@dreki-gg/pi-plan-mode 0.21.0 → 0.24.0

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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,253 @@
+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);
+  });
+});

package/extensions/plan-mode/__tests__/reconcile.test.ts

@@ -10,7 +10,13 @@ import {
   upsertPlanEntry,
   writePlansManifest,
 } from '../storage/plans-manifest.js';
-import { applyReconcile, collectPlanDrift } from '../reconcile.js';
+import { upsertInitiativeEntry, readInitiativesManifest } from '../storage/initiatives-manifest.js';
+import {
+  applyInitiativeReconcile,
+  applyReconcile,
+  collectInitiativeDrift,
+  collectPlanDrift,
+} from '../reconcile.js';
 import type { TaskMeta, TaskRecord, TaskStatus } from '../types.js';
 
 const runPlanIO = makePlanRuntime();
@@ -112,3 +118,34 @@ describe('applyReconcile', () => {
     expect(entry.status).toBe('done');
   });
 });
+
+describe('initiative drift', () => {
+  test('flags an initiative whose members are all closed but registry is in-progress', 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: 'done', title: 'B', initiative: 'big' }));
+
+    const rows = await runPlanIO(collectInitiativeDrift());
+    const big = rows.find((r) => r.name === 'big')!;
+    expect(big.drift).toBe('status');
+    expect(big.derivedStatus).toBe('done');
+    expect(big.members).toBe(2);
+  });
+
+  test('applyInitiativeReconcile repairs initiative status drift', async () => {
+    await runPlanIO(upsertInitiativeEntry('big', { status: 'in-progress', title: 'Big' }));
+    await runPlanIO(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
+
+    const repaired = await runPlanIO(applyInitiativeReconcile(await runPlanIO(collectInitiativeDrift())));
+    expect(repaired.map((r) => r.name)).toEqual(['big']);
+    const [entry] = await runPlanIO(readInitiativesManifest());
+    expect(entry.status).toBe('done');
+  });
+
+  test('never flags a manually-closed (abandoned) initiative as drift', async () => {
+    await runPlanIO(upsertInitiativeEntry('big', { status: 'abandoned', title: 'Big', reason: 'x' }));
+    await runPlanIO(upsertPlanEntry('a', { status: 'done', title: 'A', initiative: 'big' }));
+    const rows = await runPlanIO(collectInitiativeDrift());
+    expect(rows.find((r) => r.name === 'big')!.drift).toBeUndefined();
+  });
+});

package/extensions/plan-mode/__tests__/revise-plan.test.ts

@@ -26,6 +26,8 @@ interface CapturedTool {
         details?: string;
         depends_on?: string[];
       }>;
+      initiative?: string;
+      depends_on_plans?: string[];
     },
   ) => Promise<{ content?: Array<{ text: string }>; details?: unknown }>;
 }
@@ -168,4 +170,40 @@ describe('revise_plan tool', () => {
     const result = await tool.execute('c', { plan: 'ghost', title: 'x' });
     expect((result.details as { error?: string }).error).toBe('not_found');
   });
+
+  test('re-links the plan to an initiative and persists plan-level deps', async () => {
+    const plan: PlanData = {
+      title: 'P',
+      planName: 'p',
+      handoff: 'h',
+      tasks: [task('t-001')],
+    };
+    await seed(plan);
+    await runPlanIO(upsertPlanEntry('p', { status: 'in-progress', title: 'P' }));
+
+    const { tool } = setup(plan);
+    await tool.execute('c', {
+      plan: 'p',
+      initiative: 'Auth Overhaul',
+      depends_on_plans: ['Schema First'],
+    });
+
+    const [entry] = await runPlanIO(readPlansManifest());
+    expect(entry.initiative).toBe('auth-overhaul');
+    expect(entry.depends_on).toEqual(['schema-first']);
+  });
+
+  test('preserves existing initiative link when not passed', async () => {
+    const plan: PlanData = { title: 'P', planName: 'p', handoff: 'h', tasks: [task('t-001')] };
+    await seed(plan);
+    await runPlanIO(
+      upsertPlanEntry('p', { status: 'in-progress', title: 'P', initiative: 'big' }),
+    );
+
+    const { tool } = setup(plan);
+    await tool.execute('c', { plan: 'p', title: 'P2' });
+
+    const [entry] = await runPlanIO(readPlansManifest());
+    expect(entry.initiative).toBe('big');
+  });
 });

