@integrity-labs/agt-cli 0.28.1148 → 0.28.1150

package/dist/lib/manager-worker.js

@@ -77,11 +77,11 @@ import {
   setConfigHash,
   shellGuard,
   tripClass
-} from "../chunk-EZUCUG2W.js";
+} from "../chunk-HZFXWUA2.js";
 import {
   CLAUDE_CODE_SECURITY_FLOOR,
   compareVersions
-} from "../chunk-LAPK7BDU.js";
+} from "../chunk-NSX27ZTP.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -168,7 +168,7 @@ import {
   webFetchBaselineValue,
   webFetchRestartNeeded,
   writeEgressAllowlist
-} from "../chunk-2PGIZQIJ.js";
+} from "../chunk-OISSVMYG.js";
 import {
   isAgentIdle,
   isStaleForToday,
@@ -177,7 +177,7 @@ import {
   sessionTranscriptDir,
   subagentActivityAgeSeconds,
   transcriptActivityAgeSeconds
-} from "../chunk-JZZW47PT.js";
+} from "../chunk-AJ2Z3VSN.js";
 import {
   classifyUnanswerablePane,
   focusedConfirmDialogBlock,
@@ -190,6 +190,13 @@ import {
   parsePsRows,
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
+import {
+  CLAUDE_CONFIG_DIR_ENV,
+  claudeConfigDirFor,
+  claudeConfigDirIsReady,
+  effectiveClaudeJsonPath,
+  seedClaudeConfigFromLegacy
+} from "../chunk-EL5MWGGH.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -293,14 +300,7 @@ import {
   serializeAccountEnforcementMarker,
   stabiliseResetInstant,
   sumTranscriptUsageInWindow
-} from "../chunk-D25NK5E5.js";
-import {
-  CLAUDE_CONFIG_DIR_ENV,
-  claudeConfigDirFor,
-  claudeConfigDirIsReady,
-  effectiveClaudeJsonPath,
-  seedClaudeConfigFromLegacy
-} from "../chunk-EL5MWGGH.js";
+} from "../chunk-TLDY7AE4.js";
 import "../chunk-DGUM43GV.js";
 
 // src/lib/manager-worker.ts
@@ -957,6 +957,156 @@ function claudeCodeUpgradeThrottled() {
   }
 }
 
