@integrity-labs/agt-cli 0.9.0 → 0.9.2

package/dist/lib/manager-worker.js

@@ -9,7 +9,7 @@ import {
   provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-55TMBRXT.js";
+} from "../chunk-AMB6FJLZ.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -18,48 +18,24 @@ import {
   markTaskFired,
   syncTasksToScheduler
 } from "../chunk-2TSCVXHE.js";
+import {
+  getProjectDir as getProjectDir2,
+  injectMessage,
+  isSessionHealthy,
+  resetRestartCount,
+  sanitizeMcpJson,
+  startPersistentSession,
+  stopAllSessionsAndWait,
+  stopPersistentSession
+} from "../chunk-JOAT4JQN.js";
 
 // src/lib/manager-worker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync, copyFileSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync, readdirSync, statSync, unlinkSync, copyFileSync } from "fs";
 import https from "https";
-import { join as join2, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/lib/mcp-sanitize.ts
-import { readFileSync, writeFileSync } from "fs";
-function sanitizeMcpJson(mcpConfigPath, apiHost) {
-  try {
-    const mcpRaw = JSON.parse(readFileSync(mcpConfigPath, "utf-8"));
-    const servers = mcpRaw.mcpServers;
-    if (!servers) return false;
-    let changed = false;
-    for (const [key, val] of Object.entries(servers)) {
-      if (typeof val?.url !== "string") continue;
-      if (val.url.startsWith("/")) {
-        if (apiHost) {
-          val.url = `${apiHost}${val.url}`;
-          changed = true;
-        } else {
-          delete servers[key];
-          changed = true;
-          continue;
-        }
-      }
-      const url = val.url;
-      delete val.url;
-      delete val.type;
-      val.command = "npx";
-      val.args = ["-y", "mcp-remote", url, "--allow-http"];
-      changed = true;
-    }
-    if (changed) writeFileSync(mcpConfigPath, JSON.stringify(mcpRaw, null, 2));
-    return changed;
-  } catch {
-    return false;
-  }
-}
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
 
 // src/lib/gateway-client.ts
 import { EventEmitter } from "events";
@@ -330,345 +306,6 @@ var GatewayClientPool = class extends EventEmitter {
   }
 };
 
