gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/cwd-fallback-hardening.test.ts

@@ -0,0 +1,138 @@
+// Project/App: GSD-2
+// File Purpose: Behavior tests for deleted-cwd fallback handling.
+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";
+
+import { registerDbTools } from "../bootstrap/db-tools.ts";
+import { registerDynamicTools, ensureDbOpen, safeWorkspaceCwd } from "../bootstrap/dynamic-tools.ts";
+import { registerExecTools } from "../bootstrap/exec-tools.ts";
+import { registerJournalTools } from "../bootstrap/journal-tools.ts";
+import { registerMemoryTools } from "../bootstrap/memory-tools.ts";
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+
+async function withDeletedCwd(fn: (projectRoot: string) => Promise<void> | void): Promise<void> {
+  const previousCwd = process.cwd();
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-safe-cwd-project-"));
+  const removedCwd = mkdtempSync(join(tmpdir(), "gsd-removed-cwd-"));
+
+  process.env.GSD_PROJECT_ROOT = projectRoot;
+  process.chdir(removedCwd);
+  rmSync(removedCwd, { recursive: true, force: true });
+
+  try {
+    assert.throws(() => process.cwd(), /ENOENT/);
+    await fn(projectRoot);
+  } finally {
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+}
+
+function collectTools(register: (pi: any) => void): any[] {
+  const tools: any[] = [];
+  register({
+    registerTool(tool: any) {
+      tools.push(tool);
+    },
+  });
+  return tools;
+}
+
+test("safeWorkspaceCwd falls back to captured project root when cwd was removed", async () => {
+  await withDeletedCwd((projectRoot) => {
+    assert.equal(safeWorkspaceCwd(), projectRoot);
+  });
+});
+
+test("ensureDbOpen default path does not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    assert.equal(await ensureDbOpen(), false);
+  });
+});
+
+test("dynamic tools register when cwd was removed", async () => {
+  await withDeletedCwd(() => {
+    const tools = collectTools(registerDynamicTools);
+    assert.equal(tools.length, 4);
+  });
+});
+
+test("db-backed tool fallbacks return normal unavailable-db errors when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const tools = collectTools(registerDbTools);
+    const decisionSave = tools.find((tool) => tool.name === "gsd_decision_save");
+
+    const result = await decisionSave.execute(
+      "call-1",
+      {
+        scope: "test",
+        decision: "Handle deleted cwd",
+        choice: "Use captured project root",
+        rationale: "The worktree cwd may disappear during cleanup.",
+      },
+      undefined,
+      undefined,
+      undefined,
+    );
+
+    assert.equal(result.details.error, "db_unavailable");
+  });
+});
+
+test("memory and query tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const memoryTools = collectTools(registerMemoryTools);
+    const queryTools = collectTools(registerQueryTools);
+
+    await assert.doesNotReject(() =>
+      memoryTools.find((tool) => tool.name === "memory_query").execute(
+        "call-1",
+        { query: "cwd fallback" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      queryTools.find((tool) => tool.name === "gsd_milestone_status").execute(
+        "call-2",
+        { milestoneId: "M001" },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});
+
+test("journal and exec tools do not throw when cwd was removed", async () => {
+  await withDeletedCwd(async () => {
+    const journalTools = collectTools(registerJournalTools);
+    const execTools = collectTools(registerExecTools);
+
+    await assert.doesNotReject(() =>
+      journalTools.find((tool) => tool.name === "gsd_journal_query").execute(
+        "call-1",
+        { limit: 1 },
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+    await assert.doesNotReject(() =>
+      execTools.find((tool) => tool.name === "gsd_resume").execute(
+        "call-2",
+        {},
+        undefined,
+        undefined,
+        undefined,
+      ),
+    );
+  });
+});

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

@@ -1,21 +1,12 @@
 /**
- * dashboard-custom-engine.test.ts — Tests that the custom engine path
- * calls updateProgressWidget and that unitLabel handles "custom-step".
- *
- * Uses source-level assertions for the non-exported unitLabel function
- * and the updateProgressWidget call placement. Tests exported helpers
- * (unitVerb, unitPhaseLabel) directly.
+ * dashboard-custom-engine.test.ts — custom-step dashboard labels.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { unitVerb, unitPhaseLabel } from "../auto-dashboard.js";
-
-// ─── Tests ───────────────────────────────────────────────────────────────
+import { unitLabel } from "../dashboard-overlay.ts";
 
 describe("Dashboard custom-engine: unitLabel and related helpers", () => {
   it('unitVerb("custom-step") returns "executing workflow step"', () => {
@@ -26,62 +17,7 @@ describe("Dashboard custom-engine: unitLabel and related helpers", () => {
     assert.equal(unitPhaseLabel("custom-step"), "WORKFLOW");
   });
 
-  it('dashboard-overlay.ts contains a case for "custom-step" returning "Workflow Step"', () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const overlayPath = resolve(__filename, "../../dashboard-overlay.ts");
-    const source = readFileSync(overlayPath, "utf-8");
-    assert.ok(
-      source.includes('"custom-step"') && source.includes('"Workflow Step"'),
-      'dashboard-overlay.ts should contain case "custom-step": return "Workflow Step"',
-    );
-  });
-});
-
-describe("Dashboard custom-engine: updateProgressWidget in custom engine path", () => {
-  it("loop.ts custom engine path includes updateProgressWidget call before runGuards", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    // Find the custom engine block
-    const customEngineStart = source.indexOf('s.activeEngineId !== "dev"');
-    assert.ok(customEngineStart > -1, "Should find custom engine path in loop.ts");
-
-    // The updateProgressWidget call should appear after the custom engine block start
-    // and before the runGuards call in that block
-    const afterCustomEngine = source.slice(customEngineStart);
-    const widgetCallIndex = afterCustomEngine.indexOf(
-      "deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state)",
-    );
-    const guardsCallIndex = afterCustomEngine.indexOf("runGuards(ic,");
-    assert.ok(widgetCallIndex > -1, "updateProgressWidget should be called in custom engine path");
-    assert.ok(
-      widgetCallIndex < guardsCallIndex,
-      "updateProgressWidget should be called before runGuards in custom engine path",
-    );
-  });
-
-  it("updateProgressWidget call is placed after iterData is built", () => {
-    const __filename = fileURLToPath(import.meta.url);
-    const loopPath = resolve(__filename, "../../auto/loop.ts");
-    const source = readFileSync(loopPath, "utf-8");
-
-    const customEngineStart = source.indexOf('s.activeEngineId !== "dev"');
-    const afterCustomEngine = source.slice(customEngineStart);
-
-    // Verify custom engine path has iterData built before the widget call
-    const iterDataIndex = afterCustomEngine.indexOf("iterData = {");
-    const widgetIndex = afterCustomEngine.indexOf("deps.updateProgressWidget");
-    assert.ok(iterDataIndex > -1 && widgetIndex > -1, "Both iterData and widget call should exist");
-    assert.ok(
-      iterDataIndex < widgetIndex,
-      "iterData should be built before updateProgressWidget is called",
-    );
-
-    // Verify the call uses iterData.state (which holds the derived GSD state)
-    assert.ok(
-      afterCustomEngine.includes("iterData.state"),
-      "Custom engine updateProgressWidget should reference iterData.state",
-    );
+  it('unitLabel("custom-step") returns "Workflow Step"', () => {
+    assert.equal(unitLabel("custom-step"), "Workflow Step");
   });
 });

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")));
+  });
+});

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

@@ -0,0 +1,60 @@
+// Project/App: GSD-2
+// File Purpose: Tests for workspace database connection cache lifecycle helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createDbConnectionCache, type DbConnectionCacheEntry } from "../db-connection-cache.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeAdapter implements DbAdapter {
+  readonly calls: string[] = [];
+
+  exec(sql: string): void {
+    this.calls.push(`exec:${sql}`);
+  }
+
+  prepare(): DbStatement {
+    throw new Error("prepare is not used by DbConnectionCache tests");
+  }
+
+  close(): void {
+    this.calls.push("close");
+  }
+}
+
+function entry(path: string, db = new FakeAdapter()): DbConnectionCacheEntry {
+  return { dbPath: path, db };
+}
+
+describe("db-connection-cache", () => {
+  test("stores entries and exposes a readonly cache view", () => {
+    const cache = createDbConnectionCache();
+    const cached = entry("/tmp/a.db");
+
+    cache.set("workspace-a", cached);
+
+    assert.equal(cache.get("workspace-a"), cached);
+    assert.equal(cache.has("workspace-a"), true);
+    assert.equal(cache.asReadonlyMap().size, 1);
+  });
+
+  test("closeNonActive closes and removes only inactive entries", () => {
+    const cache = createDbConnectionCache();
+    const activeDb = new FakeAdapter();
+    const inactiveDb = new FakeAdapter();
+    cache.set("active", entry("/tmp/active.db", activeDb));
+    cache.set("inactive", entry("/tmp/inactive.db", inactiveDb));
+    const closed: string[] = [];
+
+    cache.closeNonActive(activeDb, (cached) => {
+      closed.push(cached.dbPath);
+      cached.db.close();
+    });
+
+    assert.deepEqual(closed, ["/tmp/inactive.db"]);
+    assert.equal(cache.has("active"), true);
+    assert.equal(cache.has("inactive"), false);
+    assert.deepEqual(activeDb.calls, []);
+    assert.deepEqual(inactiveDb.calls, ["close"]);
+  });
+});

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

@@ -0,0 +1,39 @@
+// Project/App: GSD-2
+// File Purpose: Tests for auto-mode coordination schema helper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createCoordinationTablesV24 } from "../db-coordination-schema.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    throw new Error("prepare is not used by coordination schema tests");
+  }
+
+  close(): void {}
+}
+
+describe("db-coordination-schema", () => {
+  test("creates coordination tables and claim indexes", () => {
+    const db = new FakeAdapter();
+
+    createCoordinationTablesV24(db);
+
+    assert.equal(db.execCalls.length, 9);
+    assert.match(db.execCalls[0], /CREATE TABLE IF NOT EXISTS workers/);
+    assert.match(db.execCalls[1], /CREATE TABLE IF NOT EXISTS milestone_leases/);
+    assert.match(db.execCalls[2], /CREATE TABLE IF NOT EXISTS unit_dispatches/);
+    assert.match(db.execCalls[3], /CREATE TABLE IF NOT EXISTS cancellation_requests/);
+    assert.match(db.execCalls[4], /CREATE TABLE IF NOT EXISTS command_queue/);
+    assert.ok(db.execCalls.some((sql) => sql.includes("idx_unit_dispatches_active_per_unit")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("WHERE status IN ('claimed','running')")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("idx_command_queue_pending")));
+  });
+});

package/src/resources/extensions/gsd/tests/db-decision-requirement-rows.test.ts

@@ -0,0 +1,135 @@
+// Project/App: GSD-2
+// File Purpose: Tests for decision and requirement database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  rowToActiveDecision,
+  rowToActiveRequirement,
+  rowToDecision,
+  rowToRequirement,
+  rowsToRequirementCounts,
+} from "../db-decision-requirement-rows.ts";
+
+describe("db-decision-requirement-rows", () => {
+  test("maps persisted decision rows with defaults", () => {
+    const decision = rowToDecision({
+      seq: 7,
+      id: "D007",
+      when_context: "during planning",
+      scope: "M001/S01",
+      decision: "keep SQL writes in gsd-db",
+      choice: "facade wrappers",
+      rationale: "preserve the single-writer invariant",
+      revisable: "after repository split",
+      superseded_by: "D008",
+    });
+
+    assert.deepEqual(decision, {
+      seq: 7,
+      id: "D007",
+      when_context: "during planning",
+      scope: "M001/S01",
+      decision: "keep SQL writes in gsd-db",
+      choice: "facade wrappers",
+      rationale: "preserve the single-writer invariant",
+      revisable: "after repository split",
+      made_by: "agent",
+      source: "discussion",
+      superseded_by: "D008",
+    });
+  });
+
+  test("maps active decision rows as non-superseded", () => {
+    const decision = rowToActiveDecision({
+      seq: 1,
+      id: "D001",
+      when_context: "now",
+      scope: "global",
+      decision: "active only",
+      choice: "view row",
+      rationale: "view filters superseded rows",
+      revisable: "yes",
+      made_by: "human",
+      source: "planning",
+      superseded_by: "ignored",
+    });
+
+    assert.equal(decision.made_by, "human");
+    assert.equal(decision.source, "planning");
+    assert.equal(decision.superseded_by, null);
+  });
+
+  test("maps persisted requirement rows", () => {
+    const requirement = rowToRequirement({
+      id: "R001",
+      class: "functional",
+      status: "active",
+      description: "Persist requirements",
+      why: "planning needs durable context",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "S02",
+      validation: "roundtrip",
+      notes: "important",
+      full_content: "Full requirement text",
+      superseded_by: "R002",
+    });
+
+    assert.deepEqual(requirement, {
+      id: "R001",
+      class: "functional",
+      status: "active",
+      description: "Persist requirements",
+      why: "planning needs durable context",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "S02",
+      validation: "roundtrip",
+      notes: "important",
+      full_content: "Full requirement text",
+      superseded_by: "R002",
+    });
+  });
+
+  test("maps active requirement rows as non-superseded", () => {
+    const requirement = rowToActiveRequirement({
+      id: "R001",
+      class: "functional",
+      status: "validated",
+      description: "Validated requirement",
+      why: "done",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "",
+      validation: "tests",
+      notes: "",
+      full_content: "Full requirement text",
+      superseded_by: "ignored",
+    });
+
+    assert.equal(requirement.status, "validated");
+    assert.equal(requirement.superseded_by, null);
+  });
+
+  test("reduces requirement status rows into stable counts", () => {
+    const counts = rowsToRequirementCounts([
+      { status: "active", count: 2 },
+      { status: "validated", count: 3 },
+      { status: "deferred", count: 5 },
+      { status: "out-of-scope", count: 7 },
+      { status: "out_of_scope", count: 11 },
+      { status: "blocked", count: 13 },
+      { status: "unknown", count: 17 },
+    ]);
+
+    assert.deepEqual(counts, {
+      active: 2,
+      validated: 3,
+      deferred: 5,
+      outOfScope: 18,
+      blocked: 13,
+      total: 58,
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+// Project/App: GSD-2
+// File Purpose: Tests for quality gate database row mapper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { rowToGate } from "../db-gate-rows.ts";
+
+describe("db-gate-rows", () => {
+  test("rowToGate clears verdict for pending gates", () => {
+    const gate = rowToGate({
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q3",
+      scope: "slice",
+      status: "pending",
+      verdict: "pass",
+    });
+
+    assert.equal(gate.task_id, "");
+    assert.equal(gate.verdict, null);
+    assert.equal(gate.rationale, "");
+    assert.equal(gate.findings, "");
+    assert.equal(gate.evaluated_at, null);
+  });
+
+  test("rowToGate preserves completed gate verdict and details", () => {
+    const gate = rowToGate({
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q4",
+      scope: "task",
+      task_id: "T01",
+      status: "complete",
+      verdict: "flag",
+      rationale: "needs review",
+      findings: "minor risk",
+      evaluated_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(gate, {
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q4",
+      scope: "task",
+      task_id: "T01",
+      status: "complete",
+      verdict: "flag",
+      rationale: "needs review",
+      findings: "minor risk",
+      evaluated_at: "2026-05-04T00:00:00.000Z",
+    });
+  });
+});