@integrity-labs/agt-cli 0.28.1022 → 0.28.1024

package/dist/{chunk-5MUSHNVX.js → chunk-HVTL2N3I.js}

@@ -15,7 +15,7 @@ import {
   parseEnvFileEntries,
   parseEnvIntegrations,
   shellQuote
-} from "./chunk-QXJWRE64.js";
+} from "./chunk-5XPZF6FT.js";
 import {
   BIND_FAILURE_QUARANTINE_THRESHOLD,
   INTEGRATIONS_SECTION_END,
@@ -77,7 +77,7 @@ import {
   sessionTranscriptDir,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-X7SX25N6.js";
+} from "./chunk-BHKFVSIX.js";
 import {
   classifyUnanswerablePane,
   summarizeUnanswerablePane
@@ -7140,7 +7140,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.1022" : "dev";
+var agtCliVersion = true ? "0.28.1024" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -12094,4 +12094,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-5MUSHNVX.js.map
+//# sourceMappingURL=chunk-HVTL2N3I.js.map

package/dist/{claude-pair-runtime-KKFNGRSA.js → claude-pair-runtime-IAO6B35F.js}

@@ -266,7 +266,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-ZQDNCKQH.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-GZV4EXKD.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -734,4 +734,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-KKFNGRSA.js.map
+//# sourceMappingURL=claude-pair-runtime-IAO6B35F.js.map

package/dist/lib/manager-worker.js

@@ -66,7 +66,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-5MUSHNVX.js";
+} from "../chunk-HVTL2N3I.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -118,6 +118,8 @@ import {
   parseModelPolicy,
   policyResolvedModel,
   prepareForRespawn,
+  probeClaudeProcessInTmux,
+  probeTmuxSession,
   readChannelServerEnv,
   readDirectChatSessionState,
   readOpencodePaneLogTail,
@@ -147,7 +149,7 @@ import {
   takeZombieDetection,
   toOpencodeModel,
   writeEgressAllowlist
-} from "../chunk-QXJWRE64.js";
+} from "../chunk-5XPZF6FT.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -252,8 +254,10 @@ import {
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   transcriptActivityAgeSeconds
-} from "../chunk-X7SX25N6.js";
-import "../chunk-DHWNVVX4.js";
+} from "../chunk-BHKFVSIX.js";
+import {
+  classifyUnanswerablePane
+} from "../chunk-DHWNVVX4.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -9384,6 +9388,136 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   }
 }
 
