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

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

@@ -1,6 +1,9 @@
-import { mkdir, readFile } from 'node:fs/promises';
-import { writeFileAtomic } from './atomic-write.js';
+import { Effect, Either, Option } from 'effect';
+import { FileSystem } from '../effects/filesystem.js';
+import { JsonlParseError, JsonlValidationError, PlanWriteError } from '../errors.js';
+import { decodePlanManifestEntry } from '../schema.js';
 
+const MANIFEST_DIR = '.plans';
 const MANIFEST_PATH = '.plans/plans.jsonl';
 
 export interface PlanManifestEntry {
@@ -12,66 +15,70 @@ export interface PlanManifestEntry {
   completed_at: string | null;
 }
 
-export async function readPlansManifest(): Promise<PlanManifestEntry[]> {
-  let text: string;
-  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}`);
+type ReadError = JsonlParseError | JsonlValidationError;
+
+export function readPlansManifest(): Effect.Effect<PlanManifestEntry[], ReadError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    // A missing or unreadable manifest is treated as "no plans".
+    const maybeText = yield* Effect.option(fs.readFileString(MANIFEST_PATH));
+    if (Option.isNone(maybeText)) return [];
+
+    const entries: PlanManifestEntry[] = [];
+    for (const [index, raw] of maybeText.value.split(/\r?\n/).entries()) {
+      if (!raw.trim()) continue;
+      const line = index + 1;
+
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (cause) {
+        return yield* Effect.fail(new JsonlParseError({ path: MANIFEST_PATH, line, cause }));
+      }
+
+      const decoded = decodePlanManifestEntry(parsed);
+      if (Either.isLeft(decoded)) {
+        return yield* Effect.fail(
+          new JsonlValidationError({ path: MANIFEST_PATH, line, reason: decoded.left.message }),
+        );
+      }
+      entries.push(decoded.right);
     }
-    if (!isPlanManifestEntry(parsed))
-      throw new Error(`Invalid plans.jsonl record at line ${index + 1}`);
-    entries.push(parsed);
-  }
-  return entries;
+    return entries;
+  });
 }
 
-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' : '');
-  await writeFileAtomic(MANIFEST_PATH, content);
+export function writePlansManifest(
+  entries: PlanManifestEntry[],
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(MANIFEST_DIR);
+    const content =
+      entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '');
+    yield* fs.writeFileAtomic(MANIFEST_PATH, content);
+  });
 }
 
-export async function upsertPlanEntry(
+export 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);
-  const existing = index === -1 ? undefined : entries[index];
-  const entry: PlanManifestEntry = {
-    _type: 'plan',
-    name,
-    status: updates.status,
-    title: updates.title ?? existing?.title ?? 'Untitled plan',
-    created_at: existing?.created_at ?? now,
-    completed_at: updates.status === 'done' ? now : null,
-  };
-  if (index === -1) entries.push(entry);
-  else entries[index] = entry;
-  await writePlansManifest(entries);
-}
-
-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')
-  );
+): Effect.Effect<void, ReadError | PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const entries = yield* readPlansManifest();
+    const now = new Date().toISOString();
+    const index = entries.findIndex((entry) => entry.name === name);
+    const existing = index === -1 ? undefined : entries[index];
+    const entry: PlanManifestEntry = {
+      _type: 'plan',
+      name,
+      status: updates.status,
+      title: updates.title ?? existing?.title ?? 'Untitled plan',
+      created_at: existing?.created_at ?? now,
+      completed_at: updates.status === 'done' ? now : null,
+    };
+    if (index === -1) entries.push(entry);
+    else entries[index] = entry;
+    yield* writePlansManifest(entries);
+  });
 }

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

@@ -1,7 +1,16 @@
-import { mkdir, readFile } from 'node:fs/promises';
+import { Effect, Either, Option } from 'effect';
 import { join } from 'node:path';
-import { isTaskMeta, isTaskRecord, type TaskMeta, type TaskRecord } from '../types.js';
-import { writeFileAtomic } from './atomic-write.js';
+import { FileSystem } from '../effects/filesystem.js';
+import {
+  JsonlParseError,
+  JsonlValidationError,
+  MissingMetaRecord,
+  PlanWriteError,
+  TaskNotFound,
+  TasksFileNotFound,
+} from '../errors.js';
+import { decodeTasksLine } from '../schema.js';
+import type { TaskMeta, TaskRecord } from '../types.js';
 
 const TASKS_FILE = 'tasks.jsonl';
 
@@ -10,58 +19,87 @@ export interface TasksSnapshot {
   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;
-  }
-  if (!text.trim()) throw new Error('tasks.jsonl is missing meta record');
+type ReadError = JsonlParseError | JsonlValidationError | MissingMetaRecord;
 
-  let meta: TaskMeta | undefined;
-  const tasks: TaskRecord[] = [];
-  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}`);
+export function readTasksJsonl(
+  planDir: string,
+): Effect.Effect<TasksSnapshot | undefined, ReadError, FileSystem> {
+  const path = join(planDir, TASKS_FILE);
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    // A read failure (missing or unreadable file) is treated as "no snapshot".
+    const maybeText = yield* Effect.option(fs.readFileString(path));
+    if (Option.isNone(maybeText)) return undefined;
+
+    const text = maybeText.value;
+    if (!text.trim()) return yield* Effect.fail(new MissingMetaRecord({ path }));
+
+    let meta: TaskMeta | undefined;
+    const tasks: TaskRecord[] = [];
+    for (const [index, raw] of text.split(/\r?\n/).entries()) {
+      if (!raw.trim()) continue;
+      const line = index + 1;
+
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (cause) {
+        return yield* Effect.fail(new JsonlParseError({ path, line, cause }));
+      }
+
+      const decoded = decodeTasksLine(parsed);
+      if (Either.isLeft(decoded)) {
+        return yield* Effect.fail(
+          new JsonlValidationError({ path, line, reason: decoded.left.message }),
+        );
+      }
+
+      const record = decoded.right;
+      if (record._type === 'meta') meta = record;
+      else tasks.push(record);
     }
-    if (isTaskMeta(parsed)) meta = parsed;
-    else if (isTaskRecord(parsed)) tasks.push(parsed);
-    else throw new Error(`Invalid tasks.jsonl record at line ${index + 1}`);
-  }
-  if (!meta) throw new Error('tasks.jsonl is missing meta record');
-  return { meta, tasks };
+
+    if (!meta) return yield* Effect.fail(new MissingMetaRecord({ path }));
+    return { meta, tasks };
+  });
 }
 
