@dreki-gg/pi-plan-mode 0.25.0 → 0.26.1

package/extensions/plan-mode/exec-pending.ts

@@ -0,0 +1,59 @@
+/**
+ * Exec-pending marker I/O — the pi-mode one-shot handoff from planning to
+ * execution. This is pi-workflow-specific (model + thinking preset for the
+ * execution run), so it stays in the extension rather than the engine package.
+ */
+
+import { Effect, Either, Option } from 'effect';
+import {
+  FileSystem,
+  decodeExecPendingConfig,
+  type ExecPendingConfig,
+  type PlanWriteError,
+} from '@dreki-gg/taskman';
+import { EXEC_PENDING_FILE } from './constants.js';
+
+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 function readAndClearExecPending(): Effect.Effect<
+  { planDir: string; config: ExecPendingConfig } | undefined,
+  never,
+  FileSystem
+> {
+  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 {
+        parsed = JSON.parse(maybeText.value);
+      } catch {
+        continue;
+      }
+      const decoded = decodeExecPendingConfig(parsed);
+      if (Either.isLeft(decoded)) continue;
+
+      yield* Effect.ignore(fs.removeFile(markerPath));
+      return { planDir: dir, config: decoded.right };
+    }
+    return undefined;
+  });
+}

package/extensions/plan-mode/git.ts

@@ -0,0 +1,21 @@
+/**
+ * Read-only git helpers. Failure-tolerant by design: plan-mode must never block
+ * or throw because git metadata is unavailable (no repo, detached HEAD, no
+ * commits yet). Runs on Node via execFile — no Bun APIs.
+ */
+
+import { execFile } from 'node:child_process';
+
+/**
+ * Resolve the current HEAD commit SHA, or undefined when it cannot be read.
+ * Never rejects — callers treat undefined as "no drift baseline".
+ */
+export function readHeadCommit(cwd: string = process.cwd()): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    execFile('git', ['rev-parse', 'HEAD'], { cwd }, (error, stdout) => {
+      if (error) return resolve(undefined);
+      const sha = stdout.trim();
+      resolve(sha.length > 0 ? sha : undefined);
+    });
+  });
+}

package/extensions/plan-mode/index.ts

@@ -28,19 +28,20 @@ import {
 } from './constants.js';
 import type { ThinkingLevel, TaskStatus } from './types.js';
 import { PlanModeState } from './state.js';
-import { makePlanRuntime } from './effects/runtime.js';
-import { loadHandoff, readAndClearExecPending } from './storage/plan-storage.js';
-import { readTasksJsonl, writeTasksJsonl } from './storage/task-storage.js';
-import { upsertPlanEntry, reconcilePlanStatus } from './storage/plans-manifest.js';
+import { makePlanRuntime } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
+import { readAndClearExecPending } from './exec-pending.js';
+import { readTasksJsonl, writeTasksJsonl } from '@dreki-gg/taskman';
+import { upsertPlanEntry, reconcilePlanStatus } from '@dreki-gg/taskman';
 import { updateUI } from './ui.js';
 import { buildPlanModePrompt, buildExecutionPrompt } from './prompts.js';
 import { filterExecutionMessages, filterStalePlanMessages } from './context-filter.js';
-import { activeTasksResolved, deferredTasks, isPlanFinalizable } from './task-status.js';
+import { activeTasksResolved, deferredTasks, isPlanFinalizable } from '@dreki-gg/taskman';
 import { enterPlanMode, exitPlanMode, switchModel } from './phase-transitions.js';
 import { resumePlan, executeInNewSession } from './resume.js';
 import { resolveActivePlan, focusActivePlan } from './resolve-plan.js';
-import { reconcileInitiativeForPlan } from './initiative.js';
-import { collectPlanDrift } from './reconcile.js';
+import { reconcileInitiativeForPlan } from '@dreki-gg/taskman';
+import { collectPlanDrift } from '@dreki-gg/taskman';
 import { registerSubmitPlanTool } from './tools/submit-plan.js';
 import { registerSubmitInitiativeTool } from './tools/submit-initiative.js';
 import { registerRevisePlanTool } from './tools/revise-plan.js';
@@ -626,6 +627,7 @@ export default function planMode(pi: ExtensionAPI): void {
               planName: snapshot.meta.plan_name,
               handoff: (await runPlanIO(loadHandoff(pending.planDir))) ?? '',
               tasks: snapshot.tasks,
+              base_commit: snapshot.meta.base_commit,
             }
           : undefined;
       }

package/extensions/plan-mode/prompts.ts

