@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/frame-differ.js

@@ -1,354 +0,0 @@
-/**
- * Frame differ — F1 of tui-input-flicker-fix (§3.2).
- *
- * Ink 5.2.1 has exactly one repaint strategy: on every commit it serialises the
- * WHOLE frame and hands it to `log-update`, which writes
- * `eraseLines(previousLineCount) + frame` in a single `stdout.write`
- * (`ink/build/log-update.js:17`). `ansiEscapes.eraseLines` walks BOTTOM-UP, so
- * the composer — the last row of the frame — is erased near the start of every
- * repaint and rewritten at the very end of it. During a run that happens 15–30
- * times a second with the composer's bytes unchanged, and the user sees the
- * bottom of their screen flicker while they type (§2 R1/R2).
- *
- * This module recognises that write shape, diffs the new frame against the
- * previous one line by line, and emits only the rows that actually changed, each
- * addressed absolutely. It is PURE: no I/O, no Node globals, no event emitter —
- * `stdout-frame-writer.ts` is what binds it to a real stream. That is what keeps
- * it unit-testable with plain string literals and no TTY.
- *
- * THREE INVARIANTS LIVE HERE AND EACH ONE FAILS SILENTLY IF DROPPED:
- *
- *  - I-4 · An emitted line is `CUP · SGR0 · text · SGR0 · CSI K`, IN THAT ORDER,
- *    and it never contains `CSI 2K`. Erasing first would blank the row and refill
- *    it, which is R1's defect at 1/H the scale but on the one row the user is
- *    watching. Overwriting in place means no cell is ever presentably empty; the
- *    trailing `CSI K` removes only the residue a longer previous line left, and
- *    the trailing SGR reset before it stops a BCE terminal painting that residue
- *    in whatever background colour the line ended inside.
- *    `CSI K` IS EMITTED ONLY WHEN THE LINE IS NARROWER THAN THE TERMINAL. A row
- *    that already fills every column (the unified scrollbar paints the last one)
- *    has no residue to clear, and on terminals that keep the cursor ON the last
- *    column after writing it (a pending-wrap flag rather than a virtual column
- *    N+1) the EL would erase the cell that was just written. `cols` unknown keeps
- *    the old always-EL behaviour (`paintLine`).
- *  - I-5 · Every emitted batch ends parked on row `H+1`. Ink's own
- *    `previousLineCount` is computed from the string IT produced and is
- *    unaffected by what we actually wrote, so a later pass-through's
- *    `eraseLines(H+1)` must find the cursor exactly where log-update left it last
- *    time. Drop this and one fallback shifts the frame up a row for the rest of
- *    the session.
- *  - I-6 · Any unrecognised write invalidates the cache. Absolute addressing is
- *    valid only while nothing else writes to stdout. Full-screen mode already
- *    forbids that, but "forbidden" is not "impossible", and the failure mode of
- *    the guard being absent is a permanently misaligned screen while the failure
- *    mode of it firing spuriously is one extra full repaint.
- */
-import stringWidth from 'string-width';
-import stripAnsi from 'strip-ansi';
-import { MIN_FULLSCREEN_ROWS } from './layout/frame.js';
-import { matchInkErasePrefix } from './frame-parser.js';
-// ---------------------------------------------------------------------------
-// Constants — exact, so no call site ever re-derives an escape sequence.
-// ---------------------------------------------------------------------------
-/** Control Sequence Introducer. Spelled out once; nothing below re-escapes it. */
-const CSI = '\x1b[';
-/** Erase the WHOLE line. Ink uses it on every repaint; this module never emits it (I-4). */
-const ERASE_LINE = `${CSI}2K`;
-/** Erase cursor → end of line. This is what an emitted line ends with. */
-const ERASE_TO_EOL = `${CSI}K`;
-const CURSOR_UP_1 = `${CSI}1A`;
-const CURSOR_LEFT = `${CSI}G`;
-const SGR_RESET = `${CSI}0m`;
-/** Erase cursor → end of screen. One sequence instead of H+1 line erases. */
-const ERASE_DOWN = `${CSI}J`;
-/** DEC private mode 2026 — begin/end synchronized update (F2, §3.3). */
-const SYNC_BEGIN = `${CSI}?2026h`;
-const SYNC_END = `${CSI}?2026l`;
-/**
- * `ansiEscapes.clearTerminal` — Ink's tall-frame write (`ink.js:121`).
- *
- * When `outputHeight >= stdout.rows` Ink abandons log-update and writes
- * `clearTerminal + frame` in one chunk: no erase-lines prefix, no trailing
- * `\n`. That happens on ANY height shrink, because Ink re-renders
- * synchronously from its own `'resize'` handler while the React tree still
- * holds the pre-resize height (`useTerminalSize` debounces 50 ms). Without
- * recognition the chunk lands in the prefix-less branch and counts as a
- * foreign write — the same §5.6 notice, one ordinary window-drag later.
- */
-const CLEAR_TERMINAL = `${CSI}2J${CSI}3J${CSI}H`;
-function cursorTo(row) {
-    return `${CSI}${row};1H`;
-}
-/**
- * One addressed row: `CUP · SGR0 · line · SGR0 [· CSI K]` (I-4).
- *
- * The trailing `CSI K` clears residue a longer previous line left behind, so it is
- * only meaningful when the line is narrower than the terminal. A line that already
- * fills `cols` columns ends with the cursor in the pending-wrap state, where some
- * terminals run EL from the LAST column and erase the cell just written; those
- * rows get no EL. Width is measured exactly as Ink measures it (`string-width` over
- * the ANSI-stripped text) and only for rows that changed, so it costs at most one
- * measurement per changed viewport row. `cols` unknown => the original always-EL.
- */
-function paintLine(row, line, cols) {
-    const head = cursorTo(row) + SGR_RESET + line + SGR_RESET;
-    if (cols !== undefined && stringWidth(stripAnsi(line)) >= cols)
-        return head;
-    return head + ERASE_TO_EOL;
-}
-/**
- * Rebuild `ansiEscapes.eraseLines(count)` byte for byte.
- *
- * Exported for the upgrade tripwire (`frame-differ-ink-shape.test.ts`), which
- * drives the real `ink/build/log-update.js` and asserts this reconstruction is
- * byte-equal to what it produced. If a future Ink changes the shape, that test
- * fails loudly instead of this module silently degrading to pass-through for the
- * rest of the package's life (K-2).
- */
-export function eraseLinesPrefix(count) {
-    if (count <= 0)
-        return '';
-    let out = '';
-    for (let i = 0; i < count; i += 1) {
-        out += ERASE_LINE + (i < count - 1 ? CURSOR_UP_1 : '');
-    }
-    return out + CURSOR_LEFT;
-}
-export function createFrameDiffer(options) {
-    /**
-     * Last frame AS PAINTED — what is actually on the screen.
-     *
-     * `null` = no cache, next frame is a full repaint. THE DIFF COMPARES PAINTED
-     * LINES (I-2): diffing raw against a painted screen would leave the highlight
-     * burned into rows the next frame never repaints, because those rows' RAW text
-     * did not change.
-     */
-    let prev = null;
-    /**
-     * The same frame UNDECORATED — `repaint()`'s input.
-     *
-     * Two caches rather than one, because a repaint has to re-run `decorate` over
-     * the ORIGINAL rows: painting an already-painted row would nest the selection
-     * escapes and the highlight would never come off.
-     */
-    let rawPrev = null;
-    /**
-     * Whether any chunk has been seen at all.
-     *
-     * The session's FIRST write has `previousLineCount === 0`, so `eraseLines(0)`
-     * is the empty string and the chunk carries no erase prefix (§3.2.1). That is
-     * expected, not a desync, so it must not raise the §5.6 notice on every launch.
-     * After it, every chunk Ink produces carries a prefix, so a prefix-less chunk
-     * from then on really is foreign.
-     */
-    let seenAnyChunk = false;
-    const counters = {
-        framesTotal: 0,
-        framesDiffed: 0,
-        framesFull: 0,
-        linesWritten: 0,
-        bytesWritten: 0,
-        fallbacks: 0,
-        repaints: 0,
-    };
-    /**
-     * Re-entrancy guard for `onInvalidate`. The listener clears the selection,
-     * which asks for a repaint, which can reach `invalidate()` again; one flag is
-     * cheaper than reasoning about how deep that can go.
-     */
-    let notifying = false;
-    const invalidate = () => {
-        prev = null;
-        rawPrev = null;
-        if (notifying || !options.onInvalidate)
-            return;
-        notifying = true;
-        try {
-            options.onInvalidate();
-        }
-        finally {
-            notifying = false;
-        }
-    };
-    /**
-     * `decorate`, with the line-count contract enforced. A decorator that returned
-     * a different number of rows would shift every absolute address below it for
-     * the rest of the session, so its answer is discarded rather than trusted.
-     */
-    const applyDecorate = (lines) => {
-        if (!options.decorate)
-            return lines;
-        const painted = options.decorate(lines);
-        return painted.length === lines.length ? painted : lines;
-    };
-    /**
-     * Write `chunk` verbatim — today's behaviour, and the only failure mode.
-     *
-     * `counted` is false for the two cases the differ inflicts on itself and knows
-     * are harmless (the seed write, degenerate geometry); true means a foreign
-     * write desynced absolute addressing, which is what `fallbacks` reports.
-     */
-    const passThrough = (counted) => {
-        invalidate();
-        if (counted) {
-            counters.fallbacks += 1;
-            if (counters.fallbacks === 1)
-                options.onFirstFallback?.();
-        }
-        return null;
-    };
-    const wrapSync = (payload) => options.sync ? SYNC_BEGIN + payload + SYNC_END : payload;
-    const emit = (payload, lines, raw, addressed, full) => {
-        prev = lines;
-        rawPrev = raw;
-        counters.framesTotal += 1;
-        if (full)
-            counters.framesFull += 1;
-        else
-            counters.framesDiffed += 1;
-        counters.linesWritten += addressed;
-        counters.bytesWritten += payload.length;
-        return payload;
-    };
-    /** `undefined` ⇒ the I-9 stand-down: a viewport too small to address safely. */
-    const usableRows = () => {
-        const rows = options.rows();
-        if (rows === undefined || !Number.isFinite(rows))
-            return undefined;
-        return rows < MIN_FULLSCREEN_ROWS ? undefined : rows;
-    };
-    const matchErasePrefix = (chunk) => {
-        if (prev !== null) {
-            const expected = eraseLinesPrefix(prev.length + 1);
-            if (chunk.startsWith(expected))
-                return { prefix: expected, erased: prev.length + 1 };
-        }
-        return matchInkErasePrefix(chunk);
-    };
-    /**
-     * Full repaint — the first diffable frame of a session, every invalidation
-     * (including the resize invalidation of I-8), and any line-count change.
-     *
-     * `CSI J` replaces the H+1 individual line erases with one sequence, and the
-     * alternate screen is exactly the region being erased. `\r\n` rather than `\n`
-     * is deliberate: Ink relies on the tty's `ONLCR` post-processing to turn `\n`
-     * into CRLF, and that dependency is invisible until it is not there.
-     *
-     * P0-1's blank-then-paint objection does not apply here and the asymmetry with
-     * the per-line path is deliberate: a full repaint rewrites every row, so there
-     * is no unchanged content that has to survive, and full repaints are rare by
-     * construction — one per session, one per resize, one per invalidation.
-     */
-    const fullRepaint = (lines, raw) => {
-        const payload = cursorTo(1) +
-            SGR_RESET +
-            ERASE_DOWN +
-            lines.join('\r\n') +
-            '\r\n' +
-            cursorTo(lines.length + 1);
-        return emit(wrapSync(payload), lines, raw, lines.length, true);
-    };
-    /** Terminal width for this paint, or `undefined` when unknown (I-4: always EL). */
-    const liveCols = () => {
-        const cols = options.cols?.();
-        return cols !== undefined && Number.isFinite(cols) ? cols : undefined;
-    };
-    const diffRepaint = (lines, raw, previous) => {
-        const out = [];
-        const cols = liveCols();
-        for (let i = 0; i < lines.length; i += 1) {
-            // I-4: paint, THEN clear the tail. Never `ERASE_LINE` first.
-            if (lines[i] !== previous[i])
-                out.push(paintLine(i + 1, lines[i], cols));
-        }
-        // DEFENSIVE ONLY, not a live path (P2-4). `log-update.js:13-15` returns early
-        // on an identical frame, so a chunk that reaches here differs by at least one
-        // line; the only way to observe zero is a cache that disagrees with the
-        // screen, which is the state `invalidate()` exists to prevent.
-        //
-        // With a `decorate` hook it stops being unreachable in one direction and
-        // stays correct: a frame whose RAW rows changed only where the highlight
-        // already covers them paints identically, and writing nothing is right.
-        if (out.length === 0)
-            return emit('', lines, raw, 0, false);
-        out.push(cursorTo(lines.length + 1)); // I-5
-        return emit(wrapSync(out.join('')), lines, raw, out.length - 1, false);
-    };
-    /**
-     * Re-paint the last frame's rows through `decorate` again, emitting only what
-     * changed. Called when the SELECTION moved rather than when Ink produced a
-     * frame — hence its own counter and no touch of the frame ones (P2-6).
-     *
-     * It carries the same DEC 2026 sync envelope and parks on row `H + 1` as every
-     * other batch, because it is addressed exactly like a diff frame and a
-     * half-applied highlight tears the same way a half-applied frame does.
-     */
-    const repaint = () => {
-        if (prev === null || rawPrev === null)
-            return '';
-        const rows = usableRows();
-        if (rows === undefined)
-            return ''; // I-9 — geometry we cannot address safely
-        if (rawPrev.length + 1 > rows)
-            return '';
-        const painted = applyDecorate(rawPrev);
-        const out = [];
-        const cols = liveCols();
-        for (let i = 0; i < painted.length; i += 1) {
-            if (painted[i] !== prev[i])
-                out.push(paintLine(i + 1, painted[i], cols));
-        }
-        prev = painted;
-        if (out.length === 0)
-            return '';
-        out.push(cursorTo(painted.length + 1)); // I-5
-        counters.repaints += 1;
-        return wrapSync(out.join(''));
-    };
-    const transform = (chunk) => {
-        // A+ · Ink's tall-frame write (see CLEAR_TERMINAL above): a shrink makes
-        // `outputHeight >= stdout.rows` while the tree still holds the old height,
-        // so Ink bypasses log-update and writes clearTerminal + frame in one chunk.
-        // The chunk paints the whole frame by itself, so it needs no parsing: pass
-        // it through, drop the cache (the screen it described is gone), and do NOT
-        // count it — this is Ink's own write at a moment absolute addressing cannot
-        // cover, not something behind Ink's back. The next log-update frame lands
-        // on an empty cache and is a full repaint, exactly what a cleared screen
-        // needs. Checked BEFORE the seed bookkeeping — and it must be, because the
-        // tall-frame write bypasses `this.log`: log-update's own
-        // `previousLineCount` stays 0, so the first log-update frame after it still
-        // carries no erase prefix. THAT write is the session's genuine seed frame
-        // (P1-1), and a control write arriving first must not spend its exemption.
-        if (chunk.startsWith(CLEAR_TERMINAL))
-            return passThrough(false);
-        const firstChunk = !seenAnyChunk;
-        seenAnyChunk = true;
-        const rows = usableRows();
-        if (rows === undefined)
-            return passThrough(false); // I-9
-        const matched = matchErasePrefix(chunk);
-        // A prefix-less chunk is the session's seed write (P1-1) or a foreign one.
-        if (matched === null)
-            return passThrough(!firstChunk);
-        const body = chunk.slice(matched.prefix.length);
-        if (!body.endsWith('\n'))
-            return passThrough(true); // `log.clear()` and friends
-        const lines = body.slice(0, -1).split('\n');
-        if (lines.length + 1 > rows)
-            return passThrough(false); // I-9
-        // AFTER the geometry stand-down, BEFORE the cache comparison: a frame this
-        // module refuses to address never reaches the selection layer, and what is
-        // compared below is what the screen will hold.
-        const painted = applyDecorate(lines);
-        if (prev === null || prev.length !== painted.length || matched.erased !== prev.length + 1) {
-            return fullRepaint(painted, lines);
-        }
-        return diffRepaint(painted, lines, prev);
-    };
-    return {
-        transform,
-        invalidate,
-        repaint,
-        stats: () => ({ ...counters }),
-    };
-}