-export async function writeTasksJsonl(
+export 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);
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(planDir);
+    const content = [meta, ...tasks].map((record) => JSON.stringify(record)).join('\n') + '\n';
+    yield* fs.writeFileAtomic(join(planDir, TASKS_FILE), content);
+  });
 }
 
-export async function updateTask(
+export 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(),
-  };
-  snapshot.tasks[index] = updated;
-  await writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
-  return updated;
+): Effect.Effect<
+  TaskRecord,
+  ReadError | PlanWriteError | TasksFileNotFound | TaskNotFound,
+  FileSystem
+> {
+  return Effect.gen(function* () {
+    const snapshot = yield* readTasksJsonl(planDir);
+    if (!snapshot) return yield* Effect.fail(new TasksFileNotFound({ planDir }));
+
+    const index = snapshot.tasks.findIndex((task) => task.id === taskId);
+    if (index === -1) return yield* Effect.fail(new TaskNotFound({ planDir, taskId }));
+
+    const updated: TaskRecord = {
+      ...snapshot.tasks[index],
+      ...updates,
+      updated_at: new Date().toISOString(),
+    };
+    snapshot.tasks[index] = updated;
+    yield* writeTasksJsonl(planDir, snapshot.meta, snapshot.tasks);
+    return updated;
+  });
 }

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

