u-foo 2.5.14 → 3.0.0

package/src/ui/ink/UcodeApp.js

@@ -29,10 +29,17 @@ const LOG_LINE_TEXT_PROPS = {
   assistant: {},
   system: { color: "gray", dimColor: true },
   error: { color: "red" },
+  tool: {},
   toolDetail: { color: "gray", dimColor: true },
   bus: { color: "cyan" },
 };
 
+// Only assistant prose gets markdown. Error rows are app-generated
+// (`Error: …`) and already painted red via resolveLogLineTextProps — running
+// them through the MD Error: line rule would wrap chalk ANSI and break the
+// plain-text body the Ink color prop expects.
+const MARKDOWN_LOG_KINDS = new Set(["assistant"]);
+
 // Resolve a log line kind to ink <Text> props. Unknown/missing kinds (e.g.
 // the banner, which already carries chalk ANSI styling) render uncolored.
 function resolveLogLineTextProps(kind) {
@@ -50,6 +57,11 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     engine: (props.state && props.state.engine) || "ufoo-core",
     workspaceRoot: props.workspaceRoot,
     sessionId: (props.state && props.state.sessionId) || "",
+    planMode: Boolean(
+      props.state
+      && props.state.executionState
+      && props.state.executionState.planMode
+    ),
   });
 
   return function UcodeApp() {
@@ -68,6 +80,15 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       showTimer: false,
       startedAt: 0,
     });
+    const [planUi, setPlanUi] = useState(() => ({
+      hasPlan: false,
+      visible: false,
+      bandLines: [],
+      idleHint: "",
+      statusLine: "",
+      hash: "",
+    }));
+    const [interactionLines, setInteractionLines] = useState([]);
     const [spinnerTick, setSpinnerTick] = useState(0);
     const [size, setSize] = useState({ cols: 0, rows: 0 });
     const [agents, setAgents] = useState([]);
@@ -95,6 +116,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     // visual row (i.e. moveCursorVertically returned moved=false).
     const [inputHistory, setInputHistory] = useState([]);
     const [historyIndex, setHistoryIndex] = useState(0);
+    const [completionIndex, setCompletionIndex] = useState(0);
+    const [completionWindowStart, setCompletionWindowStart] = useState(0);
+    const [completionSuppressedDraft, setCompletionSuppressedDraft] = useState(null);
+    const POPUP_PAGE_SIZE = 8;
     const { exit } = useApp();
     const { stdout } = useStdout();
     const lineSeqRef = useRef(banner.length + 1);
@@ -107,6 +132,12 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     const thinkingTailRef = useRef("");
     const thinkingFlushAtRef = useRef(0);
     const thinkingTimerRef = useRef(null);
+    // Persist fence/open-code state across streamed assistant log lines so
+    // ``` blocks stay styled even when deltas arrive one line at a time.
+    const markdownStateRef = useRef({ inCodeBlock: false });
+    // GFM tables need the full block for column alignment — buffer consecutive
+    // pipe rows and flush as one multi-line markdown unit.
+    const tableBufRef = useRef(fmt.createMarkdownTableBuffer());
 
     const targetAgent = agentSelectionMode && selectedAgentIndex >= 0
       ? agents[selectedAgentIndex]
@@ -114,6 +145,33 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
 
     const bumpBackground = useCallback(() => setBackgroundVersion((v) => v + 1), []);
 
+    const refreshPlanUi = useCallback((activityMessage = "") => {
+      try {
+        const { buildPlanUiProjection } = require("../../code/context/planProjection");
+        const {
+          getPendingUserInteraction,
+          formatInteractionPromptLines,
+          syncInteractionFromPlanGraph,
+        } = require("../../code/context/userInteraction");
+        if (props.state && props.state.executionState) {
+          syncInteractionFromPlanGraph(props.state.executionState);
+        }
+        const next = buildPlanUiProjection(
+          props.state && props.state.executionState,
+          {
+            cols: size.cols || 80,
+            activityMessage: String(activityMessage || ""),
+          }
+        );
+        setPlanUi((prev) => (prev && prev.hash === next.hash ? prev : next));
+        const pending = getPendingUserInteraction(props.state && props.state.executionState);
+        setInteractionLines(pending ? formatInteractionPromptLines(pending) : []);
+        return next;
+      } catch {
+        return null;
+      }
+    }, [props.state, size.cols]);
+
     const getBackgroundSuffix = useCallback(() => {
       const tasks = backgroundTasksRef.current;
       if (!tasks || tasks.size === 0) return "";
@@ -208,6 +266,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         if (transition.moved) {
           setHistoryIndex(transition.nextHistoryIndex);
           setDraft(transition.nextValue);
+          setCompletionSuppressedDraft(transition.nextValue || null);
           setDraftVersion((v) => v + 1);
           return;
         }
@@ -224,22 +283,31 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       }
     }, [inputHistory, historyIndex, agents, agentSelectionMode, selectedAgentIndex]);
 
