@integrity-labs/agt-cli 0.6.6

package/dist/lib/manager-worker.js

@@ -0,0 +1,3403 @@
+import {
+  api,
+  exchangeApiKey,
+  extractFrontmatter,
+  getApiKey,
+  getFramework,
+  getHostId,
+  provision,
+  requireHost,
+  resolveChannels
+} from "../chunk-EUF2V4N5.js";
+import {
+  findTaskByTemplate,
+  getProjectDir,
+  getReadyTasks,
+  loadSchedulerState,
+  markTaskFired,
+  syncTasksToScheduler
+} from "../chunk-4I4QZRBQ.js";
+
+// src/lib/manager-worker.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2, rmSync, readdirSync, statSync, unlinkSync } from "fs";
+import https from "https";
+import { join as join2 } from "path";
+
+// src/lib/gateway-client.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+var DEFAULT_PORT = 18789;
+var RECONNECT_INITIAL_MS = 1e3;
+var RECONNECT_BASE_MS = 5e3;
+var RECONNECT_MAX_MS = 3e4;
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var GatewayClient = class extends EventEmitter {
+  port;
+  token;
+  ws = null;
+  _connected = false;
+  _everConnected = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  pongReceived = true;
+  intentionalClose = false;
+  pendingRpc = /* @__PURE__ */ new Map();
+  rpcSeq = 0;
+  constructor(options = {}) {
+    super();
+    this.port = options.port ?? Number(process.env["OPENCLAW_GATEWAY_PORT"]) ?? DEFAULT_PORT;
+    this.token = options.token ?? process.env["OPENCLAW_GATEWAY_TOKEN"];
+  }
+  get connected() {
+    return this._connected;
+  }
+  connect() {
+    this.intentionalClose = false;
+    this.doConnect();
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    this.clearTimers();
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws.close(1e3);
+      this.ws = null;
+    }
+    if (this._connected) {
+      this._connected = false;
+      this.emit("disconnected");
+    }
+  }
+  // ── Private ──────────────────────────────────────────────────────────────
+  doConnect() {
+    const url = `ws://127.0.0.1:${this.port}`;
+    try {
+      const headers = {};
+      if (this.token) {
+        headers["Authorization"] = `Bearer ${this.token}`;
+      }
+      this.ws = new WebSocket(url, { headers });
+    } catch (err) {
+      this.emit("error", err);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.on("open", () => {
+    });
+    this.ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.handleMessage(msg);
+      } catch {
+      }
+    });
+    this.ws.on("close", (code, reason) => {
+      this.clearHeartbeat();
+      if (this._connected) {
+        this._connected = false;
+        this.emit("disconnected");
+      } else if (!this._everConnected) {
+        this.emit("error", new Error(`WebSocket closed before auth (code=${code}, reason=${reason?.toString() || "none"})`));
+      }
+      if (!this.intentionalClose) {
+        this.scheduleReconnect();
+      }
+    });
+    this.ws.on("error", (err) => {
+      if (!this._everConnected && err.code === "ECONNREFUSED") {
+        return;
+      }
+      this.emit("error", err);
+    });
+    this.ws.on("pong", () => {
+      this.pongReceived = true;
+    });
+  }
+  handleMessage(msg) {
+    switch (msg.type) {
+      case "challenge":
+        this.sendJson({
+          type: "connect",
+          nonce: msg.nonce,
+          role: "operator",
+          scopes: ["events:read"]
+        });
+        break;
+      case "hello-ok":
+        this._connected = true;
+        this._everConnected = true;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        this.emit("connected");
+        break;
+      case "event":
+        this.emit("event", {
+          type: "event",
+          event: msg.event,
+          payload: msg.payload,
+          seq: msg.seq,
+          stateVersion: msg.stateVersion
+        });
+        break;
+      case "heartbeat":
+      case "tick":
+        break;
+      case "rpc-result":
+      case "rpc-error": {
+        const rpcId = msg.id;
+        const pending = this.pendingRpc.get(rpcId);
+        if (pending) {
+          this.pendingRpc.delete(rpcId);
+          clearTimeout(pending.timer);
+          if (msg.type === "rpc-error") {
+            pending.reject(new Error(msg.error ?? "RPC error"));
+          } else {
+            pending.resolve(msg.result);
+          }
+        }
+        break;
+      }
+      default:
+        if (msg.id && typeof msg.id === "string") {
+          const pending = this.pendingRpc.get(msg.id);
+          if (pending) {
+            this.pendingRpc.delete(msg.id);
+            clearTimeout(pending.timer);
+            if (msg.error) {
+              pending.reject(new Error(String(msg.error)));
+            } else {
+              pending.resolve(msg);
+            }
+          }
+        }
+        break;
+    }
+  }
+  /**
+   * Send an RPC call to the gateway and wait for a response.
+   * Returns the response payload or throws on timeout/error.
+   */
+  sendRpc(method, params = {}, timeoutMs = 1e4) {
+    return new Promise((resolve, reject) => {
+      if (!this._connected || this.ws?.readyState !== WebSocket.OPEN) {
+        reject(new Error("Gateway not connected"));
+        return;
+      }
+      const id = `rpc-${++this.rpcSeq}-${Date.now()}`;
+      const timer = setTimeout(() => {
+        this.pendingRpc.delete(id);
+        reject(new Error(`RPC ${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingRpc.set(id, { resolve, reject, timer });
+      this.sendJson({ type: "rpc", id, method, params });
+    });
+  }
+  sendJson(obj) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(obj));
+    }
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.pongReceived = true;
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.pongReceived) {
+        this.ws?.terminate();
+        return;
+      }
+      this.pongReceived = false;
+      this.ws?.ping();
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.intentionalClose) return;
+    const delay = this.reconnectAttempts === 0 ? RECONNECT_INITIAL_MS : Math.min(RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts - 1), RECONNECT_MAX_MS);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.doConnect();
+    }, delay);
+  }
+  clearTimers() {
+    this.clearHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+var GatewayClientPool = class extends EventEmitter {
+  clients = /* @__PURE__ */ new Map();
+  addAgent(codeName, port, token) {
+    if (this.clients.has(codeName)) {
+      this.removeAgent(codeName);
+    }
+    const client2 = new GatewayClient({ port, token });
+    client2.on("connected", () => {
+      this.emit("connected", codeName);
+    });
+    client2.on("disconnected", () => {
+      this.emit("disconnected", codeName);
+    });
+    client2.on("error", (err) => {
+      this.emit("error", err, codeName);
+    });
+    client2.on("event", (evt) => {
+      const pooledEvent = {
+        ...evt,
+        agentCodeName: codeName
+      };
+      this.emit("event", pooledEvent);
+    });
+    this.clients.set(codeName, client2);
+    client2.connect();
+  }
+  removeAgent(codeName) {
+    const client2 = this.clients.get(codeName);
+    if (client2) {
+      client2.disconnect();
+      this.clients.delete(codeName);
+    }
+  }
+  hasAgent(codeName) {
+    return this.clients.has(codeName);
+  }
+  isConnected(codeName) {
+    return this.clients.get(codeName)?.connected ?? false;
+  }
+  /**
+   * Send an RPC call to a specific agent's gateway.
+   * Returns the response or throws on timeout/error/not connected.
+   */
+  async sendRpc(codeName, method, params = {}, timeoutMs = 1e4) {
+    const client2 = this.clients.get(codeName);
+    if (!client2) throw new Error(`No gateway client for agent '${codeName}'`);
+    return client2.sendRpc(method, params, timeoutMs);
+  }
+  disconnectAll() {
+    for (const [, client2] of this.clients) {
+      client2.disconnect();
+    }
+    this.clients.clear();
+  }
+  get size() {
+    return this.clients.size;
+  }
+};
+
+// src/lib/persistent-session.ts
+import { spawn, execSync } from "child_process";
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync } 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;
+  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", `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 {
+  }
+  const envIntegrationsPath = join(projectDir, ".env.integrations");
+  let envPrefix = "";
+  if (existsSync(envIntegrationsPath)) {
+    try {
+      const envContent = readFileSync(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(" ") ? 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;
+        }
+      }
+    };
+    acceptDialogs().catch(() => {
+    });
+  });
+  child.on("error", (err) => {
+    log2(`[persistent-session] Failed to start tmux for '${codeName}': ${err.message}`);
+    session.status = "crashed";
+  });
+}
+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 {
+  }
+  if (session.process && !session.process.killed) {
+    session.process.kill("SIGTERM");
+  }
+  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) {
+    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 {
+    }
+  }
+  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" });
+    return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
+function isSessionHealthy(codeName) {
+  const session = sessions.get(codeName);
+  if (!session || session.status !== "running") return false;
+  try {
+    execSync(`tmux has-session -t agt-${codeName} 2>/dev/null`, { stdio: "ignore" });
+    return true;
+  } catch {
+    session.status = "crashed";
+    return false;
+  }
+}
+function resetRestartCount(codeName) {
+  const session = sessions.get(codeName);
+  if (session) session.restartCount = 0;
+}
+function getProjectDir2(codeName) {
+  return join(homedir(), ".augmented", codeName, "project");
+}
+
+// src/lib/realtime-chat.ts
+import { createClient } from "@supabase/supabase-js";
+var client = null;
+var chatChannel = null;
+var driftChannel = null;
+var assignChannel = null;
+var configChannel = null;
+var kanbanChannel = null;
+var connected = false;
+var tearingDown = false;
+function ensureClient(config2) {
+  if (client) return client;
+  client = createClient(config2.supabaseUrl, config2.supabaseAnonKey, {
+    global: {
+      headers: { Authorization: `Bearer ${config2.token}` }
+    },
+    realtime: {
+      params: { apikey: config2.supabaseAnonKey }
+    }
+  });
+  client.realtime.setAuth(config2.token);
+  return client;
+}
+function startRealtimeChat(config2) {
+  const { agentIds, onMessage, onStatusChange, log: log2 } = config2;
+  if (agentIds.length === 0) return;
+  const sb = ensureClient(config2);
+  const filterStr = agentIds.length === 1 ? `agent_id=eq.${agentIds[0]}` : `agent_id=in.(${agentIds.join(",")})`;
+  chatChannel = sb.channel("direct-chat-realtime").on("postgres_changes", {
+    event: "INSERT",
+    schema: "public",
+    table: "direct_chat_messages",
+    filter: filterStr
+  }, (payload) => {
+    const msg = payload.new;
+    if (msg.status !== "pending") return;
+    log2(`[realtime] Chat message for agent ${msg.agent_id}: id=${msg.id}`);
+    onMessage(msg);
+  }).subscribe((status) => {
+    if (status === "SUBSCRIBED") {
+      connected = true;
+      log2("[realtime] Chat channel connected");
+      onStatusChange("connected");
+    } else if (status === "CLOSED" || status === "CHANNEL_ERROR" || status === "TIMED_OUT") {
+      if (tearingDown) return;
+      connected = false;
+      log2(`[realtime] Chat channel: ${status} \u2014 will reconnect next cycle`);
+      chatChannel = null;
+      driftChannel = null;
+      assignChannel = null;
+      configChannel = null;
+      kanbanChannel = null;
+      if (client) {
+        try {
+          client.removeAllChannels();
+        } catch {
+        }
+        client = null;
+      }
+      onStatusChange(status === "TIMED_OUT" ? "error" : "disconnected");
+    }
+  });
+  log2(`[realtime] Subscribing to direct_chat_messages for ${agentIds.length} agent(s)`);
+}
+function startRealtimeDrift(config2) {
+  const { agentIds, onDrift, log: log2 } = config2;
+  if (agentIds.length === 0) return;
+  const sb = ensureClient(config2);
+  const filterStr = agentIds.length === 1 ? `agent_id=eq.${agentIds[0]}` : `agent_id=in.(${agentIds.join(",")})`;
+  driftChannel = sb.channel("drift-realtime").on("postgres_changes", {
+    event: "INSERT",
+    schema: "public",
+    table: "agent_doc_versions",
+    filter: filterStr
+  }, (payload) => {
+    const doc = payload.new;
+    log2(`[realtime] Doc version change for agent ${doc.agent_id}: ${doc.doc_type} v${doc.version}`);
+    onDrift(doc);
+  }).subscribe((status) => {
+    if (status === "SUBSCRIBED") {
+      log2("[realtime] Drift channel connected");
+    } else if (status === "CLOSED" || status === "CHANNEL_ERROR") {
+      log2(`[realtime] Drift channel: ${status}`);
+    }
+  });
+  log2(`[realtime] Subscribing to agent_doc_versions for ${agentIds.length} agent(s)`);
+}
+function startRealtimeAssignments(config2) {
+  const { hostId, onAssign, onUnassign, log: log2 } = config2;
+  const sb = ensureClient(config2);
+  assignChannel = sb.channel("assignment-realtime").on("postgres_changes", {
+    event: "INSERT",
+    schema: "public",
+    table: "host_agents",
+    filter: `host_id=eq.${hostId}`
+  }, (payload) => {
+    const row = payload.new;
+    log2(`[realtime] Agent assigned: ${row.agent_id} to host ${row.host_id}`);
+    onAssign(row);
+  }).on("postgres_changes", {
+    event: "DELETE",
+    schema: "public",
+    table: "host_agents"
+  }, (payload) => {
+    const old = payload.old;
+    if (old.host_id === hostId && old.agent_id) {
+      log2(`[realtime] Agent unassigned: ${old.agent_id} from host ${hostId}`);
+      onUnassign({ agent_id: old.agent_id });
+    }
+  }).subscribe((status) => {
+    if (status === "SUBSCRIBED") {
+      log2("[realtime] Assignment channel connected");
+    } else if (status === "CLOSED" || status === "CHANNEL_ERROR") {
+      log2(`[realtime] Assignment channel: ${status}`);
+    }
+  });
+  log2(`[realtime] Subscribing to host_agents for host ${hostId}`);
+}
+function startRealtimeConfig(config2) {
+  const { agentIds, onConfigChange, log: log2 } = config2;
+  if (agentIds.length === 0) return;
+  const sb = ensureClient(config2);
+  const filterStr = agentIds.length === 1 ? `agent_id=eq.${agentIds[0]}` : `agent_id=in.(${agentIds.join(",")})`;
+  const lastKnown = /* @__PURE__ */ new Map();
+  configChannel = sb.channel("config-realtime").on("postgres_changes", {
+    event: "UPDATE",
+    schema: "public",
+    table: "agents",
+    filter: filterStr
+  }, (payload) => {
+    const agent = payload.new;
+    const fingerprint = `${agent.status}|${agent.framework}|${agent.session_mode}|${agent.primary_model}`;
+    const prev = lastKnown.get(agent.agent_id);
+    if (prev === fingerprint) return;
+    lastKnown.set(agent.agent_id, fingerprint);
+    log2(`[realtime] Agent config changed: ${agent.code_name} (status=${agent.status})`);
+    onConfigChange(agent);
+  }).subscribe((status) => {
+    if (status === "SUBSCRIBED") {
+      log2("[realtime] Config channel connected");
+    } else if (status === "CLOSED" || status === "CHANNEL_ERROR") {
+      log2(`[realtime] Config channel: ${status}`);
+    }
+  });
+  log2(`[realtime] Subscribing to agents table for ${agentIds.length} agent(s)`);
+}
+function startRealtimeKanban(config2) {
+  const { agentIds, onTodayItem, log: log2 } = config2;
+  if (agentIds.length === 0) return;
+  const sb = ensureClient(config2);
+  const filterStr = agentIds.length === 1 ? `agent_id=eq.${agentIds[0]}` : `agent_id=in.(${agentIds.join(",")})`;
+  kanbanChannel = sb.channel("kanban-realtime").on("postgres_changes", {
+    event: "INSERT",
+    schema: "public",
+    table: "agent_kanban_items",
+    filter: filterStr
+  }, (payload) => {
+    const item = payload.new;
+    if (item.status === "today") {
+      log2(`[realtime] New kanban item in 'today': "${item.title}" for agent ${item.agent_id}`);
+      onTodayItem(item);
+    }
+  }).on("postgres_changes", {
+    event: "UPDATE",
+    schema: "public",
+    table: "agent_kanban_items",
+    filter: filterStr
+  }, (payload) => {
+    const item = payload.new;
+    const old = payload.old;
+    if (item.status === "today" && old.status !== "today") {
+      log2(`[realtime] Kanban item moved to 'today': "${item.title}" for agent ${item.agent_id}`);
+      onTodayItem(item);
+    }
+  }).subscribe((status) => {
+    if (status === "SUBSCRIBED") {
+      log2("[realtime] Kanban channel connected");
+    } else if (status === "CLOSED" || status === "CHANNEL_ERROR") {
+      log2(`[realtime] Kanban channel: ${status}`);
+    }
+  });
+  log2(`[realtime] Subscribing to agent_kanban_items for ${agentIds.length} agent(s)`);
+}
+function isRealtimeConnected() {
+  return connected;
+}
+function stopRealtimeChat() {
+  if (tearingDown) return;
+  tearingDown = true;
+  try {
+    if (chatChannel) {
+      try {
+        chatChannel.unsubscribe();
+      } catch {
+      }
+      chatChannel = null;
+    }
+    if (driftChannel) {
+      try {
+        driftChannel.unsubscribe();
+      } catch {
+      }
+      driftChannel = null;
+    }
+    if (assignChannel) {
+      try {
+        assignChannel.unsubscribe();
+      } catch {
+      }
+      assignChannel = null;
+    }
+    if (configChannel) {
+      try {
+        configChannel.unsubscribe();
+      } catch {
+      }
+      configChannel = null;
+    }
+    if (kanbanChannel) {
+      try {
+        kanbanChannel.unsubscribe();
+      } catch {
+      }
+      kanbanChannel = null;
+    }
+    if (client) {
+      try {
+        client.removeAllChannels();
+      } catch {
+      }
+      client = null;
+    }
+    connected = false;
+  } finally {
+    tearingDown = false;
+  }
+}
+
+// src/lib/manager-worker.ts
+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 config = null;
+var running = false;
+var pollTimer = null;
+var knownVersions = /* @__PURE__ */ new Map();
+var knownStatuses = /* @__PURE__ */ new Map();
+var knownChannels = /* @__PURE__ */ new Map();
+var writtenHashes = /* @__PURE__ */ new Map();
+var knownSecretsHashes = /* @__PURE__ */ new Map();
+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();
+var alertedStaleItems = /* @__PURE__ */ new Set();
+var apiKeyStatusCache = /* @__PURE__ */ new Map();
+var STALE_TASK_THRESHOLD_MS = 30 * 60 * 1e3;
+var alertSlackWebhook = null;
+var alertedJobs = /* @__PURE__ */ new Set();
+var taskDisplayInfo = /* @__PURE__ */ new Map();
+var agentDisplayNames = /* @__PURE__ */ new Map();
+var codeNameToAgentId = /* @__PURE__ */ new Map();
+var agentChannelTokens = /* @__PURE__ */ new Map();
+var activeChannels = /* @__PURE__ */ new Map();
+var gatewaysStartedThisCycle = /* @__PURE__ */ new Set();
+var state = {
+  pid: process.pid,
+  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  lastPollAt: null,
+  pollCount: 0,
+  errorCount: 0,
+  agents: []
+};
+var registeredAgentsCache = /* @__PURE__ */ new Map();
+var agentFrameworkCache = /* @__PURE__ */ new Map();
+function resolveAgentFramework(codeName) {
+  const frameworkId = agentFrameworkCache.get(codeName) ?? "openclaw";
+  return getFramework(frameworkId);
+}
+var gatewayPool = null;
+function clearAgentCaches(agentId, codeName) {
+  knownVersions.delete(agentId);
+  knownStatuses.delete(agentId);
+  knownChannels.delete(agentId);
+  writtenHashes.delete(agentId);
+  knownSecretsHashes.delete(agentId);
+  knownModels.delete(agentId);
+  knownTasksHashes.delete(agentId);
+  knownIntegrationHashes.delete(agentId);
+  losslessClawInstalled.delete(codeName);
+  agentDisplayNames.delete(codeName);
+  codeNameToAgentId.delete(codeName);
+  agentFrameworkCache.delete(codeName);
+  kanbanBoardCache.delete(codeName);
+  lastHarvestAt.delete(codeName);
+  claudeSchedulerStates.delete(codeName);
+  claudeTaskConcurrency.delete(codeName);
+  for (const key of knownChannelConfigHashes.keys()) {
+    if (key.startsWith(`${agentId}:`)) knownChannelConfigHashes.delete(key);
+  }
+  for (const key of knownSkillHashes.keys()) {
+    if (key.startsWith(`${agentId}:`)) knownSkillHashes.delete(key);
+  }
+  for (const key of taskDisplayInfo.keys()) {
+    if (key.startsWith(`${codeName}:`)) taskDisplayInfo.delete(key);
+  }
+}
+var cachedFrameworkVersion = null;
+var lastVersionCheckAt = 0;
+var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
+function loadGatewayPorts() {
+  try {
+    return JSON.parse(readFileSync2(GATEWAY_PORTS_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveGatewayPorts(ports) {
+  mkdirSync(AUGMENTED_DIR, { recursive: true });
+  writeFileSync(GATEWAY_PORTS_FILE, JSON.stringify(ports, null, 2));
+}
+function allocatePort(codeName) {
+  const ports = loadGatewayPorts();
+  if (ports[codeName]) return ports[codeName];
+  const usedPorts = new Set(Object.values(ports));
+  for (let port = GATEWAY_PORT_BASE; port <= GATEWAY_PORT_MAX; port += GATEWAY_PORT_STEP) {
+    if (!usedPorts.has(port)) {
+      ports[codeName] = port;
+      saveGatewayPorts(ports);
+      return port;
+    }
+  }
+  throw new Error(`No free gateway ports in range ${GATEWAY_PORT_BASE}-${GATEWAY_PORT_MAX}`);
+}
+function freePort(codeName) {
+  const ports = loadGatewayPorts();
+  if (ports[codeName]) {
+    delete ports[codeName];
+    saveGatewayPorts(ports);
+  }
+}
+var STATE_FILE = join2(process.env["HOME"] ?? "/tmp", ".augmented", "manager-state.json");
+function send(msg) {
+  if (msg.type === "state-update") {
+    try {
+      writeFileSync(STATE_FILE, JSON.stringify(msg.state, null, 2));
+    } catch {
+    }
+  }
+  if (msg.type === "provisioned") {
+    log(`Provisioned ${msg.codeName}`);
+  } else if (msg.type === "drift-detected") {
+    log(`Drift detected: ${msg.codeName} (${msg.files?.join(", ")})`);
+  } else if (msg.type === "error") {
+    log(`Error: ${msg.message}`);
+  }
+}
+function log(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  process.stderr.write(`[manager-worker ${ts}] ${msg}
+`);
+}
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function hashFile(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return sha256(content);
+  } catch {
+    return null;
+  }
+}
+async function migrateToProfiles() {
+  const homeDir = process.env["HOME"] ?? "/tmp";
+  const sharedConfigPath = join2(homeDir, ".openclaw", "openclaw.json");
+  let sharedConfig;
+  try {
+    sharedConfig = JSON.parse(readFileSync2(sharedConfigPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const agents = sharedConfig["agents"];
+  const agentList = agents?.["list"] ?? [];
+  if (agentList.length === 0) return;
+  const adapter = getFramework("openclaw");
+  let migrated = 0;
+  for (const agentEntry of agentList) {
+    const codeName = agentEntry["id"];
+    if (!codeName) continue;
+    if (codeName === "main") continue;
+    const profileDir = join2(homeDir, `.openclaw-${codeName}`);
+    if (existsSync2(join2(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)) {
+      mkdirSync(profileAuthDir, { recursive: true });
+      const authContent = readFileSync2(authFile, "utf-8");
+      writeFileSync(join2(profileAuthDir, "auth-profiles.json"), authContent);
+    }
+    allocatePort(codeName);
+    migrated++;
+  }
+  if (migrated > 0) {
+    log(`Migration complete: ${migrated} agent(s) migrated to per-agent profiles`);
+  }
+}
+function resolveModelChain(refreshData) {
+  const agent = refreshData.agent;
+  const modelDefaults = refreshData.model_defaults;
+  const platform = modelDefaults?.platform ?? {};
+  const org = modelDefaults?.org ?? {};
+  function resolve(tier) {
+    const agentField = `${tier}_model`;
+    const platformField = `default_${tier}_model`;
+    const agentVal = agent?.[agentField];
+    if (agentVal) return agentVal;
+    const orgVal = org?.[platformField];
+    if (orgVal) return orgVal;
+    const platformVal = platform?.[platformField];
+    if (platformVal) return platformVal;
+    return void 0;
+  }
+  return {
+    primary: resolve("primary"),
+    secondary: resolve("secondary"),
+    tertiary: resolve("tertiary")
+  };
+}
+function readGatewayToken(codeName) {
+  const adapter = resolveAgentFramework(codeName);
+  if (adapter.readGatewayToken) {
+    return adapter.readGatewayToken(codeName);
+  }
+  const homeDir = process.env["HOME"] ?? "/tmp";
+  try {
+    const cfg = JSON.parse(readFileSync2(join2(homeDir, `.openclaw-${codeName}`, "openclaw.json"), "utf-8"));
+    return cfg?.gateway?.auth?.token;
+  } catch {
+    return void 0;
+  }
+}
+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;
+  try {
+    const data = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+    const jobs = data.jobs ?? data;
+    if (!Array.isArray(jobs)) return false;
+    const now = Date.now();
+    for (const job of jobs) {
+      const state2 = job.state;
+      if (!state2) continue;
+      const runStartedAt = state2.runStartedAtMs;
+      const isRunning = state2.status === "running" || state2.running === true;
+      if (isRunning && runStartedAt && now - runStartedAt > GATEWAY_HUNG_TIMEOUT_MS) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+async function ensureGatewayRunning(codeName, adapter) {
+  if (!adapter.isGatewayRunning || !adapter.startGateway) {
+    return { pid: null, port: null, running: false };
+  }
+  const status = await adapter.isGatewayRunning(codeName);
+  if (status.running) {
+    if (await isGatewayHung(codeName)) {
+      log(`Gateway for '${codeName}' appears hung (cron stuck >5min) \u2014 restarting`);
+      if (adapter.stopGateway) {
+        try {
+          await adapter.stopGateway(codeName);
+        } catch {
+        }
+      }
+      await new Promise((r) => setTimeout(r, 2e3));
+      const homeDir = process.env["HOME"] ?? "/tmp";
+      const cronJobsPath = join2(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(readFileSync2(configPath, "utf-8"));
+            if (cfg.gateway?.port !== status.port) {
+              if (!cfg.gateway) cfg.gateway = {};
+              cfg.gateway.port = status.port;
+              writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+            }
+          }
+        } catch {
+        }
+      }
+      if (gatewayPool && status.port && !gatewayPool.hasAgent(codeName)) {
+        const token = readGatewayToken(codeName);
+        gatewayPool.addAgent(codeName, status.port, token);
+      }
+      return { pid: status.pid ?? null, port: status.port ?? null, running: true };
+    }
+  }
+  const port = allocatePort(codeName);
+  try {
+    const result = await adapter.startGateway(codeName, port);
+    log(`Gateway started for '${codeName}' on port ${port} (PID ${result.pid})`);
+    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(readFileSync2(configPath, "utf-8"));
+        if (!cfg.gateway) cfg.gateway = {};
+        cfg.gateway.port = port;
+        writeFileSync(configPath, JSON.stringify(cfg, null, 2));
+      }
+    } catch {
+    }
+    if (gatewayPool) {
+      const token = readGatewayToken(codeName);
+      gatewayPool.addAgent(codeName, port, token);
+    }
+    return { pid: result.pid, port, running: true };
+  } catch (err) {
+    log(`Failed to start gateway for '${codeName}': ${err.message}`);
+    return { pid: null, port, running: false };
+  }
+}
+async function stopGatewayIfRunning(codeName, adapter) {
+  if (!adapter.stopGateway) return;
+  try {
+    const stopped = await adapter.stopGateway(codeName);
+    if (stopped) {
+      log(`Gateway stopped for '${codeName}'`);
+    }
+  } catch (err) {
+    log(`Failed to stop gateway for '${codeName}': ${err.message}`);
+  }
+  if (gatewayPool) {
+    gatewayPool.removeAgent(codeName);
+  }
+}
+async function stopAllGateways() {
+  const ports = loadGatewayPorts();
+  for (const codeName of Object.keys(ports)) {
+    const adapter = resolveAgentFramework(codeName);
+    await stopGatewayIfRunning(codeName, adapter);
+  }
+  if (gatewayPool) {
+    gatewayPool.disconnectAll();
+  }
+}
+async function healthCheckGateways(agentStates) {
+  for (const agentState of agentStates) {
+    if (agentState.status !== "active" || !agentState.gatewayPort) continue;
+    const adapter = resolveAgentFramework(agentState.codeName);
+    if (!adapter.isGatewayRunning || !adapter.startGateway) continue;
+    if (gatewaysStartedThisCycle.has(agentState.codeName)) continue;
+    const status = await adapter.isGatewayRunning(agentState.codeName);
+    if (!status.running && agentState.gatewayRunning) {
+      const displayName = agentDisplayNames.get(agentState.codeName) ?? agentState.codeName;
+      log(`Gateway for '${agentState.codeName}' crashed, restarting...`);
+      sendSlackWebhookMessage(
+        `:red_circle: *Host Down* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+OpenClaw gateway crashed. Attempting automatic restart...`
+      ).catch(() => {
+      });
+      try {
+        const result = await adapter.startGateway(agentState.codeName, agentState.gatewayPort);
+        agentState.gatewayPid = result.pid;
+        agentState.gatewayRunning = true;
+        log(`Gateway restarted for '${agentState.codeName}' (PID ${result.pid})`);
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        if (gatewayPool) {
+          const token = readGatewayToken(agentState.codeName);
+          gatewayPool.addAgent(agentState.codeName, agentState.gatewayPort, token);
+        }
+        sendSlackWebhookMessage(
+          `:large_green_circle: *Host Recovered* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+Gateway restarted successfully (PID ${result.pid}).`
+        ).catch(() => {
+        });
+      } catch (err) {
+        agentState.gatewayRunning = false;
+        log(`Failed to restart gateway for '${agentState.codeName}': ${err.message}`);
+        sendSlackWebhookMessage(
+          `:x: *Host Restart Failed* \u2014 *${displayName}* (\`${agentState.codeName}\`)
+Automatic restart failed: ${err.message}`
+        ).catch(() => {
+        });
+      }
+    }
+  }
+}
+async function pollCycle() {
+  if (!config) return;
+  try {
+    registeredAgentsCache.clear();
+    gatewaysStartedThisCycle.clear();
+    const hostId = await getHostId();
+    if (!hostId) {
+      send({ type: "error", message: "Could not resolve host ID from API key" });
+      return;
+    }
+    const now = Date.now();
+    if (now - lastVersionCheckAt > VERSION_CHECK_INTERVAL_MS) {
+      try {
+        const firstAgent = state.agents[0];
+        const versionAdapter = firstAgent ? resolveAgentFramework(firstAgent.codeName) : getFramework("openclaw");
+        if (versionAdapter.getVersion) {
+          cachedFrameworkVersion = await versionAdapter.getVersion();
+        }
+      } catch {
+      }
+      lastVersionCheckAt = now;
+    }
+    try {
+      await api.post("/host/heartbeat", {
+        host_id: hostId,
+        framework_version: cachedFrameworkVersion ?? void 0
+      });
+    } catch (err) {
+      log(`Heartbeat failed: ${err.message}`);
+    }
+    const data = await api.post("/host/agents", { host_id: hostId });
+    const agents = data.agents ?? [];
+    activeChannels.clear();
+    const agentStates = [];
+    for (const agent of agents) {
+      try {
+        await processAgent(agent, agentStates);
+      } catch (err) {
+        log(`Error processing agent '${agent.code_name}': ${err.message}`);
+        const existing = state.agents.find((a) => a.agentId === agent.agent_id);
+        if (existing) {
+          agentStates.push(existing);
+        } else {
+          agentStates.push({
+            agentId: agent.agent_id,
+            codeName: agent.code_name,
+            status: agent.status,
+            charterVersion: "",
+            toolsVersion: "",
+            secretsHash: null,
+            lastRefreshAt: null,
+            lastProvisionAt: null,
+            lastDriftCheckAt: null,
+            lastSecretsProvisionAt: null,
+            gatewayPort: null,
+            gatewayPid: null,
+            gatewayRunning: false,
+            acpSessions: []
+          });
+        }
+      }
+    }
+    try {
+      for (const [channelId, codeNames] of activeChannels) {
+        for (const codeName of codeNames) {
+          const adapter = resolveAgentFramework(codeName);
+          if (adapter.setChannelEnabled) {
+            adapter.setChannelEnabled(channelId, true, codeName);
+          }
+        }
+      }
+    } catch {
+    }
+    const currentIds = new Set(agents.map((a) => a.agent_id));
+    for (const prev of state.agents) {
+      if (!currentIds.has(prev.agentId)) {
+        log(`Agent '${prev.codeName}' unassigned from host`);
+        const adapter = resolveAgentFramework(prev.codeName);
+        clearAgentCaches(prev.agentId, prev.codeName);
+        await stopGatewayIfRunning(prev.codeName, adapter);
+      }
+    }
+    await healthCheckGateways(agentStates);
+    const lastHealthCheck = lastHarvestAt.get("__cron_health__") ?? 0;
+    if (Date.now() - lastHealthCheck >= HARVEST_INTERVAL_MS) {
+      lastHarvestAt.set("__cron_health__", Date.now());
+      monitorCronHealth(agentStates).catch((err) => {
+        log(`Cron health monitor error: ${err.message}`);
+      });
+    }
+    if (!isRealtimeConnected()) {
+      pollDirectChatMessages(agentStates).catch((err) => {
+        log(`Direct chat poll error: ${err.message}`);
+      });
+    }
+    ensureRealtimeStarted(agentStates);
+    ensureRealtimeDriftStarted(agentStates);
+    ensureRealtimeAssignStarted(agentStates);
+    ensureRealtimeConfigStarted(agentStates);
+    ensureRealtimeKanbanStarted(agentStates);
+    state = {
+      ...state,
+      lastPollAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pollCount: state.pollCount + 1,
+      agents: agentStates
+    };
+    send({ type: "state-update", state });
+  } catch (err) {
+    state.errorCount++;
+    const message = err.message;
+    log(`Poll error: ${message}`);
+    send({ type: "error", message });
+    if (message.includes("exchange failed") || message.includes("401")) {
+      log("Fatal auth error, exiting for watchdog restart");
+      send({ type: "shutdown" });
+      process.exit(1);
+    }
+  }
+}
+async function getOrCacheRegisteredAgents(adapter, profile) {
+  const cacheKey = profile ? `${adapter.id}:${profile}` : adapter.id;
+  let cached = registeredAgentsCache.get(cacheKey);
+  if (!cached) {
+    cached = await adapter.getRegisteredAgents(profile);
+    registeredAgentsCache.set(cacheKey, cached);
+  }
+  return cached;
+}
+async function processAgent(agent, agentStates) {
+  if (!config) return;
+  log(`==================== ${agent.display_name} (${agent.code_name}) ====================`);
+  agentDisplayNames.set(agent.code_name, agent.display_name);
+  codeNameToAgentId.set(agent.code_name, agent.agent_id);
+  if (agent.framework) {
+    agentFrameworkCache.set(agent.code_name, agent.framework);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const agentDir = join2(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`);
+    await stopGatewayIfRunning(agent.code_name, adapter);
+    stopPersistentSession(agent.code_name, log);
+    try {
+      const { execSync: es } = await import("child_process");
+      es(`tmux kill-session -t agt-${agent.code_name} 2>/dev/null`, { stdio: "ignore" });
+      log(`Killed tmux session for paused agent '${agent.code_name}'`);
+    } catch {
+    }
+    agentStates.push({
+      agentId: agent.agent_id,
+      codeName: agent.code_name,
+      status: agent.status,
+      charterVersion: "",
+      toolsVersion: "",
+      secretsHash: null,
+      lastRefreshAt: now,
+      lastProvisionAt: null,
+      lastDriftCheckAt: null,
+      lastSecretsProvisionAt: null,
+      gatewayPort: null,
+      gatewayPid: null,
+      gatewayRunning: false,
+      acpSessions: []
+    });
+    return;
+  }
+  if (agent.status === "revoked") {
+    log(`Agent '${agent.code_name}' is revoked, cleaning up`);
+    await stopGatewayIfRunning(agent.code_name, adapter);
+    stopPersistentSession(agent.code_name, log);
+    try {
+      const { execSync: es } = await import("child_process");
+      es(`tmux kill-session -t agt-${agent.code_name} 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    freePort(agent.code_name);
+    await cleanupAgentFiles(agent.code_name, agentDir);
+    clearAgentCaches(agent.agent_id, agent.code_name);
+    knownStatuses.set(agent.agent_id, agent.status);
+    agentStates.push({
+      agentId: agent.agent_id,
+      codeName: agent.code_name,
+      status: agent.status,
+      charterVersion: "",
+      toolsVersion: "",
+      secretsHash: null,
+      lastRefreshAt: now,
+      lastProvisionAt: null,
+      lastDriftCheckAt: null,
+      lastSecretsProvisionAt: null,
+      gatewayPort: null,
+      gatewayPid: null,
+      gatewayRunning: false,
+      acpSessions: []
+    });
+    return;
+  }
+  const previousStatus = knownStatuses.get(agent.agent_id);
+  if (previousStatus && previousStatus !== agent.status) {
+    log(`Agent '${agent.code_name}' status changed: ${previousStatus} \u2192 ${agent.status}`);
+    knownVersions.delete(agent.agent_id);
+    for (const key of knownChannelConfigHashes.keys()) {
+      if (key.startsWith(`${agent.agent_id}:`)) knownChannelConfigHashes.delete(key);
+    }
+  }
+  knownStatuses.set(agent.agent_id, agent.status);
+  let refreshData;
+  try {
+    refreshData = await api.post("/host/refresh", {
+      agent_id: agent.agent_id
+    });
+  } catch (err) {
+    log(`Refresh failed for '${agent.code_name}': ${err.message}`);
+    const existing = state.agents.find((a) => a.agentId === agent.agent_id);
+    agentStates.push(existing ?? {
+      agentId: agent.agent_id,
+      codeName: agent.code_name,
+      status: agent.status,
+      charterVersion: "",
+      toolsVersion: "",
+      secretsHash: null,
+      lastRefreshAt: null,
+      lastProvisionAt: null,
+      lastDriftCheckAt: null,
+      lastSecretsProvisionAt: null,
+      gatewayPort: null,
+      gatewayPid: null,
+      gatewayRunning: false,
+      acpSessions: []
+    });
+    return;
+  }
+  if (!alertSlackWebhook && refreshData.team?.settings) {
+    const webhook = refreshData.team.settings["alert_slack_webhook"];
+    if (typeof webhook === "string" && webhook.startsWith("https://")) {
+      alertSlackWebhook = webhook;
+    }
+  }
+  if (!refreshData.charter || !refreshData.tools) {
+    log(`No charter/tools for '${agent.code_name}', skipping`);
+    agentStates.push({
+      agentId: agent.agent_id,
+      codeName: agent.code_name,
+      status: agent.status,
+      charterVersion: "",
+      toolsVersion: "",
+      secretsHash: null,
+      lastRefreshAt: now,
+      lastProvisionAt: null,
+      lastDriftCheckAt: null,
+      lastSecretsProvisionAt: null,
+      gatewayPort: null,
+      gatewayPid: null,
+      gatewayRunning: false,
+      acpSessions: []
+    });
+    return;
+  }
+  const frameworkId = refreshData.agent.framework ?? "openclaw";
+  agentFrameworkCache.set(agent.code_name, frameworkId);
+  const frameworkAdapter = getFramework(frameworkId);
+  if (frameworkAdapter.seedProfileConfig) {
+    frameworkAdapter.seedProfileConfig(agent.code_name);
+  }
+  const charterVersion = refreshData.charter.version;
+  const toolsVersion = refreshData.tools.version;
+  const known = knownVersions.get(agent.agent_id);
+  let lastProvisionAt = state.agents.find((a) => a.agentId === agent.agent_id)?.lastProvisionAt ?? null;
+  const currentChannelIds = new Set(Object.keys(refreshData.channel_configs ?? {}));
+  const previousChannelIds = knownChannels.get(agent.agent_id);
+  const channelsChanged = !previousChannelIds || currentChannelIds.size !== previousChannelIds.size || [...currentChannelIds].some((ch) => !previousChannelIds.has(ch)) || [...previousChannelIds].some((ch) => !currentChannelIds.has(ch));
+  if (previousChannelIds && channelsChanged && frameworkAdapter.removeChannelCredentials) {
+    for (const ch of previousChannelIds) {
+      if (!currentChannelIds.has(ch)) {
+        try {
+          frameworkAdapter.removeChannelCredentials(agent.code_name, ch);
+          log(`Removed ${ch} credentials for '${agent.code_name}'`);
+        } catch (err) {
+          log(`Failed to remove ${ch} credentials for '${agent.code_name}': ${err.message}`);
+        }
+      }
+    }
+  }
+  knownChannels.set(agent.agent_id, currentChannelIds);
+  try {
+    const artifacts = generateArtifacts(agent, refreshData, frameworkAdapter);
+    const changedFiles = [];
+    mkdirSync(agentDir, { recursive: true });
+    for (const artifact of artifacts) {
+      const filePath = join2(agentDir, artifact.relativePath);
+      const newHash = sha256(artifact.content);
+      const existingHash = hashFile(filePath);
+      if (newHash !== existingHash) {
+        changedFiles.push(artifact);
+      }
+    }
+    if (changedFiles.length > 0) {
+      const isFirst = !existsSync2(join2(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) {
+        writeFileSync(join2(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));
+        if (h) hashes.set(file, h);
+      }
+      writtenHashes.set(agent.agent_id, hashes);
+      const resolvedModelsForRegistration = resolveModelChain(refreshData);
+      const primaryModel2 = resolvedModelsForRegistration.primary ?? refreshData.agent.primary_model;
+      const registeredAgents = await getOrCacheRegisteredAgents(frameworkAdapter, agent.code_name);
+      if (!registeredAgents.has(agent.code_name)) {
+        const registered = await frameworkAdapter.registerAgent(agent.code_name, agentDir, primaryModel2);
+        if (registered) {
+          registeredAgents.add(agent.code_name);
+          log(`Registered '${agent.code_name}' in ${frameworkAdapter.label}`);
+        }
+      }
+      send({ type: "provisioned", agentId: agent.agent_id, codeName: agent.code_name });
+    }
+    if (frameworkAdapter.deployArtifactsToProject) {
+      frameworkAdapter.deployArtifactsToProject(agent.code_name, agentDir);
+    }
+  } catch (err) {
+    log(`Provision failed for '${agent.code_name}': ${err.message}`);
+  }
+  const resolvedForModel = resolveModelChain(refreshData);
+  const primaryModel = resolvedForModel.primary ?? refreshData.agent.primary_model;
+  if (primaryModel && frameworkAdapter.updateAgentModel) {
+    const previousModel = knownModels.get(agent.agent_id);
+    if (previousModel !== primaryModel) {
+      try {
+        const updated = await frameworkAdapter.updateAgentModel(agent.code_name, primaryModel);
+        if (updated) {
+          if (previousModel) {
+            log(`Model updated for '${agent.code_name}': ${previousModel} \u2192 ${primaryModel}`);
+          } else {
+            log(`Model set for '${agent.code_name}': ${primaryModel}`);
+          }
+        }
+      } catch (err) {
+        log(`Failed to update model for '${agent.code_name}': ${err.message}`);
+      }
+    }
+    knownModels.set(agent.agent_id, primaryModel);
+  }
+  let lastDriftCheckAt = now;
+  const written = writtenHashes.get(agent.agent_id);
+  if (written && existsSync2(agentDir)) {
+    const driftedFiles = [];
+    for (const [file, expectedHash] of written) {
+      const localHash = hashFile(join2(agentDir, file));
+      if (localHash && localHash !== expectedHash) {
+        driftedFiles.push(file);
+      }
+    }
+    if (driftedFiles.length > 0) {
+      log(`Drift detected for '${agent.code_name}': ${driftedFiles.join(", ")}`);
+      send({ type: "drift-detected", agentId: agent.agent_id, codeName: agent.code_name, files: driftedFiles });
+      try {
+        const localHashes = {};
+        for (const file of driftedFiles) {
+          localHashes[file] = hashFile(join2(agentDir, file));
+        }
+        await api.post("/host/drift", {
+          agent_id: agent.agent_id,
+          drifted_files: driftedFiles,
+          local_hashes: localHashes
+        });
+      } catch (err) {
+        log(`Failed to report drift for '${agent.code_name}': ${err.message}`);
+      }
+    }
+  }
+  if (refreshData.channel_configs) {
+    const tokens = {};
+    const slackCfg = refreshData.channel_configs["slack"];
+    if (slackCfg?.config) {
+      const bt = slackCfg.config.bot_token;
+      if (typeof bt === "string" && bt) tokens.slack = bt;
+    }
+    const tgCfg = refreshData.channel_configs["telegram"];
+    if (tgCfg?.config) {
+      const tgConfig = tgCfg.config;
+      const bt = tgConfig.bot_token;
+      if (typeof bt === "string" && bt) tokens.telegram = bt;
+      const allowedChats = tgConfig.allowed_chat_ids;
+      if (Array.isArray(allowedChats)) tokens.telegramAllowedChats = allowedChats;
+    }
+    if (tokens.slack || tokens.telegram) {
+      agentChannelTokens.set(agent.code_name, tokens);
+    } else {
+      agentChannelTokens.delete(agent.code_name);
+    }
+  }
+  let needsGatewayRestart = false;
+  const hasChannelConfigs = refreshData.channel_configs && Object.keys(refreshData.channel_configs).length > 0;
+  if (refreshData.channel_configs && frameworkAdapter.writeChannelCredentials) {
+    if (agent.status === "active") {
+      for (const [channelId, entry] of Object.entries(refreshData.channel_configs)) {
+        if ((entry.status === "active" || entry.status === "pending") && entry.config) {
+          if (!activeChannels.has(channelId)) {
+            activeChannels.set(channelId, /* @__PURE__ */ new Set());
+          }
+          activeChannels.get(channelId).add(agent.code_name);
+          const configHash = createHash("sha256").update(JSON.stringify(entry.config)).digest("hex");
+          const cacheKey = `${agent.agent_id}:${channelId}`;
+          if (knownChannelConfigHashes.get(cacheKey) === configHash) {
+            continue;
+          }
+          try {
+            const sessionMode2 = refreshData.agent.session_mode;
+            frameworkAdapter.writeChannelCredentials(agent.code_name, channelId, entry.config, { sessionMode: sessionMode2 });
+            knownChannelConfigHashes.set(cacheKey, configHash);
+            log(`Channel credentials written for '${agent.code_name}/${channelId}'`);
+          } catch (err) {
+            log(`Failed to write channel credentials for '${agent.code_name}/${channelId}': ${err.message}`);
+          }
+        }
+      }
+    } else if (agent.status === "paused") {
+      if (frameworkAdapter.setChannelEnabled) {
+        for (const channelId of Object.keys(refreshData.channel_configs)) {
+          frameworkAdapter.setChannelEnabled(channelId, false, agent.code_name);
+        }
+      }
+    }
+  }
+  let lastSecretsProvisionAt = state.agents.find((a) => a.agentId === agent.agent_id)?.lastSecretsProvisionAt ?? null;
+  let secretsHash = knownSecretsHashes.get(agent.agent_id) ?? null;
+  try {
+    const secretsData = await api.post("/host/secrets", { agent_id: agent.agent_id });
+    const newHash = secretsData.secrets_hash;
+    const hashChanged = newHash !== secretsHash;
+    if (hashChanged && secretsData.profiles.length > 0) {
+      frameworkAdapter.writeAuthProfiles(agent.code_name, secretsData.profiles);
+      lastSecretsProvisionAt = (/* @__PURE__ */ new Date()).toISOString();
+      log(`Secrets updated for '${agent.code_name}'`);
+    }
+    if (newHash) {
+      knownSecretsHashes.set(agent.agent_id, newHash);
+      secretsHash = newHash;
+    } else {
+      knownSecretsHashes.delete(agent.agent_id);
+      secretsHash = null;
+    }
+  } catch (err) {
+    log(`Secrets fetch failed for '${agent.code_name}': ${err.message}`);
+  }
+  try {
+    const integrationsData = await api.post("/host/agent-integrations", { agent_id: agent.agent_id });
+    const integrations = integrationsData.integrations ?? [];
+    for (const integration of integrations) {
+      if (integration.auth_type !== "oauth2") continue;
+      const expiresAt = integration.credentials?.token_expires_at;
+      const refreshToken = integration.credentials?.refresh_token;
+      if (!expiresAt || !refreshToken) continue;
+      const msRemaining = new Date(expiresAt).getTime() - Date.now();
+      if (msRemaining > 10 * 60 * 1e3) continue;
+      try {
+        const integrationId = integration.id;
+        if (!integrationId) continue;
+        const refreshResult = await api.post(
+          `/integrations/oauth/${integrationId}/refresh`,
+          {}
+        );
+        if (refreshResult.ok) {
+          integration.credentials.token_expires_at = refreshResult.expires_at;
+          if (refreshResult.access_token) {
+            integration.credentials.access_token = refreshResult.access_token;
+          }
+          log(`OAuth token refreshed for '${agent.code_name}/${integration.definition_id}'`);
+          if (frameworkAdapter.writeTokenFile) {
+            frameworkAdapter.writeTokenFile(agent.code_name, integrations);
+          }
+        }
+      } catch (err) {
+        log(`OAuth token refresh failed for '${agent.code_name}/${integration.definition_id}': ${err.message}`);
+      }
+    }
+    if (integrations.length > 0) {
+      const intHash = createHash("sha256").update(JSON.stringify(integrations.map((i) => `${i.definition_id}:${JSON.stringify(i.credentials)}`))).digest("hex").slice(0, 16);
+      const prevIntHash = knownIntegrationHashes.get(agent.agent_id);
+      if (intHash !== prevIntHash) {
+        if (frameworkAdapter.writeIntegrations) {
+          frameworkAdapter.writeIntegrations(agent.code_name, integrations);
+        }
+        knownIntegrationHashes.set(agent.agent_id, intHash);
+        log(`Integrations provisioned for '${agent.code_name}' (${integrations.length} integration(s))`);
+        needsGatewayRestart = true;
+        const hasLcm = integrations.some((i) => i.definition_id === "lossless-claw");
+        if (hasLcm && !losslessClawInstalled.get(agent.code_name)) {
+          try {
+            const { execFileSync } = await import("child_process");
+            let pluginList;
+            try {
+              pluginList = execFileSync(
+                "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}'...`);
+              execFileSync(
+                "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) {
+        try {
+          const capData = await api.post("/host/capability-skill", { definition_id: capId });
+          const allSatisfied = capData.requiredIntegrations.every((reqId) => resolvedDefIds.has(reqId));
+          if (!allSatisfied) {
+            const missing = capData.requiredIntegrations.filter((reqId) => !resolvedDefIds.has(reqId));
+            log(`Capability '${capId}' skipped \u2014 missing integration(s): ${missing.join(", ")}`);
+            continue;
+          }
+          const skillContent = JSON.stringify(capData.skills.map((s) => s.files.map((f) => `${f.relativePath}:${f.content}`)));
+          const skillHash = createHash("sha256").update(skillContent).digest("hex").slice(0, 16);
+          const skillKey = `${agent.agent_id}:${capId}`;
+          const prevSkillHash = knownSkillHashes.get(skillKey);
+          if (skillHash !== prevSkillHash) {
+            if (frameworkAdapter.installSkillFiles && capData.skills) {
+              for (const skill of capData.skills) {
+                if (skill.files.length > 0) {
+                  frameworkAdapter.installSkillFiles(agent.code_name, skill.id, skill.files);
+                  log(`Installed skill '${skill.id}' for '${agent.code_name}' (${skill.files.length} file(s))`);
+                }
+              }
+            }
+            knownSkillHashes.set(skillKey, skillHash);
+          }
+          const ALLOWED_CLI_PACKAGES = /* @__PURE__ */ new Set([
+            "xero-cli",
+            "@openapitools/openapi-generator-cli",
+            "gh",
+            "@schpet/linear-cli",
+            "@googleworkspace/cli",
+            "@tobilu/qmd"
+          ]);
+          if (intHash !== prevIntHash) {
+            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 {
+                execFileSync("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 });
+                  log(`CLI tool '${tool.binary}' installed successfully`);
+                } catch (installErr) {
+                  log(`Failed to install CLI tool '${tool.package}': ${installErr.message}`);
+                }
+              }
+              if (tool.binary === "qmd") {
+                try {
+                  const agentDir2 = join2(process.env["HOME"] ?? "/tmp", ".augmented", agent.code_name);
+                  execFileSync("qmd", ["collection", "add", agent.code_name, "project"], {
+                    stdio: "ignore",
+                    timeout: 3e4,
+                    cwd: agentDir2
+                  });
+                  log(`QMD collection '${agent.code_name}' configured`);
+                } catch {
+                }
+              }
+            }
+          }
+        } catch (skillErr) {
+          const msg = skillErr.message ?? "";
+          if (!msg.includes("404") && !msg.includes("Unknown capability")) {
+            log(`Capability fetch failed for '${capId}': ${msg}`);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    log(`Integration provisioning failed for '${agent.code_name}': ${err.message}`);
+  }
+  let gatewayPort = null;
+  let gatewayPid = null;
+  let gatewayRunning = false;
+  if (agent.status === "active" && hasChannelConfigs) {
+    const gwStatus = await ensureGatewayRunning(agent.code_name, frameworkAdapter);
+    gatewayPort = gwStatus.port;
+    gatewayPid = gwStatus.pid;
+    gatewayRunning = gwStatus.running;
+  } else if (agent.status === "paused") {
+    await stopGatewayIfRunning(agent.code_name, frameworkAdapter);
+  }
+  let tasks = refreshData.scheduled_tasks ?? [];
+  const existingTemplateIds = new Set(tasks.map((t) => t.template_id));
+  try {
+    const defaultsData = await api.post("/host/resolve-default-schedules", { agent_id: agent.agent_id });
+    const missing = (defaultsData.schedules ?? []).filter(
+      (s) => !existingTemplateIds.has(s.template_id)
+    );
+    const allSchedules = defaultsData.schedules ?? [];
+    if (allSchedules.length > 0) {
+      await api.post("/host/ensure-default-schedules", {
+        agent_id: agent.agent_id,
+        team_id: defaultsData.team_id,
+        timezone: defaultsData.timezone,
+        schedules: allSchedules
+      });
+      if (missing.length > 0) {
+        log(`Auto-provisioned ${missing.length} default schedule(s) for '${agent.code_name}': ${missing.map((s) => s.template_id).join(", ")}`);
+      }
+      const freshData = await api.post("/host/refresh", { agent_id: agent.agent_id });
+      tasks = freshData.scheduled_tasks ?? tasks;
+    }
+  } catch (err) {
+    log(`Default schedule provisioning failed for '${agent.code_name}': ${err.message}`);
+  }
+  if (agent.status === "active") {
+    if (frameworkAdapter.installPlugin) {
+      try {
+        const pluginPath = join2(process.cwd(), "packages", "openclaw-plugin-augmented", "src", "index.ts");
+        if (existsSync2(pluginPath)) {
+          frameworkAdapter.installPlugin(agent.code_name, "augmented", pluginPath, {
+            agtHost: requireHost(),
+            agtApiKey: getApiKey() ?? void 0,
+            agentId: agent.agent_id
+          });
+        }
+      } catch (err) {
+        log(`Augmented plugin install failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
+    if (frameworkAdapter.installSkillFiles) {
+      try {
+        const skillContent = getBuiltInSkillContent("kanban");
+        if (skillContent) {
+          frameworkAdapter.installSkillFiles(agent.code_name, "kanban", skillContent);
+        }
+      } catch (err) {
+        log(`Kanban skill install failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
+  }
+  let boardItems = [];
+  const hasBoardTemplates = tasks.some((t) => BOARD_INJECT_TEMPLATES.has(t.template_id));
+  if (hasBoardTemplates) {
+    try {
+      const boardData = await api.post("/host/my-kanban", { agent_id: agent.agent_id });
+      boardItems = (boardData.items ?? []).map(sanitizeBoardItem);
+      kanbanBoardCache.set(agent.code_name, boardItems);
+    } catch {
+      boardItems = kanbanBoardCache.get(agent.code_name) ?? [];
+    }
+  }
+  const agentFw = agentFrameworkCache.get(agent.code_name) ?? "openclaw";
+  const sessionMode = refreshData.agent.session_mode ?? "oneshot";
+  if (agentFw === "claude-code" && sessionMode === "persistent") {
+    await ensurePersistentSession(agent, tasks, boardItems, refreshData);
+  } else if (agentFw === "claude-code" && tasks.length > 0) {
+    await syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData);
+  } else if (frameworkAdapter.syncScheduledTasks && gatewayRunning && gatewayPort) {
+    const stableTasksHash = createHash("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+    const boardHash = boardItems.length > 0 ? createHash("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+    const resolvedModels = resolveModelChain(refreshData);
+    const modelsHash = createHash("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+    const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
+    const prevTasksHash = knownTasksHashes.get(agent.agent_id);
+    if (combinedHash !== prevTasksHash) {
+      const enrichedTasks = tasks.map((t) => {
+        if (BOARD_INJECT_TEMPLATES.has(t.template_id) && boardItems.length > 0) {
+          const template = PLAN_TEMPLATES.has(t.template_id) ? "morning-plan" : "follow-up";
+          const boardPrefix = formatBoardForPrompt(boardItems, template);
+          return { ...t, prompt: boardPrefix + t.prompt };
+        }
+        return t;
+      });
+      try {
+        const token = readGatewayToken(agent.code_name);
+        await frameworkAdapter.syncScheduledTasks(
+          agent.code_name,
+          enrichedTasks.map((t) => ({
+            id: t.id,
+            template_id: t.template_id,
+            name: t.name,
+            schedule_kind: t.schedule_kind,
+            schedule_expr: t.schedule_expr,
+            schedule_every: t.schedule_every,
+            schedule_at: t.schedule_at,
+            timezone: t.timezone,
+            prompt: t.prompt,
+            session_target: t.session_target,
+            delivery_mode: t.delivery_mode,
+            delivery_channel: t.delivery_channel,
+            delivery_to: t.delivery_to,
+            enabled: t.enabled,
+            model_tier: t.model_tier ?? "primary"
+          })),
+          gatewayPort,
+          token,
+          {
+            models: resolvedModels
+          }
+        );
+        knownTasksHashes.set(agent.agent_id, combinedHash);
+        log(`Scheduled tasks synced for '${agent.code_name}' (${enrichedTasks.length} task(s))`);
+      } catch (err) {
+        log(`Failed to sync scheduled tasks for '${agent.code_name}': ${err.message}`);
+      }
+    }
+  }
+  for (const t of tasks) {
+    const jobName = `aug:${t.template_id}:${t.id ?? t.name.toLowerCase().replace(/\s+/g, "-")}`;
+    taskDisplayInfo.set(`${agent.code_name}:${jobName}`, {
+      taskName: t.name,
+      schedule: t.schedule_expr ?? t.schedule_every ?? "",
+      agentDisplayName: agent.display_name
+    });
+  }
+  const ccInFlight = agentFw === "claude-code" ? claudeTaskConcurrency.get(agent.code_name) ?? 0 : null;
+  log(`[${agent.code_name}] Harvest gate: gatewayRunning=${gatewayRunning} gatewayPort=${gatewayPort} tasks=${tasks.length} fw=${agentFw}${ccInFlight !== null ? ` claude-p=${ccInFlight}/${MAX_CLAUDE_CONCURRENCY}` : ""}`);
+  if (agentFw === "openclaw" && gatewayRunning && gatewayPort && tasks.length > 0) {
+    const lastHarvest = lastHarvestAt.get(agent.code_name) ?? 0;
+    if (Date.now() - lastHarvest >= HARVEST_INTERVAL_MS) {
+      lastHarvestAt.set(agent.code_name, Date.now());
+      harvestCronResults(agent.code_name, tasks, gatewayPort).catch((err) => {
+        log(`Cron result harvest failed for '${agent.code_name}': ${err.message}`);
+      });
+    }
+  }
+  {
+    const triggerAt = refreshData.agent.work_trigger_at;
+    if (triggerAt) {
+      const triggerTs = new Date(triggerAt).getTime();
+      const lastTrigger = lastWorkTriggerAt.get(agent.code_name) ?? 0;
+      if (triggerTs > lastTrigger) {
+        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)) {
+            try {
+              const jobsData = JSON.parse(readFileSync2(jobsPath, "utf-8"));
+              const kanbanJob = (jobsData.jobs ?? []).find(
+                (j) => typeof j.name === "string" && j.name.includes("kanban-work")
+              );
+              if (kanbanJob?.id) {
+                const cliBin = resolveAgentFramework(agent.code_name).cliBinary ?? "openclaw";
+                log(`Work trigger: firing kanban-work for '${agent.code_name}'`);
+                execFilePromise(cliBin, ["--profile", agent.code_name, "cron", "run", kanbanJob.id]).then(() => log(`Work trigger succeeded for '${agent.code_name}'`)).catch((err) => log(`Work trigger failed for '${agent.code_name}': ${err.message}`));
+              }
+            } catch {
+            }
+          }
+        } else if (agentFw === "claude-code") {
+          fireClaudeWorkTrigger(agent.code_name, agent.agent_id, boardItems);
+        }
+      }
+    }
+  }
+  if (agentFw === "openclaw") {
+    cleanupStaleSessions(agent.code_name);
+  }
+  {
+    const agentId = codeNameToAgentId.get(agent.code_name);
+    if (agentId) {
+      try {
+        const boardData = await api.post("/host/my-kanban", { agent_id: agentId });
+        const freshBoard = (boardData.items ?? []).map(sanitizeBoardItem);
+        const freshDoneIds = new Set(freshBoard.filter((b) => b.status === "done" || b.status === "failed").map((b) => b.id));
+        const previousDoneIds = notifyBoardCache.get(agent.code_name);
+        notifyBoardCache.set(agent.code_name, freshDoneIds);
+        if (!previousDoneIds) {
+          log(`[${agent.code_name}] Board diff: initial cache (${freshDoneIds.size} done items)`);
+        } else {
+          const newlyDone = freshBoard.filter(
+            (b) => (b.status === "done" || b.status === "failed") && !previousDoneIds.has(b.id)
+          );
+          log(`[${agent.code_name}] Board diff: ${previousDoneIds.size} prev done \u2192 ${freshDoneIds.size} now, ${newlyDone.length} newly done`);
+          if (newlyDone.length > 0) {
+            const displayName = agentDisplayNames.get(agent.code_name) ?? agent.code_name;
+            for (const item of newlyDone) {
+              log(`Newly done: '${item.title}' notify_channel=${item.notify_channel ?? "none"} notify_to=${item.notify_to ?? "none"}`);
+              if (item.notify_channel && item.notify_to) {
+                const isFailed = item.status === "failed";
+                const resultLine = item.result ? `
+${isFailed ? "Reason" : "Result"}: ${item.result}` : "";
+                const emoji = isFailed ? "\u274C" : "\u2705";
+                const message = `${emoji} ${isFailed ? "Task Failed" : "Task Complete"} \u2014 ${displayName}
+${item.title}${resultLine}`;
+                sendTaskNotification(agent.code_name, item.notify_channel, item.notify_to, message).catch((err) => {
+                  log(`sendTaskNotification failed for '${agent.code_name}': ${err.message}`);
+                });
+              }
+            }
+          }
+        }
+        const staleItems = freshBoard.filter((b) => {
+          if (b.status !== "in_progress" || !b.updated_at) return false;
+          const age = Date.now() - new Date(b.updated_at).getTime();
+          return age > STALE_TASK_THRESHOLD_MS && !alertedStaleItems.has(`${agent.code_name}:${b.id}`);
+        });
+        if (staleItems.length > 0) {
+          const displayName = agentDisplayNames.get(agent.code_name) ?? agent.code_name;
+          for (const item of staleItems) {
+            const age = Math.round((Date.now() - new Date(item.updated_at).getTime()) / 6e4);
+            log(`Stale task: '${item.title}' (id=${item.id}) in_progress for ${age}m \u2014 auto-failing for '${agent.code_name}'`);
+            alertedStaleItems.add(`${agent.code_name}:${item.id}`);
+            try {
+              const failResult = await api.post("/host/kanban", {
+                agent_id: agentId,
+                update: [{ id: item.id, title: item.title, status: "failed", result: `Timed out \u2014 in progress for ${age} minutes with no update` }]
+              });
+              log(`Auto-fail result for '${item.title}': updated=${failResult.updated}`);
+              if ((failResult.updated ?? 0) > 0 || failResult.ok === true) {
+                freshDoneIds.add(item.id);
+              }
+            } catch (err) {
+              log(`Auto-fail API error for '${item.title}': ${err.message}`);
+            }
+            const message = `\u23F3 Task Timed Out \u2014 ${displayName}
+${item.title}
+In progress for ${age} minutes with no update \u2014 auto-failed`;
+            if (item.notify_channel && item.notify_to) {
+              sendTaskNotification(agent.code_name, item.notify_channel, item.notify_to, message).catch(() => {
+              });
+            }
+            sendSlackWebhookMessage(`\u23F3 *Task Timed Out* \u2014 *${displayName}*
+*${item.title}*
+In progress for ${age} minutes \u2014 auto-failed`).catch(() => {
+            });
+          }
+        }
+        const prefix = `${agent.code_name}:`;
+        for (const key of alertedStaleItems) {
+          if (key.startsWith(prefix)) {
+            const itemId = key.slice(prefix.length);
+            if (!freshBoard.some((b) => b.id === itemId && b.status === "in_progress")) {
+              alertedStaleItems.delete(key);
+            }
+          }
+        }
+      } catch (err) {
+        log(`Board diff failed for '${agent.code_name}': ${err.message}`);
+      }
+    }
+  }
+  agentStates.push({
+    agentId: agent.agent_id,
+    codeName: agent.code_name,
+    status: agent.status,
+    charterVersion,
+    toolsVersion,
+    secretsHash,
+    lastRefreshAt: now,
+    lastProvisionAt,
+    lastDriftCheckAt,
+    lastSecretsProvisionAt,
+    gatewayPort,
+    gatewayPid,
+    gatewayRunning,
+    acpSessions: []
+  });
+}
+var CRON_SESSION_KEEP_COUNT = 10;
+var CRON_RUN_RETENTION_DAYS = 7;
+var lastCleanupAt = /* @__PURE__ */ new Map();
+var CLEANUP_INTERVAL_MS = 6e4;
+function cleanupStaleSessions(codeName) {
+  const lastRun = lastCleanupAt.get(codeName) ?? 0;
+  if (lastRun > 0 && Date.now() - lastRun < CLEANUP_INTERVAL_MS) return;
+  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");
+    cleanupCronSessions(sessionsDir, CRON_SESSION_KEEP_COUNT);
+  }
+  const cronRunsDir = join2(homeDir, `.openclaw-${codeName}`, "cron", "runs");
+  cleanupOldFiles(cronRunsDir, CRON_RUN_RETENTION_DAYS, ".jsonl");
+  const cronJobsPath = join2(homeDir, `.openclaw-${codeName}`, "cron", "jobs.json");
+  clearStaleCronRunState(cronJobsPath);
+}
+function cleanupCronSessions(sessionsDir, keepCount) {
+  const indexPath = join2(sessionsDir, "sessions.json");
+  if (!existsSync2(indexPath)) return;
+  try {
+    const raw = readFileSync2(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,
+      sessionId: index[k]?.sessionId,
+      updatedAt: index[k]?.updatedAt ?? 0
+    })).sort((a, b) => b.updatedAt - a.updatedAt);
+    if (cronRunKeys.length <= keepCount) return;
+    const toDelete = cronRunKeys.slice(keepCount);
+    let deletedFiles = 0;
+    for (const entry of toDelete) {
+      delete index[entry.key];
+      if (entry.sessionId) {
+        const sessionFile = join2(sessionsDir, `${entry.sessionId}.jsonl`);
+        try {
+          if (existsSync2(sessionFile)) {
+            unlinkSync(sessionFile);
+            deletedFiles++;
+          }
+        } catch {
+        }
+      }
+    }
+    const cronParentKeys = Object.keys(index).filter(
+      (k) => k.includes(":cron:") && !k.includes(":run:") && k !== "agent:main:main"
+    );
+    for (const parentKey of cronParentKeys) {
+      const hasRuns = Object.keys(index).some(
+        (k) => k.startsWith(parentKey + ":run:")
+      );
+      if (!hasRuns) {
+        const parentSessionId = index[parentKey]?.sessionId;
+        delete index[parentKey];
+        if (parentSessionId) {
+          try {
+            const f = join2(sessionsDir, `${parentSessionId}.jsonl`);
+            if (existsSync2(f)) {
+              unlinkSync(f);
+              deletedFiles++;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    writeFileSync(indexPath, JSON.stringify(index));
+    if (toDelete.length > 0) {
+      log(`Cleaned ${toDelete.length} cron session(s) and ${deletedFiles} file(s) from ${sessionsDir}`);
+    }
+  } catch {
+  }
+}
+var STALE_RUN_TIMEOUT_MS = 5 * 6e4;
+function clearStaleCronRunState(jobsPath) {
+  if (!existsSync2(jobsPath)) return;
+  try {
+    const raw = readFileSync2(jobsPath, "utf-8");
+    const data = JSON.parse(raw);
+    const jobs = data.jobs ?? data;
+    if (!Array.isArray(jobs)) return;
+    let changed = false;
+    const now = Date.now();
+    for (const job of jobs) {
+      const state2 = job.state;
+      if (!state2) continue;
+      const runStartedAt = state2.runningAtMs ?? state2.runStartedAtMs;
+      const isRunning = state2.running === true || state2.status === "running";
+      if (isRunning && runStartedAt && now - runStartedAt > STALE_RUN_TIMEOUT_MS) {
+        state2.running = false;
+        delete state2.status;
+        delete state2.runStartedAtMs;
+        delete state2.currentRunId;
+        changed = true;
+        log(`Cleared stale running state for cron job '${job.name}' (stuck for ${Math.round((now - runStartedAt) / 6e4)}min)`);
+      } else if (isRunning && !runStartedAt) {
+        state2.running = false;
+        changed = true;
+        log(`Cleared stale running state for cron job '${job.name}' (no start timestamp)`);
+      }
+    }
+    if (changed) {
+      writeFileSync(jobsPath, JSON.stringify(data, null, 2));
+    }
+  } catch {
+  }
+}
+function cleanupOldFiles(dir, maxAgeDays, ext) {
+  if (!existsSync2(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);
+      try {
+        const st = statSync(fullPath);
+        if (st.mtimeMs < cutoff) {
+          unlinkSync(fullPath);
+          removed++;
+        }
+      } catch {
+      }
+    }
+    if (removed > 0) {
+      log(`Cleaned ${removed} old cron run log(s) from ${dir}`);
+    }
+  } catch {
+  }
+}
+var inFlightClaudeTasks = /* @__PURE__ */ new Set();
+var claudeTaskConcurrency = /* @__PURE__ */ new Map();
+var MAX_CLAUDE_CONCURRENCY = 2;
+var claudeSchedulerStates = /* @__PURE__ */ new Map();
+async function syncAndCheckClaudeScheduler(agent, tasks, boardItems, refreshData) {
+  const codeName = agent.code_name;
+  const stableTasksHash = createHash("sha256").update(JSON.stringify(tasks)).digest("hex").slice(0, 16);
+  const boardHash = boardItems.length > 0 ? createHash("sha256").update(JSON.stringify(boardItems.map((b) => ({ id: b.id, title: b.title, status: b.status, priority: b.priority, deliverable: b.deliverable })))).digest("hex").slice(0, 16) : "empty";
+  const resolvedModels = resolveModelChain(refreshData);
+  const modelsHash = createHash("sha256").update(JSON.stringify(resolvedModels)).digest("hex").slice(0, 16);
+  const combinedHash = `${stableTasksHash}:${boardHash}:${modelsHash}`;
+  const prevHash = knownTasksHashes.get(agent.agent_id);
+  if (combinedHash !== 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 state3 = syncTasksToScheduler(codeName, agent.agent_id, taskInputs);
+    claudeSchedulerStates.set(codeName, state3);
+    knownTasksHashes.set(agent.agent_id, combinedHash);
+    log(`[claude-scheduler] Tasks synced for '${codeName}' (${taskInputs.length} task(s))`);
+  }
+  if (!claudeSchedulerStates.has(codeName)) {
+    claudeSchedulerStates.set(codeName, loadSchedulerState(codeName));
+  }
+  const state2 = claudeSchedulerStates.get(codeName);
+  const ready = getReadyTasks(state2);
+  if (ready.length === 0) return;
+  for (const task of ready) {
+    if (inFlightClaudeTasks.has(task.taskId)) continue;
+    if ((claudeTaskConcurrency.get(codeName) ?? 0) >= MAX_CLAUDE_CONCURRENCY) break;
+    let prompt = task.prompt;
+    if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
+      const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
+      const boardPrefix = formatBoardForPrompt(boardItems, template);
+      prompt = boardPrefix + prompt;
+    }
+    if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
+      const todayItem = boardItems.find((b) => b.status === "today");
+      if (todayItem) {
+        try {
+          await api.post("/host/kanban", {
+            agent_id: agent.agent_id,
+            update: [{ id: todayItem.id, title: todayItem.title, status: "in_progress" }]
+          });
+          log(`[claude-scheduler] Moved '${todayItem.title}' to in_progress for '${codeName}'`);
+        } catch (err) {
+          log(`[claude-scheduler] Failed to move item to in_progress: ${err.message}`);
+        }
+      }
+    }
+    inFlightClaudeTasks.add(task.taskId);
+    claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
+    log(`[claude-scheduler] Firing '${task.name}' for '${codeName}'`);
+    executeAndProcessClaudeTask(codeName, agent.agent_id, task, prompt).finally(() => {
+      inFlightClaudeTasks.delete(task.taskId);
+      claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+    });
+  }
+}
+async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
+  const projectDir = getProjectDir(codeName);
+  const mcpConfigPath = join2(projectDir, ".mcp.json");
+  try {
+    const claudeMdPath = join2(projectDir, "CLAUDE.md");
+    const claudeArgs = [
+      "-p",
+      prompt,
+      "--output-format",
+      "text",
+      "--mcp-config",
+      mcpConfigPath,
+      "--allowedTools",
+      "mcp__augmented__*,Bash,Read,Write,Edit,Grep,Glob"
+    ];
+    if (existsSync2(claudeMdPath)) {
+      claudeArgs.push("--system-prompt-file", claudeMdPath);
+    }
+    const { stdout, stderr } = await execFilePromiseLong("claude", claudeArgs, {
+      cwd: projectDir,
+      timeout: 3e5,
+      stdin: "ignore"
+    });
+    if (stderr) {
+      log(`[claude-scheduler] Task '${task.name}' stderr for '${codeName}': ${stderr.slice(0, 500)}`);
+    }
+    const output = stdout.trim();
+    log(`[claude-scheduler] Task '${task.name}' completed for '${codeName}' (${output.length} chars): ${output.slice(0, 300)}`);
+    await processClaudeTaskResult(codeName, agentId, task.templateId, output);
+    const updated = markTaskFired(codeName, task.taskId, "ok");
+    claudeSchedulerStates.set(codeName, updated);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log(`[claude-scheduler] Task '${task.name}' failed for '${codeName}': ${errMsg}`);
+    const updated = markTaskFired(codeName, task.taskId, "error");
+    claudeSchedulerStates.set(codeName, updated);
+  }
+}
+async function processClaudeTaskResult(codeName, agentId, templateId, output) {
+  try {
+    if (STANDUP_TEMPLATES.has(templateId)) {
+      const standup = parseStandupSummary(output);
+      await api.post("/host/agent-status", {
+        agent_id: agentId,
+        standup,
+        current_status: "idle"
+      });
+      log(`[claude-scheduler] Standup posted for '${codeName}'`);
+    } else if (TASK_UPDATE_TEMPLATES.has(templateId)) {
+      await api.post("/host/agent-status", {
+        agent_id: agentId,
+        current_tasks: output.slice(0, 2e3)
+      });
+      log(`[claude-scheduler] Task update posted for '${codeName}'`);
+    } else if (PLAN_TEMPLATES.has(templateId)) {
+      const planItems = parsePlanItems(output);
+      if (planItems.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          add: planItems
+        });
+        log(`[claude-scheduler] Plan items posted for '${codeName}' (${planItems.length} items)`);
+      }
+    } else if (KANBAN_WORK_TEMPLATES.has(templateId)) {
+      const kanbanUpdates = parseKanbanUpdates(output);
+      if (kanbanUpdates.length > 0) {
+        await api.post("/host/kanban", {
+          agent_id: agentId,
+          update: kanbanUpdates
+        });
+        log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
+      }
+    }
+  } catch (err) {
+    log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
+  }
+}
+function fireClaudeWorkTrigger(codeName, agentId, boardItems) {
+  const state2 = claudeSchedulerStates.get(codeName) ?? loadSchedulerState(codeName);
+  const kanbanTask = findTaskByTemplate(state2, "kanban-work");
+  if (!kanbanTask) {
+    log(`[claude-scheduler] Work trigger: no kanban-work task found for '${codeName}'`);
+    return;
+  }
+  if (inFlightClaudeTasks.has(kanbanTask.taskId)) {
+    log(`[claude-scheduler] Work trigger: kanban-work already in-flight for '${codeName}'`);
+    return;
+  }
+  let prompt = kanbanTask.prompt;
+  if (boardItems.length > 0) {
+    const boardPrefix = formatBoardForPrompt(boardItems, "follow-up");
+    prompt = boardPrefix + prompt;
+  }
+  inFlightClaudeTasks.add(kanbanTask.taskId);
+  claudeTaskConcurrency.set(codeName, (claudeTaskConcurrency.get(codeName) ?? 0) + 1);
+  log(`[claude-scheduler] Work trigger: firing kanban-work for '${codeName}'`);
+  executeAndProcessClaudeTask(codeName, agentId, kanbanTask, prompt).finally(() => {
+    inFlightClaudeTasks.delete(kanbanTask.taskId);
+    claudeTaskConcurrency.set(codeName, Math.max(0, (claudeTaskConcurrency.get(codeName) ?? 1) - 1));
+  });
+}
+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 channelConfigs = refreshData.channel_configs;
+  const channels = [];
+  const devChannels = [];
+  if (channelConfigs) {
+    if ("telegram" in channelConfigs) {
+      channels.push("plugin:telegram@claude-plugins-official");
+    }
+    if ("discord" in channelConfigs) {
+      channels.push("plugin:discord@claude-plugins-official");
+    }
+    if ("slack" in channelConfigs) {
+      devChannels.push("server:slack");
+    }
+  }
+  if (!isSessionHealthy(codeName)) {
+    if (persistentSessionAgents.has(codeName)) {
+      log(`[persistent-session] Session for '${codeName}' is unhealthy, will restart`);
+    }
+    startPersistentSession({
+      codeName,
+      agentId: agent.agent_id,
+      projectDir,
+      mcpConfigPath,
+      claudeMdPath,
+      channels,
+      devChannels,
+      log
+    });
+    persistentSessionAgents.add(codeName);
+    return;
+  }
+  resetRestartCount(codeName);
+  const state2 = claudeSchedulerStates.get(codeName);
+  if (state2) {
+    const ready = getReadyTasks(state2);
+    if (ready.length > 0) {
+      log(`[persistent-session] ${ready.length} ready task(s) for '${codeName}': ${ready.map((t) => `${t.name}(next=${t.nextFireAt ? new Date(t.nextFireAt).toISOString() : "null"})`).join(", ")}`);
+    }
+    for (const task of ready) {
+      let prompt = task.prompt;
+      if (BOARD_INJECT_TEMPLATES.has(task.templateId) && boardItems.length > 0) {
+        const template = PLAN_TEMPLATES.has(task.templateId) ? "morning-plan" : "follow-up";
+        const boardPrefix = formatBoardForPrompt(boardItems, template);
+        prompt = boardPrefix + prompt;
+      }
+      if (KANBAN_WORK_TEMPLATES.has(task.templateId)) {
+        const todayItem = boardItems.find((b) => b.status === "today");
+        if (todayItem) {
+          try {
+            await api.post("/host/kanban", {
+              agent_id: agent.agent_id,
+              update: [{ id: todayItem.id, title: todayItem.title, status: "in_progress" }]
+            });
+            log(`[persistent-session] Moved '${todayItem.title}' to in_progress for '${codeName}'`);
+          } catch {
+          }
+        }
+      }
+      log(`[persistent-session] Injecting task '${task.name}' into '${codeName}'`);
+      const injected = await injectMessage(codeName, "task", prompt, {
+        task_id: task.taskId,
+        template_id: task.templateId,
+        task_name: task.name
+      });
+      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()}`);
+      }
+      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;
+var realtimeKanbanStarted = false;
+var realtimeAssignStarted = false;
+var realtimeConfigStarted = false;
+function ensureRealtimeStarted(agentStates) {
+  if (realtimeStarted) return;
+  const activeAgentIds = agentStates.filter((a) => a.status === "active").map((a) => a.agentId);
+  if (activeAgentIds.length === 0) return;
+  const apiKey = process.env["AGT_API_KEY"];
+  if (!apiKey) return;
+  void exchangeApiKey(apiKey).then((exchange) => {
+    if (!exchange.supabaseUrl || !exchange.supabaseAnonKey) {
+      log("[realtime-chat] No Supabase URL/key from exchange \u2014 staying on polling");
+      return;
+    }
+    startRealtimeChat({
+      supabaseUrl: exchange.supabaseUrl,
+      supabaseAnonKey: exchange.supabaseAnonKey,
+      token: exchange.token,
+      agentIds: activeAgentIds,
+      onMessage: (msg) => {
+        const agent = agentStates.find((a) => a.agentId === msg.agent_id);
+        if (!agent) return;
+        if (directChatInFlight.has(msg.id)) return;
+        directChatInFlight.add(msg.id);
+        processDirectChatMessage(agent, {
+          id: msg.id,
+          session_id: msg.session_id,
+          content: msg.content
+        }).finally(() => {
+          directChatInFlight.delete(msg.id);
+        });
+      },
+      onError: (err) => {
+        log(`[realtime-chat] Error: ${err.message}`);
+      },
+      onStatusChange: (status) => {
+        if (status === "disconnected" || status === "error") {
+          log("[realtime] Disconnected \u2014 falling back to polling, will reconnect next cycle");
+          realtimeStarted = false;
+          realtimeDriftStarted = false;
+          realtimeAssignStarted = false;
+          realtimeConfigStarted = false;
+          realtimeKanbanStarted = false;
+        }
+      },
+      log
+    });
+    realtimeStarted = true;
+    log(`[realtime-chat] Started for ${activeAgentIds.length} agent(s)`);
+  }).catch((err) => {
+    log(`[realtime-chat] Failed to start: ${err.message}`);
+  });
+}
+function ensureRealtimeDriftStarted(agentStates) {
+  if (realtimeDriftStarted) return;
+  const activeAgentIds = agentStates.filter((a) => a.status === "active").map((a) => a.agentId);
+  if (activeAgentIds.length === 0) return;
+  const apiKey = process.env["AGT_API_KEY"];
+  if (!apiKey) return;
+  void exchangeApiKey(apiKey).then((exchange) => {
+    if (!exchange.supabaseUrl || !exchange.supabaseAnonKey) return;
+    startRealtimeDrift({
+      supabaseUrl: exchange.supabaseUrl,
+      supabaseAnonKey: exchange.supabaseAnonKey,
+      token: exchange.token,
+      agentIds: activeAgentIds,
+      onDrift: (doc) => {
+        const agentState = agentStates.find((a) => a.agentId === doc.agent_id);
+        if (agentState) {
+          knownVersions.delete(doc.agent_id);
+          log(`[realtime] Drift invalidated for '${agentState.codeName}' \u2014 will re-provision next cycle`);
+        }
+      },
+      log
+    });
+    realtimeDriftStarted = true;
+    log(`[realtime] Drift subscription started for ${activeAgentIds.length} agent(s)`);
+  }).catch((err) => {
+    log(`[realtime] Drift subscription failed: ${err.message}`);
+  });
+}
+function ensureRealtimeAssignStarted(agentStates) {
+  if (realtimeAssignStarted) return;
+  const apiKey = process.env["AGT_API_KEY"];
+  if (!apiKey) return;
+  void exchangeApiKey(apiKey).then((exchange) => {
+    if (!exchange.supabaseUrl || !exchange.supabaseAnonKey || !exchange.hostId) return;
+    startRealtimeAssignments({
+      supabaseUrl: exchange.supabaseUrl,
+      supabaseAnonKey: exchange.supabaseAnonKey,
+      token: exchange.token,
+      hostId: exchange.hostId,
+      onAssign: (payload) => {
+        log(`[realtime] Agent ${payload.agent_id} assigned \u2014 will pick up next cycle`);
+      },
+      onUnassign: (payload) => {
+        log(`[realtime] Agent ${payload.agent_id} unassigned`);
+        clearAgentCaches(payload.agent_id, "");
+      },
+      log
+    });
+    realtimeAssignStarted = true;
+    log(`[realtime] Assignment subscription started for host ${exchange.hostId}`);
+  }).catch((err) => {
+    log(`[realtime] Assignment subscription failed: ${err.message}`);
+  });
+}
+function ensureRealtimeConfigStarted(agentStates) {
+  if (realtimeConfigStarted) return;
+  const activeAgentIds = agentStates.filter((a) => a.status === "active").map((a) => a.agentId);
+  if (activeAgentIds.length === 0) return;
+  const apiKey = process.env["AGT_API_KEY"];
+  if (!apiKey) return;
+  void exchangeApiKey(apiKey).then((exchange) => {
+    if (!exchange.supabaseUrl || !exchange.supabaseAnonKey) return;
+    startRealtimeConfig({
+      supabaseUrl: exchange.supabaseUrl,
+      supabaseAnonKey: exchange.supabaseAnonKey,
+      token: exchange.token,
+      agentIds: activeAgentIds,
+      onConfigChange: (agent) => {
+        knownStatuses.delete(agent.agent_id);
+      },
+      log
+    });
+    realtimeConfigStarted = true;
+    log(`[realtime] Config subscription started for ${activeAgentIds.length} agent(s)`);
+  }).catch((err) => {
+    log(`[realtime] Config subscription failed: ${err.message}`);
+  });
+}
+function ensureRealtimeKanbanStarted(agentStates) {
+  if (realtimeKanbanStarted) return;
+  const activeAgentIds = agentStates.filter((a) => a.status === "active").map((a) => a.agentId);
+  if (activeAgentIds.length === 0) return;
+  const apiKey = process.env["AGT_API_KEY"];
+  if (!apiKey) return;
+  void exchangeApiKey(apiKey).then((exchange) => {
+    if (!exchange.supabaseUrl || !exchange.supabaseAnonKey) return;
+    startRealtimeKanban({
+      supabaseUrl: exchange.supabaseUrl,
+      supabaseAnonKey: exchange.supabaseAnonKey,
+      token: exchange.token,
+      agentIds: activeAgentIds,
+      onTodayItem: (item) => {
+        const agent = agentStates.find((a) => a.agentId === item.agent_id);
+        if (!agent) return;
+        const agentFw = agentFrameworkCache.get(agent.codeName) ?? "openclaw";
+        if (agentFw === "claude-code") {
+          const boardItems = kanbanBoardCache.get(agent.codeName) ?? [];
+          if (isSessionHealthy(agent.codeName)) {
+            injectMessage(agent.codeName, "task", `New task added to your board: "${item.title}" (priority ${item.priority}). Pick it up \u2014 move to in_progress and start working.`, {
+              task_name: "kanban-work-trigger"
+            });
+            log(`[realtime] Injected kanban-work trigger for '${agent.codeName}': "${item.title}"`);
+          } else {
+            fireClaudeWorkTrigger(agent.codeName, agent.agentId, boardItems);
+            log(`[realtime] Fired kanban-work for '${agent.codeName}': "${item.title}"`);
+          }
+        }
+      },
+      log
+    });
+    realtimeKanbanStarted = true;
+    log(`[realtime] Kanban subscription started for ${activeAgentIds.length} agent(s)`);
+  }).catch((err) => {
+    log(`[realtime] Kanban subscription failed: ${err.message}`);
+  });
+}
+var directChatInFlight = /* @__PURE__ */ new Set();
+async function pollDirectChatMessages(agentStates) {
+  for (const agent of agentStates) {
+    if (agent.status !== "active") continue;
+    const fw = agentFrameworkCache.get(agent.codeName) ?? "openclaw";
+    if (fw === "openclaw" && (!agent.gatewayRunning || !agent.gatewayPort)) continue;
+    try {
+      const data = await api.post("/host/direct-chat/poll", { agent_id: agent.agentId });
+      for (const msg of data.messages) {
+        if (directChatInFlight.has(msg.id)) continue;
+        directChatInFlight.add(msg.id);
+        processDirectChatMessage(agent, msg).finally(() => {
+          directChatInFlight.delete(msg.id);
+        });
+      }
+    } catch (err) {
+      log(`Direct chat poll failed for '${agent.codeName}': ${err.message}`);
+    }
+  }
+}
+async function processDirectChatMessage(agent, msg) {
+  const fw = agentFrameworkCache.get(agent.codeName) ?? "openclaw";
+  log(`[direct-chat] Processing message for '${agent.codeName}' (fw=${fw}): id=${msg.id} len=${msg.content.length}`);
+  try {
+    let reply;
+    if (fw === "claude-code") {
+      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-APXMZEK4.js");
+      const projDir = ccProjectDir(agent.codeName);
+      const chatArgs = [
+        "-p",
+        msg.content,
+        "--output-format",
+        "text",
+        "--mcp-config",
+        join2(projDir, ".mcp.json"),
+        "--allowedTools",
+        "mcp__augmented__*,Bash,Read,Write,Edit,Grep,Glob"
+      ];
+      const chatClaudeMd = join2(projDir, "CLAUDE.md");
+      if (existsSync2(chatClaudeMd)) {
+        chatArgs.push("--system-prompt-file", chatClaudeMd);
+      }
+      const { stdout } = await execFilePromiseLong("claude", chatArgs, { cwd: projDir, stdin: "ignore" });
+      reply = stdout.trim() || "[No response from agent]";
+    } else {
+      const { stdout } = await execFilePromiseLong("openclaw", [
+        "--profile",
+        agent.codeName,
+        "agent",
+        "--local",
+        "--agent",
+        agent.codeName,
+        "--message",
+        msg.content,
+        "--session-id",
+        msg.session_id,
+        "--json"
+      ]);
+      try {
+        const parsed = JSON.parse(stdout);
+        const payloads = parsed?.payloads ?? parsed?.result?.payloads;
+        reply = payloads?.[0]?.text ?? parsed?.reply ?? parsed?.text ?? parsed?.message ?? stdout;
+      } catch {
+        reply = stdout.trim() || "[No response from agent]";
+      }
+    }
+    await api.post("/host/direct-chat/reply", {
+      agent_id: agent.agentId,
+      session_id: msg.session_id,
+      content: reply
+    });
+    log(`[direct-chat] Reply sent for '${agent.codeName}'`);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const errorId = createHash("sha256").update(errMsg).digest("hex").slice(0, 12);
+    log(`[direct-chat] Failed to process message for '${agent.codeName}': error_id=${errorId}`);
+    try {
+      await api.post("/host/direct-chat/reply", {
+        agent_id: agent.agentId,
+        session_id: msg.session_id,
+        content: `[Error] Failed to process message (ref: ${errorId}). Please retry.`
+      });
+    } catch {
+    }
+  }
+}
+var STANDUP_TEMPLATES = /* @__PURE__ */ new Set(["daily-standup", "end-of-day-summary"]);
+var TASK_UPDATE_TEMPLATES = /* @__PURE__ */ new Set(["hourly-status", "task-update"]);
+var PLAN_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan"]);
+var KANBAN_WORK_TEMPLATES = /* @__PURE__ */ new Set(["kanban-work"]);
+var BOARD_INJECT_TEMPLATES = /* @__PURE__ */ new Set(["morning-plan", "task-update", "hourly-status", "end-of-day-summary", "kanban-work"]);
+var lastHarvestAt = /* @__PURE__ */ new Map();
+var HARVEST_INTERVAL_MS = 3 * 60 * 1e3;
+var kanbanBoardCache = /* @__PURE__ */ new Map();
+var notifyBoardCache = /* @__PURE__ */ new Map();
+async function harvestCronResults(codeName, tasks, gatewayPort) {
+  const token = readGatewayToken(codeName);
+  const gwArgs = ["--url", `ws://127.0.0.1:${gatewayPort}`, ...token ? ["--token", token] : []];
+  let gatewayJobs = [];
+  try {
+    const cliBin = resolveAgentFramework(codeName).cliBinary ?? "openclaw";
+    const { stdout } = await execFilePromise(cliBin, ["--profile", codeName, "cron", "list", "--json", ...gwArgs]);
+    const parsed = JSON.parse(stdout);
+    gatewayJobs = parsed.jobs ?? [];
+  } catch {
+    return;
+  }
+  const jobTemplateMap = /* @__PURE__ */ new Map();
+  for (const job of gatewayJobs) {
+    if (!job.name.startsWith("aug:")) continue;
+    const parts = job.name.split(":");
+    if (parts.length >= 3) {
+      jobTemplateMap.set(job.id, parts[1]);
+    }
+  }
+  for (const [jobId, templateId] of jobTemplateMap) {
+    if (!STANDUP_TEMPLATES.has(templateId) && !TASK_UPDATE_TEMPLATES.has(templateId) && !PLAN_TEMPLATES.has(templateId) && !KANBAN_WORK_TEMPLATES.has(templateId)) continue;
+    let runs = [];
+    try {
+      const cliBin2 = resolveAgentFramework(codeName).cliBinary ?? "openclaw";
+      const { stdout } = await execFilePromise(cliBin2, ["--profile", codeName, "cron", "runs", "--id", jobId, ...gwArgs]);
+      const parsed = JSON.parse(stdout);
+      runs = parsed.entries ?? [];
+    } catch {
+      continue;
+    }
+    const latestRun = runs.filter((r) => r.action === "finished").sort((a, b) => b.ts - a.ts)[0];
+    if (latestRun) {
+      const agentId = codeNameToAgentId.get(codeName);
+      const summary = latestRun.summary ?? "";
+      const isKeyError = summary.includes("Key limit exceeded") || summary.includes("key limit") || summary.includes("rate limit") || summary.includes("insufficient_quota") || summary.includes("billing") || summary.includes("402");
+      if (agentId) {
+        if (latestRun.status === "error" && isKeyError) {
+          const errorMsg = summary.slice(0, 200);
+          if (!apiKeyStatusCache.get(codeName)) {
+            apiKeyStatusCache.set(codeName, true);
+            api.post("/host/agent-api-key-status", { agent_id: agentId, status: "rate_limited", error: errorMsg }).catch(() => {
+            });
+            log(`API key error detected for '${codeName}': ${errorMsg}`);
+          }
+        } else if (latestRun.status === "ok" && apiKeyStatusCache.get(codeName)) {
+          apiKeyStatusCache.delete(codeName);
+          api.post("/host/agent-api-key-status", { agent_id: agentId, status: null, error: null }).catch(() => {
+          });
+          log(`API key status cleared for '${codeName}' \u2014 run succeeded`);
+        }
+      }
+    }
+    const completed = runs.filter((r) => r.action === "finished" && r.status === "ok" && r.summary).sort((a, b) => b.ts - a.ts);
+    if (completed.length === 0) continue;
+    const latest = completed[0];
+    const lastSeen = lastCronRunTs.get(jobId) ?? 0;
+    if (latest.ts <= lastSeen) continue;
+    lastCronRunTs.set(jobId, latest.ts);
+    const statusUpdate = { agent_code_name: codeName };
+    if (STANDUP_TEMPLATES.has(templateId)) {
+      const summary = latest.summary ?? "";
+      statusUpdate.standup = parseStandupSummary(summary);
+    }
+    if (TASK_UPDATE_TEMPLATES.has(templateId)) {
+      statusUpdate.current_tasks = latest.summary ?? "";
+    }
+    if (statusUpdate.standup || statusUpdate.current_tasks !== void 0) {
+      try {
+        await api.post("/host/agent-status", statusUpdate);
+        log(`Updated ${templateId} for '${codeName}' from cron result`);
+      } catch (err) {
+        log(`Failed to update ${templateId} for '${codeName}': ${err.message}`);
+      }
+    }
+    if (PLAN_TEMPLATES.has(templateId)) {
+      const summary = latest.summary ?? "";
+      const planItems = parsePlanItems(summary);
+      if (planItems.length > 0) {
+        try {
+          const agentId = codeNameToAgentId.get(codeName);
+          if (agentId) {
+            await api.post("/host/kanban", {
+              agent_id: agentId,
+              add: planItems,
+              archive_days: 7
+            });
+            log(`Added ${planItems.length} kanban items for '${codeName}' from morning-plan`);
+          }
+        } catch (err) {
+          log(`Failed to update kanban for '${codeName}': ${err.message}`);
+        }
+      }
+    }
+    if (TASK_UPDATE_TEMPLATES.has(templateId) || KANBAN_WORK_TEMPLATES.has(templateId)) {
+      const summary = latest.summary ?? "";
+      const kanbanUpdates = parseKanbanUpdates(summary);
+      if (kanbanUpdates.length > 0) {
+        try {
+          const agentId = codeNameToAgentId.get(codeName);
+          if (agentId) {
+            await api.post("/host/kanban", {
+              agent_id: agentId,
+              update: kanbanUpdates
+            });
+            log(`Updated ${kanbanUpdates.length} kanban items for '${codeName}'`);
+          }
+        } catch (err) {
+          log(`Failed to update kanban for '${codeName}': ${err.message}`);
+        }
+      }
+    }
+  }
+}
+function parseStandupSummary(summary) {
+  const lines = summary.split("\n");
+  let yesterday = "";
+  let today = "";
+  let blockers = "";
+  let currentSection = null;
+  for (const line of lines) {
+    const lower = line.toLowerCase();
+    if (lower.includes("yesterday") || lower.includes("accomplished")) {
+      currentSection = "yesterday";
+      continue;
+    } else if (lower.includes("today") || lower.includes("working on")) {
+      currentSection = "today";
+      continue;
+    } else if (lower.includes("blocker")) {
+      currentSection = "blockers";
+      continue;
+    }
+    const trimmed = line.replace(/^[-*•]\s*/, "").trim();
+    if (!trimmed) continue;
+    switch (currentSection) {
+      case "yesterday":
+        yesterday += (yesterday ? "\n" : "") + trimmed;
+        break;
+      case "today":
+        today += (today ? "\n" : "") + trimmed;
+        break;
+      case "blockers":
+        blockers += (blockers ? "\n" : "") + trimmed;
+        break;
+    }
+  }
+  if (!yesterday && !today && !blockers) {
+    today = summary;
+  }
+  return { yesterday, today, blockers };
+}
+function parsePlanItems(summary) {
+  const items = [];
+  const lines = summary.split("\n");
+  let currentItem = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const itemMatch = trimmed.match(/^(?:\d+[\.\)]\s*|[-*•]\s*)\[?(HIGH|MEDIUM|LOW|MED)\]?\s*(.+)/i);
+    if (itemMatch) {
+      if (currentItem) items.push(currentItem);
+      const priorityStr = itemMatch[1].toUpperCase();
+      const rest = itemMatch[2];
+      let estimatedMinutes;
+      const timeMatch = rest.match(/\(~?(\d+)\s*(min(?:utes?)?|hr?(?:ours?)?|h)\)/i);
+      if (timeMatch) {
+        const val = parseInt(timeMatch[1], 10);
+        const unit = timeMatch[2].toLowerCase();
+        estimatedMinutes = unit.startsWith("h") ? val * 60 : val;
+      }
+      const title = sanitizeKanbanString(
+        rest.replace(/\(~?\d+\s*(?:min(?:utes?)?|hr?(?:ours?)?|h)\)/i, ""),
+        MAX_KANBAN_TITLE_LENGTH
+      );
+      if (!title) continue;
+      const priorityMap = { HIGH: 1, MEDIUM: 2, MED: 2, LOW: 3 };
+      const priority = priorityMap[priorityStr] ?? 2;
+      if (![1, 2, 3].includes(priority)) continue;
+      currentItem = {
+        title,
+        priority,
+        estimated_minutes: estimatedMinutes,
+        status: "today"
+      };
+    } else if (currentItem && trimmed && !trimmed.match(/^(?:PLAN|---)/i)) {
+      const descLine = sanitizeKanbanString(trimmed, MAX_KANBAN_NOTES_LENGTH);
+      currentItem.description = currentItem.description ? sanitizeKanbanString(currentItem.description + "\n" + descLine, MAX_KANBAN_NOTES_LENGTH) : descLine;
+    }
+  }
+  if (currentItem) items.push(currentItem);
+  return items;
+}
+var VALID_KANBAN_STATUSES = /* @__PURE__ */ new Set(["backlog", "today", "in_progress", "done"]);
+var MAX_KANBAN_TITLE_LENGTH = 500;
+var MAX_KANBAN_NOTES_LENGTH = 2e3;
+function sanitizeKanbanString(value, maxLen) {
+  if (!value) return "";
+  return value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "").replace(/\{\{.*?\}\}/g, "").replace(/^(System|Assistant|Human):\s*/gmi, "").replace(/#{2,}/g, "").replace(/\s+/g, " ").trim().slice(0, maxLen);
+}
+function sanitizeBoardItem(item) {
+  return {
+    ...item,
+    title: sanitizeKanbanString(item.title, 200),
+    status: sanitizeKanbanString(item.status, 50),
+    ...item.deliverable ? { deliverable: sanitizeKanbanString(item.deliverable, 500) } : {}
+  };
+}
+var builtInSkillCache = /* @__PURE__ */ new Map();
+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")
+    ];
+    for (const candidate of candidates) {
+      if (existsSync2(candidate)) {
+        const content = readFileSync2(candidate, "utf-8");
+        const files = [{ relativePath: "SKILL.md", content }];
+        builtInSkillCache.set(skillId, files);
+        return files;
+      }
+    }
+    builtInSkillCache.set(skillId, null);
+    return null;
+  } catch {
+    builtInSkillCache.set(skillId, null);
+    return null;
+  }
+}
+function parseKanbanUpdates(summary) {
+  const updates = [];
+  const kanbanIdx = summary.indexOf("KANBAN UPDATE:");
+  if (kanbanIdx === -1) return updates;
+  const kanbanSection = summary.slice(kanbanIdx + "KANBAN UPDATE:".length);
+  const lines = kanbanSection.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^[-*•]\s*"([^"]+)":\s*(backlog|today|in_progress|done)(?:\s*\((.+)\))?/i);
+    if (match) {
+      const status = match[2].toLowerCase();
+      if (!VALID_KANBAN_STATUSES.has(status)) continue;
+      const title = sanitizeKanbanString(match[1], MAX_KANBAN_TITLE_LENGTH);
+      if (!title) continue;
+      const parenthetical = match[3] ?? void 0;
+      let notes;
+      let result;
+      if (parenthetical && status === "done") {
+        const resultMatch = parenthetical.match(/^result:\s*(.+)/i);
+        if (resultMatch) {
+          result = sanitizeKanbanString(resultMatch[1], MAX_KANBAN_NOTES_LENGTH);
+        } else {
+          notes = sanitizeKanbanString(parenthetical, MAX_KANBAN_NOTES_LENGTH);
+        }
+      } else if (parenthetical) {
+        notes = sanitizeKanbanString(parenthetical, MAX_KANBAN_NOTES_LENGTH);
+      }
+      updates.push({
+        title,
+        status,
+        notes,
+        result
+      });
+    }
+  }
+  return updates;
+}
+function formatBoardForPrompt(items, template) {
+  if (items.length === 0) return "";
+  const priorityLabel = (p) => p === 1 ? "HIGH" : p === 3 ? "LOW" : "MED";
+  const timeLabel = (m) => m ? ` (~${m >= 60 ? `${Math.round(m / 60)}hr` : `${m}min`})` : "";
+  const deliverableLine = (d) => d ? `
+     Deliverable: ${d}` : "";
+  const grouped = {};
+  for (const item of items) {
+    const key = item.status;
+    if (!grouped[key]) grouped[key] = [];
+    grouped[key].push(item);
+  }
+  const lines = [];
+  if (template === "morning-plan") {
+    lines.push("=== CURRENT BOARD ===");
+    for (const [status, label] of [["backlog", "BACKLOG (carry-over)"], ["today", "TODAY"], ["in_progress", "IN PROGRESS"]]) {
+      const statusItems = grouped[status];
+      if (statusItems && statusItems.length > 0) {
+        lines.push(`${label}:`);
+        statusItems.forEach((item, i) => {
+          lines.push(`  ${i + 1}. [${priorityLabel(item.priority)}] ${item.title}${timeLabel(item.estimated_minutes)}${deliverableLine(item.deliverable)}`);
+        });
+      }
+    }
+    lines.push("=====================");
+    lines.push("");
+    lines.push("Create today's plan. You may:");
+    lines.push('- Move backlog items to "today"');
+    lines.push("- Add new items you've identified");
+    lines.push("- Reprioritise existing items");
+    lines.push("");
+  } else {
+    lines.push("=== YOUR KANBAN BOARD ===");
+    for (const [status, label] of [["today", "TODAY"], ["in_progress", "IN PROGRESS"], ["backlog", "BACKLOG"]]) {
+      const statusItems = grouped[status];
+      if (statusItems && statusItems.length > 0) {
+        lines.push(`${label}:`);
+        statusItems.forEach((item, i) => {
+          lines.push(`  ${i + 1}. [${priorityLabel(item.priority)}] ${item.title}${timeLabel(item.estimated_minutes)}${deliverableLine(item.deliverable)}`);
+        });
+      }
+    }
+    const doneItems = grouped["done"];
+    if (doneItems && doneItems.length > 0) {
+      lines.push("DONE TODAY:");
+      doneItems.forEach((item, i) => {
+        lines.push(`  ${i + 1}. ${item.title}`);
+      });
+    }
+    lines.push("=========================");
+    lines.push("");
+    lines.push("IMPORTANT: Use kanban MCP tools to update the board IN REAL TIME:");
+    lines.push("1. FIRST call kanban.move to move your chosen item to in_progress BEFORE starting work");
+    lines.push("2. Do the work");
+    lines.push("3. Call kanban.done with a result summary when finished");
+    lines.push("4. If blocked, call kanban.update with notes, then pick the next item");
+    lines.push("");
+    lines.push("SELF-MANAGEMENT: When you receive a request from a channel (Slack, Telegram)");
+    lines.push("that takes more than a quick response, create a task first with kanban.add,");
+    lines.push("move to in_progress, do the work, then kanban.done with a result summary.");
+    lines.push("");
+    lines.push("If MCP tools are unavailable, include a KANBAN UPDATE section in your output:");
+    lines.push("KANBAN UPDATE:");
+    lines.push('- "item title": new_status (optional notes)');
+    lines.push('- "item title": done (result: <what you produced>)');
+    lines.push("Statuses: backlog, today, in_progress, done");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function execFilePromise(cmd, args) {
+  const { execFile: ef } = await import("child_process");
+  return new Promise((resolve, reject) => {
+    ef(cmd, args, { timeout: 15e3 }, (err, stdout, stderr) => {
+      if (err) reject(err);
+      else resolve({ stdout, stderr });
+    });
+  });
+}
+async function execFilePromiseLong(cmd, args, opts) {
+  const { spawn: sp } = await import("child_process");
+  return new Promise((resolve, reject) => {
+    const child = sp(cmd, args, {
+      cwd: opts?.cwd,
+      stdio: [opts?.stdin === "ignore" ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`Timed out after ${opts?.timeout ?? 12e4}ms`));
+    }, opts?.timeout ?? 12e4);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`Exit code ${code}: ${stderr.slice(0, 500)}`));
+      else resolve({ stdout, stderr });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+var LATE_THRESHOLD_MS = 5 * 60 * 1e3;
+async function monitorCronHealth(agentStates) {
+  const alerts = [];
+  const now = Date.now();
+  for (const agent of agentStates) {
+    if (!agent.gatewayRunning || !agent.gatewayPort) continue;
+    const token = readGatewayToken(agent.codeName);
+    const gwArgs = ["--url", `ws://127.0.0.1:${agent.gatewayPort}`, ...token ? ["--token", token] : []];
+    let jobs = [];
+    try {
+      const cliBin = resolveAgentFramework(agent.codeName).cliBinary ?? "openclaw";
+      const { stdout } = await execFilePromise(cliBin, ["--profile", agent.codeName, "cron", "list", "--json", ...gwArgs]);
+      const parsed = JSON.parse(stdout);
+      jobs = parsed.jobs ?? [];
+    } catch {
+      continue;
+    }
+    for (const job of jobs) {
+      if (!job.enabled || !job.name.startsWith("aug:")) continue;
+      const alertKey = `${agent.codeName}:${job.id}`;
+      const displayInfo = taskDisplayInfo.get(`${agent.codeName}:${job.name}`);
+      const taskName = displayInfo?.taskName ?? job.name;
+      const schedule = displayInfo?.schedule ?? "";
+      const agentDisplayName = displayInfo?.agentDisplayName ?? agent.codeName;
+      if (job.state?.nextRunAtMs && job.state.nextRunAtMs + LATE_THRESHOLD_MS < now) {
+        if (!alertedJobs.has(`late:${alertKey}`)) {
+          const minsLate = Math.round((now - job.state.nextRunAtMs) / 6e4);
+          alerts.push({
+            type: "late_standup",
+            agentCodeName: agent.codeName,
+            agentDisplayName,
+            jobName: job.name,
+            taskName,
+            schedule,
+            jobId: job.id,
+            detail: `Job is ${minsLate}m late (expected at ${new Date(job.state.nextRunAtMs).toISOString()})`
+          });
+          alertedJobs.add(`late:${alertKey}`);
+        }
+      } else {
+        alertedJobs.delete(`late:${alertKey}`);
+      }
+      if (job.state?.lastRunStatus === "error" || job.state?.consecutiveErrors && job.state.consecutiveErrors > 0) {
+        if (!alertedJobs.has(`fail:${alertKey}`)) {
+          alerts.push({
+            type: "cron_failure",
+            agentCodeName: agent.codeName,
+            agentDisplayName,
+            jobName: job.name,
+            taskName,
+            schedule,
+            jobId: job.id,
+            detail: `Last run failed (${job.state.consecutiveErrors ?? 1} consecutive error(s))`
+          });
+          alertedJobs.add(`fail:${alertKey}`);
+        }
+      } else {
+        alertedJobs.delete(`fail:${alertKey}`);
+      }
+    }
+  }
+  if (alerts.length === 0) return;
+  for (const alert of alerts) {
+    log(`ALERT [${alert.type}] ${alert.agentCodeName}/${alert.jobName}: ${alert.detail}`);
+  }
+  if (alertSlackWebhook) {
+    await sendSlackAlert(alerts);
+  }
+  try {
+    await api.post("/host/cron-alerts", { alerts });
+  } catch {
+  }
+}
+function telegramApiCall(botToken, method, body) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify(body);
+    const req = https.request({
+      hostname: "api.telegram.org",
+      port: 443,
+      path: `/bot${botToken}/${method}`,
+      method: "POST",
+      family: 4,
+      timeout: 1e4,
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }
+    }, (res) => {
+      let data = "";
+      res.on("data", (d) => {
+        data += d;
+      });
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error("Invalid JSON from Telegram API"));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Telegram API timeout"));
+    });
+    req.write(postData);
+    req.end();
+  });
+}
+async function sendSlackWebhookMessage(text) {
+  if (!alertSlackWebhook) {
+    log("sendSlackWebhookMessage: no alertSlackWebhook configured \u2014 message dropped");
+    return;
+  }
+  try {
+    const response = await fetch(alertSlackWebhook, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text })
+    });
+    if (!response.ok) {
+      log(`Slack webhook failed: ${response.status} ${response.statusText}`);
+    }
+  } catch (err) {
+    log(`Slack webhook error: ${err.message}`);
+  }
+}
+async function sendSlackChannelMessage(agentCodeName, channelId, text) {
+  const botToken = agentChannelTokens.get(agentCodeName)?.slack;
+  if (!botToken) {
+    log(`No Slack bot token cached for '${agentCodeName}' \u2014 cannot post to ${channelId}`);
+    return false;
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${botToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ channel: channelId, text }),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      const data = await response.json();
+      if (!data.ok) {
+        log(`Slack chat.postMessage failed for '${agentCodeName}' to ${channelId}: ${data.error}`);
+        return false;
+      }
+      return true;
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch (err) {
+    log(`Slack channel message error for '${agentCodeName}': ${err.message}`);
+    return false;
+  }
+}
+async function sendSlackAlert(alerts) {
+  const blocks = alerts.map((a) => {
+    const emoji = a.type === "late_standup" ? ":warning:" : ":x:";
+    const label = a.type === "late_standup" ? "Late" : "Failed";
+    const scheduleInfo = a.schedule ? ` (${a.schedule})` : "";
+    return `${emoji} *${label}* \u2014 *${a.agentDisplayName}* / ${a.taskName}${scheduleInfo}
+${a.detail}`;
+  });
+  await sendSlackWebhookMessage(`:rotating_light: *Cron Health Alert*
+
+${blocks.join("\n\n")}`);
+}
+async function sendTaskNotification(agentCodeName, channel, to, text) {
+  const tokens = agentChannelTokens.get(agentCodeName);
+  if (channel === "slack") {
+    const botToken = tokens?.slack;
+    const channelId = to.replace(/^channel:/, "");
+    if (botToken) {
+      const sent = await sendSlackChannelMessage(agentCodeName, channelId, text);
+      if (sent) return;
+    }
+    log(`No Slack bot token for '${agentCodeName}' \u2014 targeted notification dropped`);
+  } else if (channel === "telegram") {
+    const botToken = tokens?.telegram;
+    const chatId = to.replace(/^chat:/, "");
+    if (!botToken) {
+      log(`No Telegram bot token for '${agentCodeName}' \u2014 notification dropped`);
+      return;
+    }
+    const allowedChats = tokens?.telegramAllowedChats;
+    if (allowedChats && allowedChats.length > 0 && !allowedChats.includes(chatId)) {
+      log(`Telegram chat ${chatId} not in allowed_chat_ids for '${agentCodeName}'`);
+      return;
+    }
+    try {
+      const result = await telegramApiCall(botToken, "sendMessage", { chat_id: chatId, text });
+      if (!result.ok) {
+        log(`Telegram sendMessage failed for '${agentCodeName}': ${result.description}`);
+      } else {
+        log(`Telegram notification sent for '${agentCodeName}' to chat ${chatId}`);
+      }
+    } catch (err) {
+      log(`Telegram API error for '${agentCodeName}': ${err.message}`);
+    }
+  } else {
+    log(`Unknown notify_channel '${channel}' for '${agentCodeName}'`);
+  }
+}
+function generateArtifacts(agent, refreshData, adapter) {
+  if (!refreshData.charter || !refreshData.tools) {
+    throw new Error("No charter/tools available");
+  }
+  const charterContent = refreshData.charter.raw_content;
+  const toolsContent = refreshData.tools.raw_content;
+  const charterParsed = extractFrontmatter(charterContent);
+  if (!charterParsed.frontmatter) {
+    throw new Error(`Failed to parse CHARTER.md frontmatter: ${charterParsed.error ?? "unknown"}`);
+  }
+  const toolsParsed = extractFrontmatter(toolsContent);
+  if (!toolsParsed.frontmatter) {
+    throw new Error(`Failed to parse TOOLS.md frontmatter: ${toolsParsed.error ?? "unknown"}`);
+  }
+  const charterFrontmatter = charterParsed.frontmatter;
+  const toolsFrontmatter = toolsParsed.frontmatter;
+  const configuredChannels = Object.keys(refreshData.channel_configs ?? {});
+  const agentChannelPolicy = {
+    policy: "allowlist",
+    allowed: configuredChannels,
+    denied: [],
+    require_approval_to_change: true
+  };
+  let teamChannelPolicy;
+  const policyData = refreshData.team_channel_policy;
+  if (policyData) {
+    teamChannelPolicy = {
+      team_id: policyData.team_id,
+      allowed_channels: policyData.allowed_channels ?? [],
+      denied_channels: policyData.denied_channels ?? [],
+      require_elevated_for_pii: policyData.require_elevated_for_pii ?? false
+    };
+  }
+  const resolvedChannels = resolveChannels(agentChannelPolicy, teamChannelPolicy);
+  const effectiveChannels = agent.status === "paused" ? [] : resolvedChannels;
+  const provisionInput = {
+    agent: refreshData.agent,
+    charterFrontmatter,
+    charterContent,
+    toolsFrontmatter,
+    toolsContent,
+    resolvedChannels: effectiveChannels,
+    deploymentTarget: "local_docker",
+    gatewayPort: 9e3,
+    team: refreshData.team ?? void 0
+  };
+  const provisionOutput = provision(provisionInput, adapter.id);
+  return provisionOutput.artifacts;
+}
+async function cleanupAgentFiles(codeName, agentDir) {
+  if (existsSync2(agentDir)) {
+    try {
+      rmSync(agentDir, { recursive: true, force: true });
+      log(`Removed provision directory for '${codeName}'`);
+    } catch (err) {
+      log(`Failed to remove provision dir for '${codeName}': ${err.message}`);
+    }
+  }
+  try {
+    const adapter = resolveAgentFramework(codeName);
+    const registered = await getOrCacheRegisteredAgents(adapter, codeName);
+    if (registered.has(codeName)) {
+      await adapter.deregisterAgent(codeName);
+      registered.delete(codeName);
+      log(`Deregistered '${codeName}' from ${adapter.label}`);
+    }
+  } catch (err) {
+    log(`Failed to deregister '${codeName}': ${err.message}`);
+  }
+}
+function startGatewayPool() {
+  if (gatewayPool) return;
+  gatewayPool = new GatewayClientPool();
+  gatewayPool.on("connected", (codeName) => {
+    log(`Gateway WebSocket connected for '${codeName}'`);
+  });
+  gatewayPool.on("disconnected", (codeName) => {
+    log(`Gateway WebSocket disconnected for '${codeName}'`);
+  });
+  gatewayPool.on("error", (err, codeName) => {
+    log(`Gateway WebSocket error for '${codeName}': ${err.message}`);
+  });
+  gatewayPool.on("event", (evt) => {
+    send({ type: "gateway-event", event: evt.event, payload: evt.payload, agentCodeName: evt.agentCodeName });
+    getHostId().then((hostId) => {
+      if (!hostId) return;
+      api.post("/host/events", {
+        host_id: hostId,
+        agent_code_name: evt.agentCodeName,
+        event_type: evt.event,
+        payload: evt.payload,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }).catch((err) => {
+        log(`Failed to forward gateway event: ${err.message}`);
+      });
+    }).catch(() => {
+    });
+  });
+}
+function stopGatewayPool() {
+  if (gatewayPool) {
+    gatewayPool.disconnectAll();
+    gatewayPool = null;
+  }
+}
+function startPolling() {
+  if (!config || running) return;
+  running = true;
+  log(`Starting poll loop (interval=${config.intervalMs}ms, configDir=${config.configDir})`);
+  void migrateToProfiles().then(() => {
+    startGatewayPool();
+    return pollCycle();
+  }).then(() => {
+    scheduleNext();
+  });
+}
+function scheduleNext() {
+  if (!running || !config) return;
+  pollTimer = setTimeout(() => {
+    void pollCycle().then(scheduleNext);
+  }, config.intervalMs);
+}
+async function stopPolling() {
+  running = false;
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  stopRealtimeChat();
+  stopGatewayPool();
+  await stopAllGateways();
+}
+function startManager(opts) {
+  config = opts;
+  startPolling();
+}
+async function stopManager() {
+  await stopPolling();
+}
+for (const sig of ["SIGTERM", "SIGINT"]) {
+  process.on(sig, () => {
+    log(`Received ${sig}, shutting down`);
+    void stopPolling().then(() => {
+      process.exit(0);
+    });
+  });
+}
+process.on("disconnect", () => {
+  log("Parent disconnected, exiting");
+  void stopPolling().then(() => {
+    process.exit(0);
+  });
+});
+export {
+  startManager,
+  stopManager
+};
+//# sourceMappingURL=manager-worker.js.map