handoff

/handoff — Express Session Handoff (cowork variant)

Four modes covering two distinct handoff shapes:

• Next-session handoff (default + auto + snap) — Same end-of-session coverage as /aria-cowork:wrapup (review work → update PROGRESS.md / CLAUDE.md / memory → emit commit message → run /extract → verify continuity) compressed into a single combined-go review. Always emits a paste-ready next-session opener at the end. (snap is the auto variant that snapshots for later extraction instead of running /extract now — see the mode list below.)
• Coworker brief (brief) — Produces a copy/paste prose block (Slack/email-ready) summarizing the session for another person. Does NOT update PROGRESS/CLAUDE/memory, does NOT emit a commit message, does NOT run /extract. Output-only — paste it and you're done.

Cowork variant of aria-knowledge's /handoff. Behavior is byte-aligned where Cowork's runtime permits; three divergences shared with /aria-cowork:wrapup:

• Git commit step generates a copy-paste message instead of running git directly (Q-4 Option B — Cowork has no shell access for git status / git commit). Same shape as /aria-cowork:wrapup Step 6.
• Memory file updates limited to files in the attached knowledge folder. aria-knowledge reads ~/.claude/projects/.../memory/; Cowork's persistent-grant model can't reach that path.
• Tracked artifacts check (CODEMAP/STITCH staleness) skipped per ADR-005. Step 7's checklist row about tracked artifacts is omitted in cowork.

Brief mode template (/handoff brief) imports from aria-knowledge v2.17.0 schema — same 80-150 word coworker-brief format, same [coworker] literal placeholder convention, same 4 section headers (What happened / Key decisions / What's next / Where to pick up). Schema-identical regardless of which plugin generated it.

Runtime Gate (per ADR-094)

Canonical resolution: This is the Claude Cowork variant — namespaced-only. When both plugin-claude-code and plugin-claude-cowork are loaded in the same session (most common in Claude Desktop), bare /handoff resolves to aria-knowledge's variant — Code is the canonical owner of all 24 dual-port skills per ADR-094 §Part 1. To reach this skill, use the namespaced form: /aria-cowork:handoff. Do NOT match bare /handoff — that belongs to aria-knowledge.

Before Step 0: Check whether the Bash tool is available in this session. If Bash IS available (you are running in Claude Code or another runtime with shell access), surface the following notification and wait for explicit user confirmation:

⚠️ Runtime mismatch — you invoked aria-cowork's /handoff from a runtime with shell access.

This variant emits a copy-paste commit message because Cowork has no shell access — but you appear to be running in Claude Code, where git status / git commit would work directly. The runtime-appropriate variant is /handoff (the aria-knowledge canonical), which runs git directly.

Use /handoff instead? (y / n)

Wait for an explicit reply:

• y / yes — Use the Skill tool to invoke handoff (the bare-slash canonical, which routes to aria-knowledge when both ports are loaded) with the same arguments the user provided to this invocation. Do not proceed with this skill's steps; the aria-knowledge variant takes over and runs to completion. This is the default-yes path — auto-redirect is the helpful action.
• n / no — Proceed with this (aria-cowork) variant anyway despite the runtime mismatch. The user has explicitly opted in.
• No response / any other reply — Treat as "do not proceed" and exit cleanly without running either variant.

This gate applies even when mode = auto or mode = snap per ADR-094 §Part 3. Auto/snap's "implicit-yes on all gates" rule is suspended for the runtime-mismatch check — they trust that the user invoked the correct variant, and this gate enforces that precondition. All other auto/snap-mode gates remain bypassed. The friction cost is now low: on y, the auto-redirect runs the correct variant with the original args.

If Bash is NOT available (normal Cowork runtime), proceed to Step 0.

Four modes:

• Default (/handoff) — Generate ALL drafts (session summary, PROGRESS entry, CLAUDE.md edits, memory updates, commit message, next-session prompt) into one scroll, ask once for combined-go, then apply atomically. Per-item edits allowed.
• auto (/handoff auto) — Implicit-yes on all gates. Run silently. Apply all drafts without confirmation. Emit final report only. Use when the session is short and unambiguous.
• brief (/handoff brief) — Generate a coworker-facing prose brief (80-150 words, copy/paste-ready). Skips PROGRESS/CLAUDE/memory/commit/extract entirely. Emits the brief as the only artifact.
• snap (/handoff snap) — Like auto (silent, apply all drafts, emit the next-session opener), but archives the conversation via /aria-cowork:snapshot for later extraction instead of running /aria-cowork:extract now. Use when context is high: you still get the full handoff package + opener + commit message, but defer the expensive, compaction-risky knowledge synthesis to a later session (or the next /aria-cowork:audit-knowledge digest pass).

Coverage matches /aria-cowork:wrapup for default + auto + snap modes. Brief mode is a different shape — handoff to a person, not to a session.

snap is auto plus one swap. snap follows auto's behavior exactly (silent, implicit-yes, apply all drafts, emit the opener) — wherever a step below applies to auto, it applies identically to snap. The single difference is the capture step (Step 6): snap runs /aria-cowork:snapshot (archive for later) while auto runs /aria-cowork:extract (synthesize now). Nothing else differs. (snap is NOT brief — it produces the full next-session package, not a coworker prose block.)

Step 0: Resolve Config and Parse Mode

Read <knowledge_folder>/aria-config.md and extract knowledge_folder. If missing, stop: "aria-knowledge is not configured. Run /aria-setup to get started."

Parse the argument:

• No arg, or arg is empty → mode = combined-go (default)
• Arg matches auto (case-insensitive) → mode = auto
• Arg matches brief (case-insensitive) → mode = brief
• Arg matches snap (case-insensitive) → mode = snap
• Any other arg → stop: "Unknown argument '{arg}'. Use '/handoff', '/handoff auto', '/handoff brief', or '/handoff snap'."

Use {knowledge_folder} as the base path for all file operations.

Step 1: Identify Project Context

Same logic as /wrapup Step 1 — detect:

• Project root — directory containing PROGRESS.md and/or CLAUDE.md (search upward from cwd)
• PROGRESS.md path — if exists
• CLAUDE.md path(s) — root + relevant subfolder
• Memory files — any project_*.md files in ~/.claude/projects/ matching the current path
• Git repos — note them in the session summary; Cowork can't run git status so detection is conversation-context based (e.g., "user mentioned files edited in the cs repo")

Additionally, determine the project marker for the next-session opener (Step 9):

• Match the working directory against the project codes documented in the user's root CLAUDE.md (e.g., cs, ss, df, kn, ar, jp if those conventions exist).
• If no SessionStart-hook project-code convention is detected, use the project's folder name as the marker.
• If no project is identifiable, use the literal [no-project] — the opener will still work, just without auto-routing.

If no PROGRESS.md or CLAUDE.md is found, note this — proceed with the steps that apply.

Step 2: Synthesize Session Work (silent)

Build the session synthesis internally — do NOT print it yet:

1. Files changed — list files created/modified/deleted during this session (from conversation context, not git)
2. Key decisions — architectural choices, approach selections
3. Current state —