gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

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

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

@@ -0,0 +1,218 @@
+// GSD-2 + Gate 1b recovery counter bound — regression tests for H1 fix (#5012)
+//
+// Verifies that checkAutoStartAfterDiscuss stops emitting plan-blocked recovery
+// hints (with triggerTurn:true) after MAX_PLAN_BLOCKED_RECOVERIES attempts and
+// instead escalates to the user via ctx.ui.notify("error"), breaking the loop.
+
+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 });
+      },
+    },
+  };
+}
+
+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-bound-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Bound Test\n\nContext written by discuss phase.\n",
+  );
+  return base;
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("Gate 1b recovery bound (H1)", () => {
+  let base: string;
+  let cap: MockCapture;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    drainLogs();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    clearPendingAutoStart();
+    if (base) {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("first N-1 invocations increment counter and emit recovery with triggerTurn:true", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Bound Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // MAX_PLAN_BLOCKED_RECOVERIES = 3; first two calls should emit recovery
+    const resultOne = checkAutoStartAfterDiscuss();
+    assert.equal(resultOne, false, "call 1: must return false");
+    assert.equal(cap.messages.length, 1, "call 1: exactly one sendMessage");
+    assert.equal(cap.messages[0].options.triggerTurn, true, "call 1: triggerTurn must be true");
+    assert.equal(cap.messages[0].payload.customType, "gsd-plan-milestone-blocked-recovery");
+
+    const entryAfterOne = _getPendingAutoStart(base);
+    assert.ok(entryAfterOne, "entry must still exist after call 1");
+    assert.equal(entryAfterOne.planBlockedRecoveryCount, 1, "counter must be 1 after call 1");
+
+    const resultTwo = checkAutoStartAfterDiscuss();
+    assert.equal(resultTwo, false, "call 2: must return false");
+    assert.equal(cap.messages.length, 2, "call 2: second sendMessage emitted");
+    assert.equal(cap.messages[1].options.triggerTurn, true, "call 2: triggerTurn must be true");
+
+    const entryAfterTwo = _getPendingAutoStart(base);
+    assert.ok(entryAfterTwo, "entry must still exist after call 2");
+    assert.equal(entryAfterTwo.planBlockedRecoveryCount, 2, "counter must be 2 after call 2");
+  });
+
+  test("Nth invocation (at MAX_PLAN_BLOCKED_RECOVERIES) escalates via notify(error) without sendMessage(triggerTurn)", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Bound Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // Exhaust the recovery budget (MAX = 3): call 3 times to reach the limit
+    checkAutoStartAfterDiscuss(); // count → 1
+    checkAutoStartAfterDiscuss(); // count → 2
+    checkAutoStartAfterDiscuss(); // count → 3
+
+    // At count = 3 the counter equals MAX so the next call must escalate
+    cap.messages = [];
+    cap.notifies = [];
+    drainLogs();
+
+    const resultAtLimit = checkAutoStartAfterDiscuss();
+    assert.equal(resultAtLimit, false, "at-limit call: must return false");
+
+    // Must NOT trigger a new LLM turn
+    assert.equal(
+      cap.messages.length,
+      0,
+      "at-limit call: sendMessage must NOT be called (loop must stop)",
+    );
+    const triggerMessages = cap.messages.filter((m) => m.options?.triggerTurn);
+    assert.equal(triggerMessages.length, 0, "no triggerTurn message after limit");
+
+    // Must escalate to user via notify("error")
+    const errorNotify = cap.notifies.find((n) => n.level === "error");
+    assert.ok(errorNotify, "at-limit call: ctx.ui.notify('error') must be called");
+    assert.match(
+      errorNotify.msg,
+      /gsd-debug/i,
+      "error notification must direct user to run /gsd-debug",
+    );
+    assert.match(
+      errorNotify.msg,
+      /M001/,
+      "error notification must include the milestone ID",
+    );
+
+    // Confirm the log records the escalation
+    const logs = drainLogs();
+    const escalationLog = logs.find(
+      (e) => e.component === "guided" && /Gate 1b/.test(e.message) && /escalat/.test(e.message),
+    );
+    assert.ok(escalationLog, "escalation must be logged via logWarning");
+  });
+
+  test("after clearPendingAutoStart + setPendingAutoStart the counter is reset to 0", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Bound Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // Advance counter to 2
+    checkAutoStartAfterDiscuss();
+    checkAutoStartAfterDiscuss();
+
+    const entryBefore = _getPendingAutoStart(base);
+    assert.ok(entryBefore, "entry must exist");
+    assert.equal(entryBefore.planBlockedRecoveryCount, 2, "counter must be 2 before reset");
+
+    // Simulate user retry: clear then re-set
+    clearPendingAutoStart(base);
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const entryAfter = _getPendingAutoStart(base);
+    assert.ok(entryAfter, "entry must exist after re-set");
+    assert.equal(entryAfter.planBlockedRecoveryCount, 0, "counter must be 0 after re-set (fresh entry)");
+
+    // Verify first call after reset emits recovery, not escalation
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "first call after reset must return false");
+    assert.equal(cap.messages.length, 1, "recovery hint must be emitted after reset");
+    assert.equal(cap.messages[0].options.triggerTurn, true, "triggerTurn must be true after reset");
+  });
+});

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

