u-foo 3.0.4 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "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/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/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,63 @@ 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 (read/inspect/edit via tools, or plan_graph/task_run control).",
+    "Do not end the turn with text only while a TaskRun is waiting_model.",
+  ];
+  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 || ""}`
+      + (label ? ` — ${String(label).slice(0, 160)}` : "")
+    );
+  }
+  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: "",
@@ -1248,18 +1249,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