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

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

@@ -1,17 +1,35 @@
+import { Effect } from 'effect';
 import { createWriteStream } from 'node:fs';
 import { open, rename, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { PlanWriteError } from '../errors.js';
 
 export interface AtomicWriteOptions {
   /** Test seam: file mode for the temporary file. */
   mode?: number;
 }
 
-export async function writeFileAtomic(
+/**
+ * Atomically write `data` to `path`: write to a temp file, fsync, rename into
+ * place, then best-effort fsync the directory. Failures surface as
+ * `PlanWriteError`.
+ */
+export function writeFileAtomic(
   path: string,
   data: string | Buffer,
   options: AtomicWriteOptions = {},
+): Effect.Effect<void, PlanWriteError> {
+  return Effect.tryPromise({
+    try: () => writeFileAtomicPromise(path, data, options),
+    catch: (cause) => new PlanWriteError({ path, cause }),
+  });
+}
+
+async function writeFileAtomicPromise(
+  path: string,
+  data: string | Buffer,
+  options: AtomicWriteOptions,
 ): Promise<void> {
   const dir = dirname(path);
   const tempPath = join(dir, `.${process.pid}.${randomUUID()}.tmp`);

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

@@ -2,48 +2,76 @@
  * Plan disk I/O — exec-pending markers and handoff documents.
  */
 
-import { mkdir, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
+import { Effect, Either, Option } from 'effect';
+import { FileSystem } from '../effects/filesystem.js';
+import type { PlanWriteError } from '../errors.js';
+import { decodeExecPendingConfig } from '../schema.js';
 import type { ExecPendingConfig } from '../types.js';
 import { EXEC_PENDING_FILE } from '../constants.js';
 
-export async function writeExecPending(dir: string, config: ExecPendingConfig): Promise<void> {
-  await mkdir(dir, { recursive: true });
-  await writeFile(`${dir}/${EXEC_PENDING_FILE}`, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+const PLANS_DIR = '.plans';
+
+export function writeExecPending(
+  dir: string,
+  config: ExecPendingConfig,
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(dir);
+    yield* fs.writeFileString(
+      `${dir}/${EXEC_PENDING_FILE}`,
+      JSON.stringify(config, null, 2) + '\n',
+    );
+  });
 }
 
-export async function readAndClearExecPending(): Promise<
-  { planDir: string; config: ExecPendingConfig } | undefined
+export function readAndClearExecPending(): Effect.Effect<
+  { planDir: string; config: ExecPendingConfig } | undefined,
+  never,
+  FileSystem
 > {
-  try {
-    const entries = await readdir('.plans', { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dir = `.plans/${entry.name}`;
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const maybeDirs = yield* Effect.option(fs.listDirectories(PLANS_DIR));
+    if (Option.isNone(maybeDirs)) return undefined;
+
+    for (const name of maybeDirs.value) {
+      const dir = `${PLANS_DIR}/${name}`;
       const markerPath = `${dir}/${EXEC_PENDING_FILE}`;
+      const maybeText = yield* Effect.option(fs.readFileString(markerPath));
+      if (Option.isNone(maybeText)) continue;
+
+      let parsed: unknown;
       try {
-        const text = await readFile(markerPath, 'utf-8');
-        const config = JSON.parse(text) as ExecPendingConfig;
-        await unlink(markerPath);
-        return { planDir: dir, config };
+        parsed = JSON.parse(maybeText.value);
       } catch {
-        // No marker in this directory
+        continue;
       }
+      const decoded = decodeExecPendingConfig(parsed);
+      if (Either.isLeft(decoded)) continue;
+
+      yield* Effect.ignore(fs.removeFile(markerPath));
+      return { planDir: dir, config: decoded.right };
     }
-  } catch {
-    // .plans/ doesn't exist
-  }
-  return undefined;
+    return undefined;
+  });
 }
 
-export async function saveHandoff(planDir: string, content: string): Promise<void> {
-  await mkdir(planDir, { recursive: true });
-  await writeFile(`${planDir}/HANDOFF.md`, content, 'utf-8');
+export function saveHandoff(
+  planDir: string,
+  content: string,
+): Effect.Effect<void, PlanWriteError, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    yield* fs.makeDir(planDir);
+    yield* fs.writeFileString(`${planDir}/HANDOFF.md`, content);
+  });
 }
 
-export async function loadHandoff(planDir: string): Promise<string | undefined> {
-  try {
-    return await readFile(`${planDir}/HANDOFF.md`, 'utf-8');
-  } catch {
-    return undefined;
-  }
+export function loadHandoff(planDir: string): Effect.Effect<string | undefined, never, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const maybeText = yield* Effect.option(fs.readFileString(`${planDir}/HANDOFF.md`));
+    return Option.getOrUndefined(maybeText);
+  });
 }

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

@@ -9,9 +9,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 { 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';
 
@@ -34,7 +36,7 @@ function openInBrowser(filePath: string): void {
   }
 }
 
-export function registerPreviewPrototypeTool(pi: ExtensionAPI): void {
+export function registerPreviewPrototypeTool(pi: ExtensionAPI, runPlanIO: RunPlanIO): void {
   pi.registerTool({
     name: 'preview_prototype',
     label: 'Preview Prototype',
@@ -59,8 +61,13 @@ export function registerPreviewPrototypeTool(pi: ExtensionAPI): void {
       const filePath = join(PREVIEW_DIR, `${slug}.html`);
       const html = renderPrototypeHtml(params.title, params.intent, params.pug);
 
-      await mkdir(PREVIEW_DIR, { recursive: true });
-      await writeFile(filePath, html, 'utf-8');
+      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');
 

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

@@ -5,10 +5,11 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
-import { mkdir } from 'node:fs/promises';
+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';
 
@@ -16,14 +17,16 @@ 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, and HANDOFF.md.',
-    promptSnippet:
-      'Finalize the plan with title, handoff, tasks, and dependencies',
+    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.',
@@ -78,10 +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 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);