@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tests/db-engine-logs.test.ts

@@ -0,0 +1,207 @@
+// gsd-pi — DB engine failure-branch log coverage.
+//
+// `checkpointDatabase` / `closeDatabase` / `vacuumDatabase` in db/engine.ts are
+// the highest-frequency runtime paths (called every turn and at closeout).
+// Each wraps its destructive PRAGMA in a try/catch that emits a `db` warning so
+// a failed checkpoint/vacuum/close never breaks orchestration but is still
+// observable. The existing gsd-db tests only assert the *happy* path (WAL gets
+// truncated); no test exercises any of these catch branches, so a regression
+// that drops or misroutes the warning would pass silently.
+//
+// This file pins the log output for the three checkpoint/vacuum/close failure
+// branches by stubbing the live adapter's `exec`/`close` to throw on demand.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { chmodSync as fsChmodSync, mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkpointDatabase, closeDatabase, openDatabase, vacuumDatabase, _getAdapter } from "../gsd-db.ts";
+import { backupDatabaseSnapshot, readTransaction } from "../db/engine.ts";
+import {
+  drainLogs,
+  peekLogs,
+  setStderrLoggingEnabled,
+  _resetLogs,
+  type LogEntry,
+} from "../workflow-logger.ts";
+import type { DbAdapter } from "../db-adapter.ts";
+
+function makeBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-db-engine-logs-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+/** Capture log entries emitted while running fn. Stderr is suppressed. */
+function captureLogs<T>(fn: () => T): { result: T; logs: LogEntry[] } {
+  const previous = setStderrLoggingEnabled(false);
+  _resetLogs();
+  try {
+    const result = fn();
+    return { result, logs: drainLogs() };
+  } finally {
+    _resetLogs();
+    setStderrLoggingEnabled(previous);
+  }
+}
+
+/**
+ * Wrap the live adapter's `exec` so it throws for SQL matching `needle`,
+ * delegating everything else to the original. Returns a restore function.
+ */
+function breakExecOn(adapter: DbAdapter, needle: string): () => void {
+  const origExec = adapter.exec.bind(adapter);
+  adapter.exec = (sql: string): void => {
+    if (sql.includes(needle)) throw new Error(`forced failure for: ${needle}`);
+    return origExec(sql);
+  };
+  return () => {
+    adapter.exec = origExec;
+  };
+}
+
+test("checkpointDatabase logs a `db` warning when the WAL checkpoint throws", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  try {
+    const adapter = _getAdapter();
+    assert.ok(adapter, "an adapter must be open");
+    const restore = breakExecOn(adapter!, "wal_checkpoint");
+
+    const { logs } = captureLogs(() => checkpointDatabase());
+    restore();
+
+    const dbWarn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(dbWarn, "a db warning must be logged on checkpoint failure");
+    assert.match(dbWarn!.message, /WAL checkpoint failed/u);
+    assert.match(dbWarn!.message, /forced failure for: wal_checkpoint/u);
+    // checkpointDatabase must not rethrow — orchestration continues.
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("vacuumDatabase logs a `db` warning when VACUUM throws", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  try {
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    const restore = breakExecOn(adapter!, "VACUUM");
+
+    const { logs } = captureLogs(() => vacuumDatabase());
+    restore();
+
+    const dbWarn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(dbWarn, "a db warning must be logged on VACUUM failure");
+    assert.match(dbWarn!.message, /VACUUM failed/u);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("closeDatabase logs `db` warnings when WAL checkpoint and close throw on teardown", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  // Break both the WAL checkpoint and the final close. The incremental_vacuum
+  // pragma is left intact so we can assert the checkpoint/close warnings land
+  // without the teardown itself exploding mid-way.
+  const restoreExec = breakExecOn(adapter!, "wal_checkpoint");
+  const origClose = adapter!.close.bind(adapter!);
+  adapter!.close = (): void => {
+    throw new Error("forced close failure");
+  };
+
+  const { logs } = captureLogs(() => closeDatabase());
+  restoreExec();
+  adapter!.close = origClose;
+
+  try {
+    const messages = logs.filter((e) => e.component === "db").map((e) => e.message);
+    assert.ok(
+      messages.some((m) => /WAL checkpoint failed/u.test(m)),
+      "WAL checkpoint failure must be logged during close",
+    );
+    assert.ok(
+      messages.some((m) => /database close failed/u.test(m)),
+      "close failure must be logged during close",
+    );
+    // closeDatabase must fully reset engine state even when teardown steps throw.
+    assert.equal(_getAdapter(), null, "engine must release the adapter after a broken close");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("checkpointDatabase and vacuumDatabase are no-ops (and log nothing) when no DB is open", () => {
+  _resetLogs();
+  const previous = setStderrLoggingEnabled(false);
+  try {
+    checkpointDatabase();
+    vacuumDatabase();
+    assert.equal(peekLogs().length, 0, "no-db paths must not emit any logs");
+  } finally {
+    setStderrLoggingEnabled(previous);
+    _resetLogs();
+  }
+});
+
+test("readTransaction logs a db error when ROLLBACK fails after a read error (split-brain signal)", () => {
+  const base = makeBase();
+  assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+  const adapter = _getAdapter();
+  assert.ok(adapter);
+  // Make ROLLBACK throw so the read-failure path invokes the rollback-error
+  // callback (engine.ts:768-775), which logs the split-brain error.
+  const restore = breakExecOn(adapter!, "ROLLBACK");
+
+  const { logs } = captureLogs(() => {
+    assert.throws(
+      () => readTransaction(() => {
+        throw new Error("read body failed");
+      }),
+      /read body failed/u,
+      "the original read error must still propagate",
+    );
+  });
+  restore();
+  closeDatabase();
+  try {
+    const err = logs.find((e) => e.component === "db" && e.severity === "error");
+    assert.ok(err, "a db error must be logged when ROLLBACK fails");
+    assert.equal(err!.message, "snapshotState ROLLBACK failed");
+    assert.match(err!.context?.error ?? "", /forced failure for: ROLLBACK/u);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("backupDatabaseSnapshot logs a db warning when the snapshot copy fails", () => {
+  const base = makeBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  assert.equal(openDatabase(dbPath), true);
+  // Make the snapshot destination's parent dir read-only so the copy step
+  // inside backupDatabaseSnapshot (mkdirSync(backups) + copyFileSync) fails —
+  // exercising the outer catch (engine.ts:726-728). The DB handle stays open,
+  // so currentPath is set and the read-only parent only blocks the new copy.
+  fsChmodSync(join(base, ".gsd"), 0o555);
+
+  const { result, logs } = captureLogs(() => backupDatabaseSnapshot("test-label"));
+  closeDatabase();
+  try {
+    assert.equal(result, null, "a failed snapshot must return null");
+    const warn = logs.find((e) => e.component === "db" && e.severity === "warn");
+    assert.ok(warn, "a db warning must be logged on snapshot failure");
+    assert.match(warn!.message, /database snapshot failed/u);
+  } finally {
+    fsChmodSync(join(base, ".gsd"), 0o755);
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/db-migration-backup.test.ts

@@ -3,16 +3,22 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { backupDatabaseBeforeMigration } from "../db-migration-backup.ts";
+import { MigrationBackupError, backupDatabaseBeforeMigration } from "../db-migration-backup.ts";
 import type { DbAdapter, DbStatement } from "../db-adapter.ts";
 
 class FakeStatement implements DbStatement {
+  private readonly row: Record<string, unknown> | undefined;
+
+  constructor(row: Record<string, unknown> | undefined = undefined) {
+    this.row = row;
+  }
+
   run(): unknown {
     return undefined;
   }
 
   get(): Record<string, unknown> | undefined {
-    return undefined;
+    return this.row;
   }
 
   all(): Record<string, unknown>[] {
@@ -22,15 +28,19 @@ class FakeStatement implements DbStatement {
 
 class FakeAdapter implements DbAdapter {
   readonly execCalls: string[] = [];
+  readonly prepareCalls: string[] = [];
   failCheckpoint = false;
+  checkpointRow: Record<string, unknown> = { busy: 0, log: 0, checkpointed: 0 };
 
   exec(sql: string): void {
     this.execCalls.push(sql);
     if (this.failCheckpoint) throw new Error("checkpoint failed");
   }
 
-  prepare(): DbStatement {
-    return new FakeStatement();
+  prepare(sql: string): DbStatement {
+    this.prepareCalls.push(sql);
+    if (this.failCheckpoint) throw new Error("checkpoint failed");
+    return new FakeStatement(this.checkpointRow);
   }
 
   close(): void {}
@@ -73,32 +83,71 @@ describe("db-migration-backup", () => {
       logWarning: () => assert.fail("should not warn"),
     });
 
-    assert.deepEqual(db.execCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
     assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
   });
 
-  test("continues copying when checkpoint fails and warns when copy fails", () => {
+  test("throws and skips copying when checkpoint fails", () => {
     const db = new FakeAdapter();
     db.failCheckpoint = true;
     const copies: Array<[string, string]> = [];
     const warnings: string[] = [];
 
-    backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
-      existsSync: (path) => path === "/tmp/gsd.db",
-      copyFileSync: (src, dest) => copies.push([src, dest]),
-      logWarning: (_scope, message) => warnings.push(message),
-    });
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+          existsSync: (path) => path === "/tmp/gsd.db",
+          copyFileSync: (src, dest) => copies.push([src, dest]),
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      /checkpoint failed/,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(copies, []);
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Pre-migration backup failed: checkpoint failed/);
+  });
 
-    assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
+  test("throws and skips copying when checkpoint result is incomplete", () => {
+    const db = new FakeAdapter();
+    db.checkpointRow = { busy: 1, log: 4, checkpointed: 3 };
+    const copies: Array<[string, string]> = [];
+    const warnings: string[] = [];
 
-    backupDatabaseBeforeMigration(db, "/tmp/fail.db", 13, {
-      existsSync: (path) => path === "/tmp/fail.db",
-      copyFileSync: () => {
-        throw new Error("read only");
-      },
-      logWarning: (_scope, message) => warnings.push(message),
-    });
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+          existsSync: (path) => path === "/tmp/gsd.db",
+          copyFileSync: (src, dest) => copies.push([src, dest]),
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      MigrationBackupError,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(copies, []);
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Pre-migration backup failed: WAL checkpoint incomplete/);
+  });
+
+  test("throws and warns when copy fails", () => {
+    const db = new FakeAdapter();
+    const warnings: string[] = [];
 
+    assert.throws(
+      () =>
+        backupDatabaseBeforeMigration(db, "/tmp/fail.db", 13, {
+          existsSync: (path) => path === "/tmp/fail.db",
+          copyFileSync: () => {
+            throw new Error("read only");
+          },
+          logWarning: (_scope, message) => warnings.push(message),
+        }),
+      /read only/,
+    );
+
+    assert.deepEqual(db.prepareCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
     assert.equal(warnings.length, 1);
     assert.match(warnings[0], /Pre-migration backup failed: read only/);
   });

package/src/resources/extensions/gsd/tests/db-transaction.test.ts

@@ -17,6 +17,10 @@ class FakeTransactionControls implements DbTransactionControls {
     this.record("BEGIN DEFERRED");
   }
 
+  beginImmediate(): void {
+    this.record("BEGIN IMMEDIATE");
+  }
+
   commit(): void {
     this.record("COMMIT");
   }
@@ -107,4 +111,59 @@ describe("db-transaction", () => {
     assert.equal(rollbackErrors.length, 1);
     assert.match(rollbackErrors[0].message, /failed ROLLBACK/);
   });
+
+  test("commits successful immediate transactions", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    const result = runner.immediateTransaction(controls, () => {
+      assert.equal(runner.isInTransaction(), true);
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "COMMIT"]);
+  });
+
+  test("rolls back failed immediate transactions and clears depth", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    assert.throws(
+      () => runner.immediateTransaction(controls, () => {
+        throw new Error("boom");
+      }),
+      /boom/,
+    );
+
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "ROLLBACK"]);
+  });
+
+  test("nested immediate transactions inside write transactions do not issue nested BEGIN", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    runner.transaction(controls, () => {
+      runner.immediateTransaction(controls, () => {
+        assert.equal(runner.isInTransaction(), true);
+      });
+    });
+
+    assert.deepEqual(controls.calls, ["BEGIN", "COMMIT"]);
+  });
+
+  test("nested write transactions inside immediate transactions do not issue nested BEGIN", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    runner.immediateTransaction(controls, () => {
+      runner.transaction(controls, () => {
+        assert.equal(runner.isInTransaction(), true);
+      });
+    });
+
+    assert.deepEqual(controls.calls, ["BEGIN IMMEDIATE", "COMMIT"]);
+  });
 });

package/src/resources/extensions/gsd/tests/db-writer.test.ts

@@ -920,9 +920,9 @@ describe('db-writer', () => {
       decision,
     });
 
-    test('detects deferral in scope with M###/S## pattern in choice', () => {
+    test('detects deferral in scope when the scope names the slice', () => {
       const result = extractDeferredSliceRef(
-        fields('deferral of low-priority work', 'Move M001/S03 to backlog', ''),
+        fields('deferral of slice M001/S03', 'Move low-priority work to backlog', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M001', sliceId: 'S03' });
     });
@@ -950,14 +950,14 @@ describe('db-writer', () => {
 
     test('recognises "deferring" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('deferring this slice', 'M005/S02 can wait', ''),
+        fields('slice prioritization', 'deferring M005/S02 until later', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M005', sliceId: 'S02' });
     });
 
     test('recognises "defers" variant', () => {
       const result = extractDeferredSliceRef(
-        fields('team defers slice', 'M100/S10 not urgent', ''),
+        fields('slice prioritization', 'team defers slice M100/S10', ''),
       );
       assert.deepStrictEqual(result, { milestoneId: 'M100', sliceId: 'S10' });
     });
@@ -969,6 +969,17 @@ describe('db-writer', () => {
       assert.deepStrictEqual(result, { milestoneId: 'M003', sliceId: 'S01' });
     });
 
+    test('does not treat a planning scope reference as a deferred slice', () => {
+      const result = extractDeferredSliceRef(
+        fields(
+          'planning',
+          'Plan S01 as the happy-path money loop only; Defer full duplicate/replay idempotency + polling reconciliation backstop (R006).',
+          'M003/S01 scope boundary for the BTC money loop (which requirements land in the first slice vs deferred follow-on slices).',
+        ),
+      );
+      assert.strictEqual(result, null);
+    });
+
     test('returns null when no deferral keyword is present', () => {
       const result = extractDeferredSliceRef(
         fields('approved work', 'M001/S01 is ready', 'proceed with M001/S01'),

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -6,7 +6,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
-import { runDispatch, runPreDispatch } from "../auto/phases.ts";
+import { runDispatch } from "../auto/dispatch.ts";
+import { runPreDispatch } from "../auto/pre-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";

package/src/resources/extensions/gsd/tests/derive-state-helpers.test.ts

@@ -21,6 +21,7 @@ import {
   insertSlice,
   insertTask,
   setMilestoneQueueOrder,
+  transaction,
   updateTaskStatus,
 } from '../gsd-db.ts';
 
@@ -473,6 +474,31 @@ describe('derive-state-helpers', () => {
     }
   });
 
+  test('setMilestoneQueueOrder can be composed inside a transaction', async () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-CONTEXT.md', '# M001\n\nContext.');
+      writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002\n\nContext.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'First', status: 'active' });
+      insertMilestone({ id: 'M002', title: 'Second', status: 'active' });
+
+      transaction(() => {
+        setMilestoneQueueOrder(['M002', 'M001']);
+      });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assert.equal(state.activeMilestone?.id, 'M002', 'queue-order: nested transaction chooses M002');
+      assert.deepEqual(state.registry.map(entry => entry.id), ['M002', 'M001']);
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   test('getActiveMilestoneId: DB lock path ignores PARKED flag projection', async () => {
     const base = createFixtureBase();
     const previousLock = process.env.GSD_MILESTONE_LOCK;
@@ -569,6 +595,42 @@ describe('derive-state-helpers', () => {
     }
   });
 
+  // ─── Batch slice query: multi-milestone slices loaded in one query ─────
+  test('buildRegistryAndFindActive: batched slice query preserves ordering across milestones', async () => {
+    const base = createFixtureBase();
+    try {
+      // M001 is complete so the loop advances past it.
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+      writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+      // M002 is a queued shell milestone with no context and no slices — should be deferred.
+      mkdirSync(join(base, '.gsd', 'milestones', 'M002'), { recursive: true });
+      // M003 is the real active milestone with slices in non-trivial sequence order.
+      writeFile(base, 'milestones/M003/M003-CONTEXT.md', '# M003: Real\n\nReal milestone.');
+
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Complete', status: 'complete' });
+      insertMilestone({ id: 'M002', title: 'Shell', status: 'queued' });
+      insertMilestone({ id: 'M003', title: 'Real', status: 'active' });
+      // Slices intentionally inserted with out-of-order sequences to prove ordering.
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'M1 Second', status: 'complete', risk: 'low', depends: [], sequence: 2 });
+      insertSlice({ id: 'S02', milestoneId: 'M001', title: 'M1 First', status: 'complete', risk: 'low', depends: [], sequence: 1 });
+      insertSlice({ id: 'S03', milestoneId: 'M003', title: 'M3 Second', status: 'active', risk: 'low', depends: [], sequence: 5 });
+      insertSlice({ id: 'S04', milestoneId: 'M003', title: 'M3 First', status: 'active', risk: 'low', depends: [], sequence: 3 });
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(base);
+
+      assert.equal(state.activeMilestone?.id, 'M003', 'batched: M003 is active after complete M001 and shell M002');
+      assert.equal(state.activeSlice?.id, 'S04', 'batched: first slice by sequence is active');
+      assert.equal(state.registry.find(e => e.id === 'M001')?.status, 'complete', 'batched: M001 complete');
+      assert.equal(state.registry.find(e => e.id === 'M002')?.status, 'pending', 'batched: shell M002 deferred to pending');
+      assert.equal(state.registry.find(e => e.id === 'M003')?.status, 'active', 'batched: M003 active');
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
   // ─── Deferred queued shell: shell milestone deferred, real one promoted ──
   test('buildRegistryAndFindActive: queued shell deferred, later real milestone becomes active (#3470)', async () => {
     const base = createFixtureBase();

package/src/resources/extensions/gsd/tests/discuss-routing-fixes.test.ts

@@ -39,7 +39,11 @@ function makeDiscussPi() {
     tmp,
     pi: {
       getActiveTools: () => ["gsd_summary_save", "bash"],
+      emitAdjustToolSet: async () => undefined,
+      emitBeforeModelSelect: async () => undefined,
+      setModel: async () => true,
       setActiveTools: () => {},
+      setThinkingLevel: () => {},
       sendMessage: (message: { content?: unknown }) => {
         sent.push(message);
       },
@@ -53,6 +57,7 @@ function makeDiscussPi() {
 }
 
 function makeDiscussCtx(notifications: Array<{ message: string; level?: string }> = []) {
+  const model = { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" };
   return {
     hasUI: true,
     sessionManager: {
@@ -65,8 +70,13 @@ function makeDiscussCtx(notifications: Array<{ message: string; level?: string }
       setStatus: () => {},
     },
     waitForIdle: async () => {},
-    model: undefined,
-    modelRegistry: { getProviderAuthMode: () => undefined },
+    model,
+    modelRegistry: {
+      getAvailable: () => [model],
+      getAll: () => [model],
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => true,
+    },
   };
 }