u-foo 1.0.6 → 1.1.9

package/src/daemon/ops.js

@@ -1,11 +1,41 @@
-const { spawn, spawnSync } = require("child_process");
+const { spawn } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const { loadConfig } = require("../config");
 const { getUfooPaths } = require("../ufoo/paths");
 const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
-const { isAgentPidAlive } = require("../bus/utils");
+const { isAgentPidAlive, getTtyProcessInfo } = require("../bus/utils");
 const { isITerm2 } = require("../terminal/detect");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+
+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 "";
+}
+
+function toBusAgentType(agent = "") {
+  if (agent === "codex") return "codex";
+  if (agent === "claude") return "claude-code";
+  if (agent === "ufoo") return "ufoo-code";
+  return "";
+}
+
+function toTerminalBinary(agent = "") {
+  if (agent === "codex") return "./bin/ucodex.js";
+  if (agent === "claude") return "./bin/uclaude.js";
+  if (agent === "ufoo") return "./bin/ucode.js";
+  return "";
+}
+
+function toTmuxBinary(agent = "") {
+  if (agent === "codex") return "ucodex";
+  if (agent === "claude") return "uclaude";
+  if (agent === "ufoo") return "ucode";
+  return "";
+}
 
 function resolveAgentId(projectRoot, agentId) {
   if (!agentId) return agentId;
@@ -16,7 +46,8 @@ function resolveAgentId(projectRoot, agentId) {
     const entries = Object.entries(bus.agents || {});
     const match = entries.find(([, meta]) => meta?.nickname === agentId);
     if (match) return match[0];
-    const targetType = agentId === "claude" ? "claude-code" : agentId;
+    const normalized = normalizeLaunchAgent(agentId);
+    const targetType = toBusAgentType(normalized) || agentId;
     const candidates = entries
       .filter(([, meta]) => meta?.agent_type === targetType && meta?.status === "active")
       .map(([id]) => id);
@@ -27,6 +58,51 @@ function resolveAgentId(projectRoot, agentId) {
   return agentId;
 }
 
+function markAgentInactive(projectRoot, agentId) {
+  if (!agentId) return false;
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const meta = data.agents?.[agentId];
+  if (!meta) return false;
+  data.agents[agentId] = {
+    ...meta,
+    status: "inactive",
+    last_seen: new Date().toISOString(),
+  };
+  saveAgentsData(filePath, data);
+  return true;
+}
+
+
+function listSubscribers(projectRoot, agentType) {
+  const busPath = getUfooPaths(projectRoot).agentsFile;
+  try {
+    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+    return Object.entries(bus.agents || {})
+      .filter(([, meta]) => meta && meta.agent_type === agentType && meta.status === "active")
+      .map(([id]) => id);
+  } catch {
+    return [];
+  }
+}
+
+async function waitForNewSubscriber(projectRoot, agentType, existing, timeoutMs = 15000) {
+  const start = Date.now();
+  const seen = new Set(existing || []);
+  while (Date.now() - start < timeoutMs) {
+    const current = listSubscribers(projectRoot, agentType);
+    const diff = current.find((id) => !seen.has(id));
+    if (diff) return diff;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return null;
+}
+
+function escapeCommand(cmd) {
+  return cmd.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
 function shellEscape(value) {
   const str = String(value);
   return `'${str.replace(/'/g, `'\\''`)}'`;
@@ -36,75 +112,181 @@ function escapeAppleScriptString(str) {
   return String(str).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 
-/**
- * 在 Terminal.app 中打开新窗口运行 agent
- * 使用简单的 AppleScript，只负责打开窗口执行命令
- * agent 进程的监控由 uclaude/ucodex 内部的 PTY wrapper 处理
- */
-async function spawnTerminalAgent(projectRoot, agent, nickname = "") {
+function runAppleScript(lines) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("osascript", lines.flatMap((l) => ["-e", l]));
+    let stderr = "";
+    let stdout = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString("utf8");
+    });
+    proc.on("close", (code) => {
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr || "osascript failed"));
+    });
+  });
+}
+
+async function openTerminalWindow(runCmd) {
   if (process.platform !== "darwin") {
     throw new Error("Terminal mode is only supported on macOS");
   }
 
-  const binary = agent === "codex" ? "ucodex" : "uclaude";
-  const nickEnv = nickname ? `UFOO_NICKNAME=${shellEscape(nickname)} ` : "";
-  const modeEnv = "UFOO_LAUNCH_MODE=terminal ";
-  const runCmd = `cd ${shellEscape(projectRoot)} && ${modeEnv}${nickEnv}${binary}`;
+  const escaped = escapeAppleScriptString(runCmd);
+
+  if (isITerm2()) {
+    try {
+      const script = [
+        'tell application "iTerm2"',
+        "  tell current window",
+        `    create tab with default profile command "${escaped}"`,
+        "  end tell",
+        "  activate",
+        "end tell",
+      ];
+      await runAppleScript(script);
+      return;
+    } catch {
+      // fall back to Terminal.app
+    }
+  }
 
   const script = [
     'tell application "Terminal"',
-    `do script "${escapeAppleScriptString(runCmd)}"`,
+    `do script "${escaped}"`,
     "activate",
     "end tell",
   ];
+  await runAppleScript(script);
+}
 
-  return new Promise((resolve, reject) => {
-    const proc = spawn("osascript", script.flatMap((l) => ["-e", l]));
-    let stderr = "";
-    proc.stderr.on("data", (d) => {
-      stderr += d.toString("utf8");
-    });
-    proc.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(stderr || "Failed to open Terminal.app"));
-    });
-  });
+async function closeTerminalWindowByTty(ttyPath, preferApp = "") {
+  if (process.platform !== "darwin") return false;
+  if (!ttyPath) return false;
+
+  const escaped = escapeAppleScriptString(ttyPath);
+
+  const tryITerm = async () => {
+    const script = [
+      'tell application "iTerm2"',
+      "  repeat with w in windows",
+      "    repeat with t in tabs of w",
+      "      repeat with s in sessions of t",
+      `        if tty of s is \"${escaped}\" then`,
+      "          close t",
+      '          return "ok"',
+      "        end if",
+      "      end repeat",
+      "    end repeat",
+      "  end repeat",
+      "end tell",
+      'return "not found"',
+    ];
+    const res = await runAppleScript(script);
+    return res === "ok";
+  };
+
+  const tryTerminal = async () => {
+    const script = [
+      'tell application "Terminal"',
+      "  repeat with w in windows",
+      "    repeat with t in tabs of w",
+      `      if tty of t is \"${escaped}\" then`,
+      "        close t",
+      "        if (count of tabs of w) is 0 then close w",
+      '        return "ok"',
+      "      end if",
+      "    end repeat",
+      "  end repeat",
+      "end tell",
+      'return "not found"',
+    ];
+    const res = await runAppleScript(script);
+    return res === "ok";
+  };
+
+  const prefer = (preferApp || "").toLowerCase();
+  const order = prefer === "terminal"
+    ? [tryTerminal, tryITerm]
+    : prefer === "iterm2"
+      ? [tryITerm, tryTerminal]
+      : [tryITerm, tryTerminal];
+
+  for (const attempt of order) {
+    try {
+      if (await attempt()) return true;
+    } catch {
+      // ignore and try next
+    }
+  }
+  return false;
+}
+
+function buildTitleCmd(title) {
+  if (!title) return "";
+  return `printf '\\033]0;%s\\007' ${shellEscape(title)}`;
+}
+
+function buildResumeCommand(projectRoot, agent, sessionId) {
+  const binary = toTerminalBinary(agent);
+  if (!binary) {
+    throw new Error(`unsupported agent for resume: ${agent}`);
+  }
+  const args = buildResumeArgs(agent, sessionId);
+  const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
+  const skipProbeEnv = "UFOO_SKIP_SESSION_PROBE=1 ";
+  return `cd ${shellEscape(projectRoot)} && ${skipProbeEnv}${binary}${argText}`;
+}
+
+async function tryReuseTerminal(projectRoot, subscriberId, meta, agent, sessionId) {
+  if (!meta || !meta.tty) return false;
+  const info = getTtyProcessInfo(meta.tty);
+  if (!info.alive || info.hasAgent || !info.idle) return false;
+  const titleCmd = buildTitleCmd(meta.nickname || "");
+  const baseCmd = buildResumeCommand(projectRoot, agent, sessionId);
+  const command = titleCmd ? `${titleCmd} && ${baseCmd}` : baseCmd;
+  try {
+    const EventBus = require("../bus");
+    const bus = new EventBus(projectRoot);
+    bus.ensureBus();
+    await bus.inject(subscriberId, command);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 /**
- * 在 iTerm2 中打开新 tab 运行 agent
- * 使用 AppleScript 控制 iTerm2，比 Terminal.app 更丰富的功能
+ * Spawn managed terminal agent - open a real Terminal session to run the agent
  */
-async function spawnITerm2Agent(projectRoot, agent, nickname = "") {
-  if (process.platform !== "darwin") {
-    throw new Error("iTerm2 mode is only supported on macOS");
+async function spawnManagedTerminalAgent(projectRoot, agent, nickname = "", processManager = null, extraArgs = [], extraEnv = "") {
+  const normalizedAgent = normalizeLaunchAgent(agent);
+  const binary = toTerminalBinary(normalizedAgent);
+  const agentType = toBusAgentType(normalizedAgent);
+  if (!binary || !agentType) {
+    throw new Error(`unsupported agent type: ${agent}`);
   }
+  const existing = listSubscribers(projectRoot, agentType);
+  const runDir = getUfooPaths(projectRoot).runDir;
+  fs.mkdirSync(runDir, { recursive: true });
 
-  const binary = agent === "codex" ? "ucodex" : "uclaude";
+  const args = Array.isArray(extraArgs) ? extraArgs : [];
+  const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
   const nickEnv = nickname ? `UFOO_NICKNAME=${shellEscape(nickname)} ` : "";
   const modeEnv = "UFOO_LAUNCH_MODE=terminal ";
-  const runCmd = `cd ${shellEscape(projectRoot)} && ${modeEnv}${nickEnv}${binary}`;
+  const envPrefix = extraEnv ? `${String(extraEnv).trim()} ` : "";
+  const titleCmd = buildTitleCmd(nickname);
+  const prefix = titleCmd ? `${titleCmd} && ` : "";
 
-  const script = [
-    'tell application "iTerm2"',
-    "  tell current window",
-    `    create tab with default profile command "${escapeAppleScriptString(runCmd)}"`,
-    "  end tell",
-    "  activate",
-    "end tell",
-  ];
+  const runCmd = `cd ${shellEscape(projectRoot)} && ${prefix}${modeEnv}${nickEnv}${envPrefix}${binary}${argText}`;
 
-  return new Promise((resolve, reject) => {
-    const proc = spawn("osascript", script.flatMap((l) => ["-e", l]));
-    let stderr = "";
-    proc.stderr.on("data", (d) => {
-      stderr += d.toString("utf8");
-    });
-    proc.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(stderr || "Failed to open iTerm2 tab"));
-    });
-  });
+  await openTerminalWindow(runCmd);
+
+  const subscriberId = await waitForNewSubscriber(projectRoot, agentType, existing, 15000);
+  return { child: null, subscriberId: subscriberId || null };
 }
 
 async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "", processManager = null) {
@@ -129,7 +311,11 @@ async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "",
 
     // 预生成 session ID
     const sessionId = crypto.randomBytes(4).toString("hex");
-    const agentType = agent === "codex" ? "codex" : "claude-code";
+    const normalizedAgent = normalizeLaunchAgent(agent);
+    const agentType = toBusAgentType(normalizedAgent);
+    if (!agentType) {
+      throw new Error(`unsupported agent type: ${agent}`);
+    }
     const subscriberId = `${agentType}:${sessionId}`;
     subscriberIds.push(subscriberId);
 
@@ -137,7 +323,9 @@ async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "",
     bus.loadBusData();
     process.env.UFOO_PARENT_PID = String(originalPid);
 
-    const finalNickname = count > 1 ? `${nickname || agent}-${i + 1}` : (nickname || "");
+    // For ucode/ufoo agents, default nickname to "ucode" if not specified
+    const defaultNickname = agentType === "ufoo-code" ? "ucode" : agent;
+    const finalNickname = count > 1 ? `${nickname || defaultNickname}-${i + 1}` : (nickname || defaultNickname);
     const usePty = process.env.UFOO_INTERNAL_PTY !== "0";
     const launchMode = usePty ? "internal-pty" : "internal";
 
@@ -165,6 +353,18 @@ async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "",
       },
     });
 
