Session Continuity — resume without losing context

Claude Desktop's Cowork mode auto-compacts long sessions roughly every 4 hours. Session Continuity is the pattern (already built into mnueron 0.5.0+) that imports your active Cowork sessions into mnueron on a cadence, so when the compact dialog appears your full thread is still searchable from memory.

Requirements

You need:

1. mnueron 0.5.0 or later — npm install -g mnueron@latest if you're older. Check with mnueron --version.
2. Claude Desktop with the mnueron MCP server wired up — if you already use memory_save or memory_recall from a Claude session, you're done. If not, run mnueron setup once and pick "Claude Desktop" from the list.
3. At least one Cowork session in your history — required for the importer to have something to find. If you've used Cowork even once, you're fine.

Quickstart (3 minutes)

Run this once to import every Cowork session you've ever had:

mnueron import --claude-cowork

That's it. You can Ctrl-C out at the prompt if you want to bail. Re-runs are idempotent — they skip sessions already imported and only ingest new turns.

To verify:

mnueron list --namespace claude-cowork --limit 10

You should see one memory per imported session. The page below is about keeping that in sync automatically so you don't have to remember to run it.

Three ways to keep the sync running

Pick one based on how much manual work you're willing to do and whether you want it to work when Claude Desktop is closed.

Option A — In-app scheduled task (easiest, runs while Claude Desktop is open)

Inside any Claude Desktop / Cowork session, paste this prompt:

Create a scheduled task named mnueron-cowork-sync that runs every 4 hours. Have it call memory_import_cowork to back up all active Cowork session directories to mnueron. The cron expression should be 0 */4 * * *.

Claude will use the scheduled-tasks MCP to create the task. Verify it landed:

1. Open the Cowork sidebar → Scheduled
2. You should see mnueron-cowork-sync with the next-fire time

Trade-off: the task only fires while Claude Desktop is open. If you close the app at 11 PM and reopen at 9 AM the next morning, your overnight Cowork session (if you had one running) doesn't sync until 9 AM. For most users this is fine because Cowork sessions don't run while the app is closed.

Option B — Local CLI watcher (works as long as the terminal is open)

Open a terminal and run:

mnueron watch --claude-cowork --interval 240

That's a long-running process polling every 240 minutes (4 hours). State persists at ~/.mnueron/cowork-sync.json, so if you Ctrl-C and resume later it picks up where it left off. Hands-off otherwise.

Trade-off: has to be running in a terminal you don't close. Wrap it in screen, tmux, or a startup script if you want it to survive reboots.

Option C — OS-level cron (bulletproof, works even when everything's closed)

The most reliable setup. Wraps Option A's CLI command in an OS scheduler so it fires whether Claude Desktop, your terminal, or anything else is running.

Windows (Task Scheduler):

$action  = New-ScheduledTaskAction -Execute "mnueron" `
            -Argument "import --claude-cowork"
$trigger = New-ScheduledTaskTrigger -Daily -At 3am `
            -RepetitionInterval (New-TimeSpan -Hours 4) `
            -RepetitionDuration (New-TimeSpan -Days 365)
Register-ScheduledTask -TaskName "mnueron-cowork-sync" `
            -Action $action -Trigger $trigger

macOS (launchd):

Create ~/Library/LaunchAgents/com.mnueron.cowork-sync.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key><string>com.mnueron.cowork-sync</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/mnueron</string>
    <string>import</string>
    <string>--claude-cowork</string>
  </array>
  <key>StartInterval</key><integer>14400</integer>
</dict>
</plist>

Then load it:

launchctl load ~/Library/LaunchAgents/com.mnueron.cowork-sync.plist

Linux (cron):

0 */4 * * * /usr/local/bin/mnueron import --claude-cowork

How to actually resume a compacted session

When Cowork shows the "session is 4 hours old, summarize?" dialog:

1. Click Resume from summary — accept the summary as your seed context.
2. In the new session, prompt as normal.
3. When the AI needs a fact from the prior session that isn't in the summary, mnueron's recall pulls it from the imported memories.

You can also seed the new session deliberately. The previous session ID is visible in the Cowork sidebar (the entry above the current one):

Before answering, recall everything in the claude-cowork namespace tagged with source_ref="cowork:<previous-session-id>" and use anything relevant.

Or scope to topic:

Recall everything in the claude-cowork namespace about migration 041 and the rename to 023a.

Troubleshooting

What gets imported

Each turn becomes its own memory with a thread_id so memory_get_thread reconstructs the original session order in local mode (hosted-mode thread reconstruction is on the roadmap).

Cost

Cheaper than re-running the same context through any LLM at inference time.

Why this exists (background)

A long Cowork session might contain 200+ turns by the time the 4-hour compact threshold hits. The auto-generated summary preserves the headline decisions but tends to drop:

• The dead-end you tried and ruled out (so the next session re-tries it)
• File paths you read but didn't act on (so the next session re-greps for them)
• The exact error message that turned out to be the smoking gun
• Numbers, quotes, and the specific wording of a decision

None of that is technically needed to keep working. All of it saves re-discovery cost when the next session needs the same context.

The mnueron import tool ships in 0.5.0 — three surfaces, same logic: the CLI (mnueron import --claude-cowork), the MCP tool (memory_import_cowork), and the local dashboard's "Import Cowork" button at localhost:3122. Pick whichever fits your workflow.

When NOT to use this

• For one-shot Q&A sessions you'll never reopen, the scheduled task is wasted overhead.
• For sessions that contain sensitive material you want to forget (credential exploration, customer PII walkthroughs), turn the task off during that work — mnueron does not currently redact on the Cowork import path.

Path 3 — continuous sync (roadmap)

The bulletproof version bakes the watcher into the mnueron MCP server itself, so import happens continuously while the app is running (every new turn → embedding within seconds). Tracked under engine-session-continuity-v2 on the roadmap.

---

Last updated 2026-05-25. Page version 2 — added quickstart, three install options, OS-level cron examples, and troubleshooting table.