@dreki-gg/pi-plan-mode 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @dreki-gg/pi-plan-mode
 
+## 0.14.0
+
+### Minor Changes
+
+- Refactor plan-mode to conversational planning with JSONL task storage and HTML output. Replace steps with task records, add atomic writes, Pug-based plan.html generation, and migrate manifest to JSONL. Update subagent prompts.
+
 ## 0.13.0
 
 ### Minor Changes

package/extensions/plan-mode/__tests__/atomic-write.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { writeFileAtomic } from '../storage/atomic-write.js';
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-atomic-'));
+});
+
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('writeFileAtomic', () => {
+  test('writes complete content to the target path', async () => {
+    const target = join(dir, 'data.txt');
+
+    await writeFileAtomic(target, 'hello world');
+
+    expect(await readFile(target, 'utf8')).toBe('hello world');
+  });
+
+  test('replaces existing content atomically from the caller perspective', async () => {
+    const target = join(dir, 'data.txt');
+    await writeFile(target, 'old');
+
+    await writeFileAtomic(target, 'new');
+
+    expect(await readFile(target, 'utf8')).toBe('new');
+  });
+
+  test('leaves target untouched when writing fails before rename', async () => {
+    const target = join(dir, 'data.txt');
+    await writeFile(target, 'original');
+
+    await expect(writeFileAtomic(target, 'next', { mode: 0o400 })).rejects.toThrow();
+
+    expect(await readFile(target, 'utf8')).toBe('original');
+  });
+});

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'bun:test';
+import { renderPlanHtml } from '../html/render.js';
+import type { PlanData } from '../types.js';
+
+const plan: PlanData = {
+  title: 'Refactor Auth',
+  planName: 'refactor-auth',
+  handoff: '# Handoff\nShip carefully.',
+  tasks: [
+    {
+      _type: 'task',
+      id: 't-001',
+      description: 'Add auth middleware',
+      details: 'Implement the middleware.',
+      status: 'pending',
+      created_at: '2026-05-27T12:00:00.000Z',
+      updated_at: '2026-05-27T12:00:00.000Z',
+    },
+  ],
+};
+
+describe('renderPlanHtml', () => {
+  test('renders title, task count, handoff, and tasks', () => {
+    const html = renderPlanHtml(plan);
+
+    expect(html).toContain('Refactor Auth');
+    expect(html).toContain('1 task');
+    expect(html).toContain('Ship carefully.');
+    expect(html).toContain('t-001');
+    expect(html).toContain('Add auth middleware');
+  });
+
+  test('omits prototypes section when no prototype is provided', () => {
+    expect(renderPlanHtml(plan)).not.toContain('Prototype');
+  });
+
+  test('renders optional prototype pug markup', () => {
+    const html = renderPlanHtml(plan, '.mockup Prototype card');
+
+    expect(html).toContain('Prototype');
+    expect(html).toContain('Prototype card');
+  });
+});

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