+    // Update bus data with the actual child PID so isMetaActive
+    // can detect when the ptyRunner process dies.
+    try {
+      bus.loadBusData();
+      if (bus.busData.agents && bus.busData.agents[subscriberId]) {
+        bus.busData.agents[subscriberId].pid = child.pid;
+      }
+      bus.saveBusData();
+    } catch {
+      // ignore pid update errors
+    }
+
     // 本地日志记录
     child.on("exit", (code, signal) => {
       try {
@@ -173,6 +373,18 @@ async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "",
         // ignore
       }
 
+      // Mark agent as inactive when its process exits
+      try {
+        bus.loadBusData();
+        if (bus.busData.agents && bus.busData.agents[subscriberId]) {
+          bus.busData.agents[subscriberId].status = "inactive";
+          bus.busData.agents[subscriberId].last_seen = new Date().toISOString();
+        }
+        bus.saveBusData();
+      } catch {
+        // ignore
+      }
+
       if (signal) {
         fs.appendFileSync(logFile, `\n[internal-agent] ${subscriberId} killed by signal ${signal}\n`);
       } else {
@@ -200,41 +412,14 @@ async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "",
   return { children, subscriberIds };
 }
 
-/**
- * Find the first idle tmux pane in the SAME window as ufoo chat.
- * Looks for panes running a plain shell, excluding the chat pane itself.
- * Returns the pane target (e.g. "%5") or null.
- */
-function findIdleTmuxPane() {
-  const myPaneId = process.env.TMUX_PANE || "";
-  if (!myPaneId) return null;
-
-  // List panes in the same window as ufoo chat
-  const result = spawnSync("tmux", [
-    "list-panes", "-t", myPaneId,
-    "-F", "#{pane_id}\t#{pane_current_command}",
-  ], { stdio: "pipe", encoding: "utf8" });
-
-  if (result.status !== 0 || !result.stdout) return null;
-
-  const shells = new Set(["bash", "zsh", "fish", "sh", "dash", "ksh", "login"]);
-
-  for (const line of result.stdout.trim().split("\n")) {
-    const [paneId, cmd] = line.split("\t");
-    if (!paneId || !cmd) continue;
-    // Skip ufoo chat's own pane
-    if (paneId === myPaneId) continue;
-    // Only use panes running a plain shell
-    if (shells.has(path.basename(cmd))) {
-      return paneId;
-    }
-  }
-  return null;
-}
-
 function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extraEnv = "") {
   return new Promise((resolve, reject) => {
-    const binary = agent === "codex" ? "ucodex" : "uclaude";
+    const normalizedAgent = normalizeLaunchAgent(agent);
+    const binary = toTmuxBinary(normalizedAgent);
+    if (!binary) {
+      reject(new Error(`unsupported agent type: ${agent}`));
+      return;
+    }
     const nickEnv = nickname ? `UFOO_NICKNAME=${shellEscape(nickname)} ` : "";
     const modeEnv = "UFOO_LAUNCH_MODE=tmux ";
     const ttyEnv = "UFOO_TTY_OVERRIDE=$(tty) ";
@@ -242,61 +427,46 @@ function spawnTmuxWindow(projectRoot, agent, nickname = "", extraArgs = [], extr
     const envPrefix = extraEnv ? `${String(extraEnv).trim()} ` : "";
     const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
 
-    // tmux natively sets $TMUX_PANE for each pane — no need to override
-    const runCmd = `cd ${shellEscape(projectRoot)} && ${modeEnv}${nickEnv}${ttyEnv}${envPrefix}${binary}${argText}`;
+    // IMPORTANT: Set TMUX_PANE inside the new window using tmux display-message
+    // This ensures the agent gets the correct pane ID for command injection
+    const setPaneEnv = `export TMUX_PANE=$(tmux display-message -p '#{pane_id}'); `;
+    const runCmd = `cd ${shellEscape(projectRoot)} && ${setPaneEnv}${modeEnv}${nickEnv}${ttyEnv}${envPrefix}${binary}${argText}`;
     const windowName = nickname || `${agent}-${Date.now()}`;
-    const targetSession = process.env.UFOO_TMUX_SESSION || "";
 
-    // Find an idle pane in the same window, or split a new one
-    const idlePane = findIdleTmuxPane();
-    const myPane = process.env.TMUX_PANE || "";
-
-    if (idlePane) {
-      // Reuse idle pane: send the launch command there
-      const proc = spawn("tmux", ["send-keys", "-t", idlePane, runCmd, "Enter"]);
-      let stderr = "";
-      proc.stderr.on("data", (d) => { stderr += d.toString("utf8"); });
-      proc.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(stderr || "tmux send-keys failed"));
-      });
-    } else {
-      // No idle pane — split current window to create a new pane
-      const splitTarget = myPane || (targetSession ? `${targetSession}:` : "");
-      const splitArgs = ["split-window", "-d", "-h"];
-      if (splitTarget) splitArgs.push("-t", splitTarget);
-      splitArgs.push(runCmd);
-
-      const proc = spawn("tmux", splitArgs);
-      let stderr = "";
-      proc.stderr.on("data", (d) => { stderr += d.toString("utf8"); });
-      proc.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(stderr || "tmux split-window failed"));
-      });
+    // Use detached mode (-d) to avoid stealing focus
+    // Use -a flag to insert after current window, avoiding index conflicts
+    // Use target session from env or current session
+    const targetSession = process.env.UFOO_TMUX_SESSION || "";
+    const tmuxArgs = ["new-window", "-a", "-d", "-n", windowName];
+    if (targetSession) {
+      tmuxArgs.push("-t", targetSession);
     }
