u-foo 2.3.25 → 2.3.27

package/package.json

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

package/src/agent/activityStatePublisher.js

@@ -7,6 +7,10 @@ const { writeActivityState } = require("./activityStateWriter");
  * Encapsulates the "write to disk + broadcast event" pattern used by
  * ptyRunner, launcher, notifier, and internalRunner.
  *
+ * Dedupe key is `state|detail` so that within the same canonical state
+ * (e.g. `working`) callers can publish detail transitions like
+ * `thinking` → `tool bash` and have them propagate to the dashboard.
+ *
  * @param {object} options
  * @param {string} options.agentsFile  - Path to all-agents.json
  * @param {string} options.subscriber  - Subscriber ID (e.g. "claude-code:abc123")
@@ -22,16 +26,23 @@ function createActivityStatePublisher(options = {}) {
   } = options;
 
   let lastState = "";
+  let lastDetail = "";
 
   function publish(state, extra = {}, publishOptions = {}) {
-    if (state === lastState) return false;
+    const detail = typeof extra.detail === "string" ? extra.detail : "";
+    if (state === lastState && detail === lastDetail) return false;
     const since = extra.since || undefined;
     const effectiveForce = typeof publishOptions.force === "boolean"
       ? publishOptions.force
       : force;
-    const changed = writeActivityState(agentsFile, subscriber, state, { since, force: effectiveForce });
+    const changed = writeActivityState(agentsFile, subscriber, state, {
+      since,
+      force: effectiveForce,
+      detail,
+    });
     if (!changed) return false;
     lastState = state;
+    lastDetail = detail;
     // Write to bus events directory for daemon bridge to pick up.
     // Writes directly to events dir to avoid queueing into subscriber pending files.
     try {
@@ -51,7 +62,7 @@ function createActivityStatePublisher(options = {}) {
           subscriber,
           state,
           previous: extra.previous || "",
-          ...extra.detail ? { detail: extra.detail } : {},
+          ...detail ? { detail } : {},
         },
       };
       fs.appendFileSync(eventFile, JSON.stringify(entry) + "\n");
@@ -65,7 +76,11 @@ function createActivityStatePublisher(options = {}) {
     return lastState;
   }
 
-  return { publish, getLastState };
+  function getLastDetail() {
+    return lastDetail;
+  }
+
+  return { publish, getLastState, getLastDetail };
 }
 
 module.exports = { createActivityStatePublisher };

package/src/agent/activityStateWriter.js

