u-foo 1.5.0 → 1.7.0

package/src/chat/projectRuntimes.js

@@ -0,0 +1,55 @@
+function parseTimestampMs(value) {
+  const parsed = Date.parse(String(value || ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function projectLabel(row = {}) {
+  return String(row.project_name || row.project_root || "");
+}
+
+function normalizeInteractionMs(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num < 0) return 0;
+  return num;
+}
+
+function filterVisibleProjectRuntimes(rows = []) {
+  const sourceRows = Array.isArray(rows) ? rows : [];
+  return sourceRows.filter((row) => {
+    const status = String((row && row.status) || "").trim().toLowerCase();
+    return status !== "stopped";
+  });
+}
+
+function sortProjectRuntimes(options = {}) {
+  const {
+    rows = [],
+    activeProjectRoot = "",
+    resolveProjectRoot = (row) => String((row && row.project_root) || ""),
+    getInteractionMs = () => 0,
+  } = options;
+  const sourceRows = Array.isArray(rows) ? rows.slice() : [];
+  // Keep arg usage for backward compatibility with existing callers/tests.
+  void activeProjectRoot;
+  void resolveProjectRoot;
+
+  sourceRows.sort((a, b) => {
+    const bInteraction = normalizeInteractionMs(getInteractionMs(b));
+    const aInteraction = normalizeInteractionMs(getInteractionMs(a));
+    if (bInteraction !== aInteraction) return bInteraction - aInteraction;
+
+    const bSeen = parseTimestampMs(b && b.last_seen);
+    const aSeen = parseTimestampMs(a && a.last_seen);
+    if (bSeen !== aSeen) return bSeen - aSeen;
+
+    return projectLabel(a).localeCompare(projectLabel(b), "en", { sensitivity: "base" });
+  });
+
+  return sourceRows;
+}
+
+module.exports = {
+  sortProjectRuntimes,
+  parseTimestampMs,
+  filterVisibleProjectRuntimes,
+};

package/src/chat/statusLineController.js

@@ -107,20 +107,66 @@ function createStatusLineController(options = {}) {
     renderStatusLine();
   }
 
-  function queueStatusLine(text) {
-    pendingStatusLines.push(text || "");
+  function normalizePendingItem(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    return {
+      text: text || "",
+      key,
+    };
+  }
+
+  function headPendingText() {
+    if (pendingStatusLines.length === 0) return "";
+    const item = pendingStatusLines[0];
+    return item && typeof item.text === "string" ? item.text : "";
+  }
+
+  function queueStatusLine(text, options = {}) {
+    const item = normalizePendingItem(text, options);
+    if (item.key) {
+      const existingIndex = pendingStatusLines.findIndex((entry) => entry.key === item.key);
+      if (existingIndex >= 0) {
+        pendingStatusLines[existingIndex] = item;
+        if (existingIndex === 0) {
+          setPrimaryStatus(item.text, { pending: true });
+          renderScreen();
+        }
+        return;
+      }
+    }
+
+    pendingStatusLines.push(item);
     if (pendingStatusLines.length === 1) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      setPrimaryStatus(item.text, { pending: true });
       renderScreen();
     }
   }
 
-  function resolveStatusLine(text) {
+  function resolveStatusLine(text, options = {}) {
+    const key = options && typeof options.key === "string"
+      ? options.key.trim()
+      : "";
+    let removedHead = false;
+
     if (pendingStatusLines.length > 0) {
-      pendingStatusLines.shift();
+      if (key) {
+        const index = pendingStatusLines.findIndex((entry) => entry.key === key);
+        if (index >= 0) {
+          pendingStatusLines.splice(index, 1);
+          removedHead = index === 0;
+        }
+      } else {
+        pendingStatusLines.shift();
+        removedHead = true;
+      }
     }
+
     if (pendingStatusLines.length > 0) {
-      setPrimaryStatus(pendingStatusLines[0], { pending: true });
+      if (removedHead || !primaryStatusPending) {
+        setPrimaryStatus(headPendingText(), { pending: true });
+      }
     } else {
       setPrimaryStatus(text || "", { pending: false });
     }

package/src/chat/transport.js

@@ -3,10 +3,46 @@ const path = require("path");
 const fs = require("fs");
 const { spawn, spawnSync } = require("child_process");
 
-function connectSocket(sockPath) {
+function connectSocket(sockPath, options = {}) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+    ? Math.trunc(options.timeoutMs)
+    : 0;
   return new Promise((resolve, reject) => {
-    const client = net.createConnection(sockPath, () => resolve(client));
-    client.on("error", reject);
+    let timeoutHandle = null;
+    const client = net.createConnection(sockPath, () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      resolve(client);
+    });
+
+    const cleanup = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+      }
+    };
+
+    client.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+
+    if (timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        const err = new Error(`connect timeout after ${timeoutMs}ms`);
+        err.code = "ETIMEDOUT";
+        try {
+          client.destroy(err);
+        } catch {
+          // ignore
+        }
+        reject(err);
+      }, timeoutMs);
+      if (typeof timeoutHandle.unref === "function") {
+        timeoutHandle.unref();
+      }
+    }
   });
 }
 
