@integrity-labs/agt-cli 0.28.207 → 0.28.209

package/dist/{chunk-TPFTAFG3.js → chunk-Z62QHIR3.js}

@@ -5,6 +5,7 @@ import {
   expandTemplateVars,
   getFlagDefinition,
   getFramework,
+  isolationMode,
   listFlagDefinitions,
   normalizeFlagValue,
   parseEnvIntegrations,
@@ -17,7 +18,10 @@ import {
   resolveConnectivityProbe,
   worseConnectivityOutcome,
   wrapScheduledTaskPrompt
-} from "./chunk-ELBYWACS.js";
+} from "./chunk-WFCCBTA6.js";
+import {
+  parsePsRows
+} from "./chunk-XWVM4KPK.js";
 
 // ../../packages/core/dist/provisioning/mcp-config-guards.js
 import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from "fs";
@@ -4153,14 +4157,14 @@ ${sections}`
     const augDir = join2(homeDir, ".augmented");
     const agents = /* @__PURE__ */ new Set();
     try {
-      const { readdirSync: readdirSync2, statSync: statSync2 } = await import("fs");
+      const { readdirSync: readdirSync2, statSync: statSync3 } = await import("fs");
       const entries = readdirSync2(augDir);
       for (const entry of entries) {
         if (entry.startsWith("_") || entry.startsWith("."))
           continue;
         const agentRoot = join2(augDir, entry);
         try {
-          if (!statSync2(agentRoot).isDirectory())
+          if (!statSync3(agentRoot).isDirectory())
             continue;
         } catch {
           continue;
@@ -5525,7 +5529,7 @@ function requireHost() {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.207" : "dev";
+var agtCliVersion = true ? "0.28.209" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -5920,22 +5924,558 @@ var HostFlagStore = class {
   }
 };
 
-// ../../packages/core/dist/provisioning/provisioner.js
-import { createHash } from "crypto";
-function sha256(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
+// src/lib/stale-mcp-reaper.ts
+import { execFileSync } from "child_process";
+var rotationTimestamps = /* @__PURE__ */ new Map();
+var DEFAULT_ROTATION_GRACE_MS = 15e3;
+function rotationKey(codeName, serverKey) {
+  return `${codeName}\0${serverKey}`;
+}
+function recordStaleRotation(codeName, serverKeys, now = Date.now) {
+  const ts = now();
+  for (const key of serverKeys) {
+    rotationTimestamps.set(rotationKey(codeName, key), ts);
+  }
+}
+function wasRecentlyRotated(codeName, serverKey, withinMs, now = Date.now) {
+  const k = rotationKey(codeName, serverKey);
+  const ts = rotationTimestamps.get(k);
+  if (ts === void 0) return false;
+  if (now() - ts < withinMs) return true;
+  rotationTimestamps.delete(k);
+  return false;
+}
+function parseEnvIntegrationsEntries(content) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) continue;
+    const value = line.slice(eq + 1);
+    entries.set(name, value);
+  }
+  return entries;
+}
+function diffEnvIntegrations(oldContent, newContent) {
+  const oldEntries = oldContent === void 0 ? /* @__PURE__ */ new Map() : parseEnvIntegrationsEntries(oldContent);
+  const newEntries = parseEnvIntegrationsEntries(newContent);
+  const changed = /* @__PURE__ */ new Set();
+  for (const [name, value] of newEntries) {
+    if (oldEntries.get(name) !== value) changed.add(name);
+  }
+  for (const name of oldEntries.keys()) {
+    if (!newEntries.has(name)) changed.add(name);
+  }
+  return [...changed];
+}
+function findMcpServersUsingVars(mcp, changedVars) {
+  const changedSet = new Set(changedVars);
+  if (!mcp?.mcpServers || changedSet.size === 0) return [];
+  const result = [];
+  for (const [serverKey, entry] of Object.entries(mcp.mcpServers)) {
+    if (!entry || typeof entry !== "object") continue;
+    const env = entry.env;
+    if (!env || typeof env !== "object") continue;
+    let matches = false;
+    for (const value of Object.values(env)) {
+      if (typeof value !== "string") continue;
+      const placeholderMatches = value.match(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g);
+      if (placeholderMatches) {
+        for (const ph of placeholderMatches) {
+          const name = ph.slice(2, -1);
+          if (changedSet.has(name)) {
+            matches = true;
+            break;
+          }
+        }
+      }
+      if (matches) break;
+    }
+    if (matches) result.push(serverKey);
+  }
+  return result;
 }
-function provision(input, frameworkId = "claude-code") {
-  const adapter = getFramework(frameworkId);
-  const artifacts = adapter.buildArtifacts(input);
-  const charterHash = sha256(input.charterContent);
-  const toolsHash = sha256(input.toolsContent);
-  const teamDir = `.augmented/${input.agent.code_name}`;
+function buildArgvMatchersForEntry(key, entry) {
+  const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const patterns = [];
+  const args = entry?.args ?? [];
+  for (let i = args.length - 1; i >= 0; i--) {
+    const arg = args[i];
+    if (typeof arg !== "string" || !arg) continue;
+    if (arg.startsWith("-")) continue;
+    const stripped = arg.replace(
+      /@[^/@]*$/,
+      (m) => (
+        // @latest, @1.2.3, etc. — drop. But @scope at the START of a
+        // package spec must NOT be stripped, so we only strip a tail
+        // `@...` if it doesn't itself start with a slash inside.
+        // The regex above only matches a single trailing `@...`
+        // segment after the last `/`, so this is safe for `@scope/pkg`.
+        m.includes("/") ? m : ""
+      )
+    );
+    const tail = "(?![A-Za-z0-9_-])";
+    if (/^@?[a-z0-9]([a-z0-9._-]*\/)?[a-z0-9._-]+$/i.test(stripped)) {
+      patterns.push(new RegExp(`${escapeRe(stripped)}${tail}`));
+      const basename = stripped.split("/").pop();
+      if (basename && basename !== stripped) {
+        patterns.push(new RegExp(`${escapeRe(basename)}${tail}`));
+      }
+      break;
+    }
+    if (stripped.includes("/")) {
+      const basename = stripped.split("/").pop();
+      if (basename) {
+        patterns.push(new RegExp(`${escapeRe(basename)}${tail}`));
+        break;
+      }
+    }
+  }
+  if (patterns.length === 0) {
+    const safe = escapeRe(key);
+    patterns.push(new RegExp(`(?<![A-Za-z0-9_])${safe}(?![A-Za-z0-9_])`));
+    if (safe.includes("_")) {
+      const dashed = safe.replace(/_/g, "-");
+      patterns.push(new RegExp(`(?<![A-Za-z0-9_])${dashed}(?![A-Za-z0-9_])`));
+    }
+  }
+  return patterns;
+}
+function buildClaudeAgentMatcher(codeName) {
+  const safe = codeName.replace(/[^A-Za-z0-9_-]/g, "");
+  return new RegExp(`\\bclaude\\b.*--name\\s+agt-${safe}(?=\\s|$)`);
+}
+function findMcpChildrenForAgent(args) {
+  const { rows, codeName, serverKeys, mcpJson } = args;
+  const maxDepth = args.maxDepth ?? 8;
+  const inContainer = args.inContainer ?? false;
+  if (serverKeys.length === 0 || rows.length === 0) return [];
+  const claudeMatcher = inContainer ? /\bclaude\b/ : buildClaudeAgentMatcher(codeName);
+  const argvMatchers = [];
+  for (const key of serverKeys) {
+    const entry = mcpJson?.mcpServers?.[key];
+    argvMatchers.push(...buildArgvMatchersForEntry(key, entry));
+  }
+  const byPid = new Map(rows.map((r) => [r.pid, r]));
+  const matched = [];
+  for (const row of rows) {
+    if (!argvMatchers.some((re) => re.test(row.args))) continue;
+    if (/\bclaude\b/.test(row.args) && row.args.includes(`--name agt-${codeName}`)) continue;
+    let cur = byPid.get(row.ppid);
+    let belongs = false;
+    for (let depth = 0; depth < maxDepth && cur; depth++) {
+      if (claudeMatcher.test(cur.args)) {
+        belongs = true;
+        break;
+      }
+      if (cur.pid === 1) break;
+      cur = byPid.get(cur.ppid);
+    }
+    if (belongs) matched.push(row.pid);
+  }
+  return matched;
+}
+function reapStaleMcpChildren(args) {
+  const { log, codeName, serverKeys, mcpJson, graceMs = 5e3, isolated = false } = args;
+  if (serverKeys.length === 0) return [];
+  const runPs = args.runPs ?? (isolated ? () => execFileSync("docker", ["exec", `agt-${codeName}`, "ps", "-eo", "pid,ppid,args"], {
+    encoding: "utf-8",
+    timeout: 8e3
+  }) : () => execFileSync("ps", ["-eo", "pid,ppid,args"], { encoding: "utf-8", timeout: 5e3 }));
+  const killProcess = args.killProcess ?? (isolated ? (pid, signal) => {
+    try {
+      execFileSync(
+        "docker",
+        ["exec", `agt-${codeName}`, "kill", signal === "SIGKILL" ? "-KILL" : "-TERM", String(pid)],
+        { timeout: 8e3, stdio: "ignore" }
+      );
+    } catch {
+    }
+  } : (pid, signal) => {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  });
+  const isAlive = args.isAlive ?? (isolated ? (pid) => {
+    try {
+      execFileSync("docker", ["exec", `agt-${codeName}`, "kill", "-0", String(pid)], {
+        timeout: 8e3,
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  } : (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  let psOutput;
+  try {
+    psOutput = runPs();
+  } catch (err) {
+    log(`[stale-mcp-reaper] ps invocation failed for '${codeName}': ${err.message} \u2014 skipping reap`);
+    return [];
+  }
+  const rows = parsePsRows(psOutput);
+  const targets = findMcpChildrenForAgent({ rows, codeName, serverKeys, mcpJson, inContainer: isolated });
+  if (targets.length === 0) return [];
+  const byPid = new Map(rows.map((r) => [r.pid, r]));
+  const describe = (pid) => {
+    const argv = byPid.get(pid)?.args ?? "";
+    const pkgMatch = argv.match(/(@[a-z0-9_-]+\/[a-z0-9_-]+|[a-z0-9_-]+-mcp-server|[a-z0-9_-]+-mcp\b)/i);
+    return pkgMatch ? `${pkgMatch[1]} (pid ${pid})` : `pid ${pid}`;
+  };
+  log(
+    `[stale-mcp-reaper] '${codeName}': rotating ${targets.length} stale MCP child(ren) for [${serverKeys.join(", ")}]: ${targets.map(describe).join(", ")}`
+  );
+  for (const pid of targets) {
+    killProcess(pid, "SIGTERM");
+  }
+  const killedKeys = /* @__PURE__ */ new Set();
+  for (const pid of targets) {
+    const argv = byPid.get(pid)?.args ?? "";
+    for (const key of serverKeys) {
+      const entry = mcpJson?.mcpServers?.[key];
+      const matchers = buildArgvMatchersForEntry(key, entry);
+      if (matchers.some((re) => re.test(argv))) killedKeys.add(key);
+    }
+  }
+  if (killedKeys.size > 0) recordStaleRotation(codeName, killedKeys);
+  setTimeout(() => {
+    try {
+      let freshPsOutput;
+      try {
+        freshPsOutput = runPs();
+      } catch (err) {
+        log(`[stale-mcp-reaper] '${codeName}': fresh ps for SIGKILL re-verify failed: ${err.message} \u2014 skipping SIGKILL pass`);
+        return;
+      }
+      const stillOwned = new Set(
+        findMcpChildrenForAgent({
+          rows: parsePsRows(freshPsOutput),
+          codeName,
+          serverKeys,
+          mcpJson,
+          inContainer: isolated
+        })
+      );
+      const stragglers = targets.filter((pid) => isAlive(pid) && stillOwned.has(pid));
+      if (stragglers.length === 0) return;
+      log(
+        `[stale-mcp-reaper] '${codeName}': ${stragglers.length} child(ren) survived SIGTERM; sending SIGKILL: ${stragglers.map(describe).join(", ")}`
+      );
+      for (const pid of stragglers) {
+        killProcess(pid, "SIGKILL");
+      }
+    } catch (err) {
+      log(`[stale-mcp-reaper] '${codeName}': error in SIGKILL pass: ${err.message}`);
+    }
+  }, graceMs).unref();
+  return targets;
+}
+
+// src/lib/mcp-presence-reaper.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var DEFAULT_COLD_START_GRACE_MS = 9e4;
+var MAX_PRESENCE_RESTART_ATTEMPTS = 3;
+var BACKOFF_AFTER_RESTARTS = MAX_PRESENCE_RESTART_ATTEMPTS;
+var BACKOFF_BASE_MS = 6e4;
+var BACKOFF_MAX_MS = 30 * 6e4;
+var BACKOFF_WINDOW_MS = 60 * 6e4;
+var BACKOFF_GIVE_UP_RESTARTS = 2 * MAX_PRESENCE_RESTART_ATTEMPTS;
+var BACKOFF_STABLE_RESET_MS = 5 * 6e4;
+var presenceReaperState = /* @__PURE__ */ new Map();
+function stateKey(codeName, serverKey) {
+  return `${codeName}\0${serverKey}`;
+}
+function clearPresenceReaperState(codeName) {
+  const prefix = `${codeName}\0`;
+  for (const key of presenceReaperState.keys()) {
+    if (key.startsWith(prefix)) presenceReaperState.delete(key);
+  }
+}
+function clearPresenceReaperStateForKeys(codeName, keys) {
+  for (const key of keys) {
+    presenceReaperState.delete(stateKey(codeName, key));
+  }
+}
+function givenUpMcpServerKeys(codeName) {
+  const prefix = `${codeName}\0`;
+  const out = /* @__PURE__ */ new Set();
+  for (const [key, st] of presenceReaperState) {
+    if (key.startsWith(prefix) && (st.gaveUp || st.attempts >= MAX_PRESENCE_RESTART_ATTEMPTS)) {
+      out.add(key.slice(prefix.length));
+    }
+  }
+  return out;
+}
+function findMissingMcpServers(args) {
+  const { rows, codeName, mcpJson, inContainer } = args;
+  const servers = mcpJson?.mcpServers ?? {};
+  const declared = Object.keys(servers);
+  if (declared.length === 0) return [];
+  const missing = [];
+  for (const key of declared) {
+    const entry = servers[key];
+    const isStdio = typeof entry?.command === "string";
+    if (!isStdio) continue;
+    const live = findMcpChildrenForAgent({
+      rows,
+      codeName,
+      serverKeys: [key],
+      mcpJson,
+      inContainer
+    });
+    if (live.length === 0) missing.push(key);
+  }
+  return missing;
+}
+function reapMissingMcpSessions(args) {
+  const {
+    log,
+    codeName,
+    mcpJson,
+    sessionStartedAt,
+    restartPending = false,
+    stopSession,
+    graceMs = DEFAULT_COLD_START_GRACE_MS,
+    rotationGraceMs = DEFAULT_ROTATION_GRACE_MS,
+    onGiveUp,
+    onRestart,
+    // ENG-5932: defaults make quarantine a strict no-op (classify everything
+    // essential, mode off) so legacy callers/tests are unaffected.
+    classifyKey = () => "essential",
+    quarantineDwellMs = 0,
+    quarantineMode = "off",
+    onQuarantine,
+    isolated = false
+  } = args;
+  const now = args.now ?? Date.now;
+  const runPs = args.runPs ?? (isolated ? () => execFileSync2("docker", ["exec", `agt-${codeName}`, "ps", "-eo", "pid,ppid,args"], {
+    encoding: "utf-8",
+    timeout: 8e3
+  }) : () => execFileSync2("ps", ["-eo", "pid,ppid,args"], { encoding: "utf-8", timeout: 5e3 }));
+  if (!mcpJson?.mcpServers) {
+    return { missing: [], restarted: false, reason: "no-mcp-json" };
+  }
+  const declaredCount = Object.keys(mcpJson.mcpServers).length;
+  if (declaredCount === 0) {
+    return { missing: [], restarted: false, reason: "no-declared-servers" };
+  }
+  if (restartPending) {
+    return { missing: [], restarted: false, reason: "restart-pending" };
+  }
+  if (sessionStartedAt === null) {
+    return { missing: [], restarted: false, reason: "session-start-unknown" };
+  }
+  if (now() - sessionStartedAt < graceMs) {
+    return { missing: [], restarted: false, reason: "cold-start" };
+  }
+  let psOutput;
+  try {
+    psOutput = runPs();
+  } catch (err) {
+    log(`[mcp-presence-reaper] ps invocation failed for '${codeName}': ${err.message} \u2014 skipping`);
+    return { missing: [], restarted: false, reason: "healthy" };
+  }
+  const rows = parsePsRows(psOutput);
+  const missingRaw = findMissingMcpServers({ rows, codeName, mcpJson, inContainer: isolated });
+  const rotationGraced = [];
+  const missing = [];
+  for (const key of missingRaw) {
+    if (wasRecentlyRotated(codeName, key, rotationGraceMs, now)) {
+      rotationGraced.push(key);
+    } else {
+      missing.push(key);
+    }
+  }
+  if (rotationGraced.length > 0) {
+    log(
+      `[mcp-presence-reaper] '${codeName}': skipping [${rotationGraced.join(", ")}] within rotation grace window (${rotationGraceMs}ms) \u2014 child(ren) just SIGTERM'd by stale-mcp-reaper, awaiting respawn on next tool call (ENG-5344)`
+    );
+  }
+  const declared = mcpJson.mcpServers ?? {};
+  const liveKeys = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(declared)) {
+    const entry = declared[key];
+    if (typeof entry?.command !== "string") continue;
+    if (!missingRaw.includes(key)) liveKeys.add(key);
+  }
+  for (const key of liveKeys) {
+    const state = presenceReaperState.get(stateKey(codeName, key));
+    if (state) {
+      state.attempts = 0;
+      state.lastSeenLiveAt = now();
+      state.lastAttemptedSessionStartedAt = null;
+      state.gaveUpLogged = false;
+      state.firstMissingAt = null;
+      state.quarantineLogged = false;
+      state.gaveUp = false;
+      if (state.stableLiveSince === null) state.stableLiveSince = now();
+      if (now() - state.stableLiveSince >= BACKOFF_STABLE_RESET_MS) {
+        state.restartHistory = [];
+      }
+    }
+  }
+  if (missing.length === 0) {
+    return {
+      missing,
+      restarted: false,
+      reason: "healthy",
+      rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0
+    };
+  }
+  const nowMs = now();
+  const givenUp = [];
+  const active = [];
+  const backingOff = [];
+  const newGenerationKeys = /* @__PURE__ */ new Set();
+  const quarantined = [];
+  const wouldQuarantine = [];
+  for (const key of missing) {
+    const sk = stateKey(codeName, key);
+    const state = presenceReaperState.get(sk) ?? {
+      attempts: 0,
+      lastSeenLiveAt: null,
+      lastAttemptedSessionStartedAt: null,
+      gaveUpLogged: false,
+      firstMissingAt: null,
+      quarantineLogged: false,
+      restartHistory: [],
+      stableLiveSince: null,
+      gaveUp: false
+    };
+    if (state.firstMissingAt === null) state.firstMissingAt = nowMs;
+    state.stableLiveSince = null;
+    if (state.lastAttemptedSessionStartedAt !== sessionStartedAt) {
+      state.attempts += 1;
+      state.lastAttemptedSessionStartedAt = sessionStartedAt;
+      newGenerationKeys.add(key);
+    }
+    state.restartHistory = state.restartHistory.filter((t) => nowMs - t < BACKOFF_WINDOW_MS);
+    const restartsInWindow = state.restartHistory.length;
+    presenceReaperState.set(sk, state);
+    const overAttemptsCap = state.attempts > MAX_PRESENCE_RESTART_ATTEMPTS;
+    const overRateCap = restartsInWindow >= BACKOFF_GIVE_UP_RESTARTS;
+    if (overAttemptsCap || overRateCap) {
+      givenUp.push(key);
+      state.gaveUp = true;
+      if (!state.gaveUpLogged) {
+        const cause = overAttemptsCap ? `${MAX_PRESENCE_RESTART_ATTEMPTS} consecutive failed restarts \u2014 declared but never recovers (likely orphaned config; see ENG-5279)` : `${restartsInWindow} restarts within ${Math.round(BACKOFF_WINDOW_MS / 6e4)}m \u2014 persistently flapping (crash-loop; ENG-6480)`;
+        log(
+          `[mcp-presence-reaper] giving up on '${codeName}:${key}' after ${cause}`
+        );
+        state.gaveUpLogged = true;
+        if (onGiveUp) {
+          try {
+            onGiveUp(codeName, key);
+          } catch (err) {
+            log(
+              `[mcp-presence-reaper] onGiveUp callback threw for '${codeName}:${key}' (suppressed; reaper continues): ${err.message}`
+            );
+          }
+        }
+      }
+      if (quarantineMode !== "off" && !state.quarantineLogged && classifyKey(key) === "optional") {
+        const dwellElapsed = quarantineDwellMs <= 0 || state.firstMissingAt !== null && nowMs - state.firstMissingAt >= quarantineDwellMs;
+        if (dwellElapsed) {
+          state.quarantineLogged = true;
+          if (quarantineMode === "enforce") {
+            quarantined.push(key);
+            log(
+              `[mcp-presence-reaper] QUARANTINE '${codeName}:${key}' \u2014 optional channel dead past restart budget + ${quarantineDwellMs}ms dwell; dropping from provisioned set so the dead channel stops restarting the whole session (ENG-5932)`
+            );
+            if (onQuarantine) {
+              try {
+                onQuarantine(codeName, key);
+              } catch (err) {
+                log(
+                  `[mcp-presence-reaper] onQuarantine callback threw for '${codeName}:${key}' (suppressed; reaper continues): ${err.message}`
+                );
+              }
+            }
+          } else {
+            wouldQuarantine.push(key);
+            log(
+              `[mcp-presence-reaper] SHADOW would-quarantine '${codeName}:${key}' \u2014 optional channel dead past restart budget + ${quarantineDwellMs}ms dwell; no action taken (ENG-5932 shadow mode)`
+            );
+          }
+        }
+      }
+    } else {
+      const backoffMs = restartsInWindow < BACKOFF_AFTER_RESTARTS ? 0 : Math.min(
+        BACKOFF_BASE_MS * 2 ** (restartsInWindow - BACKOFF_AFTER_RESTARTS),
+        BACKOFF_MAX_MS
+      );
+      const lastRestartAt = state.restartHistory[state.restartHistory.length - 1] ?? null;
+      if (lastRestartAt !== null && nowMs - lastRestartAt < backoffMs) {
+        backingOff.push(key);
+      } else {
+        active.push(key);
+      }
+    }
+  }
+  if (active.length === 0) {
+    const reason = backingOff.length > 0 ? "backoff" : "all-keys-over-cap";
+    if (backingOff.length > 0) {
+      log(
+        `[mcp-presence-reaper] '${codeName}': holding off restart for [${backingOff.join(", ")}] \u2014 escalating backoff interval not yet elapsed (ENG-6480)${givenUp.length > 0 ? ` (given up: [${givenUp.join(", ")}])` : ""}`
+      );
+    }
+    return {
+      missing,
+      restarted: false,
+      reason,
+      givenUp,
+      backingOff: backingOff.length > 0 ? backingOff : void 0,
+      rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0,
+      quarantined: quarantined.length > 0 ? quarantined : void 0,
+      wouldQuarantine: wouldQuarantine.length > 0 ? wouldQuarantine : void 0
+    };
+  }
+  const givenUpSuffix = givenUp.length > 0 ? ` (skipping over-cap: [${givenUp.join(", ")}])` : "";
+  log(
+    `[mcp-presence-reaper] '${codeName}': declared MCP(s) [${active.join(", ")}] have no live children \u2014 restarting session${givenUpSuffix}`
+  );
+  if (onRestart) {
+    try {
+      const maybePromise = onRestart(codeName, { activeKeys: active, givenUpKeys: givenUp });
+      if (maybePromise && typeof maybePromise.then === "function") {
+        void maybePromise.then(void 0, (err) => {
+          log(
+            `[mcp-presence-reaper] onRestart callback rejected for '${codeName}' (suppressed; restart proceeds): ${err.message}`
+          );
+        });
+      }
+    } catch (err) {
+      log(
+        `[mcp-presence-reaper] onRestart callback threw for '${codeName}' (suppressed; restart proceeds): ${err.message}`
+      );
+    }
+  }
+  stopSession(codeName, { activeKeys: active });
+  for (const key of active) {
+    if (!newGenerationKeys.has(key)) continue;
+    const st = presenceReaperState.get(stateKey(codeName, key));
+    if (st) st.restartHistory.push(nowMs);
+  }
   return {
-    teamDir,
-    artifacts,
-    charterHash,
-    toolsHash
+    missing,
+    restarted: true,
+    givenUp: givenUp.length > 0 ? givenUp : void 0,
+    backingOff: backingOff.length > 0 ? backingOff : void 0,
+    rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0,
+    quarantined: quarantined.length > 0 ? quarantined : void 0,
+    wouldQuarantine: wouldQuarantine.length > 0 ? wouldQuarantine : void 0
   };
 }
 
