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

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([]);
-  });
-});

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

@@ -1,89 +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 {
-  readInitiativesManifest,
-  upsertInitiativeEntry,
-  writeInitiativesManifest,
-} 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)));
-
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-initiatives-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('initiatives.jsonl manifest', () => {
-  test('round trips entries', async () => {
-    const entry = {
-      _type: 'initiative' as const,
-      name: 'auth-overhaul',
-      status: 'in-progress' as const,
-      title: 'Auth Overhaul',
-      created_at: 'now',
-      completed_at: null,
-    };
-    await run(writeInitiativesManifest([entry]));
-    await expect(run(readInitiativesManifest())).resolves.toEqual([entry]);
-  });
-
-  test('missing manifest returns an empty list', async () => {
-    await expect(run(readInitiativesManifest())).resolves.toEqual([]);
-  });
-
-  test('upserts new entries', async () => {
-    await run(upsertInitiativeEntry('big-thing', { status: 'in-progress', title: 'Big Thing' }));
-    const entries = await run(readInitiativesManifest());
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.name).toBe('big-thing');
-    expect(entries[0]?.title).toBe('Big Thing');
-    expect(entries[0]?.completed_at).toBeNull();
-  });
-
-  test('upserts existing entries without changing created_at', async () => {
-    await run(
-      writeInitiativesManifest([
-        {
-          _type: 'initiative',
-          name: 'i',
-          status: 'in-progress',
-          title: 'Old',
-          created_at: 'created',
-          completed_at: null,
-        },
-      ]),
-    );
-    await run(upsertInitiativeEntry('i', { status: 'done', title: 'New' }));
-    const [entry] = await run(readInitiativesManifest());
-    expect(entry.created_at).toBe('created');
-    expect(entry.status).toBe('done');
-    expect(entry.completed_at).toBeString();
-  });
-
-  test('records a reason for terminal statuses and clears completed_at on reopen', async () => {
-    await run(upsertInitiativeEntry('i', { status: 'in-progress', title: 'I' }));
-    await run(upsertInitiativeEntry('i', { status: 'superseded', reason: 'merged into j' }));
-    let [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('superseded');
-    expect(entry.reason).toBe('merged into j');
-    expect(entry.completed_at).toBeString();
-
-    await run(upsertInitiativeEntry('i', { status: 'in-progress' }));
-    [entry] = await run(readInitiativesManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-});

package/extensions/plan-mode/__tests__/list-initiatives.test.ts

@@ -1,59 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { upsertInitiativeEntry } from '../storage/initiatives-manifest.js';
-import {
-  filterInitiatives,
-  formatInitiativeList,
-  loadInitiativeListItems,
-  parseFilter,
-} from '../commands/list-initiatives.js';
-
-const runPlanIO = makePlanRuntime();
-
-const originalCwd = process.cwd();
-let dir: string;
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-list-init-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('list-initiatives', () => {
-  test('parseFilter maps aliases', () => {
-    expect(parseFilter('done')).toBe('done');
-    expect(parseFilter('active')).toBe('in-progress');
-    expect(parseFilter('whatever')).toBe('all');
-  });
-
-  test('rolls up member-plan progress and readiness', async () => {
-    await runPlanIO(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
-    await runPlanIO(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
-    await runPlanIO(
-      upsertPlanEntry('b', { status: 'in-progress', title: 'B', initiative: 'big', depends_on: ['a'] }),
-    );
-
-    const items = await runPlanIO(loadInitiativeListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0]?.totalPlans).toBe(2);
-    expect(items[0]?.donePlans).toBe(1);
-    expect(items[0]?.ready).toBe(1); // b unblocked (a done)
-
-    const text = formatInitiativeList(items, 'all');
-    expect(text).toMatch(/big — Big \[1\/2 plans, ready 1, blocked 0\]/);
-  });
-
-  test('filterInitiatives narrows by status', async () => {
-    await runPlanIO(upsertInitiativeEntry('x', { status: 'in-progress', title: 'X' }));
-    await runPlanIO(upsertInitiativeEntry('y', { status: 'done', title: 'Y' }));
-    const items = await runPlanIO(loadInitiativeListItems());
-    expect(filterInitiatives(items, 'done').map((i) => i.name)).toEqual(['y']);
-  });
-});

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

@@ -1,253 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { chdir } from 'node:process';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { makePlanRuntime } from '../effects/runtime.js';
-import { upsertPlanEntry } from '../storage/plans-manifest.js';
-import { writeTasksJsonl } from '../storage/task-storage.js';
-import type { TaskMeta, TaskRecord, PlanStatus } from '../types.js';
-import {
-  filterPlans,
-  sortPlans,
-  formatPlanList,
-  parseArgs,
-  loadPlanListItems,
-  type PlanListItem,
-  type SortField,
-  type StatusFilter,
-} from '../commands/list-plans.js';
-
-const runPlanIO = makePlanRuntime();
-const originalCwd = process.cwd();
-let dir: string;
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-list-'));
-  chdir(dir);
-});
-
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-const meta = (name: string): TaskMeta => ({
-  _type: 'meta',
-  title: `Title ${name}`,
-  plan_name: name,
-  created_at: '2026-01-01T00:00:00.000Z',
-});
-
-const task = (id: string, status: 'done' | 'pending' = 'done'): TaskRecord => ({
-  _type: 'task',
-  id,
-  description: `task ${id}`,
-  status,
-  origin: 'plan',
-  created_at: '2026-01-01T00:00:00.000Z',
-  updated_at: '2026-01-01T00:00:00.000Z',
-});
-
-function makePlanItem(overrides: Partial<PlanListItem> & { name: string }): PlanListItem {
-  return {
-    title: `Title ${overrides.name}`,
-    status: 'in-progress',
-    created_at: '2026-01-01T00:00:00.000Z',
-    completed_at: null,
-    totalTasks: 3,
-    doneTasks: 1,
-    pendingTasks: 2,
-    ...overrides,
-  };
-}
-
-// ── filterPlans ──────────────────────────────────────────────────────────────
-
-describe('filterPlans', () => {
-  const plans: PlanListItem[] = [
-    makePlanItem({ name: 'alpha', status: 'in-progress' }),
-    makePlanItem({ name: 'beta', status: 'done' }),
-    makePlanItem({ name: 'gamma', status: 'abandoned' }),
-  ];
-
-  test('returns all when filter is "all"', () => {
-    expect(filterPlans(plans, 'all')).toHaveLength(3);
-  });
-
-  test('filters by in-progress', () => {
-    const result = filterPlans(plans, 'in-progress');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('alpha');
-  });
-
-  test('filters by done', () => {
-    const result = filterPlans(plans, 'done');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('beta');
-  });
-
-  test('filters by abandoned', () => {
-    const result = filterPlans(plans, 'abandoned');
-    expect(result).toHaveLength(1);
-    expect(result[0].name).toBe('gamma');
-  });
-
-  test('returns empty when no match', () => {
-    expect(filterPlans(plans, 'superseded')).toHaveLength(0);
-  });
-});
-
-// ── sortPlans ────────────────────────────────────────────────────────────────
-
-describe('sortPlans', () => {
-  const plans: PlanListItem[] = [
-    makePlanItem({ name: 'charlie', created_at: '2026-03-01T00:00:00.000Z', totalTasks: 2 }),
-    makePlanItem({ name: 'alpha', created_at: '2026-01-01T00:00:00.000Z', totalTasks: 5 }),
-    makePlanItem({ name: 'bravo', created_at: '2026-02-01T00:00:00.000Z', totalTasks: 1 }),
-  ];
-
-  test('sorts by name', () => {
-    const result = sortPlans(plans, 'name');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'bravo', 'charlie']);
-  });
-
-  test('sorts by date ascending (oldest first)', () => {
-    const result = sortPlans(plans, 'date-asc');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'bravo', 'charlie']);
-  });
-
-  test('sorts by date descending (newest first)', () => {
-    const result = sortPlans(plans, 'date-desc');
-    expect(result.map((p) => p.name)).toEqual(['charlie', 'bravo', 'alpha']);
-  });
-
-  test('sorts by task count (most tasks first)', () => {
-    const result = sortPlans(plans, 'tasks');
-    expect(result.map((p) => p.name)).toEqual(['alpha', 'charlie', 'bravo']);
-  });
-
-  test('does not mutate the original array', () => {
-    const original = [...plans];
-    sortPlans(plans, 'name');
-    expect(plans.map((p) => p.name)).toEqual(original.map((p) => p.name));
-  });
-});
-
-// ── formatPlanList ───────────────────────────────────────────────────────────
-
-describe('formatPlanList', () => {
-  test('shows message when empty and filter is all', () => {
-    expect(formatPlanList([], 'all', 'date-desc')).toContain('No plans found');
-  });
-
-  test('shows filter-specific message when empty', () => {
-    expect(formatPlanList([], 'done', 'date-desc')).toContain('No plans with status "done"');
-  });
-
-  test('includes plan details in output', () => {
-    const plans = [makePlanItem({ name: 'alpha', title: 'Alpha Plan', totalTasks: 5, doneTasks: 3 })];
-    const output = formatPlanList(plans, 'all', 'date-desc');
-    expect(output).toContain('alpha');
-    expect(output).toContain('Alpha Plan');
-    expect(output).toContain('3/5 tasks');
-  });
-
-  test('shows header with count and sort', () => {
-    const plans = [makePlanItem({ name: 'a' }), makePlanItem({ name: 'b' })];
-    const output = formatPlanList(plans, 'all', 'tasks');
-    expect(output).toContain('All plans (2)');
-    expect(output).toContain('most tasks first');
-  });
-});
-
-// ── parseArgs ────────────────────────────────────────────────────────────────
-
-describe('parseArgs', () => {
-  test('parses filter only', () => {
-    expect(parseArgs('done')).toEqual({ filter: 'done', sort: 'date-desc' });
-  });
-
-  test('parses sort only', () => {
-    expect(parseArgs('oldest')).toEqual({ filter: 'all', sort: 'date-asc' });
-  });
-
-  test('parses filter and sort together', () => {
-    expect(parseArgs('in-progress tasks')).toEqual({ filter: 'in-progress', sort: 'tasks' });
-  });
-
-  test('accepts aliases', () => {
-    expect(parseArgs('pending newest')).toEqual({ filter: 'in-progress', sort: 'date-desc' });
-    expect(parseArgs('active oldest')).toEqual({ filter: 'in-progress', sort: 'date-asc' });
-    expect(parseArgs('completed name')).toEqual({ filter: 'done', sort: 'name' });
-  });
-
-  test('defaults to all + date-desc for unknown tokens', () => {
-    expect(parseArgs('unknown gibberish')).toEqual({ filter: 'all', sort: 'date-desc' });
-  });
-
-  test('is case-insensitive', () => {
-    expect(parseArgs('DONE TASKS')).toEqual({ filter: 'done', sort: 'tasks' });
-  });
-});
-
-// ── loadPlanListItems (integration) ──────────────────────────────────────────
-
-describe('loadPlanListItems', () => {
-  test('returns empty for no plans', async () => {
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toEqual([]);
-  });
-
-  test('loads plans with task counts', async () => {
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Alpha' }));
-    await runPlanIO(
-      writeTasksJsonl('.plans/alpha', meta('alpha'), [
-        task('t-001', 'done'),
-        task('t-002', 'pending'),
-        task('t-003', 'pending'),
-      ]),
-    );
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0].name).toBe('alpha');
-    expect(items[0].totalTasks).toBe(3);
-    expect(items[0].doneTasks).toBe(1);
-    expect(items[0].pendingTasks).toBe(2);
-  });
-
-  test('handles plans without task files', async () => {
-    await runPlanIO(upsertPlanEntry('orphan', { status: 'in-progress', title: 'Orphan' }));
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(1);
-    expect(items[0].totalTasks).toBe(0);
-    expect(items[0].doneTasks).toBe(0);
-  });
-
-  test('loads multiple plans', async () => {
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Alpha' }));
-    await runPlanIO(upsertPlanEntry('beta', { status: 'done', title: 'Beta' }));
-    await runPlanIO(
-      writeTasksJsonl('.plans/alpha', meta('alpha'), [task('t-001', 'pending')]),
-    );
-    await runPlanIO(
-      writeTasksJsonl('.plans/beta', meta('beta'), [task('t-001', 'done'), task('t-002', 'done')]),
-    );
-
-    const items = await runPlanIO(loadPlanListItems());
-    expect(items).toHaveLength(2);
-
-    const alpha = items.find((i) => i.name === 'alpha')!;
-    expect(alpha.status).toBe('in-progress');
-    expect(alpha.totalTasks).toBe(1);
-
-    const beta = items.find((i) => i.name === 'beta')!;
-    expect(beta.status).toBe('done');
-    expect(beta.totalTasks).toBe(2);
-    expect(beta.doneTasks).toBe(2);
-  });
-});