u-foo 3.0.7 → 3.0.9

package/package.json

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

package/src/agents/launch/notifier.js

@@ -315,7 +315,6 @@ class AgentNotifier {
     if (this.stopped) return;
 
     const currentCount = this.getMessageCount();
-    const nowMs = Date.now();
 
     // 有新消息
     if (currentCount > this.lastCount) {
@@ -330,14 +329,22 @@ class AgentNotifier {
     }
 
     this.lastCount = this.getMessageCount();
-    if (this._launcherReady && (!this.lastWorkingAt || nowMs - this.lastWorkingAt >= this.workingHoldMs)) {
+    // Delivery moved to the daemon scheduler. ActivityDetector owns
+    // working → idle / waiting_input. Never force-idle over working here:
+    // lastWorkingAt is only set by the legacy deliverPending path, so the
+    // old hold-window check stayed permanently true and stomped real
+    // working states every poll (~2s) — Codex injections then slipped mid-turn.
+    if (this._launcherReady) {
       const currentActivityState = this.getCurrentActivityState();
-      if (currentActivityState !== "waiting_input" && currentActivityState !== "blocked") {
-        if (currentActivityState === "working") {
-          this.updateActivityState("idle", { force: true });
-        } else {
-          this.updateActivityState("idle");
-        }
+      if (
+        currentActivityState
+        && currentActivityState !== "working"
+        && currentActivityState !== "waiting_input"
+        && currentActivityState !== "blocked"
+      ) {
+        // Soft fallback only (no force): ready/starting → idle for delivery,
+        // without overriding detector-owned busy states.
+        this.updateActivityState("idle");
       }
     }
     this.refreshTitle();

package/src/code/context/executionSegment.js

@@ -27,6 +27,7 @@ function emptyExecutionState() {
     pendingUserPrompts: [],
     planGraph: require("./planGraphService").emptyPlanGraphState(),
     graphs: {},
+    archivedPlans: [],
     taskRuns: require("../runtime/taskRun").emptyTaskRunStore(),
     agentMailbox: require("../runtime/loopMailbox").emptyMailbox(),
     taskMailboxes: {},

package/src/code/context/planGraphService.js

@@ -48,6 +48,102 @@ function cloneJson(value) {
   }
 }
 
+const MAX_ARCHIVED_PLANS = 5;
+
+/**
+ * Snapshot a finished/replaced plan out of the live primary slot so the next
+ * create starts clean instead of overlaying the previous graph.
+ */
+function archivePlanGraph(executionState = null, planGraph = null, {
+  reason = "",
+} = {}) {
+  if (!executionState || typeof executionState !== "object") return null;
+  const live = planGraph && typeof planGraph === "object" ? planGraph : null;
+  const graphId = String((live && live.graphId) || "").trim();
+  if (!live || !graphId) return null;
+
+  if (!Array.isArray(executionState.archivedPlans)) {
+    executionState.archivedPlans = [];
+  }
+  const archived = {
+    ...cloneJson(live),
+    archivedAt: new Date().toISOString(),
+    archiveReason: String(reason || "").trim() || "archived",
+  };
+  executionState.archivedPlans.push(archived);
+  if (executionState.archivedPlans.length > MAX_ARCHIVED_PLANS) {
+    executionState.archivedPlans = executionState.archivedPlans.slice(-MAX_ARCHIVED_PLANS);
+  }
+  if (executionState.graphs && typeof executionState.graphs === "object") {
+    delete executionState.graphs[graphId];
+  }
+  return archived;
+}
+
+function buildPlanCompletionSummary(planGraph = null, advance = null) {
+  const pg = planGraph && typeof planGraph === "object" ? planGraph : {};
+  const nodes = Array.isArray(pg.nodes) ? pg.nodes : [];
+  const tasks = nodes.filter((node) => node && (node.type === "task" || !node.generated));
+  const succeeded = tasks.filter((n) => n.status === "succeeded").length;
+  const failed = tasks.filter((n) => (
+    n.status === "failed" || n.status === "blocked" || n.status === "cancelled"
+  )).length;
+  const lines = [
+    `Plan completed${pg.graphId ? ` (${pg.graphId})` : ""}.`,
+  ];
+  if (pg.objective) lines.push(`Objective: ${String(pg.objective).slice(0, 240)}`);
+  lines.push(`Tasks: ${succeeded} succeeded, ${failed} failed/blocked, ${tasks.length} total.`);
+  for (const node of tasks.slice(0, 12)) {
+    const bit = (node.result && node.result.summary)
+      || node.error
+      || node.status
+      || "";
+    lines.push(
+      `- ${node.id} [${node.status || "pending"}]`
+        + (bit ? `: ${String(bit).slice(0, 160)}` : ""),
+    );
+  }
+  const executed = advance && Array.isArray(advance.executedNodes) ? advance.executedNodes : [];
+  if (executed.length > 0 && tasks.length === 0) {
+    for (const entry of executed.slice(0, 8)) {
+      lines.push(`- ${entry.id}: ${entry.summary || entry.status || "done"}`);
+    }
+  }
+  lines.push("Summarize the outcome for the user. The active plan has been cleared; use plan_graph create for a new objective.");
+  return lines.join("\n");
+}
+
+/**
+ * On graph_terminal for the primary Agent Loop plan: archive, clear primary
+ * slot, and exit auto Plan Mode. Child TaskLoop graphs stay in graphs[].
+ */
+function finalizeTerminalPrimaryPlan(executionState = null, planGraph = null, advance = null) {
+  const pg = planGraph && typeof planGraph === "object" ? planGraph : null;
+  if (!pg || !pg.graphId) return null;
+  if (!advance || String(advance.yieldReason || "") !== "graph_terminal") return null;
+
+  const completionSummary = buildPlanCompletionSummary(pg, advance);
+  const archived = archivePlanGraph(executionState, pg, { reason: "graph_terminal" });
+  executionState.planGraph = emptyPlanGraphState();
+  executionState.mode = "single_action";
+
+  try {
+    const { getPlanModeSource, setPlanMode } = require("./planMode");
+    if (getPlanModeSource(executionState) === "auto") {
+      setPlanMode(executionState, false, { reason: "plan completed" });
+    }
+  } catch {
+    // planMode is optional for pure unit callers
+  }
+
+  return {
+    planCompleted: true,
+    archivedGraphId: (archived && archived.graphId) || pg.graphId,
+    completionSummary,
+    planMode: Boolean(executionState.planMode),
+  };
+}
+
 function ensurePlanGraphState(executionState = null) {
   const state = executionState && typeof executionState === "object"
     ? executionState
@@ -614,42 +710,73 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       }
       if (advanced.advance) advance = advanced.advance;
     }
-    const live = executionState.planGraph;
-    const { readyNodes, waitingNodes } = summarizeReadyWaiting(live.nodes);
+    const completedGraph = executionState.planGraph;
+    const terminal = selected.isPrimary
+      ? finalizeTerminalPrimaryPlan(executionState, completedGraph, advance)
+      : null;
+    const live = terminal
+      ? completedGraph
+      : executionState.planGraph;
+    const { readyNodes, waitingNodes } = summarizeReadyWaiting(
+      terminal ? [] : (live.nodes || []),
+    );
     const payload = controlResult.ok
       ? accepted({
-        graphId: live.graphId || "",
-        commandRevision: Number(live.specRevision) || 0,
-        stateRevision: Number(live.stateRevision) || 0,
-        revision: Number(live.specRevision) || 0,
+        graphId: terminal ? "" : (live.graphId || ""),
+        commandRevision: terminal ? 0 : (Number(live.specRevision) || 0),
+        stateRevision: terminal ? 0 : (Number(live.stateRevision) || 0),
+        revision: terminal ? 0 : (Number(live.specRevision) || 0),
         control: controlResult,
-        summary: advance.waitingFor
-          ? `waiting on ${advance.waitingFor.type}:${advance.waitingFor.id || ""}`
-          : (advance.yieldReason || "control actions applied"),
-        changes: { nodesAdded: [], nodesUpdated: [] },
+        summary: terminal
+          ? terminal.completionSummary
+          : (advance.waitingFor
+            ? `waiting on ${advance.waitingFor.type}:${advance.waitingFor.id || ""}`
+            : (advance.yieldReason || "control actions applied")),
+        changes: {
+          nodesAdded: [],
+          nodesUpdated: [],
+          ...(terminal ? { archivedGraphId: terminal.archivedGraphId } : {}),
+        },
         nodesAdded: [],
         nodesUpdated: [],
         readyNodes,
         waitingNodes,
-        waitingFor: live.waitingFor || null,
+        waitingFor: terminal ? null : (live.waitingFor || null),
         advance,
-        planView: projectPlanView(live),
+        planView: terminal ? [] : projectPlanView(live),
         validationWarnings: [],
+        ...(terminal ? {
+          planCompleted: true,
+          archivedGraphId: terminal.archivedGraphId,
+          completionSummary: terminal.completionSummary,
+        } : {}),
       })
       : rejected(controlResult.errors || [{
         code: "CONTROL_REJECTED",
         message: "one or more control actions rejected",
       }], { control: controlResult });
-    if (commandId && payload.status === "accepted") {
+    if (commandId && payload.status === "accepted" && !terminal) {
       cacheCommand(executionState.planGraph, commandId, payload);
     }
+    restorePrimaryGraph();
     return { ...payload, executionState, modelPayload: payload, ok: payload.status === "accepted" };
   }
 
   if (operation === "cancel_graph" || operation === "clear") {
     const previousId = planGraph.graphId || "";
+    if (previousId) {
+      archivePlanGraph(executionState, planGraph, { reason: "cancel_graph" });
+    }
     executionState.planGraph = emptyPlanGraphState();
     executionState.mode = "single_action";
+    try {
+      const { getPlanModeSource, setPlanMode } = require("./planMode");
+      if (getPlanModeSource(executionState) === "auto") {
+        setPlanMode(executionState, false, { reason: "plan cancelled" });
+      }
+    } catch {
+      // ignore
+    }
     const payload = accepted({
       graphId: "",
       commandRevision: 0,
@@ -662,6 +789,9 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       waitingNodes: [],
       advance: { status: "completed", yieldReason: "cancelled", executedNodes: [], failedNodes: [] },
       validationWarnings: [],
+      summary: previousId
+        ? `Plan ${previousId} cancelled and cleared.`
+        : "No active plan to cancel.",
     });
     restorePrimaryGraph();
     return { ...payload, executionState, modelPayload: payload };
@@ -697,15 +827,22 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     return rejectWorking(payload);
   }
 
-  const beforeIds = new Set(listNodeIds(planGraph.nodes));
+  const beforeIds = operation === "create"
+    ? new Set()
+    : new Set(listNodeIds(planGraph.nodes));
   let nextPlan = {
     id: planGraph.graphId || createPlanId("plan"),
     objective: planGraph.objective || "",
     nodes: snapshotNodes(planGraph),
   };
   let nodesUpdated = [];
+  let replacedGraphId = "";
 
   if (operation === "create") {
+    if (selected.isPrimary && planGraph.graphId) {
+      replacedGraphId = String(planGraph.graphId);
+      archivePlanGraph(executionState, planGraph, { reason: "replaced_by_create" });
+    }
     const graphSource = command.graph || {};
     if (Array.isArray(graphSource.nodes)) {
       nextPlan = normalizePlanGraph({
@@ -717,6 +854,11 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       nextPlan.nodes = stripModelStatuses(nextPlan.nodes);
     }
     if (!nextPlan.id) nextPlan.id = createPlanId("plan");
+    // Prefer a fresh id when replacing a live plan so the new graph does not
+    // collide with the archived one in graphs[].
+    if (replacedGraphId && nextPlan.id === replacedGraphId) {
+      nextPlan.id = createPlanId("plan");
+    }
     nodesUpdated = listNodeIds(nextPlan.nodes);
     // Parent graphs are owned by the agent loop.
     const { agentLoopOwner } = require("../runtime/graphOwner");
@@ -798,9 +940,10 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
   }
 
   // Prefer the patched node list (includes aggregate expand status).
+  // create starts clean — do not inherit statuses from a replaced graph.
   const preferredNodes = applyStatusesFromStore(
     (Array.isArray(nextPlan.nodes) ? nextPlan.nodes : []).map((node) => normalizePlanNode(node, node.id)),
-    planGraph.nodes,
+    operation === "create" ? [] : planGraph.nodes,
     { preferSourceStatus: operation === "patch" },
   );
 
@@ -831,28 +974,53 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     }
   }
 
-  const specRevision = (Number(planGraph.specRevision) || 0) + 1;
-  executionState.planGraph = {
-    ...planGraph,
-    graphId: preferredCompile.planId || nextPlan.id,
-    specRevision,
-    stateRevision: Number(planGraph.stateRevision) || 0,
-    revision: specRevision,
-    objective: preferredCompile.objective || nextPlan.objective || "",
-    failurePolicy: preferredCompile.failurePolicy
-      || nextPlan.failurePolicy
-      || planGraph.failurePolicy
-      || "continue_independent",
-    nodes: mergedNodes,
-    outputs: operation === "create" ? {} : { ...(planGraph.outputs || {}) },
-    waitingFor: null,
-    lastStoppedAt: "",
-    lastYieldReason: "",
-    commandLog: planGraph.commandLog || {},
-    owner: nextPlan.owner || planGraph.owner || null,
-    parentGraphId: planGraph.parentGraphId || "",
-    parentNodeId: planGraph.parentNodeId || "",
-  };
+  const specRevision = operation === "create"
+    ? 1
+    : (Number(planGraph.specRevision) || 0) + 1;
+  if (operation === "create") {
+    executionState.planGraph = {
+      ...emptyPlanGraphState(),
+      graphId: preferredCompile.planId || nextPlan.id,
+      specRevision,
+      stateRevision: 0,
+      revision: specRevision,
+      objective: preferredCompile.objective || nextPlan.objective || "",
+      failurePolicy: preferredCompile.failurePolicy
+        || nextPlan.failurePolicy
+        || "continue_independent",
+      nodes: mergedNodes,
+      outputs: {},
+      waitingFor: null,
+      lastStoppedAt: "",
+      lastYieldReason: "",
+      commandLog: {},
+      owner: nextPlan.owner || null,
+      parentGraphId: "",
+      parentNodeId: "",
+    };
+  } else {
+    executionState.planGraph = {
+      ...planGraph,
+      graphId: preferredCompile.planId || nextPlan.id,
+      specRevision,
+      stateRevision: Number(planGraph.stateRevision) || 0,
+      revision: specRevision,
+      objective: preferredCompile.objective || nextPlan.objective || "",
+      failurePolicy: preferredCompile.failurePolicy
+        || nextPlan.failurePolicy
+        || planGraph.failurePolicy
+        || "continue_independent",
+      nodes: mergedNodes,
+      outputs: { ...(planGraph.outputs || {}) },
+      waitingFor: null,
+      lastStoppedAt: "",
+      lastYieldReason: "",
+      commandLog: planGraph.commandLog || {},
+      owner: nextPlan.owner || planGraph.owner || null,
+      parentGraphId: planGraph.parentGraphId || "",
+      parentNodeId: planGraph.parentNodeId || "",
+    };
+  }
   if (!executionState.graphs || typeof executionState.graphs !== "object") {
     executionState.graphs = {};
   }
@@ -890,45 +1058,80 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
         ...advanced.planGraph,
         specRevision,
         revision: specRevision,
-        commandLog: planGraph.commandLog || {},
-        owner: advanced.planGraph.owner || planGraph.owner || null,
-        parentGraphId: advanced.planGraph.parentGraphId || planGraph.parentGraphId || "",
-        parentNodeId: advanced.planGraph.parentNodeId || planGraph.parentNodeId || "",
+        commandLog: operation === "create" ? {} : (planGraph.commandLog || {}),
+        owner: advanced.planGraph.owner || (operation === "create" ? nextPlan.owner : planGraph.owner) || null,
+        parentGraphId: operation === "create"
+          ? ""
+          : (advanced.planGraph.parentGraphId || planGraph.parentGraphId || ""),
+        parentNodeId: operation === "create"
+          ? ""
+          : (advanced.planGraph.parentNodeId || planGraph.parentNodeId || ""),
       };
     }
     if (advanced.advance) advance = advanced.advance;
   }
 
