@integrity-labs/agt-cli 0.28.29 → 0.28.31

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-FIB2OQLF.js";
+} from "../chunk-EJIU6AD6.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,7 @@ 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 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 +5532,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(),
@@ -5550,14 +5610,20 @@ async function maybeResumeReconcile(agent) {
     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 +5947,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 +6146,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.29" : "dev";
+var agtCliVersion = true ? "0.28.31" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();