@pugi/cli 0.1.0-beta.31 → 0.1.0-beta.36

package/dist/core/onboarding/ensure-initialized.js

@@ -0,0 +1,133 @@
+/**
+ * Wave 6 UX (2026-05-27) — `ensureInitialized` helper.
+ *
+ * Auto-init pre-flight for every Pugi command. Before this helper landed,
+ * the only entry points that exercised the init flow were:
+ *
+ *   1. The explicit `pugi init` CLI subcommand.
+ *   2. The REPL's `/init` slash (β1a r1).
+ *   3. Engine commands (`pugi code`, `pugi build`, `pugi sync`) which
+ *      called the legacy `ensureInitialized` in `cli.ts` and threw
+ *      `Error('Run pugi init first')` if the operator ran them in a
+ *      directory without `.pugi/`.
+ *
+ * Read-only commands (`pugi explain`, `pugi review`, `pugi plan`,
+ * `pugi smoke`, `pugi chain new`, ...) silently no-op'd the `.pugi/`
+ * mirror inside the engine adapter, which made early dogfooding
+ * confusing — the operator saw a successful command but no session
+ * artifacts on disk and no idea why.
+ *
+ * Auto-init contract (matches CEO directive Wave 6, 2026-05-27):
+ *
+ *   - `.pugi/` already exists  → return `{ status: 'already' }` silently.
+ *   - Interactive TTY + no `.pugi/` → prompt
+ *     "No Pugi workspace found here. Initialize? (Y/n)".
+ *     Default Y. On Y: run `scaffoldPugiWorkspace`, return `{ status:
+ *     'initialized' }`. On n: return `{ status: 'declined' }` so the
+ *     caller can bail with a helpful message.
+ *   - Non-interactive (CI / pipe / --json / --no-tty) + no `.pugi/`:
+ *     default behaviour is conservative — return `{ status: 'declined',
+ *     reason: 'non_interactive' }`. The caller decides how to surface
+ *     this (engine commands bail with a clean error; read-only
+ *     commands MAY continue with degraded semantics).
+ *   - `--no-init` flag forces conservative posture even on interactive
+ *     terminals (operator wants to fail fast).
+ *
+ * Session cache: a command pre-flight that already prompted for and
+ * scaffolded `.pugi/` MUST NOT re-prompt for the same workspace in the
+ * same process. The cache key is the absolute workspace root path. The
+ * cache is process-local (Map) — it does not persist across `pugi`
+ * invocations (a second `pugi code` in the same shell starts fresh and
+ * re-checks the filesystem).
+ *
+ * This module is intentionally framework-free: no Ink, no React, no
+ * readline. The prompt reader is injected via the `prompt` callback so
+ * the spec can drive the helper deterministically and the CLI can
+ * forward to its existing stdin-reader (`readSingleChoice` in cli.ts).
+ */
+import { existsSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+/**
+ * Process-local cache of workspaces that already passed the pre-flight
+ * gate. Keyed by absolute root path. The cache is intentionally
+ * additive-only — there is no eviction. A long-running REPL session
+ * stays in one workspace and we never want to re-prompt within it.
+ */
+const initialisedCache = new Set();
+/**
+ * Reset the cache. Exported for spec teardown — production callers
+ * never need this.
+ */
+export function resetInitializedCache() {
+    initialisedCache.clear();
+}
+/**
+ * Detect `.pugi/` at `root`. Pure filesystem read; swallows permission
+ * errors (returns false). Exported so the spec can assert the same
+ * detection the helper uses without re-implementing the check.
+ */
+export function hasPugiWorkspace(root) {
+    const path = resolve(root, '.pugi');
+    try {
+        if (!existsSync(path))
+            return false;
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Auto-init pre-flight. Idempotent and process-cache aware — calling
+ * twice in the same process for the same workspace returns `already`
+ * the second time even if the filesystem state changed underneath.
+ *
+ * Implementation notes:
+ *
+ *   - Returns `{ status: 'already' }` when `.pugi/` exists OR the cache
+ *     remembers this workspace. The cache short-circuit means a second
+ *     command in the same process never blocks on the prompt.
+ *   - Interactive + missing → prompt. The default answer (empty input
+ *     OR a leading `y` / `yes`) maps to scaffold. Anything else
+ *     (`n`, `no`, `cancel`, whitespace + non-y) maps to declined.
+ *   - Scaffolder failures propagate to the caller; the helper does
+ *     NOT swallow them because a failed scaffold means the operator's
+ *     command cannot continue anyway. Tests assert this.
+ */
+export async function ensureInitialized(opts) {
+    const root = resolve(opts.cwd ?? process.cwd());
+    if (initialisedCache.has(root)) {
+        return { status: 'already', root };
+    }
+    if (hasPugiWorkspace(root)) {
+        initialisedCache.add(root);
+        return { status: 'already', root };
+    }
+    if (opts.skip) {
+        return { status: 'declined', root, reason: 'disabled' };
+    }
+    if (!opts.interactive) {
+        return { status: 'declined', root, reason: 'non_interactive' };
+    }
+    if (!opts.prompt) {
+        // Defensive — an interactive caller forgot к wire the prompt
+        // reader. Treat the same as non-interactive rather than throwing
+        // so the surrounding command can degrade gracefully.
+        return { status: 'declined', root, reason: 'non_interactive' };
+    }
+    const write = opts.write ?? ((line) => process.stderr.write(line));
+    write(`No Pugi workspace found at ${root}.\n`);
+    const answer = (await opts.prompt('Initialize a new Pugi workspace here? (Y/n) ')).trim().toLowerCase();
+    // Default = yes (empty input OR leading 'y'). Anything else = no.
+    // Mirrors the gh CLI / claude code prompt convention where the upper-
+    // case option in `(Y/n)` is the default-on-Enter answer.
+    const acceptedShort = answer === '' || answer === 'y' || answer === 'yes';
+    if (!acceptedShort) {
+        write('Initialization declined.\n');
+        return { status: 'declined', root, reason: 'user_declined' };
+    }
+    await opts.scaffold({ cwd: root });
+    initialisedCache.add(root);
+    return { status: 'initialized', root };
+}
+//# sourceMappingURL=ensure-initialized.js.map

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': {
@@ -1131,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
@@ -1517,6 +1649,39 @@ export class ReplSession {
                 }
                 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;
@@ -1863,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');
@@ -2015,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));
                 }
             }
         }
@@ -2079,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, '');
@@ -3098,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` →
@@ -3671,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                                      */
 /* ------------------------------------------------------------------ */
@@ -3722,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')