+// src/lib/blocked-prompt-monitor.ts
+function observeBlockedPrompt(codeName, hasSession, capture) {
+  if (!hasSession) return { state: "unknown", reason: "no-session" };
+  let pane;
+  try {
+    pane = capture(codeName);
+  } catch {
+    return { state: "unknown", reason: "pane-unreadable" };
+  }
+  if (pane === null) return { state: "unknown", reason: "pane-unreadable" };
+  const kind = classifyUnanswerablePane(pane);
+  return kind ? { state: "blocked", kind } : { state: "clear" };
+}
+function carriedRecoveryFor(state9, pending2, codeName) {
+  return state9 === "clear" ? pending2.get(codeName) : void 0;
+}
+function foldPendingRecovery(cost, carried) {
+  const total = carried ? {
+    tasksDeferred: cost.tasksDeferred + carried.tasksDeferred,
+    messagesWithheld: cost.messagesWithheld + carried.messagesWithheld
+  } : cost;
+  return { total, hasCost: total.tasksDeferred > 0 || total.messagesWithheld > 0 };
+}
+function settlePendingRecovery(pending2, unreported, disposition) {
+  const retain = disposition === "withheld";
+  for (const [codeName, cost] of unreported) {
+    if (retain) pending2.set(codeName, cost);
+    else pending2.delete(codeName);
+  }
+}
+var BlockedPromptCostLedger = class {
+  /**
+   * DISTINCT ITEMS, NOT A RUNNING SUM (obi-wan `0d2a571b2181` on #6329, MAJOR).
+   *
+   * This held two integers and added to them on every call. Both accrual sites
+   * run once per ~10s poll over the SAME items:
+   *
+   *   - a scheduled-task deferral deliberately does NOT advance `nextFireAt`
+   *     (that is what makes the task fire once the prompt is answered instead
+   *     of backlogging), so `getReadyTasks` returns the same task every tick;
+   *   - a withheld direct-chat message is left PENDING for durable replay, so
+   *     `/host/direct-chat/poll` returns the same message id every tick.
+   *
+   * So the counters were multiplied by the number of polls the block lasted.
+   * One un-fired task on an agent blocked for the two days the ticket describes
+   * yields 2 days / 10s = ~17,280, and the alert renders "17280 scheduled
+   * task(s) not fired". The existing log lines are suppressed once-per-episode
+   * precisely BECAUSE they repeat; the counters sat outside that suppression
+   * and inherited the repetition instead.
+   *
+   * The whole argument for these numbers - "4 agents blocked, 9 scheduled tasks
+   * not fired is what makes someone act" - depends on them being counts of
+   * DISTINCT items. A number that grows with wall-clock time is not a cost, it
+   * is a clock, and an operator who spotted that would stop trusting the rest
+   * of the alert.
+   *
+   * Sets of ids make re-noting the same item idempotent, so correctness no
+   * longer depends on the caller noticing it is in a poll loop.
+   */
+  byAgent = /* @__PURE__ */ new Map();
+  episode(codeName) {
+    let e = this.byAgent.get(codeName);
+    if (!e) {
+      e = { tasks: /* @__PURE__ */ new Set(), messages: /* @__PURE__ */ new Set() };
+      this.byAgent.set(codeName, e);
+    }
+    return e;
+  }
+  /**
+   * Record scheduled tasks this episode has declined to fire, by task id.
+   *
+   * Called with the whole ready set each poll; re-noting an id already in the
+   * episode is a no-op, which is the point.
+   */
+  noteTasksDeferred(codeName, taskIds) {
+    const e = this.episode(codeName);
+    for (const id of taskIds) e.tasks.add(id);
+  }
+  /** Record one withheld direct-chat message, by message id. Idempotent. */
+  noteMessageWithheld(codeName, messageId) {
+    this.episode(codeName).messages.add(messageId);
+  }
+  costOf(codeName) {
+    const e = this.byAgent.get(codeName);
+    return { tasksDeferred: e?.tasks.size ?? 0, messagesWithheld: e?.messages.size ?? 0 };
+  }
+  /**
+   * Settle this sweep: return the cost to report, and the observation to report
+   * it WITH.
+   *
+   * A `clear` ends the episode, so the running total is cleared AFTER being
+   * read — the poll that observes recovery still reports what the episode cost.
+   * When that total is nonzero the observation is marked `recovering`, which is
+   * what licenses the rollup to count those counters at all: a plain clear's
+   * cost is ignored.
+   *
+   * IT IS NOT AN ANTI-TAMPERING GUARD, and this docblock used to say it was
+   * (obi-wan `579d2c059673`). Both the core module and the route retract that
+   * claim explicitly IN THIS SAME PR - `{state:'clear', recovering:true,
+   * tasks_deferred:N}` is a shape any caller can send, so the flag distinguishes
+   * a recovery from a plain clear and nothing more. I wrote the retraction
+   * twice and left the retracted sentence standing here, which is how the next
+   * reader ends up trusting a property that was withdrawn two files away.
+   *
+   * Returning the observation rather than having the caller decorate it keeps
+   * that rule in one testable place instead of inline in the poll.
+   */
+  settle(codeName, observation) {
+    const cost = this.costOf(codeName);
+    if (observation.state !== "clear") return { observation, cost };
+    this.byAgent.delete(codeName);
+    const hadCost = cost.tasksDeferred > 0 || cost.messagesWithheld > 0;
+    return { observation: hadCost ? { state: "clear", recovering: true } : observation, cost };
+  }
+  /**
+   * Drop an agent's episode entirely — teardown, not recovery (CodeRabbit on
+   * #6329). `clearAgentCaches` purges every other per-codeName map on a
+   * handoff, decommission or unassign; without this, an agent that left DURING
+   * a blocked episode would hand its `tasksDeferred` and `messagesWithheld` to
+   * whatever agent next takes that code name.
+   */
+  forget(codeName) {
+    this.byAgent.delete(codeName);
+  }
+  /** Current running cost without touching the episode. For tests and diagnostics. */
+  peek(codeName) {
+    return this.costOf(codeName);
+  }
+};
+
 // src/lib/occupancy-gate.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync9, readSync as readSync2, statSync as statSync11 } from "fs";
 import { join as join38 } from "path";
