u-foo 3.0.4 → 3.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "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/planGraphService.js

@@ -430,17 +430,128 @@ function cacheCommand(planGraph, commandId, payload) {
 }
 
 /**
- * Apply a normalized plan_graph command against executionState.planGraph.
+ * Resolve which graph a plan_graph command targets.
+ * Parent lives in executionState.planGraph; TaskLoop children live in graphs[].
+ */
+function selectGraphForCommand(executionState = null, command = {}) {
+  const state = ensurePlanGraphState(executionState);
+  if (!state.graphs || typeof state.graphs !== "object") state.graphs = {};
+  const primary = state.planGraph && typeof state.planGraph === "object"
+    ? state.planGraph
+    : emptyPlanGraphState();
+  if (primary.graphId) state.graphs[primary.graphId] = primary;
+
+  const requested = String(command && command.graphId || "").trim();
+  if (!requested) {
+    return {
+      ok: true,
+      graph: primary,
+      isPrimary: true,
+      primaryGraphId: String(primary.graphId || ""),
+    };
+  }
+  if (primary.graphId && primary.graphId === requested) {
+    return {
+      ok: true,
+      graph: primary,
+      isPrimary: true,
+      primaryGraphId: primary.graphId,
+    };
+  }
+  const mapped = state.graphs[requested];
+  if (mapped && typeof mapped === "object") {
+    return {
+      ok: true,
+      graph: mapped,
+      isPrimary: false,
+      primaryGraphId: String(primary.graphId || ""),
+    };
+  }
+  return {
+    ok: false,
+    code: "GRAPH_NOT_FOUND",
+    message: `graphId ${requested} not found`,
+  };
+}
+
+/**
+ * Apply a normalized plan_graph command against executionState.planGraph
+ * (or a TaskLoop child graph when command.graphId selects it).
  */
 function runPlanGraphCommand(commandInput = {}, options = {}) {
   const command = normalizePlanGraphCommand(commandInput) || commandInput;
   const operation = String(command && command.operation || "").trim().toLowerCase();
   const executionState = ensurePlanGraphState(options.executionState);
-  const planGraph = executionState.planGraph;
+  if (!executionState.graphs || typeof executionState.graphs !== "object") {
+    executionState.graphs = {};
+  }
   const commandId = String(command.commandId || "").trim();
 
+  if (!operation) {
+    const payload = rejected([{ code: "MISSING_OPERATION", message: "operation is required" }]);
+    return { ...payload, executionState, modelPayload: payload };
+  }
+
+  // create/control always target the primary agent graph; patch/inspect may
+  // select a TaskLoop child via command.graphId.
+  const selected = (operation === "patch" || operation === "inspect")
+    ? selectGraphForCommand(executionState, command)
+    : {
+      ok: true,
+      graph: executionState.planGraph,
+      isPrimary: true,
+      primaryGraphId: String(executionState.planGraph && executionState.planGraph.graphId || ""),
+    };
+
+  if (!selected.ok) {
+    const payload = rejected([{
+      code: selected.code || "GRAPH_NOT_FOUND",
+      message: selected.message || "graph not found",
+    }]);
+    return { ...payload, executionState, modelPayload: payload };
+  }
+
+  const primaryGraphId = selected.primaryGraphId
+    || String(executionState.planGraph && executionState.planGraph.graphId || "");
+  // Work on the selected graph for this command; restore primary afterward if child.
+  if (!selected.isPrimary) {
+    executionState.planGraph = selected.graph;
+  }
+  const planGraph = executionState.planGraph;
+
+  function restorePrimaryGraph() {
+    if (executionState.planGraph && executionState.planGraph.graphId) {
+      executionState.graphs[executionState.planGraph.graphId] = executionState.planGraph;
+    }
+    if (!selected.isPrimary && primaryGraphId && executionState.graphs[primaryGraphId]) {
+      executionState.planGraph = executionState.graphs[primaryGraphId];
+    } else if (executionState.planGraph && executionState.planGraph.graphId) {
+      executionState.graphs[executionState.planGraph.graphId] = executionState.planGraph;
+    }
+  }
+
+  function resumeChildTaskLoopIfNeeded(payload = null) {
+    if (selected.isPrimary) return null;
+    if (!payload || payload.status !== "accepted") return null;
+    if (typeof options.runTool !== "function") return null;
+    const childId = String((selected.graph && selected.graph.graphId) || "").trim();
+    const childLive = childId ? executionState.graphs[childId] : null;
+    const owner = childLive && childLive.owner;
+    if (!owner || owner.kind !== "task_loop" || !owner.taskRunId) return null;
+    try {
+      const { processTaskRun } = require("../runtime/taskLoop");
+      return processTaskRun(executionState, owner.taskRunId, {
+        runTool: options.runTool,
+        knownTools: options.knownTools,
+      });
+    } catch {
+      return null;
+    }
+  }
+
   if (commandId && planGraph.commandLog && planGraph.commandLog[commandId]) {
     const cached = cloneJson(planGraph.commandLog[commandId]);
+    restorePrimaryGraph();
     return {
       ...cached,
       ok: cached.status === "accepted",
@@ -450,13 +561,9 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     };
   }
 
-  if (!operation) {
-    const payload = rejected([{ code: "MISSING_OPERATION", message: "operation is required" }]);
-    return { ...payload, executionState, modelPayload: payload };
-  }
-
   if (operation === "inspect") {
     const payload = inspectPlanGraph(planGraph);
+    restorePrimaryGraph();
     return { ...payload, executionState, modelPayload: payload };
   }
 
@@ -556,9 +663,15 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       advance: { status: "completed", yieldReason: "cancelled", executedNodes: [], failedNodes: [] },
       validationWarnings: [],
     });
