@integrity-labs/agt-cli 0.28.568 → 0.28.570

package/dist/lib/manager-worker.js

@@ -53,7 +53,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-VGMO43EI.js";
+} from "../chunk-LNLLMDJJ.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -182,17 +182,17 @@ import {
   toOpencodeModel,
   transcriptActivityAgeSeconds,
   writeEgressAllowlist
-} from "../chunk-FSWAPB5J.js";
+} from "../chunk-6XCGZUSS.js";
 import {
   reapOrphanChannelMcps
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
 import { createHash as createHash17 } from "crypto";
-import { readFileSync as readFileSync26, writeFileSync as writeFileSync14, mkdirSync as mkdirSync11, existsSync as existsSync14, rmSync as rmSync5, readdirSync as readdirSync9, statSync as statSync8, copyFileSync } from "fs";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync14, mkdirSync as mkdirSync11, existsSync as existsSync14, rmSync as rmSync5, readdirSync as readdirSync9, statSync as statSync8, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join33, dirname as dirname9, delimiter as pathDelimiter } from "path";
-import { homedir as homedir15 } from "os";
+import { join as join34, dirname as dirname9, delimiter as pathDelimiter } from "path";
+import { homedir as homedir16 } from "os";
 import { fileURLToPath } from "url";
 
 // src/lib/claude-code-upgrade-throttle.ts
@@ -3504,20 +3504,55 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 }
 
 // src/lib/tool-call-audit.ts
