@aragon-agent/cli 0.6.46 → 0.6.48

package/dist/ui/Transcript.js

@@ -1,251 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/** Virtualized full-screen transcript and entry cards. */
-/** Virtualized full-screen transcript and shared entry cards. */
-import React, { useCallback } from 'react';
-import { Box, Text } from 'ink';
-import Spinner from 'ink-spinner';
-import { pickGlyphs, toolGlyph } from './glyphs.js';
-import { separationRows } from './density.js';
-import { EntryFrame } from './entries/EntryFrame.js';
-import { UserEntry } from './entries/UserEntry.js';
-import { InvocationCard } from './entries/InvocationCard.js';
-import { QueuedEntry } from './entries/QueuedEntry.js';
-import { AssistantEntry } from './entries/AssistantEntry.js';
-import { ToolCard, statusColor, toolEntryGlyph } from './entries/ToolCard.js';
-import { TeamCard, teamCardColor } from './entries/TeamCard.js';
-import { GovernanceCard, governanceCardColor } from './entries/GovernanceCard.js';
-import { isLiveTeamCard, rosterCounts } from './team-status.js';
-import { TodoCard, todoCardColor } from './entries/TodoCard.js';
-import { RetryCard, retryCardColor } from './entries/RetryCard.js';
-import { FastCard, fastCardColor } from './entries/FastCard.js';
-import { CompactionCard, compactionCardColor } from './entries/CompactionCard.js';
-import { ServiceCard, serviceCardColor, serviceGlyph } from './entries/ServiceCard.js';
-import { MeasuredEntry } from './layout/MeasuredEntry.js';
-import { useViewportGeometry } from './layout/viewport-geometry.js';
-import { estimateEntryRows, heightKey, selectWindow, VIRTUAL_LIMITS, } from './layout/virtual-window.js';
-import { advanceTailRows } from './layout/follow-state.js';
-/**
- * The value `EntryView` should receive for `nowSec` on THIS entry.
- *
- * `undefined` for everything that is not a running tool, which is what keeps
- * every other card's memo boundary intact — `undefined === undefined` in the
- * comparator, on every frame, forever.
- *
- * EXPORTED for `ui/scrollback/LiveTail.tsx` (release-gate-and-native-panels §6.5), and
- * that is the whole of this feature's change to this file: the live region mounts the
- * same `EntryView` the transcript does, so it must feed it the same per-entry clock.
- * A copy of this rule in the band would be a second answer to "does this card tick?"
- * and the two would disagree the first time a consumer is added.
- */
-export function nowSecFor(entry, nowSec) {
-    if (entry.kind === 'tool' && entry.status === 'running')
-        return nowSec;
-    // THE LIVE COMPACTION CARD IS THE SECOND CONSUMER (hardening W5). It is at most
-    // ONE entry in the whole transcript, and it settles - so the memo boundary this
-    // function protects is unchanged for every other card, forever.
-    if (entry.kind === 'compaction' && entry.live)
-        return nowSec;
-    // THE FOURTH CONSUMER IS A LIVE DISPATCH CARD (tui-subagent-double-roster A-1):
-    // a child's elapsed time must advance while it works, and `TeamCard` reads this
-    // same 1 Hz clock instead of a second `Date.now()` per render. A suppressed card
-    // never mounts, so this only keeps the reading honest for a directly mounted one.
-    if (entry.kind === 'team' && entry.active)
-        return nowSec;
-    // THE THIRD CONSUMER IS A LIVE JOB (long-task-jobs D-8), and it is the reason
-    // this stays a single 1 Hz clock: a task's elapsed time and its `no output`
-    // badge both have to move, and a per-card `setInterval` would be one timer per
-    // job. `terminal` entries are excluded so a settled record never re-renders.
-    if (entry.kind === 'service' && !entry.terminal)
-        return nowSec;
-    return undefined;
-}
-function noticeColor(level, theme) {
-    if (level === 'error')
-        return theme.noticeError;
-    if (level === 'warn')
-        return theme.noticeWarn;
-    return theme.noticeInfo;
-}
-function noticeSymbol(level, theme) {
-    if (level === 'error')
-        return theme.symbols.error;
-    if (level === 'warn')
-        return theme.symbols.warn;
-    return theme.symbols.info;
-}
-function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion, density, theme, caps, nowSec, }) {
-    const glyphs = pickGlyphs(caps);
-    const separation = separationRows(prev, entry, density);
-    const frame = (glyph, color, children) => (_jsx(EntryFrame, { glyph: glyph, color: color, continuation: glyphs.railVertical, separation: separation, spacerColor: theme.border, children: children }));
-    switch (entry.kind) {
-        case 'user':
-            return frame(glyphs.user, theme.user, entry.invocation
-                ? _jsx(InvocationCard, { card: entry.invocation, theme: theme, caps: caps })
-                : _jsx(UserEntry, { text: entry.text, theme: theme, caps: caps }));
-        case 'queued':
-            // `theme.muted`: quieter than a user message, louder than a notice --
-            // the row exists to be noticed UNTIL it is accepted, then rewritten in
-            // place by `turnStart` (5.2.3).
-            return frame(glyphs.queued, theme.muted, _jsx(QueuedEntry, { text: entry.text, theme: theme, caps: caps }));
-        case 'assistant': {
-            // Render-layer backstop for the reducer prune (defect 5) - the reducer is the
-            // source of truth, and this only catches a settled, entirely empty bubble
-            // that reached here some other way. Returned BEFORE `frame(...)`, so neither
-            // the glyph row nor the separation row is drawn.
-            if (!entry.streaming && entry.text.trim() === '' && (entry.thinking ?? '').trim() === '') {
-                return null;
-            }
-            const animate = entry.streaming && !reducedMotion && caps.unicode;
-            return frame(animate ? _jsx(Spinner, { type: "dots" }) : glyphs.assistant, theme.primary, _jsx(AssistantEntry, { text: entry.text, thinking: entry.thinking, thinkingOpen: entry.thinkingOpen, thinkingVisible: thinkingVisible, streaming: entry.streaming, aborted: entry.aborted, 
-                // `EntryViewImpl` hands each renderer EXPLICIT SCALAR PROPS, so
-                // nothing on the entry reaches a component by itself (P1-6b).
-                thinkingMs: entry.thinkingMs, theme: theme, caps: caps }));
-        }
-        case 'tool':
-            return frame(toolEntryGlyph(entry.name, caps), statusColor(entry.status, theme), _jsx(ToolCard, { name: entry.name, label: entry.label, argsRaw: entry.argsRaw, args: entry.args, status: entry.status, preview: entry.preview, patch: entry.patch, durationMs: entry.durationMs, isError: entry.isError, expanded: expanded, reducedMotion: reducedMotion, 
-                // `entry.live` AND NOT `entry.live ?? []` (P2-4): `ToolCard`'s default
-                // comparator sees a fresh `[]` as a changed prop, which is why that
-                // file already keeps a shared `EMPTY_LINES`.
-                live: entry.live, lastOutputAt: entry.lastOutputAt, nowSec: nowSec, theme: theme, caps: caps }));
-        case 'team': {
-            // THE LIVE DISPATCH HAS EXACTLY ONE SURFACE (tui-subagent-double-roster A-2):
-            // while `active`, the roster (`TeamPanel`) is the only live subagent block, so
-            // the transcript draws nothing for this entry and the card appears - once - as
-            // history the moment the dispatch settles. Returning BEFORE `frame(...)` draws
-            // neither the rail marker nor the separation row.
-            //
-            // `renderer.tsx`'s offscreen measurement goes through THIS function too, which is
-            // what makes the native print pump's `measureWindow` agree with the frame for
-            // free. `estimateEntryRows` carries the same predicate (0 rows), so no other
-            // arithmetic has to know about the suppression.
-            if (isLiveTeamCard(entry))
-                return null;
-            return frame(glyphs.teamAgent, teamCardColor(rosterCounts(entry.runs), entry.active, entry.aborted, theme), _jsx(TeamCard, { requested: entry.requested, runs: entry.runs, aborted: entry.aborted, durationMs: entry.durationMs, active: entry.active, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps, nowSec: nowSecFor(entry, nowSec) }));
-        }
-        case 'governance':
-            return frame(glyphs.teamAgent, governanceCardColor(entry.card, theme), _jsx(GovernanceCard, { card: entry.card, theme: theme, caps: caps }));
-        case 'todo':
-            return frame(toolGlyph(glyphs, 'todo_write'), todoCardColor(entry.doneCount, entry.total, entry.live, theme), _jsx(TodoCard, { items: entry.items, doneCount: entry.doneCount, total: entry.total, acceptance: entry.acceptance ?? null, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
-        case 'retry':
-            return frame(entry.phase === 'exhausted' ? glyphs.error : glyphs.retry, retryCardColor(entry.phase, theme), _jsx(RetryCard, { attempt: entry.attempt, maxRetries: entry.maxRetries, errorType: entry.errorType, phase: entry.phase, resumeAt: entry.resumeAt, totalRetries: entry.totalRetries, elapsedMs: entry.elapsedMs, 
-                // READ HERE, not threaded from `App`, and that is what keeps the memo
-                // boundary intact: a `now` prop on every `EntryView` would change on
-                // every frame and re-render the whole transcript. The `retryTick` action
-                // refreshes THIS entry's identity once a second, which re-renders this
-                // one card and gives it a fresh clock; nothing else moves.
-                now: Date.now(), 
-                // NOT THREADED FROM `App`: reaching this renderer means a TUI is
-                // mounted, and the TUI always binds Esc to abort. Headless mode writes
-                // its retry lines to stderr and never mounts an entry component, and the
-                // exit replay goes through `transcript-text.ts`. `RetryCard` keeps the
-                // prop so the render tests can assert the suppressed form.
-                reducedMotion: reducedMotion, theme: theme, caps: caps }));
-        case 'fast':
-            return frame(entry.status === 'failed' ? glyphs.toolError : glyphs.teamAgent, fastCardColor(entry.status, theme), _jsx(FastCard, { reviewIndex: entry.reviewIndex, model: entry.model, status: entry.status, text: entry.text, detail: entry.detail, turn: entry.turn, durationMs: entry.durationMs, live: entry.live, reducedMotion: reducedMotion, theme: theme, caps: caps }));
-        case 'compaction':
-            return frame(entry.applied || entry.live ? glyphs.compaction : glyphs.toolError, compactionCardColor(entry, theme), _jsx(CompactionCard, { index: entry.index, decision: entry.decision, memoryVersion: entry.memoryVersion, trigger: entry.trigger, mode: entry.mode, applied: entry.applied, reason: entry.reason, messagesBefore: entry.messagesBefore, messagesAfter: entry.messagesAfter, tokensBefore: entry.tokensBefore, tokensAfter: entry.tokensAfter, summary: entry.summary, model: entry.model, durationMs: entry.durationMs, tailRelief: entry.tailRelief, phase: entry.phase, keepRelaxed: entry.keepRelaxed, retainedTurns: entry.retainedTurns, retainedMessages: entry.retainedMessages, keepRecentTurnsUsed: entry.keepRecentTurnsUsed, elidedMessages: entry.elidedMessages, 
-                // ONLY WHILE LIVE, and only when the clock has ticked at least once:
-                // `nowSec` is `undefined` until then, and a settled card must keep
-                // rendering `durationMs` rather than a figure that would drift.
-                elapsedMs: entry.live && nowSec !== undefined && entry.startedAt !== undefined
-                    ? Math.max(0, nowSec * 1000 - entry.startedAt)
-                    : undefined, live: entry.live, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
-        case 'service':
-            return frame(serviceGlyph(entry, glyphs), serviceCardColor(entry, theme), _jsx(ServiceCard, { serviceId: entry.serviceId, jobKind: entry.jobKind, command: entry.command, status: entry.status, url: entry.url, port: entry.port, exitCode: entry.exitCode, startedAt: entry.startedAt, readyAt: entry.readyAt, endedAt: entry.endedAt, rows: entry.rows, terminal: entry.terminal, killIncomplete: entry.killIncomplete, progress: entry.progress, stalled: entry.stalled, lastOutputAt: entry.lastOutputAt, nowSec: nowSec, expanded: expanded, reducedMotion: reducedMotion, theme: theme, caps: caps }));
-        case 'notice':
-            return frame(noticeSymbol(entry.level, theme), noticeColor(entry.level, theme), _jsx(Text, { color: noticeColor(entry.level, theme), children: entry.text }));
-        default:
-            return null;
-    }
-}
-/**
- * THE memo boundary that makes a long transcript cheap (L2 / R3).
- *
- * The comparator is written out rather than defaulted because `prev` is the one
- * prop whose identity matters for a reason the type does not show: it feeds
- * `separationRows`, so an entry whose PREDECESSOR changed kind must re-render
- * even though the entry itself did not.
- *
- * I-L2-1 — `theme` and `caps` are `useMemo`d in `App.tsx` and are therefore
- * referentially stable across frames. If a future change makes either a fresh
- * object per render, EVERY boundary below becomes a no-op AND NOTHING FAILS;
- * `render-memo.test.tsx` asserts that stability directly so the trap is a red
- * test rather than a silent regression.
- */
-export const EntryView = React.memo(EntryViewImpl, (a, b) => {
-    return (a.entry === b.entry &&
-        a.prev === b.prev &&
-        a.expanded === b.expanded &&
-        a.thinkingVisible === b.thinkingVisible &&
-        a.reducedMotion === b.reducedMotion &&
-        a.density === b.density &&
-        a.theme === b.theme &&
-        a.caps === b.caps &&
-        /*
-         * ELEVENTH TERM, AND OMITTING IT IS THE TRAP I-L2-1 DESCRIBES ONE COMMENT UP
-         * (P1-3). This comparator is a CLOSED LIST: a prop absent from it changes
-         * without invalidating the boundary, so `ToolCard` is never re-rendered and
-         * the stall row freezes at whatever second it first drew — AC-26's "and the
-         * seconds advance" failing with nothing reporting it.
-         *
-         * It is free: `nowSecFor` returns `undefined` for every entry that is not a
-         * running tool, and `undefined === undefined` on every frame.
-         */
-        a.nowSec === b.nowSec);
-});
-export function TranscriptList({ entries, expandedToolIds, thinkingVisible, reducedMotion, density, nowSec, theme, caps, windowSize, cols, heights, mountedSink, tailSink, }) {
-    const size = Math.max(1, Math.floor(windowSize));
-    const visible = entries.length > size ? entries.slice(-size) : entries;
-    const collapsed = entries.length - visible.length;
-    const glyphs = pickGlyphs(caps);
-    const geometry = useViewportGeometry();
-    // Ctrl+T changes every assistant entry's height without changing any entry,
-    // so it has to reach the cache key or the spacers freeze at the wrong size.
-    const flags = thinkingVisible ? 't' : '';
-    // ONE key builder, shared by the lookup below and by `MeasuredEntry`'s report.
-    // Two spellings of the same key is a SILENT failure and not a compile error:
-    // the measurement lands under a key `resolve` never asks for, every entry
-    // falls back to its estimate for the rest of the session, and the spacers
-    // quietly encode heights nothing will ever correct.
-    const keyOf = (entry) => heightKey(entry, cols, !!expandedToolIds[entry.id], density, flags);
-    const { resolve, report } = heights;
-    const heightOf = useCallback((index) => {
-        const entry = visible[index];
-        // `thinkingVisible` IS PASSED, not left to the parameter's conservative
-        // default (P1-6a / condition 5). With thinking hidden the default would
-        // inflate every assistant entry that thought by its whole wrapped length,
-        // and an entry estimated at 400 rows against a real height of 1 is exactly
-        // the one `selectWindow` then never mounts and never re-measures.
-        return resolve(keyOf(entry), () => estimateEntryRows(entry, cols, density, !!expandedToolIds[entry.id], thinkingVisible));
-    }, 
-    // Memoised only incidentally: `visible` IS `entries` while the session is
-    // shorter than the horizon and a fresh slice once it is past it, so this
-    // rebuilds on some frames and not others. Either is correct — `selectWindow`
-    // consumes it synchronously below and it is never handed to a child — and
-    // `keyOf` is omitted from the list because every input it closes over is
-    // already in it.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [visible, expandedToolIds, cols, density, flags, resolve, thinkingVisible]);
-    const selection = selectWindow({
-        entries: visible,
-        heightOf,
-        viewportRows: geometry.viewportRows,
-        trailingContentRows: geometry.trailingContentRows,
-        offset: geometry.offset,
-        overscan: VIRTUAL_LIMITS.overscan,
-    });
-    const slice = visible.slice(selection.startIndex, selection.endIndex);
-    if (mountedSink)
-        mountedSink.current = slice.length;
-    // One more pass over the array `selectWindow` has already walked, reading the
-    // SAME height table and never the geometry context (§4.3.1a). `visible` is
-    // what is drawn, so its last entry is the tail; entries the horizon dropped are
-    // not "removed rows" and must not register as one.
-    if (tailSink) {
-        tailSink.current = advanceTailRows(tailSink.current, visible.map((entry) => entry.id), heightOf);
-    }
-    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [collapsed > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.hintFg ?? theme.muted, children: [glyphs.ellipsis, " ", collapsed, " earlier ", collapsed === 1 ? 'entry' : 'entries', " collapsed (/save exports the full session)"] })), selection.leadingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.leadingRows })), slice.map((entry, i) => {
-                const index = selection.startIndex + i;
-                return (_jsx(MeasuredEntry, { heightKey: keyOf(entry), onMeasure: report, children: _jsx(EntryView, { entry: entry, prev: index > 0 ? visible[index - 1] : undefined, expanded: !!expandedToolIds[entry.id], thinkingVisible: thinkingVisible, reducedMotion: reducedMotion, density: density, nowSec: nowSecFor(entry, nowSec), theme: theme, caps: caps }) }, entry.id));
-            }), selection.trailingRows > 0 && (_jsx(Box, { flexShrink: 0, height: selection.trailingRows }))] }));
-}

