gsd-pi 2.79.0 → 2.80.0-dev.c5f2443b3

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

@@ -0,0 +1,115 @@
+// Project/App: GSD-2
+// File Purpose: Tests for SQLite schema metadata helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { columnExists, ensureColumn, getCurrentSchemaVersion, indexExists, recordSchemaVersion } from "../db-schema-metadata.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeStatement implements DbStatement {
+  private readonly getResult: Record<string, unknown> | undefined;
+  private readonly allResult: Record<string, unknown>[];
+  private readonly onRun: ((params: unknown[]) => void) | undefined;
+
+  constructor(
+    getResult: Record<string, unknown> | undefined,
+    allResult: Record<string, unknown>[],
+    onRun?: (params: unknown[]) => void,
+  ) {
+    this.getResult = getResult;
+    this.allResult = allResult;
+    this.onRun = onRun;
+  }
+
+  run(...params: unknown[]): unknown {
+    this.onRun?.(params);
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return this.getResult;
+  }
+
+  all(): Record<string, unknown>[] {
+    return this.allResult;
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  readonly runCalls: unknown[][] = [];
+  readonly preparedSql: string[] = [];
+  indexNames = new Set<string>();
+  tableColumns = new Map<string, string[]>();
+  currentVersion: number | undefined = undefined;
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(sql: string): DbStatement {
+    this.preparedSql.push(sql);
+    if (sql.includes("sqlite_master")) {
+      return new FakeStatement(this.indexNames.size > 0 ? { present: 1 } : undefined, []);
+    }
+    if (sql.includes("SELECT MAX(version)")) {
+      return new FakeStatement(this.currentVersion === undefined ? undefined : { v: this.currentVersion }, []);
+    }
+    if (sql.includes("INSERT INTO schema_version")) {
+      return new FakeStatement(undefined, [], (params) => {
+        this.runCalls.push(params);
+      });
+    }
+    const tableMatch = /^PRAGMA table_info\(([^)]+)\)$/.exec(sql);
+    if (tableMatch) {
+      const columns = this.tableColumns.get(tableMatch[1]) ?? [];
+      return new FakeStatement(undefined, columns.map((name) => ({ name })));
+    }
+    return new FakeStatement(undefined, []);
+  }
+
+  close(): void {}
+}
+
+describe("db-schema-metadata", () => {
+  test("indexExists returns true when sqlite_master has a row", () => {
+    const db = new FakeAdapter();
+    db.indexNames.add("idx_present");
+
+    assert.equal(indexExists(db, "idx_present"), true);
+  });
+
+  test("columnExists reads table_info rows", () => {
+    const db = new FakeAdapter();
+    db.tableColumns.set("tasks", ["id", "status"]);
+
+    assert.equal(columnExists(db, "tasks", "status"), true);
+    assert.equal(columnExists(db, "tasks", "missing"), false);
+  });
+
+  test("ensureColumn executes ddl only when the column is missing", () => {
+    const db = new FakeAdapter();
+    db.tableColumns.set("tasks", ["id"]);
+
+    ensureColumn(db, "tasks", "status", "ALTER TABLE tasks ADD COLUMN status TEXT");
+    ensureColumn(db, "tasks", "id", "ALTER TABLE tasks ADD COLUMN id TEXT");
+
+    assert.deepEqual(db.execCalls, ["ALTER TABLE tasks ADD COLUMN status TEXT"]);
+  });
+
+  test("getCurrentSchemaVersion returns zero when no version row exists", () => {
+    const db = new FakeAdapter();
+
+    assert.equal(getCurrentSchemaVersion(db), 0);
+  });
+
+  test("records schema version rows with timestamps", () => {
+    const db = new FakeAdapter();
+
+    recordSchemaVersion(db, 25);
+
+    assert.equal(db.runCalls.length, 1);
+    assert.equal((db.runCalls[0][0] as Record<string, unknown>)[":version"], 25);
+    assert.equal(typeof (db.runCalls[0][0] as Record<string, unknown>)[":applied_at"], "string");
+  });
+});

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