@@ -4,14 +4,18 @@ const { appendAgentRegistryDiagnostic } = require("../ufoo/agentRegistryDiagnost
 
 /**
  * Centralized helper for writing activity_state to all-agents.json.
- * Used by both ptyRunner and notifier to avoid duplicated read-modify-write logic.
  *
- * - Only writes when state actually changes (monotonic activity_since).
+ * - Writes when `state` OR `detail` changes (state change refreshes `activity_since`,
+ *   detail-only change keeps the existing `activity_since` so the "busy duration"
+ *   shown in dashboards stays continuous across e.g. `working · thinking` →
+ *   `working · tool bash`).
  * - Respects priority: won't overwrite working/waiting_input/blocked with idle
- *   unless explicitly requested via `force` option.
+ *   unless explicitly requested via `force` option. Detail-only updates within
+ *   the same state are always allowed.
  */
 function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
   const { since, force = false } = options;
+  const detail = typeof options.detail === "string" ? options.detail : "";
   try {
     if (!agentsFilePath || !fs.existsSync(agentsFilePath)) return false;
     const data = readJSON(agentsFilePath, null);
@@ -26,21 +30,33 @@ function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
       return false;
     }
 
-    const current = data.agents[subscriber].activity_state;
+    const agent = data.agents[subscriber];
+    const currentState = agent.activity_state;
+    const currentDetail = typeof agent.activity_detail === "string" ? agent.activity_detail : "";
 
-    // Skip if state unchanged (monotonic update)
-    if (current === state) return false;
+    if (currentState === state && currentDetail === detail) return false;
 
-    // Don't overwrite higher-priority states with lower-priority states
-    // unless force is set (e.g. explicit markIdle from ptyRunner/launcher)
-    if (!force && (current === "working" || current === "waiting_input" || current === "blocked")) {
+    if (
+      currentState !== state
+      && !force
+      && (currentState === "working" || currentState === "waiting_input" || currentState === "blocked")
+    ) {
       if (state === "idle" || state === "ready") return false;
     }
 
-    data.agents[subscriber].activity_state = state;
-    data.agents[subscriber].activity_since = since
-      ? new Date(since).toISOString()
-      : new Date().toISOString();
+    agent.activity_state = state;
+    if (detail) {
+      agent.activity_detail = detail;
+    } else {
+      delete agent.activity_detail;
+    }
+    if (currentState !== state) {
+      agent.activity_since = since
+        ? new Date(since).toISOString()
+        : new Date().toISOString();
+    } else if (!agent.activity_since) {
+      agent.activity_since = new Date().toISOString();
+    }
     writeJSON(agentsFilePath, data);
     return true;
   } catch {

package/src/agent/activityTracker.js

@@ -0,0 +1,147 @@
+"use strict";
+
+/**
+ * Generic agent activity tracker.
+ *
+ * Maps high-level lifecycle hooks and normalized provider stream events to the
+ * canonical activity model (`starting`/`ready`/`working`/`idle`/`waiting_input`/`blocked`)
+ * plus a short detail string (e.g. `thinking`, `tool bash`). Publishes through
+ * an injected publisher so the same tracker can be reused by internal,
+ * internal-pty, or future runner shapes.
+ *
+ * Design contract:
+ *  - The tracker never reads PTY text or guesses state from prose. All state
+ *    transitions come from explicit hook calls (`notify*`, `request*`,
+ *    `mark*`) or from normalized provider events.
+ *  - Detail is best-effort: callers can override it on `notifyTurnStart` /
+ *    `markIdle` if they want a custom phrasing.
+ *  - The tracker stays passive about `waiting_input` and `blocked`. They are
+ *    intentionally exposed as explicit methods (`requestUserInput`,
+ *    `markBlocked`) and have no auto-trigger from the provider stream — those
+ *    states should only fire from structured runtime signals.
+ */
+function createActivityTracker({ publisher } = {}) {
+  if (!publisher || typeof publisher.publish !== "function") {
+    throw new Error("createActivityTracker requires a publisher with publish()");
+  }
+
+  let currentState = "";
+  let currentDetail = "";
+  let currentTurnId = "";
+
+  function emit(state, detail = "", publishOptions = {}) {
+    const normalizedDetail = String(detail || "");
+    if (state === currentState && normalizedDetail === currentDetail) return false;
+    const previous = currentState;
+    const ok = publisher.publish(state, {
+      detail: normalizedDetail,
+      previous,
+    }, publishOptions);
+    if (!ok) return false;
+    currentState = state;
+    currentDetail = normalizedDetail;
+    return true;
+  }
+
+  function compactToolName(name) {
+    const trimmed = String(name || "").trim();
+    if (!trimmed) return "tool";
+    if (trimmed.length <= 32) return trimmed;
+    return `${trimmed.slice(0, 29)}...`;
+  }
+
+  function notifyStarting(detail = "runner") {
+    emit("starting", detail);
+  }
+
+  function notifyReady(detail = "") {
+    emit("ready", detail);
+  }
+
+  function notifyTurnStart(detail = "thinking") {
+    emit("working", detail);
+  }
+
+  function markIdle(detail = "") {
+    emit("idle", detail, { force: true });
+  }
+
+  function requestUserInput(reason = "") {
+    emit("waiting_input", reason);
+  }
+
+  function clearUserInput(detail = "") {
+    if (currentState !== "waiting_input") return;
+    emit("idle", detail, { force: true });
+  }
+
+  function markBlocked(reason = "") {
+    emit("blocked", reason);
+  }
+
+  function onProviderEvent(event = {}) {
+    const type = event && typeof event === "object" ? String(event.type || "") : "";
+    if (!type) return;
+
+    if (type === "thread_started") {
+      // Provider acknowledged the thread; wait for the first turn to flip to working.
+      return;
+    }
+
+    if (type === "turn_started") {
+      currentTurnId = String(event.turnId || event.turn_id || "");
+      emit("working", "thinking");
+      return;
+    }
+
+    if (type === "text_delta") {
+      // First text delta on a turn that didn't emit turn_started still counts as working.
+      if (currentState !== "working") {
+        emit("working", "thinking");
+      }
+      return;
+    }
+
+    if (type === "tool_call") {
+      emit("working", `tool ${compactToolName(event.name)}`);
+      return;
+    }
+
+    if (type === "tool_result") {
+      // Keep `tool <name>` until the next event (text_delta or another tool_call)
+      // shifts the detail. This avoids a flap back to `thinking` for a single frame.
+      return;
+    }
+
+    if (type === "turn_completed") {
+      currentTurnId = "";
+      emit("idle", "", { force: true });
+      return;
+    }
+
+    if (type === "turn_failed") {
+      currentTurnId = "";
+      // Default policy: drop back to idle. Callers that want `blocked` semantics
+      // for unrecoverable failures should call markBlocked() explicitly.
+      emit("idle", "", { force: true });
+    }
+  }
+
+  function getState() {
+    return { state: currentState, detail: currentDetail, turnId: currentTurnId };
+  }
+
+  return {
+    notifyStarting,
+    notifyReady,
+    notifyTurnStart,
+    markIdle,
+    requestUserInput,
+    clearUserInput,
+    markBlocked,
+    onProviderEvent,
+    getState,
+  };
+}
+
+module.exports = { createActivityTracker };

package/src/agent/internalRunner.js

@@ -5,6 +5,7 @@ const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
 const { readJSON, writeJSON } = require("../bus/utils");
 const { createActivityStatePublisher } = require("./activityStatePublisher");
+const { createActivityTracker } = require("./activityTracker");
 const { loadConfig, normalizeCodexInternalThreadMode } = require("../config");
 const { createCodexThreadProvider } = require("./codexThreadProvider");
 const { createClaudeThreadProvider } = require("./claudeThreadProvider");
@@ -305,7 +306,8 @@ async function handleEvent(
   busSender,
   extraArgs = [],
   threadRuntime = null,
-  bootstrapText = ""
+  bootstrapText = "",
+  tracker = null
 ) {
   if (!evt || !evt.data || !evt.data.message) return;
   const memoryPrefix = buildMemoryPrefix(projectRoot);
@@ -333,6 +335,7 @@ async function handleEvent(
       emitStreamDelta,
       streamToPublisher,
       threadRuntime,
+      tracker,
     });
     return;
   }
@@ -349,6 +352,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,
@@ -358,20 +382,32 @@ async function handleThreadedEvent({
   emitStreamDelta,
   streamToPublisher = true,
   threadRuntime,
+  tracker = null,
 }) {
   try {
     const plainReplyParts = [];
+    if (tracker && typeof tracker.notifyTurnStart === "function") {
+      tracker.notifyTurnStart();
+    }
     for await (const event of threadRuntime.thread.runStreamed(prompt, {})) {
       if (!event || typeof event !== "object") continue;
       if (typeof threadRuntime.syncProviderSessionId === "function") {
         threadRuntime.syncProviderSessionId();
       }
+      if (tracker && typeof tracker.onProviderEvent === "function") {
+        tracker.onProviderEvent(event);
+      }
       if (event.type === "text_delta" && event.delta) {
         if (streamToPublisher) {
           emitStreamDelta(event.delta);
         } 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}`);
       }
@@ -394,6 +430,9 @@ async function handleThreadedEvent({
     if (threadRuntime && typeof threadRuntime.rebuildThread === "function") {
       await threadRuntime.rebuildThread();
     }
+    if (tracker && typeof tracker.markIdle === "function") {
+      tracker.markIdle();
+    }
     const errorText = `[internal:${agentType}] error: ${err && err.message ? err.message : "unknown error"}`;
     // eslint-disable-next-line no-console
     console.error(errorText);
@@ -731,10 +770,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
   const activityPublisher = createActivityStatePublisher({
     agentsFile, subscriber, projectRoot,
   });
-
-  function setActivityState(state) {
-    activityPublisher.publish(state);
-  }
+  const activityTracker = createActivityTracker({ publisher: activityPublisher });
 
   function getInteractiveSession(publisher) {
     const key = String(publisher || "unknown");
@@ -748,7 +784,12 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
     return session;
   }
 
-  setActivityState("ready");
+  activityTracker.notifyStarting("runner");
+  if (threadRuntime && threadRuntime.enabled) {
+    activityTracker.notifyReady(provider || "");
+  } else {
+    activityTracker.notifyReady("");
+  }
 
   // 心跳更新函数
   const updateHeartbeat = () => {
@@ -809,7 +850,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
           }
 
           if (runnableEvents.length > 0) {
-            setActivityState("working");
+            activityTracker.notifyTurnStart("thinking");
           }
 
           for (const evt of runnableEvents) {
@@ -825,7 +866,8 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
               busSender,
               bootstrap.extraArgs,
               threadRuntime,
-              bootstrap.promptText
+              bootstrap.promptText,
+              activityTracker
             );
             if (evt.__agentViewRaw) {
               getInteractiveSession(evt.publisher || "unknown").writeResponsePrompt();
@@ -835,7 +877,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
           updateHeartbeat();
           lastHeartbeat = now;
           if (runnableEvents.length > 0) {
-            setActivityState("idle");
+            activityTracker.markIdle();
           }
           await busSender.flush();
         }
@@ -854,6 +896,7 @@ module.exports = {
   runInternalRunner,
   createBusSender,
   handleEvent,
+  handleThreadedEvent,
   createThreadRuntime,
   getCodexThreadMode,
   getWorkerThreadToolMode,

package/src/agent/launchEnvironment.js

@@ -0,0 +1,64 @@
+"use strict";
+
+/**
+ * Detect the launch environment for a ufoo agent.
+ *
+ * Output is the canonical `mode` plus an optional `terminalApp` hint when the
+ * mode is `terminal` (used by the inject layer to pick AppleScript flavor).
+ *
+ * Detection rules, evaluated top-to-bottom (first match wins):
+ *
+ *   0. `UFOO_LAUNCH_MODE` is a non-`auto` canonical value → trust it (short-circuit).
+ *   1. `TMUX_PANE` is set                                 → tmux.
+ *   2. `UFOO_HOST_SESSION_ID` is set                      → host.
+ *   3. `TERM_PROGRAM === "Apple_Terminal"`                → terminal / Apple_Terminal.
+ *   4. `TERM_PROGRAM === "iTerm.app"` or `ITERM_SESSION_ID` set → terminal / iterm2.
+ *   5. Fallback                                            → terminal (no app hint).
+ *
+ * Host is detected by env var alone here; callers that want to override host
+ * with native-terminal evidence (e.g. daemon ops auto-resolution) layer that
+ * on top of the detector's output.
+ * Internal / internal-pty modes are always set explicitly by the daemon when
+ * spawning worker processes (see ptyRunner / daemon ops), so they fall through
+ * the explicit short-circuit and never need to be auto-detected here.
+ */
+
+const CANONICAL_LAUNCH_MODES = Object.freeze([
+  "terminal",
+  "tmux",
+  "host",
+  "internal",
+  "internal-pty",
+]);
+
+const CANONICAL_LAUNCH_MODE_SET = new Set(CANONICAL_LAUNCH_MODES);
+
+function detectLaunchEnvironment(env = process.env) {
+  const explicit = String(env.UFOO_LAUNCH_MODE || "").trim();
+  if (explicit && explicit !== "auto" && CANONICAL_LAUNCH_MODE_SET.has(explicit)) {
+    return { mode: explicit, terminalApp: "", source: "explicit" };
+  }
+
+  if (env.TMUX_PANE) {
+    return { mode: "tmux", terminalApp: "", source: "auto" };
+  }
+
+  if (env.UFOO_HOST_SESSION_ID) {
+    return { mode: "host", terminalApp: "", source: "auto" };
+  }
+
+  const termProgram = String(env.TERM_PROGRAM || "").trim();
+  if (termProgram === "Apple_Terminal") {
+    return { mode: "terminal", terminalApp: "Apple_Terminal", source: "auto" };
+  }
+  if (termProgram === "iTerm.app" || env.ITERM_SESSION_ID) {
+    return { mode: "terminal", terminalApp: "iterm2", source: "auto" };
+  }
+
+  return { mode: "terminal", terminalApp: "", source: "auto" };
+}
+
+module.exports = {
+  detectLaunchEnvironment,
+  CANONICAL_LAUNCH_MODES,
+};

package/src/agent/launcher.js

@@ -10,6 +10,7 @@ const { showBanner } = require("../utils/banner");
 const AgentNotifier = require("./notifier");
 const { ActivityDetector } = require("./activityDetector");
 const { createActivityStatePublisher } = require("./activityStatePublisher");
+const { detectLaunchEnvironment } = require("./launchEnvironment");
 const { getUfooPaths } = require("../ufoo/paths");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { probeHostCapabilities } = require("../terminal/adapters/hostAdapter");
@@ -191,18 +192,7 @@ 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";
+  return detectLaunchEnvironment().mode;
 }
 
 function shouldShowLaunchBanner(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/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");
@@ -1315,6 +1316,7 @@ async function runChat(projectRoot, options = {}) {
             ...currentMeta,
             activity_state: diskState,
             activity_since: currentMeta.activity_since || diskMeta.activity_since || "",
+            activity_detail: currentMeta.activity_detail || diskMeta.activity_detail || "",
           });
         }
       }
@@ -1340,7 +1342,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 +1543,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 +1675,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 +1685,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/ops.js

@@ -15,6 +15,7 @@ const {
   createSession: createHostSession,
 } = require("../terminal/adapters/hostAdapter");
 const { resolveDefaultManualBootstrap } = require("../agent/defaultBootstrap");
+const { detectLaunchEnvironment } = require("../agent/launchEnvironment");
 
 function normalizeLaunchAgent(agent = "") {
   const value = String(agent || "").trim().toLowerCase();
@@ -167,9 +168,19 @@ function resolveConfiguredLaunchMode(configuredMode = "", options = {}) {
   if (mode === "internal" || mode === "internal-pty" || mode === "tmux" || mode === "terminal" || mode === "host") {
     return mode;
   }
-  if (process.env.TMUX_PANE) return "tmux";
-  const hostContext = resolveHostLaunchContext(options);
+  // Auto mode: defer to the unified detector. Daemon ops differs from the
+  // launcher in two ways: host context can also arrive via `options`, and
+  // when running under a native terminal app we want to override a stale
+  // env-level UFOO_HOST_SESSION_ID. Both are handled here, on top of the
+  // detector's output.
+  const detected = detectLaunchEnvironment().mode;
+  if (detected === "tmux") return "tmux";
   const nativeTerminalApp = resolveNativeTerminalApp(options);
+  if (detected === "host") {
+    if (nativeTerminalApp) return "terminal";
+    return "host";
+  }
+  const hostContext = resolveHostLaunchContext(options);
   if (hostContext.hostDaemonSock && !nativeTerminalApp) return "host";
   return "terminal";
 }

package/src/daemon/status.js

@@ -155,6 +155,7 @@ function buildStatus(projectRoot, options = {}) {
     const tty = meta?.tty || "";
     const activity_state = meta?.activity_state || "";
     const activity_since = meta?.activity_since || "";
+    const activity_detail = meta?.activity_detail || "";
     return {
       id,
       nickname,
@@ -166,6 +167,7 @@ function buildStatus(projectRoot, options = {}) {
       tty,
       activity_state,
       activity_since,
+      activity_detail,
       host_inject_sock: meta?.host_inject_sock || "",
       host_daemon_sock: meta?.host_daemon_sock || "",
       host_name: meta?.host_name || "",