gsd-pi 3.0.0-dev.2e8b124f7 → 3.0.0-dev.6c9a50fd0

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -51,7 +51,15 @@ function isObjectRecord(value: unknown): value is Record<string, unknown> {
 }
 
 export function _hasEmptyAgentEndContent(content: unknown): boolean {
-  return content == null || (Array.isArray(content) && content.length === 0);
+  if (content == null) return true;
+  if (!Array.isArray(content)) return false;
+  if (content.length === 0) return true;
+  return content.every((block) => {
+    if (!block || typeof block !== "object") return true;
+    const typedBlock = block as { type?: unknown; text?: unknown };
+    if (typedBlock.type !== "text") return false;
+    return typeof typedBlock.text !== "string" || typedBlock.text.trim() === "";
+  });
 }
 
 /**
@@ -316,9 +324,22 @@ export async function handleAgentEnd(
   }
 
   if (isBareClaudeCodeStreamAbortPlaceholder(lastMsg)) {
-    // The Claude Code adapter can emit this placeholder after a prior turn has
-    // already completed and the next unit is active. It has no user/provider
-    // diagnostic value and must not cancel the newly-dispatched unit.
+    if (isSessionSwitchAbortGraceActive()) {
+      // Old turn leaking through after a session switch — drop it.
+      return;
+    }
+
+    // Mid-unit stream abort with no diagnostic. Treat as non-fatal so the loop
+    // can continue, but surface it to the user and resolve the in-flight unit.
+    ctx.ui.notify("Claude Code stream aborted mid-unit (no diagnostic). Continuing.", "warning");
+    try {
+      resetRetryState(retryState);
+      resolveAgentEnd(event);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      ctx.ui.notify(`Auto-mode error after stream-abort placeholder: ${message}. Stopping auto-mode.`, "error");
+      try { await pauseAuto(ctx, pi); } catch (e) { logWarning("bootstrap", `pauseAuto failed after stream-abort placeholder: ${(e as Error).message}`); }
+    }
     return;
   }
 

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -32,6 +32,7 @@ import {
   getAllAutoWorkers,
   markWorkerCrashed,
   markWorkerStopping,
+  markWorkerStoppingByPid,
   type AutoWorkerRow,
 } from "./db/auto-workers.js";
 import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
@@ -234,6 +235,8 @@ export function clearLock(basePath: string): void {
       deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
       return;
     }
+    const lock = readLegacyLock(basePath);
+    if (lock?.pid) markWorkerStoppingByPid(projectRoot, lock.pid);
     const worker = findActiveWorkerForCurrentProcess(projectRoot);
     if (worker) deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
 

package/src/resources/extensions/gsd/db/auto-workers.ts

@@ -157,6 +157,31 @@ export function markWorkerStopping(workerId: string): void {
   });
 }
 
+/**
+ * Mark the active worker row for a specific PID/project root as stopping.
+ * Used when we detect a dead PID from lock metadata before heartbeat expiry.
+ */
+export function markWorkerStoppingByPid(
+  projectRootRealpath: string,
+  pid: number,
+): void {
+  if (!isDbAvailable()) return;
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  const db = _getAdapter()!;
+  transaction(() => {
+    db.prepare(
+      `UPDATE workers
+       SET status = 'stopping'
+       WHERE pid = :pid
+         AND project_root_realpath = :project_root
+         AND status = 'active'`,
+    ).run({
+      ":pid": pid,
+      ":project_root": projectRootRealpath,
+    });
+  });
+}
+
 /**
  * Return all workers whose status is 'active' AND whose heartbeat is within
  * the TTL window. Workers older than the TTL are NOT auto-marked crashed

package/src/resources/extensions/gsd/preferences.ts

@@ -378,6 +378,10 @@ export function applyModeDefaults(mode: WorkflowMode, prefs: GSDPreferences): GS
 
 function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPreferences {
   return {
+    // Preserve validated preference keys that do not need custom merge logic.
+    // The explicit fields below still own defaults, arrays, and deep merges.
+    ...base,
+    ...override,
     version: override.version ?? base.version,
     mode: override.mode ?? base.mode,
     always_use_skills: mergeStringLists(base.always_use_skills, override.always_use_skills),

package/src/resources/extensions/gsd/repo-identity.ts

@@ -427,22 +427,38 @@ function hasProjectState(externalPath: string): boolean {
  *
  * Returns the resolved external path (may differ from the computed identity).
  */
