gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.2e8b124f7

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

@@ -3,7 +3,7 @@
 
 import test, { mock } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -30,6 +30,11 @@ import type { LoopDeps } from "../auto/loop-deps.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import type { SessionLockStatus } from "../session-lock.js";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.js";
+import { registerAutoWorker } from "../db/auto-workers.js";
+import { claimMilestoneLease } from "../db/milestone-leases.js";
+import { recordDispatchClaim, markCanceled } from "../db/unit-dispatches.js";
+import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -129,6 +134,8 @@ function makeMockPi() {
       setModelCalls.push(args);
       return true;
     },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
     calls,
     setModelCalls,
   } as any;
@@ -965,6 +972,79 @@ test("autoLoop exits on terminal complete state", async (t) => {
   );
 });
 
+test("autoLoop persists stuck counter reset when dispatch recovery continues", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const basePath = realpathSync(mkdtempSync(join(tmpdir(), "gsd-stuck-counter-reset-")));
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+  mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    "# Slice Plan\n\n- [ ] **T01:** task one\n",
+  );
+  writeFileSync(
+    join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+    "# Task Plan\n",
+  );
+
+  try {
+    openDatabase(join(basePath, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "pending" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "Task One", status: "pending" });
+    const workerId = registerAutoWorker({ projectRootRealpath: basePath });
+    const lease = claimMilestoneLease(workerId, "M001");
+    assert.equal(lease.ok, true);
+    if (!lease.ok) return;
+
+    for (let i = 0; i < 2; i++) {
+      const claim = recordDispatchClaim({
+        traceId: `stuck-${i}`,
+        workerId,
+        milestoneLeaseToken: lease.token,
+        milestoneId: "M001",
+        sliceId: "S01",
+        unitType: "plan-slice",
+        unitId: "M001/S01",
+      });
+      assert.equal(claim.ok, true);
+      if (!claim.ok) return;
+      markCanceled(claim.dispatchId, "seed stuck window");
+    }
+    setRuntimeKv("global", basePath, "stuck_recovery_attempts", 1);
+
+    const s = makeLoopSession({
+      basePath,
+      originalBasePath: basePath,
+      canonicalProjectRoot: basePath,
+    });
+    const deps = makeMockDeps({
+      resolveDispatch: async () => ({
+        action: "dispatch" as const,
+        unitType: "plan-slice",
+        unitId: "M001/S01",
+        prompt: "plan the slice",
+      }),
+      invalidateAllCaches: () => {
+        s.active = false;
+      },
+    });
+
+    await autoLoop(ctx, pi, s, deps);
+
+    assert.equal(
+      getRuntimeKv<number>("global", basePath, "stuck_recovery_attempts"),
+      0,
+      "dispatch-level artifact recovery exits through continue, so the reset counter must still persist",
+    );
+  } finally {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
 test("autoLoop stops before success notification when postflight stash restore needs recovery", async () => {
   _resetPendingResolve();
 
@@ -1401,6 +1481,81 @@ test("autoLoop calls deriveState → resolveDispatch → runUnit in sequence", a
   );
 });
 
+test("autoLoop dev path dispatches orchestration.advance results without legacy resolveDispatch", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  const pi = makeMockPi();
+  const stateSnapshot = {
+    phase: "executing",
+    activeMilestone: { id: "M002", title: "Advance Milestone", status: "active" },
+    activeSlice: { id: "S03", title: "Slice 3" },
+    activeTask: { id: "T05" },
+    registry: [{ id: "M002", status: "active" }],
+    blockers: [],
+  } as any;
+  let advanceCalls = 0;
+  let s: any;
+  s = makeLoopSession({
+    currentMilestoneId: "M002",
+    orchestration: {
+      start: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      advance: async () => {
+        advanceCalls++;
+        s.pendingOrchestrationDispatch = {
+          unitType: "execute-task",
+          unitId: "M002/S03/T05",
+          prompt: "advance prompt",
+          pauseAfterUatDispatch: false,
+          state: stateSnapshot,
+          mid: "M002",
+          midTitle: "Advance Milestone",
+        };
+        return {
+          kind: "advanced" as const,
+          unit: { unitType: "execute-task", unitId: "M002/S03/T05" },
+          stateSnapshot,
+        };
+      },
+      resume: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      stop: async () => ({ kind: "stopped" as const, reason: "unused" }),
+      getStatus: () => ({ phase: "running" as const, transitionCount: 1 }),
+    },
+  });
+
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      throw new Error("legacy resolveDispatch must not run when orchestration is wired");
+    },
+    postUnitPostVerification: async () => {
+      deps.callLog.push("postUnitPostVerification");
+      s.active = false;
+      return "continue" as const;
+    },
+  });
+
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+  await waitForMicrotasks(() => pi.calls.length === 1, "orchestration advance dispatch");
+  resolveAgentEnd(makeEvent());
+  await loopPromise;
+
+  assert.equal(advanceCalls, 1);
+  assert.equal(
+    deps.callLog.includes("resolveDispatch"),
+    false,
+    "orchestration.advance owns dev-path dispatch",
+  );
+  assert.equal(
+    (pi.calls[0] as any[])[0].content,
+    "advance prompt",
+    "runUnit should receive the dispatch prompt captured by advance()",
+  );
+  assert.equal(s.pendingOrchestrationDispatch, null, "pending dispatch should be one-shot");
+});
+
 test("autoLoop journals post-unit finalize stop after completed unit", async () => {
   _resetPendingResolve();
 
@@ -2725,6 +2880,89 @@ 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-"));
+  t.after(() => {
+    _resetPendingResolve();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const recordedOutcomes: Array<{ unitType: string; tier: string; success: boolean }> = [];
+  const deps = makeMockDeps({
+    selectAndApplyModel: async () => ({
+      routing: { tier: "light" } as any,
+      appliedModel: null,
+    }),
+    recordOutcome: (unitType: string, tier: string, success: boolean) => {
+      recordedOutcomes.push({ unitType, tier, success });
+    },
+  });
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = {
+    ...makeMockPi(),
+    sendMessage: () => {
+      queueMicrotask(() => resolveAgentEnd({ messages: [{ role: "assistant" }] }));
+    },
+  } as any;
+  const s = makeLoopSession({
+    basePath,
+    canonicalProjectRoot: basePath,
+    originalBasePath: basePath,
+  });
+  let seq = 0;
+
+  const result = await runUnitPhase(
+    { ctx, pi, s, deps, prefs: undefined, iteration: 1, flowId: "flow-routing-outcome", nextSeq: () => ++seq },
+    {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      prompt: "do work",
+      finalPrompt: "do work",
+      pauseAfterUatDispatch: false,
+      state: {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Milestone" },
+        activeSlice: { id: "S01", title: "Slice" },
+        activeTask: { id: "T01", title: "Task" },
+        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,
+    },
+    { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 },
+  );
+
+  assert.equal(result.action, "next");
+  assert.deepEqual(
+    recordedOutcomes,
+    [{ unitType: "execute-task", tier: "light", success: false }],
+    "routing history must treat missing artifacts as failed outcomes so retries can escalate",
+  );
+});
+
 test("resolveAgentEndCancelled without args produces no errorContext field", async () => {
   _resetPendingResolve();
 
@@ -2785,6 +3023,7 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
     const s = makeLoopSession();
 
     let preVerifyCallCount = 0;
+    const currentUnitSnapshotsAtPreVerify: Array<{ type: string; id: string; startedAt: number } | null> = [];
     // Pre-queued responses: first call returns "retry", second returns "continue"
     const preVerifyResponses = ["retry", "continue"] as const;
 
@@ -2802,6 +3041,7 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
       },
       postUnitPreVerification: async () => {
         deps.callLog.push("postUnitPreVerification");
+        currentUnitSnapshotsAtPreVerify.push(s.currentUnit);
         const response = preVerifyResponses[preVerifyCallCount++] ?? "continue";
         if (response === "retry") {
           s.pendingVerificationRetry = {
@@ -2832,6 +3072,11 @@ test("autoLoop re-iterates when postUnitPreVerification returns retry (#1571)",
     await loopPromise;
 
     assert.equal(preVerifyCallCount, 2, "preVerification should be called twice");
+    assert.deepEqual(
+      currentUnitSnapshotsAtPreVerify,
+      [null, null],
+      "currentUnit should be cleared before each preVerification run to prevent stale retry scope",
+    );
 
     const postVerifyCalls = deps.callLog.filter(
       (c: string) => c === "runPostUnitVerification",
@@ -3353,6 +3598,60 @@ test("runDispatch runs stuck detection while artifact verification retry is pend
   );
 });
 
+test("runDispatch falls back to main when dispatch guard cannot read main branch (#5530)", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-5530-main-branch-fallback-"));
+  t.after(() => rmSync(basePath, { recursive: true, force: true }));
+
+  let guardBranch: string | null = null;
+  const s = makeLoopSession({ basePath });
+  const deps = makeMockDeps({
+    getMainBranch: () => {
+      throw new Error("fatal: detected dubious ownership");
+    },
+    getPriorSliceCompletionBlocker: (_basePath, mainBranch) => {
+      guardBranch = mainBranch;
+      return null;
+    },
+  });
+
+  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(guardBranch, "main");
+  assert.equal(result.action, "next");
+});
+
 test("dispatch Worktree Safety stops unknown unit types with missing Tool Contract", async (t) => {
   _resetPendingResolve();
 

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" },
@@ -119,13 +125,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 +143,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 +304,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 +324,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 +347,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 +355,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 +389,52 @@ 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() returns blocked when advance detects a dispatch blocker", async () => {
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        return {
+          kind: "blocked",
+          reason: "remediation required",
+          action: "pause",
+        };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  const result = await orchestrator.resume();
+
+  assert.equal(result.kind, "blocked");
+  if (result.kind !== "blocked") return;
+  assert.equal(result.reason, "remediation required");
+  assert.equal(result.action, "pause");
+});
+
 test("advance() uses recovery on error", async () => {
   const { deps, calls } = makeDeps({
     runtime: {
@@ -319,7 +466,7 @@ 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);
@@ -614,7 +761,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 +784,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 () => {
@@ -658,6 +805,7 @@ test("stuck-loop: start() resets the ring so a fresh saturation cycle is require
   const next = await orchestrator.advance();
   assert.equal(next.kind, "blocked");
   assert.equal(next.reason, "idempotent advance: unit already active");
+  assert.equal(next.action, "pause");
 });
 
 test("stuck-loop: resume() resets the ring", async () => {
@@ -674,6 +822,7 @@ test("stuck-loop: resume() resets the ring", async () => {
   const next = await orchestrator.advance();
   assert.equal(next.kind, "blocked");
   assert.equal(next.reason, "idempotent advance: unit already active");
+  assert.equal(next.action, "pause");
 });
 
 test("stuck-loop: stop() resets the ring", async () => {
@@ -797,7 +946,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 +1004,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 +1021,39 @@ 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);
+  } 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();
   }