@integrity-labs/agt-cli 0.28.18 → 0.28.19

package/dist/bin/agt.js

@@ -33,7 +33,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-VPMNDODG.js";
+} from "../chunk-MGE73AKK.js";
 import {
   CHANNEL_REGISTRY,
   DEPLOYMENT_TEMPLATES,
@@ -4773,7 +4773,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.18" : "dev";
+var cliVersion = true ? "0.28.19" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5696,7 +5696,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.18" : "dev";
+var cliVersion2 = true ? "0.28.19" : "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-VPMNDODG.js → chunk-MGE73AKK.js}

@@ -8275,4 +8275,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-VPMNDODG.js.map
+//# sourceMappingURL=chunk-MGE73AKK.js.map

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-VPMNDODG.js";
+} from "../chunk-MGE73AKK.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -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 (readResumeReconcilerConfig().enabled) {
+    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();
+    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.19" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();