@integrity-labs/agt-cli 0.19.2 → 0.19.4

package/dist/lib/manager-worker.js

@@ -22,7 +22,7 @@ import {
   resolveChannels,
   resolveDmTarget,
   wrapScheduledTaskPrompt
-} from "../chunk-BEIZXSG4.js";
+} from "../chunk-MC3SMG4A.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -51,10 +51,10 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, appendFileSync, mkdirSync as mkdirSync2, chmodSync, existsSync as existsSync2, rmSync as rmSync2, readdirSync as readdirSync2, statSync, unlinkSync, copyFileSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync2, chmodSync, existsSync as existsSync3, rmSync as rmSync2, readdirSync as readdirSync2, statSync, unlinkSync, copyFileSync } from "fs";
 import https from "https";
 import { execFileSync as syncExecFile } from "child_process";
-import { join as join3, dirname } from "path";
+import { join as join4, dirname } from "path";
 import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 
@@ -588,6 +588,37 @@ function normalize(value) {
   return sorted;
 }
 
+// src/lib/channel-hash-cache.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var CACHE_FILENAME = "channel-hash-cache.json";
+function getChannelHashCacheFile(configDir) {
+  return join2(configDir, CACHE_FILENAME);
+}
+function loadChannelHashCache(target, configDir) {
+  const path = getChannelHashCacheFile(configDir);
+  if (!existsSync(path)) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string" && value.length > 0) target.set(key, value);
+  }
+}
+function saveChannelHashCache(source, configDir) {
+  const path = getChannelHashCacheFile(configDir);
+  const obj = {};
+  for (const [key, value] of source) obj[key] = value;
+  try {
+    writeFileSync(path, JSON.stringify(obj, null, 2));
+  } catch {
+  }
+}
+
 // src/lib/channel-sweep.ts
 import { execFileSync } from "child_process";
 var CHANNEL_BASENAMES = [
@@ -838,6 +869,108 @@ function killAgentChannelProcesses(codeName, opts) {
   return pids;
 }
 
+// src/lib/channel-input-watchdog.ts
+var STUCK_THRESHOLD_MS = 5e3;
+var ATTACHED_STUCK_THRESHOLD_MS = 15e3;
+var INPUT_BOX_DIVIDER = /^[─━]{10,}/;
+var PROMPT_PREFIX = "\u276F ";
+function decide(pane, prev, now, config2 = {}) {
+  const threshold = config2.stuckThresholdMs ?? STUCK_THRESHOLD_MS;
+  const inputText = extractInputBoxText(pane);
+  if (!inputText) {
+    return { fire: false, next: void 0 };
+  }
+  if (isActivelyProcessing(pane)) {
+    return { fire: false, next: prev };
+  }
+  const hash = simpleHash(inputText);
+  if (!prev || prev.lastInputHash !== hash) {
+    return {
+      fire: false,
+      next: { lastInputHash: hash, firstSeenAt: now, resolved: false }
+    };
+  }
+  if (prev.resolved) return { fire: false, next: prev };
+  if (now - prev.firstSeenAt < threshold) return { fire: false, next: prev };
+  return {
+    fire: true,
+    next: { ...prev, resolved: true }
+  };
+}
+function extractInputBoxText(pane) {
+  const lines = pane.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!line.startsWith(PROMPT_PREFIX)) continue;
+    let j = i - 1;
+    while (j >= 0 && (lines[j] ?? "").trim() === "") j--;
+    if (j < 0) continue;
+    if (!INPUT_BOX_DIVIDER.test((lines[j] ?? "").trim())) continue;
+    const text = line.slice(PROMPT_PREFIX.length).trim();
+    return text.length > 0 ? text : null;
+  }
+  return null;
+}
+function isActivelyProcessing(pane) {
+  const lines = pane.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = (lines[i] ?? "").trim();
+    if (!line.startsWith("\u273B")) continue;
+    if (/\bfor\s+\d+s\s*$/.test(line)) return false;
+    if (/\b\w+ing[…\.]{0,3}\s*$/i.test(line)) return true;
+    return false;
+  }
+  return false;
+}
+function simpleHash(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return h.toString(16);
+}
+function checkChannelInputs(codeNames, io, config2 = {}, states = sharedStates) {
+  const live = new Set(codeNames);
+  for (const codeName of codeNames) {
+    try {
+      checkOne(codeName, io, config2, states);
+    } catch (err) {
+      io.log(`[channel-input-watchdog] '${codeName}': ${err.message}`);
+    }
+  }
+  for (const key of [...states.keys()]) {
+    if (!live.has(key)) states.delete(key);
+  }
+}
+function checkOne(codeName, io, config2, states) {
+  const pane = io.capturePane(codeName);
+  if (!pane) {
+    states.delete(codeName);
+    return;
+  }
+  const attached = io.isClientAttached(codeName);
+  const effectiveConfig = attached ? {
+    ...config2,
+    stuckThresholdMs: config2.attachedStuckThresholdMs ?? ATTACHED_STUCK_THRESHOLD_MS
+  } : config2;
+  const prev = states.get(codeName);
+  const { fire, next } = decide(pane, prev, io.now(), effectiveConfig);
+  if (next === void 0) {
+    states.delete(codeName);
+  } else {
+    states.set(codeName, next);
+  }
+  if (fire) {
+    const text = extractInputBoxText(pane) ?? "";
+    const hash = next?.lastInputHash ?? simpleHash(text);
+    io.log(
+      `[channel-input-watchdog] '${codeName}': stuck channel input \u2014 firing Enter (input_hash=${hash}, len=${text.length})`
+    );
+    io.sendEnter(codeName);
+  }
+}
+var sharedStates = /* @__PURE__ */ new Map();
+
 // src/lib/delivery-hint.ts
 var DEFAULT_PROBABILITY = 0.1;
 function envSuffixFor(codeName) {
@@ -940,24 +1073,24 @@ function withScheduleLinkFooter(opts) {
 }
 
 // src/lib/restart-flags.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { randomUUID } from "crypto";
 function restartFlagsDir() {
-  return join2(homedir2(), ".augmented", "restart-flags");
+  return join3(homedir2(), ".augmented", "restart-flags");
 }
 function flagPath(codeName) {
-  return join2(restartFlagsDir(), `${codeName}.flag`);
+  return join3(restartFlagsDir(), `${codeName}.flag`);
 }
 function readRestartFlags() {
   const dir = restartFlagsDir();
-  if (!existsSync(dir)) return [];
+  if (!existsSync2(dir)) return [];
   const out = [];
   for (const entry of readdirSync(dir)) {
     if (!entry.endsWith(".flag")) continue;
     try {
-      const raw = readFileSync(join2(dir, entry), "utf8");
+      const raw = readFileSync2(join3(dir, entry), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.codeName !== "string" || parsed.codeName.length === 0) {
         parsed.codeName = entry.replace(/\.flag$/, "");
@@ -975,7 +1108,7 @@ function readRestartFlags() {
 }
 function deleteRestartFlag(codeName) {
   const path = flagPath(codeName);
-  if (existsSync(path)) {
+  if (existsSync2(path)) {
     rmSync(path, { force: true });
   }
 }
@@ -1392,8 +1525,8 @@ function stopRealtimeChat() {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join3(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join3(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join4(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join4(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;
@@ -1471,9 +1604,14 @@ function clearAgentCaches(agentId, codeName) {
   memoryFileHashes.delete(agentId);
   lastDownloadHash.delete(agentId);
   lastLocalFileHash.delete(agentId);
+  let channelCacheMutated = false;
   for (const key of knownChannelConfigHashes.keys()) {
-    if (key.startsWith(`${agentId}:`)) knownChannelConfigHashes.delete(key);
+    if (key.startsWith(`${agentId}:`)) {
+      knownChannelConfigHashes.delete(key);
+      channelCacheMutated = true;
+    }
   }
+  if (channelCacheMutated) saveChannelHashCache2();
   for (const key of knownSkillHashes.keys()) {
     if (key.startsWith(`${agentId}:`)) knownSkillHashes.delete(key);
   }
@@ -1484,7 +1622,7 @@ function clearAgentCaches(agentId, codeName) {
 var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
-var agtCliVersion = true ? "0.19.2" : "dev";
+var agtCliVersion = true ? "0.19.4" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
@@ -1497,7 +1635,7 @@ function resolveBrewPath(execFileSync2) {
     "/usr/local/bin/brew"
   ];
   for (const path of fallbacks) {
-    if (existsSync2(path)) return path;
+    if (existsSync3(path)) return path;
   }
   return null;
 }
@@ -1658,7 +1796,7 @@ async function ensureFrameworkBinary(frameworkId) {
     }
     return runAsync(brewPath, args, opts);
   };
-  let claudeExists = existsSync2("/home/linuxbrew/.linuxbrew/bin/claude");
+  let claudeExists = existsSync3("/home/linuxbrew/.linuxbrew/bin/claude");
   if (!claudeExists) {
     try {
       execFileSync2("which", ["claude"], { timeout: 5e3 });
@@ -1682,7 +1820,7 @@ async function ensureFrameworkBinary(frameworkId) {
     if (!process.env.PATH?.split(":").includes(brewBinDir)) {
       process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
     }
-    if (existsSync2("/home/linuxbrew/.linuxbrew/bin/claude")) {
+    if (existsSync3("/home/linuxbrew/.linuxbrew/bin/claude")) {
       log("Claude Code installed successfully");
     } else {
       log("Claude Code install completed but binary not found at expected path \u2014 check brew logs");
@@ -1729,7 +1867,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 = join3(homedir3(), ".augmented", ".last-update-check");
+    const markerPath = join4(homedir3(), ".augmented", ".last-update-check");
     try {
       const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
       if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
@@ -1891,10 +2029,10 @@ 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 = join3(homedir3(), ".claude");
+    const claudeDir = join4(homedir3(), ".claude");
     for (const filename of [".credentials.json", "credentials.json"]) {
-      const p = join3(claudeDir, filename);
-      if (existsSync2(p)) {
+      const p = join4(claudeDir, filename);
+      if (existsSync3(p)) {
         try {
           rmSync2(p, { force: true });
           log(`[${label}] Removed ${p} (api_key mode \u2014 preventing OAuth fallback)`);
@@ -1908,14 +2046,14 @@ async function applyClaudeAuthToEnv(childEnv, label) {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync2(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync3(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveGatewayPorts(ports) {
   mkdirSync2(AUGMENTED_DIR, { recursive: true });
-  writeFileSync2(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+  writeFileSync3(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
   const ports = loadGatewayPorts();
@@ -1938,12 +2076,21 @@ function freePort(codeName) {
   }
 }
 function getStateFile() {
-  return join3(config?.configDir ?? join3(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+  return join4(config?.configDir ?? join4(process.env["HOME"] ?? "/tmp", ".augmented"), "manager-state.json");
+}
+function channelHashCacheDir() {
+  return config?.configDir ?? join4(process.env["HOME"] ?? "/tmp", ".augmented");
+}
+function loadChannelHashCache2() {
+  loadChannelHashCache(knownChannelConfigHashes, channelHashCacheDir());
+}
+function saveChannelHashCache2() {
+  saveChannelHashCache(knownChannelConfigHashes, channelHashCacheDir());
 }
 function send(msg) {
   if (msg.type === "state-update") {
     try {
-      writeFileSync2(getStateFile(), JSON.stringify(msg.state, null, 2));
+      writeFileSync3(getStateFile(), JSON.stringify(msg.state, null, 2));
     } catch {
     }
   }
@@ -1974,9 +2121,9 @@ function log(msg) {
 `;
   if (!managerLogPath) {
     try {
-      managerLogPath = join3(homedir3(), ".augmented", "manager.log");
+      managerLogPath = join4(homedir3(), ".augmented", "manager.log");
       mkdirSync2(dirname(managerLogPath), { recursive: true });
-      if (existsSync2(managerLogPath)) {
+      if (existsSync3(managerLogPath)) {
         chmodSync(managerLogPath, 384);
       }
     } catch {
@@ -2004,7 +2151,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -2028,13 +2175,13 @@ function parseSkillFrontmatter(content) {
   return out;
 }
 async function refreshSkillsIndexInClaudeMd(configDir, codeName, log2) {
-  const { readdirSync: readdirSync3, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync3 } = await import("fs");
-  const skillsDir = join3(configDir, codeName, "project", ".claude", "skills");
-  const claudeMdPath = join3(configDir, codeName, "project", "CLAUDE.md");
+  const { readdirSync: readdirSync3, readFileSync: rfs, existsSync: ex, writeFileSync: writeFileSync4 } = await import("fs");
+  const skillsDir = join4(configDir, codeName, "project", ".claude", "skills");
+  const claudeMdPath = join4(configDir, codeName, "project", "CLAUDE.md");
   if (!ex(skillsDir) || !ex(claudeMdPath)) return;
   const entries = [];
   for (const dir of readdirSync3(skillsDir).sort()) {
-    const skillFile = join3(skillsDir, dir, "SKILL.md");
+    const skillFile = join4(skillsDir, dir, "SKILL.md");
     if (!ex(skillFile)) continue;
     try {
       const { name, description } = parseSkillFrontmatter(rfs(skillFile, "utf-8"));
@@ -2076,16 +2223,16 @@ ${SKILLS_INDEX_END}`;
     next = current.trimEnd() + "\n\n" + section + "\n";
   }
   if (next !== current) {
-    writeFileSync3(claudeMdPath, next, "utf-8");
+    writeFileSync4(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 = join3(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join4(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync2(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync3(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -2098,19 +2245,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join3(homeDir, `.openclaw-${codeName}`);
-    if (existsSync2(join3(profileDir, "openclaw.json"))) continue;
+    const profileDir = join4(homeDir, `.openclaw-${codeName}`);
+    if (existsSync3(join4(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join3(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join3(profileDir, "agents", codeName, "agent");
-    const authFile = join3(sharedAuthDir, "auth-profiles.json");
-    if (existsSync2(authFile)) {
+    const sharedAuthDir = join4(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join4(profileDir, "agents", codeName, "agent");
+    const authFile = join4(sharedAuthDir, "auth-profiles.json");
+    if (existsSync3(authFile)) {
       mkdirSync2(profileAuthDir, { recursive: true });
-      const authContent = readFileSync2(authFile, "utf-8");
-      writeFileSync2(join3(profileAuthDir, "auth-profiles.json"), authContent);
+      const authContent = readFileSync3(authFile, "utf-8");
+      writeFileSync3(join4(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -2148,7 +2295,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync2(join3(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync3(join4(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -2157,10 +2304,10 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join3(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
-  if (!existsSync2(jobsPath)) return false;
+  const jobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  if (!existsSync3(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync3(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
@@ -2193,19 +2340,19 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join3(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join3(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-          if (existsSync2(configPath)) {
-            const cfg = JSON.parse(readFileSync2(configPath, "utf-8"));
+          const configPath = join4(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          if (existsSync3(configPath)) {
+            const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
-              writeFileSync2(configPath, JSON.stringify(cfg, null, 2));
+              writeFileSync3(configPath, JSON.stringify(cfg, null, 2));
             }
           }
         } catch {
@@ -2225,12 +2372,12 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join3(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-      if (existsSync2(configPath)) {
-        const cfg = JSON.parse(readFileSync2(configPath, "utf-8"));
+      const configPath = join4(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      if (existsSync3(configPath)) {
+        const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
-        writeFileSync2(configPath, JSON.stringify(cfg, null, 2));
+        writeFileSync3(configPath, JSON.stringify(cfg, null, 2));
       }
     } catch {
     }
@@ -2486,7 +2633,7 @@ async function pollCycle() {
         }
         killAgentChannelProcesses(prev.codeName, { log });
         freePort(prev.codeName);
-        const agentDir = join3(adapter.getAgentDir(prev.codeName), "provision");
+        const agentDir = join4(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -2511,6 +2658,43 @@ async function pollCycle() {
         log(`[channel-sweep] sweep error: ${err.message}`);
       });
     }
+    {
+      const claudeCodeAgents = agentStates.filter((a) => a.status === "active").filter((a) => (agentFrameworkCache.get(a.codeName) ?? "openclaw") === "claude-code").map((a) => a.codeName);
+      checkChannelInputs(claudeCodeAgents, {
+        capturePane: (codeName) => {
+          try {
+            return syncExecFile("tmux", ["capture-pane", "-t", `agt-${codeName}`, "-p"], {
+              stdio: ["ignore", "pipe", "ignore"],
+              timeout: 2e3
+            }).toString();
+          } catch {
+            return null;
+          }
+        },
+        isClientAttached: (codeName) => {
+          try {
+            const out = syncExecFile("tmux", ["list-clients", "-t", `agt-${codeName}`], {
+              stdio: ["ignore", "pipe", "ignore"],
+              timeout: 2e3
+            }).toString();
+            return out.trim().length > 0;
+          } catch {
+            return true;
+          }
+        },
+        sendEnter: (codeName) => {
+          try {
+            syncExecFile("tmux", ["send-keys", "-t", `agt-${codeName}`, "Enter"], {
+              stdio: "ignore",
+              timeout: 2e3
+            });
+          } catch {
+          }
+        },
+        log,
+        now: () => Date.now()
+      });
+    }
     const lastHealthCheck = lastHarvestAt.get("__cron_health__") ?? 0;
     if (Date.now() - lastHealthCheck >= HARVEST_INTERVAL_MS) {
       lastHarvestAt.set("__cron_health__", Date.now());
@@ -2574,7 +2758,7 @@ async function processAgent(agent, agentStates) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const adapter = resolveAgentFramework(agent.code_name);
-  let agentDir = join3(adapter.getAgentDir(agent.code_name), "provision");
+  let agentDir = join4(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
     await stopGatewayIfRunning(agent.code_name, adapter);
@@ -2639,9 +2823,14 @@ async function processAgent(agent, agentStates) {
   if (previousStatus && previousStatus !== agent.status) {
     log(`Agent '${agent.code_name}' status changed: ${previousStatus} \u2192 ${agent.status}`);
     knownVersions.delete(agent.agent_id);
+    let channelCacheMutated = false;
     for (const key of knownChannelConfigHashes.keys()) {
-      if (key.startsWith(`${agent.agent_id}:`)) knownChannelConfigHashes.delete(key);
+      if (key.startsWith(`${agent.agent_id}:`)) {
+        knownChannelConfigHashes.delete(key);
+        channelCacheMutated = true;
+      }
     }
+    if (channelCacheMutated) saveChannelHashCache2();
   }
   knownStatuses.set(agent.agent_id, agent.status);
   let refreshData;
@@ -2699,7 +2888,7 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
-  agentDir = join3(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  agentDir = join4(frameworkAdapter.getAgentDir(agent.code_name), "provision");
   cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.seedProfileConfig) {
     frameworkAdapter.seedProfileConfig(agent.code_name);
@@ -2729,7 +2918,7 @@ async function processAgent(agent, agentStates) {
     const changedFiles = [];
     mkdirSync2(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join3(agentDir, artifact.relativePath);
+      const filePath = join4(agentDir, artifact.relativePath);
       let existingHash;
       let newHash;
       let writeContent = artifact.content;
@@ -2741,8 +2930,8 @@ async function processAgent(agent, agentStates) {
         };
         newHash = sha256(stripDynamicSections(artifact.content));
         try {
-          const projectClaudeMd = join3(config.configDir, agent.code_name, "project", "CLAUDE.md");
-          const existing = readFileSync2(projectClaudeMd, "utf-8");
+          const projectClaudeMd = join4(config.configDir, agent.code_name, "project", "CLAUDE.md");
+          const existing = readFileSync3(projectClaudeMd, "utf-8");
           existingHash = sha256(stripDynamicSections(existing));
         } catch {
           existingHash = null;
@@ -2760,7 +2949,7 @@ async function processAgent(agent, agentStates) {
         const generatorKeys = Object.keys(generatorServers);
         let existingRaw = "";
         try {
-          existingRaw = readFileSync2(filePath, "utf-8");
+          existingRaw = readFileSync3(filePath, "utf-8");
         } catch {
         }
         const existingServers = parseMcp(existingRaw);
@@ -2782,22 +2971,22 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync2(join3(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync3(join4(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 = join3(agentDir, file.relativePath);
+        const filePath = join4(agentDir, file.relativePath);
         mkdirSync2(dirname(filePath), { recursive: true });
-        writeFileSync2(filePath, file.content);
+        writeFileSync3(filePath, file.content);
       }
       try {
-        const provSkillsDir = join3(agentDir, ".claude", "skills");
-        if (existsSync2(provSkillsDir)) {
+        const provSkillsDir = join4(agentDir, ".claude", "skills");
+        if (existsSync3(provSkillsDir)) {
           for (const folder of readdirSync2(provSkillsDir)) {
             if (folder.startsWith("knowledge-")) {
               try {
-                rmSync2(join3(provSkillsDir, folder), { recursive: true });
+                rmSync2(join4(provSkillsDir, folder), { recursive: true });
               } catch {
               }
             }
@@ -2810,7 +2999,7 @@ async function processAgent(agent, agentStates) {
       const trackedFiles2 = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles2) {
-        const h = hashFile(join3(agentDir, file));
+        const h = hashFile(join4(agentDir, file));
         if (h) hashes.set(file, h);
       }
       writtenHashes.set(agent.agent_id, hashes);
@@ -2854,10 +3043,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = writtenHashes.get(agent.agent_id);
-  if (written && existsSync2(agentDir)) {
+  if (written && existsSync3(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join3(agentDir, file));
+      const localHash = hashFile(join4(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -2868,7 +3057,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join3(agentDir, file));
+          localHashes[file] = hashFile(join4(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -2933,6 +3122,7 @@ async function processAgent(agent, agentStates) {
             const sessionMode2 = refreshData.agent.session_mode;
             frameworkAdapter.writeChannelCredentials(agent.code_name, channelId, entry.config, { sessionMode: sessionMode2, agentId: agent.agent_id });
             knownChannelConfigHashes.set(cacheKey, configHash);
+            saveChannelHashCache2();
             log(`Channel credentials written for '${agent.code_name}/${channelId}' (reason=${reason}, hash=${configHash.slice(0, 8)}${prevHash ? `, prev=${prevHash.slice(0, 8)}` : ""})`);
           } catch (err) {
             log(`Failed to write channel credentials for '${agent.code_name}/${channelId}': ${err.message}`);
@@ -2951,19 +3141,19 @@ async function processAgent(agent, agentStates) {
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
       const agentProvisionDir = agentDir;
-      const projectDir = join3(homedir3(), ".augmented", agent.code_name, "project");
+      const projectDir = join4(homedir3(), ".augmented", agent.code_name, "project");
       mkdirSync2(agentProvisionDir, { recursive: true });
       mkdirSync2(projectDir, { recursive: true });
-      const provisionMcpPath = join3(agentProvisionDir, ".mcp.json");
-      const projectMcpPath = join3(projectDir, ".mcp.json");
+      const provisionMcpPath = join4(agentProvisionDir, ".mcp.json");
+      const projectMcpPath = join4(projectDir, ".mcp.json");
       let mcpConfig = { mcpServers: {} };
       try {
-        mcpConfig = JSON.parse(readFileSync2(provisionMcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync3(provisionMcpPath, "utf-8"));
         if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
       } catch {
       }
-      const localDirectChatChannel = join3(homedir3(), ".augmented", "_mcp", "direct-chat-channel.js");
-      if (existsSync2(localDirectChatChannel) && !mcpConfig.mcpServers["direct-chat"]) {
+      const localDirectChatChannel = join4(homedir3(), ".augmented", "_mcp", "direct-chat-channel.js");
+      if (existsSync3(localDirectChatChannel) && !mcpConfig.mcpServers["direct-chat"]) {
         mcpConfig.mcpServers["direct-chat"] = {
           command: "node",
           args: [localDirectChatChannel],
@@ -2974,12 +3164,12 @@ async function processAgent(agent, agentStates) {
           }
         };
         const serialized = JSON.stringify(mcpConfig, null, 2);
-        writeFileSync2(provisionMcpPath, serialized);
-        writeFileSync2(projectMcpPath, serialized);
+        writeFileSync3(provisionMcpPath, serialized);
+        writeFileSync3(projectMcpPath, serialized);
         log(`Channel credentials written for '${agent.code_name}/direct-chat'`);
       }
-      const staleChannelsPath = join3(projectDir, ".mcp-channels.json");
-      if (existsSync2(staleChannelsPath)) {
+      const staleChannelsPath = join4(projectDir, ".mcp-channels.json");
+      if (existsSync3(staleChannelsPath)) {
         try {
           rmSync2(staleChannelsPath, { force: true });
         } catch {
@@ -3094,8 +3284,8 @@ async function processAgent(agent, agentStates) {
             const mcpPath = frameworkAdapter.getMcpPath(agent.code_name);
             if (mcpPath) {
               try {
-                const { readFileSync: readFileSync3 } = await import("fs");
-                const mcpConfig = JSON.parse(readFileSync3(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync4 } = await import("fs");
+                const mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
                     "composio_",
@@ -3187,8 +3377,8 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join3(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
-        if (existsSync2(pluginPath)) {
+        const pluginPath = join4(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        if (existsSync3(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
             agtApiKey: getApiKey() ?? void 0,
@@ -3258,16 +3448,16 @@ async function processAgent(agent, agentStates) {
         const frameworkId2 = frameworkAdapter.id;
         const candidateSkillDirs = [
           // Claude Code — framework runtime tree
-          join3(homedir4(), ".augmented", agent.code_name, "skills"),
+          join4(homedir4(), ".augmented", agent.code_name, "skills"),
           // Claude Code — project tree
-          join3(homedir4(), ".augmented", agent.code_name, "project", ".claude", "skills"),
+          join4(homedir4(), ".augmented", agent.code_name, "project", ".claude", "skills"),
           // OpenClaw — framework runtime tree
-          join3(homedir4(), `.openclaw-${agent.code_name}`, "skills"),
+          join4(homedir4(), `.openclaw-${agent.code_name}`, "skills"),
           // Defensive: legacy provision-side path, not currently an
           // install target but cheap to sweep.
-          join3(agentDir, ".claude", "skills")
+          join4(agentDir, ".claude", "skills")
         ];
-        const existingDirs = candidateSkillDirs.filter((d) => existsSync2(d));
+        const existingDirs = candidateSkillDirs.filter((d) => existsSync3(d));
         const discoveredEntries = /* @__PURE__ */ new Set();
         for (const dir of existingDirs) {
           try {
@@ -3281,8 +3471,8 @@ async function processAgent(agent, agentStates) {
         }
         const removeSkillFolder = (entry, reason) => {
           for (const dir of existingDirs) {
-            const p = join3(dir, entry);
-            if (existsSync2(p)) {
+            const p = join4(dir, entry);
+            if (existsSync3(p)) {
               rmSync3(p, { recursive: true, force: true });
             }
           }
@@ -3456,10 +3646,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 = join3(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
-          if (existsSync2(jobsPath)) {
+          const jobsPath = join4(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          if (existsSync3(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync3(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -3585,10 +3775,10 @@ In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
     }
   }
   const trackedFiles = frameworkAdapter.driftTrackedFiles();
-  if (trackedFiles.length > 0 && existsSync2(agentDir)) {
+  if (trackedFiles.length > 0 && existsSync3(agentDir)) {
     const hashes = /* @__PURE__ */ new Map();
     for (const file of trackedFiles) {
-      const h = hashFile(join3(agentDir, file));
+      const h = hashFile(join4(agentDir, file));
       if (h) hashes.set(file, h);
     }
     writtenHashes.set(agent.agent_id, hashes);
@@ -3622,19 +3812,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join3(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join4(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join3(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join4(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join3(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join4(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join3(sessionsDir, "sessions.json");
-  if (!existsSync2(indexPath)) return;
+  const indexPath = join4(sessionsDir, "sessions.json");
+  if (!existsSync3(indexPath)) return;
   try {
-    const raw = readFileSync2(indexPath, "utf-8");
+    const raw = readFileSync3(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,
@@ -3647,9 +3837,9 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join3(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join4(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
-          if (existsSync2(sessionFile)) {
+          if (existsSync3(sessionFile)) {
             unlinkSync(sessionFile);
             deletedFiles++;
           }
@@ -3669,8 +3859,8 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join3(sessionsDir, `${parentSessionId}.jsonl`);
-            if (existsSync2(f)) {
+            const f = join4(sessionsDir, `${parentSessionId}.jsonl`);
+            if (existsSync3(f)) {
               unlinkSync(f);
               deletedFiles++;
             }
@@ -3679,7 +3869,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         }
       }
     }
-    writeFileSync2(indexPath, JSON.stringify(index));
+    writeFileSync3(indexPath, JSON.stringify(index));
     if (toDelete.length > 0) {
       log(`Cleaned ${toDelete.length} cron session(s) and ${deletedFiles} file(s) from ${sessionsDir}`);
     }
@@ -3688,9 +3878,9 @@ function cleanupCronSessions(sessionsDir, keepCount) {
 }
 var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
-  if (!existsSync2(jobsPath)) return;
+  if (!existsSync3(jobsPath)) return;
   try {
-    const raw = readFileSync2(jobsPath, "utf-8");
+    const raw = readFileSync3(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
@@ -3715,19 +3905,19 @@ function clearStaleCronRunState(jobsPath) {
       }
     }
     if (changed) {
-      writeFileSync2(jobsPath, JSON.stringify(data, null, 2));
+      writeFileSync3(jobsPath, JSON.stringify(data, null, 2));
     }
   } catch {
   }
 }
 function cleanupOldFiles(dir, maxAgeDays, ext) {
-  if (!existsSync2(dir)) return;
+  if (!existsSync3(dir)) return;
   const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
   let removed = 0;
   try {
     for (const f of readdirSync2(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join3(dir, f);
+      const fullPath = join4(dir, f);
       try {
         const st = statSync(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -3871,7 +4061,7 @@ async function fetchPriorScheduledRuns(agentId, taskId) {
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join3(projectDir, ".mcp.json");
+  const mcpConfigPath = join4(projectDir, ".mcp.json");
   let runId = null;
   let kanbanItemId = null;
   let taskResult;
@@ -3879,11 +4069,11 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const priorRuns = await fetchPriorScheduledRuns(agentId, task.taskId);
   prompt = wrapScheduledTaskPrompt(prompt, { priorRuns });
   try {
-    const claudeMdPath = join3(projectDir, "CLAUDE.md");
+    const claudeMdPath = join4(projectDir, "CLAUDE.md");
     const serverNames = [];
-    if (existsSync2(mcpConfigPath)) {
+    if (existsSync3(mcpConfigPath)) {
       try {
-        const d = JSON.parse(readFileSync2(mcpConfigPath, "utf-8"));
+        const d = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
         if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
       } catch {
       }
@@ -3902,14 +4092,14 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       "--allowedTools",
       allowedTools
     ];
-    if (existsSync2(claudeMdPath)) {
+    if (existsSync3(claudeMdPath)) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join3(projectDir, ".env.integrations");
-    if (existsSync2(envIntPath)) {
+    const envIntPath = join4(projectDir, ".env.integrations");
+    if (existsSync3(envIntPath)) {
       try {
-        for (const line of readFileSync2(envIntPath, "utf-8").split("\n")) {
+        for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
           if (!line || line.startsWith("#") || !line.includes("=")) continue;
           const eqIdx = line.indexOf("=");
           childEnv[line.slice(0, eqIdx)] = line.slice(eqIdx + 1);
@@ -4091,8 +4281,8 @@ var claudeAuthTupleBySession = /* @__PURE__ */ new Map();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join3(projectDir, ".mcp.json");
-  const claudeMdPath = join3(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join4(projectDir, ".mcp.json");
+  const claudeMdPath = join4(projectDir, "CLAUDE.md");
   const channelConfigs = refreshData.channel_configs;
   const channels = [];
   const devChannels = [];
@@ -4567,11 +4757,11 @@ async function processDirectChatMessage(agent, msg) {
     if (fw === "claude-code") {
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-XHJS2MZV.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join3(projDir, ".mcp.json");
+      const mcpConfigPath = join4(projDir, ".mcp.json");
       const serverNames = [];
-      if (existsSync2(mcpConfigPath)) {
+      if (existsSync3(mcpConfigPath)) {
         try {
-          const d = JSON.parse(readFileSync2(mcpConfigPath, "utf-8"));
+          const d = JSON.parse(readFileSync3(mcpConfigPath, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -4590,15 +4780,15 @@ async function processDirectChatMessage(agent, msg) {
         "--allowedTools",
         allowedTools
       ];
-      const chatClaudeMd = join3(projDir, "CLAUDE.md");
-      if (existsSync2(chatClaudeMd)) {
+      const chatClaudeMd = join4(projDir, "CLAUDE.md");
+      if (existsSync3(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join3(projDir, ".env.integrations");
+      const envIntPath = join4(projDir, ".env.integrations");
       const childEnv = { ...process.env };
-      if (existsSync2(envIntPath)) {
+      if (existsSync3(envIntPath)) {
         try {
-          for (const line of readFileSync2(envIntPath, "utf-8").split("\n")) {
+          for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
             if (!line || line.startsWith("#") || !line.includes("=")) continue;
             const eqIdx = line.indexOf("=");
             childEnv[line.slice(0, eqIdx)] = line.slice(eqIdx + 1);
@@ -4879,12 +5069,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join3(process.cwd(), "skills", skillId, "SKILL.md"),
-      join3(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join4(process.cwd(), "skills", skillId, "SKILL.md"),
+      join4(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync2(candidate)) {
-        const content = readFileSync2(candidate, "utf-8");
+      if (existsSync3(candidate)) {
+        const content = readFileSync3(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -5773,8 +5963,8 @@ function parseMemoryFile(raw, fallbackName) {
   };
 }
 async function syncMemories(agent, configDir, log2) {
-  const projectDir = join3(configDir, agent.code_name, "project");
-  const memoryDir = join3(projectDir, "memory");
+  const projectDir = join4(configDir, agent.code_name, "project");
+  const memoryDir = join4(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`);
@@ -5785,14 +5975,14 @@ async function syncMemories(agent, configDir, log2) {
     }
     pendingFreshMemorySync.delete(agent.agent_id);
   }
-  if (existsSync2(memoryDir)) {
+  if (existsSync3(memoryDir)) {
     const prevHashes = memoryFileHashes.get(agent.agent_id) ?? /* @__PURE__ */ new Map();
     const currentHashes = /* @__PURE__ */ new Map();
     const changedMemories = [];
     for (const file of readdirSync2(memoryDir)) {
       if (!file.endsWith(".md")) continue;
       try {
-        const raw = readFileSync2(join3(memoryDir, file), "utf-8");
+        const raw = readFileSync3(join4(memoryDir, file), "utf-8");
         const fileHash = createHash("sha256").update(raw).digest("hex").slice(0, 16);
         currentHashes.set(file, fileHash);
         if (prevHashes.get(file) === fileHash) continue;
@@ -5817,7 +6007,7 @@ async function syncMemories(agent, configDir, log2) {
       } catch (err) {
         for (const mem of changedMemories) {
           for (const [file] of currentHashes) {
-            const parsed = parseMemoryFile(readFileSync2(join3(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
+            const parsed = parseMemoryFile(readFileSync3(join4(memoryDir, file), "utf-8"), file.replace(/\.md$/, ""));
             if (parsed?.name === mem.name) currentHashes.delete(file);
           }
         }
@@ -5830,7 +6020,7 @@ async function syncMemories(agent, configDir, log2) {
   }
 }
 async function downloadMemories(agent, memoryDir, log2, { force }) {
-  const localFiles = existsSync2(memoryDir) ? readdirSync2(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
+  const localFiles = existsSync3(memoryDir) ? readdirSync2(memoryDir).filter((f) => f.endsWith(".md")).sort() : [];
   const localListHash = createHash("sha256").update(localFiles.join(",")).digest("hex").slice(0, 16);
   const prevLocalHash = lastLocalFileHash.get(agent.agent_id);
   const prevDownload = lastDownloadHash.get(agent.agent_id);
@@ -5852,7 +6042,7 @@ async function downloadMemories(agent, memoryDir, log2, { force }) {
         const mem = dbMemories.memories[i];
         const rawSlug = mem.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "").slice(0, 60);
         const slug = rawSlug || `memory-${i}`;
-        const filePath = join3(memoryDir, `${slug}.md`);
+        const filePath = join4(memoryDir, `${slug}.md`);
         const desired = `---
 name: ${JSON.stringify(mem.name)}
 type: ${mem.type}
@@ -5861,17 +6051,17 @@ description: ${JSON.stringify(mem.content.slice(0, 200))}
 
 ${mem.content}
 `;
-        if (existsSync2(filePath)) {
+        if (existsSync3(filePath)) {
           let existing = "";
           try {
-            existing = readFileSync2(filePath, "utf-8");
+            existing = readFileSync3(filePath, "utf-8");
           } catch {
           }
           if (existing === desired) continue;
-          writeFileSync2(filePath, desired);
+          writeFileSync3(filePath, desired);
           overwritten++;
         } else {
-          writeFileSync2(filePath, desired);
+          writeFileSync3(filePath, desired);
           written++;
         }
       }
@@ -5888,7 +6078,7 @@ ${mem.content}
   }
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync2(agentDir)) {
+  if (existsSync3(agentDir)) {
     try {
       rmSync2(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -5977,6 +6167,7 @@ function startPolling() {
   if (!config || running) return;
   running = true;
   void startCaffeinate();
+  loadChannelHashCache2();
   log(`Starting poll loop (interval=${config.intervalMs}ms, configDir=${config.configDir})`);
   void killAllAgtTmuxSessions().catch(() => {
   }).then(() => migrateToProfiles()).then(() => {
@@ -6055,7 +6246,7 @@ async function stopPolling(opts = {}) {
 function startManager(opts) {
   config = opts;
   log(
-    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join3(homedir3(), ".augmented", "manager.log")}`
+    `[startup] worker pid=${process.pid} ppid=${process.ppid} node=${process.version} log=${join4(homedir3(), ".augmented", "manager.log")}`
   );
   deployMcpAssets();
   void ensureHostFrameworkBinaries();
@@ -6116,14 +6307,14 @@ function restartRunningChannelMcps(basenames) {
   }
 }
 function deployMcpAssets() {
-  const targetDir = join3(homedir3(), ".augmented", "_mcp");
+  const targetDir = join4(homedir3(), ".augmented", "_mcp");
   mkdirSync2(targetDir, { recursive: true });
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join3(dir, "mcp");
-    if (existsSync2(join3(candidate, "index.js"))) {
+    const candidate = join4(dir, "mcp");
+    if (existsSync3(join4(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
@@ -6138,8 +6329,8 @@ function deployMcpAssets() {
   const changedBasenames = [];
   const fileHash = (p) => {
     try {
-      if (!existsSync2(p)) return null;
-      return createHash("sha256").update(readFileSync2(p)).digest("hex");
+      if (!existsSync3(p)) return null;
+      return createHash("sha256").update(readFileSync3(p)).digest("hex");
     } catch {
       return null;
     }
@@ -6150,9 +6341,9 @@ function deployMcpAssets() {
     "telegram-channel.js"
   ]);
   for (const file of ["index.js", "slack-channel.js", "direct-chat-channel.js", "telegram-channel.js"]) {
-    const src = join3(mcpSourceDir, file);
-    const dst = join3(targetDir, file);
-    if (!existsSync2(src)) continue;
+    const src = join4(mcpSourceDir, file);
+    const dst = join4(targetDir, file);
+    if (!existsSync3(src)) continue;
     const before = fileHash(dst);
     try {
       copyFileSync(src, dst);
@@ -6169,23 +6360,23 @@ function deployMcpAssets() {
     log(`[manager] Bundle(s) updated: ${changedBasenames.join(", ")} \u2014 signalling running instances to restart`);
     restartRunningChannelMcps(changedBasenames);
   }
-  const localMcpPath = join3(targetDir, "index.js");
+  const localMcpPath = join4(targetDir, "index.js");
   try {
-    const agentsDir = join3(homedir3(), ".augmented", "agents");
-    if (existsSync2(agentsDir)) {
+    const agentsDir = join4(homedir3(), ".augmented", "agents");
+    if (existsSync3(agentsDir)) {
       for (const entry of readdirSync2(agentsDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         for (const subdir of ["provision", "project"]) {
-          const mcpJsonPath = join3(agentsDir, entry.name, subdir, ".mcp.json");
+          const mcpJsonPath = join4(agentsDir, entry.name, subdir, ".mcp.json");
           try {
-            const raw = readFileSync2(mcpJsonPath, "utf-8");
+            const raw = readFileSync3(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];
-            writeFileSync2(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            writeFileSync3(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
             log(`[manager] Patched ${entry.name}/${subdir}/.mcp.json: npx \u2192 node`);
           } catch {
           }