@@ -0,0 +1,37 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+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';
+
+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 }); });
+
+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 };
+    await writePlansManifest([entry]);
+    await expect(readPlansManifest()).resolves.toEqual([entry]);
+  });
+
+  test('upserts new entries', async () => {
+    await upsertPlanEntry('new-plan', { status: 'in-progress', title: 'New Plan' });
+    const entries = await readPlansManifest();
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.name).toBe('new-plan');
+    expect(entries[0]?.title).toBe('New Plan');
+  });
+
+  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 upsertPlanEntry('p', { status: 'done', title: 'New' });
+    const [entry] = await readPlansManifest();
+    expect(entry.created_at).toBe('created');
+    expect(entry.status).toBe('done');
+    expect(entry.completed_at).toBeString();
+  });
+});

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

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readTasksJsonl, updateTask, writeTasksJsonl } from '../storage/task-storage.js';
+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 };
+
+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 () => {
+    await writeTasksJsonl(dir, meta, [task]);
+    await expect(readTasksJsonl(dir)).resolves.toEqual({ meta, tasks: [task] });
+  });
+
+  test('missing file returns undefined', async () => {
+    await expect(readTasksJsonl(dir)).resolves.toBeUndefined();
+  });
+
+  test('rejects corrupt lines', async () => {
+    await Bun.write(join(dir, 'tasks.jsonl'), `${JSON.stringify(meta)}\nnot-json\n`);
+    await expect(readTasksJsonl(dir)).rejects.toThrow(/Invalid JSONL/);
+  });
+
+  test('rejects empty files', async () => {
+    await Bun.write(join(dir, 'tasks.jsonl'), '');
+    await expect(readTasksJsonl(dir)).rejects.toThrow(/meta/);
+  });
+
+  test('updates a task by id and rewrites the snapshot', async () => {
+    await writeTasksJsonl(dir, meta, [task]);
+    const updated = await updateTask(dir, 't-001', { status: 'done', notes: 'finished' });
+
+    expect(updated.status).toBe('done');
+    expect(updated.notes).toBe('finished');
+    expect((await readTasksJsonl(dir))?.tasks[0]?.status).toBe('done');
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'bun:test';
+import { isTaskMeta, isTaskRecord } from '../types.js';
+
+const now = '2026-05-27T12:00:00.000Z';
+
+describe('task record type guards', () => {
+  test('accepts valid task records', () => {
+    expect(
+      isTaskRecord({
+        _type: 'task',
+        id: 't-001',
+        description: 'Do work',
+        details: 'Full instructions',
+        status: 'pending',
+        depends_on: ['t-000'],
+        notes: 'note',
+        created_at: now,
+        updated_at: now,
+      }),
+    ).toBe(true);
+  });
+
+  test('rejects malformed task records', () => {
+    expect(isTaskRecord({ _type: 'task', id: 't-001', status: 'pending' })).toBe(false);
+    expect(
+      isTaskRecord({
+        _type: 'task',
+        id: 't-001',
+        description: 'Do work',
+        details: 'Full instructions',
+        status: 'unknown',
+        created_at: now,
+        updated_at: now,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe('task meta type guard', () => {
+  test('accepts valid meta records', () => {
+    expect(
+      isTaskMeta({
+        _type: 'meta',
+        title: 'Refactor',
+        plan_name: 'refactor',
+        created_at: now,
+      }),
+    ).toBe(true);
+  });
+
+  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);
+  });
+});

package/extensions/plan-mode/constants.ts

@@ -10,12 +10,13 @@ export const PLAN_TOOLS = [
   'find',
   'ls',
   'submit_plan',
+  'write',
   'questionnaire',
   'search_skills',
   'subagent',
 ];
 
-export const EXEC_TOOLS = ['read', 'bash', 'edit', 'write', 'update_step'];
+export const EXEC_TOOLS = ['read', 'bash', 'edit', 'write', 'update_task'];
 
 // ── Model + thinking presets ─────────────────────────────────────────────────
 export const PLAN_MODEL = { provider: 'anthropic', id: 'claude-opus-4-6' } as const;

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

@@ -0,0 +1,67 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pug from 'pug';
+import type { PlanData } from '../types.js';
+
+const templatePath = join(dirname(fileURLToPath(import.meta.url)), 'templates', 'plan.pug');
+
+export function renderPlanHtml(plan: PlanData, prototype?: string): string {
+  const template = readFileSync(templatePath, 'utf8');
+  const prototypeHtml = prototype?.trim() ? pug.render(prototype) : undefined;
+
+  return pug.render(template, {
+    filename: templatePath,
+    plan,
+    prototypeHtml,
+    handoffHtml: markdownToHtml(plan.handoff),
+    taskCountLabel: `${plan.tasks.length} ${plan.tasks.length === 1 ? 'task' : 'tasks'}`,
+    generatedAt: new Date().toISOString(),
+  });
+}
+
+function markdownToHtml(markdown: string): string {
+  const lines = markdown.split(/\r?\n/);
+  const html: string[] = [];
+  let inList = false;
+
+  for (const line of lines) {
+    if (line.startsWith('# ')) {
+      if (inList) {
+        html.push('</ul>');
+        inList = false;
+      }
+      html.push(`<h1>${escapeHtml(line.slice(2))}</h1>`);
+    } else if (line.startsWith('## ')) {
+      if (inList) {
+        html.push('</ul>');
+        inList = false;
+      }
+      html.push(`<h2>${escapeHtml(line.slice(3))}</h2>`);
+    } else if (line.startsWith('- ')) {
+      if (!inList) {
+        html.push('<ul>');
+        inList = true;
+      }
+      html.push(`<li>${escapeHtml(line.slice(2))}</li>`);
+    } else if (line.trim()) {
+      if (inList) {
+        html.push('</ul>');
+        inList = false;
+      }
+      html.push(`<p>${escapeHtml(line)}</p>`);
+    }
+  }
+
+  if (inList) html.push('</ul>');
+  return html.join('\n');
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}

package/extensions/plan-mode/html/templates/plan.pug

@@ -0,0 +1,58 @@
+doctype html
+html(lang="en")
+  head
+    meta(charset="utf-8")
+    meta(name="viewport" content="width=device-width, initial-scale=1")
+    title= plan.title
+    style.
+      :root { color-scheme: dark; --bg:#0b0d12; --panel:#11141b; --muted:#8b93a7; --text:#eef1f7; --line:#242936; --accent:#8b5cf6; --done:#33d69f; --blocked:#ff6b6b; }
+      * { box-sizing: border-box; }
+      body { margin:0; background:radial-gradient(circle at top left,#1c1730,transparent 34rem),var(--bg); color:var(--text); font:14px/1.5 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      main { width:min(1040px, calc(100% - 48px)); margin:48px auto; }
+      header { display:flex; justify-content:space-between; gap:24px; align-items:flex-start; margin-bottom:28px; }
+      h1 { font-size:34px; line-height:1.08; margin:0 0 10px; letter-spacing:-0.04em; }
+      h2 { font-size:15px; text-transform:uppercase; color:var(--muted); letter-spacing:0.14em; margin:0 0 14px; }
+      .meta { color:var(--muted); display:flex; gap:12px; flex-wrap:wrap; }
+      .pill { border:1px solid var(--line); border-radius:999px; padding:6px 10px; background:rgba(255,255,255,0.03); }
+      section { background:rgba(17,20,27,0.82); border:1px solid var(--line); border-radius:18px; padding:22px; margin:18px 0; box-shadow:0 24px 80px rgba(0,0,0,0.24); }
+      .handoff :first-child { margin-top:0; }
+      .handoff :last-child { margin-bottom:0; }
+      .tasks { display:grid; gap:12px; }
+      .task { border:1px solid var(--line); border-radius:14px; padding:16px; background:#0f1218; }
+      .task-top { display:flex; gap:10px; align-items:center; margin-bottom:8px; }
+      .id { color:var(--accent); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+      .status { margin-left:auto; color:var(--muted); }
+      .task.done .status { color:var(--done); }
+      .task.blocked .status { color:var(--blocked); }
+      .description { font-weight:650; }
+      .details { color:#c7ccda; margin:0; white-space:pre-wrap; }
+      .deps { color:var(--muted); margin-top:10px; font-size:12px; }
+  body
+    main
+      header
+        div
+          h1= plan.title
+          .meta
+            span.pill= plan.planName
+            span.pill= taskCountLabel
+        .meta
+          span.pill Generated #{generatedAt}
+      section.handoff
+        h2 Handoff
+        != handoffHtml
+      section
+        h2 Tasks
+        .tasks
+          each task in plan.tasks
+            article.task(class=task.status)
+              .task-top
+                span.id= task.id
+                span.description= task.description
+                span.status= task.status
+              p.details= task.details
+              if task.depends_on && task.depends_on.length
+                .deps Depends on #{task.depends_on.join(', ')}
+      if prototypeHtml
+        section.prototype
+          h2 Prototype
+          != prototypeHtml

package/extensions/plan-mode/index.ts

@@ -3,7 +3,7 @@
  *
  * Two-phase workflow:
  *   1. PLAN phase  — read-only tools + submit_plan tool + medium thinking
- *   2. EXECUTE phase — full tools + update_step tool + low thinking
+ *   2. EXECUTE phase — full tools + update_task tool + low thinking
  *
  * Commands:
  *   /plan [prompt]  — enter plan mode
@@ -21,14 +21,16 @@ import { Key } from '@earendil-works/pi-tui';
 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 { loadHandoff, readAndClearExecPending } from './storage/plan-storage.js';
+import { readTasksJsonl, writeTasksJsonl } from './storage/task-storage.js';
+import { upsertPlanEntry } from './storage/plans-manifest.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 { registerUpdateTaskTool } from './tools/update-task.js';
 import { isSafeCommand } from './utils.js';
 
 export default function planMode(pi: ExtensionAPI): void {
@@ -50,12 +52,20 @@ export default function planMode(pi: ExtensionAPI): void {
     },
   });
 
-  registerUpdateStepTool(pi, {
+  registerUpdateTaskTool(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;
+    onTaskUpdated: async (taskId, status, notes) => {
+      if (!state.plan || !state.planDir) return;
+      const task = state.plan.tasks.find((candidate) => candidate.id === taskId);
+      if (!task) return;
+      task.status = status;
+      task.updated_at = new Date().toISOString();
+      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 },
+        state.plan.tasks,
+      );
       state.persist(pi);
     },
   });
@@ -85,8 +95,9 @@ export default function planMode(pi: ExtensionAPI): void {
         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.`;
+      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 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);
     },
   });
@@ -94,13 +105,13 @@ export default function planMode(pi: ExtensionAPI): void {
   pi.registerCommand('todos', {
     description: 'Show current plan progress',
     handler: async (_args, ctx) => {
-      if (!state.plan || state.plan.steps.length === 0) {
+      if (!state.plan || state.plan.tasks.length === 0) {
         ctx.ui.notify('No plan yet. Use /plan to start planning.', 'info');
         return;
       }
       const statusIcon = { pending: '○', done: '✓', skipped: '⊘', blocked: '✗' } as const;
-      const list = state.plan.steps
-        .map((s, i) => `${i + 1}. ${statusIcon[s.status]} ${s.description}`)
+      const list = state.plan.tasks
+        .map((s) => `${s.id}. ${statusIcon[s.status]} ${s.description}`)
         .join('\n');
       ctx.ui.notify(`Plan Progress:\n${list}`, 'info');
     },
@@ -157,42 +168,42 @@ export default function planMode(pi: ExtensionAPI): void {
     }
   });
 
-  // ── Event: agent_end — blocked steps, completion, post-plan menu ──────────
+  // ── Event: agent_end — blocked tasks, completion, post-plan menu ──────────
   pi.on('agent_end', async (_event, ctx) => {
-    // ── During execution: handle blocked steps and completion ──
+    // ── During execution: handle blocked tasks and completion ──
     if (state.executing && state.plan) {
-      const blocked = state.plan.steps
-        .map((s, i) => ({ ...s, num: i + 1 }))
-        .filter((s) => s.status === 'blocked');
+      const blocked = state.plan.tasks.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}`;
+          ? `Task ${bs.id}: ${bs.description}\nReason: ${bs.notes}`
+          : `Task ${bs.id}: ${bs.description}`;
 
-        const choice = await ctx.ui.select(`Step blocked — ${info}\n\nWhat next?`, [
-          'Skip this step', 'Provide instructions', 'Re-plan', 'Abort execution',
+        const choice = await ctx.ui.select(`Task blocked — ${info}\n\nWhat next?`, [
+          'Skip this task', '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);
+        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);
           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' });
+          if (state.plan.tasks.some((s) => s.status === 'pending')) {
+            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 step:', '');
+          const instructions = await ctx.ui.editor('Instructions for the blocked task:', '');
           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);
+            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);
             updateUI(state, ctx);
             state.persist(pi);
             pi.sendUserMessage(
-              `Retry step ${bs.num} with these additional instructions: ${instructions.trim()}`,
+              `Retry task ${bs.id} with these additional instructions: ${instructions.trim()}`,
               { deliverAs: 'followUp' },
             );
           }
@@ -200,7 +211,7 @@ export default function planMode(pi: ExtensionAPI): void {
         } 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.`,
+            `Task ${bs.id} was blocked: ${bs.notes ?? 'no details'}. Re-analyze and create a revised plan.`,
             { deliverAs: 'followUp' },
           );
           return;
@@ -211,24 +222,24 @@ export default function planMode(pi: ExtensionAPI): void {
       }
 
       // Check completion
-      const allResolved = state.plan.steps.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 updatePlansManifest(state.planDir.replace(/^\.plans\//, ''), 'done', state.plan.title);
-          await savePlanToDisk(state.planDir, state.plan);
+          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);
         }
-        const done = state.plan.steps.filter((s) => s.status === 'done').length;
-        const skipped = state.plan.steps.filter((s) => s.status === 'skipped').length;
-        const total = state.plan.steps.length;
+        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`;
 
-        // Build a summary of what was actually done from step notes
-        const changeSummary = state.plan.steps
-          .map((s, i) => {
+        // Build a summary of what was actually done from task notes
+        const changeSummary = state.plan.tasks
+          .map((s) => {
             const icon = s.status === 'done' ? '✓' : '⊘';
-            const label = `${i + 1}. ${icon} ${s.description}`;
+            const label = `${s.id}. ${icon} ${s.description}`;
             return s.notes ? `${label}\n   ${s.notes}` : label;
           })
           .join('\n');
@@ -276,8 +287,8 @@ export default function planMode(pi: ExtensionAPI): void {
 
 - Missing edge cases or error handling
 - Incorrect assumptions about the codebase
-- Steps that are too vague or could be misinterpreted
-- Missing dependencies between steps
+- Tasks that are too vague or could be misinterpreted
+- Missing dependencies between tasks
 - Simpler alternatives that were overlooked
 
 After your review, call submit_plan again with the improved plan.`,
@@ -302,7 +313,10 @@ After your review, call submit_plan again with the improved plan.`,
     const pending = await readAndClearExecPending();
     if (pending) {
       state.planDir = pending.planDir;
-      state.plan = await loadPlanFromDisk(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;
+      }
       if (state.plan) {
         state.executing = true;
         state.planEnabled = false;