gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.d8826a445

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

@@ -1,7 +1,7 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-// ensureDbOpen — Tests that the lazy DB opener creates + migrates the database
-// when .gsd/ exists with Markdown content but no gsd.db file.
+// ensureDbOpen — Tests that the lazy DB opener creates/opens the authoritative
+// database without implicitly importing markdown projections.
 //
 // This covers the bug where interactive (non-auto) sessions got
 // "GSD database is not available" because ensureDbOpen only opened
@@ -11,7 +11,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs';
 import { createRequire } from 'node:module';
-import { closeDatabase, isDbAvailable, getDecisionById, _getAdapter } from '../gsd-db.ts';
+import { closeDatabase, isDbAvailable, getDecisionById, SCHEMA_VERSION, _getAdapter } from '../gsd-db.ts';
 
 const _require = createRequire(import.meta.url);
 
@@ -284,11 +284,11 @@ function createLegacyV15Db(dbPath: string): void {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// ensureDbOpen creates DB + migrates when .gsd/ has Markdown
+// ensureDbOpen creates DB without implicit Markdown migration
 // ═══════════════════════════════════════════════════════════════════════════
 
 describe('ensure-db-open', () => {
-  test('ensureDbOpen: creates DB from Markdown', async () => {
+  test('ensureDbOpen: creates empty DB without importing Markdown', async () => {
     const tmpDir = makeTmpDir();
     const gsdDir = path.join(tmpDir, '.gsd');
     fs.mkdirSync(gsdDir, { recursive: true });
@@ -319,17 +319,12 @@ describe('ensure-db-open', () => {
 
       const result = await ensureDbOpen();
 
-      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ has Markdown');
+      assert.ok(result === true, 'ensureDbOpen should return true when .gsd/ exists');
       assert.ok(fs.existsSync(dbPath), 'DB file should be created after ensureDbOpen');
       assert.ok(isDbAvailable(), 'DB should be available after ensureDbOpen');
 
-      // Verify that Markdown migration actually ran
       const decision = getDecisionById('D001');
-      assert.ok(decision !== null, 'D001 should be migrated from DECISIONS.md');
-      if (decision) {
-        assert.deepStrictEqual(decision.scope, 'architecture', 'Migrated decision scope should match');
-        assert.deepStrictEqual(decision.choice, 'SQLite', 'Migrated decision choice should match');
-      }
+      assert.equal(decision, null, 'D001 should not be imported from DECISIONS.md without explicit migration');
     } finally {
       process.cwd = origCwd;
       closeDatabase();
@@ -360,7 +355,7 @@ describe('ensure-db-open', () => {
       assert.ok(result === true, 'ensureDbOpen should honor explicit basePath');
       assert.equal(process.cwd(), originalCwd, 'ensureDbOpen should not mutate process.cwd');
       assert.ok(isDbAvailable(), 'DB should be available after explicit open');
-      assert.ok(getDecisionById('D777') !== null, 'explicit basePath DB should be opened');
+      assert.equal(getDecisionById('D777'), null, 'explicit basePath should not import DECISIONS.md');
     } finally {
       closeDatabase();
       cleanupDir(tmpDir);
@@ -389,7 +384,7 @@ describe('ensure-db-open', () => {
       assert.ok(db, 'adapter should be available after ensureDbOpen');
       assert.equal(
         db.prepare('SELECT MAX(version) as version FROM schema_version').get()?.version,
-        22,
+        SCHEMA_VERSION,
         'legacy DB should migrate to current schema version',
       );
 
@@ -519,9 +514,9 @@ describe('ensure-db-open', () => {
     try {
       const { ensureDbOpen } = await import('../bootstrap/dynamic-tools.ts');
       assert.equal(await ensureDbOpen(firstDir), true);
-      assert.ok(getDecisionById('D101') !== null, 'first DB should be active');
+      assert.equal(getDecisionById('D101'), null, 'first DB should not import DECISIONS.md');
       assert.equal(await ensureDbOpen(secondDir), true);
-      assert.ok(getDecisionById('D202') !== null, 'second DB should be active after switch');
+      assert.equal(getDecisionById('D202'), null, 'second DB should not import DECISIONS.md');
       assert.equal(getDecisionById('D101'), null, 'first DB should no longer be active after switch');
     } finally {
       closeDatabase();

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -19,6 +19,7 @@ import {
   claimEscalationOverride,
   findUnappliedEscalationOverride,
   listEscalationArtifacts,
+  SCHEMA_VERSION,
   _getAdapter,
 } from "../gsd-db.ts";
 import {
@@ -348,7 +349,7 @@ test("ADR-011 P2: schema v20 fresh DB has all escalation columns on tasks + sour
   assert.ok(decCols.includes("source"), "decisions table must have source column");
 
   const version = adapter.prepare("SELECT MAX(version) as v FROM schema_version").get();
-  assert.equal(version?.["v"], 22);
+  assert.equal(version?.["v"], SCHEMA_VERSION);
 });
 
 test("ADR-011 P2: findUnappliedEscalationOverride returns null when escalation_pending=1 (still pending)", (t) => {

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -0,0 +1,193 @@
+/**
+ * GSD-2 / guided-flow — regression tests for Gate 1b orphan discrimination
+ *
+ * Gate 1b in checkAutoStartAfterDiscuss discriminates between two "queued" states:
+ *   (a) plan-blocked: discuss completed (CONTEXT.md on disk), but gsd_plan_milestone
+ *       was hard-blocked by the depth-verification gate.  DB row stuck at "queued".
+ *       → emit recovery hint directing the LLM to retry gsd_plan_milestone.
+ *   (b) discuss-incomplete: discuss did not finish, no CONTEXT.md, DB row "queued".
+ *       → silent block (no recovery hint).
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  checkAutoStartAfterDiscuss,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+} from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+
+// ─── Harness ───────────────────────────────────────────────────────────────
+
+interface MockCapture {
+  notifies: Array<{ msg: string; level: string }>;
+  messages: Array<{ payload: any; options: any }>;
+}
+
+function mkCapture(): MockCapture {
+  return { notifies: [], messages: [] };
+}
+
+function mkCtx(cap: MockCapture): any {
+  return {
+    ui: {
+      notify: (msg: string, level: string) => {
+        cap.notifies.push({ msg, level });
+      },
+    },
+  };
+}
+
+function mkPi(cap: MockCapture): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+/**
+ * Create a minimal temp tree with a .gsd/milestones/M001 directory.
+ */
+function mkBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
+  let base: string;
+  let cap: MockCapture;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    drainLogs(); // discard noise from prior tests
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    clearPendingAutoStart();
+    if (base) {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("plan-blocked: CONTEXT.md present + DB row queued → returns false + recovery hint emitted", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+
+    // DB row exists with status "queued" (plan_milestone was blocked)
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
+
+    // CONTEXT.md on disk (discuss phase completed)
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+      "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+    );
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    // Must return false — auto-start should not proceed
+    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false (plan still blocked)");
+
+    // Recovery hint must be sent to the LLM
+    assert.equal(
+      cap.messages.length,
+      1,
+      "exactly one sendMessage call expected for the recovery hint",
+    );
+    assert.equal(
+      cap.messages[0].payload.customType,
+      "gsd-plan-milestone-blocked-recovery",
+      "recovery message must have customType gsd-plan-milestone-blocked-recovery",
+    );
+    assert.equal(
+      cap.messages[0].options.triggerTurn,
+      true,
+      "recovery message must set triggerTurn: true",
+    );
+    assert.match(
+      cap.messages[0].payload.content,
+      /gsd_plan_milestone/,
+      "recovery message content must mention gsd_plan_milestone",
+    );
+
+    // User must be notified via ctx.ui.notify
+    assert.ok(
+      cap.notifies.some((n) => n.level === "warning" && /queued/.test(n.msg)),
+      "user must be notified with a warning about the queued state",
+    );
+
+    // logWarning must have recorded the Gate 1b event
+    const logs = drainLogs();
+    const gate1bLog = logs.find(
+      (e) => e.component === "guided" && /Gate 1b/.test(e.message),
+    );
+    assert.ok(gate1bLog, "Gate 1b warning must be logged via logWarning");
+  });
+
+  test("discuss-incomplete: no CONTEXT.md + DB row queued → returns false silently (no recovery hint)", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+
+    // DB row exists with status "queued", but NO CONTEXT.md on disk
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
+
+    // No CONTEXT.md written — discuss phase is incomplete
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    drainLogs(); // clear any noise before the call
+
+    const result = checkAutoStartAfterDiscuss();
+
+    // Must return false — silent block
+    assert.equal(result, false, "checkAutoStartAfterDiscuss must return false when discuss is incomplete");
+
+    // No recovery hint — Gate 1 blocks before Gate 1b is reached
+    assert.equal(
+      cap.messages.length,
+      0,
+      "no sendMessage calls expected when CONTEXT.md is absent",
+    );
+    assert.equal(
+      cap.notifies.length,
+      0,
+      "no user notifications expected for discuss-incomplete case",
+    );
+
+    // No Gate 1b log entry
+    const logs = drainLogs();
+    const gate1bLog = logs.find(
+      (e) => e.component === "guided" && /Gate 1b/.test(e.message),
+    );
+    assert.equal(gate1bLog, undefined, "Gate 1b must not log when CONTEXT.md is absent");
+  });
+});

package/src/resources/extensions/gsd/tests/gate-1b-recovery-bound-corrections.test.ts

@@ -0,0 +1,246 @@
+// GSD-2 + Gate 1b recovery bound corrections — regression tests for the two bugs
+// found in peer review of the H1 fix (commit f0e1d42a2):
+//   1. Escalation message must describe /gsd (counter reset) AND /gsd-debug (diagnose).
+//   2. planBlockedRecoveryCount must NOT increment when pi.sendMessage throws.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  checkAutoStartAfterDiscuss,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  _getPendingAutoStart,
+} from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+
+// ─── Harness ───────────────────────────────────────────────────────────────
+
+interface MockCapture {
+  notifies: Array<{ msg: string; level: string }>;
+  messages: Array<{ payload: any; options: any }>;
+}
+
+function mkCapture(): MockCapture {
+  return { notifies: [], messages: [] };
+}
+
+function mkCtx(cap: MockCapture): any {
+  return {
+    ui: {
+      notify: (msg: string, level: string) => {
+        cap.notifies.push({ msg, level });
+      },
+    },
+  };
+}
+
+/** Returns a pi stub whose sendMessage throws on the first call, succeeds after. */
+function mkPiThrowOnce(cap: MockCapture): any {
+  let callCount = 0;
+  return {
+    sendMessage: (payload: any, options: any) => {
+      callCount += 1;
+      if (callCount === 1) {
+        throw new Error("transient network error");
+      }
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkPi(cap: MockCapture): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-corrections-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Corrections Test\n\nContext written by discuss phase.\n",
+  );
+  return base;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("Gate 1b recovery bound corrections", () => {
+  let base: string;
+  let cap: MockCapture;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    drainLogs();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    clearPendingAutoStart();
+    if (base) {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  // ── Fix 1: escalation message ──────────────────────────────────────────
+
+  test("escalation message describes /gsd for reset AND /gsd-debug for diagnosis", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // Exhaust the recovery budget (MAX = 3)
+    checkAutoStartAfterDiscuss(); // count → 1
+    checkAutoStartAfterDiscuss(); // count → 2
+    checkAutoStartAfterDiscuss(); // count → 3
+
+    cap.notifies = [];
+    drainLogs();
+
+    // This call hits the cap and must escalate
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "escalation call must return false");
+
+    const errorNotify = cap.notifies.find((n) => n.level === "error");
+    assert.ok(errorNotify, "escalation must emit a notify with level 'error'");
+
+    // Must mention /gsd with reset semantics
+    assert.match(
+      errorNotify.msg,
+      /\/gsd\b/,
+      "escalation message must reference /gsd (the command that resets the counter)",
+    );
+    assert.match(
+      errorNotify.msg,
+      /reset/i,
+      "escalation message must use the word 'reset' so users know /gsd resets the counter",
+    );
+
+    // Must also mention /gsd-debug
+    assert.match(
+      errorNotify.msg,
+      /\/gsd-debug/i,
+      "escalation message must also reference /gsd-debug for diagnosis",
+    );
+
+    // Must NOT suggest /gsd-debug alone as the sole remediation
+    assert.doesNotMatch(
+      errorNotify.msg,
+      /^[^/]*\/gsd-debug[^/]*$/,
+      "escalation message must not mention /gsd-debug as the only option",
+    );
+  });
+
+  // ── Fix 2: counter ordering ────────────────────────────────────────────
+
+  test("counter stays at 0 when sendMessage throws on the first call", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPiThrowOnce(cap),
+    });
+
+    // First call: sendMessage throws — counter must NOT increment
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "must return false even when sendMessage throws");
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry must still exist after a failed sendMessage");
+    assert.equal(
+      entry.planBlockedRecoveryCount,
+      0,
+      "counter must remain 0 when sendMessage throws — no budget burned by transient failure",
+    );
+  });
+
+  test("counter increments to 1 on the second call when first sendMessage threw", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPiThrowOnce(cap),
+    });
+
+    checkAutoStartAfterDiscuss(); // sendMessage throws → count stays 0
+
+    const entryAfterThrow = _getPendingAutoStart(base);
+    assert.equal(entryAfterThrow!.planBlockedRecoveryCount, 0, "count is 0 after throw");
+
+    checkAutoStartAfterDiscuss(); // sendMessage succeeds → count becomes 1
+    assert.equal(cap.messages.length, 1, "second call must produce one successful sendMessage");
+
+    const entryAfterSuccess = _getPendingAutoStart(base);
+    assert.equal(
+      entryAfterSuccess!.planBlockedRecoveryCount,
+      1,
+      "counter must be 1 after first successful dispatch",
+    );
+  });
+
+  test("3 successful sendMessage calls exhaust the budget; 4th emits escalation notify", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // Three successful recoveries
+    checkAutoStartAfterDiscuss(); // count → 1
+    checkAutoStartAfterDiscuss(); // count → 2
+    checkAutoStartAfterDiscuss(); // count → 3
+
+    const entry = _getPendingAutoStart(base);
+    assert.equal(entry!.planBlockedRecoveryCount, 3, "counter must be 3 after three successes");
+    assert.equal(cap.messages.length, 3, "three sendMessage calls must have occurred");
+
+    // Fourth call hits the cap
+    cap.notifies = [];
+    cap.messages = [];
+    const resultAtCap = checkAutoStartAfterDiscuss();
+    assert.equal(resultAtCap, false, "4th call must return false");
+    assert.equal(cap.messages.length, 0, "4th call must NOT call sendMessage");
+    const errorNotify = cap.notifies.find((n) => n.level === "error");
+    assert.ok(errorNotify, "4th call must emit escalation notify with level 'error'");
+  });
+});