+// src/lib/claude-pair-loop.ts
+var PAIR_LOOP_ACTIVE_INTERVAL_MS = 2e3;
+var PAIR_LOOP_IDLE_INTERVAL_MS = 1e4;
+var PAIR_LOOP_MAX_BACKOFF_MS = 12e4;
+var PAIR_LOOP_ARMED_MAX_MS = 15 * 6e4;
+function pairLoopArmed(opts) {
+  const max = opts.maxArmedMs ?? PAIR_LOOP_ARMED_MAX_MS;
+  const live = /* @__PURE__ */ new Set([...opts.spawnedPairIds, ...opts.pendingPairIds]);
+  for (const id of [...opts.firstSeenMs.keys()]) {
+    if (!live.has(id)) opts.firstSeenMs.delete(id);
+  }
+  let fresh = false;
+  for (const id of live) {
+    let seen = opts.firstSeenMs.get(id);
+    if (seen === void 0) {
+      seen = opts.nowMs;
+      opts.firstSeenMs.set(id, seen);
+    }
+    if (opts.nowMs - seen < max) fresh = true;
+  }
+  return fresh;
+}
+function nextPairLoopDelayMs(armed, consecutiveFailures) {
+  if (consecutiveFailures > 0) {
+    const exp = Math.min(consecutiveFailures - 1, 16);
+    return Math.min(PAIR_LOOP_IDLE_INTERVAL_MS * 2 ** exp, PAIR_LOOP_MAX_BACKOFF_MS);
+  }
+  return armed ? PAIR_LOOP_ACTIVE_INTERVAL_MS : PAIR_LOOP_IDLE_INTERVAL_MS;
+}
+var ClaudePairLoop = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+  }
+  timer = null;
+  inFlight = false;
+  started = false;
+  consecutiveFailures = 0;
+  // Bumped by stop(): a timer callback from an earlier start() whose tick is
+  // still in flight must not schedule a second timer chain after a restart.
+  generation = 0;
+  inFlightTick = null;
+  setTimer;
+  clearTimer;
+  /** Arm the loop. The first tick runs after one idle interval. Idempotent. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.schedule(PAIR_LOOP_IDLE_INTERVAL_MS);
+  }
+  /**
+   * Disarm the loop. No new tick starts, and a callback from this generation
+   * will not reschedule. Returns a promise that settles when a tick already in
+   * flight has finished (immediately if none), so shutdown can wait for it
+   * before sweeping tmux sessions.
+   */
+  stop() {
+    this.started = false;
+    this.generation += 1;
+    if (this.timer != null) this.clearTimer(this.timer);
+    this.timer = null;
+    const pending2 = this.inFlightTick;
+    return pending2 ? pending2.then(() => void 0, () => void 0) : Promise.resolve();
+  }
+  /** True while started. A tick in flight checks this before spawning anything new. */
+  get accepting() {
+    return this.started;
+  }
+  get failures() {
+    return this.consecutiveFailures;
+  }
+  /** True while a tick is running. Set synchronously before the tick starts. */
+  get busy() {
+    return this.inFlight;
+  }
+  /** One guarded pass. Safe to call from anywhere; never overlaps itself. */
+  async runOnce() {
+    if (!this.deps.canRun()) return "skipped-not-running";
+    if (this.inFlight) return "skipped-in-flight";
+    this.inFlight = true;
+    try {
+      const tick = this.deps.tick();
+      this.inFlightTick = tick;
+      await tick;
+      if (this.consecutiveFailures > 0) {
+        this.deps.log(`[claude-pair] loop recovered after ${this.consecutiveFailures} failed tick(s)`);
+      }
+      this.consecutiveFailures = 0;
+      return "ran";
+    } catch (err) {
+      this.consecutiveFailures += 1;
+      if (this.consecutiveFailures === 1 || this.consecutiveFailures % 10 === 0) {
+        this.deps.log(
+          `[claude-pair] poll failed (${this.consecutiveFailures} in a row): ${err?.message ?? String(err)}`
+        );
+      }
+      return "failed";
+    } finally {
+      this.inFlight = false;
+      this.inFlightTick = null;
+    }
+  }
+  schedule(ms) {
+    if (!this.started) return;
+    const gen = this.generation;
+    const h = this.setTimer(() => {
+      this.timer = null;
+      if (gen !== this.generation) return;
+      void this.runOnce().finally(() => {
+        if (gen !== this.generation) return;
+        let armed = false;
+        try {
+          armed = this.deps.isArmed();
+        } catch {
+          armed = false;
+        }
+        this.schedule(nextPairLoopDelayMs(armed, this.consecutiveFailures));
+      });
+    }, ms);
+    if (h && typeof h === "object" && typeof h.unref === "function") h.unref();
+    this.timer = h;
+  }
+};
+var PairRetryBackoff = class {
+  state = /* @__PURE__ */ new Map();
+  /** True while this pair is inside its backoff window: skip it this tick. */
+  shouldSkip(pairId, nowMs) {
+    const s = this.state.get(pairId);
+    return !!s && nowMs < s.notBeforeMs;
+  }
+  recordFailure(pairId, nowMs) {
+    const failures = (this.state.get(pairId)?.failures ?? 0) + 1;
+    this.state.set(pairId, { failures, notBeforeMs: nowMs + nextPairLoopDelayMs(true, failures) });
+    return failures;
+  }
+  /** A dispatch that completed clears the pair's backoff. */
+  recordSuccess(pairId) {
+    this.state.delete(pairId);
+  }
+  /** Forget pairs that are neither spawned nor pending any more. */
+  prune(liveIds) {
+    const live = new Set(liveIds);
+    for (const id of [...this.state.keys()]) if (!live.has(id)) this.state.delete(id);
+  }
+  failuresFor(pairId) {
+    return this.state.get(pairId)?.failures ?? 0;
+  }
+};
+
 // src/lib/mcp-config-drift.ts
 import { createHash } from "crypto";
 function decideMcpDriftAction(currentHash, knownHash) {
@@ -14891,7 +15041,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-YLIBVLAR.js");
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-LVRBC2AA.js");
   const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
@@ -15649,7 +15799,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.1148" : "dev";
+var agtCliVersion = true ? "0.28.1150" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -17424,7 +17574,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-MFHKSBD5.js");
+      const { collectDiagnostics } = await import("../persistent-session-YKRO5RLK.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -17566,7 +17716,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-KQYYZZVW.js");
-      const { collectDiagnostics } = await import("../persistent-session-MFHKSBD5.js");
+      const { collectDiagnostics } = await import("../persistent-session-YKRO5RLK.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor) : void 0;
       let tailscaleHostname;
@@ -17766,8 +17916,13 @@ async function pollCycleInner() {
       setConfigHash(hbResp?.config_hash ?? null);
       try {
         const desiredClaudeCodeVersion = hbResp?.desired_claude_code_version?.trim();
-        const { maybeUpdateClaudeCode, shouldRunClaudeCodeUpdater } = await import("../claude-code-updater-NJMCC77Q.js");
-        if (desiredClaudeCodeVersion && shouldRunClaudeCodeUpdater({
+        const { maybeUpdateClaudeCode, shouldRunClaudeCodeUpdater } = await import("../claude-code-updater-JXL4CM2V.js");
+        claudeUpdaterInFlight = true;
+        if (desiredClaudeCodeVersion && (claudePairLoop.busy || claudePairingInProgress())) {
+          log(
+            claudePairingInProgress() ? "[claude-code-updater] Claude re-login in progress on this host, deferring to a later cycle" : "[claude-code-updater] a claude-pair poll is mid-flight (no re-login), deferring to the next cycle"
+          );
+        } else if (desiredClaudeCodeVersion && shouldRunClaudeCodeUpdater({
           desiredVersion: desiredClaudeCodeVersion,
           installedVersion: cachedFrameworkVersion,
           windowGate: decideMaintenanceWindowGate({ window: cachedMaintenanceWindow, now: /* @__PURE__ */ new Date() })
@@ -17780,6 +17935,8 @@ async function pollCycleInner() {
         }
       } catch (err) {
         log(`Claude Code updater error: ${err.message}`);
+      } finally {
+        claudeUpdaterInFlight = false;
       }
     } catch (err) {
       setConfigHash(null);
@@ -17791,7 +17948,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-YLIBVLAR.js");
+      } = await import("../responsiveness-probe-LVRBC2AA.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -17908,7 +18065,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-YLIBVLAR.js");
+        } = await import("../responsiveness-probe-LVRBC2AA.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-M6AFZWNU.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -18194,7 +18351,7 @@ async function pollCycleInner() {
                 }
               }
             );
-            const { parkPendingInbound } = await import("../responsiveness-probe-YLIBVLAR.js");
+            const { parkPendingInbound } = await import("../responsiveness-probe-LVRBC2AA.js");
             const { parked, deadLettered } = parkPendingInbound(codeName, new Date(fatalNowMs));
             paneFatalStreak.delete(codeName);
             paneFatalRestarts.set(codeName, [...history, fatalNowMs]);
@@ -18225,7 +18382,7 @@ async function pollCycleInner() {
         TRANSCRIPT_MOUNT_ESCALATION_REFRESH_MS,
         bindSourceEscalations
       } = await import("../transcript-mount-health-OHE6IVJV.js");
-      const { transcriptBindSourcesFor, ensureTranscriptBindSources } = await import("../persistent-session-MFHKSBD5.js");
+      const { transcriptBindSourcesFor, ensureTranscriptBindSources } = await import("../persistent-session-YKRO5RLK.js");
       const mountConfig = resolveTranscriptMountConfig();
       const liveAgents = agentState.persistentSessionAgents;
       for (const tracked of [
@@ -18390,7 +18547,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-VR5QGP3J.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-PUVWMX5P.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-FREXPXHN.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -18460,6 +18617,10 @@ async function pollCycleInner() {
     }
     const data = await api.post("/host/agents", { host_id: hostId });
     const agents = data.agents ?? [];
+    pairableAgentsSnapshot = agents.map((a) => ({
+      agentId: a.agent_id,
+      codeName: a.code_name
+    }));
     hostFlagStore().setMirrorAgentIds(agents.map((a) => a.agent_id));
     if (agents.length > 0) {
       if (consecutiveEmptyAgentPolls > 0) {
@@ -18881,14 +19042,6 @@ async function pollCycleInner() {
         clearAgentCaches(prev.agentId, prev.codeName);
       }
     }
-    try {
-      await processClaudePairSessions(agents.map((a) => ({
-        agentId: a.agent_id,
-        codeName: a.code_name
-      })));
-    } catch (err) {
-      log(`[claude-pair] poll failed: ${err.message}`);
-    }
     if (Date.now() - lastChannelSweepAt >= CHANNEL_SWEEP_INTERVAL_MS) {
       lastChannelSweepAt = Date.now();
       const agentCodeNames = new Set(
@@ -22269,7 +22422,11 @@ async function ensurePersistentSessionUnchecked(agent, tasks, boardItems, refres
   const currentPolicyId = currentPolicyModel ? modelPolicy?.policyId ?? null : null;
   const recordedAuthTuple = claudeAuthTupleBySession.get(codeName);
   const recordedPolicyModel = modelPolicyModelBySession.get(codeName);
-  if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && isSessionHealthy(codeName)) {
+  const authTupleChanged = Boolean(recordedAuthTuple && recordedAuthTuple !== currentAuthTuple);
+  if (authTupleChanged && claudePairingInProgress()) {
+    log(`[${codeName}] auth tuple changed while a Claude re-login is in progress, deferring the restart to the next cycle`);
+  }
+  if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && !claudePairingInProgress() && isSessionHealthy(codeName)) {
     const authTupleDiff = diffAuthTuples(recordedAuthTuple, currentAuthTuple);
     log(
       `[persistent-session] Auth config changed for '${codeName}' (${recordedAuthTuple} \u2192 ${currentAuthTuple}) \u2014 ${authTupleDiff.summary} \u2014 restarting session`
@@ -22280,7 +22437,9 @@ async function ensurePersistentSessionUnchecked(agent, tasks, boardItems, refres
       previousModel: recordedPolicyModel,
       currentModel: currentPolicyModel
     });
-    if (policyNotice && isSessionHealthy(codeName)) {
+    let restartNoticeLanded = false;
+    const noticeAlreadyDelivered = restartNoticeDeliveredFor.get(codeName) === currentAuthTuple;
+    if (policyNotice && isSessionHealthy(codeName) && !noticeAlreadyDelivered) {
       const status = await injectMessageWithStatus(
         codeName,
         "system",
@@ -22293,6 +22452,7 @@ async function ensurePersistentSessionUnchecked(agent, tasks, boardItems, refres
         log
       ).catch(() => ({ delivered: false, fallbackUsed: false }));
       if (status.fallbackUsed) {
+        restartNoticeLanded = true;
         await new Promise((r) => setTimeout(r, 3e3));
       } else {
         log(
@@ -22300,18 +22460,35 @@ async function ensurePersistentSessionUnchecked(agent, tasks, boardItems, refres
         );
       }
     }
-    stopPersistentSessionAndForgetMcpBaseline(codeName, "auth-tuple-change", void 0, void 0, {
-      reason: authTupleDiff.summary,
-      detail: {
-        auth_tuple: {
-          changed: authTupleDiff.changed,
-          unchanged: authTupleDiff.unchanged,
-          components: authTupleDiff.components
-        }
+    if (claudePairingInProgress()) {
+      if (restartNoticeLanded) {
+        restartNoticeDeliveredFor.set(codeName, currentAuthTuple);
+        await injectMessageWithStatus(
+          codeName,
+          "system",
+          "Update: the restart announced above is postponed for a moment while a Claude sign-in finishes on this host. Carry on; it will happen shortly, without a further notice.",
+          { task_name: "model-policy-restart-postponed" },
+          log
+        ).catch(() => void 0);
       }
-    });
-    agentState.persistentSessionAgents.delete(codeName);
-    restartTrigger = "auth-tuple";
+      log(
+        `[${codeName}] Claude re-login in progress, deferring the auth-tuple restart to the next cycle` + (restartNoticeLanded || noticeAlreadyDelivered ? " (restart notice already delivered, not re-sent)" : "")
+      );
+    } else {
+      restartNoticeDeliveredFor.delete(codeName);
+      stopPersistentSessionAndForgetMcpBaseline(codeName, "auth-tuple-change", void 0, void 0, {
+        reason: authTupleDiff.summary,
+        detail: {
+          auth_tuple: {
+            changed: authTupleDiff.changed,
+            unchanged: authTupleDiff.unchanged,
+            components: authTupleDiff.components
+          }
+        }
+      });
+      agentState.persistentSessionAgents.delete(codeName);
+      restartTrigger = "auth-tuple";
+    }
   }
   const staleForToday = isStaleForToday(codeName, /* @__PURE__ */ new Date(), agentTimezone);
   if (!staleForToday) pendingDayRolloverReset.delete(codeName);
@@ -23030,7 +23207,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
       try {
         const freshId = rotateSessionForWedge(codeName);
         consecutiveWedgeCycles.delete(codeName);
-        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-YLIBVLAR.js");
+        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-LVRBC2AA.js");
         const { parked, deadLettered } = parkForRestart(codeName, /* @__PURE__ */ new Date());
         const parkNote = parked > 0 ? `, ${parked} inbound parked` : "";
         const deadNote = deadLettered > 0 ? `, ${deadLettered} undeliverable dead-lettered` : "";
@@ -23073,7 +23250,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-MFHKSBD5.js");
+        const { collectDiagnostics } = await import("../persistent-session-YKRO5RLK.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -23124,7 +23301,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-MFHKSBD5.js");
+      const { collectDiagnostics } = await import("../persistent-session-YKRO5RLK.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -23771,6 +23948,47 @@ var boardTokenCache = new BoardTokenCache();
 var notifyBoardCache = /* @__PURE__ */ new Map();
 var notifiedWaitingHumanIds = /* @__PURE__ */ new Map();
 var spawnedPairIds = /* @__PURE__ */ new Set();
+var pairableAgentsSnapshot = [];
+var lastPairPendingIds = [];
+var pairFirstSeenMs = /* @__PURE__ */ new Map();
+function claudePairLoopArmed() {
+  return pairLoopArmed({
+    spawnedPairIds,
+    pendingPairIds: lastPairPendingIds,
+    firstSeenMs: pairFirstSeenMs,
+    nowMs: Date.now()
+  });
+}
+var pairRetryBackoff = new PairRetryBackoff();
+var restartNoticeDeliveredFor = /* @__PURE__ */ new Map();
+var claudeUpdaterInFlight = false;
+async function runClaudePairTick() {
+  if (pairableAgentsSnapshot.length === 0 && spawnedPairIds.size === 0) lastPairPendingIds = [];
+  if (claudeUpdaterInFlight) return;
+  await processClaudePairSessions(pairableAgentsSnapshot);
+  pairRetryBackoff.prune([...spawnedPairIds, ...lastPairPendingIds]);
+}
+async function _claudePairTickForTests(agents) {
+  const prevRunning = running;
+  running = true;
+  claudePairLoop.start();
+  pairableAgentsSnapshot = [...agents];
+  try {
+    await runClaudePairTick();
+  } finally {
+    void claudePairLoop.stop();
+    running = prevRunning;
+  }
+}
+function claudePairingInProgress() {
+  return claudePairLoopArmed();
+}
+var claudePairLoop = new ClaudePairLoop({
+  tick: runClaudePairTick,
+  isArmed: claudePairLoopArmed,
+  canRun: () => running && !!config && !restartAfterUpgrade,
+  log
+});
 async function processClaudePairSessions(agents) {
   if (agents.length === 0 && spawnedPairIds.size === 0) return;
   const agentIds = agents.map((a) => a.agentId);
@@ -23779,6 +23997,7 @@ async function processClaudePairSessions(agents) {
     agent_ids: agentIds,
     spawned_pair_ids: Array.from(spawnedPairIds)
   });
+  lastPairPendingIds = (pendingResp.pending ?? []).map((p) => p.pair_id);
   const {
     startClaudePair,
     submitClaudePairCode,
@@ -23796,8 +24015,10 @@ async function processClaudePairSessions(agents) {
     // ENG-10862: the pre-submit mtime baseline. Taken here because finalize
     // 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-VQJGKE4W.js");
+    snapshotPairConfig,
+    // ENG-11659: result -> report body + the manager.log line that records it.
+    planPairStartReport
+  } = await import("../claude-pair-runtime-7QPXNON3.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));
@@ -23815,7 +24036,10 @@ async function processClaudePairSessions(agents) {
     "timeout"
   ]);
   async function reportAndCleanup(pairId, body) {
-    await api.post("/host/claude-pair/result", { pair_id: pairId, ...body });
+    const resp = await api.post("/host/claude-pair/result", {
+      pair_id: pairId,
+      ...body
+    });
     if (typeof body.status === "string" && TERMINAL.has(body.status)) {
       const isOnboardingFailure = typeof body.error_code === "string" && body.error_code.startsWith("onboarding_");
       if (body.status === "success" || isOnboardingFailure) {
@@ -23826,8 +24050,12 @@ async function processClaudePairSessions(agents) {
         spawnedPairIds.delete(pairId);
       }
     }
+    return resp?.no_op !== true;
   }
   for (const session of pendingResp.pending) {
+    if (!running || !claudePairLoop.accepting) break;
+    if (pairRetryBackoff.shouldSkip(session.pair_id, Date.now())) continue;
+    let dispatchFailed = false;
     const codeName = codeNameByAgentId.get(session.agent_id) ?? "<unassigned>";
     const pairSession = pairTmuxSession(session.pair_id);
     try {
@@ -23847,26 +24075,13 @@ async function processClaudePairSessions(agents) {
         spawnedPairIds.add(session.pair_id);
         log(`[claude-pair] dispatching /login (pair ${session.pair_id.slice(0, 8)})`);
         const result = await startClaudePair({ session: pairSession });
-        if (result.kind === "url") {
-          await api.post("/host/claude-pair/result", {
-            pair_id: session.pair_id,
-            status: "awaiting_code",
-            url: result.url
-          });
-        } else if (result.kind === "timeout") {
-          await reportAndCleanup(session.pair_id, {
-            status: "timeout",
-            error_code: "url_prompt_not_seen",
-            error_message: "Claude Code did not print the URL prompt within the deadline"
-          });
-        } else {
-          const errKind = result.error.kind;
-          const errMessage2 = "message" in result.error ? result.error.message : void 0;
-          await reportAndCleanup(session.pair_id, {
-            status: errKind === "no-session" ? "session_missing" : "failure",
-            error_code: errKind,
-            error_message: errMessage2
-          });
+        const report = planPairStartReport(session.pair_id, result);
+        log(report.logLine);
+        const accepted = await reportAndCleanup(session.pair_id, report.body);
+        if (!accepted) {
+          log(
+            `[claude-pair] result for pair ${session.pair_id.slice(0, 8)} was a server no_op: the row was already terminal (e.g. cancelled from the console) when it landed`
+          );
         }
       } else if (session.status === "code_submitted" && session.code) {
         log(`[claude-pair] submitting code (pair ${session.pair_id.slice(0, 8)})`);
@@ -23937,7 +24152,13 @@ async function processClaudePairSessions(agents) {
         }
       }
     } catch (err) {
-      log(`[claude-pair] dispatch failed for pair ${session.pair_id.slice(0, 8)}: ${err.message}`);
+      dispatchFailed = true;
+      const failures = pairRetryBackoff.recordFailure(session.pair_id, Date.now());
+      log(
+        `[claude-pair] dispatch failed for pair ${session.pair_id.slice(0, 8)} (${failures} in a row, retrying in ${Math.round(nextPairLoopDelayMs(true, failures) / 1e3)}s): ${err.message}`
+      );
+    } finally {
+      if (!dispatchFailed) pairRetryBackoff.recordSuccess(session.pair_id);
     }
   }
 }
@@ -24624,6 +24845,7 @@ function startPolling() {
     void postLivenessHeartbeat();
   }, LIVENESS_HEARTBEAT_INTERVAL_MS);
   livenessTimer.unref();
+  claudePairLoop.start();
   startPaneOccupancySampler(() => agentState.persistentSessionAgents);
   startPidPressureSampler(() => agentState.persistentSessionAgents);
   startRuntimeVersionSampler(() => agentState.persistentSessionAgents);
@@ -24790,6 +25012,7 @@ async function stopPolling(opts = {}) {
     clearInterval(livenessTimer);
     livenessTimer = null;
   }
+  const pairLoopDrained = claudePairLoop.stop();
   stopPaneOccupancySampler();
   stopPidPressureSampler();
   stopRuntimeVersionSampler();
@@ -24836,6 +25059,7 @@ async function stopPolling(opts = {}) {
     closeSessionRunForCode(codeName, "completed", "manager shutdown");
   }
   const drainReleaseSnapshot = snapshotDrainReleaseTargets();
+  await Promise.race([pairLoopDrained, new Promise((r) => setTimeout(r, 3e3).unref())]);
   log("Killing tmux sessions...");
   try {
     await killAllAgtTmuxSessions();
@@ -25205,6 +25429,7 @@ export {
   REALTIME_REBIND_STUCK_AFTER_MS,
   SELF_UPDATE_LATCH_MAX_HOLD_MS,
   UntrustworthyToolkitResponseError,
+  _claudePairTickForTests,
   applyMemoryTombstones,
   applyRestartAcks,
   cancelKanbanNoticeOnDrain,
@@ -25213,6 +25438,8 @@ export {
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   claudeManagedSettingsPath,
+  claudePairLoopArmed,
+  claudePairingInProgress,
   coverageOf,
   createManagedPruneLedger,
   createManagedToolkitReader,