package/dist/ui/frame-observer.d.ts

@@ -1,17 +0,0 @@
-import type { ScrollbarBridge } from './scrollbar-controller.js';
-export interface FrameSummary {
-    columns: number;
-    rows: number;
-    trackTop: number;
-    trackRows: number;
-}
-/** Observe before differ transformation, but acknowledge only after downstream write returns. */
-export declare function createFrameObserver(options: {
-    stdout: NodeJS.WriteStream;
-    terminal: NodeJS.WriteStream;
-    scrollbar: ScrollbarBridge;
-}): {
-    stdout: NodeJS.WriteStream;
-    dispose(): void;
-    invalidate(): void;
-};

package/dist/ui/frame-observer.js

@@ -1,94 +0,0 @@
-import stripAnsi from 'strip-ansi';
-import stringWidth from 'string-width';
-import { parseInkFrame } from './frame-parser.js';
-import { pickGlyphs } from './glyphs.js';
-function summarizeFrame(chunk, rows, cols) {
-    const lines = typeof chunk === 'string' ? parseInkFrame(chunk) : null;
-    if (!lines || rows < 12 || cols < 40 || lines.length !== rows - 1)
-        return null;
-    const unicode = pickGlyphs({ unicode: true, colorLevel: 0 });
-    const cells = new Set(['|', '#', unicode.scrollTrack, unicode.scrollThumb]);
-    const plain = lines.map((line) => stripAnsi(line));
-    if (plain.some((line) => stringWidth(line) > cols))
-        return null;
-    let trackRows = 0;
-    // Fixed composer/status slots have no last-column rail. Discover the actual
-    // message track, then acknowledge it only against the published Yoga geometry.
-    for (const line of plain.slice(1)) {
-        if (stringWidth(line) !== cols || !cells.has(line.slice(-1)))
-            break;
-        trackRows++;
-    }
-    if (trackRows < 1)
-        return null;
-    return { columns: cols, rows, trackTop: 2, trackRows };
-}
-/** Observe before differ transformation, but acknowledge only after downstream write returns. */
-export function createFrameObserver(options) {
-    const { stdout, terminal, scrollbar } = options;
-    let summary = null;
-    let summaryRevision;
-    let disposed = false;
-    let resizeTimer = null;
-    const invalidate = () => { summary = null; scrollbar.invalidate(); };
-    const onResize = () => {
-        invalidate();
-        if (resizeTimer)
-            clearTimeout(resizeTimer);
-        // Ink suppresses identical frames when a resize burst returns to its starting size.
-        // Wait past the 50 ms React size debounce, then request a normal redraw if needed.
-        resizeTimer = setTimeout(() => {
-            resizeTimer = null;
-            if (!disposed && !scrollbar.frameReady)
-                scrollbar.requestRedraw?.();
-        }, 60);
-        resizeTimer.unref?.();
-    };
-    const match = () => {
-        const g = scrollbar.geometry;
-        if (summary && g && summaryRevision === undefined)
-            summaryRevision = g.revision;
-        scrollbar.frameReady = !!summary && !!g && summary.columns === terminal.columns &&
-            summary.rows === terminal.rows && g.trackCol === summary.columns &&
-            g.trackTop === summary.trackTop && g.trackRows === summary.trackRows &&
-            g.revision === summaryRevision;
-    };
-    const observe = (chunk) => {
-        summary = summarizeFrame(chunk, terminal.rows, terminal.columns);
-        summaryRevision = scrollbar.geometry?.revision;
-        if (!summary) {
-            invalidate();
-            return;
-        }
-        match();
-    };
-    scrollbar.onGeometry = match;
-    terminal.on('resize', onResize);
-    const bound = new Map();
-    const proxy = new Proxy(stdout, {
-        get(target, prop) {
-            if (prop === 'write')
-                return (...args) => {
-                    const result = Reflect.apply(target.write, target, args);
-                    if (!disposed)
-                        observe(args[0]);
-                    return result;
-                };
-            const value = Reflect.get(target, prop, target);
-            if (typeof value !== 'function')
-                return value;
-            if (!bound.has(prop))
-                bound.set(prop, value.bind(target));
-            return bound.get(prop);
-        },
-    });
-    return { stdout: proxy, invalidate, dispose: () => {
-            disposed = true;
-            if (resizeTimer)
-                clearTimeout(resizeTimer);
-            resizeTimer = null;
-            terminal.off('resize', onResize);
-            scrollbar.onGeometry = undefined;
-            invalidate();
-        } };
-}

