@opengsd/gsd-pi 1.2.0-dev.d6c5343c → 1.2.0-dev.ddc97c10

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -154,6 +154,29 @@ function parseTableSlices(section: string): RoadmapSliceEntry[] {
   return slices;
 }
 
+function looksLikeTable(section: string): boolean {
+  const lines = section.split("\n");
+
+  // Checkbox format takes precedence — embedded demo tables must not switch mode (#721).
+  if (lines.some(line => /^\s*-\s+\[[ xX]\]/.test(line))) {
+    return false;
+  }
+
+  const pipeLines = lines.filter(line => /^\s*\|/.test(line));
+  if (pipeLines.length < 2) return false;
+
+  const hasSeparatorRow = pipeLines.some((line, index) => {
+    if (index === 0) return false;
+    const cells = line.split("|").map(c => c.trim()).filter(Boolean);
+    return /^\s*\|[\s:-]+\|/.test(line) && cells.length >= 2 && cells.every(c => /^[\s:-]+$/.test(c));
+  });
+
+  if (hasSeparatorRow) return true;
+
+  // Tables without a separator row still expose slice IDs in data rows.
+  return pipeLines.some(line => /\bS\d+\b/.test(line));
+}
+
 export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
   const slicesSection = extractSlicesSection(content);
   if (!slicesSection) {
@@ -165,9 +188,11 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
 
   // Try table format first — if the section contains pipe-delimited rows with
   // slice IDs, parse them as a table (#1736).
-  const tableSlices = parseTableSlices(slicesSection);
-  if (tableSlices.length > 0) {
-    return tableSlices;
+  if (looksLikeTable(slicesSection)) {
+    const tableSlices = parseTableSlices(slicesSection);
+    if (tableSlices.length > 0) {
+      return tableSlices;
+    }
   }
 
   // Standard checkbox format

package/src/resources/extensions/gsd/session-lock.ts

@@ -387,7 +387,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     // #3218: Provide actionable workaround when lock recovery fails
     const lockDirPath = lockTarget + ".lock";
     const reason = existingPid
-      ? `Another auto-mode session (PID ${existingPid}) appears to be running.\nStop it with \`kill ${existingPid}\` before starting a new session.`
+      ? `Another auto-mode session (PID ${existingPid}) appears to be running.\nRun \`/gsd stop\` for graceful shutdown, or choose "Force start" from \`/gsd auto\` to terminate it.`
       : `Another auto-mode session lock is stuck on this project.\nRun: rm -rf "${lockDirPath}" && rm -f "${lp}"`;
 
     return { acquired: false, reason, existingPid };

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
+import { blockModelUntil, clearTemporaryModelBlocksForTest } from "../blocked-models.ts";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
@@ -223,6 +224,74 @@ test("selectAndApplyModel honors explicit phase models without downgrading (#361
   }
 });
 
