@integrity-labs/agt-cli 0.28.36 → 0.28.38

package/dist/lib/manager-worker.js

@@ -23,7 +23,7 @@ import {
   requireHost,
   safeWriteJsonAtomic,
   setConfigHash
-} from "../chunk-DUFH3RSX.js";
+} from "../chunk-IJT4B5PH.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -106,13 +106,39 @@ import {
 } from "../chunk-XWVM4KPK.js";
 
 // src/lib/manager-worker.ts
-import { createHash as createHash6 } from "crypto";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync9, rmSync as rmSync3, readdirSync as readdirSync5, statSync as statSync4, unlinkSync, copyFileSync } from "fs";
+import { createHash as createHash8 } from "crypto";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync9, rmSync as rmSync3, readdirSync as readdirSync5, statSync as statSync4, unlinkSync, copyFileSync } from "fs";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join15, dirname as dirname3 } from "path";
-import { homedir as homedir8 } from "os";
+import { join as join16, dirname as dirname4 } from "path";
+import { homedir as homedir9 } from "os";
 import { fileURLToPath } from "url";
 
+// src/lib/claude-code-upgrade-throttle.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function claudeCodeUpgradeMarkerPath() {
+  return join(homedir(), ".augmented", ".last-claude-code-upgrade-check");
+}
+function stampClaudeCodeUpgradeMarker() {
+  try {
+    const markerPath = claudeCodeUpgradeMarkerPath();
+    mkdirSync(dirname(markerPath), { recursive: true });
+    writeFileSync(markerPath, String(Date.now()));
+  } catch {
+  }
+}
+function claudeCodeUpgradeThrottled() {
+  try {
+    const lastCheck = parseInt(readFileSync(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
+    if (!Number.isFinite(lastCheck)) return false;
+    return Date.now() - lastCheck < CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/mcp-config-drift.ts
 import { createHash } from "crypto";
 function decideMcpDriftAction(currentHash, knownHash) {
@@ -767,8 +793,8 @@ function extractSlackBehaviourSubset(config2) {
 }
 
 // src/lib/channel-quarantine.ts
-import { readFileSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 var ESSENTIAL_CHANNEL_KEYS = /* @__PURE__ */ new Set(["direct-chat", "augmented"]);
 var OPTIONAL_CHANNEL_KEYS = /* @__PURE__ */ new Set([
   "telegram",
@@ -797,7 +823,7 @@ function classifyChannelCriticality(serverKey, entry) {
   return "essential";
 }
 function defaultQuarantinePath(configDir) {
-  return join(configDir, "channel-quarantine.json");
+  return join2(configDir, "channel-quarantine.json");
 }
 var ChannelQuarantineStore = class {
   path;
@@ -808,7 +834,7 @@ var ChannelQuarantineStore = class {
   load() {
     if (this.cache) return this.cache;
     try {
-      const raw = readFileSync(this.path, "utf-8");
+      const raw = readFileSync2(this.path, "utf-8");
       const parsed = JSON.parse(raw);
       this.cache = isQuarantineFile(parsed) ? parsed : {};
     } catch {
@@ -1395,8 +1421,8 @@ function runCliProbe(binary, args, opts = {}) {
 }
 
 // src/lib/self-update-coalesce.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 var DEFAULT_SELF_UPDATE_COALESCE_MS = 30 * 60 * 1e3;
 function resolveCoalesceWindowMs(env = process.env) {
   const raw = env.AGT_SELF_UPDATE_COALESCE_MS;
@@ -1405,7 +1431,7 @@ function resolveCoalesceWindowMs(env = process.env) {
   if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_SELF_UPDATE_COALESCE_MS;
   return Math.trunc(parsed);
 }
-function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync2(p, "utf-8")) {
+function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) => readFileSync3(p, "utf-8")) {
   let raw;
   try {
     raw = read(markerPath);
@@ -1418,8 +1444,8 @@ function readLastSelfUpdateAppliedMs(markerPath, now = Date.now(), read = (p) =>
   return v;
 }
 function stampLastSelfUpdateApplied(markerPath, now = Date.now(), write = (p, v) => {
-  mkdirSync(dirname(p), { recursive: true });
-  writeFileSync(p, v);
+  mkdirSync2(dirname2(p), { recursive: true });
+  writeFileSync2(p, v);
 }) {
   try {
     write(markerPath, String(now));
@@ -1549,11 +1575,11 @@ function decideRestartGate(opts) {
 }
 
 // src/lib/claude-pid-tracker.ts
-import { existsSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync, readFileSync as readFileSync4 } from "fs";
 function readPidFile(path) {
   if (!existsSync(path)) return { version: 1, spawns: [] };
   try {
-    const raw = JSON.parse(readFileSync3(path, "utf-8"));
+    const raw = JSON.parse(readFileSync4(path, "utf-8"));
     if (raw.version !== 1 || !Array.isArray(raw.spawns)) return { version: 1, spawns: [] };
     const spawns = raw.spawns.filter(
       (s) => !!s && typeof s.pid === "number" && Number.isFinite(s.pid) && s.pid > 0
@@ -1606,7 +1632,7 @@ function formatReaperBootLine(opts) {
 }
 
 // src/lib/direct-chat-spawn-gate.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var DEFAULT_DIRECT_CHAT_HOST_CONCURRENCY = 2;
 var DEFAULT_DIRECT_CHAT_PER_AGENT_CONCURRENCY = 1;
 var DEFAULT_DIRECT_CHAT_MAX_AGE_MS = 30 * 6e4;
@@ -1619,7 +1645,7 @@ function directChatMaxAgeMs() {
   return Number.isFinite(raw) && raw >= 0 ? raw : DEFAULT_DIRECT_CHAT_MAX_AGE_MS;
 }
 function directChatDoorbellPath(agentId, home) {
-  return join2(home, ".augmented", agentId, "direct-chat-doorbell");
+  return join3(home, ".augmented", agentId, "direct-chat-doorbell");
 }
 function isDirectChatMessageExpired(createdAt, nowMs, maxAgeMs) {
   if (!maxAgeMs || maxAgeMs <= 0) return false;
@@ -1722,8 +1748,8 @@ function collectEnvGates(env) {
 }
 
 // src/lib/artifact-stream.ts
-import { join as join3 } from "path";
-import { homedir } from "os";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 import { readdir, stat, readFile } from "fs/promises";
 var ARTEFACT_ENTRY_FILE = "index.html";
 function errMessage(err) {
@@ -1808,7 +1834,7 @@ var ArtifactStreamScanner = class {
         return;
       }
       for (const name of names) {
-        const file = join3(this.artifactsDir, name, ARTEFACT_ENTRY_FILE);
+        const file = join4(this.artifactsDir, name, ARTEFACT_ENTRY_FILE);
         const mtime = await this.fsDeps.mtimeMs(file).catch(() => null);
         if (mtime === null) continue;
         if (this.seenMtime.get(name) === mtime) continue;
@@ -1839,7 +1865,7 @@ var ArtifactStreamScanner = class {
   }
 };
 function artifactsDirFor(codeName) {
-  return join3(homedir(), ".augmented", codeName, "artifacts");
+  return join4(homedir2(), ".augmented", codeName, "artifacts");
 }
 var nodeArtifactFs = {
   async listArtefactNames(artifactsDir) {
@@ -1914,8 +1940,8 @@ async function maybeReportUsageBanner(args) {
 }
 
 // src/lib/token-usage-monitor.ts
-import { readdirSync, readFileSync as readFileSync4, statSync } from "fs";
-import { join as join4 } from "path";
+import { readdirSync, readFileSync as readFileSync5, statSync } from "fs";
+import { join as join5 } from "path";
 var MIN_CHECK_INTERVAL_MS2 = 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS = 2 * 24 * 60 * 60 * 1e3;
 var MAX_ENTRIES_PER_POST = 200;
@@ -1944,7 +1970,7 @@ async function maybeReportTokenUsage(args) {
     if (!name.endsWith(".jsonl")) continue;
     const sessionId = name.slice(0, -".jsonl".length);
     if (!sessionId) continue;
-    const path = join4(dir, name);
+    const path = join5(dir, name);
     let st;
     try {
       st = statSync(path);
@@ -1960,7 +1986,7 @@ async function maybeReportTokenUsage(args) {
     }
     let content;
     try {
-      content = readFileSync4(path, "utf-8");
+      content = readFileSync5(path, "utf-8");
     } catch (err) {
       log2(`[token-usage] read failed for '${codeName}/${name}': ${err.message}`);
       continue;
@@ -2041,8 +2067,8 @@ async function maybeReportTokenUsage(args) {
 }
 
 // src/lib/workflow-run-reconciler.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
 var MIN_CHECK_INTERVAL_MS3 = 5 * 6e4;
 var SETTLE_MS = 3e4;
 var TRANSCRIPT_MTIME_WINDOW_MS2 = 2 * 24 * 60 * 60 * 1e3;
@@ -2061,7 +2087,7 @@ function collectJsonlRecursive(dir, minMtimeMs, out, depth) {
     return;
   }
   for (const name of entries) {
-    const p = join5(dir, name);
+    const p = join6(dir, name);
     let st;
     try {
       st = statSync2(p);
@@ -2084,7 +2110,7 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
     return out;
   }
   for (const name of entries) {
-    const path = join5(transcriptDir, name);
+    const path = join6(transcriptDir, name);
     let st;
     try {
       st = statSync2(path);
@@ -2096,7 +2122,7 @@ function enumerateTranscriptFiles(transcriptDir, nowMs, minMtimeMs = nowMs - TRA
       continue;
     }
     if (st.isDirectory()) {
-      collectJsonlRecursive(join5(path, "subagents"), minMtimeMs, out, 0);
+      collectJsonlRecursive(join6(path, "subagents"), minMtimeMs, out, 0);
     }
   }
   return out;
@@ -2141,7 +2167,7 @@ async function maybeReconcileWorkflowRunTokens(args) {
   const contents = [];
   for (const path of files) {
     try {
-      contents.push(readFileSync5(path, "utf-8"));
+      contents.push(readFileSync6(path, "utf-8"));
     } catch {
     }
   }
@@ -2186,8 +2212,8 @@ async function maybeReconcileWorkflowRunTokens(args) {
 }
 
 // src/lib/conversation-evaluator.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
 var MIN_CHECK_INTERVAL_MS4 = 5 * 6e4;
 var TRANSCRIPT_MTIME_WINDOW_MS3 = 3 * 24 * 60 * 60 * 1e3;
 var WINDOW_PAD_MS = 5 * 6e4;
@@ -2424,7 +2450,7 @@ function readRecentTurns(dir, nowMs) {
   const turns = [];
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
-    const full = join6(dir, name);
+    const full = join7(dir, name);
     let mtimeMs;
     try {
       mtimeMs = statSync3(full).mtimeMs;
@@ -2434,7 +2460,7 @@ function readRecentTurns(dir, nowMs) {
     if (nowMs - mtimeMs > TRANSCRIPT_MTIME_WINDOW_MS3) continue;
     let content;
     try {
-      content = readFileSync6(full, "utf8");
+      content = readFileSync7(full, "utf8");
     } catch {
       continue;
     }
@@ -2603,11 +2629,11 @@ async function reportSkip2(api2, agentId, conversationId, log2, codeName) {
 }
 
 // src/lib/activity-cache-monitor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join8 } from "path";
 var MIN_CHECK_INTERVAL_MS6 = 6e4;
-var STATS_CACHE_PATH = join7(homedir2(), ".claude", "stats-cache.json");
+var STATS_CACHE_PATH = join8(homedir3(), ".claude", "stats-cache.json");
 var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 var state5 = { lastObservedDate: null, lastCheckedAt: 0 };
 function selectNewDailyRows(raw, lastObservedDate) {
@@ -2655,7 +2681,7 @@ async function maybeReportActivityCache(args) {
   }
   let raw;
   try {
-    raw = readFileSync7(STATS_CACHE_PATH, "utf-8");
+    raw = readFileSync8(STATS_CACHE_PATH, "utf-8");
   } catch (err) {
     log2(`[activity-cache] readFileSync failed: ${err.message}`);
     return;
@@ -3104,8 +3130,8 @@ var GatewayClientPool = class extends EventEmitter {
 
 // src/lib/claude-auth-detect.ts
 import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import { homedir as homedir3, platform } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir4, platform } from "os";
+import { join as join9 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
@@ -3120,8 +3146,8 @@ async function detectClaudeAuth() {
 }
 async function findClaudeCredentialsPaths() {
   const candidates = [
-    join8(homedir3(), ".claude", ".credentials.json"),
-    join8(homedir3(), ".claude", "credentials.json")
+    join9(homedir4(), ".claude", ".credentials.json"),
+    join9(homedir4(), ".claude", "credentials.json")
   ];
   const isLinuxRoot = platform() === "linux" && typeof process.getuid === "function" && process.getuid() === 0;
   if (isLinuxRoot) {
@@ -3129,8 +3155,8 @@ async function findClaudeCredentialsPaths() {
       const entries = await readdir2("/home", { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        candidates.push(join8("/home", entry.name, ".claude", ".credentials.json"));
-        candidates.push(join8("/home", entry.name, ".claude", "credentials.json"));
+        candidates.push(join9("/home", entry.name, ".claude", ".credentials.json"));
+        candidates.push(join9("/home", entry.name, ".claude", "credentials.json"));
       }
     } catch {
     }
@@ -3222,18 +3248,18 @@ function normalize(value) {
 }
 
 // src/lib/channel-hash-cache.ts
-import { existsSync as existsSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10 } from "path";
 var CACHE_FILENAME = "channel-hash-cache.json";
 function getChannelHashCacheFile(configDir) {
-  return join9(configDir, CACHE_FILENAME);
+  return join10(configDir, CACHE_FILENAME);
 }
 function loadChannelHashCache(target, configDir) {
   const path = getChannelHashCacheFile(configDir);
   if (!existsSync3(path)) return;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    parsed = JSON.parse(readFileSync9(path, "utf-8"));
   } catch {
     return;
   }
@@ -3247,7 +3273,7 @@ function saveChannelHashCache(source, configDir) {
   const obj = {};
   for (const [key, value] of source) obj[key] = value;
   try {
-    writeFileSync2(path, JSON.stringify(obj, null, 2));
+    writeFileSync3(path, JSON.stringify(obj, null, 2));
   } catch {
   }
 }
@@ -3634,9 +3660,9 @@ function planGlobalSkillSync(globalSkills, prevIds, hashOf, knownHash) {
 
 // src/lib/manager/runtime.ts
 import { createHash as createHash4 } from "crypto";
-import { readFileSync as readFileSync9, appendFileSync, mkdirSync as mkdirSync2, chmodSync, existsSync as existsSync4 } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
-import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync10, appendFileSync, mkdirSync as mkdirSync3, chmodSync, existsSync as existsSync4 } from "fs";
+import { join as join11, dirname as dirname3 } from "path";
+import { homedir as homedir5 } from "os";
 function redactForDiskLog(value) {
   try {
     return value.replace(/\b(Bearer\s+)[A-Za-z0-9._-]+\b/gi, "$1[REDACTED]").replace(/\bxox[baprs]-[A-Za-z0-9-]+\b/g, "[REDACTED-SLACK]").replace(/\btlk_[A-Za-z0-9._-]+\b/g, "[REDACTED-HOST]").replace(/\bsk-ant-[A-Za-z0-9_-]+\b/g, "[REDACTED-ANTHROPIC]").replace(/\b\d{8,12}:[A-Za-z0-9_-]{30,}\b/g, "[REDACTED-TELEGRAM]").replace(
@@ -3656,8 +3682,8 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join10(homedir4(), ".augmented", "manager.log");
-      mkdirSync2(dirname2(managerLogPath), { recursive: true });
+      managerLogPath = join11(homedir5(), ".augmented", "manager.log");
+      mkdirSync3(dirname3(managerLogPath), { recursive: true });
       if (existsSync4(managerLogPath)) {
         chmodSync(managerLogPath, 384);
       }
@@ -3686,7 +3712,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -3786,8 +3812,8 @@ function resolveModelChain(refreshData) {
 
 // src/lib/manager/claude-auth.ts
 import { existsSync as existsSync5, rmSync } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir5 } from "os";
+import { join as join12 } from "path";
+import { homedir as homedir6 } from "os";
 async function applyClaudeAuthToEnv(childEnv, label) {
   const apiKey = getApiKey();
   if (!apiKey) {
@@ -3799,9 +3825,9 @@ async function applyClaudeAuthToEnv(childEnv, label) {
       throw new Error("claude_auth_mode=api_key but /host/exchange returned no decrypted key");
     }
     childEnv.ANTHROPIC_API_KEY = exchange.anthropicApiKey;
-    const claudeDir = join11(homedir5(), ".claude");
+    const claudeDir = join12(homedir6(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join11(claudeDir, filename);
+      const p = join12(claudeDir, filename);
       if (existsSync5(p)) {
         try {
           rmSync(p, { force: true });
@@ -3816,8 +3842,8 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 
 // src/lib/manager/kanban/parsers.ts
-import { existsSync as existsSync6, readFileSync as readFileSync10 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync11 } from "fs";
+import { join as join13 } 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"]);
@@ -3937,12 +3963,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join12(process.cwd(), "skills", skillId, "SKILL.md"),
-      join12(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join13(process.cwd(), "skills", skillId, "SKILL.md"),
+      join13(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
       if (existsSync6(candidate)) {
-        const content = readFileSync10(candidate, "utf-8");
+        const content = readFileSync11(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -4407,11 +4433,140 @@ async function sendTaskNotification(agentCodeName, channel, to, text) {
   return { ok: false, error_code: `UNKNOWN_CHANNEL:${channel}` };
 }
 
-// src/lib/manager/scheduler.ts
+// src/lib/manager/scheduler/tasks.ts
+function buildSchedulerTaskInput(t) {
+  return {
+    id: t.id,
+    template_id: t.template_id,
+    name: t.name,
+    schedule_kind: t.schedule_kind,
+    schedule_expr: t.schedule_expr ?? null,
+    schedule_every: t.schedule_every ?? null,
+    schedule_at: t.schedule_at ?? null,
+    timezone: t.timezone ?? "UTC",
+    prompt: t.prompt ?? "",
+    session_target: t.session_target ?? "isolated",
+    delivery_mode: t.delivery_mode ?? "none",
+    delivery_policy: t.delivery_policy ?? "always",
+    delivery_channel: t.delivery_channel ?? null,
+    delivery_to: t.delivery_to ?? null,
+    enabled: t.enabled ?? true,
+    triggered_at: t.triggered_at ?? null
+  };
+}
+function deriveScheduledTaskNotify(task) {
+  if (task.deliveryChannel !== "msteams") return {};
+  const to = task.deliveryTo;
+  let conversationId = null;
+  if (typeof to === "string" && to.trim().length > 0) {
+    conversationId = to.trim();
+  } else if (to && typeof to === "object") {
+    const cid = to.conversation_id;
+    if (typeof cid === "string" && cid.trim().length > 0) conversationId = cid.trim();
+  }
+  if (!conversationId) return {};
+  return { notify_channel: "msteams", notify_to: conversationId };
+}
+function isScheduledViaKanbanEnabled() {
+  const v = process.env["AGT_SCHEDULED_VIA_KANBAN"];
+  return !(v === "0" || v?.toLowerCase() === "false");
+}
+
+// src/lib/manager/scheduler/runs.ts
 import { createHash as createHash5 } from "crypto";
-import { readFileSync as readFileSync11, existsSync as existsSync7 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join13 } from "path";
+async function startRun(opts) {
+  try {
+    const res = await api.post(
+      "/host/runs/start",
+      opts
+    );
+    return { run_id: res.run_id ?? null, kanban_item_id: res.kanban_item_id ?? null };
+  } catch (err) {
+    const errText = err instanceof Error ? err.message : String(err);
+    const errId = createHash5("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 };
+  }
+}
+async function finishRun(runId, outcome, options = {}) {
+  try {
+    await api.post("/host/runs/finish", {
+      run_id: runId,
+      outcome,
+      outcome_message: options.outcomeMessage,
+      metadata: options.metadata,
+      complete_kanban_item_id: options.completeKanbanItemId ?? void 0,
+      result: options.result
+    });
+  } catch (err) {
+    const errText = err instanceof Error ? err.message : String(err);
+    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
+    log(`[runs] finish failed for run_id=${runId} outcome=${outcome} error_id=${errId}`);
+  }
+}
+var MAX_PRIOR_RUNS = 5;
+async function fetchPriorScheduledRuns(agentId, taskId) {
+  try {
+    const data = await api.post("/host/scheduled-tasks/recent-outputs", {
+      agent_id: agentId,
+      task_id: taskId,
+      since_hours: 24,
+      limit: MAX_PRIOR_RUNS
+    });
+    const rows = Array.isArray(data?.runs) ? data.runs.slice(0, MAX_PRIOR_RUNS) : [];
+    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 = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
+    log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
+    return [];
+  }
+}
+
+// src/lib/manager/scheduler/state.ts
+var inFlightClaudeTasks = /* @__PURE__ */ new Set();
+var claudeTaskConcurrency = /* @__PURE__ */ new Map();
+var MAX_CLAUDE_CONCURRENCY = 2;
+var claudeSchedulerStates = /* @__PURE__ */ new Map();
+var scheduledRunsByCode = /* @__PURE__ */ new Map();
+var claimedScheduledCards = /* @__PURE__ */ new Set();
+var completedScheduledCards = /* @__PURE__ */ new Set();
+function claimScheduledCardDelivery(cardId) {
+  if (claimedScheduledCards.has(cardId)) return false;
+  claimedScheduledCards.add(cardId);
+  return true;
+}
+function releaseScheduledCardDelivery(cardId) {
+  claimedScheduledCards.delete(cardId);
+}
+function markScheduledCardDeliveryComplete(cardId) {
+  completedScheduledCards.add(cardId);
+}
+function trackScheduledRun(codeName, cardId, runId) {
+  let m = scheduledRunsByCode.get(codeName);
+  if (!m) {
+    m = /* @__PURE__ */ new Map();
+    scheduledRunsByCode.set(codeName, m);
+  }
+  m.set(cardId, runId);
+}
+function isScheduledCardTracked(cardId) {
+  for (const m of scheduledRunsByCode.values()) {
+    if (m.has(cardId)) return true;
+  }
+  return false;
+}
+function closeScheduledRunsForCode(codeName, outcome, reason) {
+  const m = scheduledRunsByCode.get(codeName);
+  if (!m || m.size === 0) return;
+  scheduledRunsByCode.delete(codeName);
+  for (const runId of m.values()) {
+    void finishRun(runId, outcome, { outcomeMessage: reason });
+  }
+}
+
+// src/lib/manager/scheduler/kanban-route.ts
+import { createHash as createHash6 } from "crypto";
 
 // src/lib/delivery-schedule-link.ts
 function envSuffixFor2(codeName) {
@@ -4637,231 +4792,38 @@ async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, bod
   }
 }
 
-// src/lib/manager/scheduler.ts
-function buildSchedulerTaskInput(t) {
-  return {
-    id: t.id,
-    template_id: t.template_id,
-    name: t.name,
-    schedule_kind: t.schedule_kind,
-    schedule_expr: t.schedule_expr ?? null,
-    schedule_every: t.schedule_every ?? null,
-    schedule_at: t.schedule_at ?? null,
-    timezone: t.timezone ?? "UTC",
-    prompt: t.prompt ?? "",
-    session_target: t.session_target ?? "isolated",
-    delivery_mode: t.delivery_mode ?? "none",
-    delivery_policy: t.delivery_policy ?? "always",
-    delivery_channel: t.delivery_channel ?? null,
-    delivery_to: t.delivery_to ?? null,
-    enabled: t.enabled ?? true,
-    triggered_at: t.triggered_at ?? null
-  };
-}
-var inFlightClaudeTasks = /* @__PURE__ */ new Set();
-var claudeTaskConcurrency = /* @__PURE__ */ new Map();
-var MAX_CLAUDE_CONCURRENCY = 2;
-function claudePidFilePath() {
-  return join13(homedir6(), ".augmented", "manager-claude-pids.json");
-}
-var inFlightClaudePids = /* @__PURE__ */ new Map();
-function registerClaudeSpawn(record) {
-  inFlightClaudePids.set(record.pid, record);
-  try {
-    addSpawn(claudePidFilePath(), record);
-  } catch (err) {
-    log(`[drain] pid-file write failed: ${err.message}`);
+// src/lib/manager/scheduler/kanban-route.ts
+async function deliverScheduledCardResult(codeName, agentId, cardId) {
+  if (!claimScheduledCardDelivery(cardId)) {
+    return completedScheduledCards.has(cardId) ? "terminal" : "in_flight";
   }
-}
-function unregisterClaudeSpawn(pid) {
-  inFlightClaudePids.delete(pid);
+  let card;
   try {
-    removeSpawn(claudePidFilePath(), pid);
-  } catch {
+    const resp = await api.post("/host/kanban-item", {
+      agent_id: agentId,
+      item_id: cardId
+    });
+    card = resp.item;
+  } catch (err) {
+    if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
+      log(`[scheduled-kanban] delivery: card ${cardId} on '${codeName}' fetch returned ${err.status} (${err.message}) \u2014 treating as terminal, not retrying`);
+      markScheduledCardDeliveryComplete(cardId);
+      return "terminal";
+    }
+    releaseScheduledCardDelivery(cardId);
+    log(`[scheduled-kanban] delivery fetch failed for card ${cardId} on '${codeName}': ${err.message} \u2014 will retry`);
+    return "retry";
   }
-}
-var claudeSchedulerStates = /* @__PURE__ */ new Map();
-async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
-  const codeName = agent.code_name;
-  const stableTasksHash = createHash5("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const boardHash = boardItems.length > 0 ? createHash5("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 = createHash5("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) {
-    const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
-    const state8 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, state8);
-    agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
-    log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
+  if (!card || card.status !== "done" || card.source_type !== "scheduled_task" || !card.source_ref) {
+    markScheduledCardDeliveryComplete(cardId);
+    return "terminal";
   }
-  if (!claudeSchedulerStates.has(codeName)) {
-    claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
-  }
-  const state7 = claudeSchedulerStates.get(codeName);
-  const ready = getReadyTasks(state7, inFlightClaudeTasks);
-  if (ready.length === 0) return;
-  for (const task of ready) {
-    if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
-    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
-      const updated = markTaskFired(codeName, task.taskId, "ok");
-      claudeSchedulerStates.set(codeName, updated);
-      continue;
-    }
-    let prompt = task.prompt;
-    if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
-      const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
-      const boardPrefix = formatBoardForPrompt(boardItems, template);
-      prompt = boardPrefix + prompt;
-    }
-    inFlightClaudeTasks.add(task.taskId);
-    claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
-    if (isScheduledViaKanbanEnabled() && isPlainScheduledTemplate(task.templateId)) {
-      await fireScheduledTaskViaKanban(codeName, agent.agent_id, task, prompt);
-      inFlightClaudeTasks.delete(task.taskId);
-      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
-      continue;
-    }
-    log(`[claude-scheduler] Firing '${task.name}' for '${codeName}'`);
-    executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).finally(() => {
-      inFlightClaudeTasks.delete(task.taskId);
-      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
-    });
-  }
-}
-function deriveScheduledTaskNotify(task) {
-  if (task.deliveryChannel !== "msteams") return {};
-  const to = task.deliveryTo;
-  let conversationId = null;
-  if (typeof to === "string" && to.trim().length > 0) {
-    conversationId = to.trim();
-  } else if (to && typeof to === "object") {
-    const cid = to.conversation_id;
-    if (typeof cid === "string" && cid.trim().length > 0) conversationId = cid.trim();
-  }
-  if (!conversationId) return {};
-  return { notify_channel: "msteams", notify_to: conversationId };
-}
-async function startRun(opts) {
-  try {
-    const res = await api.post(
-      "/host/runs/start",
-      opts
-    );
-    return { run_id: res.run_id ?? null, kanban_item_id: res.kanban_item_id ?? null };
-  } catch (err) {
-    const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash5("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 };
-  }
-}
-async function finishRun(runId, outcome, options = {}) {
-  try {
-    await api.post("/host/runs/finish", {
-      run_id: runId,
-      outcome,
-      outcome_message: options.outcomeMessage,
-      metadata: options.metadata,
-      complete_kanban_item_id: options.completeKanbanItemId ?? void 0,
-      result: options.result
-    });
-  } catch (err) {
-    const errText = err instanceof Error ? err.message : String(err);
-    const errId = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
-    log(`[runs] finish failed for run_id=${runId} outcome=${outcome} error_id=${errId}`);
-  }
-}
-var MAX_PRIOR_RUNS = 5;
-async function fetchPriorScheduledRuns(agentId, taskId) {
-  try {
-    const data = await api.post("/host/scheduled-tasks/recent-outputs", {
-      agent_id: agentId,
-      task_id: taskId,
-      since_hours: 24,
-      limit: MAX_PRIOR_RUNS
-    });
-    const rows = Array.isArray(data?.runs) ? data.runs.slice(0, MAX_PRIOR_RUNS) : [];
-    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 = createHash5("sha256").update(errText).digest("hex").slice(0, 12);
-    log(`[runs] prior-runs lookup failed for task_id=${taskId} error_id=${errId}`);
-    return [];
-  }
-}
-function isScheduledViaKanbanEnabled() {
-  const v = process.env["AGT_SCHEDULED_VIA_KANBAN"];
-  return !(v === "0" || v?.toLowerCase() === "false");
-}
-var scheduledRunsByCode = /* @__PURE__ */ new Map();
-var claimedScheduledCards = /* @__PURE__ */ new Set();
-var completedScheduledCards = /* @__PURE__ */ new Set();
-function claimScheduledCardDelivery(cardId) {
-  if (claimedScheduledCards.has(cardId)) return false;
-  claimedScheduledCards.add(cardId);
-  return true;
-}
-function releaseScheduledCardDelivery(cardId) {
-  claimedScheduledCards.delete(cardId);
-}
-function markScheduledCardDeliveryComplete(cardId) {
-  completedScheduledCards.add(cardId);
-}
-function trackScheduledRun(codeName, cardId, runId) {
-  let m = scheduledRunsByCode.get(codeName);
-  if (!m) {
-    m = /* @__PURE__ */ new Map();
-    scheduledRunsByCode.set(codeName, m);
-  }
-  m.set(cardId, runId);
-}
-function isScheduledCardTracked(cardId) {
-  for (const m of scheduledRunsByCode.values()) {
-    if (m.has(cardId)) return true;
-  }
-  return false;
-}
-function closeScheduledRunsForCode(codeName, outcome, reason) {
-  const m = scheduledRunsByCode.get(codeName);
-  if (!m || m.size === 0) return;
-  scheduledRunsByCode.delete(codeName);
-  for (const runId of m.values()) {
-    void finishRun(runId, outcome, { outcomeMessage: reason });
-  }
-}
-async function deliverScheduledCardResult(codeName, agentId, cardId) {
-  if (!claimScheduledCardDelivery(cardId)) {
-    return completedScheduledCards.has(cardId) ? "terminal" : "in_flight";
-  }
-  let card;
-  try {
-    const resp = await api.post("/host/kanban-item", {
-      agent_id: agentId,
-      item_id: cardId
-    });
-    card = resp.item;
-  } catch (err) {
-    if (err instanceof ApiError && err.status >= 400 && err.status < 500) {
-      log(`[scheduled-kanban] delivery: card ${cardId} on '${codeName}' fetch returned ${err.status} (${err.message}) \u2014 treating as terminal, not retrying`);
-      markScheduledCardDeliveryComplete(cardId);
-      return "terminal";
-    }
-    releaseScheduledCardDelivery(cardId);
-    log(`[scheduled-kanban] delivery fetch failed for card ${cardId} on '${codeName}': ${err.message} \u2014 will retry`);
-    return "retry";
-  }
-  if (!card || card.status !== "done" || card.source_type !== "scheduled_task" || !card.source_ref) {
-    markScheduledCardDeliveryComplete(cardId);
-    return "terminal";
-  }
-  const state7 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
-  const task = state7.tasks[card.source_ref];
-  if (!task) {
-    log(`[scheduled-kanban] delivery: no scheduler task for source_ref=${card.source_ref} on '${codeName}' \u2014 skipping`);
-    markScheduledCardDeliveryComplete(cardId);
-    return "terminal";
+  const state7 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const task = state7.tasks[card.source_ref];
+  if (!task) {
+    log(`[scheduled-kanban] delivery: no scheduler task for source_ref=${card.source_ref} on '${codeName}' \u2014 skipping`);
+    markScheduledCardDeliveryComplete(cardId);
+    return "terminal";
   }
   if (!isPlainScheduledTemplate(task.templateId)) {
     log(`[scheduled-kanban] delivery: card ${cardId} template '${task.templateId}' on '${codeName}' is not a plain scheduled template \u2014 skipping manager delivery`);
@@ -4996,9 +4958,152 @@ async function fireScheduledTaskViaKanban(codeName, agentId, task, prompt) {
   }
   return routed;
 }
+async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput, delivery) {
+  try {
+    const classification = classifyOutput(rawOutput);
+    if (classification.action === "suppress") {
+      const trimmed = (rawOutput ?? "").trim();
+      const outputHash = trimmed.length === 0 ? "empty" : createHash6("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 = createHash6("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) {
+        await reportDeliveryStatus(agentId, delivery.taskId, {
+          status: "skipped",
+          error_code: "NO_CONTENT"
+        });
+      }
+      return;
+    }
+    const output = classification.deliverable;
+    if (classification.action === "strip") {
+      log(`[claude-scheduler] Stripped '<no-delivery/>' sentinel from '${codeName}' output (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent mixed it with real content; delivering the rest.`);
+    }
+    if (STANDUP_TEMPLATES.has(templateId)) {
+      const standup = parseStandupSummary(output);
+      await api.post("/host/agent-status", {
+        agent_code_name: codeName,
+        standup,
+        current_status: "idle"
+      });
+      log(`[claude-scheduler] Standup posted for '${codeName}'`);
+    } else if (TASK_UPDATE_TEMPLATES.has(templateId)) {
+      await api.post("/host/agent-status", {
+        agent_code_name: codeName,
+        current_tasks: output.slice(0, 2e3)
+      });
+      log(`[claude-scheduler] Task update posted for '${codeName}'`);
+    } else if (PLAN_TEMPLATES.has(templateId)) {
+      const planItems = parsePlanItems(output);
+      if (planItems.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          add: planItems
+        });
+        log(`[claude-scheduler] Plan items posted for '${codeName}' (${planItems.length} items)`);
+      }
+    } else if (KANBAN_WORK_TEMPLATES.has(templateId)) {
+      const kanbanUpdates = parseKanbanUpdates(output);
+      if (kanbanUpdates.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          update: kanbanUpdates
+        });
+        log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
+      }
+    }
+    if (delivery?.mode === "announce" && delivery.to) {
+      await deliverScheduledTaskOutput(
+        codeName,
+        agentId,
+        delivery.to,
+        output.slice(0, 4e3),
+        delivery.taskId
+      );
+    }
+  } catch (err) {
+    log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
+  }
+}
+
+// src/lib/manager/scheduler/execution.ts
+import { createHash as createHash7 } from "crypto";
+import { readFileSync as readFileSync12, existsSync as existsSync7 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join14 } from "path";
+function claudePidFilePath() {
+  return join14(homedir7(), ".augmented", "manager-claude-pids.json");
+}
+var inFlightClaudePids = /* @__PURE__ */ new Map();
+function registerClaudeSpawn(record) {
+  inFlightClaudePids.set(record.pid, record);
+  try {
+    addSpawn(claudePidFilePath(), record);
+  } catch (err) {
+    log(`[drain] pid-file write failed: ${err.message}`);
+  }
+}
+function unregisterClaudeSpawn(pid) {
+  inFlightClaudePids.delete(pid);
+  try {
+    removeSpawn(claudePidFilePath(), pid);
+  } catch {
+  }
+}
+async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
+  const codeName = agent.code_name;
+  const stableTasksHash = createHash7("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash7("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 = createHash7("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) {
+    const taskInputs = tasks.map((t) => buildSchedulerTaskInput(t));
+    const state8 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state8);
+    agentState.knownTasksHashes.set(agent.agent_id, combinedHash);
+    log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
+  }
+  if (!claudeSchedulerStates.has(codeName)) {
+    claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
+  }
+  const state7 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state7, inFlightClaudeTasks);
+  if (ready.length === 0) return;
+  for (const task of ready) {
+    if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
+    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
+      const updated = markTaskFired(codeName, task.taskId, "ok");
+      claudeSchedulerStates.set(codeName, updated);
+      continue;
+    }
+    let prompt = task.prompt;
+    if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
+      const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
+      const boardPrefix = formatBoardForPrompt(boardItems, template);
+      prompt = boardPrefix + prompt;
+    }
+    inFlightClaudeTasks.add(task.taskId);
+    claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
+    if (isScheduledViaKanbanEnabled() && isPlainScheduledTemplate(task.templateId)) {
+      await fireScheduledTaskViaKanban(codeName, agent.agent_id, task, prompt);
+      inFlightClaudeTasks.delete(task.taskId);
+      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+      continue;
+    }
+    log(`[claude-scheduler] Firing '${task.name}' for '${codeName}'`);
+    executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).finally(() => {
+      inFlightClaudeTasks.delete(task.taskId);
+      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+    });
+  }
+}
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join13(projectDir, ".mcp.json");
+  const mcpConfigPath = join14(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -5006,11 +5111,11 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join13(projectDir, "CLAUDE.md");
+    const claudeMdPath = join14(projectDir, "CLAUDE.md");
     const serverNames = [];
     if (existsSync7(mcpConfigPath)) {
       try {
-        const d = JSON.parse(readFileSync11(mcpConfigPath, "utf-8"));
+        const d = JSON.parse(readFileSync12(mcpConfigPath, "utf-8"));
         if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
       } catch {
       }
@@ -5033,10 +5138,10 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join13(projectDir, ".env.integrations");
+    const envIntPath = join14(projectDir, ".env.integrations");
     if (existsSync7(envIntPath)) {
       try {
-        Object.assign(childEnv, parseEnvIntegrations(readFileSync11(envIntPath, "utf-8")));
+        Object.assign(childEnv, parseEnvIntegrations(readFileSync12(envIntPath, "utf-8")));
       } catch {
       }
     }
@@ -5133,75 +5238,6 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
     claudeSchedulerStates.set(codeName, updated);
   }
 }
-async function processClaudeTaskResult(codeName, agentId, templateId, rawOutput, delivery) {
-  try {
-    const classification = classifyOutput(rawOutput);
-    if (classification.action === "suppress") {
-      const trimmed = (rawOutput ?? "").trim();
-      const outputHash = trimmed.length === 0 ? "empty" : createHash5("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 = createHash5("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) {
-        await reportDeliveryStatus(agentId, delivery.taskId, {
-          status: "skipped",
-          error_code: "NO_CONTENT"
-        });
-      }
-      return;
-    }
-    const output = classification.deliverable;
-    if (classification.action === "strip") {
-      log(`[claude-scheduler] Stripped '<no-delivery/>' sentinel from '${codeName}' output (template=${templateId}, task=${delivery?.taskId ?? "n/a"}) \u2014 agent mixed it with real content; delivering the rest.`);
-    }
-    if (STANDUP_TEMPLATES.has(templateId)) {
-      const standup = parseStandupSummary(output);
-      await api.post("/host/agent-status", {
-        agent_code_name: codeName,
-        standup,
-        current_status: "idle"
-      });
-      log(`[claude-scheduler] Standup posted for '${codeName}'`);
-    } else if (TASK_UPDATE_TEMPLATES.has(templateId)) {
-      await api.post("/host/agent-status", {
-        agent_code_name: codeName,
-        current_tasks: output.slice(0, 2e3)
-      });
-      log(`[claude-scheduler] Task update posted for '${codeName}'`);
-    } else if (PLAN_TEMPLATES.has(templateId)) {
-      const planItems = parsePlanItems(output);
-      if (planItems.length > 0) {
-        await api.post("/host/kanban", {
-          agent_id: agentId,
-          add: planItems
-        });
-        log(`[claude-scheduler] Plan items posted for '${codeName}' (${planItems.length} items)`);
-      }
-    } else if (KANBAN_WORK_TEMPLATES.has(templateId)) {
-      const kanbanUpdates = parseKanbanUpdates(output);
-      if (kanbanUpdates.length > 0) {
-        await api.post("/host/kanban", {
-          agent_id: agentId,
-          update: kanbanUpdates
-        });
-        log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
-      }
-    }
-    if (delivery?.mode === "announce" && delivery.to) {
-      await deliverScheduledTaskOutput(
-        codeName,
-        agentId,
-        delivery.to,
-        output.slice(0, 4e3),
-        delivery.taskId
-      );
-    }
-  } catch (err) {
-    log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
-  }
-}
 
 // src/lib/wedge-detection.ts
 var DEFAULTS = {
@@ -5342,15 +5378,15 @@ function partitionActionableByPoison(actionable, states, config2) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync12, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync13, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join15 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join14(homedir7(), ".augmented", "restart-flags");
+  return join15(homedir8(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join14(restartFlagsDir(), `${codeName}.flag`);
+  return join15(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
@@ -5359,7 +5395,7 @@ function readRestartFlags() {
   for (const entry of readdirSync4(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync12(join14(dir, entry), "utf8");
+      const raw = readFileSync13(join15(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -5912,8 +5948,8 @@ function applyRestartAcks(args) {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join15(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join15(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join16(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join16(AUGMENTED_DIR, "gateway-ports.json");
 var CHANNEL_SWEEP_INTERVAL_MS = (() => {
   const raw = parseInt(process.env["AGT_CHANNEL_SWEEP_INTERVAL_MS"] ?? "", 10);
   if (!Number.isFinite(raw)) return 5 * 60 * 1e3;
@@ -6411,15 +6447,15 @@ var runningMcpServerKeys = /* @__PURE__ */ new Map();
 var runningChannelSecretHashes = /* @__PURE__ */ new Map();
 function projectMcpHash(_codeName, projectDir) {
   try {
-    const raw = readFileSync13(join15(projectDir, ".mcp.json"), "utf-8");
-    return createHash6("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
+    const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
+    return createHash8("sha256").update(canonicalJson(JSON.parse(raw))).digest("hex");
   } catch {
     return null;
   }
 }
 function projectMcpKeys(_codeName, projectDir) {
   try {
-    const raw = readFileSync13(join15(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
     const parsed = JSON.parse(raw);
     const servers = parsed.mcpServers;
     if (!servers || typeof servers !== "object") return /* @__PURE__ */ new Set();
@@ -6430,7 +6466,7 @@ function projectMcpKeys(_codeName, projectDir) {
 }
 function readMcpHttpServerConfig(projectDir, serverKey, env) {
   try {
-    const raw = readFileSync13(join15(projectDir, ".mcp.json"), "utf-8");
+    const raw = readFileSync14(join16(projectDir, ".mcp.json"), "utf-8");
     const servers = JSON.parse(raw).mcpServers ?? {};
     const entry = servers[serverKey];
     if (entry && typeof entry.url === "string" && (entry.type === "http" || entry.type === void 0)) {
@@ -6468,9 +6504,9 @@ async function runAgentConnectivityProbes(agent, integrations, projectDir) {
   if (integrations.length === 0) return;
   const probeEnv = { ...process.env };
   try {
-    const envIntPath = join15(projectDir, ".env.integrations");
+    const envIntPath = join16(projectDir, ".env.integrations");
     if (existsSync9(envIntPath)) {
-      Object.assign(probeEnv, parseEnvIntegrations(readFileSync13(envIntPath, "utf-8")));
+      Object.assign(probeEnv, parseEnvIntegrations(readFileSync14(envIntPath, "utf-8")));
     }
   } catch {
   }
@@ -6683,7 +6719,7 @@ function checkMcpConfigDriftAndScheduleRestart(codeName, projectDir) {
 function projectChannelSecretHash(projectDir) {
   try {
     const entries = parseEnvIntegrations(
-      readFileSync13(join15(projectDir, ".env.integrations"), "utf-8")
+      readFileSync14(join16(projectDir, ".env.integrations"), "utf-8")
     );
     return channelSecretValueHash(entries, CHANNEL_SECRET_ENV_KEYS);
   } catch {
@@ -6771,7 +6807,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.36" : "dev";
+var agtCliVersion = true ? "0.28.38" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -6866,7 +6902,7 @@ async function ensureToolkitCli(toolkitSlug) {
         toolkitCliEnsured.add(toolkitSlug);
         return;
       }
-      brewBinDir = dirname3(brewPath);
+      brewBinDir = dirname4(brewPath);
       const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
       log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
       if (isRoot) {
@@ -6948,7 +6984,7 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
   try {
     let settings = {};
     if (existsSync9(path)) {
-      const raw = readFileSync13(path, "utf-8").trim();
+      const raw = readFileSync14(path, "utf-8").trim();
       if (raw) {
         let parsed;
         try {
@@ -6964,8 +7000,8 @@ function ensureClaudeManagedSettings(path = claudeManagedSettingsPath()) {
     }
     if (settings.channelsEnabled === true) return "ok";
     settings.channelsEnabled = true;
-    mkdirSync4(dirname3(path), { recursive: true });
-    writeFileSync4(path, `${JSON.stringify(settings, null, 2)}
+    mkdirSync5(dirname4(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(settings, null, 2)}
 `);
     log(`[managed-settings] set channelsEnabled:true in ${path} (ENG-5786 \u2014 unblocks Claude Code channels)`);
     return "ok";
@@ -7006,7 +7042,7 @@ async function ensureFrameworkBinary(frameworkId) {
       log(`Claude Code install failed: ${err.message}`);
       return;
     }
-    const brewBinDir = dirname3(brewPath);
+    const brewBinDir = dirname4(brewPath);
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
@@ -7019,26 +7055,7 @@ async function ensureFrameworkBinary(frameworkId) {
   }
   agentRuntimeAuthenticated = await checkClaudeAuth();
 }
-var CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var claudeCodeUpgradeInFlight = false;
-function claudeCodeUpgradeMarkerPath() {
-  return join15(homedir8(), ".augmented", ".last-claude-code-upgrade-check");
-}
-function stampClaudeCodeUpgradeMarker() {
-  try {
-    writeFileSync4(claudeCodeUpgradeMarkerPath(), String(Date.now()));
-  } catch {
-  }
-}
-function claudeCodeUpgradeThrottled() {
-  try {
-    const lastCheck = parseInt(readFileSync13(claudeCodeUpgradeMarkerPath(), "utf-8").trim(), 10);
-    if (!Number.isFinite(lastCheck)) return false;
-    return Date.now() - lastCheck < CLAUDE_CODE_UPGRADE_CHECK_INTERVAL_MS;
-  } catch {
-    return false;
-  }
-}
 async function maybeUpgradeClaudeCode() {
   if (claudeCodeUpgradeInFlight) return;
   if (claudeCodeUpgradeThrottled()) return;
@@ -7085,7 +7102,7 @@ ${r.stderr}`;
 }
 var UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 function selfUpdateAppliedMarkerPath() {
-  return join15(homedir8(), ".augmented", ".last-self-update-applied");
+  return join16(homedir9(), ".augmented", ".last-self-update-applied");
 }
 var selfUpdateUpToDateLogged = false;
 var restartAfterUpgrade = false;
@@ -7108,7 +7125,7 @@ async function checkAndUpdateCli() {
     const isNpmGlobal = !isBrewFormula && resolvedPath.includes("node_modules");
     if (!isBrewFormula && !isNpmGlobal) return;
     const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-    const markerPath = join15(homedir8(), ".augmented", ".last-update-check");
+    const markerPath = join16(homedir9(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -7366,13 +7383,13 @@ async function checkClaudeAuth() {
 var evalEmptyMcpConfigPath = null;
 function ensureEvalEmptyMcpConfig() {
   if (evalEmptyMcpConfigPath && existsSync9(evalEmptyMcpConfigPath)) return evalEmptyMcpConfigPath;
-  const dir = join15(homedir8(), ".augmented");
+  const dir = join16(homedir9(), ".augmented");
   try {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   } catch {
   }
-  const p = join15(dir, ".eval-empty-mcp.json");
-  writeFileSync4(p, JSON.stringify({ mcpServers: {} }));
+  const p = join16(dir, ".eval-empty-mcp.json");
+  writeFileSync5(p, JSON.stringify({ mcpServers: {} }));
   evalEmptyMcpConfigPath = p;
   return p;
 }
@@ -7397,7 +7414,7 @@ async function runEvalClaude(prompt, model) {
     ""
   ];
   const { stdout } = await execFilePromiseLong(resolveClaudeBinary(), args, {
-    cwd: homedir8(),
+    cwd: homedir9(),
     timeout: 12e4,
     stdin: "ignore",
     env: childEnv,
@@ -7446,14 +7463,14 @@ function resolveConversationEvalBackend() {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync13(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync14(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveGatewayPorts(ports) {
-  mkdirSync4(AUGMENTED_DIR, { recursive: true });
-  writeFileSync4(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+  mkdirSync5(AUGMENTED_DIR, { recursive: true });
+  writeFileSync5(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
   const ports = loadGatewayPorts();
@@ -7476,10 +7493,10 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join15(config?.configDir ?? join15(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join16(config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
 }
 function channelHashCacheDir() {
-  return config?.configDir ?? join15(process.env["HOME"] ?? "/tmp", ".augmented");
+  return config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
 }
 function loadChannelHashCache2() {
   loadChannelHashCache(agentState.knownChannelConfigHashes, channelHashCacheDir());
@@ -7490,7 +7507,7 @@ function saveChannelHashCache2() {
 var _channelQuarantineStore = null;
 function channelQuarantineStore() {
   if (!_channelQuarantineStore) {
-    const dir = config?.configDir ?? join15(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
     _channelQuarantineStore = new ChannelQuarantineStore(defaultQuarantinePath(dir));
   }
   return _channelQuarantineStore;
@@ -7498,7 +7515,7 @@ function channelQuarantineStore() {
 var _hostFlagStore = null;
 function hostFlagStore() {
   if (!_hostFlagStore) {
-    const dir = config?.configDir ?? join15(process.env["HOME"] ?? "/tmp", ".augmented");
+    const dir = config?.configDir ?? join16(process.env["HOME"] ?? "/tmp", ".augmented");
     _hostFlagStore = new HostFlagStore({ cachePath: defaultFlagsCachePath(dir), log });
   }
   return _hostFlagStore;
@@ -7549,13 +7566,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync5 } = await import("fs");
-  const skillsDir = join15(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join15(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync6, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync6 } = await import("fs");
+  const skillsDir = join16(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join16(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync6(skillsDir).sort()) {
-    const skillFile = join15(skillsDir, dir, "SKILL.md");
+    const skillFile = join16(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -7597,16 +7614,16 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync5(claudeMdPath, next, "utf-8");
+    writeFileSync6(claudeMdPath, next, "utf-8");
     log2(`Refreshed skills index in CLAUDE.md for '${codeName}' (${entries.length} skills)`);
   }
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join15(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join16(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync13(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync14(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -7619,19 +7636,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join15(homeDir, `.openclaw-${codeName}`);
-    if (existsSync9(join15(profileDir, "openclaw.json"))) continue;
+    const profileDir = join16(homeDir, `.openclaw-${codeName}`);
+    if (existsSync9(join16(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join15(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join15(profileDir, "agents", codeName, "agent");
-    const authFile = join15(sharedAuthDir, "auth-profiles.json");
+    const sharedAuthDir = join16(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join16(profileDir, "agents", codeName, "agent");
+    const authFile = join16(sharedAuthDir, "auth-profiles.json");
     if (existsSync9(authFile)) {
-      mkdirSync4(profileAuthDir, { recursive: true });
-      const authContent = readFileSync13(authFile, "utf-8");
-      writeFileSync4(join15(profileAuthDir, "auth-profiles.json"), authContent);
+      mkdirSync5(profileAuthDir, { recursive: true });
+      const authContent = readFileSync14(authFile, "utf-8");
+      writeFileSync5(join16(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -7647,7 +7664,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync13(join15(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync14(join16(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -7656,10 +7673,10 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join15(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const jobsPath = join16(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   if (!existsSync9(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync13(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync14(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
@@ -7692,19 +7709,19 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join15(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join16(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join15(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          const configPath = join16(homeDir, `.openclaw-${codeName}`, "openclaw.json");
           if (existsSync9(configPath)) {
-            const cfg = JSON.parse(readFileSync13(configPath, "utf-8"));
+            const cfg = JSON.parse(readFileSync14(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
-              writeFileSync4(configPath, JSON.stringify(cfg, null, 2));
+              writeFileSync5(configPath, JSON.stringify(cfg, null, 2));
             }
           }
         } catch {
@@ -7724,12 +7741,12 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join15(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      const configPath = join16(homeDir, `.openclaw-${codeName}`, "openclaw.json");
       if (existsSync9(configPath)) {
-        const cfg = JSON.parse(readFileSync13(configPath, "utf-8"));
+        const cfg = JSON.parse(readFileSync14(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
-        writeFileSync4(configPath, JSON.stringify(cfg, null, 2));
+        writeFileSync5(configPath, JSON.stringify(cfg, null, 2));
       }
     } catch {
     }
@@ -7929,7 +7946,7 @@ async function pollCycle() {
         claudeAuth = await detectClaudeAuth();
       } catch (err) {
         const errText = err instanceof Error ? err.message : String(err);
-        const errId = createHash6("sha256").update(errText).digest("hex").slice(0, 12);
+        const errId = createHash8("sha256").update(errText).digest("hex").slice(0, 12);
         log(`Claude auth detection failed (error_id=${errId})`);
       }
       const hostHasClaudeCode = state6.agents.some(
@@ -8289,7 +8306,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join15(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join16(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -8375,10 +8392,10 @@ async function pollCycle() {
         // pending-inbound marker. Best-effort: a write failure is logged by
         // the watchdog, never fails the poll cycle.
         signalGiveUp: (codeName) => {
-          const dir = join15(homedir8(), ".augmented", codeName);
+          const dir = join16(homedir9(), ".augmented", codeName);
           if (!existsSync9(dir)) return;
           atomicWriteFileSync(
-            join15(dir, "watchdog-give-up.json"),
+            join16(dir, "watchdog-give-up.json"),
             JSON.stringify({ gave_up_at: (/* @__PURE__ */ new Date()).toISOString() })
           );
         }
@@ -8505,7 +8522,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join15(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join16(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     if (previousKnownStatus !== agent.status) {
       log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -8709,7 +8726,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join15(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join16(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.migrateSecretStorage && !migratedSecretStorage.has(agent.code_name)) {
     try {
@@ -8750,9 +8767,9 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
     const changedFiles = [];
-    mkdirSync4(agentDir, { recursive: true });
+    mkdirSync5(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join15(agentDir, artifact.relativePath);
+      const filePath = join16(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -8771,8 +8788,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join15(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync13(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join16(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync14(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -8790,7 +8807,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync13(filePath, "utf-8");
+          existingRaw = readFileSync14(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -8812,26 +8829,26 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync9(join15(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync9(join16(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 = join15(agentDir, file.relativePath);
-        mkdirSync4(dirname3(filePath), { recursive: true });
+        const filePath = join16(agentDir, file.relativePath);
+        mkdirSync5(dirname4(filePath), { recursive: true });
         if (file.relativePath === ".mcp.json") {
           safeWriteJsonAtomic(filePath, file.content, { mode: 384 });
         } else {
-          writeFileSync4(filePath, file.content);
+          writeFileSync5(filePath, file.content);
         }
       }
       try {
-        const provSkillsDir = join15(agentDir, ".claude", "skills");
+        const provSkillsDir = join16(agentDir, ".claude", "skills");
         if (existsSync9(provSkillsDir)) {
           for (const folder of readdirSync5(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync3(join15(provSkillsDir, folder), { recursive: true });
+                rmSync3(join16(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -8844,7 +8861,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join15(agentDir, file));
+        const h = hashFile(join16(agentDir, file));
         if (h) hashes.set(file, h);
       }
       agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -8862,14 +8879,14 @@ async function processAgent(agent, agentStates) {
     }
     if (Array.isArray(refreshData.workflows)) {
       try {
-        const provWorkflowsDir = join15(agentDir, ".claude", "workflows");
+        const provWorkflowsDir = join16(agentDir, ".claude", "workflows");
         if (existsSync9(provWorkflowsDir)) {
           const expected = new Set(refreshData.workflows.map((w) => `${w.name}.js`));
           for (const file of readdirSync5(provWorkflowsDir)) {
             if (!file.endsWith(".js")) continue;
             if (expected.has(file)) continue;
             try {
-              rmSync3(join15(provWorkflowsDir, file));
+              rmSync3(join16(provWorkflowsDir, file));
             } catch {
             }
           }
@@ -8929,7 +8946,7 @@ async function processAgent(agent, agentStates) {
   if (written && existsSync9(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join15(agentDir, file));
+      const localHash = hashFile(join16(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -8940,7 +8957,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join15(agentDir, file));
+          localHashes[file] = hashFile(join16(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -9014,7 +9031,7 @@ async function processAgent(agent, agentStates) {
           const sessionModeForHash = refreshData.agent.session_mode;
           const senderPolicyForHash = refreshData.sender_policy ?? null;
           const CHANNEL_WRITE_VERSION = 9;
-          const configHash = createHash6("sha256").update(
+          const configHash = createHash8("sha256").update(
             canonicalJson({
               writeVersion: CHANNEL_WRITE_VERSION,
               config: entry.config,
@@ -9128,7 +9145,7 @@ async function processAgent(agent, agentStates) {
   if (channelConfigConverged) {
     const hasSenderPolicyChannel = currentChannelIds.has("slack") || currentChannelIds.has("msteams");
     const senderPolicyForRestartHash = refreshData.sender_policy ?? null;
-    const senderPolicyHash = createHash6("sha256").update(canonicalJson({ senderPolicy: senderPolicyForRestartHash })).digest("hex");
+    const senderPolicyHash = createHash8("sha256").update(canonicalJson({ senderPolicy: senderPolicyForRestartHash })).digest("hex");
     const prevSenderPolicyHash = agentState.knownSenderPolicyHashes.get(agent.agent_id);
     const senderPolicyDecision = hasSenderPolicyChannel ? decideSenderPolicyRestart({
       previousHash: prevSenderPolicyHash,
@@ -9170,7 +9187,7 @@ async function processAgent(agent, agentStates) {
       const behaviourSubset = extractMsTeamsBehaviourSubset(
         msteamsEntry?.config
       );
-      const behaviourHash = createHash6("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
+      const behaviourHash = createHash8("sha256").update(canonicalJson(behaviourSubset)).digest("hex");
       const prevBehaviourHash = agentState.knownMsTeamsBehaviourHashes.get(agent.agent_id);
       const behaviourDecision = decideSenderPolicyRestart({
         previousHash: prevBehaviourHash,
@@ -9217,7 +9234,7 @@ async function processAgent(agent, agentStates) {
       const slackBehaviourSubset = extractSlackBehaviourSubset(
         slackEntry?.config
       );
-      const slackBehaviourHash = createHash6("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
+      const slackBehaviourHash = createHash8("sha256").update(canonicalJson(slackBehaviourSubset)).digest("hex");
       const prevSlackBehaviourHash = agentState.knownSlackBehaviourHashes.get(agent.agent_id);
       const slackBehaviourDecision = decideSenderPolicyRestart({
         previousHash: prevSlackBehaviourHash,
@@ -9264,18 +9281,18 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join15(homedir8(), ".augmented", agent.code_name, "project");
-      mkdirSync4(agentProvisionDir, { recursive: true });
-      mkdirSync4(projectDir, { recursive: true });
-      const provisionMcpPath = join15(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join15(projectDir, ".mcp.json");
+      const projectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
+      mkdirSync5(agentProvisionDir, { recursive: true });
+      mkdirSync5(projectDir, { recursive: true });
+      const provisionMcpPath = join16(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join16(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync13(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync14(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join15(homedir8(), ".augmented", "_mcp", "direct-chat-channel.js");
+      const localDirectChatChannel = join16(homedir9(), ".augmented", "_mcp", "direct-chat-channel.js");
       const directChatTeamSettings = refreshData.team?.settings;
       const directChatTz = (() => {
         const tz = directChatTeamSettings?.["timezone"];
@@ -9305,7 +9322,7 @@ async function processAgent(agent, agentStates) {
           log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
         }
       }
-      const staleChannelsPath = join15(projectDir, ".mcp-channels.json");
+      const staleChannelsPath = join16(projectDir, ".mcp-channels.json");
       if (existsSync9(staleChannelsPath)) {
         try {
           rmSync3(staleChannelsPath, { force: true });
@@ -9370,7 +9387,7 @@ async function processAgent(agent, agentStates) {
     }
     if (process.env.AGT_CONNECTIVITY_PROBE_ENABLED === "true") {
       try {
-        const probeProjectDir = join15(homedir8(), ".augmented", agent.code_name, "project");
+        const probeProjectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
         await runAgentConnectivityProbes(agent, integrations, probeProjectDir);
       } catch (err) {
         log(`Connectivity probe failed for '${agent.code_name}': ${err.message}`);
@@ -9388,11 +9405,11 @@ async function processAgent(agent, agentStates) {
         recordConfigChurnEvent(agent.agent_id, agent.code_name, FLAP_CHANNEL_INTEGRATIONS, intMembership);
       }
       if (intHash !== prevIntHash) {
-        const projectDir = join15(homedir8(), ".augmented", agent.code_name, "project");
-        const envIntPath = join15(projectDir, ".env.integrations");
+        const projectDir = join16(homedir9(), ".augmented", agent.code_name, "project");
+        const envIntPath = join16(projectDir, ".env.integrations");
         let preWriteEnv;
         try {
-          preWriteEnv = readFileSync13(envIntPath, "utf-8");
+          preWriteEnv = readFileSync14(envIntPath, "utf-8");
         } catch {
           preWriteEnv = void 0;
         }
@@ -9404,9 +9421,9 @@ async function processAgent(agent, agentStates) {
         let rotationHandled = true;
         if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
           try {
-            const projectMcpPath = join15(projectDir, ".mcp.json");
-            const postWriteEnv = readFileSync13(envIntPath, "utf-8");
-            const mcpContent = readFileSync13(projectMcpPath, "utf-8");
+            const projectMcpPath = join16(projectDir, ".mcp.json");
+            const postWriteEnv = readFileSync14(envIntPath, "utf-8");
+            const mcpContent = readFileSync14(projectMcpPath, "utf-8");
             const changedVars = diffEnvIntegrations(preWriteEnv, postWriteEnv);
             const mcpJsonForReap = JSON.parse(mcpContent);
             const affectedServerKeys = findMcpServersUsingVars(mcpJsonForReap, changedVars);
@@ -9461,10 +9478,10 @@ async function processAgent(agent, agentStates) {
           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 = createHash6("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
+          const headersHash = createHash8("sha256").update(canonicalJson(e.headers ?? {})).digest("hex").slice(0, 16);
           return `${e.serverId}|${e.url}|${headersHash}`;
         }).join("\n");
-        const mcpHash = createHash6("sha256").update(hashBasis).digest("hex").slice(0, 16);
+        const mcpHash = createHash8("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);
@@ -9479,15 +9496,15 @@ async function processAgent(agent, agentStates) {
         if (mcpHash !== prevMcpHash) {
           for (const e of desiredEntries) {
             frameworkAdapter.writeMcpServer(agent.code_name, e.serverId, { url: e.url, headers: e.headers });
-            const urlHash = createHash6("sha256").update(e.url).digest("hex").slice(0, 12);
+            const urlHash = createHash8("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.getMcpPath) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync14 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync14(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync15 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync15(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
                     "composio_",
@@ -9588,7 +9605,7 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join15(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        const pluginPath = join16(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
         if (existsSync9(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
@@ -9613,7 +9630,7 @@ async function processAgent(agent, agentStates) {
     if (frameworkAdapter.installSkillFiles) {
       const currentIntegrationSkillIds = /* @__PURE__ */ new Set();
       const installedIntegrationSkills = [];
-      const { createHash: createHash7 } = await import("crypto");
+      const { createHash: createHash9 } = await import("crypto");
       const refreshAny = refreshData;
       const contexts = refreshAny.integration_contexts ?? refreshAny.plugin_contexts ?? [];
       const contextBySlug = /* @__PURE__ */ new Map();
@@ -9642,7 +9659,7 @@ async function processAgent(agent, agentStates) {
             )
           }));
           const bundle = buildIntegrationBundle(renderedScopes);
-          const contentHash = createHash7("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
+          const contentHash = createHash9("sha256").update(bundleFingerprint(bundle.files)).digest("hex").slice(0, 12);
           const hashKey = `plugin-skill:${agent.agent_id}:${integrationSkillId}`;
           if (agentState.knownSkillHashes.get(hashKey) === contentHash) continue;
           frameworkAdapter.installSkillFiles(agent.code_name, integrationSkillId, bundle.files);
@@ -9655,18 +9672,18 @@ async function processAgent(agent, agentStates) {
       }
       try {
         const { readdirSync: readdirSync6, rmSync: rmSync4 } = await import("fs");
-        const { homedir: homedir9 } = await import("os");
+        const { homedir: homedir10 } = await import("os");
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join15(homedir9(), ".augmented", agent.code_name, "skills"),
+          join16(homedir10(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join15(homedir9(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join16(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join15(homedir9(), `.openclaw-${agent.code_name}`, "skills"),
+          join16(homedir10(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join15(agentDir, ".claude", "skills")
+          join16(agentDir, ".claude", "skills")
         ];
         const existingDirs = candidateSkillDirs.filter((d) => existsSync9(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
@@ -9682,7 +9699,7 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join15(dir, entry);
+            const p = join16(dir, entry);
             if (existsSync9(p)) {
               rmSync4(p, { recursive: true, force: true });
             }
@@ -9701,7 +9718,7 @@ async function processAgent(agent, agentStates) {
         const plan = planGlobalSkillSync(
           refreshAny.global_skills ?? [],
           agentState.knownGlobalSkillIds.get(agent.agent_id) ?? /* @__PURE__ */ new Set(),
-          (content) => createHash7("sha256").update(content).digest("hex").slice(0, 12),
+          (content) => createHash9("sha256").update(content).digest("hex").slice(0, 12),
           (skillId) => agentState.knownSkillHashes.get(`global-skill:${agent.agent_id}:${skillId}`)
         );
         for (const { skillId, content, hash } of plan.installs) {
@@ -9711,16 +9728,16 @@ async function processAgent(agent, agentStates) {
         }
         if (plan.removes.length) {
           const { rmSync: rmSync4 } = await import("fs");
-          const { homedir: homedir9 } = await import("os");
+          const { homedir: homedir10 } = await import("os");
           const globalSkillDirs = [
-            join15(homedir9(), ".augmented", agent.code_name, "skills"),
-            join15(homedir9(), ".augmented", agent.code_name, "project", ".claude", "skills"),
-            join15(homedir9(), `.openclaw-${agent.code_name}`, "skills"),
-            join15(agentDir, ".claude", "skills")
+            join16(homedir10(), ".augmented", agent.code_name, "skills"),
+            join16(homedir10(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+            join16(homedir10(), `.openclaw-${agent.code_name}`, "skills"),
+            join16(agentDir, ".claude", "skills")
           ];
           for (const id of plan.removes) {
             for (const dir of globalSkillDirs) {
-              const p = join15(dir, id);
+              const p = join16(dir, id);
               if (existsSync9(p)) rmSync4(p, { recursive: true, force: true });
             }
             agentState.knownSkillHashes.delete(`global-skill:${agent.agent_id}:${id}`);
@@ -9745,7 +9762,7 @@ async function processAgent(agent, agentStates) {
           const slug = hook.integration_slug ?? hook.plugin_slug;
           if (!slug) continue;
           try {
-            const scriptHash = createHash7("sha256").update(hook.script).digest("hex").slice(0, 12);
+            const scriptHash = createHash9("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({
@@ -9760,9 +9777,9 @@ async function processAgent(agent, agentStates) {
             } else if (result.timedOut) {
               log(`Integration hook on_install '${slug}' TIMED OUT for '${agent.code_name}' after ${result.durationMs}ms`);
             } else {
-              const stderrHash = createHash7("sha256").update(result.stderr).digest("hex").slice(0, 12);
+              const stderrHash = createHash9("sha256").update(result.stderr).digest("hex").slice(0, 12);
               const missingCmd = result.exitCode === 127 ? extractCommandNotFound(result.stderr) : null;
-              const missingCmdHash = missingCmd ? createHash7("sha256").update(missingCmd).digest("hex").slice(0, 8) : null;
+              const missingCmdHash = missingCmd ? createHash9("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}]`
               );
@@ -9896,8 +9913,8 @@ async function processAgent(agent, agentStates) {
       const sess = getSessionState(agent.code_name);
       let mcpJsonParsed = null;
       try {
-        const mcpPath = join15(getProjectDir(agent.code_name), ".mcp.json");
-        mcpJsonParsed = JSON.parse(readFileSync13(mcpPath, "utf-8"));
+        const mcpPath = join16(getProjectDir(agent.code_name), ".mcp.json");
+        mcpJsonParsed = JSON.parse(readFileSync14(mcpPath, "utf-8"));
       } catch {
       }
       reapMissingMcpSessions({
@@ -10031,10 +10048,10 @@ async function processAgent(agent, agentStates) {
   } else if (agentFw === "claude-code" && tasks.length > 0) {
     await syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData);
   } else if (frameworkAdapter.syncScheduledTasks && gatewayRunning && gatewayPort) {
-    const stableTasksHash = createHash6("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-    const boardHash = boardItems.length > 0 ? createHash6("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 = createHash8("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+    const boardHash = boardItems.length > 0 ? createHash8("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 = createHash6("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+    const modelsHash = createHash8("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
     const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
     const prevTasksHash = agentState.knownTasksHashes.get(agent.agent_id);
     if (combinedHash !== prevTasksHash) {
@@ -10106,10 +10123,10 @@ async function processAgent(agent, agentStates) {
         lastWorkTriggerAt.set(agent.code_name, triggerTs);
         if (agentFw === "openclaw" && gatewayRunning && gatewayPort) {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const jobsPath = join15(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          const jobsPath = join16(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
           if (existsSync9(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync13(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync14(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -10246,7 +10263,7 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
   if (trackedFiles.length > 0 && existsSync9(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join15(agentDir, file));
+      const h = hashFile(join16(agentDir, file));
       if (h) hashes.set(file, h);
     }
     agentState.writtenHashes.set(agent.agent_id, hashes);
@@ -10280,19 +10297,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join15(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join16(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join15(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join16(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join15(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join16(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join15(sessionsDir, "sessions.json");
+  const indexPath = join16(sessionsDir, "sessions.json");
   if (!existsSync9(indexPath)) return;
   try {
-    const raw = readFileSync13(indexPath, "utf-8");
+    const raw = readFileSync14(indexPath, "utf-8");
     const index = JSON.parse(raw);
     const cronRunKeys = Object.keys(index).filter((k) => k.includes(":cron:") && k.includes(":run:")).map((k) => ({
       key: k,
@@ -10305,7 +10322,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join15(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join16(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
           if (existsSync9(sessionFile)) {
             unlinkSync(sessionFile);
@@ -10327,7 +10344,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join15(sessionsDir, `${parentSessionId}.jsonl`);
+            const f = join16(sessionsDir, `${parentSessionId}.jsonl`);
             if (existsSync9(f)) {
               unlinkSync(f);
               deletedFiles++;
@@ -10337,7 +10354,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         }
       }
     }
-    writeFileSync4(indexPath, JSON.stringify(index));
+    writeFileSync5(indexPath, JSON.stringify(index));
     if (toDelete.length > 0) {
       log(`Cleaned ${toDelete.length} cron session(s) and ${deletedFiles} file(s) from ${sessionsDir}`);
     }
@@ -10348,7 +10365,7 @@ var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
   if (!existsSync9(jobsPath)) return;
   try {
-    const raw = readFileSync13(jobsPath, "utf-8");
+    const raw = readFileSync14(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
@@ -10373,7 +10390,7 @@ function clearStaleCronRunState(jobsPath) {
       }
     }
     if (changed) {
-      writeFileSync4(jobsPath, JSON.stringify(data, null, 2));
+      writeFileSync5(jobsPath, JSON.stringify(data, null, 2));
     }
   } catch {
   }
@@ -10385,7 +10402,7 @@ function cleanupOldFiles(dir, maxAgeDays, ext) {
   try {
     for (const f of readdirSync5(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join15(dir, f);
+      const fullPath = join16(dir, f);
       try {
         const st = statSync4(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -10407,8 +10424,8 @@ var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join15(projectDir, ".mcp.json");
-  const claudeMdPath = join15(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join16(projectDir, ".mcp.json");
+  const claudeMdPath = join16(projectDir, "CLAUDE.md");
   if (restartBreaker.isTripped(codeName)) {
     const trip = restartBreaker.getTrip(codeName);
     return {
@@ -10525,7 +10542,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:${createHash6("sha256").update(ctx.tail).digest("hex").slice(0, 12)} (raw at ~/.augmented/${codeName}/pane.log)`;
+${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash8("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(
@@ -10539,7 +10556,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash6("sha256").
       );
       getHostId().then((hostId) => {
         if (!hostId) return;
-        const paneTailHash = zombie.paneTail ? `sha256:${createHash6("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
+        const paneTailHash = zombie.paneTail ? `sha256:${createHash8("sha256").update(zombie.paneTail).digest("hex").slice(0, 12)}` : null;
         return api.post("/host/events", {
           host_id: hostId,
           agent_code_name: codeName,
@@ -10618,7 +10635,7 @@ ${truncateForLog(ctx.tail)}` : `; pane_tail_hash=sha256:${createHash6("sha256").
   if (!claudeAuthTupleBySession.has(codeName)) {
     claudeAuthTupleBySession.set(codeName, currentAuthTuple);
   }
-  const stableTasksHash = createHash6("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const stableTasksHash = createHash8("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));
@@ -11007,9 +11024,9 @@ async function processDirectChatMessage(agent, msg) {
   if (isSessionHealthy(agent.codeName)) {
     if (hostFlagStore().getBoolean("direct-chat-doorbell")) {
       try {
-        const doorbell = directChatDoorbellPath(agent.agentId, homedir8());
-        mkdirSync4(dirname3(doorbell), { recursive: true });
-        writeFileSync4(doorbell, String(Date.now()));
+        const doorbell = directChatDoorbellPath(agent.agentId, homedir9());
+        mkdirSync5(dirname4(doorbell), { recursive: true });
+        writeFileSync5(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) {
@@ -11053,11 +11070,11 @@ ${escapeXml(msg.content)}
       log(`[direct-chat] One-shot spawn for '${agent.codeName}' (msg=${msg.id}; host in-flight=${directChatSpawnGate.hostInFlight}, queued=${directChatSpawnGate.queuedCount})`);
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-FATCLHDM.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join15(projDir, ".mcp.json");
+      const mcpConfigPath = join16(projDir, ".mcp.json");
       const serverNames = [];
       if (existsSync9(mcpConfigPath)) {
         try {
-          const d = JSON.parse(readFileSync13(mcpConfigPath, "utf-8"));
+          const d = JSON.parse(readFileSync14(mcpConfigPath, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -11076,15 +11093,15 @@ ${escapeXml(msg.content)}
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join15(projDir, "CLAUDE.md");
+      const chatClaudeMd = join16(projDir, "CLAUDE.md");
       if (existsSync9(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join15(projDir, ".env.integrations");
+      const envIntPath = join16(projDir, ".env.integrations");
       const childEnv = { ...process.env };
       if (existsSync9(envIntPath)) {
         try {
-          Object.assign(childEnv, parseEnvIntegrations(readFileSync13(envIntPath, "utf-8")));
+          Object.assign(childEnv, parseEnvIntegrations(readFileSync14(envIntPath, "utf-8")));
         } catch {
         }
       }
@@ -11144,7 +11161,7 @@ ${escapeXml(msg.content)}
     log(`[direct-chat] Reply sent for '${agent.codeName}'`);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
-    const errorId = createHash6("sha256").update(errMsg).digest("hex").slice(0, 12);
+    const errorId = createHash8("sha256").update(errMsg).digest("hex").slice(0, 12);
     log(`[direct-chat] Failed to process message for '${agent.codeName}': error_id=${errorId} error=${errMsg.slice(0, 500)}`);
     try {
       await api.post("/host/direct-chat/reply", {
@@ -11680,8 +11697,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join15(configDir, agent.code_name, "project");
-  const memoryDir = join15(projectDir, "memory");
+  const projectDir = join16(configDir, agent.code_name, "project");
+  const memoryDir = join16(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`);
@@ -11699,8 +11716,8 @@ async function syncMemories(agent, configDir, log2) {
     for (const file of readdirSync5(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync13(join15(memoryDir, file), "utf-8");
-        const fileHash = createHash6("sha256").update(raw).digest("hex").slice(0, 16);
+        const raw = readFileSync14(join16(memoryDir, file), "utf-8");
+        const fileHash = createHash8("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$/, ""));
@@ -11724,7 +11741,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync13(join15(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync14(join16(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -11738,28 +11755,28 @@ async function syncMemories(agent, configDir, log2) {
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
   const localFiles = existsSync9(memoryDir) ? readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
-  const localListHash = createHash6("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
+  const localListHash = createHash8("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
   try {
     const dbMemories = await api.post("/host/memories", {
       agent_id: agent.agent_id
     });
-    const responseHash = createHash6("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
+    const responseHash = createHash8("sha256").update(JSON.stringify(dbMemories.memories ?? [])).digest("hex").slice(0, 16);
     if (!force && prevDownload && prevLocalHash === localListHash && lastDownloadHash.get(agent.agent_id) === responseHash) {
       return true;
     }
     lastDownloadHash.set(agent.agent_id, responseHash);
     lastLocalFileHash.set(agent.agent_id, localListHash);
     if (dbMemories.memories?.length) {
-      mkdirSync4(memoryDir, { recursive: true });
+      mkdirSync5(memoryDir, { recursive: true });
       let written = 0;
       let overwritten = 0;
       for (let i = 0; i < dbMemories.memories.length; i++) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join15(memoryDir, `${slug}.md`);
+        const filePath = join16(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -11771,20 +11788,20 @@ ${mem.content}
         if (existsSync9(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync13(filePath, "utf-8");
+            existing = readFileSync14(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync4(filePath, desired);
+          writeFileSync5(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync4(filePath, desired);
+          writeFileSync5(filePath, desired);
           written++;
         }
       }
       if (written > 0 || overwritten > 0) {
         const updatedFiles = readdirSync5(memoryDir).filter((f) => f.endsWith(".md")).sort();
-        lastLocalFileHash.set(agent.agent_id, createHash6("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
+        lastLocalFileHash.set(agent.agent_id, createHash8("sha256").update(updatedFiles.join(",")).digest("hex").slice(0, 16));
         log2(`Memory download for '${agent.code_name}': wrote ${written} new, overwrote ${overwritten} stale`);
       }
     }
@@ -12046,7 +12063,7 @@ function startManager(opts) {
   try {
     const stateFile = getStateFile();
     if (existsSync9(stateFile)) {
-      const raw = readFileSync13(stateFile, "utf-8");
+      const raw = readFileSync14(stateFile, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.agents)) {
         state6.agents = parsed.agents;
@@ -12067,7 +12084,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=${join15(homedir8(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join16(homedir9(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   reapOrphanChannelMcps({ log });
@@ -12088,7 +12105,7 @@ async function reapOrphanedClaudePids() {
   const looksLikeClaude = (pid) => {
     if (process.platform !== "linux") return true;
     try {
-      const comm = readFileSync13(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
+      const comm = readFileSync14(`/proc/${pid}/comm`, "utf-8").trim().toLowerCase();
       return comm.includes("claude");
     } catch {
       return false;
@@ -12198,18 +12215,18 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join15(homedir8(), ".augmented", "_mcp");
-  mkdirSync4(targetDir, { recursive: true });
-  const moduleDir = dirname3(fileURLToPath(import.meta.url));
+  const targetDir = join16(homedir9(), ".augmented", "_mcp");
+  mkdirSync5(targetDir, { recursive: true });
+  const moduleDir = dirname4(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join15(dir, "dist", "mcp");
-    if (existsSync9(join15(candidate, "index.js"))) {
+    const candidate = join16(dir, "dist", "mcp");
+    if (existsSync9(join16(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -12221,7 +12238,7 @@ function deployMcpAssets() {
   const fileHash = (p) => {
     try {
       if (!existsSync9(p)) return null;
-      return createHash6("sha256").update(readFileSync13(p)).digest("hex");
+      return createHash8("sha256").update(readFileSync14(p)).digest("hex");
     } catch {
       return null;
     }
@@ -12248,8 +12265,8 @@ function deployMcpAssets() {
     // natural session restart.
     "augmented-admin.js"
   ]) {
-    const src = join15(mcpSourceDir, file);
-    const dst = join15(targetDir, file);
+    const src = join16(mcpSourceDir, file);
+    const dst = join16(targetDir, file);
     if (!existsSync9(src)) continue;
     const before = fileHash(dst);
     try {
@@ -12267,23 +12284,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join15(targetDir, "index.js");
+  const localMcpPath = join16(targetDir, "index.js");
   try {
-    const agentsDir = join15(homedir8(), ".augmented", "agents");
+    const agentsDir = join16(homedir9(), ".augmented", "agents");
     if (existsSync9(agentsDir)) {
       for (const entry of readdirSync5(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join15(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join16(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync13(mcpJsonPath, "utf-8");
+            const raw = readFileSync14(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];
-            writeFileSync4(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync5(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }