@integrity-labs/agt-cli 0.28.720 → 0.28.722

package/dist/lib/manager-worker.js

@@ -57,7 +57,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-V5T2K5NN.js";
+} from "../chunk-LWDPZWSO.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -206,8 +206,8 @@ import {
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash18 } from "crypto";
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync16, mkdirSync as mkdirSync12, existsSync as existsSync17, rmSync as rmSync6, readdirSync as readdirSync10, statSync as statSync9, unlinkSync as unlinkSync6, renameSync as renameSync9, utimesSync as utimesSync2 } from "fs";
+import { createHash as createHash19 } from "crypto";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync17, mkdirSync as mkdirSync13, existsSync as existsSync18, rmSync as rmSync7, readdirSync as readdirSync11, statSync as statSync10, unlinkSync as unlinkSync6, renameSync as renameSync10, utimesSync as utimesSync3 } from "fs";
 
 // src/lib/atomic-file-replace.ts
 import { copyFileSync, renameSync, unlinkSync } from "fs";
@@ -233,7 +233,7 @@ function defaultUnique() {
 
 // src/lib/manager-worker.ts
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join39, dirname as dirname10, delimiter as pathDelimiter } from "path";
+import { join as join40, dirname as dirname10, delimiter as pathDelimiter } from "path";
 import { homedir as homedir17 } from "os";
 import { fileURLToPath } from "url";
 
@@ -1694,12 +1694,12 @@ function isPathInsideDir(candidate, dir) {
   return resolvedCandidate.startsWith(resolvedDir.endsWith(sep) ? resolvedDir : resolvedDir + sep);
 }
 function findMissingMcpBundles(mcpConfigPath, deps = {}) {
-  const existsSync18 = deps.existsSync ?? nodeExistsSync;
-  const readFileSync31 = deps.readFileSync ?? nodeReadFileSync;
+  const existsSync19 = deps.existsSync ?? nodeExistsSync;
+  const readFileSync32 = deps.readFileSync ?? nodeReadFileSync;
   const mcpDir = deps.mcpDir ?? getSharedMcpDir();
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync31(mcpConfigPath, "utf-8"));
+    parsed = JSON.parse(readFileSync32(mcpConfigPath, "utf-8"));
   } catch {
     return [];
   }
@@ -1719,7 +1719,7 @@ function findMissingMcpBundles(mcpConfigPath, deps = {}) {
     if (seenPaths.has(resolvedBundlePath)) continue;
     let present;
     try {
-      present = existsSync18(bundlePath);
+      present = existsSync19(bundlePath);
     } catch {
       continue;
     }
@@ -5300,19 +5300,140 @@ async function resolveKnowledgeFromManifest(args) {
   }));
 }
 
-// src/lib/channel-hash-cache.ts
-import { existsSync as existsSync7, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
+// src/lib/skill-cache.ts
+import { createHash as createHash10 } from "crypto";
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync18,
+  readdirSync as readdirSync6,
+  renameSync as renameSync6,
+  rmSync as rmSync4,
+  statSync as statSync6,
+  utimesSync as utimesSync2,
+  writeFileSync as writeFileSync9
+} from "fs";
 import { join as join24 } from "path";