@@ -0,0 +1,117 @@
+// GSD-2 + gsd-db failed-open restore: previous workspace connection survives a failed openDatabaseByWorkspace
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  openDatabase,
+  openDatabaseByWorkspace,
+  closeDatabase,
+  isDbAvailable,
+  getDbPath,
+  _getDbCache,
+} from "../gsd-db.ts";
+import { createWorkspace } from "../workspace.ts";
+import type { GsdWorkspace } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(base: string): string {
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("openDatabaseByWorkspace: restores previous connection on failure", () => {
+  let tmpA: string;
+  let tmpB: string;
+
+  beforeEach(() => {
+    tmpA = mkdtempSync(join(tmpdir(), "gsd-db-restore-a-"));
+    tmpB = mkdtempSync(join(tmpdir(), "gsd-db-restore-b-"));
+    makeProjectDir(tmpA);
+    makeProjectDir(tmpB);
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpA, { recursive: true, force: true });
+    rmSync(tmpB, { recursive: true, force: true });
+  });
+
+  test("previous workspace connection stays active after failed switch to non-existent path", () => {
+    // Open workspace A successfully
+    const wsA = createWorkspace(tmpA);
+    const openedA = openDatabaseByWorkspace(wsA);
+    assert.ok(openedA, "opening workspace A should succeed");
+    assert.ok(isDbAvailable(), "DB should be available after opening A");
+
+    const pathAfterA = getDbPath();
+    assert.ok(pathAfterA, "should have a DB path after opening A");
+
+    // Attempt to open a workspace pointing to a completely non-existent directory
+    // ("/does-not-exist-gsd-test" cannot be created), which will cause openDatabase to throw.
+    const fakeWs = {
+      identityKey: "fake-key-that-does-not-exist",
+      projectRoot: "/does-not-exist-gsd-test-ws-restore",
+      worktreeRoot: null,
+      mode: "project" as const,
+      contract: {
+        projectRoot: "/does-not-exist-gsd-test-ws-restore",
+        workRoot: "/does-not-exist-gsd-test-ws-restore",
+        projectGsd: "/does-not-exist-gsd-test-ws-restore/.gsd",
+        projectDb: "/does-not-exist-gsd-test-ws-restore/.gsd/does-not-exist.db",
+        worktreeGsd: null,
+        isWorktree: false,
+      },
+      lockRoot: "/does-not-exist-gsd-test-ws-restore",
+    } satisfies GsdWorkspace;
+
+    // This should throw because the path is invalid
+    assert.throws(
+      () => openDatabaseByWorkspace(fakeWs),
+      (err: Error) => err instanceof Error,
+    );
+
+    // After the failure, the previous workspace A connection must be restored
+    assert.ok(isDbAvailable(), "DB must still be available (workspace A connection restored)");
+    const pathAfterFailure = getDbPath();
+    assert.equal(pathAfterFailure, pathAfterA, "DB path must match workspace A's path after failed switch");
+  });
+
+  test("cache still contains workspace A entry after failed switch", () => {
+    const wsA = createWorkspace(tmpA);
+    openDatabaseByWorkspace(wsA);
+
+    const fakeWs = {
+      identityKey: "fake-key-cache-test",
+      projectRoot: "/does-not-exist-gsd-cache-test",
+      worktreeRoot: null,
+      mode: "project" as const,
+      contract: {
+        projectRoot: "/does-not-exist-gsd-cache-test",
+        workRoot: "/does-not-exist-gsd-cache-test",
+        projectGsd: "/does-not-exist-gsd-cache-test/.gsd",
+        projectDb: "/does-not-exist-gsd-cache-test/.gsd/no.db",
+        worktreeGsd: null,
+        isWorktree: false,
+      },
+      lockRoot: "/does-not-exist-gsd-cache-test",
+    } satisfies GsdWorkspace;
+
+    assert.throws(() => openDatabaseByWorkspace(fakeWs));
+
+    const cache = _getDbCache();
+    assert.ok(cache.has(wsA.identityKey), "cache must retain workspace A's entry after failed switch");
+
+    // Workspace A's connection is back as the active connection; switching back
+    // should succeed from cache (cache hit path) without re-opening.
+    const reopened = openDatabaseByWorkspace(wsA);
+    assert.ok(reopened, "switching back to workspace A should succeed from cache");
+    assert.ok(isDbAvailable(), "DB should be available after re-activating A");
+  });
+});