@opengsd/gsd-pi 1.1.1-dev.9bb7453 → 1.1.1-dev.9f86580

package/src/resources/extensions/gsd/tests/context-masker.test.ts

@@ -1,7 +1,12 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { createObservationMask } from "../context-masker.js";
+import {
+  createObservationMask,
+  createResponsesInputObservationMask,
+  truncateContextResultMessages,
+  truncateResponsesInputResultItems,
+} from "../context-masker.js";
 
 // These helpers produce messages in the pi-ai LLM payload format
 // (post-convertToLlm, pre-provider), which is what before_provider_request sees.
@@ -120,3 +125,53 @@ test("masks toolResult by role, not by type field", () => {
   const result = mask(messages as any);
   assert.equal((result[1].content as any)[0].text, MASK_TEXT);
 });
+
+test("truncates recent bash result user messages", () => {
+  const messages = [
+    userMsg("turn 1"),
+    bashResult("a".repeat(50)),
+    assistantMsg("response 1"),
+  ];
+  const result = truncateContextResultMessages(messages as any, 10);
+  const text = (result[1].content as any)[0].text;
+  assert.ok(text.length < (messages[1].content as any)[0].text.length);
+  assert.match(text, /…\[truncated\]/);
+});
+
+test("masks Responses API function outputs older than keepRecentTurns", () => {
+  const mask = createResponsesInputObservationMask(1);
+  const items = [
+    { role: "user", content: [{ type: "input_text", text: "turn 1" }] },
+    { type: "function_call_output", call_id: "call_1", output: "old output" },
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: "response 1" }] },
+    { role: "user", content: [{ type: "input_text", text: "turn 2" }] },
+  ];
+  const result = mask(items as any);
+  assert.equal(result[1].output, MASK_TEXT);
+});
+
+test("masks Responses API bash result user items older than keepRecentTurns", () => {
+  const mask = createResponsesInputObservationMask(1);
+  const items = [
+    { role: "user", content: [{ type: "input_text", text: "turn 1" }] },
+    { role: "user", content: [{ type: "input_text", text: "Ran `npm test`\n```\nold output\n```" }] },
+    { type: "message", role: "assistant", content: [{ type: "output_text", text: "response 1" }] },
+    { role: "user", content: [{ type: "input_text", text: "turn 2" }] },
+  ];
+  const result = mask(items as any);
+  assert.equal((result[1].content as any)[0].text, MASK_TEXT);
+});
+
+test("truncates Responses API function outputs and recent bash result items", () => {
+  const items = [
+    { role: "user", content: [{ type: "input_text", text: "turn 1" }] },
+    { type: "function_call_output", call_id: "call_1", output: "b".repeat(50) },
+    { role: "user", content: [{ type: "input_text", text: "Ran `npm test`\n```\n" + "c".repeat(50) + "\n```" }] },
+  ];
+  const result = truncateResponsesInputResultItems(items as any, 12);
+
+  assert.match(result[1].output as string, /…\[truncated\]/);
+  assert.match((result[2].content as any)[0].text, /…\[truncated\]/);
+  assert.ok((result[1].output as string).length < (items[1].output as string).length);
+  assert.ok((result[2].content as any)[0].text.length < (items[2].content as any)[0].text.length);
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -129,6 +129,7 @@ function makeLoopSession(overrides?: Record<string, unknown>) {
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
     verificationRetryCount: new Map<string, number>(),
+    zeroToolRetryCount: new Map<string, number>(),
     gitService: null,
     autoStartTime: Date.now(),
     activeEngineId: null,

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -14,7 +14,7 @@ import { execFileSync } from "node:child_process";
 
 import { DISPATCH_RULES, resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
 import { AutoSession } from "../auto/session.ts";
-import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertAssessment, insertGateRow, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
@@ -225,6 +225,14 @@ describe("complete phase dispatch guard (#5683)", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const ctx = buildDispatchCtx(base);
     ctx.state.phase = "complete";
@@ -234,6 +242,37 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.action, "stop");
     assert.equal(result?.reason, "All milestones complete.");
   });
+
+  test("blocks terminal stop when closed milestone still has pending gates", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
+    insertGateRow({
+      milestoneId: "M001",
+      sliceId: "S01",
+      gateId: "Q3",
+      scope: "slice",
+      status: "pending",
+    });
+
+    const ctx = buildDispatchCtx(base);
+    ctx.state.phase = "complete";
+
+    const result = await rule.match(ctx);
+
+    assert.equal(result?.action, "stop");
+    assert.equal(result?.level, "warning");
+    assert.match(result?.reason ?? "", /closeout-consistency-blocked/);
+    assert.match(result?.reason ?? "", /quality gate Q3 is still pending/);
+  });
 });
 
 describe("complete milestone context recovery guard (#5831)", () => {

package/src/resources/extensions/gsd/tests/dispatch-rule-coverage.test.ts

@@ -216,6 +216,30 @@ test("dispatch-rule-coverage: planning with active slice and skip_research → p
   );
 });
 
