u-foo 1.0.6 → 1.1.9

package/src/daemon/promptLoop.js

@@ -0,0 +1,319 @@
+function buildAssistantContinuationPrompt({
+  originalPrompt,
+  previousReply,
+  reports,
+}) {
+  const lines = [];
+  lines.push(`User: ${originalPrompt}`);
+  if (previousReply) {
+    lines.push("");
+    lines.push(`Your previous reply draft: ${previousReply}`);
+  }
+  lines.push("");
+  lines.push("Assistant execution reports (JSON):");
+  lines.push(JSON.stringify(reports, null, 2));
+  lines.push("");
+  lines.push("Using these reports, return the final JSON response.");
+  return lines.join("\n");
+}
+
+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 annotateAssistantFailureFallback(payload, assistantResult) {
+  if (!payload || typeof payload !== "object") return payload;
+  const dispatchCount = Array.isArray(payload.dispatch) ? payload.dispatch.length : 0;
+  const opsCount = Array.isArray(payload.ops) ? payload.ops.length : 0;
+  if (dispatchCount > 0 || opsCount > 0) return payload;
+
+  const error = assistantResult && typeof assistantResult.error === "string" && assistantResult.error
+    ? assistantResult.error
+    : "assistant task failed";
+  const note = `Assistant execution failed: ${error}. No action was applied.`;
+  const reply = typeof payload.reply === "string" && payload.reply
+    ? `${payload.reply}\n${note}`
+    : note;
+  return {
+    ...payload,
+    reply,
+  };
+}
+
+function extractAssistantCall(payload) {
+  if (!payload || typeof payload !== "object") {
+    return { assistantCall: null, ops: [] };
+  }
+
+  const ops = Array.isArray(payload.ops) ? payload.ops : [];
+  let assistantCall = payload.assistant_call || null;
+  const normalOps = [];
+
+  for (const op of ops) {
+    if (op && op.action === "assistant_call") {
+      if (!assistantCall) assistantCall = op;
+      continue;
+    }
+    if (op) normalOps.push(op);
+  }
+
+  return { assistantCall, ops: normalOps };
+}
+
+function normalizeAssistantCall(call) {
+  if (!call) return null;
+  if (typeof call === "string") {
+    return { task: call, kind: "mixed", context: "", expect: "" };
+  }
+  if (typeof call !== "object") return null;
+  const task = typeof call.task === "string" ? call.task : "";
+  if (!task) return null;
+  return {
+    task,
+    kind: typeof call.kind === "string" ? call.kind : "mixed",
+    context: typeof call.context === "string" ? call.context : "",
+    expect: typeof call.expect === "string" ? call.expect : "",
+    provider: typeof call.provider === "string" ? call.provider : "",
+    model: typeof call.model === "string" ? call.model : "",
+    timeoutMs: Number.isFinite(call.timeout_ms) ? call.timeout_ms : null,
+  };
+}
+
+function buildAssistantReport(call, result) {
+  return {
+    kind: call.kind,
+    task: call.task,
+    ok: result && result.ok !== false,
+    summary: result && typeof result.summary === "string" ? result.summary : "",
+    error: result && typeof result.error === "string" ? result.error : "",
+    artifacts: result && Array.isArray(result.artifacts) ? result.artifacts : [],
+    logs: result && Array.isArray(result.logs) ? result.logs : [],
+    metrics: result && typeof result.metrics === "object" ? result.metrics : {},
+  };
+}
+
+function createAssistantTaskId() {
+  return `assistant-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+async function emitAssistantReport(reportTaskStatus, payload) {
+  if (typeof reportTaskStatus !== "function") return;
+  try {
+    await reportTaskStatus(payload);
+  } catch {
+    // best effort: reporting must not break prompt flow
+  }
+}
+
+async function finalizePromptRun({
+  projectRoot,
+  payload,
+  processManager,
+  dispatchMessages,
+  handleOps,
+  markPending,
+}) {
+  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,
+    payload,
+    opsResults,
+  };
+}
+
+async function runPromptWithAssistant({
+  projectRoot,
+  prompt,
+  provider,
+  model,
+  processManager = null,
+  runUfooAgent,
+  runAssistantTask,
+  dispatchMessages,
+  handleOps,
+  markPending = () => {},
+  reportTaskStatus = () => {},
+  maxAssistantLoops = 2,
+  log = () => {},
+}) {
+  const firstResult = await runUfooAgent({
+    projectRoot,
+    prompt: prompt || "",
+    provider,
+    model,
+  });
+
+  if (!firstResult || !firstResult.ok) {
+    return {
+      ok: false,
+      error: (firstResult && firstResult.error) || "agent failed",
+    };
+  }
+
+  const firstPayload = normalizePayload(firstResult.payload);
+  const extractedFirst = extractAssistantCall(firstPayload);
+  const assistantCall = normalizeAssistantCall(extractedFirst.assistantCall);
+  const basePayload = {
+    ...firstPayload,
+    ops: extractedFirst.ops,
+  };
+  delete basePayload.assistant_call;
+
+  if (!assistantCall || maxAssistantLoops < 1) {
+    return finalizePromptRun({
+      projectRoot,
+      payload: basePayload,
+      processManager,
+      dispatchMessages,
+      handleOps,
+      markPending,
+    });
+  }
+
+  const assistantTaskId = createAssistantTaskId();
+  await emitAssistantReport(reportTaskStatus, {
+    phase: "start",
+    source: "assistant",
+    agent_id: "ufoo-assistant-agent",
+    scope: "private",
+    controller_id: "ufoo-agent",
+    task_id: assistantTaskId,
+    message: assistantCall.task,
+    summary: "",
+    error: "",
+    ok: true,
+    meta: {
+      kind: assistantCall.kind,
+      provider: assistantCall.provider || provider || "",
+      model: assistantCall.model || model || "",
+    },
+  });
+
+  let assistantResult;
+  try {
+    assistantResult = await runAssistantTask({
+      projectRoot,
+      provider: assistantCall.provider || "",
+      fallbackProvider: provider,
+      model: assistantCall.model || model,
+      task: assistantCall.task,
+      kind: assistantCall.kind,
+      context: assistantCall.context,
+      expect: assistantCall.expect,
+      timeoutMs: assistantCall.timeoutMs || undefined,
+    });
+  } catch (err) {
+    assistantResult = {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: [],
+      error: err && err.message ? err.message : "assistant task failed",
+      metrics: {},
+    };
+  }
+
+  await emitAssistantReport(reportTaskStatus, {
+    phase: assistantResult && assistantResult.ok === false ? "error" : "done",
+    source: "assistant",
+    agent_id: "ufoo-assistant-agent",
+    scope: "private",
+    controller_id: "ufoo-agent",
+    task_id: assistantTaskId,
+    message: assistantCall.task,
+    summary: assistantResult && typeof assistantResult.summary === "string" ? assistantResult.summary : "",
+    error: assistantResult && typeof assistantResult.error === "string" ? assistantResult.error : "",
+    ok: assistantResult && assistantResult.ok !== false,
+    meta: {
+      kind: assistantCall.kind,
+      provider: assistantCall.provider || provider || "",
+      model: assistantCall.model || model || "",
+      metrics: assistantResult && assistantResult.metrics && typeof assistantResult.metrics === "object"
+        ? assistantResult.metrics
+        : {},
+    },
+  });
+
+  if (!assistantResult || assistantResult.ok === false) {
+    log("assistant-loop fallback to round1 payload");
+    const fallbackPayload = annotateAssistantFailureFallback(basePayload, assistantResult);
+    return finalizePromptRun({
+      projectRoot,
+      payload: fallbackPayload,
+      processManager,
+      dispatchMessages,
+      handleOps,
+      markPending,
+    });
+  }
+
+  const reports = [buildAssistantReport(assistantCall, assistantResult)];
+  const continuationPrompt = buildAssistantContinuationPrompt({
+    originalPrompt: prompt || "",
+    previousReply: basePayload.reply || "",
+    reports,
+  });
+
+  const secondResult = await runUfooAgent({
+    projectRoot,
+    prompt: continuationPrompt,
+    provider,
+    model,
+  });
+
+  if (!secondResult || !secondResult.ok) {
+    log("assistant-loop fallback to round1 payload (round2 failed)");
+    return finalizePromptRun({
+      projectRoot,
+      payload: basePayload,
+      processManager,
+      dispatchMessages,
+      handleOps,
+      markPending,
+    });
+  }
+
+  const secondPayload = normalizePayload(secondResult.payload);
+  const extractedSecond = extractAssistantCall(secondPayload);
+  const finalPayload = {
+    ...secondPayload,
+    ops: extractedSecond.ops,
+    assistant: { runs: reports },
+  };
+  delete finalPayload.assistant_call;
+
+  return finalizePromptRun({
+    projectRoot,
+    payload: finalPayload,
+    processManager,
+    dispatchMessages,
+    handleOps,
+    markPending,
+  });
+}
+
+module.exports = {
+  runPromptWithAssistant,
+  buildAssistantContinuationPrompt,
+  normalizePayload,
+  annotateAssistantFailureFallback,
+  extractAssistantCall,
+  normalizeAssistantCall,
+  buildAssistantReport,
+};

package/src/daemon/promptRequest.js

@@ -0,0 +1,101 @@
+"use strict";
+
+const { IPC_RESPONSE_TYPES } = require("../shared/eventContract");
+const {
+  listControllerInboxEntries,
+  consumeControllerInboxEntries,
+} = require("../report/store");
+
+function buildPromptWithPrivateReports(prompt = "", reports = []) {
+  if (!Array.isArray(reports) || reports.length === 0) {
+    return prompt;
+  }
+  const lines = [];
+  lines.push(prompt || "");
+  lines.push("");
+  lines.push("Private runtime reports for ufoo-agent (JSON):");
+  lines.push(JSON.stringify(reports, null, 2));
+  lines.push("");
+  lines.push("Use these runtime reports when deciding reply/dispatch/ops.");
+  return lines.join("\n");
+}
+
+async function handlePromptRequest(options = {}) {
+  const {
+    projectRoot,
+    req = {},
+    socket,
+    provider,
+    model,
+    processManager = null,
+    runPromptWithAssistant,
+    runUfooAgent,
+    runAssistantTask,
+    dispatchMessages,
+    handleOps,
+    markPending = () => {},
+    reportTaskStatus = () => {},
+    log = () => {},
+  } = options;
+
+  log(`prompt ${String(req.text || "").slice(0, 200)}`);
+  const privateReports = listControllerInboxEntries(projectRoot, "ufoo-agent", { num: 100 });
+  const promptText = buildPromptWithPrivateReports(req.text || "", privateReports);
+
+  try {
+    const handled = await runPromptWithAssistant({
+      projectRoot,
+      prompt: promptText,
+      provider,
+      model,
+      processManager,
+      runUfooAgent,
+      runAssistantTask,
+      dispatchMessages,
+      handleOps,
+      markPending,
+      reportTaskStatus,
+      maxAssistantLoops: 2,
+      log,
+    });
+
+    if (!handled.ok) {
+      log(`agent-fail ${handled.error || "agent failed"}`);
+      socket.write(
+        `${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.ERROR,
+          error: handled.error || "agent failed",
+        })}\n`,
+      );
+      return false;
+    }
+
+    consumeControllerInboxEntries(projectRoot, "ufoo-agent", privateReports);
+
+    const payload = handled.payload || {};
+    const opsResults = handled.opsResults || [];
+    log(`ok reply=${Boolean(payload.reply)} dispatch=${(payload.dispatch || []).length} ops=${(payload.ops || []).length}`);
+    socket.write(
+      `${JSON.stringify({
+        type: IPC_RESPONSE_TYPES.RESPONSE,
+        data: payload,
+        opsResults,
+      })}\n`,
+    );
+    return true;
+  } catch (err) {
+    log(`error ${err.message || String(err)}`);
+    socket.write(
+      `${JSON.stringify({
+        type: IPC_RESPONSE_TYPES.ERROR,
+        error: err.message || String(err),
+      })}\n`,
+    );
+    return false;
+  }
+}
+
+module.exports = {
+  handlePromptRequest,
+  buildPromptWithPrivateReports,
+};

package/src/daemon/providerSessions.js

@@ -14,11 +14,16 @@ function buildProbeMarker(nickname) {
 }
 
 /**
- * Build probe command: /ufoo <nickname> for claude-code, ufoo <nickname> for codex
+ * Build probe command:
+ * - claude-code: /ufoo <nickname>
+ * - codex: $ufoo <nickname>
  */
 function buildProbeCommand(agentType, nickname) {
-  const base = `ufoo ${nickname}`;
-  return agentType === "claude-code" ? `/${base}` : base;
+  const marker = String(nickname || "").trim();
+  if (agentType === "claude-code") {
+    return `/ufoo ${marker}`;
+  }
+  return `$ufoo ${marker}`;
 }
 
 function readLines(filePath) {
@@ -30,22 +35,30 @@ function readLines(filePath) {
   }
 }
 
+function escapeRegExp(value = "") {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function containsProbeCommand(text, marker) {
+  if (!text || !marker) return false;
+  const escapedMarker = escapeRegExp(marker);
+  const pattern = `(?:^|[\\s"'\\\`])(?:\\/ufoo|\\$ufoo|ufoo)\\s+${escapedMarker}(?=$|[\\s"'\\\`.,:;!?\\]\\)\\}])`;
+  const re = new RegExp(pattern);
+  return re.test(String(text));
+}
+
 /**
  * Check if a history record contains our probe marker
- * Searches for "/ufoo <marker>" or "ufoo <marker>" pattern
+ * Searches for probe marker command patterns:
+ * - "/ufoo <marker>" (claude)
+ * - "$ufoo <marker>" (codex)
+ * - "ufoo <marker>" (legacy compatibility)
  */
 function recordContainsMarker(record, marker, rawLine) {
   if (!marker) return false;
 
-  // Build both possible patterns
-  const patterns = [`/ufoo ${marker}`, `ufoo ${marker}`];
-
   // Check raw line first (fastest)
-  if (rawLine) {
-    for (const pattern of patterns) {
-      if (rawLine.includes(pattern)) return true;
-    }
-  }
+  if (containsProbeCommand(rawLine, marker)) return true;
 
   if (!record || typeof record !== "object") return false;
 
@@ -61,11 +74,7 @@ function recordContainsMarker(record, marker, rawLine) {
   ];
 
   for (const field of fields) {
-    if (typeof field === "string") {
-      for (const pattern of patterns) {
-        if (field.includes(pattern)) return true;
-      }
-    }
+    if (containsProbeCommand(field, marker)) return true;
   }
   return false;
 }
@@ -288,4 +297,10 @@ function scheduleProviderSessionProbe({
 module.exports = {
   scheduleProviderSessionProbe,
   loadProviderSessionCache,
+  __private: {
+    buildProbeCommand,
+    recordContainsMarker,
+    containsProbeCommand,
+    escapeRegExp,
+  },
 };

package/src/daemon/reporting.js

@@ -0,0 +1,90 @@
+const fs = require("fs");
+const { BUS_STATUS_PHASES } = require("../shared/eventContract");
+const {
+  REPORT_PHASES,
+  normalizeReportInput,
+  appendReport,
+  updateReportState,
+  appendControllerInboxEntry,
+} = require("../report/store");
+const { getUfooPaths } = require("../ufoo/paths");
+
+function resolveAgentDisplayName(projectRoot, agentId) {
+  if (!agentId) return "unknown-agent";
+  try {
+    const busPath = getUfooPaths(projectRoot).agentsFile;
+    const bus = JSON.parse(fs.readFileSync(busPath, "utf8"));
+    const meta = bus && bus.agents ? bus.agents[agentId] : null;
+    if (meta && typeof meta.nickname === "string" && meta.nickname.trim()) {
+      return meta.nickname.trim();
+    }
+  } catch {
+    // ignore
+  }
+  return agentId;
+}
+
+function toStatusPhase(reportPhase) {
+  if (reportPhase === REPORT_PHASES.START || reportPhase === REPORT_PHASES.PROGRESS) {
+    return BUS_STATUS_PHASES.START;
+  }
+  if (reportPhase === REPORT_PHASES.ERROR) return BUS_STATUS_PHASES.ERROR;
+  return BUS_STATUS_PHASES.DONE;
+}
+
+function formatStatusText(displayName, entry) {
+  if (entry.phase === REPORT_PHASES.START) {
+    const detail = entry.message || entry.summary || entry.task_id;
+    return `${displayName} ${detail}`;
+  }
+  if (entry.phase === REPORT_PHASES.PROGRESS) {
+    const detail = entry.message || entry.summary || entry.task_id;
+    return `${displayName} progress: ${detail}`;
+  }
+  if (entry.phase === REPORT_PHASES.ERROR) {
+    const detail = entry.error || entry.summary || entry.message || entry.task_id;
+    return `${displayName} failed: ${detail}`;
+  }
+  const detail = entry.summary || entry.message || entry.task_id;
+  return `${displayName} done: ${detail}`;
+}
+
+function buildReportStatus(entry, displayName) {
+  return {
+    phase: toStatusPhase(entry.phase),
+    key: `report:${entry.agent_id}:${entry.task_id}`,
+    text: formatStatusText(displayName, entry),
+  };
+}
+
+function publishToPrivateController(projectRoot, entry) {
+  if (!entry || !entry.controller_id) return;
+  appendControllerInboxEntry(projectRoot, entry.controller_id, entry);
+}
+
+async function recordAgentReport({
+  projectRoot,
+  report,
+  onStatus = () => {},
+  log = () => {},
+}) {
+  const entry = normalizeReportInput(report);
+  appendReport(projectRoot, entry);
+  const state = updateReportState(projectRoot, entry);
+  publishToPrivateController(projectRoot, entry);
+  const displayName = resolveAgentDisplayName(projectRoot, entry.agent_id);
+  if (entry.scope !== "private") {
+    onStatus(buildReportStatus(entry, displayName));
+  }
+  log(`report ${entry.phase} scope=${entry.scope} agent=${entry.agent_id} task=${entry.task_id}`);
+  return { entry, state };
+}
+
+module.exports = {
+  recordAgentReport,
+  resolveAgentDisplayName,
+  toStatusPhase,
+  formatStatusText,
+  buildReportStatus,
+  publishToPrivateController,
+};

package/src/daemon/run.js

@@ -46,9 +46,7 @@ function runDaemonCli(argv) {
     // Start fresh daemon
     if (!process.env.UFOO_DAEMON_CHILD) {
       const { spawn } = require("child_process");
-      const forceResume = launchMode !== "terminal";
       const childEnv = { ...process.env, UFOO_DAEMON_CHILD: "1" };
-      if (forceResume) childEnv.UFOO_FORCE_RESUME = "1";
       const child = spawn(process.execPath, [path.join(__dirname, "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
         detached: true,
         stdio: "ignore",
@@ -58,9 +56,8 @@ function runDaemonCli(argv) {
       child.unref();
       return;
     }
-    // Skip auto-resume on restart in terminal mode to avoid reopening stale terminals.
-    const forceResume = launchMode !== "terminal";
-    startDaemon({ projectRoot, provider, model, resumeMode: forceResume ? "force" : "none" });
+    // Manual restart does not auto-resume; crash-recovery is handled on next auto start with stale lock detection.
+    startDaemon({ projectRoot, provider, model, resumeMode: "none" });
     return;
   }
   if (cmd === "status" || cmd === "--status") {

package/src/daemon/status.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { getUfooPaths } = require("../ufoo/paths");
 const { isMetaActive } = require("../bus/utils");
+const { readReportSummary } = require("../report/store");
 
 function readBus(projectRoot) {
   const busPath = getUfooPaths(projectRoot).agentsFile;
@@ -60,11 +61,28 @@ function isHiddenSubscriber(id, meta) {
   return false;
 }
 
-function buildStatus(projectRoot) {
+function normalizeCronTasks(raw = []) {
+  const items = Array.isArray(raw) ? raw : [];
+  return items.map((task) => ({
+    id: String(task && task.id ? task.id : ""),
+    intervalMs: Number(task && task.intervalMs ? task.intervalMs : 0) || 0,
+    interval: String(task && task.interval ? task.interval : ""),
+    targets: Array.isArray(task && task.targets) ? task.targets.slice() : [],
+    prompt: String(task && task.prompt ? task.prompt : ""),
+    summary: String(task && task.summary ? task.summary : ""),
+    createdAt: Number(task && task.createdAt ? task.createdAt : 0) || 0,
+    lastRunAt: Number(task && task.lastRunAt ? task.lastRunAt : 0) || 0,
+    tickCount: Number(task && task.tickCount ? task.tickCount : 0) || 0,
+  }));
+}
+
+function buildStatus(projectRoot, options = {}) {
   const bus = readBus(projectRoot);
   const decisions = readDecisions(projectRoot);
   const unread = readUnread(projectRoot);
+  const reports = readReportSummary(projectRoot);
   const subscribers = bus ? Object.keys(bus.agents || {}) : [];
+  const cronTasks = normalizeCronTasks(options.cronTasks || []);
 
   const activeEntries = bus
     ? Object.entries(bus.agents || {})
@@ -89,6 +107,11 @@ function buildStatus(projectRoot) {
     active_meta: activeMeta,
     unread,
     decisions,
+    reports,
+    cron: {
+      count: cronTasks.length,
+      tasks: cronTasks,
+    },
   };
 }