@integrity-labs/agt-cli 0.27.51 → 0.27.52

package/dist/lib/manager-worker.js

@@ -15,7 +15,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-Y4KVZGPE.js";
+} from "../chunk-IMKH4X56.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -77,10 +77,10 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, appendFileSync, mkdirSync as mkdirSync4, chmodSync, existsSync as existsSync5, rmSync as rmSync2, readdirSync as readdirSync3, statSync as statSync2, unlinkSync, copyFileSync } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, appendFileSync, mkdirSync as mkdirSync4, chmodSync, existsSync as existsSync5, rmSync as rmSync2, readdirSync as readdirSync3, statSync as statSync2, unlinkSync, copyFileSync } from "fs";
 import https from "https";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join6, dirname as dirname3 } from "path";
+import { join as join7, dirname as dirname3 } from "path";
 import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
@@ -412,7 +412,13 @@ function reapMissingMcpSessions(args) {
     graceMs = DEFAULT_COLD_START_GRACE_MS,
     rotationGraceMs = DEFAULT_ROTATION_GRACE_MS,
     onGiveUp,
-    onRestart
+    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
   } = args;
   const now = args.now ?? Date.now;
   const runPs = args.runPs ?? (() => execFileSync2("ps", ["-eo", "pid,ppid,args"], { encoding: "utf-8", timeout: 5e3 }));
@@ -466,6 +472,8 @@ function reapMissingMcpSessions(args) {
       state5.lastSeenLiveAt = now();
       state5.lastAttemptedSessionStartedAt = null;
       state5.gaveUpLogged = false;
+      state5.firstMissingAt = null;
+      state5.quarantineLogged = false;
     }
   }
   if (missing.length === 0) {
@@ -476,16 +484,22 @@ function reapMissingMcpSessions(args) {
       rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0
     };
   }
+  const nowMs = now();
   const givenUp = [];
   const active = [];
+  const quarantined = [];
+  const wouldQuarantine = [];
   for (const key of missing) {
     const sk = stateKey(codeName, key);
     const state5 = presenceReaperState.get(sk) ?? {
       attempts: 0,
       lastSeenLiveAt: null,
       lastAttemptedSessionStartedAt: null,
-      gaveUpLogged: false
+      gaveUpLogged: false,
+      firstMissingAt: null,
+      quarantineLogged: false
     };
+    if (state5.firstMissingAt === null) state5.firstMissingAt = nowMs;
     if (state5.lastAttemptedSessionStartedAt !== sessionStartedAt) {
       state5.attempts += 1;
       state5.lastAttemptedSessionStartedAt = sessionStartedAt;
@@ -508,6 +522,32 @@ function reapMissingMcpSessions(args) {
           }
         }
       }
