gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -0,0 +1,388 @@
+/**
+ * GSD-2 / guided-flow — regression tests for #4573
+ *
+ * Covers two recovery paths:
+ *   - maybeHandleReadyPhraseWithoutFiles: nudge when LLM emits
+ *     "Milestone M001 ready." without writing CONTEXT.md / ROADMAP.md
+ *   - maybeHandleEmptyIntentTurn: nudge when LLM narrates intent but
+ *     emits no tool-use blocks
+ */
+
+import { describe, test, beforeEach } 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 {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  maybeHandleReadyPhraseWithoutFiles,
+  maybeHandleEmptyIntentTurn,
+  resetEmptyTurnCounter,
+} from "../guided-flow.ts";
+
+// ─── Test 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, opts: { sendThrows?: boolean } = {}): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      if (opts.sendThrows) throw new Error("send failed");
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4573-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+function assistantMsg(text: string, opts: { toolUse?: boolean } = {}): any {
+  const content: any[] = [];
+  if (text) content.push({ type: "text", text });
+  if (opts.toolUse) content.push({ type: "tool_use", name: "whatever", input: {} });
+  return { role: "assistant", content };
+}
+
+// ─── ready-phrase recovery (Layer 2) ───────────────────────────────────────
+
+describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+    resetEmptyTurnCounter();
+  });
+
+  test("no pending entry → no-op", () => {
+    const cap = mkCapture();
+    const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+    const handled = maybeHandleReadyPhraseWithoutFiles(event);
+    assert.equal(handled, false);
+    assert.equal(cap.messages.length, 0);
+  });
+
+  test("pending entry, ready phrase, no files → notify + sendMessage", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1);
+      assert.equal(cap.messages[0].payload.customType, "gsd-ready-no-files");
+      assert.equal(cap.messages[0].options.triggerTurn, true);
+      assert.ok(
+        cap.notifies.some((n) => /rejected/.test(n.msg)),
+        "user notified about rejection",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("retry cap — after MAX_READY_REJECTS the nudge stops and entry clears", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+
+      const first = maybeHandleReadyPhraseWithoutFiles(event);
+      const second = maybeHandleReadyPhraseWithoutFiles(event);
+      const third = maybeHandleReadyPhraseWithoutFiles(event); // > MAX
+
+      assert.equal(first, true);
+      assert.equal(second, true);
+      assert.equal(third, true); // still returns true (handled via give-up)
+      assert.equal(cap.messages.length, 2, "only 2 nudges sent (MAX_READY_REJECTS=2)");
+      assert.ok(
+        cap.notifies.some((n) => /Stopping auto-nudge/.test(n.msg)),
+        "gives up with error notify",
+      );
+
+      // After giving up, a fresh re-entry starts clean
+      const fourth = maybeHandleReadyPhraseWithoutFiles(event);
+      assert.equal(fourth, false, "pending entry was cleared — nothing to handle");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("files present → no nudge (happy path already fired)", () => {
+    const base = mkBase();
+    try {
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# ctx");
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("last message lacks ready phrase → no-op", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Let me think about the slices first.")],
+      });
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("fresh entry after give-up resets counter", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      // First cycle: exhaust cap
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+      maybeHandleReadyPhraseWithoutFiles(event);
+      maybeHandleReadyPhraseWithoutFiles(event);
+      maybeHandleReadyPhraseWithoutFiles(event); // clears entry
+
+      // New /gsd run — re-seeds entry; counter must be 0 again
+      cap.messages.length = 0;
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles(event);
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1, "fresh entry fires nudge again");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+});
+
+// ─── empty-turn recovery (Layer 3) ────────────────────────────────────────
+
+describe("#4573 maybeHandleEmptyIntentTurn", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+    resetEmptyTurnCounter();
+  });
+
+  test("no pending entry + isAuto false → no-op (interactive discuss is user-driven)", () => {
+    const event = { messages: [assistantMsg("I'll write the CONTEXT.md now.")] };
+    const handled = maybeHandleEmptyIntentTurn(event, false);
+    assert.equal(handled, false);
+  });
+
+  test("text-only turn WITHOUT commit phrase → not flagged (legitimate text)", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Here is the roadmap preview — three slices.")] },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("text-only turn ending in question → treated as user-handoff, not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Ready to write, or want to adjust?")] },
+        false,
+      );
+      assert.equal(handled, false);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("commit-intent phrase WITHOUT tool call → nudge fires", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("I'll now write the CONTEXT.md file.")] },
+        false,
+      );
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1);
+      assert.equal(cap.messages[0].payload.customType, "gsd-empty-turn-recovery");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("commit-intent WITH tool-use block → not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("I'll write the file now.", { toolUse: true })] },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("ready phrase is NOT treated as empty-turn (handled by other recovery path)", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Milestone M001 ready.")] },
+        false,
+      );
+      assert.equal(handled, false);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("empty-turn retry cap — stops after MAX_EMPTY_TURN_RETRIES", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("I'll write the CONTEXT.md file.")] };
+
+      maybeHandleEmptyIntentTurn(event, false); // 1
+      maybeHandleEmptyIntentTurn(event, false); // 2
+      const third = maybeHandleEmptyIntentTurn(event, false); // > cap
+
+      assert.equal(cap.messages.length, 2, "only 2 nudges sent");
+      assert.equal(third, false, "after cap, no further injection");
+      assert.ok(
+        cap.notifies.some((n) => /Stopping auto-nudge/.test(n.msg)),
+        "user notified of give-up",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("resetEmptyTurnCounter clears state after a successful tool-use turn", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("I'll write the CONTEXT.md file.")] };
+
+      maybeHandleEmptyIntentTurn(event, false); // 1
+      maybeHandleEmptyIntentTurn(event, false); // 2 — at cap
+      resetEmptyTurnCounter(); // simulate a successful tool-use turn in between
+
+      cap.messages.length = 0;
+      const after = maybeHandleEmptyIntentTurn(event, false);
+      assert.equal(after, true, "counter reset — nudge fires again");
+      assert.equal(cap.messages.length, 1);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/reassess-default-optin.test.ts

