@integrity-labs/agt-cli 0.28.474 → 0.28.475

package/dist/lib/manager-worker.js

@@ -44,7 +44,7 @@ import {
   resolveEffectivePinRaw,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-C47UJ5QI.js";
+} from "../chunk-Q53LFQVD.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -73,7 +73,6 @@ import {
   SUPPRESS_SENTINEL,
   StreamEncoder,
   UNKNOWN_RATE_LIMIT,
-  USAGE_LIMIT_MARKER_FILENAME,
   appendDmFooter,
   attributeTranscriptUsageByRun,
   buildEgressAllowlist,
@@ -130,7 +129,6 @@ import {
   parseEnvIntegrations,
   parseTranscriptUsage,
   parseUsageBanner,
-  parseUsageLimitMarker,
   peekCurrentSession,
   pickNewerClassification,
   prepareForRespawn,
@@ -146,11 +144,9 @@ import {
   resolveChannels,
   resolveClaudeBinary,
   resolveDmTarget,
-  resolveUsageLimitUntil,
   restartEgressSidecar,
   rotateSessionForWedge,
   serializeAccountEnforcementMarker,
-  serializeUsageLimitMarker,
   sessionTranscriptDir,
   sha256,
   sharedBusyBuckets,
@@ -166,17 +162,17 @@ import {
   toOpencodeModel,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-YR6ESOCM.js";
+} from "../chunk-LGBI4P2P.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash16 } from "crypto";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync13, mkdirSync as mkdirSync11, existsSync as existsSync11, rmSync as rmSync6, readdirSync as readdirSync7, statSync as statSync6, copyFileSync } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, existsSync as existsSync11, rmSync as rmSync5, readdirSync as readdirSync7, statSync as statSync6, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join26, dirname as dirname8, delimiter as pathDelimiter } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join25, dirname as dirname8, delimiter as pathDelimiter } from "path";
+import { homedir as homedir11 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/claude-code-upgrade-throttle.ts
@@ -2203,119 +2199,7 @@ var nodeArtifactFs = {
   }
 };
 
-// src/lib/usage-limit-marker-file.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
-function agentDir(codeName) {
-  return join6(homedir3(), ".augmented", codeName);
-}
-function usageLimitMarkerPath(codeName) {
-  return join6(agentDir(codeName), USAGE_LIMIT_MARKER_FILENAME);
-}
-function writeUsageLimitMarker(codeName, limitedUntil, log2) {
-  try {
-    mkdirSync4(agentDir(codeName), { recursive: true });
-    writeFileSync4(usageLimitMarkerPath(codeName), serializeUsageLimitMarker(limitedUntil), "utf-8");
-  } catch (err) {
-    log2(`[usage-banner] usage-limit marker sync failed for '${codeName}': ${err.message}`);
-  }
-}
-function clearUsageLimitMarker(codeName, log2) {
-  try {
-    rmSync2(usageLimitMarkerPath(codeName), { force: true });
-  } catch (err) {
-    log2(`[usage-banner] usage-limit marker clear failed for '${codeName}': ${err.message}`);
-  }
-}
-function readUsageLimitUntil(opts) {
-  const path = opts.filePath ?? (opts.codeName ? usageLimitMarkerPath(opts.codeName) : null);
-  if (!path) return null;
-  let raw;
-  try {
-    raw = readFileSync7(path, "utf-8");
-  } catch {
-    return null;
-  }
-  return resolveUsageLimitUntil(parseUsageLimitMarker(raw), opts.now ?? /* @__PURE__ */ new Date());
-}
-var loggedUsageCapDeferral = /* @__PURE__ */ new Map();
-function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
-  const key = `${site}:${codeName}`;
-  const at = limitedUntil.getTime();
-  if (loggedUsageCapDeferral.get(key) === at) return false;
-  loggedUsageCapDeferral.set(key, at);
-  return true;
-}
-
-// src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync8, readdirSync, statSync } from "fs";
-import { join as join7 } from "path";
-var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
-function probeRateLimit(args) {
-  const now = args.now ?? /* @__PURE__ */ new Date();
-  const endMs = now.getTime();
-  const startMs = endMs - (args.windowMs ?? RATE_LIMIT_WINDOW_MS);
-  const dir = args.transcriptDir ?? sessionTranscriptDir(args.projectDir);
-  let entries;
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return UNKNOWN_RATE_LIMIT;
-  }
-  let newest = UNKNOWN_RATE_LIMIT;
-  for (const name of entries) {
-    if (!name.endsWith(".jsonl")) continue;
-    const path = join7(dir, name);
-    try {
-      const st = statSync(path);
-      if (!st.isFile() || st.mtimeMs < startMs) continue;
-    } catch {
-      continue;
-    }
-    let content;
-    try {
-      content = readFileSync8(path, "utf-8");
-    } catch {
-      continue;
-    }
-    newest = pickNewerClassification(
-      newest,
-      classifyTranscriptRateLimit(content, startMs, endMs, now)
-    );
-  }
-  return newest;
-}
-function probeRateLimitState(args) {
-  return probeRateLimit(args).verdict;
-}
-
 // src/lib/usage-banner-monitor.ts