-  });
-}
+    tmuxArgs.push(runCmd);
 
-/**
- * Detect the effective launch mode based on the current environment.
- */
-function detectLaunchMode() {
-  // Inside tmux → use tmux mode
-  if (process.env.TMUX) return "tmux";
-  // macOS with Terminal.app / iTerm → use terminal mode
-  if (process.platform === "darwin") return "terminal";
-  // Fallback
-  return "internal";
+    const proc = spawn("tmux", tmuxArgs);
+    let stderr = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    proc.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(stderr || "tmux new-window failed"));
+    });
+  });
 }
 
 async function launchAgent(projectRoot, agent, count = 1, nickname = "", processManager = null) {
   const config = loadConfig(projectRoot);
-  let mode = config.launchMode || "auto";
-  if (mode === "auto") {
-    mode = detectLaunchMode();
+  const mode = config.launchMode || "terminal";
+  const normalizedAgent = normalizeLaunchAgent(agent);
+  if (!normalizedAgent) {
+    throw new Error(`unsupported agent type: ${agent}`);
   }
 
+  if (mode === "internal") {
+    const result = await spawnInternalAgent(projectRoot, normalizedAgent, count, nickname, processManager);
+    return { mode: "internal", subscriberIds: result.subscriberIds };
+  }
   if (mode === "tmux") {
     // Check if tmux is available
     const tmuxCheck = spawn("tmux", ["list-sessions"], { stdio: "pipe" });
@@ -320,36 +490,36 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
       }
     }
     for (let i = 0; i < count; i += 1) {
-      const nick = count > 1 ? `${nickname || agent}-${i + 1}` : (nickname || "");
+      // Use "ucode" as default nickname for ufoo/ucode agents
+      const defaultNick = normalizedAgent === "ufoo" ? "ucode" : normalizedAgent;
+      const nick = count > 1 ? `${nickname || defaultNick}-${i + 1}` : (nickname || "");
       // eslint-disable-next-line no-await-in-loop
-      await spawnTmuxWindow(projectRoot, agent, nick);
+      await spawnTmuxWindow(projectRoot, normalizedAgent, nick);
     }
     return { mode: "tmux" };
   }
