u-foo 1.0.6 → 1.2.0

package/src/daemon/index.js

@@ -1,96 +1,53 @@
 const fs = require("fs");
 const path = require("path");
-const net = require("net");
 const { spawnSync } = require("child_process");
 const { runUfooAgent } = require("../agent/ufooAgent");
-const { launchAgent, closeAgent, resumeAgents } = require("./ops");
+const { launchAgent, closeAgent, getRecoverableAgents, resumeAgents } = require("./ops");
 const { buildStatus } = require("./status");
 const EventBus = require("../bus");
+const { AgentProcessManager } = require("./agentProcessManager");
 const NicknameManager = require("../bus/nickname");
 const { generateInstanceId, subscriberToSafeName } = require("../bus/utils");
+const { createDaemonIpcServer } = require("./ipcServer");
+const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
 const { getUfooPaths } = require("../ufoo/paths");
 const { scheduleProviderSessionProbe, loadProviderSessionCache } = require("./providerSessions");
-const { loadConfig } = require("../config");
-
-/**
- * Agent 进程管理器 - daemon 作为父进程监控所有 internal agents
- */
-class AgentProcessManager {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.processes = new Map(); // subscriber_id -> child_process
-  }
-
-  /**
-   * 注册子进程并监听退出事件
-   */
-  register(subscriberId, childProcess) {
-    if (!subscriberId || !childProcess) return;
-
-    this.processes.set(subscriberId, childProcess);
-
-    childProcess.on("exit", (code, signal) => {
-      this.processes.delete(subscriberId);
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const { createDaemonCronController } = require("./cronOps");
+const { runAssistantTask } = require("../assistant/bridge");
+const { runPromptWithAssistant } = require("./promptLoop");
+const { handlePromptRequest } = require("./promptRequest");
+const { recordAgentReport } = require("./reporting");
 
-      // 自动清理 bus 状态
-      try {
-        const eventBus = new EventBus(this.projectRoot);
-        eventBus.loadBusData();
-        if (eventBus.busData.agents?.[subscriberId]) {
-          eventBus.busData.agents[subscriberId].status = "inactive";
-          eventBus.busData.agents[subscriberId].last_seen = new Date().toISOString();
-          eventBus.saveBusData();
-          console.log(`[daemon] Agent ${subscriberId} exited (code=${code}, signal=${signal}), marked inactive`);
-        }
-      } catch (err) {
-        console.error(`[daemon] Failed to cleanup ${subscriberId}:`, err.message);
-      }
-    });
-
-    childProcess.on("error", (err) => {
-      console.error(`[daemon] Agent ${subscriberId} error:`, err.message);
-      this.processes.delete(subscriberId);
-    });
-  }
-
-  /**
-   * 获取运行中的进程
-   */
-  get(subscriberId) {
-    return this.processes.get(subscriberId);
-  }
+let providerSessions = null;
+let probeHandles = new Map();
+let daemonCronController = null;
 
