@integrity-labs/agt-cli 0.27.107 → 0.27.108

package/dist/bin/agt.js

@@ -28,7 +28,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-KBN7SNAV.js";
+} from "../chunk-N4YEE4O7.js";
 import {
   CHANNEL_REGISTRY,
   DEPLOYMENT_TEMPLATES,
@@ -4934,7 +4934,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.27.107" : "dev";
+var cliVersion = true ? "0.27.108" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5857,7 +5857,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.27.107" : "dev";
+var cliVersion2 = true ? "0.27.108" : "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-KBN7SNAV.js → chunk-N4YEE4O7.js}

@@ -7586,4 +7586,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-KBN7SNAV.js.map
+//# sourceMappingURL=chunk-N4YEE4O7.js.map

package/dist/lib/manager-worker.js

@@ -17,7 +17,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-KBN7SNAV.js";
+} from "../chunk-N4YEE4O7.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -968,6 +968,42 @@ function formatStatusMessage(events, windowMs) {
   return `Circuit breaker tripped: ${events.length} restarts in ${windowLabel} (${breakdown}); most recent=${last.reason} at ${new Date(last.at).toISOString()}`;
 }
 
+// src/lib/auto-resume.ts
+var DEFAULT_QUIET_MS = 18e5;
+var DEFAULT_BACKOFF_RESET_MS = 864e5;
+function readAutoResumeConfig(env = process.env) {
+  const raw = (env["AGT_AUTO_RESUME_ENABLED"] ?? "").trim().toLowerCase();
+  return {
+    enabled: raw === "1" || raw === "true" || raw === "yes" || raw === "on",
+    quietMs: readEnvNumber("AGT_AUTO_RESUME_QUIET_MS", DEFAULT_QUIET_MS),
+    backoffResetMs: readEnvNumber("AGT_AUTO_RESUME_BACKOFF_RESET_MS", DEFAULT_BACKOFF_RESET_MS)
+  };
+}
+function decideAutoResume(opts) {
+  const { trip, marker, config: config2, now } = opts;
+  if (!config2.enabled) return { action: "skip", reason: "disabled" };
+  if (!trip) return { action: "skip", reason: "no-trip" };
+  if (marker && now - marker.autoResumedAt < config2.backoffResetMs) {
+    return { action: "skip", reason: "already-auto-resumed" };
+  }
+  const lastEventAt = trip.eventsAtTrip.length > 0 ? Math.max(trip.trippedAt, ...trip.eventsAtTrip.map((e) => e.at)) : trip.trippedAt;
+  const quietFor = now - lastEventAt;
+  if (quietFor < config2.quietMs) {
+    return { action: "skip", reason: "not-quiet-yet", remainingMs: config2.quietMs - quietFor };
+  }
+  return { action: "resume", quietMs: quietFor };
+}
+function hydrateAutoResumeMarkers(saved) {
+  const map = /* @__PURE__ */ new Map();
+  if (!saved) return map;
+  for (const [codeName, rec] of Object.entries(saved)) {
+    if (rec && typeof rec.trippedAt === "number" && typeof rec.autoResumedAt === "number") {
+      map.set(codeName, rec);
+    }
+  }
+  return map;
+}
+
 // src/lib/model-change-respawn.ts
 function shouldRespawnForModelChange(input) {
   const { previousModel, primaryModel, framework, sessionHealthy } = input;
@@ -3730,6 +3766,64 @@ function maybeReportCurrentTrip(codeName) {
     log(`[circuit-breaker] Failed to report trip for '${codeName}' to API: ${err.message}`);
   });
 }
