@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

package/src/resources/extensions/gsd/tests/ask-user-questions-render.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Regression tests for ask_user_questions renderResult when Claude Code MCP
+ * omits structuredContent and the chat controller passes details as undefined
+ * or an empty object.
+ */
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import askUserQuestionsExtension from "../../ask-user-questions.ts";
+
+const fakeTheme = {
+	fg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+function getAskUserQuestionsTool() {
+	const tools: any[] = [];
+	askUserQuestionsExtension({ registerTool: (tool: any) => tools.push(tool) } as any);
+	const tool = tools.find((t) => t.name === "ask_user_questions");
+	assert.ok(tool, "ask_user_questions should be registered");
+	return tool;
+}
+
+function renderText(tool: any, result: unknown, args?: unknown): string {
+	const rendered = tool.renderResult(result, {}, fakeTheme, { args });
+	return String((rendered as any).content ?? (rendered as any).text ?? rendered);
+}
+
+const depthQuestion = {
+	id: "depth_check",
+	header: "Depth Check",
+	question: "Did I capture the depth right?",
+	options: [
+		{ label: "Yes, you got it", description: "Proceed" },
+		{ label: "Not quite - let me clarify", description: "Clarify" },
+	],
+};
+
+test("ask_user_questions renderResult shows answers when details is undefined (MCP text-only wire)", () => {
+	const tool = getAskUserQuestionsTool();
+	const contentText = JSON.stringify({
+		answers: { depth_check: { answers: ["Yes, you got it"] } },
+	});
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: contentText }],
+			details: undefined,
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /✓/);
+	assert.match(text, /Depth Check/);
+	assert.match(text, /Yes, you got it/);
+	assert.doesNotMatch(text, /Cancelled/i);
+});
+
+test("ask_user_questions renderResult shows answers when details is empty object (#cc-elicitation)", () => {
+	const tool = getAskUserQuestionsTool();
+	const contentText = JSON.stringify({
+		answers: { depth_check: { answers: ["Yes, you got it"] } },
+	});
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: contentText }],
+			details: {},
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /Yes, you got it/);
+	assert.doesNotMatch(text, /Cancelled/i);
+});
+
+test("ask_user_questions renderResult still shows Cancelled for explicit cancel payload", () => {
+	const tool = getAskUserQuestionsTool();
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: "ask_user_questions was cancelled before receiving a response" }],
+			details: { questions: [depthQuestion], response: null, cancelled: true },
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /Cancelled/i);
+});

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

@@ -29,11 +29,16 @@ import {
   _refreshLastCommitForTests,
   _getLastCommitForTests,
   _getLastCommitFetchedAtForTests,
+  formatToolSurfaceSnapshot,
   formatRuntimeHealthSignal,
   shouldRenderRoadmapProgress,
 } from "../auto-dashboard.ts";
 import { getAutoDashboardData } from "../auto.ts";
-import { autoSession } from "../auto-runtime-state.ts";
+import {
+  autoSession,
+  clearAutoToolSurfaceSnapshot,
+  recordAutoToolSurfaceSnapshot,
+} from "../auto-runtime-state.ts";
 import { formatRtkSavingsLabel } from "../../shared/rtk-session-stats.ts";
 import {
   openDatabase,
@@ -530,6 +535,29 @@ test("getAutoDashboardData returns RTK savings in the dashboard payload", () =>
   }
 });
 
