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

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

@@ -1,57 +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 {
-  loadHandoff,
-  readAndClearExecPending,
-  saveHandoff,
-  writeExecPending,
-} from '../storage/plan-storage.js';
-import type { ExecPendingConfig } from '../types.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;
-const config: ExecPendingConfig = { model: { provider: 'anthropic', id: 'opus' }, thinking: 'low' };
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-plan-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('handoff documents', () => {
-  test('round trips handoff content', async () => {
-    await run(saveHandoff('.plans/p', '# Handoff'));
-    await expect(run(loadHandoff('.plans/p'))).resolves.toBe('# Handoff');
-  });
-
-  test('missing handoff returns undefined', async () => {
-    await expect(run(loadHandoff('.plans/missing'))).resolves.toBeUndefined();
-  });
-});
-
-describe('exec-pending markers', () => {
-  test('writes, reads, and clears a marker', async () => {
-    await run(writeExecPending('.plans/p', config));
-    const first = await run(readAndClearExecPending());
-    expect(first?.planDir).toBe('.plans/p');
-    expect(first?.config).toEqual(config);
-
-    // Marker is cleared after reading.
-    await expect(run(readAndClearExecPending())).resolves.toBeUndefined();
-  });
-
-  test('returns undefined when .plans does not exist', async () => {
-    await expect(run(readAndClearExecPending())).resolves.toBeUndefined();
-  });
-});

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

@@ -1,120 +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 {
-  readPlansManifest,
-  reconcilePlanStatus,
-  upsertPlanEntry,
-  writePlansManifest,
-} from '../storage/plans-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-manifest-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('plans.jsonl manifest', () => {
-  test('round trips entries', async () => {
-    const entry = {
-      _type: 'plan' as const,
-      name: 'refactor',
-      status: 'in-progress' as const,
-      title: 'Refactor',
-      created_at: 'now',
-      completed_at: null,
-    };
-    await run(writePlansManifest([entry]));
-    await expect(run(readPlansManifest())).resolves.toEqual([entry]);
-  });
-
-  test('missing manifest returns an empty list', async () => {
-    await expect(run(readPlansManifest())).resolves.toEqual([]);
-  });
-
-  test('upserts new entries', async () => {
-    await run(upsertPlanEntry('new-plan', { status: 'in-progress', title: 'New Plan' }));
-    const entries = await run(readPlansManifest());
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.name).toBe('new-plan');
-    expect(entries[0]?.title).toBe('New Plan');
-  });
-
-  test('upserts existing entries without changing created_at', async () => {
-    await run(
-      writePlansManifest([
-        {
-          _type: 'plan',
-          name: 'p',
-          status: 'in-progress',
-          title: 'Old',
-          created_at: 'created',
-          completed_at: null,
-        },
-      ]),
-    );
-    await run(upsertPlanEntry('p', { status: 'done', title: 'New' }));
-    const [entry] = await run(readPlansManifest());
-    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(upsertPlanEntry('p', { status: 'in-progress', title: 'P' }));
-    await run(upsertPlanEntry('p', { status: 'superseded', reason: 'absorbed by q' }));
-    let [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('superseded');
-    expect(entry.reason).toBe('absorbed by q');
-    expect(entry.completed_at).toBeString();
-
-    // Reopening clears completed_at.
-    await run(upsertPlanEntry('p', { status: 'in-progress' }));
-    [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-});
-
-describe('reconcilePlanStatus (registry as a projection of task state)', () => {
-  test('flips in-progress → done when finalizable', async () => {
-    await run(upsertPlanEntry('p', { status: 'in-progress', title: 'P' }));
-    await run(reconcilePlanStatus('p', true, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('done');
-  });
-
-  test('reopens done → in-progress when no longer finalizable', async () => {
-    await run(upsertPlanEntry('p', { status: 'done', title: 'P' }));
-    await run(reconcilePlanStatus('p', false, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('in-progress');
-    expect(entry.completed_at).toBeNull();
-  });
-
-  test('never overrides a manually-closed terminal status', async () => {
-    await run(upsertPlanEntry('p', { status: 'abandoned', title: 'P', reason: 'rejected' }));
-    await run(reconcilePlanStatus('p', true, 'P'));
-    const [entry] = await run(readPlansManifest());
-    expect(entry.status).toBe('abandoned');
-    expect(entry.reason).toBe('rejected');
-  });
-
-  test('is a no-op for an unknown plan (nothing created)', async () => {
-    await run(reconcilePlanStatus('ghost', true));
-    await expect(run(readPlansManifest())).resolves.toEqual([]);
-  });
-});

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

@@ -1,188 +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 { writeTasksJsonl } from '../storage/task-storage.js';
-import {
-  readPlansManifest,
-  upsertPlanEntry,
-  writePlansManifest,
-} from '../storage/plans-manifest.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();
-const now = '2026-05-27T12:00:00.000Z';
-
-const meta = (name: string): TaskMeta => ({
-  _type: 'meta',
-  title: `Title ${name}`,
-  plan_name: name,
-  created_at: now,
-});
-const task = (id: string, status: TaskStatus = 'pending'): TaskRecord => ({
-  _type: 'task',
-  id,
-  description: `task ${id}`,
-  status,
-  origin: 'plan',
-  created_at: now,
-  updated_at: now,
-});
-
-const originalCwd = process.cwd();
-let dir: string;
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-reconcile-'));
-  chdir(dir);
-});
-afterEach(async () => {
-  chdir(originalCwd);
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('collectPlanDrift', () => {
-  test('flags a fully-done plan still registered in-progress as status drift', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/alpha', meta('alpha'), [task('t-001', 'done')]));
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Title alpha' }));
-
-    const rows = await runPlanIO(collectPlanDrift());
-    const alpha = rows.find((r) => r.name === 'alpha')!;
-    expect(alpha.drift).toBe('status');
-    expect(alpha.derivedStatus).toBe('done');
-    expect(alpha.resolved).toBe(1);
-    expect(alpha.total).toBe(1);
-  });
-
-  test('reports an in-sync plan with no drift', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/beta', meta('beta'), [task('t-001', 'pending')]));
-    await runPlanIO(upsertPlanEntry('beta', { status: 'in-progress', title: 'Title beta' }));
-
-    const rows = await runPlanIO(collectPlanDrift());
-    expect(rows.find((r) => r.name === 'beta')!.drift).toBeUndefined();
-  });
-
-  test('flags registry-only plans (no tasks.jsonl)', async () => {
-    await runPlanIO(upsertPlanEntry('ghost', { status: 'in-progress', title: 'Ghost' }));
-    const rows = await runPlanIO(collectPlanDrift());
-    const ghost = rows.find((r) => r.name === 'ghost')!;
-    expect(ghost.drift).toBe('registry-only');
-    expect(ghost.hasTasks).toBe(false);
-  });
-
-  test('flags orphan task dirs (tasks.jsonl, no registry entry)', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/orphan', meta('orphan'), [task('t-001', 'done')]));
-    const rows = await runPlanIO(collectPlanDrift());
-    const orphan = rows.find((r) => r.name === 'orphan')!;
-    expect(orphan.drift).toBe('orphan');
-  });
-
-  test('never flags a manually-closed terminal status as drift', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/sup', meta('sup'), [task('t-001', 'pending')]));
-    await runPlanIO(
-      writePlansManifest([
-        {
-          _type: 'plan',
-          name: 'sup',
-          status: 'superseded',
-          title: 'Title sup',
-          created_at: now,
-          completed_at: now,
-          reason: 'absorbed',
-        },
-      ]),
-    );
-    const rows = await runPlanIO(collectPlanDrift());
-    expect(rows.find((r) => r.name === 'sup')!.drift).toBeUndefined();
-  });
-});
-
-describe('applyReconcile', () => {
-  test('repairs only status drift and projects derived status into the registry', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/alpha', meta('alpha'), [task('t-001', 'done')]));
-    await runPlanIO(upsertPlanEntry('alpha', { status: 'in-progress', title: 'Title alpha' }));
-
-    const rows = await runPlanIO(collectPlanDrift());
-    const repaired = await runPlanIO(applyReconcile(rows));
-    expect(repaired.map((r) => r.name)).toEqual(['alpha']);
-
-    const [entry] = await runPlanIO(readPlansManifest());
-    expect(entry.status).toBe('done');
-  });
-
-  test('classifies an upgrade (in-progress registry, done tasks) as direction:upgrade', async () => {
-    await runPlanIO(writeTasksJsonl('.plans/up', meta('up'), [task('t-001', 'done')]));
-    await runPlanIO(upsertPlanEntry('up', { status: 'in-progress', title: 'Up' }));
-    const rows = await runPlanIO(collectPlanDrift());
-    expect(rows.find((r) => r.name === 'up')!.direction).toBe('upgrade');
-  });
-
-  test('a done plan with incomplete tasks is flagged downgrade and NOT auto-repaired', async () => {
-    // Work merged but tasks never marked done: registry done, tasks in-progress.
-    await runPlanIO(
-      writeTasksJsonl('.plans/merged', meta('merged'), [task('t-001', 'pending')]),
-    );
-    await runPlanIO(
-      writePlansManifest([
-        {
-          _type: 'plan',
-          name: 'merged',
-          status: 'done',
-          title: 'Merged',
-          created_at: now,
-          completed_at: now,
-        },
-      ]),
-    );
-
-    const rows = await runPlanIO(collectPlanDrift());
-    const merged = rows.find((r) => r.name === 'merged')!;
-    expect(merged.drift).toBe('status');
-    expect(merged.direction).toBe('downgrade');
-
-    // --apply must NOT regress it back to in-progress.
-    const repaired = await runPlanIO(applyReconcile(rows));
-    expect(repaired.map((r) => r.name)).not.toContain('merged');
-    const [entry] = await runPlanIO(readPlansManifest());
-    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__/schema.test.ts

@@ -1,319 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { Either } from 'effect';
-import {
-  decodeExecPendingConfig,
-  decodeInitiativeManifestEntry,
-  decodePlanManifestEntry,
-  decodeTaskMeta,
-  decodeTaskRecord,
-  decodeTasksLine,
-} from '../schema.js';
-
-const now = '2026-05-27T12:00:00.000Z';
-
-const isOk = (value: unknown, decode: (v: unknown) => Either.Either<unknown, unknown>): boolean =>
-  Either.isRight(decode(value));
-
-describe('task record schema', () => {
-  test('accepts a full task record', () => {
-    expect(
-      isOk(
-        {
-          _type: 'task',
-          id: 't-001',
-          description: 'Do work',
-          details: 'Full instructions',
-          status: 'pending',
-          depends_on: ['t-000'],
-          notes: 'note',
-          created_at: now,
-          updated_at: now,
-        },
-        decodeTaskRecord,
-      ),
-    ).toBe(true);
-  });
-
-  test('accepts a lightweight task record without details', () => {
-    expect(
-      isOk(
-        {
-          _type: 'task',
-          id: 't-001',
-          description: 'Do work',
-          status: 'pending',
-          created_at: now,
-          updated_at: now,
-        },
-        decodeTaskRecord,
-      ),
-    ).toBe(true);
-  });
-
-  test('accepts a deferred discovered task', () => {
-    expect(
-      isOk(
-        {
-          _type: 'task',
-          id: 't-011',
-          description: 'Follow-up discovered mid-run',
-          status: 'deferred',
-          origin: 'discovered',
-          notes: 'noticed while implementing',
-          created_at: now,
-          updated_at: now,
-        },
-        decodeTaskRecord,
-      ),
-    ).toBe(true);
-  });
-
-  test('rejects an unknown origin', () => {
-    expect(
-      isOk(
-        {
-          _type: 'task',
-          id: 't-001',
-          description: 'Do work',
-          status: 'pending',
-          origin: 'bogus',
-          created_at: now,
-          updated_at: now,
-        },
-        decodeTaskRecord,
-      ),
-    ).toBe(false);
-  });
-
-  test('rejects missing fields and unknown status', () => {
-    expect(isOk({ _type: 'task', id: 't-001', status: 'pending' }, decodeTaskRecord)).toBe(false);
-    expect(
-      isOk(
-        {
-          _type: 'task',
-          id: 't-001',
-          description: 'Do work',
-          status: 'unknown',
-          created_at: now,
-          updated_at: now,
-        },
-        decodeTaskRecord,
-      ),
-    ).toBe(false);
-  });
-});
-
-describe('task meta schema', () => {
-  test('accepts a valid meta record', () => {
-    expect(
-      isOk(
-        { _type: 'meta', title: 'Refactor', plan_name: 'refactor', created_at: now },
-        decodeTaskMeta,
-      ),
-    ).toBe(true);
-  });
-
-  test('rejects malformed meta records', () => {
-    expect(isOk({ _type: 'meta', title: 'Refactor' }, decodeTaskMeta)).toBe(false);
-    expect(
-      isOk(
-        { _type: 'task', title: 'Refactor', plan_name: 'refactor', created_at: now },
-        decodeTaskMeta,
-      ),
-    ).toBe(false);
-  });
-});
-
-describe('tasks.jsonl line schema (meta | task union)', () => {
-  test('discriminates meta from task', () => {
-    const meta = decodeTasksLine({ _type: 'meta', title: 'T', plan_name: 'p', created_at: now });
-    const task = decodeTasksLine({
-      _type: 'task',
-      id: 't-001',
-      description: 'Do work',
-      status: 'pending',
-      created_at: now,
-      updated_at: now,
-    });
-    expect(Either.isRight(meta) && Either.getOrThrow(meta)._type).toBe('meta');
-    expect(Either.isRight(task) && Either.getOrThrow(task)._type).toBe('task');
-  });
-
-  test('round-trips a deferred discovered task', () => {
-    const decoded = decodeTasksLine({
-      _type: 'task',
-      id: 't-011',
-      description: 'Follow-up',
-      status: 'deferred',
-      origin: 'discovered',
-      created_at: now,
-      updated_at: now,
-    });
-    expect(Either.isRight(decoded)).toBe(true);
-    if (Either.isRight(decoded) && decoded.right._type === 'task') {
-      expect(decoded.right.status).toBe('deferred');
-      expect(decoded.right.origin).toBe('discovered');
-    }
-  });
-
-  test('rejects records with an unknown _type', () => {
-    expect(isOk({ _type: 'bogus' }, decodeTasksLine)).toBe(false);
-  });
-});
-
-describe('plan manifest entry schema', () => {
-  test('accepts a valid entry with null completed_at', () => {
-    expect(
-      isOk(
-        {
-          _type: 'plan',
-          name: 'plan',
-          status: 'in-progress',
-          title: 'Plan',
-          created_at: now,
-          completed_at: null,
-        },
-        decodePlanManifestEntry,
-      ),
-    ).toBe(true);
-  });
-
-  test('accepts terminal statuses (superseded / abandoned) with a reason', () => {
-    for (const status of ['done', 'superseded', 'abandoned'] as const) {
-      expect(
-        isOk(
-          {
-            _type: 'plan',
-            name: 'plan',
-            status,
-            title: 'Plan',
-            created_at: now,
-            completed_at: now,
-            reason: 'another plan shipped it',
-          },
-          decodePlanManifestEntry,
-        ),
-      ).toBe(true);
-    }
-  });
-
-  test('rejects an invalid status', () => {
-    expect(
-      isOk(
-        {
-          _type: 'plan',
-          name: 'plan',
-          status: 'paused',
-          title: 'Plan',
-          created_at: now,
-          completed_at: null,
-        },
-        decodePlanManifestEntry,
-      ),
-    ).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', () => {
-  test('accepts a valid config', () => {
-    expect(
-      isOk(
-        { model: { provider: 'anthropic', id: 'opus' }, thinking: 'low' },
-        decodeExecPendingConfig,
-      ),
-    ).toBe(true);
-  });
-
-  test('rejects a config missing the model id', () => {
-    expect(
-      isOk({ model: { provider: 'anthropic' }, thinking: 'low' }, decodeExecPendingConfig),
-    ).toBe(false);
-  });
-});