gsd-pi 2.76.0 → 2.77.0-dev.538325aea

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/restore-tools-after-discuss.test.ts

@@ -45,9 +45,15 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
   })
 
   it('savedTools is restored after sendMessage', () => {
-    // Find the sendMessage call
-    const sendMsg = src.indexOf('triggerTurn: true')
-    assert.ok(sendMsg !== -1, 'sendMessage with triggerTurn must exist')
+    // #4573: guided-flow.ts now contains multiple `triggerTurn: true` calls
+    // (ready-phrase and empty-turn recovery paths). The discuss-flow scoping
+    // sendMessage is the one that follows `savedTools = currentTools`, so
+    // anchor the search there rather than at the first `triggerTurn: true`.
+    const savedToolsAssign = src.indexOf('savedTools = currentTools')
+    assert.ok(savedToolsAssign !== -1, 'savedTools = currentTools must exist')
+
+    const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
+    assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
     // After sendMessage, savedTools should be restored via setActiveTools
     const afterSend = src.slice(sendMsg, sendMsg + 500)

package/src/resources/extensions/gsd/tests/resume-dispatch-worktree.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Tests for fix of #3723: auto-mode resume/crash-recovery dispatches
+ * from project root instead of milestone worktree.
+ *
+ * During resume, the paused-session metadata may record `worktreePath` that
+ * was active when the session paused. The resume path must use that path (or
+ * derive the worktree path via filesystem lookup) to set the dispatch context
+ * (`s.basePath`), rather than defaulting to the project root.
+ *
+ * The fix adds an early worktree-path resolution step in the paused-session
+ * resume block of auto.ts — immediately after `s.basePath = base` — so that
+ * the correct dispatch directory is used before the dispatch loop runs.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoSrc = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+
+// ── Source-structure tests ────────────────────────────────────────────────────
+
+/**
+ * Extract the paused-session resume block from auto.ts.
+ *
+ * The block we care about is the `if (s.paused) { ... }` section inside
+ * startAuto, which contains `s.basePath = base` (line ~1473) followed by the
+ * `enterMilestone` call.
+ *
+ * We find it by locating the `s.basePath = base` assignment that appears
+ * WITHIN the s.paused branch (there's only one: all other basePath assignments
+ * use originalBasePath or a different value). We extract from that assignment
+ * up to just before `enterMilestone(`.
+ */
+function getBasepathToEnterMilestoneSegment(): string {
+  // Find `s.basePath = base;` in the s.paused branch
+  // This assignment appears uniquely inside the resume block
+  const assignPattern = "s.basePath = base;";
+  const assignIdx = autoSrc.indexOf(assignPattern);
+  assert.ok(
+    assignIdx > -1,
+    `auto.ts must contain '${assignPattern}' in the resume block`,
+  );
+
+  // Find the next enterMilestone call after this assignment
+  const enterMilestoneIdx = autoSrc.indexOf("enterMilestone(", assignIdx);
+  assert.ok(
+    enterMilestoneIdx > assignIdx,
+    "auto.ts must call enterMilestone after the s.basePath = base assignment",
+  );
+
+  // Return the code between the assignment and enterMilestone
+  return autoSrc.slice(assignIdx, enterMilestoneIdx);
+}
+
+test("auto.ts resume block resolves paused-session worktreePath and applies it to s.basePath before entering worktree (fixes #3723)", () => {
+  // The segment between `s.basePath = base` and `enterMilestone(` must
+  // contain logic that resolves the paused-session worktreePath and applies
+  // it to s.basePath when the worktree exists on disk.
+  //
+  // The fix reads the worktree path from freshStartAssessment.pausedSession
+  // (since `meta` is out of scope at this point in startAuto) and assigns
+  // it to s.basePath, guarded by existsSync.
+  //
+  // Without this fix, the dispatch loop runs from `base` (project root)
+  // instead of the worktree, causing split-brain execution (#3723).
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // The fix uses freshStartAssessment.pausedSession?.worktreePath via a
+  // local variable (resumeWorktreePath) and assigns to s.basePath.
+  const hasWorktreePathResolution =
+    segment.includes("worktreePath") &&
+    segment.includes("existsSync") &&
+    segment.includes("s.basePath =");
+
+  assert.ok(
+    hasWorktreePathResolution,
+    "auto.ts must resolve the paused-session worktreePath, check existsSync, and assign " +
+    "s.basePath before enterMilestone — crash-recovery currently dispatches from project root " +
+    "instead of milestone worktree (issue #3723). The fix belongs between `s.basePath = base` " +
+    "and the enterMilestone call.",
+  );
+});
+
+test("auto.ts worktreePath assignment in resume block guards against non-existent path (fixes #3723)", () => {
+  // The assignment to s.basePath from the paused-session worktreePath must
+  // be guarded by existsSync to avoid setting an invalid basePath if the
+  // worktree was cleaned up between pause and resume.
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // Must have existsSync guard AND a worktreePath reference AND s.basePath assignment
+  const hasGuardedAssignment =
+    segment.includes("existsSync") &&
+    segment.includes("worktreePath") &&
+    segment.includes("s.basePath =");
+
+  assert.ok(
+    hasGuardedAssignment,
+    "auto.ts must guard the s.basePath = worktreePath assignment with existsSync (fixes #3723)",
+  );
+});
+
+// ── Functional tests ──────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writePausedSession(
+  base: string,
+  milestoneId: string,
+  worktreePath: string | null,
+): void {
+  writeFileSync(
+    join(base, ".gsd", "runtime", "paused-session.json"),
+    JSON.stringify({
+      milestoneId,
+      originalBasePath: base,
+      stepMode: false,
+      worktreePath,
+      pausedAt: new Date().toISOString(),
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+function makeWorktreePath(base: string, milestoneId: string): string {
+  return join(base, ".gsd", "worktrees", milestoneId);
+}
+
+function setupWorktreeOnDisk(wt: string): void {
+  mkdirSync(wt, { recursive: true });
+  // Simulate a git worktree: .git file with gitdir pointer
+  writeFileSync(
+    join(wt, ".git"),
+    "gitdir: /project/.git/worktrees/M001-test\n",
+    "utf-8",
+  );
+}
+
+function writeRoadmap(base: string, milestoneId = "M001-test"): void {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, `${milestoneId}-ROADMAP.md`),
+    [
+      `# ${milestoneId}: Test Milestone`,
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Test slice** `risk:low`",
+      "  After this: Demo",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+test("readPausedSessionMetadata round-trips worktreePath from paused-session.json", () => {
+  // Verify that the paused-session metadata correctly stores and reads back
+  // the worktreePath field — this is what the resume path in auto.ts uses
+  // to determine the dispatch basePath (#3723).
+  //
+  // Implemented inline to avoid slow import chain from interrupted-session.ts.
+  const base = makeTmpBase();
+  const wt = makeWorktreePath(base, "M001-test");
+  try {
+    setupWorktreeOnDisk(wt);
+    writePausedSession(base, "M001-test", wt);
+
+    // Simulate readPausedSessionMetadata without importing the full module
+    const pausedPath = join(base, ".gsd", "runtime", "paused-session.json");
+    const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
+
+    assert.ok(meta, "paused-session metadata must be readable");
+    assert.equal(meta.milestoneId, "M001-test");
+    assert.equal(meta.worktreePath, wt, "worktreePath must round-trip through paused-session.json");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("auto.ts resume block uses worktreePath from freshStartAssessment.pausedSession as dispatch basePath when worktree exists (#3723)", () => {
+  // End-to-end structural verification: the auto.ts source must contain code
+  // that reads the worktreePath from freshStartAssessment.pausedSession AND
+  // applies it to s.basePath (guarded by existsSync) between the
+  // `s.basePath = base` assignment and `enterMilestone`.
+  //
+  // This is the core of the #3723 fix. Without this check, a session that
+  // paused while operating inside a worktree will resume dispatching from the
+  // project root, not the worktree — causing split-brain execution where some
+  // operations target the worktree and others target the project root.
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // Must reference freshStartAssessment.pausedSession?.worktreePath or
+  // equivalent local variable, AND contain an existsSync guard
+  const hasAssessmentWorktreePath =
+    segment.includes("freshStartAssessment.pausedSession") &&
+    segment.includes("worktreePath");
+
+  assert.ok(
+    hasAssessmentWorktreePath,
+    "auto.ts must read worktreePath from freshStartAssessment.pausedSession between " +
+    "s.basePath=base and enterMilestone",
+  );
+  assert.ok(
+    segment.includes("existsSync"),
+    "auto.ts must guard worktreePath usage with existsSync",
+  );
+  // The actual basePath re-assignment must be present in the segment
+  // (note: there are multiple `s.basePath =` assignments — we need one after
+  // the initial `s.basePath = base` assignment within this segment)
+  const worktreeAssignIdx = segment.lastIndexOf("s.basePath =");
+  const baseAssignIdx = segment.indexOf("s.basePath = base");
+  assert.ok(
+    worktreeAssignIdx > baseAssignIdx,
+    "auto.ts must assign s.basePath to the worktree path after `s.basePath = base` in the resume block",
+  );
+});