+var SKILL_FETCH_CHUNK = 100;
+var CACHE_TTL_MS2 = 30 * 24 * 60 * 60 * 1e3;
+var SWEEP_INTERVAL_MS2 = 24 * 60 * 60 * 1e3;
+var lastSweepAt2 = 0;
+function skillHash(content) {
+  return createHash10("sha256").update(content, "utf8").digest("hex");
+}
+function cachePath2(cacheDir, hash) {
+  return join24(cacheDir, hash);
+}
+function readCachedSkill(cacheDir, hash) {
+  const path = cachePath2(cacheDir, hash);
+  try {
+    const content = readFileSync18(path, "utf-8");
+    try {
+      const now = /* @__PURE__ */ new Date();
+      utimesSync2(path, now, now);
+    } catch {
+    }
+    return content;
+  } catch {
+    return null;
+  }
+}
+function writeCachedSkill(cacheDir, hash, content) {
+  if (skillHash(content) !== hash) return "mismatch";
+  try {
+    mkdirSync7(cacheDir, { recursive: true });
+    const tmp = `${cachePath2(cacheDir, hash)}.tmp-${process.pid}`;
+    writeFileSync9(tmp, content, "utf-8");
+    renameSync6(tmp, cachePath2(cacheDir, hash));
+    return "written";
+  } catch {
+    return "write-failed";
+  }
+}
+function sweepSkillCache(cacheDir, now = Date.now()) {
+  if (now - lastSweepAt2 < SWEEP_INTERVAL_MS2) return;
+  lastSweepAt2 = now;
+  try {
+    if (!existsSync7(cacheDir)) return;
+    for (const name of readdirSync6(cacheDir)) {
+      const path = join24(cacheDir, name);
+      try {
+        if (now - statSync6(path).mtimeMs > CACHE_TTL_MS2) rmSync4(path, { force: true });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+async function resolveSkillsFromManifest(args) {
+  const { globals, shared, cacheDir, fetchContents, log: log2 } = args;
+  const bodies = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const entry of [...globals, ...shared]) {
+    if (!entry.hash) {
+      log2?.(`[skills] manifest entry '${entry.code_name}' has no hash \u2014 skipping skill sync`);
+      return null;
+    }
+    if (bodies.has(entry.hash) || missing.includes(entry.hash)) continue;
+    const cached = readCachedSkill(cacheDir, entry.hash);
+    if (cached !== null) bodies.set(entry.hash, cached);
+    else missing.push(entry.hash);
+  }
+  for (let i = 0; i < missing.length; i += SKILL_FETCH_CHUNK) {
+    const chunk2 = missing.slice(i, i + SKILL_FETCH_CHUNK);
+    try {
+      for (const { hash, content } of await fetchContents(chunk2)) {
+        const written = writeCachedSkill(cacheDir, hash, content);
+        if (written === "mismatch") {
+          log2?.(`[skills] hash mismatch for ${hash} \u2014 skipping skill sync this poll`);
+          continue;
+        }
+        if (written === "write-failed") {
+          log2?.(`[skills] cache write failed for ${hash} \u2014 serving it uncached this poll`);
+        }
+        bodies.set(hash, content);
+      }
+    } catch (err) {
+      log2?.(`[skills] fetch failed for ${chunk2.length} entries: ${err.message}`);
+    }
+  }
+  sweepSkillCache(cacheDir);
+  const resolve2 = (entries) => {
+    const out = [];
+    for (const e of entries) {
+      const content = e.hash ? bodies.get(e.hash) : void 0;
+      if (content === void 0) return null;
+      out.push({
+        code_name: e.code_name,
+        ...e.display_name !== void 0 ? { display_name: e.display_name } : {},
+        ...e.scope !== void 0 ? { scope: e.scope } : {},
+        content
+      });
+    }
+    return out;
+  };
+  const resolvedGlobals = resolve2(globals);
+  const resolvedShared = resolve2(shared);
+  if (resolvedGlobals === null || resolvedShared === null) {
+    log2?.("[skills] one or more bodies unresolved \u2014 leaving on-disk skills untouched this poll");
+    return null;
+  }
+  return { globals: resolvedGlobals, shared: resolvedShared };
+}
+
+// src/lib/channel-hash-cache.ts
+import { existsSync as existsSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
+import { join as join25 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join24(configDir, CACHE_FILENAME);
+  return join25(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
-  if (!existsSync7(path)) return;
+  if (!existsSync8(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(path, "utf-8"));
+    parsed = JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return;
   }
@@ -5326,14 +5447,14 @@ function saveChannelHashCache(source, configDir) {
   const obj = {};
   for (const [key, value] of source) obj[key] = value;
   try {
-    writeFileSync9(path, JSON.stringify(obj, null, 2));
+    writeFileSync10(path, JSON.stringify(obj, null, 2));
   } catch {
   }
 }
 
 // src/lib/sender-policy-baseline.ts
-import { existsSync as existsSync8, readFileSync as readFileSync19 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync20 } from "fs";
+import { join as join26 } from "path";
 var BASELINE_FILENAME = "sender-policy-baseline.json";
 var SENDER_POLICY_BASELINE_VERSION = 1;
 var BASELINE_CONCERNS = ["senderPolicy", "slackBehaviour", "msteamsBehaviour"];
@@ -5345,14 +5466,14 @@ function createDeliveryBaselineMaps() {
   };
 }
 function getSenderPolicyBaselineFile(configDir) {
-  return join25(configDir, BASELINE_FILENAME);
+  return join26(configDir, BASELINE_FILENAME);
 }
 function loadSenderPolicyBaseline(target, configDir, log2) {
   const path = getSenderPolicyBaselineFile(configDir);
-  if (!existsSync8(path)) return;
+  if (!existsSync9(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync19(path, "utf-8"));
+    parsed = JSON.parse(readFileSync20(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[sender-policy] discarding corrupt ${BASELINE_FILENAME} (${err.message}) - restrictive-policy agents will take one fail-closed restart`
@@ -5401,8 +5522,8 @@ function saveSenderPolicyBaseline(source, configDir, log2) {
 }
 
 // src/lib/stuck-streak-store.ts
-import { existsSync as existsSync9, readFileSync as readFileSync20 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync21 } from "fs";
+import { join as join27 } from "path";
 var STORE_FILENAME = "stuck-streaks.json";
 var STUCK_STREAK_STORE_VERSION = 1;
 var STUCK_STREAK_CONCERNS = ["channelSync", "realtimeRebind"];
@@ -5410,7 +5531,7 @@ function createStuckStreakMaps() {
   return { channelSync: /* @__PURE__ */ new Map(), realtimeRebind: /* @__PURE__ */ new Map() };
 }
 function getStuckStreakStoreFile(configDir) {
-  return join26(configDir, STORE_FILENAME);
+  return join27(configDir, STORE_FILENAME);
 }
 function isValidPersistedStreak(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -5449,10 +5570,10 @@ function buildStuckStreakPayload(source) {
 }
 function loadStuckStreaks(target, configDir, log2) {
   const path = getStuckStreakStoreFile(configDir);
-  if (!existsSync9(path)) return;
+  if (!existsSync10(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf-8"));
+    parsed = JSON.parse(readFileSync21(path, "utf-8"));
   } catch (err) {
     log2?.(
       `[stuck-streaks] discarding corrupt ${STORE_FILENAME} (${err.message}) \u2014 stuck-streak ages restart from zero and one spurious "recovered" close may follow`
@@ -5969,7 +6090,7 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash, options)
 }
 
 // src/lib/manager/integration-skill-cache.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function integrationSkillHashKey(agentId, skillId) {
   return `plugin-skill:${agentId}:${skillId}`;
 }
@@ -5985,21 +6106,21 @@ function forgetIntegrationSkill(cache2, agentId, skillId) {
 function removeIntegrationSkillFolder(opts) {
   forgetIntegrationSkill(opts.cache, opts.agentId, opts.entry);
   for (const dir of opts.dirs) {
-    opts.removeDir(join27(dir, opts.entry));
+    opts.removeDir(join28(dir, opts.entry));
   }
 }
 
 // src/lib/manager/managed-skill-manifest.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync21, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname7, join as join28 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync22, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname7, join as join29 } from "path";
 var MANIFEST_VERSION = 1;
 function managedSkillManifestPath(agentRootDir) {
-  return join28(agentRootDir, "managed-skills.json");
+  return join29(agentRootDir, "managed-skills.json");
 }
 function readManagedSkillManifest(path) {
   try {
-    if (!existsSync10(path)) return /* @__PURE__ */ new Set();
-    const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    if (!existsSync11(path)) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(readFileSync22(path, "utf-8"));
     const ids = Array.isArray(parsed?.globalSkillIds) ? parsed.globalSkillIds : [];
     return new Set(ids.filter((id) => typeof id === "string" && id.length > 0));
   } catch {
@@ -6008,12 +6129,12 @@ function readManagedSkillManifest(path) {
 }
 function writeManagedSkillManifest(path, ids) {
   try {
-    mkdirSync7(dirname7(path), { recursive: true });
+    mkdirSync8(dirname7(path), { recursive: true });
     const body = {
       version: MANIFEST_VERSION,
       globalSkillIds: [...ids].sort()
     };
-    writeFileSync10(path, JSON.stringify(body, null, 2));
+    writeFileSync11(path, JSON.stringify(body, null, 2));
   } catch {
   }
 }
@@ -6128,8 +6249,8 @@ function resolveModelChain(refreshData) {
 }
 
 // src/lib/manager/claude-auth.ts
-import { existsSync as existsSync11, rmSync as rmSync4 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync12, rmSync as rmSync5 } from "fs";
+import { join as join30 } from "path";
 import { homedir as homedir13 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
@@ -6142,12 +6263,12 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join29(homedir13(), ".claude");
+    const claudeDir = join30(homedir13(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join29(claudeDir, filename);
-      if (existsSync11(p)) {
+      const p = join30(claudeDir, filename);
+      if (existsSync12(p)) {
         try {
-          rmSync4(p, { force: true });
+          rmSync5(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
         } catch {
         }
@@ -6226,8 +6347,8 @@ function heartbeatRuntimeAuthFields(probeVerdict) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync12, readFileSync as readFileSync22 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync23 } from "fs";
+import { join as join31 } 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"]);
@@ -6379,12 +6500,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join30(process.cwd(), "skills", skillId, "SKILL.md"),
-      join30(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join31(process.cwd(), "skills", skillId, "SKILL.md"),
+      join31(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync12(candidate)) {
-        const content = readFileSync22(candidate, "utf-8");
+      if (existsSync13(candidate)) {
+        const content = readFileSync23(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -6525,19 +6646,19 @@ function formatBoardForPrompt(items, template) {
 }
 
 // src/lib/manager/kanban/nudge-state-cache.ts
-import { existsSync as existsSync13, readFileSync as readFileSync23, writeFileSync as writeFileSync11 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "fs";
+import { join as join32 } from "path";
 var CACHE_FILENAME2 = "kanban-nudge-state.json";
 var KANBAN_NUDGE_STATE_VERSION = 1;
 function getKanbanNudgeStateFile(configDir) {
-  return join31(configDir, CACHE_FILENAME2);
+  return join32(configDir, CACHE_FILENAME2);
 }
 function loadKanbanNudgeState(target, configDir) {
   const path = getKanbanNudgeStateFile(configDir);
-  if (!existsSync13(path)) return;
+  if (!existsSync14(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync23(path, "utf-8"));
+    parsed = JSON.parse(readFileSync24(path, "utf-8"));
   } catch {
     return;
   }
@@ -6569,13 +6690,13 @@ function saveKanbanNudgeState(source, configDir) {
   const agents = {};
   for (const [codeName, state9] of source) agents[codeName] = state9;
   try {
-    writeFileSync11(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
+    writeFileSync12(path, JSON.stringify({ version: KANBAN_NUDGE_STATE_VERSION, agents }, null, 2));
   } catch {
   }
 }
 
 // src/lib/manager/kanban/notify.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 async function enqueueKanbanNotice(opts) {
   try {
     const res = await api.post(
@@ -6590,7 +6711,7 @@ async function enqueueKanbanNotice(opts) {
     return res.ok === true;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice enqueue failed for agent_id=${opts.agentId} error_id=${errId}`);
     return false;
   }
@@ -6605,7 +6726,7 @@ async function cancelKanbanNotice(agentId) {
     return typeof res.cancelled === "number" ? res.cancelled : 0;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash10("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[kanban] notice cancel failed for agent_id=${agentId} error_id=${errId}`);
     return null;
   }
@@ -7011,7 +7132,7 @@ function deriveScheduledTaskNotify(task) {
 }
 
 // src/lib/manager/scheduler/runs.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 async function startRun(opts) {
   try {
     const res = await api.post(
@@ -7026,7 +7147,7 @@ async function startRun(opts) {
     };
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] start failed for agent_id=${opts.agent_id} source_type=${opts.source_type} error_id=${errId}`);
     return { run_id: null, kanban_item_id: null };
   }
@@ -7065,7 +7186,7 @@ async function finishRun(runId, outcome, options = {}) {
       return;
     } catch (err) {
       const errText = err instanceof Error ? err.message : String(err);
-      const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
+      const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
       const status = err instanceof ApiError ? err.status : 0;
       if (isRetryableFinishError(err) && attempt < maxRetries) {
         log(
@@ -7094,7 +7215,7 @@ async function fetchPriorScheduledRuns(agentId, taskId) {
     return rows.filter((r) => typeof r.output_text === "string" && r.output_text.length > 0).map((r) => ({ startedAt: r.started_at, output: r.output_text }));
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash11("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
     log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
     return [];
   }
@@ -7154,13 +7275,13 @@ function closeSessionRunForCode(codeName, outcome, reason) {
 }
 
 // src/lib/manager/scheduler/kanban-route.ts
-import { createHash as createHash13 } from "crypto";
-import { writeFileSync as writeFileSync12, renameSync as renameSync6, mkdirSync as mkdirSync8, readFileSync as readFileSync24, unlinkSync as unlinkSync3 } from "fs";
+import { createHash as createHash14 } from "crypto";
+import { writeFileSync as writeFileSync13, renameSync as renameSync7, mkdirSync as mkdirSync9, readFileSync as readFileSync25, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join32, dirname as dirname8 } from "path";
+import { join as join33, dirname as dirname8 } from "path";
 
 // src/lib/manager/scheduler/notify.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 async function enqueueScheduledTaskNotice(opts) {
   try {
     const res = await api.post(
@@ -7177,7 +7298,7 @@ async function enqueueScheduledTaskNotice(opts) {
     return res.ok === true;
   } catch (err) {
     const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash12("sha256").update(errText).digest("hex").slice(0, 12);
+    const errId = createHash13("sha256").update(errText).digest("hex").slice(0, 12);
     log(
       `[scheduled-kanban] notice enqueue failed for agent_id=${opts.agentId} task_id=${opts.taskId} error_id=${errId}`
     );
@@ -7516,19 +7637,19 @@ function resolveScheduledSlackTarget(task) {
 }
 function stampScheduledTurnMarker(codeName, taskId, target) {
   try {
-    const file = join32(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+    const file = join33(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
     const marker = { ts: Date.now(), task_id: taskId, ...target ? { target } : {} };
     const tmp = `${file}.tmp`;
-    writeFileSync12(tmp, JSON.stringify(marker), "utf8");
-    renameSync6(tmp, file);
+    writeFileSync13(tmp, JSON.stringify(marker), "utf8");
+    renameSync7(tmp, file);
   } catch (err) {
     log(`[scheduled-kanban] scheduled-turn marker write failed for '${codeName}': ${err.message}`);
   }
 }
 function clearScheduledTurnMarkerForTask(codeName, taskId) {
-  const file = join32(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
+  const file = join33(homedir14(), ".augmented", codeName, SCHEDULED_TURN_MARKER_FILENAME);
   try {
-    const raw = JSON.parse(readFileSync24(file, "utf8"));
+    const raw = JSON.parse(readFileSync25(file, "utf8"));
     if (typeof raw?.task_id !== "string" || raw.task_id !== taskId) return;
     unlinkSync3(file);
     log(`[scheduled-kanban] scheduled-turn marker cleared for '${codeName}' (task ${taskId} complete)`);
@@ -7589,8 +7710,8 @@ async function routeScheduledTaskViaKanban(codeName, agentId, task, prompt, dura
     }
     try {
       const doorbell = directChatDoorbellPath(agentId, homedir14());
-      mkdirSync8(dirname8(doorbell), { recursive: true });
-      writeFileSync12(doorbell, String(Date.now()));
+      mkdirSync9(dirname8(doorbell), { recursive: true });
+      writeFileSync13(doorbell, String(Date.now()));
     } catch (err) {
       log(`[scheduled-kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
     }
@@ -7656,24 +7777,24 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
       const assertion = parseDeliverAssertion(rawOutput);
       if (!assertion.deliver) {
         const trimmed = (rawOutput ?? "").trim();
-        const outputHash = trimmed.length === 0 ? "empty" : createHash13("sha256").update(trimmed).digest("hex").slice(0, 12);
+        const outputHash = trimmed.length === 0 ? "empty" : createHash14("sha256").update(trimmed).digest("hex").slice(0, 12);
         log(`[claude-scheduler] Suppressed by delivery_policy=conditional for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 ${assertion.vacuous ? "deliver marker had a vacuous reason" : "no deliver marker"}; output_len=${trimmed.length} output_hash=${outputHash}`);
         if (delivery?.mode === "announce" && delivery.to) {
           await reportDeliveryStatus(agentId, delivery.taskId, { status: "skipped", error_code: "SUPPRESSED_BY_POLICY" });
         }
         return { ok: true };
       }
-      const reasonHash = createHash13("sha256").update(assertion.reason ?? "").digest("hex").slice(0, 12);
+      const reasonHash = createHash14("sha256").update(assertion.reason ?? "").digest("hex").slice(0, 12);
       log(`[claude-scheduler] Delivering conditional run for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent asserted a concrete trigger (reason_len=${(assertion.reason ?? "").length} reason_hash=${reasonHash})`);
       rawOutput = assertion.deliverable;
     }
     const classification = classifyOutput(rawOutput);
     if (classification.action === "suppress") {
       const trimmed = (rawOutput ?? "").trim();
-      const outputHash = trimmed.length === 0 ? "empty" : createHash13("sha256").update(trimmed).digest("hex").slice(0, 12);
+      const outputHash = trimmed.length === 0 ? "empty" : createHash14("sha256").update(trimmed).digest("hex").slice(0, 12);
       log(`[claude-scheduler] Suppressing delivery for '${codeName}' (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 output_len=${trimmed.length} output_hash=${outputHash}`);
       if (classification.suppressedNotes) {
-        const notesHash = createHash13("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
+        const notesHash = createHash14("sha256").update(classification.suppressedNotes).digest("hex").slice(0, 12);
         log(`[claude-scheduler] Suppressed notes for '${codeName}' (task=${delivery?.taskId ?? "n/a"}) \u2014 notes_len=${classification.suppressedNotes.length} notes_hash=${notesHash}`);
       }
       if (delivery?.mode === "announce" && delivery.to) {
@@ -7739,13 +7860,13 @@ async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput,
 }
 
 // src/lib/manager/scheduler/execution.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { homedir as homedir15 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 
 // src/lib/agent-serving-probe.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync6 } from "fs";
-import { join as join33 } from "path";
+import { readFileSync as readFileSync26, readdirSync as readdirSync7, statSync as statSync7 } from "fs";
+import { join as join34 } from "path";
 var RATE_LIMIT_WINDOW_MS = 6 * 60 * 60 * 1e3;
 function probeRateLimit(args) {
   const now = args.now ?? /* @__PURE__ */ new Date();
@@ -7754,23 +7875,23 @@ function probeRateLimit(args) {
   const dir = args.transcriptDir ?? sessionTranscriptDir(args.projectDir);
   let entries;
   try {
-    entries = readdirSync6(dir);
+    entries = readdirSync7(dir);
   } catch {
     return UNKNOWN_RATE_LIMIT;
   }
   let newest = UNKNOWN_RATE_LIMIT;
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const path = join33(dir, name);
+    const path = join34(dir, name);
     try {
-      const st = statSync6(path);
+      const st = statSync7(path);
       if (!st.isFile() || st.mtimeMs < startMs) continue;
     } catch {
       continue;
     }
     let content;
     try {
-      content = readFileSync25(path, "utf-8");
+      content = readFileSync26(path, "utf-8");
     } catch {
       continue;
     }
@@ -7832,7 +7953,7 @@ function shouldLogUsageCapDeferral(site, codeName, limitedUntil) {
 
 // src/lib/manager/scheduler/execution.ts
 function claudePidFilePath() {
-  return join34(homedir15(), ".augmented", "manager-claude-pids.json");
+  return join35(homedir15(), ".augmented", "manager-claude-pids.json");
 }
 var inFlightClaudePids = /* @__PURE__ */ new Map();
 function registerClaudeSpawn(record) {
@@ -7852,10 +7973,10 @@ function unregisterClaudeSpawn(pid) {
 }
 async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData, durableScheduledNudge = false) {
   const codeName = agent.code_name;
-  const stableTasksHash = createHash14("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const boardHash = boardItems.length > 0 ? createHash14("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+  const stableTasksHash = createHash15("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash15("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
   const resolvedModels = resolveModelChain(refreshData);
-  const modelsHash = createHash14("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+  const modelsHash = createHash15("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
   const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (combinedHash !== prevHash) {
@@ -7902,8 +8023,8 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 }
 
 // src/lib/occupancy-gate.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync7, readSync as readSync2, statSync as statSync7 } from "fs";
-import { join as join35 } from "path";
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync8, readSync as readSync2, statSync as statSync8 } from "fs";
+import { join as join36 } from "path";
 function rostersMeasuredZero(mode, attested, runtimeRunning) {
   return mode === "enforce" && attested && runtimeRunning;
 }
@@ -7917,7 +8038,7 @@ var brackets = /* @__PURE__ */ new Map();
 function readAlignedTail(path, tailBytes, maxAlignBytes) {
   let fd = null;
   try {
-    const size = statSync7(path).size;
+    const size = statSync8(path).size;
     if (size <= 0) return { content: "", complete: true, truncated: false };
     fd = openSync2(path, "r");
     let readStart = Math.max(0, size - tailBytes);
@@ -7987,26 +8108,26 @@ function candidateTranscriptPaths(dir) {
   const paths = [];
   let top;
   try {
-    top = readdirSync7(dir);
+    top = readdirSync8(dir);
   } catch {
     return { paths, complete: false };
   }
   let complete = true;
   for (const name of top) {
     if (name.endsWith(".jsonl")) {
-      paths.push(join35(dir, name));
+      paths.push(join36(dir, name));
       continue;
     }
-    const subDir = join35(dir, name, "subagents");
+    const subDir = join36(dir, name, "subagents");
     let subs;
     try {
-      subs = readdirSync7(subDir);
+      subs = readdirSync8(subDir);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
     }
     for (const sub of subs) {
-      if (sub.endsWith(".jsonl")) paths.push(join35(subDir, sub));
+      if (sub.endsWith(".jsonl")) paths.push(join36(subDir, sub));
     }
   }
   return { paths, complete };
@@ -8061,7 +8182,7 @@ function collectQualifyingTurns(codeName, nowMs, opts = {}) {
   for (const path of paths) {
     let st;
     try {
-      st = statSync7(path);
+      st = statSync8(path);
     } catch (err) {
       if (!isAbsentDirError(err)) complete = false;
       continue;
@@ -8167,7 +8288,7 @@ function qualifyBuckets(buckets, qualifying, mode, nowMs, neighbourhoodMs = DEFA
 }
 
 // src/lib/pane-occupancy-sampler.ts
-import { statSync as statSync8 } from "fs";
+import { statSync as statSync9 } from "fs";
 var SAMPLE_INTERVAL_MS = 1e4;
 var IDLE_GAP_MS = 12e4;
 var POST_IDLE_CREDIT_MS = 6e4;
@@ -8181,7 +8302,7 @@ function hasFreshPaneObservation(codeName, nowMs, maxAgeMs = OBSERVATION_FRESH_M
 }
 function paneMtimeMs(codeName) {
   try {
-    return statSync8(paneLogPath(codeName)).mtimeMs;
+    return statSync9(paneLogPath(codeName)).mtimeMs;
   } catch {
     return null;
   }
@@ -8233,7 +8354,7 @@ function stopPaneOccupancySampler() {
 
 // src/lib/pid-pressure-sampler.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync27 } from "fs";
 var SAMPLE_INTERVAL_MS2 = 3e4;
 function warnFraction() {
   const raw = Number(process.env.AGT_PID_PRESSURE_WARN_FRACTION);
@@ -8246,7 +8367,7 @@ function configuredCeiling() {
 }
 function readTextReal(path) {
   try {
-    return readFileSync26(path, "utf-8");
+    return readFileSync27(path, "utf-8");
   } catch {
     return null;
   }
@@ -8255,7 +8376,7 @@ var cgroupDirCache = /* @__PURE__ */ new Map();
 var resolveRetryAfter = /* @__PURE__ */ new Map();
 var RESOLVE_RETRY_BACKOFF_MS = 5 * 6e4;
 function resolveCgroupDirReal(codeName, deps = {}) {
-  const exists = deps.exists ?? existsSync14;
+  const exists = deps.exists ?? existsSync15;
   const inspectId = deps.inspectId ?? inspectContainerId;
   const now = deps.now ?? Date.now;
   const cached = cgroupDirCache.get(codeName);
@@ -8373,7 +8494,7 @@ function stopPidPressureSampler() {
 }
 
 // src/lib/opencode-slack-ingest.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 
 // ../../packages/core/dist/channels/slack-rich-text.js
 var MAX_DEPTH = 12;
@@ -9380,7 +9501,7 @@ function startSlackIngest(config2) {
 // src/lib/opencode-slack-ingest.ts
 var ingests = /* @__PURE__ */ new Map();
 function fingerprint(params) {
-  return createHash15("sha256").update(
+  return createHash16("sha256").update(
     JSON.stringify({
       appToken: params.appToken,
       botToken: params.botToken,
@@ -9461,7 +9582,7 @@ function stopAllOpencodeSlackIngests(log2) {
 }
 
 // src/lib/manager/opencode-scheduler.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 var MAX_OPENCODE_SCHED_CONCURRENCY = 2;
 var opencodeSchedulerStates = /* @__PURE__ */ new Map();
 var inFlightOpencodeTasks = /* @__PURE__ */ new Set();
@@ -9475,7 +9596,7 @@ function shouldDeliver(task, reply) {
 }
 async function syncAndCheckOpencodeScheduler(agent, tasks, refreshData) {
   const codeName = agent.code_name;
-  const tasksHash = createHash16("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const tasksHash = createHash17("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);
@@ -9553,10 +9674,10 @@ async function fireOpencodeScheduledTask(agent, task) {
 }
 
 // src/lib/opencode-telegram-ingest.ts
-import { createHash as createHash17 } from "crypto";
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync27, renameSync as renameSync7, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "fs";
+import { createHash as createHash18 } from "crypto";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync28, renameSync as renameSync8, unlinkSync as unlinkSync4, writeFileSync as writeFileSync14 } from "fs";
 import { randomUUID } from "crypto";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // src/lib/telegram-ingest.ts
 import https2 from "https";
@@ -10089,7 +10210,7 @@ function anySignal(signals) {
 // src/lib/opencode-telegram-ingest.ts
 var ingests2 = /* @__PURE__ */ new Map();
 function fingerprint2(params) {
-  return createHash17("sha256").update(
+  return createHash18("sha256").update(
     JSON.stringify({
       botToken: params.botToken,
       allowedChats: [...params.allowedChats].sort(),
@@ -10104,7 +10225,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
   let filePath;
   try {
     dir = getFramework("opencode").getAgentDir(codeName);
-    filePath = join36(dir, "telegram-getupdates-offset-opencode.json");
+    filePath = join37(dir, "telegram-getupdates-offset-opencode.json");
   } catch {
     dir = null;
     filePath = null;
@@ -10113,7 +10234,7 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
     load() {
       if (!filePath) return 0;
       try {
-        const parsed = JSON.parse(readFileSync27(filePath, "utf-8"));
+        const parsed = JSON.parse(readFileSync28(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;
@@ -10131,8 +10252,8 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
       if (!filePath || !dir) return;
       const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       try {
-        mkdirSync9(dir, { recursive: true, mode: 448 });
-        writeFileSync13(
+        mkdirSync10(dir, { recursive: true, mode: 448 });
+        writeFileSync14(
           tmpPath,
           JSON.stringify({
             offset,
@@ -10142,11 +10263,11 @@ function createFileOffsetStore(codeName, log2, currentBotId) {
           }),
           { mode: 384 }
         );
-        renameSync7(tmpPath, filePath);
+        renameSync8(tmpPath, filePath);
       } catch (err) {
         log2(`[telegram-ingest:${codeName}] offset persist failed: ${err instanceof Error ? err.message : String(err)}`);
         try {
-          if (existsSync15(tmpPath)) unlinkSync4(tmpPath);
+          if (existsSync16(tmpPath)) unlinkSync4(tmpPath);
         } catch {
         }
       }
@@ -10383,24 +10504,24 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync10, readdirSync as readdirSync8, readFileSync as readFileSync28, renameSync as renameSync8, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync11, readdirSync as readdirSync9, readFileSync as readFileSync29, renameSync as renameSync9, rmSync as rmSync6, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function restartFlagsDir() {
-  return join37(homedir16(), ".augmented", "restart-flags");
+  return join38(homedir16(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join37(restartFlagsDir(), `${codeName}.flag`);
+  return join38(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync16(dir)) return [];
+  if (!existsSync17(dir)) return [];
   const out = [];
-  for (const entry of readdirSync8(dir)) {
+  for (const entry of readdirSync9(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync28(join37(dir, entry), "utf8");
+      const raw = readFileSync29(join38(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -10418,8 +10539,8 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync16(path)) {
-    rmSync5(path, { force: true });
+  if (existsSync17(path)) {
+    rmSync6(path, { force: true });
   }
 }
 
@@ -10518,8 +10639,8 @@ async function sendError(flag, opts, text) {
 }
 
 // src/lib/restart-context.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, unlinkSync as unlinkSync5 } from "fs";
-import { dirname as dirname9, join as join38 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync30, writeFileSync as writeFileSync16, mkdirSync as mkdirSync12, unlinkSync as unlinkSync5 } from "fs";
+import { dirname as dirname9, join as join39 } from "path";
 var SLACK_PENDING_INBOUND_DIRNAME = "slack-pending-inbound";
 var SLACK_RESTART_CONTEXT_DIRNAME = "slack-restart-context";
 var MAX_TOPIC_CHARS = 140;
@@ -10531,10 +10652,10 @@ function augmentedAgentDir(codeName) {
   return dirname9(getProjectDir(codeName));
 }
 function slackPendingInboundDir(codeName) {
-  return join38(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
+  return join39(augmentedAgentDir(codeName), SLACK_PENDING_INBOUND_DIRNAME);
 }
 function slackRestartContextDir(codeName) {
-  return join38(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
+  return join39(augmentedAgentDir(codeName), SLACK_RESTART_CONTEXT_DIRNAME);
 }
 function sanitizeTopic(raw) {
   const cleaned = raw.replace(/\s+/g, " ").trim().replace(/[<>]/g, " ").replace(/\s+/g, " ").trim();
@@ -10569,14 +10690,14 @@ function computeRestartContextHints(markers, allTurns, nowMs, reconstruct = reco
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync9(dir);
+    return readdirSync10(dir);
   } catch {
     return [];
   }
 }
 function readStrandedMarker(path) {
   try {
-    const parsed = JSON.parse(readFileSync29(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync30(path, "utf-8"));
     if (typeof parsed.channel === "string" && typeof parsed.thread_ts === "string") {
       return { channel: parsed.channel, thread_ts: parsed.thread_ts };
     }
@@ -10585,8 +10706,8 @@ function readStrandedMarker(path) {
   return null;
 }
 function writeHintFile(path, dir, hint) {
-  mkdirSync11(dir, { recursive: true, mode: 448 });
-  writeFileSync15(path, JSON.stringify(hint), { mode: 384 });
+  mkdirSync12(dir, { recursive: true, mode: 448 });
+  writeFileSync16(path, JSON.stringify(hint), { mode: 384 });
 }
 function pruneHintsExcept(codeName, freshFilenames) {
   const ctxDir = slackRestartContextDir(codeName);
@@ -10594,7 +10715,7 @@ function pruneHintsExcept(codeName, freshFilenames) {
     if (!filename.endsWith(".json")) continue;
     if (freshFilenames.has(filename)) continue;
     try {
-      unlinkSync5(join38(ctxDir, filename));
+      unlinkSync5(join39(ctxDir, filename));
     } catch {
     }
   }
@@ -10615,7 +10736,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       }
       const markers = [];
       for (const filename of markerFilenames.slice(0, cap)) {
-        const parsed = readStrandedMarker(join38(markerDir, filename));
+        const parsed = readStrandedMarker(join39(markerDir, filename));
         if (parsed) markers.push({ filename, channel: parsed.channel, thread_ts: parsed.thread_ts });
       }
       if (markers.length === 0) {
@@ -10629,7 +10750,7 @@ function refreshSlackRestartContextHints(codeNames, opts = {}) {
       const freshFilenames = /* @__PURE__ */ new Set();
       for (const { filename, hint } of hints) {
         try {
-          writeHintFile(join38(ctxDir, filename), ctxDir, hint);
+          writeHintFile(join39(ctxDir, filename), ctxDir, hint);
           freshFilenames.add(filename);
         } catch (err) {
           log2(`[restart-context] ${codeName}: hint write failed for ${filename}: ${err.message}`);
@@ -12163,7 +12284,7 @@ function performLazyDayRolloverReset(codeName, agentTimezone) {
 }
 function paneLogAgeSecondsFor(codeName) {
   try {
-    const mtimeMs = statSync9(paneLogPath(codeName)).mtimeMs;
+    const mtimeMs = statSync10(paneLogPath(codeName)).mtimeMs;
     return Math.max(0, Math.floor((Date.now() - mtimeMs) / 1e3));
   } catch (err) {
     if (err?.code === "ENOENT") return null;
@@ -12313,15 +12434,15 @@ var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 var sessionLaunchManagedStructure = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
-    return createHash18("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    const raw = readFileSync31(join40(projectDir, ".mcp.json"), "utf-8");
+    return createHash19("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync31(join40(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -12339,7 +12460,7 @@ function seedSessionLaunchBaselines(codeName, projectDir) {
   else runningMcpServerKeys.delete(codeName);
   let launchStructure = null;
   try {
-    const raw = readFileSync30(join39(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync31(join40(projectDir, ".mcp.json"), "utf-8");
     launchStructure = managedMcpStructureHashFromFile(
       JSON.parse(raw),
       isManagedMcpServerKey
@@ -12465,7 +12586,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(readFileSync30(join39(projectDir, ".mcp.json"), "utf-8"));
+      mcpJsonForRebind = JSON.parse(readFileSync31(join40(projectDir, ".mcp.json"), "utf-8"));
     } catch {
       mcpJsonForRebind = null;
     }
@@ -12613,7 +12734,7 @@ function shouldInjectChannelSecrets(agentId) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync30(join39(projectDir, ".env.integrations"), "utf-8")
+      readFileSync31(join40(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -12711,7 +12832,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.720" : "dev";
+var agtCliVersion = true ? "0.28.722" : "dev";
 function resolveBrewPath(execFileSync3) {
   try {
     const out = execFileSync3("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -12724,7 +12845,7 @@ function resolveBrewPath(execFileSync3) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync17(path)) return path;
+    if (existsSync18(path)) return path;
   }
   return null;
 }
@@ -12734,7 +12855,7 @@ function claudeBinaryInstalled(execFileSync3) {
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude"
   ];
-  if (canonical.some((path) => existsSync17(path))) return true;
+  if (canonical.some((path) => existsSync18(path))) return true;
   try {
     execFileSync3("which", ["claude"], { timeout: 5e3 });
     return true;
@@ -13044,8 +13165,8 @@ var MANAGED_SETTINGS_KEYS = ["channelsEnabled", "enableAllProjectMcpServers"];
 function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
-    if (existsSync17(path)) {
-      const raw = readFileSync30(path, "utf-8").trim();
+    if (existsSync18(path)) {
+      const raw = readFileSync31(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -13062,8 +13183,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     const missing = MANAGED_SETTINGS_KEYS.filter((key) => settings[key] !== true);
     if (missing.length === 0) return "ok";
     for (const key of missing) settings[key] = true;
-    mkdirSync12(dirname10(path), { recursive: true });
-    writeFileSync16(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync13(dirname10(path), { recursive: true });
+    writeFileSync17(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set ${missing.map((k) => `${k}:true`).join(", ")} in ${path} (ENG-5786 unblocks Claude Code channels; ENG-9223 pre-approves project MCP servers so a headless session never freezes on the trust prompt)`);
     return "ok";
@@ -13101,7 +13222,7 @@ async function ensureOpencodeBinary() {
   try {
     const prefix = execFileSync3("npm", ["prefix", "-g"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (prefix) {
-      const npmBin = join39(prefix, "bin");
+      const npmBin = join40(prefix, "bin");
       const current = (process.env.PATH ?? "").split(pathDelimiter);
       if (!current.includes(npmBin)) {
         process.env.PATH = [npmBin, ...current.filter(Boolean)].join(pathDelimiter);
@@ -13162,7 +13283,7 @@ async function ensureFrameworkBinary(frameworkId) {
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync17("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync18("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -13218,7 +13339,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join39(homedir17(), ".augmented", ".last-self-update-applied");
+  return join40(homedir17(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var selfUpdatePinnedLogged = false;
@@ -13269,7 +13390,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 = join39(homedir17(), ".augmented", ".last-update-check");
+    const markerPath = join40(homedir17(), ".augmented", ".last-update-check");
     if (!force) {
       try {
         const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
@@ -13762,14 +13883,14 @@ async function checkClaudeAuth() {
 }
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
-  if (evalEmptyMcpConfigPath && existsSync17(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join39(homedir17(), ".augmented");
+  if (evalEmptyMcpConfigPath && existsSync18(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
+  const dir = join40(homedir17(), ".augmented");
   try {
-    mkdirSync12(dir, { recursive: true });
+    mkdirSync13(dir, { recursive: true });
   } catch {
   }
-  const p = join39(dir, ".eval-empty-mcp.json");
-  writeFileSync16(p, JSON.stringify({ mcpServers: {} }));
+  const p = join40(dir, ".eval-empty-mcp.json");
+  writeFileSync17(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -13863,10 +13984,10 @@ function resolveConversationEvalBackend() {
   return conversationEvalBackend;
 }
 function getStateFile() {
-  return join39(config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join40(config?.configDir ?? join40(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join40(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -14071,7 +14192,7 @@ function removeDeliveryBaselineEntries(agentId) {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join40(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -14087,12 +14208,12 @@ function claudeMdSizeFor(codeName) {
 }
 function forwardedToolsFor(codeName) {
   if (!config?.configDir) return null;
-  return readForwardedToolsReport(join39(config.configDir, codeName));
+  return readForwardedToolsReport(join40(config.configDir, codeName));
 }
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join39(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join40(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -14165,13 +14286,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync11, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync17 } = await import("fs");
-  const skillsDir = join39(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join39(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync12, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync18 } = await import("fs");
+  const skillsDir = join40(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join40(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
-  for (const dir of readdirSync11(skillsDir).sort()) {
-    const skillFile = join39(skillsDir, dir, "SKILL.md");
+  for (const dir of readdirSync12(skillsDir).sort()) {
+    const skillFile = join40(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -14215,7 +14336,7 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync17(claudeMdPath, next, "utf-8");
+    writeFileSync18(claudeMdPath, next, "utf-8");
     log2(
       injectSkillList ? `Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)` : `Refreshed CLAUDE.md managed block for '${codeName}' (skill list suppressed by claude-md-skills-index=false; ${entries.length} skills on disk)`
     );
@@ -14386,7 +14507,7 @@ async function pollCycleInner() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash18("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash19("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state8.agents.some(
@@ -14724,13 +14845,13 @@ async function pollCycleInner() {
             );
             if (hostFlagStore().getBoolean("wedge-transient-notice")) {
               try {
-                const paneTail = readFileSync30(paneLogPath(codeName), "utf8").slice(-65536);
+                const paneTail = readFileSync31(paneLogPath(codeName), "utf8").slice(-65536);
                 const transient = detectTransientApiErrorInLog(paneTail);
                 if (transient) {
-                  const wedgeHome = join39(homedir17(), ".augmented", codeName);
-                  if (existsSync17(wedgeHome)) {
+                  const wedgeHome = join40(homedir17(), ".augmented", codeName);
+                  if (existsSync18(wedgeHome)) {
                     atomicWriteFileSync(
-                      join39(wedgeHome, "watchdog-give-up.json"),
+                      join40(wedgeHome, "watchdog-give-up.json"),
                       JSON.stringify({
                         gave_up_at: wedgeNow.toISOString(),
                         reason: "transient_overload"
@@ -15046,7 +15167,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 = join39(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join40(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -15133,10 +15254,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 = join39(homedir17(), ".augmented", codeName);
-          if (!existsSync17(dir)) return;
+          const dir = join40(homedir17(), ".augmented", codeName);
+          if (!existsSync18(dir)) return;
           atomicWriteFileSync(
-            join39(dir, "watchdog-give-up.json"),
+            join40(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         },
@@ -15155,9 +15276,9 @@ async function pollCycleInner() {
         // parser elsewhere can only reconstruct an hour (ENG-8901).
         signalUsageLimit: (codeName, resetsHint) => {
           const dir = getFramework("claude-code").getAgentDir(codeName);
-          if (!existsSync17(dir)) return;
+          if (!existsSync18(dir)) return;
           atomicWriteFileSync(
-            join39(dir, "watchdog-give-up.json"),
+            join40(dir, "watchdog-give-up.json"),
             JSON.stringify({
               gave_up_at: (/* @__PURE__ */ new Date()).toISOString(),
               reason: "usage_limit",
@@ -15419,7 +15540,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join39(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join40(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     forgetChannelSyncState(agent.agent_id);
     if (previousKnownStatus !== agent.status) {
@@ -15460,7 +15581,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const residuals = {
         gatewayRunning: false,
         portAllocated: false,
-        provisionDirExists: existsSync17(agentDir)
+        provisionDirExists: existsSync18(agentDir)
       };
       if (!hasRevokedResiduals(residuals)) {
         agentStates.push({
@@ -15552,12 +15673,16 @@ async function processAgent(agent, agentStates, managedToolkits) {
       // ENG-9585: ask for hashes instead of knowledge bodies. An API build that
       // predates the manifest ignores this and answers with `knowledge` as
       // before, which the resolution below handles without a version check.
-      knowledge_manifest: true
+      knowledge_manifest: true,
+      // ENG-9585: the same for the two root-skill lanes. A separate flag
+      // because the two shipped in different CLI versions — an API that
+      // understands one and not the other must still be able to answer.
+      skills_manifest: true
     });
     if (refreshData.knowledge_manifest) {
       const resolved = await resolveKnowledgeFromManifest({
         manifest: refreshData.knowledge_manifest,
-        cacheDir: join39(config.configDir, "_knowledge"),
+        cacheDir: join40(config.configDir, "_knowledge"),
         delivery: refreshData.agent?.knowledge_delivery ?? "both",
         fetchContents: async (hashes) => {
           const res = await api.post(
@@ -15570,6 +15695,25 @@ async function processAgent(agent, agentStates, managedToolkits) {
       });
       refreshData.knowledge = resolved;
     }
+    if (refreshData.global_skills_manifest || refreshData.shared_skills_manifest) {
+      const resolvedSkills = await resolveSkillsFromManifest({
+        globals: refreshData.global_skills_manifest ?? [],
+        shared: refreshData.shared_skills_manifest ?? [],
+        cacheDir: join40(config.configDir, "_skills"),
+        fetchContents: async (hashes) => {
+          const res = await api.post(
+            "/host/skills/contents",
+            { agent_id: agent.agent_id, hashes }
+          );
+          return res.contents ?? [];
+        },
+        log
+      });
+      if (resolvedSkills) {
+        refreshData.global_skills = resolvedSkills.globals;
+        refreshData.shared_skills = resolvedSkills.shared;
+      }
+    }
   } catch (err) {
     log(`Refresh failed for '${agent.code_name}': ${err.message}`);
     const existing = state8.agents.find((a) => a.agentId === agent.agent_id);
@@ -15614,7 +15758,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 = join39(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join40(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,
@@ -15670,9 +15814,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter, renderIntegrationsSection);
     const changedFiles = [];
-    mkdirSync12(agentDir, { recursive: true });
+    mkdirSync13(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join39(agentDir, artifact.relativePath);
+      const filePath = join40(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -15691,8 +15835,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join39(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync30(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join40(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync31(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -15710,7 +15854,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync30(filePath, "utf-8");
+          existingRaw = readFileSync31(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -15726,7 +15870,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       } else if (artifact.relativePath === "opencode.json") {
         let existingRaw = null;
         try {
-          existingRaw = readFileSync30(filePath, "utf-8");
+          existingRaw = readFileSync31(filePath, "utf-8");
         } catch {
         }
         const mergeResult = mergeOpencodeConfigArtifact(artifact.content, existingRaw);
@@ -15742,26 +15886,26 @@ async function processAgent(agent, agentStates, managedToolkits) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync17(join39(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync18(join40(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 = join39(agentDir, file.relativePath);
-        mkdirSync12(dirname10(filePath), { recursive: true });
+        const filePath = join40(agentDir, file.relativePath);
+        mkdirSync13(dirname10(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync16(filePath, file.content);
+          writeFileSync17(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join39(agentDir, ".claude", "skills");
-        if (existsSync17(provSkillsDir)) {
-          for (const folder of readdirSync10(provSkillsDir)) {
+        const provSkillsDir = join40(agentDir, ".claude", "skills");
+        if (existsSync18(provSkillsDir)) {
+          for (const folder of readdirSync11(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync6(join39(provSkillsDir, folder), { recursive: true });
+                rmSync7(join40(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -15774,7 +15918,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join39(agentDir, file));
+        const h = hashFile(join40(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -15792,14 +15936,14 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join39(agentDir, ".claude", "workflows");
-        if (existsSync17(provWorkflowsDir)) {
+        const provWorkflowsDir = join40(agentDir, ".claude", "workflows");
+        if (existsSync18(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
-          for (const file of readdirSync10(provWorkflowsDir)) {
+          for (const file of readdirSync11(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync6(join39(provWorkflowsDir, file));
+              rmSync7(join40(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -15878,10 +16022,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
   }
   let lastDriftCheckAt = now;
   const written = agentState.writtenHashes.get(agent.agent_id);
-  if (written && existsSync17(agentDir)) {
+  if (written && existsSync18(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join39(agentDir, file));
+      const localHash = hashFile(join40(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -15892,7 +16036,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join39(agentDir, file));
+          localHashes[file] = hashFile(join40(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -16160,15 +16304,15 @@ async function processAgent(agent, agentStates, managedToolkits) {
     const addedChannels = [...restartDecision.added];
     const writeDmNoticeMarkers = isChannelAddRestart ? () => {
       try {
-        const agentAugmentedDir = join39(homedir17(), ".augmented", agent.code_name);
-        mkdirSync12(agentAugmentedDir, { recursive: true });
+        const agentAugmentedDir = join40(homedir17(), ".augmented", agent.code_name);
+        mkdirSync13(agentAugmentedDir, { recursive: true });
         const markerJson = JSON.stringify({
           version: 1,
           at: (/* @__PURE__ */ new Date()).toISOString(),
           added: addedChannels
         });
         for (const file of ["slack-channel-add-restart.json", "telegram-channel-add-restart.json"]) {
-          atomicWriteFileSync(join39(agentAugmentedDir, file), markerJson);
+          atomicWriteFileSync(join40(agentAugmentedDir, file), markerJson);
         }
       } catch (err) {
         log(`[hot-reload] channel-add DM-notice marker write failed for '${agent.code_name}' (non-fatal): ${err.message}`);
@@ -16244,7 +16388,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash18("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash19("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const msteamsBehaviourRestrictive = isMsTeamsBehaviourRestrictive(behaviourSubset);
       const behaviourDecision = decideSenderPolicyRestart({
@@ -16300,7 +16444,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash18("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash19("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourRestrictive = isSlackBehaviourRestrictive(slackBehaviourSubset);
       const slackBehaviourDecision = decideSenderPolicyRestart({
@@ -16357,24 +16501,24 @@ async function processAgent(agent, agentStates, managedToolkits) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? DEFAULT_FRAMEWORK) === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
-      mkdirSync12(agentProvisionDir, { recursive: true });
-      mkdirSync12(projectDir, { recursive: true });
-      const provisionMcpPath = join39(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join39(projectDir, ".mcp.json");
+      const projectDir = join40(homedir17(), ".augmented", agent.code_name, "project");
+      mkdirSync13(agentProvisionDir, { recursive: true });
+      mkdirSync13(projectDir, { recursive: true });
+      const provisionMcpPath = join40(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join40(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync30(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync31(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join39(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join40(homedir17(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
         return typeof tz === "string" && tz.trim() !== "" ? tz.trim() : void 0;
       })();
-      if (existsSync17(localDirectChatChannel)) {
+      if (existsSync18(localDirectChatChannel)) {
         const directChatEnv = {
           AGT_HOST: requireHost(),
           // ENG-5901 Track D: templated — the manager exports the real
@@ -16394,7 +16538,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: join39(
+          AGT_TURN_INITIATOR_FILE: join40(
             frameworkAdapter.getAgentDir(agent.code_name),
             ".current-turn-initiator.json"
           )
@@ -16414,10 +16558,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join39(projectDir, ".mcp-channels.json");
-      if (existsSync17(staleChannelsPath)) {
+      const staleChannelsPath = join40(projectDir, ".mcp-channels.json");
+      if (existsSync18(staleChannelsPath)) {
         try {
-          rmSync6(staleChannelsPath, { force: true });
+          rmSync7(staleChannelsPath, { force: true });
         } catch {
         }
       }
@@ -16504,7 +16648,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     }
     if (hostFlagStore().getBoolean("connectivity-probe")) {
       try {
-        const probeProjectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join40(homedir17(), ".augmented", agent.code_name, "project");
         let probeSet = integrations;
         try {
           const quarantined = await api.post("/host/agent-integrations/quarantined", { agent_id: agent.agent_id });
@@ -16550,7 +16694,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const forceDue = attemptsLeft > 0;
       let probeRan = false;
       try {
-        const probeProjectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join40(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}`);
@@ -16627,11 +16771,11 @@ async function processAgent(agent, agentStates, managedToolkits) {
       const intHash = computeIntegrationsHash(integrations);
       const prevIntHash = agentState.knownIntegrationHashes.get(agent.agent_id);
       if (intHash !== prevIntHash) {
-        const projectDir = join39(homedir17(), ".augmented", agent.code_name, "project");
-        const envIntPath = join39(projectDir, ".env.integrations");
+        const projectDir = join40(homedir17(), ".augmented", agent.code_name, "project");
+        const envIntPath = join40(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync30(envIntPath, "utf-8");
+          preWriteEnv = readFileSync31(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -16650,9 +16794,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join39(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync30(envIntPath, "utf-8");
-            const mcpContent = readFileSync30(projectMcpPath, "utf-8");
+            const projectMcpPath = join40(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync31(envIntPath, "utf-8");
+            const mcpContent = readFileSync31(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -16742,10 +16886,10 @@ async function processAgent(agent, agentStates, managedToolkits) {
           desiredEntries.push({ serverId, url, headers: mcpHeaders, name: tk.toolkit_name });
         }
         const hashBasis = desiredEntries.slice().sort((a, b) => a.serverId.localeCompare(b.serverId)).map((e) => {
-          const headersHash = createHash18("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash19("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash18("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash19("sha256").update(hashBasis).digest("hex").slice(0, 16);
         const prevMcpHash = agentState.knownManagedMcpHashes.get(agent.agent_id);
         const structureHash = managedMcpStructureHash(desiredEntries);
         const prevStructureHash = agentState.knownManagedMcpStructure.get(agent.agent_id);
@@ -16760,7 +16904,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
-            const urlHash = createHash18("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash19("sha256").update(e.url).digest("hex").slice(0, 12);
             log(`[managed-toolkit] ${agent.code_name}: wrote '${e.name}' (serverId=${e.serverId}, url_hash=${urlHash})`);
           }
           if (frameworkAdapter.removeMcpServer && frameworkAdapter.readMcpServers) {
@@ -16842,7 +16986,11 @@ async function processAgent(agent, agentStates, managedToolkits) {
       }
       const freshData = await api.post("/host/refresh", {
         agent_id: agent.agent_id,
-        knowledge_manifest: true
+        knowledge_manifest: true,
+        // Only `scheduled_tasks` is read here, so ask for the manifest shape on
+        // both lanes — nothing in this branch consumes a skill body, and the
+        // skill lanes are the largest part of the payload being discarded.
+        skills_manifest: true
       });
       tasks = freshData.scheduled_tasks ?? tasks;
     }
@@ -16866,7 +17014,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash19 } = await import("crypto");
+      const { createHash: createHash20 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -16895,7 +17043,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash19("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash20("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           if (!shouldWriteIntegrationSkill(
             agentState.knownSkillHashes,
             agent.agent_id,
@@ -16918,23 +17066,23 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
       }
       try {
-        const { readdirSync: readdirSync11, rmSync: rmSync7 } = await import("fs");
+        const { readdirSync: readdirSync12, rmSync: rmSync8 } = await import("fs");
         const { homedir: homedir18 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join39(homedir18(), ".augmented", agent.code_name, "skills"),
+          join40(homedir18(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join39(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join40(homedir18(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join39(agentDir, ".claude", "skills")
+          join40(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync17(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync18(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
-            for (const entry of readdirSync11(dir)) {
+            for (const entry of readdirSync12(dir)) {
               if (entry.startsWith("plugin-") || entry.startsWith("integration-")) {
                 discoveredEntries.add(entry);
               }
@@ -16949,8 +17097,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
             entry,
             dirs: existingDirs,
             removeDir: (p) => {
-              if (existsSync17(p)) {
-                rmSync7(p, { recursive: true, force: true });
+              if (existsSync18(p)) {
+                rmSync8(p, { recursive: true, force: true });
               }
             }
           });
@@ -16969,7 +17117,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sharedSkillsPayload = refreshAny.shared_skills;
         const desiredResolved = globalSkillsPayload !== void 0 || sharedSkillsPayload !== void 0;
         const manifestPath = managedSkillManifestPath(
-          join39(homedir17(), ".augmented", agent.code_name)
+          join40(homedir17(), ".augmented", agent.code_name)
         );
         const prevIds = /* @__PURE__ */ new Set([
           ...agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
@@ -16978,7 +17126,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const plan = planGlobalSkillSync(
           [...globalSkillsPayload ?? [], ...sharedSkillsPayload ?? []],
           prevIds,
-          (content) => createHash19("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash20("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`),
           { desiredResolved }
         );
@@ -16989,16 +17137,16 @@ async function processAgent(agent, agentStates, managedToolkits) {
         }
         if (plan.removes.length) {
           const globalSkillDirs = [
-            join39(homedir17(), ".augmented", agent.code_name, "skills"),
-            join39(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join39(agentDir, ".claude", "skills")
+            join40(homedir17(), ".augmented", agent.code_name, "skills"),
+            join40(homedir17(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join40(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             let prunedAny = false;
             for (const dir of globalSkillDirs) {
-              const p = join39(dir, id);
-              if (existsSync17(p) && existsSync17(join39(p, "SKILL.md"))) {
-                rmSync6(p, { recursive: true, force: true });
+              const p = join40(dir, id);
+              if (existsSync18(p) && existsSync18(join40(p, "SKILL.md"))) {
+                rmSync7(p, { recursive: true, force: true });
                 prunedAny = true;
               }
             }
@@ -17029,7 +17177,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash19("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash20("sha256").update(hook.script).digest("hex").slice(0, 12);
             const hookKey = `${agent.agent_id}:${frameworkAdapter.id}:plugin-hook:${slug}:on_install`;
             if (agentState.knownSkillHashes.get(hookKey) === scriptHash) continue;
             const result = await frameworkAdapter.executePluginHook({
@@ -17044,9 +17192,9 @@ async function processAgent(agent, agentStates, managedToolkits) {
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
             } else {
-              const stderrHash = createHash19("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash20("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash19("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash20("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
               log(
                 `Integration hook on_install '${slug}' exited ${result.exitCode} for '${agent.code_name}' ` + (missingCmdHash ? `[missing_command_hash=${missingCmdHash}] ` : "") + `[stderr_hash=${stderrHash} stderr_len=${result.stderr.length}]`
               );
@@ -17239,8 +17387,8 @@ async function processAgent(agent, agentStates, managedToolkits) {
         const sess = getSessionState(agent.code_name);
         let mcpJsonParsed = null;
         try {
-          const mcpPath = join39(getProjectDir(agent.code_name), ".mcp.json");
-          mcpJsonParsed = JSON.parse(readFileSync30(mcpPath, "utf-8"));
+          const mcpPath = join40(getProjectDir(agent.code_name), ".mcp.json");
+          mcpJsonParsed = JSON.parse(readFileSync31(mcpPath, "utf-8"));
         } catch {
         }
         reapMissingMcpSessions({
@@ -17623,7 +17771,7 @@ async function processAgent(agent, agentStates, managedToolkits) {
                 freshDoneIds.add(item.id);
               }
             } catch (err) {
-              const errId = createHash18("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
+              const errId = createHash19("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
               log(`Reap API error for item_id=${item.id} error_id=${errId}`);
             }
             if (reapAction === "dead_letter") {
@@ -17671,10 +17819,10 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync17(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync18(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join39(agentDir, file));
+      const h = hashFile(join40(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -17689,7 +17837,7 @@ Retried to the limit after repeated stalls \u2014 needs a look.`).catch(() => {
         refreshData.agent.onboarding_state
       );
       const obStep = obState.step;
-      const markerPath = join39(homedir17(), ".augmented", agent.code_name, "onboarding-drive.json");
+      const markerPath = join40(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;
@@ -17791,7 +17939,7 @@ async function ensureOpencodeRuntime(agent, refreshData, agentTimezone) {
   }
   stopOpencodeSlackIngest(codeName, log);
   stopOpencodeTelegramIngest(codeName, log);
-  const opencodeProjectDir = join39(getFramework("opencode").getAgentDir(codeName), "provision");
+  const opencodeProjectDir = join40(getFramework("opencode").getAgentDir(codeName), "provision");
   const serveEnv = {
     AGT_HOST: requireHost(),
     AGT_API_KEY: getApiKey() ?? void 0,
@@ -17846,8 +17994,8 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     });
   }
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join39(projectDir, ".mcp.json");
-  const claudeMdPath = join39(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join40(projectDir, ".mcp.json");
+  const claudeMdPath = join40(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -18096,7 +18244,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       const ctx = getLastFailureContext(codeName);
       const recovery = prepareForRespawn(codeName);
       const tailSummary = !ctx.tail ? "" : KNOWN_SAFE_TAIL_SIGNATURES.has(ctx.signature) ? `; last pane output (${PANE_TAIL_PREVIEW_LINES} of ~20 lines):
-${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash18("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash19("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
       const sigSummary = ctx.signature !== "unknown" ? `; signature=${ctx.signature}` : "";
       const recoverySummary = recovery ? `; recovery=${recovery}` : "";
       log(
@@ -18110,7 +18258,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash18("sha256")
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash18("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash19("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -18307,7 +18455,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash18("sha256")
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash18("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash19("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
   const prevHash = agentState.knownTasksHashes.get(agent.agent_id);
   if (stableTasksHash !== prevHash) {
     const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
@@ -18781,7 +18929,7 @@ function ensureRealtimeKanbanStarted(agentStates) {
               );
             }
           }).catch((err) => {
-            const errId = createHash18("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
+            const errId = createHash19("sha256").update(err instanceof Error ? err.message : String(err)).digest("hex").slice(0, 12);
             log(
               `[realtime] Work trigger enqueue threw for '${agent.codeName}' item_id=${item.id} error_id=${errId} \u2014 hybrid nudge will retry`
             );
@@ -19071,8 +19219,8 @@ async function processDirectChatMessage(agent, msg) {
     if (useDoorbell) {
       try {
         const doorbell = directChatDoorbellPath(agent.agentId, homedir17());
-        mkdirSync12(dirname10(doorbell), { recursive: true });
-        writeFileSync16(doorbell, String(Date.now()));
+        mkdirSync13(dirname10(doorbell), { recursive: true });
+        writeFileSync17(doorbell, String(Date.now()));
         log(`[direct-chat] Doorbell rung for '${agent.codeName}' (msg=${msg.id}) \u2014 in-session MCP will pull via the cursor`);
         return;
       } catch (err) {
@@ -19200,8 +19348,8 @@ ${formatRunMarker(run_id)}` : KANBAN_CHECK_COMMAND;
   if (run_id) openInjectedRunByCode.set(codeName, run_id);
   try {
     const doorbell = directChatDoorbellPath(agentId, homedir17());
-    mkdirSync12(dirname10(doorbell), { recursive: true });
-    writeFileSync16(doorbell, String(Date.now()));
+    mkdirSync13(dirname10(doorbell), { recursive: true });
+    writeFileSync17(doorbell, String(Date.now()));
   } catch (err) {
     log(`[kanban] doorbell ring failed for '${codeName}': ${err.message} (notice still queued)`);
   }
@@ -19530,17 +19678,17 @@ var lastDownloadHash = /* @__PURE__ */ new Map();
 var lastLocalFileHash = /* @__PURE__ */ new Map();
 var memoryManifests = /* @__PURE__ */ new Map();
 function memoryRetirementDir(configDir, codeName) {
-  return join39(configDir, "_memory-retirement", codeName);
+  return join40(configDir, "_memory-retirement", codeName);
 }
 function memoryManifestPath(configDir, codeName) {
-  return join39(memoryRetirementDir(configDir, codeName), "manifest.json");
+  return join40(memoryRetirementDir(configDir, codeName), "manifest.json");
 }
 function loadMemoryManifest(agentId, configDir, codeName) {
   const cached = memoryManifests.get(agentId);
   if (cached) return cached;
   let manifest = {};
   try {
-    const raw = readFileSync30(memoryManifestPath(configDir, codeName), "utf-8");
+    const raw = readFileSync31(memoryManifestPath(configDir, codeName), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       for (const [name, entry] of Object.entries(parsed)) {
@@ -19560,15 +19708,15 @@ function saveMemoryManifest(agentId, configDir, codeName) {
   if (!manifest) return;
   try {
     const path = memoryManifestPath(configDir, codeName);
-    mkdirSync12(memoryRetirementDir(configDir, codeName), { recursive: true });
+    mkdirSync13(memoryRetirementDir(configDir, codeName), { recursive: true });
     const tmp = `${path}.tmp`;
-    writeFileSync16(tmp, JSON.stringify(manifest, null, 2));
-    renameSync9(tmp, path);
+    writeFileSync17(tmp, JSON.stringify(manifest, null, 2));
+    renameSync10(tmp, path);
   } catch {
   }
 }
 function retiredMemoryDir(configDir, codeName) {
-  return join39(memoryRetirementDir(configDir, codeName), "retired");
+  return join40(memoryRetirementDir(configDir, codeName), "retired");
 }
 var RETIRED_MEMORY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var lastRetirementReport = /* @__PURE__ */ new Map();
@@ -19646,15 +19794,15 @@ function applyMemoryTombstones(opts) {
       log2(`[memory-retire] ${agent.code_name}: KEPT '${tomb.name}' \u2014 no write record, not ours to remove`);
       continue;
     }
-    const filePath = join39(memoryDir, entry.file);
-    if (!existsSync17(filePath)) {
+    const filePath = join40(memoryDir, entry.file);
+    if (!existsSync18(filePath)) {
       outcomes.already_gone++;
       delete manifest[tomb.name];
       manifestDirty = true;
       continue;
     }
     try {
-      const actual = createHash18("sha256").update(readFileSync30(filePath)).digest("hex");
+      const actual = createHash19("sha256").update(readFileSync31(filePath)).digest("hex");
       if (actual !== entry.sha) {
         outcomes.kept_modified++;
         outcomes.unapplied.push({ name: tomb.name, reason: "kept_modified" });
@@ -19664,16 +19812,16 @@ function applyMemoryTombstones(opts) {
         continue;
       }
       const destDir = retiredMemoryDir(configDir, agent.code_name);
-      mkdirSync12(destDir, { recursive: true });
+      mkdirSync13(destDir, { recursive: true });
       const stamp = Date.now();
-      let dest = join39(destDir, `${entry.file}.${stamp}.retired`);
-      for (let n = 1; existsSync17(dest); n++) {
-        dest = join39(destDir, `${entry.file}.${stamp}-${n}.retired`);
+      let dest = join40(destDir, `${entry.file}.${stamp}.retired`);
+      for (let n = 1; existsSync18(dest); n++) {
+        dest = join40(destDir, `${entry.file}.${stamp}-${n}.retired`);
       }
-      renameSync9(filePath, dest);
+      renameSync10(filePath, dest);
       try {
         const now = Date.now() / 1e3;
-        utimesSync2(dest, now, now);
+        utimesSync3(dest, now, now);
       } catch {
       }
       delete manifest[tomb.name];
@@ -19701,15 +19849,15 @@ function applyMemoryTombstones(opts) {
 }
 function reapRetiredMemories(configDir, codeName, log2) {
   const dir = retiredMemoryDir(configDir, codeName);
-  if (!existsSync17(dir)) return;
+  if (!existsSync18(dir)) return;
   const cutoff = Date.now() - RETIRED_MEMORY_TTL_MS;
   let reaped = 0;
   try {
-    for (const file of readdirSync10(dir)) {
+    for (const file of readdirSync11(dir)) {
       if (!file.endsWith(".retired")) continue;
-      const path = join39(dir, file);
+      const path = join40(dir, file);
       try {
-        if (statSync9(path).mtimeMs < cutoff) {
+        if (statSync10(path).mtimeMs < cutoff) {
           unlinkSync6(path);
           reaped++;
         }
@@ -19722,8 +19870,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 = join39(configDir, agent.code_name, "project");
-  const memoryDir = join39(projectDir, "memory");
+  const projectDir = join40(configDir, agent.code_name, "project");
+  const memoryDir = join40(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`);
@@ -19747,15 +19895,15 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync17(memoryDir)) {
+  if (existsSync18(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
-    for (const file of readdirSync10(memoryDir)) {
+    for (const file of readdirSync11(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync30(join39(memoryDir, file), "utf-8");
-        const fileHash = createHash18("sha256").update(raw).digest("hex").slice(0, 16);
+        const raw = readFileSync31(join40(memoryDir, file), "utf-8");
+        const fileHash = createHash19("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
         const parsed = parseMemoryFile(raw, file.replace(/\.md$/, ""));
@@ -19779,7 +19927,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync30(join39(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync31(join40(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -19805,8 +19953,8 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
-  const localFiles = existsSync17(memoryDir) ? readdirSync10(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash18("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localFiles = existsSync18(memoryDir) ? readdirSync11(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localListHash = createHash19("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
   try {
@@ -19814,14 +19962,14 @@ async function downloadMemories(agent, memoryDir, log2, { force, configDir }) {
       agent_id: agent.agent_id
     });
     const tombstones = Array.isArray(dbMemories.tombstones) ? dbMemories.tombstones : null;
-    const responseHash = createHash18("sha256").update(JSON.stringify({ m: dbMemories.memories ?? [], t: tombstones })).digest("hex").slice(0, 16);
+    const responseHash = createHash19("sha256").update(JSON.stringify({ m: dbMemories.memories ?? [], t: tombstones })).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return { status: "skipped", tombstones, truncated: dbMemories.tombstones_truncated === true };
     }
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync12(memoryDir, { recursive: true });
+      mkdirSync13(memoryDir, { recursive: true });
       const manifest = loadMemoryManifest(agent.agent_id, configDir, agent.code_name);
       let written = 0;
       let overwritten = 0;
@@ -19830,7 +19978,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 = join39(memoryDir, fileName);
+        const filePath = join40(memoryDir, fileName);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -19840,17 +19988,17 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 ${mem.content}
 `;
         const record = () => {
-          const sha = createHash18("sha256").update(desired).digest("hex");
+          const sha = createHash19("sha256").update(desired).digest("hex");
           const prev = manifest[mem.name];
           if (prev?.file === fileName && prev.sha === sha) return false;
           manifest[mem.name] = { file: fileName, sha };
           return true;
         };
         let manifestDirty = false;
-        if (existsSync17(filePath)) {
+        if (existsSync18(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync30(filePath, "utf-8");
+            existing = readFileSync31(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) {
@@ -19858,18 +20006,18 @@ ${mem.content}
             if (manifestDirty) saveMemoryManifest(agent.agent_id, configDir, agent.code_name);
             continue;
           }
-          writeFileSync16(filePath, desired);
+          writeFileSync17(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync16(filePath, desired);
+          writeFileSync17(filePath, desired);
           written++;
         }
         if (record()) manifestDirty = true;
         if (manifestDirty) saveMemoryManifest(agent.agent_id, configDir, agent.code_name);
       }
       if (written > 0 || overwritten > 0) {
-        const updatedFiles = readdirSync10(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash18("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        const updatedFiles = readdirSync11(memoryDir).filter((f) => f.endsWith(".md")).sort();
+        lastLocalFileHash.set(agent.agent_id, createHash19("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -19880,9 +20028,9 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync17(agentDir)) {
+  if (existsSync18(agentDir)) {
     try {
-      rmSync6(agentDir, { recursive: true, force: true });
+      rmSync7(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
     } catch (err) {
       log(`Failed to remove provision dir for '${codeName}': ${err.message}`);
@@ -20150,8 +20298,8 @@ function startManager(opts) {
   config = opts;
   try {
     const stateFile = getStateFile();
-    if (existsSync17(stateFile)) {
-      const raw = readFileSync30(stateFile, "utf-8");
+    if (existsSync18(stateFile)) {
+      const raw = readFileSync31(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state8.agents = parsed.agents;
@@ -20178,7 +20326,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=${join39(homedir17(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join40(homedir17(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -20207,7 +20355,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync30(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync31(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -20304,14 +20452,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join39(homedir17(), ".augmented", "_mcp");
-  mkdirSync12(targetDir, { recursive: true });
+  const targetDir = join40(homedir17(), ".augmented", "_mcp");
+  mkdirSync13(targetDir, { recursive: true });
   const moduleDir = dirname10(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join39(dir, "dist", "mcp");
-    if (existsSync17(join39(candidate, "index.js"))) {
+    const candidate = join40(dir, "dist", "mcp");
+    if (existsSync18(join40(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -20328,8 +20476,8 @@ function deployMcpAssets() {
   const failedFiles = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync17(p)) return null;
-      return createHash18("sha256").update(readFileSync30(p)).digest("hex");
+      if (!existsSync18(p)) return null;
+      return createHash19("sha256").update(readFileSync31(p)).digest("hex");
     } catch {
       return null;
     }
@@ -20400,9 +20548,9 @@ function deployMcpAssets() {
     // needs restarting to pick up a token rotation.
     "xero.js"
   ]) {
-    const src = join39(mcpSourceDir, file);
-    const dst = join39(targetDir, file);
-    if (!existsSync17(src)) continue;
+    const src = join40(mcpSourceDir, file);
+    const dst = join40(targetDir, file);
+    if (!existsSync18(src)) continue;
     attemptedFiles.push(file);
     const before = fileHash(dst);
     try {
@@ -20427,23 +20575,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join39(targetDir, "index.js");
+  const localMcpPath = join40(targetDir, "index.js");
   try {
-    const agentsDir = join39(homedir17(), ".augmented", "agents");
-    if (existsSync17(agentsDir)) {
-      for (const entry of readdirSync10(agentsDir, { withFileTypes: true })) {
+    const agentsDir = join40(homedir17(), ".augmented", "agents");
+    if (existsSync18(agentsDir)) {
+      for (const entry of readdirSync11(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join39(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join40(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync30(mcpJsonPath, "utf-8");
+            const raw = readFileSync31(mcpJsonPath, "utf-8");
             if (!raw.includes("@integrity-labs/augmented-mcp")) continue;
             const mcpConfig = JSON.parse(raw);
             const augServer = mcpConfig.mcpServers?.["augmented"];
             if (!augServer) continue;
             augServer.command = "node";
             augServer.args = [localMcpPath];
-            writeFileSync16(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync17(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }