gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -0,0 +1,47 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the complete milestone prompt renders required completion and verification guardrails.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("complete milestone prompt renders compact verification and completion guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-complete-milestone-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("complete-milestone", {
+    workingDirectory: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
+    milestoneId: "M001",
+    milestoneTitle: "Baseline And Safety",
+    roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+    milestoneSummaryPath: ".gsd/milestones/M001/M001-SUMMARY.md",
+    inlinedContext: "## Milestone Summary\n\n## Horizontal Checklist\n\n## Decision Re-evaluation",
+    extractLearningsSteps: "Write M001-LEARNINGS.md and call capture_thought.",
+  });
+
+  assert.match(prompt, /Complete Milestone M001/);
+  assert.match(prompt, /Verification Gate/);
+  assert.match(prompt, /Do NOT call `gsd_complete_milestone`/);
+  assert.match(prompt, /verification FAILED/);
+  assert.match(prompt, /gsd_requirement_update/);
+  assert.match(prompt, /gsd_complete_milestone/);
+  assert.match(prompt, /verificationPassed/);
+  assert.match(prompt, /gsd_milestone_status/);
+  assert.match(prompt, /Do NOT query.*\.gsd\/gsd\.db/i);
+  assert.match(prompt, /Horizontal Checklist/);
+  assert.match(prompt, /Decision Re-evaluation/);
+  assert.match(prompt, /self-diff/i);
+  assert.match(prompt, /GSD-(?:Task|Unit)/);
+  assert.match(prompt, /Milestone M001 complete/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tests
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
@@ -432,10 +433,9 @@ describe("complete-milestone", () => {
     }
   });
 
