@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

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

@@ -3,6 +3,7 @@
 
 import test, { mock } from "node:test";
 import assert from "node:assert/strict";
+import { execSync } from "node:child_process";
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -23,11 +24,14 @@ 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 } from "../auto/pre-dispatch.js";
+import { runDispatch } from "../auto/dispatch.js";
+import { runUnitPhase, resetSessionTimeoutState } from "../auto/unit-phase.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 +44,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 +82,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 +293,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));
         }
@@ -325,7 +534,7 @@ test("runUnit failsafe defers cancellation while timeout recovery is making fres
     const ctx = makeMockCtx();
     const pi = makeMockPi();
     const s = makeMockSession();
-    s.basePath = mkdtempSync(join(tmpdir(), "gsd-rununit-recovery-"));
+    s.basePath = makeLoopTestBase("gsd-rununit-recovery-");
     s.currentUnit = { type: "task", id: "T01", startedAt: 1234 };
 
     const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
@@ -497,6 +706,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();
 
@@ -1093,12 +1369,19 @@ function makeMockDeps(
  * runUnit mock (dispatch counters, milestone state, etc.).
  */
 function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-auto-loop-"));
+  // Plan 001 enforces worktree safety for all isolation modes. Loop-mechanics
+  // tests run with getIsolationMode: () => "none", so the project root itself
+  // must be a valid git working tree for source-writing Units to dispatch.
+  execSync("git init --initial-branch=main", { cwd: basePath, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: basePath, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: basePath, stdio: "ignore" });
   return {
     active: true,
     verbose: false,
     stepMode: false,
     paused: false,
-    basePath: mkdtempSync(join(tmpdir(), "gsd-auto-loop-")),
+    basePath,
     originalBasePath: "",
     currentMilestoneId: "M001",
     currentUnit: null,
@@ -1146,6 +1429,15 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
   } as any;
 }
 
+/** Create a temp project root suitable for loop-mechanics tests. */
+function makeLoopTestBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  execSync("git init --initial-branch=main", { cwd: base, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: base, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: base, stdio: "ignore" });
+  return base;
+}
+
 test("autoLoop exits when s.active is set to false", async (t) => {
   _resetPendingResolve();
 
@@ -1164,6 +1456,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();
 
@@ -1205,7 +1525,7 @@ test("autoLoop preserves stuck recovery counter when dispatch recovery continues
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
-  const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-stuck-counter-reset-")));
+  const basePath = realpathSync(makeLoopTestBase("gsd-stuck-counter-reset-"));
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
   mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
   writeFileSync(
@@ -1280,7 +1600,7 @@ test("autoLoop skips provider dispatch when execute-task is already complete in
   ctx.ui.setStatus = () => {};
   ctx.ui.setWidget = () => {};
   const pi = makeMockPi();
-  const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-already-complete-dispatch-")));
+  const basePath = realpathSync(makeLoopTestBase("gsd-already-complete-dispatch-"));
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
 
   try {
@@ -1990,11 +2310,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 +2331,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 +2423,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 +2455,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 +3295,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",
   );
 });
@@ -3023,6 +3358,110 @@ test("autoLoop handles dispatch skip action by continuing", async (t) => {
   );
 });
 
+test("autoLoop pauses after repeated orchestration skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return { action: "skip" as const, reason: "gate-marker-drift" as const };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  const dispatchCalls = deps.callLog.filter((c) => c === "resolveDispatch");
+  assert.equal(dispatchCalls.length, 3, "persistent orchestration skips should pause before the runaway cap");
+  assert.equal(deps.callLog.includes("pauseAuto"), true, "persistent orchestration skips should pause auto-mode");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "persistent orchestration skips should not hit the max-iteration stop");
+});
+
+test("autoLoop does not pause on repeated idempotent advance skips", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({
+    currentMilestoneId: "M001",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        if (advanceCalls >= 5) s.active = false;
+        return { kind: "skipped" as const, reason: "idempotent advance: unit already active" };
+      },
+      completeActiveUnit: async () => {},
+      retryActiveUnit: async () => {},
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+      getStatus: () => ({ phase: "running" as const, transitionCount: 1 }),
+    } satisfies AutoOrchestrationModule,
+  });
+
+  const deps = makeMockDeps();
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.ok(advanceCalls >= 5, "loop should complete multiple idempotent skips before deactivating");
+  assert.equal(deps.callLog.includes("pauseAuto"), false, "idempotent advance skips must not trigger the consecutive-skip pause");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "idempotent advance skips must not reach the max-iteration stop");
+});
+
+test("autoLoop skip streak survives sidecar iteration without resetting", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  let advanceCalls = 0;
+  const s = makeLoopSession({ currentMilestoneId: "M001" });
+  s.orchestration = {
+    start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    advance: async () => {
+      advanceCalls++;
+      if (advanceCalls === 2) {
+        // Inject a sidecar so the *next* iteration takes the sidecar path rather than
+        // calling orchestration.advance() — which must NOT reset the skip streak.
+        s.sidecarQueue.push({
+          kind: "hook" as const,
+          unitType: "run-uat",
+          unitId: "M001/S01/T01/review",
+          prompt: "review",
+        });
+      }
+      return { kind: "skipped" as const, reason: "gate-marker-drift" };
+    },
+    completeActiveUnit: async () => {},
+    retryActiveUnit: async () => {},
+    resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+    stop: async (reason: string) => ({ kind: "stopped" as const, reason }),
+    getStatus: () => ({ phase: "running" as const, transitionCount: advanceCalls }),
+  } satisfies AutoOrchestrationModule;
+
+  const deps = makeMockDeps();
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+
+  // Wait for the sidecar unit to call newSession (pi.calls grows)
+  await waitForMicrotasks(() => pi.calls.length >= 1, "sidecar unit to start");
+  resolveAgentEnd(makeEvent()); // resolve the sidecar unit
+
+  await loopPromise;
+
+  // Skip 1 (call 1) + sidecar iteration (no advance) + skip 3 (call 3, matches key) → pause.
+  // The old reset at the dispatch boundary would have zeroed the counter during the sidecar,
+  // requiring 3 more skips (calls 3,4,5) before pausing. With the fix, 3 total → call 3.
+  assert.equal(advanceCalls, 3, "skip streak must survive the sidecar iteration: pause on the 3rd total skip");
+  assert.ok(deps.callLog.includes("pauseAuto"), "persistent skips must still pause after an interleaved sidecar");
+  assert.equal(deps.callLog.includes("stopAuto"), false, "must not hit the max-iteration stop");
+});
+
 test("autoLoop drains sidecar queue after postUnitPostVerification enqueues items", async (t) => {
   _resetPendingResolve();
 
@@ -3676,7 +4115,7 @@ test("resolveAgentEndCancelled with errorContext passes it through to resolved p
 test("runUnitPhase pauses transient aborted cancellations instead of hard-stopping", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-aborted-cancel-"));
+  const basePath = makeLoopTestBase("gsd-aborted-cancel-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -3748,10 +4187,157 @@ test("runUnitPhase pauses transient aborted cancellations instead of hard-stoppi
   assert.equal(deps.callLog.includes("stopAuto"), false);
 });
 
+test("resetSessionTimeoutState gives a new auto session a fresh session-creation timeout budget", async (t) => {
+  _resetPendingResolve();
+
+  // runUnitPhase schedules an auto-resume setTimeout on transient session
+  // timeouts. Capture and clear those timers so the test process can exit
+  // promptly while still exercising the real production path.
+  const originalSetTimeout = globalThis.setTimeout;
+  const timerHandles: ReturnType<typeof originalSetTimeout>[] = [];
+  globalThis.setTimeout = ((callback: any, delay?: number, ...args: any[]) => {
+    const handle = originalSetTimeout(callback, delay ?? 0, ...args);
+    timerHandles.push(handle);
+    return handle;
+  }) as any;
+
+  const basePath = makeLoopTestBase("gsd-session-timeout-reset-");
+  execSync("git init", { cwd: basePath });
+  execSync('git -c user.email=test@test.com -c user.name=Test commit --allow-empty -m init', { cwd: basePath });
+
+  t.after(() => {
+    for (const handle of timerHandles) clearTimeout(handle);
+    globalThis.setTimeout = originalSetTimeout;
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const notifications: Array<{ message: string; level?: string }> = [];
+  ctx.ui.notify = (message: string, level?: string) => {
+    notifications.push({ message, level });
+  };
+  const pi = makeMockPi();
+  const s = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+  });
+  const deps = makeMockDeps();
+
+  async function runTimeoutUnit(iteration: number): Promise<string | undefined> {
+    notifications.length = 0;
+    const callsBefore = pi.calls.length;
+    let seq = 0;
+    const phasePromise = runUnitPhase(
+      { ctx, pi, s, deps, prefs: undefined, iteration, flowId: `flow-${iteration}`, nextSeq: () => ++seq },
+      {
+        unitType: "plan-slice",
+        unitId: "M001/S01",
+        prompt: "plan the slice",
+        finalPrompt: "plan the slice",
+        pauseAfterUatDispatch: false,
+        state: {
+          phase: "planning",
+          activeMilestone: { id: "M001", title: "Milestone" },
+          activeSlice: { id: "S01", title: "Slice" },
+          activeTask: null,
+          registry: [{ id: "M001", title: "Milestone", status: "active" }],
+          recentDecisions: [],
+          blockers: [],
+          nextAction: "",
+          progress: { milestones: { done: 0, total: 1 } },
+          requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+        } as any,
+        mid: "M001",
+        midTitle: "Milestone",
+        isRetry: false,
+        previousTier: undefined,
+      },
+      makeLoopState(),
+    );
+
+    // Wait until runUnit has dispatched the prompt, then resolve the unit
+    // as a session-creation timeout. This avoids the 120s real timeout and
+    // the mock-timer interaction that runUnitPhase's pre-flight setup makes
+    // fragile.
+    await new Promise<void>((resolve) => {
+      const check = () => {
+        if (pi.calls.length > callsBefore) return resolve();
+        setTimeout(check, 5);
+      };
+      check();
+    });
+    resolveAgentEndCancelled({
+      message: "Session creation timed out",
+      category: "timeout",
+      isTransient: true,
+    });
+
+    const result = await phasePromise;
+    return (result as any).reason;
+  }
+
+  // Start from a known state in case a previous test left the counter raised.
+  resetSessionTimeoutState();
+
+  // Exhaust the per-process timeout budget in the first "session".
+  for (let i = 1; i <= 4; i++) {
+    const reason = await runTimeoutUnit(i);
+    assert.equal(reason, "session-timeout");
+  }
+  const lastBudgetNotification = notifications.find((n) =>
+    n.message.includes("Session creation timed out")
+  );
+  assert.ok(lastBudgetNotification, "expected a session-creation timeout notification");
+  assert.match(
+    lastBudgetNotification.message,
+    /Pausing for manual review/,
+    "fourth consecutive timeout should exhaust the auto-resume budget",
+  );
+
+  // Simulate a new auto-mode session starting. autoLoop() must reset the
+  // module-level counter so the next timeout is treated as the first in the
+  // new session rather than inheriting the exhausted budget.
+  const freshSession = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+    active: false,
+  });
+  freshSession.orchestration = createLoopTestOrchestration(ctx, pi, freshSession, deps);
+  await rawAutoLoop(ctx, pi, freshSession, deps);
+
+  const reasonAfterReset = await runTimeoutUnit(5);
+  assert.equal(reasonAfterReset, "session-timeout");
+  const notificationAfterReset = notifications.find((n) =>
+    n.message.includes("Auto-resuming")
+  );
+  assert.ok(notificationAfterReset, "expected an auto-resume notification after reset");
+  assert.match(
+    notificationAfterReset.message,
+    /Auto-resuming/,
+    "after autoLoop entry the timeout budget should be fresh so the first timeout auto-resumes",
+  );
+});
+
 test("runUnitPhase treats setup-race cancellations as pause-induced when session is already paused", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-paused-setup-race-"));
+  const basePath = makeLoopTestBase("gsd-paused-setup-race-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -3826,7 +4412,7 @@ test("runUnitPhase treats setup-race cancellations as pause-induced when session
 test("runUnitPhase remembers aborted milestone closeout for same-unit resume", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-aborted-closeout-"));
+  const basePath = makeLoopTestBase("gsd-aborted-closeout-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -3906,7 +4492,7 @@ test("runUnitPhase remembers aborted milestone closeout for same-unit resume", a
 test("runUnitPhase schedules default auto-resume for transient provider cancellations", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-provider-resume-"));
+  const basePath = makeLoopTestBase("gsd-provider-resume-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4003,7 +4589,7 @@ test("runUnitPhase schedules default auto-resume for transient provider cancella
 test("runUnitPhase pauses ghost completions before closeout and finalize side effects", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-ghost-completion-"));
+  const basePath = makeLoopTestBase("gsd-ghost-completion-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4105,7 +4691,7 @@ test("runUnitPhase pauses ghost completions before closeout and finalize side ef
 test("runUnitPhase records failed routing outcome when expected artifact is missing", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-routing-artifact-missing-"));
+  const basePath = makeLoopTestBase("gsd-routing-artifact-missing-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4188,7 +4774,7 @@ test("runUnitPhase records failed routing outcome when expected artifact is miss
 test("runUnitPhase execute-task retry prompt instructs gsd_task_complete instead of manual summary writes", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-execute-task-retry-prompt-"));
+  const basePath = makeLoopTestBase("gsd-execute-task-retry-prompt-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4269,7 +4855,7 @@ test("runUnitPhase execute-task retry prompt instructs gsd_task_complete instead
 test("runUnitPhase non-execute-task retry prompt keeps generic required-file guidance", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-non-execute-retry-prompt-"));
+  const basePath = makeLoopTestBase("gsd-non-execute-retry-prompt-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -4617,7 +5203,7 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
 test("runUnitPhase retries 0-tool units with ordinary network-related assistant text", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-network-text-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-network-text-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -4712,7 +5298,7 @@ test("runUnitPhase retries 0-tool units with ordinary network-related assistant
 test("runUnitPhase pauses auto-mode when zero-tool-call retry is exhausted", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-exhausted-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-exhausted-");
   t.after(() => {
     rmSync(basePath, { recursive: true, force: true });
   });
@@ -4997,7 +5583,7 @@ test("autoLoop rejects complete-slice with 0 tool calls as context-exhausted (#2
 test("autoLoop pauses on zero-tool-call rate-limit assistant messages instead of immediate retry", async (t) => {
   _resetPendingResolve();
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-zero-tool-rate-limit-"));
+  const basePath = makeLoopTestBase("gsd-zero-tool-rate-limit-");
   t.after(() => {
     _resetPendingResolve();
     rmSync(basePath, { recursive: true, force: true });
@@ -5201,6 +5787,147 @@ 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-"));
+  execSync("git init --initial-branch=main", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: projectRoot, stdio: "ignore" });
+  // The lifecycle fallback checks out the milestone branch in the project
+  // root, so the safety gate's branch verification expects that branch here
+  // too. expectedBranch comes from deps.autoWorktreeBranch (mocked to
+  // "auto/M001"), so the fixture repo must be on that same branch.
+  execSync("git commit --allow-empty -m init", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git checkout -b auto/M001", { cwd: projectRoot, stdio: "ignore" });
+  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-"));
+  execSync("git init --initial-branch=main", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: projectRoot, stdio: "ignore" });
+  // Stranded recovery adopts the milestone branch in the project root, so the
+  // safety gate's branch verification expects that branch here too.
+  // expectedBranch comes from deps.autoWorktreeBranch (mocked to "auto/M001"),
+  // so the fixture repo must be on that same branch.
+  execSync("git commit --allow-empty -m init", { cwd: projectRoot, stdio: "ignore" });
+  execSync("git checkout -b auto/M001", { cwd: projectRoot, stdio: "ignore" });
+  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();
 
@@ -5209,7 +5936,7 @@ test("runDispatch runs stuck detection while artifact verification retry is pend
   const notifications: string[] = [];
   ctx.ui.notify = (msg: string) => { notifications.push(msg); };
 
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-5719-retry-stuck-"));
+  const basePath = makeLoopTestBase("gsd-5719-retry-stuck-");
   t.after(() => rmSync(basePath, { recursive: true, force: true }));
 
   const s = makeLoopSession({
@@ -5277,7 +6004,7 @@ test("runDispatch falls back to main when dispatch guard cannot read main branch
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-5530-main-branch-fallback-"));
+  const basePath = makeLoopTestBase("gsd-5530-main-branch-fallback-");
   t.after(() => rmSync(basePath, { recursive: true, force: true }));
 
   let guardBranch: string | null = null;
@@ -5804,7 +6531,7 @@ test("pre-dispatch replace resolves final unit before dispatch health and stuck
   );
 });
 
-test("autoLoop warns but proceeds for greenfield project (no project files) (#1833)", async () => {
+test("autoLoop warns but proceeds for greenfield project (no project files) (#1833)", async (t) => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
@@ -5813,7 +6540,9 @@ test("autoLoop warns but proceeds for greenfield project (no project files) (#18
   const pi = makeMockPi();
 
   const notifications: string[] = [];
-  const s = makeLoopSession({ basePath: "/tmp/empty-worktree" });
+  const basePath = makeLoopTestBase("gsd-greenfield-");
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+  const s = makeLoopSession({ basePath });
 
   ctx.ui.notify = (msg: string) => {
     notifications.push(msg);
@@ -5836,8 +6565,6 @@ test("autoLoop warns but proceeds for greenfield project (no project files) (#18
         blockers: [],
       } as any;
     },
-    // Has .git but no package.json or src/
-    existsSync: (p: string) => p.endsWith(".git"),
   });
 
   await autoLoop(ctx, pi, s, deps);