u-foo 2.5.6 → 2.5.8

package/src/code/agent.js

@@ -1,22 +1,8 @@
-const readline = require("readline");
 const fs = require("fs");
 const path = require("path");
-const { execSync } = require("child_process");
-const { runToolCall, TOOL_NAMES } = require("./dispatch");
+const { runToolCall } = require("./dispatch");
 const { runNativeAgentTask } = require("./nativeRunner");
-const {
-  runDecomposedTask,
-  createBusProgressReporter,
-} = require("./taskDecomposer");
-const {
-  runUcodeTui,
-  shouldUseUcodeTui,
-  buildUcodeBannerLines,
-  StreamBuffer,
-  createEscapeTagStripper,
-  stripLeakedEscapeTags,
-} = require("./tui");
-const { stripBlessedTags } = require("../app/chat/text");
+const { runDecomposedTask } = require("./taskDecomposer");
 const { loadConfig, defaultAgentModelForProvider, sameModelProvider } = require("../config");
 const {
   resolveSessionId,
@@ -25,77 +11,48 @@ const {
   loadSessionSnapshot,
 } = require("./sessionStore");
 const { buildPromptContext } = require("../agents/prompts/native");
+const { buildSkillInjections } = require("./skills");
 const {
-  buildSkillInjections,
-  formatSkillsList,
-  listUcodeSkills,
-  showSkill,
-} = require("./skills");
-const { DeliveryQueue } = require("../coordination/bus/deliveryQueue");
-
-function printPrompt() {
-  process.stdout.write("> ");
-}
-
-function printUcodeBanner(stdout = process.stdout, { model = "", workspaceRoot = process.cwd(), sessionId = "" } = {}) {
-  stdout.write(`${buildUcodeBannerLines({
-    model,
-    engine: "ufoo-core",
-    workspaceRoot,
-    sessionId,
-    width: (stdout && stdout.columns) || 0,
-  }).join("\n")}\n`);
-}
-
-function normalizeLine(input = "") {
-  return String(input || "").trim();
-}
-
-function parseLegacyUfooMarkerCommand(input = "") {
-  const text = String(input || "").trim();
-  if (!text) return "";
-  // Old daemons injected strict "<prefix> <single-token>" commands for
-  // session discovery. Keep ignoring those inputs after removing injection.
-  const match = text.match(/^(?:\$ufoo|\/ufoo|ufoo)\s+([A-Za-z0-9][A-Za-z0-9._:-]{0,63})$/);
-  return match ? String(match[1] || "").trim() : "";
-}
-
-function parseJson(text = "") {
-  const raw = String(text || "").trim();
-  if (!raw) return {};
-  const parsed = JSON.parse(raw);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-  return parsed;
-}
+  runUbusCommand,
+  parseBusCheckOutput,
+  extractBusMessageTask,
+  runShellCapture,
+  stripAnsi,
+  busCheckOutputIndicatesPending,
+  resolvePendingQueueFile,
+  resolveUfooProjectRoot,
+  countPendingQueueLines,
+  getPendingBusCount,
+  drainJsonlFile,
+  extractTaskFromBusEvent,
+  shouldAutoConsumeBus,
+} = require("./busConsumer");
+const {
+  runUcodeCoreAgent,
+  runSingleCommand,
+  extractAgentNickname,
+  parseAgentArgs,
+} = require("./repl");
 
 function readTextOrFile(value = "") {
   const raw = String(value || "").trim();
   if (!raw) return "";
-  try {
-    if (fs.existsSync(raw)) return String(fs.readFileSync(raw, "utf8") || "");
-  } catch {
-    // ignore
+  // Only read from disk when the value clearly looks like a path; otherwise a
+  // prompt that happens to match an existing file would be silently replaced
+  // by that file's contents.
+  const looksLikePath = !/[\r\n]/.test(raw)
+    && (raw.startsWith("./") || raw.startsWith("/") || raw.startsWith("~")
+      || /\.(?:md|txt)$/i.test(raw));
+  if (looksLikePath) {
+    try {
+      if (fs.existsSync(raw)) return String(fs.readFileSync(raw, "utf8") || "");
+    } catch {
+      // ignore
+    }
   }
   return raw;
 }
 
-function extractAgentNickname(agentId = "") {
-  // Extract nickname from agent ID like "ufoo-agent:abc123" -> "ufoo"
-  const id = String(agentId || "").trim();
-  if (!id) return "";
-
-  // Remove the instance ID part (after colon)
-  const base = id.split(":")[0];
-
-  // Common agent nickname mappings
-  if (base === "ufoo-agent") return "ufoo";
-  if (base === "claude-code") return "claude";
-  if (base === "ufoo-code") return "ucode";
-
-  // Return base name as-is for others
-  return base;
-}
-
 function resolveUcodeProviderModel({
   workspaceRoot = process.cwd(),
   provider = "",
@@ -451,7 +408,7 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
   const pushToolLog = createToolLogCollector(logs, onToolLog);
 
   // Detect bug fix tasks and use decomposed runner
-  const isBugFixTask = /fix|bug|issue|problem|error|broken|not work/i.test(taskText);
+  const isBugFixTask = /\b(?:fix(?:es|ed|ing)?|bugs?|issues?|problems?|errors?|broken)\b|doesn't work|not work/i.test(taskText);
   const useDecomposition = isBugFixTask && !options.disableDecomposition;
   const analysisTask = isProjectAnalysisTask(taskText);
   const workspaceRoot = String(state.workspaceRoot || process.cwd());
@@ -525,7 +482,6 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
     if (useDecomposition) {
       const decomposedResult = await runDecomposedTask({
         task: effectiveTaskPrompt,
-        state,
         onProgress: options.onProgress,
         onToolEvent: pushToolLog,
         signal: options.signal,
@@ -679,6 +635,21 @@ function buildSessionSnapshotFromState(state = {}) {
 
 function persistSessionState(state = {}) {
   const snapshot = buildSessionSnapshotFromState(state);
+  if (!state.sessionId && snapshot.sessionId) {
+    state.sessionId = snapshot.sessionId;
+  }
+  // Skip writing sessions that carry no messages yet; otherwise every launch
+  // (even an immediate quit) leaves an empty session file behind and the
+  // sessions directory grows without bound.
+  if (!Array.isArray(snapshot.nlMessages) || snapshot.nlMessages.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      error: "",
+      sessionId: snapshot.sessionId,
+      filePath: "",
+    };
+  }
   const saved = saveSessionSnapshot(snapshot.workspaceRoot, snapshot);
   if (saved && saved.ok) {
     state.sessionId = saved.sessionId;
@@ -731,1002 +702,6 @@ function resumeSessionState(state = {}, sessionId = "", workspaceRoot = process.
   };
 }
 
-function shellQuote(value = "") {
-  const text = String(value == null ? "" : value);
-  return `'${text.replace(/'/g, `'\"'\"'`)}'`;
-}
-
-function toText(value = "") {
-  if (typeof value === "string") return value;
-  if (Buffer.isBuffer(value)) return value.toString("utf8");
-  return String(value == null ? "" : value);
-}
-
-function stripAnsi(text = "") {
-  const raw = String(text || "");
-  if (!raw) return "";
-  // CSI + OSC sequences (best-effort).
-  return raw
-    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "")
-    .replace(/\x1b\][^\x07]*\x07/g, "")
-    .replace(/\x1b\][^\x1b]*(?:\x1b\\)/g, "");
-}
-
-function runShellCapture(command = "", workspaceRoot = process.cwd()) {
-  try {
-    const output = execSync(String(command || ""), {
-      cwd: workspaceRoot,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    return {
-      ok: true,
-      output: toText(output),
-      error: "",
-    };
-  } catch (err) {
-    const stdout = toText(err && err.stdout);
-    const stderr = toText(err && err.stderr);
-    const detail = [stdout, stderr].filter(Boolean).join("\n").trim();
-    return {
-      ok: false,
-      output: detail,
-      error: detail || (err && err.message ? err.message : "shell command failed"),
-    };
-  }
-}
-
-function safeSubscriberName(subscriberId = "") {
-  return String(subscriberId || "").replace(/:/g, "_");
-}
-
-function resolvePendingQueueFile(workspaceRoot = process.cwd(), subscriberId = "") {
-  const root = String(workspaceRoot || process.cwd()).trim() || process.cwd();
-  const sub = String(subscriberId || "").trim();
-  if (!sub) return "";
-  return path.join(root, ".ufoo", "bus", "queues", safeSubscriberName(sub), "pending.jsonl");
-}
-
-function resolveUfooProjectRoot(preferredRoot = "", env = process.env) {
-  const candidates = [
-    String(preferredRoot || "").trim(),
-    String((env && env.UFOO_UCODE_PROJECT_ROOT) || "").trim(),
-    String((env && env.UFOO_PROJECT_ROOT) || "").trim(),
-    process.cwd(),
-  ].filter(Boolean);
-
-  for (const root of candidates) {
-    try {
-      const busDir = path.join(root, ".ufoo", "bus");
-      if (fs.existsSync(busDir)) return root;
-    } catch {
-      // ignore
-    }
-  }
-
-  return candidates[0] || process.cwd();
-}
-
-function countPendingQueueLines(filePath = "") {
-  const target = String(filePath || "").trim();
-  if (!target) return 0;
-  try {
-    if (!fs.existsSync(target)) return 0;
-    const content = String(fs.readFileSync(target, "utf8") || "");
-    if (!content.trim()) return 0;
-    return content.split(/\r?\n/).filter((line) => line.trim()).length;
-  } catch {
-    return 0;
-  }
-}
-
-function isPidAlive(pid) {
-  const p = parseInt(String(pid || "").trim(), 10);
-  if (!Number.isFinite(p) || p <= 0) return false;
-  try {
-    process.kill(p, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function listProcessingFiles(pendingFilePath = "") {
-  const pendingFile = String(pendingFilePath || "").trim();
-  if (!pendingFile) return [];
-  const dir = path.dirname(pendingFile);
-  const base = path.basename(pendingFile);
-  const prefix = `${base}.processing.`;
-  try {
-    if (!fs.existsSync(dir)) return [];
-    return fs.readdirSync(dir)
-      .filter((name) => name && name.startsWith(prefix))
-      .map((name) => path.join(dir, name));
-  } catch {
-    return [];
-  }
-}
-
-function countRecoverableProcessingFiles(pendingFilePath = "", options = {}) {
-  const pendingFile = String(pendingFilePath || "").trim();
-  if (!pendingFile) return 0;
-  const maxAgeMs = Number.isFinite(options.maxAgeMs) ? options.maxAgeMs : 60000;
-  const now = Date.now();
-  const files = listProcessingFiles(pendingFile);
-  let count = 0;
-
-  for (const file of files) {
-    const name = path.basename(file);
-    const m = name.match(/\.processing\.(\d+)\./);
-    const pid = m ? parseInt(m[1], 10) : NaN;
-
-    if (Number.isFinite(pid) && pid > 0 && !isPidAlive(pid)) {
-      count += 1;
-      continue;
-    }
-
-    if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) continue;
-    try {
-      const stat = fs.statSync(file);
-      if (stat && stat.isFile() && (now - stat.mtimeMs > maxAgeMs)) {
-        count += 1;
-      }
-    } catch {
-      // ignore
-    }
-  }
-
-  return count;
-}
-
-function getPendingBusCount(workspaceRoot = process.cwd(), subscriberId = "") {
-  const pendingFile = resolvePendingQueueFile(workspaceRoot, subscriberId);
-  const pendingLines = countPendingQueueLines(pendingFile);
-  if (!pendingFile) return pendingLines;
-  // If a prior crash left `.processing.*` behind, count it so autoBus can self-heal.
-  const recoverable = countRecoverableProcessingFiles(pendingFile, { maxAgeMs: 60000 });
-  return pendingLines + recoverable;
-}
-
-function drainJsonlFile(filePath = "") {
-  const target = String(filePath || "").trim();
-  if (!target) return { drained: [], rawLines: [], error: "" };
-  const queue = new DeliveryQueue(target);
-  const drained = [];
-  const rawLines = [];
-  const claims = [];
-  try {
-    queue.recover();
-    while (true) {
-      const claim = queue.claimNext();
-      if (!claim) break;
-      claims.push(claim);
-      drained.push(claim.event);
-      rawLines.push(JSON.stringify(claim.event));
-      queue.completeClaim(claim);
-    }
-  } catch (err) {
-    for (const claim of claims) queue.restoreClaim(claim);
-    return { drained: [], rawLines: [], error: err && err.message ? err.message : "drain failed" };
-  }
-  return {
-    drained,
-    rawLines,
-    error: "",
-    claims,
-    processingFile: claims[0] ? claims[0].processingFile : "",
-  };
-}
-
-function extractTaskFromBusEvent(evt) {
-  if (!evt || typeof evt !== "object") return null;
-  if (String(evt.event || "").trim().toLowerCase() !== "message") return null;
-  let publisher = "";
-  if (typeof evt.publisher === "string") {
-    publisher = String(evt.publisher || "").trim();
-  } else if (evt.publisher && typeof evt.publisher === "object") {
-    publisher = String(evt.publisher.subscriber || evt.publisher.nickname || "").trim();
-  } else {
-    publisher = String(evt.publisher || "").trim();
-  }
-  if (publisher === "[object Object]") publisher = "";
-  if (!publisher) return null;
-  const data = evt.data && typeof evt.data === "object" ? evt.data : {};
-  const message = typeof data.message === "string"
-    ? data.message
-    : (typeof data.text === "string" ? data.text : "");
-  const task = String(message || "").trim();
-  if (!task) return null;
-  return { publisher, task };
-}
-
-function shouldAutoConsumeBus(subscriberId = "") {
-  const id = String(subscriberId || "").trim().toLowerCase();
-  if (!id) return false;
-  return id.startsWith("ufoo-code:")
-    || id.startsWith("ucode:")
-    || id.startsWith("ufoo:");
-}
-
-function extractBusMessageTask(contentRaw = "") {
-  const raw = String(contentRaw || "").trim();
-  if (!raw) return "";
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") {
-      if (typeof parsed.message === "string" && parsed.message.trim()) return parsed.message.trim();
-      if (typeof parsed.text === "string" && parsed.text.trim()) return parsed.text.trim();
-      if (typeof parsed.prompt === "string" && parsed.prompt.trim()) return parsed.prompt.trim();
-    }
-  } catch {
-    // treat as plain text below
-  }
-  return raw;
-}
-
-function busCheckOutputIndicatesPending(raw = "") {
-  const text = stripAnsi(String(raw || ""));
-  if (!text.trim()) return false;
-  if (/no pending messages/i.test(text)) return false;
-  if (/you have\s+\d+\s+pending/i.test(text)) return true;
-  if (/after handling,\s*run:\s*ufoo bus ack/i.test(text)) return true;
-  if (/pending event/i.test(text)) return true;
-  return false;
-}
-
-function parseBusCheckOutput(raw = "") {
-  const text = stripAnsi(String(raw || ""));
-  if (!text.trim()) return [];
-  if (/no pending messages/i.test(text)) return [];
-
-  const lines = text.split(/\r?\n/);
-  const rows = [];
-  let current = null;
-
-  for (const line of lines) {
-    const trimmed = String(line || "").trim();
-    if (!trimmed) continue;
-
-    const header = trimmed.match(/^@.+\s+from\s+([^\s]+)\s*$/i);
-    if (header) {
-      if (current && current.publisher) rows.push(current);
-      current = {
-        publisher: String(header[1] || "").trim(),
-        content: "",
-      };
-      continue;
-    }
-
-    if (!current) continue;
-
-    const contentMatch = trimmed.match(/^content:\s*(.*)$/i);
-    if (contentMatch) {
-      current.content = String(contentMatch[1] || "").trim();
-      continue;
-    }
-
-    if (
-      current.content
-      && !/^(type|event|seq|target|timestamp):\s*/i.test(trimmed)
-      && !trimmed.startsWith("@")
-    ) {
-      current.content = `${current.content}\n${trimmed}`;
-    }
-  }
-
-  if (current && current.publisher) rows.push(current);
-
-  return rows
-    .map((entry) => {
-      const publisher = String(entry.publisher || "").trim();
-      const content = String(entry.content || "").trim();
-      const task = extractBusMessageTask(content);
-      if (!publisher || !task) return null;
-      return {
-        publisher,
-        content,
-        task,
-      };
-    })
-    .filter(Boolean);
-}
-
-async function runUbusCommand(state = {}, options = {}) {
-  const runtimeWorkspace = resolveUfooProjectRoot(String(
-    options.workspaceRoot
-      || (state && state.workspaceRoot)
-      || ""
-  ));
-  const shell = typeof options.execShell === "function"
-    ? options.execShell
-    : (command) => runShellCapture(command, runtimeWorkspace);
-  const runNl = typeof options.runNaturalLanguageTaskImpl === "function"
-    ? options.runNaturalLanguageTaskImpl
-    : runNaturalLanguageTask;
-  const formatNl = typeof options.formatNlResultImpl === "function"
-    ? options.formatNlResultImpl
-    : formatNlResult;
-  const onMessageReceived = typeof options.onMessageReceived === "function"
-    ? options.onMessageReceived
-    : null;
-
-  const explicitSubscriber = String(options.subscriberId || "").trim();
-  const envSubscriber = String(process.env.UFOO_SUBSCRIBER_ID || "").trim();
-  let subscriberId = explicitSubscriber || envSubscriber;
-  if (!subscriberId) {
-    const whoami = shell("ufoo bus whoami 2>/dev/null || true");
-    subscriberId = String((whoami && whoami.output) || "").trim();
-  }
-  if (!subscriberId) {
-    const joined = shell("ufoo bus join | tail -1");
-    subscriberId = String((joined && joined.output) || "").trim();
-  }
-  if (!subscriberId) {
-    return {
-      ok: false,
-      summary: "",
-      error: "failed to resolve bus subscriber id",
-      handled: 0,
-      subscriberId: "",
-    };
-  }
-
-  // Prefer consuming pending.jsonl directly (stable, ANSI/wrapping-proof).
-  const pendingFile = resolvePendingQueueFile(runtimeWorkspace, subscriberId);
-  const queue = pendingFile ? new DeliveryQueue(pendingFile) : null;
-  if (queue) queue.recover();
-  const hasPendingFile = Boolean(pendingFile && fs.existsSync(pendingFile));
-  let handled = 0;
-  const sendErrors = [];
-  const messageExchanges = [];
-
-  if (queue && hasPendingFile) {
-    while (fs.existsSync(pendingFile)) {
-      const claim = queue.claimNext();
-      if (!claim) break;
-      const message = extractTaskFromBusEvent(claim.event);
-      if (!message) {
-        queue.completeClaim(claim);
-        continue;
-      }
-      let nlResult;
-
-      // Notify that we received the message (for immediate display)
-      if (onMessageReceived) {
-        onMessageReceived({
-          from: message.publisher,
-          task: message.task,
-        });
-      }
-
-      // Create progress reporter for this message
-      const progressReporter = createBusProgressReporter(shell, message.publisher);
-
-      try {
-        // Send initial acknowledgment
-        shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote("🚀 Starting task...")}`);
-
-        // eslint-disable-next-line no-await-in-loop
-        nlResult = await runNl(message.task, state, {
-          onProgress: progressReporter,
-          signal: options.signal,
-        });
-      } catch (err) {
-        const errorMessage = err && err.message ? err.message : "task failed";
-        sendErrors.push(`task from ${message.publisher} failed: ${errorMessage}`);
-        queue.restoreClaim(claim);
-        // Send error notification
-        shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote(`❌ Error: ${errorMessage}`)}`);
-        break;
-      }
-      const reply = String(formatNl(nlResult, false) || "").replace(/\s+/g, " ").trim() || "Done.";
-      const sendRes = shell(`ufoo bus send ${shellQuote(message.publisher)} ${shellQuote(reply.slice(0, 2000))}`);
-      if (!sendRes.ok) {
-        sendErrors.push(`reply to ${message.publisher} failed: ${sendRes.error || "send failed"}`);
-        queue.restoreClaim(claim);
-        break;
-      }
-      handled += 1;
-      queue.completeClaim(claim);
-      messageExchanges.push({
-        from: message.publisher,
-        task: message.task,
-        reply,
-      });
-    }
-  }
-
-  // Fallback: if there is no pending file, fall back to CLI `bus check` parsing.
-  if (!hasPendingFile) {
-    const checked = shell(`ufoo bus check ${shellQuote(subscriberId)}`);
-    if (!checked.ok) {
-      return {
-        ok: false,
-        summary: "",
-        error: checked.error || "ufoo bus check failed",
-        handled: 0,
-        subscriberId,
-      };
-    }
-    const parsed = parseBusCheckOutput(checked.output);
-    if (parsed.length === 0 && busCheckOutputIndicatesPending(checked.output)) {
-      return {
-        ok: false,
-        summary: "",
-        error: "failed to parse ufoo bus check output (pending events detected).",
-        handled: 0,
-        subscriberId,
-      };
-    }
-    for (const item of parsed) {
-      // Notify that we received the message (for immediate display)
-      if (onMessageReceived) {
-        onMessageReceived({
-          from: item.publisher,
-          task: item.task,
-        });
-      }
-
-      const nlResult = await runNl(item.task, state, {
-        signal: options.signal,
-      });
-      const reply = String(formatNl(nlResult, false) || "").replace(/\s+/g, " ").trim() || "Done.";
-      const sendRes = shell(`ufoo bus send ${shellQuote(item.publisher)} ${shellQuote(reply.slice(0, 2000))}`);
-      if (!sendRes.ok) {
-        sendErrors.push(`reply to ${item.publisher} failed: ${sendRes.error || "send failed"}`);
-        continue;
-      }
-      handled += 1;
-      messageExchanges.push({
-        from: item.publisher,
-        task: item.task,
-        reply,
-      });
-    }
-  }
-
-  if (sendErrors.length > 0) {
-    return {
-      ok: false,
-      summary: "",
-      error: sendErrors.join("; "),
-      handled,
-      subscriberId,
-      messageExchanges,
-    };
-  }
-
-  const summary = handled > 0
-    ? `ubus: handled ${handled} message${handled === 1 ? "" : "s"} for ${subscriberId}.`
-    : `ubus: no pending messages for ${subscriberId}.`;
-  return {
-    ok: true,
-    summary,
-    error: "",
-    handled,
-    subscriberId,
-    messageExchanges,
-  };
-}
-
-function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
-  const text = normalizeLine(line);
-  if (!text) return { kind: "empty" };
-  if (text === "exit" || text === "quit") return { kind: "exit" };
-  if (text === "help") {
-    return {
-      kind: "help",
-      output: [
-        "Commands:",
-        "  help",
-        "  exit|quit",
-        "  ubus|/ubus",
-        "  skills [list]",
-        "  skills show <name>",
-        "  bg|/bg <task>",
-        "  resume <session-id>",
-        "  tool <read|write|edit|bash> <args-json>",
-        "  run <read|write|edit|bash> <args-json>",
-      ].join("\n"),
-    };
-  }
-  const legacyUfooMarker = parseLegacyUfooMarkerCommand(text);
-  if (legacyUfooMarker) {
-    return {
-      kind: "legacy_ufoo_marker",
-      marker: legacyUfooMarker,
-    };
-  }
-  if (text === "ubus" || text === "/ubus") {
-    return {
-      kind: "ubus",
-    };
-  }
-  const skillsMatch = text.match(/^(?:\/skills|skills)(?:\s+(.*))?$/i);
-  if (skillsMatch) {
-    const args = String(skillsMatch[1] || "").trim().split(/\s+/).filter(Boolean);
-    const action = String(args[0] || "list").toLowerCase();
-    if (action === "list" || action === "ls") {
-      const outcome = listUcodeSkills({ workspaceRoot });
-      return {
-        kind: "skills",
-        output: formatSkillsList(outcome),
-        skills: outcome.skills,
-        errors: outcome.errors,
-      };
-    }
-    if (action === "show") {
-      const name = String(args[1] || "").trim();
-      if (!name) {
-        return {
-          kind: "error",
-          output: "usage: skills show <name>",
-        };
-      }
-      const result = showSkill({ name, workspaceRoot });
-      if (!result.ok) {
-        return {
-          kind: "error",
-          output: result.error,
-        };
-      }
-      return {
-        kind: "skills",
-        output: result.output,
-        skill: result.skill,
-      };
-    }
-    return {
-      kind: "error",
-      output: "usage: skills [list] | skills show <name>",
-    };
-  }
-  if (text === "bg" || text === "/bg") {
-    return {
-      kind: "error",
-      output: "usage: bg <task>",
-    };
-  }
-  const bgMatch = text.match(/^(?:\/bg|bg)\s+(.+)$/i);
-  if (bgMatch) {
-    const task = String(bgMatch[1] || "").trim();
-    if (!task) {
-      return {
-        kind: "error",
-        output: "usage: bg <task>",
-      };
-    }
-    return {
-      kind: "nl_bg",
-      task,
-    };
-  }
-  const resumeMatch = text.match(/^resume(?:\s+(.+))?$/i);
-  if (resumeMatch) {
-    const session = String(resumeMatch[1] || "").trim();
-    if (!session) {
-      return {
-        kind: "error",
-        output: "usage: resume <session-id>",
-      };
-    }
-    return {
-      kind: "resume",
-      sessionId: session,
-    };
-  }
-
-  const match = text.match(/^(tool|run)\s+([a-zA-Z_-]+)\s*(.*)$/);
-  if (!match) {
-    return {
-      kind: "nl",
-      task: text,
-    };
-  }
-  const tool = String(match[2] || "").trim().toLowerCase();
-  if (String(match[1]).toLowerCase() === "run" && !TOOL_NAMES.includes(tool)) {
-    // Natural language like "run the tests" is not a tool invocation.
-    return {
-      kind: "nl",
-      task: text,
-    };
-  }
-  const payload = String(match[3] || "").trim();
-  let args = {};
-  try {
-    args = parseJson(payload);
-  } catch (err) {
-    return {
-      kind: "error",
-      output: JSON.stringify({ ok: false, error: err && err.message ? err.message : "invalid json" }),
-    };
-  }
-  const result = runToolCall(
-    { tool, args },
-    { workspaceRoot, cwd: workspaceRoot }
-  );
-  return {
-    kind: "tool",
-    tool,
-    args,
-    result,
-    output: JSON.stringify(result),
-  };
-}
-
-async function runUcodeCoreAgent({
-  stdin = process.stdin,
-  stdout = process.stdout,
-  workspaceRoot = process.cwd(),
-  provider = "",
-  model = "",
-  appendSystemPrompt = "",
-  systemPrompt = "",
-  sessionId = "",
-  timeoutMs = 600000,
-  jsonOutput = false,
-  forceTui = false,
-  disableTui = false,
-} = {}) {
-  const resolvedWorkspaceRoot = resolveUfooProjectRoot(workspaceRoot);
-  const resolvedUcode = resolveUcodeProviderModel({
-    workspaceRoot: resolvedWorkspaceRoot,
-    provider,
-    model,
-  });
-  const state = {
-    workspaceRoot: resolvedWorkspaceRoot,
-    provider: resolvedUcode.provider,
-    model: resolvedUcode.model,
-    engine: "ufoo-core",
-    context: buildNlContext({
-      appendSystemPrompt,
-      systemPrompt,
-      workspaceRoot: resolvedWorkspaceRoot,
-      model: resolvedUcode.model,
-      provider: resolvedUcode.provider,
-    }),
-    nlMessages: [],
-    sessionId: resolveSessionId(String(sessionId || "").trim()),
-    timeoutMs,
-    jsonOutput,
-  };
-  persistSessionState(state);
-
-  if (shouldUseUcodeTui({
-    stdin,
-    stdout,
-    jsonOutput,
-    forceTui,
-    disableTui: disableTui || process.env.UFOO_UCODE_NO_TUI === "1",
-  })) {
-    return runUcodeTui({
-      stdin,
-      stdout,
-      runSingleCommand,
-      runNaturalLanguageTask,
-      runUbusCommand,
-      formatNlResult,
-      workspaceRoot,
-  state,
-  resumeSessionState,
-  persistSessionState,
-      autoBus: {
-        enabled: shouldAutoConsumeBus(process.env.UFOO_SUBSCRIBER_ID || ""),
-        getPendingCount: () => getPendingBusCount(state.workspaceRoot || workspaceRoot, process.env.UFOO_SUBSCRIBER_ID || ""),
-        subscriberId: String(process.env.UFOO_SUBSCRIBER_ID || "").trim(),
-      },
-    });
-  }
-
-  printUcodeBanner(stdout, {
-    model: state.model || "default",
-    workspaceRoot: workspaceRoot,
-    sessionId: state.sessionId,
-  });
-  printPrompt();
-  const rl = readline.createInterface({
-    input: stdin,
-    output: stdout,
-    terminal: true,
-    historySize: 200,
-  });
-  return new Promise((resolve) => {
-    let chain = Promise.resolve();
-    let backgroundSeq = 0;
-    const backgroundRuns = new Map();
-    const subscriberId = String(process.env.UFOO_SUBSCRIBER_ID || "").trim();
-    const autoBusEnabled = shouldAutoConsumeBus(subscriberId);
-    let autoBusTimer = null;
-    let autoBusQueued = false;
-    let autoBusError = "";
-    let closing = false;
-
-    const runAutoBusOnce = async () => {
-      if (!autoBusEnabled || closing) return;
-      if (getPendingBusCount(state.workspaceRoot || workspaceRoot, subscriberId) <= 0) {
-        autoBusError = "";
-        return;
-      }
-      const ubusResult = await runUbusCommand(state, {
-        workspaceRoot: state.workspaceRoot || workspaceRoot,
-        subscriberId,
-      });
-      if (!ubusResult.ok) {
-        const nextError = String(ubusResult.error || "ubus failed");
-        if (nextError !== autoBusError) {
-          autoBusError = nextError;
-          stdout.write(`Error: ${nextError}\n`);
-          printPrompt();
-        }
-        return;
-      }
-      autoBusError = "";
-      if (ubusResult.handled > 0) {
-        const persisted = persistSessionState(state);
-        if (!persisted || persisted.ok === false) {
-          stdout.write(`Warning: failed to persist session ${state.sessionId}: ${(persisted && persisted.error) || "unknown error"}\n`);
-          printPrompt();
-        }
-      }
-    };
-
-    const scheduleAutoBus = () => {
-      if (!autoBusEnabled || closing || autoBusQueued) return;
-      if (getPendingBusCount(state.workspaceRoot || workspaceRoot, subscriberId) <= 0) return;
-      autoBusQueued = true;
-      chain = chain
-        .then(() => runAutoBusOnce())
-        .catch(() => {})
-        .finally(() => {
-          autoBusQueued = false;
-        });
-    };
-
-    if (autoBusEnabled) {
-      autoBusTimer = setInterval(() => {
-        scheduleAutoBus();
-      }, 800);
-      scheduleAutoBus();
-    }
-
-    const startBackgroundTask = (task = "") => {
-      backgroundSeq += 1;
-      const jobId = `bg-${Date.now().toString(36)}-${backgroundSeq.toString(36)}`;
-      const bgState = {
-        workspaceRoot: state.workspaceRoot,
-        provider: state.provider,
-        model: state.model,
-        engine: state.engine,
-        context: state.context,
-        nlMessages: Array.isArray(state.nlMessages) ? state.nlMessages.slice() : [],
-        sessionId: "",
-        timeoutMs: state.timeoutMs,
-        jsonOutput: false,
-      };
-      const run = runNaturalLanguageTask(task, bgState)
-        .then((nlResult) => {
-          const summary = String(formatNlResult(nlResult, false) || "").trim();
-          const title = nlResult && nlResult.ok ? "done" : "failed";
-          stdout.write(`[${jobId}] ${title}: ${summary || "no summary"}\n`);
-          printPrompt();
-        })
-        .catch((err) => {
-          stdout.write(`[${jobId}] failed: ${err && err.message ? err.message : "background task failed"}\n`);
-          printPrompt();
-        })
-        .finally(() => {
-          backgroundRuns.delete(jobId);
-        });
-      backgroundRuns.set(jobId, run);
-      return jobId;
-    };
-
-    const handleLine = async (line) => {
-      const runtimeWorkspace = String(state.workspaceRoot || workspaceRoot || process.cwd());
-      const result = runSingleCommand(line, runtimeWorkspace);
-      if (result.kind === "exit") {
-        rl.close();
-        return;
-      }
-      if (result.kind === "legacy_ufoo_marker") {
-        return;
-      }
-      if (result.kind === "help" || result.kind === "tool" || result.kind === "skills" || result.kind === "error") {
-        stdout.write(`${result.output}\n`);
-      }
-      if (result.kind === "ubus") {
-        const ubusResult = await runUbusCommand(state, {
-          workspaceRoot: runtimeWorkspace,
-          onMessageReceived: (msg) => {
-            // Display the incoming message immediately
-            const nickname = extractAgentNickname(msg.from) || msg.from;
-            stdout.write(`${nickname}: ${msg.task}\n`);
-          },
-        });
-        if (!ubusResult.ok) {
-          stdout.write(`Error: ${ubusResult.error}\n`);
-        } else {
-          // Display replies for each message
-          if (ubusResult.messageExchanges && ubusResult.messageExchanges.length > 0) {
-            for (const exchange of ubusResult.messageExchanges) {
-              const nickname = extractAgentNickname(exchange.from) || exchange.from;
-              stdout.write(`@${nickname} ${exchange.reply}\n`);
-            }
-          } else {
-            stdout.write(`${ubusResult.summary}\n`);
-          }
-          persistSessionState(state);
-        }
-      }
-      if (result.kind === "resume") {
-        const resumed = resumeSessionState(state, result.sessionId, state.workspaceRoot || resolvedWorkspaceRoot);
-        if (!resumed.ok) {
-          stdout.write(`Error: ${resumed.error}\n`);
-        } else {
-          stdout.write(`Resumed session ${resumed.sessionId} (${resumed.restoredMessages} messages).\n`);
-        }
-      }
-      if (result.kind === "nl_bg") {
-        const jobId = startBackgroundTask(result.task);
-        stdout.write(`[${jobId}] started in background.\n`);
-      }
-      if (result.kind === "nl") {
-        let streamBuffer = null;
-        let streamedVisible = false;
-        const escapeStripper = createEscapeTagStripper();
-        if (!state.jsonOutput) {
-          streamBuffer = new StreamBuffer(stdout.write.bind(stdout), {
-            delay: 10,
-            chunkSize: 4,
-          });
-        }
-
-        const nlResult = await runNaturalLanguageTask(result.task, state, {
-          onDelta: state.jsonOutput
-            ? null
-            : async (delta) => {
-              const text = escapeStripper.write(String(delta || ""));
-              const safeText = stripBlessedTags(stripLeakedEscapeTags(text));
-              if (!safeText) return;
-              if (/[^\s]/.test(safeText)) {
-                streamedVisible = true;
-              }
-              if (streamBuffer) {
-                await streamBuffer.write(safeText);
-              } else {
-                stdout.write(safeText);
-              }
-            },
-        });
-
-        if (!state.jsonOutput) {
-          const tail = escapeStripper.flush();
-          const safeTail = stripBlessedTags(stripLeakedEscapeTags(tail));
-          if (safeTail) {
-            if (/[^\s]/.test(safeTail)) {
-              streamedVisible = true;
-            }
-            if (streamBuffer) {
-              await streamBuffer.write(safeTail);
-            } else {
-              stdout.write(safeTail);
-            }
-          }
-        }
-
-        // Ensure buffer is flushed
-        if (streamBuffer) {
-          await streamBuffer.finish();
-        }
-
-        const streamed = !state.jsonOutput && Boolean(nlResult && nlResult.streamed);
-        if (streamed && streamedVisible && nlResult && nlResult.streamLastChar !== "\n") {
-          stdout.write("\n");
-        }
-        const shouldSkipSummary = Boolean(streamed && nlResult && nlResult.ok && streamedVisible);
-        if (!shouldSkipSummary) {
-          const formatted = formatNlResult(nlResult, state.jsonOutput);
-          const safeOutput = state.jsonOutput
-            ? formatted
-            : stripBlessedTags(stripLeakedEscapeTags(formatted));
-          stdout.write(`${safeOutput}\n`);
-        }
-        const persisted = persistSessionState(state);
-        if (!state.jsonOutput && (!persisted || persisted.ok === false)) {
-          stdout.write(`Warning: failed to persist session ${state.sessionId}: ${(persisted && persisted.error) || "unknown error"}\n`);
-        }
-      }
-      printPrompt();
-    };
-
-    rl.on("line", (line) => {
-      chain = chain.then(() => handleLine(line)).catch((err) => {
-        stdout.write(`${JSON.stringify({ ok: false, error: err && err.message ? err.message : "agent loop failed" })}\n`);
-        printPrompt();
-      });
-    });
-
-    rl.on("close", () => {
-      closing = true;
-      if (autoBusTimer) {
-        clearInterval(autoBusTimer);
-        autoBusTimer = null;
-      }
-      chain.finally(() => resolve({ code: 0 }));
-    });
-  });
-}
-
-function parseAgentArgs(argv = []) {
-  const args = Array.isArray(argv) ? argv.slice() : [];
-  const out = {
-    workspaceRoot: "",
-    provider: "",
-    model: "",
-    appendSystemPrompt: "",
-    systemPrompt: "",
-    sessionId: "",
-    timeoutMs: 600000,
-    jsonOutput: false,
-    forceTui: false,
-    disableTui: false,
-  };
-  for (let i = 0; i < args.length; i += 1) {
-    const item = String(args[i] || "").trim();
-    if (!item) continue;
-    if (item === "--workspace" || item === "--cwd") {
-      out.workspaceRoot = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--provider") {
-      out.provider = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--model") {
-      out.model = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--append-system-prompt") {
-      out.appendSystemPrompt = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--system-prompt") {
-      out.systemPrompt = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--session-id") {
-      out.sessionId = String(args[i + 1] || "").trim();
-      i += 1;
-      continue;
-    }
-    if (item === "--timeout-ms") {
-      const parsed = Number(args[i + 1]);
-      if (Number.isFinite(parsed)) out.timeoutMs = Math.max(1000, Math.floor(parsed));
-      i += 1;
-      continue;
-    }
-    if (item === "--json") {
-      out.jsonOutput = true;
-      continue;
-    }
-    if (item === "--tui") {
-      out.forceTui = true;
-      continue;
-    }
-    if (item === "--no-tui") {
-      out.disableTui = true;
-      continue;
-    }
-  }
-  return out;
-}
-
 module.exports = {
   runUcodeCoreAgent,
   runSingleCommand,
@@ -1747,6 +722,8 @@ module.exports = {
   parseBusCheckOutput,
   extractBusMessageTask,
   runUbusCommand,
+  runShellCapture,
+  readTextOrFile,
   stripAnsi,
   busCheckOutputIndicatesPending,
   resolvePendingQueueFile,