@@ -13048,6 +13182,8 @@ function hasRevokedResiduals(state9) {
 }
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var lastRestartWasExternal = /* @__PURE__ */ new Map();
+var blockedPromptCost = new BlockedPromptCostLedger();
+var pendingRecoveryCost = /* @__PURE__ */ new Map();
 var computerUseTunnels = new TunnelWatcher();
 var pendingRestartVerifications = /* @__PURE__ */ new Map();
 var agentCreatedAtMs = /* @__PURE__ */ new Map();
@@ -13790,7 +13926,7 @@ var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var dayRolloverInboundHold = /* @__PURE__ */ new Map();
 var INBOUND_HOLD_EPISODE_GAP_MS = 12e4;
 async function channelInboundActivityAgeSecondsFor(codeName) {
-  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-Q27WU2MW.js");
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-WRHLHQCE.js");
   const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
@@ -14488,6 +14624,8 @@ function resolveAgentFramework(codeName) {
 function clearAgentCaches(agentId, codeName) {
   const channelCacheMutated = clearAgentState(agentId, codeName);
   agentChannelTokens.delete(codeName);
+  blockedPromptCost.forget(codeName);
+  pendingRecoveryCost.delete(codeName);
   lastRefreshPayload.delete(agentId);
   boardTokenCache.forget(agentId);
   refreshFetchGate.forget(agentId);
@@ -14534,7 +14672,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.1022" : "dev";
+var agtCliVersion = true ? "0.28.1024" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -16169,7 +16307,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-ZQDNCKQH.js");
+      const { collectDiagnostics } = await import("../persistent-session-GZV4EXKD.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -16311,7 +16449,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-KQYYZZVW.js");
-      const { collectDiagnostics } = await import("../persistent-session-ZQDNCKQH.js");
+      const { collectDiagnostics } = await import("../persistent-session-GZV4EXKD.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor) : void 0;
       let tailscaleHostname;
@@ -16487,7 +16625,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-Q27WU2MW.js");
+      } = await import("../responsiveness-probe-WRHLHQCE.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -16604,7 +16742,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-Q27WU2MW.js");
+        } = await import("../responsiveness-probe-WRHLHQCE.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-M6AFZWNU.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -16760,7 +16898,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-VR5QGP3J.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-JJUKS75B.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-ZKC2HH6T.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -17022,6 +17160,107 @@ async function pollCycleInner() {
         }
       }
     }
