u-foo 3.0.3 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "3.0.3",
+  "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/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/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.",
+      "- 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,7 +27,15 @@ const {
   clearUserPrompts,
   formatUserReminderMessage,
   ensurePendingUserPrompts,
+  shouldAutoContinuePlan,
+  buildPlanAutoContinueReminder,
 } = require("./context/userNudge");
+const {
+  drainAgentMailboxForTurn,
+  shouldAutoContinueForTaskWake,
+  buildTaskRunWakeReminder,
+  listTaskRunsAwaitingModel,
+} = require("./runtime/agentWakeup");
 const {
   runAskUserTool,
   syncInteractionFromPlanGraph,
@@ -85,6 +93,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 +1769,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,10 +1788,74 @@ async function runNativeLoop({
     messages.push({ role: "user", content });
   }
 
+  /** 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
+      && continueKey
+      && continueKey === lastAutoContinueWaitingId
+    ) {
+      return false;
+    }
+
+    // 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);
@@ -1846,6 +1923,9 @@ async function runNativeLoop({
       if (!aggregated.trim() && text) {
         aggregated = text;
       }
+      if (tryInjectAgentAutoContinue()) {
+        continue;
+      }
       return {
         text: aggregated,
         streamed,
@@ -1857,6 +1937,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 {

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