@dreki-gg/pi-plan-mode 0.6.4 → 0.10.1

package/extensions/plan-mode/index.ts

@@ -1,88 +1,38 @@
 /**
- * Plan Mode Extension
+ * Plan Mode Extension — Thin orchestrator
  *
  * Two-phase workflow:
- *   1. PLAN phase  — read-only tools (+ edit/write for .plans/ only) + medium thinking
- *                    Planner analyzes codebase, asks questions, writes PLAN.md + START-PROMPT.md
- *   2. EXECUTE phase — full tools + low thinking, clean context from START-PROMPT.md
- *                      Executor works through the plan step by step with [DONE:n] tracking
- *
- * Plans live in `.plans/<kebab-name>/PLAN.md` with a `START-PROMPT.md` sibling for clean handoff.
+ *   1. PLAN phase  — read-only tools + submit_plan tool + medium thinking
+ *   2. EXECUTE phase — full tools + update_step tool + low thinking
  *
  * Commands:
- *   /plan [prompt]  — enter plan mode (optionally with a starting prompt)
+ *   /plan [prompt]  — enter plan mode
+ *   /plan resume    — resume an in-progress plan from disk
+ *   /plan-exec      — execute the current plan in a clean session
  *   /todos          — show current plan progress
- *   Ctrl+Alt+P      — toggle plan mode (shortcut)
+ *   Ctrl+Alt+P      — toggle plan mode
  *
  * Flag:
  *   --plan          — start session in plan mode
  */
 
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import type { AssistantMessage, TextContent } from '@earendil-works/pi-ai';
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Key } from '@earendil-works/pi-tui';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { extractTodoItems, isSafeCommand, markCompletedSteps, type TodoItem } from './utils.js';
-import {
-  extractPlanTitle,
-  readPlansJson,
-  serializePlansJson,
-  type PlansManifest,
-} from './plans-json.js';
-
-// ── Tool sets ────────────────────────────────────────────────────────────────
-// Plan phase: read-only + edit/write (for .plans/ files only, enforced by prompt)
-const PLAN_TOOLS = [
-  'read',
-  'bash',
-  'grep',
-  'find',
-  'ls',
-  'edit',
-  'write',
-  'questionnaire',
-  'search_skills',
-];
-const EXEC_TOOLS = ['read', 'bash', 'edit', 'write', 'search_skills'];
-
-// ── Model + thinking presets ─────────────────────────────────────────────────
-const PLAN_MODEL = { provider: 'anthropic', id: 'claude-opus-4-6' } as const;
-const PLAN_THINKING = 'medium' as const;
-
-const EXEC_MODEL = { provider: 'openai', id: 'gpt-5.5' } as const;
-const EXEC_THINKING = 'low' as const;
+import { PLAN_TOOLS, EXEC_TOOLS, PLAN_MODEL, PLAN_THINKING, EXEC_MODEL, EXEC_THINKING } from './constants.js';
+import type { ThinkingLevel } from './types.js';
+import { PlanModeState } from './state.js';
+import { savePlanToDisk, loadPlanFromDisk, readAndClearExecPending, updatePlansManifest } from './plan-storage.js';
+import { updateUI } from './ui.js';
+import { buildPlanModePrompt, buildExecutionPrompt } from './prompts.js';
+import { filterExecutionMessages, filterStalePlanMessages } from './context-filter.js';
+import { enterPlanMode, exitPlanMode, switchModel } from './phase-transitions.js';
+import { resumePlan, executeInNewSession } from './resume.js';
+import { registerSubmitPlanTool } from './tools/submit-plan.js';
+import { registerUpdateStepTool } from './tools/update-step.js';
+import { isSafeCommand } from './utils.js';
 