+    restorePrimaryGraph();
     return { ...payload, executionState, modelPayload: payload };
   }
 
+  function rejectWorking(payload, extra = {}) {
+    restorePrimaryGraph();
+    return { ...payload, executionState, modelPayload: payload, ...extra };
+  }
+
   if (
     Number.isFinite(command.expectedSpecRevision)
     && command.expectedSpecRevision !== null
@@ -572,15 +685,16 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       commandRevision: Number(planGraph.specRevision) || 0,
       stateRevision: Number(planGraph.stateRevision) || 0,
     });
-    return { ...payload, executionState, modelPayload: payload };
+    return rejectWorking(payload);
   }
 
   if (command.graphId && planGraph.graphId && command.graphId !== planGraph.graphId) {
+    // Should not happen after selectGraphForCommand switched the working graph.
     const payload = rejected([{
       code: "GRAPH_ID_MISMATCH",
       message: `expected graphId ${command.graphId}, actual ${planGraph.graphId}`,
     }]);
-    return { ...payload, executionState, modelPayload: payload };
+    return rejectWorking(payload);
   }
 
   const beforeIds = new Set(listNodeIds(planGraph.nodes));
@@ -622,7 +736,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
             code: "NESTED_TASK_LOOP_NOT_SUPPORTED",
             message: "V1 child graphs cannot create task_loop nodes",
           }]);
-          return { ...payload, executionState, modelPayload: payload };
+          return rejectWorking(payload);
         }
       }
       const targetId = String(op.nodeId || (op.node && op.node.id) || "").trim();
@@ -639,7 +753,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
               code: "RUNNING_TASK_SPEC_FROZEN",
               message: `cannot mutate running task_loop ${targetId}`,
             }]);
-            return { ...payload, executionState, modelPayload: payload };
+            return rejectWorking(payload);
           }
         }
       }
@@ -654,7 +768,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
         commandRevision: Number(planGraph.specRevision) || 0,
         stateRevision: Number(planGraph.stateRevision) || 0,
       });
-      return { ...payload, executionState, modelPayload: payload };
+      return rejectWorking(payload);
     }
     nextPlan = applied;
     for (const op of ops) {
@@ -668,7 +782,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     }
   } else {
     const payload = rejected([{ code: "UNKNOWN_OPERATION", message: `unknown operation: ${operation}` }]);
-    return { ...payload, executionState, modelPayload: payload };
+    return rejectWorking(payload);
   }
 
   // Validate. Do not rewrite aggregate sinks via group rewrite when storing flat nodes.
@@ -680,7 +794,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       stateRevision: Number(planGraph.stateRevision) || 0,
       validationWarnings: compiled.warnings || [],
     });
-    return { ...payload, executionState, modelPayload: payload, compile: compiled };
+    return rejectWorking(payload, { compile: compiled });
   }
 
   // Prefer the patched node list (includes aggregate expand status).
@@ -702,7 +816,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
       commandRevision: Number(planGraph.specRevision) || 0,
       stateRevision: Number(planGraph.stateRevision) || 0,
     });