-  /**
-   * 获取所有进程数量
-   */
-  count() {
-    return this.processes.size;
-  }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-  /**
-   * 清理所有子进程
-   */
-  cleanup() {
-    for (const [subscriberId, child] of this.processes.entries()) {
-      try {
-        child.kill("SIGTERM");
-        console.log(`[daemon] Killed agent ${subscriberId}`);
-      } catch {
-        // ignore
-      }
-    }
-    this.processes.clear();
-  }
+function normalizeBusAgentType(agentType = "") {
+  const value = String(agentType || "").trim().toLowerCase();
+  if (!value) return "claude-code";
+  if (value === "codex") return "codex";
+  if (value === "claude" || value === "claude-code") return "claude-code";
+  if (value === "ufoo" || value === "ucode" || value === "ufoo-code") return "ufoo-code";
+  return value;
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function normalizeLaunchAgent(agent = "") {
+  const value = String(agent || "").trim().toLowerCase();
+  if (value === "codex") return "codex";
+  if (value === "claude" || value === "claude-code") return "claude";
+  if (value === "ufoo" || value === "ucode" || value === "ufoo-code") return "ufoo";
+  return "";
 }
 
 async function renameSpawnedAgent(projectRoot, agentType, nickname, startIso) {
   if (!nickname) return null;
   const busPath = getUfooPaths(projectRoot).agentsFile;
-  const targetType = agentType === "codex" ? "codex" : "claude-code";
+  const targetType = normalizeBusAgentType(agentType);
   const deadline = Date.now() + 10000;
   const eventBus = new EventBus(projectRoot);
   let lastError = null;
@@ -149,19 +106,84 @@ function readPid(projectRoot) {
   }
 }
 
+function checkPid(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return { alive: false, uncertain: false };
+  }
+  try {
+    process.kill(pid, 0);
+    return { alive: true, uncertain: false };
+  } catch (err) {
+    if (err && err.code === "EPERM") {
+      return { alive: true, uncertain: true };
+    }
+    return { alive: false, uncertain: false };
+  }
+}
+
+function readProcessArgs(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return "";
+  try {
+    const res = spawnSync("ps", ["-p", String(pid), "-o", "args="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (res && res.error) {
+      if (res.error.code === "EPERM") return "__EPERM__";
+      return "";
+    }
+    if (res && res.status === 0) {
+      return String(res.stdout || "").trim();
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function isLikelyDaemonProcess(pid) {
+  const args = readProcessArgs(pid);
+  if (!args || args === "__EPERM__") return null;
+  const text = args.toLowerCase();
+  const hasCliPattern = /\bufoo\s+daemon\s+(--start|start)\b/.test(text);
+  const hasNodePattern = /\bufoo\.js\s+daemon\s+(--start|start)\b/.test(text);
+  if (hasCliPattern || hasNodePattern) return true;
+  if (text.includes("/src/daemon/run.js")) return true;
+  return false;
+}
+
+function looksLikeRunningDaemon(projectRoot, pid) {
+  const state = checkPid(pid);
+  if (!state.alive) return false;
+  const sock = socketPath(projectRoot);
+  if (!fs.existsSync(sock)) return false;
+  try {
+    const stat = fs.statSync(sock);
+    if (!stat.isSocket()) return false;
+  } catch {
+    return false;
+  }
+  const procMatch = isLikelyDaemonProcess(pid);
+  if (procMatch === true) return true;
+  if (procMatch === false) return false;
+  if (!state.uncertain) return true;
+  const recordedPid = readPid(projectRoot);
+  return recordedPid === pid && fs.existsSync(sock);
+}
+
 function isRunning(projectRoot) {
   const pid = readPid(projectRoot);
   if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    // PID 存活即认为 daemon 正在运行
-    // 不调用 isDaemonProcess() — ps 命令可能有瞬态失败导致误判
-    // 不删除 PID/socket — 破坏性操作会导致竞争条件
+  if (looksLikeRunningDaemon(projectRoot, pid)) {
     return true;
+  }
+  try {
+    fs.unlinkSync(pidPath(projectRoot));
   } catch {
-    // 进程已死
-    return false;
+    // ignore
   }
+  removeSocket(projectRoot);
+  return false;
 }
 
 function removeSocket(projectRoot) {
@@ -240,12 +262,32 @@ function checkAndCleanupNickname(projectRoot, nickname) {
   }
 }
 
+function resolveSubscriberNickname(projectRoot, subscriberId) {
+  if (!subscriberId) return "";
+  try {
+    const busPath = getUfooPaths(projectRoot).agentsFile;
+    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+    return bus.agents?.[subscriberId]?.nickname || "";
+  } catch {
+    return "";
+  }
+}
+
 async function handleOps(projectRoot, ops = [], processManager = null) {
   const results = [];
   for (const op of ops) {
     if (op.action === "launch") {
       const count = op.count || 1;
-      const agent = op.agent === "codex" ? "codex" : "claude";
+      const agent = normalizeLaunchAgent(op.agent);
+      if (!agent) {
+        results.push({
+          action: "launch",
+          ok: false,
+          count,
+          error: `unsupported launch agent: ${op.agent || "unknown"}`,
+        });
+        continue;
+      }
       const nickname = op.nickname || "";
       const startTime = new Date(Date.now() - 1000);
       const startIso = startTime.toISOString();
@@ -278,6 +320,34 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
         }
         // eslint-disable-next-line no-await-in-loop
         const launchResult = await launchAgent(projectRoot, agent, count, nickname, processManager);
+        if (launchResult.mode === "internal" && launchResult.subscriberIds && launchResult.subscriberIds.length > 0) {
+          const probeAgentType = agent === "codex"
+            ? "codex"
+            : (agent === "claude" ? "claude-code" : "");
+          for (const subscriberId of launchResult.subscriberIds) {
+            if (!probeAgentType) continue;
+            const resolvedNickname = resolveSubscriberNickname(projectRoot, subscriberId) || nickname;
+            const probeHandle = scheduleProviderSessionProbe({
+              projectRoot,
+              subscriberId,
+              agentType: probeAgentType,
+              nickname: resolvedNickname,
+              onResolved: (id, resolved) => {
+                if (providerSessions) {
+                  providerSessions.set(id, {
+                    sessionId: resolved.sessionId,
+                    source: resolved.source || "",
+                    updated_at: new Date().toISOString(),
+                  });
+                }
+                probeHandles.delete(id);
+              },
+            });
+            if (probeHandle) {
+              probeHandles.set(subscriberId, probeHandle);
+            }
+          }
+        }
         results.push({
           action: "launch",
           mode: launchResult.mode,
@@ -349,6 +419,25 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
           error: err && err.message ? err.message : String(err || "rename failed"),
         });
       }
+    } else if (op.action === "cron") {
+      if (!daemonCronController) {
+        results.push({
+          action: "cron",
+          ok: false,
+          error: "cron controller unavailable",
+        });
+        continue;
+      }
+      try {
+        const result = daemonCronController.handleCronOp(op);
+        results.push(result);
+      } catch (err) {
+        results.push({
+          action: "cron",
+          ok: false,
+          error: err && err.message ? err.message : String(err || "cron failed"),
+        });
+      }
     }
   }
   return results;
@@ -405,7 +494,7 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
       try {
         fs.writeFileSync(debugFile, `Attempting join at ${new Date().toISOString()}\n`, { flag: "a" });
         // Determine agent type based on provider configuration
-        const agentType = provider === "codex-cli" ? "codex" : "claude-code";
+        const agentType = provider === "codex-cli" ? "codex" : (provider === "ucode" ? "ufoo-code" : "claude-code");
         // Use fixed ID "ufoo-agent" for daemon's bus identity with explicit nickname
         const sub = await eventBus.join("ufoo-agent", agentType, "ufoo-agent");
         if (!sub) {
@@ -480,7 +569,7 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
         state.pending.delete(evt.publisher);
         if (onStatus) {
           const displayName = getAgentNickname(evt.publisher);
-          onStatus({ phase: "done", text: `${displayName} done`, key: evt.publisher });
+          onStatus({ phase: BUS_STATUS_PHASES.DONE, text: `${displayName} done`, key: evt.publisher });
         }
       }
     }
@@ -493,7 +582,7 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
       state.pending.add(target);
       if (onStatus) {
         const displayName = getAgentNickname(target);
-        onStatus({ phase: "start", text: `${displayName} processing`, key: target });
+        onStatus({ phase: BUS_STATUS_PHASES.START, text: `${displayName} processing`, key: target });
       }
     },
     getSubscriber() {
@@ -522,34 +611,47 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   // 文件锁机制：防止多个 daemon 同时启动
   const lockFile = path.join(runDir, "daemon.lock");
   let lockFd;
+  let recoveredStaleLock = false;
   try {
+    // 尝试独占方式打开锁文件（如果已存在且被锁定则失败）
     lockFd = fs.openSync(lockFile, "wx");
     fs.writeSync(lockFd, `${process.pid}\n`);
   } catch (err) {
     if (err.code === "EEXIST") {
-      // 锁文件已存在，检查持有者是否还活着
-      let existingPid;
+      // 锁文件已存在，检查是否仍有效
+      let existingPid = null;
       try {
-        existingPid = parseInt(fs.readFileSync(lockFile, "utf8").trim(), 10);
+        const raw = fs.readFileSync(lockFile, "utf8").trim();
+        const parsed = parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+          existingPid = parsed;
+        }
       } catch {
-        existingPid = NaN;
+        // ignore malformed lock file and treat as stale
       }
-      if (existingPid && Number.isFinite(existingPid)) {
-        let alive = false;
-        try {
-          process.kill(existingPid, 0);
-          alive = true;
-        } catch {
-          // 进程已死
-        }
-        if (alive) {
-          throw new Error(`Daemon already running with PID ${existingPid}`);
-        }
+
+      let lockHeld = false;
+      if (existingPid) {
+        lockHeld = looksLikeRunningDaemon(projectRoot, existingPid);
+      }
+
+      if (lockHeld) {
+        throw new Error(`Daemon already running with PID ${existingPid}`);
+      }
+
+      // 进程已死或锁文件损坏，清理旧锁后重试
+      try {
+        fs.unlinkSync(lockFile);
+        recoveredStaleLock = true;
+      } catch (unlinkErr) {
+        throw new Error(`Failed to remove stale daemon lock: ${unlinkErr.message}`);
+      }
+      try {
+        lockFd = fs.openSync(lockFile, "wx");
+        fs.writeSync(lockFd, `${process.pid}\n`);
+      } catch (retryErr) {
+        throw new Error(`Failed to acquire daemon lock: ${retryErr.message}`);
       }
-      // 持有者已死，接管锁
-      try { fs.unlinkSync(lockFile); } catch { /* ignore */ }
-      lockFd = fs.openSync(lockFile, "wx");
-      fs.writeSync(lockFd, `${process.pid}\n`);
     } else {
       throw err;
     }
@@ -568,36 +670,23 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   log(`Process manager initialized`);
 
   // Provider session cache (in-memory)
-  const providerSessions = loadProviderSessionCache(projectRoot);
-
-  // Probe handles (用于agent_ready时提前触发probe)
-  const probeHandles = new Map(); // subscriberId -> { triggerNow }
-
-  const sockets = new Set();
-  const sendToSockets = (payload) => {
-    const line = `${JSON.stringify(payload)}\n`;
-    for (const sock of sockets) {
-      if (!sock || sock.destroyed) continue;
-      try {
-        sock.write(line);
-      } catch {
-        // ignore write errors
-      }
-    }
-  };
+  providerSessions = loadProviderSessionCache(projectRoot);
+  probeHandles = new Map();
+  daemonCronController = createDaemonCronController({
+    dispatch: async ({ taskId, target, message }) => {
+      await dispatchMessages(projectRoot, [{ target, message }]);
+      log(`cron:${taskId} -> ${target}`);
+    },
+    log,
+  });
 
-  const busBridge = startBusBridge(projectRoot, provider, (evt) => {
-    sendToSockets({ type: "bus", data: evt });
-  }, (status) => {
-    sendToSockets({ type: "status", data: status });
-  }, () => sockets.size > 0);
+  const buildRuntimeStatus = () =>
+    buildStatus(projectRoot, {
+      cronTasks: daemonCronController ? daemonCronController.listTasks() : [],
+    });
 
-  // 定期检测状态变化并推送（仅当有变化时）
-  let lastActiveJson = "";
-  const statusSyncInterval = setInterval(() => {
-    if (sockets.size === 0) return; // 没有客户端连接时跳过
+  const cleanupInactiveSubscribers = () => {
     try {
-      // 先清理不活跃的订阅者，确保状态准确
       const syncBus = new EventBus(projectRoot);
       syncBus.ensureBus();
       syncBus.loadBusData();
@@ -606,373 +695,450 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     } catch {
       // ignore cleanup errors
     }
-    try {
-      const status = buildStatus(projectRoot);
-      const currentActiveJson = JSON.stringify(status.active);
-      if (currentActiveJson !== lastActiveJson) {
-        lastActiveJson = currentActiveJson;
-        sendToSockets({ type: "status", data: status });
-        log(`status sync: active agents changed to ${status.active.length}`);
-      }
-    } catch {
-      // ignore status check errors
+  };
+
+  let handleIpcRequest = async () => {};
+  const ipcServer = createDaemonIpcServer({
+    projectRoot,
+    parseJsonLines,
+    handleRequest: async (req, socket) => handleIpcRequest(req, socket),
+    buildStatus: () => buildRuntimeStatus(),
+    cleanupInactive: cleanupInactiveSubscribers,
+    log,
+  });
+
+  const busBridge = startBusBridge(projectRoot, provider, (evt) => {
+    ipcServer.sendToSockets({ type: IPC_RESPONSE_TYPES.BUS, data: evt });
+  }, (status) => {
+    ipcServer.sendToSockets({ type: IPC_RESPONSE_TYPES.STATUS, data: status });
+  }, () => ipcServer.hasClients());
+
+  handleIpcRequest = async (req, socket) => {
+    if (!req || typeof req !== "object") return;
+    if (req.type === IPC_REQUEST_TYPES.STATUS) {
+      cleanupInactiveSubscribers();
+      const status = buildRuntimeStatus();
+      socket.write(`${JSON.stringify({ type: IPC_RESPONSE_TYPES.STATUS, data: status })}
+`);
+      return;
     }
-  }, 3000); // 每3秒检测一次
-
-  const server = net.createServer((socket) => {
-    sockets.add(socket);
-    socket.on("close", () => sockets.delete(socket));
-    let buffer = "";
-    socket.on("data", async (data) => {
-      buffer += data.toString("utf8");
-      const lines = buffer.split(/\r?\n/);
-      buffer = lines.pop() || "";
-      const complete = lines.filter((l) => l.trim());
-      for (const line of complete) {
-        const items = parseJsonLines(line);
-        for (const req of items) {
-          if (!req || typeof req !== "object") continue;
-          if (req.type === "status") {
-            // 先清理不活跃的订阅者，确保状态准确
-            try {
-              const eventBus = new EventBus(projectRoot);
-              eventBus.ensureBus();
-              eventBus.loadBusData();
-              eventBus.subscriberManager.cleanupInactive();
-              eventBus.saveBusData();
-            } catch {
-              // ignore cleanup errors, proceed with status
-            }
-            const status = buildStatus(projectRoot);
-            socket.write(`${JSON.stringify({ type: "status", data: status })}\n`);
-            continue;
-          }
-          if (req.type === "prompt") {
-            log(`prompt ${String(req.text || "").slice(0, 200)}`);
-            let result;
-            try {
-              result = await runUfooAgent({
-                projectRoot,
-                prompt: req.text || "",
-                provider,
-                model,
+    if (req.type === IPC_REQUEST_TYPES.PROMPT) {
+      await handlePromptRequest({
+        projectRoot,
+        req,
+        socket,
+        provider,
+        model,
+        processManager,
+        runPromptWithAssistant,
+        runUfooAgent,
+        runAssistantTask,
+        dispatchMessages,
+        handleOps,
+        markPending: (target) => busBridge.markPending(target),
+        reportTaskStatus: async (report) => {
+          await recordAgentReport({
+            projectRoot,
+            report,
+            onStatus: (status) => {
+              ipcServer.sendToSockets({
+                type: IPC_RESPONSE_TYPES.STATUS,
+                data: status,
               });
-            } catch (err) {
-              log(`error ${err.message || String(err)}`);
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || String(err),
-                })}\n`,
-              );
-              continue;
-            }
-            if (!result.ok) {
-              log(`agent-fail ${result.error || "agent failed"}`);
-              socket.write(
-                `${JSON.stringify({ type: "error", error: result.error || "agent failed" })}\n`,
-              );
-              continue;
-            }
-            for (const item of result.payload.dispatch || []) {
-              if (item && item.target && item.target !== "broadcast") {
-                busBridge.markPending(item.target);
-              }
-            }
-            await dispatchMessages(projectRoot, result.payload.dispatch || []);
-            const opsResults = await handleOps(projectRoot, result.payload.ops || [], processManager);
-            log(`ok reply=${Boolean(result.payload.reply)} dispatch=${(result.payload.dispatch || []).length} ops=${(result.payload.ops || []).length}`);
-            socket.write(
-              `${JSON.stringify({
-                type: "response",
-                data: result.payload,
-                opsResults,
-              })}\n`,
-            );
-            continue;
-          }
-          if (req.type === "bus_send") {
-            // Direct bus send request from chat UI
-            const { target, message } = req;
-            if (!target || !message) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: "bus_send requires target and message",
-                })}\n`,
-              );
-              continue;
-            }
-            try {
-              const publisher = busBridge.getSubscriber() || "ufoo-agent";
-              const eventBus = new EventBus(projectRoot);
-              await eventBus.send(target, message, publisher);
-              log(`bus_send target=${target} publisher=${publisher}`);
-              socket.write(
-                `${JSON.stringify({
-                  type: "bus_send_ok",
-                })}\n`,
-              );
-            } catch (err) {
-              log(`bus_send failed: ${err.message}`);
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || "bus_send failed",
-                })}\n`,
-              );
-            }
-            continue;
-          }
-          if (req.type === "launch_agent") {
-            const { agent, count, nickname } = req;
-            if (!agent || (agent !== "codex" && agent !== "claude")) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: "launch_agent requires agent=codex|claude",
-                })}\n`,
-              );
-              continue;
-            }
-            const parsedCount = parseInt(count, 10);
-            const finalCount = Number.isFinite(parsedCount) && parsedCount > 0 ? parsedCount : 1;
-            const op = {
-              action: "launch",
-              agent,
-              count: finalCount,
-              nickname: nickname || "",
-            };
-            try {
-              const opsResults = await handleOps(projectRoot, [op], processManager);
-              const launchResult = opsResults.find((r) => r.action === "launch");
-              const ok = launchResult ? launchResult.ok !== false : true;
-              const reply = ok
-                ? `Launched ${op.count} ${agent} agent(s)`
-                : `Launch failed: ${launchResult?.error || "unknown error"}`;
-              socket.write(
-                `${JSON.stringify({
-                  type: "response",
-                  data: {
-                    reply,
-                    dispatch: [],
-                    ops: [op],
-                  },
-                  opsResults,
-                })}\n`,
-              );
-            } catch (err) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || "launch_agent failed",
-                })}\n`,
-              );
-            }
-            continue;
-          }
-          if (req.type === "close_agent") {
-            const { agentId } = req;
-            if (!agentId) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: "close_agent requires agentId",
-                })}\n`,
-              );
-              continue;
-            }
-            try {
-              const ok = await closeAgent(projectRoot, agentId);
-              // Always cleanup inactive and broadcast — removes dead agents from list
-              try {
-                const cleanupBus = new EventBus(projectRoot);
-                cleanupBus.ensureBus();
-                cleanupBus.loadBusData();
-                cleanupBus.subscriberManager.cleanupInactive();
-                cleanupBus.saveBusData();
-              } catch { /* ignore */ }
-              log(`close_agent id=${agentId} ok=${ok}`);
-              const status = buildStatus(projectRoot);
-              socket.write(
-                `${JSON.stringify({ type: "close_agent_ok", ok: true, agentId })}\n`,
-              );
-              sendToSockets({ type: "status", data: status });
-            } catch (err) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || "close_agent failed",
-                })}\n`,
-              );
-            }
-            continue;
+            },
+            log,
+          });
+        },
+        log,
+      });
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.AGENT_REPORT) {
+      try {
+        const report = req.report && typeof req.report === "object" ? req.report : {};
+        const { entry } = await recordAgentReport({
+          projectRoot,
+          report: {
+            ...report,
+            source: report.source || "cli",
+          },
+          onStatus: (status) => {
+            ipcServer.sendToSockets({
+              type: IPC_RESPONSE_TYPES.STATUS,
+              data: status,
+            });
+          },
+          log,
+        });
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply: `Report received (${entry.phase})`,
+              report: entry,
+            },
+          })}
+`,
+        );
+        ipcServer.sendToSockets({
+          type: IPC_RESPONSE_TYPES.STATUS,
+          data: buildRuntimeStatus(),
+        });
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "agent_report failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.BUS_SEND) {
+      // Direct bus send request from chat UI
+      const { target, message } = req;
+      if (!target || !message) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "bus_send requires target and message",
+          })}
+`,
+        );
+        return;
+      }
+      try {
+        const publisher = busBridge.getSubscriber() || "ufoo-agent";
+        const eventBus = new EventBus(projectRoot);
+        await eventBus.send(target, message, publisher);
+        busBridge.markPending(target);
+        log(`bus_send target=${target} publisher=${publisher}`);
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.BUS_SEND_OK,
+          })}
+`,
+        );
+      } catch (err) {
+        log(`bus_send failed: ${err.message}`);
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "bus_send failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.CLOSE_AGENT) {
+      const { agent_id } = req;
+      if (!agent_id) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "close_agent requires agent_id",
+          })}
+`,
+        );
+        return;
+      }
+      try {
+        const op = { action: "close", agent_id };
+        const opsResults = await handleOps(projectRoot, [op], processManager);
+        const closeResult = opsResults.find((r) => r.action === "close");
+        const ok = closeResult ? closeResult.ok !== false : true;
+        const reply = ok
+          ? `Closed ${agent_id}`
+          : `Close failed: ${closeResult?.error || "unknown error"}`;
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: { reply, dispatch: [], ops: [op] },
+            opsResults,
+          })}
+`,
+        );
+        cleanupInactiveSubscribers();
+        ipcServer.sendToSockets({
+          type: IPC_RESPONSE_TYPES.STATUS,
+          data: buildRuntimeStatus(),
+        });
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "close_agent failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.LAUNCH_AGENT) {
+      const { agent, count, nickname } = req;
+      const normalizedAgent = normalizeLaunchAgent(agent);
+      if (!normalizedAgent) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "launch_agent requires agent=codex|claude|ucode",
+          })}
+`,
+        );
+        return;
+      }
+      const parsedCount = parseInt(count, 10);
+      const finalCount = Number.isFinite(parsedCount) && parsedCount > 0 ? parsedCount : 1;
+      const op = {
+        action: "launch",
+        agent: normalizedAgent,
+        count: finalCount,
+        nickname: nickname || "",
+      };
+      try {
+        const opsResults = await handleOps(projectRoot, [op], processManager);
+        const launchResult = opsResults.find((r) => r.action === "launch");
+        const ok = launchResult ? launchResult.ok !== false : true;
+        const reply = ok
+          ? `Launched ${op.count} ${agent} agent(s)`
+          : `Launch failed: ${launchResult?.error || "unknown error"}`;
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              dispatch: [],
+              ops: [op],
+            },
+            opsResults,
+          })}
+`,
+        );
+        cleanupInactiveSubscribers();
+        ipcServer.sendToSockets({
+          type: IPC_RESPONSE_TYPES.STATUS,
+          data: buildRuntimeStatus(),
+        });
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "launch_agent failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.RESUME_AGENTS) {
+      const target = req.target || "";
+      try {
+        const result = await resumeAgents(projectRoot, target, processManager);
+        const resumedCount = result.resumed.length;
+        const skippedCount = result.skipped.length;
+        const reply = resumedCount > 0
+          ? `Resumed ${resumedCount} agent(s)` + (skippedCount ? `, skipped ${skippedCount}` : "")
+          : (skippedCount ? `No agents resumed (skipped ${skippedCount})` : "No agents resumed");
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              resume: result,
+            },
+          })}
+`,
+        );
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "resume_agents failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.LIST_RECOVERABLE_AGENTS) {
+      const target = req.target || "";
+      try {
+        const result = getRecoverableAgents(projectRoot, target);
+        const count = result.recoverable.length;
+        const reply = count > 0 ? `Found ${count} recoverable agent(s)` : "No recoverable agents";
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: {
+              reply,
+              recoverable: result,
+            },
+          })}
+`,
+        );
+      } catch (err) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "list_recoverable_agents failed",
+          })}
+`,
+        );
+      }
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.REGISTER_AGENT) {
+      // Manual agent launch requests daemon to register it
+      const { agentType, nickname, parentPid, launchMode, tmuxPane, tty, skipProbe } = req;
+      if (!agentType) {
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: "register_agent requires agentType",
+          })}
+`,
+        );
+        return;
+      }
+      try {
+        const crypto = require("crypto");
+        const requestedReuse = req.reuseSession && typeof req.reuseSession === "object"
+          ? req.reuseSession
+          : null;
+        const reuseSessionId = typeof requestedReuse?.sessionId === "string"
+          ? requestedReuse.sessionId.trim()
+          : "";
+        const reuseSubscriberId = typeof requestedReuse?.subscriberId === "string"
+          ? requestedReuse.subscriberId.trim()
+          : "";
+        const reuseProviderSessionId = typeof requestedReuse?.providerSessionId === "string"
+          ? requestedReuse.providerSessionId.trim()
+          : "";
+
+        let sessionId = crypto.randomBytes(4).toString("hex");
+        let subscriberId = `${agentType}:${sessionId}`;
+        if (reuseSessionId && reuseSubscriberId === `${agentType}:${reuseSessionId}`) {
+          sessionId = reuseSessionId;
+          subscriberId = reuseSubscriberId;
+        } else if (reuseSessionId || reuseSubscriberId) {
+          log(`register_agent ignored invalid reuseSession for ${agentType}`);
+        }
+
+        // Daemon registers the agent in bus
+        const eventBus = new EventBus(projectRoot);
+        await eventBus.init();
+        eventBus.loadBusData();
+        const parsedParentPid = Number.parseInt(parentPid, 10);
+        if (!Number.isFinite(parsedParentPid) || parsedParentPid <= 0) {
+          throw new Error("register_agent requires valid parentPid");
+        }
+        const joinOptions = {
+          parentPid: Number.isFinite(parsedParentPid) ? parsedParentPid : undefined,
+          launchMode: launchMode || "",
+          tmuxPane: tmuxPane || "",
+          tty: tty || "",
+          reuseSessionId,
+          reuseProviderSessionId,
+        };
+        if (skipProbe) joinOptions.skipProbe = true;
+
+        let finalNickname = nickname || "";
+        if (finalNickname) {
+          const nickCheck = checkAndCleanupNickname(projectRoot, finalNickname);
+          if (nickCheck.existing) {
+            finalNickname = "";
           }
-          if (req.type === "resume_agents") {
-            const target = req.target || "";
-            try {
-              const result = await resumeAgents(projectRoot, target, processManager);
-              const resumedCount = result.resumed.length;
-              const skippedCount = result.skipped.length;
-              const reply = resumedCount > 0
-                ? `Resumed ${resumedCount} agent(s)` + (skippedCount ? `, skipped ${skippedCount}` : "")
-                : (skippedCount ? `No agents resumed (skipped ${skippedCount})` : "No agents resumed");
-              socket.write(
-                `${JSON.stringify({
-                  type: "response",
-                  data: {
-                    reply,
-                    resume: result,
-                  },
-                })}\n`,
-              );
-            } catch (err) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || "resume_agents failed",
-                })}\n`,
-              );
-            }
-            continue;
+        }
+        await eventBus.join(
+          sessionId,
+          normalizeBusAgentType(agentType),
+          finalNickname,
+          joinOptions,
+        );
+        if (finalNickname) {
+          eventBus.rename(subscriberId, finalNickname, "ufoo-agent");
+        }
+        eventBus.saveBusData();
+        const resolvedNickname = resolveSubscriberNickname(projectRoot, subscriberId) || finalNickname || "";
+
+        if (!skipProbe && reuseProviderSessionId) {
+          if (providerSessions) {
+            providerSessions.set(subscriberId, {
+              sessionId: reuseProviderSessionId,
+              source: "reuse",
+              updated_at: new Date().toISOString(),
+            });
           }
-          if (req.type === "register_agent") {
-            // Manual agent launch requests daemon to register it
-            const { agentType, nickname, parentPid, launchMode, tmuxPane, tty, skipProbe, reuseSession } = req;
-            if (!agentType) {
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: "register_agent requires agentType",
-                })}\n`,
-              );
-              continue;
-            }
-            try {
-              const crypto = require("crypto");
-
-              // 检查是否复用旧 session
-              let sessionId;
-              let subscriberId;
-              let isReusing = false;
-
-              if (reuseSession && reuseSession.sessionId && reuseSession.subscriberId) {
-                // 验证旧 session 是否可以复用
-                sessionId = reuseSession.sessionId;
-                subscriberId = reuseSession.subscriberId;
-                isReusing = true;
-                log(`register_agent reusing session: ${subscriberId}`);
-              } else {
-                // 生成新的 session
-                sessionId = crypto.randomBytes(4).toString("hex");
-                subscriberId = `${agentType}:${sessionId}`;
-              }
+        }
 
