@integrity-labs/agt-cli 0.28.18 → 0.28.20

package/dist/{chunk-5DIMLYS5.js → chunk-BKO5PJZ7.js}

@@ -1,7 +1,7 @@
 import {
   claudeModelAlias,
   isClaudeFastMode
-} from "./chunk-6UXSC4TR.js";
+} from "./chunk-3HZSMDEW.js";
 import {
   reapOrphanChannelMcps
 } from "./chunk-XWVM4KPK.js";
@@ -1487,4 +1487,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-5DIMLYS5.js.map
+//# sourceMappingURL=chunk-BKO5PJZ7.js.map

package/dist/{chunk-VPMNDODG.js → chunk-U6IPQT2J.js}

@@ -14,7 +14,7 @@ import {
   registerFramework,
   resolveAvatarEnvUrl,
   wrapScheduledTaskPrompt
-} from "./chunk-6UXSC4TR.js";
+} from "./chunk-3HZSMDEW.js";
 
 // ../../packages/core/dist/integrations/registry.js
 var INTEGRATION_REGISTRY = [
@@ -8275,4 +8275,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-VPMNDODG.js.map
+//# sourceMappingURL=chunk-U6IPQT2J.js.map

package/dist/{claude-pair-runtime-CFUSOOVY.js → claude-pair-runtime-LQJ5E4IF.js}

@@ -100,7 +100,7 @@ async function spawnPairSession(session) {
     return { ok: true };
   } catch {
   }
-  const { resolveClaudeBinary } = await import("./persistent-session-RANQKKKC.js");
+  const { resolveClaudeBinary } = await import("./persistent-session-5BEMWOTM.js");
   const claudeBin = resolveClaudeBinary();
   const pairEnv = {
     ...process.env,
@@ -373,4 +373,4 @@ export {
   startClaudePair,
   submitClaudePairCode
 };
-//# sourceMappingURL=claude-pair-runtime-CFUSOOVY.js.map
+//# sourceMappingURL=claude-pair-runtime-LQJ5E4IF.js.map

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-VPMNDODG.js";
+} from "../chunk-U6IPQT2J.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -64,7 +64,7 @@ import {
   takeWatchdogGiveUpCount,
   takeZombieDetection,
   transcriptActivityAgeSeconds
-} from "../chunk-5DIMLYS5.js";
+} from "../chunk-BKO5PJZ7.js";
 import {
   FLAGS_SCHEMA_VERSION,
   KANBAN_CHECK_COMMAND,
@@ -96,7 +96,7 @@ import {
   sumTranscriptUsageInWindow,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "../chunk-6UXSC4TR.js";
+} from "../chunk-3HZSMDEW.js";
 import {
   parsePsRows,
   reapOrphanChannelMcps
@@ -434,6 +434,16 @@ function clearPresenceReaperStateForKeys(codeName, keys) {
     presenceReaperState.delete(stateKey(codeName, key));
   }
 }
+function givenUpMcpServerKeys(codeName) {
+  const prefix = `${codeName}\0`;
+  const out = /* @__PURE__ */ new Set();
+  for (const [key, st] of presenceReaperState) {
+    if (key.startsWith(prefix) && st.attempts >= MAX_PRESENCE_RESTART_ATTEMPTS) {
+      out.add(key.slice(prefix.length));
+    }
+  }
+  return out;
+}
 function findMissingMcpServers(args) {
   const { rows, codeName, mcpJson } = args;
   const servers = mcpJson?.mcpServers ?? {};
@@ -1099,6 +1109,69 @@ function hydrateAutoResumeMarkers(saved) {
   return map;
 }
 
+// src/lib/resume-reconciler.ts
+var DEFAULT_MIN_HEALTHY_CYCLES = 2;
+var DEFAULT_BACKOFF_RESET_MS2 = 864e5;
+function readResumeReconcilerConfig(env = process.env) {
+  const raw = (env["AGT_RESUME_RECONCILER_ENABLED"] ?? "").trim().toLowerCase();
+  const minCycles = readEnvNumber("AGT_RESUME_MIN_HEALTHY_CYCLES", DEFAULT_MIN_HEALTHY_CYCLES);
+  return {
+    enabled: raw === "1" || raw === "true" || raw === "yes" || raw === "on",
+    // A fractional / <1 override is meaningless for a cycle count — floor to an
+    // integer and demand at least 1, so "healthy" always means "observed at
+    // least once". readEnvNumber already rejects NaN / <=0 to the default.
+    minHealthyCycles: Math.max(1, Math.floor(minCycles)),
+    backoffResetMs: readEnvNumber("AGT_AUTO_RESUME_BACKOFF_RESET_MS", DEFAULT_BACKOFF_RESET_MS2)
+  };
+}
+function decideResumeReconcile(opts) {
+  const { trip, marker, health, config: config2, now } = opts;
+  if (!config2.enabled) return { action: "hold", reason: "disabled" };
+  if (!trip) return { action: "hold", reason: "no-trip" };
+  if (marker && now - marker.autoResumedAt < config2.backoffResetMs) {
+    if (trip.trippedAt === marker.trippedAt) {
+      return { action: "hold", reason: "not-healthy-yet" };
+    }
+    return { action: "latch-unstable", trippedAt: trip.trippedAt };
+  }
+  if (!health.dependencyStatusActive) {
+    return { action: "hold", reason: "not-healthy-yet", precondition: "status" };
+  }
+  if (!health.mcpPresent) {
+    return { action: "hold", reason: "not-healthy-yet", precondition: "mcp" };
+  }
+  if (health.connectivityOkCycles < config2.minHealthyCycles) {
+    return {
+      action: "hold",
+      reason: "not-healthy-yet",
+      precondition: "connectivity",
+      cyclesShort: config2.minHealthyCycles - Math.max(0, health.connectivityOkCycles)
+    };
+  }
+  return { action: "resume", healthyCycles: health.connectivityOkCycles };
+}
+
+// src/lib/resume-reconciler-inputs.ts
+function deriveMcpPresent(declaredKeys, givenUpKeys) {
+  if (declaredKeys === null) return false;
+  for (const key of declaredKeys) {
+    if (givenUpKeys.has(key)) return false;
+  }
+  return true;
+}
+function parseResumeHealthResponse(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.dependencyStatusActive !== "boolean") return null;
+  if (typeof r.connectivityOkCycles !== "number" || !Number.isFinite(r.connectivityOkCycles)) {
+    return null;
+  }
+  return {
+    dependencyStatusActive: r.dependencyStatusActive,
+    connectivityOkCycles: r.connectivityOkCycles
+  };
+}
+
 // src/lib/model-change-respawn.ts
 function shouldRespawnForModelChange(input) {
   const { previousModel, primaryModel, framework, sessionHealthy } = input;
@@ -4741,6 +4814,10 @@ var killPausedCodeNames = /* @__PURE__ */ new Set();
 var BACK_ONLINE_GREETING_GUIDANCE = " When you reconnect, if you tell anyone you are back, start that message with a \u{1F44B} wave emoji and do not use a \u{1F7E2} green-light emoji.";
 function maybeAutoResume(agent) {
   const codeName = agent.code_name;
+  if (hostFlagStore().getBoolean("resume-reconciler")) {
+    void maybeResumeReconcile(agent);
+    return;
+  }
   if (autoResumeInFlight.has(codeName)) return;
   const trip = restartBreaker.getTrip(codeName);
   if (trip && autoResumeStandDowns.has(`${codeName}:${trip.trippedAt}`)) return;
@@ -4792,6 +4869,92 @@ function maybeAutoResume(agent) {
     log(`[auto-resume] agent=${codeName} POST failed (will retry next poll): ${err.message}`);
   });
 }
+function logResumeReconcileHoldOnce(codeName, trippedAt, reason, detail) {
+  const key = `${codeName}:${trippedAt}`;
+  if (autoResumeLoggedSkips.get(key) !== reason) {
+    autoResumeLoggedSkips.set(key, reason);
+    log(`[resume-reconciler] agent=${codeName} decision=hold reason=${reason}${detail ? ` (${detail})` : ""} (ENG-6383)`);
+  }
+}
+async function maybeResumeReconcile(agent) {
+  const codeName = agent.code_name;
+  if (autoResumeInFlight.has(codeName)) return;
+  const trip = restartBreaker.getTrip(codeName);
+  if (!trip) return;
+  const standDownKey = `${codeName}:${trip.trippedAt}`;
+  if (autoResumeStandDowns.has(standDownKey)) return;
+  autoResumeInFlight.add(codeName);
+  try {
+    const config2 = { ...readResumeReconcilerConfig(), enabled: hostFlagStore().getBoolean("resume-reconciler") };
+    const trippedAt = trip.trippedAt;
+    let serverHealth = null;
+    try {
+      const raw = await api.get(
+        `/host/circuit-breaker/resume-health?agent_id=${encodeURIComponent(agent.agent_id)}`
+      );
+      serverHealth = parseResumeHealthResponse(raw);
+    } catch (err) {
+      logResumeReconcileHoldOnce(codeName, trippedAt, "health-fetch-failed", err.message.slice(0, 80));
+      return;
+    }
+    if (!serverHealth) {
+      logResumeReconcileHoldOnce(codeName, trippedAt, "health-unparseable");
+      return;
+    }
+    const declaredKeys = projectMcpKeys(codeName, getProjectDir(codeName));
+    const mcpPresent = deriveMcpPresent(declaredKeys, givenUpMcpServerKeys(codeName));
+    const decision = decideResumeReconcile({
+      trip,
+      marker: autoResumeMarkers.get(codeName),
+      health: { ...serverHealth, mcpPresent },
+      config: config2,
+      now: Date.now()
+    });
+    if (decision.action === "hold") {
+      const reason = decision.precondition ? `not-healthy-yet:${decision.precondition}` : decision.reason;
+      const detail = decision.cyclesShort ? `${decision.cyclesShort}-short` : void 0;
+      logResumeReconcileHoldOnce(codeName, trippedAt, reason, detail);
+      return;
+    }
+    if (decision.action === "latch-unstable") {
+      autoResumeStandDowns.add(standDownKey);
+      const key = `${codeName}:${trippedAt}`;
+      if (autoResumeLoggedSkips.get(key) !== "latch-unstable") {
+        autoResumeLoggedSkips.set(key, "latch-unstable");
+        log(
+          `[resume-reconciler] agent=${codeName} decision=latch-unstable \u2014 auto-resumed once then re-tripped within the backoff window; latching to mandatory-manual (NOT resuming; restart counter untouched; agent stays paused with its circuit-breaker alert open) (ENG-6383)`
+        );
+      }
+      return;
+    }
+    log(
+      `[resume-reconciler] agent=${codeName} decision=resume healthyCycles=${decision.healthyCycles} trippedAt=${new Date(trippedAt).toISOString()} (ENG-6383)`
+    );
+    const res = await api.post(
+      "/host/circuit-breaker/auto-resume",
+      { agent_id: agent.agent_id, tripped_at: new Date(trippedAt).toISOString() }
+    );
+    if (res.resumed) {
+      autoResumeMarkers.set(codeName, { trippedAt, autoResumedAt: Date.now() });
+      restartBreaker.clear(codeName);
+      reportedTrips.delete(codeName);
+      state6 = {
+        ...state6,
+        circuitBreakerTrips: restartBreaker.serialize(),
+        circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
+      };
+      send({ type: "state-update", state: state6 });
+      log(`[resume-reconciler] agent=${codeName} resumed \u2014 a re-trip within the backoff window will latch unstable (ENG-6383)`);
+    } else {
+      autoResumeStandDowns.add(standDownKey);
+      log(`[resume-reconciler] agent=${codeName} not applied (reason=${res.reason ?? "unknown"}) \u2014 standing down for this trip (ENG-6383)`);
+    }
+  } catch (err) {
+    log(`[resume-reconciler] agent=${codeName} reconcile failed (will retry next poll): ${err.message}`);
+  } finally {
+    autoResumeInFlight.delete(codeName);
+  }
+}
 function scheduleSessionRestart(codeName, delayMs, reason, breakerReason = "hot-reload-mcp") {
   const existing = pendingSessionRestarts.get(codeName);
   if (existing) {
@@ -5266,7 +5429,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.18" : "dev";
+var agtCliVersion = true ? "0.28.20" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -6375,7 +6538,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-RANQKKKC.js");
+      const { collectDiagnostics } = await import("../persistent-session-5BEMWOTM.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -6469,7 +6632,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-KQP6MY5N.js");
+      } = await import("../responsiveness-probe-JP4HLFYU.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -6501,7 +6664,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-KQP6MY5N.js");
+        } = await import("../responsiveness-probe-JP4HLFYU.js");
         const { getProjectDir: wedgeProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -11092,7 +11255,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-CFUSOOVY.js");
+  } = await import("../claude-pair-runtime-LQJ5E4IF.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));