u-foo 3.0.6 → 3.0.8

package/src/code/context/planProjection.js

@@ -287,78 +287,94 @@ function buildPlanDag(planGraph = {}) {
   };
 }
 
-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 countDagProgress(dag = {}) {
+  const nodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+  const total = nodes.length;
+  const done = nodes.filter((node) => node && node.kind === "done").length;
+  return { done, total };
 }
 
-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;
+function titleMaxForCols(cols = 80, reserved = 12) {
+  return Math.max(12, Math.min(48, Math.floor(Number(cols) || 80) - reserved));
+}
+
+function pickFocusActiveNodes(dag = {}) {
+  const nodes = Array.isArray(dag.nodes) ? dag.nodes : [];
+  const active = nodes.filter((node) => node && node.kind === "active");
+  if (active.length > 0) return active;
+
+  const waves = Array.isArray(dag.waves) ? dag.waves : [];
+  for (const wave of waves) {
+    const incomplete = (Array.isArray(wave) ? wave : []).filter((node) => (
+      node
+      && node.kind !== "done"
+      && node.kind !== "cancelled"
+    ));
+    if (incomplete.length === 0) continue;
+    const ready = incomplete.filter((node) => String(node.status || "").toLowerCase() === "ready");
+    return ready.length > 0 ? ready : incomplete.slice(0, 1);
+  }
+  return [];
+}
+
+function pickUpcomingNodes(dag = {}, activeIds = new Set(), limit = 2) {
+  const upcoming = [];
+  const waves = Array.isArray(dag.waves) ? dag.waves : [];
+  for (const wave of waves) {
+    for (const node of (Array.isArray(wave) ? wave : [])) {
+      if (!node || activeIds.has(node.id)) continue;
+      if (node.kind === "done" || node.kind === "cancelled") continue;
+      upcoming.push(node);
+      if (upcoming.length >= limit) return upcoming;
     }
-    lines.push(`  ├─ ${body}`);
-  });
-  return lines;
+    if (upcoming.length >= limit) break;
+  }
+  return upcoming;
+}
+
+function clipRoadmapLines(lines = [], maxRows = 10) {
+  const list = Array.isArray(lines) ? lines : [];
+  const limit = Number.isFinite(maxRows) && maxRows > 0 ? Math.floor(maxRows) : 10;
+  if (list.length <= limit) return list.slice();
+  const clipped = list.slice(0, Math.max(1, limit - 1));
+  clipped.push(`… +${list.length - clipped.length} more`);
+  return clipped;
 }
 
 /**
- * Build markdown (linear list) or ASCII flowchart (parallel waves) from planGraph JSON.
+ * Default auto band: progress + current task(s) + next titles.
+ * No ASCII tree, no 4a/4b labels.
  */
