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

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,334 +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('accepts a meta record with base_commit', () => {
-    expect(
-      isOk(
-        { _type: 'meta', title: 'Refactor', plan_name: 'refactor', created_at: now, base_commit: 'abc123' },
-        decodeTaskMeta,
-      ),
-    ).toBe(true);
-  });
-
-  test('accepts a meta record without base_commit (back-compat)', () => {
-    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);
-  });
-});

package/extensions/plan-mode/__tests__/task-status.test.ts

@@ -1,74 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  activeTasksResolved,
-  deferredTasks,
-  isPlanFinalizable,
-  reactivateForExecution,
-} from '../task-status.js';
-import type { TaskRecord, TaskStatus } from '../types.js';
-
-const now = '2026-05-27T12:00:00.000Z';
-let counter = 0;
-const make = (status: TaskStatus, origin?: 'plan' | 'discovered'): TaskRecord => ({
-  _type: 'task',
-  id: `t-${String(++counter).padStart(3, '0')}`,
-  description: 'task',
-  status,
-  origin,
-  created_at: now,
-  updated_at: now,
-});
-
-describe('deferredTasks', () => {
-  test('returns only deferred tasks', () => {
-    const tasks = [make('done'), make('deferred', 'discovered'), make('pending')];
-    expect(deferredTasks(tasks).map((t) => t.status)).toEqual(['deferred']);
-  });
-});
-
-describe('activeTasksResolved', () => {
-  test('true when only done/skipped/deferred remain', () => {
-    expect(
-      activeTasksResolved([make('done'), make('skipped'), make('deferred', 'discovered')]),
-    ).toBe(true);
-  });
-
-  test('false when a task is still pending', () => {
-    expect(activeTasksResolved([make('done'), make('pending')])).toBe(false);
-  });
-
-  test('false when a task is still blocked', () => {
-    expect(activeTasksResolved([make('done'), make('blocked')])).toBe(false);
-  });
-});
-
-describe('isPlanFinalizable', () => {
-  test('true when all work is done/skipped and nothing is deferred', () => {
-    expect(isPlanFinalizable([make('done'), make('skipped')])).toBe(true);
-  });
-
-  test('false when a deferred follow-up awaits the user', () => {
-    expect(isPlanFinalizable([make('done'), make('deferred', 'discovered')])).toBe(false);
-  });
-
-  test('false when active work remains', () => {
-    expect(isPlanFinalizable([make('pending')])).toBe(false);
-  });
-});
-
-describe('reactivateForExecution', () => {
-  test('flips blocked and deferred tasks to pending and stamps updated_at', () => {
-    const tasks = [make('done'), make('blocked'), make('deferred', 'discovered')];
-    const ts = '2026-06-01T00:00:00.000Z';
-    const changed = reactivateForExecution(tasks, ts);
-    expect(changed).toBe(true);
-    expect(tasks.map((t) => t.status)).toEqual(['done', 'pending', 'pending']);
-    expect(tasks[1].updated_at).toBe(ts);
-    expect(tasks[2].updated_at).toBe(ts);
-  });
-
-  test('returns false and leaves tasks untouched when nothing to reactivate', () => {
-    const tasks = [make('done'), make('pending')];
-    expect(reactivateForExecution(tasks, '2026-06-01T00:00:00.000Z')).toBe(false);
-  });
-});

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

@@ -1,101 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { Cause, Effect, Exit, Option } from 'effect';
-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 { readTasksJsonl, updateTask, writeTasksJsonl } from '../storage/task-storage.js';
-import type { TaskMeta, TaskRecord } from '../types.js';
-
-const run = <A, E>(program: Effect.Effect<A, E, FileSystem>): Promise<A> =>
-  Effect.runPromise(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const runExit = <A, E>(program: Effect.Effect<A, E, FileSystem>) =>
-  Effect.runPromiseExit(program.pipe(Effect.provideService(FileSystem, nodeFileSystemService)));
-
-const failureTag = <A, E>(exit: Exit.Exit<A, E>): string | undefined => {
-  if (!Exit.isFailure(exit)) return undefined;
-  const error = Option.getOrUndefined(Cause.failureOption(exit.cause)) as
-    | { _tag?: string }
-    | undefined;
-  return error?._tag;
-};
-
-let dir: string;
-const now = '2026-05-27T12:00:00.000Z';
-const meta: TaskMeta = { _type: 'meta', title: 'Plan', plan_name: 'plan', created_at: now };
-const task: TaskRecord = {
-  _type: 'task',
-  id: 't-001',
-  description: 'Do work',
-  details: 'Details',
-  status: 'pending',
-  created_at: now,
-  updated_at: now,
-};
-
-beforeEach(async () => {
-  dir = await mkdtemp(join(tmpdir(), 'plan-mode-tasks-'));
-});
-afterEach(async () => {
-  await rm(dir, { recursive: true, force: true });
-});
-
-describe('tasks.jsonl storage', () => {
-  test('round trips meta and tasks', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    await expect(run(readTasksJsonl(dir))).resolves.toEqual({ meta, tasks: [task] });
-  });
-
-  test('round trips base_commit on the meta record', async () => {
-    const metaWithCommit: TaskMeta = { ...meta, base_commit: 'deadbeefcafe' };
-    await run(writeTasksJsonl(dir, metaWithCommit, [task]));
-    const result = await run(readTasksJsonl(dir));
-    expect(result?.meta.base_commit).toBe('deadbeefcafe');
-  });
-
-  test('round trips tasks without details (lightweight checklist)', async () => {
-    const lightweight: TaskRecord = {
-      _type: 'task',
-      id: 't-002',
-      description: 'Quick fix',
-      status: 'pending',
-      created_at: now,
-      updated_at: now,
-    };
-    await run(writeTasksJsonl(dir, meta, [lightweight]));
-    const result = await run(readTasksJsonl(dir));
-    expect(result?.tasks[0]?.id).toBe('t-002');
-    expect(result?.tasks[0]?.details).toBeUndefined();
-  });
-
-  test('missing file returns undefined', async () => {
-    await expect(run(readTasksJsonl(dir))).resolves.toBeUndefined();
-  });
-
-  test('rejects corrupt lines with JsonlParseError', async () => {
-    await Bun.write(join(dir, 'tasks.jsonl'), `${JSON.stringify(meta)}\nnot-json\n`);
-    expect(failureTag(await runExit(readTasksJsonl(dir)))).toBe('JsonlParseError');
-  });
-
-  test('rejects empty files with MissingMetaRecord', async () => {
-    await Bun.write(join(dir, 'tasks.jsonl'), '');
-    expect(failureTag(await runExit(readTasksJsonl(dir)))).toBe('MissingMetaRecord');
-  });
-
-  test('updates a task by id and rewrites the snapshot', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    const updated = await run(updateTask(dir, 't-001', { status: 'done', notes: 'finished' }));
-
-    expect(updated.status).toBe('done');
-    expect(updated.notes).toBe('finished');
-    expect((await run(readTasksJsonl(dir)))?.tasks[0]?.status).toBe('done');
-  });
-
-  test('fails with TaskNotFound for an unknown task id', async () => {
-    await run(writeTasksJsonl(dir, meta, [task]));
-    expect(failureTag(await runExit(updateTask(dir, 't-999', { status: 'done' })))).toBe(
-      'TaskNotFound',
-    );
-  });
-});