@integrity-labs/agt-cli 0.28.351 → 0.28.353

package/dist/{claude-pair-runtime-NUGUTMMT.js → claude-pair-runtime-KO2HWC7E.js}

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

package/dist/lib/manager-worker.js

@@ -45,8 +45,9 @@ import {
   requireHost,
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
-  setConfigHash
-} from "../chunk-F2TH5XVJ.js";
+  setConfigHash,
+  toOpencodeModel
+} from "../chunk-5MZMXKVD.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -137,7 +138,7 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-OEJ35WXL.js";
+} from "../chunk-ZALWFOHO.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
@@ -806,6 +807,19 @@ function countByClass(events) {
   }
   return { crash, provisioning, "credential-rotation": credentialRotation };
 }
+function maxProvisioningBucket(events) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (!isProvisioningReloadReason(e.reason)) continue;
+    const key = e.integrationKey ?? "";
+    buckets.set(key, (buckets.get(key) ?? 0) + 1);
+  }
+  let best = { count: 0, key: "" };
+  for (const [key, count] of buckets) {
+    if (count > best.count) best = { count, key };
+  }
+  return best;
+}
 var DEFAULT_MAX = 2;
 var DEFAULT_WINDOW_MS = 6e5;
 var DEFAULT_PROVISIONING_MAX = 5;
