@integrity-labs/agt-cli 0.7.12 → 0.8.0

package/dist/lib/manager-worker.js

@@ -9,7 +9,7 @@ import {
   provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-X3FLX6EO.js";
+} from "../chunk-55TMBRXT.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -21,7 +21,7 @@ import {
 
 // src/lib/manager-worker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync } from "fs";
 import https from "https";
 import { join as join2 } from "path";
 
@@ -45,10 +45,12 @@ function sanitizeMcpJson(mcpConfigPath, apiHost) {
           continue;
         }
       }
-      if (!val.type) {
-        val.type = "sse";
-        changed = true;
-      }
+      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;
@@ -327,73 +329,46 @@ var GatewayClientPool = class extends EventEmitter {
 };
 
 // src/lib/persistent-session.ts
-import { execFileSync, execSync } from "child_process";
+import { spawn, execSync, execFileSync } from "child_process";
 import { join, dirname } from "path";
 import { homedir } from "os";
-import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+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 localBin = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "node_modules", ".bin", "acpx");
-  if (existsSync(localBin)) {
-    _acpxBin = localBin;
-    return _acpxBin;
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  for (const candidate of [
+    join(moduleDir, "..", "..", "node_modules", ".bin", "acpx"),
+    join(moduleDir, "..", "..", "..", "..", "node_modules", ".bin", "acpx")
+  ]) {
+    if (existsSync(candidate)) {
+      _acpxBin = candidate;
+      return _acpxBin;
+    }
   }
   try {
     execSync("which acpx", { stdio: "ignore" });
     _acpxBin = "acpx";
     return _acpxBin;
   } catch {
-    throw new Error("acpx not found. Run: npm install -g acpx");
+    return "";
   }
 }
 var sessions = /* @__PURE__ */ new Map();
-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");
-  const envIntegrationsPath = join(projectDir, ".env.integrations");
-  let envPrefix = "";
-  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}=${value.includes(" ") ? JSON.stringify(value) : value}`;
-      }).join(" ");
-      if (envVars) envPrefix = `env ${envVars} `;
-    } catch {
-    }
-  }
-  const acpxConfig = {
-    defaultAgent: "claude",
-    defaultPermissions: "approve-all",
-    agents: {
-      claude: {
-        command: `${envPrefix}npx -y @agentclientprotocol/claude-agent-acp ${claudeArgs.join(" ")}`
-      }
-    }
-  };
-  writeFileSync2(join(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
-}
 function startPersistentSession(config2) {
   const existing = sessions.get(config2.codeName);
   if (existing && existing.status === "running") {
@@ -417,116 +392,219 @@ function startPersistentSession(config2) {
   return session;
 }
 function spawnSession(config2, session) {
-  const { codeName, projectDir, mcpConfigPath, apiHost, log: log2 } = config2;
-  const sessionName = `agt-${codeName}`;
-  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.";
-  log2(`[persistent-session] Starting acpx session '${sessionName}' for '${codeName}'`);
+  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);
-    execFileSync(getAcpxBin(), [
-      "claude",
-      "sessions",
-      "ensure",
-      "--name",
-      sessionName
-    ], {
-      cwd: projectDir,
-      timeout: 3e4,
-      stdio: "ignore"
-    });
-    execFileSync(getAcpxBin(), [
-      "claude",
+    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("--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 = `env ${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",
-      sessionName,
-      "--no-wait",
-      "--",
-      initPrompt
+      tmuxSession,
+      "-c",
+      projectDir,
+      claudeCmd
     ], {
       cwd: projectDir,
-      timeout: 3e4,
-      stdio: "ignore"
+      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;
-    log2(`[persistent-session] Session '${sessionName}' started for '${codeName}'`);
   } catch (err) {
-    log2(`[persistent-session] Failed to start acpx session for '${codeName}': ${err.message}`);
+    log2(`[persistent-session] Failed to start session for '${codeName}': ${err.message}`);
     session.status = "crashed";
     session.startedAt = Date.now();
     session.restartCount++;
   }
 }
-function stopPersistentSession(codeName, log2) {
-  const session = sessions.get(codeName);
-  if (!session) return;
-  log2(`[persistent-session] Stopping session for '${codeName}'`);
-  session.status = "stopped";
-  const projectDir = getProjectDir2(codeName);
-  try {
-    execFileSync(getAcpxBin(), ["claude", "sessions", "close", `agt-${codeName}`], {
-      cwd: projectDir,
-      timeout: 1e4,
-      stdio: "ignore"
-    });
-  } catch {
-  }
-  try {
-    execFileSync("tmux", ["kill-session", "-t", `agt-${codeName}`], { stdio: "ignore" });
-  } catch {
+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;
+    }
   }
