@integrity-labs/agt-cli 0.28.1149 → 0.28.1150

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-LMJH26IW.js";
+} from "../chunk-HZFXWUA2.js";
 import {
   getProjectDir,
   isSessionResumeDisabled,
@@ -5512,7 +5512,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync11, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.1149" : "dev";
+var cliVersion = true ? "0.28.1150" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6772,7 +6772,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.1149" : "dev";
+var cliVersion2 = true ? "0.28.1150" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-LMJH26IW.js → chunk-HZFXWUA2.js}

@@ -8078,7 +8078,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.1149" : "dev";
+var agtCliVersion = true ? "0.28.1150" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -13235,4 +13235,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-LMJH26IW.js.map
+//# sourceMappingURL=chunk-HZFXWUA2.js.map

package/dist/lib/manager-worker.js

@@ -77,7 +77,7 @@ import {
   setConfigHash,
   shellGuard,
   tripClass
-} from "../chunk-LMJH26IW.js";
+} from "../chunk-HZFXWUA2.js";
 import {
   CLAUDE_CODE_SECURITY_FLOOR,
   compareVersions
@@ -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) {
@@ -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.1149" : "dev";
+var agtCliVersion = true ? "0.28.1150" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -17767,7 +17917,12 @@ async function pollCycleInner() {
       try {
         const desiredClaudeCodeVersion = hbResp?.desired_claude_code_version?.trim();
         const { maybeUpdateClaudeCode, shouldRunClaudeCodeUpdater } = await import("../claude-code-updater-JXL4CM2V.js");
-        if (desiredClaudeCodeVersion && shouldRunClaudeCodeUpdater({
+        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);
@@ -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);
@@ -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,
@@ -23834,6 +24053,9 @@ async function processClaudePairSessions(agents) {
     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 {
@@ -23930,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);
     }
   }
 }
@@ -24617,6 +24845,7 @@ function startPolling() {
     void postLivenessHeartbeat();
   }, LIVENESS_HEARTBEAT_INTERVAL_MS);
   livenessTimer.unref();
+  claudePairLoop.start();
   startPaneOccupancySampler(() => agentState.persistentSessionAgents);
   startPidPressureSampler(() => agentState.persistentSessionAgents);
   startRuntimeVersionSampler(() => agentState.persistentSessionAgents);
@@ -24783,6 +25012,7 @@ async function stopPolling(opts = {}) {
     clearInterval(livenessTimer);
     livenessTimer = null;
   }
+  const pairLoopDrained = claudePairLoop.stop();
   stopPaneOccupancySampler();
   stopPidPressureSampler();
   stopRuntimeVersionSampler();
@@ -24829,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();
@@ -25198,6 +25429,7 @@ export {
   REALTIME_REBIND_STUCK_AFTER_MS,
   SELF_UPDATE_LATCH_MAX_HOLD_MS,
   UntrustworthyToolkitResponseError,
+  _claudePairTickForTests,
   applyMemoryTombstones,
   applyRestartAcks,
   cancelKanbanNoticeOnDrain,
@@ -25206,6 +25438,8 @@ export {
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   claudeManagedSettingsPath,
+  claudePairLoopArmed,
+  claudePairingInProgress,
   coverageOf,
   createManagedPruneLedger,
   createManagedToolkitReader,