u-foo 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agent/launcher.js

@@ -12,6 +12,7 @@ const { ActivityDetector } = require("./activityDetector");
 const { createActivityStatePublisher } = require("./activityStatePublisher");
 const { getUfooPaths } = require("../ufoo/paths");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const { probeHostCapabilities } = require("../terminal/adapters/hostAdapter");
 const PtyWrapper = require("./ptyWrapper");
 const ReadyDetector = require("./readyDetector");
 
@@ -152,6 +153,14 @@ function findPreviousSession(cwd, agentType, tty, tmuxPane) {
 function resolveLaunchMode() {
   const explicit = process.env.UFOO_LAUNCH_MODE || "";
   if (explicit) return explicit;
+  if (process.env.UFOO_HOST_SESSION_ID) return "host";
+  // Deprecated: HORIZON_SESSION_ID fallback (remove after migration)
+  if (process.env.HORIZON_SESSION_ID) {
+    if (process.env.UFOO_DEBUG) {
+      console.error("[launcher] HORIZON_SESSION_ID is deprecated, use UFOO_HOST_SESSION_ID");
+    }
+    return "host";
+  }
   if (process.env.TMUX_PANE) return "tmux";
   return "terminal";
 }
@@ -162,6 +171,48 @@ function shouldShowLaunchBanner(agentType = "") {
   return true;
 }
 
+async function resolveHostRegistrationData(launchMode) {
+  if (launchMode !== "host") {
+    return {
+      hostInjectSock: "",
+      hostDaemonSock: "",
+      hostName: "",
+      hostSessionId: "",
+      hostCapabilities: null,
+    };
+  }
+
+  const hostInjectSock = process.env.UFOO_HOST_INJECT_SOCK
+    || process.env.HORIZON_INJECT_SOCK
+    || "";
+  const hostDaemonSock = process.env.UFOO_HOST_DAEMON_SOCK || "";
+  const hostName = process.env.UFOO_HOST_NAME || "";
+  const hostSessionId = process.env.UFOO_HOST_SESSION_ID
+    || process.env.HORIZON_SESSION_ID
+    || "";
+
+  let hostCapabilities = null;
+  if (hostInjectSock || hostDaemonSock) {
+    try {
+      hostCapabilities = await probeHostCapabilities({
+        injectSock: hostInjectSock,
+        daemonSock: hostDaemonSock,
+        timeoutMs: 1000,
+      });
+    } catch {
+      hostCapabilities = null;
+    }
+  }
+
+  return {
+    hostInjectSock,
+    hostDaemonSock,
+    hostName,
+    hostSessionId,
+    hostCapabilities,
+  };
+}
+
 /**
  * Agent 启动器
  * 统一处理 agent 启动流程：初始化、daemon 注册、banner、命令执行
@@ -314,6 +365,13 @@ class AgentLauncher {
     const previousSession = shouldReuse
       ? findPreviousSession(this.cwd, this.agentType, tty, tmuxPane)
       : null;
+    const {
+      hostInjectSock,
+      hostDaemonSock,
+      hostName,
+      hostSessionId,
+      hostCapabilities,
+    } = await resolveHostRegistrationData(launchMode);
 
     const req = {
       type: IPC_REQUEST_TYPES.REGISTER_AGENT,
@@ -323,6 +381,11 @@ class AgentLauncher {
       launchMode,
       tmuxPane,
       tty,
+      hostInjectSock,
+      hostDaemonSock,
+      hostName,
+      hostSessionId,
+      hostCapabilities,
       skipProbe: process.env.UFOO_SKIP_SESSION_PROBE === "1",
       // 传递旧 session 信息用于复用（仅 terminal/tmux 模式）
       reuseSession: previousSession ? {

package/src/bus/activate.js

@@ -40,6 +40,11 @@ class AgentActivator {
         tty: meta.tty || "",
         tmux_pane: meta.tmux_pane || "",
         launch_mode: meta.launch_mode || "",
+        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,
       };
     } catch (err) {
       throw new Error(`Failed to get agent info: ${err.message}`);
@@ -156,7 +161,19 @@ end tell`;
       activateTerminal,
       activateTmux,
     });
-    const adapter = adapterRouter.getAdapter({ launchMode: info.launch_mode, agentId });
+    const adapter = adapterRouter.getAdapter({
+      launchMode: info.launch_mode,
+      agentId,
+      meta: info,
+    });
+
+    if (info.launch_mode === "host" && typeof adapter.connect === "function") {
+      try {
+        await adapter.connect();
+      } catch {
+        // fall back to seeded capabilities from bus metadata
+      }
+    }
 
     if (!adapter.capabilities.supportsActivate) {
       if (adapter.capabilities.supportsInternalQueueLoop) {
@@ -165,7 +182,10 @@ end tell`;
       throw new Error("Cannot activate: missing tty or tmux_pane for agent");
     }
 
-    await adapter.activate();
+    const activated = await adapter.activate();
+    if (activated === false) {
+      throw new Error("Host activation request was rejected");
+    }
   }
 }
 

package/src/bus/daemon.js

@@ -218,7 +218,7 @@ class BusDaemon {
       // - notifier/injector: terminal/tmux
       // - internal queue loop: internal/internal-pty
       // Bus daemon only handles legacy/unknown launch modes.
-      const adapter = this.adapterRouter.getAdapter({ launchMode, agentId: subscriber });
+      const adapter = this.adapterRouter.getAdapter({ launchMode, agentId: subscriber, meta });
       const { supportsNotifierInjector, supportsInternalQueueLoop } = adapter.capabilities;
       if (launchMode && (supportsNotifierInjector || supportsInternalQueueLoop)) {
         continue;

package/src/bus/inject.js

@@ -184,18 +184,11 @@ class Injector {
   }
 
   /**
-   * 使用 PTY socket 直接注入命令（无需macOS权限）
+   * 使用指定路径的 PTY socket 注入命令
    */
-  async injectPty(subscriber, command) {
-    const sockPath = this.getInjectSockPath(subscriber);
-
-    if (!fs.existsSync(sockPath)) {
-      throw new Error(`Inject socket not found: ${sockPath}`);
-    }
-
+  async injectPtyAtPath(sockPath, command) {
     return new Promise((resolve, reject) => {
       const client = net.createConnection(sockPath, () => {
-        // 发送inject请求
         client.write(JSON.stringify({ type: "inject", command }) + "\n");
       });
 
@@ -240,6 +233,19 @@ class Injector {
     });
   }
 
+  /**
+   * 使用 PTY socket 直接注入命令（无需macOS权限）
+   */
+  async injectPty(subscriber, command) {
+    const sockPath = this.getInjectSockPath(subscriber);
+
+    if (!fs.existsSync(sockPath)) {
+      throw new Error(`Inject socket not found: ${sockPath}`);
+    }
+
+    return this.injectPtyAtPath(sockPath, command);
+  }
+
   /**
    * 注入命令到订阅者的终端
    *
@@ -260,10 +266,23 @@ class Injector {
     const meta = this.getAgentMeta(subscriber) || {};
     const launchMode = meta.launch_mode || "";
     const adapterRouter = createTerminalAdapterRouter();
-    const adapter = adapterRouter.getAdapter({ launchMode, agentId: subscriber });
+    const adapter = adapterRouter.getAdapter({ launchMode, agentId: subscriber, meta });
     const supportsSocket = adapter.capabilities.supportsSocketProtocol;
     const supportsNotifier = adapter.capabilities.supportsNotifierInjector;
 
+    // 0. Try Terminal Host inject socket (ufoo Terminal Host Protocol)
+    const hostSock = (meta.host_inject_sock || "").toString();
+    if (hostSock && fs.existsSync(hostSock)) {
+      try {
+        logInject(`[inject] Using host inject socket: ${hostSock}`);
+        await this.injectPtyAtPath(hostSock, command);
+        logInject("[inject] Host inject success");
+        return;
+      } catch (err) {
+        logInject(`[inject] Host inject failed: ${err.message}, trying PTY socket`);
+      }
+    }
+
     // 1. 优先尝试 PTY socket（无需任何macOS权限）
     const injectSockPath = this.getInjectSockPath(subscriber);
     if (fs.existsSync(injectSockPath)) {

package/src/bus/subscriber.js

@@ -197,6 +197,22 @@ class SubscriberManager {
     const preservedTmuxPane = typeof existingMeta?.tmux_pane === "string" ? existingMeta.tmux_pane.trim() : "";
     const tmuxPane = explicitTmuxPane || envTmuxPane || preservedTmuxPane;
 
+    const hostInjectSock = typeof options.hostInjectSock === "string"
+      ? options.hostInjectSock.trim()
+      : "";
+    const hostDaemonSock = typeof options.hostDaemonSock === "string"
+      ? options.hostDaemonSock.trim()
+      : "";
+    const hostName = typeof options.hostName === "string"
+      ? options.hostName.trim()
+      : "";
+    const hostSessionId = typeof options.hostSessionId === "string"
+      ? options.hostSessionId.trim()
+      : "";
+    const hostCapabilities = options.hostCapabilities && typeof options.hostCapabilities === "object"
+      ? { ...options.hostCapabilities }
+      : null;
+
     this.busData.agents[subscriber] = {
       ...preserved,
       agent_type: agentType,
@@ -213,6 +229,22 @@ class SubscriberManager {
       launch_mode: launchMode,
     };
 
+    if (hostInjectSock) {
+      this.busData.agents[subscriber].host_inject_sock = hostInjectSock;
+    }
+    if (hostDaemonSock) {
+      this.busData.agents[subscriber].host_daemon_sock = hostDaemonSock;
+    }
+    if (hostName) {
+      this.busData.agents[subscriber].host_name = hostName;
+    }
+    if (hostSessionId) {
+      this.busData.agents[subscriber].host_session_id = hostSessionId;
+    }
+    if (hostCapabilities) {
+      this.busData.agents[subscriber].host_capabilities = hostCapabilities;
+    }
+
     const terminalApp = options.terminalApp || detectTerminalAppFromEnv();
     if (terminalApp) {
       this.busData.agents[subscriber].terminal_app = terminalApp;

package/src/chat/commandExecutor.js

@@ -29,6 +29,19 @@ function defaultResolveTerminalApp() {
   return "";
 }
 
+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;
+}
+
 async function withCapturedConsole(capture, fn) {
   const originalLog = console.log;
   const originalError = console.error;
@@ -445,6 +458,7 @@ function createCommandExecutor(options = {}) {
         count: Number.isFinite(count) ? count : 1,
         nickname,
         launch_scope: launchScope,
+        ...collectHostLaunchRequestContext(),
       };
       const terminalApp = String(resolveTerminalApp() || "").trim().toLowerCase();
       if (terminalApp === "terminal" || terminalApp === "iterm2") {
@@ -1126,4 +1140,5 @@ function createCommandExecutor(options = {}) {
 
 module.exports = {
   createCommandExecutor,
+  collectHostLaunchRequestContext,
 };

package/src/chat/index.js

@@ -44,7 +44,7 @@ const { createDaemonCoordinator } = require("./daemonCoordinator");
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonTransport } = require("./daemonTransport");
-const { listProjectRuntimes } = require("../projects/registry");
+const { listProjectRuntimes, resolveRuntimeDir } = require("../projects/registry");
 const { canonicalProjectRoot, buildProjectId } = require("../projects/projectId");
 const {
   sortProjectRuntimes,
@@ -725,7 +725,7 @@ async function runChat(projectRoot, options = {}) {
     if (!terminalAdapterRouter) return null;
     const meta = activeAgentMetaMap ? activeAgentMetaMap.get(agentId) : null;
     const agentLaunchMode = (meta && meta.launch_mode) || launchMode || "";
-    return terminalAdapterRouter.getAdapter({ launchMode: agentLaunchMode, agentId });
+    return terminalAdapterRouter.getAdapter({ launchMode: agentLaunchMode, agentId, meta });
   }
 
   function getViewingAgentAdapter() {
@@ -1999,6 +1999,32 @@ async function runChat(projectRoot, options = {}) {
       requestStatus();
     }
   }, 5000);
+
+  // Global mode: watch runtime registry for new/removed projects
+  if (globalMode) {
+    const runtimeDir = resolveRuntimeDir();
+    if (!fs.existsSync(runtimeDir)) {
+      fs.mkdirSync(runtimeDir, { recursive: true });
+    }
+    let runtimeWatchDebounce = null;
+    try {
+      const watcher = fs.watch(runtimeDir, () => {
+        if (runtimeWatchDebounce) return;
+        runtimeWatchDebounce = setTimeout(() => {
+          runtimeWatchDebounce = null;
+          const prevCount = projectRuntimes.length;
+          refreshProjectRuntimes();
+          if (projectRuntimes.length !== prevCount) {
+            renderDashboard();
+            screen.render();
+          }
+        }, 300);
+      });
+      screen.on("destroy", () => watcher.close());
+    } catch {
+      // Fallback: ignore if fs.watch not supported
+    }
+  }
   screen.on("resize", () => {
     if (handleResizeInAgentView()) {
       return;

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"
@@ -980,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(
@@ -1001,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);
@@ -1403,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({
@@ -1451,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/ops.js

@@ -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");
@@ -834,12 +973,14 @@ async function closeAgent(projectRoot, agentId) {
   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) {
       found = true;
+      meta = entry;
       const parsedPid = Number.parseInt(entry.pid, 10);
       pid = Number.isFinite(parsedPid) && parsedPid > 0 ? parsedPid : 0;
       launchMode = entry.launch_mode || "";
@@ -856,7 +997,7 @@ async function closeAgent(projectRoot, agentId) {
   }
 
   const adapterRouter = createTerminalAdapterRouter();
-  const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId });
+  const adapter = adapterRouter.getAdapter({ launchMode, agentId: resolvedId, meta });
   const canCloseWindow = process.platform === "darwin"
     && Boolean(adapter.capabilities.supportsWindowClose)
     && Boolean(tty);

package/src/daemon/status.js

@@ -149,7 +149,21 @@ function buildStatus(projectRoot, options = {}) {
     const tty = meta?.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 };
+    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 {

package/src/terminal/adapterRouter.js

@@ -6,6 +6,7 @@ const { createTerminalAdapter } = require("./adapters/terminalAdapter");
 const { createTmuxAdapter } = require("./adapters/tmuxAdapter");
 const { createInternalQueueAdapter } = require("./adapters/internalQueueAdapter");
 const { createInternalPtyAdapter } = require("./adapters/internalPtyAdapter");
+const { createHostAdapter } = require("./adapters/hostAdapter");
 
 function createTerminalAdapterRouter(options = {}) {
   const {
@@ -35,7 +36,7 @@ function createTerminalAdapterRouter(options = {}) {
   }
 
   function getAdapter(params = {}) {
-    const { launchMode = "", agentId = "" } = params;
+    const { launchMode = "", agentId = "", meta = null } = params;
 
     if (launchMode === "terminal") {
       return createTerminalAdapter({
@@ -53,6 +54,17 @@ function createTerminalAdapterRouter(options = {}) {
       });
     }
 
+    if (launchMode === "host") {
+      return createHostAdapter({
+        createAdapter,
+        injectSock: meta?.host_inject_sock || meta?.hostInjectSock || "",
+        daemonSock: meta?.host_daemon_sock || meta?.hostDaemonSock || "",
+        hostName: meta?.host_name || meta?.hostName || "",
+        sessionId: meta?.host_session_id || meta?.hostSessionId || "",
+        hostCapabilities: meta?.host_capabilities || meta?.hostCapabilities || null,
+      });
+    }
+
     if (launchMode === "internal-pty") {
       return createInternalPtyAdapter({
         sendRaw,

package/src/terminal/adapters/hostAdapter.js

@@ -0,0 +1,409 @@
+const { createTerminalCapabilities } = require("../adapterContract");
+const net = require("net");
+
+/**
+ * Mapping from host protocol command names to ufoo capability flags.
+ * When a host reports supporting a command, the corresponding capability is enabled.
+ */
+const COMMAND_TO_CAPABILITY = {
+  activate: "supportsActivate",
+  snapshot: "supportsSnapshot",
+  subscribe: "supportsSubscribeFull",
+  subscribe_screen: "supportsSubscribeScreen",
+  close_session: "supportsWindowClose",
+  notify: "supportsNotifierInjector",
+  replay: "supportsReplay",
+};
+
+/**
+ * Send a JSON request to a Unix socket and return the parsed response.
+ * Expects the unified envelope: {v, request_id, ok, result|error}
+ */
+function sendToSocket(sockPath, request, options = {}) {
+  return new Promise((resolve, reject) => {
+    if (!sockPath) {
+      reject(new Error("socket path not set"));
+      return;
+    }
+
+    const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+      ? options.timeoutMs
+      : 5000;
+
+    const client = net.createConnection(sockPath, () => {
+      client.write(JSON.stringify(request) + "\n");
+    });
+
+    let buffer = "";
+    const timeout = setTimeout(() => {
+      client.destroy();
+      reject(new Error("host socket timeout"));
+    }, timeoutMs);
+
+    client.on("data", (data) => {
+      buffer += data.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        clearTimeout(timeout);
+        try {
+          const res = JSON.parse(line);
+          client.end();
+          if (res.ok) {
+            resolve(res.result || {});
+          } else {
+            const err = new Error(res.error || "host request failed");
+            err.errorCode = res.error_code || "";
+            reject(err);
+          }
+        } catch (err) {
+          client.end();
+          reject(err);
+        }
+        return;
+      }
+    });
+
+    client.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+
+    client.on("close", () => {
+      clearTimeout(timeout);
+    });
+  });
+}
+
+function getInjectSock() {
+  return process.env.UFOO_HOST_INJECT_SOCK
+    || process.env.HORIZON_INJECT_SOCK  // deprecated fallback
+    || "";
+}
+
+function getDaemonSock() {
+  return process.env.UFOO_HOST_DAEMON_SOCK || "";
+}
+
+function normalizeHostValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeHostCapabilities(hostCapabilities) {
+  if (!hostCapabilities || typeof hostCapabilities !== "object") {
+    return null;
+  }
+  const normalized = { ...hostCapabilities };
+  const commands = Array.isArray(normalized.commands) ? normalized.commands : [];
+  const sessionCommands = Array.isArray(normalized.session_commands)
+    ? normalized.session_commands
+    : [];
+  if (commands.length === 0 && sessionCommands.length > 0) {
+    normalized.commands = [...sessionCommands];
+  } else {
+    normalized.commands = [...commands];
+  }
+  return normalized;
+}
+
+function clearDynamicCapabilities(capabilities) {
+  for (const flag of Object.values(COMMAND_TO_CAPABILITY)) {
+    if (flag in capabilities) {
+      capabilities[flag] = false;
+    }
+  }
+}
+
+/**
+ * Map host-reported commands array to ufoo capability flags.
+ * Mutates the capabilities object in-place.
+ */
+function applyHostCapabilities(capabilities, hostCommands) {
+  if (!Array.isArray(hostCommands)) return;
+  for (const cmd of hostCommands) {
+    const flag = COMMAND_TO_CAPABILITY[cmd];
+    if (flag && flag in capabilities) {
+      capabilities[flag] = true;
+    }
+  }
+}
+
+async function probeHostCapabilities(options = {}) {
+  const injectSock = normalizeHostValue(options.injectSock) || getInjectSock();
+  const daemonSock = normalizeHostValue(options.daemonSock) || getDaemonSock();
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+    ? options.timeoutMs
+    : 5000;
+
+  for (const sock of [injectSock, daemonSock]) {
+    if (!sock) continue;
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const result = await sendToSocket(sock, { type: "capabilities" }, { timeoutMs });
+      const normalized = normalizeHostCapabilities(result);
+      if (normalized) {
+        return normalized;
+      }
+    } catch {
+      // try next socket
+    }
+  }
+
+  return null;
+}
+
+/**
+ * ufoo Terminal Host adapter — connects to any terminal host's per-session
+ * inject socket via the ufoo Terminal Host Protocol.
+ *
+ * Detects UFOO_HOST_SESSION_ID and UFOO_HOST_INJECT_SOCK env vars.
+ * Works with any host that implements the protocol (Horizon, Warp, etc.).
+ *
+ * After connect(), capabilities are dynamically updated based on what
+ * the host reports in its capabilities handshake response.
+ */
+function createHostAdapter(options = {}) {
+  const {
+    createAdapter = () => {},
+    injectSock = "",
+    daemonSock = "",
+    hostName = "",
+    sessionId = "",
+    hostCapabilities: initialHostCapabilities = null,
+  } = options;
+
+  // Start with base capabilities; additional flags are set after connect()
+  const capabilities = createTerminalCapabilities({
+    supportsSocketProtocol: true,
+    supportsSessionReuse: true,
+  });
+
+  const explicitInjectSock = normalizeHostValue(injectSock);
+  const explicitDaemonSock = normalizeHostValue(daemonSock);
+  const explicitHostName = normalizeHostValue(hostName);
+  const explicitSessionId = normalizeHostValue(sessionId);
+  const seededHostCapabilities = normalizeHostCapabilities(initialHostCapabilities);
+
+  // Cached host capabilities from handshake
+  let hostCapabilities = seededHostCapabilities ? { ...seededHostCapabilities } : null;
+
+  function resolveInjectSock() {
+    return explicitInjectSock || getInjectSock();
+  }
+
+  function resolveDaemonSock() {
+    return explicitDaemonSock || getDaemonSock();
+  }
+
+  function resetCapabilitiesToSeed() {
+    clearDynamicCapabilities(capabilities);
+    if (seededHostCapabilities) {
+      applyHostCapabilities(capabilities, seededHostCapabilities.commands);
+      hostCapabilities = { ...seededHostCapabilities };
+    } else {
+      hostCapabilities = null;
+    }
+  }
+
+  resetCapabilitiesToSeed();
+
+  return createAdapter({
+    capabilities,
+    handlers: {
+      connect: async () => {
+        clearDynamicCapabilities(capabilities);
+        const result = await probeHostCapabilities({
+          injectSock: resolveInjectSock(),
+          daemonSock: resolveDaemonSock(),
+        });
+        if (result) {
+          hostCapabilities = result;
+          applyHostCapabilities(capabilities, result.commands);
+          return true;
+        }
+        resetCapabilitiesToSeed();
+        return false;
+      },
+      disconnect: async () => {
+        clearDynamicCapabilities(capabilities);
+        hostCapabilities = null;
+        return true;
+      },
+      send: (data) => {
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        sendToSocket(sock, { type: "inject", command: String(data) }).catch(() => {});
+        return true;
+      },
+      sendRaw: (data) => {
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        sendToSocket(sock, { type: "raw", data: String(data) }).catch(() => {});
+        return true;
+      },
+      resize: (cols, rows) => {
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        sendToSocket(sock, { type: "resize", cols, rows }).catch(() => {});
+        return true;
+      },
+      snapshot: () => {
+        if (!capabilities.supportsSnapshot) return false;
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        sendToSocket(sock, { type: "snapshot" }).catch(() => {});
+        return true;
+      },
+      subscribe: () => {
+        if (!capabilities.supportsSubscribeFull) return false;
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        sendToSocket(sock, { type: "subscribe" }).catch(() => {});
+        return true;
+      },
+      activate: async () => {
+        if (!capabilities.supportsActivate) return false;
+        const sock = resolveInjectSock();
+        if (!sock) return false;
+        try {
+          await sendToSocket(sock, { type: "activate" });
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      getState: () => ({
+        hostName: explicitHostName || process.env.UFOO_HOST_NAME || "",
+        sessionId: explicitSessionId || process.env.UFOO_HOST_SESSION_ID || process.env.HORIZON_SESSION_ID || "",
+        injectSock: resolveInjectSock(),
+        daemonSock: resolveDaemonSock(),
+        hostCapabilities,
+      }),
+    },
+  });
+}
+
+// --- Host command helpers (for callers that need async results) ---
+
+/**
+ * Request a terminal snapshot from the host.
+ * @param {string} [sockPath] - Override socket path
+ * @returns {Promise<{lines: string[], cols: number, rows: number, cursor?: {x: number, y: number}}>}
+ */
+async function requestSnapshot(sockPath) {
+  const sock = normalizeHostValue(sockPath) || getInjectSock();
+  return sendToSocket(sock, { type: "snapshot" });
+}
+
+/**
+ * Activate (focus) the host terminal window/tab.
+ * @param {string} [sockPath] - Override socket path
+ * @returns {Promise<{}>}
+ */
+async function requestActivate(sockPath) {
+  const sock = normalizeHostValue(sockPath) || getInjectSock();
+  return sendToSocket(sock, { type: "activate" });
+}
+
+/**
+ * Send a notification via the host.
+ * @param {string} message - Notification message
+ * @param {object} [opts] - Options: { title, urgency }
+ * @param {string} [sockPath] - Override socket path
+ * @returns {Promise<{}>}
+ */
+async function requestNotify(message, opts = {}, sockPath) {
+  const sock = normalizeHostValue(sockPath) || getInjectSock();
+  return sendToSocket(sock, { type: "notify", message, ...opts });
+}
+
+/**
+ * Close a terminal session via the inject socket.
+ * @param {string} [sockPath] - Override socket path
+ * @returns {Promise<{}>}
+ */
+async function requestCloseSession(sockPath) {
+  const sock = normalizeHostValue(sockPath) || getInjectSock();
+  return sendToSocket(sock, { type: "close_session" });
+}
+
+// --- Daemon lifecycle management (per-host, not per-session) ---
+
+/**
+ * Create a new terminal session via the daemon management socket.
+ * @param {string} [daemonSock] - Override daemon socket path (defaults to env)
+ * @param {object} [opts] - Options: { group_id, source_session_id }
+ * @returns {Promise<{session_id: string, inject_sock: string}>}
+ */
+async function createSession(daemonSock, opts = {}) {
+  const sock = normalizeHostValue(daemonSock) || getDaemonSock();
+  const req = { type: "create_session" };
+  if (opts.group_id) req.group_id = opts.group_id;
+  if (opts.source_session_id) req.source_session_id = opts.source_session_id;
+  return sendToSocket(sock, req);
+}
+
+/**
+ * List all terminal sessions via the daemon management socket.
+ * @param {string} [daemonSock] - Override daemon socket path
+ * @returns {Promise<{sessions: Array<{session_id: string, inject_sock: string}>}>}
+ */
+async function listSessions(daemonSock) {
+  const sock = normalizeHostValue(daemonSock) || getDaemonSock();
+  return sendToSocket(sock, { type: "list_sessions" });
+}
+
+/**
+ * Close a terminal session via the daemon management socket.
+ * @param {string} sessionId - Session to close
+ * @param {string} [daemonSock] - Override daemon socket path
+ * @returns {Promise<{}>}
+ */
+async function closeSession(sessionId, daemonSock) {
+  const sock = normalizeHostValue(daemonSock) || getDaemonSock();
+  return sendToSocket(sock, { type: "close_session", session_id: sessionId });
+}
+
+/**
+ * Query host capabilities via the daemon management socket.
+ * @param {string} [daemonSock] - Override daemon socket path
+ * @returns {Promise<object>}
+ */
+async function queryCapabilities(daemonSock) {
+  const sock = normalizeHostValue(daemonSock) || getDaemonSock();
+  return sendToSocket(sock, { type: "capabilities" });
+}
+
+/**
+ * Ping the daemon management socket.
+ * @param {string} [daemonSock] - Override daemon socket path
+ * @returns {Promise<{pong: true}>}
+ */
+async function pingDaemon(daemonSock) {
+  const sock = normalizeHostValue(daemonSock) || getDaemonSock();
+  return sendToSocket(sock, { type: "ping" });
+}
+
+module.exports = {
+  createHostAdapter,
+  // Host command helpers (async, for direct use)
+  requestSnapshot,
+  requestActivate,
+  requestNotify,
+  requestCloseSession,
+  // Daemon lifecycle API
+  createSession,
+  listSessions,
+  closeSession,
+  queryCapabilities,
+  pingDaemon,
+  // For testing
+  sendToSocket,
+  COMMAND_TO_CAPABILITY,
+  applyHostCapabilities,
+  clearDynamicCapabilities,
+  normalizeHostCapabilities,
+  probeHostCapabilities,
+};