gsd-pi 2.82.0 → 3.0.0

package/src/resources/extensions/gsd/tests/context-store-decisions-from-memories.test.ts

@@ -0,0 +1,312 @@
+// ADR-013 Phase 6 cutover (Stage 1) — queryDecisionsFromMemories parity test.
+//
+// Verifies that reading active decisions from the `memories` table returns
+// the same Decision[] shape and content as the legacy `queryDecisions` read
+// from the `decisions` table, once Phase 5 dual-write has populated both
+// surfaces. Lock-in regression for the prompt-inline read path which was
+// switched to the memories source in auto-prompts.ts:inlineDecisionsFromDb.
+//
+// Scope of parity: ACTIVE decisions only. Superseded rows are intentionally
+// skipped by the existing backfill, so this test does not assert parity for
+// the supersedes-chain — that gap is acknowledged in
+// queryDecisionsFromMemories' contract and tracked for Stage 2/3.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  closeDatabase,
+  insertDecision,
+  openDatabase,
+} from "../gsd-db.ts";
+import { saveDecisionToDb } from "../db-writer.ts";
+import {
+  queryDecisions,
+  queryDecisionsFromMemories,
+} from "../context-store.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-decisions-memories-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+async function seedDecision(
+  base: string,
+  fields: {
+    when_context: string;
+    scope: string;
+    decision: string;
+    choice: string;
+    rationale: string;
+    revisable?: string;
+    made_by?: "human" | "agent" | "collaborative";
+  },
+): Promise<string> {
+  // saveDecisionToDb writes ONLY to memories post-Stage-3. For parity tests
+  // comparing the legacy `queryDecisions` against `queryDecisionsFromMemories`,
+  // mirror the same row into the legacy decisions table directly so both
+  // surfaces hold the same data and the parity assertion is well-defined.
+  const result = await saveDecisionToDb(
+    {
+      when_context: fields.when_context,
+      scope: fields.scope,
+      decision: fields.decision,
+      choice: fields.choice,
+      rationale: fields.rationale,
+      revisable: fields.revisable ?? "Yes",
+      made_by: fields.made_by ?? "agent",
+    },
+    base,
+  );
+  insertDecision({
+    id: result.id,
+    when_context: fields.when_context,
+    scope: fields.scope,
+    decision: fields.decision,
+    choice: fields.choice,
+    rationale: fields.rationale,
+    revisable: fields.revisable ?? "Yes",
+    made_by: fields.made_by ?? "agent",
+    superseded_by: null,
+  });
+  return result.id;
+}
+
+test("queryDecisionsFromMemories returns empty when no decisions exist", () => {
+  const base = makeTmpBase();
+  try {
+    assert.deepEqual(queryDecisionsFromMemories(), []);
+    assert.deepEqual(queryDecisionsFromMemories({ milestoneId: "M001" }), []);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories matches queryDecisions for a single active decision", async () => {
+  const base = makeTmpBase();
+  try {
+    await seedDecision(base, {
+      when_context: "M001 discuss phase",
+      scope: "M001",
+      decision: "Adopt SQLite for persistence",
+      choice: "better-sqlite3",
+      rationale: "Native, synchronous, well-supported",
+    });
+
+    const fromDecisions = queryDecisions();
+    const fromMemories = queryDecisionsFromMemories();
+
+    assert.equal(fromDecisions.length, 1);
+    assert.equal(fromMemories.length, 1);
+
+    // Compare the user-visible Decision fields. seq differs across tables
+    // (memories.seq vs decisions.seq) so it's intentionally excluded.
+    const { seq: _seq1, ...d1 } = fromDecisions[0]!;
+    const { seq: _seq2, ...d2 } = fromMemories[0]!;
+    assert.deepEqual(d1, d2);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories preserves decision order across multiple writes", async () => {
+  const base = makeTmpBase();
+  try {
+    const id1 = await seedDecision(base, {
+      when_context: "M001 discuss",
+      scope: "M001",
+      decision: "First decision",
+      choice: "A",
+      rationale: "first",
+    });
+    const id2 = await seedDecision(base, {
+      when_context: "M001 plan",
+      scope: "M001",
+      decision: "Second decision",
+      choice: "B",
+      rationale: "second",
+    });
+    const id3 = await seedDecision(base, {
+      when_context: "M002 discuss",
+      scope: "M002",
+      decision: "Third decision",
+      choice: "C",
+      rationale: "third",
+    });
+
+    const fromMemories = queryDecisionsFromMemories();
+    assert.equal(fromMemories.length, 3);
+    assert.deepEqual(
+      fromMemories.map((d) => d.id),
+      [id1, id2, id3],
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories filters by milestoneId (substring match on when_context)", async () => {
+  const base = makeTmpBase();
+  try {
+    await seedDecision(base, {
+      when_context: "M001 discuss",
+      scope: "M001",
+      decision: "M001 decision",
+      choice: "A",
+      rationale: "x",
+    });
+    await seedDecision(base, {
+      when_context: "M002 plan",
+      scope: "M002",
+      decision: "M002 decision",
+      choice: "B",
+      rationale: "y",
+    });
+    await seedDecision(base, {
+      when_context: "M001 execute",
+      scope: "M001-S01",
+      decision: "M001 follow-up",
+      choice: "C",
+      rationale: "z",
+    });
+    await seedDecision(base, {
+      when_context: "M003 plan",
+      scope: "M003",
+      decision: "Use M001 as precedent",
+      choice: "D",
+      rationale: "Mentions M001 outside when_context",
+    });
+
+    const m001 = queryDecisionsFromMemories({ milestoneId: "M001" });
+    assert.equal(m001.length, 2, "two decisions reference M001 in when_context");
+    assert.ok(m001.every((d) => d.when_context.includes("M001")));
+
+    const m002 = queryDecisionsFromMemories({ milestoneId: "M002" });
+    assert.equal(m002.length, 1);
+    assert.equal(m002[0]?.decision, "M002 decision");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories filters by scope (exact match, no prefix collisions)", async () => {
+  const base = makeTmpBase();
+  try {
+    await seedDecision(base, {
+      when_context: "M001 discuss",
+      scope: "M001",
+      decision: "Milestone-level",
+      choice: "A",
+      rationale: "x",
+    });
+    await seedDecision(base, {
+      when_context: "M001 plan",
+      scope: "M001-S01",
+      decision: "Slice-level",
+      choice: "B",
+      rationale: "y",
+    });
+    await seedDecision(base, {
+      when_context: "M001 plan",
+      scope: "M001-S02",
+      decision: "Different slice",
+      choice: "C",
+      rationale: "z",
+    });
+
+    // Exact-scope filter must not match prefix-similar values.
+    const milestoneScope = queryDecisionsFromMemories({ scope: "M001" });
+    assert.equal(milestoneScope.length, 1, "scope=M001 must not match M001-S01 / M001-S02");
+    assert.equal(milestoneScope[0]?.scope, "M001");
+
+    const sliceScope = queryDecisionsFromMemories({ scope: "M001-S01" });
+    assert.equal(sliceScope.length, 1);
+    assert.equal(sliceScope[0]?.scope, "M001-S01");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories matches queryDecisions for combined milestoneId + scope filters", async () => {
+  const base = makeTmpBase();
+  try {
+    await seedDecision(base, {
+      when_context: "M001 discuss",
+      scope: "M001",
+      decision: "A",
+      choice: "1",
+      rationale: "x",
+    });
+    await seedDecision(base, {
+      when_context: "M001 plan",
+      scope: "M001-S01",
+      decision: "B",
+      choice: "2",
+      rationale: "y",
+    });
+    await seedDecision(base, {
+      when_context: "M002 discuss",
+      scope: "M002",
+      decision: "C",
+      choice: "3",
+      rationale: "z",
+    });
+
+    const opts = { milestoneId: "M001", scope: "M001-S01" };
+    const fromDecisions = queryDecisions(opts);
+    const fromMemories = queryDecisionsFromMemories(opts);
+
+    assert.equal(fromDecisions.length, fromMemories.length);
+    assert.equal(fromMemories.length, 1);
+    assert.equal(fromMemories[0]?.id, fromDecisions[0]?.id);
+    assert.equal(fromMemories[0]?.scope, "M001-S01");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("queryDecisionsFromMemories ignores memories without a sourceDecisionId marker", async () => {
+  const base = makeTmpBase();
+  try {
+    // Insert a user-authored memory (no sourceDecisionId) — must not appear in
+    // the decisions-from-memories projection.
+    const { createMemory } = await import("../memory-store.ts");
+    createMemory({
+      category: "architecture",
+      content: "User-authored architecture note, not derived from a decision",
+      scope: "project",
+    });
+
+    await seedDecision(base, {
+      when_context: "M001 discuss",
+      scope: "M001",
+      decision: "Real decision",
+      choice: "A",
+      rationale: "x",
+    });
+
+    const fromMemories = queryDecisionsFromMemories();
+    assert.equal(fromMemories.length, 1, "user-authored memory must not appear as a decision");
+    assert.equal(fromMemories[0]?.decision, "Real decision");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -19,14 +19,15 @@ import {
   insertMilestone,
   _getAdapter,
 } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
 import { claimMilestoneLease } from "../db/milestone-leases.ts";
-import { recordDispatchClaim } from "../db/unit-dispatches.ts";
+import { getLatestForUnit, markRunning, recordDispatchClaim } from "../db/unit-dispatches.ts";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
 import {
   writeLock,
   readCrashLock,
   clearLock,
+  clearStaleWorkerLock,
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
@@ -223,3 +224,86 @@ test("clearLock removes the session_file row for the active worker", (t) => {
   assert.equal(getRuntimeKv("worker", workerId, "session_file"), null,
     "session_file row deleted by clearLock");
 });
+
+test("clearLock marks stale worker crashed when no current-process worker matches", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/stale-session.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  assert.ok(readCrashLock(base), "stale worker is detected before clearLock");
+
+  clearLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), null);
+  assert.equal(readCrashLock(base), null);
+});
+
+test("clearStaleWorkerLock crashes stale worker and cancels latest active dispatch", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+  const claim = recordDispatchClaim({
+    traceId: "t1",
+    workerId,
+    milestoneLeaseToken: lease.token,
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T02",
+    unitType: "hook/codex-review",
+    unitId: "M001/S01/T02",
+  });
+  assert.equal(claim.ok, true);
+  if (!claim.ok) return;
+  markRunning(claim.dispatchId);
+  setRuntimeKv("worker", workerId, "session_file", "/tmp/pi-session-hook.jsonl");
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  assert.ok(readCrashLock(base), "stale worker is detected before cleanup");
+
+  clearStaleWorkerLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  const dispatch = getLatestForUnit("M001/S01/T02");
+  assert.ok(dispatch);
+  assert.equal(dispatch!.status, "canceled");
+  assert.equal(dispatch!.exit_reason, "crash-recovered");
+  assert.equal(getRuntimeKv("worker", workerId, "session_file"), null);
+  assert.equal(readCrashLock(base), null);
+});
+
+test("clearLock marks stale worker crashed and releases held milestone lease", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+  assert.ok(readCrashLock(base), "stale worker is detected before clearLock");
+
+  clearLock(base);
+
+  assert.equal(getAutoWorker(workerId)?.status, "crashed");
+  const leaseRow = _getAdapter()!.prepare(
+    `SELECT status FROM milestone_leases WHERE milestone_id = :m`,
+  ).get({ ":m": "M001" }) as { status: string } | undefined;
+  assert.equal(leaseRow?.status, "released");
+});

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

@@ -98,6 +98,8 @@ function makeMockPi() {
     sendMessage: (...args: unknown[]) => {
       calls.push(args);
     },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
     calls,
   } as any;
 }

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

@@ -0,0 +1,208 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for DB authority over markdown projections.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  closeDatabase,
+  getAllMilestones,
+  getSliceTasks,
+  insertMilestone,
+  insertRequirement,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import { checkMarkdownHierarchyAgainstDb } from "../migration-auto-check.ts";
+import { queryDecisions } from "../context-store.ts";
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import type { Requirement } from "../types.ts";
+
+function makeBase(prefix = "gsd-db-authority-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  rmSync(base, { recursive: true, force: true });
+}
+
+function openProjectDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+function activeRequirement(id: string): Requirement {
+  return {
+    id,
+    class: "functional",
+    status: "active",
+    description: `${id} from DB`,
+    why: "DB authority regression fixture",
+    source: "test",
+    primary_owner: "M999/S01",
+    supporting_slices: "",
+    validation: "derive state",
+    notes: "",
+    full_content: `${id} from DB`,
+    superseded_by: null,
+  };
+}
+
+test("DB authority: PROJECT.md and QUEUE-ORDER projections do not choose runtime milestone", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PROJECT.md"),
+    [
+      "# Projection Project",
+      "",
+      "## Milestone Sequence",
+      "- [ ] M001: Projection Only -- should not become active",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "QUEUE-ORDER.json"),
+    JSON.stringify({ order: ["M001", "M999"], updatedAt: new Date().toISOString() }),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M999", title: "DB Slice", status: "pending", risk: "low", depends: [], demo: "DB demo", sequence: 1 });
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.equal(state.activeMilestone?.id, "M999");
+  assert.equal(state.registry.some((entry) => entry.id === "M001"), false);
+});
+
+test("DB authority: REQUIREMENTS.md and DECISIONS.md projections do not populate DB reads", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(
+    join(base, ".gsd", "REQUIREMENTS.md"),
+    [
+      "# Requirements",
+      "",
+      "## Active",
+      "### R001 - Projection-only requirement",
+      "- Class: functional",
+      "- Status: active",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "DECISIONS.md"),
+    [
+      "# Decisions",
+      "",
+      "| # | When / Context | Scope | Decision | Choice | Rationale | Revisable | Made By |",
+      "|---|----------------|-------|----------|--------|-----------|----------|---------|",
+      "| D001 | Now | global | Projection-only decision | Ignore | DB is authority | Yes | human |",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.deepEqual(state.requirements, {
+    active: 0,
+    validated: 0,
+    deferred: 0,
+    outOfScope: 0,
+    blocked: 0,
+    total: 0,
+  });
+  assert.deepEqual(queryDecisions(), []);
+});
+
+test("DB authority: DB requirements remain canonical when REQUIREMENTS.md disagrees", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(
+    join(base, ".gsd", "REQUIREMENTS.md"),
+    [
+      "# Requirements",
+      "",
+      "## Active",
+      "### R999 - Projection-only requirement",
+      "- Class: functional",
+      "- Status: active",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  insertMilestone({ id: "M999", title: "DB Milestone", status: "active" });
+  insertRequirement(activeRequirement("R001"));
+
+  invalidateStateCache();
+  const state = await deriveStateFromDb(base);
+
+  assert.ok(state.requirements);
+  assert.equal(state.requirements.active, 1);
+  assert.equal(state.requirements.total, 1);
+});
+
+test("explicit markdown import remains opt-in and is not run by startup mismatch check", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Imported Explicitly",
+      "",
+      "**Vision:** Explicit recovery import only",
+      "",
+      "## Slices",
+      "- [ ] **S01: Slice** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Slice",
+      "",
+      "**Goal:** prove explicit import",
+      "",
+      "## Tasks",
+      "- [ ] **T01: Task** `est:5m`",
+      "",
+    ].join("\n"),
+  );
+
+  openProjectDb(base);
+  const check = await checkMarkdownHierarchyAgainstDb(base);
+  assert.equal(check.action, "recovery-required");
+  assert.equal(getAllMilestones().length, 0, "startup mismatch check must not import markdown");
+
+  const imported = migrateHierarchyToDb(base);
+  assert.deepEqual(imported, { milestones: 1, slices: 1, tasks: 1 });
+  assert.equal(getAllMilestones().length, 1);
+  assert.equal(getSliceTasks("M001", "S01").length, 1);
+});

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

@@ -27,6 +27,7 @@ import {
   saveArtifactToDb,
   extractDeferredSliceRef,
 } from '../db-writer.ts';
+import { getAllDecisionsFromMemories } from '../context-store.ts';
 import type { Decision, Requirement } from '../types.ts';
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -326,11 +327,14 @@ describe('db-writer', () => {
 
       assert.deepStrictEqual(result.id, 'D001', 'saveDecisionToDb returns D001 as first ID');
 
-      // Verify DB state
-      const dbDecision = getDecisionById('D001');
-      assert.ok(!!dbDecision, 'decision exists in DB after save');
-      assert.deepStrictEqual(dbDecision?.scope, 'arch', 'DB decision has correct scope');
-      assert.deepStrictEqual(dbDecision?.choice, 'Option A', 'DB decision has correct choice');
+      // ADR-013 Stage 3: decisions land in memories, not the legacy table.
+      const memoryDecisions = getAllDecisionsFromMemories();
+      assert.equal(memoryDecisions.length, 1, 'one memory row exists after save');
+      const memDecision = memoryDecisions[0];
+      assert.ok(memDecision, 'memory decision exists after save');
+      assert.equal(memDecision.id, 'D001');
+      assert.equal(memDecision.scope, 'arch', 'memory decision has correct scope');
+      assert.equal(memDecision.choice, 'Option A', 'memory decision has correct choice');
 
       // Verify markdown file was written
       const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
@@ -394,10 +398,11 @@ describe('db-writer', () => {
         assert.match(id, /^D\d{3}$/, `ID ${id} should match D### pattern`);
       }
 
-      // Verify all 5 exist in DB
+      // ADR-013 Stage 3: verify all 5 exist in the memories table (decisions
+      // table receives no writes from saveDecisionToDb post-cutover).
+      const memoryIds = new Set(getAllDecisionsFromMemories().map((d) => d.id));
       for (const id of ids) {
-        const row = getDecisionById(id);
-        assert.ok(row, `Decision ${id} should exist in DB`);
+        assert.ok(memoryIds.has(id), `Decision ${id} should exist in memories`);
       }
     } finally {
       closeDatabase();