+  // terminal mode - daemon 作为父进程，输出到终端窗口
+  if (process.platform !== "darwin") {
+    throw new Error("launchAgent with terminal mode is only supported on macOS Terminal.app");
+  }
 
-  // terminal mode - 使用 AppleScript 打开窗口 (iTerm2 优先)
-  if (mode === "terminal") {
-    const useITerm = isITerm2();
-    for (let i = 0; i < count; i += 1) {
-      const nick = count > 1 ? `${nickname || agent}-${i + 1}` : (nickname || "");
-      // eslint-disable-next-line no-await-in-loop
-      if (useITerm) {
-        await spawnITerm2Agent(projectRoot, agent, nick);
-      } else {
-        await spawnTerminalAgent(projectRoot, agent, nick);
-      }
-    }
-    return { mode: "terminal" };
+  const subscriberIds = [];
+  for (let i = 0; i < count; i += 1) {
+    // Use "ucode" as default nickname for ufoo/ucode agents
+    const defaultNick = normalizedAgent === "ufoo" ? "ucode" : normalizedAgent;
+    const nick = count > 1 ? `${nickname || defaultNick}-${i + 1}` : (nickname || "");
+    // eslint-disable-next-line no-await-in-loop
+    const result = await spawnManagedTerminalAgent(projectRoot, normalizedAgent, nick, processManager);
+    if (result.subscriberId) subscriberIds.push(result.subscriberId);
   }
 
-  // internal mode - 使用 PTY 方式启动
-  const result = await spawnInternalAgent(projectRoot, agent, count, nickname, processManager);
-  return { mode: "internal", subscriberIds: result.subscriberIds };
+  return { mode: "terminal", subscriberIds };
 }
 
 function normalizeAgentType(agentType) {
   if (agentType === "claude-code") return "claude";
   if (agentType === "codex") return "codex";
+  if (agentType === "ufoo-code") return "ufoo";
   return agentType;
 }
 