+test("dispatch-rule-coverage: planning boundary without planner handoff → research-slice", async (t) => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-planning-"));
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  writeMilestoneFile(tmp, "M001", "CONTEXT", "# Context\n");
+  writeMilestoneFile(tmp, "M001", "ROADMAP", "# Roadmap\n");
+
+  const state = makeState({
+    phase: "planning",
+    activeSlice: { id: "S01", title: "First Slice" },
+    nextAction: "Plan slice S01 (First Slice).",
+  });
+  const match = await findFirstMatch(makeCtx(tmp, state));
+  assertMatch(
+    match,
+    {
+      ruleName: "planning (no research, not S01) → research-slice",
+      action: "dispatch",
+      unitType: "research-slice",
+    },
+    "planning boundary without planner handoff",
+  );
+});
+
 test("dispatch-rule-coverage: executing with task plan present → execute-task", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-disp-cov-exec-"));
   t.after(() => rmSync(tmp, { recursive: true, force: true }));

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

@@ -1,12 +1,9 @@
 /**
- * gsd-pi / guided-flow — regression tests for Gate 1b orphan discrimination
+ * gsd-pi / guided-flow — regression tests for Gate 1b discussion handoff
  *
- * 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).
+ * Gate 1b treats queued + pinned CONTEXT.md as Discussion Complete, Planning
+ * Pending. It must accept the handoff without warning the user or injecting a
+ * hidden gsd_plan_milestone retry.
  */
 
 import { describe, test, beforeEach, afterEach } from "node:test";
@@ -27,8 +24,6 @@ import {
   insertMilestone,
 } from "../gsd-db.ts";
 
-// ─── Harness ───────────────────────────────────────────────────────────────
-
 interface MockCapture {
   notifies: Array<{ msg: string; level: string }>;
   messages: Array<{ payload: any; options: any }>;
@@ -58,24 +53,26 @@ function mkPi(cap: MockCapture): any {
   };
 }
 
-/**
- * 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 ─────────────────────────────────────────────────────────────────
+function writeContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
 
-describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
+describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
 
   beforeEach(() => {
     clearPendingAutoStart();
-    drainLogs(); // discard noise from prior tests
+    drainLogs();
   });
 
   afterEach(() => {
@@ -86,104 +83,59 @@ describe("Gate 1b orphan discrimination in checkAutoStartAfterDiscuss", () => {
     }
   });
 
-  test("plan-blocked: CONTEXT.md present + DB row queued → returns false + recovery hint emitted", () => {
+  test("queued row + CONTEXT.md accepts context-captured handoff without hidden retry", () => {
     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",
-    );
+    writeContext(base);
 
     cap = mkCapture();
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
+      startAuto: false,
       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(result, true, "queued + context is a valid planning-pending handoff");
+    assert.equal(cap.messages.length, 0, "must not inject a hidden recovery turn");
+    assert.equal(cap.notifies.length, 1, "must emit one success notification");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
     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",
+      cap.notifies.some(n => /queued|gsd_plan_milestone/i.test(n.msg)),
+      false,
+      "user-visible copy must not mention queued state or internal plan tool retry",
     );
-
-    // 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)", () => {
+  test("queued row without CONTEXT.md still waits silently for discussion output", () => {
     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",
+      startAuto: false,
       ctx: mkCtx(cap),
       pi: mkPi(cap),
     });
 
-    drainLogs(); // clear any noise before the call
+    drainLogs();
 
     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",
-    );
+    assert.equal(result, false, "must keep waiting while discuss has not written context");
+    assert.equal(cap.messages.length, 0, "no hidden recovery turn expected");
+    assert.equal(cap.notifies.length, 0, "no user notifications expected");
 
-    // No Gate 1b log entry
     const logs = drainLogs();
     const gate1bLog = logs.find(
       (e) => e.component === "guided" && /Gate 1b/.test(e.message),

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -178,7 +178,7 @@ test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry wh
   }
 });
 
-test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start", () => {
+test("checkAutoStartAfterDiscuss can accept context handoff without scheduling auto-start", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-headless-owned-"));
   let waitForIdleCalls = 0;
   const notifications: string[] = [];
@@ -209,9 +209,11 @@ test("checkAutoStartAfterDiscuss can emit ready without scheduling auto-start",
     });
 
     assert.equal(checkAutoStartAfterDiscuss(base), true);
-    assert.deepEqual(notifications, ["Milestone M001 ready."]);
+    assert.deepEqual(notifications, [
+      "Milestone M001 context captured. Continuing the planning pipeline.",
+    ]);
     assert.equal(waitForIdleCalls, 0, "headless-owned auto start must not schedule guided-flow auto");
-    assert.equal(getDiscussionMilestoneId(base), null, "ready handoff should still be cleared");
+    assert.equal(getDiscussionMilestoneId(base), null, "accepted handoff should still be cleared");
   } finally {
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/guided-flow-state-rebuild.test.ts

@@ -135,7 +135,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
 
     assert.equal(accepted, true);
     assert.equal(notifications.some(n => n.level === "error" && n.message.includes("no DB row exists")), false);
-    assert.ok(notifications.some(n => n.level === "success" && n.message.includes("Milestone M001 ready.")));
+    assert.ok(
+      notifications.some(
+        n =>
+          n.level === "success" &&
+          n.message.includes("Milestone M001 context captured. Continuing the planning pipeline."),
+      ),
+    );
     clearPendingAutoStart(base);
   });
 
@@ -157,13 +163,13 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     };
     setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
 
-    for (let i = 0; i < 4; i += 1) {
+    for (let i = 0; i < 3; i += 1) {
       assert.equal(checkAutoStartAfterDiscuss(), false);
     }
 
     assert.equal(
-      notifications.filter(n => n.level === "warning" && n.message.includes("recovering. Retrying gsd_plan_milestone")).length,
-      3,
+      notifications.filter(n => n.level === "warning").length,
+      0,
     );
     assert.equal(
       notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
@@ -171,4 +177,34 @@ describe("guided-flow STATE.md rebuild (#3475)", () => {
     );
     clearPendingAutoStart(base);
   });
+
+  test("checkAutoStartAfterDiscuss does not double-notify on 4th+ call after recovery limit", () => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+    const db = _getAdapter();
+    assert.ok(db, "database should be open");
+    db.exec("DROP TABLE milestones");
+    db.exec("CREATE TABLE milestones (id TEXT PRIMARY KEY)");
+
+    writeFile(base, "milestones/M001/M001-CONTEXT.md", "# M001: Planned\n");
+    writeFile(base, "STATE.md", "# GSD State\n\n**Active Milestone:** M001: Planned\n");
+
+    const notifications: Array<{ message: string; level: string }> = [];
+    const ctx = {
+      ui: { notify: (message: string, level: string) => notifications.push({ message, level }) },
+      waitForIdle: () => new Promise<void>(() => {}),
+    };
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001", ctx: ctx as any, pi: {} as any });
+
+    for (let i = 0; i < 5; i += 1) {
+      assert.equal(checkAutoStartAfterDiscuss(), false);
+    }
+
+    assert.equal(
+      notifications.filter(n => n.level === "error" && n.message.includes("DB row recovery failed")).length,
+      1,
+      "user must see exactly one error notification even after repeated calls past the recovery limit",
+    );
+    clearPendingAutoStart(base);
+  });
 });

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -29,6 +29,7 @@ import { nativeMergeSquash } from "../../native-git-bridge.ts";
 import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";
 import {
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   insertTask,
@@ -207,6 +208,13 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
         });
       }
     }
+    insertAssessment({
+      path: "milestones/M020/M020-VALIDATION.md",
+      milestoneId: "M020",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const roadmap = makeRoadmap("M020", "Backend foundation", [
       { id: "S01", title: "Core API" },

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -41,6 +41,7 @@ import {
 import {
   openDatabase,
   closeDatabase,
+  insertAssessment,
   insertMilestone,
   insertSlice,
   updateMilestoneStatus,
@@ -347,6 +348,13 @@ test("mergeCompletedMilestone — synthesizes roadmap from DB when projection is
       title: "Search Bar",
       status: "complete",
     });
+    insertAssessment({
+      path: "milestones/M010/M010-VALIDATION.md",
+      milestoneId: "M010",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     createMilestoneBranch(repo, "M010", [
       { name: "app.js", content: "export const app = true;\n" },
@@ -671,6 +679,14 @@ function setupCanonicalDbWithWorktree(basePath: string, mid: string): void {
   const dbPath = join(basePath, ".gsd", "gsd.db");
   openDatabase(dbPath);
   insertMilestone({ id: mid, title: `Milestone ${mid}`, status: "complete" });
+  insertSlice({ id: "S01", milestoneId: mid, title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: `milestones/${mid}/${mid}-VALIDATION.md`,
+    milestoneId: mid,
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   updateMilestoneStatus(mid, "complete", new Date().toISOString());
   closeDatabase();
 }

package/src/resources/extensions/gsd/tests/integration/run-uat.test.ts

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { extractUatType } from '../../files.ts';
 import { resolveSliceFile } from '../../paths.ts';
 import { buildRunUatPrompt, checkNeedsRunUat } from '../../auto-prompts.ts';
+import { buildRunUatResultPresentation, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from '../../tool-presentation-plan.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const worktreePromptsDir = join(__dirname, '../..', 'prompts');
@@ -20,6 +21,8 @@ function loadPromptFromWorktree(name: string, vars: Record<string, string> = {})
   let content = readFileSync(path, 'utf-8');
   const effectiveVars = {
     skillActivation: 'If no installed skill clearly matches this unit, skip explicit skill activation and continue with the required workflow.',
+    canonicalPresentation: JSON.stringify(buildRunUatResultPresentation(), null, 2),
+    toolPresentationPlanId: RUN_UAT_TOOL_PRESENTATION_PLAN_ID,
     ...vars,
   };
   for (const [key, value] of Object.entries(effectiveVars)) {
@@ -720,7 +723,9 @@ test('(u) run-uat prompt promotes artifact-driven browser specs to browser-execu
 
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`browser-executable`/);
       assert.match(prompt, /uatType: "browser-executable"/);
-      assert.match(prompt, /use gsd-browser tools/i);
+      assert.match(prompt, /use browser tools/i);
+      assert.match(prompt, /"browser_navigate"/);
+      assert.match(prompt, /"browser_assert"/);
     } finally {
       cleanup(base);
     }
@@ -738,6 +743,7 @@ test('(v) run-uat prompt keeps deferred browser work artifact-driven', async ()
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`artifact-driven`/);
       assert.match(prompt, /uatType: "artifact-driven"/);
       assert.doesNotMatch(prompt, /uatType: "browser-executable"/);
+      assert.doesNotMatch(prompt, /"browser_navigate"/);
     } finally {
       cleanup(base);
     }

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -226,6 +226,33 @@ test("direct /gsd auto skips paused-session replay when recovered unit already c
   }
 });
 
+test("paused-session resume skips replay when unit identity was never recorded", () => {
+  const base = makeTmpBase();
+  try {
+    // No currentUnit and no persisted unit type/id — identity is unknown. The
+    // old code fell back to the literal "unknown" unit, which can neither be
+    // verified nor correctly targeted, and synthesized a full tool-call replay
+    // (the thrash that turns one stuck unit into several). The fix skips the
+    // replay and resumes from rebuilt disk state instead.
+    const state = {
+      pausedSessionFile: join(base, ".gsd", "activity", "paused-session.jsonl"),
+      currentUnit: null,
+      pausedUnitType: null,
+      pausedUnitId: null,
+      pendingCrashRecovery: "stale-recovery-prompt",
+    };
+
+    const result = _handlePausedSessionResumeRecoveryForTest(base, state);
+    assert.equal(result.skippedReplay, true);
+    assert.equal(state.pausedSessionFile, null);
+    assert.equal(state.pendingCrashRecovery, null, "must not synthesize a replay for an unknown unit");
+    assert.equal(state.pausedUnitType, null);
+    assert.equal(state.pausedUnitId, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("interrupted-session source preserves raw lock and excludes same-pid from running classification", async () => {
   const source = await import(`node:fs/promises`).then((fs) =>
     fs.readFile(new URL("../interrupted-session.ts", import.meta.url), "utf-8")

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -200,6 +200,7 @@ function makeSession() {
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
     verificationRetryCount: new Map<string, number>(),
+    zeroToolRetryCount: new Map<string, number>(),
     gitService: null,
     autoStartTime: Date.now(),
     cmdCtx: {

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -54,7 +54,13 @@ test("ensureProjectWorkflowMcpConfig creates .mcp.json with workflow and browser
       "--identity-scope",
       "project",
     ]);
-    assert.equal(browserArgs[mcpArgIndex + 6], projectRoot);
+    // --identity-scope requires a non-empty --identity-key or gsd-browser exits
+    // immediately ("Connection closed"); the key must be stable per project.
+    assert.equal(browserArgs[mcpArgIndex + 5], "--identity-key");
+    assert.equal(typeof browserArgs[mcpArgIndex + 6], "string");
+    assert.ok((browserArgs[mcpArgIndex + 6] ?? "").length > 0, "identity-key must be non-empty");
+    assert.equal(browserArgs[mcpArgIndex + 7], "--identity-project");
+    assert.equal(browserArgs[mcpArgIndex + 8], projectRoot);
     assert.equal((browserServer as { cwd?: string })?.cwd, projectRoot);
 
     const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -342,7 +342,7 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /\/tmp\/project\/\.mcp\.json/);
     assert.match(result, /mcp-capable clients/i);
     assert.match(result, /workflow and gsd-browser MCP servers/i);
-    assert.match(result, /Pi Providers use the managed gsd-browser engine/i);
+    assert.match(result, /Pi Providers use built-in browser tools/i);
     assert.doesNotMatch(result, /claude code/i);
   });