Continue Previous Work

Continue Previous Work

Resume a conversation by loading context from Memory Copilot and Task Copilot.

Usage: /continue (interactive) | /continue Stream-B (resume specific stream)

Step 0: Check for Pause Checkpoints (Priority Check)

BEFORE loading standard initiative context, check for recent pause checkpoints:

1. Call initiative_get({ mode: "lean" }) — if no initiative, skip
2. Run tc task list --status in_progress --json — get all active tasks
3. Check each task for pause state (tasks updated via tc task update with paused status/notes)
4. Filter tasks where status indicates paused state with user-initiated pause
5. Sort by most recent update

If pause checkpoints found, present options:

## Paused Work Detected
Found N paused task(s):
1. [Task Title] — Paused: [time ago] | Reason: [reason] | Draft: Yes/No
Options: [1-N] Resume task | [c] Standard resume | [s] Show all streams

If none found, proceed to standard resume flow.

Stream Argument Handling

When stream argument provided (e.g., /continue Stream-B):

1. tc stream get Stream-B --json — load stream details
2. Setup worktree if parallel stream without worktreePath in metadata:
   • Create worktree at .claude/worktrees/{streamId}, branch stream-{streamId}
   • Update all stream tasks with worktreePath and branchName metadata
   • Foundation/integration streams use main worktree (no isolation)
3. Load stream context (~200 tokens): name, phase, task counts, dependencies, worktree info, next task
4. Begin work immediately — invoke appropriate agent with next pending/blocked task

When no argument provided:

1. tc stream list --json — check for streams
2. If streams exist, present selection list (parallel streams show worktree path/branch)
3. If no streams, proceed with standard resume flow
4. After selection, load stream context and begin work

Step 1: Load Context (Slim)

Load minimal context to preserve token budget:

If no initiative exists, ask user what they're working on and call initiative_start.

Important: Do NOT load full task lists. Use tc progress --json for compact status.

Step 2: Activate Protocol

The Agent-First Protocol is now active.

Every response MUST start with a Protocol Declaration:

[PROTOCOL: <TYPE> | Agent: @agent-<name> | Action: <INVOKING|ASKING|RESPONDING>]

You MUST invoke agents BEFORE responding with analysis or plans.

You MUST NOT skip protocol declaration, promise agents without invoking, read files yourself, write plans before agent investigation, or load full task lists.

Step 3: Present Status (Compact)

~300 tokens max:

## Resuming: [Initiative Name]
**Status:** [IN PROGRESS / BLOCKED / READY FOR REVIEW]
**Progress:** [X/Y tasks complete] | [Z work products]
**Current Focus:** [From initiative.currentFocus]
**Next Action:** [From initiative.nextAction]
**Active Stream:** [stream name, phase, worktree path, branch, task progress]
**Recent Decisions:** [Key decisions from Memory Copilot]
**Recent Activity:** [From `tc progress --json`]

Do NOT list all tasks. If resuming a parallel stream, include worktree path and branch.

Step 4: Ask

Protocol active. [Constitution: Active/Not Found]
What would you like to work on?

During Session

Routing to Agents

Pass task IDs when invoking agents:

[PROTOCOL: TECHNICAL | Agent: @agent-ta | Action: INVOKING]
Please complete TASK-xxx: <brief description>

Progress Updates

Worktree Management

Git worktrees provide isolation for parallel streams, eliminating file conflicts.

Phase to Location Mapping

Common Commands

Conflict Resolution

• Parallel streams are fully isolated — no conflicts during development
• Conflicts only arise at merge time if same file modified in multiple branches
• Foundation work is always in main worktree; parallel streams branch from it
• Use git diff across worktrees to detect shared-file risks

Troubleshooting

Best Practices

1. Commit frequently in stream worktrees
2. Keep streams focused — avoid modifying shared files across streams
3. Merge foundation first before parallel streams
4. Test in main worktree after merging
5. Remove worktrees promptly after successful merge

End of Session

Update Memory Copilot with slim context only:

initiative_update({
  currentFocus: "Brief description",       // 100 chars max
  nextAction: "Specific next step: TASK-xxx", // 100 chars max
  decisions: [{ decision, rationale }],    // Strategic only
  lessons: [{ lesson, context }],          // Key learnings only
  keyFiles: ["important/files/touched.ts"]
})

Do NOT store in Memory Copilot: completed, inProgress, blocked (live in Task Copilot), or resumeInstructions (replaced by currentFocus + nextAction).

If Initiative is Bloated

Call initiative_slim({ archiveDetails: true }) to migrate. Archive saves to ~/.claude/memory/archives/. Continue with slim initiative.