u-foo 2.4.1 → 2.4.3

package/package.json

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

package/src/agents/prompts/groupBootstrap.js

@@ -2,6 +2,14 @@
 
 const crypto = require("crypto");
 
+const SILENT_BOOTSTRAP_INSTRUCTION = [
+  "Bootstrap silence:",
+  "- This message is setup only, not a task.",
+  "- Apply these instructions silently, then wait for the next user, bus, or controller task.",
+  "- Do not reply, summarize, acknowledge, report, hand off, or call tools in response to this bootstrap message.",
+  "- Do not send `ufoo report` or `ufoo bus` until real work arrives after this bootstrap.",
+].join("\n");
+
 const SHARED_UFOO_PROTOCOL = [
   "Session harness: ufoo",
   "",
@@ -42,11 +50,15 @@ const SHARED_UFOO_PROTOCOL = [
   "dedup, so don't worry about report loops.",
   "",
   "`ufoo report start|progress|done|error \"<short summary>\"`",
+  "Do not emulate report failures with `ufoo bus send ufoo-agent ...`.",
+  "If `ufoo report` fails, continue without a fallback bus report.",
   "",
   "Then continue the active task.",
 ].join("\n");
 
 const SHARED_GROUP_PREFIX = [
+  SILENT_BOOTSTRAP_INSTRUCTION,
+  "",
   "You are part of a ufoo multi-agent group.",
   "",
   "Shared rules:",
@@ -193,6 +205,7 @@ function computeBootstrapFingerprint({
 }
 
 module.exports = {
+  SILENT_BOOTSTRAP_INSTRUCTION,
   SHARED_UFOO_PROTOCOL,
   SHARED_GROUP_PREFIX,
   SOLO_AGENT_PREFIX,

package/src/app/cli/run.js

@@ -129,6 +129,41 @@ async function sendDaemonRequest(projectRoot, payload) {
   });
 }
 
+async function sendAgentReportRequest(projectRoot, report) {
+  const { normalizeReportInput } = require("../../coordination/report/store");
+  const { enqueueAgentReport } = require("../../runtime/daemon/reportControlBus");
+  const entry = normalizeReportInput(report);
+  const queued = await enqueueAgentReport(projectRoot, entry);
+  return {
+    type: "response",
+    data: {
+      reply: `Report queued (${entry.phase})`,
+      report: entry,
+      queued,
+    },
+  };
+}
+
+function getReportDetail(out = {}) {
+  if (out.phase === "error") {
+    return out.error || out.summary || out.message || out.task_id;
+  }
+  return out.summary || out.message || out.task_id;
+}
+
+function printReportOutput(out, json = false, queued = null) {
+  if (json) {
+    console.log(JSON.stringify({
+      status: "queued",
+      report: out,
+      queued,
+    }, null, 2));
+    return;
+  }
+  const detail = getReportDetail(out);
+  console.log(`[report] queued ${out.phase} ${out.agent_id} ${out.task_id} ${detail}`);
+}
+
 function requireOptional(name) {
   try {
     // eslint-disable-next-line global-require, import/no-dynamic-require
@@ -978,20 +1013,9 @@ async function runCli(argv) {
         };
 
         try {
-          await ensureDaemonRunning(projectRoot);
-          const resp = await sendDaemonRequest(projectRoot, {
-            type: "agent_report",
-            report,
-          });
+          const resp = await sendAgentReportRequest(projectRoot, report);
           const out = resp?.data?.report || report;
-          if (opts.json) {
-            console.log(JSON.stringify(out, null, 2));
-            return;
-          }
-          const detail = out.phase === "error"
-            ? (out.error || out.summary || out.message || out.task_id)
-            : (out.summary || out.message || out.task_id);
-          console.log(`[report] ${out.phase} ${out.agent_id} ${out.task_id} ${detail}`);
+          printReportOutput(out, opts.json, resp?.data?.queued || null);
         } catch (err) {
           console.error(err.message || String(err));
           process.exitCode = 1;
@@ -1926,20 +1950,9 @@ async function runCli(argv) {
 
     (async () => {
       try {
-        await ensureDaemonRunning(process.cwd());
-        const resp = await sendDaemonRequest(process.cwd(), {
-          type: "agent_report",
-          report,
-        });
+        const resp = await sendAgentReportRequest(process.cwd(), report);
         const out = resp?.data?.report || report;
-        if (rest.includes("--json")) {
-          console.log(JSON.stringify(out, null, 2));
-          return;
-        }
-        const detail = out.phase === "error"
-          ? (out.error || out.summary || out.message || out.task_id)
-          : (out.summary || out.message || out.task_id);
-        console.log(`[report] ${out.phase} ${out.agent_id} ${out.task_id} ${detail}`);
+        printReportOutput(out, rest.includes("--json"), resp?.data?.queued || null);
       } catch (err) {
         console.error(err.message || String(err));
         process.exitCode = 1;

package/src/coordination/bus/index.js

@@ -330,7 +330,7 @@ class EventBus {
           injectionMode: options.injectionMode,
           source: options.source,
         })
-        : await this.messageManager.emit(target, eventName, data, publisher);
+        : await this.messageManager.emit(target, eventName, data, publisher, options.type);
       const silent = options.silent === true;
       if (!silent && eventName === "message") {
         logOk(

package/src/runtime/daemon/index.js

@@ -21,6 +21,11 @@ const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromR
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
 const { recordAgentReport } = require("./reporting");
+const {
+  isAgentReportControlEvent,
+  extractAgentReportControl,
+  takeReportControlEvents,
+} = require("./reportControlBus");
 const { isGlobalControllerProjectRoot } = require("../projects");
 const {
   assignSoloRoleToExistingAgent,
@@ -855,7 +860,7 @@ async function dispatchMessages(projectRoot, dispatch = []) {
   }
 }
 
-function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
+function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain, onReport) {
   const state = {
     subscriber: null,
     queueFile: null,
@@ -867,6 +872,7 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
   };
   const eventBus = new EventBus(projectRoot);
   let joinInProgress = false;
+  let polling = false;
 
   function getAgentNickname(agentId) {
     if (!agentId) return agentId;
@@ -1057,6 +1063,27 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
     })();
   }
 
+  async function handleReportControlEvent(evt) {
+    if (!isAgentReportControlEvent(evt)) return false;
+    if (typeof onReport !== "function") return false;
+    const control = extractAgentReportControl(evt);
+    if (!control) return false;
+    await onReport(control.report, {
+      event: evt,
+      requestId: control.request_id,
+      queuedAt: control.queued_at,
+    });
+    return true;
+  }
+
+  async function pollReportControlQueue() {
+    const events = takeReportControlEvents(projectRoot);
+    if (!events.length) return;
+    for (const evt of events) {
+      if (await handleReportControlEvent(evt)) continue;
+    }
+  }
+
   function pollQueue() {
     if (!state.queueFile) return;
     if (!fs.existsSync(state.queueFile)) return;
@@ -1109,14 +1136,23 @@ function startBusBridge(projectRoot, provider, onEvent, onStatus, shouldDrain) {
     }
   }
 
-  function poll() {
-    ensureSubscriber();
-    if (typeof shouldDrain === "function" && !shouldDrain()) return;
-    pollQueue();
-    pollWatchedEvents();
+  async function poll() {
+    if (polling) return;
+    polling = true;
+    try {
+      ensureSubscriber();
+      await pollReportControlQueue();
+      if (typeof shouldDrain === "function" && !shouldDrain()) return;
+      pollQueue();
+      pollWatchedEvents();
+    } finally {
+      polling = false;
+    }
   }
 
-  const interval = setInterval(poll, 1000);
+  const interval = setInterval(() => {
+    poll().catch(() => {});
+  }, 1000);
   return {
     markPending(target) {
       if (!target) return;
@@ -1300,11 +1336,53 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     log,
   });
 
+  const publishAgentReportResult = (entry) => {
+    ipcServer.sendToSockets({
+      type: IPC_RESPONSE_TYPES.BUS,
+      data: {
+        event: "controller_report",
+        publisher: entry.agent_id,
+        message: entry.summary || entry.message || entry.task_id,
+        report: entry,
+      },
+    });
+    ipcServer.sendToSockets({
+      type: IPC_RESPONSE_TYPES.STATUS,
+      data: buildRuntimeStatus(),
+    });
+  };
+
+  const handleAgentReport = async (report, options = {}) => {
+    const source = options.source || report.source || "cli";
+    const { entry } = await recordAgentReport({
+      projectRoot,
+      report: {
+        ...report,
+        source,
+      },
+      onStatus: (status) => {
+        ipcServer.sendToSockets({
+          type: IPC_RESPONSE_TYPES.STATUS,
+          data: status,
+        });
+      },
+      log,
+    });
+    publishAgentReportResult(entry);
+    return entry;
+  };
+
   const busBridge = startBusBridge(projectRoot, provider, (evt) => {
     ipcServer.sendToSockets({ type: IPC_RESPONSE_TYPES.BUS, data: evt });
   }, (status) => {
     ipcServer.sendToSockets({ type: IPC_RESPONSE_TYPES.STATUS, data: status });
-  }, () => ipcServer.hasClients());
+  }, () => ipcServer.hasClients(), async (report, meta = {}) => {
+    try {
+      await handleAgentReport(report || {}, { source: (report && report.source) || "bus" });
+    } catch (err) {
+      log(`report bus event failed request=${meta.requestId || ""} error=${err.message || String(err)}`);
+    }
+  });
 
   handleIpcRequest = async (req, socket) => {
     if (!req || typeof req !== "object") return;
@@ -1399,20 +1477,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
     if (req.type === IPC_REQUEST_TYPES.AGENT_REPORT) {
       try {
         const report = req.report && typeof req.report === "object" ? req.report : {};
-        const { entry } = await recordAgentReport({
-          projectRoot,
-          report: {
-            ...report,
-            source: report.source || "cli",
-          },
-          onStatus: (status) => {
-            ipcServer.sendToSockets({
-              type: IPC_RESPONSE_TYPES.STATUS,
-              data: status,
-            });
-          },
-          log,
-        });
+        const entry = await handleAgentReport(report, { source: report.source || "cli" });
         socket.write(
           `${JSON.stringify({
             type: IPC_RESPONSE_TYPES.RESPONSE,
@@ -1423,19 +1488,6 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
           })}
 `,
         );
-        ipcServer.sendToSockets({
-          type: IPC_RESPONSE_TYPES.BUS,
-          data: {
-            event: "controller_report",
-            publisher: entry.agent_id,
-            message: entry.summary || entry.message || entry.task_id,
-            report: entry,
-          },
-        });
-        ipcServer.sendToSockets({
-          type: IPC_RESPONSE_TYPES.STATUS,
-          data: buildRuntimeStatus(),
-        });
       } catch (err) {
         socket.write(
           `${JSON.stringify({

package/src/runtime/daemon/reportControlBus.js

@@ -0,0 +1,150 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { getUfooPaths } = require("../../coordination/state/paths");
+const {
+  appendJSONL,
+  ensureDir,
+  generateInstanceId,
+} = require("../../coordination/bus/utils");
+
+const REPORT_CONTROL_TARGET = "ufoo-agent";
+const REPORT_CONTROL_EVENT = "agent_report";
+const REPORT_CONTROL_TYPE = "control/report";
+
+function getReportControlQueueDir(projectRoot) {
+  const paths = getUfooPaths(projectRoot);
+  return path.join(paths.busDir, "control", "report");
+}
+
+function getReportControlQueueFile(projectRoot) {
+  return path.join(getReportControlQueueDir(projectRoot), "pending.jsonl");
+}
+
+function ensureReportControlQueue(projectRoot) {
+  const queueDir = getReportControlQueueDir(projectRoot);
+  ensureDir(queueDir);
+  return queueDir;
+}
+
+function resolveReportPublisher(report = {}) {
+  const fromReport = String(report.agent_id || report.agentId || "").trim();
+  if (fromReport) return fromReport;
+  const fromEnv = String(process.env.UFOO_SUBSCRIBER_ID || "").trim();
+  return fromEnv || "unknown-agent";
+}
+
+function buildReportControlData(report = {}, options = {}) {
+  return {
+    request_id: options.requestId || `report-${Date.now().toString(36)}-${generateInstanceId()}`,
+    queued_at: options.queuedAt || new Date().toISOString(),
+    report,
+  };
+}
+
+function buildReportControlEvent(report = {}, options = {}) {
+  const data = buildReportControlData(report, options);
+  return {
+    timestamp: data.queued_at,
+    type: REPORT_CONTROL_TYPE,
+    event: REPORT_CONTROL_EVENT,
+    publisher: options.publisher || resolveReportPublisher(report),
+    target: REPORT_CONTROL_TARGET,
+    data,
+  };
+}
+
+async function enqueueAgentReport(projectRoot, report, options = {}) {
+  ensureReportControlQueue(projectRoot);
+
+  const event = buildReportControlEvent(report, options);
+  appendJSONL(getReportControlQueueFile(projectRoot), event);
+
+  return {
+    queued: true,
+    request_id: event.data.request_id,
+    target: REPORT_CONTROL_TARGET,
+    targets: [REPORT_CONTROL_TARGET],
+    report,
+  };
+}
+
+function takeReportControlEvents(projectRoot) {
+  const queueFile = getReportControlQueueFile(projectRoot);
+  if (!fs.existsSync(queueFile)) return [];
+
+  const processingFile = `${queueFile}.processing.${process.pid}.${Date.now()}.${generateInstanceId()}`;
+  let content = "";
+  let readOk = false;
+  try {
+    fs.renameSync(queueFile, processingFile);
+    content = fs.readFileSync(processingFile, "utf8");
+    readOk = true;
+  } catch {
+    try {
+      if (fs.existsSync(processingFile)) {
+        fs.renameSync(processingFile, queueFile);
+      }
+    } catch {
+      // ignore rollback errors
+    }
+    return [];
+  } finally {
+    if (readOk) {
+      try {
+        if (fs.existsSync(processingFile)) {
+          fs.rmSync(processingFile, { force: true });
+        }
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  }
+
+  return content.split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function isAgentReportControlEvent(evt) {
+  if (!evt || typeof evt !== "object") return false;
+  if (evt.target !== REPORT_CONTROL_TARGET) return false;
+  if (evt.type !== REPORT_CONTROL_TYPE) return false;
+  if (evt.event !== REPORT_CONTROL_EVENT) return false;
+  const data = evt.data && typeof evt.data === "object" ? evt.data : {};
+  return Boolean(data.report && typeof data.report === "object");
+}
+
+function extractAgentReportControl(evt) {
+  if (!isAgentReportControlEvent(evt)) return null;
+  const data = evt.data && typeof evt.data === "object" ? evt.data : {};
+  return {
+    report: data.report,
+    request_id: data.request_id || "",
+    queued_at: data.queued_at || evt.timestamp || evt.ts || "",
+  };
+}
+
+module.exports = {
+  REPORT_CONTROL_TARGET,
+  REPORT_CONTROL_EVENT,
+  REPORT_CONTROL_TYPE,
+  getReportControlQueueDir,
+  getReportControlQueueFile,
+  ensureReportControlQueue,
+  resolveReportPublisher,
+  buildReportControlData,
+  buildReportControlEvent,
+  enqueueAgentReport,
+  takeReportControlEvents,
+  isAgentReportControlEvent,
+  extractAgentReportControl,
+};

package/src/ui/ink/ChatApp.js

@@ -1010,8 +1010,14 @@ function inferStatusType(text = "", requestedType = "") {
   const type = String(requestedType || "").trim().toLowerCase();
   if (type === "done" || type === "success" || type === "error" || type === "idle") return type;
   const clean = stripBlessedTags(String(text || "")).trim();
-  if (/^[✓✔]/.test(clean) || /\bdone\b/i.test(clean) || /\bprocessed\b/i.test(clean)) return "done";
-  if (/^[✗!]/.test(clean) || /\berror\b/i.test(clean) || /\bfailed\b/i.test(clean)) return "error";
+  if (/^[✗!]/.test(clean) || /\b(error|failed|failure|offline)\b/i.test(clean) || /失败|错误/.test(clean)) return "error";
+  if (
+    /^[✓✔]/.test(clean) ||
+    /^(done|closed|complete|completed|finished|success|succeeded|ready)\b/i.test(clean) ||
+    /\b(processed|reconnected|switched|saved)\b/i.test(clean) ||
+    /\bdone\s*$/i.test(clean) ||
+    /完成|成功|已处理|已保存|已切换|已连接/.test(clean)
+  ) return "done";
   return type || "typing";
 }
 
@@ -1123,12 +1129,13 @@ function createChatApp({ React, ink, props, interactive = true }) {
         dispatch({ type: "status/idle" });
         return;
       }
+      const type = inferStatusType(clean, options.type || "typing");
       dispatch({
         type: "status/set",
         payload: {
           message: clean,
-          type: inferStatusType(clean, options.type || "typing"),
-          showTimer: options.showTimer === true,
+          type,
+          showTimer: options.showTimer === true && isAnimatedStatusType(type),
           startedAt: options.startedAt || Date.now(),
         },
       });
@@ -1312,8 +1319,10 @@ function createChatApp({ React, ink, props, interactive = true }) {
 
     useEffect(() => {
       if (!stdout) return undefined;
-      const update = () =>
-        setSize({ cols: stdout.columns || 0, rows: stdout.rows || 0 });
+      const update = () => {
+        const next = { cols: stdout.columns || 0, rows: stdout.rows || 0 };
+        setSize((prev) => (prev.cols === next.cols && prev.rows === next.rows ? prev : next));
+      };
       update();
       stdout.on("resize", update);
       return () => stdout.off("resize", update);
@@ -1881,7 +1890,8 @@ function createChatApp({ React, ink, props, interactive = true }) {
     useEffect(() => {
       const internalStatus = state.viewingAgentId ? internalStatusLabel(internalAgentView.status) : "ready";
       const internalActive = internalStatus !== "ready";
-      const statusAnimated = state.status.message && isAnimatedStatusType(state.status.type);
+      const statusType = inferStatusType(state.status.message, state.status.type);
+      const statusAnimated = state.status.message && isAnimatedStatusType(statusType);
       if ((!statusAnimated) && !internalActive) return undefined;
       const timer = setInterval(() => setSpinnerTick((t) => t + 1), 100);
       return () => clearInterval(timer);
@@ -1922,13 +1932,10 @@ function createChatApp({ React, ink, props, interactive = true }) {
         dispatch({ type: "log/append", text: `Error: ${err && err.message ? err.message : err}` });
       }
       if (statusText) {
-        dispatch({
-          type: "status/set",
-          payload: { message: statusText, type: "typing", showTimer: false, startedAt: Date.now() },
-        });
+        setStatusText(statusText, { type: "typing", showTimer: false });
       }
       if (restart) restartDaemonBestEffort();
-    }, [restartDaemonBestEffort]);
+    }, [restartDaemonBestEffort, setStatusText]);
 
     const clearUfooAgentIdentity = useCallback(() => {
       try {
@@ -3501,7 +3508,7 @@ function buildDashHints(state, targetAgentLabel) {
 function computeStatusText(status, spinnerTick) {
   const message = String((status && status.message) || "");
   if (!message) return "CHAT · Ready";
-  const type = String((status && status.type) || "thinking");
+  const type = inferStatusType(message, status && status.type);
   if (type === "done" || type === "success") {
     const clean = stripBlessedTags(message).trim();
     return /^[✓✔]/.test(clean) ? clean : `✓ ${clean}`;

package/src/ui/ink/MultilineInput.js

@@ -482,11 +482,19 @@ function createMultilineInput({ React, ink }) {
         return undefined;
       }
       patchStdoutForIME(out);
+      const targetRowsUp = __imeCursor.lastFrameHadNewline
+        ? rowsBelowCursor
+        : Math.max(0, rowsBelowCursor - 1);
+      const alreadyParked = __imeCursor.active === true
+        && __imeCursor.parkRowsUp === rowsBelowCursor
+        && __imeCursor.parkCol === cursorTermCol
+        && __imeCursor.movedUpRows === targetRowsUp;
       // Publish the desired park target so the stdout monkey-patch can
       // re-park after every throttled ink frame write.
       __imeCursor.active = true;
       __imeCursor.parkRowsUp = rowsBelowCursor;
       __imeCursor.parkCol = cursorTermCol;
+      if (alreadyParked) return undefined;
       // Park immediately — covers cases where ink has nothing to render
       // (output unchanged) and won't fire a frame write at all, and keeps
       // the caret visible between frames. Combine hide + restore + park +
@@ -496,7 +504,7 @@ function createMultilineInput({ React, ink }) {
       // CRITICAL: the move-up amount must match the anchor that movedUpRows
       // was measured against. If the last frame ended without '\n' (the
       // full-screen path), the anchor is one row higher than the log-update
-      // case, so we use rowsUpFromAnchor() rather than parkRowsUp directly.
+      // case, so we use targetRowsUp rather than parkRowsUp directly.
       // Otherwise restoring down by movedUpRows then moving up parkRowsUp
       // overshoots by one and leaves the hardware cursor one row above the
       // inverse caret — the residual "ghost cursor" symptom.
@@ -505,7 +513,7 @@ function createMultilineInput({ React, ink }) {
         combined += `\x1b[${__imeCursor.movedUpRows}B`;
         __imeCursor.movedUpRows = 0;
       }
-      combined += applyParkSequence(rowsUpFromAnchor());
+      combined += applyParkSequence(targetRowsUp);
       out.write(combined);
       return undefined;
     });

package/src/ui/ink/UcodeApp.js

@@ -643,8 +643,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
     useEffect(() => {
       if (!stdout) return undefined;
-      const update = () =>
-        setSize({ cols: stdout.columns || 0, rows: stdout.rows || 0 });
+      const update = () => {
+        const next = { cols: stdout.columns || 0, rows: stdout.rows || 0 };
+        setSize((prev) => (prev.cols === next.cols && prev.rows === next.rows ? prev : next));
+      };
       update();
       stdout.on("resize", update);
       return () => stdout.off("resize", update);
@@ -652,7 +654,11 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
     // Drive the spinner + elapsed-timer redraws while a task is in flight.
     useEffect(() => {
-      if (!status.message || status.type === "none") return undefined;
+      const statusType = inferStatusType(status.message, status.type);
+      if (!status.message || statusType === "none" || statusType === "idle" ||
+        statusType === "done" || statusType === "success" || statusType === "error") {
+        return undefined;
+      }
       const timer = setInterval(() => {
         setSpinnerTick((t) => t + 1);
         if (status.showTimer) setNowTick((t) => t + 1);
@@ -792,6 +798,22 @@ function runUcodeInkTui(props = {}) {
 
 module.exports = { runUcodeInkTui, createUcodeApp, computeStatusText };
 
+function inferStatusType(text = "", requestedType = "") {
+  const type = String(requestedType || "").trim().toLowerCase();
+  if (type === "done" || type === "success" || type === "error" || type === "idle" || type === "none") {
+    return type;
+  }
+  const clean = String(text || "").trim();
+  if (/^[✗!]/.test(clean) || /\b(error|failed|failure)\b/i.test(clean) || /失败|错误/.test(clean)) return "error";
+  if (
+    /^[✓✔]/.test(clean) ||
+    /^(done|complete|completed|finished|success|succeeded|ready)\b/i.test(clean) ||
+    /\bdone\s*$/i.test(clean) ||
+    /完成|成功/.test(clean)
+  ) return "done";
+  return type || "thinking";
+}
+
 /**
  * Pure status-line text builder used by the React component (and unit
  * tests). Returns "UCODE · Ready" while idle and a spinner+message+timer
@@ -802,7 +824,16 @@ function computeStatusText(status, spinnerTick, backgroundSuffix = "") {
   const message = String((status && status.message) || "");
   const suffix = String(backgroundSuffix || "");
   if (!message) return `UCODE · Ready${suffix}`;
-  const type = String((status && status.type) || "thinking");
+  const type = inferStatusType(message, status && status.type);
+  if (type === "done" || type === "success") {
+    const clean = message.trim();
+    return `${/^[✓✔]/.test(clean) ? clean : `✓ ${clean}`}${suffix}`;
+  }
+  if (type === "error") {
+    const clean = message.trim();
+    return `${/^[✗!]/.test(clean) ? clean : `✗ ${clean}`}${suffix}`;
+  }
+  if (type === "idle" || type === "none") return `${message.trim() || "UCODE · Ready"}${suffix}`;
   const indicators = fmt.STATUS_INDICATORS[type] || fmt.STATUS_INDICATORS.thinking;
   const indicator = indicators[Math.max(0, Math.floor(Number(spinnerTick) || 0)) % indicators.length];
   const startedAt = Number.isFinite(status && status.startedAt) ? status.startedAt : 0;

package/src/ui/ink/chatReducer.js

@@ -48,6 +48,53 @@ function projectRootOf(row = {}) {
   return String((row && (row.root || row.project_root || row.projectRoot)) || "");
 }
 
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+}
+
+function shallowArrayEqual(left = [], right = []) {
+  if (left === right) return true;
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) return false;
+  }
+  return true;
+}
+
+function listPayloadEqual(left = [], right = []) {
+  if (left === right) return true;
+  if (!Array.isArray(left) || !Array.isArray(right)) return false;
+  if (left.length !== right.length) return false;
+  for (let i = 0; i < left.length; i += 1) {
+    if (stableJson(left[i]) !== stableJson(right[i])) return false;
+  }
+  return true;
+}
+
+function mapPayloadEqual(left, right) {
+  if (left === right) return true;
+  if (!(left instanceof Map) || !(right instanceof Map)) return false;
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left.entries()) {
+    if (!right.has(key)) return false;
+    if (stableJson(value) !== stableJson(right.get(key))) return false;
+  }
+  return true;
+}
+
+function statusPayloadEqual(left, right) {
+  const normalize = (value = {}) => {
+    const normalized = { ...value };
+    if (normalized.showTimer !== true) normalized.startedAt = 0;
+    return normalized;
+  };
+  return stableJson(normalize(left)) === stableJson(normalize(right));
+}
+
 function createInitialState({ banner = [], globalMode = false, globalScope = "controller", settings = {} } = {}) {
   const initialLaunchMode = settings.launchMode || "auto";
   const initialAgentProvider = settings.agentProvider || "codex-cli";
@@ -174,6 +221,14 @@ function reducer(state, action) {
       } else if (nextIdx >= ids.length) {
         nextIdx = ids.length - 1;
       }
+      if (
+        shallowArrayEqual(state.agents, ids) &&
+        mapPayloadEqual(state.activeAgentMeta, meta) &&
+        state.selectedAgentIndex === nextIdx &&
+        state.agentSelectionMode === nextMode
+      ) {
+        return state;
+      }
       return {
         ...state,
         agents: ids,
@@ -216,12 +271,22 @@ function reducer(state, action) {
       const selectedIndex = selectedRoot
         ? list.findIndex((row) => projectRootOf(row) === selectedRoot)
         : -1;
+      const nextActiveRoot = action.activeProjectRoot || state.activeProjectRoot;
+      if (
+        listPayloadEqual(state.projects, list) &&
+        state.selectedProjectRoot === (selectedIndex >= 0 ? selectedRoot : "") &&
+        state.selectedProjectIndex === selectedIndex &&
+        state.activeProjectRoot === nextActiveRoot &&
+        state.emptyProjectsDownArmed === (list.length === 0 ? state.emptyProjectsDownArmed : false)
+      ) {
+        return state;
+      }
       return {
         ...state,
         projects: list,
         selectedProjectRoot: selectedIndex >= 0 ? selectedRoot : "",
         selectedProjectIndex: selectedIndex,
-        activeProjectRoot: action.activeProjectRoot || state.activeProjectRoot,
+        activeProjectRoot: nextActiveRoot,
         emptyProjectsDownArmed: list.length === 0 ? state.emptyProjectsDownArmed : false,
       };
     }
@@ -240,8 +305,11 @@ function reducer(state, action) {
       return { ...state, projectListWindowStart: Math.max(0, action.windowStart | 0) };
     case "scope/set":
       return { ...state, globalScope: action.scope === "project" ? "project" : "controller" };
-    case "status/set":
-      return { ...state, status: { ...state.status, ...action.payload } };
+    case "status/set": {
+      const nextStatus = { ...state.status, ...action.payload };
+      if (statusPayloadEqual(state.status, nextStatus)) return state;
+      return { ...state, status: nextStatus };
+    }
     case "status/idle":
       return { ...state, status: { message: "", type: "thinking", showTimer: false, startedAt: 0 } };
     case "history/push": {
@@ -311,10 +379,16 @@ function reducer(state, action) {
       return { ...state, selectedProviderIndex: Math.max(0, action.index | 0) };
     case "cronIndex/set":
       return { ...state, selectedCronIndex: Math.max(-1, action.index | 0) };
-    case "cron/set":
-      return { ...state, cronTasks: Array.isArray(action.list) ? action.list : [] };
-    case "loop/set":
-      return { ...state, loopSummary: action.summary && typeof action.summary === "object" ? action.summary : null };
+    case "cron/set": {
+      const list = Array.isArray(action.list) ? action.list : [];
+      if (listPayloadEqual(state.cronTasks, list)) return state;
+      return { ...state, cronTasks: list };
+    }
+    case "loop/set": {
+      const summary = action.summary && typeof action.summary === "object" ? action.summary : null;
+      if (stableJson(state.loopSummary) === stableJson(summary)) return state;
+      return { ...state, loopSummary: summary };
+    }
     case "stream/begin":
       return {
         ...state,