-  test("handleCompleteMilestone does not overwrite existing SUMMARY.md on re-dispatch (#4598)", async () => {
+  test("handleCompleteMilestone treats already-complete milestone as idempotent re-dispatch (#4598)", async () => {
     // This test verifies that when SUMMARY.md already exists (from a prior completion),
     // re-calling handleCompleteMilestone does not overwrite it.
-    // Before the fix this test FAILS because the handler unconditionally writes SUMMARY.md.
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();
     const mid = "M001";
@@ -443,7 +443,7 @@ describe("complete-milestone", () => {
     try {
       // Set up DB with milestone and a complete slice + task
       openDatabase(dbPath);
-      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertMilestone({ id: mid, title: "Test Milestone", status: "complete" });
       insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
 
@@ -472,15 +472,29 @@ describe("complete-milestone", () => {
       };
 
       const result = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in result), `already-complete re-dispatch should succeed: ${JSON.stringify(result)}`);
+      assert.equal(result.alreadyComplete, true);
 
-      // The call may return an error (milestone already complete) or success
-      // but in either case the SUMMARY.md must NOT be overwritten.
       const actualContent = readFileSync(summaryPath, "utf-8");
       assert.strictEqual(
         actualContent,
         originalContent,
         "existing SUMMARY.md must not be overwritten on re-dispatch (#4598)",
       );
+
+      // Repeated re-dispatch should also be idempotent.
+      const repeatResult = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in repeatResult), "repeated re-dispatch should also succeed");
+      assert.strictEqual(repeatResult.alreadyComplete, true, "repeated re-dispatch is identified as already-complete");
+      assert.ok(
+        repeatResult.summaryPath.endsWith(join(".gsd", "milestones", mid, `${mid}-SUMMARY.md`)),
+        "repeated re-dispatch returns the existing summary path",
+      );
+      assert.strictEqual(
+        readFileSync(summaryPath, "utf-8"),
+        originalContent,
+        "repeated re-dispatch must not overwrite SUMMARY.md",
+      );
     } finally {
       try { closeDatabase(); } catch { /* */ }
       clearPathCache();

package/src/resources/extensions/gsd/tests/component-loader.test.ts

@@ -1,12 +1,5 @@
-/**
- * Component Loader — Unit Tests
- *
- * Tests for multi-format component loading:
- * - New format (component.yaml)
- * - Legacy skill format (SKILL.md with frontmatter)
- * - Legacy agent format (.md with frontmatter)
- * - Directory scanning
- */
+// Project/App: GSD-2
+// File Purpose: Verifies component loading across modern and legacy formats.
 
 import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -372,6 +372,150 @@ describe("Custom engine loop integration", () => {
     assert.ok(stopEntry?.includes("Workflow complete"), "Should stop with 'Workflow complete'");
   });
 
+  it("finalizes custom-engine complete turns and clears current turn state", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a", status: "complete" }),
+    ], "already-done");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "already-done");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+    });
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          deps.callLog.push(`turnResult:${result.status}`);
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.deepEqual(turnResults, [{ status: "completed", failureClass: "none", error: undefined }]);
+    assert.ok(
+      deps.callLog.indexOf("turnResult:completed") < deps.callLog.indexOf("stopAuto:Workflow complete"),
+      `turn should finalize before stopAuto; log=${deps.callLog.join(",")}`,
+    );
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "complete workflow should not dispatch work");
+  });
+
+  it("stops blocked custom workflows and clears current turn state", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a", dependsOn: ["step-b"] }),
+      makeStep({ id: "step-b", dependsOn: ["step-a"] }),
+    ], "blocked-workflow");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "blocked-workflow");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+    });
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.equal(turnResults.length, 1);
+    assert.equal(turnResults[0].status, "stopped");
+    assert.equal(turnResults[0].failureClass, "manual-attention");
+    assert.match(turnResults[0].error ?? "", /custom-engine-dispatch-stop/);
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "blocked workflow should not dispatch a custom step");
+    assert.match(
+      deps.callLog.find((e: string) => e.startsWith("stopAuto:")) ?? "",
+      /Workflow blocked: no pending steps are ready/,
+    );
+  });
+
+  it("finalizes the active turn when the session lock is lost", async () => {
+    _resetPendingResolve();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession();
+    const turnResults: Array<{ status: string; failureClass: string; error?: string }> = [];
+    const deps = makeMockDeps({
+      validateSessionLock: () => ({
+        valid: false,
+        failureReason: "pid-mismatch",
+        expectedPid: 111,
+        existingPid: 222,
+      } as SessionLockStatus),
+      handleLostSessionLock: () => {
+        deps.callLog.push("handleLostSessionLock");
+      },
+      uokObserver: {
+        onTurnStart: () => {},
+        onTurnResult: (result) => {
+          turnResults.push({
+            status: result.status,
+            failureClass: result.failureClass,
+            error: result.error,
+          });
+        },
+        onPhaseResult: () => {},
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.deepEqual(turnResults, [{
+      status: "stopped",
+      failureClass: "manual-attention",
+      error: "session-lock-lost",
+    }]);
+    assert.equal(s.currentTraceId, null);
+    assert.equal(s.currentTurnId, null);
+    assert.equal(pi.calls.length, 0, "lost session lock must not dispatch work");
+    assert.ok(deps.callLog.includes("handleLostSessionLock"));
+  });
+
   it("does not call runPreDispatch or runFinalize on the custom path", async () => {
     _resetPendingResolve();
 

package/src/resources/extensions/gsd/tests/custom-verify-retry-store.test.ts

@@ -0,0 +1,139 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for custom workflow verification retry persistence.
+
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  customVerifyRetryStatePath,
+  hydrateCustomVerifyRetryCounts,
+  saveCustomVerifyRetryCounts,
+} from "../auto/custom-verify-retry-store.ts";
+
+function makeSession(activeRunDir: string): {
+  activeRunDir: string;
+  basePath: string;
+  verificationRetryCount: Map<string, number>;
+} {
+  return {
+    activeRunDir,
+    basePath: activeRunDir,
+    verificationRetryCount: new Map<string, number>(),
+  };
+}
+
+test("hydrateCustomVerifyRetryCounts loads positive finite counts from disk", () => {
+    const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    mkdirSync(join(dir, "runtime"));
+    writeFileSync(customVerifyRetryStatePath(session), JSON.stringify({
+      counts: {
+        "execute-task/M001/S001/T001": 2.8,
+        "execute-task/M001/S001/T002": 1,
+        zero: 0,
+        negative: -1,
+        infinite: Number.POSITIVE_INFINITY,
+        string: "3",
+      },
+    }));
+
+    const logged: unknown[] = [];
+    const counts = hydrateCustomVerifyRetryCounts(session, {
+      logFailure: err => logged.push(err),
+    });
+
+    assert.equal(counts, session.verificationRetryCount);
+    assert.deepEqual([...counts.entries()], [
+      ["execute-task/M001/S001/T001", 2],
+      ["execute-task/M001/S001/T002", 1],
+    ]);
+    assert.deepEqual(logged, []);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("hydrateCustomVerifyRetryCounts keeps existing in-memory counts", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.verificationRetryCount.set("existing", 4);
+
+    const counts = hydrateCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    assert.deepEqual([...counts.entries()], [["existing", 4]]);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("hydrateCustomVerifyRetryCounts logs read failures and returns the existing map", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    const logged: unknown[] = [];
+
+    const counts = hydrateCustomVerifyRetryCounts(session, {
+      logFailure: err => logged.push(err),
+    });
+
+    assert.equal(counts, session.verificationRetryCount);
+    assert.equal(counts.size, 0);
+    assert.equal(logged.length, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("saveCustomVerifyRetryCounts writes counts with an updated timestamp", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.verificationRetryCount.set("execute-task/M001/S001/T001", 3);
+
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    const saved = JSON.parse(readFileSync(customVerifyRetryStatePath(session), "utf-8"));
+    assert.deepEqual(saved.counts, {
+      "execute-task/M001/S001/T001": 3,
+    });
+    assert.equal(typeof saved.updatedAt, "string");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("saveCustomVerifyRetryCounts deletes empty retry files and ignores missing files", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-verify-retries-"));
+  try {
+    const session = makeSession(dir);
+    session.verificationRetryCount.set("execute-task/M001/S001/T001", 1);
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    session.verificationRetryCount.clear();
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+    saveCustomVerifyRetryCounts(session, {
+      logFailure: () => assert.fail("logFailure should not be called"),
+    });
+
+    const logged: unknown[] = [];
+    hydrateCustomVerifyRetryCounts(session, {
+      logFailure: err => logged.push(err),
+    });
+    assert.equal(logged.length, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/custom-workflow-engine.test.ts

@@ -193,6 +193,56 @@ describe("CustomWorkflowEngine.resolveDispatch", () => {
     }
   });
 
+  it("returns stop with dependency details when pending steps are blocked", async () => {
+    const { engine } = setupEngine([
+      makeStep({ id: "a", dependsOn: ["b"] }),
+      makeStep({ id: "b", dependsOn: ["a"] }),
+    ]);
+
+    const state = await engine.deriveState("/unused");
+    const dispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+
+    assert.equal(dispatch.action, "stop");
+    if (dispatch.action === "stop") {
+      assert.equal(dispatch.level, "error");
+      assert.match(dispatch.reason, /Workflow blocked/);
+      assert.match(dispatch.reason, /a waiting on b \(pending\)/);
+      assert.match(dispatch.reason, /b waiting on a \(pending\)/);
+    }
+  });
+
+  it("reports missing dependencies when no pending step can run", async () => {
+    const { engine } = setupEngine([
+      makeStep({ id: "a", dependsOn: ["missing-step"] }),
+    ]);
+
+    const state = await engine.deriveState("/unused");
+    const dispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+
+    assert.equal(dispatch.action, "stop");
+    if (dispatch.action === "stop") {
+      assert.equal(dispatch.level, "error");
+      assert.match(dispatch.reason, /a waiting on missing-step \(missing\)/);
+    }
+  });
+
+  it("does not report expanded dependencies as blockers", async () => {
+    const { engine } = setupEngine([
+      makeStep({ id: "iter", status: "expanded" }),
+      makeStep({ id: "after", dependsOn: ["iter", "missing-step"] }),
+    ]);
+
+    const state = await engine.deriveState("/unused");
+    const dispatch = await engine.resolveDispatch(state, { basePath: "/unused" });
+
+    assert.equal(dispatch.action, "stop");
+    if (dispatch.action === "stop") {
+      assert.equal(dispatch.level, "error");
+      assert.match(dispatch.reason, /after waiting on missing-step \(missing\)/);
+      assert.doesNotMatch(dispatch.reason, /iter \(expanded\)/);
+    }
+  });
+
   it("respects dependency ordering", async () => {
     const { engine } = setupEngine([
       makeStep({ id: "a" }),

package/src/resources/extensions/gsd/tests/dashboard-custom-engine.test.ts

@@ -44,7 +44,7 @@ describe("Dashboard custom-engine: updateProgressWidget in custom engine path",
     const source = readFileSync(loopPath, "utf-8");
 
     // Find the custom engine block
-    const customEngineStart = source.indexOf('s.activeEngineId !== "dev"');
+    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
     assert.ok(customEngineStart > -1, "Should find custom engine path in loop.ts");
 
     // The updateProgressWidget call should appear after the custom engine block start
@@ -66,11 +66,11 @@ describe("Dashboard custom-engine: updateProgressWidget in custom engine path",
     const loopPath = resolve(__filename, "../../auto/loop.ts");
     const source = readFileSync(loopPath, "utf-8");
 
-    const customEngineStart = source.indexOf('s.activeEngineId !== "dev"');
+    const customEngineStart = source.indexOf("shouldUseCustomEnginePath({");
     const afterCustomEngine = source.slice(customEngineStart);
 
     // Verify custom engine path has iterData built before the widget call
-    const iterDataIndex = afterCustomEngine.indexOf("iterData = {");
+    const iterDataIndex = afterCustomEngine.indexOf("buildCustomEngineIterationData({");
     const widgetIndex = afterCustomEngine.indexOf("deps.updateProgressWidget");
     assert.ok(iterDataIndex > -1 && widgetIndex > -1, "Both iterData and widget call should exist");
     assert.ok(

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

@@ -0,0 +1,82 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for the normalized SQLite adapter wrapper.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createDbAdapter,
+  normalizeDbRow,
+  normalizeDbRows,
+} from "../db-adapter.ts";
+
+test("normalizeDbRow returns undefined for missing rows", () => {
+  assert.equal(normalizeDbRow(null), undefined);
+  assert.equal(normalizeDbRow(undefined), undefined);
+});
+
+test("normalizeDbRow converts null-prototype rows to plain objects", () => {
+  const raw = Object.create(null) as Record<string, unknown>;
+  raw.id = "M001";
+
+  const normalized = normalizeDbRow(raw);
+
+  assert.deepEqual(normalized, { id: "M001" });
+  assert.equal(Object.getPrototypeOf(normalized), Object.prototype);
+});
+
+test("normalizeDbRows normalizes every row", () => {
+  const first = Object.create(null) as Record<string, unknown>;
+  first.id = "S01";
+  const second = { id: "S02" };
+
+  assert.deepEqual(normalizeDbRows([first, second]), [{ id: "S01" }, { id: "S02" }]);
+});
+
+test("createDbAdapter caches prepared statements and clears cache on close", () => {
+  const calls: unknown[] = [];
+  const rawStatement = {
+    run: (...params: unknown[]) => {
+      calls.push(["run", params]);
+      return { changes: 1 };
+    },
+    get: (...params: unknown[]) => {
+      calls.push(["get", params]);
+      const row = Object.create(null) as Record<string, unknown>;
+      row.id = "T01";
+      return row;
+    },
+    all: (...params: unknown[]) => {
+      calls.push(["all", params]);
+      const row = Object.create(null) as Record<string, unknown>;
+      row.id = "T02";
+      return [row];
+    },
+  };
+  let prepareCount = 0;
+  const rawDb = {
+    exec: (sql: string) => calls.push(["exec", sql]),
+    prepare: (sql: string) => {
+      prepareCount += 1;
+      calls.push(["prepare", sql]);
+      return rawStatement;
+    },
+    close: () => calls.push(["close"]),
+  };
+  const adapter = createDbAdapter(rawDb);
+
+  const first = adapter.prepare("SELECT * FROM tasks WHERE id = ?");
+  const second = adapter.prepare("SELECT * FROM tasks WHERE id = ?");
+
+  assert.equal(first, second);
+  assert.equal(prepareCount, 1);
+  assert.deepEqual(first.get("T01"), { id: "T01" });
+  assert.deepEqual(first.all("T02"), [{ id: "T02" }]);
+  assert.deepEqual(first.run("T01"), { changes: 1 });
+
+  adapter.close();
+  const third = adapter.prepare("SELECT * FROM tasks WHERE id = ?");
+
+  assert.notEqual(third, first);
+  assert.equal(prepareCount, 2);
+});

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

@@ -0,0 +1,62 @@
+// Project/App: GSD-2
+// File Purpose: Tests for base GSD database schema DDL helper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createBaseSchemaObjects } from "../db-base-schema.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeStatement implements DbStatement {
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
+  all(): Record<string, unknown>[] {
+    return [];
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement();
+  }
+
+  close(): void {}
+}
+
+describe("db-base-schema", () => {
+  test("creates current base schema tables, indexes, and active views", () => {
+    const db = new FakeAdapter();
+    let ftsCalls = 0;
+    let dedupCalls = 0;
+
+    createBaseSchemaObjects(db, {
+      tryCreateMemoriesFts: () => {
+        ftsCalls += 1;
+        return true;
+      },
+      ensureVerificationEvidenceDedupIndex: () => {
+        dedupCalls += 1;
+      },
+    });
+
+    assert.equal(ftsCalls, 1);
+    assert.equal(dedupCalls, 1);
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS schema_version")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS tasks")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS quality_gates")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_tasks_active")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW IF NOT EXISTS active_decisions")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW IF NOT EXISTS active_memories")));
+  });
+});