@dreki-gg/pi-plan-mode 0.14.5 → 0.15.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @dreki-gg/pi-plan-mode
 
+## 0.15.1
+
+### Patch Changes
+
+- Fix execution stopping after the final task is marked done. `update_task` no longer terminates the turn merely because the task queue is empty, so the agent can run its closing summary / validation pass before the `agent_end` completion handler takes over. The `blocked` branch still terminates to pause for user input.
+
+## 0.15.0
+
+### Minor Changes
+
+- Restrict write/edit tools to .plans/ directory only during plan phase. Add isPlanPath utility. Update prompt to document --help/man support and write restrictions.
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @dreki-gg/pi-command-sandbox@0.3.0
+
 ## 0.14.5
 
 ### Patch Changes

package/extensions/plan-mode/__tests__/agent-end-safety.test.ts

@@ -102,9 +102,9 @@ describe('agent_end handler safety', () => {
     if (violations.length > 0) {
       throw new Error(
         `Found sendUserMessage calls inside agent_end without deliverAs.\n` +
-        `The agent is still "processing" during agent_end, so deliverAs is required.\n\n` +
-        `Violations:\n${violations.map((v) => `  - ${v}`).join('\n')}\n\n` +
-        `Fix: add { deliverAs: 'followUp' } to each call.`,
+          `The agent is still "processing" during agent_end, so deliverAs is required.\n\n` +
+          `Violations:\n${violations.map((v) => `  - ${v}`).join('\n')}\n\n` +
+          `Fix: add { deliverAs: 'followUp' } to each call.`,
       );
     }
   });

package/extensions/plan-mode/__tests__/phase-transitions.test.ts

