@pugi/cli 0.1.0-beta.30 → 0.1.0-beta.35

package/dist/core/repl/session.js

@@ -47,6 +47,22 @@ import { DispatchFSM } from './dispatch-fsm.js';
 import { computeCostUsd, formatCostUsd, formatTokens } from './model-pricing.js';
 const MAX_TRANSCRIPT_ROWS = 500;
 const MAX_TOOL_CALLS = 200;
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): width cap for the inline
+ * `streamingDelta` tail rendered next to the args while the call is
+ * `running`. Keeps the tool-stream row single-line on an 80-col
+ * terminal even when Bash output blasts through stdout. Exported so the
+ * spec can pin the truncation behaviour.
+ */
+export const STREAMING_DELTA_MAX_CHARS = 80;
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): character cap for the
+ * collapsed `resultPreview` on a completed row. The pane shows
+ * `✓ Read(file)  OK (2ms)  "first 50 chars…"` so the operator sees what
+ * the tool produced without expanding. Per CEO spec (50 chars).
+ * Exported so the spec + the pane share one source of truth.
+ */
+export const RESULT_PREVIEW_MAX_CHARS = 50;
 const MAX_RECONNECT_ATTEMPTS = 10;
 const RECONNECT_BASE_MS = 250;
 const RECONNECT_MAX_MS = 5_000;
@@ -397,6 +413,13 @@ export class ReplSession {
             // a failed flush leaves the queue intact for the next start.
             // Never blocks bootstrap.
             void this.flushFeedbackQueueOnBootstrap().catch(() => undefined);
+            // Wave 6 BT 9 Phase 2 (2026-05-27): codegraph cold-start hook.
+            // Surfaces ONE of two nudges:
+            //   - stale-index reminder ("Codegraph index is N days old…")
+            //   - 30-day post-decline reminder ("Detected medium TS repo…")
+            // Skips silently in every other case. Best-effort — a failed
+            // detection NEVER blocks bootstrap (the helper itself catches).
+            void this.runCodegraphColdStart().catch(() => undefined);
         }
         catch (error) {
             this.appendSystemLine(`Could not open Pugi session: ${this.errorMessage(error)}`);
@@ -455,6 +478,47 @@ export class ReplSession {
             apiKey: this.options.apiKey,
         });
     }