-  const live = executionState.planGraph;
-  const { readyNodes, waitingNodes } = summarizeReadyWaiting(live.nodes);
+  const completedGraph = executionState.planGraph;
+  const terminal = selected.isPrimary
+    ? finalizeTerminalPrimaryPlan(executionState, completedGraph, advance)
+    : null;
+  if (!terminal && !selected.isPrimary && advance.yieldReason === "graph_terminal") {
+    // Child TaskLoop graph finished — keep snapshot; parent stays active.
+    const childId = String(completedGraph.graphId || "").trim();
+    if (childId) {
+      executionState.graphs[childId] = {
+        ...completedGraph,
+        completedAt: new Date().toISOString(),
+        lastYieldReason: "graph_terminal",
+      };
+    }
+  }
+
+  const live = terminal ? completedGraph : executionState.planGraph;
+  const { readyNodes, waitingNodes } = summarizeReadyWaiting(
+    terminal ? [] : (live.nodes || []),
+  );
   const payload = accepted({
-    graphId: live.graphId,
-    commandRevision: live.specRevision,
-    stateRevision: live.stateRevision,
-    revision: live.specRevision,
+    graphId: terminal ? "" : live.graphId,
+    commandRevision: terminal ? 0 : live.specRevision,
+    stateRevision: terminal ? 0 : live.stateRevision,
+    revision: terminal ? 0 : live.specRevision,
     changes: {
       nodesAdded,
       nodesUpdated: Array.from(new Set(nodesUpdated)),
+      ...(replacedGraphId ? { replacedGraphId } : {}),
+      ...(terminal ? { archivedGraphId: terminal.archivedGraphId } : {}),
     },
     nodesAdded,
     nodesUpdated: Array.from(new Set(nodesUpdated)),
     readyNodes,
     waitingNodes,
-    waitingFor: live.waitingFor || null,
-    stoppedAt: live.lastStoppedAt || "",
+    waitingFor: terminal ? null : (live.waitingFor || null),
+    stoppedAt: terminal ? "graph_terminal" : (live.lastStoppedAt || ""),
     advance,
-    planView: projectPlanView(live),
+    planView: terminal ? [] : projectPlanView(live),
     validationWarnings: preferredCompile.warnings || [],
-    summary: advance.waitingFor
-      ? `waiting on ${advance.waitingFor.type}:${advance.waitingFor.id || ""}`
-      : (advance.yieldReason || "graph updated"),
+    summary: terminal
+      ? terminal.completionSummary
+      : (advance.waitingFor
+        ? `waiting on ${advance.waitingFor.type}:${advance.waitingFor.id || ""}`
+        : (advance.yieldReason || "graph updated")),
+    ...(replacedGraphId ? { replacedGraphId } : {}),
+    ...(terminal ? {
+      planCompleted: true,
+      archivedGraphId: terminal.archivedGraphId,
+      completionSummary: terminal.completionSummary,
+    } : {}),
   });
 