@@ -366,9 +536,9 @@ function isActiveAgent(meta) {
   return true;
 }
 
-async function resumeAgents(projectRoot, target = "", processManager = null) {
+function collectRecoverableAgents(projectRoot, target = "") {
   const config = loadConfig(projectRoot);
-  const mode = config.launchMode || "internal";
+  const mode = config.launchMode || "terminal";
   const filePath = getUfooPaths(projectRoot).agentsFile;
   const data = loadAgentsData(filePath);
   const entries = Object.entries(data.agents || {});
@@ -378,13 +548,22 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
     if (target.includes(":")) {
       targets = entries.filter(([id]) => id === target);
     } else {
-      targets = entries.filter(([, meta]) => meta && meta.nickname === target);
+      targets = entries.filter(([id, meta]) => id === target || (meta && meta.nickname === target));
     }
   }
 
-  const resumable = [];
+  const recoverableEntries = [];
   const skipped = [];
 
+  if (target && targets.length === 0) {
+    return {
+      mode,
+      data,
+      recoverableEntries,
+      skipped: [{ id: target, reason: "target not found" }],
+    };
+  }
+
   for (const [id, meta] of targets) {
     if (!meta || !meta.provider_session_id) {
       skipped.push({ id, reason: "no provider session" });
@@ -399,16 +578,47 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
       skipped.push({ id, reason: "unsupported agent type" });
       continue;
     }
-    resumable.push({ id, meta, agent });
+
+    if (mode === "internal") {
+      skipped.push({ id, reason: "internal mode not supported for resume" });
+      continue;
+    }
+
+    recoverableEntries.push({ id, meta, agent });
   }
 
-  if (resumable.length === 0) {
+  return {
+    mode,
+    data,
+    recoverableEntries,
+    skipped,
+  };
+}
+
+function getRecoverableAgents(projectRoot, target = "") {
+  const { mode, recoverableEntries, skipped } = collectRecoverableAgents(projectRoot, target);
+  const recoverable = recoverableEntries.map((item) => ({
+    id: item.id,
+    nickname: item.meta.nickname || "",
+    agent: item.agent,
+    sessionId: item.meta.provider_session_id || "",
+    launchMode: item.meta.launch_mode || "",
+    lastSeen: item.meta.last_seen || "",
+  }));
+  return { ok: true, mode, recoverable, skipped };
+}
+
+async function resumeAgents(projectRoot, target = "", processManager = null) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const { mode, data, recoverableEntries, skipped } = collectRecoverableAgents(projectRoot, target);
+
+  if (recoverableEntries.length === 0) {
     return { ok: true, resumed: [], skipped };
   }
 
-  // Clear old nicknames to allow reuse
+  // Clear old nicknames to allow reuse.
   let updated = false;
-  for (const item of resumable) {
+  for (const item of recoverableEntries) {
     if (item.meta && item.meta.nickname) {
       data.agents[item.id] = { ...item.meta, nickname: "" };
       updated = true;
@@ -419,46 +629,74 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
   }
 
   const resumed = [];
-
-  // tmux 模式使用 tmux new-window 恢复
-  if (mode === "tmux") {
-    for (const item of resumable) {
-      const nickname = item.meta.nickname || "";
-      const sessionId = item.meta.provider_session_id;
+  for (const item of recoverableEntries) {
+    const nickname = item.meta.nickname || "";
+    const sessionId = item.meta.provider_session_id;
+    const reused = await tryReuseTerminal(projectRoot, item.id, item.meta, item.agent, sessionId);
+    if (!reused) {
       const args = buildResumeArgs(item.agent, sessionId);
       const envPrefix = "UFOO_SKIP_SESSION_PROBE=1";
-      // eslint-disable-next-line no-await-in-loop
-      await spawnTmuxWindow(projectRoot, item.agent, nickname, args, envPrefix);
-      resumed.push({ id: item.id, nickname, agent: item.agent, sessionId, reused: false });
+      if (mode === "tmux") {
+        // eslint-disable-next-line no-await-in-loop
+        await spawnTmuxWindow(projectRoot, item.agent, nickname, args, envPrefix);
+      } else {
+        // eslint-disable-next-line no-await-in-loop
+        await spawnManagedTerminalAgent(projectRoot, item.agent, nickname, processManager, args, envPrefix);
+      }
     }
-    return { ok: true, resumed, skipped };
+    resumed.push({ id: item.id, nickname, agent: item.agent, sessionId, reused });
   }
 
-  // internal 模式暂不支持 resume（需要用户手动启动）
-  for (const item of resumable) {
-    skipped.push({ id: item.id, reason: "internal mode requires manual restart" });
-  }
   return { ok: true, resumed, skipped };
 }
 
 async function closeAgent(projectRoot, agentId) {
+  if (process.platform !== "darwin") {
+    return false;
+  }
   const resolvedId = resolveAgentId(projectRoot, agentId);
   const busPath = getUfooPaths(projectRoot).agentsFile;
   let pid = null;
+  let launchMode = "";
+  let tty = "";
+  let terminalApp = "";
   try {
     const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
     const entry = bus.agents?.[resolvedId];
-    if (entry && entry.pid) pid = entry.pid;
+    if (entry) {
+      if (entry.pid) pid = entry.pid;
+      launchMode = entry.launch_mode || "";
+      tty = entry.tty || "";
+      terminalApp = entry.terminal_app || "";
+    }
   } catch {
     pid = null;
   }
-  if (!pid) return false;
-  try {
-    process.kill(pid, "SIGTERM");
-    return true;
-  } catch {
-    return false;
+  const adapterRouter = createTerminalAdapterRouter();
+  const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId });
+  const canCloseWindow = adapter.capabilities.supportsWindowClose && tty;
+
+  // Close process first for faster state transition in chat.
+  let sentSignal = false;
+  if (pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+      sentSignal = true;
+    } catch {
+      sentSignal = false;
+    }
   }
+
+  if (sentSignal || (!pid && canCloseWindow)) {
+    markAgentInactive(projectRoot, resolvedId);
+  }
+
+  if (canCloseWindow) {
+    // Non-blocking: don't hold close response on AppleScript window operations.
+    void closeTerminalWindowByTty(tty, terminalApp).catch(() => false);
+  }
+
+  return sentSignal || (!pid && canCloseWindow);
 }
 
-module.exports = { launchAgent, closeAgent, resumeAgents };
+module.exports = { launchAgent, closeAgent, getRecoverableAgents, resumeAgents };