@askdkc/dsh-cli 0.11.3

package/lib/types/components/Spinner/useStalledAnimation.js

@@ -0,0 +1,52 @@
+import { useRef } from 'react';
+const QUIET_PERIOD_MS = 3000;
+const COLOR_RAMP_MS = 2000;
+const SMOOTHING_MS = 180;
+function clamp(value) {
+    return Math.min(1, Math.max(0, value));
+}
+/** Derive the target stall state from elapsed output time and tool activity. */
+export function getStallState(timeSinceOutput, hasActiveTools = false) {
+    if (hasActiveTools)
+        return { isStalled: false, intensity: 0 };
+    const quietFor = Math.max(0, timeSinceOutput);
+    const isStalled = quietFor > QUIET_PERIOD_MS;
+    const intensity = isStalled
+        ? clamp((quietFor - QUIET_PERIOD_MS) / COLOR_RAMP_MS)
+        : 0;
+    return { isStalled, intensity };
+}
+/**
+ * Track output silence from the parent's animation clock. The target color
+ * changes linearly over the ramp, while the displayed value eases toward it
+ * with a time-based response that remains stable if a frame is delayed.
+ */
+export function useStalledAnimation(time, currentResponseLength, hasActiveTools = false, reducedMotion = false) {
+    const lastOutputTime = useRef(time);
+    const lastResponseLength = useRef(currentResponseLength);
+    const mountedAt = useRef(time);
+    const displayedIntensity = useRef(0);
+    const previousTime = useRef(time);
+    if (currentResponseLength > lastResponseLength.current) {
+        lastResponseLength.current = currentResponseLength;
+        lastOutputTime.current = time;
+    }
+    const timeSinceOutput = currentResponseLength > 0
+        ? time - lastOutputTime.current
+        : time - mountedAt.current;
+    const state = getStallState(timeSinceOutput, hasActiveTools);
+    const delta = Math.max(0, time - previousTime.current);
+    previousTime.current = time;
+    if (reducedMotion || delta === 0) {
+        displayedIntensity.current = state.intensity;
+    }
+    else {
+        const response = 1 - Math.exp(-delta / SMOOTHING_MS);
+        displayedIntensity.current +=
+            (state.intensity - displayedIntensity.current) * response;
+    }
+    return {
+        isStalled: state.isStalled,
+        stalledIntensity: displayedIntensity.current,
+    };
+}

package/lib/types/components/SplitDiffView.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { ToolFileDiff } from '../dsh-adapter/channel.js';
+export { chalkFromToken } from '../terminal-utils/syntaxTheme.js';
+export { parseAnsiRuns, highlightLines } from '../terminal-utils/syntaxRuns.js';
+import type { ToolBackground } from '../tuiDisplayPrefs.js';
+export declare function SplitDiffView({ diffs, width, maxRows, verbose, toolBackground, reveal, }: {
+    readonly diffs: readonly ToolFileDiff[];
+    /** Content width available to the whole two-pane block (divider included). */
+    readonly width: number;
+    /** Row budget when not verbose; overflow folds into one hint row. */
+    readonly maxRows: number;
+    readonly verbose: boolean;
+    readonly toolBackground?: ToolBackground;
+    /**
+     * Smooth-streaming participation (the card owning this view computes
+     * eligibility): when present, the capped row list reveals line-by-line at
+     * the shared ~30fps cadence instead of painting as one block. The `+N
+     * lines` fold hint stays rendered throughout — it describes the cap, not
+     * the reveal.
+     */
+    readonly reveal?: {
+        readonly key: string;
+    };
+}): React.ReactNode;
+//# sourceMappingURL=SplitDiffView.d.ts.map

package/lib/types/components/SplitDiffView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplitDiffView.d.ts","sourceRoot":"","sources":["../../../src/components/SplitDiffView.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAO7D,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAI/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAwR3D,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,cAAuB,EACvB,MAAM,GACP,EAAE;IACD,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;IACvC,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAA;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C,GAAG,KAAK,CAAC,SAAS,CAwFlB"}

package/lib/types/components/SplitDiffView.js