-import { homedir as homedir9 } from "os";
-import { join as join17 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join18 } from "path";
+
+// src/lib/agent-logging-mode.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join14 } from "path";
+var LOGGING_MODES = ["hash-only", "redacted", "full-local"];
+function charterPath(codeName, homeDir) {
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir7());
+  const key = agentRuntimeKey(codeName, homeDir);
+  return join14(home, ".augmented", key, "provision", "CHARTER.md");
+}
+function readAgentLoggingMode(codeName, homeDir) {
+  let raw;
+  try {
+    raw = readFileSync11(charterPath(codeName, homeDir), "utf-8");
+  } catch {
+    return { mode: null, reason: "no-charter" };
+  }
+  let frontmatter;
+  try {
+    frontmatter = extractFrontmatter(raw).frontmatter;
+  } catch {
+    return { mode: null, reason: "unparseable" };
+  }
+  if (!frontmatter) return { mode: null, reason: "unparseable" };
+  const declared = frontmatter["logging_mode"];
+  if (declared === void 0 || declared === null) return { mode: null, reason: "not-declared" };
+  if (typeof declared !== "string" || !LOGGING_MODES.includes(declared)) {
+    return { mode: null, reason: "unrecognised" };
+  }
+  return { mode: declared };
+}
+function loggingModeWithholdsTargets(reading) {
+  return reading.mode === null || reading.mode === "hash-only";
+}
 
 // src/lib/tool-call-path-salt.ts
 import { randomBytes } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync11, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname5, join as join14 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync12, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname5, join as join15 } from "path";
 var SALT_BYTES = 32;
 var SALT_RE = /^[0-9a-f]{64}$/;
 function pathSaltPath(codeName, homeDir) {
-  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir7());
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir8());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join14(home, ".augmented", key, "tool-call-path-salt");
+  return join15(home, ".augmented", key, "tool-call-path-salt");
 }
 function readToolCallPathSalt(codeName, homeDir) {
   let file;
@@ -3528,7 +3563,7 @@ function readToolCallPathSalt(codeName, homeDir) {
   }
   try {
     if (existsSync3(file)) {
-      const existing = readFileSync11(file, "utf-8").trim();
+      const existing = readFileSync12(file, "utf-8").trim();
       if (SALT_RE.test(existing)) return existing;
     }
   } catch {
@@ -3554,7 +3589,7 @@ function readToolCallPathSalt(codeName, homeDir) {
 import { statSync as statSync4 } from "fs";
 
 // src/lib/host-archive-address.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 var DEFAULT_ARCHIVE_ADDRESS_PATH = "/var/lib/augmented/session-archive-address.json";
 var CACHE_TTL_MS = 5 * 60 * 1e3;
 var cache = /* @__PURE__ */ new Map();
@@ -3570,7 +3605,7 @@ function readHostArchiveAddress(path) {
   if (hit && now - hit.at < CACHE_TTL_MS) return hit.value;
   let value = null;
   try {
-    const raw = readFileSync12(file, "utf-8");
+    const raw = readFileSync13(file, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const obj = parsed;
@@ -3593,8 +3628,8 @@ function readHostArchiveAddress(path) {
 }
 
 // src/lib/tool-call-extractor.ts
-import { closeSync, fstatSync, openSync, readFileSync as readFileSync13, readSync, readdirSync as readdirSync4 } from "fs";
-import { basename, join as join15, relative } from "path";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync14, readSync, readdirSync as readdirSync4 } from "fs";
+import { basename, join as join16, relative } from "path";
 import { StringDecoder } from "string_decoder";
 
 // src/lib/tool-call-redaction.ts
@@ -3723,7 +3758,7 @@ function redactToolTargetInner(toolName, input, ctx) {
 var EXTRACTOR_VERSION = "e1";
 function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
   const files = [];
-  const mainAbs = join15(transcriptDir, `${sessionId}.jsonl`);
+  const mainAbs = join16(transcriptDir, `${sessionId}.jsonl`);
   files.push({
     absPath: mainAbs,
     relPath: relative(projectsRoot, mainAbs),
@@ -3731,7 +3766,7 @@ function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
     isSubagent: false,
     subagentId: null
   });
-  const subDir = join15(transcriptDir, sessionId, "subagents");
+  const subDir = join16(transcriptDir, sessionId, "subagents");
   let entries;
   try {
     entries = readdirSync4(subDir);
@@ -3740,7 +3775,7 @@ function enumerateSessionTranscripts(transcriptDir, sessionId, projectsRoot) {
   }
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const abs = join15(subDir, name);
+    const abs = join16(subDir, name);
     const stem = basename(name, ".jsonl");
     files.push({
       absPath: abs,
@@ -3833,6 +3868,7 @@ function scanLines(lines, file, opts) {
   return { records: ordered, pending: pending2 };
 }
 var WINDOW_CHUNK_BYTES = 64 * 1024;
+var WINDOW_BUDGET_BYTES = 4 * 1024 * 1024;
 function extractTranscriptWindow(file, opts, from) {
   let fd;
   try {
@@ -3844,14 +3880,17 @@ function extractTranscriptWindow(file, opts, from) {
       endLine: from.lineOffset,
       unpaired: [],
       missing: true,
-      rewound: false
+      rewound: false,
+      truncated: false
     };
   }
   let startByte = from.byteOffset;
   let startLine = from.lineOffset;
   let rewound = false;
+  let fileSize = null;
   try {
     const { size } = fstatSync(fd);
+    fileSize = size;
     if (startByte > size) {
       startByte = 0;
       startLine = 0;
@@ -3859,15 +3898,22 @@ function extractTranscriptWindow(file, opts, from) {
     }
   } catch {
   }
+  const requested = from.budgetBytes;
+  const budget = typeof requested === "number" && Number.isFinite(requested) && requested >= 1 ? Math.floor(requested) : WINDOW_BUDGET_BYTES;
   const decoder = new StringDecoder("utf8");
   const buf = Buffer.allocUnsafe(WINDOW_CHUNK_BYTES);
   let position = startByte;
   let runningByte = startByte;
   let lineOffset = startLine;
   let carry = "";
+  let hitBudget = false;
   const pairs = [];
   try {
     for (; ; ) {
+      if (runningByte - startByte >= budget) {
+        hitBudget = true;
+        break;
+      }
       const bytesRead = readSync(fd, buf, 0, WINDOW_CHUNK_BYTES, position);
       if (bytesRead <= 0) break;
       position += bytesRead;
@@ -3875,11 +3921,18 @@ function extractTranscriptWindow(file, opts, from) {
       let nl;
       while ((nl = carry.indexOf("\n")) !== -1) {
         const line = carry.slice(0, nl);
+        const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+        const consumed = runningByte - startByte;
+        if (consumed > 0 && consumed + lineBytes > budget) {
+          hitBudget = true;
+          break;
+        }
         pairs.push([lineOffset, line, runningByte]);
-        runningByte += Buffer.byteLength(line, "utf8") + 1;
+        runningByte += lineBytes;
         lineOffset += 1;
         carry = carry.slice(nl + 1);
       }
+      if (hitBudget) break;
     }
   } catch {
   } finally {
@@ -3894,13 +3947,22 @@ function extractTranscriptWindow(file, opts, from) {
     byteStart: p.byteStart,
     lineOffset: p.record.line_offset
   })).sort((a, b) => a.byteStart - b.byteStart);
-  return { records, endByte: runningByte, endLine: lineOffset, unpaired, missing: false, rewound };
+  const truncated = hitBudget && (fileSize === null || runningByte < fileSize);
+  return {
+    records,
+    endByte: runningByte,
+    endLine: lineOffset,
+    unpaired,
+    missing: false,
+    rewound,
+    truncated
+  };
 }
 
 // src/lib/tool-call-cursor.ts
-import { existsSync as existsSync4, readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync15 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join17 } from "path";
 var COVERAGE_DISPOSITIONS = [
   "ok",
   "not_entitled",
@@ -3953,27 +4015,42 @@ function parseCursorKey(key) {
   return { sessionId: sessionId.length > 0 ? sessionId : null, transcriptRef: key.slice(i + 1) };
 }
 function cursorStatePath(codeName, homeDir) {
-  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir8());
+  const home = homeDir ?? (process.env["HOME"]?.trim() || homedir9());
   const key = agentRuntimeKey(codeName, homeDir);
-  return join16(home, ".augmented", key, "tool-call-cursors.json");
+  return join17(home, ".augmented", key, "tool-call-cursors.json");
 }
 function loadCursors(path) {
   const out = /* @__PURE__ */ new Map();
   if (!existsSync4(path)) return out;
   try {
-    const parsed = JSON.parse(readFileSync14(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(path, "utf-8"));
     if (!parsed || parsed.version !== 1 || typeof parsed.files !== "object") return out;
     for (const [k, v] of Object.entries(parsed.files)) {
       if (!v || typeof v !== "object") continue;
-      const offsetsOk = ["byteOffset", "lineOffset", "startedFromLine", "callsExtracted"].every((f) => {
+      const offsetsOk = [
+        "byteOffset",
+        "lineOffset",
+        "startedFromLine",
+        "startedFromByte",
+        "scannedThroughByte",
+        "scannedThroughLine",
+        "rewindGeneration",
+        "callsExtracted"
+      ].every((f) => {
         const n = v[f];
         return n === void 0 || typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
       });
       if (typeof v.byteOffset !== "number" || typeof v.lineOffset !== "number" || !offsetsOk) continue;
+      const startedFromByte = typeof v.startedFromByte === "number" ? v.startedFromByte : v.byteOffset;
       out.set(k, {
         byteOffset: v.byteOffset,
         lineOffset: v.lineOffset,
         startedFromLine: typeof v.startedFromLine === "number" ? v.startedFromLine : 0,
+        startedFromByte,
+        scannedThroughByte: typeof v.scannedThroughByte === "number" ? v.scannedThroughByte : startedFromByte,
+        scannedThroughLine: typeof v.scannedThroughLine === "number" ? v.scannedThroughLine : typeof v.startedFromLine === "number" ? v.startedFromLine : 0,
+        rewindGeneration: typeof v.rewindGeneration === "number" ? v.rewindGeneration : 0,
+        lastWindowTruncated: v.lastWindowTruncated === true,
         callsExtracted: typeof v.callsExtracted === "number" ? v.callsExtracted : 0,
         unpairedSince: typeof v.unpairedSince === "string" ? v.unpairedSince : null,
         lastDisposition: COVERAGE_DISPOSITIONS.includes(v.lastDisposition) ? v.lastDisposition : "ok",
@@ -3992,22 +4069,47 @@ function saveCursors(path, cursors) {
   atomicWriteFileSync(path, JSON.stringify({ version: 1, files }, null, 2));
 }
 function nextCursor(args) {
-  const { previous, endByte, endLine, earliestUnpaired, outcome, nowMs } = args;
+  const { endByte, endLine, earliestUnpaired, outcome, nowMs } = args;
   const nowIso = new Date(nowMs).toISOString();
   const disposition = dispositionFor(outcome);
+  const truncated = args.truncated === true;
+  const previous = args.rewound ? {
+    ...args.previous,
+    byteOffset: 0,
+    lineOffset: 0,
+    scannedThroughByte: 0,
+    scannedThroughLine: 0,
+    startedFromByte: 0,
+    startedFromLine: 0,
+    rewindGeneration: args.previous.rewindGeneration + 1,
+    // The call this was waiting on lived in the old file. Holding its clock
+    // would apply an unrelated deadline to the new one.
+    unpairedSince: null
+  } : args.previous;
   if (!mayAdvance(outcome)) {
-    return { ...previous, lastDisposition: disposition, lastScanAt: nowIso };
+    return {
+      ...previous,
+      lastDisposition: disposition,
+      lastScanAt: nowIso,
+      lastWindowTruncated: truncated
+    };
   }
   const callsExtracted = previous.callsExtracted + args.callsExtracted;
+  const covered = (throughByte, throughLine) => ({
+    scannedThroughByte: Math.max(previous.scannedThroughByte, throughByte),
+    scannedThroughLine: Math.max(previous.scannedThroughLine, throughLine)
+  });
   if (!earliestUnpaired) {
     return {
       ...previous,
       byteOffset: endByte,
       lineOffset: endLine,
+      ...covered(endByte, endLine),
       callsExtracted,
       unpairedSince: null,
       lastDisposition: disposition,
-      lastScanAt: nowIso
+      lastScanAt: nowIso,
+      lastWindowTruncated: truncated
     };
   }
   const since = previous.unpairedSince ?? nowIso;
@@ -4017,20 +4119,30 @@ function nextCursor(args) {
       ...previous,
       byteOffset: endByte,
       lineOffset: endLine,
+      ...covered(endByte, endLine),
       callsExtracted,
       unpairedSince: null,
       lastDisposition: disposition,
-      lastScanAt: nowIso
+      lastScanAt: nowIso,
+      lastWindowTruncated: truncated
     };
   }
+  const resumeByte = Math.max(previous.byteOffset, Math.min(endByte, earliestUnpaired.byteStart));
+  const resumeLine = Math.max(previous.lineOffset, Math.min(endLine, earliestUnpaired.lineOffset));
   return {
     ...previous,
-    byteOffset: Math.max(previous.byteOffset, Math.min(endByte, earliestUnpaired.byteStart)),
-    lineOffset: Math.max(previous.lineOffset, Math.min(endLine, earliestUnpaired.lineOffset)),
+    byteOffset: resumeByte,
+    lineOffset: resumeLine,
+    // Covered ground stops at the unpaired call: the calls from there on were
+    // deliberately NOT sent (their `is_error` would be written null and
+    // `ignoreDuplicates` makes that permanent), so claiming them would be
+    // claiming rows the control plane has never been offered.
+    ...covered(resumeByte, resumeLine),
     callsExtracted,
     unpairedSince: since,
     lastDisposition: disposition,
-    lastScanAt: nowIso
+    lastScanAt: nowIso,
+    lastWindowTruncated: truncated
   };
 }
 function initialCursor(args) {
@@ -4038,7 +4150,12 @@ function initialCursor(args) {
   return {
     byteOffset: args.startByte,
     lineOffset: args.startLine,
+    scannedThroughByte: args.startByte,
+    scannedThroughLine: args.startLine,
     startedFromLine: args.startLine,
+    startedFromByte: args.startByte,
+    rewindGeneration: 0,
+    lastWindowTruncated: false,
     callsExtracted: 0,
     unpairedSince: null,
     lastDisposition: "ok",
@@ -4053,9 +4170,14 @@ function coverageRowFor(key, cursor, versions) {
     session_id: sessionId,
     transcript_ref: transcriptRef,
     transcript_rel_path: cursor.transcriptRelPath,
-    through_line: cursor.lineOffset,
-    through_byte: cursor.byteOffset,
+    through_line: cursor.scannedThroughLine,
+    through_byte: cursor.scannedThroughByte,
     started_from_line: cursor.startedFromLine,
+    started_from_byte: cursor.startedFromByte,
+    scan_position_byte: cursor.byteOffset,
+    scan_position_line: cursor.lineOffset,
+    scan_window_truncated: cursor.lastWindowTruncated,
+    rewind_generation: cursor.rewindGeneration,
     calls_extracted: cursor.callsExtracted,
     last_disposition: cursor.lastDisposition,
     extractor_version: versions.extractor,
@@ -4150,7 +4272,8 @@ async function scanAgentToolCalls(args) {
     }
     const window = extractTranscriptWindow(file, extractOpts, {
       byteOffset: cursor.byteOffset,
-      lineOffset: cursor.lineOffset
+      lineOffset: cursor.lineOffset,
+      ...args.windowBudgetBytes === void 0 ? {} : { budgetBytes: args.windowBudgetBytes }
     });
     summary.filesScanned += 1;
     if (window.missing) {
@@ -4161,6 +4284,11 @@ async function scanAgentToolCalls(args) {
     if (window.rewound) {
       log2(`[tool-call-scan] ${file.relPath} ref=${file.ref} shrank below the cursor \u2014 re-reading from 0`);
     }
+    if (window.truncated) {
+      log2(
+        `[tool-call-scan] ${file.relPath} ref=${file.ref} hit the window budget at byte ${window.endByte} \u2014 more remains, resuming next tick`
+      );
+    }
     summary.callsExtracted += window.records.length;
     const unpairedIds = new Set(window.unpaired.map((u) => u.toolUseId));
     const sendable = window.records.filter((r) => !unpairedIds.has(r.tool_use_id));
@@ -4183,7 +4311,9 @@ async function scanAgentToolCalls(args) {
       earliestUnpaired: window.unpaired[0] ?? null,
       outcome,
       callsExtracted: sendable.length,
-      nowMs: now()
+      nowMs: now(),
+      rewound: window.rewound,
+      truncated: window.truncated
     });
     const advanced = attempted ? computed : { ...computed, lastDisposition: cursor.lastDisposition };
     if (advanced.byteOffset === cursor.byteOffset && outcome.kind === "ingest_failed") {
@@ -4260,12 +4390,19 @@ async function maybeScanToolCalls(args) {
       return;
     }
     state5.set(codeName, { lastCheckedAt: nowMs, notEntitledAt: existing?.notEntitledAt ?? null });
+    const loggingMode = readAgentLoggingMode(codeName, args.homeDir);
+    const hashOnly = loggingModeWithholdsTargets(loggingMode);
+    if (loggingMode.mode === null) {
+      log2(
+        `[tool-call-audit] ${codeName}: charter logging_mode not established (${loggingMode.reason}) \u2014 withholding ALL targets for this agent`
+      );
+    }
     const salt = readToolCallPathSalt(codeName, args.homeDir);
-    if (!salt) {
+    if (!salt && !hashOnly) {
       log2(`[tool-call-audit] ${codeName}: no path-hash salt available \u2014 file targets withheld`);
     }
-    const home = args.homeDir ?? (process.env["HOME"]?.trim() || homedir9());
-    const projectsRoot = args.projectsRoot ?? join17(home, ".claude", "projects");
+    const home = args.homeDir ?? (process.env["HOME"]?.trim() || homedir10());
+    const projectsRoot = args.projectsRoot ?? join18(home, ".claude", "projects");
     const transcriptDir = args.transcriptDir ?? sessionTranscriptDir(getProjectDir(codeName));
     const current = peekCurrentSession(codeName);
     const sessionIds = current ? [current.sessionId] : [];
@@ -4277,7 +4414,7 @@ async function maybeScanToolCalls(args) {
       projectsRoot,
       sessionIds,
       pathHashSalt: salt ?? "",
-      ...args.hashOnly === void 0 ? {} : { hashOnly: args.hashOnly },
+      hashOnly,
       log: log2,
       now: nowFn,
       ...args.homeDir === void 0 ? {} : { homeDir: args.homeDir },
@@ -4294,11 +4431,11 @@ async function maybeScanToolCalls(args) {
 }
 
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync5, readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join18 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join19 } from "path";
 var MIN_CHECK_INTERVAL_MS7 = 6e4;
-var STATS_CACHE_PATH = join18(homedir10(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join19(homedir11(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state6 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -4346,7 +4483,7 @@ async function maybeReportActivityCache(args) {
   }
   let raw;
   try {
-    raw = readFileSync15(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync16(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
@@ -4571,18 +4708,18 @@ function computeChannelConfigHash(input) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync6, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "fs";
+import { join as join20 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join19(configDir, CACHE_FILENAME);
+  return join20(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
   if (!existsSync6(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf-8"));
+    parsed = JSON.parse(readFileSync17(path, "utf-8"));
   } catch {
     return;
   }
@@ -4602,8 +4739,8 @@ function saveChannelHashCache(source, configDir) {
 }
 
 // src/lib/sender-policy-baseline.ts
-import { existsSync as existsSync7, readFileSync as readFileSync17 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync18 } from "fs";
+import { join as join21 } from "path";
 var BASELINE_FILENAME = "sender-policy-baseline.json";
 var SENDER_POLICY_BASELINE_VERSION = 1;
 var BASELINE_CONCERNS = ["senderPolicy", "slackBehaviour", "msteamsBehaviour"];
@@ -4615,14 +4752,14 @@ function createDeliveryBaselineMaps() {
   };
 }
 function getSenderPolicyBaselineFile(configDir) {
-  return join20(configDir, BASELINE_FILENAME);
+  return join21(configDir, BASELINE_FILENAME);
 }
 function loadSenderPolicyBaseline(target, configDir, log2) {
   const path = getSenderPolicyBaselineFile(configDir);
   if (!existsSync7(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(path, "utf-8"));
+    parsed = JSON.parse(readFileSync18(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[sender-policy] discarding corrupt ${BASELINE_FILENAME} (${err.message}) - restrictive-policy agents will take one fail-closed restart`
@@ -5145,7 +5282,7 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // src/lib/manager/integration-skill-cache.ts
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function integrationSkillHashKey(agentId, skillId) {
   return `plugin-skill:${agentId}:${skillId}`;
 }
@@ -5161,21 +5298,21 @@ function forgetIntegrationSkill(cache3, agentId, skillId) {
 function removeIntegrationSkillFolder(opts) {
   forgetIntegrationSkill(opts.cache, opts.agentId, opts.entry);
   for (const dir of opts.dirs) {
-    opts.removeDir(join21(dir, opts.entry));
+    opts.removeDir(join22(dir, opts.entry));
   }
 }
 
 // src/lib/manager/managed-skill-manifest.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname6, join as join22 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname6, join as join23 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join22(agentRootDir, "managed-skills.json");
+  return join23(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
     if (!existsSync8(path)) return /* @__PURE__ */ new Set();
-    const parsed = JSON.parse(readFileSync18(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync19(path, "utf-8"));
     const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
     return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
   } catch {
@@ -5288,8 +5425,8 @@ function resolveModelChain(refreshData) {
 
 // src/lib/manager/claude-auth.ts
 import { existsSync as existsSync9, rmSync as rmSync3 } from "fs";
-import { join as join23 } from "path";
-import { homedir as homedir11 } from "os";
+import { join as join24 } from "path";
+import { homedir as homedir12 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -5301,9 +5438,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 = join23(homedir11(), ".claude");
+    const claudeDir = join24(homedir12(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join23(claudeDir, filename);
+      const p = join24(claudeDir, filename);
       if (existsSync9(p)) {
         try {
           rmSync3(p, { force: true });
@@ -5385,8 +5522,8 @@ function heartbeatRuntimeAuthFields(probeVerdict) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync10, readFileSync as readFileSync19 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync20 } from "fs";
+import { join as join25 } from "path";
 var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
 var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
 var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
@@ -5538,12 +5675,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join24(process.cwd(), "skills", skillId, "SKILL.md"),
-      join24(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join25(process.cwd(), "skills", skillId, "SKILL.md"),
+      join25(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync10(candidate)) {
-        const content = readFileSync19(candidate, "utf-8");
+        const content = readFileSync20(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -5684,19 +5821,19 @@ function formatBoardForPrompt(items, template) {
 }
 
 // src/lib/manager/kanban/nudge-state-cache.ts
-import { existsSync as existsSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync9 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync9 } from "fs";
+import { join as join26 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join25(configDir, CACHE_FILENAME2);
+  return join26(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
   if (!existsSync11(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf-8"));
+    parsed = JSON.parse(readFileSync21(path, "utf-8"));
   } catch {
     return;
   }
@@ -6303,9 +6440,9 @@ function closeScheduledRunsForCode(codeName, outcome, reason) {
 
 // src/lib/manager/scheduler/kanban-route.ts
 import { createHash as createHash12 } from "crypto";
-import { writeFileSync as writeFileSync10, renameSync as renameSync4, mkdirSync as mkdirSync7, readFileSync as readFileSync21, unlinkSync as unlinkSync2 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join26, dirname as dirname7 } from "path";
+import { writeFileSync as writeFileSync10, renameSync as renameSync4, mkdirSync as mkdirSync7, readFileSync as readFileSync22, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join27, dirname as dirname7 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
 import { createHash as createHash11 } from "crypto";
@@ -6664,7 +6801,7 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join26(homedir12(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join27(homedir13(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
     writeFileSync10(tmp, JSON.stringify(marker), "utf8");
@@ -6674,9 +6811,9 @@ function stampScheduledTurnMarker(codeName, taskId, target) {
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join26(homedir12(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join27(homedir13(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
-    const raw = JSON.parse(readFileSync21(file, "utf8"));
+    const raw = JSON.parse(readFileSync22(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
     unlinkSync2(file);
     log(`[scheduled-kanban] scheduled-turn marker cleared for '${codeName}' (task ${taskId} complete)`);
@@ -6736,7 +6873,7 @@ async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt, dura
       return false;
     }
     try {
-      const doorbell = directChatDoorbellPath(agentId, homedir12());
+      const doorbell = directChatDoorbellPath(agentId, homedir13());
       mkdirSync7(dirname7(doorbell), { recursive: true });
       writeFileSync10(doorbell, String(Date.now()));
     } catch (err) {
@@ -6888,12 +7025,12 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 
 // src/lib/manager/scheduler/execution.ts
 import { createHash as createHash13 } from "crypto";
-import { homedir as homedir13 } from "os";
-import { join as join28 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join29 } from "path";
 
 // src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync22, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync23, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { join as join28 } from "path";
 var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
 function probeRateLimit(args) {
   const now = args.now ?? /* @__PURE__ */ new Date();
@@ -6909,7 +7046,7 @@ function probeRateLimit(args) {
   let newest = UNKNOWN_RATE_LIMIT;
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const path = join27(dir, name);
+    const path = join28(dir, name);
     try {
       const st = statSync5(path);
       if (!st.isFile() || st.mtimeMs < startMs) continue;
@@ -6918,7 +7055,7 @@ function probeRateLimit(args) {
     }
     let content;
     try {
-      content = readFileSync22(path, "utf-8");
+      content = readFileSync23(path, "utf-8");
     } catch {
       continue;
     }
@@ -6980,7 +7117,7 @@ function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
 
 // src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join28(homedir13(), ".augmented", "manager-claude-pids.json");
+  return join29(homedir14(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -7051,7 +7188,7 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 
 // src/lib/occupancy-gate.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync6, readSync as readSync2, statSync as statSync6 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var TAIL_BYTES = 256 * 1024;
 var MAX_RECORD_ALIGN_BYTES = 8 * 1024 * 1024;
 var GATE_MAX_BUCKET_AGE_MS = 30 * 6e4;
@@ -7137,10 +7274,10 @@ function candidateTranscriptPaths(dir) {
   let complete = true;
   for (const name of top) {
     if (name.endsWith(".jsonl")) {
-      paths.push(join29(dir, name));
+      paths.push(join30(dir, name));
       continue;
     }
-    const subDir = join29(dir, name, "subagents");
+    const subDir = join30(dir, name, "subagents");
     let subs;
     try {
       subs = readdirSync6(subDir);
@@ -7149,7 +7286,7 @@ function candidateTranscriptPaths(dir) {
       continue;
     }
     for (const sub of subs) {
-      if (sub.endsWith(".jsonl")) paths.push(join29(subDir, sub));
+      if (sub.endsWith(".jsonl")) paths.push(join30(subDir, sub));
     }
   }
   return { paths, complete };
@@ -8422,9 +8559,9 @@ async function fireOpencodeScheduledTask(agent, task) {
 
 // src/lib/opencode-telegram-ingest.ts
 import { createHash as createHash16 } from "crypto";
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync23, renameSync as renameSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync24, renameSync as renameSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync11 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -8972,7 +9109,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join30(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join31(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -8981,7 +9118,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
     load() {
       if (!filePath) return 0;
       try {
-        const parsed = JSON.parse(readFileSync23(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync24(filePath, "utf-8"));
         if (currentBotId != null && typeof parsed?.bot_id === "number" && parsed.bot_id !== currentBotId) {
           log2(`[telegram-ingest:${codeName}] offset cursor belongs to a different bot; ignoring (bot swap)`);
           return 0;
@@ -9251,15 +9388,15 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync24, renameSync as renameSync6, rmSync as rmSync4, writeFileSync as writeFileSync12 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync25, renameSync as renameSync6, rmSync as rmSync4, writeFileSync as writeFileSync12 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join32 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join31(homedir14(), ".augmented", "restart-flags");
+  return join32(homedir15(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join31(restartFlagsDir(), `${codeName}.flag`);
+  return join32(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
@@ -9268,7 +9405,7 @@ function readRestartFlags() {
   for (const entry of readdirSync7(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync24(join31(dir, entry), "utf8");
+      const raw = readFileSync25(join32(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -9386,8 +9523,8 @@ async function sendError(flag, opts, text) {
 }
 
 // src/lib/restart-context.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync25, writeFileSync as writeFileSync13, mkdirSync as mkdirSync10, unlinkSync as unlinkSync4 } from "fs";
-import { dirname as dirname8, join as join32 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync26, writeFileSync as writeFileSync13, mkdirSync as mkdirSync10, unlinkSync as unlinkSync4 } from "fs";
+import { dirname as dirname8, join as join33 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -9399,10 +9536,10 @@ function augmentedAgentDir(codeName) {
   return dirname8(getProjectDir(codeName));
 }
 function slackPendingInboundDir(codeName) {
-  return join32(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
+  return join33(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
 }
 function slackRestartContextDir(codeName) {
-  return join32(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
+  return join33(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
 }
 function sanitizeTopic(raw) {
   const cleaned = raw.replace(/\s+/g, " ").trim().replace(/[<>]/g, " ").replace(/\s+/g, " ").trim();
@@ -9444,7 +9581,7 @@ function safeReaddir(dir) {
 }
 function readStrandedMarker(path) {
   try {
-    const parsed = JSON.parse(readFileSync25(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync26(path, "utf-8"));
     if (typeof parsed.channel === "string" && typeof parsed.thread_ts === "string") {
       return { channel: parsed.channel, thread_ts: parsed.thread_ts };
     }
@@ -9462,7 +9599,7 @@ function pruneHintsExcept(codeName, freshFilenames) {
     if (!filename.endsWith(".json")) continue;
     if (freshFilenames.has(filename)) continue;
     try {
-      unlinkSync4(join32(ctxDir, filename));
+      unlinkSync4(join33(ctxDir, filename));
     } catch {
     }
   }
@@ -9483,7 +9620,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       }
       const markers = [];
       for (const filename of markerFilenames.slice(0, cap)) {
-        const parsed = readStrandedMarker(join32(markerDir, filename));
+        const parsed = readStrandedMarker(join33(markerDir, filename));
         if (parsed) markers.push({ filename, channel: parsed.channel, thread_ts: parsed.thread_ts });
       }
       if (markers.length === 0) {
@@ -9497,7 +9634,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       const freshFilenames = /* @__PURE__ */ new Set();
       for (const { filename, hint } of hints) {
         try {
-          writeHintFile(join32(ctxDir, filename), ctxDir, hint);
+          writeHintFile(join33(ctxDir, filename), ctxDir, hint);
           freshFilenames.add(filename);
         } catch (err) {
           log2(`[restart-context] ${codeName}: hint write failed for ${filename}: ${err.message}`);
@@ -11014,7 +11151,7 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync26(join33(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync27(join34(projectDir, ".mcp.json"), "utf-8");
     return createHash17("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
@@ -11022,7 +11159,7 @@ function projectMcpHash(_codeName, projectDir) {
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync26(join33(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync27(join34(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -11040,7 +11177,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync26(join33(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync27(join34(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -11150,7 +11287,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(readFileSync26(join33(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync27(join34(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -11294,7 +11431,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync26(join33(projectDir, ".env.integrations"), "utf-8")
+      readFileSync27(join34(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -11390,7 +11527,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.568" : "dev";
+var agtCliVersion = true ? "0.28.570" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -11723,7 +11860,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
     if (existsSync14(path)) {
-      const raw = readFileSync26(path, "utf-8").trim();
+      const raw = readFileSync27(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -11778,7 +11915,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync2("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join33(prefix, "bin");
+      const npmBin = join34(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -11895,7 +12032,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join33(homedir15(), ".augmented", ".last-self-update-applied");
+  return join34(homedir16(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -11924,7 +12061,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 = join33(homedir15(), ".augmented", ".last-update-check");
+    const markerPath = join34(homedir16(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -12330,7 +12467,7 @@ async function runClaudeRuntimeAuthProbe() {
   ];
   try {
     const { stdout, stderr } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-      cwd: homedir15(),
+      cwd: homedir16(),
       timeout: RUNTIME_AUTH_PROBE_TIMEOUT_MS,
       stdin: "ignore",
       env: childEnv,
@@ -12377,12 +12514,12 @@ async function checkClaudeAuth() {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync14(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join33(homedir15(), ".augmented");
+  const dir = join34(homedir16(), ".augmented");
   try {
     mkdirSync11(dir, { recursive: true });
   } catch {
   }
-  const p = join33(dir, ".eval-empty-mcp.json");
+  const p = join34(dir, ".eval-empty-mcp.json");
   writeFileSync14(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
@@ -12408,7 +12545,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir15(),
+    cwd: homedir16(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -12477,10 +12614,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join33(config?.configDir ?? join33(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join34(config?.configDir ?? join34(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join33(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join34(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -12534,7 +12671,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join33(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join34(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -12551,7 +12688,7 @@ function claudeMdSizeFor(codeName) {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join33(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join34(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -12625,12 +12762,12 @@ function parseSkillFrontmatter(content) {
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
   const { readdirSync: readdirSync10, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync15 } = await import("fs");
-  const skillsDir = join33(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join33(configDir, codeName, "project", "CLAUDE.md");
+  const skillsDir = join34(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join34(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync10(skillsDir).sort()) {
-    const skillFile = join33(skillsDir, dir, "SKILL.md");
+    const skillFile = join34(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -12697,7 +12834,7 @@ function flushRestartedAgentDiagnostics(hostId, codeNames) {
   if (codeNames.length === 0) return;
   void (async () => {
     try {
-      const { collectDiagnostics } = await import("../persistent-session-DVTSZAPE.js");
+      const { collectDiagnostics } = await import("../persistent-session-HY6GUPBQ.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics(codeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics)
@@ -12805,7 +12942,7 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
-      const { collectDiagnostics } = await import("../persistent-session-DVTSZAPE.js");
+      const { collectDiagnostics } = await import("../persistent-session-HY6GUPBQ.js");
       const diagCodeNames = [...agentState.persistentSessionAgents];
       const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames, quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics) : void 0;
       let tailscaleHostname;
@@ -12928,7 +13065,7 @@ async function pollCycle() {
         collectPanelessActivityProbes,
         getResponsivenessIntervalMs,
         occupancyQualificationClassifications
-      } = await import("../responsiveness-probe-KEFPJXQ6.js");
+      } = await import("../responsiveness-probe-6EEZKJVV.js");
       const probeIntervalMs = getResponsivenessIntervalMs();
       if (now - lastResponsivenessProbeAt > probeIntervalMs) {
         const probeCodeNames = [...agentState.persistentSessionAgents];
@@ -13019,7 +13156,7 @@ async function pollCycle() {
           collectResponsivenessProbes,
           livePendingInboundOldestAgeSeconds,
           parkPendingInbound
-        } = await import("../responsiveness-probe-KEFPJXQ6.js");
+        } = await import("../responsiveness-probe-6EEZKJVV.js");
         const { getProjectDir: wedgeProjectDir } = await import("../scheduler-engine-NDP36U7O.js");
         const wedgeNow = /* @__PURE__ */ new Date();
         const liveAgents = agentState.persistentSessionAgents;
@@ -13108,13 +13245,13 @@ async function pollCycle() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync26(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync27(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join33(homedir15(), ".augmented", codeName);
+                  const wedgeHome = join34(homedir16(), ".augmented", codeName);
                   if (existsSync14(wedgeHome)) {
                     atomicWriteFileSync(
-                      join33(wedgeHome, "watchdog-give-up.json"),
+                      join34(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -13395,7 +13532,7 @@ async function pollCycle() {
         const adapter = resolveAgentFramework(prev.codeName);
         stopAgentRuntime2(prev.codeName, "removed-from-host");
         killAgentChannelProcesses(prev.codeName, { log });
-        const agentDir = join33(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join34(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -13482,10 +13619,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join33(homedir15(), ".augmented", codeName);
+          const dir = join34(homedir16(), ".augmented", codeName);
           if (!existsSync14(dir)) return;
           atomicWriteFileSync(
-            join33(dir, "watchdog-give-up.json"),
+            join34(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -13641,7 +13778,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join33(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join34(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -13815,7 +13952,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? DEFAULT_FRAMEWORK;
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join33(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join34(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,
@@ -13864,7 +14001,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync11(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join33(agentDir, artifact.relativePath);
+      const filePath = join34(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -13883,8 +14020,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join33(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync26(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join34(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync27(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -13902,7 +14039,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync26(filePath, "utf-8");
+          existingRaw = readFileSync27(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -13918,7 +14055,7 @@ async function processAgent(agent, agentStates) {
       } else if (artifact.relativePath === "opencode.json") {
         let existingRaw = null;
         try {
-          existingRaw = readFileSync26(filePath, "utf-8");
+          existingRaw = readFileSync27(filePath, "utf-8");
         } catch {
         }
         const mergeResult = mergeOpencodeConfigArtifact(artifact.content, existingRaw);
@@ -13934,12 +14071,12 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync14(join33(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync14(join34(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 = join33(agentDir, file.relativePath);
+        const filePath = join34(agentDir, file.relativePath);
         mkdirSync11(dirname9(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
@@ -13948,12 +14085,12 @@ async function processAgent(agent, agentStates) {
         }
       }
       try {
-        const provSkillsDir = join33(agentDir, ".claude", "skills");
+        const provSkillsDir = join34(agentDir, ".claude", "skills");
         if (existsSync14(provSkillsDir)) {
           for (const folder of readdirSync9(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync5(join33(provSkillsDir, folder), { recursive: true });
+                rmSync5(join34(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -13966,7 +14103,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join33(agentDir, file));
+        const h = hashFile(join34(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -13984,14 +14121,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join33(agentDir, ".claude", "workflows");
+        const provWorkflowsDir = join34(agentDir, ".claude", "workflows");
         if (existsSync14(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
           for (const file of readdirSync9(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync5(join33(provWorkflowsDir, file));
+              rmSync5(join34(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -14073,7 +14210,7 @@ async function processAgent(agent, agentStates) {
   if (written && existsSync14(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join33(agentDir, file));
+      const localHash = hashFile(join34(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -14084,7 +14221,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join33(agentDir, file));
+          localHashes[file] = hashFile(join34(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -14286,7 +14423,7 @@ async function processAgent(agent, agentStates) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join33(homedir15(), ".augmented", agent.code_name);
+        const agentAugmentedDir = join34(homedir16(), ".augmented", agent.code_name);
         mkdirSync11(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
@@ -14294,7 +14431,7 @@ async function processAgent(agent, agentStates) {
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join33(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join34(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -14483,18 +14620,18 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join33(homedir15(), ".augmented", agent.code_name, "project");
+      const projectDir = join34(homedir16(), ".augmented", agent.code_name, "project");
       mkdirSync11(agentProvisionDir, { recursive: true });
       mkdirSync11(projectDir, { recursive: true });
-      const provisionMcpPath = join33(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join33(projectDir, ".mcp.json");
+      const provisionMcpPath = join34(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join34(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync26(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync27(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join33(homedir15(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join34(homedir16(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -14520,7 +14657,7 @@ async function processAgent(agent, agentStates) {
           // ~/.augmented/<codeName>/.current-turn-initiator.json. Note getAgentDir
           // returns the agent root (NOT the /provision subdir `agentDir` points at),
           // so it byte-matches the broker readers' path.
-          AGT_TURN_INITIATOR_FILE: join33(
+          AGT_TURN_INITIATOR_FILE: join34(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -14540,7 +14677,7 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join33(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join34(projectDir, ".mcp-channels.json");
       if (existsSync14(staleChannelsPath)) {
         try {
           rmSync5(staleChannelsPath, { force: true });
@@ -14630,7 +14767,7 @@ async function processAgent(agent, agentStates) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join33(homedir15(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join34(homedir16(), ".augmented", agent.code_name, "project");
         let probeSet = integrations;
         try {
           const quarantined = await api.post("/host/agent-integrations/quarantined", { agent_id: agent.agent_id });
@@ -14676,7 +14813,7 @@ async function processAgent(agent, agentStates) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join33(homedir15(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join34(homedir16(), ".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}`);
@@ -14753,11 +14890,11 @@ async function processAgent(agent, agentStates) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join33(homedir15(), ".augmented", agent.code_name, "project");
-        const envIntPath = join33(projectDir, ".env.integrations");
+        const projectDir = join34(homedir16(), ".augmented", agent.code_name, "project");
+        const envIntPath = join34(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync26(envIntPath, "utf-8");
+          preWriteEnv = readFileSync27(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -14776,9 +14913,9 @@ async function processAgent(agent, agentStates) {
         }
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join33(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync26(envIntPath, "utf-8");
-            const mcpContent = readFileSync26(projectMcpPath, "utf-8");
+            const projectMcpPath = join34(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync27(envIntPath, "utf-8");
+            const mcpContent = readFileSync27(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -15042,16 +15179,16 @@ async function processAgent(agent, agentStates) {
       }
       try {
         const { readdirSync: readdirSync10, rmSync: rmSync6 } = await import("fs");
-        const { homedir: homedir16 } = await import("os");
+        const { homedir: homedir17 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join33(homedir16(), ".augmented", agent.code_name, "skills"),
+          join34(homedir17(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join33(homedir16(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join34(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join33(agentDir, ".claude", "skills")
+          join34(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync14(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
@@ -15092,7 +15229,7 @@ async function processAgent(agent, agentStates) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join33(homedir15(), ".augmented", agent.code_name)
+          join34(homedir16(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -15112,15 +15249,15 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join33(homedir15(), ".augmented", agent.code_name, "skills"),
-            join33(homedir15(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join33(agentDir, ".claude", "skills")
+            join34(homedir16(), ".augmented", agent.code_name, "skills"),
+            join34(homedir16(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join34(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join33(dir, id);
-              if (existsSync14(p) && existsSync14(join33(p, "SKILL.md"))) {
+              const p = join34(dir, id);
+              if (existsSync14(p) && existsSync14(join34(p, "SKILL.md"))) {
                 rmSync5(p, { recursive: true, force: true });
                 prunedAny = true;
               }
@@ -15352,8 +15489,8 @@ async function processAgent(agent, agentStates) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join33(getProjectDir(agent.code_name), ".mcp.json");
-          mcpJsonParsed = JSON.parse(readFileSync26(mcpPath, "utf-8"));
+          const mcpPath = join34(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync27(mcpPath, "utf-8"));
         } catch {
         }
         reapMissingMcpSessions({
@@ -15787,7 +15924,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
   if (trackedFiles.length > 0 && existsSync14(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join33(agentDir, file));
+      const h = hashFile(join34(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -15802,7 +15939,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join33(homedir15(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join34(homedir16(), ".augmented", agent.code_name, "onboarding-drive.json");
       const marker = readOnboardingDriveMarker(markerPath);
       const decision = decideOnboardingDrive(obStep, marker, Date.now(), obState.generation ?? 0);
       if (decision.clearMarker) {
@@ -15890,7 +16027,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join33(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join34(getFramework("opencode").getAgentDir(codeName), "provision");
   const serveEnv = {
     AGT_HOST: requireHost(),
     AGT_API_KEY: getApiKey() ?? void 0,
@@ -15945,8 +16082,8 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     });
   }
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join33(projectDir, ".mcp.json");
-  const claudeMdPath = join33(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join34(projectDir, ".mcp.json");
+  const claudeMdPath = join34(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -16578,7 +16715,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-DVTSZAPE.js");
+        const { collectDiagnostics } = await import("../persistent-session-HY6GUPBQ.js");
         await api.post("/host/heartbeat", {
           host_id: hostId,
           agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics)
@@ -16629,7 +16766,7 @@ async function respawnAgentAfterMcpStop(codeName, reason) {
     }
     try {
       const hostId = await getHostId();
-      const { collectDiagnostics } = await import("../persistent-session-DVTSZAPE.js");
+      const { collectDiagnostics } = await import("../persistent-session-HY6GUPBQ.js");
       await api.post("/host/heartbeat", {
         host_id: hostId,
         agent_diagnostics: collectDiagnostics([codeName], quarantineEntriesFor, claudeMdSizeFor, spawnOutcomeForDiagnostics)
@@ -16972,7 +17109,7 @@ async function processDirectChatMessage(agent, msg) {
     const useDoorbell = hostFlagStore().getBoolean("direct-chat-doorbell") || isolationMode(agent.codeName) === "docker";
     if (useDoorbell) {
       try {
-        const doorbell = directChatDoorbellPath(agent.agentId, homedir15());
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir16());
         mkdirSync11(dirname9(doorbell), { recursive: true });
         writeFileSync14(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
@@ -17101,7 +17238,7 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   }
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
-    const doorbell = directChatDoorbellPath(agentId, homedir15());
+    const doorbell = directChatDoorbellPath(agentId, homedir16());
     mkdirSync11(dirname9(doorbell), { recursive: true });
     writeFileSync14(doorbell, String(Date.now()));
   } catch (err) {
@@ -17207,7 +17344,7 @@ async function processClaudePairSessions(agents) {
     killPairSession,
     pairTmuxSession,
     finalizeClaudePairOnboarding
-  } = await import("../claude-pair-runtime-4C5NQQHR.js");
+  } = await import("../claude-pair-runtime-NSIF6AYH.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));
@@ -17461,8 +17598,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join33(configDir, agent.code_name, "project");
-  const memoryDir = join33(projectDir, "memory");
+  const projectDir = join34(configDir, agent.code_name, "project");
+  const memoryDir = join34(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`);
@@ -17480,7 +17617,7 @@ async function syncMemories(agent, configDir, log2) {
     for (const file of readdirSync9(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync26(join33(memoryDir, file), "utf-8");
+        const raw = readFileSync27(join34(memoryDir, file), "utf-8");
         const fileHash = createHash17("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -17505,7 +17642,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync26(join33(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync27(join34(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -17540,7 +17677,7 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join33(memoryDir, `${slug}.md`);
+        const filePath = join34(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -17552,7 +17689,7 @@ ${mem.content}
         if (existsSync14(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync26(filePath, "utf-8");
+            existing = readFileSync27(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
@@ -17816,7 +17953,7 @@ function startManager(opts) {
   try {
     const stateFile = getStateFile();
     if (existsSync14(stateFile)) {
-      const raw = readFileSync26(stateFile, "utf-8");
+      const raw = readFileSync27(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state7.agents = parsed.agents;
@@ -17843,7 +17980,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=${join33(homedir15(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join34(homedir16(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -17872,7 +18009,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync26(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync27(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -17969,14 +18106,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join33(homedir15(), ".augmented", "_mcp");
+  const targetDir = join34(homedir16(), ".augmented", "_mcp");
   mkdirSync11(targetDir, { recursive: true });
   const moduleDir = dirname9(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join33(dir, "dist", "mcp");
-    if (existsSync14(join33(candidate, "index.js"))) {
+    const candidate = join34(dir, "dist", "mcp");
+    if (existsSync14(join34(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -17992,7 +18129,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync14(p)) return null;
-      return createHash17("sha256").update(readFileSync26(p)).digest("hex");
+      return createHash17("sha256").update(readFileSync27(p)).digest("hex");
     } catch {
       return null;
     }
@@ -18063,8 +18200,8 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join33(mcpSourceDir, file);
-    const dst = join33(targetDir, file);
+    const src = join34(mcpSourceDir, file);
+    const dst = join34(targetDir, file);
     if (!existsSync14(src)) continue;
     const before = fileHash(dst);
     try {
@@ -18082,16 +18219,16 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join33(targetDir, "index.js");
+  const localMcpPath = join34(targetDir, "index.js");
   try {
-    const agentsDir = join33(homedir15(), ".augmented", "agents");
+    const agentsDir = join34(homedir16(), ".augmented", "agents");
     if (existsSync14(agentsDir)) {
       for (const entry of readdirSync9(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join33(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join34(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync26(mcpJsonPath, "utf-8");
+            const raw = readFileSync27(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];