@cspeach/cli 0.6.0

package/dist/renderer/question-normalizer.js

@@ -0,0 +1,306 @@
+/**
+ * Streaming-safe question-widget normalizer.
+ *
+ * LLMs emit the `cspeach-widget:question` payload inconsistently — sometimes
+ * with the proper code fence, sometimes as an indented code block, sometimes
+ * bare JSON with no sentinel and no fence at all (the streaming path often
+ * strips markers unpredictably). The widget extractor only matches the
+ * canonical fenced form, so everything else falls through and renders as raw
+ * JSON to the user — ugly and confusing.
+ *
+ * This normalizer runs before the widget extractor and aggressively
+ * rewrites anything that looks like a question-widget payload into clean
+ * markdown prose. Two detection modes:
+ *
+ *   1. SENTINEL MODE — `<!-- widget-real -->` followed by a balanced JSON
+ *      object. The canonical path; also handles most fenced-but-mangled
+ *      outputs because the sentinel survives even when the fence doesn't.
+ *
+ *   2. BARE-JSON MODE — any balanced JSON object containing `"question":`
+ *      AND `"kind":"choice|multi|text"`. Catches the streaming edge case
+ *      where the sentinel got stripped upstream (markdown renderer,
+ *      streaming chunk boundary, etc). Safe because the payload shape is
+ *      specific enough that we won't chew on unrelated JSON.
+ *
+ * Non-question widgets (dep-graph, bar-chart, stack-frames, diff-viewer)
+ * are left alone in both modes — their payloads don't have both `question`
+ * and `kind:choice|multi|text`.
+ */
+const SENTINEL = '<!-- widget-real -->';
+const QUESTION_KEY = '"question"';
+/**
+ * Find the start of a balanced JSON object at or after `from`. Returns the
+ * index of the opening `{` and the index ONE PAST the matching closing `}`.
+ * Returns null if no complete JSON object is found.
+ */
+function findBalancedJson(text, from) {
+    const start = text.indexOf('{', from);
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+        const c = text[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (inString) {
+            if (c === '\\')
+                escape = true;
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            continue;
+        }
+        if (c === '{')
+            depth++;
+        else if (c === '}') {
+            depth--;
+            if (depth === 0)
+                return { start, end: i + 1 };
+        }
+    }
+    return null;
+}
+/**
+ * Walk backward from the `{` at `jsonStart` to find the enclosing block
+ * start. Pulls back over a ```cspeach-widget... fence line, over a
+ * `<!-- widget-real -->` sentinel line, and over any whitespace-only lines.
+ * Returns the offset where the block begins in `text`.
+ */
+function findBlockStart(text, jsonStart) {
+    let pos = jsonStart;
+    // Walk backward over preceding lines that are empty, the sentinel, or
+    // a fence-open marker. Stop on any line that has other content.
+    while (pos > 0) {
+        const prevNewline = text.lastIndexOf('\n', pos - 1);
+        const lineStart = prevNewline === -1 ? 0 : prevNewline + 1;
+        const line = text.slice(lineStart, pos).trim();
+        if (line === '' ||
+            line === SENTINEL ||
+            /^```(?:cspeach-widget:\S+)?$/.test(line) ||
+            /^````(?:cspeach-widget:\S+)?$/.test(line)) {
+            pos = lineStart;
+            if (prevNewline === -1)
+                break;
+        }
+        else {
+            break;
+        }
+    }
+    return pos;
+}
+/**
+ * Walk forward from `jsonEnd` (one past the closing `}`) to include a
+ * trailing close-fence line if present.
+ */
+function findBlockEnd(text, jsonEnd) {
+    // Skip trailing whitespace on current line
+    let pos = jsonEnd;
+    while (pos < text.length && text[pos] !== '\n')
+        pos++;
+    if (pos < text.length)
+        pos++; // consume newline
+    // Check next line for a close fence
+    const nextNewline = text.indexOf('\n', pos);
+    const nextLineEnd = nextNewline === -1 ? text.length : nextNewline;
+    const nextLine = text.slice(pos, nextLineEnd).trim();
+    if (nextLine === '```' || nextLine === '````') {
+        pos = nextNewline === -1 ? text.length : nextNewline + 1;
+    }
+    return pos;
+}
+/** Render a parsed question payload as clean markdown prose. */
+function proseFromPayload(p) {
+    const lines = [];
+    lines.push('');
+    if (p.question)
+        lines.push(`**${p.question}**`);
+    if (p.context) {
+        lines.push('');
+        lines.push(`*${p.context}*`);
+    }
+    if (p.choices && p.choices.length > 0) {
+        lines.push('');
+        const header = p.kind === 'multi' ? 'Pick any (comma-separate your answers):' : 'Pick one:';
+        lines.push(header);
+        for (let i = 0; i < p.choices.length; i++) {
+            const c = p.choices[i];
+            lines.push(`  ${i + 1}. ${c.label}`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * True if the parsed JSON looks like a question-widget payload (has a
+ * string `question` and a valid `kind`).
+ */
+function isQuestionPayload(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const p = obj;
+    return (typeof p['question'] === 'string' &&
+        (p['kind'] === 'text' || p['kind'] === 'choice' || p['kind'] === 'multi'));
+}
+/**
+ * Main entry. Scan `text` for question-widget payloads (via sentinel OR
+ * bare JSON shape) and replace each with prose. Streaming-safe: if a
+ * sentinel or `"question":` key is present but the following JSON is
+ * incomplete, return `tailFrom` so the caller can buffer and retry.
+ */
+export function normalizeQuestionBlocks(text) {
+    let out = '';
+    let cursor = 0;
+    while (cursor < text.length) {
+        // Find the next CANDIDATE — either a sentinel or a "question" key.
+        // Whichever comes first wins.
+        const sentinelIdx = text.indexOf(SENTINEL, cursor);
+        const questionKeyIdx = text.indexOf(QUESTION_KEY, cursor);
+        let candidateIdx;
+        let mode;
+        if (sentinelIdx === -1 && questionKeyIdx === -1) {
+            out += text.slice(cursor);
+            return { normalized: out, tailFrom: null };
+        }
+        else if (sentinelIdx === -1) {
+            candidateIdx = questionKeyIdx;
+            mode = 'bare';
+        }
+        else if (questionKeyIdx === -1) {
+            candidateIdx = sentinelIdx;
+            mode = 'sentinel';
+        }
+        else if (sentinelIdx < questionKeyIdx) {
+            candidateIdx = sentinelIdx;
+            mode = 'sentinel';
+        }
+        else {
+            candidateIdx = questionKeyIdx;
+            mode = 'bare';
+        }
+        // In bare mode, the `{` is BEFORE the question key. Scan backward to
+        // find the enclosing `{`. In sentinel mode, `{` is AFTER the sentinel.
+        // `bufferAnchor` is the position we pull the streaming tail back to if
+        // the JSON is incomplete. Critically, the anchor must be pulled back
+        // FURTHER to also include any preceding ```cspeach-widget:question
+        // fence-open line — otherwise the downstream widget-extractor sees the
+        // dangling fence in `normalized` and OVERRIDES our buffer with its
+        // own (losing the sentinel + partial JSON).
+        let json;
+        let bufferAnchor;
+        if (mode === 'sentinel') {
+            json = findBalancedJson(text, candidateIdx + SENTINEL.length);
+            bufferAnchor = pullAnchorOverFence(text, candidateIdx);
+        }
+        else {
+            const braceStart = findEnclosingBrace(text, candidateIdx);
+            if (braceStart === -1) {
+                // No enclosing `{` found — buffer from the question key with the
+                // same fence-pullback treatment so any preceding fence-open line
+                // gets bundled.
+                const anchor = pullAnchorOverFence(text, candidateIdx);
+                out += text.slice(cursor, anchor);
+                return { normalized: out, tailFrom: anchor };
+            }
+            json = findBalancedJson(text, braceStart);
+            bufferAnchor = pullAnchorOverFence(text, braceStart);
+        }
+        if (!json) {
+            // JSON incomplete — emit everything up to the buffer anchor and ask
+            // the caller to buffer from the anchor. Critical: bufferAnchor must
+            // be at or before the opening `{`; otherwise the `{` is lost and
+            // the next chunk can't balance the braces. Also must be before any
+            // preceding fence-open line so widget-extractor doesn't fight us.
+            out += text.slice(cursor, bufferAnchor);
+            return { normalized: out, tailFrom: bufferAnchor };
+        }
+        // Try to parse.
+        let payload;
+        try {
+            payload = JSON.parse(text.slice(json.start, json.end));
+        }
+        catch {
+            // Malformed JSON. Skip past it — emit verbatim and advance cursor so
+            // we don't loop forever on the same candidate.
+            out += text.slice(cursor, json.end);
+            cursor = json.end;
+            continue;
+        }
+        if (!isQuestionPayload(payload)) {
+            // Not a question payload (other widget types end up here). Emit
+            // verbatim so the widget extractor or markdown renderer handles it,
+            // and advance past the JSON.
+            out += text.slice(cursor, json.end);
+            cursor = json.end;
+            continue;
+        }
+        // Replace the whole block (including any preceding fence+sentinel
+        // lines and trailing close fence) with prose.
+        const blockStart = findBlockStart(text, json.start);
+        const blockEnd = findBlockEnd(text, json.end);
+        out += text.slice(cursor, blockStart);
+        out += proseFromPayload(payload);
+        cursor = blockEnd;
+    }
+    return { normalized: out, tailFrom: null };
+}
+/**
+ * Given an anchor position (e.g. sentinel or `{`), walk backward to the
+ * start of the line containing the anchor. If the line immediately
+ * preceding that is a ```cspeach-widget:... fence opener (or any bare
+ * ``` fence), pull the anchor further back to the start of THAT fence
+ * line. This ensures the buffered tail includes any dangling fence-open
+ * line, preventing the widget-extractor from seeing an orphan fence in
+ * `normalized` and overriding our buffer with its own.
+ */
+function pullAnchorOverFence(text, anchor) {
+    const prevNewline = text.lastIndexOf('\n', anchor - 1);
+    const lineStart = prevNewline === -1 ? 0 : prevNewline + 1;
+    if (prevNewline === -1)
+        return lineStart;
+    // Check the line BEFORE `anchor`'s line.
+    const priorPrevNewline = text.lastIndexOf('\n', prevNewline - 1);
+    const priorLineStart = priorPrevNewline === -1 ? 0 : priorPrevNewline + 1;
+    const priorLine = text.slice(priorLineStart, prevNewline).trim();
+    if (/^```(?:cspeach-widget:\S+)?$/.test(priorLine) || /^````(?:cspeach-widget:\S+)?$/.test(priorLine)) {
+        return priorLineStart;
+    }
+    return lineStart;
+}
+/**
+ * Walk backward from `pos` to find the nearest `{` that is NOT inside a
+ * string. This is the enclosing JSON object's opening brace when `pos`
+ * points at a key-level position. Returns -1 if no such `{` exists in the
+ * text before `pos`.
+ *
+ * This is a best-effort scan — to be fully correct we'd need forward
+ * string-state tracking from the start of the text. For our purposes
+ * (locating an object containing `"question":`), we do a simpler check:
+ * walk back, counting unmatched `{`/`}`, stopping at the first `{` that
+ * brings us to depth -1 (i.e. one more open than close on the way back).
+ *
+ * Limitation: if the `"question"` string itself contains unbalanced braces
+ * in its value (e.g. `"question": "count { elements"`), this can pick the
+ * wrong brace. Acceptable risk — real question texts don't contain raw
+ * braces.
+ */
+function findEnclosingBrace(text, pos) {
+    let depth = 0;
+    for (let i = pos - 1; i >= 0; i--) {
+        const c = text[i];
+        if (c === '}')
+            depth++;
+        else if (c === '{') {
+            if (depth === 0)
+                return i;
+            depth--;
+        }
+    }
+    return -1;
+}

package/dist/renderer/severity.js

@@ -0,0 +1,61 @@
+// C:\Users\Admin\ClaudeProjects\ABAPForge\cspeach-cli\src\renderer\severity.ts
+import chalk from 'chalk';
+const PILLS = {
+    CRITICAL: (s) => chalk.bgRedBright.white.bold(s),
+    HIGH: (s) => chalk.bgRed.white(s),
+    MEDIUM: (s) => chalk.bgYellow.black(s),
+    LOW: (s) => chalk.bgGreen.black(s),
+};
+const FENCE_RE = /^```/;
+const ANSI_STRIP_RE = /\x1B\[[0-9;]*[mGKHFABCDsuJSTfrl]|\x1B\][^\x07]*\x07/g;
+// A line that is part of a rendered cli-table3 block always starts with one of
+// these box-drawing chars (after any ANSI codes). Severity pills in those
+// cells are applied inside markdown.ts's custom table renderer BEFORE
+// cli-table3 computes column widths — re-applying here would add ` HIGH `
+// (6 visible chars) over an already-styled 4-char "HIGH", pushing every
+// following `│` border right by 2 cells and breaking the layout.
+const TABLE_LINE_RE = /^[┌│└├┤┬┴]/;
+function isTableLine(line) {
+    return TABLE_LINE_RE.test(line.replace(ANSI_STRIP_RE, '').trimStart());
+}
+/**
+ * Replace bare severity words (CRITICAL / HIGH / MEDIUM / LOW) with
+ * chalk-styled pills. Words inside fenced code blocks or inside rendered
+ * cli-table3 rows are left untouched.
+ *
+ * Operates line-by-line so fence tracking is exact and table rows (styled
+ * upstream by markdown.ts) aren't double-wrapped.
+ */
+export function applySeverity(text) {
+    const lines = text.split('\n');
+    let insideFence = false;
+    const out = [];
+    for (const line of lines) {
+        if (FENCE_RE.test(line)) {
+            insideFence = !insideFence;
+            out.push(line);
+            continue;
+        }
+        if (insideFence) {
+            out.push(line);
+            continue;
+        }
+        if (isTableLine(line)) {
+            // Already styled inside the table renderer — skip to avoid layout drift.
+            out.push(line);
+            continue;
+        }
+        out.push(replacePills(line));
+    }
+    return out.join('\n');
+}
+/** Exposed so markdown.ts can apply per-cell severity BEFORE cli-table3 lays out the table. */
+export function applySeverityToCell(cell) {
+    return replacePills(cell);
+}
+function replacePills(line) {
+    return line.replace(/\b(CRITICAL|HIGH|MEDIUM|LOW)\b/g, (match) => {
+        const fn = PILLS[match];
+        return fn ? fn(` ${match} `) : match;
+    });
+}

package/dist/renderer/status-footer.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+const RULE_WIDTH = 72;
+const RULE = chalk.dim('─'.repeat(RULE_WIDTH));
+/**
+ * Prints a status footer after each turn ends.
+ *
+ * Format (spec §3.7, v0.2 — cost-free variant):
+ *   ────────────────────────────────────────────────────────────────────
+ *    session 870ed8cc │ S4H-DEV │ /abap-radar │ 3 turns │ 6,533 tok this turn │ 2,100 cached │ 4.2s
+ *   ────────────────────────────────────────────────────────────────────
+ *
+ * H1 — `tokens` is the per-turn delta (input + output consumed THIS turn),
+ * computed by the REPL as `after − before` around the `runTurn` call against
+ * the session-lifetime `session.usage`. `cachedTokens` remains lifetime
+ * (cache reads are rare per-turn; the session running count is more useful).
+ *
+ * M9 — Dollar display removed in v0.2: accurate pricing requires splitting
+ * input / output / cached-read / cached-write tokens against four different
+ * per-MTok prices, which the footer does not have access to post-turn.
+ * A blended `$30/M * totalTokens` formula is wrong by up to 6× on cache-heavy
+ * turns (cached reads are $0.30/M, not $30/M) and misleads rather than
+ * informs. v0.3 adds proper usage breakdown via
+ * `session.tokens_by_category` and restores a provably correct cost line.
+ *
+ * v0.3 transition: this chalk status-footer-after-turn is replaced (not
+ * augmented) by the Ink persistent footer region in Plan 4c.
+ */
+export function printStatusFooter(params) {
+    const { sessionId, sapAlias, skill, turnCount, tokens, cachedTokens, elapsedMs } = params;
+    const shortSession = sessionId.slice(0, 8);
+    const skillDisplay = skill.startsWith('/') ? skill : `/${skill}`;
+    const turns = `${turnCount} turn${turnCount === 1 ? '' : 's'}`;
+    // H1 — "this turn" makes it explicit the token count is per-turn, not
+    // session-lifetime. The REPL passes the pre/post-runTurn delta.
+    const tokStr = tokens.toLocaleString() + ' tok this turn';
+    const cachedStr = cachedTokens > 0 ? `${cachedTokens.toLocaleString()} cached` : '';
+    const elapsed = elapsedMs > 0 ? `${(elapsedMs / 1000).toFixed(1)}s` : '';
+    const parts = [
+        chalk.dim(`session ${shortSession}`),
+        chalk.dim(sapAlias),
+        chalk.dim(skillDisplay),
+        chalk.dim(turns),
+        chalk.dim(tokStr),
+        ...(cachedStr ? [chalk.dim(cachedStr)] : []),
+        ...(elapsed ? [chalk.dim(elapsed)] : []),
+    ];
+    console.log('\n' + RULE);
+    console.log(' ' + parts.join(chalk.dim(' │ ')));
+    console.log(RULE + '\n');
+}

package/dist/renderer/syntax.js

@@ -0,0 +1,58 @@
+/**
+ * Syntax dispatcher — reads the fenced-code-block language hint and routes
+ * to the correct cli-highlight grammar. Called by renderer/pipeline.ts
+ * for every fenced block it extracts.
+ *
+ * Returns a chalk-escaped string. In non-TTY mode the highlight() call
+ * still runs but the terminal won't render colours — tty.ts callers are
+ * responsible for stripping ANSI if required.
+ *
+ * M3 — cli-highlight's public API does NOT accept a `languages: {...}` map
+ * in the `highlight()` options; grammars must be registered against the
+ * underlying highlight.js namespace via `hljs.registerLanguage(name, fn)`.
+ * cli-highlight depends on and re-uses the same `highlight.js` module
+ * singleton, so registering there makes the grammars discoverable from
+ * cli-highlight's `highlight()` call. We register at module-load time so
+ * every subsequent `highlightCodeBlock` call just dispatches.
+ *
+ * If a future version of cli-highlight vends its own isolated hljs
+ * instance (check `node_modules/cli-highlight/package.json` `main` entry
+ * and its actual `require('highlight.js')` source), swap the import to
+ * `import hljs from 'cli-highlight'` and call `hljs.registerLanguage` on
+ * that object — the shape of the API is the same.
+ */
+import { highlight } from 'cli-highlight';
+import hljs from 'highlight.js';
+import abapGrammar from './highlighters/abap.js';
+import cdsGrammar from './highlighters/cds.js';
+import bdefGrammar from './highlighters/bdef.js';
+// Module-load-time registration. The grammar modules export plain objects
+// (shape matches highlight.js `Language` definition). Cast is safe — the
+// grammars match the runtime contract even when strict typings drift.
+hljs.registerLanguage('abap', () => abapGrammar);
+hljs.registerLanguage('cds', () => cdsGrammar);
+hljs.registerLanguage('bdef', () => bdefGrammar);
+const SUPPORTED = new Set(['abap', 'cds', 'bdef']);
+/**
+ * Highlight a code block body (without fence markers).
+ *
+ * @param code  Raw source text between the opening and closing ``` fences.
+ * @param lang  Language hint from the opening fence (e.g. 'abap', 'cds').
+ *              Empty string or unrecognised lang → returns `code` unchanged.
+ * @returns     ANSI-highlighted string or the original code if no grammar.
+ */
+export function highlightCodeBlock(code, lang) {
+    const normalised = lang.trim().toLowerCase();
+    if (!SUPPORTED.has(normalised))
+        return code;
+    try {
+        return highlight(code, {
+            language: normalised,
+            ignoreIllegals: true,
+        });
+    }
+    catch {
+        // Grammar error should never surface to the user.
+        return code;
+    }
+}

package/dist/renderer/tables.js

@@ -0,0 +1,55 @@
+// C:\Users\Admin\ClaudeProjects\ABAPForge\cspeach-cli\src\renderer\tables.ts
+import Table from 'cli-table3';
+import chalk from 'chalk';
+import { applySeverity } from './severity.js';
+/** Regex that matches a markdown pipe-table row (at least two | delimiters). */
+const PIPE_ROW_RE = /^\|(.+\|)+$/;
+/** Separator row: | --- | or | :---: | etc. */
+const SEP_ROW_RE = /^\|[\s|:-]+\|$/;
+/**
+ * Scan `text` for contiguous blocks of markdown pipe-table rows,
+ * replace each with a cli-table3 rendered string.
+ * Non-table lines are passed through unchanged.
+ */
+export function renderTables(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let tableLines = [];
+    const flushTable = () => {
+        if (tableLines.length === 0)
+            return;
+        out.push(buildTable(tableLines));
+        tableLines = [];
+    };
+    for (const line of lines) {
+        if (PIPE_ROW_RE.test(line.trim())) {
+            tableLines.push(line);
+        }
+        else {
+            flushTable();
+            out.push(line);
+        }
+    }
+    flushTable();
+    return out.join('\n');
+}
+function parseRow(line) {
+    return line
+        .split('|')
+        .slice(1, -1) // drop leading/trailing empty segments
+        .map((c) => c.trim());
+}
+function buildTable(lines) {
+    // First non-separator row is the header.
+    const rows = lines.filter((l) => !SEP_ROW_RE.test(l.trim()));
+    if (rows.length === 0)
+        return lines.join('\n');
+    const [headerRow, ...dataRows] = rows;
+    const headers = parseRow(headerRow).map((h) => chalk.cyan.bold(h));
+    const table = new Table({ head: headers });
+    for (const row of dataRows) {
+        const cells = parseRow(row).map((c) => applySeverity(c));
+        table.push(cells);
+    }
+    return table.toString();
+}

package/dist/renderer/thinking-heartbeat.js

@@ -0,0 +1,70 @@
+/**
+ * Thinking heartbeat — guaranteed-visible "model is alive" indicator.
+ *
+ * The animated spinner in tool-widget.ts uses `\r` cursor manipulation to
+ * paint frames in place. That's nice on a real ANSI-capable terminal but
+ * fails on:
+ *
+ *   - Windows PowerShell where process.stdout.isTTY returns false in some
+ *     configurations (the spinner self-disables).
+ *   - Terminals where the readline prompt redraw races with the spinner's
+ *     `\r\x1B[2K` and overwrites it before the user sees anything.
+ *   - CI / piped output where ANSI codes are stripped.
+ *
+ * Live test on PowerShell showed a 45-second blank-cursor wait during a
+ * resumed turn. The heartbeat solves this by printing FRESH LINES at
+ * elapsed-time thresholds — no cursor manipulation, no overwriting,
+ * works on the dumbest terminal:
+ *
+ *   3s  →  ⠂ thinking…
+ *   10s →  ⠂ thinking… (10s)
+ *   30s →  ⠂ thinking… (30s)
+ *   60s →  ⠂ thinking… (60s)
+ *   90s →  ⠂ thinking… (90s — long wait, hold on)
+ *   120s →  ⠂ thinking… (2m — provider unusually slow, may want to interrupt)
+ *
+ * Stops as soon as content arrives. Designed to complement, not replace,
+ * the animated spinner — both can run; the spinner gives a smooth in-place
+ * pulse on capable terminals, the heartbeat is the "definitely visible"
+ * fallback.
+ */
+import chalk from 'chalk';
+const THRESHOLDS_MS = [
+    { at: 3_000, label: 'thinking…' },
+    { at: 10_000, label: 'thinking… (10s)' },
+    { at: 30_000, label: 'thinking… (30s)' },
+    { at: 60_000, label: 'thinking… (60s)' },
+    { at: 90_000, label: 'thinking… (90s — long wait, hold on)' },
+    { at: 120_000, label: 'thinking… (2m — provider unusually slow, Ctrl+C to interrupt)' },
+    { at: 180_000, label: 'thinking… (3m — Ctrl+C is recommended; the stream may have stalled)' },
+    { at: 300_000, label: 'thinking… (5m — Ctrl+C and try again)' },
+];
+export function startThinkingHeartbeat() {
+    const startedAt = Date.now();
+    let nextIdx = 0;
+    let stopped = false;
+    const tick = () => {
+        if (stopped)
+            return;
+        const elapsed = Date.now() - startedAt;
+        while (nextIdx < THRESHOLDS_MS.length && THRESHOLDS_MS[nextIdx].at <= elapsed) {
+            const t = THRESHOLDS_MS[nextIdx];
+            // Plain newline-terminated line — survives any terminal mode.
+            // Indent by 2 spaces to align with tool-call rows.
+            process.stdout.write(chalk.dim(`  ${t.label}\n`));
+            nextIdx++;
+        }
+    };
+    // Check every second — granular enough to fire each threshold within a
+    // second of crossing it without producing noisy intermediate output.
+    const interval = setInterval(tick, 1000);
+    interval.unref?.();
+    return {
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            clearInterval(interval);
+        },
+    };
+}