gsd-pi 2.66.1-dev.ed243f2 → 2.67.0-dev.43b0159

package/src/resources/extensions/gsd/tests/parsers.test.ts

@@ -703,6 +703,31 @@ Widget description.
   assert.deepStrictEqual(p.tasks[0].title, 'Build the widget', 'em-dash heading T01 title');
 });
 
+test('parsePlan: filename subheadings do not become task ids', () => {
+  const content = `# S15: Filename Headings
+
+**Goal:** Ignore file-reference subheadings inside task descriptions.
+**Demo:** Only real task ids are parsed.
+
+## Tasks
+
+- [ ] **T01: First task** \`est:10m\`
+  Implement the feature.
+
+### constraints.py — \`add_off_request_tiered()\`
+- preserve behavior
+
+### annotations.py — \`annotate()\`
+- keep metadata
+`;
+
+  const p = parsePlan(content);
+  assert.deepStrictEqual(p.tasks.map((task) => task.id), ['T01'], 'filename subheadings should not create extra tasks');
+  assert.deepStrictEqual(p.tasks[0].title, 'First task', 'real task should still parse normally');
+  assert.ok(p.tasks[0].description.includes('preserve behavior'), 'detail lines under filename subheadings should remain attached to the task');
+  assert.ok(p.tasks[0].description.includes('keep metadata'), 'later detail lines should also remain attached to the task');
+});
+
 test('parsePlan: mixed checkbox and heading-style tasks', () => {
   const content = `# S14: Mixed Format
 

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -17,6 +17,8 @@ import {
   parsePreferencesMarkdown,
   _resetParseWarningFlag,
 } from "../preferences.ts";
+import { formatConfiguredModel, toPersistedModelId } from "../commands-prefs-wizard.ts";
+import { _resetLogs, peekLogs } from "../workflow-logger.ts";
 import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
 
 // ── Git preferences ──────────────────────────────────────────────────────────
@@ -346,6 +348,22 @@ test("handles model config with explicit provider field", () => {
   assert.equal(execution.provider, "bedrock");
 });
 
+test("formatConfiguredModel renders provider-qualified object config", () => {
+  assert.equal(
+    formatConfiguredModel({ model: "claude-opus-4-6", provider: "bedrock" }),
+    "bedrock/claude-opus-4-6",
+  );
+});
+
+test("toPersistedModelId prefixes provider chosen in prefs wizard", () => {
+  assert.equal(toPersistedModelId("openai", "gpt-5.4"), "openai/gpt-5.4");
+  assert.equal(
+    toPersistedModelId("openai", "openai/gpt-5.4"),
+    "openai/gpt-5.4",
+    "already-qualified IDs should be preserved",
+  );
+});
+
 test("handles empty models config", () => {
   const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
   assert.notEqual(prefs, null);
@@ -422,6 +440,25 @@ test("parsePreferencesMarkdown parses heading+list format without frontmatter (#
   assert.deepStrictEqual(result!.git, { isolation: "none" });
 });
 
+test("section parse warning is emitted at most once for heading+list YAML failures (#3759)", () => {
+  _resetParseWarningFlag();
+  _resetLogs();
+
+  const content = `## Git
+bad: [
+`;
+
+  parsePreferencesMarkdown(content);
+  parsePreferencesMarkdown(content);
+  parsePreferencesMarkdown(content);
+
+  const warnings = peekLogs().filter((entry) => entry.component === "guided" && entry.message.includes("preferences section parse failed"));
+  assert.equal(warnings.length, 1, `expected exactly 1 guided warning, got ${warnings.length}`);
+
+  _resetParseWarningFlag();
+  _resetLogs();
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -51,6 +51,12 @@ test("guided discussion prompts avoid wrap-up prompts after every round", () =>
   assert.doesNotMatch(slicePrompt, /I think I have a solid picture of this slice\. Ready to wrap up/i);
 });
 
+test("guided milestone discussion scopes depth verification to the milestone id", () => {
+  const prompt = readPrompt("guided-discuss-milestone");
+  assert.match(prompt, /depth_verification_\{\{milestoneId\}\}/, "depth verification id should include the milestone id");
+  assert.doesNotMatch(prompt, /depth_verification_confirm" — this enables the write-gate downstream/i, "legacy global depth gate wording should be gone");
+});
+
 test("guided-resume-task prompt preserves recovery state until work is superseded", () => {
   const prompt = readPrompt("guided-resume-task");
   assert.match(prompt, /Do \*\*not\*\* delete the continue file immediately/i);
@@ -65,11 +71,13 @@ test("execute-task prompt references gsd_complete_task tool", () => {
   assert.match(prompt, /gsd_complete_task/);
 });
 
-test("execute-task prompt instructs writing task summary before tool call", () => {
+test("execute-task prompt uses gsd_complete_task as canonical summary write path", () => {
   const prompt = readPrompt("execute-task");
-  // The prompt instructs writing the summary file AND calling the tool
   assert.match(prompt, /\{\{taskSummaryPath\}\}/);
   assert.match(prompt, /gsd_complete_task/);
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
+  assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{taskSummaryPath\}\}`?/i);
+  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?\s*$/m);
 });
 
 test("execute-task prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -113,10 +121,14 @@ test("guided-complete-slice prompt references gsd_slice_complete tool", () => {
 
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
-  // The prompt instructs writing the summary AND UAT files, then calling the tool
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
   assert.match(prompt, /gsd_complete_slice/);
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
+  assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceSummaryPath\}\}`?/i);
+  assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{sliceUatPath\}\}`?/i);
+  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceSummaryPath\}\}`?.*$/m);
+  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceUatPath\}\}`?.*$/m);
 });
 
 test("complete-slice prompt preserves decisions and knowledge review steps", () => {
@@ -125,6 +137,15 @@ test("complete-slice prompt preserves decisions and knowledge review steps", ()
   assert.match(prompt, /KNOWLEDGE\.md/);
 });
 
+test("validate-milestone prompt uses gsd_validate_milestone as canonical validation write path", () => {
+  const prompt = readPrompt("validate-milestone");
+  assert.match(prompt, /gsd_validate_milestone/);
+  assert.match(prompt, /\{\{validationPath\}\}/);
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
+  assert.match(prompt, /Do \*\*not\*\* manually write `?\{\{validationPath\}\}`?/i);
+  assert.doesNotMatch(prompt, /Write to `?\{\{validationPath\}\}`?:/i);
+});
+
 test("complete-slice prompt still contains template variables for context", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -188,7 +209,8 @@ test("validate-milestone prompt dispatches parallel reviewers", () => {
   assert.match(prompt, /Reviewer C/);
   assert.match(prompt, /Requirements Coverage/);
   assert.match(prompt, /Cross-Slice Integration/);
-  assert.match(prompt, /UAT/);
+  assert.match(prompt, /Assessment & Acceptance Criteria/);
+  assert.match(prompt, /assessment evidence/i);
 });
 
 // ─── Prompt migration: replan-slice → gsd_replan_slice ────────────────

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -458,6 +458,66 @@ test("openai-codex-responses.ts extracts nested error fields", () => {
   );
 });
 
+// ── Fix 1: resetTransientRetryState resets module-level singleton ────────────
+
+test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  assert.ok(
+    src.includes("export function resetTransientRetryState"),
+    "agent-end-recovery.ts must export resetTransientRetryState for provider-error-resume.ts",
+  );
+});
+
+test("provider-error-resume.ts calls resetTransientRetryState before startAuto", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "provider-error-resume.ts"), "utf-8");
+  assert.ok(
+    src.includes("resetTransientRetryState"),
+    "provider-error-resume.ts must import and call resetTransientRetryState",
+  );
+  // Ensure reset is called BEFORE startAuto — order matters
+  const resetIdx = src.indexOf("resetTransientRetryState()");
+  const startIdx = src.indexOf("await deps.startAuto(");
+  assert.ok(
+    resetIdx !== -1 && startIdx !== -1 && resetIdx < startIdx,
+    "resetTransientRetryState() must be called before deps.startAuto()",
+  );
+});
+
+// ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
+
+test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {
+  const src = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
+
+  // The cancelled + isTransient + category=timeout path must pause, not hard-stop
+  assert.ok(
+    src.includes('category === "timeout"'),
+    "phases.ts must check category === 'timeout' on transient cancelled unitResults",
+  );
+  // Must call pauseAuto (not stopAuto) for timeout cancellations
+  assert.ok(
+    /category === "timeout"[\s\S]{0,300}pauseAuto/.test(src),
+    "phases.ts must call pauseAuto for session-timeout failures (not stopAuto or continue)",
+  );
+  // Must NOT use action: "continue" for transient cancellations (causes infinite loops)
+  assert.ok(
+    !/isTransient[\s\S]{0,500}action:\s*"continue"/.test(src),
+    "phases.ts must NOT return action:continue for cancelled units — use break+pause instead",
+  );
+});
+
+// ── Fix 3: MAX_TRANSIENT_AUTO_RESUMES raised to 8 ───────────────────────────
+
+test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
+  const match = src.match(/MAX_TRANSIENT_AUTO_RESUMES\s*=\s*(\d+)/);
+  assert.ok(match, "MAX_TRANSIENT_AUTO_RESUMES must be defined");
+  const value = Number(match![1]);
+  assert.ok(
+    value >= 8,
+    `MAX_TRANSIENT_AUTO_RESUMES must be >= 8 for sustained overload resilience, got ${value}`,
+  );
+});
+
 // ── agent-session retryable regex handles server_error (#1166) ──────────────
 
 test("agent-session retryable error regex matches server_error (underscore)", () => {

package/src/resources/extensions/gsd/tests/queue-execution-guard.test.ts

@@ -13,6 +13,7 @@
  *   (e) write/edit to source path → block
  *   (f) bash command → block (could execute work)
  *   (g) registered GSD tools (gsd_milestone_generate_id, gsd_summary_save) → pass
+ *   (h) unknown custom tools → block
  */
 
 import test from 'node:test';
@@ -155,3 +156,11 @@ test('queue-guard: allows web search and library tools during queue mode', () =>
   const r4 = shouldBlockQueueExecution('fetch_page', '', true);
   assert.strictEqual(r4.block, false, 'fetch_page should pass');
 });
+
+// ─── Scenario 10: Unknown custom tools are blocked during queue mode ──
+
+test('queue-guard: blocks unknown custom tools during queue mode', () => {
+  const result = shouldBlockQueueExecution('custom_codegen_tool', '', true);
+  assert.strictEqual(result.block, true, 'unknown custom tools should be blocked');
+  assert.ok(result.reason, 'should explain the queue restriction');
+});

package/src/resources/extensions/gsd/tests/reactive-graph.test.ts

@@ -101,6 +101,25 @@ test("parseTaskPlanIO handles multiple backtick tokens on one line", () => {
   assert.deepEqual(io.outputFiles, ["src/c.ts"]);
 });
 
+test("parseTaskPlanIO strips inline descriptions from backtick-wrapped file references", () => {
+  const content = `# T01: Described Paths
+
+## Inputs
+
+- \`src/config.ts — existing configuration\`
+- \`src/flags.ts - feature flags\`
+
+## Expected Output
+
+- \`definitions/ac-audit.md — current state of AC CRM\`
+- \`docs/runbook.md - update deployment notes\`
+`;
+
+  const io = parseTaskPlanIO(content);
+  assert.deepEqual(io.inputFiles, ["src/config.ts", "src/flags.ts"]);
+  assert.deepEqual(io.outputFiles, ["definitions/ac-audit.md", "docs/runbook.md"]);
+});
+
 // ─── deriveTaskGraph ──────────────────────────────────────────────────────
 
 test("deriveTaskGraph: linear chain T01→T02→T03", () => {

package/src/resources/extensions/gsd/tests/register-shortcuts.test.ts

@@ -0,0 +1,73 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerShortcuts } from "../bootstrap/register-shortcuts.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-register-shortcuts-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+}
+
+test("dashboard shortcut resolves the project root instead of the current worktree path", async (t) => {
+  const projectRoot = makeTempDir("project");
+  const worktreeRoot = join(projectRoot, ".gsd", "worktrees", "M001");
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  mkdirSync(worktreeRoot, { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(worktreeRoot);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(projectRoot);
+  });
+
+  let capturedHandler: ((ctx: any) => Promise<void>) | null = null;
+  const shortcuts: Array<{ description: string; handler: (ctx: any) => Promise<void> }> = [];
+  const pi = {
+    registerShortcut: (_key: unknown, shortcut: { description: string; handler: (ctx: any) => Promise<void> }) => {
+      shortcuts.push(shortcut);
+      if (!capturedHandler) {
+        capturedHandler = shortcut.handler;
+      }
+    },
+  } as any;
+
+  registerShortcuts(pi);
+  assert.ok(capturedHandler, "dashboard shortcut is registered");
+  const dashboardShortcut = shortcuts[0];
+  assert.ok(dashboardShortcut, "dashboard shortcut is captured");
+
+  let customCalls = 0;
+  const notices: Array<{ message: string; type?: string }> = [];
+  await dashboardShortcut.handler({
+    hasUI: true,
+    ui: {
+      custom: async () => {
+        customCalls++;
+        return true;
+      },
+      notify: (message: string, type?: string) => {
+        notices.push({ message, type });
+      },
+    },
+  });
+
+  assert.ok(customCalls > 0, "shortcut opens the dashboard overlay when project root is resolved");
+  assert.equal(notices.length, 0, "shortcut does not fall back to the missing-.gsd warning");
+  assert.equal(shortcuts.length, 3, "all GSD shortcuts are still registered");
+});

package/src/resources/extensions/gsd/tests/remote-questions.test.ts

@@ -760,6 +760,104 @@ test("ask-user-questions source-level: tryRemoteQuestions is called before the h
   );
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Race model tests (#3810) — local TUI races against remote channel
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("ask-user-questions source-level: raceRemoteAndLocal function exists", () => {
+  const src = readFileSync(
+    join(__dirname, "..", "..", "ask-user-questions.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("async function raceRemoteAndLocal("),
+    "raceRemoteAndLocal helper should exist for racing local TUI against remote channel",
+  );
+});
+
+test("ask-user-questions source-level: race path uses isRemoteConfigured for routing", () => {
+  const src = readFileSync(
+    join(__dirname, "..", "..", "ask-user-questions.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("isRemoteConfigured()"),
+    "execute() should call isRemoteConfigured() for lightweight routing decision",
+  );
+});
+
+test("ask-user-questions source-level: race path checks both hasRemote and ctx.hasUI", () => {
+  // Regression: #3810 — the race should only activate when BOTH remote and local UI
+  // are available. Headless mode should still use remote-only, and no-remote should
+  // use local-only.
+  const src = readFileSync(
+    join(__dirname, "..", "..", "ask-user-questions.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("hasRemote && ctx.hasUI"),
+    "Race path should require both remote configured and local UI available",
+  );
+  assert.ok(
+    src.includes("hasRemote && !ctx.hasUI"),
+    "Headless path should handle remote-only when no local UI",
+  );
+});
+
+test("ask-user-questions source-level: race treats remote timeout as non-win", () => {
+  // Regression: the whole point of the race is that a remote timeout should NOT
+  // block the local TUI. The race helper must filter out timed_out results.
+  const src = readFileSync(
+    join(__dirname, "..", "..", "ask-user-questions.ts"),
+    "utf-8",
+  );
+  const raceFnStart = src.indexOf("async function raceRemoteAndLocal(");
+  const raceFnEnd = src.indexOf("\n}", raceFnStart);
+  const raceFnBody = src.slice(raceFnStart, raceFnEnd);
+  assert.ok(
+    raceFnBody.includes("timed_out"),
+    "raceRemoteAndLocal should check for timed_out in remote results",
+  );
+  assert.ok(
+    raceFnBody.includes("details?.error"),
+    "raceRemoteAndLocal should check for error in remote results",
+  );
+});
+
+test("ask-user-questions source-level: race uses AbortController to cancel loser", () => {
+  const src = readFileSync(
+    join(__dirname, "..", "..", "ask-user-questions.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("new AbortController()"),
+    "Race path should create an AbortController for cancellation",
+  );
+  assert.ok(
+    src.includes("controller.abort()"),
+    "raceRemoteAndLocal should abort the controller to cancel the losing side",
+  );
+});
+
+test("manager source-level: isRemoteConfigured export exists", () => {
+  const src = readFileSync(
+    join(__dirname, "..", "..", "remote-questions", "manager.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("export function isRemoteConfigured()"),
+    "manager.ts should export isRemoteConfigured for lightweight config checking",
+  );
+  // Must delegate to resolveRemoteConfig — no separate config parsing
+  const fnStart = src.indexOf("export function isRemoteConfigured()");
+  const fnEnd = src.indexOf("\n}", fnStart);
+  const fnBody = src.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("resolveRemoteConfig()"),
+    "isRemoteConfigured should delegate to resolveRemoteConfig",
+  );
+});
+
 test("config source-level: removeProviderToken uses auth.remove not auth.set with empty key", () => {
   const commandSrc = readFileSync(
     join(__dirname, "..", "..", "remote-questions", "remote-command.ts"),

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -6,7 +6,7 @@ import { tmpdir } from "node:os";
 
 const { deriveState } = await import("../state.js");
 
-test("deriveState reports complete when all milestone slices are done", async () => {
+test("deriveState reports the last completed milestone when all milestone slices are done", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-complete-"));
 
   try {
@@ -31,7 +31,7 @@ test("deriveState reports complete when all milestone slices are done", async ()
 
     const state = await deriveState(base);
     assert.equal(state.phase, "complete");
-    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(state.lastCompletedMilestone?.id, "M001");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -9,6 +9,7 @@ import { deriveState, isValidationTerminal } from "../state.ts";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact } from "../auto-artifact-paths.ts";
 import { verifyExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
 import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
+import { buildValidateMilestonePrompt } from "../auto-prompts.ts";
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
@@ -57,6 +58,12 @@ function writeSliceSummary(base: string, mid: string, sid: string, content: stri
   writeFileSync(join(dir, `${sid}-SUMMARY.md`), content);
 }
 
+function writeSliceAssessment(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-ASSESSMENT.md`), content);
+}
+
 const ALL_DONE_ROADMAP = `# M001: Test Milestone
 
 ## Vision
@@ -192,6 +199,25 @@ test("deriveState returns complete when both VALIDATION and SUMMARY exist", asyn
   }
 });
 
+test("buildValidateMilestonePrompt inlines ASSESSMENT evidence instead of UAT spec", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
+    const dir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(join(dir, "M001-CONTEXT.md"), CONTEXT_FILE);
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
+    writeFileSync(join(dir, "slices", "S01", "S01-UAT.md"), "# UAT Spec\nDo the thing.\n");
+    writeSliceAssessment(base, "M001", "S01", "---\nverdict: PASS\n---\n# Assessment\nEvidence captured.");
+
+    const prompt = await buildValidateMilestonePrompt("M001", "Test Milestone", base);
+    assert.match(prompt, /S01 Assessment/i, "prompt should inline assessment evidence");
+    assert.match(prompt, /verdict: PASS/i, "prompt should include the assessment verdict");
+    assert.doesNotMatch(prompt, /UAT Spec/i, "prompt should not inline the raw UAT spec as evidence");
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Dispatch rule ────────────────────────────────────────────────────────
 
 test("dispatch rule matches validating-milestone phase", async () => {

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -233,3 +233,62 @@ assert.ok(
   overlaySrc.includes('from "../shared/mod.js"'),
   "imports from shared barrel",
 );
+
+test("visualizer overlay closes on escape in filter and help submodes", async () => {
+  const mod = await import("../visualizer-overlay.js");
+
+  const mockTui = { requestRender: () => {} };
+  const mockTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+
+  let closedFilter = false;
+  const filterOverlay = new mod.GSDVisualizerOverlay(
+    mockTui,
+    mockTheme as any,
+    () => { closedFilter = true; },
+  );
+  filterOverlay.filterMode = true;
+  filterOverlay.handleInput("\u0003");
+  assert.equal(closedFilter, true, "Ctrl+C closes while filter mode is active");
+  filterOverlay.dispose();
+
+  let closedHelp = false;
+  const helpOverlay = new mod.GSDVisualizerOverlay(
+    mockTui,
+    mockTheme as any,
+    () => { closedHelp = true; },
+  );
+  helpOverlay.showHelp = true;
+  helpOverlay.handleInput("\u001b");
+  assert.equal(closedHelp, true, "Escape closes while help overlay is visible");
+  helpOverlay.dispose();
+});
+
+test("visualizer overlay tab hitboxes include rendered badges", async () => {
+  const mod = await import("../visualizer-overlay.js");
+
+  const mockTui = { requestRender: () => {} };
+  const mockTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+
+  const overlay = new mod.GSDVisualizerOverlay(
+    mockTui,
+    mockTheme as any,
+    () => {},
+  );
+  overlay.loading = true;
+  overlay.data = { captures: { pendingCount: 3 } } as any;
+
+  const lines = overlay.render(120);
+  const tabLine = lines.find((line: string) => line.includes("Captures") && line.includes("(3)"));
+  assert.ok(tabLine, "rendered tab bar includes captures badge");
+  const plain = tabLine!.replace(/\x1b\[[0-9;]*m/g, "");
+  const badgeColumn = plain.indexOf("(3)") + 2;
+  overlay.handleInput(`\x1b[<0;${badgeColumn};2M`);
+  assert.equal(overlay.activeTab, 8, "clicking the badge area selects the captures tab");
+  overlay.dispose();
+});

package/src/resources/extensions/gsd/tests/workflow-reconcile.test.ts

@@ -0,0 +1,91 @@
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { appendEvent, readEvents } from "../workflow-events.ts";
+import { listConflicts, reconcileWorktreeLogs, resolveConflict } from "../workflow-reconcile.ts";
+import { closeDatabase } from "../gsd-db.ts";
+
+const tmpDirs: string[] = [];
+
+function makeTmpRepo(): { main: string; worktree: string } {
+  const root = mkdtempSync(join(tmpdir(), "workflow-reconcile-"));
+  const main = join(root, "main");
+  const worktree = join(root, "worktree");
+  mkdirSync(main, { recursive: true });
+  mkdirSync(worktree, { recursive: true });
+  tmpDirs.push(root);
+  return { main, worktree };
+}
+
+afterEach(() => {
+  closeDatabase();
+  for (const dir of tmpDirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // Best-effort cleanup on platforms that keep files open briefly.
+    }
+  }
+  tmpDirs.length = 0;
+});
+
+test("resolveConflict(pick=main) rewrites the worktree log durably", () => {
+  const { main, worktree } = makeTmpRepo();
+
+  appendEvent(main, {
+    cmd: "plan_milestone",
+    params: { milestoneId: "M001", title: "Base Milestone" },
+    ts: "2026-01-01T00:00:00.000Z",
+    actor: "agent",
+  });
+  appendEvent(worktree, {
+    cmd: "plan_milestone",
+    params: { milestoneId: "M001", title: "Base Milestone" },
+    ts: "2026-01-01T00:00:00.000Z",
+    actor: "agent",
+  });
+
+  appendEvent(main, {
+    cmd: "plan_milestone",
+    params: { milestoneId: "M001", title: "Main Choice" },
+    ts: "2026-01-01T00:01:00.000Z",
+    actor: "agent",
+  });
+
+  appendEvent(worktree, {
+    cmd: "plan_milestone",
+    params: { milestoneId: "M001", title: "Worktree Choice" },
+    ts: "2026-01-01T00:01:00.000Z",
+    actor: "agent",
+  });
+
+  const initial = reconcileWorktreeLogs(main, worktree);
+  assert.equal(initial.conflicts.length, 1, "expected one conflict before resolution");
+  assert.ok(listConflicts(main).length === 1, "CONFLICTS.md should exist after detection");
+
+  resolveConflict(main, worktree, "milestone:M001", "main");
+
+  assert.equal(listConflicts(main).length, 0, "conflict file should be cleared after resolving main");
+  const conflictsPath = join(main, ".gsd", "CONFLICTS.md");
+  assert.equal(
+    existsSync(conflictsPath),
+    false,
+    "CONFLICTS.md should be removed after the last conflict is resolved",
+  );
+
+  const wtEvents = readEvents(join(worktree, ".gsd", "event-log.jsonl"));
+  assert.ok(
+    wtEvents.some((e) => e.cmd === "plan_milestone" && e.params.title === "Main Choice"),
+    "worktree log should be rewritten to the main-side resolution",
+  );
+  assert.ok(
+    !wtEvents.some((e) => e.cmd === "plan_milestone" && e.params.title === "Worktree Choice"),
+    "worktree log should no longer contain the discarded conflict event",
+  );
+
+  const second = reconcileWorktreeLogs(main, worktree);
+  assert.equal(second.conflicts.length, 0, "reconcile should stay clean after choosing main");
+});