@@ -0,0 +1,46 @@
+/**
+ * Pure helpers for reasoning about task status at execution checkpoints.
+ *
+ * `deferred` tasks are discovered follow-ups kept out of the active queue, so
+ * they are excluded from "resolved" checks but block plan finalization.
+ */
+
+import type { TaskRecord } from './types.js';
+
+export function deferredTasks(tasks: readonly TaskRecord[]): TaskRecord[] {
+  return tasks.filter((task) => task.status === 'deferred');
+}
+
+/**
+ * True when no active work remains — every task is done, skipped, or deferred
+ * (nothing pending or blocked).
+ */
+export function activeTasksResolved(tasks: readonly TaskRecord[]): boolean {
+  return tasks.every(
+    (task) => task.status === 'done' || task.status === 'skipped' || task.status === 'deferred',
+  );
+}
+
+/**
+ * True when the plan can be marked complete: active work is resolved AND there
+ * are no deferred follow-ups awaiting the user's decision.
+ */
+export function isPlanFinalizable(tasks: readonly TaskRecord[]): boolean {
+  return activeTasksResolved(tasks) && !tasks.some((task) => task.status === 'deferred');
+}
+
+/**
+ * Reactivate tasks for a resumed run: blocked tasks and deferred follow-ups
+ * become pending (mutated in place). Returns true if anything changed.
+ */
+export function reactivateForExecution(tasks: TaskRecord[], timestamp: string): boolean {
+  let changed = false;
+  for (const task of tasks) {
+    if (task.status === 'blocked' || task.status === 'deferred') {
+      task.status = 'pending';
+      task.updated_at = timestamp;
+      changed = true;
+    }
+  }
+  return changed;
+}

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

