u-foo 1.7.3 → 1.7.4

package/package.json

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

package/src/agent/notifier.js

@@ -7,6 +7,7 @@ const { shakeTerminalByTty } = require("../bus/shake");
 const { isITerm2 } = require("../terminal/detect");
 const iterm2 = require("../terminal/iterm2");
 const { createActivityStatePublisher } = require("./activityStatePublisher");
+const { INJECTION_MODES, getInjectionModeFromEvent } = require("../bus/messageMeta");
 
 /**
  * Agent 消息通知监听器
@@ -232,11 +233,6 @@ 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;
@@ -251,6 +247,12 @@ class AgentNotifier {
       if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
         continue;
       }
+      const injectionMode = getInjectionModeFromEvent(evt, INJECTION_MODES.IMMEDIATE);
+      const activityState = this.getCurrentActivityState();
+      if (injectionMode === INJECTION_MODES.QUEUED && this.isBusyState(activityState)) {
+        requeue.push(evt);
+        continue;
+      }
       if (consumedOne) {
         requeue.push(evt);
         continue;

package/src/agent/ufooAgent.js

@@ -274,7 +274,7 @@ function buildSystemPrompt(context) {
     "{",
     '  "reply": "string",',
     `  "assistant_call": {"kind":"explore|bash|mixed","task":"string","context":"optional","expect":"optional","provider":"codex|claude|ufoo (optional)","model":"optional","timeout_ms":${DEFAULT_ASSISTANT_TIMEOUT_MS}},`,
-    '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string"}],',
+    '  "dispatch": [{"target":"broadcast|<agent-id>|<nickname>","message":"string","injection_mode":"immediate|queued (optional)","source":"optional"}],',
     '  "ops": [{"action":"launch|close|rename|cron","agent":"codex|claude|ucode","count":1,"agent_id":"id","nickname":"optional","operation":"start|list|stop","every":"30m","interval_ms":1800000,"target":"agent-id|nickname|csv","targets":["agent-id"],"prompt":"message","id":"task-id|all"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',
     "}",
@@ -291,7 +291,10 @@ function buildSystemPrompt(context) {
     "- 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.",
+    "- dispatch.injection_mode defaults to immediate when omitted.",
+    "- Use queued only when routing a chat-dialog request that is clearly a new unrelated task for an agent whose recent prompt history shows a different ongoing thread.",
+    "- If the new request strongly continues the target agent's recent prompt history, keep injection_mode immediate even when that agent is busy.",
+    "- Manual @agent sends in ufoo chat are handled outside this router and remain immediate; do not model them here.",
     "- 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/daemon.js

@@ -5,6 +5,15 @@ const Injector = require("./inject");
 const QueueManager = require("./queue");
 const MessageManager = require("./message");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const { INJECTION_MODES, getInjectionModeFromEvent } = require("./messageMeta");
+
+function isBusyActivityState(value = "") {
+  const state = String(value || "").trim().toLowerCase();
+  return state === "working"
+    || state === "running"
+    || state === "waiting_input"
+    || state === "blocked";
+}
 
 /**
  * Bus Daemon - 监控消息并自动注入命令
@@ -25,6 +34,49 @@ class BusDaemon {
     this.queueManager = new QueueManager(busDir);
     this.injector = new Injector(busDir, agentsFile);
     this.adapterRouter = createTerminalAdapterRouter();
+    this.workingHoldMs = Number.parseInt(process.env.UFOO_ACTIVITY_WORKING_HOLD_MS || "", 10) || 5000;
+    this.lastWorkingAt = new Map();
+  }
+
+  setLegacyActivityState(subscriber, state) {
+    const busData = readJSON(this.agentsFile) || { agents: {} };
+    if (!busData.agents || !busData.agents[subscriber]) return;
+    busData.agents[subscriber].activity_state = state;
+    busData.agents[subscriber].activity_since = new Date().toISOString();
+    writeJSON(this.agentsFile, busData);
+  }
+
+  refreshLegacyActivityState(subscriber, meta, hasPending) {
+    const now = Date.now();
+    const current = String(meta?.activity_state || "").trim().toLowerCase();
+    const lastWorkingAt = this.lastWorkingAt.get(subscriber) || 0;
+    const holdActive = lastWorkingAt > 0 && (now - lastWorkingAt) < this.workingHoldMs;
+    const daemonManagedWorking = lastWorkingAt > 0;
+
+    if (holdActive) {
+      if (current !== "working") {
+        this.setLegacyActivityState(subscriber, "working");
+      }
+      return "working";
+    }
+
+    if (lastWorkingAt > 0) {
+      this.lastWorkingAt.delete(subscriber);
+    }
+
+    if (current === "starting") {
+      const next = hasPending ? "ready" : "idle";
+      this.setLegacyActivityState(subscriber, next);
+      return next;
+    }
+
+    if (current === "working" && daemonManagedWorking) {
+      const next = hasPending ? "ready" : "idle";
+      this.setLegacyActivityState(subscriber, next);
+      return next;
+    }
+
+    return current;
   }
 
   /**
@@ -257,15 +309,26 @@ class BusDaemon {
             continue;
           }
 
+          let currentActivityState = this.refreshLegacyActivityState(subscriber, meta, count > 0);
           const events = this.drainPending(pendingFile);
           const failed = [];
+          let deliveredCount = 0;
           for (const evt of events) {
             if (!evt || evt.event !== "message" || !evt.data || typeof evt.data.message !== "string") {
               continue;
             }
+            const injectionMode = getInjectionModeFromEvent(evt, INJECTION_MODES.IMMEDIATE);
+            if (injectionMode === INJECTION_MODES.QUEUED && isBusyActivityState(currentActivityState)) {
+              failed.push(evt);
+              continue;
+            }
             try {
               // eslint-disable-next-line no-await-in-loop
               await this.injector.inject(subscriber, String(evt.data.message));
+              deliveredCount += 1;
+              currentActivityState = "working";
+              this.lastWorkingAt.set(subscriber, Date.now());
+              this.setLegacyActivityState(subscriber, "working");
             } catch (err) {
               failed.push(evt);
               try {
@@ -312,7 +375,7 @@ class BusDaemon {
               // ignore requeue failures
             }
           }
-          console.log(`[daemon] Delivered ${events.length} message(s) to ${subscriber}`);
+          console.log(`[daemon] Delivered ${deliveredCount} message(s) to ${subscriber}`);
           if (wakeActive) fs.rmSync(wakePath, { force: true });
         } catch (err) {
           console.error(`[daemon] Failed to inject: ${err.message}`);

package/src/bus/index.js

@@ -306,7 +306,11 @@ class EventBus {
       const eventName = options.event || "message";
       const data = options.data || { message };
       const result = eventName === "message"
-        ? await this.messageManager.send(target, message, publisher)
+        ? await this.messageManager.send(target, message, publisher, {
+          data,
+          injectionMode: options.injectionMode,
+          source: options.source,
+        })
         : await this.messageManager.emit(target, eventName, data, publisher);
       const silent = options.silent === true;
       if (!silent && eventName === "message") {

package/src/bus/message.js

@@ -10,6 +10,7 @@ const {
   normalizeAgentTypeAlias,
 } = require("./utils");
 const NicknameManager = require("./nickname");
+const { buildMessageData } = require("./messageMeta");
 
 const SEQ_LOCK_TIMEOUT_MS = 5000;
 const SEQ_LOCK_POLL_MS = 25;
@@ -241,7 +242,7 @@ class MessageManager {
   /**
    * 发送消息
    */