-    return { ...payload, executionState, modelPayload: payload, compile: preferredCompile };
+    return rejectWorking(payload, { compile: preferredCompile });
   }
 
   const mergedNodes = applyStatusesFromStore(preferredCompile.nodes, preferredNodes, {
@@ -736,6 +850,8 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     lastYieldReason: "",
     commandLog: planGraph.commandLog || {},
     owner: nextPlan.owner || planGraph.owner || null,
+    parentGraphId: planGraph.parentGraphId || "",
+    parentNodeId: planGraph.parentNodeId || "",
   };
   if (!executionState.graphs || typeof executionState.graphs !== "object") {
     executionState.graphs = {};
@@ -767,7 +883,7 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
         commandRevision: specRevision,
         stateRevision: Number(executionState.planGraph.stateRevision) || 0,
       });
-      return { ...payload, executionState, modelPayload: payload };
+      return rejectWorking(payload);
     }
     if (advanced.planGraph) {
       executionState.planGraph = {
@@ -775,6 +891,9 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
         specRevision,
         revision: specRevision,
         commandLog: planGraph.commandLog || {},
+        owner: advanced.planGraph.owner || planGraph.owner || null,
+        parentGraphId: advanced.planGraph.parentGraphId || planGraph.parentGraphId || "",
+        parentNodeId: advanced.planGraph.parentNodeId || planGraph.parentNodeId || "",
       };
     }
     if (advanced.advance) advance = advanced.advance;
@@ -822,12 +941,16 @@ function runPlanGraphCommand(commandInput = {}, options = {}) {
     }
   }
 
+  restorePrimaryGraph();
+  const resumed = resumeChildTaskLoopIfNeeded(payload);
+
   return {
     ...payload,
     executionState,
     modelPayload: payload,
     compile: preferredCompile,
     planModeEntered,
+    taskLoopResume: resumed || null,
   };
 }
 
@@ -853,5 +976,6 @@ module.exports = {
   executionSegmentToCreateGraph,
   projectPlanView,
   activePlanRequiresExpansion,
+  selectGraphForCommand,
   stripModelStatuses,
 };

package/src/code/context/planProjection.js

@@ -204,6 +204,168 @@ function buildCompactSummary(rows = [], focusId = "") {
     .join(" · ");
 }
 