@@ -38,11 +74,11 @@ function stopDaemon(projectRoot) {
   });
 }
 
-async function connectWithRetry(sockPath, retries, delayMs) {
+async function connectWithRetry(sockPath, retries, delayMs, options = {}) {
   for (let i = 0; i < retries; i += 1) {
     try {
       // eslint-disable-next-line no-await-in-loop
-      const client = await connectSocket(sockPath);
+      const client = await connectSocket(sockPath, options);
       return client;
     } catch {
       // eslint-disable-next-line no-await-in-loop

package/src/cli.js

@@ -133,6 +133,19 @@ function requireOptional(name) {
   }
 }
 
+function collectHostLaunchRequestContext(env = process.env) {
+  const hostInjectSock = String(env.UFOO_HOST_INJECT_SOCK || env.HORIZON_INJECT_SOCK || "").trim();
+  const hostDaemonSock = String(env.UFOO_HOST_DAEMON_SOCK || "").trim();
+  const hostName = String(env.UFOO_HOST_NAME || "").trim();
+  const hostSessionId = String(env.UFOO_HOST_SESSION_ID || env.HORIZON_SESSION_ID || "").trim();
+  const context = {};
+  if (hostInjectSock) context.host_inject_sock = hostInjectSock;
+  if (hostDaemonSock) context.host_daemon_sock = hostDaemonSock;
+  if (hostName) context.host_name = hostName;
+  if (hostSessionId) context.host_session_id = hostSessionId;
+  return context;
+}
+
 function collectOption(value, previous) {
   const next = Array.isArray(previous) ? previous.slice() : [];
   const parts = String(value || "")
@@ -424,6 +437,7 @@ async function runCli(argv) {
             agent: normalizedAgent,
             nickname: nickname || "",
             count: 1,
+            ...collectHostLaunchRequestContext(),
           });
           const reply = resp?.data?.reply || `Launching ${normalizedAgent} agent...`;
           console.log(reply);

package/src/config.js

@@ -27,6 +27,7 @@ function normalizeLaunchMode(value) {
   if (value === "internal") return "internal";
   if (value === "tmux") return "tmux";
   if (value === "terminal") return "terminal";
+  if (value === "host") return "host";
   return "auto";
 }
 

package/src/daemon/index.js

@@ -328,6 +328,16 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
         const launchResult = await launchAgent(projectRoot, agent, count, nickname, processManager, {
           launchScope: op.launch_scope || "",
           terminalApp: op.terminal_app || "",
+          hostInjectSock: op.host_inject_sock || op.hostInjectSock || "",
+          hostDaemonSock: op.host_daemon_sock || op.hostDaemonSock || "",
+          hostName: op.host_name || op.hostName || "",
+          hostSessionId: op.host_session_id || op.hostSessionId || "",
+          hostCapabilities:
+            (op.host_capabilities && typeof op.host_capabilities === "object")
+            ? op.host_capabilities
+            : ((op.hostCapabilities && typeof op.hostCapabilities === "object")
+              ? op.hostCapabilities
+              : null),
         });
         if (launchResult.mode === "internal" && launchResult.subscriberIds && launchResult.subscriberIds.length > 0) {
           const probeAgentType = agent === "codex"
@@ -378,8 +388,15 @@ async function handleOps(projectRoot, ops = [], processManager = null) {
         results.push({ action: "launch", ok: false, agent, count, error: err.message });
       }
     } else if (op.action === "close") {
-      const ok = await closeAgent(projectRoot, op.agent_id);
-      results.push({ action: "close", ok, agent_id: op.agent_id });
+      const closeResult = await closeAgent(projectRoot, op.agent_id);
+      const normalizedClose = closeResult && typeof closeResult === "object"
+        ? closeResult
+        : { ok: Boolean(closeResult) };
+      results.push({
+        action: "close",
+        agent_id: op.agent_id,
+        ...normalizedClose,
+      });
     } else if (op.action === "rename") {
       const agentId = op.agent_id || "";
       const nickname = op.nickname || "";
@@ -943,7 +960,9 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         const closeResult = opsResults.find((r) => r.action === "close");
         const ok = closeResult ? closeResult.ok !== false : true;
         const reply = ok
-          ? `Closed ${agent_id}`
+          ? (closeResult && closeResult.already_stopped
+            ? `Closed ${agent_id} (already stopped)`
+            : `Closed ${agent_id}`)
           : `Close failed: ${closeResult?.error || "unknown error"}`;
         socket.write(
           `${JSON.stringify({
@@ -971,7 +990,18 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
     if (req.type === IPC_REQUEST_TYPES.LAUNCH_AGENT) {
       log(`launch_agent received: agent=${req.agent} count=${req.count}`);
-      const { agent, count, nickname, launch_scope, terminal_app } = req;
+      const {
+        agent,
+        count,
+        nickname,
+        launch_scope,
+        terminal_app,
+        host_inject_sock,
+        host_daemon_sock,
+        host_name,
+        host_session_id,
+        host_capabilities,
+      } = req;
       const normalizedAgent = normalizeLaunchAgent(agent);
       if (!normalizedAgent) {
         socket.write(
@@ -992,6 +1022,14 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         nickname: nickname || "",
         launch_scope: launch_scope || "",
         terminal_app: terminal_app || "",
+        host_inject_sock: host_inject_sock || "",
+        host_daemon_sock: host_daemon_sock || "",
+        host_name: host_name || "",
+        host_session_id: host_session_id || "",
+        host_capabilities:
+          host_capabilities && typeof host_capabilities === "object"
+            ? host_capabilities
+            : null,
       };
       try {
         const opsResults = await handleOps(projectRoot, [op], processManager);
@@ -1394,7 +1432,20 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
     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;
+      const {
+        agentType,
+        nickname,
+        parentPid,
+        launchMode,
+        tmuxPane,
+        tty,
+        hostInjectSock,
+        hostDaemonSock,
+        hostName,
+        hostSessionId,
+        hostCapabilities,
+        skipProbe,
+      } = req;
       if (!agentType) {
         socket.write(
           `${JSON.stringify({
@@ -1442,6 +1493,13 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           launchMode: launchMode || "",
           tmuxPane: tmuxPane || "",
           tty: tty || "",
+          hostInjectSock: hostInjectSock || "",
+          hostDaemonSock: hostDaemonSock || "",
+          hostName: hostName || "",
+          hostSessionId: hostSessionId || "",
+          hostCapabilities: hostCapabilities && typeof hostCapabilities === "object"
+            ? hostCapabilities
+            : null,
           reuseSessionId,
           reuseProviderSessionId,
         };

package/src/daemon/ipcServer.js

@@ -28,6 +28,7 @@ function createDaemonIpcServer(options = {}) {
   };
 
   let lastActiveJson = "";
+  let lastMetaJson = "";
   const statusSyncInterval = setInterval(() => {
     if (sockets.size === 0) return;
     try {
@@ -38,8 +39,12 @@ function createDaemonIpcServer(options = {}) {
     try {
       const status = buildStatus(projectRoot);
       const currentActiveJson = JSON.stringify(status.active);
-      if (currentActiveJson !== lastActiveJson) {
+      const currentMetaJson = JSON.stringify(
+        (status.active_meta || []).map((m) => `${m.id}:${m.activity_state || ""}`)
+      );
+      if (currentActiveJson !== lastActiveJson || currentMetaJson !== lastMetaJson) {
         lastActiveJson = currentActiveJson;
+        lastMetaJson = currentMetaJson;
         sendToSockets({ type: IPC_RESPONSE_TYPES.STATUS, data: status });
         log(`status sync: active agents changed to ${status.active.length}`);
       }

package/src/daemon/ops.js

@@ -1,4 +1,4 @@
-const { spawn } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
 const { loadConfig } = require("../config");
@@ -7,6 +7,11 @@ const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
 const { isAgentPidAlive, getTtyProcessInfo } = require("../bus/utils");
 const { isITerm2 } = require("../terminal/detect");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const {
+  createSession: createHostSession,
+  closeSession: closeHostSession,
+  sendToSocket: sendHostSocketRequest,
+} = require("../terminal/adapters/hostAdapter");
 
 function normalizeLaunchAgent(agent = "") {
   const value = String(agent || "").trim().toLowerCase();
@@ -75,6 +80,44 @@ function normalizeTerminalAppPreference(value = "") {
   return "";
 }
 
+function normalizeOptionalString(value = "") {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function resolveHostLaunchContext(options = {}) {
+  return {
+    hostInjectSock:
+      normalizeOptionalString(options.hostInjectSock)
+      || normalizeOptionalString(process.env.UFOO_HOST_INJECT_SOCK)
+      || normalizeOptionalString(process.env.HORIZON_INJECT_SOCK),
+    hostDaemonSock:
+      normalizeOptionalString(options.hostDaemonSock)
+      || normalizeOptionalString(process.env.UFOO_HOST_DAEMON_SOCK),
+    hostName:
+      normalizeOptionalString(options.hostName)
+      || normalizeOptionalString(process.env.UFOO_HOST_NAME),
+    hostSessionId:
+      normalizeOptionalString(options.hostSessionId)
+      || normalizeOptionalString(process.env.UFOO_HOST_SESSION_ID)
+      || normalizeOptionalString(process.env.HORIZON_SESSION_ID),
+    hostCapabilities:
+      options.hostCapabilities && typeof options.hostCapabilities === "object"
+        ? { ...options.hostCapabilities }
+        : null,
+  };
+}
+
+function resolveConfiguredLaunchMode(configuredMode = "", options = {}) {
+  const mode = normalizeOptionalString(configuredMode);
+  if (mode === "internal" || mode === "tmux" || mode === "terminal" || mode === "host") {
+    return mode;
+  }
+  const hostContext = resolveHostLaunchContext(options);
+  if (hostContext.hostDaemonSock) return "host";
+  if (process.env.TMUX_PANE) return "tmux";
+  return "terminal";
+}
+
 function resolveAgentId(projectRoot, agentId) {
   if (!agentId) return agentId;
   if (agentId.includes(":")) return agentId;
@@ -395,6 +438,82 @@ async function spawnManagedTerminalAgent(
   return { child: null, subscriberId: subscriberId || null };
 }
 
+async function spawnManagedHostAgent(
+  projectRoot,
+  agent,
+  nickname = "",
+  processManager = null,
+  extraArgs = [],
+  extraEnv = "",
+  hostOptions = {}
+) {
+  void processManager;
+  const normalizedAgent = normalizeLaunchAgent(agent);
+  const binary = toTerminalBinary(normalizedAgent);
+  const agentType = toBusAgentType(normalizedAgent);
+  if (!binary || !agentType) {
+    throw new Error(`unsupported agent type: ${agent}`);
+  }
+
+  const hostContext = resolveHostLaunchContext(hostOptions);
+  if (!hostContext.hostDaemonSock) {
+    throw new Error("host launch requires UFOO_HOST_DAEMON_SOCK");
+  }
+
+  const existing = listSubscribers(projectRoot, agentType);
+  const createOptions = {};
+  if (hostOptions.groupId) {
+    createOptions.group_id = String(hostOptions.groupId).trim();
+  } else if (hostContext.hostSessionId) {
+    createOptions.source_session_id = hostContext.hostSessionId;
+  }
+
+  const created = await createHostSession(hostContext.hostDaemonSock, createOptions);
+  const sessionId = normalizeOptionalString(created?.session_id);
+  const injectSock = normalizeOptionalString(created?.inject_sock);
+  if (!sessionId || !injectSock) {
+    throw new Error("host create_session returned incomplete session info");
+  }
+
+  const args = Array.isArray(extraArgs) ? extraArgs : [];
+  const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
+  const envParts = [
+    "UFOO_LAUNCH_MODE=host",
+    `UFOO_HOST_DAEMON_SOCK=${shellEscape(hostContext.hostDaemonSock)}`,
+    `UFOO_HOST_SESSION_ID=${shellEscape(sessionId)}`,
+    `UFOO_HOST_INJECT_SOCK=${shellEscape(injectSock)}`,
+  ];
+  if (nickname) {
+    envParts.push(`UFOO_NICKNAME=${shellEscape(nickname)}`);
+  }
+  if (hostContext.hostName) {
+    envParts.push(`UFOO_HOST_NAME=${shellEscape(hostContext.hostName)}`);
+  }
+  if (extraEnv) {
+    envParts.push(String(extraEnv).trim());
+  }
+
+  const titleCmd = buildTitleCmd(nickname);
+  const launchCmd = `${envParts.join(" ")} ${binary}${argText}`.trim();
+  const runCmd = titleCmd
+    ? `cd ${shellEscape(projectRoot)} && ${titleCmd} && ${launchCmd}`
+    : `cd ${shellEscape(projectRoot)} && ${launchCmd}`;
+
+  try {
+    await sendHostSocketRequest(injectSock, { type: "inject", command: runCmd });
+  } catch (err) {
+    try {
+      await closeHostSession(sessionId, hostContext.hostDaemonSock);
+    } catch {
+      // ignore cleanup failures
+    }
+    throw err;
+  }
+
+  const subscriberId = await waitForNewSubscriber(projectRoot, agentType, existing, 20000);
+  return { child: null, subscriberId: subscriberId || null, sessionId, injectSock };
+}
+
 async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "", processManager = null) {
   const runner = path.join(projectRoot, "bin", "ufoo.js");
   const logDir = getUfooPaths(projectRoot).runDir;
@@ -609,7 +728,7 @@ function spawnTmuxPane(projectRoot, agent, nickname = "", extraArgs = [], extraE
 
 async function launchAgent(projectRoot, agent, count = 1, nickname = "", processManager = null, options = {}) {
   const config = loadConfig(projectRoot);
-  const mode = config.launchMode || "terminal";
+  const mode = resolveConfiguredLaunchMode(config.launchMode, options);
   const launchScope = normalizeLaunchScope(options.launchScope, "inplace");
   const terminalApp = normalizeTerminalAppPreference(options.terminalApp);
   const normalizedAgent = normalizeLaunchAgent(agent);
@@ -665,6 +784,26 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
     }
     return { mode: "tmux", launchScope, subscriberIds: [] };
   }
+  if (mode === "host") {
+    const subscriberIds = [];
+    const hostContext = resolveHostLaunchContext(options);
+    for (let i = 0; i < count; i += 1) {
+      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 spawnManagedHostAgent(
+        projectRoot,
+        normalizedAgent,
+        nick,
+        processManager,
+        [],
+        "",
+        hostContext
+      );
+      if (result.subscriberId) subscriberIds.push(result.subscriberId);
+    }
+    return { mode: "host", launchScope, subscriberIds };
+  }
   // terminal mode - daemon 作为父进程，输出到终端窗口
   if (process.platform !== "darwin") {
     throw new Error("launchAgent with terminal mode is only supported on macOS Terminal.app");
@@ -827,43 +966,57 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
 }
 
 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 pid = 0;
   let launchMode = "";
   let tty = "";
   let terminalApp = "";
+  let tmuxPane = "";
+  let meta = null;
+  let found = false;
   try {
     const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
     const entry = bus.agents?.[resolvedId];
     if (entry) {
-      if (entry.pid) pid = entry.pid;
+      found = true;
+      meta = entry;
+      const parsedPid = Number.parseInt(entry.pid, 10);
+      pid = Number.isFinite(parsedPid) && parsedPid > 0 ? parsedPid : 0;
       launchMode = entry.launch_mode || "";
       tty = entry.tty || "";
       terminalApp = entry.terminal_app || "";
+      tmuxPane = entry.tmux_pane || "";
     }
   } catch {
-    pid = null;
+    found = false;
   }
+
+  if (!found) {
+    return { ok: true, already_stopped: true, resolved_agent_id: resolvedId };
+  }
+
   const adapterRouter = createTerminalAdapterRouter();
-  const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId });
-  const canCloseWindow = adapter.capabilities.supportsWindowClose && tty;
+  const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId, meta });
+  const canCloseWindow = process.platform === "darwin"
+    && Boolean(adapter.capabilities.supportsWindowClose)
+    && Boolean(tty);
 
   // Close process first for faster state transition in chat.
   let sentSignal = false;
-  if (pid) {
+  let killErr = null;
+  if (pid > 0) {
     try {
       process.kill(pid, "SIGTERM");
       sentSignal = true;
-    } catch {
+    } catch (err) {
+      killErr = err || null;
       sentSignal = false;
     }
   }
 
-  if (sentSignal || (!pid && canCloseWindow)) {
+  const pidGone = pid > 0 && !sentSignal && !isAgentPidAlive(pid);
+  if (sentSignal || pid === 0 || pidGone) {
     markAgentInactive(projectRoot, resolvedId);
   }
 
@@ -872,7 +1025,29 @@ async function closeAgent(projectRoot, agentId) {
     void closeTerminalWindowByTty(tty, terminalApp).catch(() => false);
   }
 
-  return sentSignal || (!pid && canCloseWindow);
+  // Tmux pane cleanup: kill the pane after sending SIGTERM to the process.
+  if (launchMode === "tmux" && tmuxPane) {
+    try {
+      spawnSync("tmux", ["kill-pane", "-t", tmuxPane], { stdio: "ignore", timeout: 3000 });
+    } catch {
+      // ignore - pane may already be gone
+    }
+  }
+
+  if (sentSignal) {
+    return { ok: true, resolved_agent_id: resolvedId };
+  }
+  if (pid === 0 || pidGone) {
+    return { ok: true, already_stopped: true, resolved_agent_id: resolvedId };
+  }
+  const reason = killErr && killErr.message
+    ? killErr.message
+    : "failed to stop process";
+  return {
+    ok: false,
+    error: reason,
+    resolved_agent_id: resolvedId,
+  };
 }
 
 module.exports = { launchAgent, closeAgent, getRecoverableAgents, resumeAgents };

package/src/daemon/status.js

@@ -147,7 +147,23 @@ function buildStatus(projectRoot, options = {}) {
     const launch_mode = meta?.launch_mode || "unknown";
     const tmux_pane = meta?.tmux_pane || "";
     const tty = meta?.tty || "";
-    return { id, nickname, display, launch_mode, tmux_pane, tty };
+    const activity_state = meta?.activity_state || "";
+    const activity_since = meta?.activity_since || "";
+    return {
+      id,
+      nickname,
+      display,
+      launch_mode,
+      tmux_pane,
+      tty,
+      activity_state,
+      activity_since,
+      host_inject_sock: meta?.host_inject_sock || "",
+      host_daemon_sock: meta?.host_daemon_sock || "",
+      host_name: meta?.host_name || "",
+      host_session_id: meta?.host_session_id || "",
+      host_capabilities: meta?.host_capabilities || null,
+    };
   });
 
   return {