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

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -9,6 +9,7 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -177,3 +178,47 @@ test("detectHealthWidgetProjectState: metrics file alone does not imply project"
   );
   assert.equal(detectHealthWidgetProjectState(dir), "initialized");
 });
+
+test("session_start bootstraps the health widget alongside notifications", async (t) => {
+  const dir = makeTempDir("bootstrap");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  t.after(() => {
+    process.chdir(originalCwd);
+    cleanup(dir);
+  });
+
+  const widgets: string[] = [];
+  const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
+  const pi = {
+    on(event: string, handler: (event: unknown, ctx: any) => Promise<void> | void) {
+      handlers.set(event, handler);
+    },
+  } as any;
+
+  registerHooks(pi);
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler is registered");
+
+  await sessionStart!({}, {
+    hasUI: true,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+      setWidget: (key: string) => {
+        widgets.push(key);
+      },
+    },
+    sessionManager: {
+      getSessionId: () => null,
+    },
+    model: null,
+  } as any);
+
+  assert.ok(widgets.includes("gsd-health"), "health widget is bootstrapped");
+  assert.ok(widgets.includes("gsd-notifications"), "notification widget still boots");
+});

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

@@ -1,9 +1,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
 
 import {
   resolveExpectedArtifactPath,
@@ -11,6 +12,7 @@ import {
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
   hasImplementationArtifacts,
+  reconcileMergeState,
 } from "../../auto-recovery.ts";
 import { parseRoadmap, parsePlan } from "../../parsers-legacy.ts";
 import { parseTaskPlanFile, clearParseCache } from "../../files.ts";
@@ -669,8 +671,6 @@ test("#793: invalidateAllCaches clears all caches so deriveState sees fresh disk
 
 // ─── hasImplementationArtifacts (#1703) ───────────────────────────────────
 
-import { execFileSync } from "node:child_process";
-
 function makeGitBase(): string {
   const base = join(tmpdir(), `gsd-test-git-${randomUUID()}`);
   mkdirSync(base, { recursive: true });
@@ -745,9 +745,6 @@ test("verifyExpectedArtifact complete-milestone fails with only .gsd/ files (#17
 
 // ─── reconcileMergeState: silent nativeCommit failure (#2542) ─────────────
 
-import { reconcileMergeState } from "../../auto-recovery.ts";
-import { chmodSync } from "node:fs";
-
 function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: string }> } {
   const notifications: Array<{ msg: string; level: string }> = [];
   const ctx = {
@@ -760,7 +757,7 @@ function makeMockCtx(): { ctx: any; notifications: Array<{ msg: string; level: s
   return { ctx, notifications };
 }
 
-test("reconcileMergeState returns false and notifies error when nativeCommit fails (#2542)", (t) => {
+test("reconcileMergeState returns blocked and notifies error when nativeCommit fails (#2542)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
@@ -786,9 +783,7 @@ test("reconcileMergeState returns false and notifies error when nativeCommit fai
   const { ctx, notifications } = makeMockCtx();
   const result = reconcileMergeState(base, ctx);
 
-  // The function should return false to signal reconciliation failure
-  // (Currently it silently swallows the error and returns true — this test should FAIL before the fix)
-  assert.equal(result, false, "reconcileMergeState should return false when nativeCommit fails");
+  assert.equal(result, "blocked", "reconcileMergeState should return blocked when nativeCommit fails");
   const errorNotifications = notifications.filter(n => n.level === "error");
   assert.ok(errorNotifications.length > 0, "should notify an error when nativeCommit fails");
   assert.ok(
@@ -797,18 +792,63 @@ test("reconcileMergeState returns false and notifies error when nativeCommit fai
   );
 });
 
-test("reconcileMergeState returns true when no merge state present", (t) => {
-  // When there's no MERGE_HEAD or SQUASH_MSG, reconcileMergeState returns false (no dirty state)
+test("reconcileMergeState returns clean when no merge state present", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));
 
   const { ctx, notifications } = makeMockCtx();
   const result = reconcileMergeState(base, ctx);
 
-  assert.equal(result, false, "should return false when no merge state exists");
+  assert.equal(result, "clean", "should return clean when no merge state exists");
   assert.equal(notifications.length, 0, "should not notify when no merge state present");
 });
 
+test("reconcileMergeState blocks and preserves unresolved code conflicts", (t) => {
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  writeFileSync(join(base, "conflict.txt"), "base\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "add conflict base"], { cwd: base, stdio: "ignore" });
+
+  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "conflict.txt"), "feature\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "feature change"], { cwd: base, stdio: "ignore" });
+
+  execFileSync("git", ["checkout", "main"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "conflict.txt"), "main\n");
+  execFileSync("git", ["add", "conflict.txt"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "main change"], { cwd: base, stdio: "ignore" });
+
+  let mergeFailed = false;
+  try {
+    execFileSync("git", ["merge", "--no-ff", "feature"], { cwd: base, stdio: "ignore" });
+  } catch {
+    mergeFailed = true;
+  }
+  assert.equal(mergeFailed, true, "merge should produce a conflict");
+  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should remain present before reconcile");
+
+  const beforeContents = readFileSync(join(base, "conflict.txt"), "utf8");
+  assert.match(beforeContents, /<<<<<<<|=======|>>>>>>>/, "fixture should contain conflict markers");
+
+  const { ctx, notifications } = makeMockCtx();
+  const result = reconcileMergeState(base, ctx);
+
+  assert.equal(result, "blocked", "code conflicts should block reconciliation");
+  assert.ok(existsSync(join(base, ".git", "MERGE_HEAD")), "MERGE_HEAD should be preserved for manual resolution");
+  assert.equal(
+    readFileSync(join(base, "conflict.txt"), "utf8"),
+    beforeContents,
+    "reconcile should preserve the conflicted file contents",
+  );
+  assert.ok(
+    notifications.some((n) => n.level === "error" && n.msg.includes("manual conflict resolution is preserved")),
+    "should notify that auto-mode paused and preserved manual work",
+  );
+});
+
 test("verifyExpectedArtifact complete-milestone passes with impl files (#1703)", (t) => {
   const base = makeGitBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -360,8 +360,8 @@ describe("session management", () => {
     assert.equal(s.unitRecoveryCount.size, 0, "recovery counts cleared");
   });
 
-  test("NEW_SESSION_TIMEOUT_MS is 30 seconds", () => {
-    assert.equal(NEW_SESSION_TIMEOUT_MS, 30_000, "session timeout should be 30s");
+  test("NEW_SESSION_TIMEOUT_MS is 120 seconds", () => {
+    assert.equal(NEW_SESSION_TIMEOUT_MS, 120_000, "session timeout should be 120s");
   });
 
   test("MAX_UNIT_DISPATCHES limits retries for a single unit", () => {

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

@@ -72,7 +72,7 @@ function makeMockDeps(
     getCurrentBranch: () => "main",
     autoWorktreeBranch: () => "auto/M001",
     resolveMilestoneFile: () => null,
-    reconcileMergeState: () => false,
+    reconcileMergeState: () => "clean",
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

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

@@ -273,9 +273,9 @@ test('Scenario 2: Fully complete project — deriveState phase', async () => {
       invalidateAllCaches();
       const state = await deriveState(base);
       assert.deepStrictEqual(state.phase, 'complete', 'complete: deriveState phase is complete (validation + summary written by migration)');
-      // When all milestones are complete, activeMilestone points to the last entry (for display)
-      assert.ok(state.activeMilestone !== null, 'complete: deriveState has activeMilestone (last entry)');
-      assert.deepStrictEqual(state.activeMilestone!.id, 'M001', 'complete: deriveState activeMilestone is M001');
+      assert.equal(state.activeMilestone, null, 'complete: deriveState has no activeMilestone');
+      assert.ok(state.lastCompletedMilestone !== null, 'complete: deriveState exposes lastCompletedMilestone');
+      assert.deepStrictEqual(state.lastCompletedMilestone!.id, 'M001', 'complete: deriveState lastCompletedMilestone is M001');
 
       // generatePreview for complete project
       const preview = generatePreview(project);
@@ -292,4 +292,3 @@ test('Scenario 2: Fully complete project — deriveState phase', async () => {
       rmSync(base, { recursive: true, force: true });
     }
 });
-

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

@@ -57,4 +57,25 @@ describe("parallel-monitor-overlay", () => {
     assert.ok(closed, "pressing q should trigger onClose");
     overlay2.dispose();
   });
+
+  it("ParallelMonitorOverlay clamps scrollOffset during render", async () => {
+    const mod = await import("../parallel-monitor-overlay.js");
+
+    const mockTui = { requestRender: () => {} };
+    const mockTheme = {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const overlay = new mod.ParallelMonitorOverlay(
+      mockTui,
+      mockTheme as any,
+      () => {},
+      "/nonexistent/path",
+    );
+
+    (overlay as any).scrollOffset = 999;
+    overlay.render(80);
+    assert.equal((overlay as any).scrollOffset, 0, "empty overlays clamp scroll to zero");
+    overlay.dispose();
+  });
 });

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -4,12 +4,15 @@
  * Verifies the dispatch rule and prompt builder exist with correct structure.
  */
 
-import test from "node:test";
+import test, { afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
+import { resolveDispatch } from "../auto-dispatch.ts";
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
@@ -17,6 +20,47 @@ const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8
 const templatePath = join(__dirname, "..", "prompts", "parallel-research-slices.md");
 const templateSrc = readFileSync(templatePath, "utf-8");
 
+const tmpDirs: string[] = [];
+
+function makeTmpProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "parallel-research-"));
+  tmpDirs.push(base);
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Parallel Research Milestone",
+      "",
+      "**Vision:** Research-ready slices.",
+      "",
+      "**Success Criteria:**",
+      "- Research both slices",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+      "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+      "",
+      "## Boundary Map",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  return base;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // Best-effort cleanup only.
+    }
+  }
+  tmpDirs.length = 0;
+});
+
 // ─── Dispatch rule ────────────────────────────────────────────────────────
 
 test("dispatch: parallel-research-slices rule exists", () => {
@@ -75,3 +119,28 @@ test("template: validate-milestone uses parallel reviewers", () => {
     "validate-milestone should dispatch 3 parallel reviewers",
   );
 });
+
+test("resolveDispatch prefers parallel research when multiple slices are ready", async () => {
+  const base = makeTmpProject();
+
+  const action = await resolveDispatch({
+    basePath: base,
+    mid: "M001",
+    midTitle: "Parallel Research Milestone",
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Parallel Research Milestone", status: "active" },
+      activeSlice: { id: "S01", title: "Alpha" },
+      activeTask: null,
+      registry: [],
+      blockers: [],
+    } as any,
+    prefs: undefined,
+  });
+
+  assert.equal(action.action, "dispatch");
+  if (action.action === "dispatch") {
+    assert.equal(action.unitType, "research-slice");
+    assert.equal(action.unitId, "M001/parallel-research");
+  }
+});

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/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);
@@ -188,7 +194,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/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 });
   }