package/dist/ui/frame-parser.d.ts

@@ -1,7 +0,0 @@
-/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
-export declare function matchInkErasePrefix(chunk: string): {
-    prefix: string;
-    erased: number;
-} | null;
-/** Parse complete frames, including Ink's prefixless initial frame. */
-export declare function parseInkFrame(chunk: string): string[] | null;

package/dist/ui/frame-parser.js

@@ -1,18 +0,0 @@
-/** Recognize Ink's erase-lines prefix without accepting arbitrary control writes. */
-export function matchInkErasePrefix(chunk) {
-    const match = /^(?:\x1b\[2K(?:\x1b\[1A)?)+\x1b\[G/.exec(chunk);
-    return match ? { prefix: match[0], erased: match[0].split('\x1b[2K').length - 1 } : null;
-}
-/** Parse complete frames, including Ink's prefixless initial frame. */
-export function parseInkFrame(chunk) {
-    const prefix = matchInkErasePrefix(chunk);
-    const body = chunk.slice(prefix?.prefix.length ?? 0);
-    if (!body.endsWith('\n'))
-        return null;
-    // SGR and OSC-8 may decorate text; cursor movement is never frame content.
-    const controls = body.replace(/\x1b\[[0-9;:]*m/g, '')
-        .replace(/\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
-    if (/[\x00-\x08\x0b-\x1f\x7f]/.test(controls))
-        return null;
-    return body.slice(0, -1).split('\n');
-}

package/dist/ui/gauge.d.ts

@@ -1,39 +0,0 @@
-/**
- * Context gauge builder (spec §3.4). Pure: turns a percentage into a block bar
- * plus a threshold-based fill colour, with an ASCII fallback when the terminal
- * has no Unicode. Kept out of the `.tsx` so it is unit-testable without Ink.
- */
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-export interface Gauge {
-    /** The filled portion of the bar. */
-    filled: string;
-    /** The empty (track) portion of the bar. */
-    empty: string;
-    /** Fill colour chosen by threshold (`theme.gauge.*`). */
-    fillColor: string | undefined;
-    /** Track colour (`theme.gauge.track`). */
-    trackColor: string | undefined;
-    /** Clamped percentage 0–100. */
-    pct: number;
-}
-/**
- * Where the bar changes colour, as percentages.
- *
- * The defaults are the values this function hardcoded before context compaction
- * existed, so every existing call site and test is byte-identical (§6.2).
- */
-export interface GaugeMarks {
-    /** Amber at or above this. */
-    warn: number;
-    /** Red strictly above this. */
-    high: number;
-}
-/**
- * Build a `width`-cell gauge for `pct` (0–100). Uses block glyphs on Unicode
- * terminals and `#`/`-` otherwise (e.g. `[######----]`).
- *
- * `marks` is OPTIONAL and defaults to today's values, so omitting it produces
- * byte-identical output to the pre-compaction build.
- */
-export declare function buildGauge(pct: number, width: number, theme: Theme, caps: TermCapabilities, marks?: GaugeMarks): Gauge;

package/dist/ui/gauge.js

@@ -1,55 +0,0 @@
-/**
- * Context gauge builder (spec §3.4). Pure: turns a percentage into a block bar
- * plus a threshold-based fill colour, with an ASCII fallback when the terminal
- * has no Unicode. Kept out of the `.tsx` so it is unit-testable without Ink.
- */
-import { pickGlyphs } from './glyphs.js';
-const DEFAULT_MARKS = { warn: 60, high: 85 };
-/**
- * Pick the fill colour by threshold: `< warn` low · `>= warn` mid · `> high` high.
- *
- * THE TWO OPERATORS ARE PRESERVED EXACTLY (`> high`, `>= warn`), and that is not
- * cosmetic: changing either would move the default 85 or 60 boundary and break
- * the byte-identity claim that makes the `marks` parameter a free change.
- *
- * WHAT RED MEANS, PRECISELY (P2-4). The compaction trigger is
- * `ratio >= threshold` (INCLUSIVE) while this fill is `pct > high` (EXCLUSIVE),
- * so with `high = threshold` any occupancy that would render red has ALREADY
- * triggered compaction, and the gauge repaints downward in the same frame. The
- * red band is therefore only ever OBSERVABLE when compaction did not or could
- * not run — the feature is off, it self-disabled, or the failure ladder ended at
- * its last rung. That is a genuinely more useful meaning than "imminent", and it
- * is the one the README and the settings screen state.
- */
-function thresholdColor(pct, theme, marks) {
-    if (pct > marks.high)
-        return theme.gauge.high;
-    if (pct >= marks.warn)
-        return theme.gauge.mid;
-    return theme.gauge.low;
-}
-/**
- * Build a `width`-cell gauge for `pct` (0–100). Uses block glyphs on Unicode
- * terminals and `#`/`-` otherwise (e.g. `[######----]`).
- *
- * `marks` is OPTIONAL and defaults to today's values, so omitting it produces
- * byte-identical output to the pre-compaction build.
- */
-export function buildGauge(pct, width, theme, caps, marks = DEFAULT_MARKS) {
-    const clamped = Math.max(0, Math.min(100, Math.round(pct)));
-    const cells = Math.max(1, width);
-    const filledCells = Math.max(0, Math.min(cells, Math.round((clamped / 100) * cells)));
-    // Was `caps.unicode ? '█' : '#'` inline. The branch was correct but the
-    // literals still had to move: leaving even a well-formed pair here would mean
-    // the A-1 scan needs an exception, and exceptions get copied (§4.1).
-    const glyphs = pickGlyphs(caps);
-    const full = glyphs.gaugeFull;
-    const empty = glyphs.gaugeEmpty;
-    return {
-        filled: full.repeat(filledCells),
-        empty: empty.repeat(cells - filledCells),
-        fillColor: thresholdColor(clamped, theme, marks),
-        trackColor: theme.gauge.track,
-        pct: clamped,
-    };
-}