-    const onArrowUpAtStart = useCallback(() => {
-      // History first: if we're already on the top visual row, walk back
-      // through the recent history before doing anything else.
+    const onArrowUpAtStart = useCallback((currentValue) => {
+      // While @-targeting an agent with an empty draft, Up clears the
+      // selection before walking input history — otherwise history eats the
+      // key and the ›@agent prefix sticks.
+      const inputValue = currentValue != null ? currentValue : draft;
+      if (fmt.shouldClearAgentSelectionOnUp({
+        agentSelectionMode,
+        inputValue,
+      })) {
+        setAgentSelectionMode(false);
+        setSelectedAgentIndex(-1);
+        return;
+      }
+      // History: if we're already on the top visual row, walk back through
+      // the recent history before doing anything else.
       if (inputHistory.length > 0) {
         const nextIndex = Math.max(0, historyIndex - 1);
         if (nextIndex !== historyIndex || draft !== inputHistory[nextIndex]) {
           setHistoryIndex(nextIndex);
-          setDraft(inputHistory[nextIndex] || "");
+          const nextValue = inputHistory[nextIndex] || "";
+          setDraft(nextValue);
+          setCompletionSuppressedDraft(nextValue || null);
           setDraftVersion((v) => v + 1);
-          return;
         }
       }
-      if (agentSelectionMode) {
-        setAgentSelectionMode(false);
-        setSelectedAgentIndex(-1);
-      }
     }, [inputHistory, historyIndex, draft, agentSelectionMode]);
 
     const onArrowSideAtEmpty = useCallback((direction) => {
@@ -253,15 +321,94 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       setSelectedAgentIndex(next);
     }, [agents, agentSelectionMode, selectedAgentIndex]);
 
-    const appendLogLine = useCallback((text, kind = "assistant") => {
+    const { UCODE_COMMAND_REGISTRY, UCODE_COMMAND_TREE } = require("../../code/commands");
+    const { listSessionSummaries } = require("../../code/sessionStore");
+    const { suggestUcodeModels, applyUcodeModelCommand } = require("../../code/modelCommand");
+    let resumeSessions = [];
+    try {
+      resumeSessions = listSessionSummaries(props.workspaceRoot || process.cwd(), { limit: 40 });
+    } catch {
+      resumeSessions = [];
+    }
+    const modelSuggestions = suggestUcodeModels(props.state || {});
+
+    const completions = fmt.buildCompletions({
+      text: draft,
+      agents: agents.map((a) => String((a && (a.fullId || a.id || a.nickname)) || "")).filter(Boolean),
+      agentLabels: agents.map((a) => getAgentLabel(a)),
+      commands: UCODE_COMMAND_REGISTRY,
+      commandTree: UCODE_COMMAND_TREE,
+      argumentLists: {
+        "/resume": resumeSessions,
+        "/model": modelSuggestions,
+      },
+      limit: 20,
+    });
+    const completionsOpen = completions.length > 0 && draft !== completionSuppressedDraft;
+
+    useEffect(() => {
+      if (completions.length === 0) {
+        if (completionIndex !== 0) setCompletionIndex(0);
+        if (completionWindowStart !== 0) setCompletionWindowStart(0);
+      } else if (completionIndex >= completions.length) {
+        setCompletionIndex(completions.length - 1);
+        setCompletionWindowStart(Math.max(0, completions.length - POPUP_PAGE_SIZE));
+      }
+    }, [completions.length, completionIndex, completionWindowStart]);
+
+    const acceptCompletion = useCallback(() => {
+      if (!completionsOpen) return false;
+      const item = completions[Math.max(0, Math.min(completions.length - 1, completionIndex))];
+      if (item) {
+        setDraft(item.replace);
+        setCompletionSuppressedDraft(item.hasChildren ? null : item.replace);
+        setDraftVersion((v) => v + 1);
+      }
+      setCompletionIndex(0);
+      return true;
+    }, [completionsOpen, completions, completionIndex]);
+
+    const pushRenderedLogLines = useCallback((rawText, kind = "assistant") => {
+      const raw = String(rawText == null ? "" : rawText);
+      let renderedLines = [raw];
+      if (MARKDOWN_LOG_KINDS.has(kind)) {
+        try {
+          renderedLines = fmt.renderLogLinesWithMarkdownAnsi(raw, markdownStateRef.current);
+          if (!Array.isArray(renderedLines) || renderedLines.length === 0) {
+            renderedLines = raw.split(/\r?\n/);
+          }
+        } catch {
+          renderedLines = raw.split(/\r?\n/);
+        }
+      }
       setLogLines((prev) => {
-        const id = `l-${lineSeqRef.current}`;
-        lineSeqRef.current += 1;
-        const next = prev.concat([{ id, text: String(text || ""), kind }]);
+        const next = prev.slice();
+        for (const line of renderedLines) {
+          const id = `l-${lineSeqRef.current}`;
+          lineSeqRef.current += 1;
+          next.push({ id, text: String(line || ""), kind });
+        }
         return next.length > 1000 ? next.slice(-1000) : next;
       });
     }, []);
 
+    const flushTableBuffer = useCallback(() => {
+      const buffered = tableBufRef.current.flush();
+      if (buffered == null) return;
+      pushRenderedLogLines(buffered, "assistant");
+    }, [pushRenderedLogLines]);
+
+    const appendLogLine = useCallback((text, kind = "assistant") => {
+      const raw = String(text == null ? "" : text);
+      if (MARKDOWN_LOG_KINDS.has(kind)) {
+        if (tableBufRef.current.push(raw)) return;
+        flushTableBuffer();
+      } else {
+        flushTableBuffer();
+      }
+      pushRenderedLogLines(raw, kind);
+    }, [flushTableBuffer, pushRenderedLogLines]);
+
     const renderMergeText = useCallback((merge) => {
       if (!merge || !Array.isArray(merge.entries)) return "";
       return fmt.buildToolMergeRowText(merge.entries);
@@ -274,7 +421,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
     const flushActiveMerge = useCallback(() => {
       setActiveMerge((current) => {
         if (!current) return null;
-        appendLogLine(renderMergeText(current));
+        appendLogLine(renderMergeText(current), "tool");
         return null;
       });
     }, [appendLogLine, renderMergeText]);
@@ -285,7 +432,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       const resObj = payload && typeof payload === "object" ? payload : (entry && entry.result) || {};
       const phase = String((entry && entry.phase) || "").trim().toLowerCase();
       const isError = phase === "error" || resObj.ok === false;
-      const detail = tool === "bash" ? fmt.normalizeBashToolCommand(entry && entry.args, resObj) : "";
+      const detail = fmt.normalizeToolLogDetail(tool, entry && entry.args, resObj);
       const errorText = String((entry && entry.error) || resObj.error || "").trim();
       const toolEntry = fmt.normalizeToolMergeEntry({ tool, detail, isError, errorText });
 
@@ -305,12 +452,14 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       // Multi-line text → split into separate log entries so <Static> keys
       // stay stable when streaming arrives line-by-line. Always promote any
       // in-flight tool group first so it freezes above the new text.
+      // Table rows are re-batched inside appendLogLine before markdown render.
       const raw = String(text == null ? "" : text);
       if (!raw) return;
       flushActiveMerge();
       const lines = raw.split(/\r?\n/);
       for (const line of lines) appendLogLine(line, kind);
-    }, [appendLogLine, flushActiveMerge]);
+      if (MARKDOWN_LOG_KINDS.has(kind)) flushTableBuffer();
+    }, [appendLogLine, flushActiveMerge, flushTableBuffer]);
 
     const expandLastMerge = useCallback(() => {
       // Try the active group first; fall back to the most recent frozen one.
@@ -370,6 +519,61 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         case "error":
           appendLogText(result.output || "");
           return;
+        case "status": {
+          try {
+            const { summarizeSessionUsage, formatSessionUsageStatus } = require("../../code/usageStore");
+            const usageSummary = summarizeSessionUsage({
+              workspaceRoot: runtimeWorkspace,
+              sessionId: (props.state && props.state.sessionId) || "",
+            });
+            appendLogText(formatSessionUsageStatus(usageSummary), "system");
+            if (props.state && props.state.executionState) {
+              const { formatPlanModeStatus } = require("../../code/context/planMode");
+              const planLines = formatPlanModeStatus(props.state.executionState)
+                .split("\n")
+                .slice(0, 6)
+                .join("\n");
+              appendLogText(planLines, "system");
+            }
+          } catch (err) {
+            appendLogText(`Error: ${err && err.message ? err.message : "status failed"}`, "error");
+          }
+          return;
+        }
+        case "model": {
+          const applied = applyUcodeModelCommand(props.state || {}, result);
+          appendLogText(applied.output || "", applied.ok ? "system" : "error");
+          if (applied.ok && result.action === "set" && typeof props.persistSessionState === "function") {
+            try {
+              const persisted = props.persistSessionState(props.state);
+              if (persisted && persisted.ok === false) {
+                appendLogText(
+                  `Error: failed to persist session ${(props.state && props.state.sessionId) || ""}: ${persisted.error || "unknown error"}`,
+                  "error"
+                );
+              }
+            } catch {
+              // persist is best-effort after a successful model switch
+            }
+          }
+          return;
+        }
+        case "plan": {
+          const { applyUcodePlanCommand } = require("../../code/context/planMode");
+          const applied = applyUcodePlanCommand(props.state || {}, result);
+          appendLogText(applied.output || "", applied.ok ? "system" : "error");
+          if (applied.refreshPlanUi || applied.ok) {
+            refreshPlanUi();
+          }
+          if (applied.ok && typeof props.persistSessionState === "function") {
+            try {
+              props.persistSessionState(props.state);
+            } catch {
+              // best-effort
+            }
+          }
+          return;
+        }
         case "ubus": {
           setStatus({ message: "Checking bus messages...", type: "typing", showTimer: false, startedAt: Date.now() });
           try {
@@ -415,7 +619,32 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
             appendLogText(`Error: ${(resumed && resumed.error) || "resume failed"}`, "error");
             return;
           }
-          appendLogText(`Resumed session ${resumed.sessionId} (${resumed.restoredMessages} messages).`, "system");
+          // Rebuild the visible log from the restored session transcript so
+          // the user sees prior turns instead of only a status toast.
+          markdownStateRef.current = { inCodeBlock: false };
+          tableBufRef.current = fmt.createMarkdownTableBuffer();
+          const history = fmt.buildUcodeSessionLogEntries(
+            Array.isArray(props.state && props.state.nlMessages) ? props.state.nlMessages : [],
+            { markdownState: markdownStateRef.current, idPrefix: "h", startSeq: 0 },
+          );
+          const bannerEntries = banner.concat([""]).map((line, idx) => ({
+            id: `b-${idx}`,
+            text: line,
+          }));
+          const notice = {
+            id: `h-resume-${Date.now().toString(36)}`,
+            text: `Resumed session ${resumed.sessionId} (${resumed.restoredMessages} messages).`,
+            kind: "system",
+          };
+          const nextLines = bannerEntries.concat(history.entries).concat([notice]);
+          setLogLines(nextLines.length > 1000 ? nextLines.slice(-1000) : nextLines);
+          lineSeqRef.current = Math.max(
+            bannerEntries.length + 1,
+            Number(history.nextSeq) || 0,
+            nextLines.length,
+          );
+          setActiveMerge(null);
+          lastMergeRef.current = null;
           return;
         }
         case "tool": {
@@ -480,12 +709,18 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           const startedAt = Date.now();
           const abortController = new AbortController();
           pendingTaskRef.current = { abortController, startedAt };
-          const setNlStatus = (msg) => setStatus({
-            message: msg,
-            type: "thinking",
-            showTimer: true,
-            startedAt,
-          });
+          const setNlStatus = (msg) => {
+            const projection = refreshPlanUi(msg);
+            const message = projection && projection.hasPlan && projection.activityStatusLine
+              ? projection.activityStatusLine
+              : msg;
+            setStatus({
+              message,
+              type: "thinking",
+              showTimer: true,
+              startedAt,
+            });
+          };
           const cancelThinkingFlush = () => {
             if (thinkingTimerRef.current) {
               clearTimeout(thinkingTimerRef.current);
@@ -561,6 +796,9 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
                   setNlStatus(`${label}...`);
                   dropLeadingStreamBlank = true;
                 }
+                if (entry.tool === "plan_graph" || entry.phase === "end" || entry.phase === "result") {
+                  refreshPlanUi();
+                }
                 logToolHint(entry, entry.result);
               },
             });
@@ -571,12 +809,14 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
             pendingTaskRef.current = null;
             cancelThinkingFlush();
             thinkingTailRef.current = "";
+            refreshPlanUi();
             setStatus({ message: "", type: "thinking", showTimer: false, startedAt: 0 });
           }
           if (streamBuf) {
             if (/[^\s]/.test(streamBuf)) sawStreamText = true;
             appendLogLine(streamBuf);
           }
+          flushTableBuffer();
           // Skip the summary echo when the model already streamed its
           // response in full — otherwise the user sees the same text twice.
           // Mirrors the shouldSkipSummary check in tui.js.
@@ -604,7 +844,7 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         default:
           if (result.output) appendLogText(result.output);
       }
-    }, [appendLogLine, appendLogText, exit, props, logToolHint, flushActiveMerge]);
+    }, [appendLogLine, appendLogText, exit, props, logToolHint, flushActiveMerge, flushTableBuffer, refreshPlanUi]);
     // ^ `props` is captured by the createUcodeApp closure on a single mount,
     // so its reference is stable across renders even though it looks like a
     // changing dep to React's exhaustive-deps lint.
