@integrity-labs/agt-cli 0.28.30 → 0.28.32

package/dist/bin/agt.js

@@ -33,7 +33,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-62PUHAXF.js";
+} from "../chunk-KJVDXL3L.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.30" : "dev";
+var cliVersion = true ? "0.28.32" : "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.30" : "dev";
+var cliVersion2 = true ? "0.28.32" : "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-62PUHAXF.js → chunk-KJVDXL3L.js}

@@ -7266,7 +7266,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.30" : "dev";
+var agtCliVersion = true ? "0.28.32" : "dev";
 var cachedExchange = null;
 var exchangeInFlight = null;
 function invalidateExchange() {
@@ -8317,4 +8317,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-62PUHAXF.js.map
+//# sourceMappingURL=chunk-KJVDXL3L.js.map

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-62PUHAXF.js";
+} from "../chunk-KJVDXL3L.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -1303,6 +1303,64 @@ async function runConnectivityProbes(integrations, options = {}) {
   return { reports, due: due.length, probed: batch.length, skipped };
 }
 
+// src/lib/dependency-recovery-ledger.ts
+function ledgerKey(kind, label) {
+  return `${kind}:${label}`;
+}
+var DependencyRecoveryLedger = class {
+  /** code_name → (`${kind}:${label}` → entry). */
+  byAgent = /* @__PURE__ */ new Map();
+  /**
+   * Fold one connectivity-probe round's verdicts into the ledger. `down`
+   * records (or re-arms) the dependency; `ok` marks an already-recorded one
+   * recovered; anything else is left untouched (non-escalating, so it neither
+   * opens nor closes an incident).
+   */
+  record(codeName, verdicts) {
+    for (const v of verdicts) {
+      if (v.status === "down") {
+        const entries = this.entriesFor(codeName);
+        const key = ledgerKey(v.kind, v.label);
+        const existing = entries.get(key);
+        if (existing) existing.recovered = false;
+        else entries.set(key, { kind: v.kind, label: v.label, recovered: false });
+      } else if (v.status === "ok") {
+        const entry = this.byAgent.get(codeName)?.get(ledgerKey(v.kind, v.label));
+        if (entry) entry.recovered = true;
+      }
+    }
+  }
+  /**
+   * The dependencies that went down and have since read `ok` again — the
+   * close-the-loop set for this agent's auto-resume. Read-only; the caller
+   * {@link clear}s the agent once the resume that consumes this succeeds.
+   */
+  collectRecovered(codeName) {
+    const entries = this.byAgent.get(codeName);
+    if (!entries) return [];
+    const out = [];
+    for (const e of entries.values()) {
+      if (e.recovered) out.push({ kind: e.kind, label: e.label });
+    }
+    return out;
+  }
+  /**
+   * Drop an agent's ledger — call when its trip clears so the next trip diffs
+   * from a clean slate (and unrecovered/deleted deps don't linger forever).
+   */
+  clear(codeName) {
+    this.byAgent.delete(codeName);
+  }
+  entriesFor(codeName) {
+    let entries = this.byAgent.get(codeName);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      this.byAgent.set(codeName, entries);
+    }
+    return entries;
+  }
+};
+
 // src/lib/cli-probe.ts
 import { execFile } from "child_process";
 var DEFAULT_TIMEOUT_MS = 8e3;
@@ -5430,6 +5488,9 @@ var autoResumeInFlight = /* @__PURE__ */ new Set();
 var AUTO_RESUME_SELF_WINDOW_MS = 12e4;
 var autoResumeLoggedSkips = /* @__PURE__ */ new Map();
 var autoResumeStandDowns = /* @__PURE__ */ new Set();
+var dependencyRecoveryLedger = new DependencyRecoveryLedger();
+var unstableLatchUnreported = /* @__PURE__ */ new Set();
+var unstableLatchReportInFlight = /* @__PURE__ */ new Set();
 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) {
@@ -5473,6 +5534,7 @@ function maybeAutoResume(agent) {
       autoResumeMarkers.set(codeName, { trippedAt, autoResumedAt: Date.now() });
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
+      dependencyRecoveryLedger.clear(codeName);
       state6 = {
         ...state6,
         circuitBreakerTrips: restartBreaker.serialize(),
@@ -5496,13 +5558,34 @@ function logResumeReconcileHoldOnce(codeName, trippedAt, reason, detail) {
     log(`[resume-reconciler] agent=${codeName} decision=hold reason=${reason}${detail ? ` (${detail})` : ""} (ENG-6383)`);
   }
 }
+function reportUnstableLatch(agent, trippedAt, standDownKey) {
+  if (unstableLatchReportInFlight.has(standDownKey)) return;
+  unstableLatchReportInFlight.add(standDownKey);
+  void api.post("/host/circuit-breaker/unstable-latch", {
+    agent_id: agent.agent_id,
+    tripped_at: new Date(trippedAt).toISOString()
+  }).then(() => {
+    unstableLatchUnreported.delete(standDownKey);
+  }).catch((err) => {
+    log(
+      `[resume-reconciler] agent=${agent.code_name} unstable-latch report failed (will retry next poll): ${err.message} (ENG-6392)`
+    );
+  }).finally(() => {
+    unstableLatchReportInFlight.delete(standDownKey);
+  });
+}
 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;
+  if (autoResumeStandDowns.has(standDownKey)) {
+    if (unstableLatchUnreported.has(standDownKey)) {
+      reportUnstableLatch(agent, trip.trippedAt, standDownKey);
+    }
+    return;
+  }
   autoResumeInFlight.add(codeName);
   try {
     const config2 = { ...readResumeReconcilerConfig(), enabled: hostFlagStore().getBoolean("resume-reconciler") };
@@ -5545,19 +5628,27 @@ async function maybeResumeReconcile(agent) {
           `[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)`
         );
       }
+      unstableLatchUnreported.add(standDownKey);
+      reportUnstableLatch(agent, trippedAt, standDownKey);
       return;
     }
     log(
       `[resume-reconciler] agent=${codeName} decision=resume healthyCycles=${decision.healthyCycles} trippedAt=${new Date(trippedAt).toISOString()} (ENG-6383)`
     );
+    const recoveredDependencies = dependencyRecoveryLedger.collectRecovered(codeName);
     const res = await api.post(
       "/host/circuit-breaker/auto-resume",
-      { agent_id: agent.agent_id, tripped_at: new Date(trippedAt).toISOString() }
+      {
+        agent_id: agent.agent_id,
+        tripped_at: new Date(trippedAt).toISOString(),
+        ...recoveredDependencies.length > 0 ? { recovered_dependencies: recoveredDependencies } : {}
+      }
     );
     if (res.resumed) {
       autoResumeMarkers.set(codeName, { trippedAt, autoResumedAt: Date.now() });
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
+      dependencyRecoveryLedger.clear(codeName);
       state6 = {
         ...state6,
         circuitBreakerTrips: restartBreaker.serialize(),
@@ -5881,6 +5972,14 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
       agent_id: agent.agent_id,
       results: result.reports
     });
+    const labelById = new Map(integrations.map((i) => [i.id, i.definition_id]));
+    dependencyRecoveryLedger.record(
+      agent.code_name,
+      result.reports.flatMap((r) => {
+        const label = labelById.get(r.integration_id);
+        return label ? [{ kind: "integration", label, status: r.status }] : [];
+      })
+    );
     log(
       `Connectivity probe for '${agent.code_name}': probed=${result.probed} reported=${result.reports.length} due=${result.due}`
     );
@@ -6072,7 +6171,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.30" : "dev";
+var agtCliVersion = true ? "0.28.32" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();