@@ -28,7 +28,7 @@ When you are ready to finalize the plan, call submit_plan with:
 - tasks: an array of tasks with id (e.g. "t-001"), description (≤60 chars), optional details, and optional depends_on task IDs
 
 Plan weight:
-- **Delegation plans** (different agent/human executes): include full details in each task so an executor with zero context can follow them.
+- **Delegation plans** (different agent/human executes): include full details in each task so an executor with zero context can follow them. End each task's details with a **verification gate** — a concrete command and its expected output (e.g. \`bun test\` → all pass) so the executor can prove success without judgement, plus any **STOP conditions** ("if X, stop and report" instead of improvising when reality doesn't match the plan).
 - **Self-execution plans** (you plan and execute in the same session): use lightweight checklist-style tasks — just id + description, skip details. The handoff doc carries the real context.
 
 submit_plan is finalization, not the starting point. It records tasks and the handoff — it does not generate HTML.
@@ -59,6 +59,10 @@ export function buildExecutionPrompt(plan: PlanData): string | undefined {
   const currentTask = remaining[0];
   const currentDetails = currentTask.details ? `\nDetails: ${currentTask.details}` : '';
 
+  const driftCheck = plan.base_commit
+    ? `\n## Drift check (do this FIRST)\nThis plan was written against git commit ${plan.base_commit}. Before editing, run \`git rev-parse HEAD\`. If it differs, the codebase has moved since the plan was written: run \`git diff ${plan.base_commit} --stat\`, re-read any files the current task touches, and proceed with caution — adjust to what the code actually looks like now. This is a warning, not a stop.\n`
+    : '';
+
   return `[EXECUTING PLAN — FOLLOW THE PLAN EXACTLY]
 
 You are executing a structured plan. Your ONLY job is to implement the plan tasks below, one at a time.
@@ -73,6 +77,7 @@ Rules:
 
 ## Current task
 ${currentTask.id}: ${currentTask.description}${currentDetails}
+${driftCheck}
 
 ## Handoff
 ${plan.handoff}

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

@@ -10,12 +10,12 @@
 
 import { Effect } from 'effect';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import type { FileSystem } from '../effects/filesystem.js';
-import type { RunPlanIO } from '../effects/runtime.js';
+import type { FileSystem } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import type { PlanStatus, TaskRecord, TaskStatus } from '../types.js';
-import { readPlansManifest } from '../storage/plans-manifest.js';
-import { readTasksJsonl } from '../storage/task-storage.js';
-import { loadHandoff } from '../storage/plan-storage.js';
+import { readPlansManifest } from '@dreki-gg/taskman';
+import { readTasksJsonl } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
 import { firstPlanReference } from './tokens.js';
 
 export interface ResolvedPlanReference {

package/extensions/plan-mode/references/plan-index.ts

@@ -7,7 +7,7 @@
  * per-keystroke disk hit.
  */
 
-import type { RunPlanIO } from '../effects/runtime.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import { loadPlanListItems, type PlanListItem } from '../commands/list-plans.js';
 
 const DEFAULT_TTL_MS = 2_000;

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

@@ -17,10 +17,10 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import type { PlanModeState } from './state.js';
 import type { PlanData } from './types.js';
-import type { RunPlanIO } from './effects/runtime.js';
-import { readPlansManifest } from './storage/plans-manifest.js';
-import { readTasksJsonl } from './storage/task-storage.js';
-import { loadHandoff } from './storage/plan-storage.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { readPlansManifest } from '@dreki-gg/taskman';
+import { readTasksJsonl } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
 
 export interface ResolvedPlan {
   /** The attached plan, when resolvable. Already written into `state`. */
@@ -57,6 +57,7 @@ async function attach(
     planName: snapshot.meta.plan_name,
     handoff: (await runPlanIO(loadHandoff(dir))) ?? '',
     tasks: snapshot.tasks,
+    base_commit: snapshot.meta.base_commit,
   };
   state.plan = plan;
   state.planDir = dir;

package/extensions/plan-mode/resume.ts

@@ -9,13 +9,14 @@ import type {
 } from '@earendil-works/pi-coding-agent';
 import type { PlanModeState } from './state.js';
 import type { PlanData } from './types.js';
-import type { RunPlanIO } from './effects/runtime.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import { EXEC_THINKING, EXEC_MODEL_OPTIONS } from './constants.js';
-import { readPlansManifest } from './storage/plans-manifest.js';
-import { loadHandoff, writeExecPending } from './storage/plan-storage.js';
-import { readTasksJsonl, writeTasksJsonl } from './storage/task-storage.js';
+import { readPlansManifest } from '@dreki-gg/taskman';
+import { loadHandoff } from '@dreki-gg/taskman';
+import { writeExecPending } from './exec-pending.js';
+import { readTasksJsonl, writeTasksJsonl } from '@dreki-gg/taskman';
 import { enterPlanMode } from './phase-transitions.js';
-import { reactivateForExecution } from './task-status.js';
+import { reactivateForExecution } from '@dreki-gg/taskman';
 
 export async function pickExecutionModel(
   ctx: ExtensionContext,
@@ -82,6 +83,7 @@ export async function resumePlan(
     planName: snapshot.meta.plan_name,
     handoff: (await runPlanIO(loadHandoff(dir))) ?? '',
     tasks: snapshot.tasks,
+    base_commit: snapshot.meta.base_commit,
   };
 
   const doneCount = state.plan.tasks.filter(

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

@@ -11,7 +11,7 @@ import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
 import type { TaskRecord } from '../types.js';
 import type { ResolvedPlan } from '../resolve-plan.js';
-import { nextTaskId } from '../utils.js';
+import { nextTaskId } from '@dreki-gg/taskman';
 
 export interface AddTaskCallbacks {
   /** Resolve the active plan, attaching from disk when none is in memory. */

package/extensions/plan-mode/tools/initiative-status.ts

@@ -12,12 +12,12 @@ 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 type { RunPlanIO } from '../effects/runtime.js';
-import { FileSystem } from '../effects/filesystem.js';
-import { readPlansManifest, type PlanManifestEntry } from '../storage/plans-manifest.js';
-import { readInitiativesManifest } from '../storage/initiatives-manifest.js';
-import { readTasksJsonl } from '../storage/task-storage.js';
-import { initiativeRollup, membersOf, type InitiativeRollup } from '../initiative.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { FileSystem } from '@dreki-gg/taskman';
+import { readPlansManifest, type PlanManifestEntry } from '@dreki-gg/taskman';
+import { readInitiativesManifest } from '@dreki-gg/taskman';
+import { readTasksJsonl } from '@dreki-gg/taskman';
+import { initiativeRollup, membersOf, type InitiativeRollup } from '@dreki-gg/taskman';
 
 /** Normalize an initiative hint (`x` or `.plans/x`) to a bare name. */
 function normalizeName(hint: string): string {

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

@@ -12,10 +12,10 @@ 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 { FileSystem } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import { buildPrototypeDocument } from '../html/render.js';
-import { toKebabCase } from '../utils.js';
+import { toKebabCase } from '@dreki-gg/taskman';
 
 const PREVIEW_DIR = '.plans/_prototypes';
 

package/extensions/plan-mode/tools/reconcile-plans.ts

@@ -10,7 +10,7 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
-import type { RunPlanIO } from '../effects/runtime.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import {
   applyInitiativeReconcile,
   applyReconcile,
@@ -18,7 +18,7 @@ import {
   collectPlanDrift,
   type InitiativeDriftRow,
   type PlanDriftRow,
-} from '../reconcile.js';
+} from '@dreki-gg/taskman';
 
 function describeRow(row: PlanDriftRow): string {
   const progress = row.hasTasks ? ` (${row.resolved}/${row.total})` : '';

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

@@ -16,17 +16,17 @@ 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 { saveHandoff } from '../storage/plan-storage.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
+import { saveHandoff } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
 import {
   readPlansManifest,
   reconcilePlanStatus,
   upsertPlanEntry,
-} from '../storage/plans-manifest.js';
-import { reconcileInitiativeForPlan, reconcileInitiativeStatus } from '../initiative.js';
-import { isPlanFinalizable } from '../task-status.js';
-import { toKebabCase } from '../utils.js';
-import type { RunPlanIO } from '../effects/runtime.js';
+} from '@dreki-gg/taskman';
+import { reconcileInitiativeForPlan, reconcileInitiativeStatus } from '@dreki-gg/taskman';
+import { isPlanFinalizable } from '@dreki-gg/taskman';
+import { toKebabCase } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import type { PlanData, TaskMeta, TaskRecord } from '../types.js';
 
 export interface RevisePlanCallbacks {
@@ -129,12 +129,14 @@ export function registerRevisePlanTool(
         title: newTitle,
         plan_name: plan.planName,
         created_at: plan.tasks[0]?.created_at ?? now,
+        base_commit: plan.base_commit,
       };
       const revised: PlanData = {
         title: newTitle,
         planName: plan.planName,
         handoff: newHandoff,
         tasks,
+        base_commit: plan.base_commit,
       };
       const planDir = `.plans/${plan.planName}`;
 

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

@@ -12,10 +12,10 @@ 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 { saveInitiative } from '../storage/plan-storage.js';
-import { upsertInitiativeEntry } from '../storage/initiatives-manifest.js';
-import type { RunPlanIO } from '../effects/runtime.js';
-import { toKebabCase } from '../utils.js';
+import { saveInitiative } from '@dreki-gg/taskman';
+import { upsertInitiativeEntry } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { toKebabCase } from '@dreki-gg/taskman';
 
 export function registerSubmitInitiativeTool(pi: ExtensionAPI, runPlanIO: RunPlanIO): void {
   pi.registerTool({

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

@@ -6,13 +6,14 @@ 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 { saveHandoff } from '../storage/plan-storage.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { readInitiativesManifest } from '../storage/initiatives-manifest.js';
-import { reconcileInitiativeForPlan } from '../initiative.js';
-import type { RunPlanIO } from '../effects/runtime.js';
-import { toKebabCase } from '../utils.js';
+import { saveHandoff } from '@dreki-gg/taskman';
+import { writeTasksJsonl } from '@dreki-gg/taskman';
+import { upsertPlanEntry } from '@dreki-gg/taskman';
+import { readInitiativesManifest } from '@dreki-gg/taskman';
+import { reconcileInitiativeForPlan } from '@dreki-gg/taskman';
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { toKebabCase } from '@dreki-gg/taskman';
+import { readHeadCommit } from '../git.js';
 import type { PlanData, TaskMeta, TaskRecord } from '../types.js';
 
 export interface SubmitPlanCallbacks {
@@ -33,6 +34,7 @@ export function registerSubmitPlanTool(
       '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.",
+      "For delegation tasks (those with details), end the details with a verification gate: a concrete command and its expected output, plus any STOP conditions, so a zero-context executor can prove success without judgement.",
       '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.',
@@ -81,11 +83,13 @@ export function registerSubmitPlanTool(
       const initiative = params.initiative ? toKebabCase(params.initiative) : undefined;
       const dependsOnPlans = params.depends_on_plans?.map(toKebabCase);
       const now = new Date().toISOString();
+      const baseCommit = await readHeadCommit();
       const meta: TaskMeta = {
         _type: 'meta',
         title: params.title,
         plan_name: planName,
         created_at: now,
+        base_commit: baseCommit,
       };
       const tasks: TaskRecord[] = params.tasks.map((task) => ({
         _type: 'task',
@@ -97,7 +101,13 @@ export function registerSubmitPlanTool(
         created_at: now,
         updated_at: now,
       }));
-      const plan: PlanData = { title: params.title, planName, handoff: params.handoff, tasks };
+      const plan: PlanData = {
+        title: params.title,
+        planName,
+        handoff: params.handoff,
+        tasks,
+        base_commit: baseCommit,
+      };
 
       const unknownInitiative = await runPlanIO(
         Effect.gen(function* () {

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

@@ -12,11 +12,11 @@ import { StringEnum } from '@earendil-works/pi-ai';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
 import type { InitiativeStatus } from '../types.js';
-import type { RunPlanIO } from '../effects/runtime.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
 import {
   readInitiativesManifest,
   upsertInitiativeEntry,
-} from '../storage/initiatives-manifest.js';
+} from '@dreki-gg/taskman';
 
 /** Normalize an initiative hint (`x` or `.plans/x`) to a bare name. */
 function normalizeName(hint: string): string {

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

@@ -16,9 +16,9 @@ import { StringEnum } from '@earendil-works/pi-ai';
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from 'typebox';
 import type { PlanStatus } from '../types.js';
-import type { RunPlanIO } from '../effects/runtime.js';
-import { readPlansManifest, upsertPlanEntry } from '../storage/plans-manifest.js';
-import { reconcileInitiativeForPlan } from '../initiative.js';
+import type { RunPlanIO } from '@dreki-gg/taskman';
+import { readPlansManifest, upsertPlanEntry } from '@dreki-gg/taskman';
+import { reconcileInitiativeForPlan } from '@dreki-gg/taskman';
 
 /** Normalize a plan hint (`my-plan` or `.plans/my-plan`) to a bare name. */
 function normalizeName(hint: string): string {

package/extensions/plan-mode/types.ts

@@ -1,55 +1,24 @@
 /**
- * Shared types for plan mode.
+ * Plan-mode types.
+ *
+ * Engine record/value types now live in `@dreki-gg/taskman` and are re-exported
+ * here so the rest of the extension keeps importing from `./types.js`. The
+ * pi-session-only types (`PersistedState`) stay local.
  */
 
-export type TaskStatus = 'pending' | 'done' | 'skipped' | 'blocked' | 'deferred';
+export type {
+  TaskStatus,
+  TaskOrigin,
+  PlanStatus,
+  InitiativeStatus,
+  TaskRecord,
+  TaskMeta,
+  PlanData,
+  ThinkingLevel,
+  ExecPendingConfig,
+} from '@dreki-gg/taskman';
 
-/** Where a task came from: the original submitted plan, or discovered during execution. */
-export type TaskOrigin = 'plan' | 'discovered';
-
-/**
- * Plan lifecycle status. Only `in-progress` is active; `done`, `superseded`,
- * and `abandoned` are terminal and drop out of active-plan resolution.
- */
-export type PlanStatus = 'in-progress' | 'done' | 'superseded' | 'abandoned';
-
-/** Initiative lifecycle reuses the plan lifecycle literals. */
-export type InitiativeStatus = PlanStatus;
-
-export interface TaskRecord {
-  _type: 'task';
-  id: string;
-  description: string;
-  details?: string;
-  status: TaskStatus;
-  /** Defaults to 'plan' when absent (back-compat with older tasks.jsonl files). */
-  origin?: TaskOrigin;
-  depends_on?: string[];
-  notes?: string;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface TaskMeta {
-  _type: 'meta';
-  title: string;
-  plan_name: string;
-  created_at: string;
-}
-
-export interface PlanData {
-  title: string;
-  planName: string;
-  handoff: string;
-  tasks: TaskRecord[];
-}
-
-export type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-
-export interface ExecPendingConfig {
-  model: { provider: string; id: string };
-  thinking: string;
-}
+import type { PlanData } from '@dreki-gg/taskman';
 
 export interface PersistedState {
   planEnabled: boolean;
@@ -58,6 +27,3 @@ export interface PersistedState {
   plan: PlanData | undefined;
   executionStartIdx: number | undefined;
 }
-
-// Record validation lives in `schema.ts` (Effect Schema). The interfaces above
-// remain the mutable shapes used by the imperative orchestration code.

package/extensions/plan-mode/utils.ts

@@ -33,32 +33,5 @@ export function isPlanPath(filePath: string): boolean {
   return /(?:^|\/)?\.plans\//.test(normalized);
 }
 
-// ── Plan name utilities ─────────────────────────────────────────────────────
-
-export function toKebabCase(name: string): string {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 60);
-}
-
-/**
- * Generate the next sequential task id (`t-NNN`) given existing ids.
- *
- * Uses the max numeric suffix of `t-<digits>` ids + 1, zero-padded to 3.
- * Falls back to `t-<count+1>` when no ids match the pattern.
- */
-export function nextTaskId(existingIds: readonly string[]): string {
-  let max = 0;
-  let matched = false;
-  for (const id of existingIds) {
-    const m = /^t-(\d+)$/.exec(id);
-    if (!m) continue;
-    matched = true;
-    const n = Number.parseInt(m[1], 10);
-    if (n > max) max = n;
-  }
-  const next = matched ? max + 1 : existingIds.length + 1;
-  return `t-${String(next).padStart(3, '0')}`;
-}
+// Plan name / task id helpers (`toKebabCase`, `nextTaskId`) now live in
+// `@dreki-gg/taskman`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-plan-mode",
-  "version": "0.25.0",
+  "version": "0.26.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"
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "@dreki-gg/pi-command-sandbox": "^0.3.0",
+    "@dreki-gg/taskman": "^0.2.0",
     "effect": "^3.21.2"
   },
   "devDependencies": {

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

@@ -1,45 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect, Exit } from 'effect';
-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 Effect.runPromise(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 Effect.runPromise(writeFileAtomic(target, 'new'));
-
-    expect(await readFile(target, 'utf8')).toBe('new');
-  });
-
-  test('fails with PlanWriteError and leaves target untouched when the write fails', async () => {
-    const target = join(dir, 'data.txt');
-    await writeFile(target, 'original');
-
-    const exit = await Effect.runPromiseExit(writeFileAtomic(target, 'next', { mode: 0o400 }));
-
-    expect(Exit.isFailure(exit)).toBe(true);
-    expect(await readFile(target, 'utf8')).toBe('original');
-  });
-});