@@ -0,0 +1,128 @@
+// Project/App: GSD-2
+// File Purpose: Tests for task and slice database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { parseTaskArrayColumn, rowToSlice, rowToTask } from "../db-task-slice-rows.ts";
+
+describe("db-task-slice-rows", () => {
+  test("parseTaskArrayColumn handles JSON arrays, scalar JSON, raw arrays, and legacy CSV", () => {
+    assert.deepEqual(parseTaskArrayColumn('["a.ts","b.ts"]'), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn('"single.ts"'), ["single.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(["a.ts", 42, "b.ts"]), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(" a.ts, b.ts ,, "), ["a.ts", "b.ts"]);
+    assert.deepEqual(parseTaskArrayColumn(""), []);
+    assert.deepEqual(parseTaskArrayColumn(null), []);
+  });
+
+  test("rowToSlice maps optional DB columns to stable defaults", () => {
+    const slice = rowToSlice({
+      milestone_id: "M001",
+      id: "S01",
+      title: "Build the thing",
+      status: "active",
+      risk: "medium",
+      depends: '["S00"]',
+      created_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(slice, {
+      milestone_id: "M001",
+      id: "S01",
+      title: "Build the thing",
+      status: "active",
+      risk: "medium",
+      depends: ["S00"],
+      demo: "",
+      created_at: "2026-05-04T00:00:00.000Z",
+      completed_at: null,
+      full_summary_md: "",
+      full_uat_md: "",
+      goal: "",
+      success_criteria: "",
+      proof_level: "",
+      integration_closure: "",
+      observability_impact: "",
+      sequence: 0,
+      replan_triggered_at: null,
+      is_sketch: 0,
+      sketch_scope: "",
+    });
+  });
+
+  test("rowToTask maps planning and escalation columns", () => {
+    const task = rowToTask({
+      milestone_id: "M001",
+      slice_id: "S01",
+      id: "T01",
+      title: "Extract row mapper",
+      status: "done",
+      one_liner: "Mapper extraction",
+      narrative: "Moved row shaping",
+      verification_result: "passed",
+      duration: "5m",
+      completed_at: "2026-05-04T00:00:00.000Z",
+      blocker_discovered: 1,
+      deviations: "",
+      known_issues: "",
+      key_files: "a.ts,b.ts",
+      key_decisions: '["D001"]',
+      full_summary_md: "summary",
+      description: "description",
+      estimate: "small",
+      files: '["src/a.ts"]',
+      verify: "npm test",
+      inputs: '"input.md"',
+      expected_output: "result.md,report.md",
+      observability_impact: "none",
+      full_plan_md: "plan",
+      sequence: 3,
+      blocker_source: "test",
+      escalation_pending: 1,
+      escalation_awaiting_review: 0,
+      escalation_artifact_path: "/tmp/escalation.md",
+      escalation_override_applied_at: "2026-05-04T00:01:00.000Z",
+    });
+
+    assert.equal(task.blocker_discovered, true);
+    assert.deepEqual(task.key_files, ["a.ts", "b.ts"]);
+    assert.deepEqual(task.key_decisions, ["D001"]);
+    assert.deepEqual(task.files, ["src/a.ts"]);
+    assert.deepEqual(task.inputs, ["input.md"]);
+    assert.deepEqual(task.expected_output, ["result.md", "report.md"]);
+    assert.equal(task.sequence, 3);
+    assert.equal(task.escalation_pending, 1);
+    assert.equal(task.escalation_artifact_path, "/tmp/escalation.md");
+  });
+
+  test("rowToTask defaults optional planning and escalation fields", () => {
+    const task = rowToTask({
+      milestone_id: "M001",
+      slice_id: "S01",
+      id: "T01",
+      title: "Pending",
+      status: "pending",
+      one_liner: "",
+      narrative: "",
+      verification_result: "",
+      duration: "",
+      blocker_discovered: 0,
+      deviations: "",
+      known_issues: "",
+      key_files: "",
+      key_decisions: "",
+      full_summary_md: "",
+    });
+
+    assert.equal(task.completed_at, null);
+    assert.deepEqual(task.files, []);
+    assert.deepEqual(task.inputs, []);
+    assert.deepEqual(task.expected_output, []);
+    assert.equal(task.sequence, 0);
+    assert.equal(task.blocker_source, "");
+    assert.equal(task.escalation_pending, 0);
+    assert.equal(task.escalation_awaiting_review, 0);
+    assert.equal(task.escalation_artifact_path, null);
+    assert.equal(task.escalation_override_applied_at, null);
+  });
+});

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

@@ -0,0 +1,110 @@
+// Project/App: GSD-2
+// File Purpose: Tests for DB transaction depth and rollback helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createDbTransactionRunner, type DbTransactionControls } from "../db-transaction.ts";
+
+class FakeTransactionControls implements DbTransactionControls {
+  readonly calls: string[] = [];
+  failCall = new Set<string>();
+
+  begin(): void {
+    this.record("BEGIN");
+  }
+
+  beginRead(): void {
+    this.record("BEGIN DEFERRED");
+  }
+
+  commit(): void {
+    this.record("COMMIT");
+  }
+
+  rollback(): void {
+    this.record("ROLLBACK");
+  }
+
+  private record(call: string): void {
+    this.calls.push(call);
+    if (this.failCall.has(call)) throw new Error(`failed ${call}`);
+  }
+}
+
+describe("db-transaction", () => {
+  test("commits successful write transactions", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    const result = runner.transaction(controls, () => {
+      assert.equal(runner.isInTransaction(), true);
+      return "ok";
+    });
+
+    assert.equal(result, "ok");
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN", "COMMIT"]);
+  });
+
+  test("rolls back failed write transactions and clears depth", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    assert.throws(
+      () => runner.transaction(controls, () => {
+        throw new Error("boom");
+      }),
+      /boom/,
+    );
+
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN", "ROLLBACK"]);
+  });
+
+  test("nested transactions do not issue nested BEGIN or COMMIT", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+
+    runner.transaction(controls, () => {
+      runner.transaction(controls, () => {
+        assert.equal(runner.isInTransaction(), true);
+      });
+    });
+
+    assert.deepEqual(controls.calls, ["BEGIN", "COMMIT"]);
+  });
+
+  test("failed BEGIN does not mark transaction depth active", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+    controls.failCall.add("BEGIN");
+
+    assert.throws(() => runner.transaction(controls, () => undefined), /failed BEGIN/);
+
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN"]);
+  });
+
+  test("read transactions log rollback failures and clear depth", () => {
+    const runner = createDbTransactionRunner();
+    const controls = new FakeTransactionControls();
+    const rollbackErrors: Error[] = [];
+    controls.failCall.add("ROLLBACK");
+
+    assert.throws(
+      () => runner.readTransaction(
+        controls,
+        () => {
+          throw new Error("read failed");
+        },
+        (error) => rollbackErrors.push(error),
+      ),
+      /read failed/,
+    );
+
+    assert.equal(runner.isInTransaction(), false);
+    assert.deepEqual(controls.calls, ["BEGIN DEFERRED", "ROLLBACK"]);
+    assert.equal(rollbackErrors.length, 1);
+    assert.match(rollbackErrors[0].message, /failed ROLLBACK/);
+  });
+});

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