-              // Daemon registers the agent in bus
-              const eventBus = new EventBus(projectRoot);
-              await eventBus.init();
-              eventBus.loadBusData();
-              const parsedParentPid = Number.parseInt(parentPid, 10);
-              if (!Number.isFinite(parsedParentPid) || parsedParentPid <= 0) {
-                throw new Error("register_agent requires valid parentPid");
-              }
-              const joinOptions = {
-                parentPid: Number.isFinite(parsedParentPid) ? parsedParentPid : undefined,
-                launchMode: launchMode || "",
-                tmuxPane: tmuxPane || "",
-                // 如果复用旧 session，保留 provider session ID
-                providerSessionId: isReusing ? reuseSession.providerSessionId : undefined,
-              };
-              if (Object.prototype.hasOwnProperty.call(req, "tty")) {
-                const ttyValue = typeof tty === "string" ? tty.trim() : "";
-                joinOptions.tty = ttyValue;
-                if (!ttyValue) {
-                  log(`register_agent warning: missing tty for ${subscriberId}`);
-                }
-              }
-              await eventBus.subscriberManager.join(sessionId, agentType, nickname || "", joinOptions);
-              eventBus.saveBusData();
-
-              const finalNickname = eventBus.busData?.agents?.[subscriberId]?.nickname || "";
-              const reusedLabel = isReusing ? " (reused)" : "";
-              log(`register_agent type=${agentType} nickname=${finalNickname || "(none)"} id=${subscriberId}${reusedLabel}`);
-
-              // 如果复用 session 且已有 provider session ID，跳过 probe
-              const hasProviderSession = isReusing && reuseSession.providerSessionId;
-              if (!skipProbe && !hasProviderSession && finalNickname) {
-                const probeHandle = scheduleProviderSessionProbe({
-                  projectRoot,
-                  subscriberId,
-                  agentType,
-                  nickname: finalNickname,
-                  onResolved: (id, resolved) => {
-                    providerSessions.set(id, {
-                      sessionId: resolved.sessionId,
-                      source: resolved.source || "",
-                      updated_at: new Date().toISOString(),
-                    });
-                    // 清理handle
-                    probeHandles.delete(id);
-                  },
+        if (!skipProbe) {
+          const probeHandle = scheduleProviderSessionProbe({
+            projectRoot,
+            subscriberId,
+            agentType,
+            nickname: resolvedNickname,
+            onResolved: (id, resolved) => {
+              if (providerSessions) {
+                providerSessions.set(id, {
+                  sessionId: resolved.sessionId,
+                  source: resolved.source || "",
+                  updated_at: new Date().toISOString(),
                 });
-                // 保存handle，用于agent_ready时提前触发
-                if (probeHandle) {
-                  probeHandles.set(subscriberId, probeHandle);
-                }
               }
-              socket.write(
-                `${JSON.stringify({
-                  type: "register_ok",
-                  subscriberId,
-                  nickname: finalNickname || "",
-                })}\n`,
-              );
-              // 广播状态更新给所有连接的客户端
-              const status = buildStatus(projectRoot);
-              sendToSockets({ type: "status", data: status });
-            } catch (err) {
-              log(`register_agent failed: ${err.message}`);
-              socket.write(
-                `${JSON.stringify({
-                  type: "error",
-                  error: err.message || "register_agent failed",
-                })}\n`,
-              );
-            }
-            continue;
-          }
-          if (req.type === "agent_ready") {
-            // Agent has completed initialization and is ready to receive commands
-            const { subscriberId } = req;
-            if (!subscriberId) {
-              continue; // Silently ignore invalid requests
-            }
-
-            log(`agent_ready id=${subscriberId} - triggering probe immediately`);
-
-            // 提前触发probe（不再等待8秒延迟）
-            const probeHandle = probeHandles.get(subscriberId);
-            if (probeHandle && typeof probeHandle.triggerNow === "function") {
-              // 异步触发，不阻塞消息处理
-              probeHandle.triggerNow().catch((err) => {
-                log(`agent_ready probe trigger failed for ${subscriberId}: ${err.message}`);
-              });
-            } else {
-              log(`agent_ready no probe handle found for ${subscriberId}`);
-            }
-
-            continue;
+              probeHandles.delete(id);
+            },
+          });
+          if (probeHandle) {
+            probeHandles.set(subscriberId, probeHandle);
           }
         }
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.REGISTER_OK,
+            subscriberId,
+            nickname: resolvedNickname,
+          })}
+`,
+        );
+      } catch (err) {
+        log(`register_agent failed: ${err.message}`);
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error: err.message || "register_agent failed",
+          })}
+`,
+        );
       }
