u-foo 1.5.0 → 1.6.0

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,

package/src/chat/agentBar.js

@@ -1,5 +1,16 @@
 const { stripAnsi, truncateAnsi } = require("./text");
 
+const ACTIVITY_INDICATORS = {
+  working: "*",
+  waiting_input: "?",
+  blocked: "!",
+};
+
+const ACTIVITY_COLORS = {
+  waiting_input: "\x1b[33m", // yellow
+  blocked: "\x1b[31m",       // red
+};
+
 function computeAgentBar(options = {}) {
   const {
     cols = 80,
@@ -11,6 +22,7 @@ function computeAgentBar(options = {}) {
     agentListWindowStart = 0,
     maxAgentWindow = 4,
     getAgentLabel = (id) => id,
+    agentStates = {},
   } = options;
 
   const hintAnsi = `\x1b[90m│ ${hintText}\x1b[0m`;
@@ -60,12 +72,18 @@ function computeAgentBar(options = {}) {
       agentParts = visible.map((agent, i) => {
         const rawLabel = getAgentLabel(agent);
         const label = maxLabelLen ? truncateLabel(rawLabel, maxLabelLen) : rawLabel;
+        const actState = agentStates[agent] || "";
+        const indicator = ACTIVITY_INDICATORS[actState] || "";
+        const indicatorColor = ACTIVITY_COLORS[actState] || "";
+        const prefix = indicator
+          ? `${indicatorColor}${indicator}\x1b[0m`
+          : "";
         const idx = s + i + 1; // +1 for ucode at index 0
         if (focusMode === "dashboard" && idx === selectedAgentIndex) {
-          return `\x1b[90;7m${label}\x1b[0m`;
+          return `${prefix}\x1b[90;7m${label}\x1b[0m`;
         }
-        if (agent === viewingAgent) return `\x1b[1;36m${label}\x1b[0m`;
-        return `\x1b[36m${label}\x1b[0m`;
+        if (agent === viewingAgent) return `${prefix}\x1b[1;36m${label}\x1b[0m`;
+        return `${prefix}\x1b[36m${label}\x1b[0m`;
       });
     }
     const agentsText = activeAgents.length > 0

package/src/chat/agentViewController.js

@@ -16,6 +16,7 @@ function createAgentViewController(options = {}) {
     getAgentListWindowStart = () => 0,
     setAgentListWindowStart = () => {},
     getAgentLabel = (id) => id,
+    getAgentStates = () => ({}),
     setDashboardView = () => {},
     setScreenGrabKeys = (value) => {
       if (screen) screen.grabKeys = Boolean(value);
@@ -79,6 +80,7 @@ function createAgentViewController(options = {}) {
       agentListWindowStart: getAgentListWindowStart(),
       maxAgentWindow,
       getAgentLabel,
+      agentStates: getAgentStates(),
     });
     setAgentListWindowStart(computed.windowStart);
     processStdout.write(`\x1b7\x1b[${rows};1H${computed.bar}\x1b8`);

package/src/chat/daemonConnection.js

@@ -7,6 +7,7 @@ function createDaemonConnection(options = {}) {
     queueStatusLine,
     resolveStatusLine,
     logMessage,
+    switchConnectionTimeoutMs = 18000,
   } = options;
 
   let connectClient = connectClientOption;
@@ -16,6 +17,35 @@ function createDaemonConnection(options = {}) {
   let connectionLostNotified = false;
   const pendingRequests = [];
   const MAX_PENDING_REQUESTS = 50;
+  const STATUS_KEY_RECONNECT = "daemon-reconnect";
+  const STATUS_KEY_SWITCH = "daemon-switch";
+  const DEFAULT_SWITCH_TIMEOUT_MS = Number.isFinite(switchConnectionTimeoutMs)
+    && switchConnectionTimeoutMs > 0
+    ? Math.trunc(switchConnectionTimeoutMs)
+    : 18000;
+
+  function withTimeout(promiseLike, timeoutMs, timeoutMessage) {
+    const ms = Number.isFinite(timeoutMs) && timeoutMs > 0
+      ? Math.trunc(timeoutMs)
+      : DEFAULT_SWITCH_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const err = new Error(timeoutMessage || `operation timed out after ${ms}ms`);
+        err.code = "UFOO_TIMEOUT";
+        reject(err);
+      }, ms);
+      if (typeof timer.unref === "function") {
+        timer.unref();
+      }
+      Promise.resolve(promiseLike).then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+      }, (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
 
   function enqueueRequest(req) {
     if (!req || req.type === IPC_REQUEST_TYPES.STATUS) return;
@@ -91,18 +121,18 @@ function createDaemonConnection(options = {}) {
     if (client && !client.destroyed) return true;
     if (exitRequested) return false;
     if (reconnectPromise) return reconnectPromise;
-    queueStatusLine("Reconnecting to daemon");
+    queueStatusLine("Reconnecting to daemon", { key: STATUS_KEY_RECONNECT });
     logMessage("status", "{white-fg}⚙{/white-fg} Reconnecting to daemon...");
     reconnectPromise = (async () => {
       const newClient = await connectClient();
       if (!newClient) {
-        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline");
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Daemon offline", { key: STATUS_KEY_RECONNECT });
         logMessage("error", "{white-fg}✗{/white-fg} Failed to reconnect to daemon");
         return false;
       }
       attachClient(newClient);
       connectionLostNotified = false;
-      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected");
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon reconnected", { key: STATUS_KEY_RECONNECT });
       requestStatus();
       return true;
     })();
@@ -130,9 +160,17 @@ function createDaemonConnection(options = {}) {
     }
     const previousClient = client;
     try {
-      queueStatusLine("Switching daemon connection");
-      const nextClient = await nextConnectClient();
+      queueStatusLine("Switching daemon connection", { key: STATUS_KEY_SWITCH });
+      const timeoutMs = Number.isFinite(next.timeoutMs) && next.timeoutMs > 0
+        ? Math.trunc(next.timeoutMs)
+        : DEFAULT_SWITCH_TIMEOUT_MS;
+      const nextClient = await withTimeout(
+        nextConnectClient(),
+        timeoutMs,
+        `Switch connection timed out after ${timeoutMs}ms`
+      );
       if (!nextClient) {
+        resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed", { key: STATUS_KEY_SWITCH });
         return { ok: false, error: "Failed to connect target daemon" };
       }
       connectClient = nextConnectClient;
@@ -140,7 +178,7 @@ function createDaemonConnection(options = {}) {
       if (next.callRequestStatus !== false) {
         requestStatus();
       }
-      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon switched");
+      resolveStatusLine("{gray-fg}✓{/gray-fg} Daemon switched", { key: STATUS_KEY_SWITCH });
       return { ok: true };
     } catch (err) {
       // Keep existing connection alive on switch failures.
@@ -148,7 +186,7 @@ function createDaemonConnection(options = {}) {
         client = previousClient;
       }
       const message = err && err.message ? err.message : String(err || "switch failed");
-      resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed");
+      resolveStatusLine("{gray-fg}✗{/gray-fg} Switch failed", { key: STATUS_KEY_SWITCH });
       logMessage("error", `{white-fg}✗{/white-fg} ${message}`);
       return { ok: false, error: message };
     }

package/src/chat/daemonMessageRouter.js

@@ -25,8 +25,17 @@ function createDaemonMessageRouter(options = {}) {
     appendStreamDelta = () => {},
     finalizeStream = () => {},
     hasStream = () => false,
+    setTransientAgentState = () => {},
+    clearTransientAgentState = () => {},
+    refreshDashboard = () => {},
   } = options;
 
+  function isLikelySubscriberId(value) {
+    const text = String(value || "");
+    if (!text) return false;
+    return text.includes(":") && !text.includes(" ");
+  }
+
   function normalizeDisplayMessage(raw) {
     let displayMessage = raw || "";
     let streamPayload = null;
@@ -53,6 +62,14 @@ function createDaemonMessageRouter(options = {}) {
     if (typeof data.phase === "string") {
       const text = data.text || "";
       const item = { key: data.key, text };
+      const key = typeof data.key === "string" ? data.key : "";
+      if (isLikelySubscriberId(key)) {
+        if (data.phase === BUS_STATUS_PHASES.START) {
+          setTransientAgentState(key, "working");
+        } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
+          clearTransientAgentState(key);
+        }
+      }
       if (data.phase === BUS_STATUS_PHASES.START) {
         enqueueBusStatus(item);
       } else if (data.phase === BUS_STATUS_PHASES.DONE || data.phase === BUS_STATUS_PHASES.ERROR) {
@@ -66,6 +83,7 @@ function createDaemonMessageRouter(options = {}) {
       } else {
         enqueueBusStatus(item);
       }
+      refreshDashboard();
       renderScreen();
       return false;
     }
@@ -301,6 +319,10 @@ function createDaemonMessageRouter(options = {}) {
 
   function handleBusMessage(msg) {
     const data = msg.data || {};
+    if (data.event === "activity_state_changed") {
+      requestStatus();
+      return true;
+    }
     const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
     const publisher = data.publisher && data.publisher !== "unknown"
       ? data.publisher

package/src/chat/daemonTransport.js

@@ -11,6 +11,7 @@ function createDaemonTransport(options = {}) {
     secondaryRetries = DAEMON_TRANSPORT_DEFAULTS.secondaryRetries,
     retryDelayMs = DAEMON_TRANSPORT_DEFAULTS.retryDelayMs,
     restartDelayMs = DAEMON_TRANSPORT_DEFAULTS.restartDelayMs,
+    connectTimeoutMs = DAEMON_TRANSPORT_DEFAULTS.connectTimeoutMs,
   } = options;
 
   let activeProjectRoot = projectRoot;
@@ -25,14 +26,24 @@ function createDaemonTransport(options = {}) {
 
   async function connectClientForTarget(override = {}) {
     const target = resolveTarget(override);
-    let client = await connectWithRetry(target.sockPath, primaryRetries, retryDelayMs);
+    let client = await connectWithRetry(
+      target.sockPath,
+      primaryRetries,
+      retryDelayMs,
+      { timeoutMs: connectTimeoutMs }
+    );
     if (!client) {
       // Retry once with a fresh daemon start and longer wait.
       if (!isRunning(target.projectRoot)) {
         startDaemon(target.projectRoot);
         await new Promise((resolve) => setTimeout(resolve, restartDelayMs));
       }
-      client = await connectWithRetry(target.sockPath, secondaryRetries, retryDelayMs);
+      client = await connectWithRetry(
+        target.sockPath,
+        secondaryRetries,
+        retryDelayMs,
+        { timeoutMs: connectTimeoutMs }
+      );
     }
     return client;
   }

package/src/chat/daemonTransportDefaults.js

@@ -3,6 +3,7 @@ const DAEMON_TRANSPORT_DEFAULTS = {
   secondaryRetries: 50,
   retryDelayMs: 200,
   restartDelayMs: 1000,
+  connectTimeoutMs: 2000,
 };
 
 module.exports = {

package/src/chat/dashboardKeyController.js

@@ -23,6 +23,7 @@ function createDashboardKeyController(options = {}) {
     clampAgentWindow = () => {},
     clampAgentWindowWithSelection = () => {},
     requestProjectSwitch = () => {},
+    requestCloseProject = () => {},
     renderDashboard = () => {},
     renderAgentDashboard = () => {},
     renderScreen = () => {},
@@ -385,6 +386,14 @@ function createDashboardKeyController(options = {}) {
       return true;
     }
 
+    if (key.name === "x" && key.ctrl) {
+      const current = Number.isFinite(state.selectedProjectIndex) ? state.selectedProjectIndex : 0;
+      if (current >= 0 && current < projects.length) {
+        requestCloseProject(current);
+      }
+      return true;
+    }
+
     if (key.name === "down") {
       state.dashboardView = "agents";
       if (!Array.isArray(state.activeAgents) || state.activeAgents.length === 0) {