u-foo 2.3.24 → 2.3.26

package/package.json

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

package/src/agent/internalRunner.js

@@ -349,6 +349,27 @@ async function handleEvent(
   await busSender.flush();
 }
 
+function compactToolDetail(value = "", maxLength = 120) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+
+function summarizeThreadToolCall(event = {}) {
+  const name = String(event.name || event.tool || event.tool_name || "tool").trim() || "tool";
+  const args = event.args && typeof event.args === "object" ? event.args : {};
+  const detail = args.command
+    || args.cmd
+    || args.code
+    || args.path
+    || args.file
+    || args.target
+    || args.query
+    || "";
+  return [name, compactToolDetail(detail)].filter(Boolean).join(" · ");
+}
+
 async function handleThreadedEvent({
   agentType,
   provider,
@@ -372,6 +393,11 @@ async function handleThreadedEvent({
         } else {
           plainReplyParts.push(String(event.delta));
         }
+      } else if (event.type === "tool_call") {
+        const summary = summarizeThreadToolCall(event);
+        if (streamToPublisher && summary) {
+          emitStreamDelta(`\nTool: ${summary}\n`);
+        }
       } else if (event.type === "turn_failed") {
         throw new Error(event.error || `thread turn failed for ${agentType}`);
       }

package/src/chat/agentViewController.js

@@ -3,6 +3,12 @@ const { version: packageVersion } = require("../../package.json");
 
 const ANSI_RESET = "\x1b[0m";
 const CLAUDE_ORANGE = "\x1b[38;2;217;119;87m";
+const BUS_STATUS_INDICATORS = {
+  working: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  starting: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  waiting_input: ["∙", "∙∙", "∙∙∙", "∙∙", "∙"],
+  blocked: ["!"],
+};
 
 function createAgentViewController(options = {}) {
   const {
@@ -11,6 +17,8 @@ function createAgentViewController(options = {}) {
     processStdout = process.stdout,
     now = () => Date.now(),
     setTimeoutFn = setTimeout,
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval,
     computeAgentBar = () => ({ bar: "", windowStart: 0 }),
     agentBarHints = { normal: "", dashboard: "" },
     maxAgentWindow = 4,
@@ -23,6 +31,7 @@ function createAgentViewController(options = {}) {
     setAgentListWindowStart = () => {},
     getAgentLabel = (id) => id,
     getAgentStates = () => ({}),
+    getAgentActivityMeta = () => ({}),
     getProjectRoot = () => process.cwd(),
     setDashboardView = () => {},
     setScreenGrabKeys = (value) => {
@@ -62,6 +71,10 @@ function createAgentViewController(options = {}) {
   let busStartupAgentId = "";
   let busStartupLineCount = 0;
   let busAgentReplyActive = false;
+  let busStatusInterval = null;
+  let busStatusIndex = 0;
+  let busStatusKey = "";
+  let busStatusLocalStartedAt = 0;
   const originalRender = screen.render.bind(screen);
   let renderFrozen = false;
 
@@ -202,6 +215,130 @@ function createAgentViewController(options = {}) {
     return hasAnsi(text) ? fitAnsiText(text, normalizedWidth) : plainLine(text, normalizedWidth);
   }
 
+  function parseTimeMs(value) {
+    if (Number.isFinite(value)) return Number(value);
+    const text = String(value || "").trim();
+    if (!text) return NaN;
+    const parsed = Date.parse(text);
+    return Number.isFinite(parsed) ? parsed : NaN;
+  }
+
+  function formatElapsed(ms = 0) {
+    const totalSeconds = Math.max(0, Math.floor(Number(ms) / 1000));
+    return `${totalSeconds} s`;
+  }
+
+  function normalizeActivityState(value = "") {
+    const state = String(value || "").trim().toLowerCase();
+    if (state === "waiting") return "waiting_input";
+    if (state === "busy" || state === "processing") return "working";
+    return state;
+  }
+
+  function getActivityLabel(state = "") {
+    if (state === "working") return "working";
+    if (state === "waiting_input") return "waiting";
+    if (state === "blocked") return "blocked";
+    if (state === "starting") return "starting";
+    if (state === "idle" || state === "ready") return "ready";
+    return state || "ready";
+  }
+
+  function isTimedActivityState(state = "") {
+    return state === "working"
+      || state === "waiting_input"
+      || state === "blocked"
+      || state === "starting";
+  }
+
+  function asActivityObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  }
+
+  function pickActivityDetail(meta = {}) {
+    const candidates = [
+      meta.activity_detail,
+      meta.detail,
+      meta.status_text,
+      meta.command,
+      meta.tool_name,
+      meta.tool,
+    ];
+    return String(candidates.find((item) => String(item || "").trim()) || "").trim();
+  }
+
+  function getViewingAgentActivity() {
+    const states = getAgentStates() || {};
+    const stateEntry = viewingAgent && states ? states[viewingAgent] : "";
+    const stateObject = asActivityObject(stateEntry);
+    const meta = {
+      ...(stateObject || {}),
+      ...(asActivityObject(getAgentActivityMeta(viewingAgent)) || {}),
+    };
+    const state = normalizeActivityState(meta.activity_state || meta.state || (stateObject ? "" : stateEntry) || "");
+    const detail = pickActivityDetail(meta);
+    const sinceMs = parseTimeMs(meta.activity_since || meta.since || meta.updated_at || meta.updatedAt);
+    return { state: state || "ready", detail, sinceMs };
+  }
+
+  function resolveBusStatus() {
+    const activity = getViewingAgentActivity();
+    const state = activity.state || "ready";
+    const timed = isTimedActivityState(state);
+    const key = `${viewingAgent || ""}:${state}:${activity.detail || ""}`;
+    if (key !== busStatusKey) {
+      busStatusKey = key;
+      busStatusIndex = 0;
+      busStatusLocalStartedAt = now();
+    }
+    const startedAt = timed && Number.isFinite(activity.sinceMs)
+      ? activity.sinceMs
+      : busStatusLocalStartedAt;
+    return {
+      ...activity,
+      state,
+      label: getActivityLabel(state),
+      timed,
+      startedAt,
+    };
+  }
+
+  function buildBusStatusLine(width = 80, status = resolveBusStatus()) {
+    const normalizedWidth = Math.max(1, width);
+    const detail = status.detail ? ` · ${status.detail}` : "";
+    if (status.timed) {
+      const indicators = BUS_STATUS_INDICATORS[status.state] || BUS_STATUS_INDICATORS.working;
+      const indicator = indicators[busStatusIndex % indicators.length] || "";
+      const elapsed = formatElapsed(now() - status.startedAt);
+      return fitText(`${indicator} ${status.label} · ${elapsed}${detail}`, normalizedWidth);
+    }
+    if (normalizedWidth < 32) return fitText(`ufoo · ${status.label}`, normalizedWidth);
+    if (normalizedWidth < 48) return fitText(`ufoo · ${status.label} · Enter send`, normalizedWidth);
+    return fitText(`ufoo · ${status.label} · Enter send · Esc back${detail}`, normalizedWidth);
+  }
+
+  function stopBusStatusTimer() {
+    if (!busStatusInterval) return;
+    clearIntervalFn(busStatusInterval);
+    busStatusInterval = null;
+  }
+
+  function syncBusStatusTimer(status) {
+    const shouldTick = currentView === "agent" && agentViewUsesBus && status && status.timed;
+    if (!shouldTick) {
+      stopBusStatusTimer();
+      return;
+    }
+    if (busStatusInterval) return;
+    busStatusInterval = setIntervalFn(() => {
+      busStatusIndex += 1;
+      renderBusView();
+    }, 1000);
+    if (busStatusInterval && typeof busStatusInterval.unref === "function") {
+      busStatusInterval.unref();
+    }
+  }
+
   function sliceDisplayCells(text = "", startCell = 0, maxCells = 1) {
     const targetStart = Math.max(0, startCell);
     const targetWidth = Math.max(1, maxCells);
@@ -456,12 +593,16 @@ function createAgentViewController(options = {}) {
     const logContentTop = 1;
     const logContentBottom = Math.max(logContentTop, inputTop - 1);
     const logContentHeight = Math.max(1, logContentBottom - logContentTop + 1);
+    const status = resolveBusStatus();
+    const logRows = Math.max(0, logContentHeight - 1);
+    const statusRow = logContentTop + logRows;
 
     processStdout.write("\x1b[?25l");
-    const visibleLines = getWrappedBusLogLines(width).slice(-logContentHeight);
-    for (let i = 0; i < logContentHeight; i += 1) {
+    const visibleLines = getWrappedBusLogLines(width).slice(-logRows);
+    for (let i = 0; i < logRows; i += 1) {
       writeAt(logContentTop + i, logLine(visibleLines[i] || "", width));
     }
+    writeAt(statusRow, logLine(buildBusStatusLine(width, status), width));
 
     writeAt(inputTop, horizontalLine(width));
     const viewport = getBusInputViewport(width);
@@ -471,6 +612,7 @@ function createAgentViewController(options = {}) {
     renderAgentDashboard();
     const cursorCol = clamp(3 + viewport.cursorCol, 1, width);
     processStdout.write(`\x1b[${inputTop + 1};${cursorCol}H\x1b[?25h`);
+    syncBusStatusTimer(status);
   }
 
   function renderAgentDashboard() {
@@ -566,6 +708,7 @@ function createAgentViewController(options = {}) {
     agentViewUsesBus = false;
     agentOutputSuppressed = false;
     agentBarVisible = false;
+    stopBusStatusTimer();
     busInputValue = "";
     busInputCursor = 0;
     busLogLines = [];
@@ -871,6 +1014,16 @@ function createAgentViewController(options = {}) {
     }
   }
 
+  function refreshAgentView() {
+    if (currentView !== "agent") return false;
+    if (agentViewUsesBus) {
+      renderBusView();
+    } else {
+      renderAgentDashboard();
+    }
+    return true;
+  }
+
   function isAgentBarVisible() {
     return agentBarVisible;
   }
@@ -882,6 +1035,7 @@ function createAgentViewController(options = {}) {
     getAgentInputSuppressUntil,
     getAgentOutputSuppressed,
     setAgentOutputSuppressed,
+    refreshAgentView,
     isAgentBarVisible,
     renderAgentDashboard,
     setAgentBarVisible,

package/src/chat/commandExecutor.js

@@ -78,6 +78,14 @@ function collectHostLaunchRequestContext(env = process.env) {
   return context;
 }
 
+function collectTerminalLaunchRequestContext(resolveTerminalApp = defaultResolveTerminalApp) {
+  const terminalApp = String(resolveTerminalApp() || "").trim().toLowerCase();
+  if (terminalApp === "terminal" || terminalApp === "iterm2") {
+    return { terminal_app: terminalApp };
+  }
+  return {};
+}
+
 async function withCapturedConsole(capture, fn) {
   const originalLog = console.log;
   const originalError = console.error;
@@ -551,11 +559,8 @@ function createCommandExecutor(options = {}) {
         prompt_profile: promptProfile,
         launch_scope: launchScope,
         ...collectHostLaunchRequestContext(),
+        ...collectTerminalLaunchRequestContext(resolveTerminalApp),
       };
-      const terminalApp = String(resolveTerminalApp() || "").trim().toLowerCase();
-      if (terminalApp === "terminal" || terminalApp === "iterm2") {
-        request.terminal_app = terminalApp;
-      }
       send(request);
       schedule(requestStatus, 1000);
     } catch (err) {
@@ -696,6 +701,7 @@ function createCommandExecutor(options = {}) {
         prompt_profile: profile,
         launch_scope: launchScope,
         ...collectHostLaunchRequestContext(),
+        ...collectTerminalLaunchRequestContext(resolveTerminalApp),
       });
       schedule(requestStatus, 1000);
     } catch (err) {
@@ -1106,6 +1112,7 @@ function createCommandExecutor(options = {}) {
         instance,
         dry_run: dryRun,
         ...collectHostLaunchRequestContext(),
+        ...collectTerminalLaunchRequestContext(resolveTerminalApp),
       });
       schedule(requestStatus, 1000);
       return;
@@ -1638,4 +1645,5 @@ function createCommandExecutor(options = {}) {
 module.exports = {
   createCommandExecutor,
   collectHostLaunchRequestContext,
+  collectTerminalLaunchRequestContext,
 };

package/src/chat/daemonMessageRouter.js

@@ -76,7 +76,7 @@ function createDaemonMessageRouter(options = {}) {
       const key = typeof data.key === "string" ? data.key : "";
       if (isLikelySubscriberId(key)) {
         if (data.phase === BUS_STATUS_PHASES.START) {
-          setTransientAgentState(key, "working");
+          setTransientAgentState(key, "working", { detail: text });
         } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
           clearTransientAgentState(key);
         }
@@ -354,6 +354,18 @@ function createDaemonMessageRouter(options = {}) {
   function handleBusMessage(msg) {
     const data = msg.data || {};
     if (data.event === "activity_state_changed") {
+      const agentId = String(data.subscriber || data.publisher || "").trim();
+      const state = String(data.state || data.activity_state || "").trim();
+      const detailSource = data.detail || (data.data && data.data.detail) || data.message || "";
+      if (agentId && state) {
+        const normalized = state.toLowerCase();
+        if (normalized === "idle" || normalized === "ready") {
+          clearTransientAgentState(agentId);
+        } else {
+          setTransientAgentState(agentId, state, { detail: detailSource });
+        }
+        refreshDashboard();
+      }
       requestStatus();
       return true;
     }

package/src/chat/index.js

@@ -61,6 +61,7 @@ const { loadPromptProfileRegistry } = require("../group/promptProfiles");
 const {
   DEFAULT_TRANSIENT_AGENT_STATE_TTL_MS,
   setTransientAgentState: setTransientAgentStateValue,
+  getTransientAgentStateEntry,
   getTransientAgentState,
   pruneTransientAgentStates,
 } = require("./transientAgentState");
@@ -1340,7 +1341,11 @@ async function runChat(projectRoot, options = {}) {
           selectedAgentIndex = 0;
         }
       }
-      renderAgentDashboard();
+      if (agentViewController && typeof agentViewController.refreshAgentView === "function") {
+        agentViewController.refreshAgentView();
+      } else {
+        renderAgentDashboard();
+      }
       return;
     }
     if (focusMode === "dashboard") {
@@ -1537,13 +1542,39 @@ async function runChat(projectRoot, options = {}) {
     getAgentLabel,
     getAgentStates: () => {
       const states = {};
-      if (activeAgentMetaMap) {
-        for (const [id, meta] of activeAgentMetaMap) {
-          if (meta && meta.activity_state) states[id] = meta.activity_state;
+      for (const id of activeAgents) {
+        let state = "";
+        if (activeAgentMetaMap) {
+          const meta = activeAgentMetaMap.get(id);
+          if (meta && meta.activity_state) state = meta.activity_state;
+        }
+        if (!state) {
+          state = getTransientAgentState(transientAgentStateMap, id, {
+            ttlMs: DEFAULT_TRANSIENT_AGENT_STATE_TTL_MS,
+          });
         }
+        if (state) states[id] = state;
       }
       return states;
     },
+    getAgentActivityMeta: (agentId) => {
+      const id = String(agentId || "").trim();
+      const meta = activeAgentMetaMap && activeAgentMetaMap.get(id)
+        ? { ...activeAgentMetaMap.get(id) }
+        : {};
+      const transient = getTransientAgentStateEntry(transientAgentStateMap, id, {
+        ttlMs: DEFAULT_TRANSIENT_AGENT_STATE_TTL_MS,
+      });
+      if (transient) {
+        const previousState = meta.activity_state;
+        meta.activity_state = transient.state;
+        if ((!meta.activity_since || previousState !== transient.state) && Number.isFinite(transient.updatedAt)) {
+          meta.activity_since = new Date(transient.updatedAt).toISOString();
+        }
+        if (transient.detail) meta.activity_detail = transient.detail;
+      }
+      return meta;
+    },
     getProjectRoot: () => activeProjectRoot,
     setDashboardView: (value) => {
       dashboardView = value;
@@ -1643,9 +1674,9 @@ async function runChat(projectRoot, options = {}) {
     appendStreamDelta,
     finalizeStream,
     hasStream: (publisher) => streamTracker.hasStream(publisher),
-    setTransientAgentState: (agentId, state) => {
+    setTransientAgentState: (agentId, state, options) => {
       if (!agentId || !state) return;
-      setTransientAgentStateValue(transientAgentStateMap, agentId, state);
+      setTransientAgentStateValue(transientAgentStateMap, agentId, state, options);
     },
     clearTransientAgentState: (agentId) => {
       if (!agentId) return;
@@ -1653,7 +1684,11 @@ async function runChat(projectRoot, options = {}) {
     },
     refreshDashboard: () => {
       if (getCurrentView() === "agent") {
-        renderAgentDashboard();
+        if (agentViewController && typeof agentViewController.refreshAgentView === "function") {
+          agentViewController.refreshAgentView();
+        } else {
+          renderAgentDashboard();
+        }
         return;
       }
       renderDashboard();

package/src/chat/transientAgentState.js

@@ -6,23 +6,38 @@ function normalizeNow(now) {
   return Number.isFinite(now) ? now : Date.now();
 }
 
-function setTransientAgentState(store, agentId, state, now = Date.now()) {
+function normalizeSetOptions(nowOrOptions, detailArg = "") {
+  if (nowOrOptions && typeof nowOrOptions === "object") {
+    return {
+      now: normalizeNow(nowOrOptions.now),
+      detail: String(nowOrOptions.detail || "").trim(),
+    };
+  }
+  return {
+    now: normalizeNow(nowOrOptions),
+    detail: String(detailArg || "").trim(),
+  };
+}
+
+function setTransientAgentState(store, agentId, state, nowOrOptions = Date.now(), detailArg = "") {
   if (!(store instanceof Map)) return;
   const id = String(agentId || "").trim();
   const nextState = String(state || "").trim();
   if (!id || !nextState) return;
+  const options = normalizeSetOptions(nowOrOptions, detailArg);
   store.set(id, {
     state: nextState,
-    updatedAt: normalizeNow(now),
+    updatedAt: options.now,
+    detail: options.detail,
   });
 }
 
-function getTransientAgentState(store, agentId, options = {}) {
-  if (!(store instanceof Map)) return "";
+function getTransientAgentStateEntry(store, agentId, options = {}) {
+  if (!(store instanceof Map)) return null;
   const id = String(agentId || "").trim();
-  if (!id) return "";
+  if (!id) return null;
   const entry = store.get(id);
-  if (!entry) return "";
+  if (!entry) return null;
 
   const ttlMs = Number.isFinite(options.ttlMs)
     ? Math.max(0, Math.trunc(options.ttlMs))
@@ -32,16 +47,23 @@ function getTransientAgentState(store, agentId, options = {}) {
   const updatedAt = typeof entry === "object" && Number.isFinite(entry.updatedAt)
     ? entry.updatedAt
     : now;
+  const detail = typeof entry === "object" ? String(entry.detail || "").trim() : "";
 
   if (!state) {
     store.delete(id);
-    return "";
+    return null;
   }
   if (ttlMs > 0 && now - updatedAt > ttlMs) {
     store.delete(id);
-    return "";
+    return null;
   }
-  return state;
+  return { state, updatedAt, detail };
+}
+
+function getTransientAgentState(store, agentId, options = {}) {
+  const entry = getTransientAgentStateEntry(store, agentId, options);
+  if (!entry) return "";
+  return entry.state;
 }
 
 function pruneTransientAgentStates(store, activeAgentIds = [], options = {}) {
@@ -59,6 +81,7 @@ function pruneTransientAgentStates(store, activeAgentIds = [], options = {}) {
 module.exports = {
   DEFAULT_TRANSIENT_AGENT_STATE_TTL_MS,
   setTransientAgentState,
+  getTransientAgentStateEntry,
   getTransientAgentState,
   pruneTransientAgentStates,
 };

package/src/daemon/groupOrchestrator.js

@@ -242,11 +242,13 @@ function buildLaunchHostContext(params = {}) {
   const hostDaemonSock = asTrimmedString(params.host_daemon_sock || params.hostDaemonSock);
   const hostName = asTrimmedString(params.host_name || params.hostName);
   const hostSessionId = asTrimmedString(params.host_session_id || params.hostSessionId);
+  const terminalApp = asTrimmedString(params.terminal_app || params.terminalApp);
   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;
+  if (terminalApp) context.terminal_app = terminalApp;
   if (params.host_capabilities && typeof params.host_capabilities === "object") {
     context.host_capabilities = { ...params.host_capabilities };
   } else if (params.hostCapabilities && typeof params.hostCapabilities === "object") {

package/src/daemon/index.js

@@ -1753,6 +1753,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
       const hostDaemonSock = req.host_daemon_sock || req.hostDaemonSock || "";
       const hostName = req.host_name || req.hostName || "";
       const hostSessionId = req.host_session_id || req.hostSessionId || "";
+      const terminalApp = req.terminal_app || req.terminalApp || "";
       const hostCapabilities =
         req.host_capabilities && typeof req.host_capabilities === "object"
           ? req.host_capabilities
@@ -1768,6 +1769,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           host_daemon_sock: hostDaemonSock,
           host_name: hostName,
           host_session_id: hostSessionId,
+          terminal_app: terminalApp,
           host_capabilities: hostCapabilities,
         });
         const ok = result && result.ok !== false;

package/src/daemon/ops.js

@@ -152,14 +152,25 @@ function resolveHostLaunchContext(options = {}) {
   };
 }
 
+function resolveNativeTerminalApp(options = {}) {
+  const explicit = normalizeTerminalAppPreference(options.terminalApp);
+  if (explicit) return explicit;
+
+  const termProgram = normalizeTerminalAppPreference(process.env.TERM_PROGRAM || "");
+  if (termProgram) return termProgram;
+  if (process.env.ITERM_SESSION_ID) return "iterm2";
+  return "";
+}
+
 function resolveConfiguredLaunchMode(configuredMode = "", options = {}) {
   const mode = normalizeOptionalString(configuredMode);
   if (mode === "internal" || mode === "internal-pty" || mode === "tmux" || mode === "terminal" || mode === "host") {
     return mode;
   }
-  const hostContext = resolveHostLaunchContext(options);
-  if (hostContext.hostDaemonSock) return "host";
   if (process.env.TMUX_PANE) return "tmux";
+  const hostContext = resolveHostLaunchContext(options);
+  const nativeTerminalApp = resolveNativeTerminalApp(options);
+  if (hostContext.hostDaemonSock && !nativeTerminalApp) return "host";
   return "terminal";
 }
 
@@ -1303,4 +1314,14 @@ async function closeAgent(projectRoot, agentId) {
   };
 }
 
-module.exports = { launchAgent, closeAgent, getRecoverableAgents, resumeAgents };
+module.exports = {
+  launchAgent,
+  closeAgent,
+  getRecoverableAgents,
+  resumeAgents,
+  __private: {
+    resolveConfiguredLaunchMode,
+    resolveHostLaunchContext,
+    resolveNativeTerminalApp,
+  },
+};