u-foo 2.3.2 → 2.3.4

package/package.json

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

package/src/agent/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/chat/agentBar.js

@@ -33,8 +33,8 @@ function computeAgentBar(options = {}) {
   let windowItems = Math.max(1, Math.min(maxAgentWindow, activeAgents.length));
   let start = agentListWindowStart;
   const ufooItem = focusMode === "dashboard" && selectedAgentIndex === 0
-    ? "\x1b[90;7mucode\x1b[0m"
-    : "\x1b[36mucode\x1b[0m";
+    ? "\x1b[90;7mufoo\x1b[0m"
+    : "\x1b[36mufoo\x1b[0m";
   const ufooLen = stripAnsi(ufooItem).length;
 
   const computeStart = (items) => {
@@ -78,7 +78,7 @@ function computeAgentBar(options = {}) {
         const prefix = indicator
           ? `${indicatorColor}${indicator}\x1b[0m`
           : "";
-        const idx = s + i + 1; // +1 for ucode at index 0
+        const idx = s + i + 1; // +1 for ufoo chat at index 0
         if (focusMode === "dashboard" && idx === selectedAgentIndex) {
           return `${prefix}\x1b[90;7m${label}\x1b[0m`;
         }

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,8 +30,10 @@ function createInputSubmitHandler(options = {}) {
     throw new Error("createInputSubmitHandler requires a mutable state object");
   }
 
-  function userPrefix() {
-    return "{white-fg}you{/white-fg} {gray-fg}·{/gray-fg}";
+  function userEcho(text, targetLabel = "") {
+    const body = escapeBlessed(text);
+    if (!targetLabel) return body;
+    return `{magenta-fg}@${escapeBlessed(targetLabel)}{/magenta-fg} ${body}`;
   }
 
   async function tryActivateTargetAgent(agentId) {
@@ -92,7 +94,7 @@ function createInputSubmitHandler(options = {}) {
       const label = getAgentLabel(state.targetAgent);
       logMessage(
         "user",
-        `${userPrefix()} {magenta-fg}@${escapeBlessed(label)}{/magenta-fg} ${escapeBlessed(text)}`
+        userEcho(text, label)
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(state.targetAgent);
@@ -126,7 +128,7 @@ function createInputSubmitHandler(options = {}) {
       const message = atTarget.message.trim();
       logMessage(
         "user",
-        `${userPrefix()} {magenta-fg}@${escapeBlessed(atTarget.target)}{/magenta-fg} ${escapeBlessed(message)}`
+        userEcho(message, atTarget.target)
       );
       renderScreen();  // Immediately render the user message
       markPendingDelivery(resolvedTarget);
@@ -143,7 +145,7 @@ function createInputSubmitHandler(options = {}) {
 
     if (text.startsWith("/")) {
       if (shouldEchoCommandInChat(text)) {
-        logMessage("user", `${userPrefix()} ${escapeBlessed(text)}`);
+        logMessage("user", userEcho(text));
         renderScreen();  // Render slash command immediately
       }
       try {
@@ -189,7 +191,7 @@ function createInputSubmitHandler(options = {}) {
           allow_relevance_queue: true,
         },
       });
-      logMessage("user", `${userPrefix()} ${escapeBlessed(text)}`);
+      logMessage("user", userEcho(text));
       renderScreen();  // Render plain text message immediately
     }
 

package/src/code/agent.js

@@ -1119,6 +1119,7 @@ async function runUbusCommand(state = {}, options = {}) {
         // eslint-disable-next-line no-await-in-loop
         nlResult = await runNl(message.task, state, {
           onProgress: progressReporter,
+          signal: options.signal,
         });
       } catch (err) {
         sendErrors.push(`task from ${message.publisher} failed: ${err && err.message ? err.message : "task failed"}`);
@@ -1180,7 +1181,9 @@ async function runUbusCommand(state = {}, options = {}) {
         });
       }
 
-      const nlResult = await runNl(item.task, state);
+      const nlResult = await runNl(item.task, state, {
+        signal: options.signal,
+      });
       const reply = String(formatNl(nlResult, false) || "").replace(/\s+/g, " ").trim() || "Done.";
       const sendRes = shell(`ufoo bus send ${shellQuote(item.publisher)} ${shellQuote(reply.slice(0, 2000))}`);
       if (!sendRes.ok) {

package/src/code/nativeRunner.js

@@ -9,6 +9,8 @@ const { getBashToolDescription } = require("./prompts/toolDescriptions/bash");
 const CORE_TOOL_NAMES = new Set(["read", "write", "edit", "bash"]);
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const DEFAULT_MAX_NATIVE_TOOL_CALLS = 12;
+const DEFAULT_MAX_NATIVE_TOOL_ERRORS = 1;
 
 function nowMs() {
   return Date.now();
@@ -20,6 +22,36 @@ function normalizeTimeoutMs(value) {
   return Math.max(1000, Math.floor(parsed));
 }
 
+function normalizePositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+}
+
+function resolveNativeToolBudget(env = process.env) {
+  return {
+    maxToolCalls: normalizePositiveInt(env.UFOO_UCODE_MAX_TOOL_CALLS, DEFAULT_MAX_NATIVE_TOOL_CALLS),
+    maxToolErrors: normalizePositiveInt(env.UFOO_UCODE_MAX_TOOL_ERRORS, DEFAULT_MAX_NATIVE_TOOL_ERRORS),
+  };
+}
+
+function enforceNativeToolBudget({
+  toolCallsExecuted = 0,
+  toolErrors = 0,
+  maxToolCalls = DEFAULT_MAX_NATIVE_TOOL_CALLS,
+  maxToolErrors = DEFAULT_MAX_NATIVE_TOOL_ERRORS,
+  lastTool = "",
+  lastError = "",
+} = {}) {
+  if (toolCallsExecuted > maxToolCalls) {
+    throw new Error(`tool call budget exceeded (${maxToolCalls})`);
+  }
+  if (toolErrors >= maxToolErrors) {
+    const detail = [lastTool, lastError].filter(Boolean).join(": ");
+    throw new Error(`tool error budget exceeded (${maxToolErrors})${detail ? `: ${detail}` : ""}`);
+  }
+}
+
 function createGuards({ signal = null, timeoutMs = 300000 } = {}) {
   const startedAt = nowMs();
   const budgetMs = normalizeTimeoutMs(timeoutMs);
@@ -907,6 +939,8 @@ async function runNativeLoopOpenAi({
   let aggregated = "";
   let streamed = false;
   let toolCallsExecuted = 0;
+  let toolErrors = 0;
+  const toolBudget = resolveNativeToolBudget();
 
   while (true) {
     guards.ensureActive();
@@ -991,6 +1025,17 @@ async function runNativeLoopOpenAi({
         onToolEvent,
       });
       toolCallsExecuted += 1;
+      if (!toolResult || toolResult.ok === false) {
+        toolErrors += 1;
+      }
+      enforceNativeToolBudget({
+        toolCallsExecuted,
+        toolErrors,
+        maxToolCalls: toolBudget.maxToolCalls,
+        maxToolErrors: toolBudget.maxToolErrors,
+        lastTool: toolCall.function.name,
+        lastError: toolResult && toolResult.error ? String(toolResult.error) : "",
+      });
       messages.push({
         role: "tool",
         tool_call_id: toolCall.id,
@@ -1034,6 +1079,8 @@ async function runNativeLoopAnthropic({
   let aggregated = "";
   let streamed = false;
   let toolCallsExecuted = 0;
+  let toolErrors = 0;
+  const toolBudget = resolveNativeToolBudget();
 
   while (true) {
     guards.ensureActive();
@@ -1109,6 +1156,17 @@ async function runNativeLoopAnthropic({
         onToolEvent,
       });
       toolCallsExecuted += 1;
+      if (!toolResult || toolResult.ok === false) {
+        toolErrors += 1;
+      }
+      enforceNativeToolBudget({
+        toolCallsExecuted,
+        toolErrors,
+        maxToolCalls: toolBudget.maxToolCalls,
+        maxToolErrors: toolBudget.maxToolErrors,
+        lastTool: call.name,
+        lastError: toolResult && toolResult.error ? String(toolResult.error) : "",
+      });
       toolResults.push({
         type: "tool_result",
         tool_use_id: String(call.id || ""),

package/src/code/taskDecomposer.js

@@ -147,8 +147,9 @@ async function runDecomposedTask({
         }
       }
 
-      // Stop on error for critical steps
-      if (!stepResult.ok && (step.id === "identify" || step.id === "locate")) {
+      // Stop on any step failure. A failed tool/provider call means the
+      // current plan is no longer reliable, and continuing can trigger loops.
+      if (!stepResult.ok) {
         return {
           ok: false,
           error: `Failed at ${step.name}: ${stepResult.error}`,
@@ -266,4 +267,4 @@ module.exports = {
   runDecomposedTask,
   compileSummary,
   createBusProgressReporter,
-};
+};

package/src/code/tui.js

@@ -993,6 +993,7 @@ function runUcodeTui({
         const ubusResult = await runUbusCommand(state, {
           workspaceRoot,
           subscriberId: autoBusSubscriberId,
+          signal: abortController.signal,
           onMessageReceived: (msg) => {
             // Display the incoming message immediately
             const { extractAgentNickname } = require("./agent");
@@ -1254,59 +1255,63 @@ function runUcodeTui({
         });
         let streamState = null;
         let renderedToolLogCount = 0;
-        const nlResult = await runNaturalLanguageTask(result.task, state, {
-          signal: abortController.signal,
-          onDelta: (delta) => {
-            const text = escapeStripper.write(String(delta || ""));
-            if (!text) return;
+        let nlResult = null;
+        try {
+          nlResult = await runNaturalLanguageTask(result.task, state, {
+            signal: abortController.signal,
+            onDelta: (delta) => {
+              const text = escapeStripper.write(String(delta || ""));
+              if (!text) return;
+              if (!streamState) {
+                streamState = createNlStreamState();
+              }
+              appendNlStreamDelta(streamState, text);
+            },
+            onToolLog: (entry) => {
+              renderedToolLogCount += 1;
+              logToolHint(entry);
+            },
+          });
+          const tail = escapeStripper.flush();
+          if (tail) {
             if (!streamState) {
               streamState = createNlStreamState();
             }
-            appendNlStreamDelta(streamState, text);
-          },
-          onToolLog: (entry) => {
-            renderedToolLogCount += 1;
-            logToolHint(entry);
-          },
-        });
-        const tail = escapeStripper.flush();
-        if (tail) {
-          if (!streamState) {
-            streamState = createNlStreamState();
+            appendNlStreamDelta(streamState, tail);
           }
-          appendNlStreamDelta(streamState, tail);
-        }
-        pendingTask = null;
-        updateStatus("", "none");
-        let finalStreamInfo = { lastChar: "" };
-        if (streamState) {
-          finalStreamInfo = finalizeNlStream(streamState);
-        }
-        if (Array.isArray(nlResult && nlResult.logs) && nlResult.logs.length > renderedToolLogCount) {
-          for (const entry of nlResult.logs.slice(renderedToolLogCount)) {
-            logToolHint(entry);
+          let finalStreamInfo = { lastChar: "" };
+          if (streamState) {
+            finalStreamInfo = finalizeNlStream(streamState);
           }
-        }
-        const streamed = Boolean(nlResult && nlResult.streamed);
-        const hasVisibleStreamText = Boolean(
-          streamState
-          && typeof streamState.full === "string"
-          && /[^\s]/.test(streamState.full)
-        );
-        const streamLastChar = nlResult && typeof nlResult.streamLastChar === "string"
-          ? nlResult.streamLastChar.slice(-1)
-          : finalStreamInfo.lastChar;
-        if (streamed && hasVisibleStreamText && streamLastChar !== "\n") {
-          logBox.log("");
-          screen.render();
-        }
-        const shouldSkipSummary = Boolean(streamed && nlResult && nlResult.ok && hasVisibleStreamText);
-        if (!shouldSkipSummary) {
-          logText(formatNlResult(nlResult, false));
-        }
-        const persisted = persistSessionState(state);
-        if (!persisted || persisted.ok === false) {
-          logText(`Error: failed to persist session ${state.sessionId}: ${(persisted && persisted.error) || "unknown error"}`);
+          if (Array.isArray(nlResult && nlResult.logs) && nlResult.logs.length > renderedToolLogCount) {
+            for (const entry of nlResult.logs.slice(renderedToolLogCount)) {
+              logToolHint(entry);
+            }
+          }
+          const streamed = Boolean(nlResult && nlResult.streamed);
+          const hasVisibleStreamText = Boolean(
+            streamState
+            && typeof streamState.full === "string"
+            && /[^\s]/.test(streamState.full)
+          );
+          const streamLastChar = nlResult && typeof nlResult.streamLastChar === "string"
+            ? nlResult.streamLastChar.slice(-1)
+            : finalStreamInfo.lastChar;
+          if (streamed && hasVisibleStreamText && streamLastChar !== "\n") {
+            logBox.log("");
+            screen.render();
+          }
+          const shouldSkipSummary = Boolean(streamed && nlResult && nlResult.ok && hasVisibleStreamText);
+          if (!shouldSkipSummary) {
+            logText(formatNlResult(nlResult, false));
+          }
+          const persisted = persistSessionState(state);
+          if (!persisted || persisted.ok === false) {
+            logText(`Error: failed to persist session ${state.sessionId}: ${(persisted && persisted.error) || "unknown error"}`);
+          }
+        } finally {
+          pendingTask = null;
+          updateStatus("", "none");
         }
       }
     };

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

@@ -44,6 +44,10 @@ function toTmuxBinary(agent = "") {
   return "";
 }
 
+function resolveUfooRunnerPath() {
+  return path.resolve(__dirname, "../../bin/ufoo.js");
+}
+
 function normalizeLaunchScope(value, fallback = "inplace") {
   const raw = String(value || "").trim().toLowerCase();
   if (!raw) return fallback;
@@ -546,7 +550,7 @@ async function spawnManagedHostAgent(
   if (hasPreRegisteredSubscriber) {
     // Group mode: use ufoo launcher for activity_state monitoring
     // This enables ReadyDetector and bootstrap to work correctly
-    const ufooRunner = path.join(projectRoot, "bin", "ufoo.js");
+    const ufooRunner = resolveUfooRunnerPath();
     const launchCmd = `${shellEscape(process.execPath)} ${shellEscape(ufooRunner)} agent-pty-runner ${shellEscape(normalizedAgent)}${argText}`.trim();
     runCmd = titleCmd
       ? `cd ${shellEscape(projectRoot)} && ${titleCmd} && ${launchCmd}`
@@ -591,7 +595,7 @@ async function spawnManagedHostAgent(
 }
 
 async function spawnInternalAgent(projectRoot, agent, count = 1, nickname = "", processManager = null, extraEnv = {}) {
-  const runner = path.join(projectRoot, "bin", "ufoo.js");
+  const runner = resolveUfooRunnerPath();
   const logDir = getUfooPaths(projectRoot).runDir;
   fs.mkdirSync(logDir, { recursive: true });
 

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,