u-foo 1.7.3 → 1.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "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,8 +274,8 @@ 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"}],',
-    '  "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"}],',
+    '  "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,"at":"YYYY-MM-DD HH:mm","once_at_ms":1700000000000,"target":"agent-id|nickname|csv","targets":["agent-id"],"title":"optional short title","prompt":"message","id":"task-id|all"}],',
     '  "disambiguate": {"prompt":"string","candidates":[{"agent_id":"id","reason":"string"}]}',
     "}",
     "Rules:",
@@ -283,7 +283,7 @@ function buildSystemPrompt(context) {
     "- If multiple possible agents, use disambiguate with candidates and no dispatch.",
     "- If user specifies a nickname for a new agent, include ops.launch with nickname so daemon can rename.",
     "- If user requests rename, use ops.rename with agent_id and nickname (do NOT launch).",
-    "- For scheduled follow-up (cron), use ops.cron with operation=start and include every+target(s)+prompt (or at for one-time).",
+    "- For scheduled follow-up (cron), use ops.cron with operation=start and include target(s)+prompt, plus optional title; use every/interval_ms for recurring or at/once_at_ms for one-time.",
     "- To check scheduled tasks, use ops.cron with operation=list.",
     "- To stop scheduled tasks, use ops.cron with operation=stop and id (or id=all).",
     "- Use top-level assistant_call for project exploration, temporary shell tasks, and quick execution support.",
@@ -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/assistant/engine.js

@@ -18,16 +18,11 @@ function resolveAssistantEngine({
 } = {}) {
   const config = loadConfig(projectRoot);
 
-  const hasRequestedProvider = String(requestedProvider || "").trim().length > 0;
   const requested = normalizeAssistantEngine(requestedProvider);
-  const configEngine = normalizeAssistantEngine(config.assistantEngine);
   const fallback = normalizeAssistantEngine(fallbackProvider) || "codex";
 
   let selected = requested;
-  if (selected === "auto") {
-    // Explicit assistant_call provider=auto should inherit current main agent provider.
-    selected = hasRequestedProvider ? fallback : configEngine;
-  }
+  // Omitted/auto assistant providers inherit the active ufoo-agent provider.
   if (selected === "auto") selected = fallback;
   if (selected === "auto") selected = "codex";
 

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;
       }
@@ -665,6 +688,9 @@ function createCommandExecutor(options = {}) {
     const targetsRaw = String(
       kv.target || kv.targets || kv.agent || kv.agents || ""
     ).trim();
+    const title = String(
+      kv.title || kv.name || kv.label || ""
+    ).trim();
     const prompt = String(
       kv.prompt || kv.message || kv.msg || nonKvParts.join(" ") || ""
     ).trim();
@@ -672,7 +698,7 @@ function createCommandExecutor(options = {}) {
     if ((!intervalRaw && !atRaw) || !targetsRaw || !prompt) {
       logMessage(
         "error",
-        "{white-fg}✗{/white-fg} Usage: /cron start every=<10s|5m> or at=\"YYYY-MM-DD HH:mm\" target=<agent1,agent2> prompt=\"...\""
+        "{white-fg}✗{/white-fg} Usage: /cron start every=<10s|5m> or at=\"YYYY-MM-DD HH:mm\" target=<agent1,agent2> [title=\"...\"] prompt=\"...\""
       );
       return;
     }
@@ -705,21 +731,18 @@ function createCommandExecutor(options = {}) {
     }
 
     if (typeof requestCron === "function") {
+      const request = {
+        operation: "start",
+        targets,
+        prompt,
+      };
+      if (title) request.title = title;
       if (atMs > 0) {
-        requestCron({
-          operation: "start",
-          once_at_ms: atMs,
-          targets,
-          prompt,
-        });
+        request.once_at_ms = atMs;
       } else {
-        requestCron({
-          operation: "start",
-          interval_ms: intervalMs,
-          targets,
-          prompt,
-        });
+        request.interval_ms = intervalMs;
       }
+      requestCron(request);
       schedule(requestStatus, 200);
       return;
     }
@@ -729,11 +752,13 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    const task = createCronTask({
+    const taskPayload = {
       intervalMs,
       targets,
       prompt,
-    });
+    };
+    if (title) taskPayload.title = title;
+    const task = createCronTask(taskPayload);
     if (!task) {
       logMessage("error", "{white-fg}✗{/white-fg} Failed to create cron task");
       return;
@@ -741,7 +766,7 @@ function createCommandExecutor(options = {}) {
 
     logMessage(
       "system",
-      `{white-fg}✓{/white-fg} Cron started ${task.id}: ${atMs > 0 ? `at ${formatCronAt(atMs)}` : `every ${formatIntervalMs(intervalMs)}`} -> ${targets.join(", ")}`
+      `{white-fg}✓{/white-fg} Cron started ${task.id}: ${task.label || `${atMs > 0 ? `at ${formatCronAt(atMs)}` : `every ${formatIntervalMs(intervalMs)}`} -> ${targets.join(", ")}`}`
     );
   }
 

package/src/chat/commands.js

@@ -30,7 +30,7 @@ const COMMAND_TREE = {
   "/cron": {
     desc: "Cron scheduler operations",
     children: {
-      start: { desc: "Create cron task" },
+      start: { desc: "Create cron task (optional title)" },
       list: { desc: "List cron tasks" },
       stop: { desc: "Stop cron task by id or all" },
     },

package/src/chat/cronScheduler.js

@@ -29,13 +29,39 @@ function sanitizeSummaryText(value = "") {
     .trim();
 }
 
+function truncateCronText(value = "", maxLength = 24) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 3))}...`;
+}
+
+function resolveTaskTitle(task = {}) {
+  const explicitTitle = truncateCronText(
+    sanitizeSummaryText(task.title || "").replace(/:/g, "-"),
+    24
+  );
+  if (explicitTitle) return explicitTitle;
+  const fallbackTitle = truncateCronText(
+    sanitizeSummaryText(task.prompt || "").replace(/:/g, "-"),
+    24
+  );
+  return fallbackTitle || "(empty)";
+}
+
+function buildTaskLabel(task = {}) {
+  const targets = Array.isArray(task.targets) && task.targets.length > 0
+    ? task.targets.join("+")
+    : "unknown";
+  const title = resolveTaskTitle(task);
+  const interval = formatIntervalMs(task.intervalMs || 0);
+  return `${targets}:${title}:${interval}`;
+}
+
 function summarizeTask(task = {}) {
   const id = String(task.id || "");
-  const interval = formatIntervalMs(task.intervalMs || 0);
-  const targets = Array.isArray(task.targets) ? task.targets.join("+") : "";
-  const promptRaw = sanitizeSummaryText(task.prompt || "");
-  const prompt = promptRaw.length > 24 ? `${promptRaw.slice(0, 24)}...` : promptRaw;
-  return `${id}@${interval}->${targets}: ${prompt || "(empty)"}`;
+  const label = buildTaskLabel(task);
+  return id ? `${id} ${label}` : label;
 }
 
 function createCronScheduler(options = {}) {
@@ -58,7 +84,7 @@ function createCronScheduler(options = {}) {
     }
   }
 
-  function addTask({ intervalMs = 0, targets = [], prompt = "" } = {}) {
+  function addTask({ intervalMs = 0, targets = [], prompt = "", title = "" } = {}) {
     const safeInterval = Number.parseInt(intervalMs, 10);
     const safeTargets = Array.isArray(targets)
       ? targets.map((item) => String(item || "").trim()).filter(Boolean)
@@ -74,6 +100,7 @@ function createCronScheduler(options = {}) {
       intervalMs: safeInterval,
       targets: Array.from(new Set(safeTargets)),
       prompt: safePrompt,
+      title: resolveTaskTitle({ title, prompt: safePrompt }),
       createdAt: nowFn(),
       lastRunAt: 0,
       tickCount: 0,
@@ -100,6 +127,7 @@ function createCronScheduler(options = {}) {
     notifyChange();
     return {
       ...task,
+      label: buildTaskLabel(task),
       summary: summarizeTask(task),
     };
   }
@@ -110,9 +138,11 @@ function createCronScheduler(options = {}) {
       intervalMs: task.intervalMs,
       targets: task.targets.slice(),
       prompt: task.prompt,
+      title: task.title,
       createdAt: task.createdAt,
       lastRunAt: task.lastRunAt,
       tickCount: task.tickCount,
+      label: buildTaskLabel(task),
       summary: summarizeTask(task),
     }));
   }
@@ -155,6 +185,7 @@ function createCronScheduler(options = {}) {
 module.exports = {
   parseIntervalMs,
   formatIntervalMs,
+  buildTaskLabel,
   summarizeTask,
   createCronScheduler,
 };

package/src/chat/daemonMessageRouter.js

@@ -254,12 +254,12 @@ function createDaemonMessageRouter(options = {}) {
         if (task.mode === "once") {
           logMessage(
             "system",
-            `{white-fg}✓{/white-fg} Cron scheduled ${escapeBlessed(task.id)} at ${escapeBlessed(task.onceAt || String(task.onceAtMs || ""))}`
+            `{white-fg}✓{/white-fg} Cron scheduled ${escapeBlessed(task.id)}: ${escapeBlessed(task.label || task.onceAt || String(task.onceAtMs || ""))}`
           );
         } else {
           logMessage(
             "system",
-            `{white-fg}✓{/white-fg} Cron started ${escapeBlessed(task.id)}: every ${escapeBlessed(task.interval || String(task.intervalMs || ""))}`
+            `{white-fg}✓{/white-fg} Cron started ${escapeBlessed(task.id)}: ${escapeBlessed(task.label || task.interval || String(task.intervalMs || ""))}`
           );
         }
       } else if (operation === "stop") {

package/src/chat/dashboardKeyController.js

@@ -18,7 +18,6 @@ function createDashboardKeyController(options = {}) {
     exitDashboardMode = () => {},
     setLaunchMode = () => {},
     setAgentProvider = () => {},
-    setAssistantEngine = () => {},
     setAutoResume = () => {},
     clampAgentWindow = () => {},
     clampAgentWindowWithSelection = () => {},
@@ -232,10 +231,7 @@ function createDashboardKeyController(options = {}) {
     }
 
     if (key.name === "down") {
-      state.dashboardView = "assistant";
-      const list = Array.isArray(state.assistantOptions) ? state.assistantOptions : [];
-      const nextIndex = list.findIndex((opt) => opt.value === state.assistantEngine);
-      state.selectedAssistantIndex = nextIndex >= 0 ? nextIndex : 0;
+      state.dashboardView = "cron";
       renderDashboardAndScreen();
       return true;
     }
@@ -261,67 +257,9 @@ function createDashboardKeyController(options = {}) {
     return true;
   }
 
-  function handleAssistantKey(key) {
-    const options = Array.isArray(state.assistantOptions) ? state.assistantOptions : [];
-    if (options.length === 0) {
-      if (key.name === "up") {
-        state.dashboardView = "provider";
-        renderDashboardAndScreen();
-        return true;
-      }
-      if (key.name === "escape" || key.name === "enter" || key.name === "return") {
-        exitDashboardMode(false);
-        return true;
-      }
-      return true;
-    }
-
-    if (key.name === "left") {
-      state.selectedAssistantIndex = state.selectedAssistantIndex <= 0
-        ? options.length - 1
-        : state.selectedAssistantIndex - 1;
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "right") {
-      state.selectedAssistantIndex = state.selectedAssistantIndex >= options.length - 1
-        ? 0
-        : state.selectedAssistantIndex + 1;
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "up") {
-      state.dashboardView = "provider";
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "down") {
-      state.dashboardView = "cron";
-      renderDashboardAndScreen();
-      return true;
-    }
-
-    if (key.name === "enter" || key.name === "return") {
-      const selected = options[state.selectedAssistantIndex];
-      if (selected) setAssistantEngine(selected.value);
-      exitDashboardMode(false);
-      return true;
-    }
-
-    if (key.name === "escape") {
-      exitDashboardMode(false);
-      return true;
-    }
-
-    return true;
-  }
-
   function handleCronKey(key) {
     if (key.name === "up") {
-      state.dashboardView = "assistant";
+      state.dashboardView = "provider";
       renderDashboardAndScreen();
       return true;
     }
@@ -552,7 +490,6 @@ function createDashboardKeyController(options = {}) {
 
     if (state.dashboardView === "mode") return handleModeKey(key);
     if (state.dashboardView === "provider") return handleProviderKey(key);
-    if (state.dashboardView === "assistant") return handleAssistantKey(key);
     if (state.dashboardView === "resume") return handleResumeKey(key);
     if (state.dashboardView === "cron") return handleCronKey(key);
 

package/src/chat/dashboardView.js

@@ -8,14 +8,6 @@ function providerLabel(value) {
   return "codex";
 }
 
-function assistantLabel(value) {
-  if (value === "codex") return "codex";
-  if (value === "claude") return "claude";
-  if (value === "ufoo") return "ucode";
-  if (value === "ucode") return "ucode";
-  return "auto";
-}
-
 function ensureAtPrefix(value) {
   const text = String(value || "").trim();
   if (!text) return text;
@@ -43,7 +35,6 @@ function buildSummaryLine(options = {}) {
     getAgentState = () => "",
     launchMode = "terminal",
     agentProvider = "codex-cli",
-    assistantEngine = "auto",
     cronTasks = [],
   } = options;
   const agents = activeAgents.length > 0
@@ -55,7 +46,6 @@ function buildSummaryLine(options = {}) {
   return `{gray-fg}Agents:{/gray-fg} {cyan-fg}${agents}{/cyan-fg}`
     + `  {gray-fg}Mode:{/gray-fg} {cyan-fg}${launchMode}{/cyan-fg}`
     + `  {gray-fg}Agent:{/gray-fg} {cyan-fg}${providerLabel(agentProvider)}{/cyan-fg}`
-    + `  {gray-fg}Assistant:{/gray-fg} {cyan-fg}${assistantLabel(assistantEngine)}{/cyan-fg}`
     + `  {gray-fg}Cron:{/gray-fg} {cyan-fg}${Array.isArray(cronTasks) ? cronTasks.length : 0}{/cyan-fg}`;
 }
 
@@ -134,11 +124,9 @@ function buildDashboardDetailLine(options = {}) {
     getAgentState = () => "",
     selectedModeIndex = 0,
     selectedProviderIndex = 0,
-    selectedAssistantIndex = 0,
     selectedResumeIndex = 0,
     cronTasks = [],
     providerOptions = [],
-    assistantOptions = [],
     resumeOptions = [],
     dashHints = {},
     modeOptions = DEFAULT_MODE_OPTIONS,
@@ -171,18 +159,6 @@ function buildDashboardDetailLine(options = {}) {
     return { content, windowStart };
   }
 
-  if (dashboardView === "assistant") {
-    const assistantParts = assistantOptions.map((opt, i) => {
-      if (i === selectedAssistantIndex) {
-        return `{inverse}${opt.label}{/inverse}`;
-      }
-      return `{cyan-fg}${opt.label}{/cyan-fg}`;
-    });
-    content += `{gray-fg}Assistant:{/gray-fg} ${assistantParts.join("  ")}`;
-    content += `  {gray-fg}│ ${dashHints.assistant || ""}{/gray-fg}`;
-    return { content, windowStart };
-  }
-
   if (dashboardView === "resume") {
     const resumeParts = resumeOptions.map((opt, i) => {
       if (i === selectedResumeIndex) {
@@ -198,9 +174,9 @@ function buildDashboardDetailLine(options = {}) {
   if (dashboardView === "cron") {
     const items = Array.isArray(cronTasks) ? cronTasks : [];
     const summary = items.length > 0
-      ? items.map((item) => item.summary || item.id || "").filter(Boolean).join(", ")
+      ? items.map((item) => item.label || item.summary || item.id || "").filter(Boolean).join(", ")
       : "none";
-    content += `{gray-fg}Cron:{/gray-fg} {cyan-fg}${summary}{/cyan-fg}`;
+    content += `{gray-fg}Cron:{/gray-fg} {inverse}${summary}{/inverse}`;
     content += `  {gray-fg}│ ${dashHints.cron || ""}{/gray-fg}`;
     return { content, windowStart };
   }
@@ -259,14 +235,11 @@ function computeDashboardContent(options = {}) {
     getAgentState = () => "",
     launchMode = "terminal",
     agentProvider = "codex-cli",
-    assistantEngine = "auto",
     selectedModeIndex = 0,
     selectedProviderIndex = 0,
-    selectedAssistantIndex = 0,
     selectedResumeIndex = 0,
     cronTasks = [],
     providerOptions = [],
-    assistantOptions = [],
     resumeOptions = [],
     dashHints = {},
     modeOptions = DEFAULT_MODE_OPTIONS,
@@ -297,7 +270,6 @@ function computeDashboardContent(options = {}) {
         getAgentState,
         launchMode,
         agentProvider,
-        assistantEngine,
         cronTasks,
       });
       return {
@@ -317,11 +289,9 @@ function computeDashboardContent(options = {}) {
       getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
-      selectedAssistantIndex,
       selectedResumeIndex,
       cronTasks,
       providerOptions,
-      assistantOptions,
       resumeOptions,
       dashHints,
       modeOptions,
@@ -344,11 +314,9 @@ function computeDashboardContent(options = {}) {
       getAgentState,
       selectedModeIndex,
       selectedProviderIndex,
-      selectedAssistantIndex,
       selectedResumeIndex,
       cronTasks,
       providerOptions,
-      assistantOptions,
       resumeOptions,
       dashHints,
       modeOptions,
@@ -362,7 +330,6 @@ function computeDashboardContent(options = {}) {
     getAgentState,
     launchMode,
     agentProvider,
-    assistantEngine,
     cronTasks,
   });
 
@@ -372,5 +339,4 @@ function computeDashboardContent(options = {}) {
 module.exports = {
   computeDashboardContent,
   providerLabel,
-  assistantLabel,
 };

package/src/chat/index.js

@@ -9,7 +9,6 @@ const {
   saveConfig,
   normalizeLaunchMode,
   normalizeAgentProvider,
-  normalizeAssistantEngine,
 } = require("../config");
 const { socketPath, isRunning } = require("../daemon");
 const UfooInit = require("../init");
@@ -104,7 +103,6 @@ async function runChat(projectRoot, options = {}) {
   const config = loadConfig(projectRoot);
   let launchMode = config.launchMode;
   let agentProvider = config.agentProvider;
-  let assistantEngine = normalizeAssistantEngine(config.assistantEngine);
   let autoResume = config.autoResume !== false;
   let cronTasks = [];
 
@@ -316,6 +314,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",
       });
     },
   });
@@ -673,7 +673,7 @@ async function runChat(projectRoot, options = {}) {
   let selectedAgentIndex = -1;  // -1 = not in dashboard selection mode
   let targetAgent = null;       // Selected agent for direct messaging
   let focusMode = "input";      // "input" or "dashboard"
-  let dashboardView = "agents"; // "projects" | "agents" | "mode" | "provider" | "assistant" | "cron"
+  let dashboardView = "agents"; // "projects" | "agents" | "mode" | "provider" | "cron"
   let reportPendingTotal = 0;
   let selectedModeIndex = Math.max(0, MODE_OPTIONS.indexOf(launchMode));
   const providerOptions = [
@@ -682,16 +682,6 @@ async function runChat(projectRoot, options = {}) {
     { label: "ucode", value: "ucode" },
   ];
   let selectedProviderIndex = Math.max(0, providerOptions.findIndex((opt) => opt.value === agentProvider));
-  const assistantOptions = [
-    { label: "auto", value: "auto" },
-    { label: "codex", value: "codex" },
-    { label: "claude", value: "claude" },
-    { label: "ucode", value: "ufoo" },
-  ];
-  let selectedAssistantIndex = Math.max(
-    0,
-    assistantOptions.findIndex((opt) => opt.value === assistantEngine)
-  );
   const resumeOptions = [
     { label: "Resume previous session", value: true },
     { label: "Start new session", value: false },
@@ -702,8 +692,7 @@ async function runChat(projectRoot, options = {}) {
     agentsGlobal: "←/→ select · Enter · ↓ mode · ↑ projects",
     agentsEmpty: "↓ mode · ↑ back",
     mode: "←/→ select · Enter · ↓ provider · ↑ back",
-    provider: "←/→ select · Enter · ↓ assistant · ↑ back",
-    assistant: "←/→ select · Enter · ↓ cron · ↑ back",
+    provider: "←/→ select · Enter · ↓ cron · ↑ back",
     cron: "Ctrl+X close · ↑ back",
     resume: "",
     projects: "Use /project switch <index|path>",
@@ -1079,12 +1068,6 @@ async function runChat(projectRoot, options = {}) {
     }
   }
 
-  function setAssistantEngine(value) {
-    if (settingsController) {
-      settingsController.setAssistantEngine(value);
-    }
-  }
-
   function setAutoResume(value) {
     if (settingsController) {
       settingsController.setAutoResume(value);
@@ -1101,7 +1084,6 @@ async function runChat(projectRoot, options = {}) {
     saveConfig,
     normalizeLaunchMode,
     normalizeAgentProvider,
-    normalizeAssistantEngine,
     fsModule: fs,
     getUfooPaths,
     logMessage,
@@ -1122,14 +1104,6 @@ async function runChat(projectRoot, options = {}) {
     setSelectedProviderIndex: (value) => {
       selectedProviderIndex = value;
     },
-    getAssistantEngine: () => assistantEngine,
-    setAssistantEngineState: (value) => {
-      assistantEngine = value;
-    },
-    setSelectedAssistantIndex: (value) => {
-      selectedAssistantIndex = value;
-    },
-    assistantOptions,
     providerOptions,
     modeOptions: MODE_OPTIONS,
     getAutoResume: () => autoResume,
@@ -1178,15 +1152,12 @@ async function runChat(projectRoot, options = {}) {
       },
       launchMode,
       agentProvider,
-      assistantEngine,
       autoResume,
       selectedModeIndex,
       selectedProviderIndex,
-      selectedAssistantIndex,
       selectedResumeIndex,
       cronTasks,
       providerOptions,
-      assistantOptions,
       resumeOptions,
       pendingReports: reportPendingTotal,
       dashHints: DASH_HINTS,
@@ -1335,10 +1306,6 @@ async function runChat(projectRoot, options = {}) {
     }
     selectedModeIndex = Math.max(0, MODE_OPTIONS.indexOf(launchMode));
     selectedProviderIndex = Math.max(0, providerOptions.findIndex((opt) => opt.value === agentProvider));
-    selectedAssistantIndex = Math.max(
-      0,
-      assistantOptions.findIndex((opt) => opt.value === assistantEngine)
-    );
     selectedResumeIndex = autoResume ? 0 : 1;
     // Immediately set @target when first agent is selected.
     if (!globalMode && selectedAgentIndex >= 0 && selectedAgentIndex < activeAgents.length) {
@@ -1366,15 +1333,12 @@ async function runChat(projectRoot, options = {}) {
     activeAgentMetaMap: { get: () => activeAgentMetaMap },
     selectedModeIndex: { get: () => selectedModeIndex, set: (value) => { selectedModeIndex = value; } },
     selectedProviderIndex: { get: () => selectedProviderIndex, set: (value) => { selectedProviderIndex = value; } },
-    selectedAssistantIndex: { get: () => selectedAssistantIndex, set: (value) => { selectedAssistantIndex = value; } },
     selectedResumeIndex: { get: () => selectedResumeIndex, set: (value) => { selectedResumeIndex = value; } },
     launchMode: { get: () => launchMode },
     agentProvider: { get: () => agentProvider },
-    assistantEngine: { get: () => assistantEngine },
     autoResume: { get: () => autoResume },
     cronTasks: { get: () => cronTasks },
     providerOptions: { get: () => providerOptions },
-    assistantOptions: { get: () => assistantOptions },
     resumeOptions: { get: () => resumeOptions },
     agentOutputSuppressed: {
       get: () => getAgentOutputSuppressed(),
@@ -1413,7 +1377,6 @@ async function runChat(projectRoot, options = {}) {
     exitDashboardMode,
     setLaunchMode,
     setAgentProvider,
-    setAssistantEngine,
     setAutoResume,
     clampAgentWindow,
     clampAgentWindowWithSelection,

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/chat/settingsController.js

@@ -6,7 +6,6 @@ function createSettingsController(options = {}) {
     saveConfig = () => {},
     normalizeLaunchMode = (value) => value,
     normalizeAgentProvider = (value) => value,
-    normalizeAssistantEngine = (value) => value,
     fsModule,
     getUfooPaths = () => ({ agentDir: "" }),
     logMessage = () => {},
@@ -19,10 +18,6 @@ function createSettingsController(options = {}) {
     getAgentProvider = () => "codex-cli",
     setAgentProviderState = () => {},
     setSelectedProviderIndex = () => {},
-    getAssistantEngine = () => "auto",
-    setAssistantEngineState = () => {},
-    setSelectedAssistantIndex = () => {},
-    assistantOptions = [],
     providerOptions = [],
     modeOptions = [],
     getAutoResume = () => true,
@@ -41,14 +36,6 @@ function createSettingsController(options = {}) {
     return value === "claude-cli" ? "claude" : "codex";
   }
 
-  function assistantLabel(value) {
-    const normalized = normalizeAssistantEngine(value);
-    if (normalized === "codex") return "codex";
-    if (normalized === "claude") return "claude";
-    if (normalized === "ufoo") return "ufoo";
-    return "auto";
-  }
-
   function clearUfooAgentIdentity() {
     const agentDir = getUfooPaths(projectRoot).agentDir;
     const stateFile = path.join(agentDir, "ufoo-agent.json");
@@ -106,26 +93,11 @@ function createSettingsController(options = {}) {
     return true;
   }
 
-  function setAssistantEngine(engine) {
-    const next = normalizeAssistantEngine(engine);
-    if (next === getAssistantEngine()) return false;
-    setAssistantEngineState(next);
-    const idx = assistantOptions.findIndex((opt) => opt && opt.value === next);
-    setSelectedAssistantIndex(idx >= 0 ? idx : 0);
-    saveConfig(projectRoot, { assistantEngine: next });
-    logMessage("status", `{white-fg}⚙{/white-fg} assistant-engine: ${assistantLabel(next)}`);
-    renderDashboard();
-    renderScreen();
-    return true;
-  }
-
   return {
     providerLabel,
-    assistantLabel,
     clearUfooAgentIdentity,
     setLaunchMode,
     setAgentProvider,
-    setAssistantEngine,
     setAutoResume,
   };
 }

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/cronOps.js

@@ -128,18 +128,41 @@ function sanitizeSummaryText(value = "") {
     .trim();
 }
 
-function summarizeCronTask(task = {}) {
-  const id = String(task.id || "");
-  const targets = Array.isArray(task.targets) ? task.targets.join("+") : "";
-  const promptRaw = sanitizeSummaryText(task.prompt || "");
-  const prompt = promptRaw.length > 24 ? `${promptRaw.slice(0, 24)}...` : promptRaw;
+function truncateCronText(value = "", maxLength = 24) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(1, maxLength - 3))}...`;
+}
 
-  if (Number(task.onceAtMs) > 0) {
-    return `${id}@once(${formatCronAtMs(task.onceAtMs)})->${targets}: ${prompt || "(empty)"}`;
-  }
+function normalizeCronTitle(value = "", prompt = "") {
+  const explicitTitle = truncateCronText(
+    sanitizeSummaryText(value || "").replace(/:/g, "-"),
+    24
+  );
+  if (explicitTitle) return explicitTitle;
+  const fallbackTitle = truncateCronText(
+    sanitizeSummaryText(prompt || "").replace(/:/g, "-"),
+    24
+  );
+  return fallbackTitle || "(empty)";
+}
 
-  const interval = formatIntervalMs(task.intervalMs || 0);
-  return `${id}@${interval}->${targets}: ${prompt || "(empty)"}`;
+function buildCronLabel(task = {}) {
+  const targets = Array.isArray(task.targets) && task.targets.length > 0
+    ? task.targets.join("+")
+    : "unknown";
+  const title = normalizeCronTitle(task.title || "", task.prompt || "");
+  const schedule = Number(task.onceAtMs) > 0
+    ? formatCronAtMs(task.onceAtMs)
+    : formatIntervalMs(task.intervalMs || 0);
+  return `${targets}:${title}:${schedule || "0s"}`;
+}
+
+function summarizeCronTask(task = {}) {
+  const id = String(task.id || "");
+  const label = buildCronLabel(task);
+  return id ? `${id} ${label}` : label;
 }
 
 function formatCronTask(task = {}) {
@@ -153,6 +176,8 @@ function formatCronTask(task = {}) {
     onceAt: onceAtMs > 0 ? formatCronAtMs(onceAtMs) : "",
     targets: Array.isArray(task.targets) ? task.targets.slice() : [],
     prompt: String(task.prompt || ""),
+    title: normalizeCronTitle(task.title || "", task.prompt || ""),
+    label: buildCronLabel(task),
     createdAt: Number(task.createdAt) || 0,
     lastRunAt: Number(task.lastRunAt) || 0,
     tickCount: Number(task.tickCount) || 0,
@@ -160,6 +185,10 @@ function formatCronTask(task = {}) {
   };
 }
 
+function resolveCronTitle(op = {}) {
+  return String(op.title || op.name || op.label || "").trim();
+}
+
 function createDaemonCronController(options = {}) {
   const {
     projectRoot = "",
@@ -198,6 +227,7 @@ function createDaemonCronController(options = {}) {
         onceAtMs: task.onceAtMs,
         targets: task.targets.slice(),
         prompt: task.prompt,
+        title: task.title,
         createdAt: task.createdAt,
         lastRunAt: task.lastRunAt,
         tickCount: task.tickCount,
@@ -275,13 +305,14 @@ function createDaemonCronController(options = {}) {
     }, task.intervalMs);
   }
 
-  function addTask({ intervalMs = 0, onceAtMs = 0, targets = [], prompt = "" } = {}) {
+  function addTask({ intervalMs = 0, onceAtMs = 0, targets = [], prompt = "", title = "" } = {}) {
     const safeInterval = Number.parseInt(intervalMs, 10);
     const safeOnceAt = Number.parseInt(onceAtMs, 10);
     const safeTargets = Array.isArray(targets)
       ? targets.map((item) => String(item || "").trim()).filter(Boolean)
       : [];
     const safePrompt = String(prompt || "").trim();
+    const safeTitle = normalizeCronTitle(title, safePrompt);
 
     if (!safePrompt || safeTargets.length === 0) return null;
 
@@ -296,6 +327,7 @@ function createDaemonCronController(options = {}) {
       onceAtMs: useOnce ? safeOnceAt : 0,
       targets: Array.from(new Set(safeTargets)),
       prompt: safePrompt,
+      title: safeTitle,
       createdAt: nowFn(),
       lastRunAt: 0,
       tickCount: 0,
@@ -367,6 +399,7 @@ function createDaemonCronController(options = {}) {
         ? item.targets.map((v) => String(v || "").trim()).filter(Boolean)
         : [];
       const prompt = String(item && item.prompt ? item.prompt : "").trim();
+      const title = normalizeCronTitle(item && item.title ? item.title : "", prompt);
 
       if (!prompt || targets.length === 0) {
         changed = true;
@@ -389,6 +422,7 @@ function createDaemonCronController(options = {}) {
         onceAtMs: Number.isFinite(onceAtMs) ? Math.floor(onceAtMs) : 0,
         targets: Array.from(new Set(targets)),
         prompt,
+        title,
         createdAt: Number(item && item.createdAt) || now,
         lastRunAt: Number(item && item.lastRunAt) || 0,
         tickCount: Number(item && item.tickCount) || 0,
@@ -535,6 +569,7 @@ function createDaemonCronController(options = {}) {
       onceAtMs,
       targets,
       prompt,
+      title: resolveCronTitle(op),
     });
 
     if (!task) {
@@ -567,8 +602,10 @@ module.exports = {
   resolveCronOperation,
   resolveCronIntervalMs,
   resolveCronOnceAtMs,
+  resolveCronTitle,
   resolveCronPrompt,
   resolveCronTaskId,
   parseCronAtMs,
+  buildCronLabel,
   formatCronTask,
 };

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(
@@ -908,9 +915,9 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           }
         } else if (result.operation === "start" && result.task) {
           if (result.task.mode === "once") {
-            reply = `Cron scheduled ${result.task.id} at ${result.task.onceAt || result.task.onceAtMs}`;
+            reply = `Cron scheduled ${result.task.id}: ${result.task.label || result.task.onceAt || result.task.onceAtMs}`;
           } else {
-            reply = `Cron started ${result.task.id}: every ${result.task.interval || result.task.intervalMs}`;
+            reply = `Cron started ${result.task.id}: ${result.task.label || result.task.interval || result.task.intervalMs}`;
           }
         } else {
           reply = "Cron updated";

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({

package/src/daemon/status.js

@@ -72,6 +72,8 @@ function normalizeCronTasks(raw = []) {
     onceAt: String(task && task.onceAt ? task.onceAt : ""),
     targets: Array.isArray(task && task.targets) ? task.targets.slice() : [],
     prompt: String(task && task.prompt ? task.prompt : ""),
+    title: String(task && task.title ? task.title : ""),
+    label: String(task && task.label ? task.label : ""),
     summary: String(task && task.summary ? task.summary : ""),
     createdAt: Number(task && task.createdAt ? task.createdAt : 0) || 0,
     lastRunAt: Number(task && task.lastRunAt ? task.lastRunAt : 0) || 0,