package/extensions/plan-mode/__tests__/schema.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from 'bun:test';
 import { Either } from 'effect';
 import {
   decodeExecPendingConfig,
+  decodeInitiativeManifestEntry,
   decodePlanManifestEntry,
   decodeTaskMeta,
   decodeTaskRecord,
@@ -211,6 +212,93 @@ describe('plan manifest entry schema', () => {
       ),
     ).toBe(false);
   });
+
+  test('accepts optional initiative + plan-level depends_on (forward compat)', () => {
+    expect(
+      isOk(
+        {
+          _type: 'plan',
+          name: 'auth-jwt',
+          status: 'in-progress',
+          title: 'Auth JWT',
+          created_at: now,
+          completed_at: null,
+          initiative: 'auth-overhaul',
+          depends_on: ['auth-schema'],
+        },
+        decodePlanManifestEntry,
+      ),
+    ).toBe(true);
+  });
+
+  test('still accepts a legacy entry without the new optional fields (back compat)', () => {
+    expect(
+      isOk(
+        {
+          _type: 'plan',
+          name: 'legacy',
+          status: 'done',
+          title: 'Legacy',
+          created_at: now,
+          completed_at: now,
+        },
+        decodePlanManifestEntry,
+      ),
+    ).toBe(true);
+  });
+});
+
+describe('initiative manifest entry schema', () => {
+  test('accepts a valid in-progress initiative', () => {
+    expect(
+      isOk(
+        {
+          _type: 'initiative',
+          name: 'auth-overhaul',
+          status: 'in-progress',
+          title: 'Auth Overhaul',
+          created_at: now,
+          completed_at: null,
+        },
+        decodeInitiativeManifestEntry,
+      ),
+    ).toBe(true);
+  });
+
+  test('accepts terminal statuses with a reason', () => {
+    for (const status of ['done', 'superseded', 'abandoned'] as const) {
+      expect(
+        isOk(
+          {
+            _type: 'initiative',
+            name: 'auth-overhaul',
+            status,
+            title: 'Auth Overhaul',
+            created_at: now,
+            completed_at: now,
+            reason: 'shipped',
+          },
+          decodeInitiativeManifestEntry,
+        ),
+      ).toBe(true);
+    }
+  });
+
+  test('rejects a plan _type masquerading as an initiative', () => {
+    expect(
+      isOk(
+        {
+          _type: 'plan',
+          name: 'auth-overhaul',
+          status: 'in-progress',
+          title: 'Auth Overhaul',
+          created_at: now,
+          completed_at: null,
+        },
+        decodeInitiativeManifestEntry,
+      ),
+    ).toBe(false);
+  });
 });
 
 describe('exec pending config schema', () => {

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

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { chdir } from 'node:process';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { makePlanRuntime } from '../effects/runtime.js';
+import { readInitiativesManifest } from '../storage/initiatives-manifest.js';
+import { registerSubmitInitiativeTool } from '../tools/submit-initiative.js';
+
+const runPlanIO = makePlanRuntime();
+
+interface CapturedTool {
+  execute: (
+    id: string,
+    params: { name: string; title: string; overview: string },
+  ) => Promise<{ content?: Array<{ text: string }>; details?: unknown }>;
+}
+
+function setup(): CapturedTool {
+  let tool: CapturedTool | undefined;
+  const pi = {
+    registerTool: (config: CapturedTool) => {
+      tool = config;
+    },
+  } as unknown as Parameters<typeof registerSubmitInitiativeTool>[0];
+  registerSubmitInitiativeTool(pi, runPlanIO);
+  return tool!;
+}
+
+const originalCwd = process.cwd();
+let dir: string;
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'plan-mode-submit-init-'));
+  chdir(dir);
+});
+afterEach(async () => {
+  chdir(originalCwd);
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('submit_initiative tool', () => {
+  test('creates a registry entry + INITIATIVE.md and kebab-cases the name', async () => {
+    const tool = setup();
+    const result = await tool.execute('c', {
+      name: 'Auth Overhaul',
+      title: 'Auth Overhaul',
+      overview: '# Overview\n\nBreak auth into plans.',
+    });
+
+    const [entry] = await runPlanIO(readInitiativesManifest());
+    expect(entry.name).toBe('auth-overhaul');
+    expect(entry.status).toBe('in-progress');
+
+    const md = await readFile(join(dir, '.plans/auth-overhaul/INITIATIVE.md'), 'utf-8');
+    expect(md).toMatch(/Break auth into plans/);
+    expect(result.content?.[0]?.text).toMatch(/initiative: "auth-overhaul"/);
+  });
+});