package/dist/ui/UpdateLine.d.ts

@@ -1,44 +0,0 @@
-/**
- * The update line (cli-auto-update section 6.2) - the THIRD occupant of the
- * already-budgeted bottom row, after the toast stack and the activity line.
- *
- * ONE ROW, ALWAYS, AND NEVER `null` (C-15 / P0-1 / D-19). The return type is
- * `React.ReactElement` rather than `React.ReactElement | null`, so the compiler
- * refuses the shortcut: `BottomStatusRow` decides presence with `if (update)`,
- * which tests a REACT ELEMENT, and an element whose render returns `null` is
- * still truthy. Taking that branch would emit a box of ZERO rows - the frame
- * keeps its fixed height, Yoga hands the row to the transcript, and
- * `viewportRows()` goes on reporting the old number to `ScrollViewport`,
- * `selectWindow`, `overlayMaxRows`, `popupMaxRows` and `buildTodoRailLayout`. The
- * transcript would gain a row while the updater is idle and lose it the moment
- * it has news. Presence is the CALLER's decision, through
- * `shouldRenderUpdateLine`, exactly as `App.tsx` already decides the activity
- * line's with `running && !overlayNode`.
- *
- * PURE: a function of `snapshot + compact + theme + caps`. No state, no timer,
- * no clock. `<Text wrap="truncate">` so a narrow terminal degrades by truncation
- * rather than by wrapping into a second row the fixed frame cannot afford.
- *
- * ASCII ONLY, and every user-visible character comes from `pickGlyphs(caps)`
- * (C-3). No literal `...`, `+` or `~` may be spelled inline - `ActivityLine`'s
- * routing of even the ellipsis through `pickGlyphs` is the precedent.
- *
- * `compact` RATHER THAN `cols` (IF-1). Section 6.2 describes the width tiers in
- * terms of `cols`, but resolving them here would mean importing
- * `UPDATE_LIMITS.statusCompactCols` - a VALUE - from `update/`, and section 3.1
- * rule 1 requires this module's only edge into that tree to be erasable by tsc.
- * The caller owns `UPDATE_LIMITS` already (it computes presence from it), so it
- * resolves the threshold too. Same rule as presence: the call site decides.
- */
-import React from 'react';
-import type { Theme } from './theme.js';
-import type { TermCapabilities } from './capabilities.js';
-import type { UpdateSnapshot } from '../update/types.js';
-export interface UpdateLineProps {
-    snapshot: UpdateSnapshot;
-    /** `cols < UPDATE_LIMITS.statusCompactCols`, resolved by the caller. */
-    compact: boolean;
-    theme: Theme;
-    caps: TermCapabilities;
-}
-export declare function UpdateLine({ snapshot, compact, theme, caps }: UpdateLineProps): React.ReactElement;