-    });
-  });
+      return;
+    }
+    if (req.type === IPC_REQUEST_TYPES.AGENT_READY) {
+      const { subscriberId } = req;
+      if (!subscriberId) {
+        return;
+      }
+      log(`agent_ready id=${subscriberId} - triggering probe immediately`);
+      const probeHandle = probeHandles.get(subscriberId);
+      if (probeHandle && typeof probeHandle.triggerNow === "function") {
+        probeHandle.triggerNow().catch((err) => {
+          log(`agent_ready probe trigger failed for ${subscriberId}: ${err.message}`);
+        });
+      } else {
+        log(`agent_ready no probe handle found for ${subscriberId}`);
+      }
+      return;
+    }
+  };
+
+  ipcServer.listen(socketPath(projectRoot));
 
-  server.listen(socketPath(projectRoot));
   log(`Started pid=${process.pid}`);
 
   // 清理旧 daemon 留下的孤儿 internal agent 进程
   const EventBus = require("../bus");
+  const { spawnSync } = require("child_process");
   const eventBus = new EventBus(projectRoot);
   try {
     eventBus.ensureBus();
@@ -1037,17 +1203,19 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
 
     // 标记对应的 agents 为 inactive
+    const adapterRouter = createTerminalAdapterRouter();
     for (const [subscriberId, meta] of Object.entries(agents)) {
-      if (meta.launch_mode && meta.launch_mode.startsWith("internal")) {
+      const launchMode = meta.launch_mode || "";
+      const adapter = adapterRouter.getAdapter({ launchMode, agentId: subscriberId });
+      if (launchMode && adapter.capabilities.supportsInternalQueueLoop) {
         if (meta.pid) {
           try {
             process.kill(meta.pid, 0);
             // 父 daemon 还活着，跳过
           } catch {
             // 父 daemon 已死，标记为 inactive
-            // 设置 last_seen 为很久以前，强制立即超时
+            // 注意：不更新 last_seen，保持原有时间戳，这样会自动超时
             meta.status = "inactive";
-            meta.last_seen = "2020-01-01T00:00:00.000Z";
             log(`Marked orphan internal agent ${subscriberId} as inactive (parent daemon ${meta.pid} is dead)`);
           }
         }
@@ -1058,10 +1226,10 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     log(`Failed to cleanup orphan agents: ${err.message}`);
   }
 
-  const config = loadConfig(projectRoot);
-  const autoResumeEnabled = config.autoResume !== false;
-  const shouldResume = resumeMode === "force" || (resumeMode === "auto" && autoResumeEnabled);
+  const shouldResume = resumeMode === "force" || (resumeMode === "auto" && recoveredStaleLock);
   if (shouldResume) {
+    const reason = resumeMode === "force" ? "forced by caller" : "stale daemon state detected";
+    log(`Auto-recover enabled: ${reason}`);
     setTimeout(() => {
       resumeAgents(projectRoot, "", processManager).catch((err) => {
         log(`auto resume failed: ${err.message || String(err)}`);
@@ -1072,10 +1240,15 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
   const cleanup = () => {
     log(`Shutting down daemon (managed agents: ${processManager.count()})`);
 
+    if (daemonCronController) {
+      daemonCronController.stopAll();
+      daemonCronController = null;
+    }
+
     // 清理所有子进程
     processManager.cleanup();
 
-    clearInterval(statusSyncInterval);
+    ipcServer.stop();
     busBridge.stop();
     removeSocket(projectRoot);