+      if (quarantineMode !== "off" && !state5.quarantineLogged && classifyKey(key) === "optional") {
+        const dwellElapsed = quarantineDwellMs <= 0 || state5.firstMissingAt !== null && nowMs - state5.firstMissingAt >= quarantineDwellMs;
+        if (dwellElapsed) {
+          state5.quarantineLogged = true;
+          if (quarantineMode === "enforce") {
+            quarantined.push(key);
+            log2(
+              `[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) {
+                log2(
+                  `[mcp-presence-reaper] onQuarantine callback threw for '${codeName}:${key}' (suppressed; reaper continues): ${err.message}`
+                );
+              }
+            }
+          } else {
+            wouldQuarantine.push(key);
+            log2(
+              `[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 {
       active.push(key);
     }
@@ -518,7 +558,9 @@ function reapMissingMcpSessions(args) {
       restarted: false,
       reason: "all-keys-over-cap",
       givenUp,
-      rotationGraced: rotationGraced.length > 0 ? rotationGraced : 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(", ")}])` : "";
@@ -546,7 +588,9 @@ function reapMissingMcpSessions(args) {
     missing,
     restarted: true,
     givenUp: givenUp.length > 0 ? givenUp : void 0,
-    rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0
+    rotationGraced: rotationGraced.length > 0 ? rotationGraced : void 0,
+    quarantined: quarantined.length > 0 ? quarantined : void 0,
+    wouldQuarantine: wouldQuarantine.length > 0 ? wouldQuarantine : void 0
   };
 }
 
@@ -609,6 +653,151 @@ function decideSenderPolicyRestart(input) {
   return { restart: true, firstPoll: false, changed: true };
 }
 
+// src/lib/channel-quarantine.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// src/lib/atomic-write.ts
+import { closeSync, fsyncSync, openSync, writeSync, renameSync, mkdirSync } from "fs";
+import { dirname } from "path";
+function atomicWriteFileSync(path, data) {
+  const dirPath = dirname(path);
+  const tmpPath = `${path}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    mkdirSync(dirPath, { recursive: true });
+  } catch {
+  }
+  const fd = openSync(tmpPath, "w", 420);
+  try {
+    writeSync(fd, data);
+    try {
+      fsyncSync(fd);
+    } catch {
+    }
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmpPath, path);
+  try {
+    const dirFd = openSync(dirPath, "r");
+    try {
+      fsyncSync(dirFd);
+    } finally {
+      closeSync(dirFd);
+    }
+  } catch {
+  }
+}
+
+// src/lib/channel-quarantine.ts
+var ESSENTIAL_CHANNEL_KEYS = /* @__PURE__ */ new Set(["direct-chat", "augmented"]);
+var OPTIONAL_CHANNEL_KEYS = /* @__PURE__ */ new Set([
+  "telegram",
+  "slack",
+  "msteams",
+  "discord",
+  "whatsapp",
+  "signal",
+  "imessage",
+  "matrix",
+  "irc",
+  "nostr"
+]);
+function readDeclaredCriticality(entry) {
+  if (!entry || typeof entry !== "object") return void 0;
+  const meta = entry._augmented;
+  if (!meta || typeof meta !== "object") return void 0;
+  const value = meta.criticality;
+  return value === "essential" || value === "optional" ? value : void 0;
+}
+function classifyChannelCriticality(serverKey, entry) {
+  if (ESSENTIAL_CHANNEL_KEYS.has(serverKey)) return "essential";
+  const declared = readDeclaredCriticality(entry);
+  if (declared) return declared;
+  if (OPTIONAL_CHANNEL_KEYS.has(serverKey)) return "optional";
+  return "essential";
+}
+function defaultQuarantinePath(configDir) {
+  return join(configDir, "channel-quarantine.json");
+}
+var ChannelQuarantineStore = class {
+  path;
+  cache = null;
+  constructor(path) {
+    this.path = path;
+  }
+  load() {
+    if (this.cache) return this.cache;
+    try {
+      const raw = readFileSync(this.path, "utf-8");
+      const parsed = JSON.parse(raw);
+      this.cache = isQuarantineFile(parsed) ? parsed : {};
+    } catch {
+      this.cache = {};
+    }
+    return this.cache;
+  }
+  persist() {
+    atomicWriteFileSync(this.path, JSON.stringify(this.cache ?? {}, null, 2));
+  }
+  /** Is `serverKey` currently quarantined for `codeName`? */
+  isQuarantined(codeName, serverKey) {
+    return this.load()[codeName]?.[serverKey] !== void 0;
+  }
+  /** The set of quarantined server keys for `codeName` (empty Set if none). */
+  getQuarantinedKeys(codeName) {
+    const forAgent = this.load()[codeName];
+    return new Set(forAgent ? Object.keys(forAgent) : []);
+  }
+  /**
+   * Mark `serverKey` quarantined for `codeName`. Idempotent — re-quarantining
+   * an already-quarantined key preserves the original `quarantinedAt` (so the
+   * "how long has this been quarantined" escalation clock in Slice 3 isn't
+   * reset by provisioning churn). Returns true iff this call newly quarantined
+   * the key (false if it was already quarantined).
+   */
+  quarantine(codeName, serverKey, reason, now) {
+    const file = this.load();
+    const forAgent = file[codeName] ??= {};
+    if (forAgent[serverKey]) return false;
+    forAgent[serverKey] = { quarantinedAt: now, reason };
+    this.persist();
+    return true;
+  }
+  /**
+   * Clear the quarantine for `serverKey` (explicit re-enable). Returns true iff
+   * a marker was actually removed. NOTE: re-enable is an EXPLICIT verb (Slice 2
+   * exposes it via the API/console) — provisioning's idempotent `.mcp.json`
+   * rewrites must NEVER call this, or a quarantined channel would re-arm into a
+   * fresh flap laundered through the config loop.
+   */
+  clearQuarantine(codeName, serverKey) {
+    const file = this.load();
+    const forAgent = file[codeName];
+    if (!forAgent || !forAgent[serverKey]) return false;
+    delete forAgent[serverKey];
+    if (Object.keys(forAgent).length === 0) delete file[codeName];
+    this.persist();
+    return true;
+  }
+  /** Test seam: drop the in-memory cache so the next read re-hits disk. */
+  __invalidateCacheForTests() {
+    this.cache = null;
+  }
+};
+function isQuarantineFile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  for (const forAgent of Object.values(value)) {
+    if (!forAgent || typeof forAgent !== "object" || Array.isArray(forAgent)) return false;
+    for (const entry of Object.values(forAgent)) {
+      if (!entry || typeof entry !== "object") return false;
+      const e = entry;
+      if (typeof e.quarantinedAt !== "number" || typeof e.reason !== "string") return false;
+    }
+  }
+  return true;
+}
+
 // src/lib/restart-breaker.ts
 function reaperRestartBreakerReason(activeKeys) {
   return activeKeys.length >= 2 ? "mcp-presence-reaper" : void 0;
@@ -942,8 +1131,8 @@ function runCliProbe(binary, args, opts = {}) {
 }
 
 // src/lib/self-update-coalesce.ts
-import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 var DEFAULT_SELF_UPDATE_COALESCE_MS = 30 * 60 * 1e3;
 function resolveCoalesceWindowMs(env = process.env) {
   const raw = env.AGT_SELF_UPDATE_COALESCE_MS;
@@ -952,7 +1141,7 @@ function resolveCoalesceWindowMs(env = process.env) {
   if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_SELF_UPDATE_COALESCE_MS;
   return Math.trunc(parsed);
 }
-function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync(p, "utf-8")) {
+function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync2(p, "utf-8")) {
   let raw;
   try {
     raw = read(markerPath);
@@ -965,7 +1154,7 @@ function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) =>
   return v;
 }
 function stampLastSelfUpdateApplied(markerPath, now = Date.now(), write = (p, v) => {
-  mkdirSync(dirname(p), { recursive: true });
+  mkdirSync2(dirname2(p), { recursive: true });
   writeFileSync(p, v);
 }) {
   try {
@@ -988,44 +1177,12 @@ function formatCoalesceDeferLogLine(opts) {
   return `[self-update] coalescing \u2014 ${opts.installed} \u2192 ${opts.latest} (${opts.channelLabel}) available, deferring for ${remainingSec}s (last restart inside ${windowMin}min window). See ENG-5862. Override with AGT_SELF_UPDATE_COALESCE_MS=0 during incident response.`;
 }
 
-// src/lib/atomic-write.ts
-import { closeSync, fsyncSync, openSync, writeSync, renameSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-function atomicWriteFileSync(path, data) {
-  const dirPath = dirname2(path);
-  const tmpPath = `${path}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 8)}`;
-  try {
-    mkdirSync2(dirPath, { recursive: true });
-  } catch {
-  }
-  const fd = openSync(tmpPath, "w", 420);
-  try {
-    writeSync(fd, data);
-    try {
-      fsyncSync(fd);
-    } catch {
-    }
-  } finally {
-    closeSync(fd);
-  }
-  renameSync(tmpPath, path);
-  try {
-    const dirFd = openSync(dirPath, "r");
-    try {
-      fsyncSync(dirFd);
-    } finally {
-      closeSync(dirFd);
-    }
-  } catch {
-  }
-}
-
 // src/lib/claude-pid-tracker.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync, readFileSync as readFileSync3 } from "fs";
 function readPidFile(path) {
   if (!existsSync(path)) return { version: 1, spawns: [] };
   try {
-    const raw = JSON.parse(readFileSync2(path, "utf-8"));
+    const raw = JSON.parse(readFileSync3(path, "utf-8"));
     if (raw.version !== 1 || !Array.isArray(raw.spawns)) return { version: 1, spawns: [] };
     const spawns = raw.spawns.filter(
       (s) => !!s && typeof s.pid === "number" && Number.isFinite(s.pid) && s.pid > 0
@@ -1133,8 +1290,8 @@ async function maybeReportUsageBanner(args) {
 }
 
 // src/lib/token-usage-monitor.ts
-import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import { join } from "path";
+import { readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import { join as join2 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
@@ -1163,7 +1320,7 @@ async function maybeReportTokenUsage(args) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
     if (!sessionId) continue;
-    const path = join(dir, name);
+    const path = join2(dir, name);
     let st;
     try {
       st = statSync(path);
@@ -1179,7 +1336,7 @@ async function maybeReportTokenUsage(args) {
     }
     let content;
     try {
-      content = readFileSync3(path, "utf-8");
+      content = readFileSync4(path, "utf-8");
     } catch (err) {
       log2(`[token-usage] read failed for '${codeName}/${name}': ${err.message}`);
       continue;
@@ -1260,11 +1417,11 @@ async function maybeReportTokenUsage(args) {
 }
 
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var MIN_CHECK_INTERVAL_MS3 = 6e4;
-var STATS_CACHE_PATH = join2(homedir(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join3(homedir(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state3 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -1312,7 +1469,7 @@ async function maybeReportActivityCache(args) {
   }
   let raw;
   try {
-    raw = readFileSync4(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync5(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
@@ -1762,7 +1919,7 @@ var GatewayClientPool = class extends EventEmitter {
 // src/lib/claude-auth-detect.ts
 import { readFile, readdir } from "fs/promises";
 import { homedir as homedir2, platform } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
@@ -1777,8 +1934,8 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join3(homedir2(), ".claude", ".credentials.json"),
-    join3(homedir2(), ".claude", "credentials.json")
+    join4(homedir2(), ".claude", ".credentials.json"),
+    join4(homedir2(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
@@ -1786,8 +1943,8 @@ async function findClaudeCredentialsPaths() {
       const entries = await readdir("/home", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        candidates.push(join3("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join3("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join4("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join4("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -1879,18 +2036,18 @@ function normalize(value) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join4(configDir, CACHE_FILENAME);
+  return join5(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
   if (!existsSync3(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    parsed = JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return;
   }
@@ -2435,15 +2592,15 @@ function clearAgentState(agentId, codeName) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync6, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join5(homedir3(), ".augmented", "restart-flags");
+  return join6(homedir3(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join5(restartFlagsDir(), `${codeName}.flag`);
+  return join6(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
@@ -2452,7 +2609,7 @@ function readRestartFlags() {
   for (const entry of readdirSync2(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync6(join5(dir, entry), "utf8");
+      const raw = readFileSync7(join6(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -2981,8 +3138,8 @@ function applyRestartAcks(args) {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join6(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join6(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join7(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join7(AUGMENTED_DIR, "gateway-ports.json");
 var CHANNEL_SWEEP_INTERVAL_MS = (() => {
   const raw = parseInt(process.env["AGT_CHANNEL_SWEEP_INTERVAL_MS"] ?? "", 10);
   if (!Number.isFinite(raw)) return 5 * 60 * 1e3;
@@ -3151,7 +3308,7 @@ var runningMcpHashes = /* @__PURE__ */ new Map();
 var runningMcpServerKeys = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     return createHash3("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -3159,7 +3316,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -3170,7 +3327,7 @@ function projectMcpKeys(_codeName, projectDir) {
 }
 function readMcpHttpServerConfig(projectDir, serverKey) {
   try {
-    const raw = readFileSync7(join6(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync8(join7(projectDir, ".mcp.json"), "utf-8");
     const servers = JSON.parse(raw).mcpServers ?? {};
     const entry = servers[serverKey];
     if (entry && typeof entry.url === "string" && (entry.type === "http" || entry.type === void 0)) {
@@ -3259,11 +3416,22 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
       const previousKeys = runningMcpServerKeys.get(codeName);
       const currentKeys = projectMcpKeys(codeName, projectDir);
       const decision = decideMcpRestartOnDrift(previousKeys, currentKeys);
+      let quarantineOnlyDrift = false;
+      if (decision.restart && !decision.membershipUnknown && currentKeys) {
+        const quarantined = channelQuarantineStore().getQuarantinedKeys(codeName);
+        const added = decision.addedOrRemoved.filter((k) => currentKeys.has(k));
+        const removed = decision.addedOrRemoved.filter((k) => !currentKeys.has(k));
+        quarantineOnlyDrift = added.length === 0 && removed.length > 0 && removed.every((k) => quarantined.has(k));
+      }
       if (decision.membershipUnknown) {
         clearPresenceReaperState(codeName);
         log(
           `[hot-reload] .mcp.json key membership unavailable for '${codeName}' \u2014 clearing full presence-reaper state and restarting (ENG-5285/ENG-5537)`
         );
+      } else if (quarantineOnlyDrift) {
+        log(
+          `[channel-quarantine] .mcp.json drift for '${codeName}' is quarantined-channel removal only [${decision.addedOrRemoved.join(", ")}] \u2014 adopting new baseline WITHOUT restart (0-restart-on-removal, ENG-5932)`
+        );
       } else if (decision.restart) {
         clearPresenceReaperStateForKeys(codeName, new Set(decision.addedOrRemoved));
         log(
@@ -3274,7 +3442,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
           `[hot-reload] .mcp.json value-only drift for '${codeName}' \u2014 preserving presence-reaper state and NOT restarting (ENG-5285/ENG-5537)`
         );
       }
-      if (decision.restart) {
+      if (decision.restart && !quarantineOnlyDrift) {
         scheduleSessionRestart(codeName, 0, ".mcp.json content change (ENG-4897)");
         runningMcpHashes.delete(codeName);
         runningMcpServerKeys.delete(codeName);
@@ -3344,7 +3512,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.51" : "dev";
+var agtCliVersion = true ? "0.27.52" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -3521,7 +3689,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
     if (existsSync5(path)) {
-      const raw = readFileSync7(path, "utf-8").trim();
+      const raw = readFileSync8(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -3593,7 +3761,7 @@ async function ensureFrameworkBinary(frameworkId) {
 var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var claudeCodeUpgradeInFlight = false;
 function claudeCodeUpgradeMarkerPath() {
-  return join6(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
+  return join7(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
 }
 function stampClaudeCodeUpgradeMarker() {
   try {
@@ -3603,7 +3771,7 @@ function stampClaudeCodeUpgradeMarker() {
 }
 function claudeCodeUpgradeThrottled() {
   try {
-    const lastCheck = parseInt(readFileSync7(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
+    const lastCheck = parseInt(readFileSync8(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
     if (!Number.isFinite(lastCheck)) return false;
     return Date.now() - lastCheck < CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS;
   } catch {
@@ -3653,7 +3821,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join6(homedir4(), ".augmented", ".last-self-update-applied");
+  return join7(homedir4(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -3676,7 +3844,7 @@ async function checkAndUpdateCli() {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return;
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join6(homedir4(), ".augmented", ".last-update-check");
+    const markerPath = join7(homedir4(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -3897,9 +4065,9 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join6(homedir4(), ".claude");
+    const claudeDir = join7(homedir4(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join6(claudeDir, filename);
+      const p = join7(claudeDir, filename);
       if (existsSync5(p)) {
         try {
           rmSync2(p, { force: true });
@@ -3914,7 +4082,7 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync7(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync8(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
@@ -3944,10 +4112,10 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join6(config?.configDir ?? join6(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join7(config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join6(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -3955,6 +4123,30 @@ function loadChannelHashCache2() {
 function saveChannelHashCache2() {
   saveChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
 }
+var _channelQuarantineStore = null;
+function channelQuarantineStore() {
+  if (!_channelQuarantineStore) {
+    const dir = config?.configDir ?? join7(process.env["HOME"] ?? "/tmp", ".augmented");
+    _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
+  }
+  return _channelQuarantineStore;
+}
+function channelQuarantineMode() {
+  const v = process.env["AGT_CHANNEL_QUARANTINE_MODE"]?.toLowerCase();
+  if (v === "off") return "off";
+  if (v === "enforce") return "enforce";
+  return "shadow";
+}
+function channelQuarantineDwellMs() {
+  const raw = parseInt(process.env["AGT_CHANNEL_QUARANTINE_DWELL_MS"] ?? "", 10);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 18e4;
+}
+function setWithout(source, remove) {
+  if (remove.size === 0) return new Set(source);
+  const out = /* @__PURE__ */ new Set();
+  for (const v of source) if (!remove.has(v)) out.add(v);
+  return out;
+}
 function send(msg) {
   if (msg.type === "state-update") {
     try {
@@ -3989,7 +4181,7 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join6(homedir4(), ".augmented", "manager.log");
+      managerLogPath = join7(homedir4(), ".augmented", "manager.log");
       mkdirSync4(dirname3(managerLogPath), { recursive: true });
       if (existsSync5(managerLogPath)) {
         chmodSync(managerLogPath, 384);
@@ -4019,7 +4211,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync7(filePath, "utf-8");
+    const content = readFileSync8(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -4044,12 +4236,12 @@ function parseSkillFrontmatter(content) {
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
   const { readdirSync: readdirSync4, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync5 } = await import("fs");
-  const skillsDir = join6(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join6(configDir, codeName, "project", "CLAUDE.md");
+  const skillsDir = join7(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join7(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync4(skillsDir).sort()) {
-    const skillFile = join6(skillsDir, dir, "SKILL.md");
+    const skillFile = join7(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -4097,10 +4289,10 @@ ${SKILLS_INDEX_END}`;
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join6(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join7(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync7(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync8(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -4113,19 +4305,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join6(homeDir, `.openclaw-${codeName}`);
-    if (existsSync5(join6(profileDir, "openclaw.json"))) continue;
+    const profileDir = join7(homeDir, `.openclaw-${codeName}`);
+    if (existsSync5(join7(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join6(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join6(profileDir, "agents", codeName, "agent");
-    const authFile = join6(sharedAuthDir, "auth-profiles.json");
+    const sharedAuthDir = join7(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join7(profileDir, "agents", codeName, "agent");
+    const authFile = join7(sharedAuthDir, "auth-profiles.json");
     if (existsSync5(authFile)) {
       mkdirSync4(profileAuthDir, { recursive: true });
-      const authContent = readFileSync7(authFile, "utf-8");
-      writeFileSync4(join6(profileAuthDir, "auth-profiles.json"), authContent);
+      const authContent = readFileSync8(authFile, "utf-8");
+      writeFileSync4(join7(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -4163,7 +4355,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync7(join6(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync8(join7(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -4172,10 +4364,10 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join6(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const jobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   if (!existsSync5(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync7(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync8(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
@@ -4208,15 +4400,15 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join6(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join6(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          const configPath = join7(homeDir, `.openclaw-${codeName}`, "openclaw.json");
           if (existsSync5(configPath)) {
-            const cfg = JSON.parse(readFileSync7(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync8(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
@@ -4240,9 +4432,9 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join6(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      const configPath = join7(homeDir, `.openclaw-${codeName}`, "openclaw.json");
       if (existsSync5(configPath)) {
-        const cfg = JSON.parse(readFileSync7(configPath, "utf-8"));
+        const cfg = JSON.parse(readFileSync8(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
         writeFileSync4(configPath, JSON.stringify(cfg, null, 2));
@@ -4608,7 +4800,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join6(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join7(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -4759,7 +4951,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join6(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join7(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -4928,7 +5120,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join6(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join7(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.seedProfileConfig) {
     frameworkAdapter.seedProfileConfig(agent.code_name);
@@ -4937,7 +5129,11 @@ async function processAgent(agent, agentStates) {
   const toolsVersion = refreshData.tools.version;
   const known = agentState.knownVersions.get(agent.agent_id);
   let lastProvisionAt = state4.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
-  const currentChannelIds = launchableChannelIds(refreshData.channel_configs);
+  const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(agent.code_name);
+  const currentChannelIds = setWithout(
+    launchableChannelIds(refreshData.channel_configs),
+    quarantinedChannels
+  );
   const previousChannelIds = agentState.knownChannels.get(agent.agent_id);
   const channelsChanged = !previousChannelIds || currentChannelIds.size !== previousChannelIds.size || [...currentChannelIds].some((ch) => !previousChannelIds.has(ch)) || [...previousChannelIds].some((ch) => !currentChannelIds.has(ch));
   let channelConfigConverged = true;
@@ -4959,7 +5155,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync4(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join6(agentDir, artifact.relativePath);
+      const filePath = join7(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -4978,8 +5174,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join6(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync7(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join7(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync8(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -4997,7 +5193,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync7(filePath, "utf-8");
+          existingRaw = readFileSync8(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -5019,22 +5215,22 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync5(join6(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync5(join7(agentDir, "CHARTER.md"));
       const verb = isFirst ? "Provisioning" : "Updating";
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        const filePath = join6(agentDir, file.relativePath);
+        const filePath = join7(agentDir, file.relativePath);
         mkdirSync4(dirname3(filePath), { recursive: true });
         writeFileSync4(filePath, file.content);
       }
       try {
-        const provSkillsDir = join6(agentDir, ".claude", "skills");
+        const provSkillsDir = join7(agentDir, ".claude", "skills");
         if (existsSync5(provSkillsDir)) {
           for (const folder of readdirSync3(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync2(join6(provSkillsDir, folder), { recursive: true });
+                rmSync2(join7(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -5047,7 +5243,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join6(agentDir, file));
+        const h = hashFile(join7(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -5115,7 +5311,7 @@ async function processAgent(agent, agentStates) {
   if (written && existsSync5(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join6(agentDir, file));
+      const localHash = hashFile(join7(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -5126,7 +5322,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join6(agentDir, file));
+          localHashes[file] = hashFile(join7(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -5164,6 +5360,14 @@ async function processAgent(agent, agentStates) {
   if (refreshData.channel_configs && frameworkAdapter.writeChannelCredentials) {
     if (agent.status === "active") {
       for (const [channelId, entry] of Object.entries(refreshData.channel_configs)) {
+        if (quarantinedChannels.has(channelId)) {
+          try {
+            frameworkAdapter.removeChannelCredentials?.(agent.code_name, channelId);
+          } catch (err) {
+            log(`[channel-quarantine] failed to drop quarantined channel '${agent.code_name}/${channelId}' from .mcp.json: ${err.message}`);
+          }
+          continue;
+        }
         if ((entry.status === "active" || entry.status === "pending") && entry.config) {
           if (!activeChannels.has(channelId)) {
             activeChannels.set(channelId, /* @__PURE__ */ new Set());
@@ -5270,7 +5474,14 @@ async function processAgent(agent, agentStates) {
     framework: agentFrameworkCache.get(agent.code_name) ?? "openclaw",
     sessionHealthy: isSessionHealthy(agent.code_name)
   }) : { restart: false, added: [], removed: [] };
-  if (restartDecision.restart) {
+  const quarantineOnlyRemoval = restartDecision.restart && restartDecision.added.length === 0 && restartDecision.removed.length > 0 && restartDecision.removed.every((c) => quarantinedChannels.has(c));
+  const channelSetRestartScheduled = restartDecision.restart && !quarantineOnlyRemoval;
+  if (quarantineOnlyRemoval) {
+    log(
+      `[channel-quarantine] suppressing channel-set-change restart for '${agent.code_name}' \u2014 only delta is quarantined-channel removal [${restartDecision.removed.join(", ")}] (0-restart-on-removal, ENG-5932)`
+    );
+  }
+  if (channelSetRestartScheduled) {
     const reasonParts = [];
     if (restartDecision.added.length > 0) reasonParts.push(`added=${restartDecision.added.join(",")}`);
     if (restartDecision.removed.length > 0) reasonParts.push(`removed=${restartDecision.removed.join(",")}`);
@@ -5295,7 +5506,7 @@ async function processAgent(agent, agentStates) {
       sessionMode: refreshData.agent.session_mode,
       framework: agentFrameworkCache.get(agent.code_name) ?? "openclaw",
       sessionHealthy: isSessionHealthy(agent.code_name),
-      channelSetRestartAlreadyScheduled: restartDecision.restart
+      channelSetRestartAlreadyScheduled: channelSetRestartScheduled
     }) : { restart: false, firstPoll: prevSenderPolicyHash === void 0, changed: false };
     if (senderPolicyDecision.restart) {
       log(
@@ -5328,18 +5539,18 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join6(homedir4(), ".augmented", agent.code_name, "project");
+      const projectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
       mkdirSync4(agentProvisionDir, { recursive: true });
       mkdirSync4(projectDir, { recursive: true });
-      const provisionMcpPath = join6(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join6(projectDir, ".mcp.json");
+      const provisionMcpPath = join7(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join7(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync7(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync8(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join6(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join7(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -5366,7 +5577,7 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join6(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join7(projectDir, ".mcp-channels.json");
       if (existsSync5(staleChannelsPath)) {
         try {
           rmSync2(staleChannelsPath, { force: true });
@@ -5431,7 +5642,7 @@ async function processAgent(agent, agentStates) {
     }
     if (process.env.AGT_CONNECTIVITY_PROBE_ENABLED === "true") {
       try {
-        const probeProjectDir = join6(homedir4(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -5441,11 +5652,11 @@ async function processAgent(agent, agentStates) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join6(homedir4(), ".augmented", agent.code_name, "project");
-        const envIntPath = join6(projectDir, ".env.integrations");
+        const projectDir = join7(homedir4(), ".augmented", agent.code_name, "project");
+        const envIntPath = join7(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync7(envIntPath, "utf-8");
+          preWriteEnv = readFileSync8(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -5457,9 +5668,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join6(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync7(envIntPath, "utf-8");
-            const mcpContent = readFileSync7(projectMcpPath, "utf-8");
+            const projectMcpPath = join7(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync8(envIntPath, "utf-8");
+            const mcpContent = readFileSync8(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -5527,8 +5738,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync8 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync8(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync9 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync9(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
                     "composio_",
@@ -5624,7 +5835,7 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join6(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        const pluginPath = join7(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
         if (existsSync5(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
@@ -5695,14 +5906,14 @@ async function processAgent(agent, agentStates) {
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join6(homedir5(), ".augmented", agent.code_name, "skills"),
+          join7(homedir5(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join6(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join7(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join6(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
+          join7(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join6(agentDir, ".claude", "skills")
+          join7(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync5(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
@@ -5718,7 +5929,7 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join6(dir, entry);
+            const p = join7(dir, entry);
             if (existsSync5(p)) {
               rmSync3(p, { recursive: true, force: true });
             }
@@ -5880,8 +6091,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join6(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync7(mcpPath, "utf-8"));
+        const mcpPath = join7(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync8(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -5952,6 +6163,37 @@ async function processAgent(agent, agentStates) {
               `[mcp-presence-reaper] failed to record restart event for '${codeName}' (ENG-5286): ${err.message} \u2014 local restart still proceeded; CloudWatch metric will under-count this event`
             );
           });
+        },
+        // ENG-5932: classify each declared key for the quarantine path. Reads a
+        // server-declared criticality field off the .mcp.json entry when
+        // present (Slice 2 will stamp it); otherwise fails closed to ESSENTIAL
+        // for everything except the known optional channel set. Tool servers
+        // (composio_*/xero) classify ESSENTIAL here and stay on the existing
+        // managed-toolkit onGiveUp path above.
+        classifyKey: (serverKey) => classifyChannelCriticality(
+          serverKey,
+          mcpJsonParsed?.mcpServers?.[serverKey]
+        ),
+        quarantineDwellMs: channelQuarantineDwellMs(),
+        quarantineMode: channelQuarantineMode(),
+        // ENG-5932: enforce-mode quarantine. Persist the local marker; the next
+        // provisioning poll then omits the channel from .mcp.json + the launch
+        // flags, and the channel-set-change / .mcp.json-drift restart paths are
+        // taught to NOT bounce the session for a quarantine-driven removal.
+        // Local-authoritative: no API call — with the control plane down, the
+        // flap still stops.
+        onQuarantine: (codeName, serverKey) => {
+          const newly = channelQuarantineStore().quarantine(
+            codeName,
+            serverKey,
+            `mcp-presence-reaper: optional channel dead past restart budget + dwell`,
+            Date.now()
+          );
+          if (newly) {
+            log(
+              `[channel-quarantine] persisted quarantine marker for '${codeName}:${serverKey}' \u2014 will be dropped from .mcp.json on next provisioning poll (ENG-5932)`
+            );
+          }
         }
       });
     } catch (err) {
@@ -6035,10 +6277,10 @@ async function processAgent(agent, agentStates) {
         lastWorkTriggerAt.set(agent.code_name, triggerTs);
         if (agentFw === "openclaw" && gatewayRunning && gatewayPort) {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const jobsPath = join6(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          const jobsPath = join7(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
           if (existsSync5(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync7(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync8(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -6175,7 +6417,7 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
   if (trackedFiles.length > 0 && existsSync5(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join6(agentDir, file));
+      const h = hashFile(join7(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -6209,19 +6451,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join6(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join7(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join6(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join7(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join6(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join7(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join6(sessionsDir, "sessions.json");
+  const indexPath = join7(sessionsDir, "sessions.json");
   if (!existsSync5(indexPath)) return;
   try {
-    const raw = readFileSync7(indexPath, "utf-8");
+    const raw = readFileSync8(indexPath, "utf-8");
     const index = JSON.parse(raw);
     const cronRunKeys = Object.keys(index).filter((k) => k.includes(":cron:") && k.includes(":run:")).map((k) => ({
       key: k,
@@ -6234,7 +6476,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join6(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join7(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
           if (existsSync5(sessionFile)) {
             unlinkSync(sessionFile);
@@ -6256,7 +6498,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join6(sessionsDir, `${parentSessionId}.jsonl`);
+            const f = join7(sessionsDir, `${parentSessionId}.jsonl`);
             if (existsSync5(f)) {
               unlinkSync(f);
               deletedFiles++;
@@ -6277,7 +6519,7 @@ var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
   if (!existsSync5(jobsPath)) return;
   try {
-    const raw = readFileSync7(jobsPath, "utf-8");
+    const raw = readFileSync8(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
@@ -6314,7 +6556,7 @@ function cleanupOldFiles(dir, maxAgeDays, ext) {
   try {
     for (const f of readdirSync3(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join6(dir, f);
+      const fullPath = join7(dir, f);
       try {
         const st = statSync2(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -6334,7 +6576,7 @@ var inFlightClaudeTasks = /* @__PURE__ */ new Set();
 var claudeTaskConcurrency = /* @__PURE__ */ new Map();
 var MAX_CLAUDE_CONCURRENCY = 2;
 function claudePidFilePath() {
-  return join6(homedir4(), ".augmented", "manager-claude-pids.json");
+  return join7(homedir4(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -6642,7 +6884,7 @@ async function fireScheduledTaskViaKanban(codeName, agentId, task, prompt) {
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join6(projectDir, ".mcp.json");
+  const mcpConfigPath = join7(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -6650,11 +6892,11 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join6(projectDir, "CLAUDE.md");
+    const claudeMdPath = join7(projectDir, "CLAUDE.md");
     const serverNames = [];
     if (existsSync5(mcpConfigPath)) {
       try {
-        const d = JSON.parse(readFileSync7(mcpConfigPath, "utf-8"));
+        const d = JSON.parse(readFileSync8(mcpConfigPath, "utf-8"));
         if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
       } catch {
       }
@@ -6677,10 +6919,10 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join6(projectDir, ".env.integrations");
+    const envIntPath = join7(projectDir, ".env.integrations");
     if (existsSync5(envIntPath)) {
       try {
-        for (const line of readFileSync7(envIntPath, "utf-8").split("\n")) {
+        for (const line of readFileSync8(envIntPath, "utf-8").split("\n")) {
           if (!line || line.startsWith("#") || !line.includes("=")) continue;
           const eqIdx = line.indexOf("=");
           childEnv[line.slice(0, eqIdx)] = line.slice(eqIdx + 1);
@@ -6849,8 +7091,8 @@ var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join6(projectDir, ".mcp.json");
-  const claudeMdPath = join6(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join7(projectDir, ".mcp.json");
+  const claudeMdPath = join7(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -6869,7 +7111,9 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const channels = [];
   const devChannels = [];
   if (channelConfigs) {
+    const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(codeName);
     const isChannelEnabled = (id) => {
+      if (quarantinedChannels.has(id)) return false;
       const entry = channelConfigs[id];
       return !!entry?.config && (entry.status === "active" || entry.status === "pending");
     };
@@ -7471,11 +7715,11 @@ ${escapeXml(msg.content)}
     if (fw === "claude-code") {
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-EM24LTGV.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join6(projDir, ".mcp.json");
+      const mcpConfigPath = join7(projDir, ".mcp.json");
       const serverNames = [];
       if (existsSync5(mcpConfigPath)) {
         try {
-          const d = JSON.parse(readFileSync7(mcpConfigPath, "utf-8"));
+          const d = JSON.parse(readFileSync8(mcpConfigPath, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -7494,15 +7738,15 @@ ${escapeXml(msg.content)}
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join6(projDir, "CLAUDE.md");
+      const chatClaudeMd = join7(projDir, "CLAUDE.md");
       if (existsSync5(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join6(projDir, ".env.integrations");
+      const envIntPath = join7(projDir, ".env.integrations");
       const childEnv = { ...process.env };
       if (existsSync5(envIntPath)) {
         try {
-          for (const line of readFileSync7(envIntPath, "utf-8").split("\n")) {
+          for (const line of readFileSync8(envIntPath, "utf-8").split("\n")) {
             if (!line || line.startsWith("#") || !line.includes("=")) continue;
             const eqIdx = line.indexOf("=");
             childEnv[line.slice(0, eqIdx)] = line.slice(eqIdx + 1);
@@ -7875,12 +8119,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join6(process.cwd(), "skills", skillId, "SKILL.md"),
-      join6(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join7(process.cwd(), "skills", skillId, "SKILL.md"),
+      join7(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync5(candidate)) {
-        const content = readFileSync7(candidate, "utf-8");
+        const content = readFileSync8(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -8833,8 +9077,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join6(configDir, agent.code_name, "project");
-  const memoryDir = join6(projectDir, "memory");
+  const projectDir = join7(configDir, agent.code_name, "project");
+  const memoryDir = join7(projectDir, "memory");
   const isFreshSync = pendingFreshMemorySync.has(agent.agent_id);
   if (isFreshSync) {
     log2(`[memory-sync] Fresh-sync requested for '${agent.code_name}' \u2014 pulling DB first`);
@@ -8852,7 +9096,7 @@ async function syncMemories(agent, configDir, log2) {
     for (const file of readdirSync3(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync7(join6(memoryDir, file), "utf-8");
+        const raw = readFileSync8(join7(memoryDir, file), "utf-8");
         const fileHash = createHash3("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -8877,7 +9121,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync7(join6(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync8(join7(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -8912,7 +9156,7 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join6(memoryDir, `${slug}.md`);
+        const filePath = join7(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -8924,7 +9168,7 @@ ${mem.content}
         if (existsSync5(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync7(filePath, "utf-8");
+            existing = readFileSync8(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
@@ -9138,7 +9382,7 @@ function startManager(opts) {
   try {
     const stateFile = getStateFile();
     if (existsSync5(stateFile)) {
-      const raw = readFileSync7(stateFile, "utf-8");
+      const raw = readFileSync8(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state4.agents = parsed.agents;
@@ -9154,7 +9398,7 @@ function startManager(opts) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);
   }
   log(
-    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join6(homedir4(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join7(homedir4(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -9175,7 +9419,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync7(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync8(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -9285,14 +9529,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join6(homedir4(), ".augmented", "_mcp");
+  const targetDir = join7(homedir4(), ".augmented", "_mcp");
   mkdirSync4(targetDir, { recursive: true });
   const moduleDir = dirname3(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join6(dir, "dist", "mcp");
-    if (existsSync5(join6(candidate, "index.js"))) {
+    const candidate = join7(dir, "dist", "mcp");
+    if (existsSync5(join7(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -9308,7 +9552,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync5(p)) return null;
-      return createHash3("sha256").update(readFileSync7(p)).digest("hex");
+      return createHash3("sha256").update(readFileSync8(p)).digest("hex");
     } catch {
       return null;
     }
@@ -9319,8 +9563,8 @@ function deployMcpAssets() {
     "telegram-channel.js"
   ]);
   for (const file of ["index.js", "slack-channel.js", "direct-chat-channel.js", "telegram-channel.js"]) {
-    const src = join6(mcpSourceDir, file);
-    const dst = join6(targetDir, file);
+    const src = join7(mcpSourceDir, file);
+    const dst = join7(targetDir, file);
     if (!existsSync5(src)) continue;
     const before = fileHash(dst);
     try {
@@ -9338,16 +9582,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join6(targetDir, "index.js");
+  const localMcpPath = join7(targetDir, "index.js");
   try {
-    const agentsDir = join6(homedir4(), ".augmented", "agents");
+    const agentsDir = join7(homedir4(), ".augmented", "agents");
     if (existsSync5(agentsDir)) {
       for (const entry of readdirSync3(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join6(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join7(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync7(mcpJsonPath, "utf-8");
+            const raw = readFileSync8(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];