@@ -707,11 +947,129 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
         setHistoryIndex(next.length);
         return next;
       });
+
+      // Pending approval/choice/chat takes priority over nudge / new NL.
+      try {
+        const {
+          hasPendingUserInteraction,
+          parseUserInteractionInput,
+          getPendingUserInteraction,
+        } = require("../../code/context/userInteraction");
+        if (props.state && props.state.executionState && hasPendingUserInteraction(props.state.executionState)) {
+          const pending = getPendingUserInteraction(props.state.executionState);
+          const parsed = parseUserInteractionInput(pending, trimmed);
+          if (!parsed.ok) {
+            appendLogText(parsed.error || "Invalid reply", "error");
+            return;
+          }
+          appendLogText(`› ${trimmed}`, "user");
+          const startedAt = Date.now();
+          setStatus({
+            message: "Applying your reply...",
+            type: "thinking",
+            showTimer: true,
+            startedAt,
+          });
+          runChainRef.current = runChainRef.current
+            .then(async () => {
+              const resume = typeof props.resumeAfterUserInteraction === "function"
+                ? props.resumeAfterUserInteraction
+                : require("../../code/agent").resumeAfterUserInteraction;
+              let streamBuf = "";
+              let sawStreamText = false;
+              let streamStarted = false;
+              let dropLeadingStreamBlank = false;
+              const result = await resume(trimmed, props.state, {
+                onDelta: (delta) => {
+                  const text = String(delta || "");
+                  if (!text) return;
+                  if (!streamStarted) {
+                    flushActiveMerge();
+                    streamStarted = true;
+                  }
+                  const split = fmt.splitStreamingLogChunk(streamBuf, text, {
+                    dropLeadingBlank: dropLeadingStreamBlank,
+                  });
+                  if (split.sawVisible) {
+                    sawStreamText = true;
+                    dropLeadingStreamBlank = false;
+                  }
+                  for (const line of split.lines) {
+                    appendLogLine(line);
+                  }
+                  streamBuf = split.buffer;
+                },
+              });
+              if (streamBuf) {
+                if (/[^\s]/.test(streamBuf)) sawStreamText = true;
+                appendLogLine(streamBuf);
+              }
+              flushTableBuffer();
+              refreshPlanUi();
+              if (result && result.waitingUserInteraction) {
+                appendLogText("Still waiting for your reply.", "system");
+                setStatus({ message: "", type: "thinking", showTimer: false, startedAt: 0 });
+                return;
+              }
+              if (!result || result.ok === false) {
+                appendLogText(`Error: ${(result && result.error) || "resume failed"}`, "error");
+              } else {
+                // Skip summary echo when deltas were already rendered (mirrors NL path).
+                const shouldSkipSummary = Boolean(result.streamed && result.ok && sawStreamText);
+                if (result.summary && !shouldSkipSummary) {
+                  appendLogText(result.summary);
+                }
+              }
+              setStatus({ message: "", type: "thinking", showTimer: false, startedAt: 0 });
+            })
+            .catch((err) => {
+              appendLogText(`Error: ${err && err.message ? err.message : err}`, "error");
+              setStatus({ message: "", type: "thinking", showTimer: false, startedAt: 0 });
+            });
+          return;
+        }
+      } catch (err) {
+        appendLogText(`Error: ${err && err.message ? err.message : "interaction failed"}`, "error");
+        return;
+      }
+
+      // While a native task is in flight, queue an additional user reminder
+      // for the next LLM turn instead of starting a second NL task.
+      if (pendingTaskRef.current) {
+        const { enqueueUserPrompt } = require("../../code/context/userNudge");
+        const { emptyExecutionState } = require("../../code/context/executionSegment");
+        if (!props.state || typeof props.state !== "object") {
+          appendLogText("Error: missing session state for user reminder", "error");
+          return;
+        }
+        if (!props.state.executionState || typeof props.state.executionState !== "object") {
+          props.state.executionState = emptyExecutionState();
+        }
+        const queued = enqueueUserPrompt(props.state.executionState, trimmed);
+        appendLogText(
+          queued.enqueued
+            ? `Queued user reminder for next model turn: ${trimmed.slice(0, 120)}${trimmed.length > 120 ? "…" : ""}`
+            : "Could not queue user reminder (empty).",
+          "system",
+        );
+        return;
+      }
+
       // Serialize executions so streaming tasks don't interleave.
       runChainRef.current = runChainRef.current
         .then(() => executeLine(value))
         .catch((err) => appendLogText(`Error: ${err && err.message ? err.message : err}`, "error"));