@@ -6097,23 +6637,229 @@ function buildConnectivityProbeDeps(projectDir, probeEnv) {
   };
 }
 
+// src/lib/session-tool-bind-probe-host.ts
+import { execFileSync as syncExecFile } from "child_process";
+import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/lib/session-tool-probe.ts
+function classifyMcpServer(entry) {
+  if (!entry || typeof entry !== "object") return "unknown";
+  const e = entry;
+  if (typeof e.command === "string") return "stdio";
+  if (typeof e.url === "string") return "http";
+  return "unknown";
+}
+function splitServerKeysByKind(mcpJson, serverKeys) {
+  const servers = mcpJson?.mcpServers ?? {};
+  const stdio = [];
+  const http = [];
+  for (const key of serverKeys) {
+    const kind = classifyMcpServer(servers[key]);
+    if (kind === "stdio") stdio.push(key);
+    else if (kind === "http") http.push(key);
+  }
+  return { stdio, http };
+}
+function computeSessionToolBindStatus(input) {
+  const { stdioServerKeys, httpServerKeys, missingStdioKeys, httpReachable, httpSessionLoaded } = input;
+  if (stdioServerKeys.length === 0 && httpServerKeys.length === 0) return "unknown";
+  if (stdioServerKeys.some((k) => missingStdioKeys.has(k))) return "missing";
+  let anyHttpUnconfirmed = false;
+  for (const k of httpServerKeys) {
+    const reachable = httpReachable.get(k);
+    if (reachable === false) return "unreachable";
+    if (reachable === void 0) {
+      anyHttpUnconfirmed = true;
+    } else if (!httpSessionLoaded) {
+      anyHttpUnconfirmed = true;
+    }
+  }
+  if (anyHttpUnconfirmed && stdioServerKeys.length === 0) return "unknown";
+  return "bound";
+}
+
+// src/lib/session-tool-bind-runner.ts
+var DEFAULT_INTERVAL_MS = 60 * 60 * 1e3;
+var DEFAULT_MAX_PER_RUN = 25;
+function sanitizeServerKey(definitionId) {
+  return definitionId.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+}
+function resolveIntegrationServerKeys(definitionId, declaredKeys, hint) {
+  const declared = new Set(declaredKeys);
+  const candidates = [hint, definitionId, sanitizeServerKey(definitionId)].filter(
+    (k) => typeof k === "string" && k.length > 0
+  );
+  const out = /* @__PURE__ */ new Set();
+  for (const c of candidates) if (declared.has(c)) out.add(c);
+  return [...out];
+}
+function isDue(last, now, intervalMs) {
+  if (!last) return true;
+  const t = Date.parse(last);
+  if (Number.isNaN(t)) return true;
+  return now - t >= intervalMs;
+}
+async function runSessionToolBindProbes(integrations, options) {
+  const now = (options.now?.() ?? /* @__PURE__ */ new Date()).getTime();
+  const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const maxPerRun = options.maxPerRun ?? DEFAULT_MAX_PER_RUN;
+  const due = integrations.filter((i) => isDue(i.last_session_tool_bind_at, now, intervalMs)).sort((a, b) => {
+    const ta = a.last_session_tool_bind_at ? Date.parse(a.last_session_tool_bind_at) : 0;
+    const tb = b.last_session_tool_bind_at ? Date.parse(b.last_session_tool_bind_at) : 0;
+    return ta - tb;
+  });
+  const batch = due.slice(0, maxPerRun);
+  const declaredKeys = Object.keys(options.mcpJson?.mcpServers ?? {});
+  const reports = [];
+  let skipped = 0;
+  let probed = 0;
+  for (const integ of batch) {
+    const keys = resolveIntegrationServerKeys(
+      integ.definition_id,
+      declaredKeys,
+      integ.mcp_server_key
+    );
+    if (keys.length === 0) {
+      skipped += 1;
+      continue;
+    }
+    probed += 1;
+    const { stdio, http } = splitServerKeysByKind(options.mcpJson, keys);
+    const httpReachable = /* @__PURE__ */ new Map();
+    for (const key of http) {
+      let reachable;
+      try {
+        reachable = await options.probeHttp(key);
+      } catch {
+        reachable = void 0;
+      }
+      if (reachable !== void 0) httpReachable.set(key, reachable);
+    }
+    const status = computeSessionToolBindStatus({
+      stdioServerKeys: stdio,
+      httpServerKeys: http,
+      missingStdioKeys: options.missingStdioKeys,
+      httpReachable,
+      httpSessionLoaded: options.httpSessionLoaded ?? false
+    });
+    if (status === "unknown") {
+      skipped += 1;
+      continue;
+    }
+    reports.push({ integration_id: integ.id, scope: integ.scope, status });
+  }
+  return { reports, due: due.length, probed, skipped };
+}
+
+// src/lib/session-tool-bind-probe-host.ts
+async function gatherSessionToolBindProbe(agent, integrations, projectDir, opts) {
+  if (integrations.length === 0) return null;
+  let mcpJson = null;
+  try {
+    mcpJson = JSON.parse(readFileSync7(join6(projectDir, ".mcp.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+  if (!mcpJson?.mcpServers || Object.keys(mcpJson.mcpServers).length === 0) return null;
+  const isolated = isolationMode(agent.code_name) === "docker";
+  const hasDeclaredStdio = Object.values(mcpJson.mcpServers).some(
+    (entry) => typeof entry?.command === "string"
+  );
+  let missingStdioKeys = /* @__PURE__ */ new Set();
+  try {
+    const psOutput = isolated ? syncExecFile("docker", ["exec", `agt-${agent.code_name}`, "ps", "-eo", "pid,ppid,args"], {
+      encoding: "utf-8",
+      timeout: 8e3
+    }) : syncExecFile("ps", ["-eo", "pid,ppid,args"], { encoding: "utf-8", timeout: 5e3 });
+    missingStdioKeys = new Set(
+      findMissingMcpServers({
+        rows: parsePsRows(psOutput),
+        codeName: agent.code_name,
+        mcpJson,
+        inContainer: isolated
+      })
+    );
+  } catch {
+    if (hasDeclaredStdio) return null;
+  }
+  const probeEnv = buildProbeEnv(projectDir);
+  const probeDeps = buildConnectivityProbeDeps(projectDir, probeEnv);
+  const probeHttp = async (serverKey) => {
+    if (!probeDeps.mcpProbe) return void 0;
+    const outcome = await probeDeps.mcpProbe({ serverKey, definitionId: serverKey });
+    if (outcome.status === "ok") return true;
+    if (outcome.status === "down") return false;
+    return void 0;
+  };
+  let httpSessionLoaded = false;
+  try {
+    const mcpMtimeMs = statSync2(join6(projectDir, ".mcp.json")).mtimeMs;
+    httpSessionLoaded = opts.sessionStartedMs != null && opts.sessionStartedMs >= mcpMtimeMs;
+  } catch {
+  }
+  return runSessionToolBindProbes(
+    integrations.map((i) => ({
+      id: i.id,
+      definition_id: i.definition_id,
+      scope: i.scope,
+      last_session_tool_bind_at: i.last_session_tool_bind_at ?? null,
+      // Server-key hint for managed/remote-MCP kinds; the runner also tries the
+      // raw + sanitised definition_id against the real `.mcp.json` keys.
+      mcp_server_key: deriveMcpServerKey({
+        definitionId: i.definition_id,
+        sourceType: i.source_type ?? null,
+        authType: i.auth_type,
+        connectivityTest: i.connectivity_test ?? null
+      })
+    })),
+    {
+      mcpJson,
+      missingStdioKeys,
+      probeHttp,
+      httpSessionLoaded,
+      intervalMs: opts.intervalMs,
+      ...opts.maxPerRun !== void 0 ? { maxPerRun: opts.maxPerRun } : {}
+    }
+  );
+}
+
+// ../../packages/core/dist/provisioning/provisioner.js
+import { createHash } from "crypto";
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function provision(input, frameworkId = "claude-code") {
+  const adapter = getFramework(frameworkId);
+  const artifacts = adapter.buildArtifacts(input);
+  const charterHash = sha256(input.charterContent);
+  const toolsHash = sha256(input.toolsContent);
+  const teamDir = `.augmented/${input.agent.code_name}`;
+  return {
+    teamDir,
+    artifacts,
+    charterHash,
+    toolsHash
+  };
+}
+
 // src/commands/manager.ts
 import chalk3 from "chalk";
 import { existsSync as existsSync8, realpathSync } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir4, userInfo } from "os";
 import { spawn as spawn2 } from "child_process";
 
 // src/lib/watchdog.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, existsSync as existsSync7, mkdirSync as mkdirSync5, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync4 } from "fs";
-import { join as join6 } from "path";
-import { spawn, execFileSync } from "child_process";
-var DEFAULT_CONFIG_DIR = join6(process.env["HOME"] ?? "/tmp", ".augmented");
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, existsSync as existsSync7, mkdirSync as mkdirSync5, openSync as openSync2, closeSync as closeSync2, chmodSync as chmodSync4 } from "fs";
+import { join as join7 } from "path";
+import { spawn, execFileSync as execFileSync3 } from "child_process";
+var DEFAULT_CONFIG_DIR = join7(process.env["HOME"] ?? "/tmp", ".augmented");
 function getManagerPaths(configDir) {
   return {
-    pidFile: join6(configDir, "manager.pid"),
-    stateFile: join6(configDir, "manager-state.json"),
-    logFile: join6(configDir, "manager.log")
+    pidFile: join7(configDir, "manager.pid"),
+    stateFile: join7(configDir, "manager-state.json"),
+    logFile: join7(configDir, "manager.log")
   };
 }
 function ensureDir(configDir) {
@@ -6127,7 +6873,7 @@ function writePidFile(configDir, pid) {
 }
 function readPidFile(configDir) {
   try {
-    const raw = readFileSync7(getManagerPaths(configDir).pidFile, "utf-8").trim();
+    const raw = readFileSync8(getManagerPaths(configDir).pidFile, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -6158,14 +6904,14 @@ function findOtherManagerPids(pgrepImpl = defaultPgrep, selfPid = process.pid) {
   return out.split("\n").map((line) => parseInt(line.trim(), 10)).filter((pid) => !isNaN(pid) && pid !== selfPid);
 }
 function defaultPgrep() {
-  return execFileSync("pgrep", ["-f", "agt manager start"], {
+  return execFileSync3("pgrep", ["-f", "agt manager start"], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "ignore"]
   });
 }
 function readStateFile(configDir) {
   try {
-    const raw = readFileSync7(getManagerPaths(configDir).stateFile, "utf-8");
+    const raw = readFileSync8(getManagerPaths(configDir).stateFile, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -6349,7 +7095,7 @@ function managerStartCommand(opts) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join7(homedir4(), ".augmented");
+  const configDir = opts.configDir ?? join8(homedir4(), ".augmented");
   if (opts.supervise) {
     if (json) {
       jsonOutput({ ok: false, error: "--supervise is not supported with --json" });
@@ -6445,7 +7191,7 @@ function runSupervisorLoop(intervalSec, configDir) {
 }
 async function managerStopCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join7(homedir4(), ".augmented");
+  const configDir = opts.configDir ?? join8(homedir4(), ".augmented");
   try {
     const result = await stopWatchdog(configDir);
     if (!result.stopped && !result.pid) {
@@ -6473,7 +7219,7 @@ async function managerStopCommand(opts = {}) {
 }
 function managerStatusCommand(opts = {}) {
   const json = isJsonMode();
-  const configDir = opts.configDir ?? join7(homedir4(), ".augmented");
+  const configDir = opts.configDir ?? join8(homedir4(), ".augmented");
   const status = getManagerStatus(configDir);
   if (!status) {
     if (json) {
@@ -6565,7 +7311,7 @@ async function managerInstallCommand(opts = {}) {
     process.exitCode = 1;
     return;
   }
-  const configDir = opts.configDir ?? join7(homedir4(), ".augmented");
+  const configDir = opts.configDir ?? join8(homedir4(), ".augmented");
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -6578,7 +7324,7 @@ async function managerInstallCommand(opts = {}) {
   if (process.platform === "darwin") {
     const home = homedir4();
     const protectedRoots = ["Documents", "Downloads", "Desktop", "Movies", "Music", "Pictures"];
-    const offending = protectedRoots.map((r) => join7(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
+    const offending = protectedRoots.map((r) => join8(home, r)).find((p) => agtBin === p || agtBin.startsWith(`${p}/`));
     if (offending) {
       const msg = `agt binary at ${agtBin} sits inside a macOS TCC-protected folder (${offending}). launchd-spawned processes cannot read files there and the manager would EPERM on startup. Either install agt globally (\`npm install -g @integrity-labs/agt-cli\`) or copy the dist outside protected folders before running this command.`;
       if (json) jsonOutput({ ok: false, error: msg });
@@ -6646,7 +7392,7 @@ async function managerInstallSystemUnitCommand(opts = {}) {
     return;
   }
   const user = opts.user ?? "root";
-  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join7("/home", user, ".augmented"));
+  const configDir = opts.configDir ?? (user === "root" ? "/root/.augmented" : join8("/home", user, ".augmented"));
   const rawAgtBin = process.argv[1];
   if (!rawAgtBin) {
     const msg = "Could not resolve the agt binary path from argv. Re-run via the installed `agt` command.";
@@ -6817,11 +7563,19 @@ export {
   resolveFlagFromLayers,
   resolveAllFlags,
   HostFlagStore,
-  provision,
-  executeConnectivityProbe,
+  diffEnvIntegrations,
+  findMcpServersUsingVars,
+  reapStaleMcpChildren,
+  clearPresenceReaperState,
+  clearPresenceReaperStateForKeys,
+  givenUpMcpServerKeys,
+  reapMissingMcpSessions,
   deriveMcpServerKey,
   buildProbeEnv,
   buildConnectivityProbeDeps,
+  gatherSessionToolBindProbe,
+  provision,
+  executeConnectivityProbe,
   getManagerPaths,
   startWatchdog,
   managerStartCommand,
@@ -6833,4 +7587,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-TPFTAFG3.js.map
+//# sourceMappingURL=chunk-Z62QHIR3.js.map