@@ -0,0 +1,132 @@
+// GSD-2 — ADR-003 §4 behavior contract: reassess-roadmap is opt-in.
+// Companion to (eventually replacing) the source-grep assertions in
+// token-profile.test.ts. This file verifies the dispatch rule's guard
+// behavior directly rather than inspecting source text.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import {
+  DISPATCH_RULES,
+  setReassessmentCheckerForTest,
+  type DispatchAction,
+  type DispatchContext,
+} from "../auto-dispatch.ts";
+import { resolveProfileDefaults } from "../preferences-models.ts";
+import type { GSDState } from "../types.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const REASSESS_RULE_NAME = "reassess-roadmap (post-completion)";
+
+function makeIsolatedBase(): string {
+  const base = join(tmpdir(), `gsd-reassess-default-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function makeCtx(prefs: GSDPreferences | undefined, basePath: string): DispatchContext {
+  const state: GSDState = {
+    phase: "executing",
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: { id: "S01", title: "First" },
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+  };
+  return { basePath, mid: "M001", midTitle: "Test", state, prefs };
+}
+
+function reassessRule() {
+  const rule = DISPATCH_RULES.find(r => r.name === REASSESS_RULE_NAME);
+  assert.ok(rule, `dispatch rule "${REASSESS_RULE_NAME}" must exist`);
+  return rule!;
+}
+
+const guardCases: Array<{ name: string; prefs: GSDPreferences | undefined; message?: string }> = [
+  {
+    name: "prefs is undefined (new default)",
+    prefs: undefined,
+    message: "default behavior must be opt-in — no prefs means no reassess dispatch",
+  },
+  {
+    name: "prefs.phases is undefined",
+    prefs: {} as GSDPreferences,
+  },
+  {
+    name: "phases.reassess_after_slice is explicitly false",
+    prefs: { phases: { reassess_after_slice: false } } as unknown as GSDPreferences,
+  },
+  {
+    name: "phases.skip_reassess is true (short-circuit guard preserved)",
+    prefs: { phases: { skip_reassess: true, reassess_after_slice: true } } as unknown as GSDPreferences,
+    message: "skip_reassess must win over reassess_after_slice",
+  },
+];
+
+for (const { name, prefs, message } of guardCases) {
+  test(`ADR-003 §4: reassess-roadmap does NOT dispatch when ${name}`, async (t) => {
+    const base = makeIsolatedBase();
+    t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+    let checkerCalls = 0;
+    const restoreChecker = setReassessmentCheckerForTest(async () => {
+      checkerCalls++;
+      return { sliceId: "S01" };
+    });
+    t.after(restoreChecker);
+
+    const result = await reassessRule().match(makeCtx(prefs, base));
+    assert.strictEqual(result, null, message);
+    assert.strictEqual(checkerCalls, 0, "preference guards must short-circuit before reassessment detection");
+  });
+}
+
+test("ADR-003 §4: reassess-roadmap opt-in path dispatches after reassessment detection", async (t) => {
+  const base = makeIsolatedBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  const checkerCalls: Array<{ basePath: string; mid: string; activeSliceId: string | undefined }> = [];
+  const restoreChecker = setReassessmentCheckerForTest(async (checkerBase, checkerMid, state) => {
+    checkerCalls.push({ basePath: checkerBase, mid: checkerMid, activeSliceId: state.activeSlice?.id });
+    return { sliceId: "S01" };
+  });
+  t.after(restoreChecker);
+
+  const prefs = { phases: { reassess_after_slice: true } } as unknown as GSDPreferences;
+  const result: DispatchAction | null = await reassessRule().match(makeCtx(prefs, base));
+
+  assert.deepStrictEqual(checkerCalls, [{ basePath: base, mid: "M001", activeSliceId: "S01" }]);
+  assert.ok(result, "opt-in path should return a dispatch action when reassessment is needed");
+  assert.strictEqual(result.action, "dispatch");
+  if (result.action !== "dispatch") assert.fail("expected dispatch action");
+  assert.strictEqual(result.unitType, "reassess-roadmap");
+  assert.strictEqual(result.unitId, "M001/S01");
+  assert.match(result.prompt, /reassess/i);
+});
+
+test("ADR-003 §4: burn-max profile opts into dedicated reassess-roadmap dispatch", () => {
+  const defaults = resolveProfileDefaults("burn-max");
+  assert.strictEqual(defaults.phases?.reassess_after_slice, true);
+  assert.strictEqual(defaults.phases?.skip_reassess, false);
+});
+
+test("ADR-003 §4: plan-slice prompt and MCP tool agree on reassess sliceChanges shape", () => {
+  const planSlicePrompt = readFileSync(new URL("../prompts/plan-slice.md", import.meta.url), "utf8");
+  assert.match(planSlicePrompt, /gsd_reassess_roadmap/);
+  assert.match(planSlicePrompt, /sliceChanges\.modified/);
+  assert.match(planSlicePrompt, /sliceChanges\.added/);
+  assert.match(planSlicePrompt, /sliceChanges\.removed/);
+
+  const dbToolsSource = readFileSync(new URL("../bootstrap/db-tools.ts", import.meta.url), "utf8");
+  assert.match(dbToolsSource, /name:\s*"gsd_reassess_roadmap"/);
+  assert.match(dbToolsSource, /sliceChanges:\s*Type\.Object/);
+  assert.match(dbToolsSource, /modified:\s*Type\.Array/);
+  assert.match(dbToolsSource, /added:\s*Type\.Array/);
+  assert.match(dbToolsSource, /removed:\s*Type\.Array/);
+});

package/src/resources/extensions/gsd/tests/recovery-attempts-reset.test.ts

@@ -81,46 +81,14 @@ try {
     );
   }
 
-  // ═══ Verify the BUG scenario: omitting recoveryAttempts carries it over ═══
-
-  {
-    console.log("\n=== #2322: demonstrates bug — omitting recoveryAttempts carries it over ===");
-
-    const unitType = "execute-task";
-    const unitId = "M001/S01/T02";
-    const startedAt1 = Date.now() - 10000;
-
-    // First dispatch
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      phase: "dispatched",
-    });
-
-    // Timeout bumps recoveryAttempts to 1
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      recoveryAttempts: 1,
-      lastRecoveryReason: "hard",
-    });
-
-    // Re-dispatch WITHOUT resetting recoveryAttempts (the bug)
-    const startedAt2 = Date.now();
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt2, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: startedAt2,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-      // recoveryAttempts: NOT included — this is the bug
-    });
-
-    const afterBuggyRedispatch = readUnitRuntimeRecord(base, unitType, unitId);
-    // This DEMONSTRATES the bug: recoveryAttempts is still 1
-    assertEq(
-      afterBuggyRedispatch?.recoveryAttempts,
-      1,
-      "BUG DEMO: recoveryAttempts carries over when not explicitly reset",
-    );
-  }
+  // Note (#4837): the previous "BUG DEMO" block was tautological — it only
+  // asserted that writeUnitRuntimeRecord merges partial updates into the
+  // stored record (which is the function's documented behaviour and is
+  // already covered by unit-runtime.test.ts). Proving merge semantics here
+  // added zero coverage of the #2322 fix. The first block above verifies the
+  // fix itself (explicit recoveryAttempts: 0 on re-dispatch resets the
+  // counter); the block below verifies the end-to-end budget-reset
+  // invariant.
 
   // ═══ Hard timeout maxRecoveryAttempts=1 — second dispatch must get full budget ═══