-    }, [draft, executeLine, appendLogText]);
+    }, [
+      draft,
+      executeLine,
+      appendLogText,
+      appendLogLine,
+      flushActiveMerge,
+      flushTableBuffer,
+      props.state,
+      props.resumeAfterUserInteraction,
+      refreshPlanUi,
+    ]);
 
     useEffect(() => {
       if (!stdout) return undefined;
@@ -724,6 +1082,10 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       return () => stdout.off("resize", update);
     }, [stdout]);
 
+    useEffect(() => {
+      refreshPlanUi();
+    }, [refreshPlanUi]);
+
     // Drive the spinner + elapsed-timer redraws while a task is in flight.
     useEffect(() => {
       const statusType = inferStatusType(status.message, status.type);
@@ -737,44 +1099,214 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
       return () => clearInterval(timer);
     }, [status.message, status.type, status.showTimer]);
 
-    const statusText = useMemoStatusText(React, status, spinnerTick, getBackgroundSuffix());
+    const statusText = useMemoStatusText(
+      React,
+      status,
+      spinnerTick,
+      getBackgroundSuffix(),
+      !status.message ? (planUi.idleHint || "") : ""
+    );
 
-    // Top-level only catches Ctrl+C and Ctrl+O (expand last tool group);
-    // the editor handles all text editing.
+    // Top-level catches Ctrl+C / Ctrl+O, plus completion popup navigation
+    // while a slash/agent menu is open.
     useInput((input, key) => {
       if (key.ctrl && input === "c") { exit(); return; }
       if (key.ctrl && input === "o") { expandLastMerge(); return; }
+      if (!completionsOpen) return;
+      if (key.upArrow) {
+        setCompletionIndex((i) => {
+          const next = (i - 1 + completions.length) % completions.length;
+          setCompletionWindowStart((ws) => {
+            if (next < ws) return next;
+            if (next === completions.length - 1) {
+              return Math.max(0, completions.length - POPUP_PAGE_SIZE);
+            }
+            return ws;
+          });
+          return next;
+        });
+        return;
+      }
+      if (key.downArrow) {
+        setCompletionIndex((i) => {
+          const next = (i + 1) % completions.length;
+          setCompletionWindowStart((ws) => {
+            if (next === 0) return 0;
+            if (next >= ws + POPUP_PAGE_SIZE) return next - POPUP_PAGE_SIZE + 1;
+            return ws;
+          });
+          return next;
+        });
+        return;
+      }
+      if (key.return) {
+        // Leaf completions (e.g. /resume <session>) run immediately on Enter.
+        // Parents with children only fill the draft so the next menu can open.
+        const item = completions[Math.max(0, Math.min(completions.length - 1, completionIndex))];
+        if (item && !item.hasChildren) {
+          const cmd = String(item.replace || "").trim();
+          setCompletionIndex(0);
+          setCompletionSuppressedDraft(null);
+          if (cmd) submit(cmd);
+          return;
+        }
+        acceptCompletion();
+        return;
+      }
+      if (key.tab) {
+        acceptCompletion();
+        return;
+      }
+      if (key.escape) {
+        setCompletionSuppressedDraft(null);
+        setDraft("");
+        setDraftVersion((v) => v + 1);
+      }
     }, { isActive: interactive });
 
     return h(Box, { flexDirection: "column", width: "100%" },
       h(Box, { flexDirection: "column", width: "100%" },
-        ...logLines.map((item) =>
-          h(Text, { key: item.id, ...resolveLogLineTextProps(item.kind) }, item.text || " ")
-        )
+        ...(() => {
+          // Re-render raw markdown at paint time so leftover ** / ### / tables
+          // from older append paths or nested `**code**` patterns still resolve.
+          const mdState = { inCodeBlock: false };
+          return logLines.map((item, idx) => {
+            let text = item.text || " ";
+            if (MARKDOWN_LOG_KINDS.has(item.kind) && /(?:\*\*|__|^\s*#{1,6}\s|^\s*`{3}|^\s*\|)/m.test(text)) {
+              try {
+                const rendered = fmt.renderLogLinesWithMarkdownAnsi(text, mdState);
+                if (Array.isArray(rendered) && rendered.length > 0) {
+                  text = rendered.length === 1 ? rendered[0] : rendered.join("\n");
+                }
+              } catch {
+                // keep original
+              }
+            } else if (MARKDOWN_LOG_KINDS.has(item.kind) && mdState.inCodeBlock) {
+              try {
+                const rendered = fmt.renderLogLinesWithMarkdownAnsi(text, mdState);
+                if (Array.isArray(rendered) && rendered[0] != null) text = rendered[0];
+              } catch {
+                // keep original
+              }
+            }
+            const textEl = h(Text, { ...resolveLogLineTextProps(item.kind) }, text || " ");
+            // Give user turns a blank line above/below so › prompts don't
+            // sit flush against system/tool rows. Multi-line user blocks
+            // only pad the outer edges.
+            if (item.kind === "user") {
+              const prev = logLines[idx - 1];
+              const next = logLines[idx + 1];
+              const marginTop = !prev || prev.kind !== "user" ? 1 : 0;
+              const marginBottom = !next || next.kind !== "user" ? 1 : 0;
+              return h(Box, {
+                key: item.id,
+                width: "100%",
+                marginTop,
+                marginBottom,
+              }, textEl);
+            }
+            return h(Text, { key: item.id, ...resolveLogLineTextProps(item.kind) }, text || " ");
+          });
+        })()
       ),
       activeMerge ? h(Box, null,
         h(Text, { color: activeMerge.entries.some((e) => e.isError) ? "red" : "cyan" },
           renderMergeText(activeMerge)
         ),
       ) : null,
+      planUi.visible && 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 || " ")),
+        )
+        : null,
+      interactionLines.length > 0
+        ? h(Box, {
+          flexDirection: "column",
+          width: "100%",
+          marginTop: 1,
+        },
+          ...interactionLines.map((line, idx) => h(Text, {
+            key: `ask-${idx}`,
+            color: "yellow",
+            wrap: "truncate",
+          }, line || " ")),
+        )
+        : null,
       h(Box, { marginTop: 1, width: "100%" },
         h(Text, { color: "gray" }, statusText),
         h(Box, { flexGrow: 1 }),
         h(Text, { color: "gray" }, `v${fmt.UCODE_VERSION}`),
       ),