-function syncUsageLimitMarker(args) {
-  if (args.pct < 100) {
-    clearUsageLimitMarker(args.codeName, args.log);
-    return;
-  }
-  const verdict = args.verdict ?? probeRateLimitState({
-    codeName: args.codeName,
-    projectDir: getProjectDir(args.codeName),
-    now: args.now
-  });
-  if (verdict === "serving") {
-    args.log(
-      `[usage-banner] saturated banner for '${args.codeName}' NOT armed - a turn completed, so the agent is serving (ENG-8198)`
-    );
-    clearUsageLimitMarker(args.codeName, args.log);
-    return;
-  }
-  if (verdict === "unknown") {
-    args.log(
-      `[usage-banner] saturated banner for '${args.codeName}' NOT armed - no classifiable turn in the transcript; leaving any existing marker untouched (ENG-8198)`
-    );
-    return;
-  }
-  writeUsageLimitMarker(args.codeName, args.weekResetsAt, args.log);
-}
 var SPAWN_MARKER = /--- spawn \S+ \(session [^)]*\) ---/g;
 function scopeToCurrentPaneEpoch(tail) {
   SPAWN_MARKER.lastIndex = 0;
@@ -2324,8 +2208,8 @@ function scopeToCurrentPaneEpoch(tail) {
   while ((match = SPAWN_MARKER.exec(tail)) !== null) {
     lastIndex = match.index;
   }
-  if (lastIndex < 0) return { epochText: tail, sawSpawnMarker: false };
-  return { epochText: tail.slice(lastIndex), sawSpawnMarker: true };
+  if (lastIndex < 0) return tail;
+  return tail.slice(lastIndex);
 }
 var MIN_CHECK_INTERVAL_MS = 6e4;
 var PANE_TAIL_LINES_FOR_BANNER = 5e3;
@@ -2354,22 +2238,12 @@ async function maybeReportUsageBanner(args) {
     state.set(codeName, next);
     return;
   }
-  const { epochText, sawSpawnMarker } = scopeToCurrentPaneEpoch(tail);
+  const epochText = scopeToCurrentPaneEpoch(tail);
   const observation = parseUsageBanner(epochText, now);
   if (!observation) {
-    if (sawSpawnMarker) {
-      clearUsageLimitMarker(codeName, log2);
-    }
     state.set(codeName, next);
     return;
   }
-  syncUsageLimitMarker({
-    codeName,
-    pct: observation.pct,
-    weekResetsAt: observation.weekResetsAt,
-    log: log2,
-    now
-  });
   const observedAtIso = next.lastWeekResetsAt;
   const weekResetsAtIso = observation.weekResetsAt.toISOString();
   if (existing && existing.lastPct === observation.pct && observedAtIso === weekResetsAtIso) {
@@ -2395,13 +2269,13 @@ async function maybeReportUsageBanner(args) {
 // src/lib/claude-account-fingerprint.ts
 import { createHash as createHash6 } from "crypto";
 import { readFile as readFile3, readdir as readdir3 } from "fs/promises";
-import { homedir as homedir5, platform as platform2 } from "os";
-import { dirname as dirname4, join as join9 } from "path";
+import { homedir as homedir4, platform as platform2 } from "os";
+import { dirname as dirname4, join as join7 } from "path";
 
 // src/lib/claude-auth-detect.ts
 import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { homedir as homedir4, platform } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir3, platform } from "os";
+import { join as join6 } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -2416,16 +2290,16 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join8(homedir4(), ".claude", ".credentials.json"),
-    join8(homedir4(), ".claude", "credentials.json")
+    join6(homedir3(), ".claude", ".credentials.json"),
+    join6(homedir3(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
     try {
       const entries = await readdir2("/home", { withFileTypes: true });
       for (const entry of entries.filter((entry2) => entry2.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-        candidates.push(join8("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join8("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join6("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join6("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -2503,13 +2377,13 @@ function parseExpiresAt(raw) {
 
 // src/lib/claude-account-fingerprint.ts
 async function candidateHomes() {
-  const homes = [homedir5()];
+  const homes = [homedir4()];
   const isLinuxRoot = platform2() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
     try {
       const entries = await readdir3("/home", { withFileTypes: true });
       for (const entry of entries.filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-        homes.push(join9("/home", entry.name));
+        homes.push(join7("/home", entry.name));
       }
     } catch {
     }
@@ -2529,11 +2403,11 @@ async function homeOfActiveCredentials() {
 async function claudeConfigCandidatePaths() {
   const paths = [];
   const configDir = process.env["CLAUDE_CONFIG_DIR"]?.trim();
-  if (configDir) paths.push(join9(configDir, ".claude.json"));
+  if (configDir) paths.push(join7(configDir, ".claude.json"));
   const activeHome = await homeOfActiveCredentials();
-  if (activeHome) paths.push(join9(activeHome, ".claude.json"));
+  if (activeHome) paths.push(join7(activeHome, ".claude.json"));
   for (const home of await candidateHomes()) {
-    const path = join9(home, ".claude.json");
+    const path = join7(home, ".claude.json");
     if (!paths.includes(path)) paths.push(path);
   }
   return paths;
@@ -2630,11 +2504,11 @@ function diffAuthTuples(recorded, current) {
 }
 
 // src/lib/account-enforcement-marker.ts
-import { mkdirSync as mkdirSync5, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync4, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
 function accountEnforcementMarkerPath(codeName) {
-  return join10(homedir6(), ".augmented", codeName, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
+  return join8(homedir5(), ".augmented", codeName, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
 }
 function syncAccountEnforcementMarker(codeName, level, log2 = (m) => process.stderr.write(`${m}
 `)) {
@@ -2642,16 +2516,16 @@ function syncAccountEnforcementMarker(codeName, level, log2 = (m) => process.std
     clearAccountEnforcementMarker(codeName, log2);
     return;
   }
-  const dir = join10(homedir6(), ".augmented", codeName);
-  const path = join10(dir, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
+  const dir = join8(homedir5(), ".augmented", codeName);
+  const path = join8(dir, ACCOUNT_ENFORCEMENT_MARKER_FILENAME);
   const tempPath = `${path}.${process.pid}.tmp`;
   try {
-    mkdirSync5(dir, { recursive: true });
-    writeFileSync5(tempPath, serializeAccountEnforcementMarker(level), "utf-8");
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync4(tempPath, serializeAccountEnforcementMarker(level), "utf-8");
     renameSync(tempPath, path);
   } catch (err) {
     try {
-      rmSync3(tempPath, { force: true });
+      rmSync2(tempPath, { force: true });
     } catch {
     }
     log2(`[account-enforcement] marker sync failed for '${codeName}': ${err.message}`);
@@ -2661,15 +2535,15 @@ function clearAccountEnforcementMarker(codeName, log2 = (m) => process.stderr.wr
 `)) {
   const path = accountEnforcementMarkerPath(codeName);
   try {
-    rmSync3(path, { force: true });
+    rmSync2(path, { force: true });
   } catch (err) {
     log2(`[account-enforcement] marker clear failed for '${codeName}': ${err.message}`);
   }
 }
 
 // src/lib/token-usage-monitor.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync, readFileSync as readFileSync7, statSync } from "fs";
+import { join as join9 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
@@ -2687,7 +2561,7 @@ async function maybeReportTokenUsage(args) {
   const next = { files, lastCheckedAt: nowMs };
   let dirEntries;
   try {
-    dirEntries = readdirSync2(dir);
+    dirEntries = readdirSync(dir);
   } catch {
     state2.set(codeName, next);
     return;
@@ -2698,10 +2572,10 @@ async function maybeReportTokenUsage(args) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
     if (!sessionId) continue;
-    const path = join11(dir, name);
+    const path = join9(dir, name);
     let st;
     try {
-      st = statSync2(path);
+      st = statSync(path);
     } catch {
       continue;
     }
@@ -2714,7 +2588,7 @@ async function maybeReportTokenUsage(args) {
     }
     let content;
     try {
-      content = readFileSync9(path, "utf-8");
+      content = readFileSync7(path, "utf-8");
     } catch (err) {
       log2(`[token-usage] read failed for '${codeName}/${name}': ${err.message}`);
       continue;
@@ -2795,8 +2669,8 @@ async function maybeReportTokenUsage(args) {
 }
 
 // src/lib/workflow-run-reconciler.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync3 } from "fs";
-import { join as join12 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import { join as join10 } from "path";
 var MIN_CHECK_INTERVAL_MS3 = 5 * 6e4;
 var SETTLE_MS = 3e4;
 var TRANSCRIPT_MTIME_WINDOW_MS2 = 2 * 24 * 60 * 60 * 1e3;
@@ -2810,15 +2684,15 @@ function collectJsonlRecursive(dir, minMtimeMs, out, depth) {
   if (depth > MAX_SUBAGENT_DEPTH) return;
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync2(dir);
   } catch {
     return;
   }
   for (const name of entries) {
-    const p = join12(dir, name);
+    const p = join10(dir, name);
     let st;
     try {
-      st = statSync3(p);
+      st = statSync2(p);
     } catch {
       continue;
     }
@@ -2833,15 +2707,15 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
   const out = [];
   let entries;
   try {
-    entries = readdirSync3(transcriptDir);
+    entries = readdirSync2(transcriptDir);
   } catch {
     return out;
   }
   for (const name of entries) {
-    const path = join12(transcriptDir, name);
+    const path = join10(transcriptDir, name);
     let st;
     try {
-      st = statSync3(path);
+      st = statSync2(path);
     } catch {
       continue;
     }
@@ -2850,7 +2724,7 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
       continue;
     }
     if (st.isDirectory()) {
-      collectJsonlRecursive(join12(path, "subagents"), minMtimeMs, out, 0);
+      collectJsonlRecursive(join10(path, "subagents"), minMtimeMs, out, 0);
     }
   }
   return out;
@@ -2895,7 +2769,7 @@ async function maybeReconcileWorkflowRunTokens(args) {
   const contents = [];
   for (const path of files) {
     try {
-      contents.push(readFileSync10(path, "utf-8"));
+      contents.push(readFileSync8(path, "utf-8"));
     } catch {
     }
   }
@@ -2940,8 +2814,8 @@ async function maybeReconcileWorkflowRunTokens(args) {
 }
 
 // src/lib/conversation-evaluator.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync4 } from "fs";
-import { join as join13 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
 var MIN_CHECK_INTERVAL_MS4 = 5 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS3 = 7 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS = 5 * 6e4;
@@ -3372,12 +3246,12 @@ function readRecentTurns(dir, nowMs) {
   const visit = (d) => {
     let entries;
     try {
-      entries = readdirSync4(d, { withFileTypes: true });
+      entries = readdirSync3(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = join13(d, ent.name);
+      const full = join11(d, ent.name);
       if (ent.isDirectory()) {
         visit(full);
         continue;
@@ -3385,14 +3259,14 @@ function readRecentTurns(dir, nowMs) {
       if (!ent.isFile() || !ent.name.endsWith(".jsonl")) continue;
       let mtimeMs;
       try {
-        mtimeMs = statSync4(full).mtimeMs;
+        mtimeMs = statSync3(full).mtimeMs;
       } catch {
         continue;
       }
       if (nowMs - mtimeMs > TRANSCRIPT_MTIME_WINDOW_MS3) continue;
       let content;
       try {
-        content = readFileSync11(full, "utf8");
+        content = readFileSync9(full, "utf8");
       } catch {
         continue;
       }
@@ -3682,11 +3556,11 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 }
 
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync10 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join12 } from "path";
 var MIN_CHECK_INTERVAL_MS6 = 6e4;
-var STATS_CACHE_PATH = join14(homedir7(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join12(homedir6(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state5 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -3734,7 +3608,7 @@ async function maybeReportActivityCache(args) {
   }
   let raw;
   try {
-    raw = readFileSync12(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync10(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
@@ -3938,18 +3812,18 @@ function computeChannelConfigHash(input) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join15(configDir, CACHE_FILENAME);
+  return join13(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
   if (!existsSync3(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync13(path, "utf-8"));
+    parsed = JSON.parse(readFileSync11(path, "utf-8"));
   } catch {
     return;
   }
@@ -3963,14 +3837,14 @@ function saveChannelHashCache(source, configDir) {
   const obj = {};
   for (const [key, value] of source) obj[key] = value;
   try {
-    writeFileSync6(path, JSON.stringify(obj, null, 2));
+    writeFileSync5(path, JSON.stringify(obj, null, 2));
   } catch {
   }
 }
 
 // src/lib/sender-policy-baseline.ts
-import { existsSync as existsSync4, readFileSync as readFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync12 } from "fs";
+import { join as join14 } from "path";
 var BASELINE_FILENAME = "sender-policy-baseline.json";
 var SENDER_POLICY_BASELINE_VERSION = 1;
 var BASELINE_CONCERNS = ["senderPolicy", "slackBehaviour", "msteamsBehaviour"];
@@ -3982,14 +3856,14 @@ function createDeliveryBaselineMaps() {
   };
 }
 function getSenderPolicyBaselineFile(configDir) {
-  return join16(configDir, BASELINE_FILENAME);
+  return join14(configDir, BASELINE_FILENAME);
 }
 function loadSenderPolicyBaseline(target, configDir, log2) {
   const path = getSenderPolicyBaselineFile(configDir);
   if (!existsSync4(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync14(path, "utf-8"));
+    parsed = JSON.parse(readFileSync12(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[sender-policy] discarding corrupt ${BASELINE_FILENAME} (${err.message}) - restrictive-policy agents will take one fail-closed restart`
@@ -4512,16 +4386,16 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // src/lib/manager/managed-skill-manifest.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname5, join as join17 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, join as join15 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join17(agentRootDir, "managed-skills.json");
+  return join15(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
     if (!existsSync5(path)) return /* @__PURE__ */ new Set();
-    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf-8"));
     const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
     return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
   } catch {
@@ -4530,12 +4404,12 @@ function readManagedSkillManifest(path) {
 }
 function writeManagedSkillManifest(path, ids) {
   try {
-    mkdirSync6(dirname5(path), { recursive: true });
+    mkdirSync5(dirname5(path), { recursive: true });
     const body = {
       version: MANIFEST_VERSION,
       globalSkillIds: [...ids].sort()
     };
-    writeFileSync7(path, JSON.stringify(body, null, 2));
+    writeFileSync6(path, JSON.stringify(body, null, 2));
   } catch {
   }
 }
@@ -4633,9 +4507,9 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync6, rmSync as rmSync4 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync6, rmSync as rmSync3 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir7 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -4647,12 +4521,12 @@ 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 = join18(homedir8(), ".claude");
+    const claudeDir = join16(homedir7(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join18(claudeDir, filename);
+      const p = join16(claudeDir, filename);
       if (existsSync6(p)) {
         try {
-          rmSync4(p, { force: true });
+          rmSync3(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
         } catch {
         }
@@ -4664,8 +4538,8 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync7, readFileSync as readFileSync16 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync14 } from "fs";
+import { join as join17 } from "path";
 var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
@@ -4804,12 +4678,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join19(process.cwd(), "skills", skillId, "SKILL.md"),
-      join19(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join17(process.cwd(), "skills", skillId, "SKILL.md"),
+      join17(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync7(candidate)) {
-        const content = readFileSync16(candidate, "utf-8");
+        const content = readFileSync14(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -4950,19 +4824,19 @@ function formatBoardForPrompt(items, template) {
 }
 
 // src/lib/manager/kanban/nudge-state-cache.ts
-import { existsSync as existsSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
+import { join as join18 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join20(configDir, CACHE_FILENAME2);
+  return join18(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
   if (!existsSync8(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(path, "utf-8"));
+    parsed = JSON.parse(readFileSync15(path, "utf-8"));
   } catch {
     return;
   }
@@ -4987,7 +4861,7 @@ function saveKanbanNudgeState(source, configDir) {
   const agents = {};
   for (const [codeName, state7] of source) agents[codeName] = state7;
   try {
-    writeFileSync8(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
+    writeFileSync7(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
   } catch {
   }
 }
@@ -5562,9 +5436,9 @@ function closeScheduledRunsForCode(codeName, outcome, reason) {
 
 // src/lib/manager/scheduler/kanban-route.ts
 import { createHash as createHash11 } from "crypto";
-import { writeFileSync as writeFileSync9, renameSync as renameSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync18, unlinkSync } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join21, dirname as dirname6 } from "path";
+import { writeFileSync as writeFileSync8, renameSync as renameSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync16, unlinkSync } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join19, dirname as dirname6 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
 import { createHash as createHash10 } from "crypto";
@@ -5904,19 +5778,19 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join21(homedir9(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join19(homedir8(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
-    writeFileSync9(tmp, JSON.stringify(marker), "utf8");
+    writeFileSync8(tmp, JSON.stringify(marker), "utf8");
     renameSync2(tmp, file);
   } catch (err) {
     log(`[scheduled-kanban] scheduled-turn marker write failed for '${codeName}': ${err.message}`);
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join21(homedir9(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join19(homedir8(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
-    const raw = JSON.parse(readFileSync18(file, "utf8"));
+    const raw = JSON.parse(readFileSync16(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
     unlinkSync(file);
     log(`[scheduled-kanban] scheduled-turn marker cleared for '${codeName}' (task ${taskId} complete)`);
@@ -5970,9 +5844,9 @@ async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt, dura
       return false;
     }
     try {
-      const doorbell = directChatDoorbellPath(agentId, homedir9());
-      mkdirSync7(dirname6(doorbell), { recursive: true });
-      writeFileSync9(doorbell, String(Date.now()));
+      const doorbell = directChatDoorbellPath(agentId, homedir8());
+      mkdirSync6(dirname6(doorbell), { recursive: true });
+      writeFileSync8(doorbell, String(Date.now()));
     } catch (err) {
       log(`[scheduled-kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
     }
@@ -6122,10 +5996,99 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 
 // src/lib/manager/scheduler/execution.ts
 import { createHash as createHash12 } from "crypto";
-import { homedir as homedir10 } from "os";
-import { join as join22 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join21 } from "path";
+
+// src/lib/agent-serving-probe.ts
+import { readFileSync as readFileSync17, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join20 } from "path";
+var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
+function probeRateLimit(args) {
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const endMs = now.getTime();
+  const startMs = endMs - (args.windowMs ?? RATE_LIMIT_WINDOW_MS);
+  const dir = args.transcriptDir ?? sessionTranscriptDir(args.projectDir);
+  let entries;
+  try {
+    entries = readdirSync4(dir);
+  } catch {
+    return UNKNOWN_RATE_LIMIT;
+  }
+  let newest = UNKNOWN_RATE_LIMIT;
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join20(dir, name);
+    try {
+      const st = statSync4(path);
+      if (!st.isFile() || st.mtimeMs < startMs) continue;
+    } catch {
+      continue;
+    }
+    let content;
+    try {
+      content = readFileSync17(path, "utf-8");
+    } catch {
+      continue;
+    }
+    newest = pickNewerClassification(
+      newest,
+      classifyTranscriptRateLimit(content, startMs, endMs, now)
+    );
+  }
+  return newest;
+}
+var USAGE_CAP_PROBE_TTL_MS = 6e4;
+var usageCapProbeCache = /* @__PURE__ */ new Map();
+var claudeAccountByAgent = /* @__PURE__ */ new Map();
+var usageCapEvidenceFloorMs = /* @__PURE__ */ new Map();
+var loggedUsageCapDeferral = /* @__PURE__ */ new Map();
+function noteClaudeAccountChange(codeName, fingerprint3, log2, now) {
+  if (!fingerprint3) return;
+  const previous = claudeAccountByAgent.get(codeName);
+  claudeAccountByAgent.set(codeName, fingerprint3);
+  if (previous === void 0 || previous === fingerprint3) return;
+  usageCapEvidenceFloorMs.set(codeName, (now ?? /* @__PURE__ */ new Date()).getTime());
+  usageCapProbeCache.delete(codeName);
+  log2(
+    `[usage-cap] signed-in Claude account changed for '${codeName}' (${previous} \u2192 ${fingerprint3}) \u2014 disregarding rate-limit evidence recorded before now; the cap belonged to the previous account (ENG-8202)`
+  );
+}
+function readUsageCapUntil(args) {
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const floorMs = usageCapEvidenceFloorMs.get(args.codeName);
+  const requestedWindowMs = args.windowMs ?? RATE_LIMIT_WINDOW_MS;
+  const windowMs = floorMs === void 0 ? requestedWindowMs : Math.max(0, Math.min(requestedWindowMs, nowMs - floorMs));
+  const cached = usageCapProbeCache.get(args.codeName);
+  let classification;
+  if (cached && nowMs - cached.at < (args.ttlMs ?? USAGE_CAP_PROBE_TTL_MS)) {
+    classification = cached.classification;
+  } else {
+    classification = probeRateLimit({
+      codeName: args.codeName,
+      projectDir: args.projectDir,
+      now,
+      windowMs,
+      transcriptDir: args.transcriptDir
+    });
+    usageCapProbeCache.set(args.codeName, { at: nowMs, classification });
+  }
+  if (classification.verdict !== "capped") return null;
+  const resetsAt = classification.resetsAt;
+  if (!resetsAt) return null;
+  return resetsAt.getTime() > nowMs ? resetsAt : null;
+}
+function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
+  const key = `${site}:${codeName}`;
+  const at = limitedUntil.getTime();
+  if (loggedUsageCapDeferral.get(key) === at) return false;
+  loggedUsageCapDeferral.set(key, at);
+  return true;
+}
+
+// src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join22(homedir10(), ".augmented", "manager-claude-pids.json");
+  return join21(homedir9(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -6164,7 +6127,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   const state7 = claudeSchedulerStates.get(codeName);
   const ready = getReadyTasks(state7, inFlightClaudeTasks);
   if (ready.length === 0) return;
-  const limitedUntil = readUsageLimitUntil({ codeName });
+  const limitedUntil = readUsageCapUntil({ codeName, projectDir: getProjectDir(codeName) });
   if (limitedUntil) {
     if (shouldLogUsageCapDeferral("claude-scheduler", codeName, limitedUntil)) {
       log(
@@ -7358,9 +7321,9 @@ async function fireOpencodeScheduledTask(agent, task) {
 
 // src/lib/opencode-telegram-ingest.ts
 import { createHash as createHash15 } from "crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync19, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync18, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join23 } from "path";
+import { join as join22 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -7908,7 +7871,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join23(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join22(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -7917,7 +7880,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
     load() {
       if (!filePath) return 0;
       try {
-        const parsed = JSON.parse(readFileSync19(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync18(filePath, "utf-8"));
         if (currentBotId != null && typeof parsed?.bot_id === "number" && parsed.bot_id !== currentBotId) {
           log2(`[telegram-ingest:${codeName}] offset cursor belongs to a different bot; ignoring (bot swap)`);
           return 0;
@@ -7935,8 +7898,8 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       if (!filePath || !dir) return;
       const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       try {
-        mkdirSync8(dir, { recursive: true, mode: 448 });
-        writeFileSync10(
+        mkdirSync7(dir, { recursive: true, mode: 448 });
+        writeFileSync9(
           tmpPath,
           JSON.stringify({
             offset,
@@ -8187,15 +8150,15 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync5, readFileSync as readFileSync20, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join24 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync19, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join23 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join24(homedir11(), ".augmented", "restart-flags");
+  return join23(homedir10(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join24(restartFlagsDir(), `${codeName}.flag`);
+  return join23(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
@@ -8204,7 +8167,7 @@ function readRestartFlags() {
   for (const entry of readdirSync5(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync20(join24(dir, entry), "utf8");
+      const raw = readFileSync19(join23(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -8223,7 +8186,7 @@ function readRestartFlags() {
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
   if (existsSync10(path)) {
-    rmSync5(path, { force: true });
+    rmSync4(path, { force: true });
   }
 }
 
@@ -8322,8 +8285,8 @@ async function sendError(flag, opts, text) {
 }
 
 // src/lib/restart-context.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname7, join as join25 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync20, writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, unlinkSync as unlinkSync3 } from "fs";
+import { dirname as dirname7, join as join24 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -8335,10 +8298,10 @@ function augmentedAgentDir(codeName) {
   return dirname7(getProjectDir(codeName));
 }
 function slackPendingInboundDir(codeName) {
-  return join25(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
+  return join24(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
 }
 function slackRestartContextDir(codeName) {
-  return join25(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
+  return join24(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
 }
 function sanitizeTopic(raw) {
   const cleaned = raw.replace(/\s+/g, " ").trim().replace(/[<>]/g, " ").replace(/\s+/g, " ").trim();
@@ -8380,7 +8343,7 @@ function safeReaddir(dir) {
 }
 function readStrandedMarker(path) {
   try {
-    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf-8"));
     if (typeof parsed.channel === "string" && typeof parsed.thread_ts === "string") {
       return { channel: parsed.channel, thread_ts: parsed.thread_ts };
     }
@@ -8389,8 +8352,8 @@ function readStrandedMarker(path) {
   return null;
 }
 function writeHintFile(path, dir, hint) {
-  mkdirSync10(dir, { recursive: true, mode: 448 });
-  writeFileSync12(path, JSON.stringify(hint), { mode: 384 });
+  mkdirSync9(dir, { recursive: true, mode: 448 });
+  writeFileSync11(path, JSON.stringify(hint), { mode: 384 });
 }
 function pruneHintsExcept(codeName, freshFilenames) {
   const ctxDir = slackRestartContextDir(codeName);
@@ -8398,7 +8361,7 @@ function pruneHintsExcept(codeName, freshFilenames) {
     if (!filename.endsWith(".json")) continue;
     if (freshFilenames.has(filename)) continue;
     try {
-      unlinkSync3(join25(ctxDir, filename));
+      unlinkSync3(join24(ctxDir, filename));
     } catch {
     }
   }
@@ -8419,7 +8382,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       }
       const markers = [];
       for (const filename of markerFilenames.slice(0, cap)) {
-        const parsed = readStrandedMarker(join25(markerDir, filename));
+        const parsed = readStrandedMarker(join24(markerDir, filename));
         if (parsed) markers.push({ filename, channel: parsed.channel, thread_ts: parsed.thread_ts });
       }
       if (markers.length === 0) {
@@ -8433,7 +8396,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       const freshFilenames = /* @__PURE__ */ new Set();
       for (const { filename, hint } of hints) {
         try {
-          writeHintFile(join25(ctxDir, filename), ctxDir, hint);
+          writeHintFile(join24(ctxDir, filename), ctxDir, hint);
           freshFilenames.add(filename);
         } catch (err) {
           log2(`[restart-context] ${codeName}: hint write failed for ${filename}: ${err.message}`);
@@ -9712,7 +9675,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync22(join26(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync21(join25(projectDir, ".mcp.json"), "utf-8");
     return createHash16("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -9720,7 +9683,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync22(join26(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync21(join25(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -9738,7 +9701,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync22(join26(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync21(join25(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -9842,7 +9805,7 @@ async function runAgentSessionToolBindProbes(agent, integrations, projectDir, op
   if (result && result.rebindCandidates.length > 0 && hostFlagStore().getBoolean("session-tool-rebind")) {
     let mcpJsonForRebind = null;
     try {
-      mcpJsonForRebind = JSON.parse(readFileSync22(join26(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync21(join25(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -9998,7 +9961,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync22(join26(projectDir, ".env.integrations"), "utf-8")
+      readFileSync21(join25(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -10094,7 +10057,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.474" : "dev";
+var agtCliVersion = true ? "0.28.475" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -10383,7 +10346,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
     if (existsSync11(path)) {
-      const raw = readFileSync22(path, "utf-8").trim();
+      const raw = readFileSync21(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -10399,8 +10362,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     }
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
-    mkdirSync11(dirname8(path), { recursive: true });
-    writeFileSync13(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync10(dirname8(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -10438,7 +10401,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync2("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join26(prefix, "bin");
+      const npmBin = join25(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -10555,7 +10518,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join26(homedir12(), ".augmented", ".last-self-update-applied");
+  return join25(homedir11(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -10583,7 +10546,7 @@ async function checkAndUpdateCli(opts) {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return "noop";
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join26(homedir12(), ".augmented", ".last-update-check");
+    const markerPath = join25(homedir11(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -10943,13 +10906,13 @@ async function checkClaudeAuth() {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync11(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join26(homedir12(), ".augmented");
+  const dir = join25(homedir11(), ".augmented");
   try {
-    mkdirSync11(dir, { recursive: true });
+    mkdirSync10(dir, { recursive: true });
   } catch {
   }
-  const p = join26(dir, ".eval-empty-mcp.json");
-  writeFileSync13(p, JSON.stringify({ mcpServers: {} }));
+  const p = join25(dir, ".eval-empty-mcp.json");
+  writeFileSync12(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -10974,7 +10937,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir12(),
+    cwd: homedir11(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -11040,10 +11003,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join26(config?.configDir ?? join26(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join25(config?.configDir ?? join25(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join26(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join25(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -11097,7 +11060,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join26(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join25(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -11114,7 +11077,7 @@ function claudeMdSizeFor(codeName) {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join26(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join25(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -11184,13 +11147,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync8, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync14 } = await import("fs");
-  const skillsDir = join26(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join26(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync8, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync13 } = await import("fs");
+  const skillsDir = join25(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join25(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync8(skillsDir).sort()) {
-    const skillFile = join26(skillsDir, dir, "SKILL.md");
+    const skillFile = join25(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -11234,7 +11197,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync14(claudeMdPath, next, "utf-8");
+    writeFileSync13(claudeMdPath, next, "utf-8");
     log2(
       injectSkillList ? `Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)` : `Refreshed CLAUDE.md managed block for '${codeName}' (skill list suppressed by claude-md-skills-index=false; ${entries.length} skills on disk)`
     );
@@ -11257,7 +11220,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-Y77TKSL6.js");
+      const { collectDiagnostics } = await import("../persistent-session-BBWEPY24.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor)
@@ -11364,7 +11327,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-Y77TKSL6.js");
+      const { collectDiagnostics } = await import("../persistent-session-BBWEPY24.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor) : void 0;
       let tailscaleHostname;
@@ -11478,7 +11441,7 @@ async function pollCycle() {
         collectResponsivenessProbes,
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs
-      } = await import("../responsiveness-probe-KIPMD2UJ.js");
+      } = await import("../responsiveness-probe-5AG6X2BN.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -11542,7 +11505,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-KIPMD2UJ.js");
+        } = await import("../responsiveness-probe-5AG6X2BN.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -11631,13 +11594,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync22(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync21(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join26(homedir12(), ".augmented", codeName);
+                  const wedgeHome = join25(homedir11(), ".augmented", codeName);
                   if (existsSync11(wedgeHome)) {
                     atomicWriteFileSync(
-                      join26(wedgeHome, "watchdog-give-up.json"),
+                      join25(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -11908,8 +11871,8 @@ async function pollCycle() {
         const adapter = resolveAgentFramework(prev.codeName);
         stopAgentRuntime2(prev.codeName, "removed-from-host");
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir2 = join26(adapter.getAgentDir(prev.codeName), "provision");
-        await cleanupAgentFiles(prev.codeName, agentDir2);
+        const agentDir = join25(adapter.getAgentDir(prev.codeName), "provision");
+        await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
     }
@@ -11995,10 +11958,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join26(homedir12(), ".augmented", codeName);
+          const dir = join25(homedir11(), ".augmented", codeName);
           if (!existsSync11(dir)) return;
           atomicWriteFileSync(
-            join26(dir, "watchdog-give-up.json"),
+            join25(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -12140,7 +12103,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir2 = join26(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join25(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`);
@@ -12180,7 +12143,7 @@ async function processAgent(agent, agentStates) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync11(agentDir2)
+        provisionDirExists: existsSync11(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -12205,7 +12168,7 @@ async function processAgent(agent, agentStates) {
     log(`Agent '${agent.code_name}' is revoked, cleaning up`);
     stopAgentRuntime2(agent.code_name, "revoked");
     killAgentChannelProcesses(agent.code_name, { log });
-    await cleanupAgentFiles(agent.code_name, agentDir2);
+    await cleanupAgentFiles(agent.code_name, agentDir);
     clearAgentCaches(agent.agent_id, agent.code_name);
     agentState.knownStatuses.set(agent.agent_id, agent.status);
     agentStates.push({
@@ -12314,7 +12277,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir2 = join26(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join25(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   agentRestartTimezoneInputs.set(agent.code_name, {
     agentTimezone: typeof refreshData.agent.timezone === "string" ? refreshData.agent.timezone : null,
@@ -12361,9 +12324,9 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter, renderIntegrationsSection);
     const changedFiles = [];
-    mkdirSync11(agentDir2, { recursive: true });
+    mkdirSync10(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join26(agentDir2, artifact.relativePath);
+      const filePath = join25(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -12382,8 +12345,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join26(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync22(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join25(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync21(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -12401,7 +12364,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync22(filePath, "utf-8");
+          existingRaw = readFileSync21(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -12417,7 +12380,7 @@ async function processAgent(agent, agentStates) {
       } else if (artifact.relativePath === "opencode.json") {
         let existingRaw = null;
         try {
-          existingRaw = readFileSync22(filePath, "utf-8");
+          existingRaw = readFileSync21(filePath, "utf-8");
         } catch {
         }
         const mergeResult = mergeOpencodeConfigArtifact(artifact.content, existingRaw);
@@ -12433,26 +12396,26 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync11(join26(agentDir2, "CHARTER.md"));
+      const isFirst = !existsSync11(join25(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 = join26(agentDir2, file.relativePath);
-        mkdirSync11(dirname8(filePath), { recursive: true });
+        const filePath = join25(agentDir, file.relativePath);
+        mkdirSync10(dirname8(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync13(filePath, file.content);
+          writeFileSync12(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join26(agentDir2, ".claude", "skills");
+        const provSkillsDir = join25(agentDir, ".claude", "skills");
         if (existsSync11(provSkillsDir)) {
           for (const folder of readdirSync7(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync6(join26(provSkillsDir, folder), { recursive: true });
+                rmSync5(join25(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -12465,7 +12428,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join26(agentDir2, file));
+        const h = hashFile(join25(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -12473,7 +12436,7 @@ async function processAgent(agent, agentStates) {
       const primaryModel2 = resolvedModelsForRegistration.primary ?? refreshData.agent.primary_model;
       const registeredAgents = await getOrCacheRegisteredAgents(frameworkAdapter, agent.code_name);
       if (!registeredAgents.has(agent.code_name)) {
-        const registered = await frameworkAdapter.registerAgent(agent.code_name, agentDir2, primaryModel2, agent.agent_id);
+        const registered = await frameworkAdapter.registerAgent(agent.code_name, agentDir, primaryModel2, agent.agent_id);
         if (registered) {
           registeredAgents.add(agent.code_name);
           log(`Registered '${agent.code_name}' in ${frameworkAdapter.label}`);
@@ -12483,14 +12446,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join26(agentDir2, ".claude", "workflows");
+        const provWorkflowsDir = join25(agentDir, ".claude", "workflows");
         if (existsSync11(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
           for (const file of readdirSync7(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync6(join26(provWorkflowsDir, file));
+              rmSync5(join25(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -12499,7 +12462,7 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (frameworkAdapter.deployArtifactsToProject) {
-      frameworkAdapter.deployArtifactsToProject(agent.code_name, agentDir2);
+      frameworkAdapter.deployArtifactsToProject(agent.code_name, agentDir);
     }
   } catch (err) {
     log(`Provision failed for '${agent.code_name}': ${err.message}`);
@@ -12569,10 +12532,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync11(agentDir2)) {
+  if (written && existsSync11(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join26(agentDir2, file));
+      const localHash = hashFile(join25(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -12583,7 +12546,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join26(agentDir2, file));
+          localHashes[file] = hashFile(join25(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -12785,15 +12748,15 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join26(homedir12(), ".augmented", agent.code_name);
-        mkdirSync11(agentAugmentedDir, { recursive: true });
+        const agentAugmentedDir = join25(homedir11(), ".augmented", agent.code_name);
+        mkdirSync10(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
           at: (/* @__PURE__ */ new Date()).toISOString(),
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join26(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join25(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -12981,19 +12944,19 @@ async function processAgent(agent, agentStates) {
   const agentSessionMode = refreshData.agent.session_mode;
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
-      const agentProvisionDir = agentDir2;
-      const projectDir = join26(homedir12(), ".augmented", agent.code_name, "project");
-      mkdirSync11(agentProvisionDir, { recursive: true });
-      mkdirSync11(projectDir, { recursive: true });
-      const provisionMcpPath = join26(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join26(projectDir, ".mcp.json");
+      const agentProvisionDir = agentDir;
+      const projectDir = join25(homedir11(), ".augmented", agent.code_name, "project");
+      mkdirSync10(agentProvisionDir, { recursive: true });
+      mkdirSync10(projectDir, { recursive: true });
+      const provisionMcpPath = join25(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join25(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync22(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync21(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join26(homedir12(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join25(homedir11(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -13019,7 +12982,7 @@ async function processAgent(agent, agentStates) {
           // ~/.augmented/<codeName>/.current-turn-initiator.json. Note getAgentDir
           // returns the agent root (NOT the /provision subdir `agentDir` points at),
           // so it byte-matches the broker readers' path.
-          AGT_TURN_INITIATOR_FILE: join26(
+          AGT_TURN_INITIATOR_FILE: join25(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -13039,10 +13002,10 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join26(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join25(projectDir, ".mcp-channels.json");
       if (existsSync11(staleChannelsPath)) {
         try {
-          rmSync6(staleChannelsPath, { force: true });
+          rmSync5(staleChannelsPath, { force: true });
         } catch {
         }
       }
@@ -13129,7 +13092,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join26(homedir12(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join25(homedir11(), ".augmented", agent.code_name, "project");
         let probeSet = integrations;
         try {
           const quarantined = await api.post("/host/agent-integrations/quarantined", { agent_id: agent.agent_id });
@@ -13175,7 +13138,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join26(homedir12(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join25(homedir11(), ".augmented", agent.code_name, "project");
         probeRan = await runAgentSessionToolBindProbes(agent, integrations, probeProjectDir, { forceDue });
       } catch (err) {
         log(`Session-tool-bind probe failed for '${agent.code_name}': ${err.message}`);
@@ -13252,11 +13215,11 @@ async function processAgent(agent, agentStates) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join26(homedir12(), ".augmented", agent.code_name, "project");
-        const envIntPath = join26(projectDir, ".env.integrations");
+        const projectDir = join25(homedir11(), ".augmented", agent.code_name, "project");
+        const envIntPath = join25(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync22(envIntPath, "utf-8");
+          preWriteEnv = readFileSync21(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -13275,9 +13238,9 @@ async function processAgent(agent, agentStates) {
         }
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join26(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync22(envIntPath, "utf-8");
-            const mcpContent = readFileSync22(projectMcpPath, "utf-8");
+            const projectMcpPath = join25(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync21(envIntPath, "utf-8");
+            const mcpContent = readFileSync21(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -13523,17 +13486,17 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const { readdirSync: readdirSync8, rmSync: rmSync7 } = await import("fs");
-        const { homedir: homedir13 } = await import("os");
+        const { readdirSync: readdirSync8, rmSync: rmSync6 } = await import("fs");
+        const { homedir: homedir12 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join26(homedir13(), ".augmented", agent.code_name, "skills"),
+          join25(homedir12(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join26(homedir13(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join25(homedir12(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join26(agentDir2, ".claude", "skills")
+          join25(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync11(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
@@ -13549,9 +13512,9 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join26(dir, entry);
+            const p = join25(dir, entry);
             if (existsSync11(p)) {
-              rmSync7(p, { recursive: true, force: true });
+              rmSync6(p, { recursive: true, force: true });
             }
           }
           log(`Removed ${reason} '${entry}' for '${agent.code_name}' (framework=${frameworkId2})`);
@@ -13569,7 +13532,7 @@ async function processAgent(agent, agentStates) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join26(homedir12(), ".augmented", agent.code_name)
+          join25(homedir11(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -13589,16 +13552,16 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join26(homedir12(), ".augmented", agent.code_name, "skills"),
-            join26(homedir12(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join26(agentDir2, ".claude", "skills")
+            join25(homedir11(), ".augmented", agent.code_name, "skills"),
+            join25(homedir11(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join25(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join26(dir, id);
-              if (existsSync11(p) && existsSync11(join26(p, "SKILL.md"))) {
-                rmSync6(p, { recursive: true, force: true });
+              const p = join25(dir, id);
+              if (existsSync11(p) && existsSync11(join25(p, "SKILL.md"))) {
+                rmSync5(p, { recursive: true, force: true });
                 prunedAny = true;
               }
             }
@@ -13745,7 +13708,10 @@ async function processAgent(agent, agentStates) {
           );
         }
       } else if (nudgeAction === "nudge") {
-        const tickLimitedUntil = readUsageLimitUntil({ codeName: agent.code_name });
+        const tickLimitedUntil = readUsageCapUntil({
+          codeName: agent.code_name,
+          projectDir: getProjectDir(agent.code_name)
+        });
         if (tickLimitedUntil) {
           if (shouldLogUsageCapDeferral("kanban-tick", agent.code_name, tickLimitedUntil)) {
             log(
@@ -13825,8 +13791,8 @@ async function processAgent(agent, agentStates) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join26(getProjectDir(agent.code_name), ".mcp.json");
-          mcpJsonParsed = JSON.parse(readFileSync22(mcpPath, "utf-8"));
+          const mcpPath = join25(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync21(mcpPath, "utf-8"));
         } catch {
         }
         reapMissingMcpSessions({
@@ -14249,10 +14215,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync11(agentDir2)) {
+  if (trackedFiles.length > 0 && existsSync11(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join26(agentDir2, file));
+      const h = hashFile(join25(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -14267,7 +14233,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join26(homedir12(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join25(homedir11(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -14321,20 +14287,6 @@ var lastModelApiErrorSig = /* @__PURE__ */ new Map();
 var DAY_ROLLOVER_FORCE_GRACE_MIN = 30;
 var persistentSessionStuckTracker = new PersistentSessionStuckTracker();
 var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
-var claudeAccountByAgent = /* @__PURE__ */ new Map();
-function _resetClaudeAccountByAgent() {
-  claudeAccountByAgent.clear();
-}
-function clearUsageLimitMarkerOnAccountChange(codeName, fingerprint3, log2) {
-  if (!fingerprint3) return;
-  const previous = claudeAccountByAgent.get(codeName);
-  claudeAccountByAgent.set(codeName, fingerprint3);
-  if (previous === void 0 || previous === fingerprint3) return;
-  log2(
-    `[usage-banner] signed-in Claude account changed for '${codeName}' (${previous} \u2192 ${fingerprint3}) \u2014 clearing the usage-limit marker; the cap belonged to the previous account (ENG-8202)`
-  );
-  clearUsageLimitMarker(codeName, log2);
-}
 var opencodeCredentialFingerprintBySession = /* @__PURE__ */ new Map();
 var egressAllowlistBySession = /* @__PURE__ */ new Map();
 function deriveEgressAllowlist(toolsRaw) {
@@ -14369,7 +14321,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join26(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join25(getFramework("opencode").getAgentDir(codeName), "provision");
   const serveEnv = {
     AGT_HOST: requireHost(),
     AGT_API_KEY: getApiKey() ?? void 0,
@@ -14412,8 +14364,8 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join26(projectDir, ".mcp.json");
-  const claudeMdPath = join26(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join25(projectDir, ".mcp.json");
+  const claudeMdPath = join25(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -14552,7 +14504,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   let dayRolloverDeferred = false;
   let dayRolloverForced = false;
   const claudeAccountFingerprint = !openRouterForAgent && claudeAuthMode === "subscription" ? await getClaudeAccountFingerprint() : null;
-  clearUsageLimitMarkerOnAccountChange(codeName, claudeAccountFingerprint, log);
+  noteClaudeAccountChange(codeName, claudeAccountFingerprint, log);
   const currentAuthTuple = openRouterForAgent ? `openrouter:${openRouterForAgent.fingerprint ?? openRouterForAgent.model}` : `${claudeAuthMode}:${anthropicApiKeyFingerprint ?? "none"}${claudeAccountFingerprint ? `:${claudeAccountFingerprint}` : ""}`;
   const recordedAuthTuple = claudeAuthTupleBySession.get(codeName);
   if (recordedAuthTuple && recordedAuthTuple !== currentAuthTuple && isSessionHealthy(codeName)) {
@@ -14736,22 +14688,11 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash16("sha256")
       // host. An agent with no per-agent override inherits the host-wide value;
       // the launcher still lets an operator AGT_NOTIFY_DISPATCH env override win.
       notifyDispatchMode: hostFlagStore().getStringForAgent("notify-dispatch", agent.agent_id),
-      // ENG-8201: materialize usage-limit-reactive-notice into the spawn env
-      // (AGT_USAGE_LIMIT_REACTIVE_MODE) so the channel MCPs report a usage cap
-      // reactively instead of refusing to dispatch on a prediction. Resolved
-      // PER-AGENT so the rollout can start with one agent rather than a whole
-      // host, and materialized (not just left to the flags-cache) because an
-      // isolated agent's container never mounts that cache — without this the
-      // flip reaches nothing running under Docker isolation.
-      usageLimitReactiveMode: hostFlagStore().getStringForAgent(
-        "usage-limit-reactive-notice",
-        agent.agent_id
-      ),
       // ENG-8269: materialize wedge-transient-notice into the spawn env so the
       // channel MCPs can tell a waiting user their turn died on a transient
-      // provider failure. Same isolation reasoning as the line above — the
-      // flags-cache is not mounted into an agent's container, so without this the
-      // flip reaches nothing running under Docker.
+      // provider failure. Materialized rather than left to the flags-cache
+      // because an isolated agent's container never mounts that cache — without
+      // this the flip reaches nothing running under Docker isolation.
       turnFailureNoticeEnabled: hostFlagStore().getBoolean("wedge-transient-notice"),
       egressAllowlist,
       log
@@ -14816,7 +14757,10 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash16("sha256")
     }
     let deferReadyForUsageCap = false;
     if (ready.length > 0) {
-      const schedLimitedUntil = readUsageLimitUntil({ codeName });
+      const schedLimitedUntil = readUsageCapUntil({
+        codeName,
+        projectDir: getProjectDir(codeName)
+      });
       if (schedLimitedUntil) {
         if (shouldLogUsageCapDeferral("persistent-scheduler", codeName, schedLimitedUntil)) {
           log(
@@ -15037,7 +14981,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     void api.post("/host/restart-ack", { host_id: hostId, agent_id: agentId, restart_requested_at: requestedAt }).catch((err) => log(`[restart-lane] ack failed for '${codeName}': ${err.message}`));
     void (async () => {
       try {
-        const { collectDiagnostics } = await import("../persistent-session-Y77TKSL6.js");
+        const { collectDiagnostics } = await import("../persistent-session-BBWEPY24.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor)
@@ -15087,7 +15031,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-Y77TKSL6.js");
+      const { collectDiagnostics } = await import("../persistent-session-BBWEPY24.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor)
@@ -15377,9 +15321,9 @@ async function processDirectChatMessage(agent, msg) {
     const useDoorbell = hostFlagStore().getBoolean("direct-chat-doorbell") || isolationMode(agent.codeName) === "docker";
     if (useDoorbell) {
       try {
-        const doorbell = directChatDoorbellPath(agent.agentId, homedir12());
-        mkdirSync11(dirname8(doorbell), { recursive: true });
-        writeFileSync13(doorbell, String(Date.now()));
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir11());
+        mkdirSync10(dirname8(doorbell), { recursive: true });
+        writeFileSync12(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
         return;
       } catch (err) {
@@ -15487,9 +15431,9 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   }
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
-    const doorbell = directChatDoorbellPath(agentId, homedir12());
-    mkdirSync11(dirname8(doorbell), { recursive: true });
-    writeFileSync13(doorbell, String(Date.now()));
+    const doorbell = directChatDoorbellPath(agentId, homedir11());
+    mkdirSync10(dirname8(doorbell), { recursive: true });
+    writeFileSync12(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -15545,7 +15489,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-62G3PXXX.js");
+  } = await import("../claude-pair-runtime-IIQ6O7QX.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));
@@ -15799,8 +15743,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join26(configDir, agent.code_name, "project");
-  const memoryDir = join26(projectDir, "memory");
+  const projectDir = join25(configDir, agent.code_name, "project");
+  const memoryDir = join25(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`);
@@ -15818,7 +15762,7 @@ async function syncMemories(agent, configDir, log2) {
     for (const file of readdirSync7(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync22(join26(memoryDir, file), "utf-8");
+        const raw = readFileSync21(join25(memoryDir, file), "utf-8");
         const fileHash = createHash16("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -15843,7 +15787,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync22(join26(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync21(join25(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -15871,14 +15815,14 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync11(memoryDir, { recursive: true });
+      mkdirSync10(memoryDir, { recursive: true });
       let written = 0;
       let overwritten = 0;
       for (let i = 0; i < dbMemories.memories.length; i++) {
         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 = join26(memoryDir, `${slug}.md`);
+        const filePath = join25(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -15890,14 +15834,14 @@ ${mem.content}
         if (existsSync11(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync22(filePath, "utf-8");
+            existing = readFileSync21(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync13(filePath, desired);
+          writeFileSync12(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync13(filePath, desired);
+          writeFileSync12(filePath, desired);
           written++;
         }
       }
@@ -15913,10 +15857,10 @@ ${mem.content}
     return false;
   }
 }
-async function cleanupAgentFiles(codeName, agentDir2) {
-  if (existsSync11(agentDir2)) {
+async function cleanupAgentFiles(codeName, agentDir) {
+  if (existsSync11(agentDir)) {
     try {
-      rmSync6(agentDir2, { recursive: true, force: true });
+      rmSync5(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
     } catch (err) {
       log(`Failed to remove provision dir for '${codeName}': ${err.message}`);
@@ -16154,7 +16098,7 @@ function startManager(opts) {
   try {
     const stateFile = getStateFile();
     if (existsSync11(stateFile)) {
-      const raw = readFileSync22(stateFile, "utf-8");
+      const raw = readFileSync21(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -16181,7 +16125,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=${join26(homedir12(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join25(homedir11(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -16210,7 +16154,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync22(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync21(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -16307,14 +16251,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join26(homedir12(), ".augmented", "_mcp");
-  mkdirSync11(targetDir, { recursive: true });
+  const targetDir = join25(homedir11(), ".augmented", "_mcp");
+  mkdirSync10(targetDir, { recursive: true });
   const moduleDir = dirname8(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join26(dir, "dist", "mcp");
-    if (existsSync11(join26(candidate, "index.js"))) {
+    const candidate = join25(dir, "dist", "mcp");
+    if (existsSync11(join25(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -16330,7 +16274,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync11(p)) return null;
-      return createHash16("sha256").update(readFileSync22(p)).digest("hex");
+      return createHash16("sha256").update(readFileSync21(p)).digest("hex");
     } catch {
       return null;
     }
@@ -16394,8 +16338,8 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join26(mcpSourceDir, file);
-    const dst = join26(targetDir, file);
+    const src = join25(mcpSourceDir, file);
+    const dst = join25(targetDir, file);
     if (!existsSync11(src)) continue;
     const before = fileHash(dst);
     try {
@@ -16413,23 +16357,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join26(targetDir, "index.js");
+  const localMcpPath = join25(targetDir, "index.js");
   try {
-    const agentsDir = join26(homedir12(), ".augmented", "agents");
+    const agentsDir = join25(homedir11(), ".augmented", "agents");
     if (existsSync11(agentsDir)) {
       for (const entry of readdirSync7(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join26(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join25(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync22(mcpJsonPath, "utf-8");
+            const raw = readFileSync21(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync13(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync12(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }
@@ -16466,13 +16410,11 @@ process.on("disconnect", () => {
 export {
   BACK_ONLINE_GREETING_GUIDANCE,
   DAY_ROLLOVER_FORCE_GRACE_MIN,
-  _resetClaudeAccountByAgent,
   applyRestartAcks,
   cancelKanbanNoticeOnDrain,
   claudeCodeUpgradeMarkerPath,
   claudeCodeUpgradeThrottled,
   claudeManagedSettingsPath,
-  clearUsageLimitMarkerOnAccountChange,
   dashboardRestartBreakerReason,
   ensureClaudeManagedSettings,
   extractCharterSlackPeers,