-  cacheCommand(executionState.planGraph, commandId, payload);
+  if (!terminal) {
+    cacheCommand(executionState.planGraph, commandId, payload);
+  }
 
   // Agent Loop create enables Plan Mode; TaskLoop child graphs must not.
+  // Skip when create immediately ran to terminal (already exited Plan Mode).
   let planModeEntered = null;
-  if (operation === "create" && payload.status === "accepted") {
+  if (operation === "create" && payload.status === "accepted" && !terminal) {
     const ownerKind = String(
       (executionState.planGraph && executionState.planGraph.owner && executionState.planGraph.owner.kind)
       || "agent_loop",
@@ -968,6 +1171,9 @@ function activePlanRequiresExpansion(planGraph = {}) {
 module.exports = {
   emptyPlanGraphState,
   ensurePlanGraphState,
+  archivePlanGraph,
+  buildPlanCompletionSummary,
+  finalizeTerminalPrimaryPlan,
   normalizePlanGraphCommand,
   normalizeExpandOp,
   runPlanGraphCommand,

package/src/code/context/promptLayers.js

@@ -54,6 +54,7 @@ function buildImmutablePrefix() {
       "- Turning Plan Mode off does not cancel an existing graph or running TaskRuns. Cancel with task_run (standalone) or plan_graph operation=cancel_graph / control.cancel_task (graph-bound).",
       "- When the user enables Plan Mode and no active graph exists, create a plan_graph before performing side effects.",
       "- After an accepted plan_graph create or patch, Runtime automatically advances ready tool nodes. Never invent or request an execute_graph tool.",
+      "- When the last plan node finishes (graph_terminal), Runtime archives and clears the active plan, exits auto Plan Mode, and returns a completion summary — narrate that summary to the user. Start a new objective with plan_graph create (create replaces any leftover graph); do not patch a finished plan for a new goal.",
       "- Do not call plan_graph or task_run together with read, read_image, write, edit, bash, or artifact_read in the same assistant turn.",
       "- When an active graph is waiting on a task, advance that node through plan_graph instead of bypassing it with direct workspace tools: use patch.expand_node for execution.kind=expand, control.complete_task (nodeId) for execution.kind=inline_llm, or control.start_task for execution.kind=task_loop.",
       "- TaskLoop start returns childGraphId. While that TaskRun is waiting_model on child root, patch with graphId=<childGraphId> and expand_node nodeId=root (add tool children). Do not ask the user to /plan off.",

package/src/code/context/userNudge.js

@@ -58,6 +58,14 @@ function hasPendingUserPrompts(executionState = null) {
   return state.pendingUserPrompts.length > 0;
 }
 
+/** Peek pending nudge texts without draining (for TUI queue banner). */
+function listPendingUserPrompts(executionState = null) {
+  const state = ensurePendingUserPrompts(executionState);
+  return state.pendingUserPrompts
+    .map((entry) => String(entry && entry.text || "").trim())
+    .filter(Boolean);
+}
+
 function shouldFrameAsUserReminder(executionState = null) {
   if (!executionState || typeof executionState !== "object") return false;
   if (executionState.planMode === true) return true;
@@ -131,7 +139,8 @@ function shouldAutoContinuePlan(executionState = null) {
 
 /**
  * Internal reminder injected by runtime when the model ends a turn while the
- * plan is still waiting on a task. Same shape as user nudges.
+ * plan is still waiting on a task. Must NOT reuse the User reminder label —
+ * that is reserved for real mid-run user text and pollutes transcript/TUI.
  */
 function buildPlanAutoContinueReminder(executionState = null) {
   const waiting = executionState
@@ -140,14 +149,17 @@ function buildPlanAutoContinueReminder(executionState = null) {
     ? executionState.planGraph.waitingFor
     : null;
   if (!waiting || !waiting.id) return "";
-  return formatUserReminderMessage(
-    [
-      "Continue the active plan. Serve the waiting task now via plan_graph "
-        + "(expand_node, control.start_task, or control.complete_task as appropriate). "
-        + "Do not end the turn with text only while this node is waiting.",
-    ],
-    { waitingFor: waiting },
-  );
+  const label = waiting.title || waiting.objective || waiting.reason || waiting.id;
+  const lines = [
+    "Runtime wake (not a user message): active plan is still waiting.",
+    "Continue serving it now via plan_graph "
+      + "(expand_node, control.start_task, or control.complete_task as appropriate). "
+      + "Do not end the turn with text only while this node is waiting.",
+    `Prefer serving the current waiting ${waiting.type || "node"}: ${waiting.id}`
+      + (label && label !== waiting.id ? ` — ${label}` : "")
+      + ".",
+  ];
+  return lines.join("\n");
 }
 
 module.exports = {
@@ -156,6 +168,7 @@ module.exports = {
   drainUserPrompts,
   clearUserPrompts,
   hasPendingUserPrompts,
+  listPendingUserPrompts,
   shouldFrameAsUserReminder,
   formatUserReminderMessage,
   buildContinuationUserPrompt,

package/src/runtime/daemon/deliveryScheduler.js

@@ -5,6 +5,7 @@ const Injector = require("../../coordination/bus/inject");
 const { buildPromptInjectionText } = require("../../coordination/bus/promptEnvelope");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { normalizeQueueEnvelope } = require("../../coordination/bus/deliveryQueue");
+const { writeActivityState } = require("../../agents/activity/activityStateWriter");
 
 function asState(value = "") {
   return String(value || "").trim().toLowerCase();
@@ -58,6 +59,14 @@ class DeliveryScheduler {
     this.emitDelivery = typeof options.emitDelivery === "function"
       ? options.emitDelivery
       : async () => {};
+    this.markWorking = typeof options.markWorking === "function"
+      ? options.markWorking
+      : (subscriber) => {
+        writeActivityState(this.paths.agentsFile, subscriber, "working", {
+          force: true,
+          detail: "inject",
+        });
+      };
     this.log = typeof options.log === "function" ? options.log : () => {};
     this.now = typeof options.now === "function" ? options.now : () => Date.now();
     this.deferWarnAfterMs = positiveMs(options.deferWarnAfterMs, DEFAULT_DEFER_WARN_AFTER_MS);
@@ -224,6 +233,15 @@ class DeliveryScheduler {
       try {
         await this.injector.inject(subscriber, injectionText);
         queue.completeClaim(claim);
+        // Close the idle gate immediately. PTY ActivityDetector will refresh
+        // working from output, then quiet-window back to idle; without this
+        // stamp a second pending message can slip through on the next tick
+        // before any Codex stdout arrives.
+        try {
+          this.markWorking(subscriber);
+        } catch {
+          // activity stamp must never undo a successful inject
+        }
         await this.emitDelivery({
           subscriber,
           event: envelope,

package/src/ui/ink/ChatApp.js

@@ -732,6 +732,86 @@ function wrapInternalPlainLine(text = "", width = 80) {
   return rows;
 }
 
+// Ink's wrap:"wrap" + <Static> under-counts CJK row height on live appends,
+// so later log writes overpaint the previous line. Pre-wrap by display cells
+// and paint with wrap:"truncate" so each Static item occupies a known height.
+function expandChatLogPhysicalLines(text = "", width = 80) {
+  const limit = Math.max(1, Math.floor(Number(width) || 80));
+  const source = String(text || "").replace(/\r/g, "");
+  if (!source) return [""];
+  const out = [];
+  for (const line of source.split("\n")) {
+    out.push(...wrapInternalPlainLine(line, limit));
+  }
+  return out.length > 0 ? out : [""];
+}
+
+function padDisplayCells(cells = 0) {
+  return " ".repeat(Math.max(0, Math.floor(Number(cells) || 0)));
+}
+
+function splitUserLogAtMention(bodyText = "") {
+  const body = String(bodyText || "");
+  const atMatch = body.match(/^@([^\s]+)\s+(.*)$/);
+  if (atMatch) {
+    return { at: atMatch[1], rest: atMatch[2] || "" };
+  }
+  return { at: "", rest: body };
+}
+
+/**
+ * Flatten one chat log row into terminal-width physical lines. Each returned
+ * line is a single string (marker/speaker/body already merged) so Ink never
+ * has to wrap it — critical for <Static> append-only CJK safety.
+ */
+function buildChatLogDisplayLines(row = {}, options = {}) {
+  const cols = Math.max(8, Math.floor(Number(options.cols) || 80));
+  const continuation = Boolean(options.continuation);
+  const groupKind = options.groupKind || row.kind || "plain";
+  const kind = row.kind || "plain";
+
+  if (kind === "spacer") return [" "];
+  if (kind === "divider") {
+    return [fitPlainLine(`  ${compactDividerLabel(row.body || row.bodyText || "")}`, cols)];
+  }
+  if (kind === "banner") {
+    return expandChatLogPhysicalLines(stripInternalLogMarkup(row.bodyText || row.body || ""), cols)
+      .map((line) => fitPlainLine(line, cols));
+  }
+
+  const markerText = continuation
+    ? (groupKind === "assistant" || groupKind === "agent" || groupKind === "report" ? "   " : "  ")
+    : String(row.markerText != null ? row.markerText : "");
+
+  if (kind === "user") {
+    const userBody = splitUserLogAtMention(row.bodyText || row.body || "");
+    const atPrefix = userBody.at ? `@${userBody.at} ` : "";
+    const firstPrefix = `${markerText || "› "}${atPrefix}`;
+    const prefixCells = fmt.displayCellWidth(firstPrefix);
+    const budget = Math.max(1, cols - prefixCells);
+    const chunks = expandChatLogPhysicalLines(userBody.rest, budget);
+    const contPad = padDisplayCells(prefixCells);
+    return chunks.map((chunk, idx) => {
+      const line = idx === 0 ? `${firstPrefix}${chunk}` : `${contPad}${chunk}`;
+      return fitPlainLine(line, cols);
+    });
+  }
+
+  const speakerPrefix = (!continuation && row.speaker)
+    ? `${row.speaker} · `
+    : "";
+  const head = `${markerText}${speakerPrefix}`;
+  const headCells = fmt.displayCellWidth(head);
+  const budget = Math.max(1, cols - headCells);
+  const bodyPlain = stripInternalLogMarkup(row.bodyText != null ? row.bodyText : (row.body || ""));
+  const chunks = expandChatLogPhysicalLines(bodyPlain, budget);
+  const contPad = padDisplayCells(headCells);
+  return chunks.map((chunk, idx) => {
+    const line = idx === 0 ? `${head}${chunk}` : `${contPad}${chunk}`;
+    return fitPlainLine(line, cols);
+  });
+}
+
 function classifyInternalLogLine(line = "") {
   const raw = stripInternalLogMarkup(line).replace(/\r/g, "");
   if (!raw) return { kind: "spacer", text: "", markdown: false, bold: false };
@@ -3580,16 +3660,44 @@ function createChatApp({ React, ink, props, interactive = true }) {
       return null;
     }
 
-    const renderUserLogBody = (bodyText = "") => {
-      const body = String(bodyText || "");
-      const atMatch = body.match(/^@([^\s]+)\s+(.*)$/);
-      if (atMatch) {
-        return {
-          at: atMatch[1],
-          rest: atMatch[2] || "",
-        };
+    const renderChatLogLines = (row, { key, continuation = false, groupKind = "", marginTop = 0, marginBottom = 0 } = {}) => {
+      const colors = CHAT_LOG_ROW_PALETTE[row.kind] || CHAT_LOG_ROW_PALETTE.plain;
+      const cols = Math.max(20, size.cols || 80);
+      const lines = buildChatLogDisplayLines(row, {
+        continuation,
+        groupKind: groupKind || row.kind,
+        cols,
+      });
+      const textProps = {
+        color: row.kind === "user" ? "green" : colors.body,
+        bold: Boolean(
+          row.kind === "user"
+          || colors.bold
+          || row.kind === "error"
+          || row.kind === "assistant"
+          || row.kind === "banner"
+        ),
+        wrap: "truncate",
+      };
+      if (colors.dim) textProps.dimColor = true;
+      if (row.kind === "agent" || row.kind === "report") {
+        textProps.color = colors.speaker;
       }
-      return { at: "", rest: body };
+      if (lines.length <= 1) {
+        return h(Box, { key, width: "100%", marginTop, marginBottom },
+          h(Text, textProps, (lines[0] != null ? lines[0] : " ") || " "));
+      }
+      return h(Box, {
+        key,
+        flexDirection: "column",
+        width: "100%",
+        marginTop,
+        marginBottom,
+      },
+      ...lines.map((line, idx) => h(Text, {
+        key: `${key}-r${idx}`,
+        ...textProps,
+      }, line || " ")));
     };
 
     const renderChatLogEntry = (entry, group) => {
@@ -3598,53 +3706,12 @@ function createChatApp({ React, ink, props, interactive = true }) {
       if (row.kind === "spacer") {
         return h(Text, { key, color: "gray" }, " ");
       }
-      const colors = CHAT_LOG_ROW_PALETTE[row.kind] || CHAT_LOG_ROW_PALETTE.plain;
-      if (row.kind === "divider") {
-        return h(Box, { key, marginBottom: 1 },
-          h(Text, { color: colors.body, wrap: "truncate" }, `  ${compactDividerLabel(row.body)}`),
-        );
-      }
-      if (row.kind === "banner") {
-        return h(Box, { key },
-          h(Text, { color: colors.body, bold: true, wrap: "truncate" }, row.body),
-        );
-      }
-      if (row.kind === "user") {
-        const userBody = renderUserLogBody(row.bodyText);
-        return h(Box, { key, width: "100%", marginBottom: 1, alignItems: "flex-start" },
-          h(Text, { color: "green", bold: true }, row.markerText || "› "),
-          userBody.at
-            ? h(Text, { color: "magenta", bold: true }, `@${userBody.at} `)
-            : null,
-          h(Text, { color: "green", bold: true, wrap: "wrap" }, userBody.rest),
-        );
-      }
-      const markerText = entry && entry.continuation
-        ? (group && (group.kind === "assistant" || group.kind === "agent" || group.kind === "report") ? "   " : "  ")
-        : row.markerText;
-      const bodyProps = {
-        color: colors.body,
-        wrap: "wrap",
-      };
-      if (colors.dim) bodyProps.dimColor = true;
-      // Pin the gutter glyph to the first text line; default Yoga stretch/center
-      // floats markers above wrapped speaker · body rows.
-      return h(Box, { key, width: "100%", alignItems: "flex-start" },
-        h(Text, {
-          color: colors.marker,
-          bold: row.kind === "error" || row.kind === "assistant",
-          dimColor: Boolean(colors.dim),
-        }, markerText),
-        h(Text, bodyProps,
-          row.speaker && !(entry && entry.continuation)
-            ? h(Text, { color: colors.speaker, bold: colors.bold }, row.speaker)
-            : null,
-          row.speaker && !(entry && entry.continuation)
-            ? h(Text, { color: "gray" }, " · ")
-            : null,
-          row.bodyText,
-        ),
-      );
+      return renderChatLogLines(row, {
+        key,
+        continuation: Boolean(entry && entry.continuation),
+        groupKind: group && group.kind ? group.kind : row.kind,
+        marginBottom: row.kind === "user" || row.kind === "divider" ? 1 : 0,
+      });
     };
 
     const renderChatLogGroup = (group) => {
@@ -3664,64 +3731,23 @@ function createChatApp({ React, ink, props, interactive = true }) {
       ...entries.map((entry) => renderChatLogEntry(entry, group)));
     };
 
-    // Renderer for one finalized (append-only) <Static> log item. Mirrors
-    // renderChatLogEntry visually; spacing differs because per-item
-    // rendering can't wrap a group in one margin-bottom Box — instead the
-    // decoration pass flags `marginBefore` on whatever entry follows a
-    // transcript group.
+    // Renderer for one finalized (append-only) <Static> log item. Spacing
+    // uses decorateStaticLogEntry's marginBefore; body text is pre-wrapped to
+    // the terminal width so Ink never wrap:"wrap"s CJK inside Static.
     const renderStaticChatLogItem = (item) => {
       const { row, groupKind, continuation, marginBefore } = item;
       const key = item.entry && item.entry.id ? item.entry.id : `log-${row.body}`;
-      const marginTop = marginBefore ? 1 : 0;
       if (row.kind === "spacer") {
-        return h(Box, { key, marginTop },
+        return h(Box, { key, marginTop: marginBefore ? 1 : 0 },
           h(Text, { color: "gray" }, " "));
       }
-      const colors = CHAT_LOG_ROW_PALETTE[row.kind] || CHAT_LOG_ROW_PALETTE.plain;
-      if (row.kind === "divider") {
-        return h(Box, { key, marginTop, marginBottom: 1 },
-          h(Text, { color: colors.body, wrap: "truncate" }, `  ${compactDividerLabel(row.body)}`),
-        );
-      }
-      if (row.kind === "banner") {
-        return h(Box, { key, marginTop },
-          h(Text, { color: colors.body, bold: true, wrap: "truncate" }, row.body),
-        );
-      }
-      if (row.kind === "user") {
-        const userBody = renderUserLogBody(row.bodyText);
-        return h(Box, { key, width: "100%", marginTop, marginBottom: 1, alignItems: "flex-start" },
-          h(Text, { color: "green", bold: true }, row.markerText || "› "),
-          userBody.at
-            ? h(Text, { color: "magenta", bold: true }, `@${userBody.at} `)
-            : null,
-          h(Text, { color: "green", bold: true, wrap: "wrap" }, userBody.rest),
-        );
-      }
-      const markerText = continuation
-        ? (groupKind === "assistant" || groupKind === "agent" || groupKind === "report" ? "   " : "  ")
-        : row.markerText;
-      const bodyProps = {
-        color: colors.body,
-        wrap: "wrap",
-      };
-      if (colors.dim) bodyProps.dimColor = true;
-      return h(Box, { key, width: "100%", marginTop, alignItems: "flex-start" },
-        h(Text, {
-          color: colors.marker,
-          bold: row.kind === "error" || row.kind === "assistant",
-          dimColor: Boolean(colors.dim),
-        }, markerText),
-        h(Text, bodyProps,
-          row.speaker && !continuation
-            ? h(Text, { color: colors.speaker, bold: colors.bold }, row.speaker)
-            : null,
-          row.speaker && !continuation
-            ? h(Text, { color: "gray" }, " · ")
-            : null,
-          row.bodyText,
-        ),
-      );
+      return renderChatLogLines(row, {
+        key,
+        continuation,
+        groupKind,
+        marginTop: marginBefore ? 1 : 0,
+        marginBottom: row.kind === "user" || row.kind === "divider" ? 1 : 0,
+      });
     };
 
     if (state.viewingAgentId) {
@@ -4099,6 +4125,8 @@ module.exports = {
   createInkStreamState,
   createThrottledSender,
   decorateStaticLogEntry,
+  buildChatLogDisplayLines,
+  expandChatLogPhysicalLines,
   bootstrapEnvironment,
   buildDirectBusSendRequest,
   buildPromptIpcRequest,

package/src/ui/ink/UcodeApp.js

@@ -96,6 +96,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       hash: "",
     }));
     const [interactionLines, setInteractionLines] = useState([]);
+    // Bumps when pendingUserPrompts change so the near-input queue banner
+    // re-renders without dumping a chat-log system line.
+    const [queueTick, setQueueTick] = useState(0);
+    const bumpQueue = useCallback(() => setQueueTick((n) => n + 1), []);
     const [spinnerTick, setSpinnerTick] = useState(0);
     const [size, setSize] = useState({ cols: 0, rows: 0 });
     const [contextMeter, setContextMeter] = useState(() => {
@@ -903,6 +907,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
             cancelThinkingFlush();
             thinkingTailRef.current = "";
             refreshPlanUi();
+            bumpQueue();
             setStatus({ message: "", type: "thinking", showTimer: false, startedAt: 0 });
           }
           if (streamBuf) {
@@ -942,7 +947,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         default:
           if (result.output) appendLogText(result.output);
       }
-    }, [appendLogLine, appendLogText, exit, props, logToolHint, flushActiveMerge, flushTableBuffer, refreshPlanUi]);
+    }, [appendLogLine, appendLogText, exit, props, logToolHint, flushActiveMerge, flushTableBuffer, refreshPlanUi, bumpQueue]);
     // ^ `props` is captured by the createUcodeApp closure on a single mount,
     // so its reference is stable across renders even though it looks like a
     // changing dep to React's exhaustive-deps lint.
@@ -1131,7 +1136,19 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
       // While a native task is in flight, queue an additional user reminder
       // for the next LLM turn instead of starting a second NL task.
+      // Slash commands (/model, /plan, …) must still run immediately — same
+      // rule as the REPL path — otherwise they pollute the nudge queue.
       if (pendingTaskRef.current) {
+        if (/^\//.test(trimmed)) {
+          runChainRef.current = runChainRef.current
+            .then(() => executeLine(modelText, {
+              modelText,
+              logText,
+              preserveNewlines: attachments.length > 0,
+            }))
+            .catch((err) => appendLogText(`Error: ${err && err.message ? err.message : err}`, "error"));
+          return;
+        }
         const { enqueueUserPrompt } = require("../../code/context/userNudge");
         const { emptyExecutionState } = require("../../code/context/executionSegment");
         if (!props.state || typeof props.state !== "object") {
@@ -1141,14 +1158,8 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         if (!props.state.executionState || typeof props.state.executionState !== "object") {
           props.state.executionState = emptyExecutionState();
         }
-        const queued = enqueueUserPrompt(props.state.executionState, modelText);
-        const reminderPreview = logText.slice(0, 120) + (logText.length > 120 ? "…" : "");
-        appendLogText(
-          queued.enqueued
-            ? `Queued user reminder for next model turn: ${reminderPreview}`
-            : "Could not queue user reminder (empty).",
-          "system",
-        );
+        enqueueUserPrompt(props.state.executionState, modelText);
+        bumpQueue();
         return;
       }
 
@@ -1168,6 +1179,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       appendLogLine,
       flushActiveMerge,
       flushTableBuffer,
+      bumpQueue,
       props.state,
       props.submitUserInteractionAnswer,
       refreshPlanUi,
@@ -1398,6 +1410,25 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           ),
         )
         : null,
+      (() => {
+        void queueTick;
+        let pending = [];
+        try {
+          const { listPendingUserPrompts } = require("../../code/context/userNudge");
+          pending = listPendingUserPrompts(props.state && props.state.executionState);
+        } catch {
+          pending = [];
+        }
+        if (pending.length === 0) return null;
+        const latest = String(pending[pending.length - 1] || "");
+        const more = pending.length > 1 ? ` · +${pending.length - 1}` : "";
+        const preview = latest.length > 72 ? `${latest.slice(0, 72)}…` : latest;
+        return h(Box, { width: "100%" },
+          h(Text, { color: "yellow", wrap: "truncate" },
+            `排队中 · 未发出 · ${preview}${more}`,
+          ),
+        );
+      })(),
       h(Box, { width: "100%" },
         h(MultilineInput, {
           value: draft,
@@ -1457,6 +1488,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
                 if (props.state && props.state.executionState) {
                   clearUserPrompts(props.state.executionState);
                 }
+                bumpQueue();
               } catch { /* ignore */ }
               appendLogLine("⚙ Cancellation requested. Stopping the current task...", "system");
               setStatus({