deepclause-sdk 0.0.88 → 0.1.0

package/dist/repl/render.js

@@ -0,0 +1,715 @@
+/**
+ * Line-oriented REPL renderer.
+ *
+ * Three modes:
+ *  - `rich` (default on a TTY): coloured bindings and labels, no live rewriting.
+ *  - `plain` (default when stdout is not a TTY): one static line per event, no ANSI.
+ *  - `json`: one JSON object per event for tooling.
+ *
+ * This is the M1 surface (solutions, output, answer, errors). Live streaming
+ * of model text/tool calls is added in M3.
+ */
+import { formatListing } from './highlight.js';
+import { MarkdownStream } from './markdown.js';
+/** Activity events hidden by `--no-events` (output/answer/input/error stay). */
+const ACTIVITY_EVENTS = new Set([
+    'task_activity',
+    'tool_call',
+    'model_call',
+    'usage',
+    'log',
+    'memory_compaction',
+    'meta_result',
+]);
+function formatArgs(args) {
+    if (!args || Object.keys(args).length === 0) {
+        return '';
+    }
+    const parts = Object.entries(args).map(([key, value]) => {
+        const text = (typeof value === 'string' ? value : JSON.stringify(value)).replace(/\s+/g, ' ').trim();
+        const compact = text.length > 60 ? `${text.slice(0, 57)}…` : text;
+        return `${key}=${compact}`;
+    });
+    return `(${parts.join(', ')})`;
+}
+/** Max captured output lines previewed under a completed tool call. */
+const TOOL_OUTPUT_LINES = 3;
+/** Max physical lines of a single `output` event before it is collapsed. */
+const OUTPUT_LINES = 24;
+/**
+ * Bound a potentially huge `output` event (e.g. a `write/1` of a large term).
+ * Keeps the head and tail and collapses the middle; `--verbose` shows it whole.
+ */
+function boundOutput(text, max = OUTPUT_LINES) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    if (lines.length <= max) {
+        return lines;
+    }
+    const head = Math.ceil((max - 1) / 2);
+    const tail = max - 1 - head;
+    const omitted = lines.length - head - tail;
+    return [
+        ...lines.slice(0, head),
+        `… (+${omitted} more line${omitted === 1 ? '' : 's'})`,
+        ...lines.slice(lines.length - tail),
+    ];
+}
+/** Pull a few output lines from a tool result (bash stdout/stderr). */
+function extractToolOutput(result) {
+    if (!result || typeof result !== 'object')
+        return [];
+    const r = result;
+    const text = typeof r.stdout === 'string' && r.stdout.trim()
+        ? r.stdout
+        : (typeof r.stderr === 'string' ? r.stderr : '');
+    if (!text.trim())
+        return [];
+    return text
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => line.replace(/\t/g, '    ').trimEnd())
+        .filter((line) => line.trim() !== '');
+}
+/** Word-wrap a single line to `width`, hard-breaking tokens that are longer. */
+function wrapLine(text, width) {
+    if (width <= 0 || text.length <= width) {
+        return [text];
+    }
+    const out = [];
+    let remaining = text;
+    while (remaining.length > width) {
+        let breakAt = remaining.lastIndexOf(' ', width);
+        if (breakAt <= 0) {
+            breakAt = width; // no space: hard-break a long token (URL, path, flag)
+        }
+        out.push(remaining.slice(0, breakAt));
+        remaining = remaining.slice(breakAt).replace(/^ +/, '');
+    }
+    out.push(remaining);
+    return out;
+}
+function truncate(text, max) {
+    const singleLine = text.replace(/\s+/g, ' ').trim();
+    return singleLine.length > max ? `${singleLine.slice(0, max - 1)}…` : singleLine;
+}
+/** Human-readable wall-clock duration: `450ms`, `1.2s`, `2m05s`. */
+export function formatDuration(ms) {
+    if (!Number.isFinite(ms) || ms < 0) {
+        return '';
+    }
+    if (ms < 1000) {
+        return `${Math.round(ms)}ms`;
+    }
+    const seconds = ms / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainder = Math.round(seconds % 60);
+    return `${minutes}m${String(remainder).padStart(2, '0')}s`;
+}
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    cyan: '\u001b[36m',
+    green: '\u001b[32m',
+    red: '\u001b[31m',
+    /** Model reasoning: italic grey, like pi's thinking text. */
+    thinking: '\u001b[3;38;5;245m',
+    /** DML `output/1` intermediate results. */
+    output: '\u001b[38;5;150m',
+    /** The final `answer/1`. */
+    answer: '\u001b[1;38;5;118m',
+};
+/** True when the terminal advertises 24-bit colour (COLORTERM). */
+const TRUECOLOR = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? '');
+/**
+ * Tool-call panel: a subtle, near-transparent green tint behind activity
+ * (truecolor when available, else a 256-colour fallback). Kept light so it
+ * reads as a faint wash over the terminal background rather than a solid fill.
+ */
+const TOOL_PANEL_GREEN_BG = TRUECOLOR ? '\u001b[48;2;40;54;44m' : '\u001b[48;5;22m';
+/** Blue tint for `execute` (a goal, not a shell command). */
+const TOOL_PANEL_BLUE_BG = TRUECOLOR ? '\u001b[48;2;34;44;62m' : '\u001b[48;5;24m';
+const TOOL_PANEL_FG = '\u001b[38;5;252m';
+const TOOL_PANEL_ERROR_BG = TRUECOLOR ? '\u001b[48;2;58;36;36m' : '\u001b[48;5;52m';
+const TOOL_PANEL_ERROR_FG = '\u001b[38;5;224m';
+/**
+ * Tools whose main argument is a long literal worth showing in full (wrapped
+ * and indented under the header), with the panel colour for that tool.
+ */
+const TOOL_DETAIL = {
+    bash: { arg: 'command', tone: 'green' },
+    execute: { arg: 'goal', tone: 'blue' },
+};
+/** A copy of `args` without `key` (for the compact header of a detail tool). */
+function omitKey(args, key) {
+    if (!args)
+        return undefined;
+    const rest = {};
+    for (const [k, v] of Object.entries(args)) {
+        if (k !== key)
+            rest[k] = v;
+    }
+    return rest;
+}
+/** Spinner frames for the live model-call indicator. */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/** Strip ANSI SGR sequences (for measuring visible width). */
+function stripAnsi(text) {
+    return text.replace(/\u001b\[[0-9;]*m/g, '');
+}
+/** Format solution bindings as `Name = value` lines (or `true`). */
+export function formatBindings(bindings) {
+    if (bindings.length === 0) {
+        return 'true';
+    }
+    return bindings.map((binding) => `${binding.name} = ${binding.value}`).join('\n');
+}
+/** Max characters of reasoning shown in `summary` mode. */
+const REASONING_SUMMARY_CHARS = 600;
+export class ReplRenderer {
+    mode;
+    color;
+    verbose;
+    showStream;
+    showEvents;
+    reasoningMode;
+    markdownEnabled;
+    markdown = new MarkdownStream();
+    pendingTextEvent;
+    width;
+    sink;
+    errorSink;
+    eventSink;
+    /** Frame key of the currently open streamed-text region, or null. */
+    lastStreamFrame = null;
+    /** Reasoning region key and characters shown so far (for `summary` mode). */
+    reasoningRegion = '';
+    reasoningChars = 0;
+    reasoningTruncated = false;
+    atLineStart = true;
+    /** Last detail body printed for a running call (dedupes start/running). */
+    lastToolDetail;
+    /** Live model-call indicator state. */
+    spinnerTimer;
+    spinnerFrame = 0;
+    spinnerPrefix = '';
+    spinnerLabel = '';
+    spinnerVisible = false;
+    constructor(options = {}) {
+        this.mode = options.mode ?? 'plain';
+        this.color = (options.color ?? true) && this.mode === 'rich';
+        this.verbose = options.verbose ?? false;
+        this.showStream = options.stream ?? true;
+        this.showEvents = options.events ?? true;
+        this.reasoningMode = options.reasoning ?? 'full';
+        this.markdownEnabled = options.markdown ?? true;
+        this.width = options.width ?? (process.stdout.columns || 80);
+        this.sink = options.sink ?? ((text) => process.stdout.write(text));
+        this.errorSink = options.errorSink ?? ((text) => process.stderr.write(text));
+        this.eventSink = options.onEvent;
+    }
+    /** Replace the output sinks (used when moving into a TUI transcript). */
+    setSink(sink, errorSink) {
+        this.sink = sink;
+        if (errorSink)
+            this.errorSink = errorSink;
+    }
+    /** Update the rendering width (TUI resize). */
+    setWidth(width) {
+        if (width > 0)
+            this.width = width;
+    }
+    /** Clean up and syntax-highlight a Prolog listing for display. */
+    listing(text) {
+        return formatListing(text, { color: this.color && this.mode === 'rich' });
+    }
+    /**
+     * Suppress `input_required` prompt lines. The TUI editor shows the question in
+     * its border, so a transcript line would be a duplicate.
+     */
+    setSuppressInputPrompt(suppress) {
+        this.suppressInputPrompt = suppress;
+    }
+    /** Stop the live indicator (call before the renderer goes out of scope). */
+    dispose() {
+        this.stopSpinner();
+    }
+    /** Last rendered block group, used to separate tool/text/output blocks. */
+    currentBlock = null;
+    toolBlockCounter = 0;
+    currentToolBlock = null;
+    taskBlockCounter = 0;
+    currentTaskBlock = null;
+    /** When true, `input_required` events are rendered by the input UI instead. */
+    suppressInputPrompt = false;
+    /** Write a raw chunk to the normal sink. */
+    write(text) {
+        this.stopSpinner();
+        this.sink(text);
+    }
+    /** Write a line to the normal sink. */
+    writeLine(text = '') {
+        this.stopSpinner();
+        this.flushStream();
+        this.sink(`${text}\n`);
+        this.lastStreamFrame = null;
+        this.atLineStart = true;
+    }
+    /** Flush any buffered streamed text (e.g. an unterminated markdown line). */
+    flush() {
+        this.flushStream();
+    }
+    writeErrorLine(text) {
+        this.stopSpinner();
+        this.errorSink(`${text}\n`);
+    }
+    /**
+     * The visual block an event belongs to. Events in the same block are printed
+     * contiguously; switching blocks inserts one blank line. Returns null for
+     * events that do not participate (solutions, spinners, metadata).
+     */
+    blockKeyFor(event) {
+        switch (event.type) {
+            case 'stream':
+                return `text:${event.frameKind ?? 'run'}@${event.depth ?? 0}`;
+            case 'reasoning':
+                return event.content ? `reasoning:${event.frameKind ?? 'run'}@${event.depth ?? 0}` : null;
+            case 'tool_call': {
+                if (this.currentToolBlock === null || event.toolState === 'starting') {
+                    this.toolBlockCounter += 1;
+                    this.currentToolBlock = `tool:${this.toolBlockCounter}`;
+                }
+                return this.currentToolBlock;
+            }
+            case 'task_activity': {
+                if (this.currentTaskBlock === null || event.taskState === 'started') {
+                    this.taskBlockCounter += 1;
+                    this.currentTaskBlock = `task:${this.taskBlockCounter}`;
+                }
+                return this.currentTaskBlock;
+            }
+            case 'output':
+            case 'answer':
+            case 'error':
+                return 'output';
+            case 'memory_compaction':
+                return 'compaction';
+            default:
+                return null;
+        }
+    }
+    /** Insert a separating blank line when the block changes. */
+    beginBlock(key) {
+        if (!key)
+            return;
+        if (this.currentBlock !== null && this.currentBlock !== key) {
+            this.writeLine('');
+        }
+        this.currentBlock = key;
+    }
+    /** Render one runtime event. */
+    render(event) {
+        this.eventSink?.(event);
+        if (!this.showStream && (event.type === 'stream' || event.type === 'reasoning')) {
+            return;
+        }
+        if (!this.showEvents && ACTIVITY_EVENTS.has(event.type)) {
+            return;
+        }
+        if (this.mode === 'json') {
+            this.sink(`${JSON.stringify(event)}\n`);
+            return;
+        }
+        // The top-level prompt task and the meta frame simply echo work that is
+        // already shown by the user message and the streamed authoring text, and
+        // skipped compactions are noise. Hide them unless verbose; the status
+        // tracker still observes every event via `eventSink`.
+        if (event.type === 'task_activity'
+            && !event.frameKind) {
+            return;
+        }
+        if (event.type === 'memory_compaction' && event.compactionAction === 'skipped' && !this.verbose) {
+            return;
+        }
+        if (event.type !== 'stream' && event.type !== 'reasoning') {
+            this.stopSpinner();
+            this.flushStream();
+        }
+        this.beginBlock(this.blockKeyFor(event));
+        const prefix = this.frameLabel(event);
+        switch (event.type) {
+            case 'solution':
+                this.solution(event.solution?.bindings ?? [], undefined, prefix, 
+                // Nested (`execute` child) bindings often carry a whole result term;
+                // keep the transcript readable by truncating them.
+                event.frameKind === 'nested' ? 160 : undefined);
+                break;
+            case 'output': {
+                // A single event can carry a large multi-line term (`write/1` of an
+                // `exec(...)` result). Bound the line count, then fit each line to the
+                // terminal width so nothing wraps (which would desync the TUI). Nested
+                // activity is truncated to one line each; top-level output wraps.
+                const max = event.frameKind === 'nested' ? 6 : OUTPUT_LINES;
+                const bounded = this.verbose
+                    ? (event.content ?? '')
+                    : boundOutput(event.content ?? '', max).join('\n');
+                this.writeFrameText(prefix, bounded, ANSI.output, event.frameKind === 'nested');
+                break;
+            }
+            case 'answer':
+                this.writeFrameText(prefix, event.content ?? '', ANSI.answer, false);
+                break;
+            case 'model_call':
+                this.renderModelCall(event, prefix);
+                break;
+            case 'stream':
+                // Visible model text supersedes the working indicator.
+                this.stopSpinner();
+                this.writeStream(event, event.content ?? '', 'text');
+                break;
+            case 'reasoning':
+                if (event.content) {
+                    if (this.writeReasoning(event, event.content)) {
+                        this.stopSpinner();
+                    }
+                    else {
+                        // Reasoning is hidden (`off`) or truncated (`summary`): commit any
+                        // visible reasoning, then keep a spinner so the user still sees the
+                        // model working.
+                        this.flushStream();
+                        this.ensureThinkingSpinner(prefix);
+                    }
+                }
+                break;
+            case 'log':
+                if (this.verbose) {
+                    this.writeLine(this.paint(`${prefix}[log] ${event.content ?? ''}`, ANSI.dim));
+                }
+                break;
+            case 'task_activity':
+                this.renderTaskActivity(event, prefix);
+                break;
+            case 'tool_call':
+                this.renderToolCall(event, prefix);
+                break;
+            case 'input_required':
+                if (!this.suppressInputPrompt) {
+                    this.writeLine(this.paint(`${prefix}? ${event.prompt ?? ''}`, ANSI.bold));
+                }
+                break;
+            case 'error':
+                this.writeErrorLine(this.paint(`${prefix}ERROR: ${event.content ?? ''}`, ANSI.red));
+                break;
+            case 'usage':
+                if (this.verbose && event.usage) {
+                    this.writeLine(this.paint(`${prefix}[usage] in=${event.usage.inputTokens} out=${event.usage.outputTokens} total=${event.usage.totalTokens}`, ANSI.dim));
+                }
+                break;
+            case 'memory_compaction':
+                this.writeLine(this.paint(`${prefix}${event.content ?? 'memory compacted'}`, ANSI.dim));
+                break;
+            case 'finished':
+            case 'meta_result':
+            default:
+                break;
+        }
+    }
+    renderTaskActivity(event, prefix) {
+        const state = event.taskState ?? 'started';
+        if (state === 'started') {
+            this.writeLine(this.paint(`${prefix}▸ Task  ${this.describeTask(event)}`, ANSI.dim));
+            return;
+        }
+        const ok = state === 'completed';
+        this.writeLine(this.paint(`${prefix}${ok ? '✔' : '✖'} Task  ${ok ? 'done' : 'failed'}`, ok ? ANSI.dim : ANSI.red));
+    }
+    describeTask(event) {
+        const description = (event.taskDescription ?? '').replace(/\s+/g, ' ').trim();
+        if (!description)
+            return 'task';
+        return description.length > 72 ? `${description.slice(0, 69)}…` : description;
+    }
+    renderToolCall(event, prefix) {
+        const name = event.toolName ?? 'tool';
+        const state = event.toolState;
+        // Some tools have a long literal argument (a shell script, a DML goal) that
+        // is shown in full, wrapped and indented, rather than truncated inline.
+        const spec = TOOL_DETAIL[name];
+        const rawDetail = spec ? event.toolArgs?.[spec.arg] : undefined;
+        const detail = typeof rawDetail === 'string' ? rawDetail : undefined;
+        const tone = spec?.tone ?? 'green';
+        const args = detail === undefined ? formatArgs(event.toolArgs) : '';
+        if (state === 'completed') {
+            const duration = typeof event.toolDurationMs === 'number' ? ` · ${formatDuration(event.toolDurationMs)}` : '';
+            const summary = event.toolSummary ? ` — ${truncate(event.toolSummary, 80)}` : '';
+            this.lastToolDetail = undefined;
+            this.writeLine(this.toolPanel(`${prefix}  ✔ ${name}${args}${duration}${summary}`, tone));
+            // A short tail of the captured output (bash). Full output is --verbose.
+            if (!this.verbose) {
+                for (const line of this.toolOutputLines(prefix, tone, event.toolResult)) {
+                    this.writeLine(line);
+                }
+            }
+            return;
+        }
+        if (state === 'failed') {
+            const duration = typeof event.toolDurationMs === 'number' ? ` · ${formatDuration(event.toolDurationMs)}` : '';
+            const reason = event.toolError ?? event.toolSummary ?? 'failed';
+            this.lastToolDetail = undefined;
+            this.writeLine(this.toolPanel(`${prefix}  ✖ ${name}${args}${duration} — ${truncate(reason, 120)}`, 'error'));
+            return;
+        }
+        if (detail !== undefined) {
+            // A call emits `starting` then `running`; print the body once.
+            if (detail !== this.lastToolDetail) {
+                this.lastToolDetail = detail;
+                const others = formatArgs(omitKey(event.toolArgs, spec.arg));
+                this.writeLine(this.toolPanel(`${prefix}  ⚙ ${name}${others}`, tone));
+                // Print the body on panel lines, word-wrapped to the available width
+                // and indented under the header so wrapped bodies stay aligned.
+                const indent = '    ';
+                const avail = Math.max(20, this.width - stripAnsi(prefix).length - indent.length);
+                for (const rawLine of detail.replace(/\r\n?/g, '\n').split('\n')) {
+                    for (const segment of wrapLine(rawLine, avail)) {
+                        this.writeLine(this.toolPanel(`${prefix}${indent}${segment}`, tone));
+                    }
+                }
+            }
+            return;
+        }
+        this.writeLine(this.toolPanel(`${prefix}  ⚙ ${name}${args}`, tone));
+    }
+    /** Up to TOOL_OUTPUT_LINES captured output lines, as tinted panel lines. */
+    toolOutputLines(prefix, tone, result) {
+        const lines = extractToolOutput(result);
+        if (lines.length === 0) {
+            return [];
+        }
+        const indent = '    ';
+        const avail = Math.max(20, this.width - stripAnsi(prefix).length - indent.length);
+        const shown = lines.slice(-TOOL_OUTPUT_LINES);
+        const omitted = lines.length - shown.length;
+        const out = [];
+        if (omitted > 0) {
+            out.push(this.toolPanel(`${prefix}${indent}… (+${omitted} more line${omitted === 1 ? '' : 's'})`, tone));
+        }
+        for (const line of shown) {
+            out.push(this.toolPanel(`${prefix}${indent}${line.length > avail ? `${line.slice(0, avail - 1)}…` : line}`, tone));
+        }
+        return out;
+    }
+    /** Show/hide the live model-call indicator. */
+    renderModelCall(event, prefix) {
+        if (event.modelCallState === 'started') {
+            this.startSpinner(prefix, 'working…');
+            return;
+        }
+        this.stopSpinner();
+    }
+    /** Start a `\r`-based spinner on the current line (rich TTY only). */
+    startSpinner(prefix, label) {
+        if (!this.color || this.mode !== 'rich') {
+            return;
+        }
+        this.stopSpinner();
+        this.spinnerPrefix = prefix;
+        this.spinnerLabel = label;
+        this.spinnerFrame = 0;
+        this.paintSpinner();
+        this.spinnerTimer = setInterval(() => {
+            this.spinnerFrame += 1;
+            this.paintSpinner();
+        }, 90);
+    }
+    paintSpinner() {
+        const frame = SPINNER_FRAMES[this.spinnerFrame % SPINNER_FRAMES.length];
+        this.sink(`\r\u001b[K${this.spinnerPrefix}${this.paint(`${frame} ${this.spinnerLabel}`, ANSI.dim)}`);
+        this.spinnerVisible = true;
+    }
+    /** Clear the spinner line and stop its timer (no-op when inactive). */
+    stopSpinner() {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = undefined;
+        }
+        if (this.spinnerVisible) {
+            this.sink('\r\u001b[K');
+            this.spinnerVisible = false;
+        }
+    }
+    /**
+     * A full-width, tinted line for tool activity (pi-style panel). Falls back to
+     * the bare text when colour is disabled. Existing ANSI in `text` is preserved
+     * and the visible width (ignoring SGR) is padded out to the terminal width.
+     */
+    toolPanel(text, tone) {
+        if (!this.color) {
+            return text;
+        }
+        const bg = tone === 'error'
+            ? TOOL_PANEL_ERROR_BG
+            : tone === 'blue'
+                ? TOOL_PANEL_BLUE_BG
+                : TOOL_PANEL_GREEN_BG;
+        const fg = tone === 'error' ? TOOL_PANEL_ERROR_FG : TOOL_PANEL_FG;
+        const width = this.width - stripAnsi(text).length;
+        const pad = width > 0 ? ' '.repeat(width) : '';
+        return `${bg}${fg}${text}${pad}${ANSI.reset}`;
+    }
+    /**
+     * Write `text` as frame-prefixed lines that each fit the terminal width:
+     * wrap by default, or truncate each physical line (nested activity).
+     */
+    writeFrameText(prefix, text, code, truncate) {
+        const avail = Math.max(20, this.width - stripAnsi(prefix).length);
+        const normalized = text.replace(/\r\n?/g, '\n').replace(/\t/g, '    ');
+        for (const rawLine of normalized.split('\n')) {
+            const segments = truncate
+                ? [rawLine.length > avail ? `${rawLine.slice(0, avail - 1)}…` : rawLine]
+                : wrapLine(rawLine, avail);
+            for (const segment of segments) {
+                this.writeLine(`${prefix}${this.paint(segment, code)}`);
+            }
+        }
+    }
+    /**
+     * Stream reasoning according to `showReasoning`: `off` hides it, `summary`
+     * shows a bounded preview, `full` shows everything (all dimmed).
+     */
+    /**
+     * Stream reasoning according to `showReasoning`: `off` hides it, `summary`
+     * shows a bounded preview, `full` shows everything (all dimmed). Returns
+     * whether anything was made visible (so the caller can keep a spinner when it
+     * is hidden).
+     */
+    writeReasoning(event, chunk) {
+        if (this.reasoningMode === 'off') {
+            return false;
+        }
+        const region = `${event.frameKind ?? 'plain'}@${event.depth ?? 0}`;
+        if (region !== this.reasoningRegion) {
+            this.reasoningRegion = region;
+            this.reasoningChars = 0;
+            this.reasoningTruncated = false;
+        }
+        const limit = this.reasoningMode === 'summary' ? REASONING_SUMMARY_CHARS : Infinity;
+        if (this.reasoningChars >= limit) {
+            this.announceReasoningTruncated(event);
+            return false;
+        }
+        const remaining = limit - this.reasoningChars;
+        const text = chunk.length > remaining ? chunk.slice(0, remaining) : chunk;
+        this.reasoningChars += text.length;
+        this.writeStream(event, this.paint(text, ANSI.thinking), 'reasoning');
+        if (this.reasoningChars >= limit) {
+            this.announceReasoningTruncated(event);
+        }
+        return text.length > 0;
+    }
+    /** Keep a `thinking…` spinner running (restart once if the label differs). */
+    ensureThinkingSpinner(prefix) {
+        if (this.spinnerTimer && this.spinnerLabel === 'thinking…') {
+            return;
+        }
+        this.startSpinner(prefix, 'thinking…');
+    }
+    announceReasoningTruncated(event) {
+        if (this.reasoningTruncated) {
+            return;
+        }
+        this.reasoningTruncated = true;
+        this.writeStream(event, this.paint(' … (reasoning truncated; set showReasoning=full to see it all)', ANSI.dim), 'reasoning');
+    }
+    /** Write a streamed chunk, prefixing it with its frame label on first use. */
+    writeStream(event, chunk, kind) {
+        if (kind === 'text' && this.markdownEnabled) {
+            this.pendingTextEvent = event;
+            for (const line of this.markdown.push(chunk)) {
+                this.writeStreamChunk(event, `${line}\n`, kind);
+            }
+            return;
+        }
+        this.writeStreamChunk(event, chunk, kind);
+    }
+    writeStreamChunk(event, chunk, kind) {
+        // Include the kind so switching reasoning <-> text starts a fresh region.
+        const key = `${event.frameKind ?? 'plain'}@${event.depth ?? 0}:${kind}`;
+        if (key !== this.lastStreamFrame) {
+            if (!this.atLineStart) {
+                this.sink('\n');
+            }
+            const prefix = this.frameLabel(event);
+            if (prefix)
+                this.sink(prefix);
+            this.lastStreamFrame = key;
+            this.atLineStart = false;
+        }
+        this.sink(chunk);
+        this.atLineStart = chunk.endsWith('\n');
+    }
+    /** Close an open streamed-text region before writing a line. */
+    flushStream() {
+        if (this.markdownEnabled && this.pendingTextEvent) {
+            const event = this.pendingTextEvent;
+            this.pendingTextEvent = undefined;
+            for (const line of this.markdown.flush()) {
+                this.writeStreamChunk(event, `${line}\n`, 'text');
+            }
+        }
+        if (this.lastStreamFrame !== null) {
+            if (!this.atLineStart)
+                this.sink('\n');
+            this.lastStreamFrame = null;
+            this.atLineStart = true;
+        }
+    }
+    /** `run │ ` for an object frame; nested (`execute` child) events use indentation + `│`. */
+    frameLabel(event) {
+        // `--no-events` also drops the frame label, so output/answer lines are plain.
+        if (!this.showEvents || !event.frameKind)
+            return '';
+        const depth = event.depth ?? 0;
+        // Nested (`execute` child) activity reads as belonging to the parent tool
+        // call through indentation plus a hanging `│`, with no `nested` label.
+        if (event.frameKind === 'nested') {
+            return `${'  '.repeat(depth + 1)}│ `;
+        }
+        const label = event.frameKind === 'object' ? 'run' : event.frameKind;
+        const indent = '  '.repeat(depth);
+        return `${indent}${label} │ `;
+    }
+    /**
+     * Render one solution's bindings. `terminator` is appended after the last
+     * binding line ('.' for the final answer, ' ' while more may follow).
+     */
+    solution(bindings, terminator, prefix = '', maxValue) {
+        if (this.mode === 'json') {
+            this.sink(`${JSON.stringify({ type: 'solution', solution: { bindings, deterministic: false } })}\n`);
+            return;
+        }
+        this.flushStream();
+        if (bindings.length === 0) {
+            this.writeLine(`${prefix}true${terminator ?? '.'}`);
+            return;
+        }
+        const lines = bindings.map((binding) => {
+            const value = maxValue !== undefined ? truncate(binding.value, maxValue) : binding.value;
+            const name = this.paint(binding.name, ANSI.cyan);
+            return `${prefix}${name} = ${value}`;
+        });
+        const last = lines.length - 1;
+        lines.forEach((line, index) => {
+            this.writeLine(index === last ? `${line}${terminator ?? '.'}` : line);
+        });
+    }
+    paint(text, code) {
+        if (!this.color) {
+            return text;
+        }
+        return `${code}${text}${ANSI.reset}`;
+    }
+}
+//# sourceMappingURL=render.js.map