@cabane/companion 0.6.71 → 0.6.72

package/dist/runtime.js

@@ -6775,10 +6775,13 @@ var ConnectorHealthStore = class {
 };
 
 // src/dispatcher.ts
-import { createHash as createHash2, randomUUID } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync2, statSync } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join14 } from "path";
 
+// src/turn-execution.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { existsSync as existsSync10 } from "fs";
+
 // src/turn-control-tools.ts
 import { z as z13 } from "zod";
 var COMPANION_LOCAL_MCP_SERVER = "cabane_companion";
@@ -7588,7 +7591,7 @@ var TurnCommitter = class {
   }
 };
 
-// src/dispatcher.ts
+// src/turn-execution.ts
 var PREPARING_TOOL_NAME = "preparing";
 var PREPARE_FAILED_PREFIX = "**Couldn't prepare your environment.** I wasn't able to provision a working directory for this conversation, so I can't run this turn. The provisioning command reported:";
 var MISSING_SECRET_PREFIX = "**Missing secret on this companion.** This agent's tools need a credential this device hasn't been given, so I can't run this turn safely. Declare it in this companion\u2019s secret store (`~/.cabane/secrets.json`) and try again. Missing:";
@@ -7600,33 +7603,6 @@ var DEFAULT_PREPARING_ROW_DELAY_MS = 1500;
 var DEFAULT_AGENT_IDLE_TIMEOUT_MS = 10 * 6e4;
 var DEFAULT_AGENT_TOTAL_TIMEOUT_MS = 6 * 60 * 6e4;
 var DEFAULT_LEASE_RENEWAL_MS = 3e4;
