cvc-tui 0.1.0 → 0.4.0

package/dist/components/skillsHub.js

@@ -0,0 +1,165 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { Box, Text, useInput, useStdout } from '@cvc/ink';
+import { useEffect, useState } from 'react';
+import { rpcErrorMessage } from '../lib/rpc.js';
+import { OverlayHint, useOverlayKeys, windowItems, windowOffset } from './overlayControls.js';
+const VISIBLE = 12;
+const MIN_WIDTH = 40;
+const MAX_WIDTH = 90;
+export function SkillsHub({ gw, onClose, t }) {
+    const [skillsByCat, setSkillsByCat] = useState({});
+    const [selectedCat, setSelectedCat] = useState('');
+    const [catIdx, setCatIdx] = useState(0);
+    const [skillIdx, setSkillIdx] = useState(0);
+    const [stage, setStage] = useState('category');
+    const [info, setInfo] = useState(null);
+    const [installing, setInstalling] = useState(false);
+    const [err, setErr] = useState('');
+    const [loading, setLoading] = useState(true);
+    const { stdout } = useStdout();
+    const width = Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, (stdout?.columns ?? 80) - 6));
+    useEffect(() => {
+        gw.request('skills.manage', { action: 'list' })
+            .then(r => {
+            setSkillsByCat(r?.skills ?? {});
+            setErr('');
+            setLoading(false);
+        })
+            .catch((e) => {
+            setErr(rpcErrorMessage(e));
+            setLoading(false);
+        });
+    }, [gw]);
+    const cats = Object.keys(skillsByCat).sort();
+    const skills = selectedCat ? (skillsByCat[selectedCat] ?? []) : [];
+    const skillName = skills[skillIdx] ?? '';
+    const back = () => {
+        if (stage === 'actions') {
+            setStage('skill');
+            setInfo(null);
+            setErr('');
+            return;
+        }
+        if (stage === 'skill') {
+            setStage('category');
+            setSkillIdx(0);
+            return;
+        }
+        onClose();
+    };
+    useOverlayKeys({ disabled: installing, onBack: back, onClose });
+    const inspect = (name) => {
+        setInfo(null);
+        setErr('');
+        gw.request('skills.manage', { action: 'inspect', query: name })
+            .then(r => setInfo(r?.info ?? { name }))
+            .catch((e) => setErr(rpcErrorMessage(e)));
+    };
+    const install = (name) => {
+        setInstalling(true);
+        setErr('');
+        gw.request('skills.manage', { action: 'install', query: name })
+            .then(() => onClose())
+            .catch((e) => setErr(rpcErrorMessage(e)))
+            .finally(() => setInstalling(false));
+    };
+    useInput((ch, key) => {
+        if (installing) {
+            return;
+        }
+        if (stage === 'actions') {
+            if (key.return) {
+                setStage('skill');
+                setInfo(null);
+                setErr('');
+                return;
+            }
+            if (ch.toLowerCase() === 'x' && skillName) {
+                install(skillName);
+                return;
+            }
+            if (ch.toLowerCase() === 'i' && skillName) {
+                inspect(skillName);
+            }
+            return;
+        }
+        const count = stage === 'category' ? cats.length : skills.length;
+        const sel = stage === 'category' ? catIdx : skillIdx;
+        const setSel = stage === 'category' ? setCatIdx : setSkillIdx;
+        if (key.upArrow && sel > 0) {
+            setSel(v => v - 1);
+            return;
+        }
+        if (key.downArrow && sel < count - 1) {
+            setSel(v => v + 1);
+            return;
+        }
+        if (key.return) {
+            if (stage === 'category') {
+                const cat = cats[catIdx];
+                if (!cat) {
+                    return;
+                }
+                setSelectedCat(cat);
+                setSkillIdx(0);
+                setStage('skill');
+                return;
+            }
+            const name = skills[skillIdx];
+            if (name) {
+                setStage('actions');
+                inspect(name);
+            }
+            return;
+        }
+        const n = ch === '0' ? 10 : parseInt(ch, 10);
+        if (!Number.isNaN(n) && n >= 1 && n <= Math.min(10, count)) {
+            const next = windowOffset(count, sel, VISIBLE) + n - 1;
+            if (stage === 'category') {
+                const cat = cats[next];
+                if (cat) {
+                    setSelectedCat(cat);
+                    setCatIdx(next);
+                    setSkillIdx(0);
+                    setStage('skill');
+                }
+                return;
+            }
+            const name = skills[next];
+            if (name) {
+                setSkillIdx(next);
+                setStage('actions');
+                inspect(name);
+            }
+        }
+    });
+    if (loading) {
+        return _jsx(Text, { color: t.color.muted, children: "loading skills\u2026" });
+    }
+    if (err && stage === 'category') {
+        return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(Text, { color: t.color.label, children: ["error: ", err] }), _jsx(OverlayHint, { t: t, children: "Esc/q cancel" })] }));
+    }
+    if (!cats.length) {
+        return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsx(Text, { color: t.color.muted, children: "no skills available" }), _jsx(OverlayHint, { t: t, children: "Esc/q cancel" })] }));
+    }
+    if (stage === 'category') {
+        const rows = cats.map(c => `${c} · ${skillsByCat[c]?.length ?? 0} skills`);
+        const { items, offset } = windowItems(rows, catIdx, VISIBLE);
+        return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsx(Text, { bold: true, color: t.color.accent, children: "Skills Hub" }), _jsx(Text, { color: t.color.muted, children: "select a category" }), offset > 0 && _jsxs(Text, { color: t.color.muted, children: [" \u2191 ", offset, " more"] }), items.map((row, i) => {
+                    const idx = offset + i;
+                    return (_jsxs(Text, { bold: catIdx === idx, color: catIdx === idx ? t.color.accent : t.color.muted, inverse: catIdx === idx, wrap: "truncate-end", children: [catIdx === idx ? '▸ ' : '  ', i + 1, ". ", row] }, row));
+                }), offset + VISIBLE < rows.length && _jsxs(Text, { color: t.color.muted, children: [" \u2193 ", rows.length - offset - VISIBLE, " more"] }), _jsx(OverlayHint, { t: t, children: "\u2191/\u2193 select \u00B7 Enter open \u00B7 1-9,0 quick \u00B7 Esc/q cancel" })] }));
+    }
+    if (stage === 'skill') {
+        const { items, offset } = windowItems(skills, skillIdx, VISIBLE);
+        return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsx(Text, { bold: true, color: t.color.accent, children: selectedCat }), _jsxs(Text, { color: t.color.muted, children: [skills.length, " skill(s)"] }), !skills.length ? _jsx(Text, { color: t.color.muted, children: "no skills in this category" }) : null, offset > 0 && _jsxs(Text, { color: t.color.muted, children: [" \u2191 ", offset, " more"] }), items.map((row, i) => {
+                    const idx = offset + i;
+                    return (_jsxs(Text, { bold: skillIdx === idx, color: skillIdx === idx ? t.color.accent : t.color.muted, inverse: skillIdx === idx, wrap: "truncate-end", children: [skillIdx === idx ? '▸ ' : '  ', i + 1, ". ", row] }, row));
+                }), offset + VISIBLE < skills.length && (_jsxs(Text, { color: t.color.muted, children: [" \u2193 ", skills.length - offset - VISIBLE, " more"] })), _jsx(OverlayHint, { t: t, children: skills.length ? '↑/↓ select · Enter open · 1-9,0 quick · Esc back · q close' : 'Esc back · q close' })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsx(Text, { bold: true, color: t.color.accent, children: info?.name ?? skillName }), _jsx(Text, { color: t.color.muted, children: info?.category ?? selectedCat }), info?.description ? _jsx(Text, { color: t.color.text, children: info.description }) : null, info?.path ? _jsxs(Text, { color: t.color.muted, children: ["path: ", info.path] }) : null, !info && !err ? _jsx(Text, { color: t.color.muted, children: "loading\u2026" }) : null, err ? _jsxs(Text, { color: t.color.label, children: ["error: ", err] }) : null, installing ? _jsx(Text, { color: t.color.accent, children: "installing\u2026" }) : null, _jsx(OverlayHint, { t: t, children: "i reinspect \u00B7 x reinstall \u00B7 Enter/Esc back \u00B7 q close" })] }));
+}

