u-foo 1.4.1 → 1.6.0

package/src/agent/notifier.js

@@ -6,6 +6,7 @@ const { getUfooPaths } = require("../ufoo/paths");
 const { shakeTerminalByTty } = require("../bus/shake");
 const { isITerm2 } = require("../terminal/detect");
 const iterm2 = require("../terminal/iterm2");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 /**
  * Agent 消息通知监听器
@@ -16,7 +17,11 @@ class AgentNotifier {
     this.projectRoot = projectRoot;
     this.subscriber = subscriber;
     this.interval = 2000; // 2秒轮询一次
+    this.workingHoldMs = Number.parseInt(process.env.UFOO_ACTIVITY_WORKING_HOLD_MS || "", 10) || 5000;
     this.lastCount = 0;
+    this.lastWorkingAt = 0;
+    this.injectFailCount = 0;
+    this.maxInjectRetries = 5;
     this.timer = null;
     this.stopped = false;
     this.autoTrigger = process.env.UFOO_AUTO_TRIGGER !== "0"; // 默认启用自动触发
@@ -37,6 +42,12 @@ class AgentNotifier {
     const busDir = paths.busDir;
     this.injector = new Injector(busDir, paths.agentsFile);
     this.eventBus = new EventBus(projectRoot);
+    this.activityPublisher = createActivityStatePublisher({
+      agentsFile: paths.agentsFile,
+      subscriber,
+      projectRoot,
+      force: false, // notifier is low-priority; don't overwrite working/waiting_input/blocked
+    });
   }
 
   isUfooCodeSubscriber() {
@@ -97,6 +108,36 @@ class AgentNotifier {
     }
   }
 
+  /**
+   * 更新 activity_state（terminal/tmux agent 基础支持）
+   * 基于消息投递推断 WORKING，无 pending 时推断 IDLE
+   */
+  updateActivityState(state) {
+    return this.activityPublisher.publish(state);
+  }
+
+  getCurrentActivityState() {
+    try {
+      if (!this.agentsFile || !fs.existsSync(this.agentsFile)) return "";
+      const data = JSON.parse(fs.readFileSync(this.agentsFile, "utf8"));
+      const meta = data.agents && data.agents[this.subscriber];
+      return meta && typeof meta.activity_state === "string"
+        ? String(meta.activity_state).trim().toLowerCase()
+        : "";
+    } catch {
+      return "";
+    }
+  }
+
+  isBusyState(state = "") {
+    const value = String(state || "").trim().toLowerCase();
+    return value === "working"
+      || value === "starting"
+      || value === "running"
+      || value === "waiting_input"
+      || value === "blocked";
+  }
+
   /**
    * 获取当前队列中的消息数量
    */
@@ -191,14 +232,29 @@ class AgentNotifier {
       return 0;
     }
 
+    const activityState = this.getCurrentActivityState();
+    if (this.isBusyState(activityState)) {
+      return 0;
+    }
+
+    // Back off on consecutive inject failures to avoid tight retry loop
+    if (this.injectFailCount >= this.maxInjectRetries) {
+      return 0;
+    }
+
     const events = this.drainPending();
     if (events.length === 0) return 0;
-    const failed = [];
+    const requeue = [];
     let delivered = 0;
+    let consumedOne = false;
     for (const evt of events) {
       if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
         continue;
       }
+      if (consumedOne) {
+        requeue.push(evt);
+        continue;
+      }
       const message = String(evt.data.message);
       try {
         // Inject the actual message text into the terminal/tmux agent
@@ -206,22 +262,30 @@ class AgentNotifier {
         // eslint-disable-next-line no-await-in-loop
         await this.injector.inject(this.subscriber, message);
         delivered += 1;
+        consumedOne = true;
+        this.injectFailCount = 0;
+        this.updateActivityState("working");
         // eslint-disable-next-line no-await-in-loop
         await this.emitDelivery(evt, "ok");
       } catch (err) {
-        failed.push(evt);
+        consumedOne = true;
+        this.injectFailCount += 1;
+        requeue.push(evt);
         // eslint-disable-next-line no-await-in-loop
         await this.emitDelivery(evt, "error", err.message || "inject failed");
       }
     }
-    if (failed.length > 0) {
+    if (requeue.length > 0) {
       try {
-        const content = failed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+        const content = requeue.map((e) => JSON.stringify(e)).join("\n") + "\n";
         fs.appendFileSync(this.queueFile, content, "utf8");
       } catch {
         // ignore requeue failures
       }
     }
+    if (delivered > 0) {
+      this.lastWorkingAt = Date.now();
+    }
     return delivered;
   }
 
