u-foo 1.5.0 → 1.7.0

package/src/agent/ufooAgent.js

@@ -10,6 +10,7 @@ const {
   resolveAnthropicMessagesUrl,
 } = require("../code/nativeRunner");
 const { DEFAULT_ASSISTANT_TIMEOUT_MS } = require("../assistant/constants");
+const { normalizeAgentTypeAlias } = require("../bus/utils");
 
 function loadSessionState(projectRoot) {
   const dir = getUfooPaths(projectRoot).agentDir;
@@ -28,13 +29,166 @@ function saveSessionState(projectRoot, state) {
   fs.writeFileSync(path.join(dir, "ufoo-agent.json"), JSON.stringify(state, null, 2));
 }
 
+function toReportAgentSnapshot(value = {}) {
+  const last = value && typeof value.last === "object" ? value.last : null;
+  return {
+    agent_id: String(value && value.agent_id ? value.agent_id : ""),
+    pending_count: Number(value && value.pending_count ? value.pending_count : 0) || 0,
+    updated_at: String(value && value.updated_at ? value.updated_at : ""),
+    last: last
+      ? {
+        phase: String(last.phase || ""),
+        task_id: String(last.task_id || ""),
+        ok: last.ok !== false,
+      }
+      : null,
+  };
+}
+
+function isBusyActivityState(value = "") {
+  const state = String(value || "").trim().toLowerCase();
+  return state === "working" || state === "starting" || state === "running"
+    || state === "waiting_input" || state === "blocked";
+}
+
+function clipPromptText(value = "", maxChars = 240) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}...[truncated]`;
+}
+
+function resolveHistoryAgentId(rawTarget, activeIdSet, nicknames) {
+  const target = String(rawTarget || "").trim();
+  if (!target) return "";
+  if (target === "*" || target === "broadcast") return "";
+  if (activeIdSet.has(target)) return target;
+  if (nicknames[target]) return nicknames[target];
+
+  const targetAlias = normalizeAgentTypeAlias(target);
+  if (!targetAlias) return "";
+
+  const matches = [];
+  for (const id of activeIdSet) {
+    const prefix = String(id).split(":")[0] || "";
+    const alias = normalizeAgentTypeAlias(prefix);
+    if (alias === targetAlias) matches.push(id);
+  }
+  return matches.length === 1 ? matches[0] : "";
+}
+
+function buildAgentPromptHistory(projectRoot, agents = [], nicknames = {}, options = {}) {
+  const perAgentLimit = Number.isFinite(options.perAgentLimit) && options.perAgentLimit > 0
+    ? Math.floor(options.perAgentLimit)
+    : 6;
+  const maxFiles = Number.isFinite(options.maxFiles) && options.maxFiles > 0
+    ? Math.floor(options.maxFiles)
+    : 3;
+  const eventsDir = getUfooPaths(projectRoot).busEventsDir;
+  const activeIds = new Set((Array.isArray(agents) ? agents : []).map((item) => String(item.id || "")).filter(Boolean));
+  if (activeIds.size === 0) {
+    return { per_agent: [], scanned_files: 0, matched_events: 0 };
+  }
+
+  const entries = new Map();
+  for (const item of agents) {
+    if (!item || !item.id) continue;
+    entries.set(item.id, {
+      agent_id: String(item.id),
+      nickname: String(item.nickname || ""),
+      samples: [],
+      sample_count: 0,
+      total_count: 0,
+      first_ts: "",
+      last_ts: "",
+    });
+  }
+
+  let files = [];
+  try {
+    files = fs
+      .readdirSync(eventsDir)
+      .filter((name) => name.endsWith(".jsonl"))
+      .sort()
+      .slice(-maxFiles)
+      .reverse();
+  } catch {
+    return { per_agent: [], scanned_files: 0, matched_events: 0 };
+  }
+
+  let matchedEvents = 0;
+  for (const file of files) {
+    let lines = [];
+    try {
+      const raw = fs.readFileSync(path.join(eventsDir, file), "utf8");
+      lines = raw.split(/\r?\n/).filter(Boolean).reverse();
+    } catch {
+      continue;
+    }
+
+    for (const line of lines) {
+      let evt = null;
+      try {
+        evt = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!evt || evt.event !== "message") continue;
+      const targetAgentId = resolveHistoryAgentId(evt.target, activeIds, nicknames);
+      if (!targetAgentId) continue;
+      const prompt = evt.data && typeof evt.data.message === "string"
+        ? clipPromptText(evt.data.message)
+        : "";
+      if (!prompt) continue;
+
+      const row = entries.get(targetAgentId);
+      if (!row) continue;
+      matchedEvents += 1;
+      row.total_count += 1;
+      const ts = String(evt.timestamp || evt.ts || "");
+      if (!row.last_ts) row.last_ts = ts;
+      row.first_ts = ts || row.first_ts;
+      if (row.samples.length < perAgentLimit) {
+        row.samples.push({
+          ts,
+          publisher: String(evt.publisher || ""),
+          prompt,
+        });
+        row.sample_count = row.samples.length;
+      }
+    }
+  }
+
+  const perAgent = Array.from(entries.values())
+    .filter((row) => row.total_count > 0)
+    .sort((a, b) => {
+      const left = String(a.last_ts || "");
+      const right = String(b.last_ts || "");
+      return right.localeCompare(left);
+    });
+
+  return {
+    per_agent: perAgent,
+    scanned_files: files.length,
+    matched_events: matchedEvents,
+  };
+}
+
 function loadBusSummary(projectRoot, maxLines = 20) {
-  // Use daemon's buildStatus as the single source of truth
+  // Use daemon's buildStatus as the single source of truth.
   let agents = [];
   let nicknames = {};
+  let reports = { pending_total: 0, agents: [] };
+  let promptHistory = { per_agent: [], scanned_files: 0, matched_events: 0 };
+  let summary = {
+    active_count: 0,
+    busy_count: 0,
+    ready_count: 0,
+    pending_total: 0,
+  };
   try {
     const status = buildStatus(projectRoot);
-    const activeMeta = status.active_meta || [];
+    const activeMeta = Array.isArray(status && status.active_meta) ? status.active_meta : [];
     agents = activeMeta.map((item) => {
       const nickname = item.nickname || "";
       if (nickname) {
@@ -42,16 +196,45 @@ function loadBusSummary(projectRoot, maxLines = 20) {
       }
       return {
         id: item.id,
+        nickname,
         status: "active",
         online: true,
-        agent_type: "", // Not included in active_meta, but not needed
-        nickname,
-        last_heartbeat: "",
+        launch_mode: String(item.launch_mode || ""),
+        activity_state: String(item.activity_state || ""),
+        activity_since: String(item.activity_since || ""),
       };
     });
+
+    const reportState = status && status.reports && typeof status.reports === "object"
+      ? status.reports
+      : {};
+    const reportAgents = Array.isArray(reportState.agents)
+      ? reportState.agents.slice(0, 50).map((item) => toReportAgentSnapshot(item))
+      : [];
+    reports = {
+      pending_total: Number(reportState.pending_total || 0) || 0,
+      agents: reportAgents,
+    };
+
+    const busyCount = agents.filter((item) => isBusyActivityState(item.activity_state)).length;
+    summary = {
+      active_count: agents.length,
+      busy_count: busyCount,
+      ready_count: Math.max(agents.length - busyCount, 0),
+      pending_total: reports.pending_total,
+    };
+    promptHistory = buildAgentPromptHistory(projectRoot, agents, nicknames);
   } catch {
     agents = [];
     nicknames = {};
+    reports = { pending_total: 0, agents: [] };
+    promptHistory = { per_agent: [], scanned_files: 0, matched_events: 0 };
+    summary = {
+      active_count: 0,
+      busy_count: 0,
+      ready_count: 0,
+      pending_total: 0,
+    };
   }
 
   const eventsDir = getUfooPaths(projectRoot).busEventsDir;
@@ -74,7 +257,7 @@ function loadBusSummary(projectRoot, maxLines = 20) {
     recent = [];
   }
 
-  return { agents, nicknames, recent };
+  return { agents, nicknames, reports, agent_prompt_history: promptHistory, summary, recent };
 }
 
 function buildSystemPrompt(context) {
@@ -106,6 +289,9 @@ function buildSystemPrompt(context) {
     "- Use top-level assistant_call for project exploration, temporary shell tasks, and quick execution support.",
     "- assistant_call fields: kind (explore|bash|mixed), task (required), context/expect (optional), provider (codex|claude|ufoo, optional), model/timeout_ms (optional).",
     "- Prefer assistant_call over launching coding agents when the task is short-lived.",
+    "- Primary routing signal is semantic continuity from agent_prompt_history; prefer the agent that already handled similar prompts.",
+    "- Launch a new coding agent when the request is a new topic without clear ownership in existing histories.",
+    "- If best-matching target agent is busy, keep routing to that same agent (queue semantics) instead of rerouting only by idle status.",
     "- Legacy compatibility: if model emits ops.assistant_call, daemon will still process it.",
     "- If no action needed, return reply with empty dispatch/ops.",
     agentGuidance,

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/message.js

@@ -7,6 +7,7 @@ const {
   appendJSONL,
   readLastLine,
   isPidAlive,
+  normalizeAgentTypeAlias,
 } = require("./utils");
 const NicknameManager = require("./nickname");
 
@@ -14,15 +15,6 @@ const SEQ_LOCK_TIMEOUT_MS = 5000;
 const SEQ_LOCK_POLL_MS = 25;
 const SEQ_LOCK_STALE_MS = 30000;
 
-function normalizeAgentTypeAlias(value = "") {
-  const text = String(value || "").trim().toLowerCase();
-  if (!text) return "";
-  if (text === "codex") return "codex";
-  if (text === "claude" || text === "claude-code") return "claude-code";
-  if (text === "ufoo" || text === "ucode" || text === "ufoo-code") return "ufoo-code";
-  return text;
-}
-
 /**
  * 消息管理器
  */

package/src/bus/subscriber.js

@@ -197,11 +197,29 @@ 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,
       nickname: finalNickname,
       status: "active",
+      activity_state: "starting",
+      activity_since: getTimestamp(),
       joined_at: existingMeta?.joined_at || getTimestamp(),
       last_seen: getTimestamp(),
       pid: overridePid || getJoinedPid(),
@@ -211,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/bus/utils.js

@@ -331,7 +331,17 @@ function isMetaActive(meta) {
   return false;
 }
 
+function normalizeAgentTypeAlias(value = "") {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text) return "";
+  if (text === "codex") return "codex";
+  if (text === "claude" || text === "claude-code") return "claude-code";
+  if (text === "ufoo" || text === "ucode" || text === "ufoo-code") return "ufoo-code";
+  return text;
+}
+
 module.exports = {
+  normalizeAgentTypeAlias,
   getTimestamp,
   getDate,
   generateInstanceId,

package/src/chat/agentBar.js

@@ -1,5 +1,16 @@
 const { stripAnsi, truncateAnsi } = require("./text");
 
+const ACTIVITY_INDICATORS = {
+  working: "*",
+  waiting_input: "?",
+  blocked: "!",
+};
+
+const ACTIVITY_COLORS = {
+  waiting_input: "\x1b[33m", // yellow
+  blocked: "\x1b[31m",       // red
+};
+
 function computeAgentBar(options = {}) {
   const {
     cols = 80,
@@ -11,6 +22,7 @@ function computeAgentBar(options = {}) {
     agentListWindowStart = 0,
     maxAgentWindow = 4,
     getAgentLabel = (id) => id,
+    agentStates = {},
   } = options;
 
   const hintAnsi = `\x1b[90m│ ${hintText}\x1b[0m`;
@@ -60,12 +72,18 @@ function computeAgentBar(options = {}) {
       agentParts = visible.map((agent, i) => {
         const rawLabel = getAgentLabel(agent);
         const label = maxLabelLen ? truncateLabel(rawLabel, maxLabelLen) : rawLabel;
+        const actState = agentStates[agent] || "";
+        const indicator = ACTIVITY_INDICATORS[actState] || "";
+        const indicatorColor = ACTIVITY_COLORS[actState] || "";
+        const prefix = indicator
+          ? `${indicatorColor}${indicator}\x1b[0m`
+          : "";
         const idx = s + i + 1; // +1 for ucode at index 0
         if (focusMode === "dashboard" && idx === selectedAgentIndex) {
-          return `\x1b[90;7m${label}\x1b[0m`;
+          return `${prefix}\x1b[90;7m${label}\x1b[0m`;
         }
-        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
-        return `\x1b[36m${label}\x1b[0m`;
+        if (agent === viewingAgent) return `${prefix}\x1b[1;36m${label}\x1b[0m`;
+        return `${prefix}\x1b[36m${label}\x1b[0m`;
       });
     }
     const agentsText = activeAgents.length > 0

package/src/chat/agentViewController.js

@@ -16,6 +16,7 @@ function createAgentViewController(options = {}) {
     getAgentListWindowStart = () => 0,
     setAgentListWindowStart = () => {},
     getAgentLabel = (id) => id,
+    getAgentStates = () => ({}),
     setDashboardView = () => {},
     setScreenGrabKeys = (value) => {
       if (screen) screen.grabKeys = Boolean(value);
@@ -79,6 +80,7 @@ function createAgentViewController(options = {}) {
       agentListWindowStart: getAgentListWindowStart(),
       maxAgentWindow,
       getAgentLabel,
+      agentStates: getAgentStates(),
     });
     setAgentListWindowStart(computed.windowStart);
     processStdout.write(`\x1b7\x1b[${rows};1H${computed.bar}\x1b8`);

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/daemonConnection.js

@@ -7,6 +7,7 @@ function createDaemonConnection(options = {}) {
     queueStatusLine,
     resolveStatusLine,
     logMessage,
+    switchConnectionTimeoutMs = 18000,
   } = options;
 
   let connectClient = connectClientOption;
@@ -16,6 +17,35 @@ function createDaemonConnection(options = {}) {
   let connectionLostNotified = false;
   const pendingRequests = [];
   const MAX_PENDING_REQUESTS = 50;
+  const STATUS_KEY_RECONNECT = "daemon-reconnect";
+  const STATUS_KEY_SWITCH = "daemon-switch";
+  const DEFAULT_SWITCH_TIMEOUT_MS = Number.isFinite(switchConnectionTimeoutMs)
+    && switchConnectionTimeoutMs > 0
+    ? Math.trunc(switchConnectionTimeoutMs)
+    : 18000;
+
+  function withTimeout(promiseLike, timeoutMs, timeoutMessage) {
+    const ms = Number.isFinite(timeoutMs) && timeoutMs > 0
+      ? Math.trunc(timeoutMs)
+      : DEFAULT_SWITCH_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const err = new Error(timeoutMessage || `operation timed out after ${ms}ms`);
+        err.code = "UFOO_TIMEOUT";
+        reject(err);
+      }, ms);
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+      Promise.resolve(promiseLike).then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+      }, (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
 
   function enqueueRequest(req) {
     if (!req || req.type === IPC_REQUEST_TYPES.STATUS) return;
@@ -91,18 +121,18 @@ function createDaemonConnection(options = {}) {
     if (client && !client.destroyed) return true;
     if (exitRequested) return false;
     if (reconnectPromise) return reconnectPromise;
-    queueStatusLine("Reconnecting to daemon");
+    queueStatusLine("Reconnecting to daemon", { key: STATUS_KEY_RECONNECT });
     logMessage("status", "{white-fg}⚙{/white-fg} Reconnecting to daemon...");
     reconnectPromise = (async () => {
       const newClient = await connectClient();
       if (!newClient) {
-        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline");
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline", { key: STATUS_KEY_RECONNECT });
         logMessage("error", "{white-fg}✗{/white-fg} Failed to reconnect to daemon");
         return false;
       }
       attachClient(newClient);
       connectionLostNotified = false;
-      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected");
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected", { key: STATUS_KEY_RECONNECT });
       requestStatus();
       return true;
     })();
@@ -130,9 +160,17 @@ function createDaemonConnection(options = {}) {
     }
     const previousClient = client;
     try {
-      queueStatusLine("Switching daemon connection");
-      const nextClient = await nextConnectClient();
+      queueStatusLine("Switching daemon connection", { key: STATUS_KEY_SWITCH });
+      const timeoutMs = Number.isFinite(next.timeoutMs) && next.timeoutMs > 0
+        ? Math.trunc(next.timeoutMs)
+        : DEFAULT_SWITCH_TIMEOUT_MS;
+      const nextClient = await withTimeout(
+        nextConnectClient(),
+        timeoutMs,
+        `Switch connection timed out after ${timeoutMs}ms`
+      );
       if (!nextClient) {
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed", { key: STATUS_KEY_SWITCH });
         return { ok: false, error: "Failed to connect target daemon" };
       }
       connectClient = nextConnectClient;
@@ -140,7 +178,7 @@ function createDaemonConnection(options = {}) {
       if (next.callRequestStatus !== false) {
         requestStatus();
       }
-      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon switched");
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon switched", { key: STATUS_KEY_SWITCH });
       return { ok: true };
     } catch (err) {
       // Keep existing connection alive on switch failures.
@@ -148,7 +186,7 @@ function createDaemonConnection(options = {}) {
         client = previousClient;
       }
       const message = err && err.message ? err.message : String(err || "switch failed");
-      resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed");
+      resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed", { key: STATUS_KEY_SWITCH });
       logMessage("error", `{white-fg}✗{/white-fg} ${message}`);
       return { ok: false, error: message };
     }