package/dist/components/streamingAssistant.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { useStore } from '@nanostores/react';
+import { memo } from 'react';
+import { toggleTodoCollapsed, useTurnSelector } from '../app/turnStore.js';
+import { $uiState } from '../app/uiStore.js';
+import { appendToolShelfMessage } from '../lib/liveProgress.js';
+import { MessageLine } from './messageLine.js';
+import { TodoPanel } from './todoPanel.js';
+const groupedSegments = (segments) => segments.reduce((acc, msg) => appendToolShelfMessage(acc, msg), []);
+export const StreamingAssistant = memo(function StreamingAssistant({ cols, compact, detailsMode, detailsModeCommandOverride, progress, sections }) {
+    const ui = useStore($uiState);
+    const streamSegments = useTurnSelector(state => state.streamSegments);
+    const streamPendingTools = useTurnSelector(state => state.streamPendingTools);
+    const streaming = useTurnSelector(state => state.streaming);
+    const activeTools = useTurnSelector(state => state.tools);
+    const showStreamingArea = Boolean(streaming);
+    if (!progress.showProgressArea && !showStreamingArea && !activeTools.length) {
+        return null;
+    }
+    return (_jsxs(_Fragment, { children: [groupedSegments(streamSegments).map((msg, i) => (_jsx(MessageLine, { cols: cols, compact: compact, detailsMode: detailsMode, detailsModeCommandOverride: detailsModeCommandOverride, msg: msg, sections: sections, t: ui.theme }, `seg:${i}`))), !!activeTools.length && (_jsx(MessageLine, { cols: cols, compact: compact, detailsMode: detailsMode, detailsModeCommandOverride: detailsModeCommandOverride, msg: { kind: 'trail', role: 'system', text: '' }, sections: sections, t: ui.theme, tools: activeTools })), showStreamingArea && (_jsx(MessageLine, { cols: cols, compact: compact, detailsMode: detailsMode, detailsModeCommandOverride: detailsModeCommandOverride, isStreaming: true, msg: {
+                    role: 'assistant',
+                    text: streaming,
+                    ...(streamPendingTools.length && { tools: streamPendingTools })
+                }, sections: sections, t: ui.theme })), !showStreamingArea && !!streamPendingTools.length && (_jsx(MessageLine, { cols: cols, compact: compact, detailsMode: detailsMode, detailsModeCommandOverride: detailsModeCommandOverride, msg: { kind: 'trail', role: 'system', text: '', tools: streamPendingTools }, sections: sections, t: ui.theme }))] }));
+});
+export const LiveTodoPanel = memo(function LiveTodoPanel() {
+    const ui = useStore($uiState);
+    const todos = useTurnSelector(state => state.todos);
+    const collapsed = useTurnSelector(state => state.todoCollapsed);
+    return _jsx(TodoPanel, { collapsed: collapsed, onToggle: toggleTodoCollapsed, t: ui.theme, todos: todos });
+});