+test("getAutoDashboardData exposes typed tool-surface snapshots", () => {
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+  autoSession.active = true;
+  recordAutoToolSurfaceSnapshot({
+    source: "provider-adjustment",
+    unitType: "run-uat",
+    modelFacingToolNames: ["read"],
+    registeredToolNames: ["read", "browser_navigate"],
+    scopedToolNames: ["read", "browser_navigate"],
+    presentedToolNames: ["browser_navigate"],
+    capturedAt: 456,
+  });
+
+  const data = getAutoDashboardData();
+
+  assert.equal(data.toolSurface?.source, "provider-adjustment");
+  assert.equal(formatToolSurfaceSnapshot(data.toolSurface), "run-uat: model 1 / registered 2 / scoped 2 / presented 1");
+
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+});
+
 test("RTK savings label formats the dashboard footer text", () => {
   assert.equal(formatRtkSavingsLabel(null), null);
   assert.equal(

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

@@ -23,11 +23,12 @@ import {
 import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
 import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
-import { autoLoop } from "../auto/loop.js";
-import { runDispatch, runUnitPhase } from "../auto/phases.js";
+import { autoLoop as rawAutoLoop } from "../auto/loop.js";
+import { runPreDispatch, runDispatch, runUnitPhase } from "../auto/phases.js";
 import { detectStuck } from "../auto/detect-stuck.js";
-import type { UnitResult, AgentEndEvent } from "../auto/types.js";
+import type { UnitResult, AgentEndEvent, LoopState } from "../auto/types.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
+import type { AutoAdvanceResult, AutoOrchestrationModule, AutoStatus, UnitRef } from "../auto/contracts.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import type { SessionLockStatus } from "../session-lock.js";
@@ -40,6 +41,17 @@ import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
+const ORCHESTRATION_MISSING_REASON =
+  "Auto Orchestration Module is not wired; cannot dispatch built-in GSD Unit.";
+
+type CapturedAutoSideEffects<T> = {
+  result: T;
+  stopped: boolean;
+  stoppedReason?: string;
+  paused: boolean;
+  pausedReason?: string;
+};
+
 function makeEvent(
   messages: unknown[] = [{ role: "assistant" }],
 ): AgentEndEvent {
@@ -67,12 +79,203 @@ async function waitForMicrotasks(
   assert.fail(`Timed out waiting for ${label}`);
 }
 
+function makeLoopState(): LoopState {
+  return {
+    recentUnits: [],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null,
+    lastDispatchPhase: null,
+  };
+}
+
+function createLoopTestOrchestration(
+  ctx: any,
+  pi: any,
+  s: any,
+  deps: LoopDeps,
+): AutoOrchestrationModule {
+  // Production auto.ts wires the real Auto Orchestration Module before entering
+  // autoLoop. These loop-mechanics tests keep their LoopDeps fixtures by
+  // adapting the old phase helpers to the public orchestration Interface.
+  const loopState = makeLoopState();
+  const status: AutoStatus = { phase: "running", transitionCount: 0 };
+  let iteration = 0;
+  let seq = 0;
+
+  function nextSeq(): number {
+    return ++seq;
+  }
+
+  function clearActiveUnit(): void {
+    status.activeUnit = undefined;
+  }
+
+  async function captureAutoSideEffects<T>(
+    run: () => Promise<T>,
+  ): Promise<CapturedAutoSideEffects<T>> {
+    const originalStopAuto = deps.stopAuto;
+    const originalPauseAuto = deps.pauseAuto;
+    let stoppedReason: string | undefined;
+    let pausedReason: string | undefined;
+    let stopped = false;
+    let paused = false;
+
+    (deps as any).stopAuto = async (...args: Parameters<LoopDeps["stopAuto"]>) => {
+      stopped = true;
+      stoppedReason = args[2];
+      return originalStopAuto(...args);
+    };
+    (deps as any).pauseAuto = async (...args: Parameters<LoopDeps["pauseAuto"]>) => {
+      paused = true;
+      const context = args[2] as { message?: string } | undefined;
+      pausedReason = context?.message;
+      return originalPauseAuto(...args);
+    };
+
+    try {
+      const result = await run();
+      return { result, stopped, stoppedReason, paused, pausedReason };
+    } finally {
+      (deps as any).stopAuto = originalStopAuto;
+      (deps as any).pauseAuto = originalPauseAuto;
+    }
+  }
+
+  function resultForBreak(
+    reason: string,
+    sideEffects: CapturedAutoSideEffects<unknown>,
+  ): AutoAdvanceResult {
+    clearActiveUnit();
+    status.phase = sideEffects.paused && !sideEffects.stopped ? "paused" : "stopped";
+    status.transitionCount += 1;
+    if (sideEffects.paused && !sideEffects.stopped) {
+      return {
+        kind: "blocked",
+        reason: sideEffects.pausedReason ?? reason,
+        action: "pause",
+      };
+    }
+    return {
+      kind: "stopped",
+      reason: sideEffects.stoppedReason ?? reason,
+    };
+  }
+
+  return {
+    async start() {
+      status.phase = "running";
+      status.transitionCount += 1;
+      return { kind: "started" };
+    },
+    async advance() {
+      iteration += 1;
+      seq = 0;
+      const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
+      const ic = {
+        ctx,
+        pi,
+        s,
+        deps,
+        prefs,
+        iteration,
+        flowId: `loop-test-orchestration-${iteration}`,
+        nextSeq,
+      };
+
+      const preDispatch = await captureAutoSideEffects(() => runPreDispatch(ic, loopState));
+      const preDispatchResult = preDispatch.result;
+      if (preDispatchResult.action === "break") {
+        return resultForBreak(preDispatchResult.reason, preDispatch);
+      }
+      if (preDispatchResult.action === "continue") {
+        return { kind: "skipped", reason: "pre-dispatch-skip" };
+      }
+      if (preDispatchResult.action === "retry") {
+        return { kind: "paused", reason: preDispatchResult.reason };
+      }
+
+      const dispatch = await captureAutoSideEffects(() =>
+        runDispatch(ic, preDispatchResult.data, loopState),
+      );
+      if (dispatch.result.action === "break") {
+        return resultForBreak(dispatch.result.reason, dispatch);
+      }
+      if (dispatch.result.action === "continue") {
+        return {
+          kind: "skipped",
+          reason: "dispatch-skip",
+          stateSnapshot: preDispatchResult.data.state,
+        };
+      }
+      if (dispatch.result.action === "retry") {
+        return { kind: "paused", reason: dispatch.result.reason };
+      }
+
+      const data = dispatch.result.data;
+      const unit: UnitRef = { unitType: data.unitType, unitId: data.unitId };
+      s.pendingOrchestrationDispatch = {
+        unitType: data.unitType,
+        unitId: data.unitId,
+        prompt: data.prompt,
+        pauseAfterUatDispatch: data.pauseAfterUatDispatch,
+        state: data.state,
+        mid: data.mid,
+        midTitle: data.midTitle,
+      };
+      status.phase = "running";
+      status.activeUnit = unit;
+      status.transitionCount += 1;
+      return { kind: "advanced", unit, stateSnapshot: data.state };
+    },
+    async completeActiveUnit() {
+      clearActiveUnit();
+    },
+    async retryActiveUnit() {
+      clearActiveUnit();
+    },
+    async resume() {
+      status.phase = "running";
+      status.transitionCount += 1;
+      return { kind: "resumed" };
+    },
+    async stop(reason: string) {
+      status.phase = "stopped";
+      clearActiveUnit();
+      status.transitionCount += 1;
+      return { kind: "stopped", reason };
+    },
+    getStatus() {
+      return {
+        ...status,
+        activeUnit: status.activeUnit ? { ...status.activeUnit } : undefined,
+      };
+    },
+  };
+}
+
+async function autoLoop(
+  ctx: any,
+  pi: any,
+  s: any,
+  deps: LoopDeps,
+  options?: Parameters<typeof rawAutoLoop>[4],
+): Promise<void> {
+  if (!s.orchestration) {
+    s.orchestration = createLoopTestOrchestration(ctx, pi, s, deps);
+  }
+  await rawAutoLoop(ctx, pi, s, deps, options);
+}
+
 /**
  * Build a minimal mock AutoSession with controllable newSession behavior.
  */
 function makeMockSession(opts?: {
   newSessionResult?: { cancelled: boolean };
   newSessionThrows?: string;
+  /** Reject newSession() with a specific Error instance (e.g. TypeError). */
+  newSessionThrowsError?: Error;
   newSessionDelayMs?: number;
   onNewSessionStart?: (session: any) => void;
   onNewSessionSettle?: (session: any) => void;
@@ -87,6 +290,9 @@ function makeMockSession(opts?: {
     cmdCtx: {
       newSession: (options?: { abortSignal?: AbortSignal; workspaceRoot?: string }) => {
         opts?.onNewSessionStart?.(session);
+        if (opts?.newSessionThrowsError) {
+          return Promise.reject(opts.newSessionThrowsError);
+        }
         if (opts?.newSessionThrows) {
           return Promise.reject(new Error(opts.newSessionThrows));
         }
@@ -497,6 +703,73 @@ test("runUnit returns cancelled when session creation fails", async () => {
   assert.equal(pi.calls.length, 0);
 });
 
+test("runUnit: TypeError from newSession is classified as structural (isTransient: false)", async () => {
+  // Regression for #572: a TypeError thrown from newSession (e.g. "something is
+  // not a function") indicates a programming error, not a transient provider
+  // blip. Before the fix it was always classified isTransient: true, causing
+  // auto-mode to retry indefinitely instead of surfacing the real problem.
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({
+    newSessionThrowsError: new TypeError("pi.sendMessage is not a function"),
+  });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, false, "TypeError must be non-transient");
+});
+
+test("runUnit: 'is not a function' message from newSession is classified as structural", async () => {
+  // Regression for #572: the pattern also catches errors where the thrown
+  // object is not a TypeError instance but the message contains "is not a function".
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({ newSessionThrows: "pi.sendMessage is not a function" });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, false, "'is not a function' errors must be non-transient");
+});
+
+test("runUnit: generic network error from newSession remains transient", async () => {
+  // Confirm that non-structural session errors (e.g. 429, ECONNREFUSED) are
+  // still classified as transient so auto-mode can retry them.
+  _resetPendingResolve();
+
+  const baseCtx = {
+    ...makeMockCtx(),
+    ui: { notify: () => {}, setStatus: () => {}, setWorkingMessage: () => {} },
+    sessionManager: { getEntries: () => [] },
+    modelRegistry: { getProviderAuthMode: () => undefined, isProviderRequestReady: () => true },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession({ newSessionThrows: "connection refused" });
+
+  const result = await runUnit(baseCtx, pi, s, "task", "T01", "prompt");
+
+  assert.equal(result.status, "cancelled");
+  assert.equal(result.errorContext?.category, "session-failed");
+  assert.equal(result.errorContext?.isTransient, true, "network errors must remain transient");
+});
+
 test("runUnit clears queued switch cancellation when session creation fails", async () => {
   _resetPendingResolve();
 
@@ -1164,6 +1437,34 @@ test("autoLoop exits when s.active is set to false", async (t) => {
   );
 });
 
+test("autoLoop pauses visibly when Auto Orchestration Module is not wired", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  let pauseContext: unknown;
+
+  const deps = makeMockDeps({
+    pauseAuto: async (_ctx, _pi, errorContext) => {
+      pauseContext = errorContext;
+      deps.callLog.push("pauseAuto");
+    },
+  });
+
+  await rawAutoLoop(ctx, pi, s, deps);
+
+  assert.ok(deps.callLog.includes("pauseAuto"), "missing orchestration should pause auto-mode");
+  assert.equal(
+    (pauseContext as { message?: string } | undefined)?.message,
+    ORCHESTRATION_MISSING_REASON,
+  );
+  assert.equal(deps.callLog.includes("deriveState"), false);
+  assert.equal(deps.callLog.includes("resolveDispatch"), false);
+  assert.equal(s.pendingOrchestrationDispatch, null);
+});
+
 test("autoLoop exits on terminal complete state", async (t) => {
   _resetPendingResolve();
 
@@ -1990,11 +2291,15 @@ test("autoLoop retries next iteration when orchestration reports paused", async
     },
   });
 
+  const journalEvents: Array<{ eventType: string; data?: any }> = [];
   const deps = makeMockDeps({
     resolveDispatch: async () => {
       deps.callLog.push("resolveDispatch");
       throw new Error("legacy resolveDispatch must not run after orchestration paused");
     },
+    emitJournalEvent: (entry: any) => {
+      journalEvents.push(entry);
+    },
   });
 
   await autoLoop(ctx, pi, s, deps);
@@ -2007,6 +2312,11 @@ test("autoLoop retries next iteration when orchestration reports paused", async
     "orchestration paused must not fall back to legacy dispatch",
   );
   assert.equal(s.pendingOrchestrationDispatch, null, "no orchestration dispatch should remain pending");
+
+  const pausedIterationEnd = journalEvents.find(
+    (e) => e.eventType === "iteration-end" && e.data?.status === "paused",
+  );
+  assert.ok(pausedIterationEnd, "orchestration paused must emit iteration-end to close the iteration journal");
 });
 
 test("autoLoop consumes pending orchestration dispatch without advancing twice", async () => {
@@ -2094,8 +2404,13 @@ test("autoLoop stops orchestrator complete state through completion surface", as
       start: async () => ({ kind: "stopped" as const, reason: "unused" }),
       advance: async () => ({
         kind: "stopped" as const,
-        reason: "all milestones complete",
+        reason: "legacy text not used",
         stateSnapshot,
+        terminalOutcome: {
+          code: "all-complete" as const,
+          displayReason: "All milestones complete",
+          allMilestonesComplete: true as const,
+        },
       }),
       completeActiveUnit: async () => {},
       retryActiveUnit: async () => {},
@@ -2121,6 +2436,7 @@ test("autoLoop stops orchestrator complete state through completion surface", as
     milestoneTitle: "Priority Levels",
     allMilestonesComplete: true,
   });
+  assert.equal((stopCalls[0]?.options as any)?.terminalOutcome?.code, "all-complete");
   assert.equal(
     deps.callLog.includes("resolveDispatch"),
     false,
@@ -2960,7 +3276,7 @@ test("autoLoop closes journal iteration on pre-dispatch health-gate break", asyn
   assert.equal(deps.callLog.includes("pauseAuto"), true);
   assert.deepEqual(pauseOptions, { expectedCurrentUnit: null });
   assert.ok(
-    journalEvents.some((event) => event.eventType === "iteration-end" && event.data?.reason === "pre-dispatch-break"),
+    journalEvents.some((event) => event.eventType === "iteration-end" && event.data?.reason === "health-gate-failed"),
     "pre-dispatch break must close the started iteration",
   );
 });
@@ -5201,6 +5517,129 @@ test("dispatch Worktree Safety wins before stuck detection for execute-task with
   );
 });
 
+test("dispatch Worktree Safety honors degraded branch fallback instead of demanding the canonical worktree root", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  // Worktree creation failed and the lifecycle fell back to the milestone
+  // branch in the project root. The safety gate must validate against that
+  // effective branch mode, not the configured worktree mode.
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-degraded-"));
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath: projectRoot,
+    originalBasePath: projectRoot,
+    canonicalProjectRoot: projectRoot,
+    isolationDegraded: true,
+  });
+  const deps = makeMockDeps({
+    getIsolationMode: () => "worktree",
+  });
+  const result = await runDispatch(
+    {
+      ctx,
+      pi,
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+    },
+    {
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any,
+      mid: "M001",
+      midTitle: "Test",
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+
+  assert.equal(result.action, "next", "dispatch must proceed under degraded branch isolation");
+  assert.ok(
+    !notifications.some((n) => n.includes("Worktree Safety failed")),
+    "degraded branch fallback must not trip a false invalid-root",
+  );
+  assert.ok(!deps.callLog.includes("stopAuto"), "auto-mode must not stop on the degraded fallback");
+});
+
+test("dispatch Worktree Safety honors stranded branch recovery instead of demanding the canonical worktree root", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  // Bootstrap adopted stranded work by checking out the milestone branch in
+  // the project root (strandedRecoveryIsolationMode = "branch"). Isolation is
+  // NOT degraded — the adoption is intentional. The safety gate must validate
+  // against the effective branch mode, not the configured worktree mode.
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-stranded-"));
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath: projectRoot,
+    originalBasePath: projectRoot,
+    canonicalProjectRoot: projectRoot,
+    strandedRecoveryIsolationMode: "branch",
+  });
+  const deps = makeMockDeps({
+    getIsolationMode: () => "worktree",
+  });
+  const result = await runDispatch(
+    {
+      ctx,
+      pi,
+      s,
+      deps,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+    },
+    {
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Test", status: "active" },
+        activeSlice: { id: "S01", title: "Slice 1" },
+        activeTask: { id: "T01" },
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any,
+      mid: "M001",
+      midTitle: "Test",
+    },
+    {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    },
+  );
+
+  assert.equal(result.action, "next", "dispatch must proceed under stranded branch recovery");
+  assert.ok(
+    !notifications.some((n) => n.includes("Worktree Safety failed")),
+    "stranded branch recovery must not trip a false invalid-root",
+  );
+  assert.ok(!deps.callLog.includes("stopAuto"), "auto-mode must not stop on stranded branch recovery");
+});
+
 test("runDispatch runs stuck detection while artifact verification retry is pending (#5719)", async (t) => {
   _resetPendingResolve();