-type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-
-// ── Persisted state ──────────────────────────────────────────────────────────
-interface PersistedState {
-  planEnabled: boolean;
-  executing: boolean;
-  planDir: string | undefined;
-  todos: TodoItem[];
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function isAssistantMessage(m: AgentMessage): m is AssistantMessage {
-  return m.role === 'assistant' && Array.isArray(m.content);
-}
-
-function getTextContent(message: AssistantMessage): string {
-  return message.content
-    .filter((b): b is TextContent => b.type === 'text')
-    .map((b) => b.text)
-    .join('\n');
-}
-
-// ── Extension ────────────────────────────────────────────────────────────────
 export default function planMode(pi: ExtensionAPI): void {
-  let planEnabled = false;
-  let executing = false;
-  let planDir: string | undefined;
-  let todos: TodoItem[] = [];
-  let previousThinking: ThinkingLevel | undefined;
-  let previousModel: { provider: string; id: string } | undefined;
+  const state = new PlanModeState();
 
   // ── Flag ──────────────────────────────────────────────────────────────────
   pi.registerFlag('plan', {
@@ -91,178 +41,85 @@ export default function planMode(pi: ExtensionAPI): void {
     default: false,
   });
 
-  // ── State persistence ─────────────────────────────────────────────────────
-  function persist(): void {
-    pi.appendEntry<PersistedState>('plan-mode', {
-      planEnabled,
-      executing,
-      planDir,
-      todos,
-    });
-  }
-
-  // ── plans.json tracking ───────────────────────────────────────────────────
-  async function updatePlansManifest(
-    planName: string,
-    status: 'in-progress' | 'done',
-    title?: string,
-  ): Promise<void> {
-    const manifest = await readPlansJson();
-    const existing = manifest[planName];
-    const now = new Date().toISOString();
-
-    manifest[planName] = {
-      status,
-      title: title ?? existing?.title ?? 'Untitled plan',
-      created: existing?.created ?? now,
-      completed: status === 'done' ? now : null,
-    };
-
-    await mkdir('.plans', { recursive: true });
-    const content = serializePlansJson(manifest);
-    await writeFile('.plans/plans.json', content, 'utf-8');
-  }
-
-  // ── UI updates ────────────────────────────────────────────────────────────
-  function updateUI(ctx: ExtensionContext): void {
-    const { theme } = ctx.ui;
-
-    if (executing && todos.length > 0) {
-      const done = todos.filter((t) => t.completed).length;
-      ctx.ui.setStatus('plan-mode', theme.fg('accent', `📋 exec ${done}/${todos.length}`));
-    } else if (planEnabled) {
-      ctx.ui.setStatus('plan-mode', theme.fg('warning', '📝 plan'));
-    } else {
-      ctx.ui.setStatus('plan-mode', undefined);
-    }
-
-    if (executing && todos.length > 0) {
-      const lines = todos.map((item) => {
-        if (item.completed) {
-          return theme.fg('success', '☑ ') + theme.fg('muted', theme.strikethrough(item.text));
-        }
-        return `${theme.fg('muted', '☐ ')}${item.text}`;
-      });
-      ctx.ui.setWidget('plan-todos', lines);
-    } else {
-      ctx.ui.setWidget('plan-todos', undefined);
-    }
-  }
-
-  // ── Model switching ───────────────────────────────────────────────────────
-  async function switchModel(
-    ctx: ExtensionContext,
-    preset: { provider: string; id: string },
-  ): Promise<boolean> {
-    const model = ctx.modelRegistry.find(preset.provider, preset.id);
-    if (!model) {
-      ctx.ui.notify(`Model ${preset.provider}/${preset.id} not found`, 'error');
-      return false;
-    }
-    const ok = await pi.setModel(model);
-    if (!ok) {
-      ctx.ui.notify(`No API key for ${preset.provider}/${preset.id}`, 'error');
-      return false;
-    }
-    return true;
-  }
-
-  // ── Phase transitions ─────────────────────────────────────────────────────
-  async function enterPlanMode(ctx: ExtensionContext): Promise<void> {
-    planEnabled = true;
-    executing = false;
-    planDir = undefined;
-    todos = [];
-    previousThinking = pi.getThinkingLevel() as ThinkingLevel;
-    previousModel = ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
-    pi.setActiveTools(PLAN_TOOLS);
-    await switchModel(ctx, PLAN_MODEL);
-    pi.setThinkingLevel(PLAN_THINKING);
-    ctx.ui.notify(
-      `Plan mode ON — ${PLAN_MODEL.provider}/${PLAN_MODEL.id}:${PLAN_THINKING}`,
-      'info',
-    );
-    updateUI(ctx);
-    persist();
-  }
-
-  async function exitPlanMode(ctx: ExtensionContext): Promise<void> {
-    planEnabled = false;
-    executing = false;
-    planDir = undefined;
-    todos = [];
-    pi.setActiveTools(EXEC_TOOLS);
-    if (previousModel) {
-      await switchModel(ctx, previousModel);
-    }
-    if (previousThinking) {
-      pi.setThinkingLevel(previousThinking);
-    }
-    ctx.ui.notify('Plan mode OFF — original model restored', 'info');
-    updateUI(ctx);
-    persist();
-  }
-
-  async function startExecution(ctx: ExtensionContext): Promise<void> {
-    planEnabled = false;
-    executing = true;
-    pi.setActiveTools(EXEC_TOOLS);
-    await switchModel(ctx, EXEC_MODEL);
-    pi.setThinkingLevel(EXEC_THINKING);
-    ctx.ui.notify(
-      `Executing plan — ${EXEC_MODEL.provider}/${EXEC_MODEL.id}:${EXEC_THINKING}`,
-      'info',
-    );
-    updateUI(ctx);
-    persist();
-  }
+  // ── Tools ─────────────────────────────────────────────────────────────────
+  registerSubmitPlanTool(pi, {
+    onPlanSubmitted: (dir, submittedPlan) => {
+      state.planDir = dir;
+      state.plan = submittedPlan;
+      state.persist(pi);
+    },
+  });
 
-  async function togglePlanMode(ctx: ExtensionContext): Promise<void> {
-    if (planEnabled || executing) {
-      await exitPlanMode(ctx);
-    } else {
-      await enterPlanMode(ctx);
-    }
-  }
+  registerUpdateStepTool(pi, {
+    getPlan: () => state.plan,
+    onStepUpdated: (step, status, notes) => {
+      if (!state.plan) return;
+      state.plan.steps[step - 1].status = status;
+      if (notes) state.plan.steps[step - 1].notes = notes;
+      state.persist(pi);
+    },
+  });
 
   // ── Commands ──────────────────────────────────────────────────────────────
   pi.registerCommand('plan', {
-    description: 'Enter plan mode, optionally with a starting prompt',
+    description: 'Enter plan mode, optionally with a starting prompt. Use "/plan resume" to pick up an existing plan.',
     handler: async (args, ctx) => {
-      if (planEnabled || executing) {
-        await togglePlanMode(ctx);
+      const trimmed = args?.trim();
+      if (trimmed === 'resume') {
+        await resumePlan(state, pi, ctx);
         return;
       }
-      await enterPlanMode(ctx);
-      const prompt = args?.trim();
-      if (prompt) {
-        pi.sendUserMessage(prompt);
+      if (state.planEnabled || state.executing) {
+        await exitPlanMode(state, pi, ctx);
+        return;
       }
+      await enterPlanMode(state, pi, ctx);
+      if (trimmed) pi.sendUserMessage(trimmed);
+    },
+  });
+
+  pi.registerCommand('plan-exec', {
+    description: 'Execute the current plan in a clean session',
+    handler: async (_args, ctx) => {
+      if (!state.planDir || !state.plan) {
+        ctx.ui.notify('No plan to execute.', 'error');
+        return;
+      }
+      const stepList = state.plan.steps.map((s, i) => `${i + 1}. ${s.description}`).join('\n');
+      const kickoff = `Execute the following plan: "${state.plan.title}"\n\nSteps:\n${stepList}\n\nStart with step 1. Call update_step after completing each step.`;
+      await executeInNewSession(ctx, state.planDir, state.plan, kickoff);
     },
   });
 
   pi.registerCommand('todos', {
     description: 'Show current plan progress',
     handler: async (_args, ctx) => {
-      if (todos.length === 0) {
+      if (!state.plan || state.plan.steps.length === 0) {
         ctx.ui.notify('No plan yet. Use /plan to start planning.', 'info');
         return;
       }
-      const list = todos.map((t, i) => `${i + 1}. ${t.completed ? '✓' : '○'} ${t.text}`).join('\n');
+      const statusIcon = { pending: '○', done: '✓', skipped: '⊘', blocked: '✗' } as const;
+      const list = state.plan.steps
+        .map((s, i) => `${i + 1}. ${statusIcon[s.status]} ${s.description}`)
+        .join('\n');
       ctx.ui.notify(`Plan Progress:\n${list}`, 'info');
     },
   });
 
   pi.registerShortcut(Key.ctrlAlt('p'), {
     description: 'Toggle plan mode',
-    handler: async (ctx) => togglePlanMode(ctx),
+    handler: async (ctx) => {
+      if (state.planEnabled || state.executing) {
+        await exitPlanMode(state, pi, ctx);
+      } else {
+        await enterPlanMode(state, pi, ctx);
+      }
+    },
   });
 
-  // ── Block destructive bash in plan mode ───────────────────────────────────
+  // ── Event: block destructive bash in plan mode ────────────────────────────
   pi.on('tool_call', async (event) => {
-    if (!planEnabled) return;
-
-    // Block bash commands that aren't on the safe allowlist
+    if (!state.planEnabled) return;
     if (event.toolName === 'bash') {
       const command = event.input.command as string;
       if (!isSafeCommand(command)) {
@@ -272,270 +129,127 @@ export default function planMode(pi: ExtensionAPI): void {
         };
       }
     }
-
-    // Block edit/write to paths outside .plans/
-    if (event.toolName === 'edit' || event.toolName === 'write') {
-      const path = (event.input as { path?: string }).path ?? '';
-      if (!path.startsWith('.plans/') && !path.startsWith('.plans\\')) {
-        return {
-          block: true,
-          reason: `Plan mode: file modifications are restricted to .plans/ directory.\nPath: ${path}`,
-        };
-      }
-    }
   });
 
-  // ── Filter stale plan context when not planning ───────────────────────────
+  // ── Event: filter context ─────────────────────────────────────────────────
   pi.on('context', async (event) => {
-    if (planEnabled) return;
-    return {
-      messages: event.messages.filter((m) => {
-        const msg = m as AgentMessage & { customType?: string };
-        if (msg.customType === 'plan-mode-context') return false;
-        if (msg.role !== 'user') return true;
-        const content = msg.content;
-        if (typeof content === 'string') {
-          return !content.includes('[PLAN MODE ACTIVE]');
-        }
-        if (Array.isArray(content)) {
-          return !content.some(
-            (c) => c.type === 'text' && (c as TextContent).text?.includes('[PLAN MODE ACTIVE]'),
-          );
-        }
-        return true;
-      }),
-    };
+    if (state.planEnabled) return;
+    if (state.executing && state.executionStartIdx !== undefined) {
+      return { messages: filterExecutionMessages(event.messages, state.executionStartIdx) };
+    }
+    return { messages: filterStalePlanMessages(event.messages) };
   });
 
-  // ── Inject context for each phase ─────────────────────────────────────────
+  // ── Event: inject phase prompts ───────────────────────────────────────────
   pi.on('before_agent_start', async () => {
-    if (planEnabled) {
-      return {
-        message: {
-          customType: 'plan-mode-context',
-          content: `[PLAN MODE ACTIVE]
-You are in plan mode — a planning phase with strict bash restrictions.
-
-Restrictions:
-- Available tools: ${PLAN_TOOLS.join(', ')}
-- Bash is restricted to read-only commands (ls, grep, git status, etc.)
-- edit and write are ONLY allowed for files inside the \`.plans/\` directory
-
-Your task:
-1. Analyze the codebase thoroughly using the available read-only tools
-2. Ask clarifying questions if needed (use the questionnaire tool)
-3. Produce a detailed, concrete plan
-
-When you are ready to finalize the plan:
-1. Choose a short descriptive kebab-case name for the plan (e.g. "add-auth-middleware")
-2. Create \`.plans/<plan-name>/PLAN.md\` with the full numbered plan under a \`Plan:\` header:
-
-\`\`\`markdown
-# <Plan Title>
-
-<Brief description of what this plan accomplishes>
-
-## Context
-<Key findings from codebase analysis>
-
-## Plan:
-1. First step — what to change and where
-2. Second step — what to change and where
-...
-
-## Risks / Open Questions
-<Any concerns or assumptions>
-\`\`\`
-
-3. Create \`.plans/<plan-name>/START-PROMPT.md\` — a self-contained handoff prompt that a different model can use to execute the plan WITHOUT access to this conversation. It must include:
-   - Complete context about the codebase (relevant file paths, APIs, patterns)
-   - The full plan steps to execute
-   - Any critical constraints or gotchas
-   - Clear instructions to mark each step done with \`[DONE:n]\` tags
-
-The START-PROMPT.md is critical — it must be thorough enough that an implementor with zero prior context can execute the plan correctly.
-
-If you need supporting reference files for extra context (code snippets, diagrams, specs), place them alongside in the same \`.plans/<plan-name>/\` directory.
-
-Do NOT attempt to make product code changes — only create planning artifacts in \`.plans/\`.`,
-          display: false,
-        },
-      };
-    }
-
-    if (executing && todos.length > 0) {
-      const remaining = todos.filter((t) => !t.completed);
-      const todoList = remaining.map((t) => `${t.step}. ${t.text}`).join('\n');
+    if (state.planEnabled) {
       return {
-        message: {
-          customType: 'plan-execution-context',
-          content: `[EXECUTING PLAN — Full tool access enabled]
-
-Remaining steps:
-${todoList}
-
-Execute each step in order. You MUST include [DONE:n] in your response after completing each step before moving to the next one.`,
-          display: false,
-        },
+        message: { customType: 'plan-mode-context', content: buildPlanModePrompt(), display: false },
       };
     }
-  });
-
-  // ── Track [DONE:n] markers during execution ───────────────────────────────
-  pi.on('turn_end', async (event, ctx) => {
-    if (!executing || todos.length === 0) return;
-    if (!isAssistantMessage(event.message)) return;
-
-    const text = getTextContent(event.message);
-    if (markCompletedSteps(text, todos) > 0) {
-      updateUI(ctx);
+    if (state.executing && state.plan) {
+      const content = buildExecutionPrompt(state.plan);
+      if (content) {
+        return {
+          message: { customType: 'plan-execution-context', content, display: false },
+        };
+      }
     }
-    persist();
   });
 
-  // ── Detect plan directory from written files ──────────────────────────────
-  pi.on('tool_result', async (event) => {
-    if (!planEnabled) return;
-    if (event.toolName !== 'write' && event.toolName !== 'edit') return;
-    if (event.isError) return;
-
-    const path = (event.input as { path?: string }).path;
-    if (!path) return;
-
-    // Detect .plans/<name>/ directory from written files
-    const match = path.match(/\.plans\/([^/]+)\//);
-    if (match && !planDir) {
-      planDir = `.plans/${match[1]}`;
-      const planName = match[1];
-
-      // Read PLAN.md to extract the title for plans.json
-      let title = 'Untitled plan';
-      if (path.endsWith('PLAN.md')) {
-        try {
-          const content = await readFile(path, 'utf-8');
-          title = extractPlanTitle(content);
-        } catch {
-          // Fall through
+  // ── Event: agent_end — blocked steps, completion, post-plan menu ──────────
+  pi.on('agent_end', async (_event, ctx) => {
+    // ── During execution: handle blocked steps and completion ──
+    if (state.executing && state.plan) {
+      const blocked = state.plan.steps
+        .map((s, i) => ({ ...s, num: i + 1 }))
+        .filter((s) => s.status === 'blocked');
+
+      if (blocked.length > 0) {
+        const bs = blocked[0];
+        const info = bs.notes
+          ? `Step ${bs.num}: ${bs.description}\nReason: ${bs.notes}`
+          : `Step ${bs.num}: ${bs.description}`;
+
+        const choice = await ctx.ui.select(`Step blocked — ${info}\n\nWhat next?`, [
+          'Skip this step', 'Provide instructions', 'Re-plan', 'Abort execution',
+        ]);
+
+        if (choice === 'Skip this step') {
+          state.plan.steps[bs.num - 1].status = 'skipped';
+          await savePlanToDisk(state.planDir!, state.plan);
+          updateUI(state, ctx);
+          state.persist(pi);
+          if (state.plan.steps.some((s) => s.status === 'pending')) {
+            pi.sendUserMessage('The blocked step has been skipped. Continue with the next step.', { deliverAs: 'followUp' });
+          }
+        } else if (choice === 'Provide instructions') {
+          const instructions = await ctx.ui.editor('Instructions for the blocked step:', '');
+          if (instructions?.trim()) {
+            state.plan.steps[bs.num - 1].status = 'pending';
+            state.plan.steps[bs.num - 1].notes = undefined;
+            await savePlanToDisk(state.planDir!, state.plan);
+            updateUI(state, ctx);
+            state.persist(pi);
+            pi.sendUserMessage(
+              `Retry step ${bs.num} with these additional instructions: ${instructions.trim()}`,
+              { deliverAs: 'followUp' },
+            );
+          }
+          return;
+        } else if (choice === 'Re-plan') {
+          await enterPlanMode(state, pi, ctx);
+          pi.sendUserMessage(
+            `Step ${bs.num} was blocked: ${bs.notes ?? 'no details'}. Re-analyze and create a revised plan.`,
+            { deliverAs: 'followUp' },
+          );
+          return;
+        } else if (choice === 'Abort execution') {
+          await exitPlanMode(state, pi, ctx);
+          return;
         }
       }
-      await updatePlansManifest(planName, 'in-progress', title);
-      persist();
-    } else if (match && planDir && path.endsWith('PLAN.md')) {
-      // planDir already set but PLAN.md just written — update title
-      try {
-        const content = await readFile(path, 'utf-8');
-        const title = extractPlanTitle(content);
-        await updatePlansManifest(match[1], 'in-progress', title);
-      } catch {
-        // Fall through
-      }
-    }
-  });
 
-  // ── After agent finishes: prompt for next action ──────────────────────────
-  pi.on('agent_end', async (event, ctx) => {
-    // Check execution completion
-    if (executing && todos.length > 0) {
-      if (todos.every((t) => t.completed)) {
-        // Mark plan as done in plans.json
-        if (planDir) {
-          const planName = planDir.replace(/^\.plans\//, '');
-          await updatePlansManifest(planName, 'done');
+      // Check completion
+      const allResolved = state.plan.steps.every((s) => s.status === 'done' || s.status === 'skipped');
+      if (allResolved) {
+        if (state.planDir) {
+          await updatePlansManifest(state.planDir.replace(/^\.plans\//, ''), 'done', state.plan.title);
+          await savePlanToDisk(state.planDir, state.plan);
         }
-
-        const list = todos.map((t) => `~~${t.text}~~`).join('\n');
+        const list = state.plan.steps
+          .map((s) => s.status === 'done' ? `~~${s.description}~~` : `⊘ ~~${s.description}~~`)
+          .join('\n');
         pi.sendMessage(
-          {
-            customType: 'plan-complete',
-            content: `**Plan Complete!** ✓\n\n${list}`,
-            display: true,
-          },
+          { customType: 'plan-complete', content: `**Plan Complete!** ✓\n\n${list}`, display: true },
           { triggerTurn: false },
         );
-        executing = false;
-        todos = [];
-        planDir = undefined;
+
+        const { previousModel: pm, previousThinking: pt } = state;
+        state.reset();
         pi.setActiveTools(EXEC_TOOLS);
-        if (previousModel) {
-          await switchModel(ctx, previousModel);
-        }
-        if (previousThinking) {
-          pi.setThinkingLevel(previousThinking);
-        }
-        updateUI(ctx);
-        persist();
+        if (pm) await switchModel(pi, ctx, pm);
+        if (pt) pi.setThinkingLevel(pt);
+        updateUI(state, ctx);
+        state.persist(pi);
+        return;
       }
       return;
     }
 
-    if (!planEnabled || !ctx.hasUI) return;
+    // ── After plan submission: show post-plan menu ──
+    if (!state.planEnabled || !ctx.hasUI) return;
+    if (!state.planDir || !state.plan) return;
 
-    // Check if plan files were created by looking for planDir
-    if (!planDir) return;
-
-    // Show menu
     const choice = await ctx.ui.select('Plan ready — what next?', [
-      'Execute Plan',
-      'Refine Plan',
-      'Follow up',
-      'Exit plan mode',
+      'Execute Plan', 'Refine Plan', 'Follow up', 'Exit plan mode',
     ]);
 
     if (choice === 'Execute Plan') {
-      // Read START-PROMPT.md for clean context handoff
-      const startPromptPath = `${planDir}/START-PROMPT.md`;
-      const planMdPath = `${planDir}/PLAN.md`;
-
-      // Read the plan to extract todos
-      let planContent = '';
-      try {
-        planContent = await readFile(planMdPath, 'utf-8');
-      } catch {
-        // Fall through — will use empty plan content
-      }
-
-      const extracted = extractTodoItems(planContent);
-      if (extracted.length > 0) {
-        todos = extracted;
-      }
-
-      // Read the start prompt for clean handoff
-      let startPrompt = '';
-      try {
-        startPrompt = (await readFile(startPromptPath, 'utf-8')).trim();
-      } catch {
-        // Fall through
-      }
-
-      await startExecution(ctx);
-      updateUI(ctx);
-
-      if (startPrompt) {
-        pi.sendMessage(
-          {
-            customType: 'plan-mode-execute',
-            content: startPrompt,
-            display: true,
-          },
-          { triggerTurn: true, deliverAs: 'followUp' },
-        );
-      } else {
-        // Fallback: ask executor to read the plan
-        pi.sendMessage(
-          {
-            customType: 'plan-mode-execute',
-            content: `Execute the plan in ${planMdPath}. Read it first, then execute step by step. Mark each step with [DONE:n] before moving to the next.`,
-            display: true,
-          },
-          { triggerTurn: true, deliverAs: 'followUp' },
-        );
-      }
+      pi.sendUserMessage('/plan-exec', { deliverAs: 'followUp' });
     } else if (choice === 'Refine Plan') {
-      // Adversarial review — planner critiques its own plan
-      pi.sendMessage(
-        {
-          customType: 'plan-mode-refine',
-          content: `Review the plan you just created in ${planDir}/PLAN.md with an adversarial lens. Challenge assumptions, find gaps, identify risks, and look for:
+      pi.sendUserMessage(
+        `Review the plan you just created with an adversarial lens. Challenge assumptions, find gaps, identify risks, and look for:
 
 - Missing edge cases or error handling
 - Incorrect assumptions about the codebase
@@ -543,88 +257,52 @@ Execute each step in order. You MUST include [DONE:n] in your response after com
 - Missing dependencies between steps
 - Simpler alternatives that were overlooked
 
-After your review, update PLAN.md and START-PROMPT.md with any improvements.`,
-          display: true,
-        },
-        { triggerTurn: true, deliverAs: 'followUp' },
+After your review, call submit_plan again with the improved plan.`,
+        { deliverAs: 'followUp' },
       );
     } else if (choice === 'Follow up') {
-      const followUp = await ctx.ui.editor('Follow-up instructions for the planner:', '');
-      if (followUp?.trim()) {
-        pi.sendMessage(
-          {
-            customType: 'plan-mode-followup',
-            content: followUp.trim(),
-            display: true,
-          },
-          { triggerTurn: true, deliverAs: 'followUp' },
-        );
-      }
+      // No-op: dismiss menu, let user type naturally
     } else if (choice === 'Exit plan mode') {
-      await exitPlanMode(ctx);
+      await exitPlanMode(state, pi, ctx);
     }
   });
 
-  // ── Restore state on session start/resume ─────────────────────────────────
+  // ── Event: session restore ────────────────────────────────────────────────
   pi.on('session_start', async (_event, ctx) => {
-    // Check CLI flag
-    if (pi.getFlag('plan') === true) {
-      planEnabled = true;
-    }
+    if (pi.getFlag('plan') === true) state.planEnabled = true;
 
-    // Restore persisted state
-    const entries = ctx.sessionManager.getEntries();
-    const saved = entries
-      .filter(
-        (e: { type: string; customType?: string }) =>
-          e.type === 'custom' && e.customType === 'plan-mode',
-      )
-      .pop() as { data?: PersistedState } | undefined;
-
-    if (saved?.data) {
-      planEnabled = saved.data.planEnabled ?? planEnabled;
-      executing = saved.data.executing ?? executing;
-      planDir = saved.data.planDir ?? planDir;
-      todos = saved.data.todos ?? todos;
-    }
-
-    // Re-scan [DONE:n] markers on resume
-    if (executing && todos.length > 0) {
-      let execIdx = -1;
-      for (let i = entries.length - 1; i >= 0; i--) {
-        const entry = entries[i] as { type: string; customType?: string };
-        if (entry.customType === 'plan-mode-execute') {
-          execIdx = i;
-          break;
-        }
-      }
+    state.restore(
+      ctx.sessionManager.getEntries() as Array<{ type: string; customType?: string; data?: any }>,
+    );
 
-      const messages: AssistantMessage[] = [];
-      for (let i = execIdx + 1; i < entries.length; i++) {
-        const entry = entries[i];
-        if (
-          entry.type === 'message' &&
-          'message' in entry &&
-          isAssistantMessage(entry.message as AgentMessage)
-        ) {
-          messages.push(entry.message as AssistantMessage);
-        }
+    // Check for exec-pending handoff from planning session
+    const pending = await readAndClearExecPending();
+    if (pending) {
+      state.planDir = pending.planDir;
+      state.plan = await loadPlanFromDisk(pending.planDir);
+      if (state.plan) {
+        state.executing = true;
+        state.planEnabled = false;
+        pi.setActiveTools(EXEC_TOOLS);
+        await switchModel(pi, ctx, pending.config.model);
+        pi.setThinkingLevel(pending.config.thinking as ThinkingLevel);
+        updateUI(state, ctx);
+        state.persist(pi);
+        return;
       }
-      const allText = messages.map(getTextContent).join('\n');
-      markCompletedSteps(allText, todos);
     }
 
     // Apply tool restrictions, model, and thinking level
-    if (planEnabled) {
+    if (state.planEnabled) {
       pi.setActiveTools(PLAN_TOOLS);
-      await switchModel(ctx, PLAN_MODEL);
+      await switchModel(pi, ctx, PLAN_MODEL);
       pi.setThinkingLevel(PLAN_THINKING);
-    } else if (executing) {
+    } else if (state.executing) {
       pi.setActiveTools(EXEC_TOOLS);
-      await switchModel(ctx, EXEC_MODEL);
+      await switchModel(pi, ctx, EXEC_MODEL);
       pi.setThinkingLevel(EXEC_THINKING);
     }
 
-    updateUI(ctx);
+    updateUI(state, ctx);
   });
 }