gsd-pi 2.66.1-dev.0df32ec → 2.66.1-dev.3cea7ac

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");
+});

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -3,9 +3,9 @@
  *
  * Exercises shouldBlockContextWrite() — a pure function that implements:
  *   (a) toolName !== "write" → pass
- *   (b) milestoneId null → pass (not in discussion)
+ *   (b) milestone context must resolve to a verified milestone
  *   (c) path doesn't match /M\d+-CONTEXT\.md$/ → pass
- *   (d) depthVerified → pass
+ *   (d) non-context files → pass
  *   (e) else → block with actionable reason
  */
 
@@ -14,12 +14,12 @@ import assert from 'node:assert/strict';
 import {
   isDepthConfirmationAnswer,
   shouldBlockContextWrite,
-  isDepthVerified,
-  isQueuePhaseActive,
   setQueuePhaseActive,
 } from '../index.ts';
 import {
   markDepthVerified,
+  isMilestoneDepthVerified,
+  shouldBlockContextArtifactSave,
   clearDiscussionFlowState,
   resetWriteGateState,
 } from '../bootstrap/write-gate.ts';
@@ -53,26 +53,27 @@ test('write-gate: blocks CONTEXT.md write during discussion without depth verifi
 // ─── Scenario 3: Allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write after depth verification', () => {
+  clearDiscussionFlowState();
+  markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
     '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
     'M001',
-    true,
   );
   assert.strictEqual(result.block, false, 'should not block after depth verification');
   assert.strictEqual(result.reason, undefined, 'should have no reason');
+  clearDiscussionFlowState();
 });
 
-// ─── Scenario 4: Allows CONTEXT.md write outside discussion phase (milestoneId null) ──
+// ─── Scenario 4: Ambiguous session context no longer bypasses the gate ──
 
-test('write-gate: allows CONTEXT.md write outside discussion phase', () => {
+test('write-gate: blocks CONTEXT.md write when milestoneId is ambiguous', () => {
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,
-    false,
   );
-  assert.strictEqual(result.block, false, 'should not block outside discussion phase');
+  assert.strictEqual(result.block, true, 'should block when milestone context is ambiguous');
 });
 
 // ─── Scenario 5: Allows non-CONTEXT.md writes during discussion ──
@@ -83,7 +84,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     '.gsd/milestones/M001/M001-DISCUSSION.md',
     'M001',
-    false,
   );
   assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
 
@@ -92,7 +92,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     '.gsd/milestones/M001/slices/S01/S01-PLAN.md',
     'M001',
-    false,
   );
   assert.strictEqual(r2.block, false, 'slice plan should pass');
 
@@ -101,7 +100,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     'src/index.ts',
     'M001',
-    false,
   );
   assert.strictEqual(r3.block, false, 'regular code file should pass');
 });
@@ -113,7 +111,6 @@ test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', ()
     'write',
     '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
     'M001',
-    false,
   );
   assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
 });
@@ -125,7 +122,6 @@ test('write-gate: blocked reason contains depth_verification keyword and anti-by
     'write',
     '.gsd/milestones/M999/M999-CONTEXT.md',
     'M999',
-    false,
   );
   assert.strictEqual(result.block, true);
   assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
@@ -141,7 +137,6 @@ test('write-gate: blocks CONTEXT.md write in queue mode without depth verificati
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,   // no milestoneId in queue mode
-    false,  // not depth-verified
     true,   // queue phase active
   );
   assert.strictEqual(result.block, true, 'should block in queue mode without depth verification');
@@ -151,48 +146,228 @@ test('write-gate: blocks CONTEXT.md write in queue mode without depth verificati
 // ─── Scenario 9: Queue mode allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write in queue mode after depth verification', () => {
+  clearDiscussionFlowState();
+  markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,   // no milestoneId in queue mode
-    true,   // depth-verified
     true,   // queue phase active
   );
   assert.strictEqual(result.block, false, 'should not block in queue mode after depth verification');
+  clearDiscussionFlowState();
 });
 
-// ─── Scenario 10: markDepthVerified works in queue-only mode (no milestoneId) ──
-// This is the core regression for #1812: in queue mode, the tool_result handler
-// must call markDepthVerified() even when getDiscussionMilestoneId() is null.
+// ─── Scenario 10: depth verification is scoped per milestone, not global ──
 
