u-foo 3.0.3 → 3.0.4

package/package.json

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

package/src/code/context/planMode.js

@@ -232,6 +232,7 @@ function renderPlanModeContext(executionState = null) {
     "  2) expand_node on the current ready/waiting task when needed",
     "  3) Runtime executes ready tools / TaskLoops; continue from results",
     "  4) control.complete_task (inline) or control.start_task (task_loop)",
+    "Do not end the turn with text only while a task is waiting — advance it.",
     "Do not mix plan_graph with data-plane tools in the same turn.",
   );
 

package/src/code/context/promptLayers.js

@@ -56,6 +56,7 @@ function buildImmutablePrefix() {
       "- After an accepted plan_graph create or patch, Runtime automatically advances ready tool nodes. Never invent or request an execute_graph tool.",
       "- Do not call plan_graph or task_run together with read, read_image, write, edit, bash, or artifact_read in the same assistant turn.",
       "- When an active graph is waiting on a task, advance that node through plan_graph instead of bypassing it with direct workspace tools: use patch.expand_node for execution.kind=expand, control.complete_task (nodeId) for execution.kind=inline_llm, or control.start_task for execution.kind=task_loop.",
+      "- Do not end a turn with text only while the plan is still waiting on a task; expand, start, or complete that node. Runtime will auto-continue if you stop early, but prefer advancing in the same turn.",
       "- control.complete_task with nodeId completes a waiting_llm inline_llm task for the current Graph owner. control.complete_task with taskRunId (or task_run complete) is reserved for the owning TaskLoop. Do not directly complete expand or aggregate tasks.",
       "- While Plan Mode is ON, workspace mutations must be represented as plan_graph tool nodes or performed inside a running TaskRun/task_loop.",
       "- Treat a User reminder as the latest user instruction. Reconcile it before continuing from tool results. If it is compatible with the active plan, resume the waiting plan node; otherwise patch, cancel, or replan first.",

package/src/code/context/userNudge.js

@@ -104,6 +104,52 @@ function buildContinuationUserPrompt(userText = "", executionState = null) {
   return formatUserReminderMessage([text], { waitingFor: waiting });
 }
 
+const PLAN_AUTO_CONTINUE_STOP_REASONS = new Set([
+  "approval_required",
+  "graph_terminal",
+  "scheduler_deadlock",
+]);
+
+/**
+ * Whether the Agent Loop should keep going after a text-only model turn
+ * because the plan graph is still waiting on an agent-actionable task.
+ */
+function shouldAutoContinuePlan(executionState = null) {
+  if (!executionState || typeof executionState !== "object") return false;
+  if (executionState.pendingUserInteraction) return false;
+  const pg = executionState.planGraph && typeof executionState.planGraph === "object"
+    ? executionState.planGraph
+    : null;
+  if (!pg) return false;
+  const waiting = pg.waitingFor && typeof pg.waitingFor === "object" ? pg.waitingFor : null;
+  if (!waiting || !waiting.id) return false;
+  if (String(waiting.type || "").trim().toLowerCase() !== "task") return false;
+  const yieldReason = String(pg.lastYieldReason || "").trim().toLowerCase();
+  if (yieldReason && PLAN_AUTO_CONTINUE_STOP_REASONS.has(yieldReason)) return false;
+  return true;
+}
+
+/**
+ * Internal reminder injected by runtime when the model ends a turn while the
+ * plan is still waiting on a task. Same shape as user nudges.
+ */
+function buildPlanAutoContinueReminder(executionState = null) {
+  const waiting = executionState
+    && executionState.planGraph
+    && executionState.planGraph.waitingFor
+    ? executionState.planGraph.waitingFor
+    : null;
+  if (!waiting || !waiting.id) return "";
+  return formatUserReminderMessage(
+    [
+      "Continue the active plan. Serve the waiting task now via plan_graph "
+        + "(expand_node, control.start_task, or control.complete_task as appropriate). "
+        + "Do not end the turn with text only while this node is waiting.",
+    ],
+    { waitingFor: waiting },
+  );
+}
+
 module.exports = {
   ensurePendingUserPrompts,
   enqueueUserPrompt,
@@ -113,4 +159,7 @@ module.exports = {
   shouldFrameAsUserReminder,
   formatUserReminderMessage,
   buildContinuationUserPrompt,
+  shouldAutoContinuePlan,
+  buildPlanAutoContinueReminder,
+  PLAN_AUTO_CONTINUE_STOP_REASONS,
 };

package/src/code/nativeRunner.js

@@ -27,6 +27,8 @@ const {
   clearUserPrompts,
   formatUserReminderMessage,
   ensurePendingUserPrompts,
+  shouldAutoContinuePlan,
+  buildPlanAutoContinueReminder,
 } = require("./context/userNudge");
 const {
   runAskUserTool,
@@ -85,6 +87,8 @@ const DEFAULT_KIMI_MODEL = "k3";
 const DEFAULT_MAX_NATIVE_TOOL_CALLS = 100;
 const DEFAULT_MAX_NATIVE_TOOL_ERRORS = 20;
 const DEFAULT_NATIVE_TIMEOUT_MS = 43200000; // 12 hours
+/** Max text-only auto-continues while a plan is waiting on a task (per user submit). */
+const DEFAULT_MAX_PLAN_AUTO_CONTINUES = 24;
 // Anthropic Messages rejects max_tokens above the model's real cap (64K on
 // current models), so the transports use different defaults. Override either
 // via UFOO_UCODE_MAX_TOKENS (positive integer).
@@ -1759,6 +1763,9 @@ async function runNativeLoop({
   // materialize Provider messages yet. STRICT via UFOO_UCODE_PROTOCOL_STRICT=1.
   let activeLedger = null;
   let lastProtocolLedger = null;
+  let planAutoContinues = 0;
+  let lastAutoContinueWaitingId = "";
+  let consecutiveEmptyAutoContinues = 0;
 
   if (resume) {
     await withFaultPoint("before_provider_resume", () => {});
@@ -1775,6 +1782,29 @@ async function runNativeLoop({
     messages.push({ role: "user", content });
   }
 
+  function tryInjectPlanAutoContinue() {
+    if (!shouldAutoContinuePlan(executionState)) return false;
+    if (planAutoContinues >= DEFAULT_MAX_PLAN_AUTO_CONTINUES) return false;
+    const waitingId = String(
+      (executionState.planGraph && executionState.planGraph.waitingFor
+        && executionState.planGraph.waitingFor.id) || ""
+    ).trim();
+    if (
+      consecutiveEmptyAutoContinues >= 2
+      && waitingId
+      && waitingId === lastAutoContinueWaitingId
+    ) {
+      return false;
+    }
+    const reminder = buildPlanAutoContinueReminder(executionState);
+    if (!reminder) return false;
+    messages.push({ role: "user", content: reminder });
+    planAutoContinues += 1;
+    lastAutoContinueWaitingId = waitingId;
+    consecutiveEmptyAutoContinues += 1;
+    return true;
+  }
+
   while (true) {
     guards.ensureActive();
 
@@ -1846,6 +1876,9 @@ async function runNativeLoop({
       if (!aggregated.trim() && text) {
         aggregated = text;
       }
+      if (tryInjectPlanAutoContinue()) {
+        continue;
+      }
       return {
         text: aggregated,
         streamed,
@@ -1857,6 +1890,9 @@ async function runNativeLoop({
       };
     }
 
+    // A tool-using turn resets the empty auto-continue streak (progress possible).
+    consecutiveEmptyAutoContinues = 0;
+
     const pendingCalls = transport.prepareToolCalls({ messages, turnResult, toolCalls });
     if (!pendingCalls) {
       return {