package/dist/components/streamingMarkdown.js

@@ -1,45 +1,63 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Streaming markdown renderer for the CVC TUI.
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+// StreamingMd — incremental markdown renderer for in-flight assistant text.
 //
-// Behaviour parity with Hermes' streamingMarkdown:
-//   * Splits in-flight text at the last stable top-level block boundary
-//     (a blank line OUTSIDE a fenced code block) so the stable prefix is
-//     memoised and only the unstable suffix re-tokenises on each delta.
-//   * The stable prefix is monotonically growing (stored in a ref), so
-//     React reuses the cached subtree across deltas.
+// Naive approach (render <Md text={full}/>) re-tokenizes the entire message
+// on every stream delta. At 20-char batches over a 3 KB response that's 150
+// full re-parses.
 //
-// Block support:
-//   * ATX headings (#, ##, …)        — bold, accent-coloured by level
-//   * Fenced code (``` / ~~~) w/ syntax highlighting via cli-highlight
-//   * Bullet & numbered lists (incl. nesting via leading whitespace)
-//   * Blockquotes (`> …`)            — dim left bar
-//   * Horizontal rules (---, ***)
-//   * Inline: **bold**, *italic*, `code`, ~~strike~~, [text](url)
-//   * Bare URLs and OSC 8 hyperlinks (terminal-clickable)
+// This splits `text` at the last stable top-level block boundary (blank
+// line outside a fenced code span) into:
+//   stablePrefix — passed to an inner <Md>, memoized on its exact text
+//                  value. During the turn, the prefix only grows monotonically,
+//                  so its memo key matches the previous render and React
+//                  reuses the cached subtree — zero re-tokenization.
+//   unstableSuffix — the in-flight block(s). A separate <Md> re-parses just
+//                    this tail on every delta (O(unstable length) vs.
+//                    O(total length)).
 //
