u-foo 2.3.26 → 2.3.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.3.26",
+  "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;
   }
@@ -379,14 +382,21 @@ 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);
@@ -420,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);
@@ -757,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");
@@ -774,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 = () => {
@@ -835,7 +850,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
           }
 
           if (runnableEvents.length > 0) {
-            setActivityState("working");
+            activityTracker.notifyTurnStart("thinking");
           }
 
           for (const evt of runnableEvents) {
@@ -851,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();
@@ -861,7 +877,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex", extraArgs =
           updateHeartbeat();
           lastHeartbeat = now;
           if (runnableEvents.length > 0) {
-            setActivityState("idle");
+            activityTracker.markIdle();
           }
           await busSender.flush();
         }
@@ -880,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/index.js

@@ -1316,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 || "",
           });
         }
       }

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 || "",