@@ -0,0 +1,279 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from '../ui.js';
+import * as JsDiff from 'diff';
+import { extname } from 'node:path';
+import { getCliHighlightPromise } from '../terminal-utils/cliHighlight.js';
+import { highlightLines, syntaxThemeSignature } from '../terminal-utils/syntaxRuns.js';
+// Backward-compatible re-export: repro scripts import chalkFromToken from
+// this module's old home.
+export { chalkFromToken } from '../terminal-utils/syntaxTheme.js';
+export { parseAnsiRuns, highlightLines } from '../terminal-utils/syntaxRuns.js';
+import { getTheme } from '../theme.js';
+import { t } from '../i18n.js';
+import { useTheme } from './design-system/ThemeProvider.js';
+import { revealLinesOf } from './smoothReveal.js';
+/** Replace tabs so width math and alignment hold (pi convention). */
+const expandTabs = (text) => text.replaceAll('\t', '   ');
+/**
+ * Merge syntax runs with word-diff change flags over the same string: both
+ * partition it, so an offset sweep yields runs carrying a syntax color AND
+ * a changed flag. The render layer lets `changed` override the color.
+ */
+function mergeRuns(syntax, words) {
+    const out = [];
+    let si = 0;
+    let wi = 0;
+    let sOff = 0;
+    let wOff = 0;
+    while (si < syntax.length && wi < words.length) {
+        const s = syntax[si];
+        const w = words[wi];
+        const sLen = s.text.length - sOff;
+        const wLen = w.text.length - wOff;
+        const take = Math.min(sLen, wLen);
+        if (take > 0) {
+            out.push({
+                text: w.text.slice(wOff, wOff + take),
+                changed: w.changed,
+                color: w.changed ? undefined : s.color,
+            });
+        }
+        sOff += take;
+        wOff += take;
+        if (sOff >= s.text.length) {
+            si++;
+            sOff = 0;
+        }
+        if (wOff >= w.text.length) {
+            wi++;
+            wOff = 0;
+        }
+    }
+    return out;
+}
+// --- word-level diff --------------------------------------------------------
+/** Strip the shared leading whitespace before word-diffing: otherwise the
+ *  whole indent reads as one changed blob (pi's renderIntraLineDiff trick). */
+function wordSegments(oldLine, newLine) {
+    const oldIndent = /^\s*/.exec(oldLine)?.[0] ?? '';
+    const newIndent = /^\s*/.exec(newLine)?.[0] ?? '';
+    const sharedIndent = oldIndent === newIndent ? oldIndent : '';
+    const parts = JsDiff.diffWords(oldLine.slice(sharedIndent.length), newLine.slice(sharedIndent.length));
+    const oldSegments = sharedIndent === '' ? [] : [{ text: sharedIndent, changed: false }];
+    const newSegments = sharedIndent === '' ? [] : [{ text: sharedIndent, changed: false }];
+    for (const part of parts) {
+        if (part.added)
+            newSegments.push({ text: part.value, changed: true });
+        else if (part.removed)
+            oldSegments.push({ text: part.value, changed: true });
+        else {
+            oldSegments.push({ text: part.value, changed: false });
+            newSegments.push({ text: part.value, changed: false });
+        }
+    }
+    return { old: oldSegments, new: newSegments };
+}
+const plainSegments = (line) => [{ text: line, changed: false }];
+// --- hunk alignment ---------------------------------------------------------
+/**
+ * Pair the lines of an unequal removed+added block via a case-insensitive
+ * LCS: lines equal modulo case align as change pairs, everything before the
+ * first match stays block order. An inserted line above an edited one
+ * (`foo,bar` → `insert,FOO,bar`) therefore yields `insert` add-only, then
+ * `foo ↔ FOO`, instead of the index-zip misalignment (issue #250, P2-4).
+ */
+function lcsPairs(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    // dp[i][j] = LCS length of oldLines[i:] and newLines[j:].
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    const eq = (a, b) => a.toLowerCase() === b.toLowerCase();
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            dp[i][j] = eq(oldLines[i], newLines[j])
+                ? dp[i + 1][j + 1] + 1
+                : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const pairs = [];
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (eq(oldLines[i], newLines[j])) {
+            pairs.push([i, j]);
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            i++;
+        }
+        else {
+            j++;
+        }
+    }
+    return pairs;
+}
+/** Align one file's hunks into rows (plain text + word flags; styling is a
+ *  render-time concern over the visible slice). */
+function alignFileDiff(fileIndex, oldText, newText) {
+    const rows = [];
+    const parts = JsDiff.diffLines(expandTabs(oldText ?? ''), expandTabs(newText));
+    let oldIndex = 0;
+    let newIndex = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const lines = part.value.replace(/\n$/, '').split('\n');
+        if (!part.added && !part.removed) {
+            for (const line of lines) {
+                rows.push({
+                    kind: 'context',
+                    fileIndex,
+                    oldIndex: oldIndex++,
+                    newIndex: newIndex++,
+                    oldWords: plainSegments(line),
+                    newWords: plainSegments(line),
+                });
+            }
+            continue;
+        }
+        if (part.removed) {
+            const addedPart = parts[i + 1]?.added === true ? parts[i + 1] : undefined;
+            const addedLines = addedPart === undefined ? [] : addedPart.value.replace(/\n$/, '').split('\n');
+            // Same-length replacement blocks zip index-for-index (the common
+            // edit case); unequal blocks pair through the ci-LCS so an inserted
+            // line cannot shift the alignment (issue #250, P2-4).
+            const pairs = lines.length === addedLines.length
+                ? lines.map((_, index) => [index, index])
+                : lcsPairs(lines, addedLines);
+            // Block order: walk both lists; unpaired entries emit in place, pairs
+            // emit at the later of the two positions.
+            const events = [];
+            let oi = 0;
+            let ai = 0;
+            for (const [o, a] of pairs) {
+                while (oi < o)
+                    events.push({ kind: 'del', o: oi++ });
+                while (ai < a)
+                    events.push({ kind: 'add', a: ai++ });
+                events.push({ kind: 'change', o: oi++, a: ai++ });
+            }
+            while (oi < lines.length)
+                events.push({ kind: 'del', o: oi++ });
+            while (ai < addedLines.length)
+                events.push({ kind: 'add', a: ai++ });
+            for (const event of events) {
+                if (event.kind === 'change') {
+                    const segments = wordSegments(lines[event.o], addedLines[event.a]);
+                    rows.push({
+                        kind: 'change',
+                        fileIndex,
+                        oldIndex: oldIndex++,
+                        newIndex: newIndex++,
+                        oldWords: segments.old,
+                        newWords: segments.new,
+                    });
+                }
+                else if (event.kind === 'del') {
+                    rows.push({ kind: 'del', fileIndex, oldIndex: oldIndex++, oldWords: plainSegments(lines[event.o]) });
+                }
+                else {
+                    rows.push({ kind: 'add', fileIndex, newIndex: newIndex++, newWords: plainSegments(addedLines[event.a]) });
+                }
+            }
+            if (addedPart !== undefined)
+                i++;
+            continue;
+        }
+        for (const line of lines) {
+            rows.push({ kind: 'add', fileIndex, newIndex: newIndex++, newWords: plainSegments(line) });
+        }
+    }
+    return rows;
+}
+// --- rendering --------------------------------------------------------------
+function PaneLine({ side, kind, width, tone, toolBackground, padLeft = false, }) {
+    const ordinaryBackground = toolBackground === 'subtle'
+        ? 'toolCardBackgroundDim'
+        : toolBackground === 'strong'
+            ? 'toolCardBackground'
+            : undefined;
+    // Additions/removals keep their semantic tint; unchanged and empty panes
+    // inherit the configured ordinary tool-card surface.
+    const backgroundColor = kind === 'context'
+        ? ordinaryBackground
+        : tone === 'old'
+            ? 'diffRemovedDimmed'
+            : 'diffAddedDimmed';
+    const wordColor = tone === 'old' ? 'diffRemovedWord' : 'diffAddedWord';
+    // Status gutter instead of line numbers: ToolFileDiff has no file
+    // offsets, and an invented number misleads (issue #250, P2-3).
+    const marker = kind === 'context' ? ' ' : tone === 'old' ? '−' : '+';
+    const prefix = padLeft ? ` ${marker}` : marker;
+    return (_jsxs(Box, { width: width, flexShrink: 0, backgroundColor: backgroundColor, children: [_jsx(Text, { dimColor: true, backgroundColor: backgroundColor, children: `${prefix} ` }), side === undefined ? (_jsx(Text, { backgroundColor: backgroundColor, children: " " })) : (_jsx(Text, { wrap: "truncate", backgroundColor: backgroundColor, children: side.segments.map((segment, index) => segment.changed ? (_jsx(Text, { color: wordColor, bold: true, backgroundColor: backgroundColor, children: segment.text }, index)) : (_jsx(Text, { color: segment.color, backgroundColor: backgroundColor, children: segment.text }, index))) }))] }));
+}
+export function SplitDiffView({ diffs, width, maxRows, verbose, toolBackground = 'none', reveal, }) {
+    const [hl, setHl] = React.useState(null);
+    React.useEffect(() => {
+        let mounted = true;
+        void getCliHighlightPromise().then(loaded => {
+            if (mounted)
+                setHl(loaded);
+        });
+        return () => { mounted = false; };
+    }, []);
+    const [themeName] = useTheme();
+    // Resolved-palette signature: covers dark→light, light→dark, AND the
+    // `auto` base flip where the name never changes (issue #250, P1-2).
+    const syntaxTheme = React.useMemo(() => getTheme(themeName), [themeName]);
+    const themeSig = React.useMemo(() => syntaxThemeSignature(syntaxTheme), [syntaxTheme]);
+    // Alignment is text-only and capped BEFORE styling: the highlighter and
+    // word-diff work lands only on the visible slice (issue #250, P2-8).
+    const rows = [];
+    let prevPath;
+    diffs.forEach((diff, fileIndex) => {
+        if (diffs.length > 1) {
+            if (diff.path !== prevPath)
+                rows.push({ separator: diff.path });
+            else
+                rows.push({ separator: '⋯' });
+        }
+        prevPath = diff.path;
+        rows.push(...alignFileDiff(fileIndex, diff.oldText, diff.newText));
+    });
+    const totalRows = rows.length;
+    const capped = verbose || totalRows <= maxRows || totalRows - maxRows === 1;
+    const visible = capped ? rows : rows.slice(0, maxRows);
+    const hidden = totalRows - visible.length;
+    // Smooth reveal reads happen during render (the owning card subscribes to
+    // the scheduler's version, so its re-render drives this view too).
+    const revealedRows = reveal !== undefined
+        ? revealLinesOf(reveal.key, visible.length, { enabled: true, active: true })
+        : visible.length;
+    const shown = revealedRows >= visible.length ? visible : visible.slice(0, revealedRows);
+    const paneWidth = Math.max(20, Math.floor((width - 1) / 2));
+    // Whole-hunk highlight per file (multi-line lexer state preserved);
+    // only the visible rows merge syntax runs with word flags below.
+    const fileSyntax = diffs.map(diff => {
+        const language = extname(diff.path).replace(/^\./, '') || undefined;
+        return {
+            old: highlightLines(expandTabs(diff.oldText ?? ''), language, hl, syntaxTheme, themeSig),
+            next: highlightLines(expandTabs(diff.newText), language, hl, syntaxTheme, themeSig),
+        };
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: paneWidth * 2 + 1, children: [shown.map((row, index) => {
+                if ('separator' in row) {
+                    return (_jsx(Box, { width: paneWidth * 2 + 1, children: _jsx(Text, { dimColor: true, wrap: "truncate", children: row.separator === '⋯' ? '⋯' : `  ${row.separator}` }) }, index));
+                }
+                const syntax = fileSyntax[row.fileIndex];
+                const oldRuns = row.oldIndex !== undefined ? syntax?.old?.[row.oldIndex] : undefined;
+                const newRuns = row.newIndex !== undefined ? syntax?.next?.[row.newIndex] : undefined;
+                const oldSide = row.oldWords === undefined
+                    ? undefined
+                    : { segments: oldRuns !== undefined ? mergeRuns(oldRuns, row.oldWords) : row.oldWords };
+                const newSide = row.newWords === undefined
+                    ? undefined
+                    : { segments: newRuns !== undefined ? mergeRuns(newRuns, row.newWords) : row.newWords };
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsx(PaneLine, { side: oldSide, kind: row.kind === 'add' ? 'context' : row.kind, tone: "old", width: paneWidth, toolBackground: toolBackground }), _jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: "\u2502" }) }), _jsx(PaneLine, { side: newSide, kind: row.kind === 'del' ? 'context' : row.kind, tone: "new", width: paneWidth, toolBackground: toolBackground, padLeft: true })] }, index));
+            }), hidden > 0 && (_jsx(Text, { dimColor: true, children: t('lines-folded-expand', { n: hidden }) }))] }));
+}