package/dist/ui/UpdateLine.js

@@ -1,129 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { pickGlyphs } from './glyphs.js';
-export function UpdateLine({ snapshot, compact, theme, caps }) {
-    const glyphs = pickGlyphs(caps);
-    const version = snapshot.latestVersion ?? snapshot.currentVersion;
-    const advice = snapshot.advice ?? '';
-    const dot = glyphs.midDot;
-    const line = (() => {
-        if (snapshot.phase === 'installing') {
-            return {
-                glyph: glyphs.arrowUp,
-                text: compact
-                    ? `${version}${glyphs.ellipsis}`
-                    : `updating to ${version}${glyphs.ellipsis}`,
-                color: theme.muted,
-            };
-        }
-        if (snapshot.phase === 'ready') {
-            return {
-                glyph: glyphs.check,
-                text: compact ? `${version} ready` : `${version} installed ${dot} restart aragon to apply`,
-                color: theme.toast.success,
-            };
-        }
-        if (snapshot.phase === 'failed') {
-            // H2's three classified failures (cli-auto-update-hardening section 8).
-            // Each names the REAL obstacle rather than the generic one, because each
-            // is allowed to break the three-strike silence and a notice that breaks
-            // silence must be worth the interruption.
-            if (snapshot.reason === 'blocked-by-os') {
-                // `npm i -g` FROM THE SAME SHELL HITS THE SAME HANDLE. On Windows the
-                // shim that launched us is being read by the `cmd.exe` running it for
-                // as long as our process lives, and npm's install rewrites that shim -
-                // so the generic advice is not merely unhelpful here, it is a wrong
-                // instruction (R-3 / section 5.3.1).
-                return {
-                    glyph: glyphs.warn,
-                    text: compact || !advice
-                        ? 'update blocked'
-                        : `update blocked ${dot} close other aragon windows, then: ${advice}`,
-                    color: theme.noticeWarn,
-                };
-            }
-            if (snapshot.reason === 'no-space') {
-                return {
-                    glyph: glyphs.warn,
-                    text: compact ? 'no disk space' : `update failed ${dot} no disk space`,
-                    color: theme.noticeWarn,
-                };
-            }
-            if (snapshot.reason === 'not-writable') {
-                return {
-                    glyph: glyphs.warn,
-                    text: compact || !advice
-                        ? 'update blocked'
-                        : `update needs write access ${dot} ${advice}`,
-                    color: theme.noticeWarn,
-                };
-            }
-            return {
-                glyph: glyphs.warn,
-                text: compact || !advice ? 'update failed' : `update failed ${dot} ${advice}`,
-                color: theme.noticeWarn,
-            };
-        }
-        if (snapshot.phase === 'available') {
-            if (snapshot.reason === 'node-too-old') {
-                // Both numbers or neither: "needs a newer Node" without saying which is
-                // a notice the user cannot act on.
-                const detail = snapshot.requiredNode && snapshot.runningNode
-                    ? `${version} needs Node ${snapshot.requiredNode} (running ${snapshot.runningNode})`
-                    : `${version} needs a newer Node`;
-                return {
-                    glyph: glyphs.warn,
-                    text: compact ? 'needs newer Node' : detail,
-                    color: theme.noticeWarn,
-                };
-            }
-            if (snapshot.reason === 'install-ineffective') {
-                return {
-                    glyph: glyphs.warn,
-                    text: compact
-                        ? 'check npm prefix'
-                        : `${version} installed elsewhere${advice ? ` ${dot} ${advice}` : ''}`,
-                    color: theme.noticeWarn,
-                };
-            }
-            return {
-                glyph: glyphs.arrowUp,
-                text: compact
-                    ? version
-                    : `${version} available${advice ? ` ${dot} ${advice}` : ''}`,
-                color: theme.muted,
-            };
-        }
-        // H1's rollback notice, and it goes HERE rather than in a phase branch
-        // (cli-auto-update-hardening section 8 / P0-1). It is true for a whole
-        // SESSION rather than for a phase, so `shouldRenderUpdateLine` decides its
-        // presence from `snapshot.rolledBackFrom` outside `phase` entirely - and the
-        // phases that leaves are exactly `idle` / `checking`, which is this
-        // fallthrough. An earlier draft put it in the `failed` / `available`
-        // branches and keyed it on phase `idle`, a phase neither branch handles;
-        // three independent suppressions, so the one line telling a user their CLI
-        // had been silently downgraded could never have appeared.
-        //
-        // NOT `version` ABOVE: that is `latestVersion ?? currentVersion`, and after
-        // a rollback `latestVersion` may well be the BAD release we just escaped.
-        if (snapshot.rolledBackFrom) {
-            const to = snapshot.rolledBackTo ?? snapshot.currentVersion;
-            return {
-                glyph: glyphs.warn,
-                text: compact
-                    ? 'rolled back'
-                    : `rolled back to ${to} after ${snapshot.rolledBackFrom} failed to start`,
-                color: theme.noticeWarn,
-            };
-        }
-        // `idle` / `checking`, and a `failed` below the notice threshold. The CALLER
-        // never mounts us here (`shouldRenderUpdateLine` is false), but the row must
-        // still be exactly one row if it ever is - the same blank-row discipline
-        // `ToastStack` applies to its own budgeted row.
-        return null;
-    })();
-    if (!line) {
-        return (_jsx(Box, { flexShrink: 0, children: _jsx(Text, { children: " " }) }));
-    }
-    return (_jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate", color: line.color, children: [' ', line.glyph, " ", line.text] }) }));
-}

package/dist/ui/activity-phrases.d.ts

@@ -1,33 +0,0 @@
-/**
- * The working line's vocabulary (agent-activity-presentation §3.2.1).
- *
- * PURE: no React, no Ink, no clock. Everything here is a function of the two
- * numbers the caller already has, which is what makes the rotation testable
- * without a terminal and without fake timers.
- */
-/** Rotation cadence. Long enough to read, short enough to prove liveness. */
-export declare const PHRASE_ROTATE_MS = 4000;
-/**
- * ASCII ONLY, by the rule this tree is under (`glyphs.ts` header, enforced by
- * `glyphs.test.ts`'s static scan). Present participles, so the line reads as an
- * action in progress; twelve characters or fewer so the row never fights the
- * terminal's width.
- */
-export declare const ACTIVITY_PHRASES: readonly string[];
-/**
- * The phrase for a run at a moment.
- *
- * PURE AND TOTAL: the same inputs give the same word, for any finite numbers,
- * including a `now` before `startedAt`.
- *
- * The run's start seeds the sequence, so two consecutive runs do not open on the
- * same word — which is what makes the line read as alive rather than as a fixed
- * label. (The seed's granularity is one second, so two runs starting inside the
- * same second do share an opening word — P2-6.)
- *
- * `rotate: false` is the reduced-motion path: the word is chosen once for the run
- * and then holds. Rotating text IS motion, and a user who asked for
- * `reducedMotion` asked for the screen to stop changing under them; degrading
- * only the spinner would honor the letter of the setting and not its point.
- */
-export declare function pickActivityPhrase(startedAt: number, now: number, rotate?: boolean): string;

package/dist/ui/activity-phrases.js

@@ -1,50 +0,0 @@
-/**
- * The working line's vocabulary (agent-activity-presentation §3.2.1).
- *
- * PURE: no React, no Ink, no clock. Everything here is a function of the two
- * numbers the caller already has, which is what makes the rotation testable
- * without a terminal and without fake timers.
- */
-/** Rotation cadence. Long enough to read, short enough to prove liveness. */
-export const PHRASE_ROTATE_MS = 4_000;
-/**
- * ASCII ONLY, by the rule this tree is under (`glyphs.ts` header, enforced by
- * `glyphs.test.ts`'s static scan). Present participles, so the line reads as an
- * action in progress; twelve characters or fewer so the row never fights the
- * terminal's width.
- */
-export const ACTIVITY_PHRASES = [
-    'Assembling', 'Brewing', 'Calibrating', 'Cogitating', 'Composing',
-    'Computing', 'Concocting', 'Conjuring', 'Considering', 'Crunching',
-    'Distilling', 'Divining', 'Drafting', 'Excavating', 'Fathoming',
-    'Fermenting', 'Finessing', 'Foraging', 'Germinating', 'Herding',
-    'Incubating', 'Inferring', 'Marinating', 'Meandering', 'Mulling',
-    'Musing', 'Noodling', 'Percolating', 'Pondering', 'Puzzling',
-    'Ruminating', 'Scheming', 'Sculpting', 'Simmering', 'Sketching',
-    'Spelunking', 'Steeping', 'Stitching', 'Summoning', 'Tinkering',
-    'Unfurling', 'Untangling', 'Weaving', 'Whittling', 'Wrangling',
-];
-/**
- * The phrase for a run at a moment.
- *
- * PURE AND TOTAL: the same inputs give the same word, for any finite numbers,
- * including a `now` before `startedAt`.
- *
- * The run's start seeds the sequence, so two consecutive runs do not open on the
- * same word — which is what makes the line read as alive rather than as a fixed
- * label. (The seed's granularity is one second, so two runs starting inside the
- * same second do share an opening word — P2-6.)
- *
- * `rotate: false` is the reduced-motion path: the word is chosen once for the run
- * and then holds. Rotating text IS motion, and a user who asked for
- * `reducedMotion` asked for the screen to stop changing under them; degrading
- * only the spinner would honor the letter of the setting and not its point.
- */
-export function pickActivityPhrase(startedAt, now, rotate = true) {
-    const n = ACTIVITY_PHRASES.length;
-    if (!Number.isFinite(startedAt) || !Number.isFinite(now))
-        return ACTIVITY_PHRASES[0];
-    const seed = Math.floor(startedAt / 1000);
-    const step = rotate ? Math.floor(Math.max(0, now - startedAt) / PHRASE_ROTATE_MS) : 0;
-    return ACTIVITY_PHRASES[(((seed + step) % n) + n) % n];
-}

package/dist/ui/capabilities.d.ts

@@ -1,27 +0,0 @@
-/**
- * Terminal capability detection (spec §3.2).
- *
- * A *pure* `detectCapabilities(env, stdout)` that reports how much color and
- * which glyph set the current terminal can render, so the theme engine can
- * degrade truecolor → 256 → 16 → monochrome and swap Unicode box/round glyphs
- * for ASCII on legacy terminals (e.g. `cmd.exe`). Keeping it env-in / value-out
- * makes it unit-testable without a real TTY.
- */
-export interface TermCapabilities {
-    /** 0 none · 1 basic-16 · 2 ansi-256 · 3 truecolor. */
-    colorLevel: 0 | 1 | 2 | 3;
-    /** May we use box/round glyphs, spinners, and emoji-ish symbols? */
-    unicode: boolean;
-}
-type EnvLike = Record<string, string | undefined>;
-interface StdoutLike {
-    isTTY?: boolean;
-}
-/**
- * Detect the terminal's color depth and Unicode support. `stdout` is accepted
- * for future TTY-aware refinements and kept in the signature for callers.
- */
-export declare function detectCapabilities(env: EnvLike, _stdout?: StdoutLike): TermCapabilities;
-/** Full TUI styling is a policy, not a guess based on inherited shell markers. */
-export declare function resolveTuiCapabilities(env: EnvLike, color?: boolean): TermCapabilities;
-export {};

package/dist/ui/capabilities.js

@@ -1,65 +0,0 @@
-/**
- * Terminal capability detection (spec §3.2).
- *
- * A *pure* `detectCapabilities(env, stdout)` that reports how much color and
- * which glyph set the current terminal can render, so the theme engine can
- * degrade truecolor → 256 → 16 → monochrome and swap Unicode box/round glyphs
- * for ASCII on legacy terminals (e.g. `cmd.exe`). Keeping it env-in / value-out
- * makes it unit-testable without a real TTY.
- */
-import chalk from 'chalk';
-/** Resolve the effective color depth from environment signals + chalk. */
-function detectColorLevel(env) {
-    // Explicit opt-outs win (https://no-color.org — any value, even empty).
-    if (env.NO_COLOR !== undefined)
-        return 0;
-    if (env.TERM === 'dumb')
-        return 0;
-    // FORCE_COLOR is an explicit override of the auto-detected depth.
-    const force = env.FORCE_COLOR;
-    if (force !== undefined) {
-        if (force === '0' || force === 'false')
-            return 0;
-        if (force === '2')
-            return 2;
-        if (force === '3')
-            return 3;
-        return 1; // '1' | 'true' | '' → at least basic color
-    }
-    // A truecolor-capable terminal advertises itself.
-    const colorterm = env.COLORTERM?.toLowerCase();
-    if (colorterm === 'truecolor' || colorterm === '24bit')
-        return 3;
-    // Fall back to chalk's own platform detection.
-    const level = chalk.level;
-    return level >= 0 && level <= 3 ? level : 0;
-}
-/** Decide whether Unicode box/round glyphs are safe to emit. */
-function detectUnicode(env) {
-    const locale = [env.LC_ALL, env.LC_CTYPE, env.LANG].filter(Boolean).join(' ').toUpperCase();
-    if (locale.includes('UTF'))
-        return true;
-    if (env.WT_SESSION)
-        return true; // Windows Terminal
-    const program = env.TERM_PROGRAM;
-    if (program === 'aragonmesh' || program === 'vscode' || program === 'iTerm.app' || program === 'Apple_Terminal')
-        return true;
-    // Legacy cmd.exe (no TERM, no WT_SESSION) and unknown terminals fall back to ASCII.
-    return false;
-}
-/**
- * Detect the terminal's color depth and Unicode support. `stdout` is accepted
- * for future TTY-aware refinements and kept in the signature for callers.
- */
-export function detectCapabilities(env, _stdout) {
-    return {
-        colorLevel: detectColorLevel(env),
-        unicode: detectUnicode(env),
-    };
-}
-/** Full TUI styling is a policy, not a guess based on inherited shell markers. */
-export function resolveTuiCapabilities(env, color) {
-    const disabled = color === false || env.NO_COLOR !== undefined ||
-        env.FORCE_COLOR === '0' || env.FORCE_COLOR === 'false';
-    return { unicode: true, colorLevel: disabled ? 0 : 3 };
-}

package/dist/ui/clipboard-task.d.ts

@@ -1,29 +0,0 @@
-import { type ClipboardOptions, type CopyResult } from './clipboard.js';
-export interface CopyRequest {
-    text: string;
-    lines: number;
-}
-export type CopyRequestResult = CopyResult | {
-    status: 'busy';
-};
-export interface ClipboardState {
-    busy: boolean;
-    cleanupPending: boolean;
-}
-export interface ClipboardCoordinatorOptions {
-    clipboard?: ClipboardOptions;
-    /** Clears the previous Ctrl+C exit preparation for both copy entry points. */
-    onRequest?: () => void;
-    /** A repeated request is consumed; its selection must remain untouched. */
-    onBusy?: (state: ClipboardState) => void;
-    onResult?: (result: CopyResult, request: CopyRequest) => void;
-    onStateChange?: (state: ClipboardState) => void;
-}
-export interface ClipboardCoordinator {
-    requestCopy(request: CopyRequest): Promise<CopyRequestResult>;
-    isBusy(): boolean;
-    isCleanupPending(): boolean;
-    dispose(): void;
-}
-/** Create the App-owned copy port; use its live busy state before taking a selection. */
-export declare function createClipboardCoordinator(options?: ClipboardCoordinatorOptions): ClipboardCoordinator;