@integrity-labs/agt-cli 0.28.1047 → 0.28.1048

package/dist/lib/manager-worker.js

@@ -66,7 +66,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-2DUVDY2Y.js";
+} from "../chunk-4BOPLS65.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -149,7 +149,7 @@ import {
   takeZombieDetection,
   toOpencodeModel,
   writeEgressAllowlist
-} from "../chunk-QGUJSDN3.js";
+} from "../chunk-QGGDQMWF.js";
 import {
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   AnchorSessionClient,
@@ -160,6 +160,8 @@ import {
   DEFAULT_FRAMEWORK,
   DEFAULT_NEIGHBOURHOOD_MS,
   EXTRACTOR_IDENTIFIER_RULE,
+  FAILING_TURN_DEFAULT_MAX_TURN_MS,
+  FAILING_TURN_RUN_DEFAULT_THRESHOLD,
   FLAGS_SCHEMA_VERSION,
   FLAG_REGISTRY,
   FORCED_UPDATE_HARD_DEADLINE_MS,
@@ -171,6 +173,7 @@ import {
   KANBAN_CHECK_COMMAND,
   KANBAN_NUDGE_ACTIONABLE_STATUSES,
   MAX_AVATAR_ENV_URL_BYTES,
+  NO_FAILING_TURN_RUN,
   SCHEDULED_TURN_MARKER_FILENAME,
   SKILLS_INDEX_SECTION_END,
   SKILLS_INDEX_SECTION_START,
@@ -179,6 +182,7 @@ import {
   UNKNOWN_RATE_LIMIT,
   agentHasRules,
   agentRulesRestartBasis,
+  analyzeFailingTurnRun,
   appendDmFooter,
   attributeTranscriptUsageByRun,
   bannerRemedyFor,
@@ -254,7 +258,7 @@ import {
   subagentActivityAgeSeconds,
   sumTranscriptUsageInWindow,
   transcriptActivityAgeSeconds
-} from "../chunk-5GCYYWKW.js";
+} from "../chunk-APAEM42J.js";
 import {
   classifyUnanswerablePane,
   paneRemedy
@@ -273,7 +277,7 @@ import "../chunk-DGUM43GV.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash20 } from "crypto";
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15, existsSync as existsSync19, rmSync as rmSync8, readdirSync as readdirSync12, statSync as statSync13, unlinkSync as unlinkSync6, renameSync as renameSync11, utimesSync as utimesSync4 } from "fs";
+import { readFileSync as readFileSync34, writeFileSync as writeFileSync18, mkdirSync as mkdirSync15, existsSync as existsSync19, rmSync as rmSync8, readdirSync as readdirSync13, statSync as statSync14, unlinkSync as unlinkSync6, renameSync as renameSync11, utimesSync as utimesSync4 } from "fs";
 
 // src/lib/atomic-file-replace.ts
 import { copyFileSync, renameSync, unlinkSync } from "fs";
@@ -299,7 +303,7 @@ function defaultUnique() {
 
 // src/lib/manager-worker.ts
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join42, dirname as dirname11, delimiter as pathDelimiter } from "path";
+import { join as join43, dirname as dirname11, delimiter as pathDelimiter } from "path";
 import { homedir as homedir17 } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -3684,10 +3688,115 @@ async function maybeReportTokenUsage(args) {
   state3.set(codeName, next);
 }
 
-// src/lib/workflow-run-reconciler.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync2 } from "fs";
+// src/lib/failing-turn-monitor.ts
+import { closeSync, openSync, readdirSync as readdirSync2, readSync, statSync as statSync2 } from "fs";
 import { join as join17 } from "path";
-var MIN_CHECK_INTERVAL_MS3 = 5 * 6e4;
+var MIN_CHECK_INTERVAL_MS3 = 3e4;
+var FAILING_TURN_TAIL_BYTES = 512 * 1024;
+var ACTIVE_TRANSCRIPT_WINDOW_MS = 60 * 60 * 1e3;
+var STATE_TTL_MS = 10 * 60 * 1e3;
+var state4 = /* @__PURE__ */ new Map();
+function positiveIntFromEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+function failingTurnThreshold() {
+  return positiveIntFromEnv("AGT_FAILING_TURN_THRESHOLD", FAILING_TURN_RUN_DEFAULT_THRESHOLD);
+}
+function failingTurnLiveMs() {
+  return positiveIntFromEnv("AGT_FAILING_TURN_LIVE_MS", FAILING_TURN_DEFAULT_LIVE_MS);
+}
+var FAILING_TURN_DEFAULT_LIVE_MS = 10 * 60 * 1e3;
+function failingTurnMaxMs() {
+  return positiveIntFromEnv("AGT_FAILING_TURN_MAX_MS", FAILING_TURN_DEFAULT_MAX_TURN_MS);
+}
+function newestActiveTranscript(dir, nowMs) {
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of names) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join17(dir, name);
+    try {
+      const st = statSync2(path);
+      if (!st.isFile() || nowMs - st.mtimeMs > ACTIVE_TRANSCRIPT_WINDOW_MS) continue;
+      if (best === null || st.mtimeMs > best.mtimeMs) best = { path, mtimeMs: st.mtimeMs, size: st.size };
+    } catch {
+      continue;
+    }
+  }
+  return best;
+}
+function readTail(path, size, bytes = FAILING_TURN_TAIL_BYTES) {
+  const length = Math.min(size, bytes);
+  const buf = Buffer.alloc(length);
+  const fd = openSync(path, "r");
+  try {
+    readSync(fd, buf, 0, length, size - length);
+  } finally {
+    closeSync(fd);
+  }
+  return buf.toString("utf-8");
+}
+function maybeCheckFailingTurns(args) {
+  const nowMs = args.now ?? Date.now();
+  const prev = state4.get(args.agentId);
+  if (prev && nowMs - prev.checkedAt < MIN_CHECK_INTERVAL_MS3) return;
+  try {
+    const dir = args.transcriptDir ?? sessionTranscriptDir(getProjectDir(args.codeName));
+    const file = newestActiveTranscript(dir, nowMs);
+    if (file === null) {
+      state4.set(args.agentId, { run: NO_FAILING_TURN_RUN, checkedAt: nowMs, file: null });
+      return;
+    }
+    if (prev?.file && prev.file.path === file.path && prev.file.mtimeMs === file.mtimeMs && prev.file.size === file.size) {
+      prev.checkedAt = nowMs;
+      return;
+    }
+    const run = analyzeFailingTurnRun(readTail(file.path, file.size), { maxTurnMs: failingTurnMaxMs() });
+    state4.set(args.agentId, { run, checkedAt: nowMs, file });
+  } catch (err) {
+    args.log(`[failing-turns] check failed for '${args.codeName}': ${err.message}`);
+    if (prev) prev.checkedAt = nowMs;
+  }
+}
+function failingTurnLoops(now = Date.now(), threshold = failingTurnThreshold(), liveMs = failingTurnLiveMs()) {
+  const failing = [];
+  const recovered = [];
+  for (const [agentId, s] of state4) {
+    if (now - s.checkedAt > STATE_TTL_MS) {
+      state4.delete(agentId);
+      continue;
+    }
+    const live = s.run.lastFailureAtMs !== null && now - s.run.lastFailureAtMs <= liveMs;
+    if (s.run.consecutive >= threshold && live) {
+      failing.push({
+        agent_id: agentId,
+        verdict: "failing",
+        consecutive: s.run.consecutive,
+        first_failure_at: s.run.firstFailureAtMs === null ? null : new Date(s.run.firstFailureAtMs).toISOString(),
+        last_failure_at: s.run.lastFailureAtMs === null ? null : new Date(s.run.lastFailureAtMs).toISOString(),
+        last_status: s.run.lastStatus,
+        last_error_code: s.run.lastErrorCode
+      });
+    } else if (s.run.newestTurn === "served") {
+      recovered.push({ agent_id: agentId, verdict: "recovered" });
+    }
+  }
+  failing.sort((a, b) => b.consecutive - a.consecutive);
+  return [...failing, ...recovered];
+}
+
+// src/lib/workflow-run-reconciler.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { join as join18 } from "path";
+var MIN_CHECK_INTERVAL_MS4 = 5 * 6e4;
 var SETTLE_MS = 3e4;
 var TRANSCRIPT_MTIME_WINDOW_MS2 = 2 * 24 * 60 * 60 * 1e3;
 var MAX_RUNS_PER_TICK = 20;
@@ -3700,15 +3809,15 @@ function collectJsonlRecursive(dir, minMtimeMs, out, depth) {
   if (depth > MAX_SUBAGENT_DEPTH) return;
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync3(dir);
   } catch {
     return;
   }
   for (const name of entries) {
-    const p = join17(dir, name);
+    const p = join18(dir, name);
     let st;
     try {
-      st = statSync2(p);
+      st = statSync3(p);
     } catch {
       continue;
     }
@@ -3723,15 +3832,15 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
   const out = [];
   let entries;
   try {
-    entries = readdirSync2(transcriptDir);
+    entries = readdirSync3(transcriptDir);
   } catch {
     return out;
   }
   for (const name of entries) {
-    const path = join17(transcriptDir, name);
+    const path = join18(transcriptDir, name);
     let st;
     try {
-      st = statSync2(path);
+      st = statSync3(path);
     } catch {
       continue;
     }
@@ -3740,7 +3849,7 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
       continue;
     }
     if (st.isDirectory()) {
-      collectJsonlRecursive(join17(path, "subagents"), minMtimeMs, out, 0);
+      collectJsonlRecursive(join18(path, "subagents"), minMtimeMs, out, 0);
     }
   }
   return out;
@@ -3765,7 +3874,7 @@ async function maybeReconcileWorkflowRunTokens(args) {
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
   const prev = lastCheckedAt.get(codeName);
-  if (prev !== void 0 && nowMs - prev < MIN_CHECK_INTERVAL_MS3) return;
+  if (prev !== void 0 && nowMs - prev < MIN_CHECK_INTERVAL_MS4) return;
   lastCheckedAt.set(codeName, nowMs);
   let runs;
   try {
@@ -3830,8 +3939,8 @@ async function maybeReconcileWorkflowRunTokens(args) {
 }
 
 // src/lib/conversation-evaluator.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
-import { join as join18 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync13, statSync as statSync4 } from "fs";
+import { join as join19 } from "path";
 
 // src/lib/detect-meta-egress.ts
 var REPOST_PREAMBLE_WINDOW = 200;
@@ -3877,7 +3986,7 @@ function detectMetaEgress(agentMessages) {
 }
 
 // src/lib/conversation-evaluator.ts
-var MIN_CHECK_INTERVAL_MS4 = 5 * 6e4;
+var MIN_CHECK_INTERVAL_MS5 = 5 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS3 = 7 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS = 5 * 6e4;
 var MAX_TURN_CHARS = 1500;
@@ -4006,7 +4115,7 @@ function selectEvalBackend(opts) {
     }
   };
 }
-var state4 = /* @__PURE__ */ new Map();
+var state5 = /* @__PURE__ */ new Map();
 function channelRefTokens(channelRef) {
   return channelRef.split(":").slice(1).filter((p) => p && p !== "dm");
 }
@@ -4182,11 +4291,11 @@ async function maybeEvaluateConversations(args) {
   const { api: api2, backend, codeName, agentId, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  const existing = state4.get(codeName);
-  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS4) {
+  const existing = state5.get(codeName);
+  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS5) {
     return;
   }
-  state4.set(codeName, { lastCheckedAt: nowMs });
+  state5.set(codeName, { lastCheckedAt: nowMs });
   let pending2;
   try {
     const resp = await api2.get(
@@ -4311,12 +4420,12 @@ function readRecentTurns(dir, nowMs) {
   const visit = (d) => {
     let entries;
     try {
-      entries = readdirSync3(d, { withFileTypes: true });
+      entries = readdirSync4(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
-      const full = join18(d, ent.name);
+      const full = join19(d, ent.name);
       if (ent.isDirectory()) {
         visit(full);
         continue;
@@ -4324,7 +4433,7 @@ function readRecentTurns(dir, nowMs) {
       if (!ent.isFile() || !ent.name.endsWith(".jsonl")) continue;
       let mtimeMs;
       try {
-        mtimeMs = statSync3(full).mtimeMs;
+        mtimeMs = statSync4(full).mtimeMs;
       } catch {
         continue;
       }
@@ -4451,7 +4560,7 @@ async function maybeEmitRoutineCandidates(args) {
 }
 
 // src/lib/memory-extractor.ts
-var MIN_CHECK_INTERVAL_MS5 = 10 * 6e4;
+var MIN_CHECK_INTERVAL_MS6 = 10 * 6e4;
 var WINDOW_PAD_MS2 = 5 * 6e4;
 var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["user", "feedback", "project", "reference"]);
 var SECRET_PATTERNS = [
@@ -4469,7 +4578,7 @@ var SECRET_PATTERNS = [
 function scrubSensitive(text) {
   return scrubPreservingIdentifiers(text, SECRET_PATTERNS);
 }
-var state5 = /* @__PURE__ */ new Map();
+var state6 = /* @__PURE__ */ new Map();
 function buildExtractionPrompt(channel, transcript) {
   return `You are extracting durable, reusable memories from one completed ${channel} conversation between an AI agent and an end-user. A good memory is a stable preference, fact, correction, or recurring work context that will help the agent in FUTURE conversations \u2014 not a one-off task detail or pleasantry.
 
@@ -4589,12 +4698,12 @@ async function maybeExtractMemories(args) {
   const { api: api2, backend, codeName, agentId, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  const existing = state5.get(codeName);
-  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS5) {
+  const existing = state6.get(codeName);
+  if (existing && nowMs - existing.lastCheckedAt < MIN_CHECK_INTERVAL_MS6) {
     return;
   }
   const st = { lastCheckedAt: nowMs, salvaged: existing?.salvaged ?? /* @__PURE__ */ new Set() };
-  state5.set(codeName, st);
+  state6.set(codeName, st);
   let pending2;
   try {
     const resp = await api2.get(
@@ -4704,17 +4813,17 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 
 // src/lib/tool-call-audit.ts
 import { homedir as homedir11 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/lib/agent-logging-mode.ts
 import { readFileSync as readFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var LOGGING_MODES = ["hash-only", "redacted", "full-local"];
 function charterPath(codeName, homeDir) {
   const home = homeDir ?? (process.env["HOME"]?.trim() || homedir8());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join19(home, ".augmented", key, "provision", "CHARTER.md");
+  return join20(home, ".augmented", key, "provision", "CHARTER.md");
 }
 function readAgentLoggingMode(codeName, homeDir) {
   let raw;
@@ -4745,13 +4854,13 @@ function loggingModeWithholdsTargets(reading) {
 import { randomBytes } from "crypto";
 import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync15, renameSync as renameSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname7, join as join20 } from "path";
+import { dirname as dirname7, join as join21 } from "path";
 var SALT_BYTES = 32;
 var SALT_RE = /^[0-9a-f]{64}$/;
 function pathSaltPath(codeName, homeDir) {
   const home = homeDir ?? (process.env["HOME"]?.trim() || homedir9());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join20(home, ".augmented", key, "tool-call-path-salt");
+  return join21(home, ".augmented", key, "tool-call-path-salt");
 }
 function readToolCallPathSalt(codeName, homeDir) {
   let file;
@@ -4785,11 +4894,11 @@ function readToolCallPathSalt(codeName, homeDir) {
 }
 
 // src/lib/tool-call-scan.ts
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync5 } from "fs";
 
 // src/lib/tool-call-extractor.ts
-import { closeSync, fstatSync, openSync, readFileSync as readFileSync16, readSync, readdirSync as readdirSync4 } from "fs";
-import { basename as basename2, join as join21, relative } from "path";
+import { closeSync as closeSync2, fstatSync, openSync as openSync2, readFileSync as readFileSync16, readSync as readSync2, readdirSync as readdirSync5 } from "fs";
+import { basename as basename2, join as join22, relative } from "path";
 import { StringDecoder } from "string_decoder";
 
 // src/lib/tool-call-redaction.ts
@@ -4918,7 +5027,7 @@ function redactToolTargetInner(toolName, input, ctx) {
 var EXTRACTOR_VERSION = "e1";
 function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
   const files = [];
-  const mainAbs = join21(transcriptDir, `${sessionId}.jsonl`);
+  const mainAbs = join22(transcriptDir, `${sessionId}.jsonl`);
   files.push({
     absPath: mainAbs,
     relPath: relative(projectsRoot, mainAbs),
@@ -4926,16 +5035,16 @@ function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
     isSubagent: false,
     subagentId: null
   });
-  const subDir = join21(transcriptDir, sessionId, "subagents");
+  const subDir = join22(transcriptDir, sessionId, "subagents");
   let entries;
   try {
-    entries = readdirSync4(subDir);
+    entries = readdirSync5(subDir);
   } catch {
     return files;
   }
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const abs = join21(subDir, name);
+    const abs = join22(subDir, name);
     const stem = basename2(name, ".jsonl");
     files.push({
       absPath: abs,
@@ -5038,7 +5147,7 @@ var WINDOW_BUDGET_BYTES = 4 * 1024 * 1024;
 function extractTranscriptWindow(file, opts, from) {
   let fd;
   try {
-    fd = openSync(file.absPath, "r");
+    fd = openSync2(file.absPath, "r");
   } catch {
     return {
       records: [],
@@ -5084,7 +5193,7 @@ function extractTranscriptWindow(file, opts, from) {
         hitBudget = true;
         break;
       }
-      const bytesRead = readSync(fd, buf, 0, WINDOW_CHUNK_BYTES, position);
+      const bytesRead = readSync2(fd, buf, 0, WINDOW_CHUNK_BYTES, position);
       if (bytesRead <= 0) break;
       position += bytesRead;
       carry += decoder.write(buf.subarray(0, bytesRead));
@@ -5107,7 +5216,7 @@ function extractTranscriptWindow(file, opts, from) {
   } catch {
   } finally {
     try {
-      closeSync(fd);
+      closeSync2(fd);
     } catch {
     }
   }
@@ -5135,7 +5244,7 @@ function extractTranscriptWindow(file, opts, from) {
 // src/lib/tool-call-cursor.ts
 import { existsSync as existsSync5, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var COVERAGE_DISPOSITIONS = [
   "ok",
   "not_entitled",
@@ -5190,7 +5299,7 @@ function parseCursorKey(key) {
 function cursorStatePath(codeName, homeDir) {
   const home = homeDir ?? (process.env["HOME"]?.trim() || homedir10());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join22(home, ".augmented", key, "tool-call-cursors.json");
+  return join23(home, ".augmented", key, "tool-call-cursors.json");
 }
 function loadCursors(path) {
   const out = /* @__PURE__ */ new Map();
@@ -5412,7 +5521,7 @@ function chunk(items, size) {
 }
 function endOfFile(absPath) {
   try {
-    return { byteOffset: statSync4(absPath).size, lineOffset: 0 };
+    return { byteOffset: statSync5(absPath).size, lineOffset: 0 };
   } catch {
     return null;
   }
@@ -5567,9 +5676,9 @@ async function reportCoverage(args, cursors, touched, log2) {
 }
 
 // src/lib/tool-call-audit.ts
-var MIN_CHECK_INTERVAL_MS6 = 10 * 6e4;
+var MIN_CHECK_INTERVAL_MS7 = 10 * 6e4;
 var ENTITLEMENT_RECHECK_MS = 30 * 6e4;
-var state6 = /* @__PURE__ */ new Map();
+var state7 = /* @__PURE__ */ new Map();
 function entitlementLatch(entry, nowMs) {
   if (!entry?.notEntitledAt) return false;
   return !hasElapsed(entry.notEntitledAt, nowMs, ENTITLEMENT_RECHECK_MS);
@@ -5584,13 +5693,13 @@ async function maybeScanToolCalls(args) {
   const nowFn = args.now ?? Date.now;
   const nowMs = nowFn();
   try {
-    const existing = state6.get(codeName);
-    if (existing && !hasElapsed(existing.lastCheckedAt, nowMs, MIN_CHECK_INTERVAL_MS6)) return;
+    const existing = state7.get(codeName);
+    if (existing && !hasElapsed(existing.lastCheckedAt, nowMs, MIN_CHECK_INTERVAL_MS7)) return;
     if (entitlementLatch(existing, nowMs)) {
-      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
+      state7.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
       return;
     }
-    state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
+    state7.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
     const loggingMode = readAgentLoggingMode(codeName, args.homeDir);
     const hashOnly = loggingModeWithholdsTargets(loggingMode);
     if (loggingMode.mode === null) {
@@ -5603,7 +5712,7 @@ async function maybeScanToolCalls(args) {
       log2(`[tool-call-audit] ${codeName}: no path-hash salt available \u2014 file targets withheld`);
     }
     const home = args.homeDir ?? (process.env["HOME"]?.trim() || homedir11());
-    const projectsRoot = args.projectsRoot ?? join23(home, ".claude", "projects");
+    const projectsRoot = args.projectsRoot ?? join24(home, ".claude", "projects");
     const transcriptDir = args.transcriptDir ?? sessionTranscriptDir(getProjectDir(codeName));
     const current = peekCurrentSession(codeName);
     const sessionIds = current ? [current.sessionId] : [];
@@ -5622,9 +5731,9 @@ async function maybeScanToolCalls(args) {
       ...args.cursorPath === void 0 ? {} : { cursorPath: args.cursorPath }
     });
     if (summary.notEntitled) {
-      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: nowMs });
+      state7.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: nowMs });
     } else if (summary.callsIngested > 0) {
-      state6.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: null });
+      state7.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: null });
     }
   } catch (err) {
     log2(`[tool-call-audit] ${codeName}: scan failed: ${err.message}`);
@@ -5634,11 +5743,11 @@ async function maybeScanToolCalls(args) {
 // src/lib/activity-cache-monitor.ts
 import { existsSync as existsSync6, readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join24 } from "path";
-var MIN_CHECK_INTERVAL_MS7 = 6e4;
-var STATS_CACHE_PATH = join24(homedir12(), ".claude", "stats-cache.json");
+import { join as join25 } from "path";
+var MIN_CHECK_INTERVAL_MS8 = 6e4;
+var STATS_CACHE_PATH = join25(homedir12(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var state7 = { lastObservedDate: null, lastCheckedAt: 0 };
+var state8 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
   let parsed;
   try {
@@ -5677,8 +5786,8 @@ async function maybeReportActivityCache(args) {
   const { api: api2, log: log2 } = args;
   const now = args.now ?? /* @__PURE__ */ new Date();
   const nowMs = now.getTime();
-  if (nowMs - state7.lastCheckedAt < MIN_CHECK_INTERVAL_MS7) return;
-  state7.lastCheckedAt = nowMs;
+  if (nowMs - state8.lastCheckedAt < MIN_CHECK_INTERVAL_MS8) return;
+  state8.lastCheckedAt = nowMs;
   if (!existsSync6(STATS_CACHE_PATH)) {
     return;
   }
@@ -5689,12 +5798,12 @@ async function maybeReportActivityCache(args) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
   }
-  const rows = selectNewDailyRows(raw, state7.lastObservedDate);
+  const rows = selectNewDailyRows(raw, state8.lastObservedDate);
   if (rows.length === 0) return;
   for (const row of rows) {
     try {
       await api2.post("/host/activity-observations", row);
-      state7.lastObservedDate = row.date;
+      state8.lastObservedDate = row.date;
     } catch (err) {
       log2(
         `[activity-cache] POST /host/activity-observations failed for date=${row.date}: ${err.message}`
@@ -5927,11 +6036,11 @@ function bundleFingerprint(files) {
 }
 
 // src/lib/self-update-device-state-hold.ts
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync6 } from "fs";
 import { platform as osPlatform } from "os";
 function realStat(path) {
   try {
-    return { isFile: statSync5(path).isFile() };
+    return { isFile: statSync6(path).isFile() };
   } catch (err) {
     return { errno: err?.code ?? "UNKNOWN" };
   }
@@ -6007,14 +6116,14 @@ import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync19,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   renameSync as renameSync5,
   rmSync as rmSync3,
-  statSync as statSync6,
+  statSync as statSync7,
   utimesSync,
   writeFileSync as writeFileSync8
 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var KNOWLEDGE_FETCH_CHUNK = 100;
 var CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -6023,7 +6132,7 @@ function knowledgeHash(content) {
   return createHash9("sha256").update(content, "utf8").digest("hex");
 }
 function cachePath(cacheDir, hash) {
-  return join25(cacheDir, hash);
+  return join26(cacheDir, hash);
 }
 function readCachedKnowledge(cacheDir, hash) {
   const path = cachePath(cacheDir, hash);
@@ -6056,10 +6165,10 @@ function sweepKnowledgeCache(cacheDir, now = Date.now()) {
   lastSweepAt = now;
   try {
     if (!existsSync7(cacheDir)) return;
-    for (const name of readdirSync5(cacheDir)) {
-      const path = join25(cacheDir, name);
+    for (const name of readdirSync6(cacheDir)) {
+      const path = join26(cacheDir, name);
       try {
-        if (now - statSync6(path).mtimeMs > CACHE_TTL_MS) rmSync3(path, { force: true });
+        if (now - statSync7(path).mtimeMs > CACHE_TTL_MS) rmSync3(path, { force: true });
       } catch {
       }
     }
@@ -6110,14 +6219,14 @@ import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync20,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   renameSync as renameSync6,
   rmSync as rmSync4,
-  statSync as statSync7,
+  statSync as statSync8,
   utimesSync as utimesSync2,
   writeFileSync as writeFileSync9
 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var MEMORY_FETCH_CHUNK = 100;
 var CACHE_TTL_MS2 = 30 * 24 * 60 * 60 * 1e3;
 var SWEEP_INTERVAL_MS2 = 24 * 60 * 60 * 1e3;
@@ -6126,7 +6235,7 @@ function memoryHash(content) {
   return createHash10("sha256").update(content, "utf8").digest("hex");
 }
 function cachePath2(cacheDir, hash) {
-  return join26(cacheDir, hash);
+  return join27(cacheDir, hash);
 }
 function readCachedMemory(cacheDir, hash) {
   const path = cachePath2(cacheDir, hash);
@@ -6159,10 +6268,10 @@ function sweepMemoryCache(cacheDir, now = Date.now()) {
   lastSweepAt2.set(cacheDir, now);
   try {
     if (!existsSync8(cacheDir)) return;
-    for (const name of readdirSync6(cacheDir)) {
-      const path = join26(cacheDir, name);
+    for (const name of readdirSync7(cacheDir)) {
+      const path = join27(cacheDir, name);
       try {
-        if (now - statSync7(path).mtimeMs > CACHE_TTL_MS2) rmSync4(path, { force: true });
+        if (now - statSync8(path).mtimeMs > CACHE_TTL_MS2) rmSync4(path, { force: true });
       } catch {
       }
     }
@@ -6219,14 +6328,14 @@ import {
   existsSync as existsSync9,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync21,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   renameSync as renameSync7,
   rmSync as rmSync5,
-  statSync as statSync8,
+  statSync as statSync9,
   utimesSync as utimesSync3,
   writeFileSync as writeFileSync10
 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var SKILL_FETCH_CHUNK = 100;
 var CACHE_TTL_MS3 = 30 * 24 * 60 * 60 * 1e3;
 var SWEEP_INTERVAL_MS3 = 24 * 60 * 60 * 1e3;
@@ -6235,7 +6344,7 @@ function skillHash(content) {
   return createHash11("sha256").update(content, "utf8").digest("hex");
 }
 function cachePath3(cacheDir, hash) {
-  return join27(cacheDir, hash);
+  return join28(cacheDir, hash);
 }
 function readCachedSkill(cacheDir, hash) {
   const path = cachePath3(cacheDir, hash);
@@ -6268,10 +6377,10 @@ function sweepSkillCache(cacheDir, now = Date.now()) {
   lastSweepAt3 = now;
   try {
     if (!existsSync9(cacheDir)) return;
-    for (const name of readdirSync7(cacheDir)) {
-      const path = join27(cacheDir, name);
+    for (const name of readdirSync8(cacheDir)) {
+      const path = join28(cacheDir, name);
       try {
-        if (now - statSync8(path).mtimeMs > CACHE_TTL_MS3) rmSync5(path, { force: true });
+        if (now - statSync9(path).mtimeMs > CACHE_TTL_MS3) rmSync5(path, { force: true });
       } catch {
       }
     }
@@ -6557,10 +6666,10 @@ function resolveConditionalResponse(wire, hasCachedBody) {
 
 // src/lib/channel-hash-cache.ts
 import { existsSync as existsSync10, readFileSync as readFileSync22, writeFileSync as writeFileSync11 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join28(configDir, CACHE_FILENAME);
+  return join29(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
@@ -6588,7 +6697,7 @@ function saveChannelHashCache(source, configDir) {
 
 // src/lib/sender-policy-baseline.ts
 import { existsSync as existsSync11, readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var BASELINE_FILENAME = "sender-policy-baseline.json";
 var SENDER_POLICY_BASELINE_VERSION = 1;
 var BASELINE_CONCERNS = [
@@ -6626,7 +6735,7 @@ function createDeliveryBaselineMaps() {
   };
 }
 function getSenderPolicyBaselineFile(configDir) {
-  return join29(configDir, BASELINE_FILENAME);
+  return join30(configDir, BASELINE_FILENAME);
 }
 function loadSenderPolicyBaseline(target, configDir, log2) {
   const path = getSenderPolicyBaselineFile(configDir);
@@ -6683,7 +6792,7 @@ function saveSenderPolicyBaseline(source, configDir, log2) {
 
 // src/lib/stuck-streak-store.ts
 import { existsSync as existsSync12, readFileSync as readFileSync24 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var STORE_FILENAME = "stuck-streaks.json";
 var STUCK_STREAK_STORE_VERSION = 1;
 var STUCK_STREAK_CONCERNS = ["channelSync", "realtimeRebind"];
@@ -6691,7 +6800,7 @@ function createStuckStreakMaps() {
   return { channelSync: /* @__PURE__ */ new Map(), realtimeRebind: /* @__PURE__ */ new Map() };
 }
 function getStuckStreakStoreFile(configDir) {
-  return join30(configDir, STORE_FILENAME);
+  return join31(configDir, STORE_FILENAME);
 }
 function isValidPersistedStreak(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -6776,13 +6885,13 @@ function pruneStuckStreaksToAgents(maps, activeAgentIds) {
 }
 
 // src/lib/claude-device-state.ts
-import { readFileSync as readFileSync25, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync25, statSync as statSync10 } from "fs";
 function claudeDeviceStatePath(env = process.env) {
   return effectiveClaudeJsonPath(void 0, env);
 }
 function probeClaudeDeviceStatePresence(path = claudeDeviceStatePath()) {
   try {
-    return statSync9(path).isFile() ? { present: true } : { present: false, reason: "not-a-file" };
+    return statSync10(path).isFile() ? { present: true } : { present: false, reason: "not-a-file" };
   } catch (err) {
     return {
       present: false,
@@ -6792,7 +6901,7 @@ function probeClaudeDeviceStatePresence(path = claudeDeviceStatePath()) {
 }
 function checkClaudeDeviceState(path = claudeDeviceStatePath()) {
   try {
-    if (!statSync9(path).isFile()) return { usable: false, reason: "not-a-file" };
+    if (!statSync10(path).isFile()) return { usable: false, reason: "not-a-file" };
   } catch (err) {
     return {
       usable: false,
@@ -7479,7 +7588,7 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // src/lib/manager/integration-skill-cache.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 function integrationSkillHashKey(agentId, skillId) {
   return `plugin-skill:${agentId}:${skillId}`;
 }
@@ -7495,16 +7604,16 @@ function forgetIntegrationSkill(cache2, agentId, skillId) {
 function removeIntegrationSkillFolder(opts) {
   forgetIntegrationSkill(opts.cache, opts.agentId, opts.entry);
   for (const dir of opts.dirs) {
-    opts.removeDir(join31(dir, opts.entry));
+    opts.removeDir(join32(dir, opts.entry));
   }
 }
 
 // src/lib/manager/managed-skill-manifest.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync26, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname8, join as join32 } from "path";
+import { dirname as dirname8, join as join33 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join32(agentRootDir, "managed-skills.json");
+  return join33(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
@@ -7639,7 +7748,7 @@ function resolveModelChain(refreshData) {
 
 // src/lib/manager/claude-auth.ts
 import { existsSync as existsSync14, rmSync as rmSync6 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 import { homedir as homedir13 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
@@ -7652,9 +7761,9 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join33(homedir13(), ".claude");
+    const claudeDir = join34(homedir13(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join33(claudeDir, filename);
+      const p = join34(claudeDir, filename);
       if (existsSync14(p)) {
         try {
           rmSync6(p, { force: true });
@@ -7771,21 +7880,21 @@ function nudgeIntervalForCount(nudgeCount, fullCadenceMs, maxCadenceMs) {
   const exponent = Math.max(0, Math.min(nudgeCount - 1, 8));
   return Math.min(fullCadenceMs * 3 ** exponent, Math.max(maxCadenceMs, fullCadenceMs));
 }
-function shouldNudgeUnchangedBoard(signature, state9, now, fullCadenceMs, maxCadenceMs = fullCadenceMs) {
-  if (!state9) return true;
-  if (state9.signature !== signature) return true;
-  return now - state9.nudgedAt >= nudgeIntervalForCount(state9.nudgeCount ?? 1, fullCadenceMs, maxCadenceMs);
+function shouldNudgeUnchangedBoard(signature, state10, now, fullCadenceMs, maxCadenceMs = fullCadenceMs) {
+  if (!state10) return true;
+  if (state10.signature !== signature) return true;
+  return now - state10.nudgedAt >= nudgeIntervalForCount(state10.nudgeCount ?? 1, fullCadenceMs, maxCadenceMs);
 }
 function failureRetryIntervalForCount(failureCount2, baseMs, maxMs) {
   const exponent = Math.max(0, Math.min(failureCount2 - 1, 8));
   return Math.min(baseMs * 3 ** exponent, Math.max(maxMs, baseMs));
 }
 var KANBAN_NOTICE_BREAKER_THRESHOLD = 5;
-function shouldAttemptNoticeEnqueue(state9, now, baseMs, maxMs, breakerThreshold = KANBAN_NOTICE_BREAKER_THRESHOLD) {
-  const failures = state9?.failureCount ?? 0;
+function shouldAttemptNoticeEnqueue(state10, now, baseMs, maxMs, breakerThreshold = KANBAN_NOTICE_BREAKER_THRESHOLD) {
+  const failures = state10?.failureCount ?? 0;
   if (failures <= 0) return { attempt: true, breakerOpen: false };
   const breakerOpen = failures >= breakerThreshold;
-  const failedAt = state9?.failedAt;
+  const failedAt = state10?.failedAt;
   const due = failedAt === void 0 || failedAt > now || now - failedAt >= failureRetryIntervalForCount(failures, baseMs, maxMs);
   return { attempt: due, breakerOpen };
 }
@@ -8011,11 +8120,11 @@ function formatBoardForPrompt(items, template) {
 
 // src/lib/manager/kanban/nudge-state-cache.ts
 import { existsSync as existsSync15, readFileSync as readFileSync27, writeFileSync as writeFileSync13 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join34(configDir, CACHE_FILENAME2);
+  return join35(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
@@ -8052,7 +8161,7 @@ function loadKanbanNudgeState(target, configDir) {
 function saveKanbanNudgeState(source, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
   const agents = {};
-  for (const [codeName, state9] of source) agents[codeName] = state9;
+  for (const [codeName, state10] of source) agents[codeName] = state10;
   try {
     writeFileSync13(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
   } catch {
@@ -8642,7 +8751,7 @@ function closeSessionRunForCode(codeName, outcome, reason) {
 import { createHash as createHash15 } from "crypto";
 import { writeFileSync as writeFileSync14, renameSync as renameSync8, mkdirSync as mkdirSync11, readFileSync as readFileSync28, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join35, dirname as dirname9 } from "path";
+import { join as join36, dirname as dirname9 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
 import { createHash as createHash14 } from "crypto";
@@ -8892,8 +9001,8 @@ async function runScheduledCardDelivery(codeName, agentId, cardId, completedBy,
     markScheduledCardDeliveryComplete(cardId);
     return "terminal";
   }
-  const state9 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const task = state9.tasks[card.source_ref];
+  const state10 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state10.tasks[card.source_ref];
   if (!task) {
     log(`[scheduled-kanban] delivery: no scheduler task for source_ref=${card.source_ref} on '${codeName}' \u2014 skipping`);
     markScheduledCardDeliveryComplete(cardId);
@@ -9001,7 +9110,7 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join35(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join36(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
     writeFileSync14(tmp, JSON.stringify(marker), "utf8");
@@ -9011,7 +9120,7 @@ function stampScheduledTurnMarker(codeName, taskId, target) {
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join35(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join36(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
     const raw = JSON.parse(readFileSync28(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
@@ -9233,11 +9342,11 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 // src/lib/manager/scheduler/execution.ts
 import { createHash as createHash16 } from "crypto";
 import { homedir as homedir15 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync29, readdirSync as readdirSync8, statSync as statSync10 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync29, readdirSync as readdirSync9, statSync as statSync11 } from "fs";
+import { join as join37 } from "path";
 var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
 function probeRateLimit(args) {
   const now = args.now ?? /* @__PURE__ */ new Date();
@@ -9246,16 +9355,16 @@ function probeRateLimit(args) {
   const dir = args.transcriptDir ?? sessionTranscriptDir(args.projectDir);
   let entries;
   try {
-    entries = readdirSync8(dir);
+    entries = readdirSync9(dir);
   } catch {
     return UNKNOWN_RATE_LIMIT;
   }
   let newest = UNKNOWN_RATE_LIMIT;
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const path = join36(dir, name);
+    const path = join37(dir, name);
     try {
-      const st = statSync10(path);
+      const st = statSync11(path);
       if (!st.isFile() || st.mtimeMs < startMs) continue;
     } catch {
       continue;
@@ -9324,7 +9433,7 @@ function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
 
 // src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join37(homedir15(), ".augmented", "manager-claude-pids.json");
+  return join38(homedir15(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -9352,16 +9461,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state10 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state10);
+    const state11 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state11);
     agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
     log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state9 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state9, inFlightClaudeTasks);
+  const state10 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state10, inFlightClaudeTasks);
   if (ready.length === 0) return;
   const limitedUntil = readUsageCapUntil({ codeName, projectDir: getProjectDir(codeName) });
   if (limitedUntil) {
@@ -9406,8 +9515,8 @@ function observeBlockedPrompt(codeName, hasSession, capture) {
   const kind = classifyUnanswerablePane(pane);
   return kind ? { state: "blocked", kind } : { state: "clear" };
 }
-function carriedRecoveryFor(state9, pending2, codeName) {
-  return state9 === "clear" ? pending2.get(codeName) : void 0;
+function carriedRecoveryFor(state10, pending2, codeName) {
+  return state10 === "clear" ? pending2.get(codeName) : void 0;
 }
 function foldPendingRecovery(cost, carried) {
   const total = carried ? {
@@ -9524,8 +9633,8 @@ var BlockedPromptCostLedger = class {
 };
 
 // src/lib/occupancy-gate.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync9, readSync as readSync2, statSync as statSync11 } from "fs";
-import { join as join38 } from "path";
+import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync10, readSync as readSync3, statSync as statSync12 } from "fs";
+import { join as join39 } from "path";
 function rostersMeasuredZero(mode, attested, runtimeRunning) {
   return mode === "enforce" && attested && runtimeRunning;
 }
@@ -9539,9 +9648,9 @@ var brackets = /* @__PURE__ */ new Map();
 function readAlignedTail(path, tailBytes, maxAlignBytes) {
   let fd = null;
   try {
-    const size = statSync11(path).size;
+    const size = statSync12(path).size;
     if (size <= 0) return { content: "", complete: true, truncated: false };
-    fd = openSync2(path, "r");
+    fd = openSync3(path, "r");
     let readStart = Math.max(0, size - tailBytes);
     if (readStart > 0) {
       const scanFloor = Math.max(0, readStart - maxAlignBytes);
@@ -9552,7 +9661,7 @@ function readAlignedTail(path, tailBytes, maxAlignBytes) {
         const from = Math.max(scanFloor, pos - CHUNK);
         const len2 = pos - from;
         const b = Buffer.allocUnsafe(len2);
-        if (readSync2(fd, b, 0, len2, from) !== len2) return null;
+        if (readSync3(fd, b, 0, len2, from) !== len2) return null;
         const idx = b.lastIndexOf(10);
         if (idx !== -1) {
           boundary = from + idx + 1;
@@ -9570,14 +9679,14 @@ function readAlignedTail(path, tailBytes, maxAlignBytes) {
     }
     const len = size - readStart;
     const buf = Buffer.allocUnsafe(len);
-    if (readSync2(fd, buf, 0, len, readStart) !== len) return null;
+    if (readSync3(fd, buf, 0, len, readStart) !== len) return null;
     return { content: buf.toString("utf-8", 0, len), complete: true, truncated: readStart > 0 };
   } catch {
     return null;
   } finally {
     if (fd != null) {
       try {
-        closeSync2(fd);
+        closeSync3(fd);
       } catch {
       }
     }
@@ -9609,42 +9718,42 @@ function candidateTranscriptPaths(dir) {
   const paths = [];
   let top;
   try {
-    top = readdirSync9(dir);
+    top = readdirSync10(dir);
   } catch {
     return { paths, complete: false };
   }
   let complete = true;
   for (const name of top) {
     if (name.endsWith(".jsonl")) {
-      paths.push(join38(dir, name));
+      paths.push(join39(dir, name));
       continue;
     }
-    const subDir = join38(dir, name, "subagents");
+    const subDir = join39(dir, name, "subagents");
     let subs;
     try {
-      subs = readdirSync9(subDir);
+      subs = readdirSync10(subDir);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
     }
     for (const sub of subs) {
-      if (sub.endsWith(".jsonl")) paths.push(join38(subDir, sub));
+      if (sub.endsWith(".jsonl")) paths.push(join39(subDir, sub));
     }
   }
   return { paths, complete };
 }
 function foldToolCallBrackets(codeName, eventsByPath, nowMs) {
-  const state9 = brackets.get(codeName) ?? {
+  const state10 = brackets.get(codeName) ?? {
     open: /* @__PURE__ */ new Map(),
     closed: []
   };
   const nextOpen = /* @__PURE__ */ new Map();
   const openOut = [];
-  const paths = /* @__PURE__ */ new Set([...state9.open.keys(), ...eventsByPath.keys()]);
+  const paths = /* @__PURE__ */ new Set([...state10.open.keys(), ...eventsByPath.keys()]);
   for (const path of paths) {
-    const carried = state9.open.get(path) ?? [];
+    const carried = state10.open.get(path) ?? [];
     const paired = pairToolCallBrackets(eventsByPath.get(path) ?? [], carried);
-    state9.closed.push(...paired.brackets);
+    state10.closed.push(...paired.brackets);
     const live = paired.open.filter((c) => nowMs - c.startMs <= MAX_BRACKET_DEFERRAL_MS);
     if (live.length > 0) {
       nextOpen.set(path, live);
@@ -9654,7 +9763,7 @@ function foldToolCallBrackets(codeName, eventsByPath, nowMs) {
   const keepFrom = nowMs - GATE_MAX_BUCKET_AGE_MS;
   const seen = /* @__PURE__ */ new Set();
   const closed = [];
-  for (const b of state9.closed) {
+  for (const b of state10.closed) {
     if (b.endMs < keepFrom) continue;
     const key = `${b.id}\0${b.startMs}\0${b.endMs}`;
     if (seen.has(key)) continue;
@@ -9683,7 +9792,7 @@ function collectQualifyingTurns(codeName, nowMs, opts = {}) {
   for (const path of paths) {
     let st;
     try {
-      st = statSync11(path);
+      st = statSync12(path);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
@@ -9789,7 +9898,7 @@ function qualifyBuckets(buckets, qualifying, mode, nowMs, neighbourhoodMs = DEFA
 }
 
 // src/lib/pane-occupancy-sampler.ts
-import { statSync as statSync12 } from "fs";
+import { statSync as statSync13 } from "fs";
 var SAMPLE_INTERVAL_MS = 1e4;
 var IDLE_GAP_MS = 12e4;
 var POST_IDLE_CREDIT_MS = 6e4;
@@ -9803,7 +9912,7 @@ function hasFreshPaneObservation(codeName, nowMs, maxAgeMs = OBSERVATION_FRESH_M
 }
 function paneMtimeMs(codeName) {
   try {
-    return statSync12(paneLogPath(codeName)).mtimeMs;
+    return statSync13(paneLogPath(codeName)).mtimeMs;
   } catch {
     return null;
   }
@@ -9937,8 +10046,8 @@ function countDefunct(cgroupDir, readText) {
     if (stat2 == null) continue;
     const close = stat2.lastIndexOf(")");
     if (close < 0) continue;
-    const state9 = stat2.slice(close + 1).trim().charAt(0);
-    if (state9 === "Z") defunct += 1;
+    const state10 = stat2.slice(close + 1).trim().charAt(0);
+    if (state10 === "Z") defunct += 1;
   }
   return defunct;
 }
@@ -11188,16 +11297,16 @@ async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
   const tasksHash = createHash18("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   if (knownOpencodeTaskHashes.get(agent.agent_id) !== tasksHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state10 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    opencodeSchedulerStates.set(codeName, state10);
+    const state11 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    opencodeSchedulerStates.set(codeName, state11);
     knownOpencodeTaskHashes.set(agent.agent_id, tasksHash);
     log(`[opencode-scheduler] tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
   }
   if (!opencodeSchedulerStates.has(codeName)) {
     opencodeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state9 = opencodeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state9, inFlightOpencodeTasks);
+  const state10 = opencodeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state10, inFlightOpencodeTasks);
   if (ready.length === 0) return;
   if (!isOpencodeSessionHealthy(codeName)) {
     log(`[opencode-scheduler] '${codeName}' has ${ready.length} due task(s) but no healthy serve yet - deferring`);
@@ -11266,7 +11375,7 @@ async function fireOpencodeScheduledTask(agent, task) {
 import { createHash as createHash19 } from "crypto";
 import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync31, renameSync as renameSync9, unlinkSync as unlinkSync4, writeFileSync as writeFileSync15 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -11919,7 +12028,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join39(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join40(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -12182,10 +12291,10 @@ function recordWedgeForCards(states, inProgressCardIds, nowMs, config2) {
 function pruneCardStates(states, liveInProgressCardIds, nowMs, config2) {
   const live = liveInProgressCardIds instanceof Set ? liveInProgressCardIds : new Set(liveInProgressCardIds);
   const next = /* @__PURE__ */ new Map();
-  for (const [id, state9] of states) {
+  for (const [id, state10] of states) {
     if (!live.has(id)) continue;
-    if (nowMs - state9.lastWedgeAtMs > config2.cooldownMs) continue;
-    next.set(id, state9);
+    if (nowMs - state10.lastWedgeAtMs > config2.cooldownMs) continue;
+    next.set(id, state10);
   }
   return next;
 }
@@ -12203,24 +12312,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync13, readdirSync as readdirSync10, readFileSync as readFileSync32, renameSync as renameSync10, rmSync as rmSync7, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readdirSync as readdirSync11, readFileSync as readFileSync32, renameSync as renameSync10, rmSync as rmSync7, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join40(homedir16(), ".augmented", "restart-flags");
+  return join41(homedir16(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join40(restartFlagsDir(), `${codeName}.flag`);
+  return join41(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
   if (!existsSync18(dir)) return [];
   const out = [];
-  for (const entry of readdirSync10(dir)) {
+  for (const entry of readdirSync11(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync32(join40(dir, entry), "utf8");
+      const raw = readFileSync32(join41(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -12338,8 +12447,8 @@ async function sendError(flag, opts, text) {
 }
 
 // src/lib/restart-context.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync33, writeFileSync as writeFileSync17, mkdirSync as mkdirSync14, unlinkSync as unlinkSync5 } from "fs";
-import { dirname as dirname10, join as join41 } from "path";
+import { readdirSync as readdirSync12, readFileSync as readFileSync33, writeFileSync as writeFileSync17, mkdirSync as mkdirSync14, unlinkSync as unlinkSync5 } from "fs";
+import { dirname as dirname10, join as join42 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -12351,10 +12460,10 @@ function augmentedAgentDir(codeName) {
   return dirname10(getProjectDir(codeName));
 }
 function slackPendingInboundDir(codeName) {
-  return join41(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
+  return join42(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
 }
 function slackRestartContextDir(codeName) {
-  return join41(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
+  return join42(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
 }
 function sanitizeTopic(raw) {
   const cleaned = raw.replace(/\s+/g, " ").trim().replace(/[<>]/g, " ").replace(/\s+/g, " ").trim();
@@ -12389,7 +12498,7 @@ function computeRestartContextHints(markers, allTurns, nowMs, reconstruct = reco
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync11(dir);
+    return readdirSync12(dir);
   } catch {
     return [];
   }
@@ -12414,7 +12523,7 @@ function pruneHintsExcept(codeName, freshFilenames) {
     if (!filename.endsWith(".json")) continue;
     if (freshFilenames.has(filename)) continue;
     try {
-      unlinkSync5(join41(ctxDir, filename));
+      unlinkSync5(join42(ctxDir, filename));
     } catch {
     }
   }
@@ -12435,7 +12544,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       }
       const markers = [];
       for (const filename of markerFilenames.slice(0, cap)) {
-        const parsed = readStrandedMarker(join41(markerDir, filename));
+        const parsed = readStrandedMarker(join42(markerDir, filename));
         if (parsed) markers.push({ filename, channel: parsed.channel, thread_ts: parsed.thread_ts });
       }
       if (markers.length === 0) {
@@ -12449,7 +12558,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       const freshFilenames = /* @__PURE__ */ new Set();
       for (const { filename, hint } of hints) {
         try {
-          writeHintFile(join41(ctxDir, filename), ctxDir, hint);
+          writeHintFile(join42(ctxDir, filename), ctxDir, hint);
           freshFilenames.add(filename);
         } catch (err) {
           log2(`[restart-context] ${codeName}: hint write failed for ${filename}: ${err.message}`);
@@ -13182,8 +13291,8 @@ var KNOWN_SAFE_TAIL_SIGNATURES = /* @__PURE__ */ new Set(["session_id_in_use"]);
 function shouldSkipRevokedCleanup(previousKnownStatus) {
   return previousKnownStatus === "revoked";
 }
-function hasRevokedResiduals(state9) {
-  return state9.gatewayRunning || state9.portAllocated || state9.provisionDirExists;
+function hasRevokedResiduals(state10) {
+  return state10.gatewayRunning || state10.portAllocated || state10.provisionDirExists;
 }
 var pendingSessionRestarts = /* @__PURE__ */ new Map();
 var lastRestartWasExternal = /* @__PURE__ */ new Map();
@@ -13413,12 +13522,12 @@ function maybeClearStaleTrip(agent) {
   const marker = getAutoResumeMarker(codeName);
   const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
   if (!isSelfResume) deleteAutoResumeMarker(codeName);
-  state8 = {
-    ...state8,
+  state9 = {
+    ...state9,
     circuitBreakerTrips: restartBreaker.serialize(),
     circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
   };
-  send({ type: "state-update", state: state8 });
+  send({ type: "state-update", state: state9 });
 }
 var autoResumeMarkers = /* @__PURE__ */ new Map();
 function autoResumeMarkerKey(codeName) {
@@ -13521,12 +13630,12 @@ function maybeAutoResume(agent) {
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
       dependencyRecoveryLedger.clear(codeName);
-      state8 = {
-        ...state8,
+      state9 = {
+        ...state9,
         circuitBreakerTrips: restartBreaker.serialize(),
         circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
       };
-      send({ type: "state-update", state: state8 });
+      send({ type: "state-update", state: state9 });
       log(`[auto-resume] agent=${codeName} resumed \u2014 re-trip within backoff window will stay paused (ENG-6088)`);
     } else {
       autoResumeStandDowns.add(`${codeName}:${trippedAt}`);
@@ -13635,12 +13744,12 @@ async function maybeResumeReconcile(agent) {
       restartBreaker.clear(codeName);
       reportedTrips.delete(codeName);
       dependencyRecoveryLedger.clear(codeName);
-      state8 = {
-        ...state8,
+      state9 = {
+        ...state9,
         circuitBreakerTrips: restartBreaker.serialize(),
         circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
       };
-      send({ type: "state-update", state: state8 });
+      send({ type: "state-update", state: state9 });
       log(`[resume-reconciler] agent=${codeName} resumed \u2014 a re-trip within the backoff window will latch unstable (ENG-6383)`);
     } else {
       autoResumeStandDowns.add(standDownKey);
@@ -13931,7 +14040,7 @@ var pendingDayRolloverReset = /* @__PURE__ */ new Set();
 var dayRolloverInboundHold = /* @__PURE__ */ new Map();
 var INBOUND_HOLD_EPISODE_GAP_MS = 12e4;
 async function channelInboundActivityAgeSecondsFor(codeName) {
-  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-E23YHRUT.js");
+  const { newestPendingInboundActivityMtimeMs } = await import("../responsiveness-probe-BFDPJWZE.js");
   const newest = newestPendingInboundActivityMtimeMs(dirname11(paneLogPath(codeName)));
   if (newest === null) return null;
   return Math.max(0, Math.floor((Date.now() - newest) / 1e3));
@@ -14086,7 +14195,7 @@ function performLazyDayRolloverReset(codeName, agentTimezone) {
 }
 function paneLogAgeSecondsFor(codeName) {
   try {
-    const mtimeMs = statSync13(paneLogPath(codeName)).mtimeMs;
+    const mtimeMs = statSync14(paneLogPath(codeName)).mtimeMs;
     return Math.max(0, Math.floor((Date.now() - mtimeMs) / 1e3));
   } catch (err) {
     if (err?.code === "ENOENT") return null;
@@ -14135,7 +14244,7 @@ function restartGateFor(codeName, reason) {
 }
 function isHostBusyForForcedUpdate(opts) {
   const now = /* @__PURE__ */ new Date();
-  for (const agent of state8.agents) {
+  for (const agent of state9.agents) {
     const decision = decideRestartGate({
       window: null,
       paneLogAgeSeconds: paneLogAgeSecondsFor(agent.codeName),
@@ -14168,7 +14277,7 @@ function runPendingForcedUpdate() {
     relaxed
   } = decidePendingForcedUpdate({
     requestedAt: requestedUpdateAt,
-    lastProcessedAt: state8.lastUpdateRequestProcessedAt ?? null,
+    lastProcessedAt: state9.lastUpdateRequestProcessedAt ?? null,
     deferStreak: forcedUpdateDeferStreak,
     nowMs: Date.now(),
     isHostBusy: (isRelaxed) => isHostBusyForForcedUpdate({ relaxed: isRelaxed })
@@ -14211,7 +14320,7 @@ function runPendingForcedUpdate() {
       forcedUpdate === "consume-deadline" ? `[self-update] WARN "Update CLI now" requested at ${requestedUpdateAt} has been pending ${describePendingFor(pendingForMs)} and the host still reads busy \u2014 running the window-bypassing self-update anyway (ENG-8449 hard deadline). A live turn may be interrupted; the operator asked for this update explicitly.` : `[self-update] "Update CLI now" requested at ${requestedUpdateAt} \u2014 running window-bypassing self-update now (host idle${relaxed ? ", relaxed gate" : ""}).`
     );
   }
-  const prevProcessedAt = state8.lastUpdateRequestProcessedAt ?? null;
+  const prevProcessedAt = state9.lastUpdateRequestProcessedAt ?? null;
   const attemptStartedMs = Date.now();
   void checkAndUpdateCli({ force: true }).then((outcome) => {
     if (!shouldConsumeForcedUpdate(outcome)) {
@@ -14233,11 +14342,11 @@ function runPendingForcedUpdate() {
     log(
       outcome === "updated" ? `[self-update] "Update CLI now" completed \u2014 upgrade installed; manager restart scheduled.` : `[self-update] "Update CLI now" completed \u2014 host was already on the latest in-channel build; nothing to install.`
     );
-    state8.lastUpdateRequestProcessedAt = requestedUpdateAt;
+    state9.lastUpdateRequestProcessedAt = requestedUpdateAt;
     try {
-      atomicWriteFileSync(getStateFile(), JSON.stringify(state8, null, 2));
+      atomicWriteFileSync(getStateFile(), JSON.stringify(state9, null, 2));
     } catch (err) {
-      state8.lastUpdateRequestProcessedAt = prevProcessedAt;
+      state9.lastUpdateRequestProcessedAt = prevProcessedAt;
       log(
         `[self-update] failed to persist update-request ack; retrying next poll: ${err.message}`
       );
@@ -14256,7 +14365,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync34(join42(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync34(join43(projectDir, ".mcp.json"), "utf-8");
     return createHash20("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -14264,7 +14373,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync34(join42(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync34(join43(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -14282,7 +14391,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync34(join42(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync34(join43(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -14417,7 +14526,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(readFileSync34(join42(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync34(join43(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -14566,7 +14675,7 @@ function shouldInjectChannelSecrets(agentId) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync34(join42(projectDir, ".env.integrations"), "utf-8")
+      readFileSync34(join43(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -14607,7 +14716,7 @@ var STALE_TASK_THRESHOLD_MS = (() => {
 })();
 var taskDisplayInfo = /* @__PURE__ */ new Map();
 var activeChannels = /* @__PURE__ */ new Map();
-var state8 = {
+var state9 = {
   pid: process.pid,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   lastPollAt: null,
@@ -14677,7 +14786,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.1047" : "dev";
+var agtCliVersion = true ? "0.28.1048" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -15004,7 +15113,7 @@ function runAsync(cmd, args, opts) {
   });
 }
 function claudeManagedSettingsPath() {
-  return join42(CLAUDE_MANAGED_SETTINGS_DIR, "managed-settings.json");
+  return join43(CLAUDE_MANAGED_SETTINGS_DIR, "managed-settings.json");
 }
 var MANAGED_SETTINGS_KEYS = ["channelsEnabled", "enableAllProjectMcpServers"];
 var MANAGED_SETTINGS_ENV = { DISABLE_AUTOUPDATER: "1" };
@@ -15079,7 +15188,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync3("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join42(prefix, "bin");
+      const npmBin = join43(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -15219,7 +15328,7 @@ async function maybeUpgradeClaudeCode() {
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join42(homedir17(), ".augmented", ".last-self-update-applied");
+  return join43(homedir17(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -15270,7 +15379,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 = join42(homedir17(), ".augmented", ".last-update-check");
+    const markerPath = join43(homedir17(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -15768,12 +15877,12 @@ async function checkClaudeAuth() {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync19(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join42(homedir17(), ".augmented");
+  const dir = join43(homedir17(), ".augmented");
   try {
     mkdirSync15(dir, { recursive: true });
   } catch {
   }
-  const p = join42(dir, ".eval-empty-mcp.json");
+  const p = join43(dir, ".eval-empty-mcp.json");
   writeFileSync18(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
@@ -15868,10 +15977,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join42(config?.configDir ?? join42(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join43(config?.configDir ?? join43(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join42(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join43(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -15919,21 +16028,21 @@ function recordChannelSyncFailure(failures, agentId, reason, now) {
   failures.set(agentId, next);
   return next;
 }
-function shouldLogChannelSyncFailure(state9) {
-  if (state9.attempts === 1) return true;
-  if (state9.attempts <= CHANNEL_SYNC_FREE_ATTEMPTS) return false;
-  return state9.attempts > state9.loggedAtAttempt;
+function shouldLogChannelSyncFailure(state10) {
+  if (state10.attempts === 1) return true;
+  if (state10.attempts <= CHANNEL_SYNC_FREE_ATTEMPTS) return false;
+  return state10.attempts > state10.loggedAtAttempt;
 }
 function stuckChannelSyncs(failures, now, thresholdMs = CHANNEL_SYNC_STUCK_AFTER_MS) {
   const out = [];
-  for (const [agentId, state9] of failures) {
-    const stuckForMs = now - state9.since;
+  for (const [agentId, state10] of failures) {
+    const stuckForMs = now - state10.since;
     if (stuckForMs < thresholdMs) continue;
     out.push({
       agent_id: agentId,
-      attempts: state9.attempts,
+      attempts: state10.attempts,
       stuck_for_seconds: Math.floor(stuckForMs / 1e3),
-      reason: state9.lastReason
+      reason: state10.lastReason
     });
   }
   out.sort((a, b) => b.stuck_for_seconds - a.stuck_for_seconds);
@@ -16084,7 +16193,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join42(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join43(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -16092,7 +16201,7 @@ function channelQuarantineStore() {
 var _channelResumeHistoryStore = null;
 function channelResumeHistoryStore() {
   if (!_channelResumeHistoryStore) {
-    const dir = config?.configDir ?? join42(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join43(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelResumeHistoryStore = new ChannelResumeHistoryStore(defaultResumeHistoryPath(dir));
   }
   return _channelResumeHistoryStore;
@@ -16119,12 +16228,12 @@ function claudeMdSizeFor(codeName) {
 }
 function forwardedToolsFor(codeName) {
   if (!config?.configDir) return null;
-  return readForwardedToolsReport(join42(config.configDir, codeName));
+  return readForwardedToolsReport(join43(config.configDir, codeName));
 }
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join42(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join43(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -16197,13 +16306,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync13, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync19 } = await import("fs");
-  const skillsDir = join42(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join42(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync14, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync19 } = await import("fs");
+  const skillsDir = join43(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join43(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
-  for (const dir of readdirSync13(skillsDir).sort()) {
-    const skillFile = join42(skillsDir, dir, "SKILL.md");
+  for (const dir of readdirSync14(skillsDir).sort()) {
+    const skillFile = join43(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -16312,7 +16421,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-X3C3R22F.js");
+      const { collectDiagnostics } = await import("../persistent-session-OSQVHP6N.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -16443,7 +16552,7 @@ async function pollCycleInner() {
     const now = Date.now();
     if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
       try {
-        const firstAgent = state8.agents[0];
+        const firstAgent = state9.agents[0];
         const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework(DEFAULT_FRAMEWORK);
         if (versionAdapter.getVersion) {
           cachedFrameworkVersion = await versionAdapter.getVersion();
@@ -16454,7 +16563,7 @@ async function pollCycleInner() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-KQYYZZVW.js");
-      const { collectDiagnostics } = await import("../persistent-session-X3C3R22F.js");
+      const { collectDiagnostics } = await import("../persistent-session-OSQVHP6N.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor) : void 0;
       let tailscaleHostname;
@@ -16487,7 +16596,7 @@ async function pollCycleInner() {
         const errId = createHash20("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
-      const hostHasClaudeCode = state8.agents.some(
+      const hostHasClaudeCode = state9.agents.some(
         (a) => agentFrameworkCache.get(a.codeName) === "claude-code"
       );
       if (hostHasClaudeCode) {
@@ -16571,6 +16680,15 @@ async function pollCycleInner() {
         // customer agents had been dark for three minutes. Bounding the retry
         // without this would fix the CPU and leave the blindness.
         realtime_rebind_stuck: stuckRealtimeRebinds(realtimeRebindFailures, Date.now()),
+        // ENG-10981: per-agent verdicts on turns that complete but fail
+        // instantly (API error, no tool calls). The koda loop of 23-24 Sep ran
+        // 16h and $484 with every monitor green, because each failed turn still
+        // COMPLETES. DIFFERENT contract from the fields above, deliberately:
+        // `failing` opens, `recovered` closes, and an agent not listed is left
+        // alone. An empty array is NOT an all-clear, because this beat runs
+        // before the poll has checked any agent after a restart (Obi Wan
+        // 63a07c30429f).
+        failing_turn_loops: failingTurnLoops(Date.now()),
         // ENG-10351: ONE host-level verdict for rotations held because the
         // host's ~/.claude.json is not usable. ALWAYS sent: `null` is the
         // affirmative all-clear that lets the API close the alert on the edge,
@@ -16589,7 +16707,7 @@ async function pollCycleInner() {
         // ENG-6692: ack the last consumed "Update CLI now" timestamp so the API
         // clears hosts.update_requested_at. Echoes our persisted dedup marker;
         // null until we've ever consumed one.
-        update_request_processed_at: state8.lastUpdateRequestProcessedAt ?? null
+        update_request_processed_at: state9.lastUpdateRequestProcessedAt ?? null
       });
       if (hbResp?.maintenance_window) {
         cachedMaintenanceWindow = hbResp.maintenance_window;
@@ -16630,7 +16748,7 @@ async function pollCycleInner() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-E23YHRUT.js");
+      } = await import("../responsiveness-probe-BFDPJWZE.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -16747,7 +16865,7 @@ async function pollCycleInner() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-E23YHRUT.js");
+        } = await import("../responsiveness-probe-BFDPJWZE.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-M6AFZWNU.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -16839,10 +16957,10 @@ async function pollCycleInner() {
                 const paneTail = readFileSync34(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join42(homedir17(), ".augmented", codeName);
+                  const wedgeHome = join43(homedir17(), ".augmented", codeName);
                   if (existsSync19(wedgeHome)) {
                     atomicWriteFileSync(
-                      join42(wedgeHome, "watchdog-give-up.json"),
+                      join43(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -16903,7 +17021,7 @@ async function pollCycleInner() {
     }
     try {
       const { scrapeMcpFailedBannerCount } = await import("../pane-mcp-banner-scraper-VR5QGP3J.js");
-      const { probeSessionAuth } = await import("../session-auth-dead-WCUXKBHP.js");
+      const { probeSessionAuth } = await import("../session-auth-dead-A3WD2YRK.js");
       const observations = [];
       const pendingCacheCommits = [];
       const modelApiErrorReportingOn = hostFlagStore().getBoolean("model-api-error-reporting");
@@ -17004,7 +17122,7 @@ async function pollCycleInner() {
       const requested = agent.restart_requested_at ?? null;
       if (!requested) continue;
       if (restartInFlight.has(agent.agent_id)) continue;
-      const prev = state8.agents.find((a) => a.agentId === agent.agent_id);
+      const prev = state9.agents.find((a) => a.agentId === agent.agent_id);
       const lastProcessed = prev?.lastRestartProcessedAt ?? null;
       const alreadyServiced = lastProcessed != null && Date.parse(lastProcessed) >= Date.parse(requested);
       if (!alreadyServiced) {
@@ -17288,7 +17406,7 @@ async function pollCycleInner() {
     boardTokenCache.resetStats();
     for (const agent of processOrder) {
       if (restartInFlight.has(agent.agent_id)) {
-        const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state9.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
           continue;
@@ -17298,7 +17416,7 @@ async function pollCycleInner() {
         await processAgent(agent, agentStates, managedToolkits);
       } catch (err) {
         log(`Error processing agent '${agent.code_name}': ${err.message}`);
-        const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
+        const existing = state9.agents.find((a) => a.agentId === agent.agent_id);
         if (existing) {
           agentStates.push(existing);
         } else {
@@ -17333,12 +17451,12 @@ async function pollCycleInner() {
     if (crossAgentPrune) log(crossAgentPrune);
     const restartAckStateChanged = applyRestartAcks({
       agentStates,
-      priorAgents: state8.agents,
+      priorAgents: state9.agents,
       restartAcks
     });
     if (restartAckStateChanged) {
       try {
-        const ackedState = { ...state8, agents: agentStates };
+        const ackedState = { ...state9, agents: agentStates };
         atomicWriteFileSync(getStateFile(), JSON.stringify(ackedState, null, 2));
       } catch (err) {
         log(`[restart] failed to persist ack immediately: ${err.message}`);
@@ -17360,7 +17478,7 @@ async function pollCycleInner() {
     } catch {
     }
     const currentIds = new Set(agents.map((a) => a.agent_id));
-    for (const prev of state8.agents) {
+    for (const prev of state9.agents) {
       if (!currentIds.has(prev.agentId)) {
         log(`Agent '${prev.codeName}' removed from host (deleted or unassigned)`);
         const adapter = resolveAgentFramework(prev.codeName);
@@ -17385,7 +17503,7 @@ async function pollCycleInner() {
             `[drain-flush] FAILED for '${prev.codeName}': ${err.message} \u2014 proceeding to teardown; this session was NOT shipped (ENG-9491)`
           );
         }
-        const agentDir = join42(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join43(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -17472,10 +17590,10 @@ async function pollCycleInner() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join42(homedir17(), ".augmented", codeName);
+          const dir = join43(homedir17(), ".augmented", codeName);
           if (!existsSync19(dir)) return;
           atomicWriteFileSync(
-            join42(dir, "watchdog-give-up.json"),
+            join43(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         },
@@ -17503,17 +17621,17 @@ async function pollCycleInner() {
           const dir = getFramework("claude-code").getAgentDir(codeName);
           if (!existsSync19(dir)) return;
           atomicWriteFileSync(
-            join42(dir, "blocked-prompt.json"),
+            join43(dir, "blocked-prompt.json"),
             JSON.stringify({ kind, last_seen_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         },
         clearBlockedPromptLiveness: (codeName) => {
-          const file = join42(getFramework("claude-code").getAgentDir(codeName), "blocked-prompt.json");
+          const file = join43(getFramework("claude-code").getAgentDir(codeName), "blocked-prompt.json");
           if (existsSync19(file)) rmSync8(file, { force: true });
         },
         refreshUsageLimitLiveness: (codeName) => {
           const dir = getFramework("claude-code").getAgentDir(codeName);
-          const file = join42(dir, "watchdog-give-up.json");
+          const file = join43(dir, "watchdog-give-up.json");
           if (!existsSync19(file)) return;
           try {
             const raw = JSON.parse(readFileSync34(file, "utf8"));
@@ -17527,7 +17645,7 @@ async function pollCycleInner() {
           const dir = getFramework("claude-code").getAgentDir(codeName);
           if (!existsSync19(dir)) return;
           atomicWriteFileSync(
-            join42(dir, "watchdog-give-up.json"),
+            join43(dir, "watchdog-give-up.json"),
             JSON.stringify({
               gave_up_at: (/* @__PURE__ */ new Date()).toISOString(),
               reason: "usage_limit",
@@ -17578,10 +17696,10 @@ async function pollCycleInner() {
       }
     } catch {
     }
-    state8 = {
-      ...state8,
+    state9 = {
+      ...state9,
       lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
-      pollCount: state8.pollCount + 1,
+      pollCount: state9.pollCount + 1,
       agents: agentStates,
       // ENG-5441: serialise trip state on every poll so manager restarts
       // never silently clear a tripped breaker. Cheap — only tripped
@@ -17595,9 +17713,9 @@ async function pollCycleInner() {
       consecutivePollFailures = 0;
     }
     verifyPendingRestarts(Date.now());
-    send({ type: "state-update", state: state8 });
+    send({ type: "state-update", state: state9 });
   } catch (err) {
-    state8.errorCount++;
+    state9.errorCount++;
     const message = err.message;
     log(`Poll error: ${message}`);
     send({ type: "error", message });
@@ -17755,6 +17873,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       agentId: agent.agent_id,
       log
     });
+    maybeCheckFailingTurns({ codeName: agent.code_name, agentId: agent.agent_id, log });
     void maybeReconcileWorkflowRunTokens({
       api,
       codeName: agent.code_name,
@@ -17798,7 +17917,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join42(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join43(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     forgetChannelSyncState(agent.agent_id);
     reapLegacyTokenFileEdgeWarned(agent.code_name, log);
@@ -17898,11 +18017,11 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const marker = getAutoResumeMarker(agent.code_name);
       const isSelfResume = marker !== void 0 && Date.now() - marker.autoResumedAt < AUTO_RESUME_SELF_WINDOW_MS;
       if (!isSelfResume && deleteAutoResumeMarker(agent.code_name)) {
-        state8 = {
-          ...state8,
+        state9 = {
+          ...state9,
           circuitBreakerAutoResumes: Object.fromEntries(autoResumeMarkers.entries())
         };
-        send({ type: "state-update", state: state8 });
+        send({ type: "state-update", state: state9 });
         log(`[auto-resume] Cleared auto-resume marker for '${agent.code_name}' on operator resume \u2014 credit re-armed (ENG-6088)`);
       }
     }
@@ -17946,7 +18065,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       if (refreshData.knowledge_manifest) {
         const resolved = await resolveKnowledgeFromManifest({
           manifest: refreshData.knowledge_manifest,
-          cacheDir: join42(config.configDir, "_knowledge"),
+          cacheDir: join43(config.configDir, "_knowledge"),
           delivery: refreshData.agent?.knowledge_delivery ?? "both",
           fetchContents: async (hashes) => {
             const res = await api.post(
@@ -17963,7 +18082,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const resolvedSkills = await resolveSkillsFromManifest({
           globals: refreshData.global_skills_manifest ?? [],
           shared: refreshData.shared_skills_manifest ?? [],
-          cacheDir: join42(config.configDir, "_skills"),
+          cacheDir: join43(config.configDir, "_skills"),
           fetchContents: async (hashes) => {
             const res = await api.post(
               "/host/skills/contents",
@@ -17981,7 +18100,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       if (refreshData.integration_skills_manifest) {
         const resolvedIntegrationSkills = await resolveIntegrationSkillsFromManifest({
           manifest: refreshData.integration_skills_manifest,
-          cacheDir: join42(config.configDir, "_skills"),
+          cacheDir: join43(config.configDir, "_skills"),
           fetchContents: async (hashes) => {
             const res = await api.post(
               "/host/skills/contents",
@@ -17997,7 +18116,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       }
     } catch (err) {
       log(`Refresh failed for '${agent.code_name}': ${err.message}`);
-      const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
+      const existing = state9.agents.find((a) => a.agentId === agent.agent_id);
       agentStates.push(existing ?? {
         agentId: agent.agent_id,
         codeName: agent.code_name,
@@ -18043,7 +18162,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join42(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join43(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,
@@ -18065,7 +18184,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   const charterVersion = refreshData.charter.version;
   const toolsVersion = refreshData.tools.version;
   const known = agentState.knownVersions.get(agent.agent_id);
-  let lastProvisionAt = state8.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  let lastProvisionAt = state9.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
   const quarantinedChannels = channelQuarantineStore().getQuarantinedKeys(agent.code_name);
   let telegramPolicyEnvForRestart;
   const currentChannelIds = setWithout(
@@ -18102,7 +18221,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const changedFiles = [];
     mkdirSync15(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join42(agentDir, artifact.relativePath);
+      const filePath = join43(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -18121,7 +18240,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join42(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const projectClaudeMd = join43(config.configDir, agent.code_name, "project", "CLAUDE.md");
           const existing = readFileSync34(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
@@ -18172,12 +18291,12 @@ async function processAgent(agent, agentStates, managedToolkits) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync19(join42(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync19(join43(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 = join42(agentDir, file.relativePath);
+        const filePath = join43(agentDir, file.relativePath);
         mkdirSync15(dirname11(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
@@ -18186,12 +18305,12 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const provSkillsDir = join42(agentDir, ".claude", "skills");
+        const provSkillsDir = join43(agentDir, ".claude", "skills");
         if (existsSync19(provSkillsDir)) {
-          for (const folder of readdirSync12(provSkillsDir)) {
+          for (const folder of readdirSync13(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync8(join42(provSkillsDir, folder), { recursive: true });
+                rmSync8(join43(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -18204,7 +18323,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join42(agentDir, file));
+        const h = hashFile(join43(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -18222,14 +18341,14 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join42(agentDir, ".claude", "workflows");
+        const provWorkflowsDir = join43(agentDir, ".claude", "workflows");
         if (existsSync19(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
-          for (const file of readdirSync12(provWorkflowsDir)) {
+          for (const file of readdirSync13(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync8(join42(provWorkflowsDir, file));
+              rmSync8(join43(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -18311,7 +18430,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   if (written && existsSync19(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join42(agentDir, file));
+      const localHash = hashFile(join43(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -18322,7 +18441,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join42(agentDir, file));
+          localHashes[file] = hashFile(join43(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -18531,18 +18650,18 @@ async function processAgent(agent, agentStates, managedToolkits) {
       agentState.knownChannels.set(agent.agent_id, currentChannelIds);
     }
   } else {
-    const state9 = recordChannelSyncFailure(
+    const state10 = recordChannelSyncFailure(
       channelSyncFailures,
       agent.agent_id,
       channelConfigFailureReason || "reason not recorded",
       Date.now()
     );
-    if (shouldLogChannelSyncFailure(state9)) {
-      state9.loggedAtAttempt = state9.attempts;
-      const stuckForSeconds = Math.floor((Date.now() - state9.since) / 1e3);
-      const waitMs = channelSyncBackoffMs(state9.attempts);
+    if (shouldLogChannelSyncFailure(state10)) {
+      state10.loggedAtAttempt = state10.attempts;
+      const stuckForSeconds = Math.floor((Date.now() - state10.since) / 1e3);
+      const waitMs = channelSyncBackoffMs(state10.attempts);
       log(
-        `[channels] Credential sync did not converge for '${agent.code_name}' \u2014 attempt ${state9.attempts}, stuck ${stuckForSeconds}s, next retry in ${Math.round(waitMs / 1e3)}s. Cause: ${state9.lastReason}. Diff left live (ENG-9252).`
+        `[channels] Credential sync did not converge for '${agent.code_name}' \u2014 attempt ${state10.attempts}, stuck ${stuckForSeconds}s, next retry in ${Math.round(waitMs / 1e3)}s. Cause: ${state10.lastReason}. Diff left live (ENG-9252).`
       );
     }
   }
@@ -18600,7 +18719,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join42(homedir17(), ".augmented", agent.code_name);
+        const agentAugmentedDir = join43(homedir17(), ".augmented", agent.code_name);
         mkdirSync15(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
@@ -18608,7 +18727,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join42(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join43(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -18907,18 +19026,18 @@ async function processAgent(agent, agentStates, managedToolkits) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join42(homedir17(), ".augmented", agent.code_name, "project");
+      const projectDir = join43(homedir17(), ".augmented", agent.code_name, "project");
       mkdirSync15(agentProvisionDir, { recursive: true });
       mkdirSync15(projectDir, { recursive: true });
-      const provisionMcpPath = join42(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join42(projectDir, ".mcp.json");
+      const provisionMcpPath = join43(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join43(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
         mcpConfig = JSON.parse(readFileSync34(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join42(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join43(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -18944,7 +19063,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           // ~/.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: join42(
+          AGT_TURN_INITIATOR_FILE: join43(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -18964,7 +19083,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join42(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join43(projectDir, ".mcp-channels.json");
       if (existsSync19(staleChannelsPath)) {
         try {
           rmSync8(staleChannelsPath, { force: true });
@@ -18975,7 +19094,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       log(`Failed to provision direct-chat channel for '${agent.code_name}': ${err.message}`);
     }
   }
-  let lastSecretsProvisionAt = state8.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let lastSecretsProvisionAt = state9.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
   let secretsHash = agentState.knownSecretsHashes.get(agent.agent_id) ?? null;
   const secretsToken = secretsFetchGate.beginFetch(agent.agent_id);
   if (secretsFetchGate.shouldFetch(agent.agent_id)) {
@@ -19074,7 +19193,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join42(homedir17(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join43(homedir17(), ".augmented", agent.code_name, "project");
         let probeSet = integrations;
         const fetchQuarantined = async () => {
           const quarantined = await api.post("/host/agent-integrations/quarantined", { agent_id: agent.agent_id });
@@ -19134,7 +19253,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join42(homedir17(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join43(homedir17(), ".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}`);
@@ -19212,8 +19331,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join42(homedir17(), ".augmented", agent.code_name, "project");
-        const envIntPath = join42(projectDir, ".env.integrations");
+        const projectDir = join43(homedir17(), ".augmented", agent.code_name, "project");
+        const envIntPath = join43(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
           preWriteEnv = readFileSync34(envIntPath, "utf-8");
@@ -19236,7 +19355,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join42(projectDir, ".mcp.json");
+            const projectMcpPath = join43(projectDir, ".mcp.json");
             const postWriteEnv = readFileSync34(envIntPath, "utf-8");
             const mcpContent = readFileSync34(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
@@ -19540,23 +19659,23 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const { readdirSync: readdirSync13, rmSync: rmSync9 } = await import("fs");
+        const { readdirSync: readdirSync14, rmSync: rmSync9 } = await import("fs");
         const { homedir: homedir18 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join42(homedir18(), ".augmented", agent.code_name, "skills"),
+          join43(homedir18(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join42(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join43(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join42(agentDir, ".claude", "skills")
+          join43(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync19(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
-            for (const entry of readdirSync13(dir)) {
+            for (const entry of readdirSync14(dir)) {
               if (entry.startsWith("plugin-") || entry.startsWith("integration-")) {
                 discoveredEntries.add(entry);
               }
@@ -19593,7 +19712,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join42(homedir17(), ".augmented", agent.code_name)
+          join43(homedir17(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -19613,15 +19732,15 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join42(homedir17(), ".augmented", agent.code_name, "skills"),
-            join42(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join42(agentDir, ".claude", "skills")
+            join43(homedir17(), ".augmented", agent.code_name, "skills"),
+            join43(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join43(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join42(dir, id);
-              if (existsSync19(p) && existsSync19(join42(p, "SKILL.md"))) {
+              const p = join43(dir, id);
+              if (existsSync19(p) && existsSync19(join43(p, "SKILL.md"))) {
                 rmSync8(p, { recursive: true, force: true });
                 prunedAny = true;
               }
@@ -19877,7 +19996,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join42(getProjectDir(agent.code_name), ".mcp.json");
+          const mcpPath = join43(getProjectDir(agent.code_name), ".mcp.json");
           mcpJsonParsed = JSON.parse(readFileSync34(mcpPath, "utf-8"));
         } catch {
         }
@@ -20390,7 +20509,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
   if (trackedFiles.length > 0 && existsSync19(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join42(agentDir, file));
+      const h = hashFile(join43(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -20405,7 +20524,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join42(homedir17(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join43(homedir17(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const obContactRaw = refreshData.agent.manager_last_contacted_at;
       const obContact = typeof obContactRaw === "string" && obContactRaw ? obContactRaw : null;
@@ -20520,7 +20639,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join42(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join43(getFramework("opencode").getAgentDir(codeName), "provision");
   const serveEnv = {
     AGT_HOST: requireHost(),
     AGT_API_KEY: getApiKey() ?? void 0,
@@ -20580,8 +20699,8 @@ async function ensurePersistentSessionUnchecked(agent, tasks, boardItems, refres
     });
   }
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join42(projectDir, ".mcp.json");
-  const claudeMdPath = join42(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join43(projectDir, ".mcp.json");
+  const claudeMdPath = join43(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -21142,9 +21261,9 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash20("sha256")
   } else if (!claudeSchedulerStates.has(codeName)) {
     claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
   }
-  const state9 = claudeSchedulerStates.get(codeName);
-  if (state9) {
-    const ready = getReadyTasks(state9, inFlightClaudeTasks);
+  const state10 = claudeSchedulerStates.get(codeName);
+  if (state10) {
+    const ready = getReadyTasks(state10, inFlightClaudeTasks);
     if (ready.length > 0) {
       log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
     }
@@ -21251,19 +21370,19 @@ function recordRealtimeRebindFailure(failures, agentId, status, now) {
   return next;
 }
 function realtimeRebindDue(failures, now) {
-  for (const state9 of failures.values()) if (now >= state9.nextAttemptAt) return true;
+  for (const state10 of failures.values()) if (now >= state10.nextAttemptAt) return true;
   return false;
 }
 function stuckRealtimeRebinds(failures, now, thresholdMs = REALTIME_REBIND_STUCK_AFTER_MS) {
   const out = [];
-  for (const [agentId, state9] of failures) {
-    const stuckForMs = now - state9.since;
+  for (const [agentId, state10] of failures) {
+    const stuckForMs = now - state10.since;
     if (stuckForMs < thresholdMs) continue;
     out.push({
       agent_id: agentId,
-      attempts: state9.attempts,
+      attempts: state10.attempts,
       stuck_for_seconds: Math.floor(stuckForMs / 1e3),
-      status: state9.lastStatus
+      status: state10.lastStatus
     });
   }
   out.sort((a, b) => b.stuck_for_seconds - a.stuck_for_seconds);
@@ -21286,8 +21405,8 @@ function pruneRealtimeRebindState(failures, liveAgentIds) {
 function holdRealtimeRebindInFlight(failures, agentIds, now, graceMs = REALTIME_REBIND_IN_FLIGHT_GRACE_MS) {
   const until = now + graceMs;
   for (const agentId of agentIds) {
-    const state9 = failures.get(agentId);
-    if (state9) state9.nextAttemptAt = Math.max(state9.nextAttemptAt, until);
+    const state10 = failures.get(agentId);
+    if (state10) state10.nextAttemptAt = Math.max(state10.nextAttemptAt, until);
   }
 }
 var realtimeAssignStarted = false;
@@ -21420,7 +21539,7 @@ async function fetchSpawnRefreshData(agentId, codeName, lane) {
   }
 }
 async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
-  const prev = state8.agents.find((a) => a.agentId === agentId);
+  const prev = state9.agents.find((a) => a.agentId === agentId);
   const codeName = prev?.codeName;
   if (!codeName) return;
   const lastProcessed = prev?.lastRestartProcessedAt ?? null;
@@ -21446,7 +21565,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
       try {
         const freshId = rotateSessionForWedge(codeName);
         consecutiveWedgeCycles.delete(codeName);
-        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-E23YHRUT.js");
+        const { parkPendingInbound: parkForRestart } = await import("../responsiveness-probe-BFDPJWZE.js");
         const { parked, deadLettered } = parkForRestart(codeName, /* @__PURE__ */ new Date());
         const parkNote = parked > 0 ? `, ${parked} inbound parked` : "";
         const deadNote = deadLettered > 0 ? `, ${deadLettered} undeliverable dead-lettered` : "";
@@ -21489,7 +21608,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-X3C3R22F.js");
+        const { collectDiagnostics } = await import("../persistent-session-OSQVHP6N.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -21500,7 +21619,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
     })();
     prev.lastRestartProcessedAt = requestedAt;
     try {
-      atomicWriteFileSync(getStateFile(), JSON.stringify(state8, null, 2));
+      atomicWriteFileSync(getStateFile(), JSON.stringify(state9, null, 2));
     } catch (err) {
       log(`[restart-lane] failed to persist ack for '${codeName}': ${err.message}`);
     }
@@ -21510,7 +21629,7 @@ async function handleRestartDoorbell(agentId, requestedAt, restartReason) {
   }
 }
 async function respawnAgentAfterMcpStop(codeName, reason) {
-  const prev = state8.agents.find((a) => a.codeName === codeName);
+  const prev = state9.agents.find((a) => a.codeName === codeName);
   if (!prev) return;
   const agentId = prev.agentId;
   if (restartInFlight.has(agentId)) return;
@@ -21540,7 +21659,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-X3C3R22F.js");
+      const { collectDiagnostics } = await import("../persistent-session-OSQVHP6N.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics, pidPressureFor, forwardedToolsFor, runtimeVersionFor)
@@ -21764,18 +21883,18 @@ function ensureRealtimeIntegrationContextStarted(agentStates) {
         );
       },
       onSubscriptionLost: (agentId, status) => {
-        const state9 = recordRealtimeRebindFailure(
+        const state10 = recordRealtimeRebindFailure(
           realtimeRebindFailures,
           agentId,
           status,
           Date.now()
         );
-        const waitMs = realtimeRebindBackoffMs(state9.attempts);
-        if (state9.attempts === 1 || state9.attempts > state9.loggedAtAttempt) {
-          state9.loggedAtAttempt = state9.attempts;
-          const stuckForSeconds = Math.floor((Date.now() - state9.since) / 1e3);
+        const waitMs = realtimeRebindBackoffMs(state10.attempts);
+        if (state10.attempts === 1 || state10.attempts > state10.loggedAtAttempt) {
+          state10.loggedAtAttempt = state10.attempts;
+          const stuckForSeconds = Math.floor((Date.now() - state10.since) / 1e3);
           log(
-            `[realtime] Token rotation subscription lost for agent ${agentId} (${status}) \u2014 attempt ${state9.attempts}, stuck ${stuckForSeconds}s, next rebind in ${Math.round(waitMs / 1e3)}s (ENG-9265)`
+            `[realtime] Token rotation subscription lost for agent ${agentId} (${status}) \u2014 attempt ${state10.attempts}, stuck ${stuckForSeconds}s, next rebind in ${Math.round(waitMs / 1e3)}s (ENG-9265)`
           );
         }
         if (waitMs === 0) subscribedIntegrationContextAgentIds = /* @__PURE__ */ new Set();
@@ -22016,10 +22135,10 @@ function getKanbanNudgeState(codeName) {
 function loadKanbanNudgeStateFromDisk() {
   loadKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
 }
-function setKanbanNudgeState(codeName, state9) {
+function setKanbanNudgeState(codeName, state10) {
   const key = kanbanNudgeStateKey(codeName);
   if (key !== codeName) kanbanNudgeStateByCode.delete(codeName);
-  kanbanNudgeStateByCode.set(key, state9);
+  kanbanNudgeStateByCode.set(key, state10);
   saveKanbanNudgeState(kanbanNudgeStateByCode, channelHashCacheDir());
 }
 function clearKanbanNudgeState(codeName) {
@@ -22212,7 +22331,7 @@ async function processClaudePairSessions(agents) {
     // cannot take it for itself — by the time it runs, the write it is looking
     // for may already have happened.
     snapshotPairConfig
-  } = await import("../claude-pair-runtime-TOHT7XVN.js");
+  } = await import("../claude-pair-runtime-KWN4XZ2H.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));
@@ -22479,10 +22598,10 @@ var lastLocalFileHash = /* @__PURE__ */ new Map();
 var lastMemoriesBody = /* @__PURE__ */ new Map();
 var memoryManifests = /* @__PURE__ */ new Map();
 function memoryRetirementDir(configDir, codeName) {
-  return join42(configDir, "_memory-retirement", codeName);
+  return join43(configDir, "_memory-retirement", codeName);
 }
 function memoryManifestPath(configDir, codeName) {
-  return join42(memoryRetirementDir(configDir, codeName), "manifest.json");
+  return join43(memoryRetirementDir(configDir, codeName), "manifest.json");
 }
 function loadMemoryManifest(agentId, configDir, codeName) {
   const cached = memoryManifests.get(agentId);
@@ -22517,7 +22636,7 @@ function saveMemoryManifest(agentId, configDir, codeName) {
   }
 }
 function retiredMemoryDir(configDir, codeName) {
-  return join42(memoryRetirementDir(configDir, codeName), "retired");
+  return join43(memoryRetirementDir(configDir, codeName), "retired");
 }
 var RETIRED_MEMORY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var lastRetirementReport = /* @__PURE__ */ new Map();
@@ -22596,7 +22715,7 @@ function applyMemoryTombstones(opts) {
       log2(`[memory-retire] ${agent.code_name}: KEPT '${tomb.name}' \u2014 no write record, not ours to remove`);
       continue;
     }
-    const filePath = join42(memoryDir, entry.file);
+    const filePath = join43(memoryDir, entry.file);
     if (!existsSync19(filePath)) {
       outcomes.already_gone++;
       delete manifest[tomb.name];
@@ -22616,9 +22735,9 @@ function applyMemoryTombstones(opts) {
       const destDir = retiredMemoryDir(configDir, agent.code_name);
       mkdirSync15(destDir, { recursive: true });
       const stamp = Date.now();
-      let dest = join42(destDir, `${entry.file}.${stamp}.retired`);
+      let dest = join43(destDir, `${entry.file}.${stamp}.retired`);
       for (let n = 1; existsSync19(dest); n++) {
-        dest = join42(destDir, `${entry.file}.${stamp}-${n}.retired`);
+        dest = join43(destDir, `${entry.file}.${stamp}-${n}.retired`);
       }
       renameSync11(filePath, dest);
       try {
@@ -22655,11 +22774,11 @@ function reapRetiredMemories(configDir, codeName, log2) {
   const cutoff = Date.now() - RETIRED_MEMORY_TTL_MS;
   let reaped = 0;
   try {
-    for (const file of readdirSync12(dir)) {
+    for (const file of readdirSync13(dir)) {
       if (!file.endsWith(".retired")) continue;
-      const path = join42(dir, file);
+      const path = join43(dir, file);
       try {
-        if (statSync13(path).mtimeMs < cutoff) {
+        if (statSync14(path).mtimeMs < cutoff) {
           unlinkSync6(path);
           reaped++;
         }
@@ -22672,8 +22791,8 @@ function reapRetiredMemories(configDir, codeName, log2) {
   if (reaped > 0) log2(`[memory-retire] ${codeName}: reaped ${reaped} retired memory file(s) past TTL`);
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join42(configDir, agent.code_name, "project");
-  const memoryDir = join42(projectDir, "memory");
+  const projectDir = join43(configDir, agent.code_name, "project");
+  const memoryDir = join43(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`);
@@ -22701,10 +22820,10 @@ async function syncMemories(agent, configDir, log2) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
-    for (const file of readdirSync12(memoryDir)) {
+    for (const file of readdirSync13(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync34(join42(memoryDir, file), "utf-8");
+        const raw = readFileSync34(join43(memoryDir, file), "utf-8");
         const fileHash = createHash20("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -22729,7 +22848,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync34(join42(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync34(join43(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -22755,7 +22874,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
-  const localFiles = existsSync19(memoryDir) ? readdirSync12(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync19(memoryDir) ? readdirSync13(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash20("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -22810,7 +22929,7 @@ async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
         // Per-agent, not host-wide: memories are agent-private, so a shared
         // store would buy almost no dedupe while exposing one agent's content
         // to every other agent on the host. See memory-cache.ts's header.
-        cacheDir: join42(configDir, agent.code_name, "_memory_bodies"),
+        cacheDir: join43(configDir, agent.code_name, "_memory_bodies"),
         fetchContents: async (hashes) => {
           const res = await api.post(
             "/host/memories/contents",
@@ -22848,7 +22967,7 @@ async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
         const fileName = `${slug}.md`;
-        const filePath = join42(memoryDir, fileName);
+        const filePath = join43(memoryDir, fileName);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -22886,7 +23005,7 @@ ${mem.content}
         if (manifestDirty) saveMemoryManifest(agent.agent_id, configDir, agent.code_name);
       }
       if (written > 0 || overwritten > 0) {
-        const updatedFiles = readdirSync12(memoryDir).filter((f) => f.endsWith(".md")).sort();
+        const updatedFiles = readdirSync13(memoryDir).filter((f) => f.endsWith(".md")).sort();
         lastLocalFileHash.set(agent.agent_id, createHash20("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
@@ -22962,7 +23081,7 @@ async function driveArtifactStreaming() {
 }
 async function driveArtifactStreamingInner() {
   const liveIds = /* @__PURE__ */ new Set();
-  for (const agent of state8.agents) {
+  for (const agent of state9.agents) {
     if (!agent.agentId || !agent.codeName || agent.status !== "active") continue;
     liveIds.add(agent.agentId);
     let scanner = artifactScanners.get(agent.agentId);
@@ -22995,7 +23114,7 @@ async function postLivenessHeartbeat() {
     await api.post("/host/heartbeat", {
       host_id: hostId,
       agt_version: agtCliVersion,
-      last_poll_at: state8.lastPollAt ?? void 0,
+      last_poll_at: state9.lastPollAt ?? void 0,
       // The delay actually in force, so the monitor compares against reality
       // rather than a constant — a manager riding out an API outage under the
       // ENG-5041 backoff must not be paged as stopped.
@@ -23264,8 +23383,8 @@ function startManager(opts) {
       const raw = readFileSync34(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
-        state8.agents = parsed.agents;
-        log(`[startup] rehydrated ${state8.agents.length} agent state(s) from ${stateFile}`);
+        state9.agents = parsed.agents;
+        log(`[startup] rehydrated ${state9.agents.length} agent state(s) from ${stateFile}`);
       }
       if (parsed.circuitBreakerTrips && typeof parsed.circuitBreakerTrips === "object") {
         restartBreaker.hydrate(parsed.circuitBreakerTrips);
@@ -23278,9 +23397,9 @@ function startManager(opts) {
         if (n > 0) log(`[startup] rehydrated ${n} auto-resume marker(s) (ENG-6088)`);
       }
       if (typeof parsed.lastUpdateRequestProcessedAt === "string" || parsed.lastUpdateRequestProcessedAt === null) {
-        state8.lastUpdateRequestProcessedAt = parsed.lastUpdateRequestProcessedAt;
-        if (state8.lastUpdateRequestProcessedAt) {
-          log(`[startup] rehydrated update-request ack at ${state8.lastUpdateRequestProcessedAt} (ENG-6692)`);
+        state9.lastUpdateRequestProcessedAt = parsed.lastUpdateRequestProcessedAt;
+        if (state9.lastUpdateRequestProcessedAt) {
+          log(`[startup] rehydrated update-request ack at ${state9.lastUpdateRequestProcessedAt} (ENG-6692)`);
         }
       }
     }
@@ -23288,7 +23407,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=${join42(homedir17(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join43(homedir17(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -23300,7 +23419,7 @@ function startManager(opts) {
     }
     try {
       refreshSlackRestartContextHints(
-        state8.agents.map((a) => a.codeName),
+        state9.agents.map((a) => a.codeName),
         { log }
       );
     } catch (err) {
@@ -23414,14 +23533,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join42(homedir17(), ".augmented", "_mcp");
+  const targetDir = join43(homedir17(), ".augmented", "_mcp");
   mkdirSync15(targetDir, { recursive: true });
   const moduleDir = dirname11(fileURLToPath2(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join42(dir, "dist", "mcp");
-    if (existsSync19(join42(candidate, "index.js"))) {
+    const candidate = join43(dir, "dist", "mcp");
+    if (existsSync19(join43(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -23521,8 +23640,8 @@ function deployMcpAssets() {
     // natural session restart.
     "computer-use-proxy.js"
   ]) {
-    const src = join42(mcpSourceDir, file);
-    const dst = join42(targetDir, file);
+    const src = join43(mcpSourceDir, file);
+    const dst = join43(targetDir, file);
     if (!existsSync19(src)) continue;
     attemptedFiles.push(file);
     const before = fileHash(dst);
@@ -23548,14 +23667,14 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join42(targetDir, "index.js");
+  const localMcpPath = join43(targetDir, "index.js");
   try {
-    const agentsDir = join42(homedir17(), ".augmented", "agents");
+    const agentsDir = join43(homedir17(), ".augmented", "agents");
     if (existsSync19(agentsDir)) {
-      for (const entry of readdirSync12(agentsDir, { withFileTypes: true })) {
+      for (const entry of readdirSync13(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join42(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join43(agentsDir, entry.name, subdir, ".mcp.json");
           try {
             const raw = readFileSync34(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;