/multi-plan-handoff

name: multi-plan-handoff
description: Auto-detect plan files in conversation context and pass them to multi:* execute subagents by reference, not by paraphrase
user-invocable: false

Multi-CLI Plan Handoff

When the user asks to delegate work to a `multi:*` execute/delegate subagent (`multi:codex-execute`, `multi:cursor-delegate`, `multi:opencode-delegate`, or any future execute/delegate subagent), you must check whether a plan file exists in conversation context. If one does, dispatch the subagent with `--plan <path>` and **never** paste the plan's content into the Agent tool's prompt.

The reason: every paraphrasing layer (you summarizing the plan, the Sonnet wrapper prepending framing, the upstream CLI re-reading prose) loses fidelity. `--plan <path>` makes the upstream CLI read the file directly — bytes-identical, zero rewriting.

Detection — when is there a plan in context?

Scan recent conversation for these signals, in priority order:

1. **Plan mode `Plan File Info` block.** When Claude Code's plan mode is or was active, system reminders contain a line like: `You should create your plan at C:\Users\<user>\.claude\plans\<slug>.md` That path is canonical even after `ExitPlanMode` — the file persists. If you see this in any system reminder this session, treat it as the active plan file.

2. **Superpowers `writing-plans` output.** The `superpowers:writing-plans` skill writes plan files to a known location and announces the path in its output. If you used or saw it this session, that path is in scope.

3. **Explicit user reference.** Any path the user typed or that you wrote that matches one of:

• `*/.claude/plans/*.md`
• `*/plans/*.md` (project-local plans)
• A path the user explicitly called "the plan" or "the spec"

4. **A plan you just authored.** If you wrote a markdown file in this session whose path includes `/plans/` and whose contents are step-by-step instructions, that's a plan.

Trigger phrases

Apply this skill when the user says any of these (case-insensitive, fuzzy):

• "execute it via codex" / "send to codex" / "delegate to codex" / "have codex implement this" / "codex it"
• "execute via cursor" / "send to cursor" / "delegate to cursor" / "cursor it"
• "execute via opencode" / "send to opencode" / "delegate to opencode" / "opencode it"
• "execute the plan" (with no path — auto-resolve from context)
• Any explicit "/codex:execute", "/cursor:delegate", or "/opencode:delegate" with no inline prompt text

If the user explicitly types a prompt rather than referencing a plan ("write me a fizzbuzz via cursor"), don't apply this skill — that's a normal prompt-based dispatch.

Dispatch behavior

When detection matches:

1. **Resolve to exactly one path.** If multiple plan files are in context, ask the user which one (one short sentence, no menu of options unless 3+).

2. **Dispatch with `--plan <path>`.** Pass the absolute path through the Agent tool's prompt as `--plan <absolute-path>` (plus any other runtime flags the user specified like `--background`, `--model`, `--effort`).

3. **Do not paste plan content.** The Agent tool's prompt should contain the path reference, NOT the plan's text. The subagent translates `--plan` to `--prompt-file` on the companion call and skips the framing block.

4. **Inline addenda go after the path.** If the user adds something like "execute the plan via codex but also add a CHANGELOG entry", append the addendum as plain text after the `--plan <path>` flag in the dispatch prompt. The subagent will pass the path as `--prompt-file` AND append the addendum as additional task text. Example: `--plan C:/Users/.../plans/foo.md add a CHANGELOG.md entry dated 2026-04-30 documenting the change`

5. **Re-read on dispatch.** If the user edited the plan file mid-conversation, the file's current bytes are what gets used — the subagent reads from disk, not from your context. Trust the file.

What NOT to do

• **Never paraphrase a plan you can pass by reference.** The whole point of this skill is that paraphrasing is lossy.
• **Never combine `--plan` with the subagent's framing block.** When `--plan` is present, the subagent drops its preamble and passes the plan file as the entire prompt body.
• **Never invent a plan file path.** If detection produces nothing, fall through to the normal prompt flow and ask the user what to delegate.
• **Never read the plan file yourself just to summarize it back.** The subagent and the upstream CLI handle the file directly.

Worked example

User in conversation:

• *(plan mode produces ~/.claude/plans/cursor-format-test.md)*
• *(user exits plan mode)*
• User: "send it to cursor"

Wrong (current behavior):

• You: *(reads plan file, paraphrases into a 200-word Agent prompt)*
• Subagent: *(prepends framing, forwards 250 words)*
• Cursor: receives third-generation rewrite

Right (with this skill):

• You: dispatch `multi:cursor-delegate` with prompt: `--plan C:/Users/.../plans/cursor-format-test.md`
• Subagent: `node ... task --cli cursor --role delegate --prompt-file C:/Users/.../plans/cursor-format-test.md --write`
• Cursor: reads the file directly, bytes-identical to what was authored

The same pattern applies to the other delegate subagents. For "send it to opencode":

• You: dispatch `multi:opencode-delegate` with prompt: `--plan C:/Users/.../plans/cursor-format-test.md`
• Subagent: `node ... task --cli opencode --role delegate --prompt-file C:/Users/.../plans/cursor-format-test.md --write`
• OpenCode: reads the file directly, bytes-identical to what was authored