+      completionsOpen ? (() => {
+        const start = Math.min(completionWindowStart, Math.max(0, completions.length - POPUP_PAGE_SIZE));
+        const end = Math.min(completions.length, start + POPUP_PAGE_SIZE);
+        const visible = completions.slice(start, end);
+        const cols = Math.max(8, size.cols || 80);
+        // Frame the popup with a top rule; MultilineInput's borderTop is the
+        // matching bottom rule, so we intentionally omit a trailing ─ here.
+        return h(Box, { flexDirection: "column", width: "100%" },
+          h(Text, { color: "gray" }, "─".repeat(cols)),
+          ...visible.map((s, idxInWindow) => {
+            const idx = start + idxInWindow;
+            const selected = idx === completionIndex;
+            // Keep label+description in one Text. Splitting into sibling
+            // Text nodes with wrap:"truncate" lets Yoga shrink the label
+            // and mid-cut commands (e.g. "/help" → "/he p").
+            const line = s.description
+              ? `${s.label}  ${s.description}`
+              : String(s.label || "");
+            return h(Box, { key: `cmp-${idx}`, width: "100%" },
+              h(Text, {
+                color: selected ? "cyan" : "gray",
+                inverse: selected,
+                wrap: "truncate",
+              }, line),
+            );
+          }),
+        );
+      })() : null,
       h(Box, { width: "100%" },
         h(MultilineInput, {
           value: draft,
           valueVersion: draftVersion,
-          onChange: (next) => setDraft(next),
-          onSubmit: (value) => submit(value),
+          onChange: (next) => {
+            if (completionSuppressedDraft !== null && next !== completionSuppressedDraft) {
+              setCompletionSuppressedDraft(null);
+            }
+            setDraft(next);
+          },
+          onSubmit: (value) => {
+            setCompletionSuppressedDraft(null);
+            submit(value);
+          },
           onCancel: () => {
+            if (completionsOpen) {
+              setCompletionSuppressedDraft(null);
+              setDraft("");
+              setDraftVersion((v) => v + 1);
+              return;
+            }
             // If a task is in flight, Esc requests cancellation. Otherwise
             // it clears the agent selection (matches blessed). The text
             // value is left alone so the user doesn't lose what they typed.
             const pending = pendingTaskRef.current;
             if (pending && pending.abortController && !pending.abortController.signal.aborted) {
               try { pending.abortController.abort(); } catch { /* ignore */ }
+              try {
+                const { clearUserPrompts } = require("../../code/context/userNudge");
+                if (props.state && props.state.executionState) {
+                  clearUserPrompts(props.state.executionState);
+                }
+              } catch { /* ignore */ }
               appendLogLine("⚙ Cancellation requested. Stopping the current task...", "system");
               setStatus({
                 message: "Cancelling...",
@@ -795,11 +1327,12 @@ function createUcodeApp({ React, ink, props, interactive = true }) {
           onArrowRightAtEmpty: () => onArrowSideAtEmpty("right"),
           width: Math.max(20, (size.cols || 80) - 4),
           interactive,
+          interceptArrowsAndEnter: completionsOpen,
           placeholder: "",
           promptPrefix: targetAgent ? `›@${getAgentLabel(targetAgent)} ` : "› ",
-          // The agents footer is rendered below the input. Matching chat's
-          // IME parking contract keeps the hardware cursor aligned with the
-          // inverse caret instead of drifting to the bottom of the frame.
+          // Completions render ABOVE the input. Only the Agents footer is
+          // below — counting popup rows here parks the hardware cursor up
+          // into the menu (ghost block on /status etc.).
           linesBelowInput: 1,
           // During model/tool activity ucode redraws the status line every
           // spinner frame. Keeping the hardware cursor hidden avoids a
@@ -900,14 +1433,30 @@ function collapseThinkingTail(text, maxChars = 80) {
   const collapsed = String(text || "").replace(/\s+/g, " ").trim();
   const parsed = Number(maxChars);
   const limit = Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 80;
-  if (collapsed.length <= limit) return collapsed;
-  return collapsed.slice(collapsed.length - limit);
+  if (!collapsed) return "";
+
+  // Prefer the latest markdown emphasis / section so the status line shows the
+  // current thought instead of a mid-word tail of an earlier heading.
+  let candidate = collapsed;
+  const boldParts = collapsed.match(/\*\*[^*]+\*\*/g);
+  if (boldParts && boldParts.length > 0) {
+    candidate = boldParts[boldParts.length - 1].replace(/\*/g, "").trim() || candidate;
+  } else {
+    const clauses = collapsed.split(/(?<=[.!?。！？])\s+/).map((part) => part.trim()).filter(Boolean);
+    if (clauses.length > 1) candidate = clauses[clauses.length - 1];
+  }
+
+  if (candidate.length <= limit) return candidate;
+  return `…${candidate.slice(-(limit - 1))}`;
 }
 
-function computeStatusText(status, spinnerTick, backgroundSuffix = "") {
+function computeStatusText(status, spinnerTick, backgroundSuffix = "", idlePlanHint = "") {
   const message = String((status && status.message) || "");
   const suffix = String(backgroundSuffix || "");
-  if (!message) return `UCODE · Ready${suffix}`;
+  if (!message) {
+    const hint = String(idlePlanHint || "").trim();
+    return hint ? `UCODE · Ready · ${hint}${suffix}` : `UCODE · Ready${suffix}`;
+  }
   const type = inferStatusType(message, status && status.type);
   if (type === "done" || type === "success") {
     const clean = message.trim();
@@ -927,11 +1476,11 @@ function computeStatusText(status, spinnerTick, backgroundSuffix = "") {
   return `${indicator} ${message}${timerText}${suffix}`;
 }
 
-function useMemoStatusText(React, status, spinnerTick, backgroundSuffix = "") {
+function useMemoStatusText(React, status, spinnerTick, backgroundSuffix = "", idlePlanHint = "") {
   // Dependencies intentionally include startedAt so the timer ticks even
   // when the message string is unchanged.
   return React.useMemo(
-    () => computeStatusText(status, spinnerTick, backgroundSuffix),
-    [status, spinnerTick, backgroundSuffix]
+    () => computeStatusText(status, spinnerTick, backgroundSuffix, idlePlanHint),
+    [status, spinnerTick, backgroundSuffix, idlePlanHint]
   );
 }