u-foo 2.4.0 → 2.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "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/chat/commandExecutor.js

@@ -112,6 +112,7 @@ async function withCapturedConsole(capture, fn) {
 }
 
 function createCommandExecutor(options = {}) {
+  const hasRestartDaemon = typeof options.restartDaemon === "function";
   const {
     projectRoot,
     getActiveProjectRoot = () => projectRoot,
@@ -255,6 +256,18 @@ function createCommandExecutor(options = {}) {
     }
 
     if (subcommand === "restart") {
+      if (hasRestartDaemon) {
+        statusMsg("{gray-fg}⚙{/gray-fg} Restarting daemon...");
+        await restartDaemon(targetRoot);
+        await sleep(500);
+        if (isDaemonRunning(targetRoot)) {
+          statusMsg("{gray-fg}✓{/gray-fg} Daemon restarted");
+        } else {
+          statusMsg("{gray-fg}✗{/gray-fg} Failed to restart daemon");
+        }
+        return;
+      }
+
       statusMsg("{gray-fg}⚙{/gray-fg} Restarting daemon...");
       stopDaemon(targetRoot, { source: "chat-command:/daemon restart" });
       await sleep(500);

package/src/app/chat/daemonReconnect.js

@@ -30,6 +30,9 @@ function restartDaemonFlow(options = {}) {
       startDaemon(projectRoot);
       const connected = connection ? await connection.connect() : false;
       if (connected) {
+        if (typeof connection.requestStatus === "function") {
+          connection.requestStatus();
+        }
         statusMsg("{gray-fg}✓{/gray-fg} Daemon reconnected");
       } else {
         statusMsg("{gray-fg}✗{/gray-fg} Failed to reconnect to daemon");

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,
+};