@@ -0,0 +1,76 @@
+// Project/App: GSD-2
+// File Purpose: Tests for verification evidence schema helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  dedupeVerificationEvidenceRows,
+  ensureVerificationEvidenceDedupIndex,
+} from "../db-verification-evidence-schema.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) {
+    this.row = row;
+  }
+
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return this.row;
+  }
+
+  all(): Record<string, unknown>[] {
+    return [];
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  hasDedupIndex = false;
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement(this.hasDedupIndex ? { present: 1 } : undefined);
+  }
+
+  close(): void {}
+}
+
+describe("db-verification-evidence-schema", () => {
+  test("dedupeVerificationEvidenceRows keeps the first row for each evidence identity", () => {
+    const db = new FakeAdapter();
+
+    dedupeVerificationEvidenceRows(db);
+
+    assert.equal(db.execCalls.length, 1);
+    assert.match(db.execCalls[0], /DELETE FROM verification_evidence/);
+    assert.match(db.execCalls[0], /GROUP BY task_id, slice_id, milestone_id, command, verdict/);
+  });
+
+  test("ensureVerificationEvidenceDedupIndex dedupes before creating the unique index", () => {
+    const db = new FakeAdapter();
+
+    ensureVerificationEvidenceDedupIndex(db);
+
+    assert.equal(db.execCalls.length, 2);
+    assert.match(db.execCalls[0], /DELETE FROM verification_evidence/);
+    assert.match(db.execCalls[1], /CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup/);
+  });
+
+  test("ensureVerificationEvidenceDedupIndex no-ops when the index already exists", () => {
+    const db = new FakeAdapter();
+    db.hasDedupIndex = true;
+
+    ensureVerificationEvidenceDedupIndex(db);
+
+    assert.deepEqual(db.execCalls, []);
+  });
+});

package/src/resources/extensions/gsd/tests/deep-planning-mode-dispatch.test.ts

@@ -14,6 +14,7 @@ import {
   DISPATCH_RULES,
   getDeepStageGate,
   hasPendingDeepStage,
+  resolveDispatch,
   setResearchProjectPromptBuilderForTest,
   type DispatchContext,
 } from "../auto-dispatch.ts";
@@ -248,6 +249,11 @@ function writeCapturedDeepPrefs(base: string): void {
   );
 }
 
+function writeSkippedProjectResearchDecision(base: string): void {
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "runtime", "research-decision.json"), JSON.stringify({ decision: "skip" }));
+}
+
 function makeCtx(
   basePath: string,
   prefs: GSDPreferences | undefined,
@@ -785,6 +791,42 @@ test("Deep mode: research-project DOES dispatch when only 3 of 4 research files
   assert.ok(result && result.action === "dispatch", "any missing dimension must trigger re-run");
 });
 