+    let sweepComplete = false;
+    let omittedNoSession = 0;
+    try {
+      const unreportedRecovery = /* @__PURE__ */ new Map();
+      const sweeps = [];
+      for (const agent of agents) {
+        if (agent.status !== "active") continue;
+        const framework = agent.framework ?? agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK;
+        if (framework !== "claude-code") continue;
+        const tmuxProbe = probeTmuxSession(`agt-${agent.code_name}`);
+        const claudeProbe = tmuxProbe === "alive" ? probeClaudeProcessInTmux(`agt-${agent.code_name}`) : "dead";
+        if (tmuxProbe === "unknown" || claudeProbe === "unknown") {
+          sweeps.push({
+            agent_id: agent.agent_id,
+            state: "unknown",
+            unknown_reason: "pane-unreadable",
+            tasks_deferred: 0,
+            messages_withheld: 0
+          });
+          continue;
+        }
+        if (tmuxProbe !== "alive" || claudeProbe !== "alive") {
+          omittedNoSession += 1;
+          continue;
+        }
+        const observation = observeBlockedPrompt(agent.code_name, true, (codeName) => {
+          try {
+            return syncExecFile("tmux", ["capture-pane", "-t", `agt-${codeName}`, "-p"], {
+              stdio: ["ignore", "pipe", "ignore"],
+              timeout: 2e3
+            }).toString();
+          } catch {
+            return null;
+          }
+        });
+        const { observation: settled, cost } = blockedPromptCost.settle(
+          agent.code_name,
+          observation
+        );
+        const carried = carriedRecoveryFor(settled.state, pendingRecoveryCost, agent.code_name);
+        const { total, hasCost } = foldPendingRecovery(cost, carried);
+        const recovering = settled.state === "clear" && hasCost;
+        if (recovering) unreportedRecovery.set(agent.code_name, total);
+        sweeps.push({
+          agent_id: agent.agent_id,
+          state: settled.state,
+          ...settled.state === "blocked" ? { variant: settled.kind } : {},
+          ...settled.state === "unknown" ? { unknown_reason: settled.reason } : {},
+          ...recovering ? { recovering: true } : {},
+          tasks_deferred: total.tasksDeferred,
+          messages_withheld: total.messagesWithheld
+        });
+      }
+      sweepComplete = omittedNoSession === 0;
+      if (!sweepComplete) {
+        log(
+          `[blocked-prompt-monitor] partial sweep: ${omittedNoSession} active agent(s) had no live session, so this batch may not close an open alert (ENG-10825)`
+        );
+      }
+      if (sweeps.length === 0 && omittedNoSession > 0) {
+        log(
+          `[blocked-prompt-monitor] NOTHING REPORTED: all ${omittedNoSession} active claude-code agent(s) had no live session this poll, so no batch was sent and this host is unassessed. A wedged tmux now reads as 'unknown' rather than 'dead', so reaching here means either a genuine host-wide teardown or no tmux server at all (ENG-10825)`
+        );
+      }
+      if (sweeps.length > 0) {
+        const disposition = await api.post(
+          "/host/blocked-prompt-report",
+          {
+            agents: sweeps,
+            sweep_complete: sweepComplete,
+            // WHY the sweep was partial, not just that it was (obi-wan
+            // `82a0dd7ef253`). `sweep_complete: false` tells the route it may
+            // not close an alert; it does not tell an operator that four agents
+            // on this host have no session and that is why their critical will
+            // not clear. The route writes this onto the alert payload.
+            omitted_no_session: omittedNoSession
+          }
+        ).then((res) => {
+          const dropped = res?.dropped_agent_ids ?? [];
+          if (dropped.length > 0) {
+            log(
+              `[blocked-prompt-monitor] the route DROPPED ${dropped.length} reported agent(s): ${dropped.join(", ")} \u2014 they are not in host_agents for this host, so this sweep cannot be complete and an open alert cannot close until they stop being swept or the rows return (ENG-10825)`
+            );
+          }
+          return res?.cost_disposition;
+        }).catch((err) => {
+          log(
+            `[blocked-prompt-monitor] report failed (ENG-10825): ${err.message} \u2014 the sweep still ran locally; this poll's result did not reach the alert board`
+          );
+          return "withheld";
+        });
+        settlePendingRecovery(pendingRecoveryCost, unreportedRecovery, disposition);
+        if (disposition === "withheld" && unreportedRecovery.size > 0) {
+          log(
+            `[blocked-prompt-monitor] holding ${unreportedRecovery.size} unreported recovery total(s) for the next poll \u2014 the route did not persist them (ENG-10825)`
+          );
+        }
+      }
+    } catch (err) {
+      log(`[blocked-prompt-monitor] sweep threw (suppressed): ${err.message}`);
+    }
     const frameworksThisCycle = new Set(agents.map((a) => a.framework).filter(Boolean));
     for (const fw of frameworksThisCycle) {
       await ensureFrameworkBinary(fw);
@@ -17252,6 +17491,21 @@ async function pollCycleInner() {
         // reason untouched. Merge-then-write rather than write-fresh: clobbering
         // the file each poll would reset gave_up_at and keep re-arming the
         // give-up notice for as long as the modal sat there.
+        // ENG-10972 AC3: the wedged-on-a-prompt marker the channel servers read.
+        // Its own file with nothing to preserve, so write-fresh is correct - unlike
+        // watchdog-give-up.json, whose gave_up_at must survive a refresh.
+        refreshBlockedPromptLiveness: (codeName, kind) => {
+          const dir = getFramework("claude-code").getAgentDir(codeName);
+          if (!existsSync19(dir)) return;
+          atomicWriteFileSync(
+            join42(dir, "blocked-prompt.json"),
+            JSON.stringify({ kind, last_seen_at: (/* @__PURE__ */ new Date()).toISOString() })
+          );
+        },
+        clearBlockedPromptLiveness: (codeName) => {
+          const file = join42(getFramework("claude-code").getAgentDir(codeName), "blocked-prompt.json");
+          if (existsSync19(file)) rmSync8(file, { force: true });
+        },
         refreshUsageLimitLiveness: (codeName) => {
           const dir = getFramework("claude-code").getAgentDir(codeName);
           const file = join42(dir, "watchdog-give-up.json");
@@ -20917,6 +21171,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash20("sha256")
       const blockedKind = sessionBlockedOnPrompt(codeName);
       if (blockedKind) {
         deferReadyForBlockedPrompt = true;
+        blockedPromptCost.noteTasksDeferred(codeName, ready.map((t) => t.taskId));
         if (shouldLogBlockedPrompt(codeName, "scheduled-firing")) {
           log(
             `[persistent-session] Deferring ${ready.length} ready task(s) for '${codeName}' \u2014 session is blocked on an interactive prompt (${blockedKind}) and cannot run a tool call; schedule NOT advanced, will fire once the prompt is answered (further deferrals this episode are not logged) [ENG-10335]`
@@ -21186,7 +21441,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
       try {
         const freshId = rotateSessionForWedge(codeName);
         consecutiveWedgeCycles.delete(codeName);
-        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-Q27WU2MW.js");
+        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-WRHLHQCE.js");
         const { parked, deadLettered } = parkForRestart(codeName, /* @__PURE__ */ new Date());
         const parkNote = parked > 0 ? `, ${parked} inbound parked` : "";
         const deadNote = deadLettered > 0 ? `, ${deadLettered} undeliverable dead-lettered` : "";
@@ -21229,7 +21484,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-ZQDNCKQH.js");
+        const { collectDiagnostics } = await import("../persistent-session-GZV4EXKD.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -21280,7 +21535,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-ZQDNCKQH.js");
+      const { collectDiagnostics } = await import("../persistent-session-GZV4EXKD.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -21679,6 +21934,7 @@ async function processDirectChatMessage(agent, msg) {
     return;
   }
   const blockedOnPrompt = sessionBlockedOnPrompt(agent.codeName);
+  if (blockedOnPrompt) blockedPromptCost.noteMessageWithheld(agent.codeName, msg.id);
   if (blockedOnPrompt && shouldLogBlockedPrompt(agent.codeName, "direct-chat")) {
     log(
       `[direct-chat] Not delivering to '${agent.codeName}' (msg=${msg.id}) \u2014 session is blocked on an interactive prompt (${blockedOnPrompt}), so nothing in-session can pull it; leaving pending for durable replay once the prompt is answered (further messages this episode are not logged) [ENG-10335]`
@@ -21951,7 +22207,7 @@ async function processClaudePairSessions(agents) {
     // cannot take it for itself — by the time it runs, the write it is looking
     // for may already have happened.
     snapshotPairConfig
-  } = await import("../claude-pair-runtime-KKFNGRSA.js");
+  } = await import("../claude-pair-runtime-IAO6B35F.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));