-  sessions.delete(codeName);
 }
 async function injectMessage(codeName, type, content, meta) {
   const session = sessions.get(codeName);
   if (!session || session.status !== "running") {
     return false;
   }
-  const projectDir = getProjectDir2(codeName);
-  const sessionName = `agt-${codeName}`;
   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);
+      execFileSync(acpx, [
+        "claude",
+        "exec",
+        "--cwd",
+        projectDir,
+        "-f",
+        tmpFile
+      ], {
+        cwd: projectDir,
+        timeout: 3e5,
+        // 5 min for task execution
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+    }
+  }
   try {
-    execFileSync(getAcpxBin(), [
-      "claude",
-      "-s",
-      sessionName,
-      "--no-wait",
-      "--",
-      text
-    ], {
-      cwd: projectDir,
-      timeout: 15e3,
-      stdio: "ignore"
-    });
-    return true;
+    execFileSync("tmux", ["send-keys", "-t", `agt-${codeName}`, text, "Enter"], { stdio: "ignore" });
+    return false;
   } catch {
     return false;
   }
 }
-function isSessionHealthy(codeName) {
+function stopPersistentSession(codeName, log2) {
   const session = sessions.get(codeName);
-  if (!session || session.status !== "running") return false;
-  const projectDir = getProjectDir2(codeName);
+  if (!session) return;
+  log2(`[persistent-session] Stopping session for '${codeName}'`);
+  session.status = "stopped";
   try {
-    const output = execFileSync(getAcpxBin(), [
-      "claude",
-      "-s",
-      `agt-${codeName}`,
-      "status"
-    ], {
-      cwd: projectDir,
-      timeout: 1e4,
-      encoding: "utf-8"
-    });
-    return output.includes("status: running") || output.includes("status: idle");
+    execSync(`tmux kill-session -t agt-${codeName} 2>/dev/null`, { stdio: "ignore" });
   } catch {
-    session.status = "crashed";
-    session.startedAt = Date.now();
-    session.restartCount++;
+  }
+  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);
@@ -543,6 +621,47 @@ async function stopAllSessionsAndWait(log2, opts) {
 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");
+  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);
+  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 = `env ${envVars} `;
+    } catch {
+    }
+  }
+  const acpxConfig = {
+    defaultAgent: "claude",
+    defaultPermissions: "approve-all",
+    agents: {
+      claude: {
+        command: `${envPrefix}npx -y @agentclientprotocol/claude-agent-acp ${claudeArgs.map((a) => a.includes(" ") || a.includes("*") ? JSON.stringify(a) : a).join(" ")}`
+      }
+    }
+  };
+  writeFileSync2(join(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
+}
 
 // src/lib/realtime-chat.ts
 import { createClient } from "@supabase/supabase-js";
@@ -800,7 +919,6 @@ var knownChannelConfigHashes = /* @__PURE__ */ new Map();
 var knownModels = /* @__PURE__ */ new Map();
 var knownTasksHashes = /* @__PURE__ */ new Map();
 var knownIntegrationHashes = /* @__PURE__ */ new Map();
-var losslessClawInstalled = /* @__PURE__ */ new Map();
 var knownSkillHashes = /* @__PURE__ */ new Map();
 var lastCronRunTs = /* @__PURE__ */ new Map();
 var lastWorkTriggerAt = /* @__PURE__ */ new Map();
@@ -841,7 +959,6 @@ function clearAgentCaches(agentId, codeName) {
   knownModels.delete(agentId);
   knownTasksHashes.delete(agentId);
   knownIntegrationHashes.delete(agentId);
-  losslessClawInstalled.delete(codeName);
   agentDisplayNames.delete(codeName);
   codeNameToAgentId.delete(codeName);
   agentFrameworkCache.delete(codeName);
@@ -862,47 +979,10 @@ function clearAgentCaches(agentId, codeName) {
 var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
-async function ensureBrewDependency(binary, formula) {
-  if (frameworkBinaryChecked.has(`dep:${binary}`)) return true;
-  const { execFileSync: execFileSync2 } = await import("child_process");
-  try {
-    execFileSync2("which", [binary], { timeout: 5e3 });
-    frameworkBinaryChecked.add(`dep:${binary}`);
-    return true;
-  } catch {
-  }
-  let brewPath;
-  try {
-    brewPath = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
-  } catch {
-    log(`${binary} not found and Homebrew not available \u2014 install manually: brew install ${formula}`);
-    frameworkBinaryChecked.add(`dep:${binary}`);
-    return false;
-  }
-  log(`${binary} not found \u2014 installing via Homebrew...`);
-  try {
-    execFileSync2(brewPath, ["install", formula], { timeout: 12e4, stdio: "pipe" });
-  } catch (err) {
-    log(`Failed to install ${formula}: ${err.message}`);
-    frameworkBinaryChecked.add(`dep:${binary}`);
-    return false;
-  }
-  try {
-    execFileSync2("which", [binary], { timeout: 5e3 });
-    log(`${binary} installed successfully`);
-    frameworkBinaryChecked.add(`dep:${binary}`);
-    return true;
-  } catch {
-    log(`${formula} install completed but ${binary} not found on PATH`);
-    frameworkBinaryChecked.add(`dep:${binary}`);
-    return false;
-  }
-}
 async function ensureFrameworkBinary(frameworkId) {
   if (frameworkId !== "claude-code") return;
   if (frameworkBinaryChecked.has(frameworkId)) return;
   frameworkBinaryChecked.add(frameworkId);
-  await ensureBrewDependency("tmux", "tmux");
   const { execFileSync: execFileSync2 } = await import("child_process");
   let brewPath;
   try {
@@ -957,6 +1037,59 @@ async function ensureFrameworkBinary(frameworkId) {
   }
   agentRuntimeAuthenticated = checkClaudeAuth(execFileSync2);
 }
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var selfUpdateChecked = false;
+async function checkAndUpdateCli() {
+  if (selfUpdateChecked) return;
+  selfUpdateChecked = true;
+  const cliPath = process.argv[1] ?? "";
+  const isHomebrew = cliPath.includes("/Cellar/") || cliPath.includes("/homebrew/");
+  const isDevMode = cliPath.includes("/src/") || cliPath.includes("tsx");
+  if (isDevMode) return;
+  if (!isHomebrew && !cliPath.includes("node_modules")) return;
+  const { homedir: homedir2 } = await import("os");
+  const { readFileSync: readF, writeFileSync: writeF } = await import("fs");
+  const markerPath = join2(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");
+  let brewPath;
+  try {
+    brewPath = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();
+  } catch {
+    return;
+  }
+  try {
+    const outdated = execFileSync2(brewPath, ["outdated", "--json=v2"], {
+      timeout: 3e4,
+      encoding: "utf-8"
+    });
+    const data = JSON.parse(outdated);
+    const agtOutdated = data.formulae?.find((f) => f.name === "agt" || f.name === "integrity-labs/tap/agt");
+    if (agtOutdated) {
+      const installed = agtOutdated.installed_versions?.[0] ?? "unknown";
+      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"], {
+          timeout: 12e4,
+          stdio: "pipe"
+        });
+        log(`[self-update] agt CLI upgraded to ${latest}. Restart the manager to use the new version.`);
+      } catch (err) {
+        log(`[self-update] Upgrade failed: ${err.message}`);
+      }
+    }
+  } catch {
+  }
+  try {
+    writeF(markerPath, String(Date.now()));
+  } catch {
+  }
+}
 function checkClaudeAuth(execFileSync2) {
   try {
     const authOutput = execFileSync2("claude", ["auth", "status"], { timeout: 1e4, stdio: "pipe" }).toString().trim();
@@ -990,7 +1123,7 @@ function loadGatewayPorts() {
   }
 }
 function saveGatewayPorts(ports) {
-  mkdirSync(AUGMENTED_DIR, { recursive: true });
+  mkdirSync2(AUGMENTED_DIR, { recursive: true });
   writeFileSync3(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
@@ -1073,7 +1206,7 @@ async function migrateToProfiles() {
     const profileAuthDir = join2(profileDir, "agents", codeName, "agent");
     const authFile = join2(sharedAuthDir, "auth-profiles.json");
     if (existsSync2(authFile)) {
-      mkdirSync(profileAuthDir, { recursive: true });
+      mkdirSync2(profileAuthDir, { recursive: true });
       const authContent = readFileSync3(authFile, "utf-8");
       writeFileSync3(join2(profileAuthDir, "auth-profiles.json"), authContent);
     }
@@ -1580,7 +1713,7 @@ async function processAgent(agent, agentStates) {
   try {
     const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
     const changedFiles = [];
-    mkdirSync(agentDir, { recursive: true });
+    mkdirSync2(agentDir, { recursive: true });
     for (const artifact of artifacts) {
       const filePath = join2(agentDir, artifact.relativePath);
       const newHash = sha256(artifact.content);
@@ -1787,6 +1920,14 @@ async function processAgent(agent, agentStates) {
         }
         knownIntegrationHashes.set(agent.agent_id, intHash);
         log(`Integrations provisioned for '${agent.code_name}' (${integrations.length} integration(s))`);
+        const fw = agentFrameworkCache.get(agent.code_name) ?? "openclaw";
+        if (fw === "claude-code" && isSessionHealthy(agent.code_name)) {
+          const names = integrations.map((i) => i.display_name || i.definition_id).join(", ");
+          injectMessage(agent.code_name, "system", `Your integrations have been updated. You now have access to: ${names}. Re-read your CLAUDE.md for details.`, {
+            task_name: "integration-update"
+          }).catch(() => {
+          });
+        }
         const managedIntegrations = integrations.filter((i) => i.auth_type === "managed");
         if (managedIntegrations.length > 0 && frameworkAdapter.writeMcpServer) {
           try {
@@ -1796,11 +1937,12 @@ async function processAgent(agent, agentStates) {
               if (tk.agent_id !== agent.agent_id) continue;
               const serverId = tk.toolkit_id.replace(/\//g, "-");
               expectedServerIds.add(serverId);
+              const mcpUrl = tk.mcp_url;
+              const mcpHeaders = tk.mcp_headers;
               const proxyUrl = tk.proxy_url.startsWith("/") ? `${requireHost()}${tk.proxy_url}` : tk.proxy_url;
-              frameworkAdapter.writeMcpServer(agent.code_name, serverId, {
-                url: proxyUrl
-              });
-              log(`[managed-toolkit] ${agent.code_name}: ${tk.toolkit_name} \u2192 ${proxyUrl}`);
+              const url = mcpUrl ?? proxyUrl;
+              frameworkAdapter.writeMcpServer(agent.code_name, serverId, { url, headers: mcpHeaders });
+              log(`[managed-toolkit] ${agent.code_name}: ${tk.toolkit_name} \u2192 ${url}`);
             }
             if (frameworkAdapter.removeMcpServer) {
               try {
@@ -1826,38 +1968,6 @@ async function processAgent(agent, agentStates) {
           }
         }
         needsGatewayRestart = true;
-        const hasLcm = integrations.some((i) => i.definition_id === "lossless-claw");
-        if (hasLcm && !losslessClawInstalled.get(agent.code_name)) {
-          try {
-            const { execFileSync: execFileSync2 } = await import("child_process");
-            let pluginList;
-            try {
-              pluginList = execFileSync2(
-                "openclaw",
-                ["--profile", agent.code_name, "plugins", "list", "--json"],
-                { timeout: 15e3 }
-              ).toString();
-            } catch {
-              pluginList = "[]";
-            }
-            const installed = JSON.parse(pluginList);
-            const alreadyInstalled = installed.some(
-              (p) => p.name === "lossless-claw" || p.name === "@martian-engineering/lossless-claw"
-            );
-            if (!alreadyInstalled) {
-              log(`Installing lossless-claw plugin for '${agent.code_name}'...`);
-              execFileSync2(
-                "openclaw",
-                ["--profile", agent.code_name, "plugins", "install", "@martian-engineering/lossless-claw"],
-                { stdio: "ignore", timeout: 6e4 }
-              );
-              log(`lossless-claw plugin installed for '${agent.code_name}'`);
-            }
-            losslessClawInstalled.set(agent.code_name, true);
-          } catch (pluginErr) {
-            log(`lossless-claw plugin install failed for '${agent.code_name}': ${pluginErr.message}`);
-          }
-        }
       }
       const resolvedDefIds = new Set(integrations.map((i) => i.definition_id));
       for (const capId of resolvedDefIds) {
@@ -2641,7 +2751,7 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       const markerDir = join2(projectDir2, ".claude");
       const markerPath = join2(markerDir, ".agt-pending-task.json");
       try {
-        mkdirSync(markerDir, { recursive: true });
+        mkdirSync2(markerDir, { recursive: true });
         writeFileSync3(markerPath, JSON.stringify({
           agent_id: agent.agent_id,
           task_id: task.taskId,
@@ -3640,8 +3750,8 @@ var caffeinateProc = null;
 async function startCaffeinate() {
   if (process.platform !== "darwin") return;
   try {
-    const { spawn } = await import("child_process");
-    caffeinateProc = spawn("caffeinate", ["-dims"], {
+    const { spawn: spawn2 } = await import("child_process");
+    caffeinateProc = spawn2("caffeinate", ["-dims"], {
       stdio: "ignore",
       detached: false
     });
@@ -3671,6 +3781,7 @@ function startPolling() {
   running = true;
   void startCaffeinate();
   log(`Starting poll loop (interval=${config.intervalMs}ms, configDir=${config.configDir})`);
+  checkAndUpdateCli().catch((err) => log(`[self-update] Check failed: ${err.message}`));
   void migrateToProfiles().then(() => {
     startGatewayPool();
     return pollCycle();