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

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`. */

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,

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 {

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,13 @@ 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';
 

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,63 +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;
-  /**
-   * Git commit (HEAD) the plan was written against, captured at submit time.
-   * Optional for back-compat: older tasks.jsonl files predate this field, and
-   * it stays undefined when git metadata is unavailable (no repo, no commits).
-   */
-  base_commit?: string;
-}
-
-export interface PlanData {
-  title: string;
-  planName: string;
-  handoff: string;
-  tasks: TaskRecord[];
-  /** Git commit the plan was written against; powers the executor drift check. */
-  base_commit?: string;
-}
-
-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;
@@ -66,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.26.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');
-  });
-});

package/extensions/plan-mode/__tests__/concurrent-writes.test.ts

@@ -1,85 +0,0 @@
-/**
- * Regression: concurrent read-modify-write on the registries must not lose
- * updates. Each `Effect.runPromise` mimics a separate tool execute running in
- * the same block (e.g. three `submit_initiative` calls). Before the file-lock
- * fix, their reads all saw the same starting file and the last write clobbered
- * the rest — only one entry survived.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect } from 'effect';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { FileSystem, nodeFileSystemService } from '../effects/filesystem.js';
-import { readPlansManifest, upsertPlanEntry } from '../storage/plans-manifest.js';
-import {
-  readInitiativesManifest,
-  upsertInitiativeEntry,
-} from '../storage/initiatives-manifest.js';
-import { writeTasksJsonl, readTasksJsonl, updateTask } from '../storage/task-storage.js';
-import type { TaskMeta, TaskRecord } from '../types.js';
-
-// Each call gets its OWN runPromise so the writes are genuinely concurrent —
-// the same shape as independent tool executes sharing one Node process.
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-concurrent-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('concurrent registry writes', () => {
-  test('5 concurrent plan upserts all persist (no lost updates)', async () => {
-    const names = ['a', 'b', 'c', 'd', 'e'];
-    await Promise.all(
-      names.map((n) => run(upsertPlanEntry(n, { status: 'in-progress', title: n.toUpperCase() }))),
-    );
-    const entries = await run(readPlansManifest());
-    expect(entries.map((e) => e.name).sort()).toEqual(names);
-  });
-
-  test('3 concurrent initiative upserts all persist (no lost updates)', async () => {
-    const names = ['one', 'two', 'three'];
-    await Promise.all(
-      names.map((n) => run(upsertInitiativeEntry(n, { status: 'in-progress', title: n }))),
-    );
-    const entries = await run(readInitiativesManifest());
-    expect(entries.map((e) => e.name).sort()).toEqual([...names].sort());
-  });
-
-  test('concurrent task updates to the same plan all persist', async () => {
-    const planDir = join('.plans', 'p');
-    const meta: TaskMeta = {
-      _type: 'meta',
-      plan_name: 'p',
-      title: 'P',
-      created_at: 'now',
-    };
-    const tasks: TaskRecord[] = ['t-001', 't-002', 't-003'].map((id) => ({
-      _type: 'task',
-      id,
-      description: id,
-      status: 'pending',
-      created_at: 'now',
-      updated_at: 'now',
-    }));
-    await run(writeTasksJsonl(planDir, meta, tasks));
-
-    await Promise.all(
-      tasks.map((t) => run(updateTask(planDir, t.id, { status: 'done' }))),
-    );
-
-    const snapshot = await run(readTasksJsonl(planDir));
-    expect(snapshot?.tasks.every((t) => t.status === 'done')).toBe(true);
-  });
-});

package/extensions/plan-mode/__tests__/initiative-readiness.test.ts

@@ -1,159 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Effect } from 'effect';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { FileSystem, nodeFileSystemService } from '../effects/filesystem.js';
-import {
-  computePlanReadiness,
-  initiativeRollup,
-  isInitiativeFinalizable,
-  reconcileInitiativeForPlan,
-  reconcileInitiativeStatus,
-} from '../initiative.js';
-import { upsertPlanEntry, type PlanManifestEntry } from '../storage/plans-manifest.js';
-import {
-  readInitiativesManifest,
-  upsertInitiativeEntry,
-} from '../storage/initiatives-manifest.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-function plan(partial: Partial<PlanManifestEntry> & { name: string }): PlanManifestEntry {
-  return {
-    _type: 'plan',
-    status: 'in-progress',
-    title: partial.name,
-    created_at: 'now',
-    completed_at: null,
-    ...partial,
-  };
-}
-
-describe('computePlanReadiness (pure)', () => {
-  test('a plan with no deps is ready', () => {
-    const rows = computePlanReadiness([plan({ name: 'a' })]);
-    expect(rows).toEqual([{ name: 'a', ready: true, blockedBy: [] }]);
-  });
-
-  test('a plan whose dep is done is ready; otherwise blocked', () => {
-    const plans = [
-      plan({ name: 'schema', status: 'done' }),
-      plan({ name: 'api', depends_on: ['schema'] }),
-      plan({ name: 'ui', depends_on: ['api'] }),
-    ];
-    const byName = new Map(computePlanReadiness(plans).map((r) => [r.name, r]));
-    expect(byName.get('api')?.ready).toBe(true);
-    expect(byName.get('ui')?.ready).toBe(false);
-    expect(byName.get('ui')?.blockedBy).toEqual(['api']);
-  });
-
-  test('only in-progress plans are reported (done dep itself is not a row)', () => {
-    const rows = computePlanReadiness([
-      plan({ name: 'schema', status: 'done' }),
-      plan({ name: 'api', depends_on: ['schema'] }),
-    ]);
-    expect(rows.map((r) => r.name)).toEqual(['api']);
-  });
-
-  test('an unknown or terminally-closed dep keeps a plan blocked', () => {
-    const rows = computePlanReadiness([
-      plan({ name: 'ghost-dep', status: 'abandoned' }),
-      plan({ name: 'x', depends_on: ['ghost-dep', 'missing'] }),
-    ]);
-    const x = rows.find((r) => r.name === 'x');
-    expect(x?.ready).toBe(false);
-    expect(x?.blockedBy.sort()).toEqual(['ghost-dep', 'missing']);
-  });
-});
-
-describe('isInitiativeFinalizable / initiativeRollup (pure)', () => {
-  const plans = [
-    plan({ name: 'a', initiative: 'big', status: 'done' }),
-    plan({ name: 'b', initiative: 'big', status: 'in-progress', depends_on: ['a'] }),
-    plan({ name: 'c', initiative: 'big', status: 'in-progress', depends_on: ['b'] }),
-    plan({ name: 'solo' }), // not a member
-  ];
-
-  test('not finalizable while a member is in-progress', () => {
-    expect(isInitiativeFinalizable('big', plans)).toBe(false);
-  });
-
-  test('finalizable when all members are terminal', () => {
-    const allClosed = [
-      plan({ name: 'a', initiative: 'big', status: 'done' }),
-      plan({ name: 'b', initiative: 'big', status: 'superseded' }),
-    ];
-    expect(isInitiativeFinalizable('big', allClosed)).toBe(true);
-  });
-
-  test('an empty initiative is never finalizable', () => {
-    expect(isInitiativeFinalizable('nope', plans)).toBe(false);
-  });
-
-  test('rollup counts members, progress, and readiness', () => {
-    const r = initiativeRollup('big', plans);
-    expect(r.total).toBe(3);
-    expect(r.done).toBe(1);
-    expect(r.inProgress).toBe(2);
-    expect(r.ready).toBe(1); // b (dep a is done)
-    expect(r.blocked).toBe(1); // c (dep b is in-progress)
-    const b = r.members.find((m) => m.name === 'b');
-    expect(b?.ready).toBe(true);
-    const c = r.members.find((m) => m.name === 'c');
-    expect(c?.blockedBy).toEqual(['b']);
-  });
-});
-
-describe('reconcileInitiativeStatus / reconcileInitiativeForPlan (IO projection)', () => {
-  const originalCwd = process.cwd();
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'plan-mode-init-proj-'));
-    chdir(dir);
-  });
-  afterEach(async () => {
-    chdir(originalCwd);
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  test('flips an initiative to done when its last in-progress member completes', async () => {
-    await run(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
-    await run(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
-    await run(upsertPlanEntry('b', { status: 'in-progress', title: 'B', initiative: 'big' }));
-
-    await run(reconcileInitiativeStatus('big'));
-    let [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('in-progress'); // b still open
-
-    await run(upsertPlanEntry('b', { status: 'done', title: 'B', initiative: 'big' }));
-    await run(reconcileInitiativeForPlan('b'));
-    [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('done');
-  });
-
-  test('reopens a done initiative when a member goes back in-progress', async () => {
-    await run(upsertInitiativeEntry('big', { status: 'done', title: 'Big' }));
-    await run(upsertPlanEntry('a', { status: 'in-progress', title: 'A', initiative: 'big' }));
-    await run(reconcileInitiativeStatus('big'));
-    const [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('in-progress');
-  });
-
-  test('never overrides a manually-closed (superseded) initiative', async () => {
-    await run(upsertInitiativeEntry('big', { status: 'superseded', title: 'Big', reason: 'x' }));
-    await run(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
-    await run(reconcileInitiativeStatus('big'));
-    const [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('superseded');
-  });
-
-  test('reconcileInitiativeForPlan is a no-op for a standalone plan', async () => {
-    await run(upsertPlanEntry('solo', { status: 'done', title: 'Solo' }));
-    await run(reconcileInitiativeForPlan('solo'));
-    await expect(run(readInitiativesManifest())).resolves.toEqual([]);
-  });
-});