u-foo 2.5.15 → 3.0.0

package/src/code/repl.js

@@ -24,17 +24,24 @@ const {
 const { summarizeSessionUsage, formatSessionUsageStatus } = require("./usageStore");
 const { listUcodeCommandsForHelp } = require("./commands");
 const { applyUcodeModelCommand, suggestUcodeModels } = require("./modelCommand");
+const { applyUcodePlanCommand } = require("./context/planMode");
 
 function printPrompt(stdout = process.stdout) {
   stdout.write("> ");
 }
 
-function printUcodeBanner(stdout = process.stdout, { model = "", workspaceRoot = process.cwd(), sessionId = "" } = {}) {
+function printUcodeBanner(stdout = process.stdout, {
+  model = "",
+  workspaceRoot = process.cwd(),
+  sessionId = "",
+  planMode = false,
+} = {}) {
   stdout.write(`${buildUcodeBannerLines({
     model,
     engine: "ufoo-core",
     workspaceRoot,
     sessionId,
+    planMode,
     width: (stdout && stdout.columns) || 0,
   }).join("\n")}\n`);
 }
@@ -123,6 +130,22 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
       model: nextModel,
     };
   }
+  const planMatch = text.match(/^(?:\/plan|plan)(?:\s+(.*))?$/i);
+  if (planMatch) {
+    const arg = String(planMatch[1] || "").trim().toLowerCase();
+    if (!arg || arg === "show" || arg === "status") return { kind: "plan", action: "show" };
+    if (arg === "on" || arg === "enable") return { kind: "plan", action: "on" };
+    if (arg === "off" || arg === "disable") return { kind: "plan", action: "off" };
+    if (arg === "clear") return { kind: "plan", action: "clear" };
+    if (arg === "hide") return { kind: "plan", action: "hide" };
+    if (arg === "focus") return { kind: "plan", action: "focus" };
+    if (arg === "debug") return { kind: "plan", action: "debug" };
+    if (arg === "toggle") return { kind: "plan", action: "toggle" };
+    return {
+      kind: "error",
+      output: "usage: /plan [on|off|show|hide|focus|debug|clear]",
+    };
+  }
   const skillsMatch = text.match(/^(?:\/skills|skills)(?:\s+(.*))?$/i);
   if (skillsMatch) {
     const args = String(skillsMatch[1] || "").trim().split(/\s+/).filter(Boolean);
@@ -259,6 +282,7 @@ async function runUcodeCoreAgent({
     resolveNlTaskTimeoutMs,
     resolveUcodeProviderModel,
     runNaturalLanguageTask,
+    resumeAfterUserInteraction,
   } = require("./agent");
   const resolvedWorkspaceRoot = resolveUfooProjectRoot(workspaceRoot);
   const resolvedUcode = resolveUcodeProviderModel({
@@ -315,6 +339,7 @@ async function runUcodeCoreAgent({
     model: state.model || "default",
     workspaceRoot: workspaceRoot,
     sessionId: state.sessionId,
+    planMode: Boolean(state.executionState && state.executionState.planMode),
   });
   printPrompt(stdout);
   const rl = readline.createInterface({
@@ -333,6 +358,7 @@ async function runUcodeCoreAgent({
     let autoBusQueued = false;
     let autoBusError = "";
     let closing = false;
+    let taskInFlight = false;
 
     const runAutoBusOnce = async () => {
       if (!autoBusEnabled || closing) return;
@@ -433,6 +459,10 @@ async function runUcodeCoreAgent({
           sessionId: state.sessionId,
         });
         stdout.write(`${formatSessionUsageStatus(usageSummary)}\n`);
+        const { formatPlanModeStatus } = require("./context/planMode");
+        if (state.executionState) {
+          stdout.write(`${formatPlanModeStatus(state.executionState).split("\n").slice(0, 5).join("\n")}\n`);
+        }
       }
       if (result.kind === "model") {
         const applied = applyUcodeModelCommand(state, result);
@@ -441,6 +471,11 @@ async function runUcodeCoreAgent({
           persistSessionState(state);
         }
       }
+      if (result.kind === "plan") {
+        const applied = applyUcodePlanCommand(state, result);
+        stdout.write(`${applied.output}\n`);
+        if (applied.ok) persistSessionState(state);
+      }
       if (result.kind === "ubus") {
         const ubusResult = await runUbusCommand(state, {
           workspaceRoot: runtimeWorkspace,
@@ -488,23 +523,29 @@ async function runUcodeCoreAgent({
           });
         }
 
-        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);
-              }
-            },
-        });
+        taskInFlight = true;
+        let nlResult;
+        try {
+          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);
+                }
+              },
+          });
+        } finally {
+          taskInFlight = false;
+        }
 
         if (!state.jsonOutput) {
           const tail = escapeStripper.flush();
@@ -547,6 +588,106 @@ async function runUcodeCoreAgent({
     };
 
     rl.on("line", (line) => {
+      const trimmed = normalizeLine(line);
+
+      // Pending approval/choice/chat takes priority over nudge / new NL.
+      try {
+        const {
+          hasPendingUserInteraction,
+          parseUserInteractionInput,
+          getPendingUserInteraction,
+        } = require("./context/userInteraction");
+        if (
+          trimmed
+          && state.executionState
+          && hasPendingUserInteraction(state.executionState)
+        ) {
+          const pending = getPendingUserInteraction(state.executionState);
+          const parsed = parseUserInteractionInput(pending, trimmed);
+          if (!parsed.ok) {
+            stdout.write(`${parsed.error || "Invalid reply"}\n`);
+            printPrompt(stdout);
+            return;
+          }
+          chain = chain.then(async () => {
+            let streamBuffer = null;
+            let streamedVisible = false;
+            const escapeStripper = createEscapeTagStripper();
+            if (!state.jsonOutput) {
+              streamBuffer = new StreamBuffer(stdout.write.bind(stdout), {
+                delay: 10,
+                chunkSize: 4,
+              });
+            }
+            taskInFlight = true;
+            let resumeResult;
+            try {
+              resumeResult = await resumeAfterUserInteraction(trimmed, 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);
+                    }
+                  },
+              });
+            } finally {
+              taskInFlight = false;
+            }
+            if (streamBuffer) {
+              await streamBuffer.finish();
+            }
+            const streamed = !state.jsonOutput && Boolean(resumeResult && resumeResult.streamed);
+            if (streamed && streamedVisible && resumeResult && resumeResult.streamLastChar !== "\n") {
+              stdout.write("\n");
+            }
+            if (resumeResult && resumeResult.waitingUserInteraction) {
+              stdout.write("Still waiting for your reply.\n");
+            } else if (!resumeResult || resumeResult.ok === false) {
+              stdout.write(`Error: ${(resumeResult && resumeResult.error) || "resume failed"}\n`);
+            } else {
+              const shouldSkipSummary = Boolean(streamed && resumeResult.ok && streamedVisible);
+              if (!shouldSkipSummary && resumeResult.summary) {
+                stdout.write(`${resumeResult.summary}\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(stdout);
+          }).catch((err) => {
+            stdout.write(`${JSON.stringify({ ok: false, error: err && err.message ? err.message : "resume failed" })}\n`);
+            printPrompt(stdout);
+          });
+          return;
+        }
+      } catch (err) {
+        stdout.write(`Error: ${err && err.message ? err.message : "interaction failed"}\n`);
+        printPrompt(stdout);
+        return;
+      }
+
+      // Mid-task NL input becomes a pending user reminder for the next LLM turn.
+      if (taskInFlight && trimmed && !/^\//.test(trimmed)) {
+        const { enqueueUserPrompt } = require("./context/userNudge");
+        const { emptyExecutionState } = require("./context/executionSegment");
+        if (!state.executionState || typeof state.executionState !== "object") {
+          state.executionState = emptyExecutionState();
+        }
+        enqueueUserPrompt(state.executionState, trimmed);
+        stdout.write("Queued user reminder for next model turn.\n");
+        printPrompt(stdout);
+        return;
+      }
       chain = chain.then(() => handleLine(line)).catch((err) => {
         stdout.write(`${JSON.stringify({ ok: false, error: err && err.message ? err.message : "agent loop failed" })}\n`);
         printPrompt(stdout);
@@ -640,5 +781,6 @@ module.exports = {
   parseAgentArgs,
   formatSessionUsageStatus,
   applyUcodeModelCommand,
+  applyUcodePlanCommand,
   suggestUcodeModels,
 };

package/src/code/runtime/agentWakeup.js

@@ -0,0 +1,58 @@
+"use strict";
+
+/**
+ * Drain Agent Loop mailbox into a turnDynamic block (never as user role).
+ */
+
+const { drainAgentMailbox, ensureMailbox } = require("./loopMailbox");
+
+function formatAgentRuntimeEvents(events = []) {
+  const list = Array.isArray(events) ? events : [];
+  if (list.length === 0) return "";
+  const lines = ["Runtime events (Agent Loop mailbox; not user messages):"];
+  for (const entry of list) {
+    if (!entry) continue;
+    if (entry.kind === "user") {
+      lines.push(`- user_nudge: ${String(entry.text || "").slice(0, 400)}`);
+      continue;
+    }
+    if (entry.kind === "runtime" && entry.event) {
+      const ev = entry.event;
+      const bits = [`type=${ev.type}`];
+      if (ev.taskId) bits.push(`taskId=${ev.taskId}`);
+      if (ev.taskRunId) bits.push(`taskRunId=${ev.taskRunId}`);
+      if (ev.result && ev.result.summary) bits.push(`summary=${String(ev.result.summary).slice(0, 200)}`);
+      if (ev.error && (ev.error.message || ev.error)) {
+        bits.push(`error=${String(ev.error.message || ev.error).slice(0, 200)}`);
+      }
+      if (Array.isArray(ev.readyNodes) && ev.readyNodes.length) {
+        bits.push(`readyNodes=[${ev.readyNodes.join(",")}]`);
+      }
+      lines.push(`- ${bits.join(" ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Peek without drain — for inspect. Prefer drainForAgentTurn for consumption.
+ */
+function peekAgentMailboxText(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  const box = ensureMailbox(state, "agentMailbox");
+  return formatAgentRuntimeEvents(box.queue || []);
+}
+
+function drainAgentMailboxForTurn(executionState = null) {
+  const events = drainAgentMailbox(executionState);
+  return {
+    events,
+    text: formatAgentRuntimeEvents(events),
+  };
+}
+
+module.exports = {
+  formatAgentRuntimeEvents,
+  peekAgentMailboxText,
+  drainAgentMailboxForTurn,
+};

package/src/code/runtime/graphOwner.js

@@ -0,0 +1,41 @@
+"use strict";
+
+/**
+ * Graph ownership: which loop consumes waiting_llm / yields.
+ */
+
+function agentLoopOwner(agentLoopId = "agent") {
+  return {
+    kind: "agent_loop",
+    agentLoopId: String(agentLoopId || "agent").trim() || "agent",
+  };
+}
+
+function taskLoopOwner(taskRunId = "") {
+  return {
+    kind: "task_loop",
+    taskRunId: String(taskRunId || "").trim(),
+  };
+}
+
+function normalizeGraphOwner(source = null) {
+  if (!source || typeof source !== "object") return agentLoopOwner();
+  const kind = String(source.kind || "").trim();
+  if (kind === "task_loop") {
+    const taskRunId = String(source.taskRunId || "").trim();
+    if (!taskRunId) return agentLoopOwner();
+    return taskLoopOwner(taskRunId);
+  }
+  return agentLoopOwner(source.agentLoopId);
+}
+
+function isTaskLoopOwner(owner = null) {
+  return Boolean(owner && owner.kind === "task_loop" && owner.taskRunId);
+}
+
+module.exports = {
+  agentLoopOwner,
+  taskLoopOwner,
+  normalizeGraphOwner,
+  isTaskLoopOwner,
+};

package/src/code/runtime/graphYieldRouter.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/**
+ * Route graph yields to the owning loop mailbox.
+ */
+
+const { isTaskLoopOwner } = require("./graphOwner");
+const { enqueueAgentRuntime, enqueueTaskEvent } = require("./loopMailbox");
+const { createRuntimeEvent } = require("./runtimeEvents");
+
+function routeGraphYield(executionState = null, {
+  graph = null,
+  reason = "",
+  waitingFor = null,
+} = {}) {
+  const owner = graph && graph.owner ? graph.owner : null;
+  const graphId = graph && graph.graphId ? graph.graphId : "";
+  const payload = {
+    graphId,
+    reason: String(reason || "").trim() || "llm_required",
+    waitingFor: waitingFor || null,
+  };
+
+  if (isTaskLoopOwner(owner)) {
+    return enqueueTaskEvent(executionState, owner.taskRunId, {
+      kind: "graph_yield",
+      ...payload,
+    });
+  }
+
+  // Parent / agent-owned graph: surface as runtime event (not user message).
+  return enqueueAgentRuntime(executionState, createRuntimeEvent("parent_graph_ready_changed", {
+    readyNodes: waitingFor && waitingFor.id ? [waitingFor.id] : [],
+    graphId,
+    yieldReason: payload.reason,
+    waitingFor,
+  }));
+}
+
+module.exports = {
+  routeGraphYield,
+};

package/src/code/runtime/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = {
+  ...require("./runtimeEvents"),
+  ...require("./graphOwner"),
+  ...require("./loopMailbox"),
+  ...require("./taskRun"),
+  ...require("./workspaceLease"),
+  ...require("./taskFocus"),
+  ...require("./taskLoop"),
+  ...require("./taskControl"),
+  ...require("./toolProvenance"),
+  ...require("./graphYieldRouter"),
+  ...require("./agentWakeup"),
+};

package/src/code/runtime/loopMailbox.js

@@ -0,0 +1,124 @@
+"use strict";
+
+/**
+ * Typed mailboxes for Agent Loop vs TaskLoop.
+ * Task mailbox schema has no user-event type (runtime isolation).
+ */
+
+const { isRuntimeEvent } = require("./runtimeEvents");
+
+const AGENT_EVENT_KINDS = Object.freeze(["user", "runtime"]);
+const TASK_EVENT_KINDS = Object.freeze([
+  "graph_yield",
+  "tool_result",
+  "control",
+  "advance",
+  "model_turn",
+]);
+
+function emptyMailbox() {
+  return { queue: [], seq: 0 };
+}
+
+function ensureMailbox(store = null, key = "mailbox") {
+  const target = store && typeof store === "object" ? store : {};
+  if (!target[key] || typeof target[key] !== "object") {
+    target[key] = emptyMailbox();
+  }
+  if (!Array.isArray(target[key].queue)) target[key].queue = [];
+  if (!Number.isFinite(target[key].seq)) target[key].seq = 0;
+  return target[key];
+}
+
+function enqueue(mailbox = null, event = {}) {
+  const box = mailbox && typeof mailbox === "object" ? mailbox : emptyMailbox();
+  if (!Array.isArray(box.queue)) box.queue = [];
+  box.seq = (Number(box.seq) || 0) + 1;
+  const entry = {
+    id: `evt_${box.seq}`,
+    enqueuedAt: new Date().toISOString(),
+    ...event,
+  };
+  box.queue.push(entry);
+  return entry;
+}
+
+function drain(mailbox = null, { max = 0 } = {}) {
+  const box = mailbox && typeof mailbox === "object" ? mailbox : emptyMailbox();
+  if (!Array.isArray(box.queue) || box.queue.length === 0) return [];
+  if (!max || max >= box.queue.length) {
+    const all = box.queue.slice();
+    box.queue = [];
+    return all;
+  }
+  const taken = box.queue.splice(0, Math.max(1, Math.floor(max)));
+  return taken;
+}
+
+function peek(mailbox = null) {
+  const box = mailbox && typeof mailbox === "object" ? mailbox : emptyMailbox();
+  return Array.isArray(box.queue) && box.queue.length > 0 ? box.queue[0] : null;
+}
+
+function enqueueAgentUser(executionState = null, text = "") {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  const mailbox = ensureMailbox(state, "agentMailbox");
+  return enqueue(mailbox, {
+    kind: "user",
+    text: String(text || "").trim(),
+  });
+}
+
+function enqueueAgentRuntime(executionState = null, runtimeEvent = {}) {
+  if (!isRuntimeEvent(runtimeEvent)) {
+    throw new Error("enqueueAgentRuntime requires a runtime event");
+  }
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  const mailbox = ensureMailbox(state, "agentMailbox");
+  return enqueue(mailbox, {
+    kind: "runtime",
+    event: runtimeEvent,
+  });
+}
+
+function enqueueTaskEvent(executionState = null, taskRunId = "", event = {}) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.taskMailboxes || typeof state.taskMailboxes !== "object") {
+    state.taskMailboxes = {};
+  }
+  const id = String(taskRunId || "").trim();
+  if (!id) throw new Error("taskRunId required");
+  const kind = String(event.kind || "").trim();
+  if (!TASK_EVENT_KINDS.includes(kind)) {
+    throw new Error(`invalid task mailbox event kind: ${kind}`);
+  }
+  if (!state.taskMailboxes[id]) state.taskMailboxes[id] = emptyMailbox();
+  return enqueue(state.taskMailboxes[id], event);
+}
+
+function drainAgentMailbox(executionState = null, options = {}) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  return drain(ensureMailbox(state, "agentMailbox"), options);
+}
+
+function drainTaskMailbox(executionState = null, taskRunId = "", options = {}) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  const id = String(taskRunId || "").trim();
+  if (!state.taskMailboxes || !state.taskMailboxes[id]) return [];
+  return drain(state.taskMailboxes[id], options);
+}
+
+module.exports = {
+  AGENT_EVENT_KINDS,
+  TASK_EVENT_KINDS,
+  emptyMailbox,
+  ensureMailbox,
+  enqueue,
+  drain,
+  peek,
+  enqueueAgentUser,
+  enqueueAgentRuntime,
+  enqueueTaskEvent,
+  drainAgentMailbox,
+  drainTaskMailbox,
+};

package/src/code/runtime/runtimeEvents.js

@@ -0,0 +1,39 @@
+"use strict";
+
+/**
+ * Runtime event types for Agent Loop wakeup (never user-role messages).
+ */
+
+const RUNTIME_EVENT_TYPES = Object.freeze([
+  "task_started",
+  "task_succeeded",
+  "task_failed",
+  "task_cancelled",
+  "parent_graph_ready_changed",
+]);
+
+function createRuntimeEvent(type = "", payload = {}) {
+  const eventType = String(type || "").trim();
+  if (!RUNTIME_EVENT_TYPES.includes(eventType)) {
+    throw new Error(`unknown runtime event type: ${type}`);
+  }
+  return {
+    type: eventType,
+    at: new Date().toISOString(),
+    ...payload,
+  };
+}
+
+function isRuntimeEvent(value = null) {
+  return Boolean(
+    value
+    && typeof value === "object"
+    && RUNTIME_EVENT_TYPES.includes(String(value.type || "")),
+  );
+}
+
+module.exports = {
+  RUNTIME_EVENT_TYPES,
+  createRuntimeEvent,
+  isRuntimeEvent,
+};