-function buildRoadmapMarkdown(planGraph = {}, {
+function buildFocusRoadmap(planGraph = {}, {
   cols = 80,
   taskRunLine = "",
-  maxRows = 10,
+  maxRows = 4,
 } = {}) {
   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**"];
+  const titleMax = titleMaxForCols(cols, 8);
+  const { done, total } = countDagProgress(dag);
+  const lines = [`**Plan** · ${done}/${total}`];
 
-  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 active = pickFocusActiveNodes(dag);
+  const activeIds = new Set(active.map((node) => node.id));
+  for (const node of active) {
+    lines.push(`${node.mark} ${truncate(node.title, titleMax)}`);
   }
 
-  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`);
+  const upcoming = pickUpcomingNodes(dag, activeIds, 2);
+  if (upcoming.length > 0) {
+    const titles = upcoming.map((node) => truncate(node.title, Math.max(8, Math.floor(titleMax / upcoming.length))));
+    lines.push(`接下来 · ${titles.join(" · ")}`);
   }
 
+  const extra = String(taskRunLine || "").trim();
+  if (extra) lines.push(truncate(extra, Math.max(24, titleMax + 8)));
+
+  const clipped = clipRoadmapLines(lines, maxRows);
   return {
     markdown: clipped.join("\n"),
     lines: clipped,
@@ -366,6 +382,89 @@ function buildRoadmapMarkdown(planGraph = {}, {
   };
 }
 
+/**
+ * Expanded (/plan focus): flat numbered list; parallel waves share a step number.
+ */
+function buildExpandedRoadmap(planGraph = {}, {
+  cols = 80,
+  taskRunLine = "",
+  maxRows = 16,
+} = {}) {
+  const dag = buildPlanDag(planGraph);
+  if (dag.nodes.length === 0) {
+    return { markdown: "", lines: [], dag };
+  }
+
+  const titleMax = titleMaxForCols(cols, 14);
+  const { done, total } = countDagProgress(dag);
+  const objective = truncate(String(planGraph.objective || "").trim(), Math.max(12, titleMax - 8));
+  const header = objective
+    ? `**Plan** · ${done}/${total} · ${objective}`
+    : `**Plan** · ${done}/${total}`;
+  const body = [];
+
+  dag.waves.forEach((wave, waveIndex) => {
+    const step = waveIndex + 1;
+    for (const node of wave) {
+      body.push(`${node.mark} ${step} ${truncate(node.title, titleMax)}`);
+    }
+  });
+
+  const extra = String(taskRunLine || "").trim();
+  if (extra) body.push(truncate(extra, Math.max(24, titleMax + 8)));
+
+  const budget = Math.max(1, (Number.isFinite(maxRows) ? Math.floor(maxRows) : 16) - 1);
+  let clippedBody = body;
+  if (body.length > budget) {
+    let windowStart = 0;
+    while (
+      windowStart < body.length
+      && (body[windowStart].startsWith("✓") || body[windowStart].startsWith("⊘"))
+    ) {
+      windowStart += 1;
+    }
+    // Keep one completed row before the live window for context.
+    windowStart = Math.max(0, windowStart - 1);
+    const window = body.slice(windowStart);
+    if (window.length <= budget) {
+      clippedBody = windowStart > 0
+        ? [`… +${windowStart} more`, ...window]
+        : window;
+    } else {
+      const kept = window.slice(0, Math.max(1, budget - 1));
+      const omittedAfter = body.length - (windowStart + kept.length);
+      clippedBody = windowStart > 0
+        ? [`… +${windowStart} more`, ...kept.slice(0, Math.max(1, budget - 2)), `… +${omittedAfter} more`]
+        : [...kept, `… +${omittedAfter} more`];
+      // If double ellipsis blew the budget, fall back to simple clip.
+      if (clippedBody.length > budget) {
+        clippedBody = clipRoadmapLines(body, budget);
+      }
+    }
+  }
+
+  const lines = [header, ...clippedBody];
+  return {
+    markdown: lines.join("\n"),
+    lines,
+    dag,
+  };
+}
+
+/**
+ * Build roadmap markdown from planGraph JSON.
+ * variant=focus (default auto band) or expanded (/plan focus).
+ */
+function buildRoadmapMarkdown(planGraph = {}, options = {}) {
+  const variant = String(options.variant || "focus").trim().toLowerCase() === "expanded"
+    ? "expanded"
+    : "focus";
+  if (variant === "expanded") {
+    return buildExpandedRoadmap(planGraph, options);
+  }
+  return buildFocusRoadmap(planGraph, options);
+}
+
 function buildDebugLines(executionState = null, planGraph = {}) {
   const lines = [];
   const pg = planGraph && typeof planGraph === "object" ? planGraph : {};
@@ -491,27 +590,27 @@ function buildPlanUiProjection(executionState = null, options = {}) {
       )];
       roadmapMarkdown = "";
     } else {
-      // auto + expanded: JSON → DAG → roadmap markdown
+      // auto → progress-focus; expanded → flat numbered list (no ASCII tree)
+      const variant = bandMode === "expanded" ? "expanded" : "focus";
       const maxRows = Number.isFinite(options.maxBandRows)
         ? options.maxBandRows
-        : (bandMode === "expanded" ? 16 : 10);
+        : (variant === "expanded" ? 16 : 4);
       const roadmap = buildRoadmapMarkdown(pg, {
         cols,
         taskRunLine: taskRunSuffix,
         maxRows,
+        variant,
       });
       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)));
-          }
+      if (bandLines.length === 0 && tree.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)));
         }
+        roadmapMarkdown = "";
       }
     }
   }
@@ -585,5 +684,7 @@ module.exports = {
   statusToMark,
   buildPlanDag,
   buildRoadmapMarkdown,
+  buildFocusRoadmap,
+  buildExpandedRoadmap,
   buildPlanUiProjection,
 };

package/src/code/context/promptLayers.js

@@ -54,6 +54,7 @@ function buildImmutablePrefix() {
       "- Turning Plan Mode off does not cancel an existing graph or running TaskRuns. Cancel with task_run (standalone) or plan_graph operation=cancel_graph / control.cancel_task (graph-bound).",
       "- When the user enables Plan Mode and no active graph exists, create a plan_graph before performing side effects.",
       "- After an accepted plan_graph create or patch, Runtime automatically advances ready tool nodes. Never invent or request an execute_graph tool.",
+      "- When the last plan node finishes (graph_terminal), Runtime archives and clears the active plan, exits auto Plan Mode, and returns a completion summary — narrate that summary to the user. Start a new objective with plan_graph create (create replaces any leftover graph); do not patch a finished plan for a new goal.",
       "- 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.",

package/src/code/context/userNudge.js

@@ -131,7 +131,8 @@ function shouldAutoContinuePlan(executionState = null) {
 
 /**
  * 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.
+ * plan is still waiting on a task. Must NOT reuse the User reminder label —
+ * that is reserved for real mid-run user text and pollutes transcript/TUI.
  */
 function buildPlanAutoContinueReminder(executionState = null) {
   const waiting = executionState
@@ -140,14 +141,17 @@ function buildPlanAutoContinueReminder(executionState = null) {
     ? 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 },
-  );
+  const label = waiting.title || waiting.objective || waiting.reason || waiting.id;
+  const lines = [
+    "Runtime wake (not a user message): active plan is still waiting.",
+    "Continue serving it 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.",
+    `Prefer serving the current waiting ${waiting.type || "node"}: ${waiting.id}`
+      + (label && label !== waiting.id ? ` — ${label}` : "")
+      + ".",
+  ];
+  return lines.join("\n");
 }
 
 module.exports = {

package/src/code/contextWindow.js

@@ -0,0 +1,117 @@
+"use strict";
+
+/**
+ * Context-window helpers for the ucode TUI meter (used / limit in K).
+ *
+ * usedTokens comes from the latest model request's prompt occupancy.
+ * limitTokens is resolved from the model id (provider catalogs rarely
+ * expose a reliable context_window field).
+ */
+
+function toTokenCount(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+  return Math.floor(parsed);
+}
+
+/**
+ * Prompt-side tokens currently occupying the context window.
+ * Anthropic splits input / cache_read / cache_creation; OpenAI folds
+ * cache hits into prompt_tokens (cached_tokens is a subset).
+ */
+function contextTokensFromUsage(usage = null) {
+  if (!usage || typeof usage !== "object") return 0;
+  const input = toTokenCount(usage.input);
+  const cacheRead = toTokenCount(usage.cacheRead);
+  const cacheCreation = toTokenCount(usage.cacheCreation);
+  if (cacheCreation > 0) return input + cacheRead + cacheCreation;
+  // Anthropic exclusive split: input can be smaller than cache_read alone.
+  if (cacheRead > 0 && input < cacheRead) return input + cacheRead + cacheCreation;
+  // OpenAI-compatible: prompt_tokens already includes cached tokens.
+  return input;
+}
+
+function resolveModelContextLimit(model = "", options = {}) {
+  const override = toTokenCount(options.limit || options.contextLimit);
+  if (override > 0) return override;
+
+  const id = String(model || "").trim().toLowerCase();
+  if (!id) return 200000;
+
+  if (/\b1m\b|1000000|million|1\.0m/.test(id)) return 1000000;
+  if (/256k/.test(id)) return 256000;
+  if (/128k/.test(id)) return 128000;
+  if (/64k/.test(id)) return 64000;
+  if (/32k/.test(id)) return 32000;
+
+  if (/claude|anthropic|opus|sonnet|haiku/.test(id)) return 200000;
+  if (/gemini|gemma/.test(id)) return 1000000;
+  if (/kimi|moonshot|k2\.|k2-|k3/.test(id)) return 256000;
+  if (/gpt-5|o3|o4|codex/.test(id)) return 200000;
+  if (/gpt-4\.1|gpt-4o|gpt-4-turbo|o1/.test(id)) return 128000;
+  if (/gpt-4|gpt-3\.5/.test(id)) return 128000;
+
+  return 200000;
+}
+
+function formatTokensK(tokens = 0) {
+  const n = Math.max(0, Math.floor(Number(tokens) || 0));
+  if (n < 1000) return String(n);
+  const k = n / 1000;
+  if (k >= 100) return `${Math.round(k)}K`;
+  const tenths = Math.round(k * 10) / 10;
+  if (Number.isInteger(tenths)) return `${tenths}K`;
+  return `${tenths.toFixed(1)}K`;
+}
+
+function formatContextMeter({ usedTokens = 0, limitTokens = 0 } = {}) {
+  const used = Math.max(0, Math.floor(Number(usedTokens) || 0));
+  const limit = Math.max(0, Math.floor(Number(limitTokens) || 0));
+  if (limit > 0) return `${formatTokensK(used)} / ${formatTokensK(limit)}`;
+  return formatTokensK(used);
+}
+
+function buildContextMeter({
+  usage = null,
+  usedTokens = null,
+  model = "",
+  limitTokens = null,
+} = {}) {
+  const used = usedTokens != null
+    ? toTokenCount(usedTokens)
+    : contextTokensFromUsage(usage);
+  const limit = resolveModelContextLimit(model, { limit: limitTokens });
+  return {
+    usedTokens: used,
+    limitTokens: limit,
+    model: String(model || "").trim(),
+    label: formatContextMeter({ usedTokens: used, limitTokens: limit }),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function normalizeContextMeter(value = null, model = "") {
+  const source = value && typeof value === "object" ? value : {};
+  const used = toTokenCount(source.usedTokens);
+  const limit = resolveModelContextLimit(
+    String(source.model || model || "").trim(),
+    { limit: source.limitTokens },
+  );
+  return {
+    usedTokens: used,
+    limitTokens: limit,
+    model: String(source.model || model || "").trim(),
+    label: formatContextMeter({ usedTokens: used, limitTokens: limit }),
+    updatedAt: String(source.updatedAt || "").trim(),
+  };
+}
+
+module.exports = {
+  toTokenCount,
+  contextTokensFromUsage,
+  resolveModelContextLimit,
+  formatTokensK,
+  formatContextMeter,
+  buildContextMeter,
+  normalizeContextMeter,
+};