@integrity-labs/agt-cli 0.7.8 → 0.7.10

package/dist/lib/manager-worker.js

@@ -9,7 +9,7 @@ import {
   provisionStopHook,
   requireHost,
   resolveChannels
-} from "../chunk-B47JW4MM.js";
+} from "../chunk-X3FLX6EO.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -17,11 +17,11 @@ import {
   loadSchedulerState,
   markTaskFired,
   syncTasksToScheduler
-} from "../chunk-4I4QZRBQ.js";
+} from "../chunk-5UGOY3IV.js";
 
 // src/lib/manager-worker.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, 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";
 
@@ -327,55 +327,30 @@ var GatewayClientPool = class extends EventEmitter {
 };
 
 // src/lib/persistent-session.ts
-import { spawn, execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { join } from "path";
 import { homedir } from "os";
-import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 var sessions = /* @__PURE__ */ new Map();
-function startPersistentSession(config2) {
-  const existing = sessions.get(config2.codeName);
-  if (existing && existing.status === "running" && existing.process && !existing.process.killed) {
-    return existing;
-  }
-  const session = {
-    codeName: config2.codeName,
-    process: null,
-    taskChannelPort: null,
-    startedAt: null,
-    restartCount: existing?.restartCount ?? 0,
-    status: "starting"
-  };
-  sessions.set(config2.codeName, session);
-  spawnSession(config2, session);
-  return session;
-}
-function spawnSession(config2, session) {
-  const { codeName, projectDir, mcpConfigPath, claudeMdPath, channels, devChannels, log: log2 } = config2;
-  sanitizeMcpJson(mcpConfigPath);
-  const args = [];
+function writeAcpxConfig(config2) {
+  const { projectDir, mcpConfigPath, claudeMdPath, channels, devChannels } = config2;
+  const claudeArgs = [];
   if (channels.length > 0) {
-    args.push("--channels", ...channels);
+    claudeArgs.push("--channels", ...channels);
   }
   if (devChannels.length > 0) {
-    args.push("--dangerously-load-development-channels", ...devChannels);
+    claudeArgs.push("--dangerously-load-development-channels", ...devChannels);
   }
-  args.push("--mcp-config", mcpConfigPath);
+  claudeArgs.push("--mcp-config", mcpConfigPath);
   const channelsConfigPath = join(projectDir, ".mcp-channels.json");
   if (existsSync(channelsConfigPath)) {
-    args.push("--mcp-config", channelsConfigPath);
+    claudeArgs.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", `agt-${codeName}`);
-  log2(`[persistent-session] Starting session for '${codeName}' with args: ${args.join(" ")}`);
-  const tmuxSession = `agt-${codeName}`;
-  try {
-    execSync(`tmux kill-session -t ${tmuxSession} 2>/dev/null`, { stdio: "ignore" });
-  } catch {
+    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)) {
@@ -385,138 +360,154 @@ function spawnSession(config2, session) {
         const eqIdx = line.indexOf("=");
         const key = line.slice(0, eqIdx);
         const value = line.slice(eqIdx + 1);
-        return `${key}=${JSON.stringify(value)}`;
+        return `${key}=${value.includes(" ") ? JSON.stringify(value) : 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(" ") ? 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
-  });
-  session.process = child;
-  session.startedAt = Date.now();
-  session.status = "running";
-  child.on("close", (code) => {
-    if (code !== 0) {
-      log2(`[persistent-session] Failed to create tmux session for '${codeName}' (exit ${code})`);
-      session.status = "crashed";
-      session.process = null;
-      return;
-    }
-    log2(`[persistent-session] tmux session '${tmuxSession}' created for '${codeName}'`);
-    const acceptDialogs = async () => {
-      for (let i = 0; i < 15; i++) {
-        await new Promise((r) => setTimeout(r, 2e3));
-        try {
-          const { execSync: es } = await import("child_process");
-          const screen = es(`tmux capture-pane -t ${tmuxSession} -p 2>/dev/null`, { encoding: "utf-8" });
-          if (screen.includes("Yes, I trust this folder")) {
-            es(`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")) {
-            es(`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")) {
-            es(`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")) {
-            es(`tmux send-keys -t ${tmuxSession} 2`, { stdio: "ignore" });
-            await new Promise((r) => setTimeout(r, 300));
-            es(`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;
-        }
+  const acpxConfig = {
+    defaultAgent: "claude",
+    defaultPermissions: "approve-all",
+    agents: {
+      claude: {
+        command: `${envPrefix}npx -y @agentclientprotocol/claude-agent-acp ${claudeArgs.join(" ")}`
       }
-    };
-    acceptDialogs().catch(() => {
+    }
+  };
+  writeFileSync2(join(projectDir, ".acpxrc.json"), JSON.stringify(acpxConfig, null, 2));
+}
+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, 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}'`);
+  try {
+    sanitizeMcpJson(mcpConfigPath, apiHost);
+    writeAcpxConfig(config2);
+    execFileSync("acpx", [
+      "claude",
+      "sessions",
+      "ensure",
+      "--name",
+      sessionName
+    ], {
+      cwd: projectDir,
+      timeout: 3e4,
+      stdio: "ignore"
     });
-  });
-  child.on("error", (err) => {
-    log2(`[persistent-session] Failed to start tmux for '${codeName}': ${err.message}`);
+    execFileSync("acpx", [
+      "claude",
+      "-s",
+      sessionName,
+      "--no-wait",
+      "--",
+      initPrompt
+    ], {
+      cwd: projectDir,
+      timeout: 3e4,
+      stdio: "ignore"
+    });
+    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}`);
     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 {
-    execSync(`tmux kill-session -t agt-${codeName} 2>/dev/null`, { stdio: "ignore" });
+    execFileSync("acpx", ["claude", "sessions", "close", `agt-${codeName}`], {
+      cwd: projectDir,
+      timeout: 1e4,
+      stdio: "ignore"
+    });
   } catch {
   }
-  if (session.process && !session.process.killed) {
-    session.process.kill("SIGTERM");
+  try {
+    execFileSync("tmux", ["kill-session", "-t", `agt-${codeName}`], { stdio: "ignore" });
+  } catch {
   }
-  setTimeout(() => {
-    if (session.process && !session.process.killed) {
-      session.process.kill("SIGKILL");
-    }
-  }, 1e4);
   sessions.delete(codeName);
 }
 async function injectMessage(codeName, type, content, meta) {
   const session = sessions.get(codeName);
-  if (!session || session.status !== "running" || !session.process) {
+  if (!session || session.status !== "running") {
     return false;
   }
-  if (session.taskChannelPort) {
-    try {
-      const res = await fetch(`http://127.0.0.1:${session.taskChannelPort}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ type, content, meta }),
-        signal: AbortSignal.timeout(1e4)
-      });
-      if (res.ok) return true;
-    } catch {
-    }
-  }
+  const projectDir = getProjectDir2(codeName);
+  const sessionName = `agt-${codeName}`;
+  const prefix = meta?.task_name ? `[Task: ${meta.task_name}] ` : "";
+  const text = prefix + content;
   try {
-    const prefix = meta?.task_name ? `[Task: ${meta.task_name}] ` : "";
-    const text = prefix + content;
-    const escaped = text.replace(/'/g, "'\\''");
-    execSync(`tmux send-keys -t agt-${codeName} '${escaped}' Enter`, { stdio: "ignore" });
+    execFileSync("acpx", [
+      "claude",
+      "-s",
+      sessionName,
+      "--no-wait",
+      "--",
+      text
+    ], {
+      cwd: projectDir,
+      timeout: 15e3,
+      stdio: "ignore"
+    });
     return true;
   } catch {
     return false;
   }
-  return false;
 }
 function isSessionHealthy(codeName) {
   const session = sessions.get(codeName);
   if (!session || session.status !== "running") return false;
+  const projectDir = getProjectDir2(codeName);
   try {
-    execSync(`tmux has-session -t agt-${codeName} 2>/dev/null`, { stdio: "ignore" });
-    return true;
+    const output = execFileSync("acpx", [
+      "claude",
+      "-s",
+      `agt-${codeName}`,
+      "status"
+    ], {
+      cwd: projectDir,
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    return output.includes("status: running") || output.includes("status: idle");
   } catch {
     session.status = "crashed";
+    session.startedAt = Date.now();
+    session.restartCount++;
     return false;
   }
 }
@@ -527,28 +518,10 @@ function resetRestartCount(codeName) {
 async function stopAllSessionsAndWait(log2, opts) {
   const codeNames = [...sessions.keys()];
   if (codeNames.length === 0) return;
-  const exitPromises = [];
   for (const codeName of codeNames) {
-    const session = sessions.get(codeName);
-    const proc = session?.process;
     stopPersistentSession(codeName, log2);
-    if (proc && !proc.killed && proc.exitCode === null) {
-      exitPromises.push(
-        new Promise((resolve) => {
-          proc.on("close", resolve);
-          proc.on("error", resolve);
-        })
-      );
-    }
   }
-  if (exitPromises.length === 0) return;
-  await Promise.race([
-    Promise.all(exitPromises),
-    new Promise((resolve) => setTimeout(() => {
-      log2(`[persistent-session] Shutdown timeout (${opts.timeoutMs}ms), force-killing remaining sessions`);
-      resolve();
-    }, opts.timeoutMs))
-  ]);
+  await new Promise((resolve) => setTimeout(resolve, Math.min(opts.timeoutMs, 2e3)));
 }
 function getProjectDir2(codeName) {
   return join(homedir(), ".augmented", codeName, "project");
@@ -874,16 +847,16 @@ 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 } = await import("child_process");
+  const { execFileSync: execFileSync2 } = await import("child_process");
   try {
-    execFileSync("which", [binary], { timeout: 5e3 });
+    execFileSync2("which", [binary], { timeout: 5e3 });
     frameworkBinaryChecked.add(`dep:${binary}`);
     return true;
   } catch {
   }
   let brewPath;
   try {
-    brewPath = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    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}`);
@@ -891,14 +864,14 @@ async function ensureBrewDependency(binary, formula) {
   }
   log(`${binary} not found \u2014 installing via Homebrew...`);
   try {
-    execFileSync(brewPath, ["install", formula], { timeout: 12e4, stdio: "pipe" });
+    execFileSync2(brewPath, ["install", formula], { timeout: 12e4, stdio: "pipe" });
   } catch (err) {
     log(`Failed to install ${formula}: ${err.message}`);
     frameworkBinaryChecked.add(`dep:${binary}`);
     return false;
   }
   try {
-    execFileSync("which", [binary], { timeout: 5e3 });
+    execFileSync2("which", [binary], { timeout: 5e3 });
     log(`${binary} installed successfully`);
     frameworkBinaryChecked.add(`dep:${binary}`);
     return true;
@@ -913,24 +886,24 @@ async function ensureFrameworkBinary(frameworkId) {
   if (frameworkBinaryChecked.has(frameworkId)) return;
   frameworkBinaryChecked.add(frameworkId);
   await ensureBrewDependency("tmux", "tmux");
-  const { execFileSync } = await import("child_process");
+  const { execFileSync: execFileSync2 } = await import("child_process");
   let brewPath;
   try {
-    brewPath = execFileSync("which", ["brew"], { timeout: 5e3 }).toString().trim();
+    brewPath = execFileSync2("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 {
-    execFileSync("which", ["claude"], { timeout: 5e3 });
+    execFileSync2("which", ["claude"], { timeout: 5e3 });
     claudeExists = true;
   } catch {
   }
   if (!claudeExists) {
     log("Claude Code binary not found \u2014 installing via Homebrew...");
     try {
-      execFileSync(brewPath, ["install", "--cask", "claude-code"], {
+      execFileSync2(brewPath, ["install", "--cask", "claude-code"], {
         timeout: 12e4,
         stdio: "pipe"
       });
@@ -939,7 +912,7 @@ async function ensureFrameworkBinary(frameworkId) {
       return;
     }
     try {
-      execFileSync("which", ["claude"], { timeout: 5e3 });
+      execFileSync2("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");
@@ -947,7 +920,7 @@ async function ensureFrameworkBinary(frameworkId) {
   } else {
     log("Checking for Claude Code updates...");
     try {
-      const output = execFileSync(brewPath, ["upgrade", "--cask", "claude-code"], {
+      const output = execFileSync2(brewPath, ["upgrade", "--cask", "claude-code"], {
         timeout: 12e4,
         stdio: "pipe"
       }).toString();
@@ -965,11 +938,11 @@ async function ensureFrameworkBinary(frameworkId) {
       }
     }
   }
-  agentRuntimeAuthenticated = checkClaudeAuth(execFileSync);
+  agentRuntimeAuthenticated = checkClaudeAuth(execFileSync2);
 }
-function checkClaudeAuth(execFileSync) {
+function checkClaudeAuth(execFileSync2) {
   try {
-    const authOutput = execFileSync("claude", ["auth", "status"], { timeout: 1e4, stdio: "pipe" }).toString().trim();
+    const authOutput = execFileSync2("claude", ["auth", "status"], { timeout: 1e4, stdio: "pipe" }).toString().trim();
     let loggedIn = null;
     try {
       const parsed = JSON.parse(authOutput);
@@ -1000,8 +973,8 @@ function loadGatewayPorts() {
   }
 }
 function saveGatewayPorts(ports) {
-  mkdirSync(AUGMENTED_DIR, { recursive: true });
-  writeFileSync2(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+  mkdirSync2(AUGMENTED_DIR, { recursive: true });
+  writeFileSync3(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
 }
 function allocatePort(codeName) {
   const ports = loadGatewayPorts();
@@ -1027,7 +1000,7 @@ var STATE_FILE = join2(process.env["HOME"] ?? "/tmp", ".augmented", "manager-sta
 function send(msg) {
   if (msg.type === "state-update") {
     try {
-      writeFileSync2(STATE_FILE, JSON.stringify(msg.state, null, 2));
+      writeFileSync3(STATE_FILE, JSON.stringify(msg.state, null, 2));
     } catch {
     }
   }
@@ -1083,9 +1056,9 @@ 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");
-      writeFileSync2(join2(profileAuthDir, "auth-profiles.json"), authContent);
+      writeFileSync3(join2(profileAuthDir, "auth-profiles.json"), authContent);
     }
     allocatePort(codeName);
     migrated++;
@@ -1180,7 +1153,7 @@ async function ensureGatewayRunning(codeName, adapter) {
             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 {
@@ -1205,7 +1178,7 @@ async function ensureGatewayRunning(codeName, adapter) {
         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 {
     }
@@ -1590,7 +1563,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);
@@ -1605,7 +1578,7 @@ async function processAgent(agent, agentStates) {
       const fileNames = changedFiles.map((f) => f.relativePath).join(", ");
       log(`${verb} '${agent.code_name}': ${fileNames}`);
       for (const file of changedFiles) {
-        writeFileSync2(join2(agentDir, file.relativePath), file.content);
+        writeFileSync3(join2(agentDir, file.relativePath), file.content);
       }
       lastProvisionAt = (/* @__PURE__ */ new Date()).toISOString();
       knownVersions.set(agent.agent_id, { charterVersion, toolsVersion });
@@ -1839,10 +1812,10 @@ async function processAgent(agent, agentStates) {
         const hasLcm = integrations.some((i) => i.definition_id === "lossless-claw");
         if (hasLcm && !losslessClawInstalled.get(agent.code_name)) {
           try {
-            const { execFileSync } = await import("child_process");
+            const { execFileSync: execFileSync2 } = await import("child_process");
             let pluginList;
             try {
-              pluginList = execFileSync(
+              pluginList = execFileSync2(
                 "openclaw",
                 ["--profile", agent.code_name, "plugins", "list", "--json"],
                 { timeout: 15e3 }
@@ -1856,7 +1829,7 @@ async function processAgent(agent, agentStates) {
             );
             if (!alreadyInstalled) {
               log(`Installing lossless-claw plugin for '${agent.code_name}'...`);
-              execFileSync(
+              execFileSync2(
                 "openclaw",
                 ["--profile", agent.code_name, "plugins", "install", "@martian-engineering/lossless-claw"],
                 { stdio: "ignore", timeout: 6e4 }
@@ -1903,18 +1876,18 @@ async function processAgent(agent, agentStates) {
             "@tobilu/qmd"
           ]);
           if (intHash !== prevIntHash) {
-            const { execFileSync } = await import("child_process");
+            const { execFileSync: execFileSync2 } = 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 {
-                execFileSync("which", [tool.binary], { stdio: "ignore" });
+                execFileSync2("which", [tool.binary], { stdio: "ignore" });
               } catch {
                 log(`Installing CLI tool '${tool.package}' for '${agent.code_name}'...`);
                 try {
-                  execFileSync("npm", ["install", "-g", tool.package], { stdio: "ignore", timeout: 6e4 });
+                  execFileSync2("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}`);
@@ -1923,7 +1896,7 @@ async function processAgent(agent, agentStates) {
               if (tool.binary === "qmd") {
                 try {
                   const agentDir2 = join2(process.env["HOME"] ?? "/tmp", ".augmented", agent.code_name);
-                  execFileSync("qmd", ["collection", "add", agent.code_name, "project"], {
+                  execFileSync2("qmd", ["collection", "add", agent.code_name, "project"], {
                     stdio: "ignore",
                     timeout: 3e4,
                     cwd: agentDir2
@@ -2304,7 +2277,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}`);
     }
@@ -2340,7 +2313,7 @@ function clearStaleCronRunState(jobsPath) {
       }
     }
     if (changed) {
-      writeFileSync2(jobsPath, JSON.stringify(data, null, 2));
+      writeFileSync3(jobsPath, JSON.stringify(data, null, 2));
     }
   } catch {
   }
@@ -2563,8 +2536,8 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
     }
   }
   if (!agentRuntimeAuthenticated) {
-    const { execFileSync } = await import("child_process");
-    agentRuntimeAuthenticated = checkClaudeAuth(execFileSync);
+    const { execFileSync: execFileSync2 } = await import("child_process");
+    agentRuntimeAuthenticated = checkClaudeAuth(execFileSync2);
     if (!agentRuntimeAuthenticated) {
       log(`[persistent-session] Skipping '${codeName}' \u2014 Claude Code not authenticated`);
       return;
@@ -2587,12 +2560,39 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       claudeMdPath,
       channels,
       devChannels,
+      apiHost: requireHost(),
       log
     });
     persistentSessionAgents.add(codeName);
     return;
   }
   resetRestartCount(codeName);
+  const stableTasksHash = createHash("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const prevHash = knownTasksHashes.get(agent.agent_id);
+  if (stableTasksHash !== prevHash) {
+    const taskInputs = tasks.map((t) => ({
+      id: t.id,
+      template_id: t.template_id,
+      name: t.name,
+      schedule_kind: t.schedule_kind,
+      schedule_expr: t.schedule_expr ?? null,
+      schedule_every: t.schedule_every ?? null,
+      schedule_at: t.schedule_at ?? null,
+      timezone: t.timezone ?? "UTC",
+      prompt: t.prompt ?? "",
+      session_target: t.session_target ?? "isolated",
+      delivery_mode: t.delivery_mode ?? "none",
+      delivery_channel: t.delivery_channel ?? null,
+      delivery_to: t.delivery_to ?? null,
+      enabled: t.enabled ?? true
+    }));
+    const schedulerState = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, schedulerState);
+    knownTasksHashes.set(agent.agent_id, stableTasksHash);
+    log(`[persistent-session] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
+  } else if (!claudeSchedulerStates.has(codeName)) {
+    claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
+  }
   const state2 = claudeSchedulerStates.get(codeName);
   if (state2) {
     const ready = getReadyTasks(state2);
@@ -2624,8 +2624,8 @@ 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 });
-        writeFileSync2(markerPath, JSON.stringify({
+        mkdirSync2(markerDir, { recursive: true });
+        writeFileSync3(markerPath, JSON.stringify({
           agent_id: agent.agent_id,
           task_id: task.taskId,
           template_id: task.templateId,
@@ -2643,35 +2643,13 @@ async function ensurePersistentSession(agent, tasks, boardItems, refreshData) {
       if (injected) {
         const updated = markTaskFired(codeName, task.taskId, "ok");
         claudeSchedulerStates.set(codeName, updated);
-        log(`[persistent-session] Task '${task.name}' injected, next fire at ${new Date(updated.tasks[task.taskId]?.nextFireAt ?? 0).toISOString()}`);
+        log(`[persistent-session] Task '${task.name}' injected for '${codeName}', next fire at ${new Date(updated.tasks[task.taskId]?.nextFireAt ?? 0).toISOString()}`);
+      } else {
+        log(`[persistent-session] Task '${task.name}' injection FAILED for '${codeName}' \u2014 injectMessage returned false`);
       }
       break;
     }
   }
-  const stableTasksHash = createHash("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
-  const prevHash = knownTasksHashes.get(agent.agent_id);
-  if (stableTasksHash !== prevHash) {
-    const taskInputs = tasks.map((t) => ({
-      id: t.id,
-      template_id: t.template_id,
-      name: t.name,
-      schedule_kind: t.schedule_kind,
-      schedule_expr: t.schedule_expr ?? null,
-      schedule_every: t.schedule_every ?? null,
-      schedule_at: t.schedule_at ?? null,
-      timezone: t.timezone ?? "UTC",
-      prompt: t.prompt ?? "",
-      session_target: t.session_target ?? "isolated",
-      delivery_mode: t.delivery_mode ?? "none",
-      delivery_channel: t.delivery_channel ?? null,
-      delivery_to: t.delivery_to ?? null,
-      enabled: t.enabled ?? true
-    }));
-    const schedulerState = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
-    claudeSchedulerStates.set(codeName, schedulerState);
-    knownTasksHashes.set(agent.agent_id, stableTasksHash);
-    log(`[persistent-session] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
-  }
 }
 var realtimeStarted = false;
 var realtimeDriftStarted = false;
@@ -2886,7 +2864,7 @@ async function processDirectChatMessage(agent, msg) {
   try {
     let reply;
     if (fw === "claude-code") {
-      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-APXMZEK4.js");
+      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-V2QNX3Z4.js");
       const projDir = ccProjectDir(agent.codeName);
       const chatArgs = [
         "-p",
@@ -3645,8 +3623,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
     });