+test("selectAndApplyModel skips a rate-limited primary until its reset time", async () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-rate-limit-fallback-project-");
+  const tempGsdHome = makeTempDir("gsd-rate-limit-fallback-home-");
+  const setModelCalls: string[] = [];
+
+  try {
+    clearTemporaryModelBlocksForTest();
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  execution:",
+        "    model: gpt-5.5",
+        "    provider: openai-codex",
+        "    fallbacks:",
+        "      - anthropic/claude-sonnet-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const availableModels = [
+      { id: "gpt-5.5", provider: "openai-codex", api: "responses" },
+      { id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" },
+    ];
+    const ctx = {
+      modelRegistry: { getAvailable: () => availableModels },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "openai-codex", id: "gpt-5.5", api: "responses" },
+    } as any;
+    const pi = {
+      setModel: async (model: { provider: string; id: string }) => {
+        setModelCalls.push(`${model.provider}/${model.id}`);
+        return true;
+      },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any;
+
+    blockModelUntil(tempProject, "openai-codex", "gpt-5.5", Date.now() + 60_000, "session limit");
+    await selectAndApplyModel(ctx, pi, "execute-task", "M001/S01/T01", tempProject, undefined, false, { provider: "openai-codex", id: "gpt-5.5" }, undefined, true);
+
+    blockModelUntil(tempProject, "openai-codex", "gpt-5.5", Date.now() - 1, "expired");
+    await selectAndApplyModel(ctx, pi, "execute-task", "M001/S01/T02", tempProject, undefined, false, { provider: "openai-codex", id: "gpt-5.5" }, undefined, true);
+
+    assert.deepEqual(setModelCalls, [
+      "anthropic/claude-sonnet-4-6",
+      "openai-codex/gpt-5.5",
+    ]);
+  } finally {
+    clearTemporaryModelBlocksForTest();
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("selectAndApplyModel lets explicit unit models bypass stale cross-provider lock (#116)", async () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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

@@ -1223,6 +1223,103 @@ test("decideOrchestratorDispatch forwards constructor session when advance input
   }
 });
 
+test("decideOrchestratorDispatch evaluates deep pre-planning rules without an active milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+});
+
+test("decideOrchestratorDispatch does not replay milestone-scoped verification retry when no milestone is active", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-no-active-retry-"));
+  t.after(() => {
+    resetRegistry();
+    rmSync(base, { recursive: true, force: true });
+  });
+  resetRegistry();
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "workflow_prefs_captured: true",
+      "---",
+      "",
+    ].join("\n"),
+  );
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: null,
+    phase: "pre-planning",
+    nextAction: "All remaining milestones are parked (M027). Run /gsd unpark M027 or create a new milestone.",
+    registry: [{ id: "M027", title: "Parked", status: "parked" }],
+  };
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as never;
+  const pi = { getActiveTools: () => [] } as never;
+  const stalePendingRetry = {
+    unitType: "execute-task",
+    unitId: "M027.S1.T1",
+    prompt: "stale retry prompt",
+    pauseAfterUatDispatch: false,
+    state: stateSnapshot,
+    mid: "M027",
+    midTitle: "Parked",
+  };
+  const session = {
+    basePath: base,
+    originalBasePath: base,
+    currentMilestoneId: "M027",
+    pendingVerificationRetryDispatch: stalePendingRetry,
+  } as never;
+
+  const result = await decideOrchestratorDispatch(ctx, pi, base, session, { stateSnapshot });
+
+  assert.ok(result && "unitType" in result, `expected project-level dispatch, got ${JSON.stringify(result)}`);
+  assert.equal(result.unitType, "discuss-project");
+  assert.equal(result.unitId, "PROJECT");
+  // The stale retry must be preserved for a future tick, not consumed by this
+  // no-active-milestone path (mirrors pre-#712-fix behavior where !active
+  // returned null before touching the retry).
+  const sess = session as unknown as { pendingVerificationRetryDispatch: unknown };
+  assert.equal(sess.pendingVerificationRetryDispatch, stalePendingRetry);
+});
+
 test("decideOrchestratorDispatch adopts next active milestone after the session milestone is closed", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-milestone-adopt-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -1,12 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { checkRemoteAutoSession } from "../auto.ts";
+import { checkRemoteAutoSession, forceStopAutoRemote } from "../auto.ts";
 import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { getAutoWorker, registerAutoWorker } from "../db/auto-workers.ts";
+import { claimMilestoneLease, getMilestoneLease } from "../db/milestone-leases.ts";
 import { normalizeRealPath } from "../paths.ts";
 import { readCrashLock } from "../crash-recovery.ts";
 
@@ -35,6 +36,29 @@ function setWorkerPid(workerId: string, pid: number): void {
   ).run({ ":pid": pid, ":worker_id": workerId });
 }
 
+function insertMilestone(id: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `INSERT INTO milestones (id, title, status, created_at)
+     VALUES (:id, :title, 'active', :created_at)`,
+  ).run({
+    ":id": id,
+    ":title": id,
+    ":created_at": new Date().toISOString(),
+  });
+}
+
+function writeLegacyLock(base: string, pid: number): void {
+  const now = new Date().toISOString();
+  writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify({
+    pid,
+    startedAt: now,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: now,
+  }));
+}
+
 function findDeadPidCandidate(): number {
   const candidates = [99_999, 199_999, 299_999, 399_999];
   for (const pid of candidates) {
@@ -62,3 +86,41 @@ test("checkRemoteAutoSession clears stale lock state when lock PID is dead", (t)
   assert.deepEqual(remote, { running: false });
   assert.equal(readCrashLock(base), null, "stale lock should be cleared by remote session check");
 });
+
+test("forceStopAutoRemote escalates a live remote PID and releases worker state", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  const pid = 424_242;
+  setWorkerPid(workerId, pid);
+  insertMilestone("M001");
+  writeLegacyLock(base, pid);
+  const lease = claimMilestoneLease(workerId, "M001");
+  assert.equal(lease.ok, true, "precondition: worker holds a milestone lease");
+
+  const signals: Array<NodeJS.Signals | 0> = [];
+  const originalKill = process.kill;
+  process.kill = ((target: number, signal?: NodeJS.Signals | number) => {
+    assert.equal(target, pid);
+    signals.push((signal ?? 0) as NodeJS.Signals | 0);
+    return true;
+  }) as typeof process.kill;
+  t.after(() => {
+    process.kill = originalKill;
+  });
+
+  const result = forceStopAutoRemote(base);
+
+  assert.deepEqual(result, { found: true, pid });
+  assert.ok(signals.includes("SIGTERM"), "force stop should request graceful termination first");
+  assert.ok(signals.includes("SIGKILL"), "force stop should escalate when the PID is still alive");
+  assert.equal(getAutoWorker(workerId)?.status, "stopping");
+  assert.equal(
+    getMilestoneLease("M001")?.status,
+    "released",
+    "force stop should release held milestone leases",
+  );
+  assert.equal(readCrashLock(base), null, "force stop should remove the visible remote lock");
+});