+/**
+ * Top-level plan tasks from planGraph JSON (no parent, not generated tools).
+ */
+function listTopLevelPlanTasks(planGraph = {}) {
+  const nodes = Array.isArray(planGraph.nodes) ? planGraph.nodes : [];
+  return nodes.filter((node) => (
+    node
+    && node.type === "task"
+    && !String(node.parentTaskId || "").trim()
+    && !node.generated
+  ));
+}
+
+/**
+ * Parse planGraph JSON into a DAG IR: nodes, edges, dependency waves.
+ */
+function buildPlanDag(planGraph = {}) {
+  const tasks = listTopLevelPlanTasks(planGraph);
+  const idSet = new Set(tasks.map((node) => String(node.id || "").trim()).filter(Boolean));
+  const nodes = tasks.map((task) => {
+    const id = String(task.id || "").trim();
+    const deps = (Array.isArray(task.dependsOn) ? task.dependsOn : [])
+      .map((dep) => String(dep || "").trim())
+      .filter((dep) => dep && idSet.has(dep));
+    const { mark, kind } = statusToMark(task.status);
+    return {
+      id,
+      title: nodeTitle(task),
+      status: String(task.status || "pending"),
+      mark,
+      kind,
+      dependsOn: deps,
+      displayOrder: Number(task.displayOrder) || 0,
+    };
+  }).filter((node) => node.id);
+
+  const byId = new Map(nodes.map((node) => [node.id, node]));
+  const edges = [];
+  for (const node of nodes) {
+    for (const dep of node.dependsOn) {
+      edges.push({ from: dep, to: node.id });
+    }
+  }
+
+  const depthMemo = new Map();
+  function depthOf(id, stack = new Set()) {
+    if (depthMemo.has(id)) return depthMemo.get(id);
+    if (stack.has(id)) return 0;
+    stack.add(id);
+    const node = byId.get(id);
+    let depth = 0;
+    if (node) {
+      for (const dep of node.dependsOn) {
+        depth = Math.max(depth, depthOf(dep, stack) + 1);
+      }
+    }
+    stack.delete(id);
+    depthMemo.set(id, depth);
+    return depth;
+  }
+
+  for (const node of nodes) depthOf(node.id);
+
+  const maxDepth = nodes.reduce((max, node) => Math.max(max, depthMemo.get(node.id) || 0), 0);
+  const buckets = Array.from({ length: maxDepth + 1 }, () => []);
+  const ordered = nodes.slice().sort((a, b) => {
+    const depthDiff = (depthMemo.get(a.id) || 0) - (depthMemo.get(b.id) || 0);
+    if (depthDiff !== 0) return depthDiff;
+    if (a.displayOrder !== b.displayOrder) return a.displayOrder - b.displayOrder;
+    return a.id.localeCompare(b.id);
+  });
+  for (const node of ordered) {
+    buckets[depthMemo.get(node.id) || 0].push(node);
+  }
+  const waves = buckets.filter((wave) => wave.length > 0);
+  return {
+    nodes,
+    edges,
+    waves,
+    linear: waves.length > 0 && waves.every((wave) => wave.length === 1),
+  };
+}
+
+function waveStepLabel(waveIndex = 0, nodeIndex = 0, waveSize = 1) {
+  const step = Math.max(1, Math.floor(Number(waveIndex) || 0) + 1);
+  if (waveSize <= 1) return String(step);
+  const letter = String.fromCharCode(97 + Math.max(0, Math.min(25, Math.floor(Number(nodeIndex) || 0))));
+  return `${step}${letter}`;
+}
+
+function formatParallelWaveLines(wave = [], waveIndex = 0, titleMax = 40) {
+  const lines = [];
+  const size = wave.length;
+  wave.forEach((node, nodeIndex) => {
+    const label = waveStepLabel(waveIndex, nodeIndex, size);
+    const body = `${label} ${node.mark} ${truncate(node.title, titleMax)}`;
+    if (nodeIndex === 0) {
+      lines.push(`  ┌─ ${body}`);
+      if (size > 1) lines.push("──┤");
+      return;
+    }
+    if (nodeIndex === size - 1) {
+      lines.push(`  └─ ${body}`);
+      return;
+    }
+    lines.push(`  ├─ ${body}`);
+  });
+  return lines;
+}
+
+/**
+ * Build markdown (linear list) or ASCII flowchart (parallel waves) from planGraph JSON.
+ */
+function buildRoadmapMarkdown(planGraph = {}, {
+  cols = 80,
+  taskRunLine = "",
+  maxRows = 10,
+} = {}) {
+  const dag = buildPlanDag(planGraph);
+  if (dag.nodes.length === 0) {
+    return { markdown: "", lines: [], dag };
+  }
+
+  const titleMax = Math.max(12, Math.min(48, Math.floor(Number(cols) || 80) - 12));
+  const objective = truncate(String(planGraph.objective || "").trim(), titleMax);
+  const lines = [objective ? `**Plan** · ${objective}` : "**Plan**"];
+
+  if (dag.linear) {
+    dag.waves.forEach((wave, waveIndex) => {
+      const node = wave[0];
+      lines.push(`${waveIndex + 1}. ${node.mark} ${truncate(node.title, titleMax)}`);
+    });
+  } else {
+    dag.waves.forEach((wave, waveIndex) => {
+      if (wave.length === 1) {
+        const node = wave[0];
+        lines.push(`${waveStepLabel(waveIndex, 0, 1)} ${node.mark} ${truncate(node.title, titleMax)}`);
+        return;
+      }
+      for (const line of formatParallelWaveLines(wave, waveIndex, Math.max(8, titleMax - 4))) {
+        lines.push(line);
+      }
+    });
+  }
+
+  const extra = String(taskRunLine || "").trim();
+  if (extra) lines.push(extra);
+
+  const limit = Number.isFinite(maxRows) && maxRows > 0 ? Math.floor(maxRows) : 10;
+  let clipped = lines.slice(0, Math.max(1, limit));
+  if (lines.length > clipped.length) {
+    clipped = clipped.slice(0, Math.max(1, limit - 1));
+    clipped.push(`… +${lines.length - clipped.length} more`);
+  }
+
+  return {
+    markdown: clipped.join("\n"),
+    lines: clipped,
+    dag,
+  };
+}
+
 function buildDebugLines(executionState = null, planGraph = {}) {
   const lines = [];
   const pg = planGraph && typeof planGraph === "object" ? planGraph : {};
@@ -305,61 +467,52 @@ function buildPlanUiProjection(executionState = null, options = {}) {
   const focusTitle = focus ? truncate(focus.title, narrow ? 18 : 28) : "";
 
   let bandLines = [];
+  let roadmapMarkdown = "";
   let visible = false;
+  let planDag = null;
+
+  const taskRunSuffix = (() => {
+    if (!taskRun) return "";
+    const leaseBit = leaseHeld ? "writing" : taskRun.phase;
+    const files = taskRun.changedFilesHint ? ` · ${taskRun.changedFilesHint}` : "";
+    return `TaskLoop ${leaseBit}${files}`;
+  })();
 
   if (hasPlan && bandMode !== "hidden") {
     visible = true;
     if (bandMode === "debug") {
       bandLines = buildDebugLines(state, pg);
+      roadmapMarkdown = "";
     } else if (narrow) {
       const summary = buildCompactSummary(tree, focus && focus.nodeId);
       bandLines = [truncate(
         `Plan${focusTitle ? ` · ${focusTitle}` : ""}${progressLabel ? ` (${progressLabel})` : ""}${summary && !focusTitle ? `  ${summary}` : ""}`,
         Math.max(24, cols - 2)
       )];
-    } else if (bandMode === "auto") {
-      const summary = buildCompactSummary(tree, focus && focus.nodeId);
-      const header = truncate(
-        `Plan${pg.objective ? ` · ${pg.objective}` : ""}${summary ? `  ${summary}` : ""}`,
-        Math.max(24, cols - 2)
-      );
-      bandLines = [header];
-      if (focus) {
-        const focusChildren = view
-          .filter((node) => node && node.parentId === focus.nodeId)
-          .map((node) => {
-            const { mark } = statusToMark(node.status);
-            return `${mark} ${nodeTitle(node)}`;
-          });
-        if (focusChildren.length > 0) {
-          bandLines.push(truncate(
-            `      └ ${focusChildren.join(" · ")}`,
-            Math.max(24, cols - 2)
-          ));
-        } else if (focus.title) {
-          bandLines.push(truncate(`      → ${focus.title}`, Math.max(24, cols - 2)));
-        }
-      }
-      if (taskRun) {
-        const leaseBit = leaseHeld ? "writing" : taskRun.phase;
-        const files = taskRun.changedFilesHint ? ` · ${taskRun.changedFilesHint}` : "";
-        bandLines.push(truncate(`      TaskLoop ${leaseBit}${files}`, Math.max(24, cols - 2)));
-      }
-      const maxRows = Number.isFinite(options.maxBandRows) ? options.maxBandRows : 3;
-      bandLines = bandLines.slice(0, Math.max(1, maxRows));
+      roadmapMarkdown = "";
     } else {
-      // expanded
-      const title = pg.objective ? `Plan · ${pg.objective}` : "Plan";
-      bandLines = [truncate(title, Math.max(24, cols - 2))];
-      for (const row of tree) {
-        bandLines.push(truncate(formatTreeLine(row), Math.max(24, cols - 2)));
-      }
-      if (taskRun) {
-        const files = taskRun.changedFilesHint ? ` · ${taskRun.changedFilesHint}` : "";
-        bandLines.push(truncate(`TaskLoop · ${taskRun.phase}${files}`, Math.max(24, cols - 2)));
+      // auto + expanded: JSON → DAG → roadmap markdown
+      const maxRows = Number.isFinite(options.maxBandRows)
+        ? options.maxBandRows
+        : (bandMode === "expanded" ? 16 : 10);
+      const roadmap = buildRoadmapMarkdown(pg, {
+        cols,
+        taskRunLine: taskRunSuffix,
+        maxRows,
+      });
+      planDag = roadmap.dag;
+      roadmapMarkdown = roadmap.markdown;
+      bandLines = roadmap.lines.slice();
+      if (bandMode === "expanded" && tree.length > 0) {
+        // Keep tree as fallback detail only when roadmap empty (shouldn't happen).
+        if (bandLines.length === 0) {
+          const title = pg.objective ? `Plan · ${pg.objective}` : "Plan";
+          bandLines = [truncate(title, Math.max(24, cols - 2))];
+          for (const row of tree) {
+            bandLines.push(truncate(formatTreeLine(row), Math.max(24, cols - 2)));
+          }
+        }
       }
-      const maxRows = Number.isFinite(options.maxBandRows) ? options.maxBandRows : 7;
-      bandLines = bandLines.slice(0, Math.max(1, maxRows));
     }
   }
 
@@ -402,7 +555,7 @@ function buildPlanUiProjection(executionState = null, options = {}) {
     leaseHeld,
     progressDone: progress.done,
     progressTotal: progress.total,
-    bandLines,
+    bandLines: roadmapMarkdown ? [roadmapMarkdown] : bandLines,
   });
 
   return {
@@ -413,11 +566,13 @@ function buildPlanUiProjection(executionState = null, options = {}) {
     progress,
     focus,
     tree,
+    dag: planDag,
     taskRun,
     leaseHeld,
     statusLine,
     idleHint,
     activityStatusLine,
+    roadmapMarkdown,
     bandLines,
     hash,
   };
@@ -428,5 +583,7 @@ module.exports = {
   getBandMode,
   setBandMode,
   statusToMark,
+  buildPlanDag,
+  buildRoadmapMarkdown,
   buildPlanUiProjection,
 };

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.",
+      "- TaskLoop start returns childGraphId. While that TaskRun is waiting_model on child root, patch with graphId=<childGraphId> and expand_node nodeId=root (add tool children). Do not ask the user to /plan off.",
       "- 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.",

package/src/code/context/userInteraction.js

@@ -387,15 +387,40 @@ function resolveUserInteraction(executionState = null, rawText = "") {
   };
 }
 
-function formatInteractionPromptLines(pending = null) {
+function wrapLabeledBlock(label = "", prompt = "", cols = 80) {
+  const title = String(label || "Question").trim() || "Question";
+  const text = String(prompt || "").replace(/\s+/g, " ").trim();
+  const width = Math.max(24, Math.min(120, Math.floor(Number(cols) || 80) - 2));
+  if (!text) return [`${title}:`];
+
+  const prefix = `${title}: `;
+  const firstWidth = Math.max(8, width - prefix.length);
+  const contPrefix = "  ";
+  const contWidth = Math.max(8, width - contPrefix.length);
+  const lines = [];
+
+  let offset = 0;
+  const firstChunk = text.slice(0, firstWidth);
+  lines.push(`${prefix}${firstChunk}`);
+  offset = firstChunk.length;
+  while (offset < text.length) {
+    const chunk = text.slice(offset, offset + contWidth);
+    lines.push(`${contPrefix}${chunk}`);
+    offset += chunk.length;
+  }
+  return lines;
+}
+
+function formatInteractionPromptLines(pending = null, options = {}) {
   if (!pending) return [];
+  const cols = Number(options.cols) > 0 ? Number(options.cols) : 80;
   const lines = [];
   const kind = pending.kind || "chat";
   if (kind === "approval") {
-    lines.push(`Approval: ${pending.prompt}`);
+    lines.push(...wrapLabeledBlock("Approval", pending.prompt, cols));
     lines.push("  [yes] Yes    [no] No    or type a free-text reply");
   } else if (kind === "choice") {
-    lines.push(`Choice: ${pending.prompt}`);
+    lines.push(...wrapLabeledBlock("Choice", pending.prompt, cols));
     for (const opt of pending.options || []) {
       lines.push(`  [${opt.key}] ${opt.label}`);
     }
@@ -403,7 +428,7 @@ function formatInteractionPromptLines(pending = null) {
       lines.push("  or type a free-text reply");
     }
   } else {
-    lines.push(`Question: ${pending.prompt}`);
+    lines.push(...wrapLabeledBlock("Question", pending.prompt, cols));
     lines.push("  (type your reply)");
   }
   return lines;

package/src/code/nativeRunner.js

@@ -30,6 +30,12 @@ const {
   shouldAutoContinuePlan,
   buildPlanAutoContinueReminder,
 } = require("./context/userNudge");
+const {
+  drainAgentMailboxForTurn,
+  shouldAutoContinueForTaskWake,
+  buildTaskRunWakeReminder,
+  listTaskRunsAwaitingModel,
+} = require("./runtime/agentWakeup");
 const {
   runAskUserTool,
   syncInteractionFromPlanGraph,
@@ -1782,33 +1788,74 @@ async function runNativeLoop({
     messages.push({ role: "user", content });
   }
 
-  function tryInjectPlanAutoContinue() {
-    if (!shouldAutoContinuePlan(executionState)) return false;
-    if (planAutoContinues >= DEFAULT_MAX_PLAN_AUTO_CONTINUES) return false;
+  /** Deliver mid-loop TaskRun runtime events before the next model call. */
+  function injectRuntimeMailboxEvents() {
+    const drained = drainAgentMailboxForTurn(executionState);
+    if (!drained.text) return false;
+    messages.push({ role: "user", content: drained.text });
+    return true;
+  }
+
+  function nextAutoContinueKey() {
     const waitingId = String(
       (executionState.planGraph && executionState.planGraph.waitingFor
         && executionState.planGraph.waitingFor.id) || ""
     ).trim();
+    if (waitingId) return `plan:${waitingId}`;
+    const runs = listTaskRunsAwaitingModel(executionState);
+    if (runs.length > 0) {
+      return `task:${runs.map((run) => run.id).sort().join(",")}`;
+    }
+    return "mailbox";
+  }
+
+  function tryInjectAgentAutoContinue() {
+    if (planAutoContinues >= DEFAULT_MAX_PLAN_AUTO_CONTINUES) return false;
+    const continueKey = nextAutoContinueKey();
     if (
       consecutiveEmptyAutoContinues >= 2
-      && waitingId
-      && waitingId === lastAutoContinueWaitingId
+      && continueKey
+      && continueKey === 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;
+
+    // Prefer draining fresh runtime mail (task_started, etc.) before nudges.
+    if (injectRuntimeMailboxEvents()) {
+      planAutoContinues += 1;
+      lastAutoContinueWaitingId = continueKey;
+      consecutiveEmptyAutoContinues += 1;
+      return true;
+    }
+
+    if (shouldAutoContinuePlan(executionState)) {
+      const reminder = buildPlanAutoContinueReminder(executionState);
+      if (!reminder) return false;
+      messages.push({ role: "user", content: reminder });
+      planAutoContinues += 1;
+      lastAutoContinueWaitingId = continueKey;
+      consecutiveEmptyAutoContinues += 1;
+      return true;
+    }
+
+    if (shouldAutoContinueForTaskWake(executionState)) {
+      const reminder = buildTaskRunWakeReminder(executionState);
+      if (!reminder) return false;
+      messages.push({ role: "user", content: reminder });
+      planAutoContinues += 1;
+      lastAutoContinueWaitingId = continueKey;
+      consecutiveEmptyAutoContinues += 1;
+      return true;
+    }
+
+    return false;
   }
 
   while (true) {
     guards.ensureActive();
 
     injectPendingUserReminders();
+    injectRuntimeMailboxEvents();
 
     if (activeLedger) {
       runProviderTurnGate(activeLedger);
@@ -1876,7 +1923,7 @@ async function runNativeLoop({
       if (!aggregated.trim() && text) {
         aggregated = text;
       }
-      if (tryInjectPlanAutoContinue()) {
+      if (tryInjectAgentAutoContinue()) {
         continue;
       }
       return {

package/src/code/runtime/agentWakeup.js

@@ -2,9 +2,12 @@
 
 /**
  * Drain Agent Loop mailbox into a turnDynamic block (never as user role).
+ * Mid-loop wakeups (nativeRunner) also consume the same mailbox into the
+ * conversation so TaskRun waiting_model does not strand the Agent Loop.
  */
 
-const { drainAgentMailbox, ensureMailbox } = require("./loopMailbox");
+const { drainAgentMailbox, ensureMailbox, peek } = require("./loopMailbox");
+const { ensureTaskRunStore } = require("./taskRun");
 
 function formatAgentRuntimeEvents(events = []) {
   const list = Array.isArray(events) ? events : [];
@@ -43,6 +46,11 @@ function peekAgentMailboxText(executionState = null) {
   return formatAgentRuntimeEvents(box.queue || []);
 }
 
+function hasPendingAgentMailbox(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  return Boolean(peek(ensureMailbox(state, "agentMailbox")));
+}
+
 function drainAgentMailboxForTurn(executionState = null) {
   const events = drainAgentMailbox(executionState);
   return {
@@ -51,8 +59,65 @@ function drainAgentMailboxForTurn(executionState = null) {
   };
 }
 
+const AWAITING_MODEL_PHASES = new Set([
+  "waiting_model",
+  "planning",
+  "initializing",
+]);
+
+/**
+ * TaskRuns that still need the Agent Loop (model turn / planning).
+ */
+function listTaskRunsAwaitingModel(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  return Object.values(store.byId || {}).filter((run) => (
+    run
+    && (run.status === "running" || run.status === "queued")
+    && AWAITING_MODEL_PHASES.has(String(run.phase || "").trim().toLowerCase())
+  ));
+}
+
+function shouldWakeAgentForTaskRuns(executionState = null) {
+  return listTaskRunsAwaitingModel(executionState).length > 0;
+}
+
+/**
+ * Whether the Agent Loop must keep going after a text-only model turn
+ * because TaskRuns or unread runtime mail still need service.
+ */
+function shouldAutoContinueForTaskWake(executionState = null) {
+  if (!executionState || typeof executionState !== "object") return false;
+  if (executionState.pendingUserInteraction) return false;
+  return hasPendingAgentMailbox(executionState) || shouldWakeAgentForTaskRuns(executionState);
+}
+
+function buildTaskRunWakeReminder(executionState = null) {
+  const runs = listTaskRunsAwaitingModel(executionState);
+  if (runs.length === 0 && !hasPendingAgentMailbox(executionState)) return "";
+  const lines = [
+    "Runtime wake (not a user message): active TaskRun(s) still need the Agent Loop.",
+    "Continue serving them now. For a TaskLoop child graph waiting on root:",
+    "call plan_graph operation=patch with graphId=<childGraphId> and expand_node on nodeId=root",
+    "(tool children). Do not ask the user to /plan off. Do not end with text only.",
+  ];
+  for (const run of runs.slice(0, 4)) {
+    const label = run.title || run.objective || run.parentNodeId || run.id;
+    lines.push(
+      `- taskRunId=${run.id} phase=${run.phase || ""} status=${run.status || ""}`
+      + (run.childGraphId ? ` childGraphId=${run.childGraphId}` : "")
+      + (label ? ` — ${String(label).slice(0, 120)}` : "")
+    );
+  }
+  return lines.join("\n");
+}
+
 module.exports = {
   formatAgentRuntimeEvents,
   peekAgentMailboxText,
+  hasPendingAgentMailbox,
   drainAgentMailboxForTurn,
+  listTaskRunsAwaitingModel,
+  shouldWakeAgentForTaskRuns,
+  shouldAutoContinueForTaskWake,
+  buildTaskRunWakeReminder,
 };

package/src/ui/ink/UcodeApp.js

@@ -90,6 +90,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       hasPlan: false,
       visible: false,
       bandLines: [],
+      roadmapMarkdown: "",
       idleHint: "",
       statusLine: "",
       hash: "",
@@ -171,7 +172,9 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         );
         setPlanUi((prev) => (prev && prev.hash === next.hash ? prev : next));
         const pending = getPendingUserInteraction(props.state && props.state.executionState);
-        setInteractionLines(pending ? formatInteractionPromptLines(pending) : []);
+        setInteractionLines(pending ? formatInteractionPromptLines(pending, {
+          cols: size.cols || 80,
+        }) : []);
         return next;
       } catch {
         return null;
@@ -1248,18 +1251,30 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           renderMergeText(activeMerge)
         ),
       ) : null,
-      planUi.visible && planUi.bandLines.length > 0
+      planUi.visible && (planUi.roadmapMarkdown || (planUi.bandLines && planUi.bandLines.length > 0))
         ? h(Box, {
           flexDirection: "column",
           width: "100%",
           marginTop: 1,
         },
-          ...planUi.bandLines.map((line, idx) => h(Text, {
-            key: `plan-band-${idx}`,
-            color: "magenta",
-            dimColor: idx > 0,
-            wrap: "truncate",
-          }, line || " ")),
+          ...(() => {
+            let lines = Array.isArray(planUi.bandLines) ? planUi.bandLines.slice() : [];
+            const md = String(planUi.roadmapMarkdown || "").trim();
+            if (md) {
+              try {
+                const rendered = fmt.renderLogLinesWithMarkdownAnsi(md, { inCodeBlock: false });
+                if (Array.isArray(rendered) && rendered.length > 0) lines = rendered;
+              } catch {
+                lines = md.split(/\r?\n/);
+              }
+            }
+            return lines.map((line, idx) => h(Text, {
+              key: `plan-band-${idx}`,
+              color: md ? undefined : "magenta",
+              dimColor: !md && idx > 0,
+              wrap: "truncate",
+            }, line || " "));
+          })(),
         )
         : null,
       interactionLines.length > 0
@@ -1271,7 +1286,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           ...interactionLines.map((line, idx) => h(Text, {
             key: `ask-${idx}`,
             color: "yellow",
-            wrap: "truncate",
+            wrap: "wrap",
           }, line || " ")),
         )
         : null,