-function resolveExternalPathWithRecovery(projectPath: string): string {
-  const computedPath = externalGsdRoot(projectPath);
+function resolveExternalPathWithRecovery(projectPath: string): { path: string; identity: string } {
+  const base = process.env.GSD_STATE_DIR || gsdHome();
   const computedId = repoIdentity(projectPath);
+  const computedPath = join(base, "projects", computedId);
+  const computedHasState = hasProjectState(computedPath);
+  const markerId = readGsdIdMarker(projectPath);
+  const markerPath = markerId ? join(base, "projects", markerId) : null;
+  const markerHasState = markerPath ? hasProjectState(markerPath) : false;
+
+  // Split-brain guard: when marker and computed identities disagree and both
+  // directories contain state, prefer the marker-backed directory. This keeps
+  // all writers anchored to a single canonical project identity even if a
+  // transient identity computation produced a stale computed hash.
+  if (
+    markerId
+    && markerPath
+    && markerId !== computedId
+    && markerHasState
+    && computedHasState
+  ) {
+    return { path: markerPath, identity: markerId };
+  }
 
   // Check if computed path already has state — fast path, no recovery needed.
-  if (hasProjectState(computedPath)) {
-    return computedPath;
+  if (computedHasState) {
+    return { path: computedPath, identity: computedId };
   }
 
   // Check for .gsd-id marker from a previous location.
-  const markerId = readGsdIdMarker(projectPath);
-  if (markerId && markerId !== computedId) {
+  if (markerId && markerPath && markerId !== computedId) {
     // The marker points to a different identity — the repo was likely moved.
-    const base = process.env.GSD_STATE_DIR || gsdHome();
-    const markerPath = join(base, "projects", markerId);
-    if (hasProjectState(markerPath)) {
+    if (markerHasState) {
       // Recover: use the old state directory and update the marker to the new identity.
       // Move the state from the old hash dir to the new one so future lookups work
       // without the marker.
@@ -465,12 +481,12 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
         try { rmSync(markerPath, { recursive: true, force: true }); } catch { /* non-fatal */ }
       } catch {
         // If migration fails, just point at the old directory.
-        return markerPath;
+        return { path: markerPath, identity: markerId };
       }
     }
   }
 
-  return computedPath;
+  return { path: computedPath, identity: computedId };
 }
 
 // ─── Symlink Management ─────────────────────────────────────────────────────
@@ -489,20 +505,21 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(projectPath: string): string {
-  const result = ensureGsdSymlinkCore(projectPath);
+  const { path: result, identity } = ensureGsdSymlinkCore(projectPath);
 
   // Write .gsd-id marker so future relocations can recover this state (#2750).
   // Only write for the project root (not subdirectories or worktrees that
   // delegate to a parent .gsd).
   if (!isInsideWorktree(projectPath)) {
-    writeGsdIdMarker(projectPath, repoIdentity(projectPath));
+    writeGsdIdMarker(projectPath, identity);
   }
 
   return result;
 }
 
-function ensureGsdSymlinkCore(projectPath: string): string {
-  const externalPath = resolveExternalPathWithRecovery(projectPath);
+function ensureGsdSymlinkCore(projectPath: string): { path: string; identity: string } {
+  const resolved = resolveExternalPathWithRecovery(projectPath);
+  const externalPath = resolved.path;
   const localGsd = join(projectPath, ".gsd");
   const inWorktree = isInsideWorktree(projectPath);
 
@@ -519,7 +536,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   const localGsdNormalized = normalizeForGuard(localGsd);
   const gsdHomeNorm = normalizeForGuard(gsdHome());
   if (localGsdNormalized === gsdHomeNorm) {
-    return localGsd;
+    return { path: localGsd, identity: resolved.identity };
   }
 
   // Guard: If projectPath is a plain subdirectory (not a worktree) of a git
@@ -538,7 +555,10 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           try {
             const rootStat = lstatSync(rootGsd);
             if (rootStat.isSymbolicLink() || rootStat.isDirectory()) {
-              return rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd;
+              return {
+                path: rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd,
+                identity: resolved.identity,
+              };
             }
           } catch {
             // Fall through to normal logic if we can't stat root .gsd
@@ -560,12 +580,12 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   // Write repo metadata once so cleanup commands can identify this directory later.
   writeRepoMeta(externalPath, getRemoteUrl(projectPath), resolveGitRoot(projectPath));
 
-  const replaceWithSymlink = (): string => {
+  const replaceWithSymlink = (): { path: string; identity: string } => {
     rmSync(localGsd, { recursive: true, force: true });
     // Defensive: remove any residual entry (e.g. dangling symlink) before creating.
     try { unlinkSync(localGsd); } catch { /* already gone */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   };
 
   // Check for dangling symlinks (e.g. after relocation recovery removed the old
@@ -585,7 +605,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
     // Defensive: remove any residual entry to avoid EEXIST race (#2750).
     try { unlinkSync(localGsd); } catch { /* nothing to remove */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   }
 
   try {
@@ -595,7 +615,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // Already a symlink — verify it points to the right place
       const target = realpathSync(localGsd);
       if (target === externalPath) {
-        return externalPath; // correct symlink, no-op
+        return resolved; // correct symlink, no-op
       }
       // In a worktree, mismatched symlinks are always stale. Heal them so
       // the worktree points at the same external state dir as the main repo.
@@ -620,11 +640,11 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           return replaceWithSymlink();
         } catch {
           // Migration failed — preserve old symlink
-          return target;
+          return { path: target, identity: resolved.identity };
         }
       }
       // Outside worktrees, preserve custom overrides or legacy symlinks.
-      return target;
+      return { path: target, identity: resolved.identity };
     }
 
     if (stat.isDirectory()) {
@@ -632,13 +652,13 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // In worktrees, keep the directory in place and let syncGsdStateToWorktree
       // refresh its contents. Replacing a git-tracked .gsd directory with a
       // symlink makes git think tracked planning files were deleted.
-      return localGsd;
+      return { path: localGsd, identity: resolved.identity };
     }
   } catch {
     // lstat failed — path exists but we can't stat it
   }
 
-  return localGsd;
+  return { path: localGsd, identity: resolved.identity };
 }
 
 // ─── Worktree Detection ─────────────────────────────────────────────────────

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

@@ -19,8 +19,9 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { markWorkerStoppingByPid } from "./db/auto-workers.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -281,6 +282,13 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   // Clean up numbered lock file variants from cloud sync conflicts (#1315)
   cleanupStrayLockFiles(basePath);
 
+  // If lock metadata points to a dead PID, mark that worker row stopping so
+  // crash diagnostics do not keep surfacing it as active.
+  const existingPreflight = readExistingLockData(lp);
+  if (existingPreflight?.pid && !isPidAlive(existingPreflight.pid)) {
+    markWorkerStoppingByPid(normalizeRealPath(basePath), existingPreflight.pid);
+  }
+
   // Write our lock data first (the content is informational; the OS lock is the real guard)
   const lockData: SessionLockData = {
     pid: process.pid,
@@ -308,7 +316,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   const lockDir = lockTarget + ".lock";
   if (existsSync(lockDir)) {
     const existingData = readExistingLockData(lp);
-    const isOrphan = !existingData || (existingData.pid && !isPidAlive(existingData.pid));
+    const deadPid = existingData?.pid && !isPidAlive(existingData.pid) ? existingData.pid : null;
+    if (deadPid) markWorkerStoppingByPid(normalizeRealPath(basePath), deadPid);
+    const isOrphan = !existingData || !!deadPid;
     if (isOrphan) {
       try { rmSync(lockDir, { recursive: true, force: true }); } catch { /* best-effort */ }
       try { if (existsSync(lp)) unlinkSync(lp); } catch { /* best-effort */ }
@@ -344,6 +354,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
     const existingData = readExistingLockData(lp);
     const existingPid = existingData?.pid;
+    if (existingPid && !isPidAlive(existingPid)) {
+      markWorkerStoppingByPid(normalizeRealPath(basePath), existingPid);
+    }
 
     // If no lock file or no alive process, try to clean up and re-acquire (#1245)
     if (!existingData || (existingPid && !isPidAlive(existingPid))) {

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

@@ -3652,6 +3652,81 @@ test("runDispatch falls back to main when dispatch guard cannot read main branch
   assert.equal(result.action, "next");
 });
 
+test("runDispatch clamps oversized stuck window before detection (#6216)", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  const deps = makeMockDeps({
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "dispatch" as const,
+        unitType: "complete-slice",
+        unitId: "M006/S03",
+        prompt: "close out slice",
+      };
+    },
+  });
+  const loopState = {
+    recentUnits: [
+      { key: "complete-slice/M006/S03" },
+      { key: "execute-task/M006/S03/T01" },
+      { key: "complete-slice/M006/S03" },
+      { key: "execute-task/M006/S03/T01" },
+      { key: "execute-task/M006/S03/T02" },
+      { key: "execute-task/M006/S03/T03" },
+      { key: "execute-task/M006/S03/T04" },
+      { key: "execute-task/M006/S03/T05" },
+      { key: "execute-task/M006/S03/T06" },
+      { key: "execute-task/M006/S03/T07" },
+      { key: "execute-task/M006/S03/T08" },
+      { key: "execute-task/M006/S03/T09" },
+      { key: "execute-task/M006/S03/T10" },
+      { key: "execute-task/M006/S03/T11" },
+      { key: "execute-task/M006/S03/T12" },
+      { key: "complete-slice/M006/S03" },
+      { key: "execute-task/M006/S03/T13" },
+      { key: "execute-task/M006/S03/T14" },
+      { key: "execute-task/M006/S03/T15" },
+      { key: "execute-task/M006/S03/T16" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  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",
+    },
+    loopState,
+  );
+
+  assert.equal(result.action, "next");
+  assert.equal(loopState.recentUnits.length, 6, "stuck window should be capped to the active detector size");
+  assert.ok(!deps.callLog.includes("stopAuto"), "oversized persisted history should not trigger a false stuck stop");
+});
+
 test("dispatch Worktree Safety stops unknown unit types with missing Tool Contract", async (t) => {
   _resetPendingResolve();
 
@@ -3722,6 +3797,66 @@ test("dispatch Worktree Safety stops unknown unit types with missing Tool Contra
   );
 });
 
+test("dispatch Worktree Safety accepts sidecar-prefixed known unit types", async (t) => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-safety-sidecar-prefix-"));
+  const worktreeRoot = join(projectRoot, ".gsd", "worktrees", "M001");
+  mkdirSync(worktreeRoot, { recursive: true });
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
+  const s = makeLoopSession({
+    basePath: worktreeRoot,
+    originalBasePath: projectRoot,
+    canonicalProjectRoot: projectRoot,
+  });
+  const deps = makeMockDeps({
+    getIsolationMode: () => "worktree",
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "sidecar/triage-captures",
+      unitId: "M001/S01/triage",
+      prompt: "triage",
+    }),
+  });
+
+  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");
+  assert.ok(!deps.callLog.includes("stopAuto"), "should not stop for sidecar-prefixed known unit types");
+});
+
 test("pre-dispatch skip resolves before dispatch health and stuck accounting", async () => {
   _resetPendingResolve();
 

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

@@ -98,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 () => {
@@ -413,26 +412,16 @@ test("advance() surfaces dispatch blocker reason instead of generic no remaining
   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",
-        };
-      },
-    },
-  });
+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, "blocked");
-  if (result.kind !== "blocked") return;
-  assert.equal(result.reason, "remediation required");
-  assert.equal(result.action, "pause");
+  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 () => {
@@ -472,13 +461,13 @@ test("advance() is idempotent for the same active unit", async () => {
   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");
 });
 
@@ -489,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 () => {
@@ -607,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 () => {
@@ -798,14 +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.action, "pause");
+  assert.equal(next.kind, "advanced");
 });
 
 test("stuck-loop: resume() resets the ring", async () => {
@@ -817,12 +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.action, "pause");
+  assert.equal(next.kind, "advanced");
 });
 
 test("stuck-loop: stop() resets the ring", async () => {
@@ -1027,6 +1016,46 @@ test("wired DispatchAdapter prefers caller-supplied dispatch inputs over ctx-der
   }
 });
 
+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);
+  } finally {
+    resetRegistry();
+  }
+});
+
 test("wired DispatchAdapter preserves stop reason as a blocked decision", async () => {
   const stateSnapshot = makeState();
   const stopRule: UnifiedRule = {