u-foo 1.5.0 → 1.7.0

package/README.md

@@ -111,6 +111,26 @@ ucode-core run-once --json
 ucode-core list --json
 ```
 
+## Global Chat (`ufoo -g`)
+
+Use `ufoo -g` (or `ufoo --global`) to launch a cross-project chat dashboard. Instead of being scoped to a single project, global mode connects to all running ufoo daemons and lets you switch between projects on the fly.
+
+```bash
+$ ufoo -g
+
+> /project list          # List all running project daemons
+> /project switch 2      # Switch to project #2
+> /launch claude scope=inplace   # Launch agent in current context
+> @claude-1 Start reviewing the auth module
+```
+
+| Command | Description |
+|---------|-------------|
+| `/project list` | List running projects from global runtime registry |
+| `/project switch <index\|path>` | Switch active project daemon connection |
+| `/launch <agent> scope=inplace` | Launch agent in current workspace |
+| `/launch <agent> scope=window` | Launch agent in separate terminal window |
+
 ## Agent Configuration
 
 Configure AI providers in `.ufoo/config.json`:
@@ -187,6 +207,7 @@ Bus state lives in `.ufoo/agent/all-agents.json` (metadata), `.ufoo/bus/*` (queu
 |---------|-------------|
 | `ufoo` | Launch chat interface (default) |
 | `ufoo chat` | Launch interactive multi-agent chat UI |
+| `ufoo -g` | Launch global chat mode (cross-project dashboard) |
 | `ufoo init` | Initialize .ufoo in current project |
 | `ufoo status` | Show banner, unread bus messages, open decisions |
 | `ufoo doctor` | Check installation health |

package/README.zh-CN.md

@@ -111,6 +111,26 @@ ucode-core run-once --json
 ucode-core list --json
 ```
 
+## 全局聊天（`ufoo -g`）
+
+使用 `ufoo -g`（或 `ufoo --global`）启动跨项目聊天仪表盘。全局模式会连接所有正在运行的 ufoo 守护进程，支持在不同项目之间快速切换。
+
+```bash
+$ ufoo -g
+
+> /project list          # 列出所有运行中的项目守护进程
+> /project switch 2      # 切换到第 2 个项目
+> /launch claude scope=inplace   # 在当前上下文启动 Agent
+> @claude-1 开始审查 auth 模块
+```
+
+| 命令 | 说明 |
+|------|------|
+| `/project list` | 列出全局运行时注册的项目 |
+| `/project switch <序号\|路径>` | 切换活动项目的 daemon 连接 |
+| `/launch <agent> scope=inplace` | 在当前工作区启动 Agent |
+| `/launch <agent> scope=window` | 在独立终端窗口启动 Agent |
+
 ## Agent 配置
 
 在 `.ufoo/config.json` 中配置 AI 提供商：
@@ -187,6 +207,7 @@ Bus 状态存放于 `.ufoo/agent/all-agents.json`（元数据）、`.ufoo/bus/*`
 |------|------|
 | `ufoo` | 启动聊天界面（默认） |
 | `ufoo chat` | 启动交互式多 Agent 聊天 UI |
+| `ufoo -g` | 启动全局聊天模式（跨项目仪表盘） |
 | `ufoo init` | 在当前项目初始化 .ufoo |
 | `ufoo status` | 显示 banner、未读消息和未处理决策 |
 | `ufoo doctor` | 检查安装状态 |

package/modules/AGENTS.template.md

@@ -1,105 +1,7 @@
 <!-- ufoo -->
-## ufoo Protocol
+## ufoo Agent Protocol
 
-This project uses **ufoo** for agent coordination. Read the full documentation at `.ufoo/docs/` (symlinked from ufoo installation).
-
-### Core Principles
-
-1. **Agents are autonomous** - Execute tasks without asking for permission
-2. **Communication via bus** - Use `ufoo bus` for inter-agent messaging
-3. **Decisions are recorded** - Use `ufoo ctx` for decision tracking
-4. **Context is shared** - All agents read from `.ufoo/context/`
-
-### Available Commands
-
-| Command | Description |
-|---------|-------------|
-| `uinit` | Initialize/repair .ufoo directory |
-| `uctx` | Check context status and decisions |
-| `ustatus` | Unified status view (banner, unread bus, open decisions) |
-| `ubus` | Check bus messages and **auto-execute** them |
-
-### Quick Reference
-
-```bash
-# Context
-ufoo ctx decisions -l          # List all decisions
-ufoo ctx decisions -n 1        # Show latest decision
-
-# Bus
-SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"
-[ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)
-ufoo bus check $SUBSCRIBER     # Check pending messages
-ufoo bus send "<id>" "<msg>"   # Send message
-ufoo bus status                # Show bus status
-
-# Runtime report (shared contract for assistant/ucodex/uclaude)
-ufoo report start "<task>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report progress "<detail>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report done "<summary>" --task <id> --agent "$SUBSCRIBER" --scope public
-ufoo report error "<reason>" --task <id> --agent "$SUBSCRIBER" --scope public
-```
-
----
-
-## ufoo context Protocol
-
-On session start, check context status:
-```bash
-ufoo ctx decisions -l
-ufoo ctx decisions -n 1
-```
-
-Key files in `.ufoo/context/`:
-- `decisions/` - Decision log (append-only)
-
-**Decision recording policy — "If it has information value, write it down":**
-
-Record a decision whenever your work produces knowledge that would be useful to your future self, other agents, or the user. The threshold is LOW — when in doubt, record it.
-
-- **Always record**: architectural choices, trade-off analysis, research findings, non-obvious gotchas, naming/convention changes, external API behavior discovered, performance observations, bug root causes
-- **Also record**: open questions you couldn't resolve, assumptions you made, approaches you considered and rejected (with reasons), edge cases noticed but not handled
-- **Write the decision BEFORE acting on it** — if your session dies, the knowledge survives
-- **Granularity**: A decision can be one sentence ("X doesn't support Y, use Z instead") or a multi-page analysis. Match the depth to the information value.
-
-```bash
-ufoo ctx decisions new "Short descriptive title"
-# Then edit the created file with Context/Decision/Implications
-```
-
----
-
-## ufoo bus Protocol
-
-### CRITICAL: `ubus` Command Behavior
-
-**When you receive `ubus`, you MUST:**
-1. Resolve subscriber ID first (reuse existing ID, join only as fallback):
-   `SUBSCRIBER="${UFOO_SUBSCRIBER_ID:-$(ufoo bus whoami 2>/dev/null || true)}"; [ -n "$SUBSCRIBER" ] || SUBSCRIBER=$(ufoo bus join | tail -1)`
-2. Check pending messages: `ufoo bus check $SUBSCRIBER`
-3. **EXECUTE each task immediately** - Do NOT ask the user
-4. Reply to sender: `ufoo bus send "<publisher>" "<result>"`
-5. **CRITICAL: Acknowledge messages after handling**: `ufoo bus ack $SUBSCRIBER`
-
-**Rules:**
-- Execute tasks immediately without asking
-- Always reply to the sender
-- Do NOT ask "Want me to...?" or "Should I...?"
-- Do NOT wait for user confirmation
-
-### Message Format
-
-```
-@you from claude-code:abc123
-Type: message/targeted
-Content: {"message":"Please analyze the project structure"}
-```
-
-Extract sender ID from "from" field, use it to reply.
-
-### Example
-
-1. Receive: `@you from claude-code:bd36dda0 Content: {"message":"Please analyze the project structure"}`
-2. Execute: Analyze the project structure
-3. Reply: `ufoo bus send "claude-code:bd36dda0" "Project contains src/, modules/, bin/"`
+> **Record decisions before acting.** Any knowledge with information value → `ufoo ctx decisions new "Title"` BEFORE you act on it.
+> **Auto-execute bus messages.** On `ubus`: execute tasks immediately, reply to sender, then `ufoo bus ack`. Never ask the user.
+> **Full protocol**: `/ufoo` skill (auto-loaded on session start). Docs: `.ufoo/docs/`
 <!-- /ufoo -->

package/package.json

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

package/src/agent/activityDetector.js

@@ -0,0 +1,328 @@
+/**
+ * Agent Activity State Detector
+ * 持续监控 agent 启动后的活动状态（readyDetector 的补充）
+ *
+ * State machine:
+ *   STARTING → READY → WORKING ↔ IDLE
+ *                         ↓        ↑
+ *                   WAITING_INPUT --+
+ *                         ↓        ↑
+ *                      BLOCKED ----+
+ */
+
+const ACTIVITY_STATES = {
+  starting: "starting",
+  ready: "ready",
+  working: "working",
+  idle: "idle",
+  waiting_input: "waiting_input",
+  blocked: "blocked",
+};
+
+const DEFAULT_BUFFER_SIZE = 4000;
+const DEFAULT_TAIL_LINES = 10;
+const DEFAULT_BLOCKED_TIMEOUT_MS = 300000;
+const DEFAULT_INTERNAL_QUIET_MS = 3500;
+const DEFAULT_EXTERNAL_QUIET_MS = 5000;
+const ANSI_PATTERN = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const OSC_PATTERN = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+
+// Agent-specific patterns that indicate the agent is waiting for user input.
+// Patterns are anchored to prompt/question contexts to reduce false positives.
+const INPUT_PATTERNS = {
+  "claude-code": [
+    /\bAllow\b.*\bDeny\b/,            // Claude Code permission dialog: "Allow | Deny"
+    /\ballow mcp\b/i,                 // MCP tool approval prompt
+    /Enter to select.*\u2191\/\u2193 to navigate/, // Ink TUI interactive prompt navigation bar (permissions, AskUserQuestion, Plan approval)
+  ],
+  codex: [
+    /\[Y\/n\]/,                        // Bracket-style prompt
+    /\by\/n\b/i,                       // y/n prompt (common in confirmation dialogs)
+  ],
+};
+
+const COMMON_PATTERNS = [
+  /Continue\?\s*$/m,                   // Line-ending "Continue?"
+  /Proceed\?\s*$/m,                    // Line-ending "Proceed?"
+  /Press enter/i,                      // "Press enter to continue"
+  /\(y\/n\)\s*:?\s*$/m,               // "(y/n)" at line end
+];
+
+// Deny-list for per-line context around a matched prompt.
+// Prevents false positives from code output while avoiding global-buffer suppression.
+const LINE_DENY_CONTEXT_PATTERNS = [
+  /function\s+\w+/,                   // Function definition context
+  /\/\//,                             // Code comment
+  /import\s+/,                        // Import statement
+  /require\s*\(/,                     // Require statement
+];
+
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function getDefaultQuietWindowMs(mode) {
+  const normalized = String(mode || "").trim().toLowerCase();
+  if (normalized.includes("internal")) return DEFAULT_INTERNAL_QUIET_MS;
+  return DEFAULT_EXTERNAL_QUIET_MS;
+}
+
+class ActivityDetector {
+  /**
+   * @param {string} agentType - e.g. "claude-code", "codex"
+   * @param {object} [options]
+   * @param {string} [options.mode] - launch mode ("internal-pty"/"terminal"/"tmux"/"iterm2")
+   * @param {number} [options.bufferSize=4000] - rolling buffer size in chars
+   * @param {number} [options.tailLines=10] - number of tail lines used for quiet-time prompt detection
+   * @param {boolean} [options.startOnOutput=false] - allow STARTING -> WORKING on first output
+   * @param {number} [options.quietWindowMs] - output quiet window before WAITING_INPUT/IDLE classification
+   * @param {number} [options.blockedTimeoutMs=300000] - 5 min WAITING_INPUT → BLOCKED
+   */
+  constructor(agentType, options = {}) {
+    this.agentType = agentType;
+    this.mode = String(options.mode || "").trim().toLowerCase();
+    this.bufferSize = toPositiveInt(options.bufferSize, DEFAULT_BUFFER_SIZE);
+    this.tailLines = toPositiveInt(options.tailLines, DEFAULT_TAIL_LINES);
+    this.startOnOutput = options.startOnOutput === true;
+    this.blockedTimeoutMs = toPositiveInt(options.blockedTimeoutMs, DEFAULT_BLOCKED_TIMEOUT_MS);
+    const optionQuietMs = toPositiveInt(options.quietWindowMs, 0);
+    const envQuietMs = toPositiveInt(process.env.UFOO_ACTIVITY_QUIET_MS, 0);
+    this.quietWindowMs = optionQuietMs || envQuietMs || getDefaultQuietWindowMs(this.mode);
+
+    this.state = ACTIVITY_STATES.starting;
+    this.since = Date.now();
+    this.detail = "";
+    this.buffer = "";
+    this.callbacks = [];
+    this.blockedTimer = null;
+    this.quietTimer = null;
+    this.quietToken = 0;
+  }
+
+  /**
+   * Register a state-change callback: fn(newState, oldState, detail)
+   */
+  onChange(callback) {
+    this.callbacks.push(callback);
+  }
+
+  /**
+   * Transition to a new state (internal)
+   */
+  _setState(newState, detail = "") {
+    if (newState === this.state) return;
+    const oldState = this.state;
+    this.state = newState;
+    this.since = Date.now();
+    this.detail = detail;
+    for (const cb of this.callbacks) {
+      try {
+        cb(newState, oldState, detail);
+      } catch {
+        // ignore callback errors
+      }
+    }
+  }
+
+  /**
+   * STARTING → READY
+   */
+  markReady() {
+    if (this.state !== ACTIVITY_STATES.starting) return;
+    this._setState(ACTIVITY_STATES.ready);
+  }
+
+  /**
+   * any → WORKING
+   * - clears WAITING/BLOCKED timers
+   * - cancels pending quiet classification
+   * - resets buffer by default when coming from non-WORKING states
+   */
+  markWorking(options = {}) {
+    const hasResetFlag = Object.prototype.hasOwnProperty.call(options, "resetBuffer");
+    const resetBuffer = hasResetFlag ? Boolean(options.resetBuffer) : this.state !== ACTIVITY_STATES.working;
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    if (resetBuffer) {
+      this.buffer = "";
+    }
+    this._setState(ACTIVITY_STATES.working);
+  }
+
+  /**
+   * WORKING/WAITING_INPUT/BLOCKED → IDLE
+   * Allows recovery from stuck states when queue drains, marker hits, etc.
+   */
+  markIdle() {
+    if (this.state !== ACTIVITY_STATES.working
+      && this.state !== ACTIVITY_STATES.waiting_input
+      && this.state !== ACTIVITY_STATES.blocked) return;
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    this.buffer = "";
+    this._setState(ACTIVITY_STATES.idle);
+  }
+
+  /**
+   * Process PTY output.
+   * Any output (except STARTING) implies WORKING.
+   * WAITING_INPUT/IDLE are only classified after quiet window.
+   * @param {string} text - cleaned (ANSI-stripped) output text
+   */
+  processOutput(text) {
+    const normalized = this._normalizeOutput(text);
+    if (!normalized) return;
+    if (!this._hasMeaningfulOutput(normalized)) return;
+    if (this.state === ACTIVITY_STATES.starting) {
+      if (!this.startOnOutput) return;
+      this._setState(ACTIVITY_STATES.working, "output");
+    }
+
+    this.buffer += normalized;
+    // Rolling buffer: keep last N chars
+    if (this.buffer.length > this.bufferSize) {
+      this.buffer = this.buffer.slice(-this.bufferSize);
+    }
+
+    if (this.state !== ACTIVITY_STATES.working) {
+      this._clearBlockedTimer();
+      this._setState(ACTIVITY_STATES.working);
+    }
+    this._scheduleQuietClassification();
+  }
+
+  _normalizeOutput(text) {
+    if (!text) return "";
+    return String(text)
+      .replace(OSC_PATTERN, "")
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "\n")
+      .replace(ANSI_PATTERN, "");
+  }
+
+  _hasMeaningfulOutput(text) {
+    if (!text) return false;
+    const visible = String(text).replace(/[\s\u0000-\u001F\u007F]+/g, "");
+    return visible.length > 0;
+  }
+
+  _scheduleQuietClassification() {
+    this.quietToken += 1;
+    const quietToken = this.quietToken;
+    this._clearQuietTimer();
+    this.quietTimer = setTimeout(() => {
+      if (quietToken !== this.quietToken) return;
+      this.quietTimer = null;
+      this._classifyAfterQuietWindow();
+    }, this.quietWindowMs);
+    if (this.quietTimer && typeof this.quietTimer.unref === "function") {
+      this.quietTimer.unref();
+    }
+  }
+
+  _classifyAfterQuietWindow() {
+    if (this.state !== ACTIVITY_STATES.working) return;
+    const tailBuffer = this._tailWindow();
+
+    // Check agent-specific patterns only after output has stabilized.
+    const agentPatterns = INPUT_PATTERNS[this.agentType] || [];
+    const allPatterns = [...agentPatterns, ...COMMON_PATTERNS];
+    for (const pattern of allPatterns) {
+      const match = pattern.exec(tailBuffer);
+      if (!match) continue;
+      const matchedText = String(match[0] || "");
+      const matchIndex = Number.isFinite(match.index)
+        ? match.index
+        : Math.max(0, tailBuffer.length - matchedText.length);
+      if (this._hasDeniedContext(tailBuffer, matchIndex, matchedText.length)) continue;
+      this._setState(ACTIVITY_STATES.waiting_input, pattern.source);
+      this._startBlockedTimer();
+      return;
+    }
+
+    this._setState(ACTIVITY_STATES.idle);
+  }
+
+  _tailWindow() {
+    if (!this.buffer) return "";
+    const lines = this.buffer.split("\n");
+    if (lines.length <= this.tailLines) return this.buffer;
+    return lines.slice(-this.tailLines).join("\n");
+  }
+
+  _lineAt(haystack, index) {
+    const safeIndex = Math.max(0, Math.min(index, haystack.length));
+    const lineStart = haystack.lastIndexOf("\n", safeIndex - 1) + 1;
+    const lineEndCandidate = haystack.indexOf("\n", safeIndex);
+    const lineEnd = lineEndCandidate >= 0 ? lineEndCandidate : haystack.length;
+    return haystack.slice(lineStart, lineEnd);
+  }
+
+  _isInsideCodeFence(haystack, index) {
+    const before = haystack.slice(0, Math.max(0, index));
+    const fences = before.match(/```/g);
+    return (fences ? fences.length : 0) % 2 === 1;
+  }
+
+  _hasDeniedContext(haystack, matchIndex, matchLength = 0) {
+    if (this._isInsideCodeFence(haystack, matchIndex)) return true;
+    const centerIndex = Math.max(0, matchIndex + Math.max(0, Math.trunc(matchLength / 2)));
+    const line = this._lineAt(haystack, centerIndex);
+    return LINE_DENY_CONTEXT_PATTERNS.some((deny) => deny.test(line));
+  }
+
+  /**
+   * Start the WAITING_INPUT → BLOCKED timer
+   */
+  _startBlockedTimer() {
+    this._clearBlockedTimer();
+    this.blockedTimer = setTimeout(() => {
+      this.blockedTimer = null;
+      if (this.state === ACTIVITY_STATES.waiting_input) {
+        this._setState(ACTIVITY_STATES.blocked, `waiting_input for ${this.blockedTimeoutMs}ms`);
+      }
+    }, this.blockedTimeoutMs);
+    // Allow process to exit even if timer is pending
+    if (this.blockedTimer && typeof this.blockedTimer.unref === "function") {
+      this.blockedTimer.unref();
+    }
+  }
+
+  _clearBlockedTimer() {
+    if (this.blockedTimer) {
+      clearTimeout(this.blockedTimer);
+      this.blockedTimer = null;
+    }
+  }
+
+  _clearQuietTimer() {
+    if (this.quietTimer) {
+      clearTimeout(this.quietTimer);
+      this.quietTimer = null;
+    }
+  }
+
+  /**
+   * Get current state snapshot
+   */
+  getState() {
+    return {
+      state: this.state,
+      since: this.since,
+      detail: this.detail,
+    };
+  }
+
+  /**
+   * Clean up timers
+   */
+  destroy() {
+    this._clearBlockedTimer();
+    this._clearQuietTimer();
+    this.callbacks = [];
+  }
+}
+
+module.exports = { ACTIVITY_STATES, ActivityDetector };

package/src/agent/activityStatePublisher.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const { writeActivityState } = require("./activityStateWriter");
+
+/**
+ * Unified activity state publisher.
+ * Encapsulates the "write to disk + broadcast event" pattern used by
+ * ptyRunner, launcher, notifier, and internalRunner.
+ *
+ * @param {object} options
+ * @param {string} options.agentsFile  - Path to all-agents.json
+ * @param {string} options.subscriber  - Subscriber ID (e.g. "claude-code:abc123")
+ * @param {string} options.projectRoot - Project root (unused, kept for API compat)
+ * @param {boolean} [options.force=true] - Force overwrite priority-protected states
+ */
+function createActivityStatePublisher(options = {}) {
+  const {
+    agentsFile,
+    subscriber,
+    force = true,
+  } = options;
+
+  let lastState = "";
+
+  function publish(state, extra = {}) {
+    if (state === lastState) return false;
+    const since = extra.since || undefined;
+    const changed = writeActivityState(agentsFile, subscriber, state, { since, force });
+    if (!changed) return false;
+    lastState = state;
+    // Write to bus events directory for daemon bridge to pick up.
+    // Writes directly to events dir to avoid queueing into subscriber pending files.
+    try {
+      const eventsDir = path.join(
+        path.dirname(path.dirname(agentsFile)),
+        "bus", "events"
+      );
+      const date = new Date().toISOString().slice(0, 10);
+      const eventFile = path.join(eventsDir, `${date}.jsonl`);
+      const entry = {
+        timestamp: new Date().toISOString(),
+        type: "status/agent",
+        event: "activity_state_changed",
+        publisher: subscriber,
+        target: "*",
+        data: {
+          subscriber,
+          state,
+          previous: extra.previous || "",
+          ...extra.detail ? { detail: extra.detail } : {},
+        },
+      };
+      fs.appendFileSync(eventFile, JSON.stringify(entry) + "\n");
+    } catch {
+      // ignore event write errors — dashboard polling is the fallback
+    }
+    return true;
+  }
+
+  function getLastState() {
+    return lastState;
+  }
+
+  return { publish, getLastState };
+}
+
+module.exports = { createActivityStatePublisher };

package/src/agent/activityStateWriter.js

@@ -0,0 +1,40 @@
+const fs = require("fs");
+
+/**
+ * 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).
+ * - Respects priority: won't overwrite working/waiting_input/blocked with idle
+ *   unless explicitly requested via `force` option.
+ */
+function writeActivityState(agentsFilePath, subscriber, state, options = {}) {
+  const { since, force = false } = options;
+  try {
+    if (!agentsFilePath || !fs.existsSync(agentsFilePath)) return false;
+    const data = JSON.parse(fs.readFileSync(agentsFilePath, "utf8"));
+    if (!data.agents || !data.agents[subscriber]) return false;
+
+    const current = data.agents[subscriber].activity_state;
+
+    // Skip if state unchanged (monotonic update)
+    if (current === state) 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 (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();
+    fs.writeFileSync(agentsFilePath, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { writeActivityState };

package/src/agent/internalRunner.js

@@ -5,6 +5,7 @@ const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
 const { runCliAgent } = require("./cliRunner");
 const { normalizeCliOutput } = require("./normalizeOutput");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -220,6 +221,16 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
   process.on("SIGINT", stop);
 
   const cliSessionState = { cliSessionId, needsSave: false };
+  const agentsFile = getUfooPaths(projectRoot).agentsFile;
+  const activityPublisher = createActivityStatePublisher({
+    agentsFile, subscriber, projectRoot,
+  });
+
+  function setActivityState(state) {
+    activityPublisher.publish(state);
+  }
+
+  setActivityState("ready");
 
   // 心跳更新函数
   const updateHeartbeat = () => {
@@ -248,6 +259,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
       try {
         const lines = drainQueue(queueFile);
         if (lines.length > 0) {
+          setActivityState("working");
           const events = [];
           for (const line of lines) {
             try {
@@ -289,6 +301,7 @@ async function runInternalRunner({ projectRoot, agentType = "codex" }) {
           // 处理消息后更新心跳
           updateHeartbeat();
           lastHeartbeat = now;
+          setActivityState("idle");
         }
       } finally {
         processing = false;