@integrity-labs/agt-cli 0.28.352 → 0.28.354

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

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

package/dist/lib/manager-worker.js

@@ -30,6 +30,7 @@ import {
   getHostId,
   givenUpMcpServerKeys,
   liveProxyExtraHeaderVars,
+  parseOpencodeModelRef,
   pinAllowsUrgent,
   provision,
   provisionAutoKanbanProgressHook,
@@ -47,7 +48,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   toOpencodeModel
-} from "../chunk-BERN3B42.js";
+} from "../chunk-4ITNBU3K.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -138,16 +139,16 @@ import {
   takeZombieDetection,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-ZALWFOHO.js";
+} from "../chunk-LDIKBFDR.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash14 } from "crypto";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync13, rmSync as rmSync5, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, existsSync as existsSync13, rmSync as rmSync5, readdirSync as readdirSync5, statSync as statSync4, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join23, dirname as dirname6, delimiter as pathDelimiter } from "path";
+import { join as join23, dirname as dirname7, delimiter as pathDelimiter } from "path";
 import { homedir as homedir12 } from "os";
 import { fileURLToPath } from "url";
 
@@ -807,6 +808,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;
@@ -863,20 +877,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"
@@ -893,6 +912,7 @@ var RestartBreaker = class {
       provisioning: provEvents.length,
       "credential-rotation": credRotCount
     };
+    const provBucket = maxProvisioningBucket(provEvents);
     let trippedClass;
     let tripEvents;
     let tripWindowMs = this.windowMs;
@@ -902,22 +922,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) {
@@ -948,14 +982,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
@@ -3769,6 +3804,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(),
   /**
@@ -3804,6 +3850,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
@@ -3841,6 +3897,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);
@@ -3849,6 +3906,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}:`)) {
@@ -5579,9 +5637,9 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 import { spawn, execSync } from "child_process";
 import { createServer } from "net";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync9 } from "fs";
 import { homedir as homedir10, userInfo } from "os";
-import { join as join20 } from "path";
+import { join as join20, dirname as dirname6 } from "path";
 var OPENCODE_BIN = process.env["AGT_OPENCODE_BIN"]?.trim() || "opencode";
 var sessions = /* @__PURE__ */ new Map();
 var bridges = /* @__PURE__ */ new Map();
@@ -5592,14 +5650,43 @@ function opencodePaneLogPath(codeName) {
   return join20(homedir10(), ".augmented", codeName, "opencode-serve.log");
 }
 function readProvisionedOpencodeModel(agentDir) {
+  return readOpencodeModelString(join20(agentDir, "provision", "opencode.json"));
+}
+function readOpencodeModelString(configPath) {
   try {
-    const raw = readFileSync16(join20(agentDir, "provision", "opencode.json"), "utf-8");
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(readFileSync16(configPath, "utf-8"));
     return typeof parsed.model === "string" ? parsed.model : null;
   } catch {
     return null;
   }
 }
+function readOpencodeModelFromConfigDir(configDir) {
+  return parseOpencodeModelRef(readOpencodeModelString(join20(configDir, "opencode.json")));
+}
+function materializeEnvPlaceholders(raw, env) {
+  return raw.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (whole, name) => {
+    const v = env[name];
+    return typeof v === "string" && v.length > 0 ? v : whole;
+  });
+}
+function deliverOpencodeConfigToXdg(codeName, projectDir, serveEnv, log2) {
+  let raw;
+  try {
+    raw = readFileSync16(join20(projectDir, "opencode.json"), "utf-8");
+  } catch {
+    return null;
+  }
+  const materialized = materializeEnvPlaceholders(raw, serveEnv);
+  const xdgConfigHome = join20(dirname6(projectDir), "opencode-xdg");
+  try {
+    mkdirSync7(join20(xdgConfigHome, "opencode"), { recursive: true });
+    writeFileSync9(join20(xdgConfigHome, "opencode", "opencode.json"), materialized, { mode: 384 });
+    return xdgConfigHome;
+  } catch (err) {
+    log2(`[opencode-session] failed to deliver opencode config to XDG for '${codeName}': ${err.message}`);
+    return null;
+  }
+}
 function baseUrlFor(port) {
   return `http://127.0.0.1:${port}`;
 }