-  async send(target, message, publisher = "unknown") {
+  async send(target, message, publisher = "unknown", options = {}) {
     const seq = await this.getNextSeq();
     const timestamp = getTimestamp();
     const date = getDate();
@@ -252,6 +253,8 @@ class MessageManager {
       throw new Error(`Target "${target}" not found`);
     }
 
+    const data = buildMessageData(message, options);
+
     // 构建事件
     const event = {
       seq,
@@ -260,7 +263,7 @@ class MessageManager {
       event: "message",
       publisher,
       target,
-      data: { message },
+      data,
     };
 
     // 写入事件日志

package/src/bus/messageMeta.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const INJECTION_MODES = {
+  IMMEDIATE: "immediate",
+  QUEUED: "queued",
+};
+
+function normalizeInjectionMode(value, fallback = INJECTION_MODES.IMMEDIATE) {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === INJECTION_MODES.QUEUED) return INJECTION_MODES.QUEUED;
+  if (raw === INJECTION_MODES.IMMEDIATE) return INJECTION_MODES.IMMEDIATE;
+  return fallback;
+}
+
+function normalizeMessageSource(value) {
+  const raw = String(value || "").trim();
+  return raw || "";
+}
+
+function buildMessageData(message, options = {}) {
+  const base = options && typeof options.data === "object" && options.data
+    ? { ...options.data }
+    : {};
+  const data = { ...base, message };
+  data.injection_mode = normalizeInjectionMode(
+    options.injectionMode || data.injection_mode,
+    INJECTION_MODES.IMMEDIATE,
+  );
+  const source = normalizeMessageSource(options.source || data.source);
+  if (source) {
+    data.source = source;
+  } else {
+    delete data.source;
+  }
+  return data;
+}
+
+function getInjectionModeFromEvent(evt, fallback = INJECTION_MODES.IMMEDIATE) {
+  const data = evt && typeof evt.data === "object" && evt.data ? evt.data : {};
+  return normalizeInjectionMode(
+    data.injection_mode || evt?.injection_mode,
+    fallback,
+  );
+}
+
+module.exports = {
+  INJECTION_MODES,
+  normalizeInjectionMode,
+  normalizeMessageSource,
+  buildMessageData,
+  getInjectionModeFromEvent,
+};

package/src/chat/commandExecutor.js

@@ -241,13 +241,36 @@ function createCommandExecutor(options = {}) {
 
     try {
       if (subcommand === "send") {
-        if (args.length < 3) {
-          logMessage("error", "{white-fg}✗{/white-fg} Usage: /bus send <target> <message>");
+        let injectionMode = "immediate";
+        let index = 1;
+        while (index < args.length) {
+          const arg = args[index];
+          if (arg === "--queued") {
+            injectionMode = "queued";
+            index += 1;
+            continue;
+          }
+          if (arg === "--immediate") {
+            injectionMode = "immediate";
+            index += 1;
+            continue;
+          }
+          break;
+        }
+        const positionals = args.slice(index);
+        if (positionals.length < 2) {
+          logMessage("error", "{white-fg}✗{/white-fg} Usage: /bus send [--queued|--immediate] <target> <message>");
           return;
         }
-        const target = args[1];
-        const message = args.slice(2).join(" ");
-        send({ type: IPC_REQUEST_TYPES.BUS_SEND, target, message });
+        const target = positionals[0];
+        const message = positionals.slice(1).join(" ");
+        send({
+          type: IPC_REQUEST_TYPES.BUS_SEND,
+          target,
+          message,
+          injection_mode: injectionMode,
+          source: "chat-command",
+        });
         logMessage("system", `{white-fg}✓{/white-fg} Message sent to ${target}`);
         return;
       }

package/src/chat/index.js

@@ -316,6 +316,8 @@ async function runChat(projectRoot, options = {}) {
         type: IPC_REQUEST_TYPES.BUS_SEND,
         target,
         message: JSON.stringify({ raw: true, data }),
+        injection_mode: "immediate",
+        source: "chat-agent-view",
       });
     },
   });

package/src/chat/inputSubmitHandler.js

@@ -90,7 +90,13 @@ function createInputSubmitHandler(options = {}) {
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(state.targetAgent);
-      send({ type: IPC_REQUEST_TYPES.BUS_SEND, target: state.targetAgent, message: text });
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target: state.targetAgent,
+        message: text,
+        injection_mode: "immediate",
+        source: "chat-direct",
+      });
       clearTargetAgent();
       focusInput();
       return;
@@ -120,7 +126,13 @@ function createInputSubmitHandler(options = {}) {
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(resolvedTarget);
-      send({ type: IPC_REQUEST_TYPES.BUS_SEND, target: resolvedTarget, message: atTarget.message });
+      send({
+        type: IPC_REQUEST_TYPES.BUS_SEND,
+        target: resolvedTarget,
+        message: atTarget.message,
+        injection_mode: "immediate",
+        source: "chat-direct",
+      });
       focusInput();
       return;
     }
@@ -145,6 +157,11 @@ function createInputSubmitHandler(options = {}) {
         send({
           type: IPC_REQUEST_TYPES.PROMPT,
           text: `Use agent ${choice.agent_id} to handle: ${state.pending.original || "the request"}`,
+          request_meta: {
+            source: "chat-dialog",
+            dispatch_default_injection_mode: "immediate",
+            allow_relevance_queue: true,
+          },
         });
         state.pending = null;
       } else {
@@ -153,7 +170,15 @@ function createInputSubmitHandler(options = {}) {
     } else {
       state.pending = { original: text };
       queueStatusLine("ufoo-agent processing");
-      send({ type: IPC_REQUEST_TYPES.PROMPT, text });
+      send({
+        type: IPC_REQUEST_TYPES.PROMPT,
+        text,
+        request_meta: {
+          source: "chat-dialog",
+          dispatch_default_injection_mode: "immediate",
+          allow_relevance_queue: true,
+        },
+      });
       logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
       renderScreen();  // Render plain text message immediately
     }

package/src/cli/busCoreCommands.js

@@ -1,5 +1,44 @@
 "use strict";
 
+function parseSendArgs(cmdArgs = []) {
+  let injectionMode = "immediate";
+  let source = "";
+  let index = 0;
+
+  while (index < cmdArgs.length) {
+    const arg = cmdArgs[index];
+    if (arg === "--queued") {
+      injectionMode = "queued";
+      index += 1;
+      continue;
+    }
+    if (arg === "--immediate") {
+      injectionMode = "immediate";
+      index += 1;
+      continue;
+    }
+    if (arg === "--source") {
+      source = String(cmdArgs[index + 1] || "").trim();
+      index += 2;
+      continue;
+    }
+    break;
+  }
+
+  const positionals = cmdArgs.slice(index);
+
+  if (positionals.length < 2) {
+    throw new Error("send requires <target> <message>");
+  }
+
+  return {
+    target: positionals[0],
+    message: positionals.slice(1).join(" "),
+    injectionMode,
+    source,
+  };
+}
+
 async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
   switch (cmd) {
     case "init":
@@ -15,7 +54,11 @@ async function runBusCoreCommand(eventBus, cmd, cmdArgs = []) {
     case "send":
       {
         const publisher = await eventBus.ensureJoined();
-        await eventBus.send(cmdArgs[0], cmdArgs[1], publisher);
+        const parsed = parseSendArgs(cmdArgs);
+        await eventBus.send(parsed.target, parsed.message, publisher, {
+          injectionMode: parsed.injectionMode,
+          source: parsed.source,
+        });
       }
       return {};
     case "broadcast":

package/src/daemon/index.js

@@ -478,11 +478,15 @@ async function dispatchMessages(projectRoot, dispatch = []) {
   for (const item of dispatch) {
     if (!item || !item.target || !item.message) continue;
     const pub = item.publisher || defaultPublisher;
+    const sendOptions = {
+      injectionMode: item.injection_mode,
+      source: item.source,
+    };
     try {
       if (item.target === "broadcast") {
-        await eventBus.broadcast(item.message, pub);
+        await eventBus.broadcast(item.message, pub, sendOptions);
       } else {
-        await eventBus.send(item.target, item.message, pub);
+        await eventBus.send(item.target, item.message, pub, sendOptions);
       }
     } catch {
       // ignore dispatch failures
@@ -844,7 +848,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     }
     if (req.type === IPC_REQUEST_TYPES.BUS_SEND) {
       // Direct bus send request from chat UI
-      const { target, message } = req;
+      const { target, message, injection_mode, source } = req;
       if (!target || !message) {
         socket.write(
           `${JSON.stringify({
@@ -858,7 +862,10 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
       try {
         const publisher = busBridge.getSubscriber() || "ufoo-agent";
         const eventBus = new EventBus(projectRoot);
-        await eventBus.send(target, message, publisher);
+        await eventBus.send(target, message, publisher, {
+          injectionMode: injection_mode,
+          source,
+        });
         busBridge.markPending(target);
         log(`bus_send target=${target} publisher=${publisher}`);
         socket.write(

package/src/daemon/promptRequest.js

@@ -6,13 +6,30 @@ const {
   consumeControllerInboxEntries,
 } = require("../report/store");
 
-function buildPromptWithPrivateReports(prompt = "", reports = []) {
+function buildPromptWithPrivateReports(prompt = "", reports = [], requestMeta = {}) {
+  const meta = requestMeta && typeof requestMeta === "object" ? requestMeta : {};
+  const hasMeta = Object.keys(meta).length > 0;
   if (!Array.isArray(reports) || reports.length === 0) {
-    return prompt;
+    if (!hasMeta) return prompt;
+    const lines = [];
+    lines.push(prompt || "");
+    lines.push("");
+    lines.push("Routing request metadata (JSON):");
+    lines.push(JSON.stringify(meta, null, 2));
+    lines.push("");
+    lines.push("Honor this metadata when choosing dispatch targets and injection_mode.");
+    return lines.join("\n");
   }
   const lines = [];
   lines.push(prompt || "");
   lines.push("");
+  if (hasMeta) {
+    lines.push("Routing request metadata (JSON):");
+    lines.push(JSON.stringify(meta, null, 2));
+    lines.push("");
+    lines.push("Honor this metadata when choosing dispatch targets and injection_mode.");
+    lines.push("");
+  }
   lines.push("Private runtime reports for ufoo-agent (JSON):");
   lines.push(JSON.stringify(reports, null, 2));
   lines.push("");
@@ -40,7 +57,7 @@ async function handlePromptRequest(options = {}) {
 
   log(`prompt ${String(req.text || "").slice(0, 200)}`);
   const privateReports = listControllerInboxEntries(projectRoot, "ufoo-agent", { num: 100 });
-  const promptText = buildPromptWithPrivateReports(req.text || "", privateReports);
+  const promptText = buildPromptWithPrivateReports(req.text || "", privateReports, req.request_meta);
 
   try {
     const handled = await runPromptWithAssistant({