@@ -261,6 +325,7 @@ class AgentNotifier {
     if (this.stopped) return;
 
     const currentCount = this.getMessageCount();
+    const nowMs = Date.now();
 
     // 有新消息
     if (currentCount > this.lastCount) {
@@ -297,6 +362,9 @@ class AgentNotifier {
     }
 
     this.lastCount = this.getMessageCount();
+    if (!this.lastWorkingAt || nowMs - this.lastWorkingAt >= this.workingHoldMs) {
+      this.updateActivityState("idle");
+    }
     this.refreshTitle();
     this.updateHeartbeat();
   }
@@ -311,6 +379,7 @@ class AgentNotifier {
     if (this.lastNickname) {
       this.setTitle(this.lastNickname);
     }
+    this.updateActivityState("ready");
 
     // 启动轮询
     this.timer = setInterval(() => {

package/src/agent/ptyRunner.js

@@ -4,8 +4,9 @@ const net = require("net");
 const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
 const { PTY_SOCKET_MESSAGE_TYPES, PTY_SOCKET_SUBSCRIBE_MODES } = require("../shared/ptySocketContract");
-const { runInternalRunner } = require("./internalRunner");
 const { getUfooPaths } = require("../ufoo/paths");
+const { ActivityDetector } = require("./activityDetector");
+const { createActivityStatePublisher } = require("./activityStatePublisher");
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -140,6 +141,10 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   };
 
   const eventBus = new EventBus(projectRoot);
+  const activityDetector = new ActivityDetector(agentType, {
+    mode: "internal-pty",
+  });
+  const agentsFilePath = getUfooPaths(projectRoot).agentsFile;
 
   let running = true;
   let busy = false;
@@ -156,13 +161,13 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   let suppressEcho = false;
   let echoMarker = "";
   let suppressTimer = null;
-  let fallbackInProgress = false;
   let ptyProcess = null;
   let restartCount = 0;
   let lastSpawnTime = 0;
-  const MAX_RESTARTS = 3;
+  const MAX_RESTARTS = 10;
   const RESTART_STABLE_MS = 30000; // reset counter if process ran > 30s
   const RESTART_DELAY_MS = 2000;
+  const RESTART_BACKOFF_CAP_MS = 30000;
   const READY_QUIET_MS = 3000; // TUI is "ready" after 3s of no output
   const messageQueue = [];
   const injectServer = setupInjectServer();
@@ -171,7 +176,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   const idleMs = 30000;
   const watchdogMs = 120000;
   const maxQueue = 200;
-  const watchdogAction = String(process.env.UFOO_PTY_WATCHDOG_ACTION || "restart").toLowerCase();
   let sendQueue = Promise.resolve();
   const DROP_LINE_PATTERNS = [
     /__UFOO_DONE_/,
@@ -503,6 +507,51 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     }
   }
 
+  // Unified activity state publisher (write + broadcast)
+  const activityPublisher = createActivityStatePublisher({
+    agentsFile: agentsFilePath,
+    subscriber,
+    projectRoot,
+  });
+
+  function writeActivityState() {
+    const snap = activityDetector.getState();
+    activityPublisher.publish(snap.state, {
+      since: snap.since,
+      detail: snap.detail,
+    });
+  }
+
+  activityDetector.onChange((newState, oldState) => {
+    const snap = activityDetector.getState();
+    activityPublisher.publish(newState, {
+      since: snap.since,
+      previous: oldState,
+      detail: snap.detail,
+    });
+    // Quiet-window detector may classify IDLE sooner than stream fallback timer.
+    // Release queue only when no explicit marker is being awaited.
+    if (newState === "idle" && busy && !currentMarker && !suppressEcho) {
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+      if (currentPublisher) {
+        enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "idle" }));
+      }
+      busy = false;
+      currentPublisher = "";
+      processQueue();
+    }
+  });
+  // Ensure daemon/dashboard can read initial state immediately after runner boots,
+  // instead of waiting for the next 30s heartbeat tick.
+  writeActivityState();
+
   function attachPty(proc) {
     proc.onData((data) => {
       const raw = String(data || "");
@@ -516,6 +565,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       const clean = stripAnsi(raw).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
       if (!clean) return;
       outputBuffer += clean;
+      activityDetector.processOutput(clean);
       if (suppressEcho) {
         if (echoMarker && outputBuffer.includes(echoMarker)) {
           const idx = outputBuffer.indexOf(echoMarker);
@@ -545,6 +595,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           }
           currentMarker = "";
           busy = false;
+          activityDetector.markIdle();
           currentPublisher = "";
           if (watchdogTimer) {
             clearTimeout(watchdogTimer);
@@ -567,6 +618,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           readyTimer = null;
           if (!ptyReady) {
             ptyReady = true;
+            activityDetector.markReady();
             // Discard TUI startup noise accumulated before ready
             outputBuffer = "";
             pendingOutput = [];
@@ -583,6 +635,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
             enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "idle" }));
           }
           busy = false;
+          activityDetector.markIdle();
           currentPublisher = "";
           processQueue();
         }, idleMs);
@@ -620,6 +673,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
       // Reset busy state
       busy = false;
+      activityDetector.markIdle();
       currentPublisher = "";
       currentMarker = "";
 
@@ -634,7 +688,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       restartCount++;
 
       if (restartCount <= MAX_RESTARTS) {
-        const delay = Math.min(restartCount * RESTART_DELAY_MS, 10000);
+        const delay = Math.min(restartCount * RESTART_DELAY_MS, RESTART_BACKOFF_CAP_MS);
         logNote(`Auto-restarting PTY in ${delay}ms (attempt ${restartCount}/${MAX_RESTARTS})`);
         setTimeout(() => {
           if (!running) return;
@@ -643,12 +697,26 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
             processQueue();
           } catch (err) {
             logNote(`Restart failed: ${err.message || err}`);
-            void fallbackHeadless(`restart failed: ${err.message || err}`);
+            // Keep retrying instead of falling back
+            restartCount++;
+            if (restartCount <= MAX_RESTARTS) {
+              const retryDelay = Math.min(restartCount * RESTART_DELAY_MS, RESTART_BACKOFF_CAP_MS);
+              setTimeout(() => {
+                if (!running) return;
+                try {
+                  ptyProcess = spawnPtyProcess();
+                  processQueue();
+                } catch {
+                  logNote(`PTY spawn keeps failing after ${restartCount} attempts. Agent is offline.`);
+                }
+              }, retryDelay);
+            } else {
+              logNote(`PTY spawn failed after ${MAX_RESTARTS} attempts. Agent is offline. Fix the issue and re-launch.`);
+            }
           }
         }, delay);
       } else {
-        logNote(`Max PTY restarts (${MAX_RESTARTS}) reached, falling back to headless runner`);
-        void fallbackHeadless("max PTY restarts exceeded");
+        logNote(`PTY crashed ${MAX_RESTARTS} times within ${RESTART_STABLE_MS}ms. Agent is offline. Fix the issue and re-launch.`);
       }
     });
   }
@@ -691,24 +759,6 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     ptyProcess = spawnPtyProcess();
   }
 
-  async function fallbackHeadless(reason) {
-    if (fallbackInProgress) return;
-    fallbackInProgress = true;
-    logNote(`Fallback to headless: ${reason}`);
-    if (outputBuffer) {
-      flushOutput();
-    }
-    cleanupInjectServer(injectServer);
-    try {
-      if (ptyProcess) ptyProcess.kill();
-    } catch {
-      // ignore
-    }
-    running = false;
-    await runInternalRunner({ projectRoot, agentType });
-    process.exit(0);
-  }
-
   const stop = () => {
     running = false;
     cleanupInjectServer(injectServer);
@@ -732,6 +782,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     const next = messageQueue.shift();
     if (!next) return;
     busy = true;
+    activityDetector.markWorking();
     currentPublisher = next.publisher;
     currentMarker = next.marker || "";
     if (suppressTimer) {
@@ -794,21 +845,16 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     watchdogTimer = setTimeout(() => {
       watchdogTimer = null;
       if (!busy) return;
-      const timeoutNote = `[internal-pty] marker timeout; action=${watchdogAction}`;
+      const timeoutNote = `[internal-pty] marker timeout; restarting PTY`;
       if (currentPublisher) enqueueSend(currentPublisher, timeoutNote);
       if (currentPublisher) {
         enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "timeout" }));
       }
       logNote(timeoutNote);
-      if (watchdogAction === "fallback") {
-        void fallbackHeadless("marker timeout");
-        return;
-      }
-      if (watchdogAction === "restart") {
-        restartPty("marker timeout");
-      }
+      restartPty("marker timeout");
       currentMarker = "";
       busy = false;
+      activityDetector.markIdle();
       currentPublisher = "";
       processQueue();
     }, watchdogMs);
@@ -828,6 +874,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     } catch {
       // ignore heartbeat errors
     }
+    writeActivityState();
   };
 
   while (running) {

package/src/agent/ufooAgent.js

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

package/src/bus/message.js

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

package/src/bus/subscriber.js

@@ -202,6 +202,8 @@ class SubscriberManager {
       agent_type: agentType,
       nickname: finalNickname,
       status: "active",
+      activity_state: "starting",
+      activity_since: getTimestamp(),
       joined_at: existingMeta?.joined_at || getTimestamp(),
       last_seen: getTimestamp(),
       pid: overridePid || getJoinedPid(),

package/src/bus/utils.js

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