@@ -5638,7 +5725,8 @@ async function startOpencodeSession(config2) {
       status: "crashed",
       port: null,
       password: null,
-      lastFailureTail: "opencode isolation not implemented (ADR-0047)"
+      lastFailureTail: "opencode isolation not implemented (ADR-0047)",
+      model: null
     };
     sessions.set(codeName, blocked);
     return blocked;
@@ -5650,7 +5738,11 @@ async function startOpencodeSession(config2) {
     status: "starting",
     port: null,
     password: null,
-    lastFailureTail: existing?.lastFailureTail ?? null
+    lastFailureTail: existing?.lastFailureTail ?? null,
+    // ENG-7931: parse the resolved model from the provisioned opencode.json
+    // (config.projectDir IS the provision dir the serve reads) so the bridge can
+    // pass it explicitly on session-create + prompt.
+    model: readOpencodeModelFromConfigDir(config2.projectDir)
   };
   sessions.set(codeName, session);
   try {
@@ -5686,6 +5778,8 @@ async function spawnServe(config2, session) {
   };
   if (config2.runId) serveEnv["AGT_RUN_ID"] = config2.runId;
   if (config2.agentTimezone) serveEnv["TZ"] = config2.agentTimezone;
+  const xdgConfigHome = deliverOpencodeConfigToXdg(codeName, projectDir, serveEnv, log2);
+  if (xdgConfigHome) serveEnv["XDG_CONFIG_HOME"] = xdgConfigHome;
   const serveCmd = `${OPENCODE_BIN} serve --hostname 127.0.0.1 --port ${port} --print-logs`;
   log2(`[opencode-session] starting '${tmuxSession}' for '${codeName}' on 127.0.0.1:${port}`);
   const child = spawn(
@@ -5756,7 +5850,11 @@ function getBridge(codeName, port, password) {
   const cached = bridges.get(codeName);
   if (cached && cached.port === port && cached.password === password) return cached.bridge;
   const client2 = new HttpOpencodeClient({ baseUrl: baseUrlFor(port), password });
-  const bridge = new OpencodeInboundBridge({ client: client2 });
+  const model = sessions.get(codeName)?.model ?? null;
+  const bridge = new OpencodeInboundBridge({
+    client: client2,
+    sessionDefaults: model ? { model } : void 0
+  });
   bridges.set(codeName, { port, password, bridge });
   return bridge;
 }
@@ -6915,7 +7013,7 @@ async function fireOpencodeScheduledTask(agent, task) {
 
 // src/lib/opencode-telegram-ingest.ts
 import { createHash as createHash13 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync17, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync17, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync10 } from "fs";
 import { randomUUID } from "crypto";
 import { join as join21 } from "path";
 
@@ -7493,7 +7591,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       try {
         mkdirSync8(dir, { recursive: true, mode: 448 });
-        writeFileSync9(
+        writeFileSync10(
           tmpPath,
           JSON.stringify({
             offset,
@@ -7724,7 +7822,7 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync4, readFileSync as readFileSync18, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync4, readFileSync as readFileSync18, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir11 } from "os";
 import { join as join22 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -8472,6 +8570,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",
@@ -8510,11 +8612,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;
@@ -9342,7 +9452,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.352" : "dev";
+var agtCliVersion = true ? "0.28.354" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -9437,7 +9547,7 @@ async function ensureToolkitCli(toolkitSlug) {
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      brewBinDir = dirname6(brewPath);
+      brewBinDir = dirname7(brewPath);
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
@@ -9537,8 +9647,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     }
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
-    mkdirSync10(dirname6(path), { recursive: true });
-    writeFileSync11(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync10(dirname7(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -9633,7 +9743,7 @@ async function ensureFrameworkBinary(frameworkId) {
       log(`Claude Code install failed: ${err.message}`);
       return;
     }
-    const brewBinDir = dirname6(brewPath);
+    const brewBinDir = dirname7(brewPath);
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
@@ -10071,7 +10181,7 @@ function ensureEvalEmptyMcpConfig() {
   } catch {
   }
   const p = join23(dir, ".eval-empty-mcp.json");
-  writeFileSync11(p, JSON.stringify({ mcpServers: {} }));
+  writeFileSync12(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -10292,7 +10402,7 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync12 } = await import("fs");
+  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync13 } = await import("fs");
   const skillsDir = join23(configDir, codeName, "project", ".claude", "skills");
   const claudeMdPath = join23(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
@@ -10340,7 +10450,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync12(claudeMdPath, next, "utf-8");
+    writeFileSync13(claudeMdPath, next, "utf-8");
     log2(`Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)`);
   }
 }
@@ -10361,7 +10471,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
+      const { collectDiagnostics } = await import("../persistent-session-SZ5VHS4C.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames)
@@ -10460,7 +10570,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
+      const { collectDiagnostics } = await import("../persistent-session-SZ5VHS4C.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -10615,7 +10725,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-TCTSHDH3.js");
+      } = await import("../responsiveness-probe-2D64EQAU.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -10647,7 +10757,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-TCTSHDH3.js");
+        } = await import("../responsiveness-probe-2D64EQAU.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-HYOOQV4A.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -11517,11 +11627,11 @@ async function processAgent(agent, agentStates) {
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
         const filePath = join23(agentDir, file.relativePath);
-        mkdirSync10(dirname6(filePath), { recursive: true });
+        mkdirSync10(dirname7(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync11(filePath, file.content);
+          writeFileSync12(filePath, file.content);
         }
       }
       try {
@@ -12231,6 +12341,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);
@@ -13783,7 +13912,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-WMQO3QKU.js");
+        const { collectDiagnostics } = await import("../persistent-session-SZ5VHS4C.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName])
@@ -13833,7 +13962,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-WMQO3QKU.js");
+      const { collectDiagnostics } = await import("../persistent-session-SZ5VHS4C.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName])
@@ -14119,8 +14248,8 @@ async function processDirectChatMessage(agent, msg) {
     if (useDoorbell) {
       try {
         const doorbell = directChatDoorbellPath(agent.agentId, homedir12());
-        mkdirSync10(dirname6(doorbell), { recursive: true });
-        writeFileSync11(doorbell, String(Date.now()));
+        mkdirSync10(dirname7(doorbell), { recursive: true });
+        writeFileSync12(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
         return;
       } catch (err) {
@@ -14229,8 +14358,8 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
     const doorbell = directChatDoorbellPath(agentId, homedir12());
-    mkdirSync10(dirname6(doorbell), { recursive: true });
-    writeFileSync11(doorbell, String(Date.now()));
+    mkdirSync10(dirname7(doorbell), { recursive: true });
+    writeFileSync12(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -14331,7 +14460,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-KO2HWC7E.js");
+  } = await import("../claude-pair-runtime-LLUV4KX6.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));
@@ -14676,10 +14805,10 @@ ${mem.content}
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync11(filePath, desired);
+          writeFileSync12(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync11(filePath, desired);
+          writeFileSync12(filePath, desired);
           written++;
         }
       }
@@ -15081,7 +15210,7 @@ function restartRunningChannelMcps(basenames) {
 function deployMcpAssets() {
   const targetDir = join23(homedir12(), ".augmented", "_mcp");
   mkdirSync10(targetDir, { recursive: true });
-  const moduleDir = dirname6(fileURLToPath(import.meta.url));
+  const moduleDir = dirname7(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
@@ -15090,7 +15219,7 @@ function deployMcpAssets() {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname6(dir);
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -15201,7 +15330,7 @@ function deployMcpAssets() {
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync11(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync12(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }