u-foo 2.5.1 → 2.5.2

package/src/coordination/bus/message.js

@@ -13,6 +13,8 @@ const {
 const NicknameManager = require("./nickname");
 const { buildMessageData } = require("./messageMeta");
 const { getUfooPaths } = require("../state/paths");
+const { applyProjectNicknamePrefix } = require("../../runtime/daemon/nicknameScope");
+const { QUEUE_TYPES, normalizeQueueEnvelope } = require("./deliveryQueue");
 
 const SEQ_LOCK_TIMEOUT_MS = 5000;
 const SEQ_LOCK_POLL_MS = 25;
@@ -222,7 +224,19 @@ class MessageManager {
       return [byNickname];
     }
 
-    // 3. 尝试作为代理类型（匹配所有该类型的订阅者）
+    // 3. Try the project-scoped nickname form. Group prompts intentionally show
+    // short names, while older/runtime metadata may only contain scoped names.
+    if (this.projectRoot) {
+      const scopedTarget = applyProjectNicknamePrefix(this.projectRoot, target);
+      if (scopedTarget && scopedTarget !== target) {
+        const byScopedNickname = nicknameManager.resolveNickname(scopedTarget);
+        if (byScopedNickname) {
+          return [byScopedNickname];
+        }
+      }
+    }
+
+    // 4. 尝试作为代理类型（匹配所有该类型的订阅者）
     const isActive = (meta) => !meta || meta.status === "active";
 
     const byType = Object.entries(subscribers)
@@ -233,7 +247,7 @@ class MessageManager {
       return byType;
     }
 
-    // 4. 通配符（所有活跃订阅者）
+    // 5. 通配符（所有活跃订阅者）
     if (target === "*") {
       return Object.entries(subscribers)
         .filter(([, meta]) => isActive(meta))
@@ -257,7 +271,14 @@ class MessageManager {
     if (meta && normalizedTarget === normalizeAgentTypeAlias(meta.agent_type)) return true;
 
     // 昵称匹配
-    if (meta && (target === meta.nickname || target === meta.scoped_nickname)) return true;
+    if (meta) {
+      const candidates = [target];
+      if (this.projectRoot) {
+        const scopedTarget = applyProjectNicknamePrefix(this.projectRoot, target);
+        if (scopedTarget && scopedTarget !== target) candidates.push(scopedTarget);
+      }
+      if (candidates.includes(meta.nickname) || candidates.includes(meta.scoped_nickname)) return true;
+    }
 
     // 通配符
     if (target === "*") return true;
@@ -426,17 +447,22 @@ class MessageManager {
       target,
       data,
     };
+    const queueEvent = normalizeQueueEnvelope(event, {
+      queueType: QUEUE_TYPES.AGENT_MESSAGE,
+      delivery: { mode: "inject", gate: "idle", max_inflight: 1 },
+      ack: { policy: "on_delivery" },
+    });
 
     // 写入事件日志
     const eventFile = path.join(this.eventsDir, `${date}.jsonl`);
-    appendJSONL(eventFile, event);
+    appendJSONL(eventFile, queueEvent);
 
     // 为每个目标订阅者添加到待处理队列
     for (const targetSubscriber of targets) {
       // 检查订阅者的 offset，如果已经消费过这个 seq，不再添加
       const offset = await this.queueManager.getOffset(targetSubscriber);
       if (seq > offset) {
-        await this.queueManager.appendPending(targetSubscriber, event);
+        await this.queueManager.appendPending(targetSubscriber, queueEvent);
       }
     }
 
@@ -473,14 +499,15 @@ class MessageManager {
       target,
       data,
     };
+    const queueEvent = normalizeQueueEnvelope(event);
 
     const eventFile = path.join(this.eventsDir, `${date}.jsonl`);
-    appendJSONL(eventFile, event);
+    appendJSONL(eventFile, queueEvent);
 
     for (const targetSubscriber of targets) {
       const offset = await this.queueManager.getOffset(targetSubscriber);
       if (seq > offset) {
-        await this.queueManager.appendPending(targetSubscriber, event);
+        await this.queueManager.appendPending(targetSubscriber, queueEvent);
       }
     }
 
@@ -499,14 +526,7 @@ class MessageManager {
    * 确认消息（清空待处理队列）
    */
   async ack(subscriber) {
-    const pending = await this.queueManager.readPending(subscriber);
-    const count = pending.length;
-
-    if (count > 0) {
-      await this.queueManager.clearPending(subscriber);
-    }
-
-    return count;
+    return this.queueManager.ackPending(subscriber);
   }
 
   /**

package/src/coordination/bus/queue.js

@@ -3,10 +3,9 @@ const path = require("path");
 const {
   subscriberToSafeName,
   ensureDir,
-  readJSONL,
-  appendJSONL,
   truncateFile,
 } = require("./utils");
+const { DeliveryQueue, stripQueueEnvelope } = require("./deliveryQueue");
 
 /**
  * 队列管理器
@@ -49,6 +48,10 @@ class QueueManager {
     return path.join(this.getQueueDir(subscriber), "pending.jsonl");
   }
 
+  getDeliveryQueue(subscriber) {
+    return new DeliveryQueue(this.getPendingPath(subscriber));
+  }
+
   /**
    * 获取 tty 文件路径
    */
@@ -81,17 +84,15 @@ class QueueManager {
    * 读取待处理消息
    */
   async readPending(subscriber) {
-    const pendingPath = this.getPendingPath(subscriber);
-    return readJSONL(pendingPath);
+    return this.getDeliveryQueue(subscriber).readPending().map(stripQueueEnvelope);
   }
 
   /**
    * 追加待处理消息
    */
   async appendPending(subscriber, event) {
-    this.ensureQueueDir(subscriber);
-    const pendingPath = this.getPendingPath(subscriber);
-    appendJSONL(pendingPath, event);
+    const deliveryQueue = this.getDeliveryQueue(subscriber);
+    deliveryQueue.append(event);
     if (event && event.event === "wake") {
       const wakePath = path.join(this.getQueueDir(subscriber), "wake");
       fs.writeFileSync(wakePath, String(event.seq || Date.now()), "utf8");
@@ -106,6 +107,21 @@ class QueueManager {
     truncateFile(pendingPath);
   }
 
+  /**
+   * 确认待处理消息
+   */
+  async ackPending(subscriber) {
+    const deliveryQueue = this.getDeliveryQueue(subscriber);
+    let count = 0;
+    while (true) {
+      const claim = deliveryQueue.claimNext();
+      if (!claim) break;
+      deliveryQueue.completeClaim(claim);
+      count += 1;
+    }
+    return count;
+  }
+
   /**
    * 检查是否有待处理消息
    */

package/src/runtime/daemon/deliveryScheduler.js

@@ -0,0 +1,205 @@
+const fs = require("fs");
+const { getUfooPaths } = require("../../coordination/state/paths");
+const { DeliveryQueue } = require("../../coordination/bus/deliveryQueue");
+const Injector = require("../../coordination/bus/inject");
+const { buildPromptInjectionText } = require("../../coordination/bus/promptEnvelope");
+const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
+const { normalizeQueueEnvelope } = require("../../coordination/bus/deliveryQueue");
+
+function asState(value = "") {
+  return String(value || "").trim().toLowerCase();
+}
+
+function isDeliverableActivityState(value = "") {
+  const state = asState(value);
+  return state === "idle" || state === "ready";
+}
+
+function readAgentsFile(agentsFile) {
+  try {
+    if (!agentsFile || !fs.existsSync(agentsFile)) return { agents: {} };
+    const parsed = JSON.parse(fs.readFileSync(agentsFile, "utf8"));
+    if (!parsed || typeof parsed !== "object") return { agents: {} };
+    if (!parsed.agents || typeof parsed.agents !== "object") parsed.agents = {};
+    return parsed;
+  } catch {
+    return { agents: {} };
+  }
+}
+
+class DeliveryScheduler {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.paths = getUfooPaths(projectRoot);
+    this.injector = options.injector || new Injector(this.paths.busDir, this.paths.agentsFile);
+    this.queueFactory = typeof options.queueFactory === "function"
+      ? options.queueFactory
+      : (subscriber) => DeliveryQueue.forSubscriber(this.paths.busDir, subscriber);
+    this.buildInjectionText = typeof options.buildInjectionText === "function"
+      ? options.buildInjectionText
+      : buildPromptInjectionText;
+    this.readAgents = typeof options.readAgents === "function"
+      ? options.readAgents
+      : () => readAgentsFile(this.paths.agentsFile);
+    this.emitDelivery = typeof options.emitDelivery === "function"
+      ? options.emitDelivery
+      : async () => {};
+    this.log = typeof options.log === "function" ? options.log : () => {};
+    this.intervalMs = Number.isFinite(options.intervalMs) && options.intervalMs > 0
+      ? options.intervalMs
+      : 1000;
+    this.adapterRouter = options.adapterRouter || createTerminalAdapterRouter();
+    this.locks = new Set();
+    this.timer = null;
+    this.running = false;
+  }
+
+  getAgentMeta(subscriber) {
+    const data = this.readAgents() || { agents: {} };
+    const agents = data.agents && typeof data.agents === "object" ? data.agents : {};
+    return {
+      agents,
+      meta: agents[subscriber] || null,
+    };
+  }
+
+  shouldDeliver(subscriber) {
+    const { meta } = this.getAgentMeta(subscriber);
+    if (!meta || meta.status === "inactive") {
+      return { ok: false, reason: "missing_or_inactive" };
+    }
+    const launchMode = String(meta.launch_mode || "").trim();
+    const adapter = this.adapterRouter.getAdapter({ launchMode, agentId: subscriber, meta });
+    if (!adapter.capabilities.supportsNotifierInjector) {
+      return { ok: false, reason: launchMode ? "unsupported_launch_mode" : "missing_launch_mode" };
+    }
+    const activityState = asState(meta.activity_state);
+    if (!isDeliverableActivityState(activityState)) {
+      return { ok: false, reason: activityState || "unknown_activity_state" };
+    }
+    return { ok: true, reason: "deliverable" };
+  }
+
+  async deliverSubscriber(subscriber) {
+    if (!subscriber) return { ok: false, delivered: 0, reason: "missing_subscriber" };
+    if (this.locks.has(subscriber)) {
+      return { ok: true, delivered: 0, deferred: true, reason: "locked" };
+    }
+
+    this.locks.add(subscriber);
+    try {
+      const gate = this.shouldDeliver(subscriber);
+      if (!gate.ok) {
+        return { ok: true, delivered: 0, deferred: true, reason: gate.reason };
+      }
+
+      const queue = this.queueFactory(subscriber);
+      const claim = queue.claimNext();
+      if (!claim) {
+        return { ok: true, delivered: 0, reason: "empty" };
+      }
+
+      const evt = claim.event;
+      const envelope = normalizeQueueEnvelope(evt || {});
+      const delivery = envelope.delivery || {};
+      if (delivery.mode !== "inject") {
+        queue.completeClaim(claim);
+        return { ok: true, delivered: 0, skipped: true, reason: "unsupported_delivery_mode" };
+      }
+      if (!envelope || envelope.event !== "message" || !envelope.data || typeof envelope.data.message !== "string") {
+        queue.completeClaim(claim);
+        return { ok: true, delivered: 0, skipped: true, reason: "unsupported_event" };
+      }
+
+      if (delivery.gate === "idle") {
+        const secondGate = this.shouldDeliver(subscriber);
+        if (!secondGate.ok) {
+          queue.restoreClaim(claim);
+          return { ok: true, delivered: 0, deferred: true, reason: secondGate.reason };
+        }
+      }
+
+      const { agents } = this.getAgentMeta(subscriber);
+      const injectionText = this.buildInjectionText(envelope, subscriber, agents);
+      try {
+        await this.injector.inject(subscriber, injectionText);
+        queue.completeClaim(claim);
+        await this.emitDelivery({
+          subscriber,
+          event: envelope,
+          status: "ok",
+        });
+        return { ok: true, delivered: 1, event: envelope };
+      } catch (err) {
+        queue.restoreClaim(claim);
+        await this.emitDelivery({
+          subscriber,
+          event: envelope,
+          status: "error",
+          error: err && err.message ? err.message : String(err || "inject failed"),
+        });
+        return {
+          ok: false,
+          delivered: 0,
+          reason: "inject_failed",
+          error: err && err.message ? err.message : String(err || "inject failed"),
+        };
+      }
+    } finally {
+      this.locks.delete(subscriber);
+    }
+  }
+
+  async deliverTargets(targets = []) {
+    const unique = Array.from(new Set((Array.isArray(targets) ? targets : [targets]).filter(Boolean)));
+    const results = [];
+    for (const subscriber of unique) {
+      // eslint-disable-next-line no-await-in-loop
+      results.push(await this.deliverSubscriber(subscriber));
+    }
+    return results;
+  }
+
+  listPendingSubscribers() {
+    const data = this.readAgents() || { agents: {} };
+    const agents = data.agents && typeof data.agents === "object" ? data.agents : {};
+    const subscribers = [];
+    for (const [subscriber, meta] of Object.entries(agents)) {
+      if (!meta || meta.status === "inactive") continue;
+      const queue = this.queueFactory(subscriber);
+      if (queue.readPending().length > 0) subscribers.push(subscriber);
+    }
+    return subscribers;
+  }
+
+  async tick() {
+    const subscribers = this.listPendingSubscribers();
+    return this.deliverTargets(subscribers);
+  }
+
+  start() {
+    if (this.running) return;
+    this.running = true;
+    const run = () => {
+      this.tick().catch((err) => {
+        this.log(`delivery scheduler tick failed: ${err && err.message ? err.message : String(err)}`);
+      });
+    };
+    run();
+    this.timer = setInterval(run, this.intervalMs);
+    if (this.timer && typeof this.timer.unref === "function") this.timer.unref();
+  }
+
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+module.exports = {
+  DeliveryScheduler,
+  isDeliverableActivityState,
+};

package/src/runtime/daemon/index.js

@@ -8,6 +8,7 @@ const { buildStatus } = require("./status");
 const EventBus = require("../../coordination/bus");
 const { AgentProcessManager } = require("./agentProcessManager");
 const NicknameManager = require("../../coordination/bus/nickname");
+const { DeliveryQueue } = require("../../coordination/bus/deliveryQueue");
 const { generateInstanceId, subscriberToSafeName } = require("../../coordination/bus/utils");
 const { createDaemonIpcServer } = require("./ipcServer");
 const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../contracts/eventContract");
@@ -17,6 +18,7 @@ const { scheduleProviderSessionResolve, resolveSessionFromFile, persistProviderS
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
 const { createGroupOrchestrator } = require("./groupOrchestrator");
+const { DeliveryScheduler } = require("./deliveryScheduler");
 const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromRuntime } = require("../../orchestration/groups/diagram");
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
@@ -1064,46 +1066,23 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain, o
 
   function pollQueue() {
     if (!state.queueFile) return;
-    if (!fs.existsSync(state.queueFile)) return;
-    let content = "";
-    let readOk = false;
-    const processingFile = `${state.queueFile}.processing.${process.pid}.${Date.now()}`;
-    try {
-      fs.renameSync(state.queueFile, processingFile);
-      content = fs.readFileSync(processingFile, "utf8");
-      readOk = true;
-    } catch {
-      try {
-        if (fs.existsSync(processingFile)) {
-          fs.renameSync(processingFile, state.queueFile);
-        }
-      } catch {
-        // ignore rollback errors
-      }
-      return;
-    } finally {
-      if (readOk) {
-        try {
-          if (fs.existsSync(processingFile)) {
-            fs.rmSync(processingFile, { force: true });
-          }
-        } catch {
-          // ignore cleanup errors
-        }
+    const queue = new DeliveryQueue(state.queueFile);
+    queue.recover();
+    while (true) {
+      const claim = queue.claimNext();
+      if (!claim) break;
+      const evt = claim.event;
+      if (!evt) {
+        queue.completeClaim(claim);
+        continue;
       }
-    }
-
-    const lines = content.split(/\r?\n/).filter(Boolean);
-    if (!lines.length) return;
-    for (const line of lines) {
-      let evt;
       try {
-        evt = JSON.parse(line);
+        emitBusEvent(evt);
+        queue.completeClaim(claim);
       } catch {
+        queue.restoreClaim(claim);
         continue;
       }
-      if (!evt) continue;
-      emitBusEvent(evt);
       if (evt.publisher && state.pending.has(evt.publisher)) {
         state.pending.delete(evt.publisher);
         if (onStatus) {
@@ -1361,6 +1340,8 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
       log(`report bus event failed request=${meta.requestId || ""} error=${err.message || String(err)}`);
     }
   });
+  const deliveryScheduler = new DeliveryScheduler(projectRoot, { log });
+  deliveryScheduler.start();
 
   handleIpcRequest = async (req, socket) => {
     if (!req || typeof req !== "object") return;
@@ -1493,12 +1474,19 @@ 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, {
+        const result = await eventBus.send(target, message, publisher, {
           injectionMode: injection_mode,
           source,
         });
-        busBridge.markPending(target);
-        log(`bus_send target=${target} publisher=${publisher}`);
+        const resolvedTargets = Array.isArray(result && result.targets) ? result.targets : [];
+        for (const resolvedTarget of resolvedTargets) {
+          busBridge.markPending(resolvedTarget);
+        }
+        if (resolvedTargets.length === 0) busBridge.markPending(target);
+        deliveryScheduler.deliverTargets(resolvedTargets).catch((err) => {
+          log(`delivery scheduler send trigger failed target=${target} error=${err.message || String(err)}`);
+        });
+        log(`bus_send target=${target} resolved=${resolvedTargets.join(",")} publisher=${publisher}`);
         socket.write(
           `${JSON.stringify({
             type: IPC_RESPONSE_TYPES.BUS_SEND_OK,
@@ -2595,6 +2583,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     processManager.cleanup();
 
     ipcServer.stop();
+    deliveryScheduler.stop();
     busBridge.stop();
     removeSocket(projectRoot);
     removePidIfOwned(projectRoot);

package/src/runtime/daemon/reportControlBus.js

@@ -1,13 +1,16 @@
 "use strict";
 
-const fs = require("fs");
 const path = require("path");
 const { getUfooPaths } = require("../../coordination/state/paths");
 const {
-  appendJSONL,
   ensureDir,
   generateInstanceId,
 } = require("../../coordination/bus/utils");
+const {
+  DeliveryQueue,
+  QUEUE_TYPES,
+  normalizeQueueEnvelope,
+} = require("../../coordination/bus/deliveryQueue");
 
 const REPORT_CONTROL_TARGET = "ufoo-agent";
 const REPORT_CONTROL_EVENT = "agent_report";
@@ -58,8 +61,12 @@ function buildReportControlEvent(report = {}, options = {}) {
 async function enqueueAgentReport(projectRoot, report, options = {}) {
   ensureReportControlQueue(projectRoot);
 
-  const event = buildReportControlEvent(report, options);
-  appendJSONL(getReportControlQueueFile(projectRoot), event);
+  const event = normalizeQueueEnvelope(buildReportControlEvent(report, options), {
+    queueType: QUEUE_TYPES.REPORT,
+    delivery: { mode: "daemon_consume", gate: "none", max_inflight: 1 },
+    ack: { policy: "on_consume" },
+  });
+  new DeliveryQueue(getReportControlQueueFile(projectRoot)).append(event);
 
   return {
     queued: true,
@@ -72,46 +79,16 @@ async function enqueueAgentReport(projectRoot, report, options = {}) {
 
 function takeReportControlEvents(projectRoot) {
   const queueFile = getReportControlQueueFile(projectRoot);
-  if (!fs.existsSync(queueFile)) return [];
-
-  const processingFile = `${queueFile}.processing.${process.pid}.${Date.now()}.${generateInstanceId()}`;
-  let content = "";
-  let readOk = false;
-  try {
-    fs.renameSync(queueFile, processingFile);
-    content = fs.readFileSync(processingFile, "utf8");
-    readOk = true;
-  } catch {
-    try {
-      if (fs.existsSync(processingFile)) {
-        fs.renameSync(processingFile, queueFile);
-      }
-    } catch {
-      // ignore rollback errors
-    }
-    return [];
-  } finally {
-    if (readOk) {
-      try {
-        if (fs.existsSync(processingFile)) {
-          fs.rmSync(processingFile, { force: true });
-        }
-      } catch {
-        // ignore cleanup errors
-      }
-    }
+  const queue = new DeliveryQueue(queueFile);
+  const events = [];
+  queue.recover();
+  while (true) {
+    const claim = queue.claimNext();
+    if (!claim) break;
+    events.push(claim.event);
+    queue.completeClaim(claim);
   }
-
-  return content.split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
+  return events;
 }
 
 function isAgentReportControlEvent(evt) {