u-foo 2.3.1 → 2.3.3

package/package.json

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

package/src/agent/loopRuntime.js

@@ -2,6 +2,7 @@
 
 const { executeControllerTool } = require("./controllerToolExecutor");
 const { createLoopObserver } = require("./loopObservability");
+const { finalizeRouterPayload } = require("../controller/routerFinalize");
 
 const DEFAULT_LOOP_OPTIONS = {
   enabled: false,
@@ -126,34 +127,23 @@ function buildLoopContinuationPrompt({
 async function finalizeLoopRun({
   projectRoot,
   payload,
+  prompt = "",
   processManager,
   dispatchMessages,
   handleOps,
   markPending,
   finalizeLocally = true,
 }) {
-  if (finalizeLocally === false) {
-    return { ok: true, payload, opsResults: [] };
-  }
-
-  const dispatch = Array.isArray(payload.dispatch) ? payload.dispatch : [];
-  const ops = Array.isArray(payload.ops) ? payload.ops : [];
-
-  for (const item of dispatch) {
-    if (item && item.target && item.target !== "broadcast" && typeof markPending === "function") {
-      markPending(item.target);
-    }
-  }
-
-  if (typeof dispatchMessages === "function") {
-    await dispatchMessages(projectRoot, dispatch);
-  }
-
-  const opsResults = typeof handleOps === "function"
-    ? await handleOps(projectRoot, ops, processManager || null)
-    : [];
-
-  return { ok: true, payload, opsResults };
+  return finalizeRouterPayload({
+    projectRoot,
+    payload,
+    prompt,
+    processManager: processManager || null,
+    dispatchMessages,
+    handleOps,
+    markPending,
+    finalizeLocally,
+  });
 }
 
 function buildTerminalPayload(reason, lastPayload, rounds, toolCalls, toolErrors, totals = {}) {
@@ -248,6 +238,7 @@ async function runPromptWithControllerLoop({
       return finalizeLoopRun({
         projectRoot,
         payload,
+        prompt: currentPrompt,
         processManager,
         dispatchMessages,
         handleOps,
@@ -261,6 +252,7 @@ async function runPromptWithControllerLoop({
       return finalizeLoopRun({
         projectRoot,
         payload,
+        prompt: currentPrompt,
         processManager,
         dispatchMessages,
         handleOps,
@@ -357,6 +349,7 @@ async function runPromptWithControllerLoop({
       return finalizeLoopRun({
         projectRoot,
         payload: finalPayload,
+        prompt: currentPrompt,
         processManager,
         dispatchMessages,
         handleOps,
@@ -370,6 +363,7 @@ async function runPromptWithControllerLoop({
       return finalizeLoopRun({
         projectRoot,
         payload: finalPayload,
+        prompt: currentPrompt,
         processManager,
         dispatchMessages,
         handleOps,
@@ -430,6 +424,7 @@ async function runPromptWithControllerLoop({
       return finalizeLoopRun({
         projectRoot,
         payload: finalPayload,
+        prompt: currentPrompt,
         processManager,
         dispatchMessages,
         handleOps,
@@ -456,6 +451,7 @@ async function runPromptWithControllerLoop({
   return finalizeLoopRun({
     projectRoot,
     payload,
+    prompt: currentPrompt,
     processManager,
     dispatchMessages,
     handleOps,

package/src/agent/ufooAgent.js

@@ -9,6 +9,7 @@ const { normalizeProvider, sendUpstreamPrompt } = require("./upstreamTransport")
 const { normalizeAgentTypeAlias } = require("../bus/utils");
 const { buildCachedMemoryPrefix } = require("../memory");
 const { listProjectRuntimes, isGlobalControllerProjectRoot } = require("../projects");
+const { assignMissingLaunchNicknames } = require("../controller/launchRouting");
 const {
   CONTROLLER_MODES,
   resolveControllerMode,
@@ -462,6 +463,8 @@ function buildSystemPrompt(context, options = {}) {
       "- When returning tool_call, set done=false and keep dispatch/ops empty for that round.",
       "- Use dispatch_message for direct bus delivery, ack_bus for controller queue acknowledgement, and launch_agent for bounded worker launches.",
       "- When you have enough information, omit tool_call and return the final reply/dispatch/ops with done=true.",
+      "- When launching a new coding agent for a user task, include a short task-specific nickname and include a dispatch to that launched nickname with the task.",
+      "- Do not emit launch-only ops for delegated work; a launched worker must receive a task in dispatch.",
       "- Do not emit assistant_call or ops.assistant_call; that legacy helper path has been removed.",
       `- Round budget: maxRounds=${loopRuntime.maxRounds || ""}, remainingToolCalls=${loopRuntime.remainingToolCalls || 0}.`,
       agentGuidance,
@@ -505,6 +508,8 @@ function buildSystemPrompt(context, options = {}) {
     "- For short-lived exploration, prefer a dispatch to an online agent or reply with a clarification.",
     "- 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.",
+    "- When launching a new coding agent for a user task, include a short task-specific nickname and include a dispatch to that launched nickname with the task.",
+    "- Do not emit launch-only ops for delegated work; a launched worker must receive a task in dispatch.",
     "- 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.",
@@ -588,21 +593,6 @@ function buildRouteAgentSystemPrompt(context, options = {}) {
   ].join("\n");
 }
 
-function extractNickname(prompt) {
-  if (!prompt) return "";
-  const patterns = [
-    /(?:叫|名为|叫做|取名|昵称)\s*([A-Za-z0-9_-]{1,32})/i,
-    /(?:named|name)\s+([A-Za-z0-9_-]{1,32})/i,
-  ];
-  for (const re of patterns) {
-    const match = prompt.match(re);
-    if (match && match[1]) return match[1];
-  }
-  const quoted = prompt.match(/[“"']([^“"'\\]{1,32})[”"']/);
-  if (quoted && quoted[1]) return quoted[1];
-  return "";
-}
-
 function shouldUseDirectProvider(value = "") {
   const provider = normalizeProvider(value);
   return provider === "ucode" || provider === "codex" || provider === "claude";
@@ -733,15 +723,7 @@ async function runUfooAgent({
     payload = { reply: text, dispatch: [], ops: [] };
   }
 
-  const fallbackNickname = extractNickname(prompt);
-  if (fallbackNickname && payload && Array.isArray(payload.ops)) {
-    for (const op of payload.ops) {
-      if (op && (op.action === "launch" || op.action === "rename") && !op.nickname) {
-        op.nickname = fallbackNickname;
-        break;
-      }
-    }
-  }
+  payload = assignMissingLaunchNicknames(payload, { prompt, context: bus });
 
   saveSessionState(projectRoot, {
     provider,

package/src/bus/subscriber.js

@@ -122,10 +122,11 @@ class SubscriberManager {
     }
   }
 
-  async cleanupDuplicateTty(currentSubscriber, ttyPath) {
+  async cleanupDuplicateTty(currentSubscriber, ttyPath, options = {}) {
     if (!ttyPath) return null;
     if (!this.busData.agents) return null;
 
+    const currentAgentType = String(options.agentType || "").trim();
     let inheritedNickname = null;
     const entries = Object.entries(this.busData.agents);
     for (const [id, meta] of entries) {
@@ -136,8 +137,9 @@ class SubscriberManager {
         : (await this.queueManager.readTty(id));
       if (!metaTty) continue;
       if (metaTty === ttyPath) {
-        // Inherit user-set nickname from the displaced entry
-        if (meta.nickname && !inheritedNickname) {
+        const sameAgentType = !currentAgentType || meta?.agent_type === currentAgentType;
+        // Inherit user-set nickname only when replacing the same agent type.
+        if (sameAgentType && meta.nickname && !inheritedNickname) {
           inheritedNickname = meta.nickname;
         }
         // Remove stale subscriber using same tty
@@ -227,7 +229,7 @@ class SubscriberManager {
     // 清理同一 tty 的旧订阅者（避免重复启动污染）
     // Inherit nickname from displaced entry when this is a new subscriber
     // with no explicit nickname (e.g. session restart on same TTY)
-    const inheritedNickname = await this.cleanupDuplicateTty(subscriber, finalTty);
+    const inheritedNickname = await this.cleanupDuplicateTty(subscriber, finalTty, { agentType });
     if (inheritedNickname && !nickname && !existingMeta) {
       finalNickname = inheritedNickname;
       if (!finalScopedNickname) finalScopedNickname = inheritedNickname;

package/src/chat/commandExecutor.js

@@ -117,6 +117,7 @@ function createCommandExecutor(options = {}) {
     parseCommand = () => null,
     escapeBlessed = (value) => String(value || ""),
     logMessage = () => {},
+    resolveStatusLine = null,
     renderScreen = () => {},
     getActiveAgents = () => [],
     getActiveAgentMetaMap = () => new Map(),
@@ -157,6 +158,10 @@ function createCommandExecutor(options = {}) {
     throw new Error("createCommandExecutor requires projectRoot");
   }
 
+  const statusMsg = typeof resolveStatusLine === "function"
+    ? resolveStatusLine
+    : (text) => logMessage("status", text);
+
   async function handleDoctorCommand() {
     logMessage("system", "{white-fg}⚙{/white-fg} Running health check...");
 
@@ -221,51 +226,51 @@ function createCommandExecutor(options = {}) {
 
     if (subcommand === "start") {
       if (isDaemonRunning(targetRoot)) {
-        logMessage("system", "{white-fg}⚠{/white-fg} Daemon already running");
+        statusMsg("{gray-fg}⚠{/gray-fg} Daemon already running");
       } else {
-        logMessage("system", "{white-fg}⚙{/white-fg} Starting daemon...");
+        statusMsg("{gray-fg}⚙{/gray-fg} Starting daemon...");
         startDaemon(targetRoot);
         await sleep(1000);
         if (isDaemonRunning(targetRoot)) {
-          logMessage("system", "{white-fg}✓{/white-fg} Daemon started");
+          statusMsg("{gray-fg}✓{/gray-fg} Daemon started");
         } else {
-          logMessage("error", "{white-fg}✗{/white-fg} Failed to start daemon");
+          statusMsg("{gray-fg}✗{/gray-fg} Failed to start daemon");
         }
       }
       return;
     }
 
     if (subcommand === "stop") {
-      logMessage("system", "{white-fg}⚙{/white-fg} Stopping daemon...");
+      statusMsg("{gray-fg}⚙{/gray-fg} Stopping daemon...");
       stopDaemon(targetRoot);
       await sleep(1000);
       if (!isDaemonRunning(targetRoot)) {
-        logMessage("system", "{white-fg}✓{/white-fg} Daemon stopped");
+        statusMsg("{gray-fg}✓{/gray-fg} Daemon stopped");
       } else {
-        logMessage("error", "{white-fg}✗{/white-fg} Failed to stop daemon");
+        statusMsg("{gray-fg}✗{/gray-fg} Failed to stop daemon");
       }
       return;
     }
 
     if (subcommand === "restart") {
-      logMessage("system", "{white-fg}⚙{/white-fg} Restarting daemon...");
+      statusMsg("{gray-fg}⚙{/gray-fg} Restarting daemon...");
       stopDaemon(targetRoot);
       await sleep(500);
       startDaemon(targetRoot);
       await sleep(1000);
       if (isDaemonRunning(targetRoot)) {
-        logMessage("system", "{white-fg}✓{/white-fg} Daemon restarted");
+        statusMsg("{gray-fg}✓{/gray-fg} Daemon restarted");
       } else {
-        logMessage("error", "{white-fg}✗{/white-fg} Failed to restart daemon");
+        statusMsg("{gray-fg}✗{/gray-fg} Failed to restart daemon");
       }
       return;
     }
 
     if (subcommand === "status") {
       if (isDaemonRunning(targetRoot)) {
-        logMessage("system", "{white-fg}✓{/white-fg} Daemon is running");
+        statusMsg("{gray-fg}✓{/gray-fg} Daemon is running");
       } else {
-        logMessage("system", "{white-fg}✗{/white-fg} Daemon is not running");
+        statusMsg("{gray-fg}✗{/gray-fg} Daemon is not running");
       }
       return;
     }

package/src/chat/daemonMessageRouter.js

@@ -37,6 +37,14 @@ function createDaemonMessageRouter(options = {}) {
     return text.includes(":") && !text.includes(" ");
   }
 
+  function speakerPrefix(label, color = "cyan") {
+    const escapedLabel = escapeBlessed(label);
+    if (color === "white") {
+      return `{white-fg}${escapedLabel}{/white-fg} {gray-fg}·{/gray-fg} `;
+    }
+    return `{cyan-fg}${escapedLabel}{/cyan-fg} {gray-fg}·{/gray-fg} `;
+  }
+
   function normalizeDisplayMessage(raw) {
     let displayMessage = raw || "";
     let streamPayload = null;
@@ -77,9 +85,9 @@ function createDaemonMessageRouter(options = {}) {
         resolveBusStatus(item);
         if (text) {
           const prefix = data.phase === BUS_STATUS_PHASES.ERROR
-            ? "{white-fg}✗{/white-fg}"
-            : "{white-fg}✓{/white-fg}";
-          logMessage("status", `${prefix} ${escapeBlessed(text)}`, data);
+            ? "{gray-fg}✗{/gray-fg}"
+            : "{gray-fg}✓{/gray-fg}";
+          resolveStatusLine(`${prefix} ${escapeBlessed(text)}`, data);
         }
       } else {
         enqueueBusStatus(item);
@@ -214,7 +222,7 @@ function createDaemonMessageRouter(options = {}) {
       );
       // Suppress lifecycle confirmations from chat history — status line plus structured payload is enough.
       if (!isLifecycleStatusOnly && !isGroupStartedConfirmation) {
-        logMessage("reply", `{white-fg}←{/white-fg} ${escapeBlessed(replyText)}`);
+        logMessage("reply", `${speakerPrefix("ufoo", "white")}${escapeBlessed(replyText)}`);
       }
     }
 
@@ -352,15 +360,11 @@ function createDaemonMessageRouter(options = {}) {
       const publisher = report.agent_id || data.publisher || "ufoo-agent";
       const displayName = resolveAgentDisplayName(publisher);
       const detail = report.summary || report.message || data.message || report.task_id || "report";
-      logMessage(
-        "system",
-        `{gray-fg}↥{/gray-fg} {cyan-fg}${escapeBlessed(displayName)}{/cyan-fg} {gray-fg}→ ufoo-agent{/gray-fg} ${escapeBlessed(detail)}`
-      );
+      logMessage("bus", `${speakerPrefix(displayName)}${escapeBlessed(detail)}`);
       requestStatus();
       renderScreen();
       return true;
     }
-    const prefix = data.event === "broadcast" ? "{gray-fg}⇢{/gray-fg}" : "{gray-fg}↔{/gray-fg}";
     const publisher = data.publisher && data.publisher !== "unknown"
       ? data.publisher
       : (data.event === "broadcast" ? "broadcast" : "bus");
@@ -399,7 +403,7 @@ function createDaemonMessageRouter(options = {}) {
     }
 
     const pendingBeforeMessage = getPendingState(publisher, displayName);
-    const prefixLabel = `${prefix} {gray-fg}${escapeBlessed(displayName)}{/gray-fg}: `;
+    const prefixLabel = speakerPrefix(displayName);
     const continuationPrefix = " ".repeat(stripBlessedTags(prefixLabel).length);
 
     if (streamPayload) {

package/src/chat/index.js

@@ -1905,6 +1905,7 @@ async function runChat(projectRoot, options = {}) {
     renderDashboard,
     renderScreen: () => screen.render(),
     logMessage,
+    resolveStatusLine,
     escapeBlessed,
   });
 
@@ -1919,6 +1920,7 @@ async function runChat(projectRoot, options = {}) {
     parseCommand,
     escapeBlessed,
     logMessage,
+    resolveStatusLine,
     renderScreen: () => screen.render(),
     getActiveAgents: () => activeAgents,
     getActiveAgentMetaMap: () => activeAgentMetaMap,

package/src/chat/inputMath.js

@@ -76,35 +76,30 @@ function getWrapWidth(input, fallbackWidth) {
 
 /**
  * Simulate blessed's wrapping for a single logical line (no newlines).
- * Returns { rows, lastCol }.
+ * Returns the zero-based visual row and column at the end of the line.
  *
- * Blessed preprocesses double-width chars by inserting a \x03 marker after
- * each one, then wraps at character count = width. This means a double-width
- * char at col (width - 1) overflows by 1 cell — only the \x03 marker wraps
- * to the next line. We replicate this behavior so cursor math matches what
- * blessed actually renders.
+ * A cursor at exactly width cells is still at the end of the current visual
+ * row; it should not become a phantom row until another character or an
+ * explicit newline is processed.
  */
-function wrapLine(line, width, strWidth) {
+function measureLineEnd(line, width, strWidth) {
   const chars = Array.from(String(line || ""));
+  let row = 0;
   let col = 0;
-  let rows = 1;
   for (const ch of chars) {
     const w = safeStrWidth(strWidth, ch);
     if (w === 0) continue;
-    if (col >= width) {
-      rows += 1;
-      col = col - width;
+    if (col > 0 && col + w > width) {
+      row += 1;
+      col = 0;
     }
     col += w;
   }
-  if (col > width) {
-    rows += 1;
-    col = col - width;
-  } else if (col === width) {
-    rows += 1;
-    col = 0;
-  }
-  return { rows, lastCol: col };
+  return { row, col };
+}
+
+function countLineRows(line, width, strWidth) {
+  return measureLineEnd(line, width, strWidth).row + 1;
 }
 
 function countLines(text, width, strWidth) {
@@ -114,8 +109,7 @@ function countLines(text, width, strWidth) {
   const lines = expanded.split("\n");
   let total = 0;
   for (const line of lines) {
-    const { rows, lastCol } = wrapLine(line, width, strWidth);
-    total += (lastCol === 0 && rows > 1) ? rows - 1 : rows;
+    total += countLineRows(line, width, strWidth);
   }
   return total;
 }
@@ -136,28 +130,10 @@ function getCursorRowCol(text, pos, width, strWidth) {
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i] || "";
     if (i < lines.length - 1) {
-      const { rows, lastCol } = wrapLine(line, width, strWidth);
-      row += (lastCol === 0 && rows > 1) ? rows - 1 : rows;
+      row += countLineRows(line, width, strWidth);
     } else {
-      const chars = Array.from(line);
-      let col = 0;
-      for (const ch of chars) {
-        const w = safeStrWidth(strWidth, ch);
-        if (w === 0) continue;
-        if (col >= width) {
-          row += 1;
-          col = col - width;
-        }
-        col += w;
-      }
-      if (col > width) {
-        row += 1;
-        col = col - width;
-      } else if (col === width) {
-        row += 1;
-        col = 0;
-      }
-      return { row, col };
+      const measured = measureLineEnd(line, width, strWidth);
+      return { row: row + measured.row, col: measured.col };
     }
   }
   return { row, col: 0 };
@@ -187,27 +163,20 @@ function getCursorPosForRowCol(text, targetRow, targetCol, width, strWidth) {
         lineOffset += ch.length;
         continue;
       }
-      if (col >= width) {
+      if (col > 0 && col + w > width) {
+        if (row === targetRow && targetCol >= col) {
+          return expandedToOriginal(original, expPos + lineOffset);
+        }
         row += 1;
-        col = col - width;
+        col = 0;
       }
       if (row === targetRow && col + w > targetCol) {
         return expandedToOriginal(original, expPos + lineOffset);
       }
       col += w;
       lineOffset += ch.length;
-      if (col > width) {
-        if (row === targetRow) {
-          return expandedToOriginal(original, expPos + lineOffset);
-        }
-        row += 1;
-        col = col - width;
-      } else if (col === width) {
-        if (row === targetRow) {
-          return expandedToOriginal(original, expPos + lineOffset);
-        }
-        row += 1;
-        col = 0;
+      if (row === targetRow && col === targetCol) {
+        return expandedToOriginal(original, expPos + lineOffset);
       }
     }
 

package/src/chat/inputSubmitHandler.js

@@ -30,6 +30,12 @@ function createInputSubmitHandler(options = {}) {
     throw new Error("createInputSubmitHandler requires a mutable state object");
   }
 
+  function userEcho(text, targetLabel = "") {
+    const body = escapeBlessed(text);
+    if (!targetLabel) return body;
+    return `{magenta-fg}@${escapeBlessed(targetLabel)}{/magenta-fg} ${body}`;
+  }
+
   async function tryActivateTargetAgent(agentId) {
     const adapter = getAgentAdapter(agentId);
     const capabilities = adapter && adapter.capabilities ? adapter.capabilities : null;
@@ -88,7 +94,7 @@ function createInputSubmitHandler(options = {}) {
       const label = getAgentLabel(state.targetAgent);
       logMessage(
         "user",
-        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(label)}{/magenta-fg} ${escapeBlessed(text)}`
+        userEcho(text, label)
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(state.targetAgent);
@@ -114,10 +120,7 @@ function createInputSubmitHandler(options = {}) {
           return;
         }
         setTargetAgent(resolvedTarget);
-        logMessage(
-          "status",
-          `{white-fg}⚙{/white-fg} Target selected: @${escapeBlessed(atTarget.target)}`
-        );
+        queueStatusLine(`Target selected: @${escapeBlessed(atTarget.target)}`);
         focusInput();
         return;
       }
@@ -125,7 +128,7 @@ function createInputSubmitHandler(options = {}) {
       const message = atTarget.message.trim();
       logMessage(
         "user",
-        `{cyan-fg}→{/cyan-fg} {magenta-fg}@${escapeBlessed(atTarget.target)}{/magenta-fg} ${escapeBlessed(message)}`
+        userEcho(message, atTarget.target)
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(resolvedTarget);
@@ -142,7 +145,7 @@ function createInputSubmitHandler(options = {}) {
 
     if (text.startsWith("/")) {
       if (shouldEchoCommandInChat(text)) {
-        logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
+        logMessage("user", userEcho(text));
         renderScreen();  // Render slash command immediately
       }
       try {
@@ -188,7 +191,7 @@ function createInputSubmitHandler(options = {}) {
           allow_relevance_queue: true,
         },
       });
-      logMessage("user", `{white-fg}→{/white-fg} ${escapeBlessed(text)}`);
+      logMessage("user", userEcho(text));
       renderScreen();  // Render plain text message immediately
     }
 

package/src/chat/projectCloseController.js

@@ -23,10 +23,14 @@ function createProjectCloseController(options = {}) {
     renderDashboard = () => {},
     renderScreen = () => {},
     logMessage = () => {},
+    resolveStatusLine = null,
     escapeBlessed = (value) => String(value || ""),
   } = options;
 
   let closingProject = false;
+  const statusMsg = typeof resolveStatusLine === "function"
+    ? resolveStatusLine
+    : (text) => logMessage("status", text);
 
   function pickFallbackProjectRoot(targetProjectRoot) {
     const rows = Array.isArray(getProjects()) ? getProjects() : [];
@@ -61,7 +65,7 @@ function createProjectCloseController(options = {}) {
 
     closingProject = true;
     try {
-      logMessage("status", `{white-fg}⚙{/white-fg} Closing project ${escapedName} daemon and agents...`);
+      statusMsg(`{gray-fg}⚙{/gray-fg} Closing project ${escapedName} daemon and agents...`);
 
       let switchedTo = "";
       if (activeProjectRoot === projectRoot) {
@@ -89,9 +93,9 @@ function createProjectCloseController(options = {}) {
       renderScreen();
 
       if (wasRunning) {
-        logMessage("status", `{white-fg}✓{/white-fg} Closed project ${escapedName} daemon and agents`);
+        statusMsg(`{gray-fg}✓{/gray-fg} Closed project ${escapedName} daemon and agents`);
       } else {
-        logMessage("status", `{white-fg}✓{/white-fg} Project ${escapedName} daemon already stopped`);
+        statusMsg(`{gray-fg}✓{/gray-fg} Project ${escapedName} daemon already stopped`);
       }
 
       return {

package/src/chat/settingsController.js

@@ -75,7 +75,8 @@ function createSettingsController(options = {}) {
     setSelectedProviderIndex(Math.max(0, providerOptions.findIndex((opt) => opt.value === next)));
     saveConfig(projectRoot, { agentProvider: next });
     clearUfooAgentIdentity();
-    logMessage("status", `{white-fg}⚙{/white-fg} ufoo-agent: ${providerLabel(next)}`);
+    const statusMsg = resolveStatusLine || ((text) => logMessage("status", text));
+    statusMsg(`{gray-fg}⚙{/gray-fg} ufoo-agent: ${providerLabel(next)}`);
     renderDashboard();
     renderScreen();
     void restartDaemon();
@@ -89,7 +90,8 @@ function createSettingsController(options = {}) {
     setSelectedResumeIndex(next ? 0 : 1);
     saveConfig(projectRoot, { autoResume: next });
     const label = next ? "Resume previous session" : "Start new session";
-    logMessage("status", `{white-fg}⚙{/white-fg} Resume mode: ${label}`);
+    const statusMsg = resolveStatusLine || ((text) => logMessage("status", text));
+    statusMsg(`{gray-fg}⚙{/gray-fg} Resume mode: ${label}`);
     renderDashboard();
     renderScreen();
     return true;

package/src/controller/launchRouting.js

@@ -0,0 +1,206 @@
+"use strict";
+
+function asTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeNicknameSegment(value = "", fallback = "task") {
+  const normalized = asTrimmedString(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return normalized || fallback;
+}
+
+function stripRoutingPromptMetadata(prompt = "") {
+  let text = String(prompt || "");
+  const markers = [
+    "\nRouting request metadata (JSON):",
+    "\nPrivate runtime reports for ufoo-agent (JSON):",
+    "\nController loop state (JSON):",
+    "\nController tool results so far (JSON):",
+  ];
+  for (const marker of markers) {
+    const index = text.indexOf(marker);
+    if (index >= 0) {
+      text = text.slice(0, index);
+    }
+  }
+  return text.trim();
+}
+
+function normalizeLaunchAgentForNickname(agent = "") {
+  const raw = asTrimmedString(agent).toLowerCase();
+  if (raw === "claude" || raw === "claude-code" || raw === "uclaude") return "claude";
+  if (raw === "codex" || raw === "ucodex") return "codex";
+  if (raw === "ufoo" || raw === "ucode" || raw === "ufoo-code") return "ucode";
+  return "";
+}
+
+function nicknameCapturePattern() {
+  return "(?:`([^`]{1,32})`|[\"'“”]([^\"'“”]{1,32})[\"'“”]?|([A-Za-z0-9_-]{1,32}))";
+}
+
+function pickNicknameCapture(match) {
+  if (!match) return "";
+  for (let i = 1; i < match.length; i += 1) {
+    const value = asTrimmedString(match[i]);
+    if (value) return normalizeNicknameSegment(value, "");
+  }
+  return "";
+}
+
+function extractRequestedLaunchNickname(prompt = "") {
+  const text = stripRoutingPromptMetadata(prompt);
+  if (!text) return "";
+  const value = nicknameCapturePattern();
+  const patterns = [
+    new RegExp(`(?:launch|start|create|spawn|open|new|启动|新建|创建|拉起)[\\s\\S]{0,80}(?:named|name|nickname|叫做|叫|名为|昵称|取名|为)\\s*${value}`, "i"),
+    new RegExp(`(?:named|name|nickname|叫做|叫|名为|昵称|取名)\\s*${value}[\\s\\S]{0,80}(?:agent|worker|codex|claude|ucode|ufoo|代理|智能体)`, "i"),
+  ];
+  for (const re of patterns) {
+    const nickname = pickNicknameCapture(text.match(re));
+    if (nickname) return nickname;
+  }
+  return "";
+}
+
+function collectKeywordTokens(text = "") {
+  const specs = [
+    [/处理|修复|解决|排查/g, "fix"],
+    [/路由|主路由/g, "route"],
+    [/启动|新启动|拉起/g, "launch"],
+    [/投递|派发|发送|分发/g, "dispatch"],
+    [/任务|工作/g, "task"],
+    [/测试|验证/g, "test"],
+    [/前端|界面/g, "frontend"],
+    [/后端|服务端/g, "backend"],
+    [/设计/g, "design"],
+    [/审查|评审/g, "review"],
+    [/调试/g, "debug"],
+    [/重构/g, "refactor"],
+    [/发布/g, "release"],
+    [/文档/g, "docs"],
+    [/性能/g, "perf"],
+  ];
+  const matches = [];
+  for (const [re, token] of specs) {
+    re.lastIndex = 0;
+    let match = re.exec(text);
+    while (match) {
+      matches.push({ index: match.index, token });
+      match = re.exec(text);
+    }
+  }
+  return matches
+    .sort((a, b) => a.index - b.index)
+    .map((item) => item.token);
+}
+
+const ENGLISH_STOPWORDS = new Set([
+  "the", "a", "an", "and", "or", "to", "for", "with", "from", "this", "that",
+  "please", "pls", "ufoo", "chat", "agent", "agents", "worker", "workers",
+  "nickname", "nick", "name", "named", "new", "current", "online", "source",
+  "metadata", "json", "request", "user", "feedback", "bug", "issue",
+]);
+
+function collectEnglishTokens(text = "") {
+  const rawTokens = String(text || "").toLowerCase().match(/[a-z][a-z0-9_-]{1,24}/g) || [];
+  return rawTokens
+    .map((token) => normalizeNicknameSegment(token, ""))
+    .filter((token) => token && !ENGLISH_STOPWORDS.has(token));
+}
+
+function uniqueOrdered(values = []) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const token = normalizeNicknameSegment(value, "");
+    if (!token || seen.has(token)) continue;
+    seen.add(token);
+    result.push(token);
+  }
+  return result;
+}
+
+function toExistingNicknameSet(existingNicknames = []) {
+  if (existingNicknames instanceof Set) return new Set(existingNicknames);
+  if (Array.isArray(existingNicknames)) return new Set(existingNicknames.map((item) => normalizeNicknameSegment(item, "")));
+  if (existingNicknames && typeof existingNicknames === "object") {
+    return new Set(Object.keys(existingNicknames).map((item) => normalizeNicknameSegment(item, "")));
+  }
+  return new Set();
+}
+
+function truncateNickname(value = "", maxLength = 32) {
+  const normalized = normalizeNicknameSegment(value, "task");
+  if (normalized.length <= maxLength) return normalized;
+  return normalized.slice(0, maxLength).replace(/-+$/g, "") || "task";
+}
+
+function makeUniqueNickname(base, existingNicknames = []) {
+  const existing = toExistingNicknameSet(existingNicknames);
+  const normalizedBase = truncateNickname(base);
+  if (!existing.has(normalizedBase)) return normalizedBase;
+  for (let i = 2; i < 100; i += 1) {
+    const suffix = `-${i}`;
+    const candidate = `${truncateNickname(normalizedBase, 32 - suffix.length)}${suffix}`;
+    if (!existing.has(candidate)) return candidate;
+  }
+  return `${truncateNickname(normalizedBase, 27)}-${Date.now().toString(36).slice(-4)}`;
+}
+
+function collectExistingNicknames(context = {}) {
+  const values = [];
+  if (context && typeof context === "object") {
+    if (context.nicknames && typeof context.nicknames === "object") {
+      values.push(...Object.keys(context.nicknames));
+    }
+    if (Array.isArray(context.agents)) {
+      for (const agent of context.agents) {
+        if (agent && agent.nickname) values.push(agent.nickname);
+      }
+    }
+  }
+  return values;
+}
+
+function buildLaunchNickname(prompt = "", agent = "", existingNicknames = []) {
+  const explicit = extractRequestedLaunchNickname(prompt);
+  if (explicit) return makeUniqueNickname(explicit, existingNicknames);
+
+  const corePrompt = stripRoutingPromptMetadata(prompt);
+  const agentPrefix = normalizeLaunchAgentForNickname(agent) || "agent";
+  const tokens = uniqueOrdered([
+    ...collectKeywordTokens(corePrompt),
+    ...collectEnglishTokens(corePrompt),
+  ]).filter((token) => token !== agentPrefix);
+  const stem = tokens.slice(0, 2).join("-") || "task";
+  return makeUniqueNickname(`${agentPrefix}-${stem}`, existingNicknames);
+}
+
+function assignMissingLaunchNicknames(payload = {}, options = {}) {
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.ops)) return payload;
+  const existing = new Set(collectExistingNicknames(options.context));
+  let changed = false;
+  const ops = payload.ops.map((op) => {
+    if (!op || op.action !== "launch" || op.nickname) return op;
+    const count = Number.parseInt(op.count || 1, 10);
+    if (Number.isFinite(count) && count > 1) return op;
+    const nickname = buildLaunchNickname(options.prompt || "", op.agent || "", existing);
+    existing.add(nickname);
+    changed = true;
+    return { ...op, nickname };
+  });
+  return changed ? { ...payload, ops } : payload;
+}
+
+module.exports = {
+  assignMissingLaunchNicknames,
+  buildLaunchNickname,
+  collectExistingNicknames,
+  extractRequestedLaunchNickname,
+  normalizeLaunchAgentForNickname,
+  stripRoutingPromptMetadata,
+};

package/src/controller/routerFinalize.js

@@ -0,0 +1,222 @@
+"use strict";
+
+const {
+  normalizeLaunchAgentForNickname,
+  stripRoutingPromptMetadata,
+} = require("./launchRouting");
+
+const LAUNCH_TARGET_PREFIX = "__ufoo_launch_";
+
+function normalizePayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    return { reply: "", dispatch: [], ops: [] };
+  }
+  return {
+    ...payload,
+    reply: typeof payload.reply === "string" ? payload.reply : "",
+    dispatch: Array.isArray(payload.dispatch) ? payload.dispatch : [],
+    ops: Array.isArray(payload.ops) ? payload.ops : [],
+  };
+}
+
+function isLaunchOp(op) {
+  return Boolean(op && op.action === "launch");
+}
+
+function hasDispatchMessage(item) {
+  return Boolean(item && String(item.target || "").trim() && String(item.message || "").trim());
+}
+
+function launchPlaceholder(index) {
+  return `${LAUNCH_TARGET_PREFIX}${index}`;
+}
+
+function parseLaunchPlaceholder(target = "") {
+  const raw = String(target || "").trim();
+  if (!raw.startsWith(LAUNCH_TARGET_PREFIX)) return -1;
+  const parsed = Number.parseInt(raw.slice(LAUNCH_TARGET_PREFIX.length), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : -1;
+}
+
+function isLaunchDispatchTarget(target = "", op = {}) {
+  const raw = String(target || "").trim();
+  if (!raw || raw.includes(":")) return false;
+  const normalized = raw.toLowerCase();
+  const nickname = String(op.nickname || "").trim();
+  if (nickname && raw === nickname) return true;
+  const placeholders = new Set([
+    "new",
+    "new-agent",
+    "new-worker",
+    "worker",
+    "agent",
+    "launched",
+    "launched-agent",
+    "launched-worker",
+  ]);
+  if (placeholders.has(normalized)) return true;
+  const launchAgent = normalizeLaunchAgentForNickname(op.agent || "");
+  return Boolean(launchAgent && normalizeLaunchAgentForNickname(raw) === launchAgent);
+}
+
+function resolveLaunchResultTarget(op = {}, result = {}) {
+  if (result && result.agent_id) return String(result.agent_id);
+  if (result && Array.isArray(result.subscriber_ids) && result.subscriber_ids[0]) {
+    return String(result.subscriber_ids[0]);
+  }
+  if (result && result.subscriber_id) return String(result.subscriber_id);
+  if (result && result.nickname) return String(result.nickname);
+  if (op && op.nickname) return String(op.nickname);
+  return "";
+}
+
+function resolveDispatchLaunchIndex(dispatchItem = {}, launchOps = []) {
+  const target = String(dispatchItem.target || "").trim();
+  const placeholderIndex = parseLaunchPlaceholder(target);
+  if (placeholderIndex >= 0) return placeholderIndex;
+
+  for (let i = 0; i < launchOps.length; i += 1) {
+    if (isLaunchDispatchTarget(target, launchOps[i])) return i;
+  }
+  return -1;
+}
+
+function prepareLaunchDispatchPayload(payload, prompt = "") {
+  const normalized = normalizePayload(payload);
+  const launchOps = [];
+  const otherOps = [];
+  for (const op of normalized.ops) {
+    if (isLaunchOp(op)) launchOps.push(op);
+    else if (op) otherOps.push(op);
+  }
+
+  if (launchOps.length === 0) {
+    return {
+      payload: normalized,
+      launchOps,
+      otherOps,
+      dispatch: normalized.dispatch.filter(hasDispatchMessage),
+    };
+  }
+
+  let dispatch = normalized.dispatch.filter(hasDispatchMessage).map((item) => ({ ...item }));
+  const taskMessage = stripRoutingPromptMetadata(prompt);
+  if (dispatch.length === 0 && !taskMessage) {
+    return {
+      payload: { ...normalized, dispatch: [], ops: otherOps },
+      launchOps: [],
+      otherOps,
+      dispatch: [],
+      droppedLaunches: launchOps,
+    };
+  }
+
+  if (dispatch.length === 0 && taskMessage) {
+    dispatch = launchOps.map((op, index) => ({
+      target: op.nickname || launchPlaceholder(index),
+      message: taskMessage,
+      injection_mode: "immediate",
+      source: "ufoo-agent",
+    }));
+  } else if (launchOps.length === 1) {
+    const fallbackTarget = launchOps[0].nickname || launchPlaceholder(0);
+    dispatch = dispatch.map((item) => (
+      isLaunchDispatchTarget(item.target, launchOps[0])
+        ? { ...item, target: fallbackTarget }
+        : item
+    ));
+  }
+
+  return {
+    payload: { ...normalized, dispatch, ops: [...launchOps, ...otherOps] },
+    launchOps,
+    otherOps,
+    dispatch,
+  };
+}
+
+function bindDispatchToLaunchResults(dispatch = [], launchOps = [], launchResults = []) {
+  const resultByIndex = launchResults.filter((item) => item && item.action === "launch");
+  return dispatch.map((item) => {
+    const index = resolveDispatchLaunchIndex(item, launchOps);
+    if (index < 0) return item;
+    const target = resolveLaunchResultTarget(launchOps[index], resultByIndex[index] || {});
+    return target ? { ...item, target } : item;
+  });
+}
+
+async function finalizeRouterPayload({
+  projectRoot,
+  payload,
+  prompt = "",
+  processManager,
+  dispatchMessages,
+  handleOps,
+  markPending = () => {},
+  finalizeLocally = true,
+}) {
+  const prepared = prepareLaunchDispatchPayload(payload, prompt);
+  if (finalizeLocally === false) {
+    return {
+      ok: true,
+      payload: prepared.payload,
+      opsResults: [],
+    };
+  }
+
+  if (prepared.launchOps.length === 0) {
+    for (const item of prepared.dispatch) {
+      if (item && item.target && item.target !== "broadcast") {
+        markPending(item.target);
+      }
+    }
+    if (typeof dispatchMessages === "function") {
+      await dispatchMessages(projectRoot, prepared.dispatch);
+    }
+    const opsResults = typeof handleOps === "function" && prepared.otherOps.length > 0
+      ? await handleOps(projectRoot, prepared.otherOps, processManager)
+      : [];
+    return {
+      ok: true,
+      payload: { ...prepared.payload, dispatch: prepared.dispatch, ops: prepared.otherOps },
+      opsResults,
+    };
+  }
+
+  const launchResults = typeof handleOps === "function"
+    ? await handleOps(projectRoot, prepared.launchOps, processManager)
+    : [];
+  const boundDispatch = bindDispatchToLaunchResults(prepared.dispatch, prepared.launchOps, launchResults);
+
+  for (const item of boundDispatch) {
+    if (item && item.target && item.target !== "broadcast") {
+      markPending(item.target);
+    }
+  }
+  if (typeof dispatchMessages === "function") {
+    await dispatchMessages(projectRoot, boundDispatch);
+  }
+
+  const otherResults = typeof handleOps === "function" && prepared.otherOps.length > 0
+    ? await handleOps(projectRoot, prepared.otherOps, processManager)
+    : [];
+
+  return {
+    ok: true,
+    payload: { ...prepared.payload, dispatch: boundDispatch },
+    opsResults: [...launchResults, ...otherResults],
+  };
+}
+
+module.exports = {
+  bindDispatchToLaunchResults,
+  finalizeRouterPayload,
+  normalizePayload,
+  prepareLaunchDispatchPayload,
+  __private: {
+    isLaunchDispatchTarget,
+    launchPlaceholder,
+    resolveLaunchResultTarget,
+    stripRoutingPromptMetadata,
+  },
+};

package/src/daemon/promptLoop.js

@@ -1,3 +1,5 @@
+const { finalizeRouterPayload } = require("../controller/routerFinalize");
+
 function normalizePayload(payload) {
   if (!payload || typeof payload !== "object") {
     return { reply: "", dispatch: [], ops: [] };
@@ -36,34 +38,23 @@ function stripAssistantCall(payload) {
 async function finalizePromptRun({
   projectRoot,
   payload,
+  prompt,
   processManager,
   dispatchMessages,
   handleOps,
   markPending,
   finalizeLocally = true,
 }) {
-  if (finalizeLocally === false) {
-    return {
-      ok: true,
-      payload,
-      opsResults: [],
-    };
-  }
-
-  for (const item of payload.dispatch || []) {
-    if (item && item.target && item.target !== "broadcast") {
-      markPending(item.target);
-    }
-  }
-
-  await dispatchMessages(projectRoot, payload.dispatch || []);
-  const opsResults = await handleOps(projectRoot, payload.ops || [], processManager);
-
-  return {
-    ok: true,
+  return finalizeRouterPayload({
+    projectRoot,
     payload,
-    opsResults,
-  };
+    prompt,
+    processManager,
+    dispatchMessages,
+    handleOps,
+    markPending,
+    finalizeLocally,
+  });
 }
 
 async function runPromptWithAssistant({
@@ -129,6 +120,7 @@ async function runPromptWithAssistant({
   return finalizePromptRun({
     projectRoot,
     payload: firstPayload,
+    prompt: prompt || "",
     processManager,
     dispatchMessages,
     handleOps,