gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

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

@@ -13,6 +13,12 @@ import { RuleRegistry, setRegistry, resetRegistry } from "../rule-registry.js";
 import type { UnifiedRule } from "../rule-types.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
 
+function assertBlockedResult(
+  result: Awaited<ReturnType<ReturnType<typeof createAutoOrchestrator>["advance"]>>,
+): asserts result is Extract<typeof result, { kind: "blocked" }> {
+  assert.equal(result.kind, "blocked");
+}
+
 function makeState(): GSDState {
   return {
     activeMilestone: { id: "M001", title: "Milestone" },
@@ -92,19 +98,18 @@ function makeDeps(overrides: Partial<AutoOrchestratorDeps> = {}): { deps: AutoOr
   return { deps: { ...deps, ...overrides }, calls };
 }
 
-test("start() advances and records active unit", async () => {
+test("start() enters running phase without dispatching", async () => {
   const { deps, calls } = makeDeps();
   const orchestrator = createAutoOrchestrator(deps);
 
   const result = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
 
-  assert.equal(result.kind, "advanced");
-  assert.deepEqual(result.unit, { unitType: "execute-task", unitId: "T01" });
+  assert.equal(result.kind, "started");
   const status = orchestrator.getStatus();
   assert.equal(status.phase, "running");
-  assert.deepEqual(status.activeUnit, { unitType: "execute-task", unitId: "T01" });
+  assert.equal(status.activeUnit, undefined);
   assert.ok(calls.includes("journal:start"));
-  assert.ok(calls.includes("journal:advance"));
+  assert.ok(!calls.includes("journal:advance"));
 });
 
 test("advance() returns blocked when health gate denies", async () => {
@@ -119,13 +124,13 @@ test("advance() returns blocked when health gate denies", async () => {
 
   const result = await orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
+  assertBlockedResult(result);
   assert.equal(result.reason, "doctor-block");
   assert.equal(result.action, "pause");
   assert.ok(calls.includes("gate:pre-dispatch-health-gate:manual-attention"));
 });
 
-test("advance() returns blocked stop when resources are stale", async () => {
+test("advance() returns blocked pause when resources are stale", async () => {
   const { deps, calls } = makeDeps({
     health: {
       checkResourcesStale: () => "resources changed since session start",
@@ -137,14 +142,89 @@ test("advance() returns blocked stop when resources are stale", async () => {
 
   const result = await orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
+  assertBlockedResult(result);
   assert.equal(result.reason, "resources changed since session start");
-  assert.equal(result.action, "stop");
+  assert.equal(result.action, "pause");
   assert.ok(calls.includes("gate:resource-version-guard:fail"));
   assert.ok(!calls.includes("health.pre"));
   assert.ok(!calls.includes("state.reconcile"));
 });
 
+test("advance() pre-dispatch parity: gate emissions and control-flow action match legacy branches", async () => {
+  type Scenario = {
+    name: string;
+    staleMsg: string | null;
+    gateResult: Awaited<ReturnType<AutoOrchestratorDeps["health"]["preAdvanceGate"]>>;
+    expectedKind: "advanced" | "blocked";
+    expectedAction?: "pause" | "stop";
+    expectedReason?: string;
+    expectedGates: string[];
+  };
+  const scenarios: Scenario[] = [
+    {
+      name: "pass",
+      staleMsg: null,
+      gateResult: { kind: "pass" },
+      expectedKind: "advanced",
+      expectedGates: [
+        "resource-version-guard:policy:pass:none:resource version guard passed:",
+        "pre-dispatch-health-gate:execution:pass:none:pre-dispatch health gate passed:",
+      ],
+    },
+    {
+      name: "resource-stale",
+      staleMsg: "resources changed since session start",
+      gateResult: { kind: "pass" },
+      expectedKind: "blocked",
+      expectedAction: "pause",
+      expectedReason: "resources changed since session start",
+      expectedGates: [
+        "resource-version-guard:policy:fail:policy:resource version guard blocked dispatch:resources changed since session start",
+      ],
+    },
+    {
+      name: "health-gate-fail",
+      staleMsg: null,
+      gateResult: { kind: "fail", reason: "doctor-block" },
+      expectedKind: "blocked",
+      expectedAction: "pause",
+      expectedReason: "doctor-block",
+      expectedGates: [
+        "resource-version-guard:policy:pass:none:resource version guard passed:",
+        "pre-dispatch-health-gate:execution:manual-attention:manual-attention:pre-dispatch health gate blocked dispatch:doctor-block",
+      ],
+    },
+  ];
+
+  for (const scenario of scenarios) {
+    const gateEvents: string[] = [];
+    const { deps } = makeDeps({
+      health: {
+        checkResourcesStale: () => scenario.staleMsg,
+        async preAdvanceGate() { return scenario.gateResult; },
+        async postAdvanceRecord() {},
+      },
+      uokGate: {
+        async emit(input) {
+          gateEvents.push(
+            `${input.gateId}:${input.gateType}:${input.outcome}:${input.failureClass}:${input.rationale}:${input.findings ?? ""}`,
+          );
+        },
+      },
+    });
+    const orchestrator = createAutoOrchestrator(deps);
+    const result = await orchestrator.advance();
+
+    assert.equal(result.kind, scenario.expectedKind, `${scenario.name} result kind`);
+    if (scenario.expectedKind === "blocked") {
+      assertBlockedResult(result);
+      assert.equal(result.action, scenario.expectedAction, `${scenario.name} blocked action`);
+      assert.equal(result.reason, scenario.expectedReason, `${scenario.name} blocked reason`);
+    }
+    assert.deepEqual(gateEvents, scenario.expectedGates, `${scenario.name} gate parity`);
+  }
+});
+
 test("advance() continues past pre-dispatch health gate when it throws", async () => {
   const { deps, calls } = makeDeps({
     health: {
@@ -223,7 +303,7 @@ test("advance() blocks before dispatch when State Reconciliation blocks", async
 
   const result = await orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
+  assertBlockedResult(result);
   assert.equal(result.reason, "state drift blocked");
   assert.equal(result.action, "pause");
   assert.ok(!calls.includes("dispatch.decide"));
@@ -243,7 +323,7 @@ test("advance() blocks before Runtime persistence when Tool Contract fails", asy
 
   const result = await orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
+  assertBlockedResult(result);
   assert.equal(result.reason, "unknown Unit");
   assert.equal(result.action, "pause");
   assert.ok(!calls.includes("worktree.prepare"));
@@ -266,7 +346,7 @@ test("advance() blocks before Runtime persistence when Worktree Safety fails", a
 
   const result = await orchestrator.advance();
 
-  assert.equal(result.kind, "blocked");
+  assertBlockedResult(result);
   assert.equal(result.reason, "worktree invalid");
   assert.equal(result.action, "pause");
   assert.ok(!calls.includes("journal:advance"));
@@ -274,6 +354,26 @@ test("advance() blocks before Runtime persistence when Worktree Safety fails", a
   assert.ok(calls.includes("journal:advance-blocked"));
 });
 
+test("advance() allows non-worktree isolation prepare result", async () => {
+  const { deps, calls } = makeDeps({
+    worktree: {
+      async prepareForUnit() {
+        calls.push("worktree.prepare");
+        return { ok: true, reason: "isolation-not-worktree" };
+      },
+      async syncAfterUnit() { calls.push("worktree.sync"); },
+      async cleanupOnStop() { calls.push("worktree.cleanup"); },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "advanced");
+  assert.ok(calls.includes("journal:advance"));
+  assert.ok(calls.includes("worktree.sync"));
+});
+
 test("advance() stops when dispatch has no next unit", async () => {
   const { deps } = makeDeps({
     dispatch: {
@@ -288,6 +388,42 @@ test("advance() stops when dispatch has no next unit", async () => {
   assert.equal(orchestrator.getStatus().phase, "stopped");
 });
 
+test("advance() surfaces dispatch blocker reason instead of generic no remaining units", async () => {
+  const { deps, calls } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        return {
+          kind: "blocked",
+          reason: "Milestone M001 validation verdict is needs-remediation but all slices are complete.",
+          action: "pause",
+        };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.advance();
+
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.reason, "Milestone M001 validation verdict is needs-remediation but all slices are complete.");
+  assert.equal(result.action, "pause");
+  assert.ok(calls.includes("journal:advance-blocked"));
+  assert.ok(!calls.includes("journal:advance-stopped"));
+});
+
+test("resume() enters running phase without dispatching", async () => {
+  const { deps, calls } = makeDeps();
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "resumed");
+  assert.equal(orchestrator.getStatus().phase, "running");
+  assert.ok(!calls.includes("journal:advance"));
+  assert.ok(!calls.includes("dispatch.decide"));
+});
+
 test("advance() uses recovery on error", async () => {
   const { deps, calls } = makeDeps({
     runtime: {
@@ -319,19 +455,19 @@ test("advance() is idempotent for the same active unit", async () => {
   assert.deepEqual(first.unit, { unitType: "execute-task", unitId: "T01" });
   assert.equal(second.kind, "blocked");
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "stop");
+  assert.equal(second.action, "pause");
 
   const prepareCalls = calls.filter((c) => c === "worktree.prepare").length;
   assert.equal(prepareCalls, 1);
 });
 
-test("resume() re-enters running flow via advance", async () => {
+test("resume() re-enters running phase", async () => {
   const { deps } = makeDeps();
   const orchestrator = createAutoOrchestrator(deps);
 
   const result = await orchestrator.resume();
 
-  assert.equal(result.kind, "advanced");
+  assert.equal(result.kind, "resumed");
   assert.equal(orchestrator.getStatus().phase, "running");
 });
 
@@ -342,10 +478,12 @@ test("resume() clears idempotent lock and allows re-advance", async () => {
   const first = await orchestrator.advance();
   const blocked = await orchestrator.advance();
   const resumed = await orchestrator.resume();
+  const next = await orchestrator.advance();
 
   assert.equal(first.kind, "advanced");
   assert.equal(blocked.kind, "blocked");
-  assert.equal(resumed.kind, "advanced");
+  assert.equal(resumed.kind, "resumed");
+  assert.equal(next.kind, "advanced");
 });
 
 test("transitionCount increases across lifecycle transitions", async () => {
@@ -460,9 +598,11 @@ test("start() clears prior idempotent lock", async () => {
   await orchestrator.advance();
   const blocked = await orchestrator.advance();
   const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
+  const next = await orchestrator.advance();
 
   assert.equal(blocked.kind, "blocked");
-  assert.equal(restarted.kind, "advanced");
+  assert.equal(restarted.kind, "started");
+  assert.equal(next.kind, "advanced");
 });
 
 test("error path emits error notification", async () => {
@@ -614,7 +754,7 @@ test("stuck-loop: ring saturated with same unit blocks with action 'stop' and st
     assert.equal(r.kind, "blocked", `round ${i} should be blocked`);
     if (r.kind !== "blocked") return;
     assert.equal(r.reason, "idempotent advance: unit already active");
-    assert.equal(r.action, "stop");
+    assert.equal(r.action, "pause");
   }
 
   // The final call (ring now holds STUCK_WINDOW_SIZE copies) returns stuck-loop.
@@ -637,7 +777,7 @@ test("stuck-loop: idempotency block continues to fire with its own reason before
   assert.equal(first.kind, "advanced");
   assert.equal(second.kind, "blocked");
   assert.equal(second.reason, "idempotent advance: unit already active");
-  assert.equal(second.action, "stop");
+  assert.equal(second.action, "pause");
 });
 
 test("stuck-loop: start() resets the ring so a fresh saturation cycle is required", async () => {
@@ -651,13 +791,12 @@ test("stuck-loop: start() resets the ring so a fresh saturation cycle is require
   }
 
   const restarted = await orchestrator.start({ basePath: "/tmp/project", trigger: "manual" });
-  assert.equal(restarted.kind, "advanced");
+  assert.equal(restarted.kind, "started");
 
-  // Immediately after start(), the next advance is idempotent (one element in
-  // ring), not stuck-loop, confirming the ring was reset.
+  // Immediately after start(), the next advance should succeed because start()
+  // no longer pre-dispatches and the ring was reset.
   const next = await orchestrator.advance();
-  assert.equal(next.kind, "blocked");
-  assert.equal(next.reason, "idempotent advance: unit already active");
+  assert.equal(next.kind, "advanced");
 });
 
 test("stuck-loop: resume() resets the ring", async () => {
@@ -669,11 +808,10 @@ test("stuck-loop: resume() resets the ring", async () => {
   }
 
   const resumed = await orchestrator.resume();
-  assert.equal(resumed.kind, "advanced");
+  assert.equal(resumed.kind, "resumed");
 
   const next = await orchestrator.advance();
-  assert.equal(next.kind, "blocked");
-  assert.equal(next.reason, "idempotent advance: unit already active");
+  assert.equal(next.kind, "advanced");
 });
 
 test("stuck-loop: stop() resets the ring", async () => {
@@ -797,7 +935,9 @@ test("wired DispatchAdapter forwards session-derived dispatch inputs identically
     assert.equal(adapterCtx.midTitle, directCtx.midTitle);
 
     // Dispatch action equality: both flows reach the same dispatch decision.
-    assert.ok(adapterResult);
+    if (!adapterResult || !("unitType" in adapterResult)) {
+      assert.fail("expected adapter result to be a dispatch decision");
+    }
     assert.equal(adapterResult.unitType, "execute-task");
     assert.equal(adapterResult.unitId, "T01");
     assert.equal(adapterResult.reason, "test-capture");
@@ -853,9 +993,11 @@ test("wired DispatchAdapter prefers caller-supplied dispatch inputs over ctx-der
       getActiveTools: () => [],
     } as any;
     const adapter = createWiredDispatchAdapter(ctx, pi, "/tmp/parity-fixture");
+    const session = { basePath: "/tmp/session-fixture" } as any;
 
     const result = await adapter.decideNextUnit({
       stateSnapshot,
+      session,
       structuredQuestionsAvailable: "true",
       sessionContextWindow: 500_000,
       sessionProvider: "openai",
@@ -868,6 +1010,81 @@ test("wired DispatchAdapter prefers caller-supplied dispatch inputs over ctx-der
     assert.equal(captured[0].sessionContextWindow, 500_000);
     assert.equal(captured[0].sessionProvider, "openai");
     assert.equal(captured[0].modelRegistry, overrideModelRegistry);
+    assert.equal(captured[0].session, session);
+    assert.equal(captured[0].basePath, "/tmp/session-fixture");
+  } finally {
+    resetRegistry();
+  }
+});
+
+test("wired DispatchAdapter forwards constructor session when advance input omits session", async () => {
+  const stateSnapshot = makeState();
+  const captured: DispatchContext[] = [];
+  const captureRule: UnifiedRule = {
+    name: "test-session-fallback",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async (ctx: DispatchContext) => {
+      captured.push(ctx);
+      return {
+        action: "dispatch" as const,
+        unitType: "execute-task",
+        unitId: "T01",
+        prompt: "session-fallback-fixture",
+      };
+    },
+    then: (r: unknown) => r,
+  };
+  setRegistry(new RuleRegistry([captureRule]));
+
+  try {
+    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;
+    const pi = { getActiveTools: () => [] } as any;
+    const session = {
+      basePath: "/tmp/worktree-fixture",
+      originalBasePath: "/tmp/project-fixture",
+      currentMilestoneId: "M001",
+    } as any;
+    const adapter = createWiredDispatchAdapter(ctx, pi, "/tmp/project-fixture", session);
+
+    const result = await adapter.decideNextUnit({ stateSnapshot });
+
+    assert.ok(result);
+    assert.equal(captured.length, 1, "expected one captured dispatch context");
+    assert.equal(captured[0].session, session);
+    assert.equal(captured[0].basePath, "/tmp/worktree-fixture");
+  } finally {
+    resetRegistry();
+  }
+});
+
+test("wired DispatchAdapter preserves stop reason as a blocked decision", async () => {
+  const stateSnapshot = makeState();
+  const stopRule: UnifiedRule = {
+    name: "test-stop",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async () => ({
+      action: "stop" as const,
+      reason: "remediation blocker",
+      level: "warning" as const,
+    }),
+    then: (r: unknown) => r,
+  };
+  setRegistry(new RuleRegistry([stopRule]));
+
+  try {
+    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;
+    const pi = { getActiveTools: () => [] } as any;
+    const adapter = createWiredDispatchAdapter(ctx, pi, "/tmp/parity-fixture");
+
+    const result = await adapter.decideNextUnit({ stateSnapshot });
+
+    assert.deepEqual(result, {
+      kind: "blocked",
+      reason: "remediation blocker",
+      action: "pause",
+    });
   } finally {
     resetRegistry();
   }

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -6,7 +6,7 @@ import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "nod
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { cleanupAfterLoopExit, rerootCommandSession, stopAuto } from "../auto.ts";
+import { cleanupAfterLoopExit, pauseAuto, rerootCommandSession, stopAuto } from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
@@ -43,7 +43,53 @@ test("cleanupAfterLoopExit preserves paused auto badge after provider pause", as
   }
 });
 
-test("cleanupAfterLoopExit clears status without replacing the last auto surface", async () => {
+test("cleanupAfterLoopExit preserves paused worktree session and visible failure output", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-session-preserve-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {
+    restoreCalls += 1;
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 0, "paused cleanup must not restore out of the active worktree");
+    assert.deepEqual(newSessionWorkspaces, [], "paused cleanup must not start a blank rerooted session");
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+    assert.equal(autoSession.paused, true);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit clears status and progress widget without replacing outcome surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -64,8 +110,8 @@ test("cleanupAfterLoopExit clears status without replacing the last auto surface
     assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
     assert.equal(
       widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
-      false,
-      "cleanup must not clear the last meaningful auto progress surface",
+      true,
+      "cleanup must clear the stale auto progress widget",
     );
     assert.equal(
       widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
@@ -79,7 +125,7 @@ test("cleanupAfterLoopExit clears status without replacing the last auto surface
   }
 });
 
-test("cleanupAfterLoopExit preserves completion roll-up after stopAuto reset", async () => {
+test("cleanupAfterLoopExit clears progress widget after stopAuto reset", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
 
@@ -103,8 +149,8 @@ test("cleanupAfterLoopExit preserves completion roll-up after stopAuto reset", a
     assert.deepEqual(statusCalls, [["gsd-auto", undefined]]);
     assert.equal(
       widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
-      false,
-      "completion cleanup must not clear the roll-up progress widget",
+      true,
+      "completion cleanup must clear the stale progress widget",
     );
     assert.equal(
       widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-outcome"),
@@ -117,6 +163,98 @@ test("cleanupAfterLoopExit preserves completion roll-up after stopAuto reset", a
   }
 });
 
+test("pauseAuto preserves artifact retry counts across pause/resume", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pause-retry-count-"));
+  const previousCwd = process.cwd();
+  const retryKey = "execute-task:M001/S01/T01";
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.verificationRetryCount.set(retryKey, 2);
+  autoSession.pendingVerificationRetry = {
+    unitId: "M001/S01/T01",
+    failureContext: "Missing expected artifact (attempt 2/3).",
+    attempt: 2,
+  };
+
+  try {
+    process.chdir(base);
+    await pauseAuto();
+
+    assert.equal(autoSession.paused, true);
+    assert.equal(autoSession.pendingVerificationRetry, null);
+    assert.equal(autoSession.verificationRetryCount.get(retryKey), 2);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit preserves step-mode surface and worktree session after completed step", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-surface-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {
+    restoreCalls += 1;
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.stepMode = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [], "step-mode cleanup must leave the NEXT badge visible");
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      false,
+      "step-mode cleanup must not clear the completed step progress surface",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-health"),
+      false,
+      "step-mode cleanup must not replace the progress surface with idle health",
+    );
+    assert.deepEqual(newSessionWorkspaces, [], "step-mode cleanup must not re-root the visible command session");
+    assert.equal(restoreCalls, 0, "step-mode cleanup must not restore out of the active worktree");
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");
@@ -159,14 +297,15 @@ test("cleanupAfterLoopExit keeps cleanup best-effort when lifecycle restore thro
   const previousCwd = process.cwd();
   let restoreCalls = 0;
   // ADR-016 phase 3 (#5693): the real `restoreToProjectRoot` assigns
-  // `s.basePath = s.originalBasePath` BEFORE any throwable work
+  // `s.basePath = s.originalBasePath` AND chdir's BEFORE any throwable work
   // (rebuildGitService, cache invalidation). Mirror that ordering in the
-  // mock so the throw scenario reflects production: basePath is restored
-  // even when the verb throws partway through.
+  // mock so the throw scenario reflects production: basePath and cwd are
+  // restored even when the verb throws partway through.
   t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function (this: WorktreeLifecycle) {
     restoreCalls += 1;
-    (this as unknown as { s: { basePath: string; originalBasePath: string } })
-      .s.basePath = (this as unknown as { s: { originalBasePath: string } }).s.originalBasePath;
+    const sRef = this as unknown as { s: { basePath: string; originalBasePath: string } };
+    sRef.s.basePath = sRef.s.originalBasePath;
+    try { process.chdir(sRef.s.basePath); } catch { /* mirror real verb's best-effort */ }
     throw new Error("restore failed");
   });