@@ -4,10 +4,21 @@ import type { PlanData, TaskRecord } from '../types.js';
 
 function makePlan(overrides?: Partial<PlanData>): PlanData {
   const task: TaskRecord = {
-    _type: 'task', id: 't-001', description: 'Do work', details: 'Details',
-    status: 'pending', created_at: '2026-01-01T00:00:00Z', updated_at: '2026-01-01T00:00:00Z',
+    _type: 'task',
+    id: 't-001',
+    description: 'Do work',
+    details: 'Details',
+    status: 'pending',
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-01-01T00:00:00Z',
+  };
+  return {
+    title: 'Test Plan',
+    planName: 'test-plan',
+    handoff: '# Handoff',
+    tasks: [task],
+    ...overrides,
   };
-  return { title: 'Test Plan', planName: 'test-plan', handoff: '# Handoff', tasks: [task], ...overrides };
 }
 
 describe('PlanModeState', () => {

package/extensions/plan-mode/__tests__/plans-manifest.test.ts

@@ -3,17 +3,34 @@ import { chdir } from 'node:process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { readPlansManifest, upsertPlanEntry, writePlansManifest } from '../storage/plans-manifest.js';
+import {
+  readPlansManifest,
+  upsertPlanEntry,
+  writePlansManifest,
+} from '../storage/plans-manifest.js';
 
 const originalCwd = process.cwd();
 let dir: string;
 
-beforeEach(async () => { dir = await mkdtemp(join(tmpdir(), 'plan-mode-manifest-')); chdir(dir); });
-afterEach(async () => { chdir(originalCwd); await rm(dir, { recursive: true, force: true }); });
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-manifest-'));
+  chdir(dir);
+});
+afterEach(async () => {
+  chdir(originalCwd);
+  await rm(dir, { recursive: true, force: true });
+});
 
 describe('plans.jsonl manifest', () => {
   test('round trips entries', async () => {
-    const entry = { _type: 'plan' as const, name: 'refactor', status: 'in-progress' as const, title: 'Refactor', created_at: 'now', completed_at: null };
+    const entry = {
+      _type: 'plan' as const,
+      name: 'refactor',
+      status: 'in-progress' as const,
+      title: 'Refactor',
+      created_at: 'now',
+      completed_at: null,
+    };
     await writePlansManifest([entry]);
     await expect(readPlansManifest()).resolves.toEqual([entry]);
   });
@@ -27,7 +44,16 @@ describe('plans.jsonl manifest', () => {
   });
 
   test('upserts existing entries without changing created_at', async () => {
-    await writePlansManifest([{ _type: 'plan', name: 'p', status: 'in-progress', title: 'Old', created_at: 'created', completed_at: null }]);
+    await writePlansManifest([
+      {
+        _type: 'plan',
+        name: 'p',
+        status: 'in-progress',
+        title: 'Old',
+        created_at: 'created',
+        completed_at: null,
+      },
+    ]);
     await upsertPlanEntry('p', { status: 'done', title: 'New' });
     const [entry] = await readPlansManifest();
     expect(entry.created_at).toBe('created');

package/extensions/plan-mode/__tests__/prompts.test.ts

@@ -5,7 +5,15 @@ import type { PlanData, TaskRecord } from '../types.js';
 
 const now = '2026-01-01T00:00:00Z';
 function makeTask(overrides?: Partial<TaskRecord>): TaskRecord {
-  return { _type: 'task', id: 't-001', description: 'Do work', status: 'pending', created_at: now, updated_at: now, ...overrides };
+  return {
+    _type: 'task',
+    id: 't-001',
+    description: 'Do work',
+    status: 'pending',
+    created_at: now,
+    updated_at: now,
+    ...overrides,
+  };
 }
 
 describe('buildPlanModePrompt', () => {
@@ -54,13 +62,23 @@ describe('buildExecutionPrompt', () => {
   });
 
   test('includes Details line when task has details', () => {
-    const plan: PlanData = { title: 'Test', planName: 'test', handoff: '# H', tasks: [makeTask({ details: 'Full instructions here' })] };
+    const plan: PlanData = {
+      title: 'Test',
+      planName: 'test',
+      handoff: '# H',
+      tasks: [makeTask({ details: 'Full instructions here' })],
+    };
     const prompt = buildExecutionPrompt(plan)!;
     expect(prompt).toContain('Details: Full instructions here');
   });
 
   test('returns undefined when no pending tasks', () => {
-    const plan: PlanData = { title: 'Test', planName: 'test', handoff: '# H', tasks: [makeTask({ status: 'done' })] };
+    const plan: PlanData = {
+      title: 'Test',
+      planName: 'test',
+      handoff: '# H',
+      tasks: [makeTask({ status: 'done' })],
+    };
     expect(buildExecutionPrompt(plan)).toBeUndefined();
   });
 });

package/extensions/plan-mode/__tests__/task-storage.test.ts

@@ -8,10 +8,22 @@ import type { TaskMeta, TaskRecord } from '../types.js';
 let dir: string;
 const now = '2026-05-27T12:00:00.000Z';
 const meta: TaskMeta = { _type: 'meta', title: 'Plan', plan_name: 'plan', created_at: now };
-const task: TaskRecord = { _type: 'task', id: 't-001', description: 'Do work', details: 'Details', status: 'pending', created_at: now, updated_at: now };
+const task: TaskRecord = {
+  _type: 'task',
+  id: 't-001',
+  description: 'Do work',
+  details: 'Details',
+  status: 'pending',
+  created_at: now,
+  updated_at: now,
+};
 
-beforeEach(async () => { dir = await mkdtemp(join(tmpdir(), 'plan-mode-tasks-')); });
-afterEach(async () => { await rm(dir, { recursive: true, force: true }); });
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-tasks-'));
+});
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
 
 describe('tasks.jsonl storage', () => {
   test('round trips meta and tasks', async () => {
@@ -20,7 +32,14 @@ describe('tasks.jsonl storage', () => {
   });
 
   test('round trips tasks without details (lightweight checklist)', async () => {
-    const lightweight: TaskRecord = { _type: 'task', id: 't-002', description: 'Quick fix', status: 'pending', created_at: now, updated_at: now };
+    const lightweight: TaskRecord = {
+      _type: 'task',
+      id: 't-002',
+      description: 'Quick fix',
+      status: 'pending',
+      created_at: now,
+      updated_at: now,
+    };
     await writeTasksJsonl(dir, meta, [lightweight]);
     const result = await readTasksJsonl(dir);
     expect(result?.tasks[0]?.id).toBe('t-002');

package/extensions/plan-mode/__tests__/types.test.ts

@@ -63,6 +63,8 @@ describe('task meta type guard', () => {
 
   test('rejects malformed meta records', () => {
     expect(isTaskMeta({ _type: 'meta', title: 'Refactor' })).toBe(false);
-    expect(isTaskMeta({ _type: 'task', title: 'Refactor', plan_name: 'refactor', created_at: now })).toBe(false);
+    expect(
+      isTaskMeta({ _type: 'task', title: 'Refactor', plan_name: 'refactor', created_at: now }),
+    ).toBe(false);
   });
 });

package/extensions/plan-mode/__tests__/utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { isSafeCommand } from '../utils.js';
+import { isSafeCommand, isPlanPath } from '../utils.js';
 
 describe('isSafeCommand', () => {
   // ── Commands that SHOULD be allowed ──────────────────────────────────────
@@ -14,7 +14,9 @@ describe('isSafeCommand', () => {
 
     test('command with 2>/dev/null stderr redirect', () => {
       expect(
-        isSafeCommand('cat .release-please-manifest.json 2>/dev/null; echo "---"; cat release-please-config.json 2>/dev/null'),
+        isSafeCommand(
+          'cat .release-please-manifest.json 2>/dev/null; echo "---"; cat release-please-config.json 2>/dev/null',
+        ),
       ).toBe(true);
     });
 
@@ -113,4 +115,61 @@ describe('isSafeCommand', () => {
       expect(isSafeCommand('touch newfile.ts')).toBe(false);
     });
   });
+
+  // ── Help/version commands via command-sandbox ────────────────────────────
+  describe('help and version commands', () => {
+    test('bun --help is allowed', () => {
+      expect(isSafeCommand('bun --help')).toBe(true);
+    });
+
+    test('man git is allowed', () => {
+      expect(isSafeCommand('man git')).toBe(true);
+    });
+
+    test('npm --version is allowed', () => {
+      expect(isSafeCommand('npm --version')).toBe(true);
+    });
+
+    test('rm --help is still blocked', () => {
+      expect(isSafeCommand('rm --help')).toBe(false);
+    });
+  });
+});
+
+describe('isPlanPath', () => {
+  test('relative .plans/ path', () => {
+    expect(isPlanPath('.plans/my-plan/context.md')).toBe(true);
+  });
+
+  test('absolute path containing .plans/', () => {
+    expect(isPlanPath('/Users/me/project/.plans/my-plan/context.md')).toBe(true);
+  });
+
+  test('just .plans/', () => {
+    expect(isPlanPath('.plans/foo')).toBe(true);
+  });
+
+  test('windows-style backslashes', () => {
+    expect(isPlanPath('.plans\\my-plan\\context.md')).toBe(true);
+  });
+
+  test('src/ path is blocked', () => {
+    expect(isPlanPath('src/index.ts')).toBe(false);
+  });
+
+  test('root file is blocked', () => {
+    expect(isPlanPath('README.md')).toBe(false);
+  });
+
+  test('package.json is blocked', () => {
+    expect(isPlanPath('package.json')).toBe(false);
+  });
+
+  test('path with plans but not .plans is blocked', () => {
+    expect(isPlanPath('src/plans/something.ts')).toBe(false);
+  });
+
+  test('path ending in .plans without slash is blocked', () => {
+    expect(isPlanPath('.plans')).toBe(false);
+  });
 });

package/extensions/plan-mode/context-filter.ts

@@ -4,10 +4,7 @@
  */
 
 /** Drop everything before the execution start index. */
-export function filterExecutionMessages<T>(
-  messages: T[],
-  executionStartIdx: number,
-): T[] {
+export function filterExecutionMessages<T>(messages: T[], executionStartIdx: number): T[] {
   return messages.filter((_m, i) => i >= executionStartIdx);
 }
 

package/extensions/plan-mode/html/render.ts

@@ -32,7 +32,10 @@ function markdownToHtml(markdown: string): string {
     // Fenced code blocks
     if (line.startsWith('```')) {
       if (!inCode) {
-        if (inList) { html.push('</ul>'); inList = false; }
+        if (inList) {
+          html.push('</ul>');
+          inList = false;
+        }
         inCode = true;
         codeLang = line.slice(3).trim();
         codeLines.length = 0;
@@ -53,7 +56,10 @@ function markdownToHtml(markdown: string): string {
     // Headings
     const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
     if (headingMatch) {
-      if (inList) { html.push('</ul>'); inList = false; }
+      if (inList) {
+        html.push('</ul>');
+        inList = false;
+      }
       const level = headingMatch[1].length;
       html.push(`<h${level}>${inlineMarkdown(escapeHtml(headingMatch[2]))}</h${level}>`);
       continue;
@@ -62,19 +68,28 @@ function markdownToHtml(markdown: string): string {
     // List items (- or *)
     const listMatch = line.match(/^\s*[-*]\s+(.*)$/);
     if (listMatch) {
-      if (!inList) { html.push('<ul>'); inList = true; }
+      if (!inList) {
+        html.push('<ul>');
+        inList = true;
+      }
       html.push(`<li>${inlineMarkdown(escapeHtml(listMatch[1]))}</li>`);
       continue;
     }
 
     // Blank line
     if (!line.trim()) {
-      if (inList) { html.push('</ul>'); inList = false; }
+      if (inList) {
+        html.push('</ul>');
+        inList = false;
+      }
       continue;
     }
 
     // Paragraph
-    if (inList) { html.push('</ul>'); inList = false; }
+    if (inList) {
+      html.push('</ul>');
+      inList = false;
+    }
     html.push(`<p>${inlineMarkdown(escapeHtml(line))}</p>`);
   }
 
@@ -88,17 +103,19 @@ function markdownToHtml(markdown: string): string {
 
 /** Converts inline markdown (bold, italic, inline code, links) in already-escaped HTML. */
 function inlineMarkdown(text: string): string {
-  return text
-    // Inline code: `code`
-    .replace(/`([^`]+)`/g, '<code>$1</code>')
-    // Bold: **text** or __text__
-    .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
-    .replace(/__(.+?)__/g, '<strong>$1</strong>')
-    // Italic: *text* or _text_
-    .replace(/\*(.+?)\*/g, '<em>$1</em>')
-    .replace(/_(.+?)_/g, '<em>$1</em>')
-    // Links: [text](url)
-    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  return (
+    text
+      // Inline code: `code`
+      .replace(/`([^`]+)`/g, '<code>$1</code>')
+      // Bold: **text** or __text__
+      .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+      .replace(/__(.+?)__/g, '<strong>$1</strong>')
+      // Italic: *text* or _text_
+      .replace(/\*(.+?)\*/g, '<em>$1</em>')
+      .replace(/_(.+?)_/g, '<em>$1</em>')
+      // Links: [text](url)
+      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+  );
 }
 
 function escapeHtml(value: string): string {

package/extensions/plan-mode/index.ts

@@ -18,7 +18,14 @@
 
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Key } from '@earendil-works/pi-tui';
-import { PLAN_TOOLS, EXEC_TOOLS, PLAN_MODEL, PLAN_THINKING, EXEC_MODEL, EXEC_THINKING } from './constants.js';
+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 { loadHandoff, readAndClearExecPending } from './storage/plan-storage.js';
@@ -31,7 +38,7 @@ import { enterPlanMode, exitPlanMode, switchModel } from './phase-transitions.js
 import { resumePlan, executeInNewSession } from './resume.js';
 import { registerSubmitPlanTool } from './tools/submit-plan.js';
 import { registerUpdateTaskTool } from './tools/update-task.js';
-import { isSafeCommand } from './utils.js';
+import { isSafeCommand, isPlanPath } from './utils.js';
 
 export default function planMode(pi: ExtensionAPI): void {
   const state = new PlanModeState();
@@ -63,7 +70,12 @@ export default function planMode(pi: ExtensionAPI): void {
       if (notes) task.notes = notes;
       await writeTasksJsonl(
         state.planDir,
-        { _type: 'meta', title: state.plan.title, plan_name: state.plan.planName, created_at: state.plan.tasks[0]?.created_at ?? task.updated_at },
+        {
+          _type: 'meta',
+          title: state.plan.title,
+          plan_name: state.plan.planName,
+          created_at: state.plan.tasks[0]?.created_at ?? task.updated_at,
+        },
         state.plan.tasks,
       );
       state.persist(pi);
@@ -72,7 +84,8 @@ export default function planMode(pi: ExtensionAPI): void {
 
   // ── Commands ──────────────────────────────────────────────────────────────
   pi.registerCommand('plan', {
-    description: 'Enter plan mode, optionally with a starting prompt. Use "/plan resume" to pick up an existing plan.',
+    description:
+      'Enter plan mode, optionally with a starting prompt. Use "/plan resume" to pick up an existing plan.',
     handler: async (args, ctx) => {
       const trimmed = args?.trim();
       if (trimmed === 'resume') {
@@ -96,7 +109,8 @@ export default function planMode(pi: ExtensionAPI): void {
         return;
       }
       const taskList = state.plan.tasks.map((task) => `${task.id}. ${task.description}`).join('\n');
-      const first = state.plan.tasks.find((task) => task.status === 'pending')?.id ?? state.plan.tasks[0]?.id;
+      const first =
+        state.plan.tasks.find((task) => task.status === 'pending')?.id ?? state.plan.tasks[0]?.id;
       const kickoff = `Execute the following plan: "${state.plan.title}"\n\nTasks:\n${taskList}\n\nStart with ${first}. Call update_task after completing each task.`;
       await executeInNewSession(ctx, state.planDir, state.plan, kickoff);
     },
@@ -128,9 +142,11 @@ export default function planMode(pi: ExtensionAPI): void {
     },
   });
 
-  // ── Event: block destructive bash in plan mode ────────────────────────────
+  // ── Event: block destructive bash + restrict writes in plan mode ──────────
   pi.on('tool_call', async (event) => {
     if (!state.planEnabled) return;
+
+    // Block destructive bash commands
     if (event.toolName === 'bash') {
       const command = event.input.command as string;
       if (!isSafeCommand(command)) {
@@ -140,6 +156,17 @@ export default function planMode(pi: ExtensionAPI): void {
         };
       }
     }
+
+    // Restrict write to .plans/ directory only
+    if (event.toolName === 'write' || event.toolName === 'edit') {
+      const path = event.input.path as string;
+      if (!isPlanPath(path)) {
+        return {
+          block: true,
+          reason: `Plan mode: writes are restricted to .plans/ directory only.\nPath: ${path}`,
+        };
+      }
+    }
   });
 
   // ── Event: filter context ─────────────────────────────────────────────────
@@ -155,7 +182,11 @@ export default function planMode(pi: ExtensionAPI): void {
   pi.on('before_agent_start', async () => {
     if (state.planEnabled) {
       return {
-        message: { customType: 'plan-mode-context', content: buildPlanModePrompt(), display: false },
+        message: {
+          customType: 'plan-mode-context',
+          content: buildPlanModePrompt(),
+          display: false,
+        },
       };
     }
     if (state.executing && state.plan) {
@@ -181,17 +212,31 @@ export default function planMode(pi: ExtensionAPI): void {
           : `Task ${bs.id}: ${bs.description}`;
 
         const choice = await ctx.ui.select(`Task blocked — ${info}\n\nWhat next?`, [
-          'Skip this task', 'Provide instructions', 'Re-plan', 'Abort execution',
+          'Skip this task',
+          'Provide instructions',
+          'Re-plan',
+          'Abort execution',
         ]);
 
         if (choice === 'Skip this task') {
           bs.status = 'skipped';
           bs.updated_at = new Date().toISOString();
-          await writeTasksJsonl(state.planDir!, { _type: 'meta', title: state.plan.title, plan_name: state.plan.planName, created_at: state.plan.tasks[0]?.created_at ?? bs.updated_at }, state.plan.tasks);
+          await writeTasksJsonl(
+            state.planDir!,
+            {
+              _type: 'meta',
+              title: state.plan.title,
+              plan_name: state.plan.planName,
+              created_at: state.plan.tasks[0]?.created_at ?? bs.updated_at,
+            },
+            state.plan.tasks,
+          );
           updateUI(state, ctx);
           state.persist(pi);
           if (state.plan.tasks.some((s) => s.status === 'pending')) {
-            pi.sendUserMessage('The blocked task has been skipped. Continue with the next task.', { deliverAs: 'followUp' });
+            pi.sendUserMessage('The blocked task has been skipped. Continue with the next task.', {
+              deliverAs: 'followUp',
+            });
           }
         } else if (choice === 'Provide instructions') {
           const instructions = await ctx.ui.editor('Instructions for the blocked task:', '');
@@ -199,7 +244,16 @@ export default function planMode(pi: ExtensionAPI): void {
             bs.status = 'pending';
             bs.notes = undefined;
             bs.updated_at = new Date().toISOString();
-            await writeTasksJsonl(state.planDir!, { _type: 'meta', title: state.plan.title, plan_name: state.plan.planName, created_at: state.plan.tasks[0]?.created_at ?? bs.updated_at }, state.plan.tasks);
+            await writeTasksJsonl(
+              state.planDir!,
+              {
+                _type: 'meta',
+                title: state.plan.title,
+                plan_name: state.plan.planName,
+                created_at: state.plan.tasks[0]?.created_at ?? bs.updated_at,
+              },
+              state.plan.tasks,
+            );
             updateUI(state, ctx);
             state.persist(pi);
             pi.sendUserMessage(
@@ -222,18 +276,28 @@ export default function planMode(pi: ExtensionAPI): void {
       }
 
       // Check completion
-      const allResolved = state.plan.tasks.every((s) => s.status === 'done' || s.status === 'skipped');
+      const allResolved = state.plan.tasks.every(
+        (s) => s.status === 'done' || s.status === 'skipped',
+      );
       if (allResolved) {
         if (state.planDir) {
           await upsertPlanEntry(state.plan.planName, { status: 'done', title: state.plan.title });
-          await writeTasksJsonl(state.planDir, { _type: 'meta', title: state.plan.title, plan_name: state.plan.planName, created_at: state.plan.tasks[0]?.created_at ?? new Date().toISOString() }, state.plan.tasks);
+          await writeTasksJsonl(
+            state.planDir,
+            {
+              _type: 'meta',
+              title: state.plan.title,
+              plan_name: state.plan.planName,
+              created_at: state.plan.tasks[0]?.created_at ?? new Date().toISOString(),
+            },
+            state.plan.tasks,
+          );
         }
         const done = state.plan.tasks.filter((s) => s.status === 'done').length;
         const skipped = state.plan.tasks.filter((s) => s.status === 'skipped').length;
         const total = state.plan.tasks.length;
-        const stats = skipped > 0
-          ? `${done}/${total} done, ${skipped} skipped`
-          : `${done}/${total} done`;
+        const stats =
+          skipped > 0 ? `${done}/${total} done, ${skipped} skipped` : `${done}/${total} done`;
 
         // Build a summary of what was actually done from task notes
         const changeSummary = state.plan.tasks
@@ -289,7 +353,14 @@ export default function planMode(pi: ExtensionAPI): void {
       state.planDir = pending.planDir;
       {
         const snapshot = await readTasksJsonl(pending.planDir);
-        state.plan = snapshot ? { title: snapshot.meta.title, planName: snapshot.meta.plan_name, handoff: (await loadHandoff(pending.planDir)) ?? '', tasks: snapshot.tasks } : undefined;
+        state.plan = snapshot
+          ? {
+              title: snapshot.meta.title,
+              planName: snapshot.meta.plan_name,
+              handoff: (await loadHandoff(pending.planDir)) ?? '',
+              tasks: snapshot.tasks,
+            }
+          : undefined;
       }
       if (state.plan) {
         state.executing = true;

package/extensions/plan-mode/phase-transitions.ts

@@ -5,7 +5,14 @@
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { PlanModeState } from './state.js';
 import type { ThinkingLevel } from './types.js';
-import { PLAN_TOOLS, EXEC_TOOLS, PLAN_MODEL, PLAN_THINKING, EXEC_MODEL, EXEC_THINKING } from './constants.js';
+import {
+  PLAN_TOOLS,
+  EXEC_TOOLS,
+  PLAN_MODEL,
+  PLAN_THINKING,
+  EXEC_MODEL,
+  EXEC_THINKING,
+} from './constants.js';
 import { updateUI } from './ui.js';
 
 export async function switchModel(
@@ -40,10 +47,7 @@ export async function enterPlanMode(
   pi.setActiveTools(PLAN_TOOLS);
   await switchModel(pi, ctx, PLAN_MODEL);
   pi.setThinkingLevel(PLAN_THINKING);
-  ctx.ui.notify(
-    `Plan mode ON — ${PLAN_MODEL.provider}/${PLAN_MODEL.id}:${PLAN_THINKING}`,
-    'info',
-  );
+  ctx.ui.notify(`Plan mode ON — ${PLAN_MODEL.provider}/${PLAN_MODEL.id}:${PLAN_THINKING}`, 'info');
   updateUI(state, ctx);
   state.persist(pi);
 }

package/extensions/plan-mode/plan-storage.ts

@@ -1 +1,6 @@
-export { loadHandoff, readAndClearExecPending, saveHandoff, writeExecPending } from './storage/plan-storage.js';
+export {
+  loadHandoff,
+  readAndClearExecPending,
+  saveHandoff,
+  writeExecPending,
+} from './storage/plan-storage.js';

package/extensions/plan-mode/prompts.ts

@@ -11,7 +11,8 @@ You are in conversational plan mode — a planning dialogue with strict bash res
 
 Restrictions:
 - Available tools: ${PLAN_TOOLS.join(', ')}
-- Bash is restricted to read-only commands (ls, grep, git status, etc.)
+- Bash is restricted to read-only commands (ls, grep, git status, etc.) and info commands (--help, -h, --version, man)
+- The write tool is restricted to .plans/ directory only — no codebase file creation or modification
 - Do NOT make product code changes during planning.
 
 Your job is to reach shared understanding before formalizing a plan:
@@ -49,9 +50,7 @@ export function buildExecutionPrompt(plan: PlanData): string | undefined {
     .join('\n\n');
 
   const currentTask = remaining[0];
-  const currentDetails = currentTask.details
-    ? `\nDetails: ${currentTask.details}`
-    : '';
+  const currentDetails = currentTask.details ? `\nDetails: ${currentTask.details}` : '';
 
   return `[EXECUTING PLAN — FOLLOW THE PLAN EXACTLY]
 

package/extensions/plan-mode/resume.ts

@@ -2,7 +2,11 @@
  * Resume and execution handoff — pick up in-progress plans, model picker, new session handoff.
  */
 
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ExtensionCommandContext,
+} from '@earendil-works/pi-coding-agent';
 import type { PlanModeState } from './state.js';
 import type { PlanData } from './types.js';
 import { EXEC_THINKING, EXEC_MODEL_OPTIONS } from './constants.js';
@@ -11,7 +15,9 @@ import { loadHandoff, writeExecPending } from './storage/plan-storage.js';
 import { readTasksJsonl, writeTasksJsonl } from './storage/task-storage.js';
 import { enterPlanMode } from './phase-transitions.js';
 
-export async function pickExecutionModel(ctx: ExtensionContext): Promise<{ provider: string; id: string } | undefined> {
+export async function pickExecutionModel(
+  ctx: ExtensionContext,
+): Promise<{ provider: string; id: string } | undefined> {
   const labels = EXEC_MODEL_OPTIONS.map((o) => o.label);
   const choice = await ctx.ui.select('Execute with:', labels);
   if (!choice) return undefined;
@@ -38,7 +44,11 @@ export async function executeInNewSession(
   });
 }
 
-export async function resumePlan(state: PlanModeState, pi: ExtensionAPI, ctx: ExtensionCommandContext): Promise<void> {
+export async function resumePlan(
+  state: PlanModeState,
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
   const manifest = await readPlansManifest();
   const inProgress = manifest.filter((entry) => entry.status === 'in-progress');
 
@@ -70,12 +80,17 @@ export async function resumePlan(state: PlanModeState, pi: ExtensionAPI, ctx: Ex
     tasks: snapshot.tasks,
   };
 
-  const doneCount = state.plan.tasks.filter((task) => task.status === 'done' || task.status === 'skipped').length;
+  const doneCount = state.plan.tasks.filter(
+    (task) => task.status === 'done' || task.status === 'skipped',
+  ).length;
   const pendingCount = state.plan.tasks.filter((task) => task.status === 'pending').length;
   const blockedCount = state.plan.tasks.filter((task) => task.status === 'blocked').length;
 
   if (pendingCount === 0 && blockedCount === 0) {
-    ctx.ui.notify(`Plan "${state.plan.title}" is already complete (${doneCount}/${state.plan.tasks.length} done).`, 'info');
+    ctx.ui.notify(
+      `Plan "${state.plan.title}" is already complete (${doneCount}/${state.plan.tasks.length} done).`,
+      'info',
+    );
     state.plan = undefined;
     state.planDir = undefined;
     return;

package/extensions/plan-mode/state.ts

@@ -25,9 +25,7 @@ export class PlanModeState {
   }
 
   restore(entries: Array<{ type: string; customType?: string; data?: PersistedState }>): void {
-    const saved = entries
-      .filter((e) => e.type === 'custom' && e.customType === 'plan-mode')
-      .pop();
+    const saved = entries.filter((e) => e.type === 'custom' && e.customType === 'plan-mode').pop();
     if (saved?.data) {
       this.planEnabled = saved.data.planEnabled ?? this.planEnabled;
       this.executing = saved.data.executing ?? this.executing;

package/extensions/plan-mode/storage/atomic-write.ts

@@ -8,7 +8,11 @@ export interface AtomicWriteOptions {
   mode?: number;
 }
 
-export async function writeFileAtomic(path: string, data: string | Buffer, options: AtomicWriteOptions = {}): Promise<void> {
+export async function writeFileAtomic(
+  path: string,
+  data: string | Buffer,
+  options: AtomicWriteOptions = {},
+): Promise<void> {
   const dir = dirname(path);
   const tempPath = join(dir, `.${process.pid}.${randomUUID()}.tmp`);
   let completed = false;

package/extensions/plan-mode/storage/plan-storage.ts

@@ -11,7 +11,9 @@ export async function writeExecPending(dir: string, config: ExecPendingConfig):
   await writeFile(`${dir}/${EXEC_PENDING_FILE}`, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 }
 
-export async function readAndClearExecPending(): Promise<{ planDir: string; config: ExecPendingConfig } | undefined> {
+export async function readAndClearExecPending(): Promise<
+  { planDir: string; config: ExecPendingConfig } | undefined
+> {
   try {
     const entries = await readdir('.plans', { withFileTypes: true });
     for (const entry of entries) {

package/extensions/plan-mode/storage/plans-manifest.ts

@@ -14,13 +14,22 @@ export interface PlanManifestEntry {
 
 export async function readPlansManifest(): Promise<PlanManifestEntry[]> {
   let text: string;
-  try { text = await readFile(MANIFEST_PATH, 'utf8'); } catch { return []; }
+  try {
+    text = await readFile(MANIFEST_PATH, 'utf8');
+  } catch {
+    return [];
+  }
   const entries: PlanManifestEntry[] = [];
   for (const [index, raw] of text.split(/\r?\n/).entries()) {
     if (!raw.trim()) continue;
     let parsed: unknown;
-    try { parsed = JSON.parse(raw); } catch (error) { throw new Error(`Invalid plans.jsonl at line ${index + 1}: ${(error as Error).message}`); }
-    if (!isPlanManifestEntry(parsed)) throw new Error(`Invalid plans.jsonl record at line ${index + 1}`);
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`Invalid plans.jsonl at line ${index + 1}: ${(error as Error).message}`);
+    }
+    if (!isPlanManifestEntry(parsed))
+      throw new Error(`Invalid plans.jsonl record at line ${index + 1}`);
     entries.push(parsed);
   }
   return entries;
@@ -28,11 +37,15 @@ export async function readPlansManifest(): Promise<PlanManifestEntry[]> {
 
 export async function writePlansManifest(entries: PlanManifestEntry[]): Promise<void> {
   await mkdir('.plans', { recursive: true });
-  const content = entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '');
+  const content =
+    entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '');
   await writeFileAtomic(MANIFEST_PATH, content);
 }
 
-export async function upsertPlanEntry(name: string, updates: { status: 'in-progress' | 'done'; title?: string }): Promise<void> {
+export async function upsertPlanEntry(
+  name: string,
+  updates: { status: 'in-progress' | 'done'; title?: string },
+): Promise<void> {
   const entries = await readPlansManifest();
   const now = new Date().toISOString();
   const index = entries.findIndex((entry) => entry.name === name);
@@ -53,5 +66,12 @@ export async function upsertPlanEntry(name: string, updates: { status: 'in-progr
 function isPlanManifestEntry(value: unknown): value is PlanManifestEntry {
   if (typeof value !== 'object' || value === null) return false;
   const record = value as Record<string, unknown>;
-  return record._type === 'plan' && typeof record.name === 'string' && (record.status === 'in-progress' || record.status === 'done') && typeof record.title === 'string' && typeof record.created_at === 'string' && (record.completed_at === null || typeof record.completed_at === 'string');
+  return (
+    record._type === 'plan' &&
+    typeof record.name === 'string' &&
+    (record.status === 'in-progress' || record.status === 'done') &&
+    typeof record.title === 'string' &&
+    typeof record.created_at === 'string' &&
+    (record.completed_at === null || typeof record.completed_at === 'string')
+  );
 }

package/extensions/plan-mode/storage/task-storage.ts

@@ -5,11 +5,18 @@ import { writeFileAtomic } from './atomic-write.js';
 
 const TASKS_FILE = 'tasks.jsonl';
 
-export interface TasksSnapshot { meta: TaskMeta; tasks: TaskRecord[] }
+export interface TasksSnapshot {
+  meta: TaskMeta;
+  tasks: TaskRecord[];
+}
 
 export async function readTasksJsonl(planDir: string): Promise<TasksSnapshot | undefined> {
   let text: string;
-  try { text = await readFile(join(planDir, TASKS_FILE), 'utf8'); } catch { return undefined; }
+  try {
+    text = await readFile(join(planDir, TASKS_FILE), 'utf8');
+  } catch {
+    return undefined;
+  }
   if (!text.trim()) throw new Error('tasks.jsonl is missing meta record');
 
   let meta: TaskMeta | undefined;
@@ -17,7 +24,11 @@ export async function readTasksJsonl(planDir: string): Promise<TasksSnapshot | u
   for (const [index, raw] of text.split(/\r?\n/).entries()) {
     if (!raw.trim()) continue;
     let parsed: unknown;
-    try { parsed = JSON.parse(raw); } catch (error) { throw new Error(`Invalid JSONL at line ${index + 1}: ${(error as Error).message}`); }
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`Invalid JSONL at line ${index + 1}: ${(error as Error).message}`);
+    }
     if (isTaskMeta(parsed)) meta = parsed;
     else if (isTaskRecord(parsed)) tasks.push(parsed);
     else throw new Error(`Invalid tasks.jsonl record at line ${index + 1}`);
@@ -26,18 +37,30 @@ export async function readTasksJsonl(planDir: string): Promise<TasksSnapshot | u
   return { meta, tasks };
 }
 
-export async function writeTasksJsonl(planDir: string, meta: TaskMeta, tasks: TaskRecord[]): Promise<void> {
+export async function writeTasksJsonl(
+  planDir: string,
+  meta: TaskMeta,
+  tasks: TaskRecord[],
+): Promise<void> {
   await mkdir(planDir, { recursive: true });
   const content = [meta, ...tasks].map((record) => JSON.stringify(record)).join('\n') + '\n';
   await writeFileAtomic(join(planDir, TASKS_FILE), content);
 }
 
-export async function updateTask(planDir: string, taskId: string, updates: Partial<Omit<TaskRecord, '_type' | 'id' | 'created_at'>>): Promise<TaskRecord> {
+export async function updateTask(
+  planDir: string,
+  taskId: string,
+  updates: Partial<Omit<TaskRecord, '_type' | 'id' | 'created_at'>>,
+): Promise<TaskRecord> {
   const snapshot = await readTasksJsonl(planDir);
   if (!snapshot) throw new Error(`No tasks.jsonl found in ${planDir}`);
   const index = snapshot.tasks.findIndex((task) => task.id === taskId);
   if (index === -1) throw new Error(`Task not found: ${taskId}`);
-  const updated: TaskRecord = { ...snapshot.tasks[index], ...updates, updated_at: new Date().toISOString() };
+  const updated: TaskRecord = {
+    ...snapshot.tasks[index],
+    ...updates,
+    updated_at: new Date().toISOString(),
+  };
   snapshot.tasks[index] = updated;
   await writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
   return updated;

package/extensions/plan-mode/tools/submit-plan.ts

@@ -21,36 +21,54 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
   pi.registerTool({
     name: 'submit_plan',
     label: 'Submit Plan',
-    description: 'Finalize a conversational plan with task IDs, JSONL storage, HANDOFF.md, and generated plan.html.',
-    promptSnippet: 'Finalize the plan with title, handoff, tasks, dependencies, and optional prototype Pug',
+    description:
+      'Finalize a conversational plan with task IDs, JSONL storage, HANDOFF.md, and generated plan.html.',
+    promptSnippet:
+      'Finalize the plan with title, handoff, tasks, dependencies, and optional prototype Pug',
     promptGuidelines: [
       'Only call submit_plan after shared understanding has been reached with the user.',
       'Each task needs an id like t-001, a short description, and optional depends_on task IDs.',
-      'When a different agent or human will execute the plan, include detailed implementation instructions in each task\'s details field.',
+      "When a different agent or human will execute the plan, include detailed implementation instructions in each task's details field.",
       'When you are planning and executing yourself (same session), use lightweight checklist-style tasks: just id + description, omit details. Put the real context in the handoff document instead.',
       'The handoff must be thorough enough that both a human reviewer and executor agent with zero prior context can understand the plan.',
     ],
     parameters: Type.Object({
-      name: Type.String({ description: 'Short kebab-case name for the plan (e.g. "add-auth-middleware")' }),
+      name: Type.String({
+        description: 'Short kebab-case name for the plan (e.g. "add-auth-middleware")',
+      }),
       title: Type.String({ description: 'Human-readable plan title' }),
       handoff: Type.String({ description: 'Markdown content for HANDOFF.md' }),
       tasks: Type.Array(
         Type.Object({
           id: Type.String({ description: 'Stable task ID, e.g. t-001' }),
-          description: Type.String({ description: 'Short task label for progress display (≤60 chars)' }),
-          details: Type.Optional(Type.String({ description: 'Full implementation instructions for this task. Omit for lightweight checklist-style plans when you are executing yourself.' })),
+          description: Type.String({
+            description: 'Short task label for progress display (≤60 chars)',
+          }),
+          details: Type.Optional(
+            Type.String({
+              description:
+                'Full implementation instructions for this task. Omit for lightweight checklist-style plans when you are executing yourself.',
+            }),
+          ),
           depends_on: Type.Optional(Type.Array(Type.String({ description: 'Dependency task ID' }))),
         }),
         { minItems: 1 },
       ),
-      prototype: Type.Optional(Type.String({ description: 'Optional Pug markup for the prototype section in plan.html' })),
+      prototype: Type.Optional(
+        Type.String({ description: 'Optional Pug markup for the prototype section in plan.html' }),
+      ),
     }),
 
     async execute(_toolCallId, params) {
       const planName = toKebabCase(params.name);
       const planDir = `.plans/${planName}`;
       const now = new Date().toISOString();
-      const meta: TaskMeta = { _type: 'meta', title: params.title, plan_name: planName, created_at: now };
+      const meta: TaskMeta = {
+        _type: 'meta',
+        title: params.title,
+        plan_name: planName,
+        created_at: now,
+      };
       const tasks: TaskRecord[] = params.tasks.map((task) => ({
         _type: 'task',
         id: task.id,
@@ -72,7 +90,12 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
       callbacks.onPlanSubmitted(planDir, plan);
 
       return {
-        content: [{ type: 'text' as const, text: `Plan "${params.title}" saved with ${tasks.length} tasks. Review ${planDir}/plan.html, then execute when ready.` }],
+        content: [
+          {
+            type: 'text' as const,
+            text: `Plan "${params.title}" saved with ${tasks.length} tasks. Review ${planDir}/plan.html, then execute when ready.`,
+          },
+        ],
         details: { planDir, plan },
         terminate: true,
       };
@@ -91,7 +114,8 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
       const plan = (result.details as { plan?: PlanData } | undefined)?.plan;
       if (!plan) return new Text(theme.fg('success', '✓ Plan saved'), 0, 0);
       const lines = [theme.fg('success', '✓ ') + theme.fg('accent', theme.bold(plan.title)), ''];
-      for (const task of plan.tasks) lines.push(`  ${theme.fg('muted', task.id)} ${task.description}`);
+      for (const task of plan.tasks)
+        lines.push(`  ${theme.fg('muted', task.id)} ${task.description}`);
       return new Text(lines.join('\n'), 0, 0);
     },
   });

package/extensions/plan-mode/tools/update-task.ts

@@ -10,14 +10,19 @@ import type { PlanData, TaskStatus } from '../types.js';
 
 export interface UpdateTaskCallbacks {
   getPlan: () => PlanData | undefined;
-  onTaskUpdated: (taskId: string, status: Exclude<TaskStatus, 'pending'>, notes?: string) => void | Promise<void>;
+  onTaskUpdated: (
+    taskId: string,
+    status: Exclude<TaskStatus, 'pending'>,
+    notes?: string,
+  ) => void | Promise<void>;
 }
 
 export function registerUpdateTaskTool(pi: ExtensionAPI, callbacks: UpdateTaskCallbacks): void {
   pi.registerTool({
     name: 'update_task',
     label: 'Update Task',
-    description: 'Mark a plan task as done, skipped, or blocked. If blocked, execution pauses for user intervention.',
+    description:
+      'Mark a plan task as done, skipped, or blocked. If blocked, execution pauses for user intervention.',
     promptSnippet: 'Mark a plan task as done, skipped, or blocked',
     promptGuidelines: [
       'Call update_task after completing each plan task before moving to the next.',
@@ -27,7 +32,9 @@ export function registerUpdateTaskTool(pi: ExtensionAPI, callbacks: UpdateTaskCa
     parameters: Type.Object({
       task_id: Type.String({ description: 'Task ID (for example, t-001)' }),
       status: StringEnum(['done', 'skipped', 'blocked'] as const),
-      notes: Type.Optional(Type.String({ description: 'What was done, why skipped, or why blocked' })),
+      notes: Type.Optional(
+        Type.String({ description: 'What was done, why skipped, or why blocked' }),
+      ),
     }),
 
     async execute(_toolCallId, params) {
@@ -37,15 +44,27 @@ export function registerUpdateTaskTool(pi: ExtensionAPI, callbacks: UpdateTaskCa
       const task = plan.tasks.find((candidate) => candidate.id === params.task_id);
       if (!task) throw new Error(`Task not found: ${params.task_id}`);
       if (task.status !== 'pending') {
-        throw new Error(`Task ${params.task_id} is already "${task.status}". Only pending tasks can be updated.`);
+        throw new Error(
+          `Task ${params.task_id} is already "${task.status}". Only pending tasks can be updated.`,
+        );
       }
 
       await callbacks.onTaskUpdated(params.task_id, params.status, params.notes);
 
-      const details = { task_id: params.task_id, status: params.status, notes: params.notes, description: task.description };
+      const details = {
+        task_id: params.task_id,
+        status: params.status,
+        notes: params.notes,
+        description: task.description,
+      };
       if (params.status === 'blocked') {
         return {
-          content: [{ type: 'text' as const, text: `Task ${params.task_id} blocked. Execution paused — waiting for user input.` }],
+          content: [
+            {
+              type: 'text' as const,
+              text: `Task ${params.task_id} blocked. Execution paused — waiting for user input.`,
+            },
+          ],
           details,
           terminate: true,
         };
@@ -60,7 +79,12 @@ export function registerUpdateTaskTool(pi: ExtensionAPI, callbacks: UpdateTaskCa
       if (params.notes) text += ` — ${params.notes}`;
       text += next ? `\n\nNext task ${next.id}: ${next.description}` : '\n\nAll tasks resolved!';
 
-      return { content: [{ type: 'text' as const, text }], details, terminate: !next };
+      // Do not terminate the turn just because the queue is empty: that would cut off
+      // the agent's final pass (closing summary, validation, follow-up) after the last
+      // task is marked done. Completion is handled out-of-band by the `agent_end`
+      // handler in index.ts. Only the `blocked` branch above terminates, to pause for
+      // user input.
+      return { content: [{ type: 'text' as const, text }], details };
     },
 
     renderCall(args, theme) {
@@ -68,15 +92,31 @@ export function registerUpdateTaskTool(pi: ExtensionAPI, callbacks: UpdateTaskCa
       const status = (args as { status?: string }).status ?? '';
       let content = theme.fg('toolTitle', theme.bold('update_task '));
       content += theme.fg('muted', taskId);
-      if (status) content += ' ' + theme.fg(status === 'done' ? 'success' : status === 'skipped' ? 'warning' : 'error', status);
+      if (status)
+        content +=
+          ' ' +
+          theme.fg(
+            status === 'done' ? 'success' : status === 'skipped' ? 'warning' : 'error',
+            status,
+          );
       return new Text(content, 0, 0);
     },
 
     renderResult(result, _options, theme) {
-      const details = result.details as { task_id?: string; status?: string; description?: string } | undefined;
+      const details = result.details as
+        | { task_id?: string; status?: string; description?: string }
+        | undefined;
       if (!details) return new Text(theme.fg('dim', 'Updated'), 0, 0);
-      const statusMap: Record<string, string> = { done: theme.fg('success', '✓'), skipped: theme.fg('warning', '⊘'), blocked: theme.fg('error', '✗') };
-      return new Text(`${statusMap[details.status ?? ''] ?? ''} Task ${details.task_id}: ${details.description ?? ''}`, 0, 0);
+      const statusMap: Record<string, string> = {
+        done: theme.fg('success', '✓'),
+        skipped: theme.fg('warning', '⊘'),
+        blocked: theme.fg('error', '✗'),
+      };
+      return new Text(
+        `${statusMap[details.status ?? ''] ?? ''} Task ${details.task_id}: ${details.description ?? ''}`,
+        0,
+        0,
+      );
     },
   });
 }

package/extensions/plan-mode/utils.ts

@@ -23,6 +23,16 @@ function isMkdirPlans(command: string): boolean {
   return /^\s*mkdir\s+(-p\s+)?\.plans(\/|\\|\s|$)/.test(command);
 }
 
+/**
+ * Check if a file path is inside the .plans/ directory.
+ *
+ * Accepts both relative (.plans/foo) and absolute paths containing .plans/.
+ */
+export function isPlanPath(filePath: string): boolean {
+  const normalized = filePath.replace(/\\/g, '/');
+  return /(?:^|\/)?\.plans\//.test(normalized);
+}
+
 // ── Plan name utilities ─────────────────────────────────────────────────────
 
 export function toKebabCase(name: string): string {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-plan-mode",
-  "version": "0.14.5",
+  "version": "0.15.1",
   "description": "Two-phase planning workflow for pi — plan with claude-opus-4-6:medium, execute with gpt-5.5:low, with .plans/ file-based handoff",
   "keywords": [
     "pi-package"
@@ -40,7 +40,7 @@
     ]
   },
   "dependencies": {
-    "@dreki-gg/pi-command-sandbox": "^0.2.0",
+    "@dreki-gg/pi-command-sandbox": "^0.3.0",
     "pug": "^3.0.3"
   },
   "devDependencies": {