+test("Deep mode: queued milestone without CONTEXT.md routes to milestone research after project setup", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  writeCapturedDeepPrefs(base);
+  writeValidProject(base);
+  writeValidRequirements(base);
+  writeSkippedProjectResearchDecision(base);
+
+  const prefs = { planning_depth: "deep" } as GSDPreferences;
+  const result = await resolveDispatch(makeCtx(base, prefs));
+
+  assert.equal(result.action, "dispatch");
+  if (result.action === "dispatch") {
+    assert.equal(result.unitType, "research-milestone");
+    assert.equal(result.unitId, "M001");
+  }
+});
+
+test("Deep mode: queued milestone without CONTEXT.md can route directly to milestone planning", async (t) => {
+  const base = makeIsolatedBaseWithCleanup(t);
+
+  writeCapturedDeepPrefs(base);
+  writeValidProject(base);
+  writeValidRequirements(base);
+  writeSkippedProjectResearchDecision(base);
+
+  const prefs = { planning_depth: "deep", phases: { skip_research: true } } as GSDPreferences;
+  const result = await resolveDispatch(makeCtx(base, prefs));
+
+  assert.equal(result.action, "dispatch");
+  if (result.action === "dispatch") {
+    assert.equal(result.unitType, "plan-milestone");
+    assert.equal(result.unitId, "M001");
+  }
+});
+
 // ─── centralized deep-stage gate ─────────────────────────────────────────
 
 test("Deep mode gate reports the earliest missing section", (t) => {

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -23,6 +23,11 @@ import {
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.ts";
 import type { GSDPreferences } from "../preferences.ts";
 import type { GSDState } from "../types.ts";
 
@@ -342,6 +347,62 @@ test("deep project setup: pre-dispatch can run before the first milestone exists
   }
 });
 
+test("deep project setup: bootstrap continues queued M002 without milestone context", async () => {
+  const base = makeRepo();
+  try {
+    writeCapturedDeepPrefs(base);
+    writeValidProjectAndRequirements(base);
+    mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "runtime", "research-decision.json"), '{"decision":"skip"}\n');
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "First milestone", status: "complete" });
+    insertMilestone({ id: "M002", title: "Second milestone", status: "queued" });
+    closeDatabase();
+
+    const messages: unknown[] = [];
+    const pi = {
+      ...makePi(messages),
+      getThinkingLevel: () => "medium",
+    };
+    const s = new AutoSession();
+    const ready = await bootstrapAutoSession(
+      s,
+      makeCtx(`queued-${randomUUID()}`) as any,
+      pi as any,
+      base,
+      false,
+      false,
+      {
+        shouldUseWorktreeIsolation: () => false,
+        registerSigtermHandler: () => {},
+        lockBase: () => base,
+        buildResolver: () => ({}) as any,
+      },
+      {
+        classification: "none",
+        lock: null,
+        pausedSession: null,
+        state: null,
+        recovery: null,
+        recoveryPrompt: null,
+        recoveryToolCallCount: 0,
+        artifactSatisfied: false,
+        hasResumableDiskState: false,
+        isBootstrapCrash: false,
+      },
+    );
+
+    assert.equal(ready, true);
+    assert.equal(s.active, true);
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.equal(messages.length, 0, "queued deep milestone must not re-enter smart new-milestone discussion");
+  } finally {
+    try { closeDatabase(); } catch {}
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: pre-dispatch takes precedence over an existing draft milestone", async () => {
   const base = makeBase();
   try {
@@ -1020,7 +1081,7 @@ test("deep project setup: research-project blocker placeholder is a file, not th
   const base = makeBase();
   try {
     const expectedPath = resolveExpectedArtifactPath("research-project", "PROJECT-RESEARCH", base);
-    assert.equal(expectedPath, join(base, ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
+    assert.equal(expectedPath, join(realpathSync(base), ".gsd", "research", "PROJECT-RESEARCH-BLOCKER.md"));
 
     mkdirSync(join(base, ".gsd", "research"), { recursive: true });
     const diagnosis = writeBlockerPlaceholder(

package/src/resources/extensions/gsd/tests/discuss-headless-rendering.test.ts

@@ -0,0 +1,37 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the headless discussion prompt renders compact required guidance.
+
+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("discuss-headless prompt renders compact investigation and audit guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-discuss-headless-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("discuss-headless", {
+    seedContext: "# Spec\n\nBuild the thing.",
+    milestoneId: "M001",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    commitInstruction: "Commit the created milestone artifacts.",
+    multiMilestoneCommitInstruction: "Commit the created milestone artifacts.",
+    inlinedTemplates: "## Template\n\nUse standard GSD artifacts.",
+  });
+
+  assert.match(prompt, /Investigate before making decisions:/);
+  assert.match(prompt, /Budget searches across investigation and focused research\./);
+  assert.match(prompt, /Resolve all of these from the spec and investigation before writing artifacts:/);
+  assert.match(prompt, /Print a structured depth summary in chat/);
+  assert.match(prompt, /Document every assumption in CONTEXT\.md/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});