gsd-pi 2.76.0-dev.82e249f7b → 2.76.0-dev.97f5583d9

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/safety-harness-false-positives.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Regression tests for three false-positive sources in the safety harness.
+ * Issue #4385
+ *
+ * Bug 1: Hardcoded BASH_READ_ONLY_RE — new legitimate commands blocked
+ * Bug 2: Non-persisted evidence — session restart causes false positive on resume
+ * Bug 3: git diff HEAD~1 scope check — fails on initial commits / shallow clones
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { shouldBlockQueueExecution } from "../bootstrap/write-gate.ts";
+import {
+  resetEvidence,
+  recordToolCall,
+  getEvidence,
+  saveEvidenceToDisk,
+  loadEvidenceFromDisk,
+} from "../safety/evidence-collector.ts";
+import { validateFileChanges } from "../safety/file-change-validator.ts";
+
+// ─── Bug 1: Hardcoded Bash allowlist ────────────────────────────────────────
+
+test("safety-harness-bug1: npm commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "npm run test", true);
+  assert.strictEqual(r.block, false, "npm run test must be read-only-safe");
+});
+
+test("safety-harness-bug1: npx commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "npx tsc --noEmit", true);
+  assert.strictEqual(r.block, false, "npx tsc --noEmit must pass");
+});
+
+test("safety-harness-bug1: tsx commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "tsx src/index.ts", true);
+  assert.strictEqual(
+    r.block,
+    false,
+    "tsx (TypeScript runner — read-only investigative) must pass",
+  );
+});
+
+test("safety-harness-bug1: node --print commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "node --print 'process.version'", true);
+  assert.strictEqual(r.block, false, "node --print must pass");
+});
+
+test("safety-harness-bug1: python read-only invocations are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "python -c 'import sys; print(sys.version)'", true);
+  assert.strictEqual(r.block, false, "python -c read-only must pass");
+});
+
+test("safety-harness-bug1: jq read-only command is not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "jq '.version' package.json", true);
+  assert.strictEqual(r.block, false, "jq (read-only JSON query) must pass");
+});
+
+test("safety-harness-bug1: destructive commands are still blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "rm -rf dist/", true);
+  assert.strictEqual(r.block, true, "rm -rf must still be blocked");
+});
+
+// ─── Bug 2: Non-persisted evidence ──────────────────────────────────────────
+
+test("safety-harness-bug2: evidence survives save/load round-trip (simulates session restart)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-persist-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+
+  // Simulate bash tool calls during unit execution
+  recordToolCall("tc-001", "Bash", { command: "npm run test:unit" });
+  recordToolCall("tc-002", "Bash", { command: "npx tsc --noEmit" });
+  recordToolCall("tc-003", "Write", { file_path: "src/foo.ts" });
+
+  const before = getEvidence();
+  assert.equal(before.length, 3, "three entries before save");
+
+  // Persist to disk
+  saveEvidenceToDisk(base, "M001", "S001", "T001");
+
+  // Simulate session restart: module-level array reset
+  resetEvidence();
+  assert.equal(getEvidence().length, 0, "in-memory cleared after reset");
+
+  // Resume: load from disk
+  loadEvidenceFromDisk(base, "M001", "S001", "T001");
+
+  const after = getEvidence();
+  assert.equal(after.length, 3, "evidence restored from disk after simulated restart");
+
+  const bashEntries = after.filter((e) => e.kind === "bash");
+  assert.equal(bashEntries.length, 2, "both bash entries restored");
+
+  const writeEntries = after.filter((e) => e.kind === "write");
+  assert.equal(writeEntries.length, 1, "write entry restored");
+});
+
+test("safety-harness-bug2: loadEvidenceFromDisk returns empty array when no file exists (fresh unit)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-nopersist-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+  loadEvidenceFromDisk(base, "M001", "S001", "T001");
+  assert.equal(getEvidence().length, 0, "no evidence on fresh unit is correct — not a false positive");
+});
+
+// ─── Bug 3: git diff HEAD~1 scope check ─────────────────────────────────────
+
+test("safety-harness-bug3: validateFileChanges works on initial commit (no HEAD~1)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-initial-commit-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  execFileSync("git", ["init"], { cwd: base });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base });
+
+  writeFileSync(join(base, "index.ts"), "export const x = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base });
+
+  // On initial commit, HEAD~1 does not exist — must not throw or produce wrong results
+  const audit = validateFileChanges(base, ["index.ts"], []);
+
+  assert.ok(audit !== null, "audit must be produced for initial commit");
+  assert.deepEqual(audit!.unexpectedFiles, [], "no unexpected files on initial commit");
+  assert.deepEqual(audit!.missingFiles, [], "no missing files on initial commit");
+});
+
+test("safety-harness-bug3: validateFileChanges works on shallow clone (shallow repo without full history)", (t) => {
+  // Simulate shallow clone: create a repo, then clone it with depth=1
+  const origin = mkdtempSync(join(tmpdir(), "gsd-origin-"));
+  const shallow = mkdtempSync(join(tmpdir(), "gsd-shallow-"));
+  t.after(() => {
+    rmSync(origin, { recursive: true, force: true });
+    rmSync(shallow, { recursive: true, force: true });
+  });
+
+  // Set up origin with multiple commits
+  execFileSync("git", ["init"], { cwd: origin });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: origin });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: origin });
+  writeFileSync(join(origin, "a.ts"), "export const a = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: origin });
+  execFileSync("git", ["commit", "-m", "first"], { cwd: origin });
+  writeFileSync(join(origin, "b.ts"), "export const b = 2;\n");
+  execFileSync("git", ["add", "."], { cwd: origin });
+  execFileSync("git", ["commit", "-m", "second"], { cwd: origin });
+
+  // Shallow clone with depth=1 — HEAD~1 will not exist
+  execFileSync("git", ["clone", "--depth=1", `file://${origin}`, shallow], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  // Verify the shallow clone has no parent (HEAD~1 unavailable)
+  let hasParent = true;
+  try {
+    execFileSync("git", ["rev-parse", "HEAD~1"], {
+      cwd: shallow,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    hasParent = false;
+  }
+  assert.equal(hasParent, false, "shallow clone should not have HEAD~1");
+
+  // validateFileChanges must not throw or give wrong results
+  const audit = validateFileChanges(shallow, ["b.ts"], []);
+  assert.ok(audit !== null, "audit must be produced even in shallow clone");
+});
+
+test("safety-harness-bug3: validateFileChanges works on merge commit", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-merge-commit-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  execFileSync("git", ["init", "-b", "main"], { cwd: base });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base });
+
+  // Main branch: initial commit
+  writeFileSync(join(base, "main.ts"), "export const m = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base });
+
+  // Feature branch
+  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base });
+  writeFileSync(join(base, "feature.ts"), "export const f = 2;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "feature work"], { cwd: base });
+
+  // Merge back to main
+  execFileSync("git", ["checkout", "main"], { cwd: base });
+  execFileSync("git", ["merge", "--no-ff", "feature", "-m", "Merge feature"], { cwd: base });
+
+  // HEAD is now a merge commit with two parents — git diff HEAD~1 gives wrong scope
+  const audit = validateFileChanges(base, ["feature.ts"], []);
+
+  // Must produce a valid result without throwing
+  assert.ok(audit !== null, "audit must be produced for merge commit repo");
+});