@@ -862,20 +876,25 @@ var RestartBreaker = class {
    * without double-counting events. Callers may still record the reason
    * via the decision-log for forensics.
    */
-  record(codeName, reason) {
+  record(codeName, reason, integrationKey) {
     const existing = this.trips.get(codeName);
     if (existing) {
+      const bucket = maxProvisioningBucket(existing.eventsAtTrip);
       return {
         tripped: false,
         trip: existing,
         windowCount: existing.eventsAtTrip.length,
-        classCounts: countByClass(existing.eventsAtTrip)
+        classCounts: countByClass(existing.eventsAtTrip),
+        maxProvisioningBucket: bucket.count,
+        maxProvisioningBucketKey: bucket.key
       };
     }
     const at = this.now();
     const retentionCutoff = at - this.retentionMs;
     const prior = (this.events.get(codeName) ?? []).filter((e) => e.at >= retentionCutoff);
-    prior.push({ reason, at });
+    prior.push(
+      isProvisioningReloadReason(reason) && integrationKey ? { reason, at, integrationKey } : { reason, at }
+    );
     this.events.set(codeName, prior);
     const crashCount = prior.filter(
       (e) => e.at >= at - this.windowMs && restartReasonClass(e.reason) === "crash"
@@ -892,6 +911,7 @@ var RestartBreaker = class {
       provisioning: provEvents.length,
       "credential-rotation": credRotCount
     };
+    const provBucket = maxProvisioningBucket(provEvents);
     let trippedClass;
     let tripEvents;
     let tripWindowMs = this.windowMs;
@@ -901,22 +921,36 @@ var RestartBreaker = class {
         (e) => e.at >= at - this.windowMs && restartReasonClass(e.reason) === "crash"
       );
       tripWindowMs = this.windowMs;
-    } else if (provEvents.length > this.provisioningMax) {
+    } else if (provBucket.count > this.provisioningMax) {
       trippedClass = "provisioning";
-      tripEvents = provEvents;
+      tripEvents = provEvents.filter((e) => (e.integrationKey ?? "") === provBucket.key);
       tripWindowMs = this.provisioningWindowMs;
     }
     if (trippedClass && tripEvents) {
       const trip = {
         trippedAt: at,
         eventsAtTrip: [...tripEvents],
-        statusMessage: formatStatusMessage(tripEvents, tripWindowMs, trippedClass)
+        statusMessage: formatStatusMessage(tripEvents, tripWindowMs, trippedClass, provBucket.key)
       };
       this.trips.set(codeName, trip);
       this.events.delete(codeName);
-      return { tripped: true, trip, windowCount, classCounts, trippedClass };
+      return {
+        tripped: true,
+        trip,
+        windowCount,
+        classCounts,
+        trippedClass,
+        maxProvisioningBucket: provBucket.count,
+        maxProvisioningBucketKey: provBucket.key
+      };
     }
-    return { tripped: false, windowCount, classCounts };
+    return {
+      tripped: false,
+      windowCount,
+      classCounts,
+      maxProvisioningBucket: provBucket.count,
+      maxProvisioningBucketKey: provBucket.key
+    };
   }
   /** Operator-initiated reset: drops the trip + the events log for this agent. */
   clear(codeName) {
@@ -947,14 +981,15 @@ var RestartBreaker = class {
     return (this.events.get(codeName) ?? []).filter((e) => e.at >= cutoff).length;
   }
 };
-function formatStatusMessage(events, windowMs, klass = "crash") {
+function formatStatusMessage(events, windowMs, klass = "crash", integrationKey = "") {
   const last = events[events.length - 1];
   const windowLabel = windowMs < 6e4 ? `${Math.round(windowMs / 1e3)}s` : `${(windowMs / 6e4).toFixed(1).replace(/\.0$/, "")}min`;
   const reasonCounts = /* @__PURE__ */ new Map();
   for (const e of events) reasonCounts.set(e.reason, (reasonCounts.get(e.reason) ?? 0) + 1);
   const breakdown = Array.from(reasonCounts.entries()).map(([r, n]) => `${r}=${n}`).join(", ");
   const classLabel = klass === "provisioning" ? "provisioning-reload " : "";
-  return `Circuit breaker tripped: ${events.length} ${classLabel}restarts in ${windowLabel} (${breakdown}); most recent=${last.reason} at ${new Date(last.at).toISOString()}`;
+  const integrationLabel = klass === "provisioning" && integrationKey ? ` for integration '${integrationKey}'` : "";
+  return `Circuit breaker tripped: ${events.length} ${classLabel}restarts in ${windowLabel}${integrationLabel} (${breakdown}); most recent=${last.reason} at ${new Date(last.at).toISOString()}`;
 }
 
 // src/lib/mcp-flap-dampener.ts
@@ -1250,12 +1285,25 @@ function parseResumeHealthResponse(raw) {
 // src/lib/model-change-respawn.ts
 function shouldRespawnForModelChange(input) {
   const { previousModel, primaryModel, framework, sessionHealthy } = input;
-  if (framework !== "claude-code") return false;
+  if (framework !== "claude-code" && framework !== "opencode") return false;
   if (!sessionHealthy) return false;
   if (!previousModel) return false;
   if (!primaryModel) return false;
   return previousModel !== primaryModel;
 }
+function decideOpencodeModelRestart(input) {
+  const { previousModel, primaryModel, provisionedModel, onDiskModel, sessionHealthy } = input;
+  if (onDiskModel !== provisionedModel) {
+    return { restart: false, recordModel: false };
+  }
+  const restart = shouldRespawnForModelChange({
+    previousModel,
+    primaryModel,
+    framework: "opencode",
+    sessionHealthy
+  });
+  return { restart, recordModel: true };
+}
 
 // src/lib/connectivity-probe-runner.ts
 var DEFAULT_INTERVAL_MS = 60 * 60 * 1e3;
@@ -3755,6 +3803,17 @@ var agentState = {
   knownModels: /* @__PURE__ */ new Map(),
   knownTasksHashes: /* @__PURE__ */ new Map(),
   knownIntegrationHashes: /* @__PURE__ */ new Map(),
+  /**
+   * ENG-7812: the integration MEMBERSHIP (sorted `definition_id`s, credential/
+   * config churn ignored) observed on the previous refresh. Diffed against the
+   * current membership each poll to derive which integration(s) an
+   * `integration-change` / `hot-reload-mcp` restart is attributable to, which the
+   * restart breaker buckets its provisioning trip by (so onboarding many distinct
+   * integrations doesn't auto-pause a healthy new agent). In-memory only: a
+   * manager restart re-seeds it on the first poll (that first delta is treated as
+   * "no attribution", which is safe: it only widens, never narrows, the trip).
+   */
+  knownIntegrationMembership: /* @__PURE__ */ new Map(),
   knownManagedMcpHashes: /* @__PURE__ */ new Map(),
   knownManagedMcpStructure: /* @__PURE__ */ new Map(),
   /**
@@ -3790,6 +3849,16 @@ var agentState = {
   // ---------------------------------------------------------------------------
   agentDisplayNames: /* @__PURE__ */ new Map(),
   codeNameToAgentId: /* @__PURE__ */ new Map(),
+  /**
+   * ENG-7812: the most recent integration-membership delta for this agent, used
+   * to attribute a provisioning-reload restart to the integration that caused it.
+   * Set when a poll observes an integration add/remove (the changed
+   * `definition_id`s, `+`-joined); read by `recordRestartForBreaker` when a
+   * provisioning restart fires shortly after. `at` bounds its freshness to the
+   * breaker's provisioning window so a stale delta can't mis-attribute a much
+   * later reprovision (those fall through to the shared unattributed bucket).
+   */
+  provisioningAttribution: /* @__PURE__ */ new Map(),
   /**
    * Set of code_names with a live persistent session managed by this worker.
    * Borderline ownership: written from pollCycle and the persistent-session
@@ -3827,6 +3896,7 @@ function clearAgentState(agentId, codeName) {
   agentState.knownModels.delete(agentId);
   agentState.knownTasksHashes.delete(agentId);
   agentState.knownIntegrationHashes.delete(agentId);
+  agentState.knownIntegrationMembership.delete(agentId);
   agentState.knownManagedMcpHashes.delete(agentId);
   agentState.knownManagedMcpStructure.delete(agentId);
   agentState.knownSenderPolicyHashes.delete(agentId);
@@ -3835,6 +3905,7 @@ function clearAgentState(agentId, codeName) {
   agentState.knownGlobalSkillIds.delete(agentId);
   agentState.agentDisplayNames.delete(codeName);
   agentState.codeNameToAgentId.delete(codeName);
+  agentState.provisioningAttribution.delete(codeName);
   let channelCacheMutated = false;
   for (const key of agentState.knownChannelConfigHashes.keys()) {
     if (key.startsWith(`${agentId}:`)) {
@@ -5577,6 +5648,15 @@ function opencodeTmuxSession(codeName) {
 function opencodePaneLogPath(codeName) {
   return join20(homedir10(), ".augmented", codeName, "opencode-serve.log");
 }
+function readProvisionedOpencodeModel(agentDir) {
+  try {
+    const raw = readFileSync16(join20(agentDir, "provision", "opencode.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.model === "string" ? parsed.model : null;
+  } catch {
+    return null;
+  }
+}
 function baseUrlFor(port) {
   return `http://127.0.0.1:${port}`;
 }
@@ -5737,6 +5817,21 @@ function getBridge(codeName, port, password) {
   bridges.set(codeName, { port, password, bridge });
   return bridge;
 }
+function stopOpencodeSession(codeName, log2) {
+  const tmuxSession = opencodeTmuxSession(codeName);
+  try {
+    execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
+    log2(`[opencode-session] stopped '${tmuxSession}' for '${codeName}'`);
+  } catch {
+  }
+  bridges.delete(codeName);
+  const session = sessions.get(codeName);
+  if (session) {
+    session.status = "stopped";
+    session.port = null;
+    session.password = null;
+  }
+}
 function stripUndefined(env) {
   const out = {};
   for (const [k, v] of Object.entries(env)) if (v !== void 0) out[k] = v;
@@ -8434,6 +8529,10 @@ var pendingRestartVerifications = /* @__PURE__ */ new Map();
 var restartBreaker = new RestartBreaker();
 var reportedTrips = /* @__PURE__ */ new Map();
 var RESTART_BREAKER_PROVISIONING_MAX = readEnvNumber("AGT_RESTART_BREAKER_PROVISIONING_MAX", 5);
+var RESTART_BREAKER_PROVISIONING_WINDOW_MS = readEnvNumber(
+  "AGT_RESTART_BREAKER_PROVISIONING_WINDOW_MS",
+  18e5
+);
 var mcpFlapDampener = new McpFlapDampener();
 var FLAP_BREAKER_COOLDOWN_MS = readEnvNumber2(
   "AGT_MCP_FLAP_BREAKER_COOLDOWN_MS",
@@ -8472,11 +8571,19 @@ function recordRestartForBreaker(codeName, reason) {
     );
     return;
   }
-  const result = restartBreaker.record(codeName, reason);
+  let integrationKey;
+  if (isProvisioningReloadReason(reason)) {
+    const attribution = agentState.provisioningAttribution.get(codeName);
+    if (attribution && Date.now() - attribution.at <= RESTART_BREAKER_PROVISIONING_WINDOW_MS) {
+      integrationKey = attribution.key;
+    }
+  }
+  const result = restartBreaker.record(codeName, reason, integrationKey);
   if (!result.tripped || !result.trip) {
-    if (isProvisioningReloadReason(reason) && result.classCounts.provisioning >= RESTART_BREAKER_PROVISIONING_MAX) {
+    if (isProvisioningReloadReason(reason) && result.maxProvisioningBucket >= RESTART_BREAKER_PROVISIONING_MAX) {
+      const culprit = result.maxProvisioningBucketKey ? ` [${result.maxProvisioningBucketKey}]` : "";
       log(
-        `[restart-breaker] agent=${codeName} provisioning-reload churn at the trip bar: ${result.classCounts.provisioning} provisioning restarts in window (reason=${reason}); one more will auto-pause the agent \u2014 a freshly-added integration is likely churning (ENG-7560)`
+        `[restart-breaker] agent=${codeName} provisioning-reload churn at the trip bar: ${result.maxProvisioningBucket} restarts for one integration${culprit} in window (reason=${reason}); one more will auto-pause the agent; that integration is likely churning (ENG-7560, ENG-7812)`
       );
     }
     return;
@@ -9304,7 +9411,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.351" : "dev";
+var agtCliVersion = true ? "0.28.353" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -10323,7 +10430,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-KFR2GLKC.js");
+      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -10422,7 +10529,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-KFR2GLKC.js");
+      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -10577,7 +10684,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-PFPXYTL2.js");
+      } = await import("../responsiveness-probe-TCTSHDH3.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -10609,7 +10716,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-PFPXYTL2.js");
+        } = await import("../responsiveness-probe-TCTSHDH3.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-HYOOQV4A.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -11584,6 +11691,28 @@ async function processAgent(agent, agentStates) {
       }
     }
     agentState.knownModels.set(agent.agent_id, primaryModel);
+  } else if (primaryModel && frameworkId === "opencode") {
+    const previousModel = agentState.knownModels.get(agent.agent_id);
+    const provisionedModel = toOpencodeModel(primaryModel);
+    const onDiskModel = readProvisionedOpencodeModel(getFramework("opencode").getAgentDir(agent.code_name));
+    const { restart, recordModel } = decideOpencodeModelRestart({
+      previousModel,
+      primaryModel,
+      provisionedModel,
+      onDiskModel,
+      sessionHealthy: isOpencodeSessionHealthy(agent.code_name)
+    });
+    if (restart) {
+      log(
+        `[hot-reload] opencode model changed for '${agent.code_name}': ${previousModel} -> ${primaryModel} - restarting serve`
+      );
+      stopOpencodeSession(agent.code_name, log);
+    } else if (previousModel && previousModel !== primaryModel && onDiskModel !== provisionedModel) {
+      log(
+        `[hot-reload] opencode model change for '${agent.code_name}' deferred: opencode.json shows '${onDiskModel}' not '${provisionedModel}' (provision not yet applied) - retrying next poll`
+      );
+    }
+    if (recordModel) agentState.knownModels.set(agent.agent_id, primaryModel);
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
@@ -12171,6 +12300,25 @@ async function processAgent(agent, agentStates) {
         }
       }
     }
+    const currentIntIds = integrations.map((i) => i.definition_id);
+    const prevIntIds = agentState.knownIntegrationMembership.get(agent.agent_id) ?? [];
+    const prevIntSet = new Set(prevIntIds);
+    const curIntSet = new Set(currentIntIds);
+    const changedIntIds = Array.from(
+      /* @__PURE__ */ new Set([
+        ...currentIntIds.filter((id) => !prevIntSet.has(id)),
+        // added
+        ...prevIntIds.filter((id) => !curIntSet.has(id))
+        // removed
+      ])
+    ).sort();
+    if (changedIntIds.length > 0) {
+      agentState.provisioningAttribution.set(agent.code_name, {
+        key: changedIntIds.join("+"),
+        at: Date.now()
+      });
+    }
+    agentState.knownIntegrationMembership.set(agent.agent_id, currentIntIds);
     if (integrations.length > 0) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
@@ -13723,7 +13871,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-KFR2GLKC.js");
+        const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -13773,7 +13921,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-KFR2GLKC.js");
+      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -14271,7 +14419,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-NUGUTMMT.js");
+  } = await import("../claude-pair-runtime-KO2HWC7E.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));