@@ -0,0 +1,95 @@
+/**
+ * add_task tool — available during execution.
+ *
+ * Lets the agent capture a follow-up task it discovered while implementing.
+ * The task is recorded as a *deferred* `discovered` task so it stays out of the
+ * active execution queue — the user reviews and decides via `/plan resume`.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Text } from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import type { PlanData, TaskRecord } from '../types.js';
+import { nextTaskId } from '../utils.js';
+
+export interface AddTaskCallbacks {
+  getPlan: () => PlanData | undefined;
+  onTaskAdded: (task: TaskRecord) => void | Promise<void>;
+}
+
+export function registerAddTaskTool(pi: ExtensionAPI, callbacks: AddTaskCallbacks): void {
+  pi.registerTool({
+    name: 'add_task',
+    label: 'Add Task',
+    description:
+      'Capture a follow-up task you discovered while implementing. It is recorded as a deferred task for the user to review later — it is NOT executed in this run.',
+    promptSnippet: 'Capture a discovered follow-up as a deferred task for later review',
+    promptGuidelines: [
+      'Use add_task when you notice worthwhile work outside the current plan while implementing.',
+      'Discovered tasks are deferred for the user to review — do NOT implement them now; continue with the planned tasks.',
+      'Give a clear reason so the user can decide whether the follow-up is worth doing.',
+    ],
+    parameters: Type.Object({
+      description: Type.String({ description: 'Short task label (≤60 chars)' }),
+      reason: Type.String({
+        description: 'Why this follow-up matters — what you noticed and why it is worth doing',
+      }),
+      details: Type.Optional(
+        Type.String({ description: 'Optional fuller implementation notes for the follow-up' }),
+      ),
+      depends_on: Type.Optional(Type.Array(Type.String({ description: 'Dependency task ID' }))),
+    }),
+
+    async execute(_toolCallId, params) {
+      const plan = callbacks.getPlan();
+      if (!plan) throw new Error('No active plan. Cannot add a follow-up task.');
+
+      const now = new Date().toISOString();
+      const task: TaskRecord = {
+        _type: 'task',
+        id: nextTaskId(plan.tasks.map((candidate) => candidate.id)),
+        description: params.description.slice(0, 60),
+        details: params.details ?? '',
+        status: 'deferred',
+        origin: 'discovered',
+        depends_on: params.depends_on,
+        notes: params.reason,
+        created_at: now,
+        updated_at: now,
+      };
+
+      await callbacks.onTaskAdded(task);
+
+      const deferred = plan.tasks.filter((candidate) => candidate.status === 'deferred').length;
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Captured follow-up ${task.id}: ${task.description} (deferred for review). ${deferred} follow-up(s) pending. Continue with the planned tasks — do not implement this now.`,
+          },
+        ],
+        details: { task_id: task.id, description: task.description, reason: params.reason },
+      };
+    },
+
+    renderCall(args, theme) {
+      const description = (args as { description?: string }).description ?? '';
+      let content = theme.fg('toolTitle', theme.bold('add_task '));
+      content += theme.fg('accent', '+ ');
+      content += description;
+      return new Text(content, 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const details = result.details as { task_id?: string; description?: string } | undefined;
+      if (!details) return new Text(theme.fg('dim', 'Follow-up captured'), 0, 0);
+      return new Text(
+        theme.fg('accent', '+ ') +
+          `${theme.fg('muted', details.task_id ?? '')} ${details.description ?? ''} ` +
+          theme.fg('dim', '(deferred)'),
+        0,
+        0,
+      );
+    },
+  });
+}

package/extensions/plan-mode/tools/preview-prototype.ts

@@ -0,0 +1,98 @@
+/**
+ * preview_prototype tool — available during the plan phase.
+ *
+ * Renders a Pug prototype to a standalone HTML visual aid, writes it under
+ * .plans/_prototypes/, and best-effort opens it so the user can react to the
+ * visual BEFORE the plan is finalized.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Text } from '@earendil-works/pi-tui';
+import { Type } from 'typebox';
+import { Effect } from 'effect';
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { FileSystem } from '../effects/filesystem.js';
+import type { RunPlanIO } from '../effects/runtime.js';
+import { renderPrototypeHtml } from '../html/render.js';
+import { toKebabCase } from '../utils.js';
+
+const PREVIEW_DIR = '.plans/_prototypes';
+
+/** Best-effort open of a file in the OS default app. Never throws. */
+function openInBrowser(filePath: string): void {
+  const command =
+    process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  try {
+    const child = spawn(command, [filePath], {
+      detached: true,
+      stdio: 'ignore',
+      shell: process.platform === 'win32',
+    });
+    child.on('error', () => {});
+    child.unref();
+  } catch {
+    // Opening is a convenience — ignore failures (headless, sandbox, etc.).
+  }
+}
+
+export function registerPreviewPrototypeTool(pi: ExtensionAPI, runPlanIO: RunPlanIO): void {
+  pi.registerTool({
+    name: 'preview_prototype',
+    label: 'Preview Prototype',
+    description:
+      'Render a Pug prototype to a standalone HTML visual aid and open it for review during planning.',
+    promptSnippet: 'Render a Pug UI prototype to HTML and open it for the user to review',
+    promptGuidelines: [
+      'Use preview_prototype during planning for visual/UI/layout/style work, before submit_plan.',
+      'The prototype is a convergence aid — show it so the user can react before the plan hardens.',
+      'Keep the Pug self-contained; inline any styles the prototype needs.',
+    ],
+    parameters: Type.Object({
+      title: Type.String({ description: 'Short title for the prototype' }),
+      intent: Type.String({
+        description: 'One-line description of what this prototype is showing',
+      }),
+      pug: Type.String({ description: 'Pug markup for the prototype body' }),
+    }),
+
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const slug = toKebabCase(params.title) || 'prototype';
+      const filePath = join(PREVIEW_DIR, `${slug}.html`);
+      const html = renderPrototypeHtml(params.title, params.intent, params.pug);
+
+      await runPlanIO(
+        Effect.gen(function* () {
+          const fs = yield* FileSystem;
+          yield* fs.makeDir(PREVIEW_DIR);
+          yield* fs.writeFileString(filePath, html);
+        }),
+      );
+      openInBrowser(filePath);
+      ctx?.ui?.notify(`Prototype written to ${filePath} — opening for review.`, 'info');
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Prototype "${params.title}" rendered to ${filePath} and opened. Ask the user for feedback before submitting the plan.`,
+          },
+        ],
+        details: { filePath, title: params.title },
+      };
+    },
+
+    renderCall(args, theme) {
+      const title = (args as { title?: string }).title ?? 'prototype';
+      let content = theme.fg('toolTitle', theme.bold('preview_prototype '));
+      content += theme.fg('accent', title);
+      return new Text(content, 0, 0);
+    },
+
+    renderResult(result, _options, theme) {
+      const filePath = (result.details as { filePath?: string } | undefined)?.filePath;
+      const label = filePath ? `✓ Prototype → ${filePath}` : '✓ Prototype rendered';
+      return new Text(theme.fg('success', label), 0, 0);
+    },
+  });
+}

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

@@ -5,11 +5,11 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { renderPlanHtml } from '../html/render.js';
+import { Effect } from 'effect';
 import { saveHandoff } from '../storage/plan-storage.js';
 import { writeTasksJsonl } from '../storage/task-storage.js';
 import { upsertPlanEntry } from '../storage/plans-manifest.js';
+import type { RunPlanIO } from '../effects/runtime.js';
 import { toKebabCase } from '../utils.js';
 import type { PlanData, TaskMeta, TaskRecord } from '../types.js';
 
@@ -17,20 +17,23 @@ export interface SubmitPlanCallbacks {
   onPlanSubmitted: (planDir: string, plan: PlanData) => void;
 }
 
-export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCallbacks): void {
+export function registerSubmitPlanTool(
+  pi: ExtensionAPI,
+  runPlanIO: RunPlanIO,
+  callbacks: SubmitPlanCallbacks,
+): void {
   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, and HANDOFF.md.',
+    promptSnippet: 'Finalize the plan with title, handoff, tasks, and dependencies',
     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 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.',
+      'For visual/UI work, preview a prototype with preview_prototype during planning — before submit_plan, not as part of it.',
     ],
     parameters: Type.Object({
       name: Type.String({
@@ -54,9 +57,6 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
         }),
         { minItems: 1 },
       ),
-      prototype: Type.Optional(
-        Type.String({ description: 'Optional Pug markup for the prototype section in plan.html' }),
-      ),
     }),
 
     async execute(_toolCallId, params) {
@@ -81,11 +81,13 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
       }));
       const plan: PlanData = { title: params.title, planName, handoff: params.handoff, tasks };
 
-      await mkdir(planDir, { recursive: true });
-      await writeTasksJsonl(planDir, meta, tasks);
-      await saveHandoff(planDir, params.handoff);
-      await writeFile(`${planDir}/plan.html`, renderPlanHtml(plan, params.prototype), 'utf-8');
-      await upsertPlanEntry(planName, { status: 'in-progress', title: params.title });
+      await runPlanIO(
+        Effect.gen(function* () {
+          yield* writeTasksJsonl(planDir, meta, tasks);
+          yield* saveHandoff(planDir, params.handoff);
+          yield* upsertPlanEntry(planName, { status: 'in-progress', title: params.title });
+        }),
+      );
 
       callbacks.onPlanSubmitted(planDir, plan);
 
@@ -93,7 +95,7 @@ export function registerSubmitPlanTool(pi: ExtensionAPI, callbacks: SubmitPlanCa
         content: [
           {
             type: 'text' as const,
-            text: `Plan "${params.title}" saved with ${tasks.length} tasks. Review ${planDir}/plan.html, then execute when ready.`,
+            text: `Plan "${params.title}" saved with ${tasks.length} tasks in ${planDir}. Execute when ready.`,
           },
         ],
         details: { planDir, plan },