package/src/resources/extensions/gsd/tests/blocked-models.test.ts

@@ -8,7 +8,10 @@ import { join } from "node:path";
 
 import {
   blockModel,
+  blockModelUntil,
+  clearTemporaryModelBlocksForTest,
   isModelBlocked,
+  isModelTemporarilyUnavailable,
   loadBlockedModels,
 } from "../blocked-models.ts";
 
@@ -96,3 +99,19 @@ test("blocked-models: file created under .gsd/runtime/", () => {
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("blocked-models: temporary rate-limit blocks expire without persisting", () => {
+  const base = mkBase();
+  try {
+    clearTemporaryModelBlocksForTest();
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() + 60_000, "session limit");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), true);
+    assert.equal(loadBlockedModels(base).length, 0, "rate-limit windows must not persist as account blocks");
+
+    blockModelUntil(base, "openai-codex", "gpt-5.5", Date.now() - 1, "expired");
+    assert.equal(isModelTemporarilyUnavailable(base, "openai-codex", "gpt-5.5"), false);
+  } finally {
+    clearTemporaryModelBlocksForTest();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/consent-question.test.ts

@@ -238,6 +238,21 @@ test("isAwaitingUserInput does not trigger on thinking-block approval phrases",
   assert.equal(shouldPauseForQuestion("discuss-requirements", messages), false);
 });
 
+test("isAwaitingUserInput treats plain-text next steps menus as waiting for the user (#454)", () => {
+  const messages = [
+    {
+      role: "assistant",
+      content: [
+        "Next steps:",
+        "1. Walk through the runtime placement check above.",
+        "2. Build a release once you're satisfied.",
+        "3. Other.",
+      ].join("\n"),
+    },
+  ];
+  assert.equal(isAwaitingUserInput(messages), true);
+});
+
 test("isAwaitingUserInput still triggers on text-block question marks when thinking is also present", () => {
   // When thinking + text are both present and the text asks a question, it should still pause.
   const messages = [

package/src/resources/extensions/gsd/tests/doctor-git-checks-terminal.test.ts

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Doctor git checks treat validation-pass closeout as terminal without SUMMARY.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { openDatabase, insertMilestone, insertSlice, insertAssessment, closeDatabase } from "../gsd-db.js";
+import { createWorktree, worktreePath } from "../worktree-manager.ts";
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-terminal-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, "package.json"), "{\"scripts\":{}}\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+  return base;
+}
+
+test.after(() => {
+  closeDatabase();
+});
+
+test("doctor flags orphaned worktree for DB-complete milestone without SUMMARY", async (t) => {
+  const base = makeRepo();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M008", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M008/M008-VALIDATION.md",
+    milestoneId: "M008",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\ngit:\n  isolation: worktree\n---\n",
+  );
+  mkdirSync(join(base, ".gsd", "milestones", "M008"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M008", "M008-ROADMAP.md"),
+    "# M008 Roadmap\n\n- [x] **S01: Slice** `risk:low` `depends:[]`\n",
+  );
+
+  createWorktree(base, "M008", { branch: "milestone/M008" });
+  const wtPath = worktreePath(base, "M008");
+  assert.ok(existsSync(wtPath), "worktree should exist for the test");
+
+  const report = await runGSDDoctor(base, { isolationMode: "worktree" });
+
+  assert.ok(
+    report.issues.some((issue) => issue.code === "orphaned_auto_worktree" && issue.unitId === "M008"),
+    "doctor should treat DB-complete milestone without SUMMARY as terminal for cleanup",
+  );
+});

package/src/resources/extensions/gsd/tests/gsd-command-home.test.ts

@@ -4,10 +4,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { buildGsdHomeModel, showGsdHome } from "../gsd-command-home.ts";
+import { buildIdleMenuSummary, detectIdleMilestoneResidueHint } from "../closeout-wizard.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
 import type { GSDState } from "../types.ts";
 
 function baseState(overrides: Partial<GSDState> = {}): GSDState {
@@ -118,6 +121,123 @@ test("/gsd home recommends start or configure after all milestones complete", ()
   assert.match(model.summary.join("\n"), /All milestones complete/);
 });
 
+test("/gsd home recommends fix or recover when milestone git residue is stranded", () => {
+  const model = buildGsdHomeModel(baseState({
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "complete",
+    nextAction: "All milestones complete.",
+  }), {
+    strandedQuick: null,
+    unmergedMilestones: [],
+    idleResidueHint: {
+      milestoneIds: ["M008"],
+      message:
+        "Stranded milestone git residue detected (M008: worktree dir and/or milestone/* branch). " +
+        "Run /gsd dispatch complete-milestone M008 or /gsd status to recover closeout before starting new work.",
+    },
+  });
+
+  assert.equal(action(model, "fix_recover").recommended, true);
+  assert.equal(action(model, "fix_recover").enabled, true);
+  assert.match(model.summary[0], /Stranded milestone git residue/);
+  assert.equal(action(model, "continue_step").enabled, false);
+});
+
+test("detectIdleMilestoneResidueHint reports missing workflow database in a git repo", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-"));
+  try {
+    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
+    const hint = detectIdleMilestoneResidueHint(base);
+    assert.ok(hint);
+    assert.match(hint!.message, /\.gsd\/gsd\.db/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("detectIdleMilestoneResidueHint matches unique-format milestone ids (M###-abc123)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-unique-"));
+  try {
+    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd-worktrees", "M042-abc123"), { recursive: true });
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    try {
+      // Closed milestone with lingering worktree dir — classic residue.
+      insertMilestone({ id: "M042-abc123", title: "Closed Unique", status: "complete" });
+      const hint = detectIdleMilestoneResidueHint(base);
+      assert.ok(hint, "unique-format closed milestone with worktree should be detected");
+      assert.deepEqual(hint!.milestoneIds, ["M042-abc123"]);
+      assert.match(hint!.message, /M042-abc123/);
+    } finally {
+      closeDatabase();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("detectIdleMilestoneResidueHint ignores in-flight milestones with worktree artifacts", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-active-"));
+  try {
+    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd-worktrees", "M001"), { recursive: true });
+    mkdirSync(join(base, ".gsd-worktrees", "M002-abc123"), { recursive: true });
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    try {
+      // Active and pending milestones must not be flagged as stranded residue.
+      insertMilestone({ id: "M001", title: "Active milestone", status: "active" });
+      insertMilestone({ id: "M002-abc123", title: "Pending milestone", status: "pending" });
+      const hint = detectIdleMilestoneResidueHint(base);
+      assert.equal(hint, null, "active/pending milestone worktrees must not be classified as residue");
+    } finally {
+      closeDatabase();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("buildIdleMenuSummary surfaces idle residue hint even when phase is complete", () => {
+  const summary = buildIdleMenuSummary(
+    {
+      activeMilestone: null,
+      activeSlice: null,
+      activeTask: null,
+      phase: "complete",
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "All milestones complete.",
+      lastCompletedMilestone: { id: "M001", title: "Menu Cleanup" },
+      registry: [{ id: "M001", title: "Menu Cleanup", status: "complete" }],
+      requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      progress: {
+        milestones: { done: 1, total: 1 },
+        slices: { done: 0, total: 0 },
+        tasks: { done: 0, total: 0 },
+      },
+    },
+    {
+      strandedQuick: null,
+      unmergedMilestones: [],
+      idleResidueHint: {
+        milestoneIds: ["M008"],
+        message:
+          "Stranded milestone git residue detected (M008: worktree dir and/or milestone/* branch). " +
+          "Run /gsd dispatch complete-milestone M008 or /gsd status to recover closeout before starting new work.",
+      },
+    },
+  );
+
+  assert.match(summary[0] ?? "", /Stranded milestone git residue/);
+  assert.doesNotMatch(summary.join("\n"), /All milestones complete/);
+});
+
 test("showGsdHome renders the five-slot home text without an interactive TUI", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-home-"));
   const notifications: Array<{ message: string; level: string }> = [];

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -77,12 +77,8 @@ test("guided dispatch passes the explicit project root through model and compati
             seen.modelRoot = projectRoot;
             return { routing: null, appliedModel: null };
           },
-          getTransportSupportError: (
-            _provider: string | undefined,
-            _requiredTools: string[],
-            options?: { projectRoot?: string },
-          ) => {
-            seen.compatibilityRoot = options?.projectRoot ?? "";
+          getDispatchReadinessError: (input: { projectRoot?: string }) => {
+            seen.compatibilityRoot = input.projectRoot ?? "";
             return null;
           },
         },