-test('write-gate: markDepthVerified unblocks queue-mode writes when milestoneId is null', () => {
+test('write-gate: markDepthVerified unlocks only the matching milestone', () => {
   clearDiscussionFlowState();
-  setQueuePhaseActive(true);
+  markDepthVerified('M001');
 
-  // Before marking: should block
-  const blocked = shouldBlockContextWrite(
+  const allowed = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,
-    isDepthVerified(),
-    isQueuePhaseActive(),
   );
-  assert.strictEqual(blocked.block, true, 'should block before markDepthVerified');
+  assert.strictEqual(allowed.block, false, 'should allow the verified milestone');
 
-  // Simulate what the fixed tool_result handler does
-  markDepthVerified();
-
-  // After marking: should pass
-  const allowed = shouldBlockContextWrite(
+  const blockedOther = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
+    '.gsd/milestones/M002/M002-CONTEXT.md',
     null,
-    isDepthVerified(),
-    isQueuePhaseActive(),
   );
-  assert.strictEqual(allowed.block, false, 'should allow after markDepthVerified in queue mode');
+  assert.strictEqual(blockedOther.block, true, 'other milestones should remain blocked');
+  assert.strictEqual(isMilestoneDepthVerified('M001'), true);
+  assert.strictEqual(isMilestoneDepthVerified('M002'), false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 11: gsd_summary_save CONTEXT contract is milestone-scoped ──
+
+test('write-gate: gsd_summary_save only blocks final milestone CONTEXT writes', () => {
+  clearDiscussionFlowState();
+
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001').block,
+    false,
+    'draft CONTEXT should be allowed',
+  );
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001', 'S01').block,
+    false,
+    'slice CONTEXT should be allowed',
+  );
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001').block,
+    true,
+    'final milestone CONTEXT should block before verification',
+  );
+
+  markDepthVerified('M001');
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001').block,
+    false,
+    'final milestone CONTEXT should pass after verification',
+  );
+
+  clearDiscussionFlowState();
+});
 
+// ═══════════════════════════════════════════════════════════════════════
+// Discussion gate enforcement tests (pending gate mechanism)
+// ═══════════════════════════════════════════════════════════════════════
+
+import {
+  isGateQuestionId,
+  shouldBlockPendingGate,
+  shouldBlockPendingGateBash,
+  setPendingGate,
+  clearPendingGate,
+  getPendingGate,
+} from '../bootstrap/write-gate.ts';
+
+// ─── Scenario 19: isGateQuestionId recognizes all gate patterns ──
+
+test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
+  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer2_architecture_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer3_error_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer4_quality_gate'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification_M002'), true);
+  assert.strictEqual(isGateQuestionId('my_layer1_scope_gate_question'), true);
+  // Non-gate question IDs
+  assert.strictEqual(isGateQuestionId('project_intent'), false);
+  assert.strictEqual(isGateQuestionId('feature_priority'), false);
+  assert.strictEqual(isGateQuestionId(''), false);
+});
+
+// ─── Scenario 20: setPendingGate / getPendingGate / clearPendingGate lifecycle ──
+
+test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   clearDiscussionFlowState();
+  assert.strictEqual(getPendingGate(), null, 'starts null');
+
+  setPendingGate('layer1_scope_gate');
+  assert.strictEqual(getPendingGate(), 'layer1_scope_gate', 'set correctly');
+
+  clearPendingGate();
+  assert.strictEqual(getPendingGate(), null, 'cleared correctly');
+
+  // clearDiscussionFlowState also clears pending gate
+  setPendingGate('layer2_architecture_gate');
+  clearDiscussionFlowState();
+  assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
+});
+
+// ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
+
+test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // write should be blocked during discussion
+  const writeResult = shouldBlockPendingGate('write', 'M001', false);
+  assert.strictEqual(writeResult.block, true, 'write should be blocked');
+  assert.ok(writeResult.reason!.includes('layer1_scope_gate'), 'reason mentions the gate');
+
+  // edit should be blocked
+  const editResult = shouldBlockPendingGate('edit', 'M001', false);
+  assert.strictEqual(editResult.block, true, 'edit should be blocked');
+
+  // gsd tools should be blocked
+  const gsdResult = shouldBlockPendingGate('gsd_plan_milestone', 'M001', false);
+  assert.strictEqual(gsdResult.block, true, 'gsd tools should be blocked');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 22: shouldBlockPendingGate allows safe tools when gate is pending ──
+
+test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // ask_user_questions is always safe (model needs to re-ask)
+  assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
+  // read-only tools are safe
+  assert.strictEqual(shouldBlockPendingGate('read', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('grep', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('glob', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('ls', 'M001').block, false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 23: shouldBlockPendingGate still blocks when the session is ambiguous ──
+
+test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // No milestoneId and no queue phase — still block because the gate is pending
+  const result = shouldBlockPendingGate('write', null, false);
+  assert.strictEqual(result.block, true, 'should block even when milestoneId is null');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 24: shouldBlockPendingGate blocks in queue mode ──
+
+test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pending', () => {
+  clearDiscussionFlowState();
+  setQueuePhaseActive(true);
+  setPendingGate('depth_verification');
+
+  const result = shouldBlockPendingGate('write', null, true);
+  assert.strictEqual(result.block, true, 'should block in queue mode');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 25: shouldBlockPendingGateBash allows read-only commands ──
+
+test('write-gate: shouldBlockPendingGateBash allows read-only commands during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer2_architecture_gate');
+
+  assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('grep -r pattern .', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('ls -la', 'M001').block, false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 26: shouldBlockPendingGateBash blocks mutating commands ──
+
+test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer2_architecture_gate');
+
+  const result = shouldBlockPendingGateBash('npm run build', 'M001');
+  assert.strictEqual(result.block, true, 'mutating bash should be blocked');
+  assert.ok(result.reason!.includes('layer2_architecture_gate'));
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 27: no pending gate means no blocking ──
+
+test('write-gate: no pending gate means no blocking', () => {
+  clearDiscussionFlowState();
+
+  assert.strictEqual(shouldBlockPendingGate('write', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('npm run build', 'M001').block, false);
+});
+
+// ─── Scenario 28: resetWriteGateState clears pending gate ──
+
+test('write-gate: resetWriteGateState clears pending gate', () => {
+  setPendingGate('layer3_error_gate');
+  resetWriteGateState();
+  assert.strictEqual(getPendingGate(), null);
 });
 
 // ─── Standard options fixture used across depth confirmation tests ──

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

@@ -34,6 +34,24 @@ const TAB_LABELS = [
   "0 Export",
 ];
 
+type TabBarEntry = { label: string; width: number };
+
+function buildTabBarEntries(activeTab: number, filterText: string, capturesPendingCount?: number): TabBarEntry[] {
+  return TAB_LABELS.map((label, i) => {
+    let displayLabel = label;
+    if (i === activeTab && filterText) {
+      displayLabel += " \u2731";
+    }
+    if (i === 8 && capturesPendingCount) {
+      displayLabel += ` (${capturesPendingCount})`;
+    }
+    return {
+      label: displayLabel,
+      width: visibleWidth(displayLabel) + 2,
+    };
+  });
+}
+
 export class GSDVisualizerOverlay {
   private tui: { requestRender: () => void };
   private theme: Theme;
@@ -116,15 +134,14 @@ export class GSDVisualizerOverlay {
   }
 
   handleInput(data: string): void {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      this.dispose();
+      this.onClose();
+      return;
+    }
+
     // Filter mode input routing
     if (this.filterMode) {
-      if (matchesKey(data, Key.escape)) {
-        this.filterMode = false;
-        this.filterText = "";
-        this.invalidate();
-        this.tui.requestRender();
-        return;
-      }
       if (matchesKey(data, Key.enter)) {
         this.filterMode = false;
         this.invalidate();
@@ -179,8 +196,9 @@ export class GSDVisualizerOverlay {
         // Left click — check if on tab bar row
         if (mouse.y === 2) {
           let xPos = 3;
-          for (let i = 0; i < TAB_LABELS.length; i++) {
-            const tabWidth = TAB_LABELS[i].length + 2;
+          const tabs = buildTabBarEntries(this.activeTab, this.filterText, this.data?.captures?.pendingCount);
+          for (let i = 0; i < tabs.length; i++) {
+            const tabWidth = tabs[i]!.width;
             if (mouse.x >= xPos && mouse.x < xPos + tabWidth) {
               this.activeTab = i;
               this.invalidate();
@@ -194,12 +212,6 @@ export class GSDVisualizerOverlay {
       return;
     }
 
-    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
-      this.dispose();
-      this.onClose();
-      return;
-    }
-
     if (matchesKey(data, Key.shift("tab"))) {
       this.activeTab = (this.activeTab - 1 + TAB_COUNT) % TAB_COUNT;
       this.invalidate();
@@ -442,20 +454,12 @@ export class GSDVisualizerOverlay {
     const content: string[] = [];
 
     // Tab bar
-    const tabs = TAB_LABELS.map((label, i) => {
-      let displayLabel = label;
-      // Show filter indicator on active tab with filter
-      if (i === this.activeTab && this.filterText) {
-        displayLabel += " \u2731";
-      }
-      // Show captures badge
-      if (i === 8 && this.data?.captures?.pendingCount) {
-        displayLabel += ` (${this.data.captures.pendingCount})`;
-      }
+    const tabEntries = buildTabBarEntries(this.activeTab, this.filterText, this.data?.captures?.pendingCount);
+    const tabs = tabEntries.map((entry, i) => {
       if (i === this.activeTab) {
-        return th.fg("accent", `[${displayLabel}]`);
+        return th.fg("accent", `[${entry.label}]`);
       }
-      return th.fg("dim", `[${displayLabel}]`);
+      return th.fg("dim", `[${entry.label}]`);
     });
     content.push(" " + tabs.join(" "));
     content.push("");