-// Implementation notes:
-//   * We do NOT use marked's full HTML pipeline — the lexer is enough.
-//     marked.lexer() returns block tokens; we recurse into inline tokens
-//     ourselves so we can control Ink primitives exactly.
-//   * Code highlighting is opt-in per language. cli-highlight already
-//     emits ANSI escapes (which Ink's <Text> passes through).
-//   * Links: we render them as OSC 8 hyperlinks via a raw escape string
-//     wrapped in <Text> — terminals that don't understand OSC 8 will
-//     simply show the visible text portion.
-import { Fragment, memo, useRef } from 'react';
-import { Box, Text } from 'ink';
-import { marked } from 'marked';
-import { highlight, supportsLanguage } from 'cli-highlight';
-import { CVC_THEME } from '../types.js';
-const ESC = '\x1b';
-const OSC8_OPEN = (url) => `${ESC}]8;;${url}${ESC}\\`;
-const OSC8_CLOSE = `${ESC}]8;;${ESC}\\`;
-/** Wrap visible text with OSC 8 hyperlink escape so terminals make it clickable. */
-export const osc8Link = (url, label) => `${OSC8_OPEN(url)}${label}${OSC8_CLOSE}`;
-// -- stable-boundary chunker ---------------------------------------------------
-/** Count whether `s[0..end)` ends inside an open ``` / ~~~ fence. */
+// The boundary is stored in a ref so it only advances — idempotent under
+// StrictMode double-render. Component unmounts between turns (isStreaming
+// flips off → message moves to history and renders via <Md> directly), so
+// the ref resets naturally.
+//
+// Layout: the two <Md> subtrees MUST render stacked (column). The parent
+// container in messageLine.tsx is a default `flexDirection: 'row'` Box
+// (Ink's default), so returning a bare Fragment of two <Md> siblings
+// laid them out side-by-side — producing the "two jumbled columns while
+// streaming" rendering bug. Wrapping in a flexDirection="column" Box
+// here localizes the fix to the streaming path; the non-streaming <Md>
+// already returns its own column Box, so its single-child case was never
+// affected.
+import { Box } from '@cvc/ink';
+import { memo, useRef } from 'react';
+import { Md } from './markdown.js';
+// Count ``` / ~~~ AND `$$` / `\[…\]` fence toggles in `s` up to `end`. Odd
+// = currently inside a fenced block; splitting the prefix there would
+// orphan the fence and let the unstable suffix re-render as broken
+// markdown. Math fences only toggle when the code fence is closed so
+// snippets like ` ```\n$$x$$\n``` ` (math example inside a code block)
+// don't double-count. A `$$x$$` line that opens AND closes on its own
+// produces zero net toggles; that's `len >= 4` plus `endsDollar`.
+//
+// NB: this is INTENTIONALLY more conservative than `markdown.tsx`'s
+// parser, which falls back to paragraph rendering when an `$$` opener
+// has no matching closer. The renderer can do that safely because it
+// always sees the full text on every call. The streaming chunker
+// cannot — once a chunk is committed to the monotonic stable prefix it
+// is frozen, so prematurely deciding "this `$$` is just prose" would
+// permanently commit a paragraph rendering that becomes wrong the
+// instant the closer streams in. Treating any unmatched `$$` opener
+// as still-open keeps the boundary parked behind it until the closer
+// arrives (or the stream ends and the non-streaming `<Md>` takes over,
+// at which point the renderer's fallback kicks in correctly).
 const fenceOpenAt = (s, end) => {
     let codeOpen = false;
+    let mathOpen = false;
+    let mathOpener = null;
     let i = 0;
     while (i < end) {
         const nl = s.indexOf('\n', i);
@@ -48,173 +66,79 @@ const fenceOpenAt = (s, end) => {
         if (/^(?:`{3,}|~{3,})/.test(line)) {
             codeOpen = !codeOpen;
         }
-        if (nl < 0 || nl >= end)
+        else if (!codeOpen) {
+            if (!mathOpen && /^\$\$/.test(line)) {
+                const isSingleLine = line.length >= 4 && /\$\$$/.test(line);
+                if (!isSingleLine) {
+                    mathOpen = true;
+                    mathOpener = '$$';
+                }
+            }
+            else if (!mathOpen && /^\\\[/.test(line)) {
+                const isSingleLine = /\\\]$/.test(line);
+                if (!isSingleLine) {
+                    mathOpen = true;
+                    mathOpener = '\\[';
+                }
+            }
+            else if (mathOpen && mathOpener === '$$' && /\$\$$/.test(line)) {
+                mathOpen = false;
+                mathOpener = null;
+            }
+            else if (mathOpen && mathOpener === '\\[' && /\\\]$/.test(line)) {
+                mathOpen = false;
+                mathOpener = null;
+            }
+        }
+        if (nl < 0 || nl >= end) {
             break;
+        }
         i = nl + 1;
     }
-    return codeOpen;
+    return codeOpen || mathOpen;
 };
-/** Last \n\n boundary outside a fenced block, returned as start-of-next-block index. */
+// Find the last "\n\n" boundary before `end` that is OUTSIDE a fenced code
+// block. Returns the index AFTER the second newline (start of the next
+// block), or -1 if no safe boundary exists yet.
 export const findStableBoundary = (text) => {
     let idx = text.length;
     while (idx > 0) {
         const boundary = text.lastIndexOf('\n\n', idx - 1);
-        if (boundary < 0)
+        if (boundary < 0) {
             return -1;
+        }
+        // Boundary candidate: end of stable prefix is boundary + 2 (start of
+        // next block). Check fence balance up to that point.
         const splitAt = boundary + 2;
-        if (!fenceOpenAt(text, splitAt))
+        if (!fenceOpenAt(text, splitAt)) {
             return splitAt;
+        }
         idx = boundary;
     }
     return -1;
 };
-// -- inline rendering ---------------------------------------------------------
-const HEADING_COLOURS = {
-    1: CVC_THEME.primary, // CVC red
-    2: CVC_THEME.accent,
-    3: CVC_THEME.accent,
-};
-const renderInline = (tokens, key = 0) => {
-    if (!tokens)
-        return null;
-    const out = [];
-    tokens.forEach((tok, i) => {
-        const k = `${key}-${i}`;
-        switch (tok.type) {
-            case 'text':
-            case 'escape':
-                out.push(_jsx(Text, { children: tok.text ?? tok.raw ?? '' }, k));
-                break;
-            case 'strong':
-                out.push(_jsx(Text, { bold: true, children: renderInline(tok.tokens, i) }, k));
-                break;
-            case 'em':
-                out.push(_jsx(Text, { italic: true, children: renderInline(tok.tokens, i) }, k));
-                break;
-            case 'del':
-                out.push(_jsx(Text, { strikethrough: true, children: renderInline(tok.tokens, i) }, k));
-                break;
-            case 'codespan':
-                out.push(_jsxs(Text, { color: CVC_THEME.accent, backgroundColor: "#1b2735", children: [' ', tok.text ?? '', ' '] }, k));
-                break;
-            case 'link': {
-                const href = tok.href ?? '';
-                const label = (tok.text ?? href) || '';
-                // OSC 8 — embed the click target in the escape sequence so the
-                // visible text is just the label (still styled accent+underline).
-                out.push(_jsx(Text, { color: CVC_THEME.accent, underline: true, children: osc8Link(href, label) }, k));
-                break;
-            }
-            case 'br':
-                out.push(_jsx(Text, { children: '\n' }, k));
-                break;
-            case 'image': {
-                const href = tok.href ?? '';
-                const label = tok.text ?? '';
-                out.push(_jsxs(Text, { color: CVC_THEME.dim, children: ["[image: ", label, "] ", href] }, k));
-                break;
-            }
-            default:
-                out.push(_jsx(Text, { children: tok.raw ?? tok.text ?? '' }, k));
-        }
-    });
-    return out;
-};
-// -- block rendering ----------------------------------------------------------
-const renderCodeBlock = (text, lang, k) => {
-    const language = (lang ?? '').trim().toLowerCase();
-    let body = text;
-    if (language && supportsLanguage(language)) {
-        try {
-            body = highlight(text, { language, ignoreIllegals: true });
-        }
-        catch {
-            body = text;
-        }
+export const StreamingMd = memo(function StreamingMd({ compact, t, text }) {
+    const stablePrefixRef = useRef('');
+    // Reset if the text no longer starts with our recorded prefix (defensive;
+    // normally the component unmounts between turns so this shouldn't trigger).
+    if (!text.startsWith(stablePrefixRef.current)) {
+        stablePrefixRef.current = '';
     }
-    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginY: 0, children: [language ? _jsxs(Text, { color: CVC_THEME.dim, children: ["\u2500 ", language] }) : null, body.split('\n').map((line, i) => (_jsx(Text, { children: line }, i)))] }, k));
-};
-const renderListItem = (item, ordered, index, k) => {
-    const bullet = ordered ? `${index + 1}. ` : '• ';
-    return (_jsxs(Box, { children: [_jsx(Text, { color: CVC_THEME.accent, children: bullet }), _jsx(Box, { flexDirection: "column", children: item.tokens?.map((child, ci) => (_jsx(Fragment, { children: renderBlock(child, `${k}-${ci}`) }, ci))) })] }, k));
-};
-const renderBlock = (tok, k) => {
-    switch (tok.type) {
-        case 'heading': {
-            const t = tok;
-            const colour = HEADING_COLOURS[t.depth] ?? CVC_THEME.dim;
-            return (_jsx(Box, { children: _jsxs(Text, { bold: true, color: colour, children: ['#'.repeat(t.depth), ' ', renderInline(t.tokens)] }) }, k));
-        }
-        case 'paragraph': {
-            const t = tok;
-            return (_jsx(Text, { children: renderInline(t.tokens) }, k));
-        }
-        case 'code': {
-            const t = tok;
-            return renderCodeBlock(t.text ?? '', t.lang ?? undefined, k);
-        }
-        case 'blockquote': {
-            const t = tok;
-            return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: CVC_THEME.dim, children: "\u2502 " }), _jsx(Box, { flexDirection: "column", children: (t.tokens ?? []).map((child, ci) => (_jsx(Fragment, { children: renderBlock(child, `${k}-${ci}`) }, ci))) })] }, k));
-        }
-        case 'list': {
-            const t = tok;
-            return (_jsx(Box, { flexDirection: "column", children: t.items.map((it, i) => renderListItem(it, !!t.ordered, i, `${k}-i${i}`)) }, k));
-        }
-        case 'hr':
-            return (_jsx(Text, { color: CVC_THEME.dim, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }, k));
-        case 'space':
-            return _jsx(Text, { children: " " }, k);
-        case 'html':
-            return _jsx(Text, { children: tok.text }, k);
-        case 'text': {
-            const t = tok;
-            const inline = t.tokens;
-            return (_jsx(Text, { children: inline ? renderInline(inline) : t.text }, k));
-        }
-        default:
-            return (_jsx(Text, { children: tok.raw ?? '' }, k));
-    }
-};
-const lexerOptions = { gfm: true, breaks: false };
-/** Public: render arbitrary markdown as a stack of Ink Box/Text nodes. */
-export const Markdown = memo(function Markdown({ text }) {
-    if (!text)
-        return null;
-    let tokens = [];
-    try {
-        tokens = marked.lexer(text, lexerOptions);
-    }
-    catch {
-        return _jsx(Text, { children: text });
-    }
-    return (_jsx(Box, { flexDirection: "column", children: tokens.map((tok, i) => (_jsx(Fragment, { children: renderBlock(tok, `b${i}`) }, i))) }));
-});
-/**
- * StreamingMarkdown — the renderer used while a turn is in flight.
- * Splits `content` at the last safe block boundary so the stable prefix
- * memoises across deltas (avoiding O(N) re-tokenisation per chunk).
- */
-export const StreamingMarkdown = memo(function StreamingMarkdown({ content, color, }) {
-    const stableRef = useRef('');
-    if (!content.startsWith(stableRef.current)) {
-        stableRef.current = '';
+    const boundary = findStableBoundary(text);
+    // Only advance the prefix — never retreat. The boundary math looks at the
+    // FULL text each call; if it returns a larger index than before, we grow
+    // the cached prefix. Monotonic growth makes the memo key stable across
+    // deltas (identical string → same <Md> subtree → no re-render).
+    if (boundary > stablePrefixRef.current.length) {
+        stablePrefixRef.current = text.slice(0, boundary);
     }
-    const boundary = findStableBoundary(content);
-    if (boundary > stableRef.current.length) {
-        stableRef.current = content.slice(0, boundary);
+    const stablePrefix = stablePrefixRef.current;
+    const unstableSuffix = text.slice(stablePrefix.length);
+    if (!stablePrefix) {
+        return _jsx(Md, { compact: compact, t: t, text: unstableSuffix });
     }
-    const stable = stableRef.current;
-    const unstable = content.slice(stable.length);
-    if (!content)
-        return null;
-    if (color) {
-        // Plain-text override path (used for user echo bubbles).
-        return _jsx(Text, { color: color, children: content });
+    if (!unstableSuffix) {
+        return _jsx(Md, { compact: compact, t: t, text: stablePrefix });
     }
-    if (!stable)
-        return _jsx(Markdown, { text: unstable });
-    if (!unstable)
-        return _jsx(Markdown, { text: stable });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Markdown, { text: stable }), _jsx(Markdown, { text: unstable })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Md, { compact: compact, t: t, text: stablePrefix }), _jsx(Md, { compact: compact, t: t, text: unstableSuffix })] }));
 });