-function checkoutState(cwd) {
-  if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
-  if (!existsSync10(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
-  let entries;
-  try {
-    entries = readdirSync2(cwd);
-  } catch (error) {
-    return { ok: false, reason: `${cwd} is unreadable (${error.message})` };
-  }
-  if (entries.length === 0) {
-    return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
-  }
-  const gitPath = join14(cwd, ".git");
-  if (!existsSync10(gitPath)) return { ok: true, reason: "usable" };
-  let stat;
-  try {
-    stat = statSync(gitPath);
-  } catch (error) {
-    return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
-  }
-  if (stat.isDirectory() && !existsSync10(join14(gitPath, "HEAD")))
-    return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
-  return { ok: true, reason: "usable" };
-}
-function runKey(conversationId, agentId) {
-  return `${conversationId}|${agentId}`;
-}
 var LEASE_REFUSALS = /* @__PURE__ */ new Set([
   "dispatch_not_admitted",
   "turn_already_ended",
@@ -7661,61 +7637,128 @@ function describeErrorBody(body) {
   if (text.length === 0) return void 0;
   return text.length > ERROR_BODY_LOG_CAP ? `${text.slice(0, ERROR_BODY_LOG_CAP)}\u2026` : text;
 }
-var Dispatcher = class {
-  constructor(opts) {
+function initialOutcome() {
+  return {
+    sessionWritten: false,
+    sessionDegraded: false,
+    sessionWriteRejected: false,
+    okResult: false,
+    resultReason: void 0,
+    turnUsage: void 0,
+    turnResolvedModel: void 0,
+    turnResolvedConfig: void 0,
+    turnMcpInventory: void 0,
+    eventCounts: { session: 0, text: 0, thinking: 0, tool: 0, result: 0 },
+    runtimeResultKind: null,
+    contentBearingEvents: 0,
+    latestSessionState: null,
+    settledDiagnostics: null,
+    silentMarkerEmitted: false,
+    timeoutReason: null,
+    leaseLost: false
+  };
+}
+var TurnConcluded = class {
+  constructor(reason, errorReason) {
+    this.reason = reason;
+    this.errorReason = errorReason;
+  }
+  reason;
+  errorReason;
+};
+var TurnExecution = class {
+  constructor(opts, supervisor, payload, handleOpts = {}) {
     this.opts = opts;
-    this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
+    this.supervisor = supervisor;
+    this.payload = payload;
+    this.dispatchId = payload.messageId;
+    this.workspaceId = opts.workspaceId;
+    this.turnLog = opts.log.child({
+      workspaceId: opts.workspaceId,
+      conversationId: payload.conversationId,
+      agentId: payload.agentId,
+      messageId: payload.messageId
+    });
+    this.turnId = handleOpts.turnId ?? randomUUID();
   }
   opts;
-  // SJ383: per-(conversation, agent) abort registry.
-  // CT1288: RunKey -> (turnId -> controller). This used to be one controller
-  // per (conversation, agent), which quietly encoded the invariant the whole
-  // task exists to enforce: that a pair can only ever have one live loop. When
-  // that assumption broke, the second `set` EVICTED the first controller and
-  // the first loop became permanently uncancellable — no other code path can
-  // reach into a running turn. So the registry that Stop depends on failed
-  // exactly when Stop was the thing you needed.
-  //
-  // Nesting by turn id costs nothing in the normal single-turn case and makes
-  // `cancel` total: it aborts every loop under the pair, not the newest one.
-  aborts;
-  // CT1109: pairs already told, in the conversation, that their session state is
-  // being refused. The failure repeats every single turn until someone fixes the
-  // payload, so without this the notice would be a per-turn drumbeat; one notice
-  // is the signal and the rest is noise. Deliberately in-memory and unbounded-free:
-  // a companion restart re-arms it, which is the behaviour we want — a restart is
-  // exactly when it's worth re-stating that memory is still being lost.
-  sessionWriteNotified = /* @__PURE__ */ new Set();
-  notifyStart(info) {
-    try {
-      this.opts.observer?.onStart(info);
-    } catch {
-    }
-  }
-  notifyEnd(info) {
+  supervisor;
+  payload;
+  startedAt = Date.now();
+  turnId;
+  dispatchId;
+  workspaceId;
+  turnLog;
+  abortController = new AbortController();
+  outcome = initialOutcome();
+  seqCounter = 0;
+  // CT11: per-turn monotonic counter mirroring the in-process dispatcher's.
+  nextSeq = () => ++this.seqCounter;
+  turnContext;
+  resolvedMcpServers;
+  effectiveCwd;
+  hookEnv;
+  turnEnv;
+  sendState;
+  skipState;
+  askState;
+  wakeState;
+  replyState;
+  controlOrder;
+  turnControlServer;
+  request;
+  adapter;
+  committer = null;
+  transcript = null;
+  turnControlIntentFetched = false;
+  applyRecordedTurnControlIntent = async () => {
+  };
+  // CT1292: the committer is built before the lease watchdog arms, so the
+  // failed-commit hint reaches it through this slot. Safe as a no-op until the
+  // watchdog replaces it — the committer only fires it from inside the adapter
+  // loop, which runs after.
+  noteCommitFailed = () => {
+  };
+  disarmWatchdogs = () => {
+  };
+  // Codo's stack review, blocking finding #2: set the moment `acquireLease`'s
+  // PATCH returns — the mailroom now holds this turn as the conversation's
+  // running one, so every exit after this point must settle THE TURN, not just
+  // clear the participant flag.
+  admitted = false;
+  concluded(reason, errorReason) {
+    return new TurnConcluded(reason, errorReason);
+  }
+  // The arc. Phases in order; every pre-loop exit throws `TurnConcluded` and
+  // funnels through ONE conclusion (hand back the controller — idempotent and
+  // identity-checked at the supervisor — then clear the active-run flag);
+  // everything past the lease settles in `execute()`'s one `finally`.
+  async run() {
     try {
-      this.opts.observer?.onEnd(info);
-    } catch {
+      await this.fetchContext();
+      this.gateTrigger();
+      await this.resolveSecrets();
+      await this.prepareEnvironment();
+      this.buildRequest();
+      await this.acquireLease();
+      await this.selectAdapter();
+    } catch (err) {
+      if (err instanceof TurnConcluded) {
+        this.supervisor.releaseAbort(this.turnId, this.abortController);
+        return this.admitted ? this.concludeAdmittedRun(err.reason, err.errorReason) : this.concludeBeforeRun(err.reason, err.errorReason);
+      }
+      if (this.admitted) {
+        this.supervisor.releaseAbort(this.turnId, this.abortController);
+        const msg = err instanceof Error ? err.message : String(err);
+        await this.concludeAdmittedRun("setup_failed", `setup_failed: ${msg}`);
+      }
+      throw err;
     }
+    await this.execute();
+    return this.report();
   }
-  // CT138: shared pre-run teardown for every early-return that happens BEFORE
-  // the active-run flag is flipped (the `setActiveRun` working-flip below).
-  // The server lights the "X is replying…" indicator eagerly at dispatch
-  // (chat-dispatch.ts `scheduleRun`), and from that point only the companion can
-  // clear it — the SJ383 `finally` after the SDK loop is the one clear, and
-  // every pre-run exit returns before reaching it. So each pre-run failure has
-  // to clear `active_run_started_at` itself, mirroring that `finally`, or the
-  // indicator strands until the 12h age sweep.
-  //
-  // `errorReason` controls the server's duplicate-notice rule (the active-run
-  // PATCH handler in conversations.ts): a clear carrying `errorReason` makes the
-  // server post a `role:'system'` "X's reply failed: …" notice. Exits that
-  // already posted their own user-facing `final` (prepare-failed, missing-secret)
-  // pass NO errorReason, so the user doesn't see a second failure message; exits
-  // that posted nothing pass `errorReason` so the user still gets a notice. The
-  // clear is durable (CT93 outbox, last-writer-wins per pair), so a terminal
-  // failure here just logs and the server age-sweep backstops it.
-  async concludeBeforeRun(payload, turnLog, startedAt, reason, errorReason) {
+  async concludeBeforeRun(reason, errorReason) {
+    const { payload, turnLog, startedAt } = this;
     const body = {
       activeRunStartedAt: null,
       // CT1046: this dispatch is over before it ran — retire its evidence so it
@@ -7737,25 +7780,47 @@ var Dispatcher = class {
       );
     }
     const durationMs = Date.now() - startedAt;
-    this.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
+    this.supervisor.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
     return { ok: false, durationMs, reason };
   }
-  // CT1288: `opts.turnId` is a RESUMED turn id — the id this event already ran
-  // under before the companion died. Passing it makes the replay ask the
-  // mailroom to re-admit the turn it already owns, which the server explicitly
-  // supports ("a replay reports, it never re-points"). Omitted on a fresh
-  // dispatch, where minting below is correct.
-  async handle(payload, opts = {}) {
-    const startedAt = Date.now();
-    const dispatchId = payload.messageId;
-    const workspaceId = this.opts.workspaceId;
-    const turnLog = this.opts.log.child({
-      workspaceId,
-      conversationId: payload.conversationId,
-      agentId: payload.agentId,
-      messageId: payload.messageId
-    });
-    const turnId = opts.turnId ?? randomUUID();
+  // The post-admission analogue of `concludeBeforeRun` (Codo's stack review,
+  // blocking finding #2): this turn WAS admitted — the mailroom holds it as
+  // the conversation's running turn — so the clear must NAME the turn and
+  // DECLARE its terminal outcome. A bare pre-run clear here would reset the
+  // participant flag while the turn metadata stayed running, the dispatch
+  // stayed live, and the queue stayed held until the reaper. `outcome`
+  // follows the settle wire's rule: a failure names its reason; without one
+  // the turn settled — the runtime-unavailable exit posts its user-facing
+  // `final` before concluding, so the turn genuinely produced its terminal
+  // output and `settled` releases the queue honestly.
+  async concludeAdmittedRun(reason, errorReason) {
+    const { payload, turnLog, startedAt, turnId } = this;
+    const body = {
+      activeRunStartedAt: null,
+      turnId,
+      settledMessageId: payload.messageId,
+      outcome: errorReason ? "failed" : "settled"
+    };
+    if (errorReason) body.errorReason = errorReason.slice(0, 200);
+    try {
+      await this.opts.api.setActiveRun(
+        this.opts.workspaceId,
+        payload.conversationId,
+        payload.agentId,
+        body
+      );
+    } catch (err) {
+      turnLog.warn(
+        { err: err instanceof Error ? err.message : String(err), turnId },
+        "dispatcher: admitted-run settle failed terminally; server age-sweep is the backstop"
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    this.supervisor.notifyEnd({ id: payload.messageId, ok: false, durationMs, reason });
+    return { ok: false, durationMs, reason };
+  }
+  async fetchContext() {
+    const { payload, turnId, turnLog } = this;
     let turnContext;
     try {
       turnContext = await this.opts.api.getTurnContext(
@@ -7770,35 +7835,36 @@ var Dispatcher = class {
           { err: err instanceof Error ? err.message : String(err) },
           "dispatcher: turn-context 404 (stale event \u2014 conversation/message/participant gone); skipping"
         );
-        return this.concludeBeforeRun(payload, turnLog, startedAt, "turn_context_not_found");
+        throw this.concluded("turn_context_not_found");
       }
       const reason = err instanceof Error ? err.message : String(err);
       turnLog.error({ err: reason }, "dispatcher: failed to fetch turn context");
       const fetchReason = `fetch_failed: ${reason}`;
-      return this.concludeBeforeRun(payload, turnLog, startedAt, fetchReason, fetchReason);
+      throw this.concluded(fetchReason, fetchReason);
     }
-    const message = turnContext.message;
+    this.turnContext = turnContext;
+  }
+  gateTrigger() {
+    const { payload, turnLog } = this;
+    const message = this.turnContext.message;
     const isDispatchableTrigger = message.role === "user" || message.role === "agent" || message.role === "system" && message.hasPrimaryDispatch === true;
     if (!isDispatchableTrigger) {
       turnLog.warn({ role: message.role }, "dispatcher: trigger role not dispatchable \u2014 skipping");
-      return this.concludeBeforeRun(
-        payload,
-        turnLog,
-        startedAt,
-        "unexpected_role",
-        UNEXPECTED_ROLE_REASON
-      );
+      throw this.concluded("unexpected_role", UNEXPECTED_ROLE_REASON);
     }
-    this.notifyStart({
-      id: dispatchId,
+    this.supervisor.notifyStart({
+      id: this.dispatchId,
       conversationId: payload.conversationId,
       message: message.body
     });
+  }
+  async resolveSecrets() {
+    const { payload, workspaceId, turnLog } = this;
     const secretStore = this.opts.secretStore ?? loadSecretStoreTolerant((m) => turnLog.warn(m));
     const { servers: resolvedMcpServers, missing } = resolveMcpSecrets(
       // CT262: the user MCP DEFINITIONS (placeholder form) come from the turn
       // context now, not a separate `getAgentSelf` run-config fetch.
-      turnContext.mcpServers ?? {},
+      this.turnContext.mcpServers ?? {},
       secretStore
     );
     if (missing.length > 0) {
@@ -7819,13 +7885,15 @@ var Dispatcher = class {
         );
       }
       const reason = `missing_secret: ${missing.join(",")}`;
-      return this.concludeBeforeRun(payload, turnLog, startedAt, reason);
+      throw this.concluded(reason);
     }
+    this.resolvedMcpServers = resolvedMcpServers;
+  }
+  async prepareEnvironment() {
+    const { payload, workspaceId, turnId, turnLog } = this;
     const localCwd = this.opts.local.cwd;
     const prepareHook = this.opts.local.prepareHook;
-    const cabaneCwd = turnContext.cwd;
-    let seqCounter = 0;
-    const nextSeq = () => ++seqCounter;
+    const cabaneCwd = this.turnContext.cwd;
     let effectiveCwd = localCwd ?? cabaneCwd;
     if (effectiveCwd && !existsSync10(effectiveCwd)) {
       turnLog.warn(
@@ -7835,9 +7903,9 @@ var Dispatcher = class {
       effectiveCwd = void 0;
     }
     let hookEnv;
-    const triggerIsPrepareFailure = message.body.startsWith(PREPARE_FAILED_PREFIX);
-    const prepareFailureDispatch = turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
-      dispatch: turnContext.dispatchedByAgentId,
+    const triggerIsPrepareFailure = this.turnContext.message.body.startsWith(PREPARE_FAILED_PREFIX);
+    const prepareFailureDispatch = this.turnContext.dispatchedByAgentId && !triggerIsPrepareFailure ? {
+      dispatch: this.turnContext.dispatchedByAgentId,
       dispatchBody: `${PREPARE_FAILED_PREFIX}
 
 The dispatched turn could not start. Re-dispatch it after repairing the preparation failure shown in this conversation.`
@@ -7863,11 +7931,11 @@ The dispatched turn could not start. Re-dispatch it after repairing the preparat
               conversationId: payload.conversationId,
               agentId: payload.agentId,
               agentUsername: this.opts.agentUsername,
-              runtime: turnContext.runtime,
-              hostAccess: turnContext.policy.hostFs,
-              triggerEntryPaths: turnContext.conversation.triggerEntryPaths ?? [],
-              title: turnContext.conversation.title,
-              messageBody: message.body,
+              runtime: this.turnContext.runtime,
+              hostAccess: this.turnContext.policy.hostFs,
+              triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
+              title: this.turnContext.conversation.title,
+              messageBody: this.turnContext.message.body,
               prepared: cached2
             });
           } catch (err) {
@@ -7889,7 +7957,7 @@ ${reason}`,
                 "dispatcher: prepare-rejection post failed"
               );
             }
-            return this.concludeBeforeRun(payload, turnLog, startedAt, `prepare_failed: ${reason}`);
+            throw this.concluded(`prepare_failed: ${reason}`);
           }
         }
       } else {
@@ -7897,7 +7965,7 @@ ${reason}`,
         let preparingStarted = false;
         let preparingSeq = null;
         const reportPreparing = (phase) => {
-          if (preparingSeq === null) preparingSeq = nextSeq();
+          if (preparingSeq === null) preparingSeq = this.nextSeq();
           const seq = preparingSeq;
           void this.opts.api.reportActivity(workspaceId, payload.conversationId, payload.agentId, {
             turnId,
@@ -7925,18 +7993,18 @@ ${reason}`,
             conversationId: payload.conversationId,
             agentId: payload.agentId,
             agentUsername: this.opts.agentUsername,
-            runtime: turnContext.runtime,
-            hostAccess: turnContext.policy.hostFs,
+            runtime: this.turnContext.runtime,
+            hostAccess: this.turnContext.policy.hostFs,
             // CT317/CT319: the trigger message's referenced-entry paths — what the
             // tasker prepare hook keys its per-task env off. Defaults to `[]` for
             // an older API. The conversation anchor is gone (CT319).
-            triggerEntryPaths: turnContext.conversation.triggerEntryPaths ?? [],
-            title: turnContext.conversation.title,
+            triggerEntryPaths: this.turnContext.conversation.triggerEntryPaths ?? [],
+            title: this.turnContext.conversation.title,
             // CT943: the dispatching message's text — where an `env:` directive
             // rides. The server has always sent the trigger body on the turn
             // context (for the live feed); this is the first thing to read it as
             // an INPUT, so a dispatch can ask for its environment in words.
-            messageBody: message.body
+            messageBody: this.turnContext.message.body
           });
           clearTimeout(preparingTimer);
           if (preparingStarted) reportPreparing("done");
@@ -7966,31 +8034,23 @@ ${reason}`,
             );
           }
           const failReason = `prepare_failed: ${reason}`;
-          return this.concludeBeforeRun(payload, turnLog, startedAt, failReason);
+          throw this.concluded(failReason);
         }
       }
     }
     const turnEnv = {
       ...hookEnv,
-      CABANE_HOST_ACCESS: turnContext.policy.hostFs ? "1" : "0",
+      CABANE_HOST_ACCESS: this.turnContext.policy.hostFs ? "1" : "0",
       CABANE_COMPANION_HOME: agentCompanionHome()
     };
-    const key = runKey(payload.conversationId, payload.agentId);
-    const abortController = new AbortController();
-    let pairAborts = this.aborts.get(key);
-    if (!pairAborts) {
-      pairAborts = /* @__PURE__ */ new Map();
-      this.aborts.set(key, pairAborts);
-    }
-    pairAborts.set(turnId, abortController);
-    const releaseAbort = () => {
-      const pair = this.aborts.get(key);
-      if (pair?.get(turnId) !== abortController) return;
-      pair.delete(turnId);
-      if (pair.size === 0) this.aborts.delete(key);
-    };
-    let timeoutReason = null;
-    let leaseLost = false;
+    this.effectiveCwd = effectiveCwd;
+    this.hookEnv = hookEnv;
+    this.turnEnv = turnEnv;
+  }
+  async acquireLease() {
+    const { payload, workspaceId, turnId, turnLog } = this;
+    const abortController = this.abortController;
+    this.supervisor.registerAbort(turnId, abortController);
     try {
       await this.opts.api.setActiveRun(workspaceId, payload.conversationId, payload.agentId, {
         activeRunStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8003,27 +8063,30 @@ ${reason}`,
       });
     } catch (err) {
       const refusal = leaseRefusal(err);
-      releaseAbort();
       if (refusal === "dispatch_not_admitted" || refusal === "turn_already_ended") {
         turnLog.error(
           { refusal, turnId },
           "dispatcher: refused a turn lease; not running the model"
         );
-        return this.concludeBeforeRun(payload, turnLog, startedAt, `lease_refused: ${refusal}`);
+        throw this.concluded(`lease_refused: ${refusal}`);
       }
       const reason = refusal ? `lease_refused: ${refusal}` : "lease_unconfirmed";
       turnLog.error(
         { refusal, turnId, err: err instanceof Error ? err.message : String(err) },
         "dispatcher: turn lease not confirmed; not running the model"
       );
-      return this.concludeBeforeRun(payload, turnLog, startedAt, reason, reason);
-    }
-    const sendState = createSendState();
-    const skipState = createSkipState();
-    const askState = createAskState();
-    const wakeState = createWakeState();
-    const replyState = createReplyState();
-    const controlOrder = createTurnControlOrder();
+      throw this.concluded(reason, reason);
+    }
+    this.admitted = true;
+  }
+  buildRequest() {
+    const { payload, workspaceId } = this;
+    const sendState = this.sendState = createSendState();
+    const skipState = this.skipState = createSkipState();
+    const askState = this.askState = createAskState();
+    const wakeState = this.wakeState = createWakeState();
+    const replyState = this.replyState = createReplyState();
+    const controlOrder = this.controlOrder = createTurnControlOrder();
     const turnControlServer = createTurnControlMcpServer(
       sendState,
       skipState,
@@ -8032,18 +8095,18 @@ ${reason}`,
       replyState,
       controlOrder
     );
-    const request = buildCompanionTurnRequest({
-      turnContext,
+    this.request = buildCompanionTurnRequest({
+      turnContext: this.turnContext,
       baseUrl: this.opts.baseUrl,
       agentPat: this.opts.credential,
       // CT306: the per-turn OBO credential when the API minted one; falls back to
       // the companion PAT (`agentPat`) inside `buildCompanionTurnRequest` otherwise.
-      ...turnContext.turnToken ? { turnToken: turnContext.turnToken } : {},
+      ...this.turnContext.turnToken ? { turnToken: this.turnContext.turnToken } : {},
       // SJ524: the hook-resolved cwd overrides the static local cwd.
-      ...effectiveCwd ? { cwd: effectiveCwd } : {},
+      ...this.effectiveCwd ? { cwd: this.effectiveCwd } : {},
       // CT1103: the prepare-hook env plus the authoritative host-access token.
-      env: turnEnv,
-      mcpServers: resolvedMcpServers,
+      env: this.turnEnv,
+      mcpServers: this.resolvedMcpServers,
       turnControlServer,
       // CT238: this turn's conversation, forwarded as the active-conversation
       // header so a cross-thread post/spawn stamps its origin.
@@ -8054,6 +8117,9 @@ ${reason}`,
       // CT289: the operator's auto-memory escape hatch (machine-local), when set.
       ...this.opts.local.claudeCode ? { claudeCode: this.opts.local.claudeCode } : {}
     });
+  }
+  async selectAdapter() {
+    const { payload, workspaceId, turnId, turnLog } = this;
     const onWarn = (msg, meta) => turnLog.warn(meta ?? {}, msg);
     const adapters = [];
     if (this.opts.claudeCodeAvailable?.() ?? true) {
@@ -8072,9 +8138,8 @@ ${reason}`,
       );
     }
     const registry = createAdapterRegistry(adapters);
-    let adapter;
     try {
-      adapter = selectAdapter(registry, turnContext.runtime);
+      this.adapter = selectAdapter(registry, this.turnContext.runtime);
     } catch (err) {
       if (!(err instanceof RuntimeUnavailableError)) throw err;
       turnLog.error(
@@ -8093,17 +8158,18 @@ ${reason}`,
           { err: postErr instanceof Error ? postErr.message : String(postErr) },
           "dispatcher: runtime-unavailable notice post failed"
         );
+        const reason = `runtime_unavailable:${err.runtime}`;
+        throw this.concluded(reason, reason);
       }
-      releaseAbort();
-      return this.concludeBeforeRun(
-        payload,
-        turnLog,
-        startedAt,
-        `runtime_unavailable:${err.runtime}`
-      );
+      throw this.concluded(`runtime_unavailable:${err.runtime}`);
     }
+  }
+  async execute() {
+    const { payload, workspaceId, turnId, turnLog, startedAt } = this;
+    const o = this.outcome;
+    const abortController = this.abortController;
     const totalTimeoutMs = this.opts.totalTimeoutMs ?? DEFAULT_AGENT_TOTAL_TIMEOUT_MS;
-    const transcript = this.opts.transcriptDir ? new TranscriptWriter(
+    const transcript = this.transcript = this.opts.transcriptDir ? new TranscriptWriter(
       this.opts.transcriptDir,
       {
         ts: new Date(startedAt).toISOString(),
@@ -8111,36 +8177,13 @@ ${reason}`,
         workspaceId,
         conversationId: payload.conversationId,
         agentId: payload.agentId,
-        dispatchId,
-        message: message.body
+        dispatchId: this.dispatchId,
+        message: this.turnContext.message.body
       },
       (m) => turnLog.warn(m)
     ) : null;
-    let sessionWritten = false;
-    let sessionDegraded = false;
-    let sessionWriteRejected = false;
-    let okResult = false;
-    let resultReason;
-    const turnRuntime = turnContext.runtime;
-    let turnUsage;
-    let turnResolvedModel;
-    let turnResolvedConfig;
-    let turnMcpInventory;
-    const eventCounts = {
-      session: 0,
-      text: 0,
-      thinking: 0,
-      tool: 0,
-      result: 0
-    };
-    let runtimeResultKind = null;
-    let contentBearingEvents = 0;
-    let latestSessionState = request.session;
-    let settledDiagnostics = null;
-    let silentMarkerEmitted = false;
-    let noteCommitFailed = () => {
-    };
-    const committer = new TurnCommitter({
+    const turnRuntime = this.turnContext.runtime;
+    const committer = this.committer = new TurnCommitter({
       api: this.opts.api,
       workspaceId,
       conversationId: payload.conversationId,
@@ -8151,29 +8194,32 @@ ${reason}`,
       parentMessageId: payload.messageId,
       signal: abortController.signal,
       log: turnLog,
-      nextSeq,
+      nextSeq: this.nextSeq,
       // The committer reads this at commit to carry the addressed send on the
       // terminal row; the server writes the send itself as a distinct message.
-      sendState,
+      sendState: this.sendState,
       // CT326: likewise the ask payload. CT1281: the server writes the ask as its
       // own addressed message to the human — which ENQUEUES like any other send —
       // and creates the `asks` row against that carrier, not against turn speech.
-      askState,
+      askState: this.askState,
       // CT442: likewise the wake payload — attached to the `final` row so the
       // server arms the wake schedule atomically with the reply it rode on.
-      wakeState,
-      replyState,
+      wakeState: this.wakeState,
+      replyState: this.replyState,
       // The ledger-derived owed reply, for the runtime's own declaration when
       // the agent doesn't call `reply_to` (resolveDeclaredReplyField).
-      owedReplyMessageId: turnContext.owedReplyMessageId ?? null,
+      owedReplyMessageId: this.turnContext.owedReplyMessageId ?? null,
       // CT1292: a commit that didn't land may mean this turn's lease is gone.
-      onCommitFailed: (err) => noteCommitFailed(err)
+      // `noteCommitFailed` is a field slot the lease watchdog fills when it
+      // arms (it starts as a no-op) — the committer only fires it from inside
+      // the adapter loop, which runs after the watchdog has replaced it.
+      onCommitFailed: (err) => this.noteCommitFailed(err)
     });
     const usesHttpTurnControl = turnRuntime === "codex" || turnRuntime === "opencode";
-    let turnControlIntentFetched = false;
-    const applyRecordedTurnControlIntent = async () => {
-      if (turnControlIntentFetched || !usesHttpTurnControl || !turnContext.turnToken) return;
-      turnControlIntentFetched = true;
+    this.applyRecordedTurnControlIntent = async () => {
+      if (this.turnControlIntentFetched || !usesHttpTurnControl || !this.turnContext.turnToken)
+        return;
+      this.turnControlIntentFetched = true;
       try {
         const intent = await this.opts.api.getTurnIntent(
           workspaceId,
@@ -8182,44 +8228,44 @@ ${reason}`,
           turnId
         );
         if (intent.ask) {
-          askState.targetUserId = intent.ask.targetUserId;
+          this.askState.targetUserId = intent.ask.targetUserId;
           if (intent.ask.questions && intent.ask.questions.length > 0) {
-            askState.questions = intent.ask.questions;
-            askState.question = null;
-            askState.headline = null;
-            askState.options = null;
+            this.askState.questions = intent.ask.questions;
+            this.askState.question = null;
+            this.askState.headline = null;
+            this.askState.options = null;
           } else {
-            askState.question = intent.ask.question ?? null;
-            askState.headline = intent.ask.headline ?? null;
-            askState.options = intent.ask.options ?? null;
-            askState.questions = null;
+            this.askState.question = intent.ask.question ?? null;
+            this.askState.headline = intent.ask.headline ?? null;
+            this.askState.options = intent.ask.options ?? null;
+            this.askState.questions = null;
           }
         }
         if (intent.wake) {
           if ("cancel" in intent.wake) {
-            wakeState.cancelled = true;
-            wakeState.afterSeconds = null;
-            wakeState.at = null;
-            wakeState.note = null;
+            this.wakeState.cancelled = true;
+            this.wakeState.afterSeconds = null;
+            this.wakeState.at = null;
+            this.wakeState.note = null;
           } else {
-            wakeState.cancelled = false;
-            wakeState.afterSeconds = intent.wake.afterSeconds ?? null;
-            wakeState.at = intent.wake.at ?? null;
-            wakeState.note = intent.wake.note;
+            this.wakeState.cancelled = false;
+            this.wakeState.afterSeconds = intent.wake.afterSeconds ?? null;
+            this.wakeState.at = intent.wake.at ?? null;
+            this.wakeState.note = intent.wake.note;
           }
         }
         if (intent.sendAgentId && intent.sendBody) {
-          sendState.agentId = intent.sendAgentId;
-          sendState.message = intent.sendBody;
-          sendState.order = intent.sendOrder ?? null;
+          this.sendState.agentId = intent.sendAgentId;
+          this.sendState.message = intent.sendBody;
+          this.sendState.order = intent.sendOrder ?? null;
         }
         if (intent.answersMessageId) {
-          replyState.answersMessageId = intent.answersMessageId;
-          replyState.order = intent.replyOrder ?? null;
+          this.replyState.answersMessageId = intent.answersMessageId;
+          this.replyState.order = intent.replyOrder ?? null;
         }
         if (intent.skipped) {
-          skipState.skipped = true;
-          skipState.reason = intent.skipReason;
+          this.skipState.skipped = true;
+          this.skipState.reason = intent.skipReason;
         }
       } catch (err) {
         turnLog.warn(
@@ -8231,7 +8277,7 @@ ${reason}`,
     const idleTimeoutMs = this.opts.idleTimeoutMs ?? DEFAULT_AGENT_IDLE_TIMEOUT_MS;
     const fireTimeout = (reason) => {
       if (abortController.signal.aborted) return;
-      timeoutReason = reason;
+      o.timeoutReason = reason;
       turnLog.warn(
         { reason, idleTimeoutMs, totalTimeoutMs },
         "dispatcher: turn timeout \u2014 aborting"
@@ -8250,7 +8296,7 @@ ${reason}`,
     const leaseRenewalMs = this.opts.leaseRenewalMs ?? DEFAULT_LEASE_RENEWAL_MS;
     let leaseCheckInFlight = false;
     const checkLease = async (trigger) => {
-      if (leaseLost || leaseCheckInFlight || abortController.signal.aborted) return;
+      if (o.leaseLost || leaseCheckInFlight || abortController.signal.aborted) return;
       leaseCheckInFlight = true;
       try {
         const state = await this.opts.api.checkTurnLease(
@@ -8261,7 +8307,7 @@ ${reason}`,
         );
         if (state !== "ended") return;
         if (abortController.signal.aborted) return;
-        leaseLost = true;
+        o.leaseLost = true;
         turnLog.warn(
           { turnId, trigger },
           "dispatcher: this turn is no longer running server-side \u2014 aborting the loop"
@@ -8273,26 +8319,31 @@ ${reason}`,
     };
     const leaseTimer = setInterval(() => void checkLease("cadence"), leaseRenewalMs);
     leaseTimer.unref?.();
-    noteCommitFailed = (err) => {
+    this.noteCommitFailed = (err) => {
       if (isWriteFenceRefusal(err)) void checkLease("commit_refused");
     };
+    this.disarmWatchdogs = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      clearTimeout(totalTimer);
+      clearInterval(leaseTimer);
+    };
     try {
-      for await (const event of adapter.runTurn(request, abortController.signal)) {
+      for await (const event of this.adapter.runTurn(this.request, abortController.signal)) {
         transcript?.write(event);
-        eventCounts[event.type] += 1;
-        if (isContentBearingEvent(event)) contentBearingEvents += 1;
+        o.eventCounts[event.type] += 1;
+        if (isContentBearingEvent(event)) o.contentBearingEvents += 1;
         armIdle();
         if (abortController.signal.aborted) {
           turnLog.info("dispatcher: aborted mid-turn");
-          okResult = false;
-          resultReason = timeoutReason ?? "cancelled";
+          o.okResult = false;
+          o.resultReason = o.timeoutReason ?? "cancelled";
           break;
         }
         if (event.type === "session") {
-          latestSessionState = event.state;
-          if (event.degraded) sessionDegraded = true;
-          if (!sessionWritten) {
-            sessionWritten = true;
+          o.latestSessionState = event.state;
+          if (event.degraded) o.sessionDegraded = true;
+          if (!o.sessionWritten) {
+            o.sessionWritten = true;
             try {
               await this.opts.api.setActiveRun(
                 workspaceId,
@@ -8303,7 +8354,7 @@ ${reason}`,
             } catch (err) {
               const status = err instanceof ApiError ? err.status : void 0;
               if (status !== void 0 && status >= 400 && status < 500) {
-                sessionWriteRejected = true;
+                o.sessionWriteRejected = true;
                 turnLog.error(
                   {
                     err: err instanceof Error ? err.message : String(err),
@@ -8323,48 +8374,52 @@ ${reason}`,
             }
           }
         } else if (event.type === "result") {
-          okResult = event.ok;
-          resultReason = event.reason;
-          turnUsage = event.usage;
-          turnResolvedModel = event.resolvedModel;
-          turnResolvedConfig = event.resolvedConfig;
-          turnMcpInventory = event.mcpInventory;
-          runtimeResultKind = event.ok ? "success" : event.reason === "no_terminal" ? "no_terminal" : "error";
-        } else if (event.type === "text" && skipState.skipped) {
+          o.okResult = event.ok;
+          o.resultReason = event.reason;
+          o.turnUsage = event.usage;
+          o.turnResolvedModel = event.resolvedModel;
+          o.turnResolvedConfig = event.resolvedConfig;
+          o.turnMcpInventory = event.mcpInventory;
+          o.runtimeResultKind = event.ok ? "success" : event.reason === "no_terminal" ? "no_terminal" : "error";
+        } else if (event.type === "text" && this.skipState.skipped) {
         } else {
           if (event.type === "text" && event.terminal) {
-            await applyRecordedTurnControlIntent();
+            await this.applyRecordedTurnControlIntent();
           }
           await committer.ingestEvent(event);
         }
       }
       if (abortController.signal.aborted) {
-        okResult = false;
-        resultReason = leaseLost ? "lease_lost" : timeoutReason ?? "cancelled";
+        o.okResult = false;
+        o.resultReason = o.leaseLost ? "lease_lost" : o.timeoutReason ?? "cancelled";
       }
-      const emptyResultReason = !skipState.skipped && classifyEmptyResult({ ok: okResult, contentBearingEvents, usage: turnUsage });
+      const emptyResultReason = !this.skipState.skipped && classifyEmptyResult({
+        ok: o.okResult,
+        contentBearingEvents: o.contentBearingEvents,
+        usage: o.turnUsage
+      });
       if (emptyResultReason) {
-        okResult = false;
-        resultReason = emptyResultReason;
+        o.okResult = false;
+        o.resultReason = emptyResultReason;
       }
-      if (!okResult && !resultReason) {
-        resultReason = "no_result";
+      if (!o.okResult && !o.resultReason) {
+        o.resultReason = "no_result";
       }
       if (!abortController.signal.aborted) {
-        await applyRecordedTurnControlIntent();
+        await this.applyRecordedTurnControlIntent();
       }
-      if (!abortController.signal.aborted && skipState.skipped) {
+      if (!abortController.signal.aborted && this.skipState.skipped) {
         turnLog.info(
-          { reason: skipState.reason, turnId, ok: okResult },
+          { reason: this.skipState.reason, turnId, ok: o.okResult },
           "agent skipped turn (skip_turn)"
         );
-        const { wake: skipWake } = wakeCommitField(wakeState);
+        const { wake: skipWake } = wakeCommitField(this.wakeState);
         try {
           await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
             body: SKIPPED_MARKER_BODY,
             kind: "skipped",
             turnId,
-            seq: nextSeq(),
+            seq: this.nextSeq(),
             parentMessageId: payload.messageId,
             ...skipWake ? { wake: skipWake } : {}
           });
@@ -8375,21 +8430,21 @@ ${reason}`,
           );
         }
       } else {
-        await committer.finalize(okResult);
-        if (!abortController.signal.aborted && okResult && !committer.finalEmitted) {
+        await committer.finalize(o.okResult);
+        if (!abortController.signal.aborted && o.okResult && !committer.finalEmitted) {
           try {
             await this.opts.api.postTurnMessage(workspaceId, payload.conversationId, {
               body: SILENT_MARKER_BODY,
               kind: "silent",
               turnId,
-              seq: nextSeq(),
+              seq: this.nextSeq(),
               parentMessageId: payload.messageId,
               // ask, wake and send must survive a wordless turn exactly as
               // they survive a textual final; dropping one can strand a person
               // or the next actor with no visible failure.
               ...committer.turnControlFields("silent")
             });
-            silentMarkerEmitted = true;
+            o.silentMarkerEmitted = true;
           } catch (err) {
             turnLog.warn(
               { err: err instanceof Error ? err.message : String(err) },
@@ -8399,27 +8454,25 @@ ${reason}`,
         }
       }
     } catch (err) {
-      okResult = false;
-      resultReason = err instanceof Error ? err.message : String(err);
-      turnLog.error({ err: resultReason }, "dispatcher: SDK query threw");
+      o.okResult = false;
+      o.resultReason = err instanceof Error ? err.message : String(err);
+      turnLog.error({ err: o.resultReason }, "dispatcher: SDK query threw");
     } finally {
-      if (idleTimer) clearTimeout(idleTimer);
-      clearTimeout(totalTimer);
-      clearInterval(leaseTimer);
-      if (leaseLost) {
-        resultReason = "lease_lost";
-        okResult = false;
+      this.disarmWatchdogs();
+      if (o.leaseLost) {
+        o.resultReason = "lease_lost";
+        o.okResult = false;
       }
-      const userCancelled = abortController.signal.aborted && timeoutReason === null && !leaseLost;
-      if (timeoutReason !== null) {
-        resultReason = timeoutReason;
-        okResult = false;
-        if (timeoutReason === "timeout_idle") {
+      const userCancelled = abortController.signal.aborted && o.timeoutReason === null && !o.leaseLost;
+      if (o.timeoutReason !== null) {
+        o.resultReason = o.timeoutReason;
+        o.okResult = false;
+        if (o.timeoutReason === "timeout_idle") {
           const health = this.opts.connectorHealth?.lookup(turnRuntime);
           if (health?.quotaState === "limited" && health.limitedUntil) {
             const resetMs = Date.parse(health.limitedUntil);
             if (Number.isFinite(resetMs) && resetMs > Date.now()) {
-              resultReason = encodeFailureReason({
+              o.resultReason = encodeFailureReason({
                 kind: "usage_capped",
                 resetsAt: health.limitedUntil
               });
@@ -8443,42 +8496,41 @@ ${reason}`,
         // turn is just as over, and its evidence must die with it.
         settledMessageId: payload.messageId
       };
-      if (turnUsage) {
-        body.usage = turnUsage;
+      if (o.turnUsage) {
+        body.usage = o.turnUsage;
       }
-      if (turnResolvedModel) {
-        body.resolvedModel = turnResolvedModel;
+      if (o.turnResolvedModel) {
+        body.resolvedModel = o.turnResolvedModel;
       }
-      if (turnResolvedConfig && Object.keys(turnResolvedConfig).length > 0) {
-        body.resolvedConfig = turnResolvedConfig;
+      if (o.turnResolvedConfig && Object.keys(o.turnResolvedConfig).length > 0) {
+        body.resolvedConfig = o.turnResolvedConfig;
       }
-      if (!okResult && resultReason && resultReason !== "cancelled" && !userCancelled && !leaseLost && !skipState.skipped) {
-        body.errorReason = resultReason.slice(0, 200);
+      if (!o.okResult && o.resultReason && o.resultReason !== "cancelled" && !userCancelled && !o.leaseLost && !this.skipState.skipped) {
+        body.errorReason = o.resultReason.slice(0, 200);
       }
-      if (okResult) {
+      if (o.okResult) {
         body.lastSeenMessageId = payload.messageId;
       }
-      body.outcome = okResult ? "settled" : body.errorReason ? "failed" : "interrupted";
-      if (sessionDegraded) {
+      body.outcome = o.okResult ? "settled" : body.errorReason ? "failed" : "interrupted";
+      if (o.sessionDegraded) {
         body.degraded = true;
       }
-      if (sessionWriteRejected && !this.sessionWriteNotified.has(key)) {
+      if (o.sessionWriteRejected && this.supervisor.claimSessionWriteNotice()) {
         body.sessionWriteRejected = true;
-        this.sessionWriteNotified.add(key);
       }
-      const outcome = skipState.skipped ? "skipped" : userCancelled || leaseLost ? "cancelled" : okResult ? "success" : "failure";
-      const diagnosticReason = outcome === "skipped" ? { kind: "skipped" } : outcome === "cancelled" ? leaseLost ? { kind: "lease_lost" } : { kind: "cancelled" } : outcome === "failure" ? normalizeTurnResultReason(resultReason) : null;
-      settledDiagnostics = {
+      const outcome = this.skipState.skipped ? "skipped" : userCancelled || o.leaseLost ? "cancelled" : o.okResult ? "success" : "failure";
+      const diagnosticReason = outcome === "skipped" ? { kind: "skipped" } : outcome === "cancelled" ? o.leaseLost ? { kind: "lease_lost" } : { kind: "cancelled" } : outcome === "failure" ? normalizeTurnResultReason(o.resultReason) : null;
+      o.settledDiagnostics = {
         outcome,
         resultReason: diagnosticReason,
-        sessionMode: sessionDegraded ? "degraded" : request.session ? "resumed" : "fresh",
-        sessionFingerprint: fingerprintSessionState(latestSessionState),
-        eventCounts,
-        runtimeResultKind,
-        ...turnMcpInventory ? { mcpInventory: turnMcpInventory } : {},
-        finalSource: outcome === "skipped" || outcome === "cancelled" || silentMarkerEmitted ? "marker" : committer.finalSource
+        sessionMode: o.sessionDegraded ? "degraded" : this.request.session ? "resumed" : "fresh",
+        sessionFingerprint: fingerprintSessionState(o.latestSessionState),
+        eventCounts: o.eventCounts,
+        runtimeResultKind: o.runtimeResultKind,
+        ...o.turnMcpInventory ? { mcpInventory: o.turnMcpInventory } : {},
+        finalSource: outcome === "skipped" || outcome === "cancelled" || o.silentMarkerEmitted ? "marker" : committer.finalSource
       };
-      body.diagnostics = settledDiagnostics;
+      body.diagnostics = o.settledDiagnostics;
       if (diagnosticReason && !["usage_capped", "rate_limited", "auth_expired", "cancelled", "skipped"].includes(
         diagnosticReason.kind
       )) {
@@ -8489,16 +8541,16 @@ ${reason}`,
             conversationId: payload.conversationId,
             agentId: payload.agentId,
             runtime: turnRuntime,
-            model: turnResolvedModel ?? null,
-            usage: turnUsage ?? null,
-            hadStoredSession: request.session != null,
-            diagnostics: settledDiagnostics
+            model: o.turnResolvedModel ?? null,
+            usage: o.turnUsage ?? null,
+            hadStoredSession: this.request.session != null,
+            diagnostics: o.settledDiagnostics
           },
           "dispatcher: anomalous turn settled"
         );
       }
       this.opts.connectorHealth?.recordSettle(turnRuntime, {
-        ok: okResult,
+        ok: o.okResult,
         errorReason: body.errorReason ?? null
       });
       try {
@@ -8514,45 +8566,151 @@ ${reason}`,
           "dispatcher: active-run clear failed terminally; server age-sweep is the backstop"
         );
       }
-      releaseAbort();
+      this.supervisor.releaseAbort(turnId, abortController);
     }
+  }
+  report() {
+    const o = this.outcome;
+    const { startedAt, turnLog } = this;
     const durationMs = Date.now() - startedAt;
-    const finalReplyBody = committer.replyBody;
-    if (transcript) {
-      transcript.close({
-        ok: okResult,
-        ...resultReason ? { reason: resultReason } : {},
+    const finalReplyBody = this.committer.replyBody;
+    if (this.transcript) {
+      this.transcript.close({
+        ok: o.okResult,
+        ...o.resultReason ? { reason: o.resultReason } : {},
         durationMs
       });
-      if (!okResult && resultReason !== "cancelled") {
-        turnLog.info(`turn failed \u2014 full transcript: ${transcript.path}`);
+      if (!o.okResult && o.resultReason !== "cancelled") {
+        turnLog.info(`turn failed \u2014 full this.transcript: ${this.transcript.path}`);
       }
-      if (settledDiagnostics?.resultReason?.kind === "empty_result" || settledDiagnostics?.resultReason?.kind === "empty_result_unverified") {
-        transcript.preserveAnomaly();
+      if (o.settledDiagnostics?.resultReason?.kind === "empty_result" || o.settledDiagnostics?.resultReason?.kind === "empty_result_unverified") {
+        this.transcript.preserveAnomaly();
       }
     }
-    if (okResult) {
+    if (o.okResult) {
       turnLog.debug({ durationMs }, "dispatcher: turn end (ok)");
-      this.notifyEnd({
-        id: dispatchId,
+      this.supervisor.notifyEnd({
+        id: this.dispatchId,
         ok: true,
         durationMs,
         ...finalReplyBody ? { reply: finalReplyBody.trim() } : {}
       });
       return { ok: true, durationMs };
     }
-    turnLog.debug({ durationMs, reason: resultReason }, "dispatcher: turn end (not ok)");
-    this.notifyEnd({
-      id: dispatchId,
+    turnLog.debug({ durationMs, reason: o.resultReason }, "dispatcher: turn end (not ok)");
+    this.supervisor.notifyEnd({
+      id: this.dispatchId,
       ok: false,
       durationMs,
-      ...resultReason ? { reason: resultReason } : {}
+      ...o.resultReason ? { reason: o.resultReason } : {}
     });
     return {
       ok: false,
       durationMs,
-      ...resultReason ? { reason: resultReason } : {}
+      ...o.resultReason ? { reason: o.resultReason } : {}
+    };
+  }
+};
+function fingerprintSessionState(state) {
+  if (!state) return null;
+  let opaqueId = state;
+  try {
+    const parsed = JSON.parse(state);
+    const candidate = parsed.sdkSessionId ?? parsed.threadId ?? parsed.sessionId;
+    if (typeof candidate === "string" && candidate.length > 0) opaqueId = candidate;
+  } catch {
+  }
+  return createHash2("sha256").update(opaqueId).digest("hex").slice(0, 16);
+}
+
+// src/dispatcher.ts
+function checkoutState(cwd) {
+  if (!cwd) return { ok: false, reason: "no working directory was resolved for this turn" };
+  if (!existsSync11(cwd)) return { ok: false, reason: `the working directory is gone (${cwd})` };
+  let entries;
+  try {
+    entries = readdirSync2(cwd);
+  } catch (error) {
+    return { ok: false, reason: `${cwd} is unreadable (${error.message})` };
+  }
+  if (entries.length === 0) {
+    return { ok: false, reason: `${cwd} is empty \u2014 a recreated shell, not a prepared directory` };
+  }
+  const gitPath = join14(cwd, ".git");
+  if (!existsSync11(gitPath)) return { ok: true, reason: "usable" };
+  let stat;
+  try {
+    stat = statSync(gitPath);
+  } catch (error) {
+    return { ok: false, reason: `${gitPath} is unreadable (${error.message})` };
+  }
+  if (stat.isDirectory() && !existsSync11(join14(gitPath, "HEAD")))
+    return { ok: false, reason: `${gitPath} has no HEAD \u2014 an empty shell, not a checkout` };
+  return { ok: true, reason: "usable" };
+}
+function runKey(conversationId, agentId) {
+  return `${conversationId}|${agentId}`;
+}
+var Dispatcher = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.aborts = opts.aborts ?? /* @__PURE__ */ new Map();
+  }
+  opts;
+  // CT1288: keyed (conversation|agent) → per-TURN controllers. Stop is
+  // pair-scoped and must reach every live loop for the pair.
+  aborts;
+  // CT1109: pairs already told "your session couldn't be saved" — the notice is
+  // once per (conversation, agent), while the rejection repeats every turn.
+  sessionWriteNotified = /* @__PURE__ */ new Set();
+  notifyStart(info) {
+    try {
+      this.opts.observer?.onStart(info);
+    } catch {
+    }
+  }
+  notifyEnd(info) {
+    try {
+      this.opts.observer?.onEnd(info);
+    } catch {
+    }
+  }
+  // CT1288: `opts.turnId` is a RESUMED turn id — the id this event already ran
+  // under before the companion died. Passing it makes the replay ask the
+  // mailroom to re-admit the turn it already owns, which the server explicitly
+  // supports ("a replay reports, it never re-points"). Omitted on a fresh
+  // dispatch, where minting is correct.
+  //
+  // CT1261: a short `handle` creates a `TurnExecution` and runs it. The
+  // supervisor seam hands the execution exactly the three cross-turn duties —
+  // the abort registry, the session-write notice latch, the observer — and
+  // nothing else.
+  async handle(payload, opts = {}) {
+    const key = runKey(payload.conversationId, payload.agentId);
+    const supervisor = {
+      registerAbort: (turnId, controller) => {
+        let pairAborts = this.aborts.get(key);
+        if (!pairAborts) {
+          pairAborts = /* @__PURE__ */ new Map();
+          this.aborts.set(key, pairAborts);
+        }
+        pairAborts.set(turnId, controller);
+      },
+      releaseAbort: (turnId, controller) => {
+        const pair = this.aborts.get(key);
+        if (pair?.get(turnId) !== controller) return;
+        pair.delete(turnId);
+        if (pair.size === 0) this.aborts.delete(key);
+      },
+      claimSessionWriteNotice: () => {
+        if (this.sessionWriteNotified.has(key)) return false;
+        this.sessionWriteNotified.add(key);
+        return true;
+      },
+      notifyStart: (info) => this.notifyStart(info),
+      notifyEnd: (info) => this.notifyEnd(info)
     };
+    return new TurnExecution(this.opts, supervisor, payload, opts).run();
   }
   // SJ383: cancel a specific (conversation, agent) run if one is in flight in
   // THIS companion process. Returns true if an in-flight run was aborted.
@@ -8569,17 +8727,6 @@ ${reason}`,
     return true;
   }
 };
-function fingerprintSessionState(state) {
-  if (!state) return null;
-  let opaqueId = state;
-  try {
-    const parsed = JSON.parse(state);
-    const candidate = parsed.sdkSessionId ?? parsed.threadId ?? parsed.sessionId;
-    if (typeof candidate === "string" && candidate.length > 0) opaqueId = candidate;
-  } catch {
-  }
-  return createHash2("sha256").update(opaqueId).digest("hex").slice(0, 16);
-}
 
 // src/opencode-models.ts
 var OPENCODE_RUNTIME = "opencode";
@@ -8624,7 +8771,7 @@ async function enumerateOpencodeModels(serverUrl, fetchImpl = fetch) {
 
 // src/outbox.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync3,
   readFileSync as readFileSync8,
@@ -8680,7 +8827,7 @@ var Outbox = class {
   // wedging the drain.
   list() {
     const dir2 = this.dir();
-    if (!existsSync11(dir2)) return [];
+    if (!existsSync12(dir2)) return [];
     let names;
     try {
       names = readdirSync3(dir2);
@@ -8716,7 +8863,7 @@ var Outbox = class {
   }
   size() {
     const dir2 = this.dir();
-    if (!existsSync11(dir2)) return 0;
+    if (!existsSync12(dir2)) return 0;
     try {
       return readdirSync3(dir2).filter((n) => n.endsWith(".json")).length;
     } catch {
@@ -9956,7 +10103,7 @@ function handleUncaught(log, err, origin) {
 }
 
 // src/crash-marker.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync9, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
 import { join as join16 } from "path";
 function crashMarkerPath() {
   return join16(cabaneDir(), "last-error.json");
@@ -9971,7 +10118,7 @@ function recordCrash(rec) {
 function clearCrash() {
   try {
     const path = crashMarkerPath();
-    if (existsSync12(path)) rmSync8(path, { force: true });
+    if (existsSync13(path)) rmSync8(path, { force: true });
   } catch {
   }
 }