+    /**
+     * Wave 6 BT 9 Phase 2 (2026-05-27): codegraph cold-start nudge.
+     *
+     * Surfaces ONE of two nudges on REPL boot when the gate trips:
+     *   - 30-day post-decline reminder ("Detected medium TS repo…")
+     *   - stale-index reminder ("Codegraph index is N days old…")
+     *
+     * The evaluator is pure; we stamp `lastReindexCheckAt` here so the
+     * stale-index nudge throttles к once-per-day. The init-flow first-
+     * run prompt is handled separately by `pugi init` to avoid double-
+     * prompting в the common "init + then code" boot sequence.
+     *
+     * Best-effort: any error inside the codegraph module is swallowed —
+     * a cold-start nudge that breaks the REPL would be worse than no
+     * nudge at all.
+     */
+    async runCodegraphColdStart() {
+        try {
+            const workspaceRoot = this.options.workspace?.workspaceCwd ?? process.cwd();
+            const { evaluateColdStart } = await import('../codegraph/offer-hook.js');
+            const verdict = evaluateColdStart({ workspaceRoot });
+            if (verdict.kind === 'silent')
+                return;
+            if (verdict.kind === 'stale-index') {
+                this.appendSystemLine(verdict.message);
+                const { markReindexChecked } = await import('../codegraph/decision-store.js');
+                markReindexChecked(workspaceRoot);
+                return;
+            }
+            // 'remind' — surface the offer copy as a system line. Operator
+            // accepts via `/codegraph-status --install` OR explicitly via
+            // `pugi mcp install codegraph codegraph serve --mcp`.
+            this.appendSystemLine('');
+            this.appendSystemLine(verdict.message);
+            this.appendSystemLine('  Accept: run `pugi mcp install codegraph codegraph serve --mcp && pugi mcp trust codegraph`');
+            this.appendSystemLine('  Skip:   /codegraph-status to inspect the decision; the prompt re-appears in 30 days');
+        }
+        catch {
+            // Codegraph nudge is decoration — failure must NEVER surface.
+        }
+    }
     /**
      * Tear down the SSE stream and stop the reconnect timer. The session
      * id stays valid server-side; `pugi resume <id>` reopens later.
@@ -714,7 +778,43 @@ export class ReplSession {
                 return verdict;
             }
             case 'jobs': {
-                await this.dispatchJobs();
+                // Wave 6 cleanup (2026-05-27): `/jobs --watch` mounts the
+                // live Ink TUI from inside the REPL. The dispatcher does NOT
+                // mount the watcher itself (that would unmount the REPL's
+                // own Ink tree) — instead it surfaces the shell command so
+                // the operator runs the watcher in a fresh terminal. Bare
+                // `/jobs` continues to render the one-shot snapshot.
+                if (verdict.watch) {
+                    this.appendSystemLine('Run `pugi jobs --watch` from a fresh shell — the live TUI cannot share the REPL Ink tree.');
+                }
+                else {
+                    await this.dispatchJobs();
+                }
+                return verdict;
+            }
+            case 'cancel': {
+                // Wave 6 small-CC-parity batch (2026-05-27): forward the parsed
+                // mode + dispatchId to `runCancelCommand`. The dispatcher uses
+                // a dynamic import so the cancel module's filesystem helpers
+                // stay out of the REPL keystroke hot path; same separation as
+                // `/redo`, `/prd-check`, `/chain`. The runner writes its
+                // output lines through `appendSystemLine` so the verdict
+                // lands on the system pane alongside other slash results.
+                try {
+                    const { runCancelCommand } = await import('../../runtime/commands/cancel.js');
+                    const cancelMode = verdict.mode === 'list'
+                        ? { kind: 'list' }
+                        : verdict.mode === 'all'
+                            ? { kind: 'all' }
+                            : { kind: 'one', dispatchId: verdict.dispatchId };
+                    await runCancelCommand(cancelMode, {
+                        write: (line) => this.appendSystemLine(line),
+                    });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.appendSystemLine(`/cancel failed: ${message}`);
+                }
                 return verdict;
             }
             case 'diff': {
@@ -1052,6 +1152,15 @@ export class ReplSession {
                 // `/prd-check` and `pugi prd-check`. Dynamic-import the
                 // module to keep the parser + verifier graph out of the
                 // REPL hot path.
+                //
+                // Wave 6 final (2026-05-27): the runner now also honours
+                // `--session` mode (orthogonal to the verifier graph — walks
+                // up for PRD.md, reads NDJSON turns, dispatches a cross-
+                // review subagent). We stream the runner's status lines
+                // directly to the system pane so the operator sees
+                // "Locating PRD..." / "Reviewing against PRD..." while the
+                // dispatch is in flight, then the structured Satisfied /
+                // Outstanding lists when it lands.
                 try {
                     const { parsePrdCheckArgs, runPrdCheckCommand } = await import('../../runtime/commands/prd-check.js');
                     const parsed = parsePrdCheckArgs(verdict.args, { jsonDefault: false });
@@ -1059,7 +1168,7 @@ export class ReplSession {
                         this.appendSystemLine(`/prd-check: ${parsed.error}`);
                         return verdict;
                     }
-                    const lines = [];
+                    let sawOutput = false;
                     await runPrdCheckCommand({
                         cwd: process.cwd(),
                         ...(parsed.prdPath !== undefined ? { prdPath: parsed.prdPath } : {}),
@@ -1074,13 +1183,13 @@ export class ReplSession {
                         knownCommands: new Set(),
                         writeOutput: (_payload, text) => {
                             const trimmed = text.replace(/\n+$/u, '');
-                            if (trimmed.length > 0)
-                                lines.push(trimmed);
+                            if (trimmed.length > 0) {
+                                this.appendSystemLine(trimmed);
+                                sawOutput = true;
+                            }
                         },
                     });
-                    for (const line of lines)
-                        this.appendSystemLine(line);
-                    if (lines.length === 0) {
+                    if (!sawOutput) {
                         this.appendSystemLine('/prd-check: no output.');
                     }
                 }
@@ -1122,6 +1231,38 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'codegraph-status': {
+                // Wave 6 BT 9 Phase 2 (2026-05-27): forward to the runner. The
+                // bare form renders the four-row status table; flags handle
+                // install / reindex / offer. Dynamic import keeps the
+                // codegraph module out of the REPL hot path until first use.
+                try {
+                    const { runCodegraphStatusCommand } = await import('../../runtime/commands/codegraph-status.js');
+                    const lines = [];
+                    const workspaceRoot = this.options.workspace?.workspaceCwd ?? process.cwd();
+                    await runCodegraphStatusCommand(verdict.args, {
+                        workspaceRoot,
+                        writeOutput: (_payload, text) => {
+                            for (const raw of text.split('\n')) {
+                                const trimmed = raw.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/codegraph-status: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/codegraph-status failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'permissions': {
                 // Leak L6: handle the `/permissions [mode] [--persist]` flow.
                 // The session module forwards to the runtime helper so the
@@ -1474,6 +1615,73 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'undo': {
+                // Wave 6 final (2026-05-27): graduated from stub. The runtime
+                // command `runUndoCommand` already exists with full Aider walk-
+                // back semantics — single-step revert of the most recent
+                // successful `write` / `edit` / `multi_edit` tool result, with
+                // an mtime+hash gate that refuses to overwrite uncommitted
+                // operator work. We open a fresh PugiSession against the cwd
+                // so the inverse-mutation audit lands on the same NDJSON
+                // events stream the REPL writes to; dynamic-import keeps the
+                // runner + git plumbing out of the REPL hot path.
+                try {
+                    const [{ runUndoCommand }, { openSession }] = await Promise.all([
+                        import('../../runtime/commands/undo.js'),
+                        import('../session.js'),
+                    ]);
+                    const workspaceRoot = process.cwd();
+                    const session = openSession(workspaceRoot);
+                    this.appendSystemLine('Reverting last write...');
+                    await runUndoCommand([], {
+                        workspaceRoot,
+                        session,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                this.appendSystemLine(trimmed);
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/undo failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'redo': {
+                // Wave 6 cleanup (2026-05-27): counterpart к /undo. The runtime
+                // command `runRedoCommand` consumes one entry from the LIFO
+                // undo stack (most recent unconsumed `tool=undo` result), reads
+                // the captured AFTER content from `.pugi/undo-blobs/`, and
+                // re-applies the mutations under the same mtime+hash external-
+                // modification gate the undo runner uses. Same dynamic-import
+                // posture as /undo so the redo + blob-store + git plumbing
+                // stays out of the REPL hot path.
+                try {
+                    const [{ runRedoCommand }, { openSession }] = await Promise.all([
+                        import('../../runtime/commands/redo.js'),
+                        import('../session.js'),
+                    ]);
+                    const workspaceRoot = process.cwd();
+                    const session = openSession(workspaceRoot);
+                    this.appendSystemLine('Reapplying last undo...');
+                    await runRedoCommand([], {
+                        workspaceRoot,
+                        session,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                this.appendSystemLine(trimmed);
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/redo failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
@@ -1820,22 +2028,87 @@ export class ReplSession {
         try {
             const registry = getJobRegistry();
             const entries = await registry.list();
-            if (entries.length === 0) {
+            // Wave 6 cleanup (2026-05-27): also scan `.pugi/agent-progress/*.json`
+            // so long-running external agents (the JSON pattern from
+            // `feedback_agent_progress_tracking_pattern.md`) show up next к
+            // background-bash entries. The two surfaces are orthogonal — bash
+            // jobs come from the in-process registry, agent-progress comes from
+            // sidecar JSON written by any agent (Pugi-spawned or external) — so
+            // we render both, sorted with running first.
+            const agentProgressRows = await this.collectAgentProgressRows();
+            if (entries.length === 0 && agentProgressRows.length === 0) {
                 this.appendSystemLine('No background jobs tracked.');
                 return;
             }
-            this.appendSystemLine(`Background jobs (${entries.length}):`);
-            for (const entry of entries) {
-                const id = entry.id.replace(/^pj-/, '').slice(0, 8);
-                const status = entry.status;
-                const cmd = entry.command.length > 48 ? `${entry.command.slice(0, 47)}…` : entry.command;
-                this.appendSystemLine(`  ${id}  ${status.padEnd(10)}  ${cmd}`);
+            if (entries.length > 0) {
+                this.appendSystemLine(`Background jobs (${entries.length}):`);
+                for (const entry of entries) {
+                    const id = entry.id.replace(/^pj-/, '').slice(0, 8);
+                    const status = entry.status;
+                    const cmd = entry.command.length > 48 ? `${entry.command.slice(0, 47)}…` : entry.command;
+                    this.appendSystemLine(`  ${id}  ${status.padEnd(10)}  ${cmd}`);
+                }
+            }
+            if (agentProgressRows.length > 0) {
+                this.appendSystemLine(`Agent progress (${agentProgressRows.length}):`);
+                for (const row of agentProgressRows) {
+                    this.appendSystemLine(`  ${row}`);
+                }
+                this.appendSystemLine('Tip: run `pugi jobs --watch` for the live Ink TUI.');
             }
         }
         catch (error) {
             this.appendSystemLine(`/jobs failed: ${this.errorMessage(error)}`);
         }
     }
+    /**
+     * Wave 6 cleanup (2026-05-27): scan `.pugi/agent-progress/*.json`
+     * for in-flight long-running agent tasks and emit a one-line per
+     * agent for the `/jobs` snapshot. Sorting matches the live TUI's
+     * `sortProgressEntries` (running first, then by lastUpdate desc).
+     *
+     * Best-effort: a missing dir, malformed JSON, or bad permissions
+     * yields an empty list and a swallowed error — the in-process
+     * registry view is the older well-tested surface and must never be
+     * gated behind a sidecar dir's health.
+     */
+    async collectAgentProgressRows() {
+        try {
+            const [{ resolveProgressDir }, { readProgressFile, sortProgressEntries }, fs, path] = await Promise.all([
+                import('../agent-progress/writer.js'),
+                import('../../commands/jobs-watch.js'),
+                import('node:fs'),
+                import('node:path'),
+            ]);
+            const dir = resolveProgressDir();
+            if (!fs.existsSync(dir))
+                return [];
+            const files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => path.join(dir, f));
+            const progress = files
+                .map((p) => readProgressFile(p))
+                .filter((p) => p !== undefined);
+            const sorted = sortProgressEntries(progress);
+            return sorted.map((p) => {
+                const id = p.agentId.length > 24 ? `${p.agentId.slice(0, 23)}…` : p.agentId;
+                const pct = `${String(Math.round(p.percentComplete)).padStart(3, ' ')}%`;
+                const elapsedSec = Math.max(0, Math.floor(p.elapsedMs / 1000));
+                const elapsed = elapsedSec >= 60
+                    ? `${Math.floor(elapsedSec / 60)}m${String(elapsedSec % 60).padStart(2, '0')}s`
+                    : `${elapsedSec}s`;
+                const status = p.status.padEnd(9, ' ');
+                const step = p.stepDescription.length > 36
+                    ? `${p.stepDescription.slice(0, 35)}…`
+                    : p.stepDescription;
+                return `${id.padEnd(24, ' ')}  ${status}  ${pct}  ${elapsed.padStart(6, ' ')}  ${step}`;
+            });
+        }
+        catch {
+            return [];
+        }
+    }
     dispatchDiff() {
         try {
             const artifactsRoot = resolvePath(process.cwd(), '.pugi', 'artifacts');
@@ -1972,14 +2245,25 @@ export class ReplSession {
                 ['review', used.review, caps.review],
                 ['engine', used.engine, caps.engine],
             ];
+            // Wave 6 cleanup (2026-05-27): color-code each counter row by
+            // utilisation. The thresholds match Claude Code's tier-meter
+            // convention so operators trained on that surface read the same
+            // signal here. ANSI codes wrap the WHOLE row (not just the
+            // percent) so the line wraps as one visual unit; the cost-quota
+            // spec regex still matches because anchors are inside the
+            // wrapped substring.
             for (const [name, value, cap] of counters) {
                 const v = typeof value === 'number' ? value : 0;
                 if (cap === null || cap === undefined) {
+                    // Unlimited counters never trip the gauge — leave them
+                    // uncolored so the eye does not register an alarm signal
+                    // where there is no cap к exhaust.
                     this.appendSystemLine(`  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / unlimited`);
                 }
                 else {
                     const pct = cap > 0 ? Math.round((v / cap) * 100) : 0;
-                    this.appendSystemLine(`  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`);
+                    const row = `  ${name.padEnd(7, ' ')} ${v.toLocaleString()} / ${cap.toLocaleString()} (${pct}%)`;
+                    this.appendSystemLine(colorizeQuotaRow(row, pct));
                 }
             }
         }
@@ -2036,6 +2320,17 @@ export class ReplSession {
                 liveTokensUsed: liveTokens >= 0 ? liveTokens : 0,
                 lastCommand,
                 lastCommandAtEpochMs,
+                // Repl-mode context: the session knows both the live
+                // transport URL and the operator's workspace label, so we
+                // forward them as authoritative inputs к the snapshot.
+                // The status snapshot used к infer these from the
+                // credentials file, which was wrong in two cases:
+                //   (a) the operator was inside a REPL talking к Anvil dev
+                //       (port 4100) but credentials still pointed к
+                //       api.pugi.io — the `Backend` row mis-reported;
+                //   (b) `workspaceLabel` was никогда rendered at all.
+                liveApiUrl: this.options.apiUrl,
+                workspaceLabel: this.options.workspaceLabel,
                 writeOutput: (_payload, text) => {
                     for (const line of text.split('\n')) {
                         const trimmed = line.replace(/\s+$/u, '');
@@ -3055,6 +3350,73 @@ export class ReplSession {
         const agent = this.state.agents.find((a) => a.taskId === taskId);
         return agent?.personaSlug ?? 'unknown';
     }
+    /**
+     * Wave 6 small-CC-parity batch (2026-05-27): public ingest path for
+     * a backend-driven `tool.call.delta` event. Appends the delta tail
+     * onto the row's `streamingDelta` (capped at
+     * `STREAMING_DELTA_MAX_CHARS` so the row stays single-line) when the
+     * id matches a `running` row. No-op when the id is unknown OR when
+     * the row already transitioned to a terminal status — late deltas
+     * from a completed call must not overwrite the final detail.
+     *
+     * The renderer in `tool-stream-pane.tsx` reads `streamingDelta` to
+     * paint the inline preview after the canonical args. This method is
+     * the seam the future admin-api SSE consumer hooks into; until then
+     * the spec drives it directly so the delta-append branch is locked
+     * down behaviourally.
+     */
+    appendToolCallDelta(id, deltaChunk) {
+        if (!id || !deltaChunk)
+            return;
+        const idx = this.state.toolCalls.findIndex((c) => c.id === id);
+        if (idx < 0)
+            return;
+        const existing = this.state.toolCalls[idx];
+        if (existing.status !== 'running')
+            return;
+        const current = existing.streamingDelta ?? '';
+        let combined = current + deltaChunk;
+        if (combined.length > STREAMING_DELTA_MAX_CHARS) {
+            // Keep the TAIL — the operator wants the freshest bytes (the
+            // line being written right now), not the stale head. The leading
+            // ellipsis signals truncation.
+            combined = `…${combined.slice(combined.length - STREAMING_DELTA_MAX_CHARS + 1)}`;
+        }
+        const next = this.state.toolCalls.slice();
+        next[idx] = { ...existing, streamingDelta: combined };
+        this.patch({ toolCalls: next });
+    }
+    /**
+     * Wave 6 small-CC-parity batch (2026-05-27): public ingest path for
+     * the terminal `tool.call.end` event. Flips the row to `ok` / `error`
+     * with the resolved duration + optional result preview. Cleans up the
+     * transient `streamingDelta` so the completed row renders cleanly
+     * without the live tail. No-op when the id is unknown.
+     */
+    endToolCall(input) {
+        if (!input.id)
+            return;
+        const idx = this.state.toolCalls.findIndex((c) => c.id === input.id);
+        if (idx < 0)
+            return;
+        const existing = this.state.toolCalls[idx];
+        const endedAt = input.endedAtEpochMs ?? Date.now();
+        const durationMs = Math.max(0, endedAt - existing.startedAtEpochMs);
+        const preview = input.resultPreview
+            ? truncatePreview(input.resultPreview, RESULT_PREVIEW_MAX_CHARS)
+            : undefined;
+        const next = this.state.toolCalls.slice();
+        next[idx] = {
+            ...existing,
+            status: input.status,
+            detail: input.detail ?? existing.detail,
+            resultLines: input.resultLines ?? existing.resultLines,
+            durationMs,
+            resultPreview: preview,
+            streamingDelta: undefined,
+        };
+        this.patch({ toolCalls: next });
+    }
     /**
      * Fold a tool call entry into the rolling list. If the entry id
      * already exists, replace it in-place (so a synthesised `running` →
@@ -3628,6 +3990,30 @@ function formatResetWindow(resetAtIso, nowEpochMs) {
     const minutes = Math.max(1, Math.floor(deltaMs / (60 * 1000)));
     return `in ${minutes}m`;
 }
+/**
+ * Wave 6 cleanup (2026-05-27): wrap a `/quota` counter row in ANSI
+ * color codes by utilisation percent. Thresholds match Claude Code's
+ * tier-meter convention so operators trained on that surface read the
+ * same signal here:
+ *
+ *   - 0..70%   → green (32m)  — comfortable headroom
+ *   - 70..90%  → yellow (33m) — approaching cap, plan ahead
+ *   - 90..100% → red (31m)    — burn rate alarm, throttle now
+ *
+ * The wrap is whole-row (not just the percent) so the eye registers
+ * the level on the line, not just the trailing parenthesis. Tests
+ * that match the inner row text via regex are unaffected because the
+ * regex anchors live inside the wrapped substring; the ANSI codes
+ * sit at the boundaries.
+ */
+export function colorizeQuotaRow(row, pct) {
+    const RESET = '\x1b[0m';
+    if (pct >= 90)
+        return `\x1b[31m${row}${RESET}`;
+    if (pct >= 70)
+        return `\x1b[33m${row}${RESET}`;
+    return `\x1b[32m${row}${RESET}`;
+}
 /* ------------------------------------------------------------------ */
 /* Tool call synthesiser - α6.12                                      */
 /* ------------------------------------------------------------------ */
@@ -3679,6 +4065,24 @@ export function synthesiseToolCall(input) {
         startedAtEpochMs: input.now,
     };
 }
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): collapse a multi-line
+ * result preview down to a single-line head capped at `max` chars. The
+ * collapsed-result row on a completed tool call uses this so the
+ * preview never expands the row vertically. Exported для the spec so
+ * the truncation behaviour is locked down.
+ */
+export function truncatePreview(value, max) {
+    if (!value)
+        return '';
+    // Strip CR/LF + tab so the preview stays single-line. Multiple
+    // whitespace runs collapse to single space — operator wants signal,
+    // not formatting noise.
+    const single = value.replace(/[\r\n\t]+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+    if (single.length <= max)
+        return single;
+    return `${single.slice(0, Math.max(0, max - 1))}…`;
+}
 function normaliseToolName(raw) {
     const lower = raw.toLowerCase();
     if (lower === 'webfetch' || lower === 'web_fetch')