-// src/lib/persistent-session.ts
-import { spawn, execSync, execFileSync } from "child_process";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync } from "fs";
-import { fileURLToPath } from "url";
-function collectMcpServerNames(mcpConfigPath, channelsConfigPath) {
-  const names = [];
-  for (const path of [mcpConfigPath, channelsConfigPath]) {
-    if (!existsSync(path)) continue;
-    try {
-      const data = JSON.parse(readFileSync2(path, "utf-8"));
-      const servers = data.mcpServers;
-      if (servers) names.push(...Object.keys(servers));
-    } catch {
-    }
-  }
-  return names;
-}
-var _acpxBin = null;
-function getAcpxBin() {
-  if (_acpxBin) return _acpxBin;
-  const moduleDir = dirname(fileURLToPath(import.meta.url));
-  let dir = moduleDir;
-  for (let i = 0; i < 6; i++) {
-    const candidate = join(dir, "node_modules", ".bin", "acpx");
-    if (existsSync(candidate)) {
-      _acpxBin = candidate;
-      return _acpxBin;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  try {
-    execSync("which acpx", { stdio: "ignore" });
-    _acpxBin = "acpx";
-    return _acpxBin;
-  } catch {
-    return "";
-  }
-}
-var sessions = /* @__PURE__ */ new Map();
-function startPersistentSession(config2) {
-  const existing = sessions.get(config2.codeName);
-  if (existing && existing.status === "running") {
-    return existing;
-  }
-  const restartCount = existing?.restartCount ?? 0;
-  if (existing?.status === "crashed" && existing.startedAt) {
-    const backoffMs = Math.min(5e3 * Math.pow(2, restartCount), 6e4);
-    if (Date.now() - existing.startedAt < backoffMs) {
-      return existing;
-    }
-  }
-  const session = {
-    codeName: config2.codeName,
-    startedAt: null,
-    restartCount,
-    status: "starting"
-  };
-  sessions.set(config2.codeName, session);
-  spawnSession(config2, session);
-  return session;
-}
-function spawnSession(config2, session) {
-  const { codeName, projectDir, mcpConfigPath, claudeMdPath, channels, devChannels, apiHost, log: log2 } = config2;
-  const tmuxSession = `agt-${codeName}`;
-  log2(`[persistent-session] Starting tmux session '${tmuxSession}' for '${codeName}'`);
-  try {
-    sanitizeMcpJson(mcpConfigPath, apiHost);
-    writeAcpxConfig(config2);
-    try {
-      execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-    } catch {
-    }
-    const args = [];
-    if (channels.length > 0) args.push("--channels", ...channels);
-    if (devChannels.length > 0) args.push("--dangerously-load-development-channels", ...devChannels);
-    args.push("--mcp-config", mcpConfigPath);
-    const channelsConfigPath = join(projectDir, ".mcp-channels.json");
-    if (existsSync(channelsConfigPath)) args.push("--mcp-config", channelsConfigPath);
-    if (existsSync(claudeMdPath)) args.push("--system-prompt-file", claudeMdPath);
-    args.push("--allow-dangerously-skip-permissions");
-    args.push("--dangerously-skip-permissions");
-    args.push("--strict-mcp-config");
-    args.push("--name", tmuxSession);
-    const mcpServerNames = collectMcpServerNames(mcpConfigPath, channelsConfigPath);
-    const mcpPatterns = mcpServerNames.map((name) => `mcp__${name.replace(/-/g, "_")}__*`);
-    const allowedTools = [
-      ...mcpPatterns,
-      "Bash",
-      "Read",
-      "Write",
-      "Edit",
-      "Grep",
-      "Glob",
-      "Agent",
-      "Skill"
-    ].join(",");
-    args.push("--allowedTools", allowedTools);
-    let envPrefix = "";
-    const envIntegrationsPath = join(projectDir, ".env.integrations");
-    if (existsSync(envIntegrationsPath)) {
-      try {
-        const envContent = readFileSync2(envIntegrationsPath, "utf-8");
-        const envVars = envContent.split("\n").filter((line) => line && !line.startsWith("#") && line.includes("=")).map((line) => {
-          const eqIdx = line.indexOf("=");
-          const key = line.slice(0, eqIdx);
-          const value = line.slice(eqIdx + 1);
-          return `${key}=${JSON.stringify(value)}`;
-        }).join(" ");
-        if (envVars) envPrefix = `${envVars} `;
-      } catch {
-      }
-    }
-    const initPrompt = "You are now online. Wait for messages from your channels (Telegram, Slack) and respond to them. Use your kanban tools to track work.";
-    const claudeCmd = `${envPrefix}claude ${JSON.stringify(initPrompt)} ${args.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ")}`;
-    const child = spawn("tmux", [
-      "new-session",
-      "-d",
-      "-s",
-      tmuxSession,
-      "-c",
-      projectDir,
-      claudeCmd
-    ], {
-      cwd: projectDir,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: process.env
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        log2(`[persistent-session] Failed to create tmux session for '${codeName}' (exit ${code})`);
-        session.status = "crashed";
-        session.startedAt = Date.now();
-        session.restartCount++;
-        return;
-      }
-      log2(`[persistent-session] tmux session '${tmuxSession}' created for '${codeName}'`);
-      acceptDialogs(tmuxSession, codeName, log2).catch(() => {
-      });
-    });
-    child.on("error", (err) => {
-      log2(`[persistent-session] Failed to start tmux for '${codeName}': ${err.message}`);
-      session.status = "crashed";
-      session.startedAt = Date.now();
-      session.restartCount++;
-    });
-    session.startedAt = Date.now();
-    session.status = "running";
-    session.restartCount = 0;
-  } catch (err) {
-    log2(`[persistent-session] Failed to start session for '${codeName}': ${err.message}`);
-    session.status = "crashed";
-    session.startedAt = Date.now();
-    session.restartCount++;
-  }
-}
-async function acceptDialogs(tmuxSession, codeName, log2) {
-  for (let i = 0; i < 15; i++) {
-    await new Promise((r) => setTimeout(r, 2e3));
-    try {
-      const screen = execSync(`tmux capture-pane -t ${tmuxSession} -p 2>/dev/null`, { encoding: "utf-8" });
-      if (screen.includes("Yes, I trust this folder")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log2(`[persistent-session] Auto-accepted workspace trust for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("I am using this for local development")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log2(`[persistent-session] Auto-accepted dev channels for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log2(`[persistent-session] Auto-accepted MCP servers for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("Yes, I accept") && screen.includes("Bypass Permissions")) {
-        execSync(`tmux send-keys -t ${tmuxSession} 2`, { stdio: "ignore" });
-        await new Promise((r) => setTimeout(r, 300));
-        execSync(`tmux send-keys -t ${tmuxSession} Enter`, { stdio: "ignore" });
-        log2(`[persistent-session] Auto-accepted bypass permissions for '${codeName}'`);
-        continue;
-      }
-      if (screen.includes("\u276F") && !screen.includes("Enter to confirm")) {
-        log2(`[persistent-session] Session ready for '${codeName}' \u2014 no more dialogs`);
-        break;
-      }
-    } catch {
-      break;
-    }
-  }
-}
-async function injectMessage(codeName, type, content, meta, log2) {
-  const _log = log2 ?? ((_) => {
-  });
-  const session = sessions.get(codeName);
-  if (!session || session.status !== "running") {
-    _log(`[inject] SKIP '${codeName}' \u2014 session ${session ? `status=${session.status}` : "not found in Map"}`);
-    return false;
-  }
-  const prefix = meta?.task_name ? `[Task: ${meta.task_name}] ` : "";
-  const text = prefix + content;
-  const projectDir = getProjectDir2(codeName);
-  const acpx = getAcpxBin();
-  if (acpx) {
-    try {
-      const tmpDir = join(projectDir, ".claude");
-      mkdirSync(tmpDir, { recursive: true });
-      const tmpFile = join(tmpDir, ".agt-inject-prompt.txt");
-      writeFileSync2(tmpFile, text);
-      _log(`[inject] acpx exec (fire-and-forget): cwd=${projectDir}, file=${tmpFile}`);
-      const child = spawn(acpx, ["claude", "exec", "-f", tmpFile], {
-        cwd: projectDir,
-        stdio: "ignore",
-        detached: true
-      });
-      child.on("error", (err) => {
-        _log(`[inject] acpx spawn error for '${codeName}': ${err.message}`);
-      });
-      child.unref();
-      return true;
-    } catch (err) {
-      _log(`[inject] acpx exec failed for '${codeName}': ${err.message}`);
-    }
-  } else {
-    _log(`[inject] acpx binary not found \u2014 falling back to tmux send-keys`);
-  }
-  try {
-    execFileSync("tmux", ["send-keys", "-t", `agt-${codeName}`, text, "Enter"], { stdio: "ignore" });
-    _log(`[inject] tmux send-keys sent for '${codeName}' \u2014 unverified (returning false)`);
-    return false;
-  } catch (err) {
-    _log(`[inject] tmux send-keys failed for '${codeName}': ${err.message}`);
-    return false;
-  }
-}
-function stopPersistentSession(codeName, log2) {
-  const session = sessions.get(codeName);
-  if (!session) return;
-  log2(`[persistent-session] Stopping session for '${codeName}'`);
-  session.status = "stopped";
-  try {
-    execSync(`tmux kill-session -t agt-${codeName} 2>/dev/null`, { stdio: "ignore" });
-  } catch {
-  }
-  try {
-    const acpx = getAcpxBin();
-    if (acpx) {
-      execFileSync(acpx, ["claude", "sessions", "close", `agt-${codeName}`], {
-        cwd: getProjectDir2(codeName),
-        timeout: 5e3,
-        stdio: "ignore"
-      });
-    }
-  } catch {
-  }
-  sessions.delete(codeName);
-}
-function isSessionHealthy(codeName) {
-  const tmuxSession = `agt-${codeName}`;
-  try {
-    execSync(`tmux has-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-  } catch {
-    const session2 = sessions.get(codeName);
-    if (session2 && session2.status === "running") {
-      session2.status = "crashed";
-    }
-    return false;
-  }
-  if (!sessions.has(codeName)) {
-    sessions.set(codeName, {
-      codeName,
-      startedAt: Date.now(),
-      restartCount: 0,
-      status: "running"
-    });
-  }
-  const session = sessions.get(codeName);
-  if (session.status !== "running") {
-    session.status = "running";
-  }
-  return true;
-}
-function resetRestartCount(codeName) {
-  const session = sessions.get(codeName);
-  if (session) session.restartCount = 0;
-}
-async function stopAllSessionsAndWait(log2, opts) {
-  const codeNames = [...sessions.keys()];
-  if (codeNames.length === 0) return;
-  for (const codeName of codeNames) {
-    stopPersistentSession(codeName, log2);
-  }
-  await new Promise((resolve) => setTimeout(resolve, Math.min(opts.timeoutMs, 2e3)));
-}
-function getProjectDir2(codeName) {
-  return join(homedir(), ".augmented", codeName, "project");
-}
-function writeAcpxConfig(config2) {
-  const { projectDir, mcpConfigPath, claudeMdPath, channels, devChannels } = config2;
-  const claudeArgs = [];
-  if (channels.length > 0) claudeArgs.push("--channels", ...channels);
-  if (devChannels.length > 0) claudeArgs.push("--dangerously-load-development-channels", ...devChannels);
-  claudeArgs.push("--mcp-config", mcpConfigPath);
-  const channelsConfigPath = join(projectDir, ".mcp-channels.json");
-  if (existsSync(channelsConfigPath)) claudeArgs.push("--mcp-config", channelsConfigPath);
-  if (existsSync(claudeMdPath)) claudeArgs.push("--system-prompt-file", claudeMdPath);
-  claudeArgs.push("--allow-dangerously-skip-permissions");
-  claudeArgs.push("--dangerously-skip-permissions");
-  claudeArgs.push("--strict-mcp-config");
-  const mcpServerNames2 = collectMcpServerNames(mcpConfigPath, channelsConfigPath);
-  const mcpPatterns2 = mcpServerNames2.map((name) => `mcp__${name.replace(/-/g, "_")}__*`);
-  const allowedTools2 = [...mcpPatterns2, "Bash", "Read", "Write", "Edit", "Grep", "Glob", "Agent", "Skill"].join(",");
-  claudeArgs.push("--allowedTools", allowedTools2);
-  const acpCmd = `npx -y @agentclientprotocol/claude-agent-acp ${claudeArgs.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ")}`;
-  const envIntegrationsPath = join(projectDir, ".env.integrations");
-  const wrapperPath = join(projectDir, ".claude", "acpx-agent.sh");
-  const wrapperLines = ["#!/usr/bin/env bash"];
-  if (existsSync(envIntegrationsPath)) {
-    wrapperLines.push(`set -a`, `source ${JSON.stringify(envIntegrationsPath)}`, `set +a`);
-  }
-  wrapperLines.push(`exec ${acpCmd}`);
-  mkdirSync(join(projectDir, ".claude"), { recursive: true });
-  writeFileSync2(wrapperPath, wrapperLines.join("\n") + "\n", { mode: 493 });
-  const acpxConfig = {
-    defaultAgent: "claude",
-    defaultPermissions: "approve-all",
-    agents: {
-      claude: {
-        command: wrapperPath
-      }
-    }
-  };
-  writeFileSync2(join(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
-}
-
 // src/lib/realtime-chat.ts
 import { createClient } from "@supabase/supabase-js";
 var client = null;
@@ -911,8 +548,8 @@ function stopRealtimeChat() {
 var GATEWAY_PORT_BASE = 18800;
 var GATEWAY_PORT_STEP = 10;
 var GATEWAY_PORT_MAX = 18899;
-var AUGMENTED_DIR = join2(process.env["HOME"] ?? "/tmp", ".augmented");
-var GATEWAY_PORTS_FILE = join2(AUGMENTED_DIR, "gateway-ports.json");
+var AUGMENTED_DIR = join(process.env["HOME"] ?? "/tmp", ".augmented");
+var GATEWAY_PORTS_FILE = join(AUGMENTED_DIR, "gateway-ports.json");
 var config = null;
 var running = false;
 var pollTimer = null;
@@ -989,24 +626,24 @@ async function ensureFrameworkBinary(frameworkId) {
   if (frameworkId !== "claude-code") return;
   if (frameworkBinaryChecked.has(frameworkId)) return;
   frameworkBinaryChecked.add(frameworkId);
-  const { execFileSync: execFileSync2 } = await import("child_process");
+  const { execFileSync } = await import("child_process");
   let brewPath;
   try {
-    brewPath = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    brewPath = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
   } catch {
     log("Homebrew not found \u2014 cannot auto-install/upgrade Claude Code. Install manually: https://claude.ai/download");
     return;
   }
   let claudeExists = false;
   try {
-    execFileSync2("which", ["claude"], { timeout: 5e3 });
+    execFileSync("which", ["claude"], { timeout: 5e3 });
     claudeExists = true;
   } catch {
   }
   if (!claudeExists) {
     log("Claude Code binary not found \u2014 installing via Homebrew...");
     try {
-      execFileSync2(brewPath, ["install", "--cask", "claude-code"], {
+      execFileSync(brewPath, ["install", "--cask", "claude-code"], {
         timeout: 12e4,
         stdio: "pipe"
       });
@@ -1015,7 +652,7 @@ async function ensureFrameworkBinary(frameworkId) {
       return;
     }
     try {
-      execFileSync2("which", ["claude"], { timeout: 5e3 });
+      execFileSync("which", ["claude"], { timeout: 5e3 });
       log("Claude Code installed successfully");
     } catch {
       log("Claude Code install completed but binary not found on PATH \u2014 you may need to restart your terminal");
@@ -1023,7 +660,7 @@ async function ensureFrameworkBinary(frameworkId) {
   } else {
     log("Checking for Claude Code updates...");
     try {
-      const output = execFileSync2(brewPath, ["upgrade", "--cask", "claude-code"], {
+      const output = execFileSync(brewPath, ["upgrade", "--cask", "claude-code"], {
         timeout: 12e4,
         stdio: "pipe"
       }).toString();
@@ -1041,7 +678,7 @@ async function ensureFrameworkBinary(frameworkId) {
       }
     }
   }
-  agentRuntimeAuthenticated = checkClaudeAuth(execFileSync2);
+  agentRuntimeAuthenticated = checkClaudeAuth(execFileSync);
 }
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var selfUpdateChecked = false;
@@ -1053,23 +690,23 @@ async function checkAndUpdateCli() {
   const isDevMode = cliPath.includes("/src/") || cliPath.includes("tsx");
   if (isDevMode) return;
   if (!isHomebrew && !cliPath.includes("node_modules")) return;
-  const { homedir: homedir3 } = await import("os");
+  const { homedir: homedir2 } = await import("os");
   const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
-  const markerPath = join2(homedir3(), ".augmented", ".last-update-check");
+  const markerPath = join(homedir2(), ".augmented", ".last-update-check");
   try {
     const lastCheck = parseInt(readF(markerPath, "utf-8").trim(), 10);
     if (Date.now() - lastCheck < UPDATE_CHECK_INTERVAL_MS) return;
   } catch {
   }
-  const { execFileSync: execFileSync2 } = await import("child_process");
+  const { execFileSync } = await import("child_process");
   let brewPath;
   try {
-    brewPath = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    brewPath = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
   } catch {
     return;
   }
   try {
-    const outdated = execFileSync2(brewPath, ["outdated", "--json=v2"], {
+    const outdated = execFileSync(brewPath, ["outdated", "--json=v2"], {
       timeout: 3e4,
       encoding: "utf-8"
     });
@@ -1080,7 +717,7 @@ async function checkAndUpdateCli() {
       const latest = agtOutdated.current_version ?? "unknown";
       log(`[self-update] agt CLI update available: ${installed} \u2192 ${latest}. Upgrading...`);
       try {
-        execFileSync2(brewPath, ["upgrade", "integrity-labs/tap/agt"], {
+        execFileSync(brewPath, ["upgrade", "integrity-labs/tap/agt"], {
           timeout: 12e4,
           stdio: "pipe"
         });
@@ -1096,9 +733,9 @@ async function checkAndUpdateCli() {
   } catch {
   }
 }
-function checkClaudeAuth(execFileSync2) {
+function checkClaudeAuth(execFileSync) {
   try {
-    const authOutput = execFileSync2("claude", ["auth", "status"], { timeout: 1e4, stdio: "pipe" }).toString().trim();
+    const authOutput = execFileSync("claude", ["auth", "status"], { timeout: 1e4, stdio: "pipe" }).toString().trim();
     let loggedIn = null;
     try {
       const parsed = JSON.parse(authOutput);
@@ -1123,14 +760,14 @@ function checkClaudeAuth(execFileSync2) {
 }
 function loadGatewayPorts() {
   try {
-    return JSON.parse(readFileSync3(GATEWAY_PORTS_FILE, "utf-8"));
+    return JSON.parse(readFileSync(GATEWAY_PORTS_FILE, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveGatewayPorts(ports) {
-  mkdirSync2(AUGMENTED_DIR, { recursive: true });
-  writeFileSync3(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+  mkdirSync(AUGMENTED_DIR, { recursive: true });
+  writeFileSync(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
   const ports = loadGatewayPorts();
@@ -1152,11 +789,11 @@ function freePort(codeName) {
     saveGatewayPorts(ports);
   }
 }
-var STATE_FILE = join2(process.env["HOME"] ?? "/tmp", ".augmented", "manager-state.json");
+var STATE_FILE = join(process.env["HOME"] ?? "/tmp", ".augmented", "manager-state.json");
 function send(msg) {
   if (msg.type === "state-update") {
     try {
-      writeFileSync3(STATE_FILE, JSON.stringify(msg.state, null, 2));
+      writeFileSync(STATE_FILE, JSON.stringify(msg.state, null, 2));
     } catch {
     }
   }
@@ -1178,7 +815,7 @@ function sha256(content) {
 }
 function hashFile(filePath) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync(filePath, "utf-8");
     return sha256(content);
   } catch {
     return null;
@@ -1186,10 +823,10 @@ function hashFile(filePath) {
 }
 async function migrateToProfiles() {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const sharedConfigPath = join2(homeDir, ".openclaw", "openclaw.json");
+  const sharedConfigPath = join(homeDir, ".openclaw", "openclaw.json");
   let sharedConfig;
   try {
-    sharedConfig = JSON.parse(readFileSync3(sharedConfigPath, "utf-8"));
+    sharedConfig = JSON.parse(readFileSync(sharedConfigPath, "utf-8"));
   } catch {
     return;
   }
@@ -1202,19 +839,19 @@ async function migrateToProfiles() {
     const codeName = agentEntry["id"];
     if (!codeName) continue;
     if (codeName === "main") continue;
-    const profileDir = join2(homeDir, `.openclaw-${codeName}`);
-    if (existsSync2(join2(profileDir, "openclaw.json"))) continue;
+    const profileDir = join(homeDir, `.openclaw-${codeName}`);
+    if (existsSync(join(profileDir, "openclaw.json"))) continue;
     log(`Migrating agent '${codeName}' to per-agent profile`);
     if (adapter.seedProfileConfig) {
       adapter.seedProfileConfig(codeName);
     }
-    const sharedAuthDir = join2(homeDir, ".openclaw", "agents", codeName, "agent");
-    const profileAuthDir = join2(profileDir, "agents", codeName, "agent");
-    const authFile = join2(sharedAuthDir, "auth-profiles.json");
-    if (existsSync2(authFile)) {
-      mkdirSync2(profileAuthDir, { recursive: true });
-      const authContent = readFileSync3(authFile, "utf-8");
-      writeFileSync3(join2(profileAuthDir, "auth-profiles.json"), authContent);
+    const sharedAuthDir = join(homeDir, ".openclaw", "agents", codeName, "agent");
+    const profileAuthDir = join(profileDir, "agents", codeName, "agent");
+    const authFile = join(sharedAuthDir, "auth-profiles.json");
+    if (existsSync(authFile)) {
+      mkdirSync(profileAuthDir, { recursive: true });
+      const authContent = readFileSync(authFile, "utf-8");
+      writeFileSync(join(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -1252,7 +889,7 @@ function readGatewayToken(codeName) {
   }
   const homeDir = process.env["HOME"] ?? "/tmp";
   try {
-    const cfg = JSON.parse(readFileSync3(join2(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    const cfg = JSON.parse(readFileSync(join(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
     return cfg?.gateway?.auth?.token;
   } catch {
     return void 0;
@@ -1261,10 +898,10 @@ function readGatewayToken(codeName) {
 var GATEWAY_HUNG_TIMEOUT_MS = 5 * 6e4;
 function isGatewayHung(codeName) {
   const homeDir = process.env["HOME"] ?? "/tmp";
-  const jobsPath = join2(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
-  if (!existsSync2(jobsPath)) return false;
+  const jobsPath = join(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  if (!existsSync(jobsPath)) return false;
   try {
-    const data = JSON.parse(readFileSync3(jobsPath, "utf-8"));
+    const data = JSON.parse(readFileSync(jobsPath, "utf-8"));
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return false;
     const now = Date.now();
@@ -1297,19 +934,19 @@ async function ensureGatewayRunning(codeName, adapter) {
       }
       await new Promise((r) => setTimeout(r, 2e3));
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const cronJobsPath = join2(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+      const cronJobsPath = join(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
       clearStaleCronRunState(cronJobsPath);
     } else {
       if (status.port) {
         try {
           const homeDir = process.env["HOME"] ?? "/tmp";
-          const configPath = join2(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-          if (existsSync2(configPath)) {
-            const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
+          const configPath = join(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+          if (existsSync(configPath)) {
+            const cfg = JSON.parse(readFileSync(configPath, "utf-8"));
             if (cfg.gateway?.port !== status.port) {
               if (!cfg.gateway) cfg.gateway = {};
               cfg.gateway.port = status.port;
-              writeFileSync3(configPath, JSON.stringify(cfg, null, 2));
+              writeFileSync(configPath, JSON.stringify(cfg, null, 2));
             }
           }
         } catch {
@@ -1329,12 +966,12 @@ async function ensureGatewayRunning(codeName, adapter) {
     gatewaysStartedThisCycle.add(codeName);
     try {
       const homeDir = process.env["HOME"] ?? "/tmp";
-      const configPath = join2(homeDir, `.openclaw-${codeName}`, "openclaw.json");
-      if (existsSync2(configPath)) {
-        const cfg = JSON.parse(readFileSync3(configPath, "utf-8"));
+      const configPath = join(homeDir, `.openclaw-${codeName}`, "openclaw.json");
+      if (existsSync(configPath)) {
+        const cfg = JSON.parse(readFileSync(configPath, "utf-8"));
         if (!cfg.gateway) cfg.gateway = {};
         cfg.gateway.port = port;
-        writeFileSync3(configPath, JSON.stringify(cfg, null, 2));
+        writeFileSync(configPath, JSON.stringify(cfg, null, 2));
       }
     } catch {
     }
@@ -1438,11 +1075,39 @@ async function pollCycle() {
     }
     try {
       const { detectHostSecurity } = await import("../host-security-6PDFG7F5.js");
+      const { collectDiagnostics } = await import("../persistent-session-M6GXAEQF.js");
+      const diagCodeNames = [...persistentSessionAgents];
+      const agentDiagnostics = diagCodeNames.length > 0 ? collectDiagnostics(diagCodeNames) : void 0;
+      let tailscaleHostname;
+      try {
+        const { execSync: es } = await import("child_process");
+        const tsJson = es("tailscale status --self --json 2>/dev/null", {
+          encoding: "utf-8",
+          timeout: 3e3
+        }).trim();
+        const ts = JSON.parse(tsJson);
+        tailscaleHostname = ts.Self?.DNSName?.replace(/\.$/, "") || void 0;
+      } catch {
+        try {
+          const { execSync: es } = await import("child_process");
+          tailscaleHostname = es("hostname", { encoding: "utf-8", timeout: 1e3 }).trim();
+        } catch {
+        }
+      }
+      let osUsername;
+      try {
+        const { userInfo } = await import("os");
+        osUsername = userInfo().username;
+      } catch {
+      }
       await api.post("/host/heartbeat", {
         host_id: hostId,
         framework_version: cachedFrameworkVersion ?? void 0,
         host_security: detectHostSecurity() ?? void 0,
-        agent_runtime_authenticated: agentRuntimeAuthenticated
+        agent_runtime_authenticated: agentRuntimeAuthenticated,
+        agent_diagnostics: agentDiagnostics,
+        hostname: tailscaleHostname,
+        os_username: osUsername
       });
     } catch (err) {
       log(`Heartbeat failed: ${err.message}`);
@@ -1501,7 +1166,7 @@ async function pollCycle() {
         const adapter = resolveAgentFramework(prev.codeName);
         await stopGatewayIfRunning(prev.codeName, adapter);
         freePort(prev.codeName);
-        const agentDir = join2(config.configDir, prev.codeName, "provision");
+        const agentDir = join(config.configDir, prev.codeName, "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -1568,7 +1233,7 @@ async function processAgent(agent, agentStates) {
     agentFrameworkCache.set(agent.code_name, agent.framework);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const agentDir = join2(config.configDir, agent.code_name, "provision");
+  const agentDir = join(config.configDir, agent.code_name, "provision");
   const adapter = resolveAgentFramework(agent.code_name);
   if (agent.status === "draft" || agent.status === "paused") {
     log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
@@ -1719,9 +1384,9 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
     const changedFiles = [];
-    mkdirSync2(agentDir, { recursive: true });
+    mkdirSync(agentDir, { recursive: true });
     for (const artifact of artifacts) {
-      const filePath = join2(agentDir, artifact.relativePath);
+      const filePath = join(agentDir, artifact.relativePath);
       const newHash = sha256(artifact.content);
       const existingHash = hashFile(filePath);
       if (newHash !== existingHash) {
@@ -1729,19 +1394,19 @@ async function processAgent(agent, agentStates) {
       }
     }
     if (changedFiles.length > 0) {
-      const isFirst = !existsSync2(join2(agentDir, "CHARTER.md"));
+      const isFirst = !existsSync(join(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) {
-        writeFileSync3(join2(agentDir, file.relativePath), file.content);
+        writeFileSync(join(agentDir, file.relativePath), file.content);
       }
       lastProvisionAt = (/* @__PURE__ */ new Date()).toISOString();
       knownVersions.set(agent.agent_id, { charterVersion, toolsVersion });
       const trackedFiles = frameworkAdapter.driftTrackedFiles();
       const hashes = /* @__PURE__ */ new Map();
       for (const file of trackedFiles) {
-        const h = hashFile(join2(agentDir, file));
+        const h = hashFile(join(agentDir, file));
         if (h) hashes.set(file, h);
       }
       writtenHashes.set(agent.agent_id, hashes);
@@ -1785,10 +1450,10 @@ async function processAgent(agent, agentStates) {
   }
   let lastDriftCheckAt = now;
   const written = writtenHashes.get(agent.agent_id);
-  if (written && existsSync2(agentDir)) {
+  if (written && existsSync(agentDir)) {
     const driftedFiles = [];
     for (const [file, expectedHash] of written) {
-      const localHash = hashFile(join2(agentDir, file));
+      const localHash = hashFile(join(agentDir, file));
       if (localHash && localHash !== expectedHash) {
         driftedFiles.push(file);
       }
@@ -1799,7 +1464,7 @@ async function processAgent(agent, agentStates) {
       try {
         const localHashes = {};
         for (const file of driftedFiles) {
-          localHashes[file] = hashFile(join2(agentDir, file));
+          localHashes[file] = hashFile(join(agentDir, file));
         }
         await api.post("/host/drift", {
           agent_id: agent.agent_id,
@@ -1952,11 +1617,11 @@ async function processAgent(agent, agentStates) {
             }
             if (frameworkAdapter.removeMcpServer) {
               try {
-                const { readFileSync: readFileSync4 } = await import("fs");
-                const { join: join3 } = await import("path");
-                const { homedir: homedir3 } = await import("os");
-                const mcpPath = join3(homedir3(), ".augmented", "agents", agent.code_name, "provision", ".mcp.json");
-                const mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+                const { readFileSync: readFileSync2 } = await import("fs");
+                const { join: join2 } = await import("path");
+                const { homedir: homedir2 } = await import("os");
+                const mcpPath = join2(homedir2(), ".augmented", "agents", agent.code_name, "provision", ".mcp.json");
+                const mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = ["composio-", "one-", "nango-", "paragon-"];
                   for (const key of Object.keys(mcpConfig.mcpServers)) {
@@ -2009,18 +1674,18 @@ async function processAgent(agent, agentStates) {
             "@tobilu/qmd"
           ]);
           if (intHash !== prevIntHash) {
-            const { execFileSync: execFileSync2 } = await import("child_process");
+            const { execFileSync } = await import("child_process");
             for (const tool of capData.cliTools) {
               if (!ALLOWED_CLI_PACKAGES.has(tool.package)) {
                 log(`Skipping CLI tool '${tool.package}' for '${agent.code_name}' \u2014 not on the allowed packages list`);
                 continue;
               }
               try {
-                execFileSync2("which", [tool.binary], { stdio: "ignore" });
+                execFileSync("which", [tool.binary], { stdio: "ignore" });
               } catch {
                 log(`Installing CLI tool '${tool.package}' for '${agent.code_name}'...`);
                 try {
-                  execFileSync2("npm", ["install", "-g", tool.package], { stdio: "ignore", timeout: 6e4 });
+                  execFileSync("npm", ["install", "-g", tool.package], { stdio: "ignore", timeout: 6e4 });
                   log(`CLI tool '${tool.binary}' installed successfully`);
                 } catch (installErr) {
                   log(`Failed to install CLI tool '${tool.package}': ${installErr.message}`);
@@ -2028,8 +1693,8 @@ async function processAgent(agent, agentStates) {
               }
               if (tool.binary === "qmd") {
                 try {
-                  const agentDir2 = join2(process.env["HOME"] ?? "/tmp", ".augmented", agent.code_name);
-                  execFileSync2("qmd", ["collection", "add", agent.code_name, "project"], {
+                  const agentDir2 = join(process.env["HOME"] ?? "/tmp", ".augmented", agent.code_name);
+                  execFileSync("qmd", ["collection", "add", agent.code_name, "project"], {
                     stdio: "ignore",
                     timeout: 3e4,
                     cwd: agentDir2
@@ -2089,8 +1754,8 @@ async function processAgent(agent, agentStates) {
   if (agent.status === "active") {
     if (frameworkAdapter.installPlugin) {
       try {
-        const pluginPath = join2(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
-        if (existsSync2(pluginPath)) {
+        const pluginPath = join(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        if (existsSync(pluginPath)) {
           frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
             agtHost: requireHost(),
             agtApiKey: getApiKey() ?? void 0,
@@ -2205,10 +1870,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 = join2(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
-          if (existsSync2(jobsPath)) {
+          const jobsPath = join(homeDir, `.openclaw-${agent.code_name}`, "cron", "jobs.json");
+          if (existsSync(jobsPath)) {
             try {
-              const jobsData = JSON.parse(readFileSync3(jobsPath, "utf-8"));
+              const jobsData = JSON.parse(readFileSync(jobsPath, "utf-8"));
               const kanbanJob = (jobsData.jobs ?? []).find(
                 (j) => typeof j.name === "string" && j.name.includes("kanban-work")
               );
@@ -2353,19 +2018,19 @@ function cleanupStaleSessions(codeName) {
   lastCleanupAt.set(codeName, Date.now());
   const homeDir = process.env["HOME"] ?? "/tmp";
   for (const agentDir of ["main", codeName]) {
-    const sessionsDir = join2(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
+    const sessionsDir = join(homeDir, `.openclaw-${codeName}`, "agents", agentDir, "sessions");
     cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
   }
-  const cronRunsDir = join2(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  const cronRunsDir = join(homeDir, `.openclaw-${codeName}`, "cron", "runs");
   cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
-  const cronJobsPath = join2(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  const cronJobsPath = join(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
   clearStaleCronRunState(cronJobsPath);
 }
 function cleanupCronSessions(sessionsDir, keepCount) {
-  const indexPath = join2(sessionsDir, "sessions.json");
-  if (!existsSync2(indexPath)) return;
+  const indexPath = join(sessionsDir, "sessions.json");
+  if (!existsSync(indexPath)) return;
   try {
-    const raw = readFileSync3(indexPath, "utf-8");
+    const raw = readFileSync(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,
@@ -2378,9 +2043,9 @@ function cleanupCronSessions(sessionsDir, keepCount) {
     for (const entry of toDelete) {
       delete index[entry.key];
       if (entry.sessionId) {
-        const sessionFile = join2(sessionsDir, `${entry.sessionId}.jsonl`);
+        const sessionFile = join(sessionsDir, `${entry.sessionId}.jsonl`);
         try {
-          if (existsSync2(sessionFile)) {
+          if (existsSync(sessionFile)) {
             unlinkSync(sessionFile);
             deletedFiles++;
           }
@@ -2400,8 +2065,8 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         delete index[parentKey];
         if (parentSessionId) {
           try {
-            const f = join2(sessionsDir, `${parentSessionId}.jsonl`);
-            if (existsSync2(f)) {
+            const f = join(sessionsDir, `${parentSessionId}.jsonl`);
+            if (existsSync(f)) {
               unlinkSync(f);
               deletedFiles++;
             }
@@ -2410,7 +2075,7 @@ function cleanupCronSessions(sessionsDir, keepCount) {
         }
       }
     }
-    writeFileSync3(indexPath, JSON.stringify(index));
+    writeFileSync(indexPath, JSON.stringify(index));
     if (toDelete.length > 0) {
       log(`Cleaned ${toDelete.length} cron session(s) and ${deletedFiles} file(s) from ${sessionsDir}`);
     }
@@ -2419,9 +2084,9 @@ function cleanupCronSessions(sessionsDir, keepCount) {
 }
 var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
 function clearStaleCronRunState(jobsPath) {
-  if (!existsSync2(jobsPath)) return;
+  if (!existsSync(jobsPath)) return;
   try {
-    const raw = readFileSync3(jobsPath, "utf-8");
+    const raw = readFileSync(jobsPath, "utf-8");
     const data = JSON.parse(raw);
     const jobs = data.jobs ?? data;
     if (!Array.isArray(jobs)) return;
@@ -2446,19 +2111,19 @@ function clearStaleCronRunState(jobsPath) {
       }
     }
     if (changed) {
-      writeFileSync3(jobsPath, JSON.stringify(data, null, 2));
+      writeFileSync(jobsPath, JSON.stringify(data, null, 2));
     }
   } catch {
   }
 }
 function cleanupOldFiles(dir, maxAgeDays, ext) {
-  if (!existsSync2(dir)) return;
+  if (!existsSync(dir)) return;
   const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
   let removed = 0;
   try {
     for (const f of readdirSync(dir)) {
       if (!f.endsWith(ext)) continue;
-      const fullPath = join2(dir, f);
+      const fullPath = join(dir, f);
       try {
         const st = statSync(fullPath);
         if (st.mtimeMs < cutoff) {
@@ -2549,16 +2214,16 @@ async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData
 }
 async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
   const projectDir = getProjectDir(codeName);
-  const mcpConfigPath = join2(projectDir, ".mcp.json");
+  const mcpConfigPath = join(projectDir, ".mcp.json");
   sanitizeMcpJson(mcpConfigPath, requireHost());
   try {
-    const claudeMdPath = join2(projectDir, "CLAUDE.md");
+    const claudeMdPath = join(projectDir, "CLAUDE.md");
     const serverNames = [];
-    const channelsConfigPath = join2(projectDir, ".mcp-channels.json");
+    const channelsConfigPath = join(projectDir, ".mcp-channels.json");
     for (const p of [mcpConfigPath, channelsConfigPath]) {
-      if (existsSync2(p)) {
+      if (existsSync(p)) {
         try {
-          const d = JSON.parse(readFileSync3(p, "utf-8"));
+          const d = JSON.parse(readFileSync(p, "utf-8"));
           if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
         } catch {
         }
@@ -2577,15 +2242,15 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
       "--allowedTools",
       allowedTools
     ];
-    if (existsSync2(channelsConfigPath)) claudeArgs.push("--mcp-config", channelsConfigPath);
-    if (existsSync2(claudeMdPath)) {
+    if (existsSync(channelsConfigPath)) claudeArgs.push("--mcp-config", channelsConfigPath);
+    if (existsSync(claudeMdPath)) {
       claudeArgs.push("--system-prompt-file", claudeMdPath);
     }
     const childEnv = { ...process.env };
-    const envIntPath = join2(projectDir, ".env.integrations");
-    if (existsSync2(envIntPath)) {
+    const envIntPath = join(projectDir, ".env.integrations");
+    if (existsSync(envIntPath)) {
       try {
-        for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
+        for (const line of readFileSync(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);
@@ -2688,8 +2353,8 @@ var persistentSessionAgents = /* @__PURE__ */ new Set();
 async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
   const codeName = agent.code_name;
   const projectDir = getProjectDir2(codeName);
-  const mcpConfigPath = join2(projectDir, ".mcp.json");
-  const claudeMdPath = join2(projectDir, "CLAUDE.md");
+  const mcpConfigPath = join(projectDir, ".mcp.json");
+  const claudeMdPath = join(projectDir, "CLAUDE.md");
   const channelConfigs = refreshData.channel_configs;
   const channels = [];
   const devChannels = [];
@@ -2705,8 +2370,8 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     }
   }
   if (!agentRuntimeAuthenticated) {
-    const { execFileSync: execFileSync2 } = await import("child_process");
-    agentRuntimeAuthenticated = checkClaudeAuth(execFileSync2);
+    const { execFileSync } = await import("child_process");
+    agentRuntimeAuthenticated = checkClaudeAuth(execFileSync);
     if (!agentRuntimeAuthenticated) {
       log(`[persistent-session] Skipping '${codeName}' \u2014 Claude Code not authenticated`);
       return;
@@ -3022,13 +2687,13 @@ async function processDirectChatMessage(agent, msg) {
     if (fw === "claude-code") {
       const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-VFBZFE6U.js");
       const projDir = ccProjectDir(agent.codeName);
-      const mcpConfigPath = join2(projDir, ".mcp.json");
-      const channelsConfigPath = join2(projDir, ".mcp-channels.json");
+      const mcpConfigPath = join(projDir, ".mcp.json");
+      const channelsConfigPath = join(projDir, ".mcp-channels.json");
       const serverNames = [];
       for (const p of [mcpConfigPath, channelsConfigPath]) {
-        if (existsSync2(p)) {
+        if (existsSync(p)) {
           try {
-            const d = JSON.parse(readFileSync3(p, "utf-8"));
+            const d = JSON.parse(readFileSync(p, "utf-8"));
             if (d.mcpServers) serverNames.push(...Object.keys(d.mcpServers));
           } catch {
           }
@@ -3047,16 +2712,16 @@ async function processDirectChatMessage(agent, msg) {
         "--allowedTools",
         allowedTools
       ];
-      if (existsSync2(channelsConfigPath)) chatArgs.push("--mcp-config", channelsConfigPath);
-      const chatClaudeMd = join2(projDir, "CLAUDE.md");
-      if (existsSync2(chatClaudeMd)) {
+      if (existsSync(channelsConfigPath)) chatArgs.push("--mcp-config", channelsConfigPath);
+      const chatClaudeMd = join(projDir, "CLAUDE.md");
+      if (existsSync(chatClaudeMd)) {
         chatArgs.push("--system-prompt-file", chatClaudeMd);
       }
-      const envIntPath = join2(projDir, ".env.integrations");
+      const envIntPath = join(projDir, ".env.integrations");
       const childEnv = { ...process.env };
-      if (existsSync2(envIntPath)) {
+      if (existsSync(envIntPath)) {
         try {
-          for (const line of readFileSync3(envIntPath, "utf-8").split("\n")) {
+          for (const line of readFileSync(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);
@@ -3328,12 +2993,12 @@ function getBuiltInSkillContent(skillId) {
   if (builtInSkillCache.has(skillId)) return builtInSkillCache.get(skillId);
   try {
     const candidates = [
-      join2(process.cwd(), "skills", skillId, "SKILL.md"),
-      join2(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
+      join(process.cwd(), "skills", skillId, "SKILL.md"),
+      join(new URL(".", import.meta.url).pathname, "..", "..", "..", "..", "skills", skillId, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync2(candidate)) {
-        const content = readFileSync3(candidate, "utf-8");
+      if (existsSync(candidate)) {
+        const content = readFileSync(candidate, "utf-8");
         const files = [{ relativePath: "SKILL.md", content }];
         builtInSkillCache.set(skillId, files);
         return files;
@@ -3749,7 +3414,7 @@ function generateArtifacts(agent, refreshData, adapter) {
   return provisionOutput.artifacts;
 }
 async function cleanupAgentFiles(codeName, agentDir) {
-  if (existsSync2(agentDir)) {
+  if (existsSync(agentDir)) {
     try {
       rmSync(agentDir, { recursive: true, force: true });
       log(`Removed provision directory for '${codeName}'`);
@@ -3808,8 +3473,8 @@ var caffeinateProc = null;
 async function startCaffeinate() {
   if (process.platform !== "darwin") return;
   try {
-    const { spawn: spawn2 } = await import("child_process");
-    caffeinateProc = spawn2("caffeinate", ["-dims"], {
+    const { spawn } = await import("child_process");
+    caffeinateProc = spawn("caffeinate", ["-dims"], {
       stdio: "ignore",
       detached: false
     });
@@ -3860,8 +3525,8 @@ async function killAllAgtTmuxSessions() {
       ["list-sessions", "-F", "#{session_name}"],
       { timeout: 2e3, stdin: "ignore" }
     );
-    const sessions2 = output.trim().split("\n").filter((s) => s.startsWith("agt-"));
-    for (const session of sessions2) {
+    const sessions = output.trim().split("\n").filter((s) => s.startsWith("agt-"));
+    for (const session of sessions) {
       try {
         await execFilePromiseLong("tmux", ["kill-session", "-t", session], {
           timeout: 2e3,
@@ -3871,8 +3536,8 @@ async function killAllAgtTmuxSessions() {
       } catch {
       }
     }
-    if (sessions2.length > 0) {
-      log(`Cleaned up ${sessions2.length} agt-* tmux session(s)`);
+    if (sessions.length > 0) {
+      log(`Cleaned up ${sessions.length} agt-* tmux session(s)`);
     }
   } catch {
   }
@@ -3904,18 +3569,18 @@ function startManager(opts) {
   startPolling();
 }
 function deployMcpAssets() {
-  const targetDir = join2(homedir2(), ".augmented", "_mcp");
-  mkdirSync2(targetDir, { recursive: true });
-  const moduleDir = dirname2(fileURLToPath2(import.meta.url));
+  const targetDir = join(homedir(), ".augmented", "_mcp");
+  mkdirSync(targetDir, { recursive: true });
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
   let mcpSourceDir = "";
   let dir = moduleDir;
   for (let i = 0; i < 6; i++) {
-    const candidate = join2(dir, "mcp");
-    if (existsSync2(join2(candidate, "index.js"))) {
+    const candidate = join(dir, "mcp");
+    if (existsSync(join(candidate, "index.js"))) {
       mcpSourceDir = candidate;
       break;
     }
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3924,9 +3589,9 @@ function deployMcpAssets() {
     return;
   }
   for (const file of ["index.js", "slack-channel.js"]) {
-    const src = join2(mcpSourceDir, file);
-    const dst = join2(targetDir, file);
-    if (!existsSync2(src)) continue;
+    const src = join(mcpSourceDir, file);
+    const dst = join(targetDir, file);
+    if (!existsSync(src)) continue;
     try {
       copyFileSync(src, dst);
     } catch (err) {