@integrity-labs/agt-cli 0.23.1 → 0.24.0

package/dist/lib/manager-worker.js

@@ -1,6 +1,7 @@
 import {
   SUPERVISOR_RESTART_EXIT_CODE,
   api,
+  estimateActiveTasksTokens,
   exchangeApiKey,
   extractCommandNotFound,
   getApiKey,
@@ -11,7 +12,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-Q4QD3TAC.js";
+} from "../chunk-WZTRMJM4.js";
 import {
   findTaskByTemplate,
   getProjectDir as getProjectDir2,
@@ -46,7 +47,7 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   takeZombieDetection
-} from "../chunk-TCCBS3PD.js";
+} from "../chunk-ZKQGDH3T.js";
 import {
   KANBAN_CHECK_COMMAND,
   appendDmFooter,
@@ -62,15 +63,15 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-2TOCO5D2.js";
+} from "../chunk-HSIESZMZ.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, existsSync as existsSync3, rmSync as rmSync2, readdirSync as readdirSync2, statSync, unlinkSync, copyFileSync } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, existsSync as existsSync4, rmSync as rmSync2, readdirSync as readdirSync2, statSync, unlinkSync, copyFileSync } from "fs";
 import https from "https";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join4, dirname } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join5, dirname } from "path";
+import { homedir as homedir4 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/mcp-config-drift.ts
@@ -434,12 +435,12 @@ function reapMissingMcpSessions(args) {
     if (!missingRaw.includes(key)) liveKeys.add(key);
   }
   for (const key of liveKeys) {
-    const state3 = presenceReaperState.get(stateKey(codeName, key));
-    if (state3) {
-      state3.attempts = 0;
-      state3.lastSeenLiveAt = now();
-      state3.lastAttemptedSessionStartedAt = null;
-      state3.gaveUpLogged = false;
+    const state4 = presenceReaperState.get(stateKey(codeName, key));
+    if (state4) {
+      state4.attempts = 0;
+      state4.lastSeenLiveAt = now();
+      state4.lastAttemptedSessionStartedAt = null;
+      state4.gaveUpLogged = false;
     }
   }
   if (missing.length === 0) {
@@ -454,24 +455,24 @@ function reapMissingMcpSessions(args) {
   const active = [];
   for (const key of missing) {
     const sk = stateKey(codeName, key);
-    const state3 = presenceReaperState.get(sk) ?? {
+    const state4 = presenceReaperState.get(sk) ?? {
       attempts: 0,
       lastSeenLiveAt: null,
       lastAttemptedSessionStartedAt: null,
       gaveUpLogged: false
     };
-    if (state3.lastAttemptedSessionStartedAt !== sessionStartedAt) {
-      state3.attempts += 1;
-      state3.lastAttemptedSessionStartedAt = sessionStartedAt;
+    if (state4.lastAttemptedSessionStartedAt !== sessionStartedAt) {
+      state4.attempts += 1;
+      state4.lastAttemptedSessionStartedAt = sessionStartedAt;
     }
-    presenceReaperState.set(sk, state3);
-    if (state3.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
+    presenceReaperState.set(sk, state4);
+    if (state4.attempts > MAX_PRESENCE_RESTART_ATTEMPTS) {
       givenUp.push(key);
-      if (!state3.gaveUpLogged) {
+      if (!state4.gaveUpLogged) {
         log2(
           `[mcp-presence-reaper] giving up on '${codeName}:${key}' after ${MAX_PRESENCE_RESTART_ATTEMPTS} consecutive failed restarts \u2014 declared but never recovers (likely orphaned config; see ENG-5279)`
         );
-        state3.gaveUpLogged = true;
+        state4.gaveUpLogged = true;
         if (onGiveUp) {
           try {
             onGiveUp(codeName, key);
@@ -552,6 +553,108 @@ function decideChannelRestart(input) {
   return { restart: true, added, removed };
 }
 
+// src/lib/restart-breaker.ts
+var DEFAULT_MAX = 2;
+var DEFAULT_WINDOW_MS = 6e5;
+function readEnvNumber(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var RestartBreaker = class {
+  max;
+  windowMs;
+  now;
+  events = /* @__PURE__ */ new Map();
+  trips = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.max = opts.max ?? readEnvNumber("AGT_RESTART_BREAKER_MAX", DEFAULT_MAX);
+    this.windowMs = opts.windowMs ?? readEnvNumber("AGT_RESTART_BREAKER_WINDOW_MS", DEFAULT_WINDOW_MS);
+    this.now = opts.now ?? Date.now;
+    if (!Number.isFinite(this.max) || this.max < 1) {
+      throw new Error("restart-breaker max must be a finite number >= 1");
+    }
+    if (!Number.isFinite(this.windowMs) || this.windowMs < 1e3) {
+      throw new Error("restart-breaker windowMs must be a finite number >= 1000");
+    }
+  }
+  /** True if this agent's breaker is currently tripped (manager must skip spawn). */
+  isTripped(codeName) {
+    return this.trips.has(codeName);
+  }
+  getTrip(codeName) {
+    return this.trips.get(codeName);
+  }
+  /**
+   * Record a restart event. If recording this event puts the count
+   * inside the window above `max`, the breaker trips and the call site
+   * should NOT respawn.
+   *
+   * Idempotent on already-tripped breakers: returns the existing trip
+   * without double-counting events. Callers may still record the reason
+   * via the decision-log for forensics.
+   */
+  record(codeName, reason) {
+    const existing = this.trips.get(codeName);
+    if (existing) {
+      return { tripped: false, trip: existing, windowCount: existing.eventsAtTrip.length };
+    }
+    const at = this.now();
+    const cutoff = at - this.windowMs;
+    const prior = (this.events.get(codeName) ?? []).filter((e) => e.at >= cutoff);
+    prior.push({ reason, at });
+    this.events.set(codeName, prior);
+    if (prior.length > this.max) {
+      const trip = {
+        trippedAt: at,
+        eventsAtTrip: [...prior],
+        statusMessage: formatStatusMessage(prior, this.windowMs)
+      };
+      this.trips.set(codeName, trip);
+      this.events.delete(codeName);
+      return { tripped: true, trip, windowCount: prior.length };
+    }
+    return { tripped: false, windowCount: prior.length };
+  }
+  /** Operator-initiated reset: drops the trip + the events log for this agent. */
+  clear(codeName) {
+    this.trips.delete(codeName);
+    this.events.delete(codeName);
+  }
+  /** Snapshot tripped agents for `manager-state.json`. */
+  serialize() {
+    return Object.fromEntries(this.trips.entries());
+  }
+  /**
+   * Rehydrate trip state from `manager-state.json`. Called once at
+   * worker startup. Window history is intentionally NOT persisted — only
+   * tripped state. A tripped breaker survives manager restart; an
+   * un-tripped one starts a fresh window in the new worker.
+   */
+  hydrate(saved) {
+    if (!saved) return;
+    for (const [codeName, trip] of Object.entries(saved)) {
+      if (trip && typeof trip.trippedAt === "number" && Array.isArray(trip.eventsAtTrip)) {
+        this.trips.set(codeName, trip);
+      }
+    }
+  }
+  /** Test helper — current in-window event count for `codeName`. */
+  windowCount(codeName) {
+    const cutoff = this.now() - this.windowMs;
+    return (this.events.get(codeName) ?? []).filter((e) => e.at >= cutoff).length;
+  }
+};
+function formatStatusMessage(events, windowMs) {
+  const last = events[events.length - 1];
+  const windowLabel = windowMs < 6e4 ? `${Math.round(windowMs / 1e3)}s` : `${(windowMs / 6e4).toFixed(1).replace(/\.0$/, "")}min`;
+  const reasonCounts = /* @__PURE__ */ new Map();
+  for (const e of events) reasonCounts.set(e.reason, (reasonCounts.get(e.reason) ?? 0) + 1);
+  const breakdown = Array.from(reasonCounts.entries()).map(([r, n]) => `${r}=${n}`).join(", ");
+  return `Circuit breaker tripped: ${events.length} restarts in ${windowLabel} (${breakdown}); most recent=${last.reason} at ${new Date(last.at).toISOString()}`;
+}
+
 // src/lib/usage-banner-monitor.ts
 var MIN_CHECK_INTERVAL_MS = 6e4;
 var PANE_TAIL_LINES_FOR_BANNER = 200;
@@ -607,6 +710,79 @@ async function maybeReportUsageBanner(args) {
   }
 }
 
+// src/lib/activity-cache-monitor.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var MIN_CHECK_INTERVAL_MS2 = 6e4;
+var STATS_CACHE_PATH = join(homedir(), ".claude", "stats-cache.json");
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var state2 = { lastObservedDate: null, lastCheckedAt: 0 };
+function selectNewDailyRows(raw, lastObservedDate) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const days = Array.isArray(parsed.dailyActivity) ? parsed.dailyActivity : [];
+  const nonNegInt = (v) => {
+    if (typeof v !== "number" || !Number.isFinite(v)) return null;
+    const n = Math.trunc(v);
+    return n >= 0 ? n : null;
+  };
+  const result = [];
+  for (const d of days) {
+    if (typeof d.date !== "string" || !ISO_DATE_RE.test(d.date)) continue;
+    if (lastObservedDate !== null && d.date <= lastObservedDate) continue;
+    const m = nonNegInt(d.messageCount);
+    const s = nonNegInt(d.sessionCount);
+    const t = nonNegInt(d.toolCallCount);
+    if (m === null || s === null || t === null) continue;
+    const breakdownForDay = parsed.dailyModelTokens?.[d.date];
+    const model_breakdown = breakdownForDay && typeof breakdownForDay === "object" && !Array.isArray(breakdownForDay) ? breakdownForDay : null;
+    result.push({
+      date: d.date,
+      message_count: m,
+      session_count: s,
+      tool_call_count: t,
+      model_breakdown
+    });
+  }
+  result.sort((a, b) => a.date.localeCompare(b.date));
+  return result;
+}
+async function maybeReportActivityCache(args) {
+  const { api: api2, log: log2 } = args;
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  if (nowMs - state2.lastCheckedAt < MIN_CHECK_INTERVAL_MS2) return;
+  state2.lastCheckedAt = nowMs;
+  if (!existsSync(STATS_CACHE_PATH)) {
+    return;
+  }
+  let raw;
+  try {
+    raw = readFileSync(STATS_CACHE_PATH, "utf-8");
+  } catch (err) {
+    log2(`[activity-cache] readFileSync failed: ${err.message}`);
+    return;
+  }
+  const rows = selectNewDailyRows(raw, state2.lastObservedDate);
+  if (rows.length === 0) return;
+  for (const row of rows) {
+    try {
+      await api2.post("/host/activity-observations", row);
+      state2.lastObservedDate = row.date;
+    } catch (err) {
+      log2(
+        `[activity-cache] POST /host/activity-observations failed for date=${row.date}: ${err.message}`
+      );
+      return;
+    }
+  }
+}
+
 // src/lib/poll-backoff.ts
 var POLL_BACKOFF_BASE_MS = 1e3;
 var POLL_BACKOFF_MAX_MS = 6e4;
@@ -1036,8 +1212,8 @@ var GatewayClientPool = class extends EventEmitter {
 
 // src/lib/claude-auth-detect.ts
 import { readFile, readdir } from "fs/promises";
-import { homedir, platform } from "os";
-import { join } from "path";
+import { homedir as homedir2, platform } from "os";
+import { join as join2 } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -1052,8 +1228,8 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join(homedir(), ".claude", ".credentials.json"),
-    join(homedir(), ".claude", "credentials.json")
+    join2(homedir2(), ".claude", ".credentials.json"),
+    join2(homedir2(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
@@ -1061,8 +1237,8 @@ async function findClaudeCredentialsPaths() {
       const entries = await readdir("/home", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        candidates.push(join("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join2("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join2("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -1154,18 +1330,18 @@ function normalize(value) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join2(configDir, CACHE_FILENAME);
+  return join3(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
-  if (!existsSync(path)) return;
+  if (!existsSync2(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync(path, "utf-8"));
+    parsed = JSON.parse(readFileSync2(path, "utf-8"));
   } catch {
     return;
   }
@@ -1638,24 +1814,24 @@ function withScheduleLinkFooter(opts) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join3(homedir2(), ".augmented", "restart-flags");
+  return join4(homedir3(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join3(restartFlagsDir(), `${codeName}.flag`);
+  return join4(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync2(dir)) return [];
+  if (!existsSync3(dir)) return [];
   const out = [];
   for (const entry of readdirSync(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync2(join3(dir, entry), "utf8");
+      const raw = readFileSync3(join4(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -1673,7 +1849,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync2(path)) {
+  if (existsSync3(path)) {
     rmSync(path, { force: true });
   }
 }
@@ -2171,8 +2347,8 @@ function applyRestartAcks(args) {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join4(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join4(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join5(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join5(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;
@@ -2279,14 +2455,45 @@ var KNOWN_SAFE_TAIL_SIGNATURES = /* @__PURE__ */ new Set(["session_id_in_use"]);
 function shouldSkipRevokedCleanup(previousKnownStatus) {
   return previousKnownStatus === "revoked";
 }
-function hasRevokedResiduals(state3) {
-  return state3.gatewayRunning || state3.portAllocated || state3.provisionDirExists;
+function hasRevokedResiduals(state4) {
+  return state4.gatewayRunning || state4.portAllocated || state4.provisionDirExists;
 }
 var knownVersions = /* @__PURE__ */ new Map();
 var knownStatuses = /* @__PURE__ */ new Map();
 var knownChannels = /* @__PURE__ */ new Map();
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
-function scheduleSessionRestart(codeName, delayMs, reason) {
+var restartBreaker = new RestartBreaker();
+var reportedTrips = /* @__PURE__ */ new Map();
+function recordRestartForBreaker(codeName, reason) {
+  const result = restartBreaker.record(codeName, reason);
+  if (!result.tripped || !result.trip) return;
+  const trip = result.trip;
+  log(
+    `[persistent-session-decision] agent=${codeName} decision=circuit-tripped detail=${JSON.stringify(trip.statusMessage)} (ENG-5441)`
+  );
+  maybeReportCurrentTrip(codeName);
+}
+async function reportCircuitTripped(codeName, trip) {
+  if (reportedTrips.get(codeName) === trip.trippedAt) return;
+  const agentId = codeNameToAgentId.get(codeName);
+  if (!agentId) throw new Error(`no agent_id known yet for '${codeName}' \u2014 will retry next poll`);
+  await api.post("/host/circuit-breaker/trip", {
+    agent_id: agentId,
+    status_message: trip.statusMessage,
+    tripped_at: new Date(trip.trippedAt).toISOString(),
+    events: trip.eventsAtTrip.map((e) => ({ reason: e.reason, at: new Date(e.at).toISOString() }))
+  });
+  reportedTrips.set(codeName, trip.trippedAt);
+}
+function maybeReportCurrentTrip(codeName) {
+  const trip = restartBreaker.getTrip(codeName);
+  if (!trip) return;
+  if (reportedTrips.get(codeName) === trip.trippedAt) return;
+  reportCircuitTripped(codeName, trip).catch((err) => {
+    log(`[circuit-breaker] Failed to report trip for '${codeName}' to API: ${err.message}`);
+  });
+}
+function scheduleSessionRestart(codeName, delayMs, reason, breakerReason = "hot-reload-mcp") {
   const existing = pendingSessionRestarts.get(codeName);
   if (existing) {
     clearTimeout(existing);
@@ -2296,6 +2503,7 @@ function scheduleSessionRestart(codeName, delayMs, reason) {
     pendingSessionRestarts.delete(codeName);
     stopPersistentSession(codeName, log);
     runningMcpHashes.delete(codeName);
+    recordRestartForBreaker(codeName, breakerReason);
     log(`[hot-reload] Session stopped for '${codeName}' \u2014 will respawn with ${reason}`);
   }, delayMs);
   timer.unref?.();
@@ -2314,7 +2522,7 @@ var runningMcpHashes = /* @__PURE__ */ new Map();
 var runningMcpServerKeys = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync3(join4(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync4(join5(projectDir, ".mcp.json"), "utf-8");
     return createHash2("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -2322,7 +2530,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync3(join4(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync4(join5(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -2331,11 +2539,14 @@ function projectMcpKeys(_codeName, projectDir) {
     return null;
   }
 }
-function stopPersistentSessionAndForgetMcpBaseline(codeName) {
+function stopPersistentSessionAndForgetMcpBaseline(codeName, breakerReason) {
   cancelPendingSessionRestart(codeName);
   stopPersistentSession(codeName, log);
   runningMcpHashes.delete(codeName);
   runningMcpServerKeys.delete(codeName);
+  if (breakerReason) {
+    recordRestartForBreaker(codeName, breakerReason);
+  }
 }
 function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
   const currentHash = projectMcpHash(codeName, projectDir);
@@ -2416,7 +2627,7 @@ var codeNameToAgentId = /* @__PURE__ */ new Map();
 var agentChannelTokens = /* @__PURE__ */ new Map();
 var activeChannels = /* @__PURE__ */ new Map();
 var gatewaysStartedThisCycle = /* @__PURE__ */ new Set();
-var state2 = {
+var state3 = {
   pid: process.pid,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   lastPollAt: null,
@@ -2450,6 +2661,7 @@ function clearAgentCaches(agentId, codeName) {
   lastHarvestAt.delete(codeName);
   claudeSchedulerStates.delete(codeName);
   claudeTaskConcurrency.delete(codeName);
+  lastMcpFailedBannerCount.delete(codeName);
   memoryFileHashes.delete(agentId);
   lastDownloadHash.delete(agentId);
   lastLocalFileHash.delete(agentId);
@@ -2472,7 +2684,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.23.1" : "dev";
+var agtCliVersion = true ? "0.24.0" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -2485,7 +2697,7 @@ function resolveBrewPath(execFileSync4) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync3(path)) return path;
+    if (existsSync4(path)) return path;
   }
   return null;
 }
@@ -2495,7 +2707,7 @@ function claudeBinaryInstalled(execFileSync4) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync3(path))) return true;
+  if (canonical.some((path) => existsSync4(path))) return true;
   try {
     execFileSync4("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -2677,7 +2889,7 @@ async function ensureFrameworkBinary(frameworkId) {
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync3("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync4("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -2689,7 +2901,7 @@ async function ensureFrameworkBinary(frameworkId) {
 var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var claudeCodeUpgradeInFlight = false;
 function claudeCodeUpgradeMarkerPath() {
-  return join4(homedir3(), ".augmented", ".last-claude-code-upgrade-check");
+  return join5(homedir4(), ".augmented", ".last-claude-code-upgrade-check");
 }
 function stampClaudeCodeUpgradeMarker() {
   try {
@@ -2699,7 +2911,7 @@ function stampClaudeCodeUpgradeMarker() {
 }
 function claudeCodeUpgradeThrottled() {
   try {
-    const lastCheck = parseInt(readFileSync3(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
+    const lastCheck = parseInt(readFileSync4(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
     if (!Number.isFinite(lastCheck)) return false;
     return Date.now() - lastCheck < CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS;
   } catch {
@@ -2769,7 +2981,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 = join4(homedir3(), ".augmented", ".last-update-check");
+    const markerPath = join5(homedir4(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -2834,17 +3046,18 @@ async function checkAndUpdateCliViaBrew() {
 async function checkAndUpdateCliViaNpm() {
   const { execFileSync: execFileSync4 } = await import("child_process");
   if (agtCliVersion === "dev") return;
+  const channel = process.env.AGT_CLI_RELEASE_CHANNEL || "latest";
   let latest;
   try {
     const res = await fetch(
-      "https://registry.npmjs.org/@integrity-labs/agt-cli/latest",
+      `https://registry.npmjs.org/@integrity-labs/agt-cli/${encodeURIComponent(channel)}`,
       {
         signal: AbortSignal.timeout(1e4),
         headers: { Accept: "application/json" }
       }
     );
     if (!res.ok) {
-      log(`[self-update] npm registry returned ${res.status}`);
+      log(`[self-update] npm registry returned ${res.status} (channel=${channel})`);
       return;
     }
     const body = await res.json();
@@ -2857,14 +3070,15 @@ async function checkAndUpdateCliViaNpm() {
     log(`[self-update] npm registry fetch failed: ${err.message}`);
     return;
   }
-  if (!isNewerSemver(agtCliVersion, latest)) {
+  const shouldUpdate = channel === "latest" ? isNewerSemver(agtCliVersion, latest) : latest !== agtCliVersion;
+  if (!shouldUpdate) {
     if (!selfUpdateUpToDateLogged) {
-      log(`[self-update] agt CLI is up to date (npm, ${agtCliVersion})`);
+      log(`[self-update] agt CLI is up to date (npm, channel=${channel}, ${agtCliVersion})`);
       selfUpdateUpToDateLogged = true;
     }
     return;
   }
-  log(`[self-update] agt CLI update available: ${agtCliVersion} \u2192 ${latest}. Upgrading via npm...`);
+  log(`[self-update] agt CLI update available: ${agtCliVersion} \u2192 ${latest} (channel=${channel}). Upgrading via npm...`);
   const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
   const cmd = isRoot ? "npm" : "sudo";
   const args = isRoot ? [
@@ -2931,10 +3145,10 @@ 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 = join4(homedir3(), ".claude");
+    const claudeDir = join5(homedir4(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join4(claudeDir, filename);
-      if (existsSync3(p)) {
+      const p = join5(claudeDir, filename);
+      if (existsSync4(p)) {
         try {
           rmSync2(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -2948,7 +3162,7 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync3(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync4(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
@@ -2978,10 +3192,10 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join4(config?.configDir ?? join4(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join5(config?.configDir ?? join5(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join4(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join5(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(knownChannelConfigHashes, channelHashCacheDir());
@@ -3023,9 +3237,9 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join4(homedir3(), ".augmented", "manager.log");
+      managerLogPath = join5(homedir4(), ".augmented", "manager.log");
       mkdirSync2(dirname(managerLogPath), { recursive: true });
-      if (existsSync3(managerLogPath)) {
+      if (existsSync4(managerLogPath)) {
         chmodSync(managerLogPath, 384);
       }
     } catch {
@@ -3053,7 +3267,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync4(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -3078,12 +3292,12 @@ function parseSkillFrontmatter(content) {
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
   const { readdirSync: readdirSync3, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync4 } = await import("fs");
-  const skillsDir = join4(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join4(configDir, codeName, "project", "CLAUDE.md");
+  const skillsDir = join5(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join5(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync3(skillsDir).sort()) {
-    const skillFile = join4(skillsDir, dir, "SKILL.md");
+    const skillFile = join5(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -3131,10 +3345,10 @@ ${SKILLS_INDEX_END}`;
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join4(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join5(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync3(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync4(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -3147,19 +3361,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join4(homeDir, `.openclaw-${codeName}`);
-    if (existsSync3(join4(profileDir, "openclaw.json"))) continue;
+    const profileDir = join5(homeDir, `.openclaw-${codeName}`);
+    if (existsSync4(join5(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join4(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join4(profileDir, "agents", codeName, "agent");
-    const authFile = join4(sharedAuthDir, "auth-profiles.json");
-    if (existsSync3(authFile)) {
+    const sharedAuthDir = join5(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join5(profileDir, "agents", codeName, "agent");
+    const authFile = join5(sharedAuthDir, "auth-profiles.json");
+    if (existsSync4(authFile)) {
       mkdirSync2(profileAuthDir, { recursive: true });
-      const authContent = readFileSync3(authFile, "utf-8");
-      writeFileSync3(join4(profileAuthDir, "auth-profiles.json"), authContent);
+      const authContent = readFileSync4(authFile, "utf-8");
+      writeFileSync3(join5(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -3197,7 +3411,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync3(join4(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync4(join5(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -3206,18 +3420,18 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
-  if (!existsSync3(jobsPath)) return false;
+  const jobsPath = join5(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  if (!existsSync4(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync3(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync4(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
     for (const job of jobs) {
-      const state3 = job.state;
-      if (!state3) continue;
-      const runStartedAt = state3.runStartedAtMs;
-      const isRunning = state3.status === "running" || state3.running === true;
+      const state4 = job.state;
+      if (!state4) continue;
+      const runStartedAt = state4.runStartedAtMs;
+      const isRunning = state4.status === "running" || state4.running === true;
       if (isRunning && runStartedAt && now - runStartedAt > GATEWAY_HUNG_TIMEOUT_MS) {
         return true;
       }
@@ -3242,15 +3456,15 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join5(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join4(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-          if (existsSync3(configPath)) {
-            const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
+          const configPath = join5(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          if (existsSync4(configPath)) {
+            const cfg = JSON.parse(readFileSync4(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
@@ -3274,9 +3488,9 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join4(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-      if (existsSync3(configPath)) {
-        const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
+      const configPath = join5(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      if (existsSync4(configPath)) {
+        const cfg = JSON.parse(readFileSync4(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
         writeFileSync3(configPath, JSON.stringify(cfg, null, 2));
@@ -3368,7 +3582,7 @@ async function pollCycle() {
       log,
       resolveFramework: (codeName) => agentFrameworkCache.get(codeName) ?? null,
       stopSession: (codeName) => {
-        stopPersistentSessionAndForgetMcpBaseline(codeName);
+        stopPersistentSessionAndForgetMcpBaseline(codeName, "channel-set-change");
         persistentSessionAgents.delete(codeName);
         claudeAuthTupleBySession.delete(codeName);
       },
@@ -3418,7 +3632,7 @@ async function pollCycle() {
     const now = Date.now();
     if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
       try {
-        const firstAgent = state2.agents[0];
+        const firstAgent = state3.agents[0];
         const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework("openclaw");
         if (versionAdapter.getVersion) {
           cachedFrameworkVersion = await versionAdapter.getVersion();
@@ -3429,7 +3643,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-XEA4SPAN.js");
+      const { collectDiagnostics } = await import("../persistent-session-L4YIJJML.js");
       const diagCodeNames = [...persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
       let tailscaleHostname;
@@ -3480,7 +3694,7 @@ async function pollCycle() {
       const {
         collectResponsivenessProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-VWPOCABI.js");
+      } = await import("../responsiveness-probe-YRLESO54.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...persistentSessionAgents];
@@ -3497,13 +3711,50 @@ async function pollCycle() {
     } catch (err) {
       log(`[responsiveness-probe] collection failed: ${err.message}`);
     }
+    try {
+      const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-JA437JIB.js");
+      const observations = [];
+      const pendingCacheCommits = [];
+      for (const codeName of persistentSessionAgents) {
+        const agentId = codeNameToAgentId.get(codeName);
+        if (!agentId) continue;
+        const tail = readPaneLogTail(codeName, 40);
+        if (!tail) continue;
+        const observed = scrapeMcpFailedBannerCount(tail);
+        const count = observed ?? 0;
+        const last = lastMcpFailedBannerCount.get(codeName);
+        if (last === count) continue;
+        observations.push({ agent_id: agentId, count });
+        pendingCacheCommits.push({ codeName, count });
+      }
+      if (observations.length > 0) {
+        void api.post(
+          "/host/mcp-banner-observation",
+          { observations }
+        ).then((resp) => {
+          const accepted = new Set(
+            (resp?.results ?? []).filter((r) => r.ok).map((r) => r.agent_id)
+          );
+          for (const { codeName, count } of pendingCacheCommits) {
+            const agentId = codeNameToAgentId.get(codeName);
+            if (agentId && accepted.has(agentId)) {
+              lastMcpFailedBannerCount.set(codeName, count);
+            }
+          }
+        }).catch((err) => {
+          log(`[mcp-banner] post failed: ${err.message}`);
+        });
+      }
+    } catch (err) {
+      log(`[mcp-banner] collection failed: ${err.message}`);
+    }
     const data = await api.post("/host/agents", { host_id: hostId });
     const agents = data.agents ?? [];
     const restartAcks = /* @__PURE__ */ new Map();
     for (const agent of agents) {
       const requested = agent.restart_requested_at ?? null;
       if (!requested) continue;
-      const prev = state2.agents.find((a) => a.agentId === agent.agent_id);
+      const prev = state3.agents.find((a) => a.agentId === agent.agent_id);
       const lastProcessed = prev?.lastRestartProcessedAt ?? null;
       if (lastProcessed && Date.parse(lastProcessed) >= Date.parse(requested)) continue;
       log(`[restart] Dashboard requested restart for '${agent.code_name}' at ${requested}`);
@@ -3526,7 +3777,7 @@ async function pollCycle() {
         await processAgent(agent, agentStates);
       } catch (err) {
         log(`Error processing agent '${agent.code_name}': ${err.message}`);
-        const existing = state2.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state3.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
         } else {
@@ -3549,14 +3800,15 @@ async function pollCycle() {
         }
       }
     }
+    void maybeReportActivityCache({ api, log });
     const restartAckStateChanged = applyRestartAcks({
       agentStates,
-      priorAgents: state2.agents,
+      priorAgents: state3.agents,
       restartAcks
     });
     if (restartAckStateChanged) {
       try {
-        const ackedState = { ...state2, agents: agentStates };
+        const ackedState = { ...state3, agents: agentStates };
         writeFileSync3(getStateFile(), JSON.stringify(ackedState, null, 2));
       } catch (err) {
         log(`[restart] failed to persist ack immediately: ${err.message}`);
@@ -3574,7 +3826,7 @@ async function pollCycle() {
     } catch {
     }
     const currentIds = new Set(agents.map((a) => a.agent_id));
-    for (const prev of state2.agents) {
+    for (const prev of state3.agents) {
       if (!currentIds.has(prev.agentId)) {
         log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
@@ -3587,7 +3839,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join4(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join5(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -3674,19 +3926,23 @@ async function pollCycle() {
       }
     } catch {
     }
-    state2 = {
-      ...state2,
+    state3 = {
+      ...state3,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pollCount: state2.pollCount + 1,
-      agents: agentStates
+      pollCount: state3.pollCount + 1,
+      agents: agentStates,
+      // ENG-5441: serialise trip state on every poll so manager restarts
+      // never silently clear a tripped breaker. Cheap — only tripped
+      // entries are stored, and the typical state is zero entries.
+      circuitBreakerTrips: restartBreaker.serialize()
     };
     if (consecutivePollFailures > 0) {
       log(`[poll-backoff] recovered after ${consecutivePollFailures} failure(s), resuming normal interval`);
       consecutivePollFailures = 0;
     }
-    send({ type: "state-update", state: state2 });
+    send({ type: "state-update", state: state3 });
   } catch (err) {
-    state2.errorCount++;
+    state3.errorCount++;
     const message = err.message;
     log(`Poll error: ${message}`);
     send({ type: "error", message });
@@ -3713,6 +3969,7 @@ async function processAgent(agent, agentStates) {
   const previousKnownStatus = knownStatuses.get(agent.agent_id);
   agentDisplayNames.set(agent.code_name, agent.display_name);
   codeNameToAgentId.set(agent.code_name, agent.agent_id);
+  maybeReportCurrentTrip(agent.code_name);
   if (agent.framework) {
     agentFrameworkCache.set(agent.code_name, agent.framework);
   }
@@ -3726,7 +3983,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join4(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join5(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`);
@@ -3765,7 +4022,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: gatewayLiveness.running,
         portAllocated: Object.prototype.hasOwnProperty.call(ports, agent.code_name),
-        provisionDirExists: existsSync3(agentDir)
+        provisionDirExists: existsSync4(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -3825,6 +4082,11 @@ async function processAgent(agent, agentStates) {
   if (previousStatus && previousStatus !== agent.status) {
     log(`Agent '${agent.code_name}' status changed: ${previousStatus} \u2192 ${agent.status}`);
     knownVersions.delete(agent.agent_id);
+    if (previousStatus === "paused" && agent.status === "active" && restartBreaker.isTripped(agent.code_name)) {
+      restartBreaker.clear(agent.code_name);
+      reportedTrips.delete(agent.code_name);
+      log(`[circuit-breaker] Cleared trip for '${agent.code_name}' on operator resume (paused \u2192 active)`);
+    }
     let channelCacheMutated = false;
     for (const key of knownChannelConfigHashes.keys()) {
       if (key.startsWith(`${agent.agent_id}:`)) {
@@ -3842,7 +4104,7 @@ async function processAgent(agent, agentStates) {
     });
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
-    const existing = state2.agents.find((a) => a.agentId === agent.agent_id);
+    const existing = state3.agents.find((a) => a.agentId === agent.agent_id);
     agentStates.push(existing ?? {
       agentId: agent.agent_id,
       codeName: agent.code_name,
@@ -3890,7 +4152,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join4(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join5(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.seedProfileConfig) {
     frameworkAdapter.seedProfileConfig(agent.code_name);
@@ -3898,7 +4160,7 @@ async function processAgent(agent, agentStates) {
   const charterVersion = refreshData.charter.version;
   const toolsVersion = refreshData.tools.version;
   const known = knownVersions.get(agent.agent_id);
-  let lastProvisionAt = state2.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  let lastProvisionAt = state3.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const currentChannelIds = launchableChannelIds(refreshData.channel_configs);
   const previousChannelIds = knownChannels.get(agent.agent_id);
   const channelsChanged = !previousChannelIds || currentChannelIds.size !== previousChannelIds.size || [...currentChannelIds].some((ch) => !previousChannelIds.has(ch)) || [...previousChannelIds].some((ch) => !currentChannelIds.has(ch));
@@ -3921,7 +4183,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync2(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join4(agentDir, artifact.relativePath);
+      const filePath = join5(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -3933,8 +4195,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join4(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync3(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join5(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync4(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -3952,7 +4214,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync3(filePath, "utf-8");
+          existingRaw = readFileSync4(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -3974,22 +4236,22 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync3(join4(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync4(join5(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 = join4(agentDir, file.relativePath);
+        const filePath = join5(agentDir, file.relativePath);
         mkdirSync2(dirname(filePath), { recursive: true });
         writeFileSync3(filePath, file.content);
       }
       try {
-        const provSkillsDir = join4(agentDir, ".claude", "skills");
-        if (existsSync3(provSkillsDir)) {
+        const provSkillsDir = join5(agentDir, ".claude", "skills");
+        if (existsSync4(provSkillsDir)) {
           for (const folder of readdirSync2(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync2(join4(provSkillsDir, folder), { recursive: true });
+                rmSync2(join5(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -4002,7 +4264,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join4(agentDir, file));
+        const h = hashFile(join5(agentDir, file));
         if (h) hashes.set(file, h);
       }
       writtenHashes.set(agent.agent_id, hashes);
@@ -4046,10 +4308,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = writtenHashes.get(agent.agent_id);
-  if (written && existsSync3(agentDir)) {
+  if (written && existsSync4(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join4(agentDir, file));
+      const localHash = hashFile(join5(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -4060,7 +4322,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join4(agentDir, file));
+          localHashes[file] = hashFile(join5(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -4218,24 +4480,24 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join4(homedir3(), ".augmented", agent.code_name, "project");
+      const projectDir = join5(homedir4(), ".augmented", agent.code_name, "project");
       mkdirSync2(agentProvisionDir, { recursive: true });
       mkdirSync2(projectDir, { recursive: true });
-      const provisionMcpPath = join4(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join4(projectDir, ".mcp.json");
+      const provisionMcpPath = join5(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join5(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync3(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync4(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join4(homedir3(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join5(homedir4(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
         return typeof tz === "string" && tz.trim() !== "" ? tz.trim() : void 0;
       })();
-      if (existsSync3(localDirectChatChannel) && !mcpConfig.mcpServers["direct-chat"]) {
+      if (existsSync4(localDirectChatChannel) && !mcpConfig.mcpServers["direct-chat"]) {
         mcpConfig.mcpServers["direct-chat"] = {
           command: "node",
           args: [localDirectChatChannel],
@@ -4251,8 +4513,8 @@ async function processAgent(agent, agentStates) {
         writeFileSync3(projectMcpPath, serialized);
         log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
       }
-      const staleChannelsPath = join4(projectDir, ".mcp-channels.json");
-      if (existsSync3(staleChannelsPath)) {
+      const staleChannelsPath = join5(projectDir, ".mcp-channels.json");
+      if (existsSync4(staleChannelsPath)) {
         try {
           rmSync2(staleChannelsPath, { force: true });
         } catch {
@@ -4262,7 +4524,7 @@ async function processAgent(agent, agentStates) {
       log(`Failed to provision direct-chat channel for '${agent.code_name}': ${err.message}`);
     }
   }
-  let lastSecretsProvisionAt = state2.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let lastSecretsProvisionAt = state3.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
   let secretsHash = knownSecretsHashes.get(agent.agent_id) ?? null;
   try {
     const secretsData = await api.post("/host/secrets", { agent_id: agent.agent_id });
@@ -4318,11 +4580,11 @@ async function processAgent(agent, agentStates) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join4(homedir3(), ".augmented", agent.code_name, "project");
-        const envIntPath = join4(projectDir, ".env.integrations");
+        const projectDir = join5(homedir4(), ".augmented", agent.code_name, "project");
+        const envIntPath = join5(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync3(envIntPath, "utf-8");
+          preWriteEnv = readFileSync4(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -4334,9 +4596,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join4(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync3(envIntPath, "utf-8");
-            const mcpContent = readFileSync3(projectMcpPath, "utf-8");
+            const projectMcpPath = join5(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync4(envIntPath, "utf-8");
+            const mcpContent = readFileSync4(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -4402,8 +4664,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync4 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync5 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync5(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
                     "composio_",
@@ -4492,8 +4754,8 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join4(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
-        if (existsSync3(pluginPath)) {
+        const pluginPath = join5(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        if (existsSync4(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
             agtApiKey: getApiKey() ?? void 0,
@@ -4559,20 +4821,20 @@ async function processAgent(agent, agentStates) {
       }
       try {
         const { readdirSync: readdirSync3, rmSync: rmSync3 } = await import("fs");
-        const { homedir: homedir4 } = await import("os");
+        const { homedir: homedir5 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join4(homedir4(), ".augmented", agent.code_name, "skills"),
+          join5(homedir5(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join4(homedir4(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join5(homedir5(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join4(homedir4(), `.openclaw-${agent.code_name}`, "skills"),
+          join5(homedir5(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join4(agentDir, ".claude", "skills")
+          join5(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync3(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync4(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -4586,8 +4848,8 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join4(dir, entry);
-            if (existsSync3(p)) {
+            const p = join5(dir, entry);
+            if (existsSync4(p)) {
               rmSync3(p, { recursive: true, force: true });
             }
           }
@@ -4747,8 +5009,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join4(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync3(mcpPath, "utf-8"));
+        const mcpPath = join5(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync4(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -4756,7 +5018,12 @@ async function processAgent(agent, agentStates) {
         codeName: agent.code_name,
         mcpJson: mcpJsonParsed,
         sessionStartedAt: sess?.startedAt ?? null,
-        stopSession: (codeName) => stopPersistentSessionAndForgetMcpBaseline(codeName),
+        // ENG-5441: mcp-presence-reaper-driven restart counts against
+        // the breaker. Each declared MCP has its own ENG-5279 give-up
+        // cap (~3 cycles per server), but a thrashing collection of
+        // MCPs can still rotate restarts of the whole session. The
+        // breaker catches the rotating case the per-MCP cap can't see.
+        stopSession: (codeName) => stopPersistentSessionAndForgetMcpBaseline(codeName, "mcp-presence-reaper"),
         // ENG-5292: when the reaper gives up on a managed MCP (cap from
         // ENG-5279 + state-preservation from ENG-5285 both said "this
         // MCP keeps failing after 3 restart cycles"), mark the matching
@@ -4892,10 +5159,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 = join4(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
-          if (existsSync3(jobsPath)) {
+          const jobsPath = join5(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          if (existsSync4(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync3(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync4(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -5036,10 +5303,10 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync3(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync4(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join4(agentDir, file));
+      const h = hashFile(join5(agentDir, file));
       if (h) hashes.set(file, h);
     }
     writtenHashes.set(agent.agent_id, hashes);
@@ -5073,19 +5340,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join4(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join5(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join4(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join5(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join5(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join4(sessionsDir, "sessions.json");
-  if (!existsSync3(indexPath)) return;
+  const indexPath = join5(sessionsDir, "sessions.json");
+  if (!existsSync4(indexPath)) return;
   try {
-    const raw = readFileSync3(indexPath, "utf-8");
+    const raw = readFileSync4(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,
@@ -5098,9 +5365,9 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join4(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join5(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
-          if (existsSync3(sessionFile)) {
+          if (existsSync4(sessionFile)) {
             unlinkSync(sessionFile);
             deletedFiles++;
           }
@@ -5120,8 +5387,8 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join4(sessionsDir, `${parentSessionId}.jsonl`);
-            if (existsSync3(f)) {
+            const f = join5(sessionsDir, `${parentSessionId}.jsonl`);
+            if (existsSync4(f)) {
               unlinkSync(f);
               deletedFiles++;
             }
@@ -5139,28 +5406,28 @@ function cleanupCronSessions(sessionsDir, keepCount) {
 }
 var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
-  if (!existsSync3(jobsPath)) return;
+  if (!existsSync4(jobsPath)) return;
   try {
-    const raw = readFileSync3(jobsPath, "utf-8");
+    const raw = readFileSync4(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
     let changed = false;
     const now = Date.now();
     for (const job of jobs) {
-      const state3 = job.state;
-      if (!state3) continue;
-      const runStartedAt = state3.runningAtMs ?? state3.runStartedAtMs;
-      const isRunning = state3.running === true || state3.status === "running";
+      const state4 = job.state;
+      if (!state4) continue;
+      const runStartedAt = state4.runningAtMs ?? state4.runStartedAtMs;
+      const isRunning = state4.running === true || state4.status === "running";
       if (isRunning && runStartedAt && now - runStartedAt > STALE_RUN_TIMEOUT_MS) {
-        state3.running = false;
-        delete state3.status;
-        delete state3.runStartedAtMs;
-        delete state3.currentRunId;
+        state4.running = false;
+        delete state4.status;
+        delete state4.runStartedAtMs;
+        delete state4.currentRunId;
         changed = true;
         log(`Cleared stale running state for cron job '${job.name}' (stuck for ${Math.round((now - runStartedAt) / 6e4)}min)`);
       } else if (isRunning && !runStartedAt) {
-        state3.running = false;
+        state4.running = false;
         changed = true;
         log(`Cleared stale running state for cron job '${job.name}' (no start timestamp)`);
       }
@@ -5172,13 +5439,13 @@ function clearStaleCronRunState(jobsPath) {
   }
 }
 function cleanupOldFiles(dir, maxAgeDays, ext) {
-  if (!existsSync3(dir)) return;
+  if (!existsSync4(dir)) return;
   const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
   let removed = 0;
   try {
     for (const f of readdirSync2(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join4(dir, f);
+      const fullPath = join5(dir, f);
       try {
         const st = statSync(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -5224,16 +5491,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
       enabled: t.enabled ?? true,
       triggered_at: t.triggered_at ?? null
     }));
-    const state4 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state4);
+    const state5 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state5);
     knownTasksHashes.set(agent.agent_id, combinedHash);
     log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state3 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state3, inFlightClaudeTasks);
+  const state4 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state4, inFlightClaudeTasks);
   if (ready.length === 0) return;
   for (const task of ready) {
     if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
@@ -5322,7 +5589,7 @@ async function fetchPriorScheduledRuns(agentId, taskId) {
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join4(projectDir, ".mcp.json");
+  const mcpConfigPath = join5(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -5330,11 +5597,11 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join4(projectDir, "CLAUDE.md");
+    const claudeMdPath = join5(projectDir, "CLAUDE.md");
     const serverNames = [];
-    if (existsSync3(mcpConfigPath)) {
+    if (existsSync4(mcpConfigPath)) {
       try {
-        const d = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
+        const d = JSON.parse(readFileSync4(mcpConfigPath, "utf-8"));
         if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
       } catch {
       }
@@ -5353,14 +5620,14 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       "--allowedTools",
       allowedTools
     ];
-    if (existsSync3(claudeMdPath)) {
+    if (existsSync4(claudeMdPath)) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join4(projectDir, ".env.integrations");
-    if (existsSync3(envIntPath)) {
+    const envIntPath = join5(projectDir, ".env.integrations");
+    if (existsSync4(envIntPath)) {
       try {
-        for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
+        for (const line of readFileSync4(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);
@@ -5514,8 +5781,8 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
   }
 }
 function fireClaudeWorkTrigger(codeName, agentId, boardItems) {
-  const state3 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const kanbanTask = findTaskByTemplate(state3, "kanban-work");
+  const state4 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const kanbanTask = findTaskByTemplate(state4, "kanban-work");
   if (!kanbanTask) {
     log(`[claude-scheduler] Work trigger: no kanban-work task found for '${codeName}'`);
     return;
@@ -5538,13 +5805,23 @@ function fireClaudeWorkTrigger(codeName, agentId, boardItems) {
   });
 }
 var persistentSessionAgents = /* @__PURE__ */ new Set();
+var lastMcpFailedBannerCount = /* @__PURE__ */ new Map();
 var persistentSessionStuckTracker = new PersistentSessionStuckTracker();
 var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join4(projectDir, ".mcp.json");
-  const claudeMdPath = join4(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join5(projectDir, ".mcp.json");
+  const claudeMdPath = join5(projectDir, "CLAUDE.md");
+  if (restartBreaker.isTripped(codeName)) {
+    const trip = restartBreaker.getTrip(codeName);
+    return {
+      decision: "circuit-tripped",
+      spawnAttempted: false,
+      sessionHealthyAfter: isSessionHealthy(codeName),
+      detail: trip.statusMessage
+    };
+  }
   const teamSettingsForTz = refreshData.team?.settings;
   const agentTimezone = (() => {
     const tz = teamSettingsForTz?.["timezone"];
@@ -5627,7 +5904,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const recordedAuthTuple = claudeAuthTupleBySession.get(codeName);
   if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && isSessionHealthy(codeName)) {
     log(`[persistent-session] Auth config changed for '${codeName}' (${recordedAuthTuple} \u2192 ${currentAuthTuple}) \u2014 restarting session`);
-    stopPersistentSessionAndForgetMcpBaseline(codeName);
+    stopPersistentSessionAndForgetMcpBaseline(codeName, "auth-tuple-change");
     persistentSessionAgents.delete(codeName);
     restartTrigger = "auth-tuple";
   }
@@ -5639,7 +5916,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
         log(
           `[persistent-session] Day rollover for '${codeName}' (yesterday=${current.date}) \u2014 agent idle, restarting to mint fresh session`
         );
-        stopPersistentSessionAndForgetMcpBaseline(codeName);
+        stopPersistentSessionAndForgetMcpBaseline(codeName, "day-rollover");
         persistentSessionAgents.delete(codeName);
         restartTrigger = "day-rollover";
       } else {
@@ -5650,6 +5927,15 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       }
     }
   }
+  if (restartBreaker.isTripped(codeName)) {
+    const trip = restartBreaker.getTrip(codeName);
+    return {
+      decision: "circuit-tripped",
+      spawnAttempted: false,
+      sessionHealthyAfter: isSessionHealthy(codeName),
+      detail: trip.statusMessage
+    };
+  }
   if (!isSessionHealthy(codeName)) {
     if (persistentSessionAgents.has(codeName)) {
       const ctx = getLastFailureContext(codeName);
@@ -5763,9 +6049,9 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash2("sha256").
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state3 = claudeSchedulerStates.get(codeName);
-  if (state3) {
-    const ready = getReadyTasks(state3, inFlightClaudeTasks);
+  const state4 = claudeSchedulerStates.get(codeName);
+  if (state4) {
+    const ready = getReadyTasks(state4, inFlightClaudeTasks);
     if (ready.length > 0) {
       log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
     }
@@ -6144,11 +6430,11 @@ ${escapeXml(msg.content)}
     if (fw === "claude-code") {
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-XHJS2MZV.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join4(projDir, ".mcp.json");
+      const mcpConfigPath = join5(projDir, ".mcp.json");
       const serverNames = [];
-      if (existsSync3(mcpConfigPath)) {
+      if (existsSync4(mcpConfigPath)) {
         try {
-          const d = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
+          const d = JSON.parse(readFileSync4(mcpConfigPath, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -6167,15 +6453,15 @@ ${escapeXml(msg.content)}
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join4(projDir, "CLAUDE.md");
-      if (existsSync3(chatClaudeMd)) {
+      const chatClaudeMd = join5(projDir, "CLAUDE.md");
+      if (existsSync4(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join4(projDir, ".env.integrations");
+      const envIntPath = join5(projDir, ".env.integrations");
       const childEnv = { ...process.env };
-      if (existsSync3(envIntPath)) {
+      if (existsSync4(envIntPath)) {
         try {
-          for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
+          for (const line of readFileSync4(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);
@@ -6518,12 +6804,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join4(process.cwd(), "skills", skillId, "SKILL.md"),
-      join4(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join5(process.cwd(), "skills", skillId, "SKILL.md"),
+      join5(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync3(candidate)) {
-        const content = readFileSync3(candidate, "utf-8");
+      if (existsSync4(candidate)) {
+        const content = readFileSync4(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -7136,7 +7422,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-KUWBZW33.js");
+  } = await import("../claude-pair-runtime-XCFWTH6T.js");
   for (const pairId of pendingResp.cancelled_pair_ids ?? []) {
     log(`[claude-pair] sweeping orphan tmux session for pair ${pairId.slice(0, 8)}`);
     const killed = await killPairSession(pairTmuxSession(pairId));
@@ -7357,6 +7643,14 @@ function generateArtifacts(agent, refreshData, adapter) {
       };
     }
   }
+  const activeTasksInjectEnabled = process.env["AGT_ACTIVE_TASKS_INJECT"] === "1";
+  const activeTasksFromRefresh = activeTasksInjectEnabled ? refreshData.active_tasks ?? [] : void 0;
+  if (activeTasksInjectEnabled) {
+    const tokens = estimateActiveTasksTokens(activeTasksFromRefresh);
+    log(
+      `[provision/active-tasks] agent=${agent.code_name} count=${activeTasksFromRefresh?.length ?? 0} estimated_tokens=${tokens}`
+    );
+  }
   const provisionInput = {
     agent: refreshData.agent,
     charterFrontmatter,
@@ -7367,6 +7661,7 @@ function generateArtifacts(agent, refreshData, adapter) {
     deploymentTarget: "local_docker",
     gatewayPort: 9e3,
     team: refreshData.team ?? void 0,
+    activeTasks: activeTasksFromRefresh,
     // ENG-5009: org name for the identity-preamble. Only present when
     // /host/refresh ships the field — falls through cleanly for older
     // API payloads that don't carry it.
@@ -7422,8 +7717,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join4(configDir, agent.code_name, "project");
-  const memoryDir = join4(projectDir, "memory");
+  const projectDir = join5(configDir, agent.code_name, "project");
+  const memoryDir = join5(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`);
@@ -7434,14 +7729,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync3(memoryDir)) {
+  if (existsSync4(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
     for (const file of readdirSync2(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync3(join4(memoryDir, file), "utf-8");
+        const raw = readFileSync4(join5(memoryDir, file), "utf-8");
         const fileHash = createHash2("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -7466,7 +7761,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync3(join4(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync4(join5(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -7479,7 +7774,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync3(memoryDir) ? readdirSync2(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync4(memoryDir) ? readdirSync2(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash2("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -7501,7 +7796,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 = join4(memoryDir, `${slug}.md`);
+        const filePath = join5(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -7510,10 +7805,10 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync3(filePath)) {
+        if (existsSync4(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync3(filePath, "utf-8");
+            existing = readFileSync4(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
@@ -7537,7 +7832,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync3(agentDir)) {
+  if (existsSync4(agentDir)) {
     try {
       rmSync2(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -7708,19 +8003,24 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync3(stateFile)) {
-      const raw = readFileSync3(stateFile, "utf-8");
+    if (existsSync4(stateFile)) {
+      const raw = readFileSync4(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
-        state2.agents = parsed.agents;
-        log(`[startup] rehydrated ${state2.agents.length} agent state(s) from ${stateFile}`);
+        state3.agents = parsed.agents;
+        log(`[startup] rehydrated ${state3.agents.length} agent state(s) from ${stateFile}`);
+      }
+      if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
+        restartBreaker.hydrate(parsed.circuitBreakerTrips);
+        const n = Object.keys(parsed.circuitBreakerTrips).length;
+        if (n > 0) log(`[startup] rehydrated ${n} circuit-breaker trip(s) \u2014 agents will remain paused until manually resumed`);
       }
     }
   } catch (err) {
     log(`[startup] state rehydration failed (continuing with empty state): ${err.message}`);
   }
   log(
-    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join4(homedir3(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join5(homedir4(), ".augmented", "manager.log")}`
   );
   warnOnConflictingKanbanModes();
   deployMcpAssets();
@@ -7783,14 +8083,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join4(homedir3(), ".augmented", "_mcp");
+  const targetDir = join5(homedir4(), ".augmented", "_mcp");
   mkdirSync2(targetDir, { recursive: true });
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join4(dir, "dist", "mcp");
-    if (existsSync3(join4(candidate, "index.js"))) {
+    const candidate = join5(dir, "dist", "mcp");
+    if (existsSync4(join5(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -7805,8 +8105,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync3(p)) return null;
-      return createHash2("sha256").update(readFileSync3(p)).digest("hex");
+      if (!existsSync4(p)) return null;
+      return createHash2("sha256").update(readFileSync4(p)).digest("hex");
     } catch {
       return null;
     }
@@ -7817,9 +8117,9 @@ function deployMcpAssets() {
     "telegram-channel.js"
   ]);
   for (const file of ["index.js", "slack-channel.js", "direct-chat-channel.js", "telegram-channel.js"]) {
-    const src = join4(mcpSourceDir, file);
-    const dst = join4(targetDir, file);
-    if (!existsSync3(src)) continue;
+    const src = join5(mcpSourceDir, file);
+    const dst = join5(targetDir, file);
+    if (!existsSync4(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -7836,16 +8136,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join4(targetDir, "index.js");
+  const localMcpPath = join5(targetDir, "index.js");
   try {
-    const agentsDir = join4(homedir3(), ".augmented", "agents");
-    if (existsSync3(agentsDir)) {
+    const agentsDir = join5(homedir4(), ".augmented", "agents");
+    if (existsSync4(agentsDir)) {
       for (const entry of readdirSync2(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join4(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join5(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync3(mcpJsonPath, "utf-8");
+            const raw = readFileSync4(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];