+var autoResumeMarkers = /* @__PURE__ */ new Map();
+var autoResumeInFlight = /* @__PURE__ */ new Set();
+var AUTO_RESUME_SELF_WINDOW_MS = 12e4;
+var autoResumeLoggedSkips = /* @__PURE__ */ new Map();
+var autoResumeStandDowns = /* @__PURE__ */ new Set();
+function maybeAutoResume(agent) {
+  const codeName = agent.code_name;
+  if (autoResumeInFlight.has(codeName)) return;
+  const trip = restartBreaker.getTrip(codeName);
+  if (trip && autoResumeStandDowns.has(`${codeName}:${trip.trippedAt}`)) return;
+  const decision = decideAutoResume({
+    trip,
+    marker: autoResumeMarkers.get(codeName),
+    config: readAutoResumeConfig(),
+    now: Date.now()
+  });
+  if (decision.action === "skip") {
+    if ((decision.reason === "already-auto-resumed" || decision.reason === "not-quiet-yet") && trip) {
+      const key = `${codeName}:${trip.trippedAt}`;
+      if (autoResumeLoggedSkips.get(key) !== decision.reason) {
+        autoResumeLoggedSkips.set(key, decision.reason);
+        const detail = decision.reason === "not-quiet-yet" ? ` (~${Math.ceil((decision.remainingMs ?? 0) / 6e4)}min remaining)` : " \u2014 credit spent for this cycle; operator resume re-arms it";
+        log(`[auto-resume] agent=${codeName} decision=skip reason=${decision.reason}${detail} (ENG-6088)`);
+      }
+    }
+    return;
+  }
+  const trippedAt = trip.trippedAt;
+  log(
+    `[auto-resume] agent=${codeName} decision=resume quiet=${Math.round(decision.quietMs / 6e4)}min trippedAt=${new Date(trippedAt).toISOString()} (ENG-6088)`
+  );
+  autoResumeInFlight.add(codeName);
+  api.post("/host/circuit-breaker/auto-resume", {
+    agent_id: agent.agent_id,
+    quiet_ms: decision.quietMs,
+    tripped_at: new Date(trippedAt).toISOString()
+  }).then((res) => {
+    autoResumeInFlight.delete(codeName);
+    if (res.resumed) {
+      autoResumeMarkers.set(codeName, { trippedAt, autoResumedAt: Date.now() });
+      restartBreaker.clear(codeName);
+      reportedTrips.delete(codeName);
+      state5 = {
+        ...state5,
+        circuitBreakerTrips: restartBreaker.serialize(),
+        circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
+      };
+      send({ type: "state-update", state: state5 });
+      log(`[auto-resume] agent=${codeName} resumed \u2014 re-trip within backoff window will stay paused (ENG-6088)`);
+    } else {
+      autoResumeStandDowns.add(`${codeName}:${trippedAt}`);
+      log(`[auto-resume] agent=${codeName} not applied (reason=${res.reason ?? "unknown"}) \u2014 standing down for this trip (ENG-6088)`);
+    }
+  }).catch((err) => {
+    autoResumeInFlight.delete(codeName);
+    log(`[auto-resume] agent=${codeName} POST failed (will retry next poll): ${err.message}`);
+  });
+}
 function scheduleSessionRestart(codeName, delayMs, reason, breakerReason = "hot-reload-mcp") {
   const existing = pendingSessionRestarts.get(codeName);
   if (existing) {
@@ -4039,7 +4133,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.107" : "dev";
+var agtCliVersion = true ? "0.27.108" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -5615,7 +5709,9 @@ async function pollCycle() {
       // ENG-5441: serialise trip state on every poll so manager restarts
       // never silently clear a tripped breaker. Cheap — only tripped
       // entries are stored, and the typical state is zero entries.
-      circuitBreakerTrips: restartBreaker.serialize()
+      circuitBreakerTrips: restartBreaker.serialize(),
+      // ENG-6088: spent auto-resume credits survive manager restarts too.
+      circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
     };
     if (consecutivePollFailures > 0) {
       log(`[poll-backoff] recovered after ${consecutivePollFailures} failure(s), resuming normal interval`);
@@ -5690,6 +5786,9 @@ async function processAgent(agent, agentStates) {
       log(`Killed tmux session for paused agent '${agent.code_name}'`);
     } catch {
     }
+    if (agent.status === "paused") {
+      maybeAutoResume(agent);
+    }
     agentStates.push({
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -5781,6 +5880,18 @@ async function processAgent(agent, agentStates) {
       reportedTrips.delete(agent.code_name);
       log(`[circuit-breaker] Cleared trip for '${agent.code_name}' on operator resume (paused \u2192 active)`);
     }
+    if (previousStatus === "paused" && agent.status === "active") {
+      const marker = autoResumeMarkers.get(agent.code_name);
+      const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
+      if (!isSelfResume && autoResumeMarkers.delete(agent.code_name)) {
+        state5 = {
+          ...state5,
+          circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
+        };
+        send({ type: "state-update", state: state5 });
+        log(`[auto-resume] Cleared auto-resume marker for '${agent.code_name}' on operator resume \u2014 credit re-armed (ENG-6088)`);
+      }
+    }
     let channelCacheMutated = false;
     for (const key of agentState.knownChannelConfigHashes.keys()) {
       if (key.startsWith(`${agent.agent_id}:`)) {
@@ -10305,6 +10416,11 @@ function startManager(opts) {
         const n = Object.keys(parsed.circuitBreakerTrips).length;
         if (n > 0) log(`[startup] rehydrated ${n} circuit-breaker trip(s) \u2014 agents will remain paused until manually resumed`);
       }
+      if (parsed.circuitBreakerAutoResumes && typeof parsed.circuitBreakerAutoResumes === "object") {
+        autoResumeMarkers = hydrateAutoResumeMarkers(parsed.circuitBreakerAutoResumes);
+        const n = autoResumeMarkers.size;
+        if (n > 0) log(`[startup] rehydrated ${n} auto-resume marker(s) (ENG-6088)`);
+      }
     }
   } catch (err) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);