package/lib/types/components/StreamingMarkdown.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function StreamingMarkdown({ children, dimColor, }: {
+    children: string;
+    dimColor?: boolean;
+}): React.ReactNode;
+//# sourceMappingURL=StreamingMarkdown.d.ts.map

package/lib/types/components/StreamingMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingMarkdown.d.ts","sourceRoot":"","sources":["../../../src/components/StreamingMarkdown.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAuMzB,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,QAAgB,GACjB,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GAAG,KAAK,CAAC,SAAS,CAyIlB"}

package/lib/types/components/StreamingMarkdown.js

@@ -0,0 +1,279 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { marked } from 'marked';
+import Box from '../ink/components/Box.js';
+import { formatToken, stripPromptXMLTags } from '../terminal-utils/markdown.js';
+import { t } from '../i18n.js';
+import { isStandaloneToken, Markdown } from './Markdown.js';
+/**
+ * Renders streaming markdown in sealed groups of completed top-level blocks.
+ * Only the unsealed group and growing final block change as text arrives.
+ * marked.lexer() keeps unclosed fences inside one token, and the boundary
+ * analysis below preserves the whole-document formatter's row spacing.
+ */
+/**
+ * Tail budget for the unstable suffix during streaming. The sticky view only
+ * ever shows the last viewport of rows, but the suffix Text is re-wrapped
+ * every frame — an unbounded suffix (a single huge paragraph with no block
+ * boundary to advance the prefix) made that O(total) per frame. The suffix
+ * is clipped to this many characters (preferring a paragraph boundary),
+ * with a leading marker naming the dropped amount; settling renders the
+ * full text once through the non-streaming path.
+ *
+ * The cut point is STICKY (advances only when the suffix outgrows budget +
+ * step): a cut that slid every frame would break append-only growth, and
+ * the layout layer's incremental wrap would fall back to a full re-wrap of
+ * the whole tail on every token.
+ */
+const SUFFIX_TAIL_BUDGET = 3584;
+const SUFFIX_BOUNDARY_LOOKBACK = 2048;
+const SUFFIX_CUT_STEP = 1024;
+const STABLE_BLOCK_BUDGET = 8192;
+function clipSuffixTail(suffix, cut) {
+    const total = suffix.length;
+    if (total <= SUFFIX_TAIL_BUDGET) {
+        cut.current = 0;
+        return suffix;
+    }
+    // Advance the sticky cut only once the suffix outgrew the budget by a
+    // full step, preferring a paragraph boundary inside the lookback window.
+    if (total - cut.current > SUFFIX_TAIL_BUDGET + SUFFIX_CUT_STEP) {
+        const windowStart = total - SUFFIX_TAIL_BUDGET;
+        const boundary = suffix.lastIndexOf('\n\n', windowStart + SUFFIX_BOUNDARY_LOOKBACK);
+        cut.current = boundary !== -1 && boundary >= windowStart - SUFFIX_BOUNDARY_LOOKBACK
+            ? boundary + 2
+            : windowStart;
+    }
+    const dropped = cut.current;
+    return `${t('streaming-folded', { count: dropped })}\n\n${suffix.slice(cut.current)}`;
+}
+const UNSAFE_BOUNDARY = {
+    safe: false,
+    gap: 0,
+    endsWithNode: false,
+    trailingEmptyTextNode: false,
+};
+/**
+ * Token types whose formatted output is provably blank, taken from
+ * the markdown dispatcher's table: `space`/`br` emit a single newline,
+ * `def`/`del`/`html` emit nothing. Kept in step with `analyzeSuffixStart`,
+ * which splits the same set into "newline" and "empty" halves.
+ */
+function isBlankTokenType(type) {
+    return type === 'space' || type === 'br' || type === 'def' || type === 'del' || type === 'html';
+}
+/** Newlines contributed by a blank token: one for `space`/`br`, none otherwise. */
+function blankTokenNewlines(type) {
+    return type === 'space' || type === 'br' ? 1 : 0;
+}
+/**
+ * Analyze the candidate stable tokens using the same formatter as Markdown.
+ * Both split halves trim their outer whitespace, so the trailing newline count
+ * determines the Yoga gap: one newline merely starts the next row; every
+ * additional newline is one genuinely blank row. Standalone nodes are
+ * separate layout nodes and therefore keep Markdown's fixed one-row node gap.
+ *
+ * Only the LAST token that can produce visible text decides the outcome, so
+ * the region is walked backwards and formatted one token at a time instead of
+ * concatenating (and syntax-highlighting) every settled block on each new
+ * boundary. `formatToken` runs once for the common case.
+ */
+function analyzeStableBoundary(tokens, suffixIndex) {
+    // A standalone node resets the accumulated text, so only the segment after
+    // the last one matters; anything before it is already folded into the node branch.
+    let segmentStart = 0;
+    let hasNode = false;
+    for (let i = suffixIndex - 1; i >= 0; i--) {
+        if (isStandaloneToken(tokens[i])) {
+            segmentStart = i + 1;
+            hasNode = true;
+            break;
+        }
+    }
+    // Skip the trailing run of blank tokens, banking their newlines: they sit
+    // after the last visible text and therefore only extend its newline run.
+    let blankNewlines = 0;
+    let cursor = suffixIndex - 1;
+    while (cursor >= segmentStart && isBlankTokenType(tokens[cursor].type)) {
+        blankNewlines += blankTokenNewlines(tokens[cursor].type);
+        cursor--;
+    }
+    // Format backwards until a token actually produces visible text. A token
+    // that formats to blank is folded into the newline run and skipped over.
+    for (let i = cursor; i >= segmentStart; i--) {
+        const token = tokens[i];
+        const ansiText = formatToken(token);
+        if (ansiText.trim() === '') {
+            blankNewlines += ansiText.match(/\n+$/)?.[0].length ?? 0;
+            continue;
+        }
+        const trailingNewlines = (ansiText.match(/\n+$/)?.[0].length ?? 0) + blankNewlines;
+        // A zero-newline boundary (notably `hr` followed immediately by prose)
+        // belongs in one Markdown component; separate column children would force
+        // a line break that the whole-document formatter does not contain.
+        if (trailingNewlines === 0)
+            return UNSAFE_BOUNDARY;
+        return {
+            safe: true,
+            gap: Math.max(0, trailingNewlines - 1),
+            endsWithNode: false,
+            trailingEmptyTextNode: false,
+        };
+    }
+    if (hasNode) {
+        return {
+            safe: true,
+            gap: 1,
+            endsWithNode: true,
+            // Whitespace after the node still occupies a zero-height text node
+            // between two standalone nodes.
+            trailingEmptyTextNode: blankNewlines > 0,
+        };
+    }
+    // Definitions/raw HTML alone render nothing; advancing them buys no stable
+    // work and can lose whitespace that belongs to the next visible block.
+    return UNSAFE_BOUNDARY;
+}
+/** Find the first visible suffix node without formatting the growing token.
+ * Whitespace around invisible definitions/HTML is internal in a whole render
+ * but gets trimmed at the start of the split suffix, so count it into the
+ * boundary gap explicitly. */
+function analyzeSuffixStart(tokens, startIndex) {
+    let leadingNewlines = 0;
+    for (let i = startIndex; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token === undefined)
+            break;
+        if (isStandaloneToken(token))
+            return { kind: 'node', leadingNewlines };
+        if (token.type === 'space' || token.type === 'br') {
+            leadingNewlines += 1;
+            continue;
+        }
+        if (token.type === 'def' || token.type === 'del' || token.type === 'html')
+            continue;
+        return { kind: 'text', leadingNewlines };
+    }
+    return { kind: undefined, leadingNewlines };
+}
+function gapBetween(boundary, start) {
+    if (start.kind === undefined)
+        return 0;
+    if (boundary.endsWithNode) {
+        return start.kind === 'node' && (boundary.trailingEmptyTextNode || start.leadingNewlines > 0) ? 2 : 1;
+    }
+    return start.kind === 'node' ? 1 : boundary.gap + start.leadingNewlines;
+}
+export function StreamingMarkdown({ children, dimColor = false, }) {
+    // The prefix tracks source offsets; its rendered blocks are sealed once
+    // so an advancing boundary never reparses the entire accumulated answer.
+    const prefixRef = React.useRef('');
+    const blocksRef = React.useRef({
+        blocks: [], end: 0, tokens: [], tail: '', tailGap: 0,
+        boundary: undefined, definitions: false,
+    });
+    const cutRef = React.useRef(0);
+    const boundaryGapRef = React.useRef(0);
+    const prefixVisibleRef = React.useRef(false);
+    const prefixEndsWithNodeRef = React.useRef(false);
+    const prefixTrailingEmptyTextRef = React.useRef(false);
+    const stripped = stripPromptXMLTags(children);
+    // Reset if text was replaced (defensive; normally unmount handles this)
+    if (!stripped.startsWith(prefixRef.current)) {
+        prefixRef.current = '';
+        cutRef.current = 0;
+        boundaryGapRef.current = 0;
+        prefixVisibleRef.current = false;
+        prefixEndsWithNodeRef.current = false;
+        prefixTrailingEmptyTextRef.current = false;
+        blocksRef.current = {
+            blocks: [], end: 0, tokens: [], tail: '', tailGap: 0,
+            boundary: undefined, definitions: false,
+        };
+    }
+    // Lex only from current boundary — O(unstable length), not O(full text)
+    const boundary = prefixRef.current.length;
+    const tokens = marked.lexer(stripped.substring(boundary));
+    const blocks = blocksRef.current;
+    // Reference definitions have document-wide scope, including references
+    // in the growing suffix. These documents cannot use independent parsers.
+    if (!blocks.definitions && Object.keys(tokens.links).length > 0) {
+        blocks.definitions = true;
+        blocks.blocks = [];
+        blocks.tokens = [];
+        blocks.end = 0;
+        blocks.boundary = undefined;
+    }
+    // Last non-space token is the growing block; everything before is final
+    let lastContentIdx = tokens.length - 1;
+    while (lastContentIdx >= 0 && tokens[lastContentIdx].type === 'space') {
+        lastContentIdx--;
+    }
+    let advance = 0;
+    for (let i = 0; i < lastContentIdx; i++) {
+        advance += tokens[i].raw.length;
+    }
+    let suffixTokenIndex = 0;
+    if (advance > 0) {
+        const stableBoundary = analyzeStableBoundary(tokens, lastContentIdx);
+        if (stableBoundary.safe) {
+            if (!blocks.definitions) {
+                let end = boundary;
+                for (let index = 0; index < lastContentIdx; index++) {
+                    const token = tokens[index];
+                    blocks.tokens.push(token);
+                    end += token.raw.length;
+                    if (end - blocks.end < STABLE_BLOCK_BUDGET)
+                        continue;
+                    const blockBoundary = analyzeStableBoundary(blocks.tokens, blocks.tokens.length);
+                    if (!blockBoundary.safe)
+                        continue;
+                    const gap = blocks.boundary === undefined ? 0 : gapBetween(blocks.boundary, analyzeSuffixStart(blocks.tokens, 0));
+                    // Detach the sealed slice from the growing source buffer, preserving
+                    // UTF-16 code units rather than pinning every historical full reply.
+                    const text = Buffer.from(stripped.substring(blocks.end, end), 'utf16le').toString('utf16le');
+                    blocks.blocks.push({ text, gap });
+                    blocks.end = end;
+                    blocks.boundary = blockBoundary;
+                    blocks.tokens = [];
+                }
+                blocks.tail = stripped.substring(blocks.end, boundary + advance);
+                blocks.tailGap = blocks.boundary === undefined ? 0 : gapBetween(blocks.boundary, analyzeSuffixStart(blocks.tokens, 0));
+            }
+            prefixRef.current = stripped.substring(0, boundary + advance);
+            boundaryGapRef.current = stableBoundary.gap;
+            prefixVisibleRef.current = true;
+            prefixEndsWithNodeRef.current = stableBoundary.endsWithNode;
+            prefixTrailingEmptyTextRef.current = stableBoundary.trailingEmptyTextNode;
+            suffixTokenIndex = lastContentIdx;
+        }
+    }
+    if (blocks.definitions) {
+        return _jsx(Markdown, { dimColor: dimColor, cacheTokens: false, children: stripped });
+    }
+    const stablePrefix = prefixRef.current;
+    const prefixTail = blocks.tail;
+    const suffixSource = stripped.substring(stablePrefix.length);
+    const unstableSuffix = clipSuffixTail(suffixSource, cutRef);
+    const suffixStart = cutRef.current > 0
+        ? { kind: 'text', leadingNewlines: 0 }
+        : analyzeSuffixStart(tokens, suffixTokenIndex);
+    const boundaryGap = prefixVisibleRef.current && suffixStart.kind !== undefined
+        ? prefixEndsWithNodeRef.current
+            ? suffixStart.kind === 'node' &&
+                (prefixTrailingEmptyTextRef.current || suffixStart.leadingNewlines > 0)
+                ? 2
+                : 1
+            : suffixStart.kind === 'node'
+                ? 1
+                : boundaryGapRef.current + suffixStart.leadingNewlines
+        : 0;
+    // A lexer boundary must be strictly outside the stable prefix. If marked
+    // reports a raw span that ends at the current cursor (possible around an
+    // unfinished fence/table while deltas arrive), rendering both branches can
+    // paint the same tail twice. Keep the suffix authoritative and never render
+    // an overlapping empty/duplicate boundary.
+    const hasDistinctSuffix = unstableSuffix !== '' &&
+        (stablePrefix === '' || !unstableSuffix.startsWith(stablePrefix));
+    return (_jsxs(Box, { flexDirection: "column", children: [blocks.blocks.map((block, index) => (_jsx(Box, { flexDirection: "column", marginTop: block.gap, children: _jsx(Markdown, { dimColor: dimColor, children: block.text }) }, index))), prefixTail && (_jsx(Box, { flexDirection: "column", marginTop: blocks.tailGap, children: _jsx(Markdown, { dimColor: dimColor, children: prefixTail }) }, "prefix")), hasDistinctSuffix && (_jsx(Box, { flexDirection: "column", marginTop: boundaryGap, children: _jsx(Markdown, { dimColor: dimColor, cacheTokens: false, children: unstableSuffix }) }, "suffix"))] }));
+}

package/lib/types/components/SubagentCard.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { SubagentState } from '../dsh-adapter/subagents.js';
+import type { ClickEvent } from '../ink/events/click-event.js';
+export interface SubagentCardProps {
+    subagent: SubagentState;
+    focused?: boolean;
+    onClick?(event: ClickEvent): void;
+}
+export declare function SubagentCard({ subagent, focused, onClick }: SubagentCardProps): React.ReactNode;
+//# sourceMappingURL=SubagentCard.d.ts.map

package/lib/types/components/SubagentCard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubagentCard.d.ts","sourceRoot":"","sources":["../../../src/components/SubagentCard.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAEvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAO9D,MAAM,WAAW,iBAAiB;IAAG,QAAQ,EAAE,aAAa,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE;AAEpH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAgD/F"}