@aragon-agent/cli 0.6.47 → 0.6.48

package/dist/ui/governance-status.js

@@ -1,326 +0,0 @@
-/**
- * Governance status: snapshot -> display derivations (governance-mode section 10.3).
- *
- * Pure: no Ink, no clock (callers inject `now`), no I/O. ASCII ONLY.
- *
- * WHAT LIVES HERE AND WHAT DOES NOT. The panel, the chip, the card and the board each
- * need the same few JUDGEMENTS - which colour a score label gets, whether a score change
- * is still inside its emphasis window, which pipeline step is current, what an agent's
- * state looks like to `team-status.ts`. Putting each judgement here once is the same
- * discipline `team-status.ts` records: the roster, the card and the chip used to disagree
- * about what "running" looked like because nine files each answered it.
- *
- * COLOUR IS A SEMANTIC KEY, NOT A THEME FIELD. The layout modules emit `Tone` values and
- * the components resolve them through `toneColor`, so a layout test never needs a `Theme`
- * and a theme change never touches a layout.
- */
-import { POSTURE_LABEL } from '../governance/posture.js';
-import { MODE_LABEL } from '../agent/agent-mode.js';
-import { GOV_LIMITS } from '../governance/limits.js';
-/**
- * A table, not a switch: exhaustive over `Tone` at compile time (a new tone is a
- * missing-key error) and flat in complexity however many tones there are.
- */
-const TONE_COLOR = {
-    text: (theme) => theme.assistant,
-    muted: (theme) => theme.muted,
-    hint: (theme) => theme.hintFg,
-    border: (theme) => theme.border,
-    primary: (theme) => theme.primary,
-    govern: (theme) => theme.governAccent,
-    ok: (theme) => theme.toolDone,
-    warn: (theme) => theme.noticeWarn,
-    error: (theme) => theme.noticeError,
-    pending: (theme) => theme.toolPending,
-    running: (theme) => theme.toolRunning,
-};
-/** Resolve a tone against a theme. The ONLY place a `Tone` becomes a colour. */
-export function toneColor(tone, theme) {
-    return TONE_COLOR[tone](theme);
-}
-export function segment(text, tone, bold = false) {
-    return bold ? { text, tone, bold } : { text, tone };
-}
-// ---------------------------------------------------------------------------
-// Agent state -> the team roster's vocabulary
-// ---------------------------------------------------------------------------
-/**
- * A governance agent state, read as a `team-status.ts` `ChildStatus`, so the glyph and
- * the colour come from THAT module (`statusGlyph` / `statusMarkerCell`) and not from a
- * second table (spec 10.3, "do not make a second copy").
- *
- * `idle` and `queued` are both "not doing anything yet"; `eliminated` borrows the
- * failure reading because the marker for it is the cross and the colour is the error
- * colour - the row's TEXT says `replaced by ...`, which is what stops it reading as a
- * crash.
- */
-const STATUS_BY_STATE = {
-    queued: 'queued',
-    idle: 'queued',
-    working: 'running',
-    submitted: 'done',
-    failed: 'failed',
-    eliminated: 'failed',
-};
-export function govChildStatus(state) {
-    return STATUS_BY_STATE[state];
-}
-/**
- * The tone that `statusColor(status, theme)` resolves to, as a key. A test pins the pair
- * (`toneColor(statusTone(s), theme) === statusColor(s, theme)` for every status and every
- * theme) so the two tables cannot drift apart.
- */
-const TONE_BY_STATUS = {
-    queued: 'pending',
-    running: 'running',
-    done: 'ok',
-    failed: 'error',
-    aborted: 'warn',
-};
-export function statusTone(status) {
-    return TONE_BY_STATUS[status];
-}
-export function scoreTone(label) {
-    switch (label) {
-        case 'NORMAL':
-            return 'ok';
-        case 'WARNING':
-            return 'warn';
-        case 'DANGER':
-        case 'KILLED':
-            return 'danger';
-        case 'NOT_SCORED':
-            return 'muted';
-    }
-}
-const TONE_BY_SCORE = {
-    ok: 'ok',
-    warn: 'warn',
-    danger: 'error',
-    muted: 'muted',
-};
-export function scoreToneKey(label) {
-    return TONE_BY_SCORE[scoreTone(label)];
-}
-/** The short word for a label in the roster's tag column; `NORMAL` says nothing. */
-export function labelTag(label) {
-    switch (label) {
-        case 'WARNING':
-            return 'WARN';
-        case 'DANGER':
-            return 'DANGER';
-        case 'KILLED':
-            return 'KILLED';
-        case 'NORMAL':
-        case 'NOT_SCORED':
-            return '';
-    }
-}
-/** Scored agents start here; the gauge is full at this value. */
-export const GAUGE_FULL_SCORE = GOV_LIMITS.initialTokens;
-export const GAUGE_CELLS = 10;
-/**
- * Filled cells of the 10-cell score gauge: `round(confirmed / 100 * 10)` clamped to
- * [0, 10] (spec 10.3). Non-finite input draws an empty bar rather than throwing - the
- * gauge is decoration over a number that is printed beside it.
- */
-export function gaugeFilledCells(confirmed) {
-    if (!Number.isFinite(confirmed))
-        return 0;
-    const raw = Math.round((confirmed / GAUGE_FULL_SCORE) * GAUGE_CELLS);
-    return Math.min(GAUGE_CELLS, Math.max(0, raw));
-}
-/** `115+` when the score is over the starting value, otherwise the plain number. */
-export function scoreText(confirmed) {
-    const rounded = Math.round(confirmed);
-    return rounded > GAUGE_FULL_SCORE ? `${rounded}+` : String(Math.max(0, rounded));
-}
-// ---------------------------------------------------------------------------
-// Delta emphasis (AC-27)
-// ---------------------------------------------------------------------------
-/** How long a score change stays emphasised on its row. */
-export const DELTA_EMPHASIS_MS = 4000;
-const NO_DELTA = { text: '', tone: 'muted', bold: false };
-/** Signed delta text; a provisional gain carries the `P` suffix (`+15P`). */
-export function signedDeltaText(delta, provisional) {
-    const sign = delta > 0 ? '+' : delta < 0 ? '-' : '';
-    return `${sign}${Math.abs(Math.round(delta))}${provisional && delta > 0 ? 'P' : ''}`;
-}
-/**
- * The emphasised delta of a row.
- *
- * Motion allowed: bold + coloured for `DELTA_EMPHASIS_MS` after the change, then gone.
- * Reduced motion: nothing is time-windowed, so nothing flashes - the delta stays, plain,
- * until the engine replaces or clears `lastDelta` at the next phase (spec 10.3 "the
- * increment text is kept until the next phase"). A zero delta says nothing in either mode.
- */
-export function deltaCell(row, now, reducedMotion) {
-    const last = row.lastDelta;
-    if (last === null || last.delta === 0)
-        return NO_DELTA;
-    const tone = last.delta > 0 ? 'ok' : 'error';
-    const text = signedDeltaText(last.delta, last.provisional);
-    if (reducedMotion)
-        return { text, tone, bold: false };
-    const age = now - last.at;
-    if (age < 0 || age > DELTA_EMPHASIS_MS)
-        return NO_DELTA;
-    return { text, tone, bold: true };
-}
-/**
- * Mount rule (D-17): a running stage -> the full panel (which REPLACES the team roster);
- * a live run between stages -> the two-line strip; no run, a closed run or an abandoned
- * run -> nothing at all (zero rows, zero layout shift).
- */
-export function governancePanelMode(snapshot) {
-    if (snapshot === null)
-        return 'none';
-    if (isFinishedRun(snapshot.status))
-        return 'none';
-    return snapshot.stageRunning ? 'panel' : 'run-strip';
-}
-/**
- * EXACTLY ONE LIVE ROSTER (D-17 / AC-25). A running governed stage owns the region even
- * though the same children are also in `state.team` (the reducer still writes it for
- * `/agents`); between stages the two-line strip shows only when no dispatch is live; with
- * no live governed run the team roster behaves exactly as it always did.
- */
-export function liveRosterSurface(snapshot, teamLive) {
-    const mode = governancePanelMode(snapshot);
-    if (mode === 'panel')
-        return 'governance';
-    if (mode === 'run-strip' && !teamLive)
-        return 'governance';
-    return teamLive ? 'team' : 'none';
-}
-export function isFinishedRun(status) {
-    return status === 'closed' || status === 'abandoned';
-}
-/** Agents currently doing something: the minimal tier's "4 working". */
-export function workingCount(snapshot) {
-    return snapshot.roster.filter((row) => row.state === 'working').length;
-}
-/** Display position in the pipeline: the active step's key, or the stage, or null. */
-export function activeStepKey(snapshot) {
-    const active = snapshot.pipeline.find((step) => step.state === 'active');
-    if (active !== undefined && active.key !== 'intake')
-        return active.key;
-    return snapshot.stage;
-}
-/** Tokens spent by the governed team (spec 8.5: team tokens, never the session total). */
-export function teamTokens(snapshot) {
-    return snapshot.usage.inputTokens + snapshot.usage.outputTokens;
-}
-/**
- * Budget readout for the chip's `$` hint: 'none' without a budget, 'warn' from 80%,
- * 'over' from 100% (spec 8.5). Only budgets > 0 are budgets.
- */
-export function budgetState(snapshot) {
-    if (snapshot.budgetTokens <= 0)
-        return 'none';
-    const fraction = teamTokens(snapshot) / snapshot.budgetTokens;
-    if (fraction >= 1)
-        return 'over';
-    return fraction >= 0.8 ? 'warn' : 'ok';
-}
-/** Short run id for the header: the last five alphanumerics, so ids that share a prefix differ. */
-export function shortRunId(runId) {
-    const clean = runId.replace(/[^A-Za-z0-9]/g, '');
-    return clean.length <= 5 ? clean : clean.slice(clean.length - 5);
-}
-/**
- * Fold a snapshot into the first-seen-eliminated map.
- *
- * WHY THE PANEL KEEPS THIS ITSELF: `RosterRow` carries no "eliminated in phase N" field,
- * and the board still needs the full roster from the same snapshot, so the engine cannot
- * simply drop the row. A member that disappears from the map's keys (never happens) or
- * that was never seen eliminated is treated as "eliminated now" by `isRetired`. Returns
- * the SAME object when nothing changed so React memo / ref comparisons stay cheap.
- */
-export function trackEliminated(previous, snapshot) {
-    let next = null;
-    for (const row of snapshot.roster) {
-        if (row.state !== 'eliminated' || previous[row.id] !== undefined)
-            continue;
-        next ??= { ...previous };
-        next[row.id] = snapshot.phase;
-    }
-    return next ?? previous;
-}
-/**
- * True when an eliminated member's one visible phase is over: it was first seen in an
- * earlier phase than the one now displayed.
- */
-export function isRetired(row, phase, since) {
-    if (row.state !== 'eliminated')
-        return false;
-    const seen = since[row.id];
-    return seen !== undefined && phase > seen;
-}
-// ---------------------------------------------------------------------------
-// Sorting
-// ---------------------------------------------------------------------------
-const ROLE_ORDER = { DEV: 0, REV: 1, TEST: 2, INSP: 3 };
-/**
- * Roster order: DEV -> REV -> TEST -> INSP, active members before eliminated ones, then
- * by generation and id so `dev2` precedes its successor `dev2-r1` and the order is total
- * (a stable roster does not reshuffle between snapshots).
- */
-export function sortRoster(roster) {
-    return [...roster].sort((a, b) => {
-        const gone = Number(a.state === 'eliminated') - Number(b.state === 'eliminated');
-        if (gone !== 0)
-            return gone;
-        const role = ROLE_ORDER[a.role] - ROLE_ORDER[b.role];
-        if (role !== 0)
-            return role;
-        if (a.generation !== b.generation)
-            return a.generation - b.generation;
-        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-    });
-}
-// ---------------------------------------------------------------------------
-// PLAN+GOVERN interview chip
-// ---------------------------------------------------------------------------
-/**
- * `PLAN+GOVERN  interview round 2/2+` while rounds are still owed, and `... 2/2 OK` once
- * the minimum is met (governance-mode 10.6). The trailing `+` reads "at least this many":
- * the model may ask more rounds than the minimum.
- */
-export function interviewChipText(round, required) {
-    const answered = Math.max(0, Math.floor(round));
-    const needed = Math.max(0, Math.floor(required));
-    const met = answered >= needed;
-    return `${POSTURE_LABEL.plan_govern}  interview round ${answered}/${needed}${met ? ' OK' : '+'}`;
-}
-// ---------------------------------------------------------------------------
-// Posture words
-// ---------------------------------------------------------------------------
-/**
- * A `/gov pause` is waiting for the running stage to finish (governance-mode-v1-1 6.4).
- * Only meaningful while the run is still `executing`: once it is `paused` the request has
- * been redeemed, and an `escalated` run drops it.
- */
-export function isPausePending(snapshot) {
-    return snapshot.pauseRequested === true && snapshot.status === 'executing';
-}
-/** True for the two governed postures, given a mode OR posture value as a string. */
-export function isGovernedModeValue(value) {
-    return value === 'govern' || value === 'plan_govern';
-}
-/**
- * The status row's word for a mode OR a posture. `MODE_LABEL` answers for `build` /
- * `plan` (so the byte-identical pre-governance output is preserved); the two governed
- * postures are the only values that reach the second table.
- *
- * Short form: the first letter, except `plan_govern` which is `PG` - `P` is already PLAN
- * and a status row that cannot tell them apart has defeated the badge.
- */
-export function modeWord(value, full) {
-    const label = MODE_LABEL[value] ?? POSTURE_LABEL[value];
-    if (label === undefined)
-        return undefined;
-    if (full)
-        return label;
-    return value === 'plan_govern' ? 'PG' : label[0];
-}

package/dist/ui/gradient.d.ts

@@ -1,11 +0,0 @@
-/**
- * Gradient wordmark helper (spec §3.2). Pure: interpolates an RGB gradient
- * across a short string using chalk. Below ansi-256 (or with no stops) it
- * returns the text unchanged so the header falls back to a bold single-color
- * wordmark. No new runtime dependency — `chalk` is already present.
- */
-/**
- * Render `text` with a per-character gradient across `stops` (hex colors).
- * Returns the text unchanged when `colorLevel < 2` or `stops` is empty.
- */
-export declare function gradientLine(text: string, stops: string[], colorLevel: 0 | 1 | 2 | 3): string;

package/dist/ui/gradient.js

@@ -1,50 +0,0 @@
-/**
- * Gradient wordmark helper (spec §3.2). Pure: interpolates an RGB gradient
- * across a short string using chalk. Below ansi-256 (or with no stops) it
- * returns the text unchanged so the header falls back to a bold single-color
- * wordmark. No new runtime dependency — `chalk` is already present.
- */
-import { Chalk } from 'chalk';
-/** Parse a `#rrggbb` (or `#rgb`) string into an `[r, g, b]` triple. */
-function parseHex(hex) {
-    let h = hex.replace('#', '').trim();
-    if (h.length === 3)
-        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
-    const n = Number.parseInt(h, 16);
-    if (!Number.isFinite(n))
-        return [255, 255, 255];
-    return [(n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff];
-}
-function lerp(a, b, t) {
-    return Math.round(a + (b - a) * t);
-}
-/** Interpolate a colour at position `t` ∈ [0,1] across the RGB `stops`. */
-function colorAt(stops, t) {
-    if (stops.length === 1)
-        return stops[0];
-    const clamped = Math.max(0, Math.min(1, t));
-    const scaled = clamped * (stops.length - 1);
-    const idx = Math.min(stops.length - 2, Math.floor(scaled));
-    const local = scaled - idx;
-    const from = stops[idx];
-    const to = stops[idx + 1];
-    return [lerp(from[0], to[0], local), lerp(from[1], to[1], local), lerp(from[2], to[2], local)];
-}
-/**
- * Render `text` with a per-character gradient across `stops` (hex colors).
- * Returns the text unchanged when `colorLevel < 2` or `stops` is empty.
- */
-export function gradientLine(text, stops, colorLevel) {
-    if (colorLevel < 2 || stops.length === 0 || text.length === 0)
-        return text;
-    const rgbStops = stops.map(parseHex);
-    const c = new Chalk({ level: colorLevel === 3 ? 3 : 2 });
-    const chars = [...text];
-    const denom = chars.length > 1 ? chars.length - 1 : 1;
-    return chars
-        .map((ch, i) => {
-        const [r, g, b] = colorAt(rgbStops, i / denom);
-        return c.rgb(r, g, b)(ch);
-    })
-        .join('');
-}

package/dist/ui/ink-runtime.d.ts

@@ -1,4 +0,0 @@
-import type { TermCapabilities } from './capabilities.js';
-export declare const render: (node: import("react").ReactNode, options?: NodeJS.WriteStream | import("ink").RenderOptions) => import("ink").Instance;
-/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
-export declare function renderTui(node: Parameters<typeof render>[0], options: Parameters<typeof render>[1], caps: TermCapabilities): ReturnType<typeof render>;

package/dist/ui/ink-runtime.js

@@ -1,51 +0,0 @@
-import process from 'node:process';
-/** Ink 5 caches CI detection at import time and otherwise paints only on exit. */
-async function loadInk() {
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        return import('ink');
-    const originalCi = process.env.CI;
-    try {
-        // A real interactive terminal always needs live frames and resize events.
-        // `0` also overrides CI_* / CONTINUOUS_INTEGRATION in Ink's detector.
-        process.env.CI = '0';
-        return await import('ink');
-    }
-    finally {
-        // Commands, subprocesses and the updater must see the original environment.
-        if (originalCi === undefined)
-            delete process.env.CI;
-        else
-            process.env.CI = originalCi;
-    }
-}
-export const { render } = await loadInk();
-// Keep asynchronous dependency resolution after Ink's CI initialization. A
-// static import here would let sibling UI modules load Ink before CI is reset.
-const { useTuiColors } = await import('./color-runtime.js');
-/** Mount the TUI with its resolved colors, restoring all renderers on exit. */
-export function renderTui(node, options, caps) {
-    const restore = useTuiColors(caps.colorLevel);
-    try {
-        // Ink creates its exit promise lazily and does not replay earlier exits.
-        // Mount the host first, then subscribe before application render or layout
-        // effects can fail or call useApp().exit().
-        const instance = render(null, options);
-        void instance.waitUntilExit().then(restore, restore);
-        instance.rerender(node);
-        return {
-            ...instance,
-            unmount() {
-                try {
-                    instance.unmount();
-                }
-                finally {
-                    restore();
-                }
-            },
-        };
-    }
-    catch (error) {
-        restore();
-        throw error;
-    }
-}

package/dist/ui/interaction-copy.d.ts

@@ -1,84 +0,0 @@
-/** Built-in product text; user content retains its original language. */
-export declare const interactionCopy: {
-    readonly copied: "Copied";
-    readonly lines: "lines";
-    readonly copySent: "Copy sent; clipboard confirmation unavailable";
-    readonly copyReasons: {
-        readonly empty: "Nothing to copy";
-        readonly unavailable: "Clipboard tool unavailable";
-        readonly write: "Clipboard write failed";
-        readonly timeout: "Clipboard tool timed out";
-        readonly 'too-large': "Content exceeds clipboard limit";
-        readonly cancelled: "Copy cancelled";
-    };
-    readonly stopServicesShort: "^C stop services";
-    readonly approveTool: "y approve";
-    readonly rejectTool: "n/Enter reject";
-    readonly saveSettings: "Enter save";
-    readonly modeLabel: "switch mode";
-    readonly idle: readonly ["Idle", "Idle"];
-    readonly starting: readonly ["Start", "Starting"];
-    readonly waiting: readonly ["Wait", "Waiting for model"];
-    readonly thinking: readonly ["Think", "Thinking"];
-    readonly generating: readonly ["Write", "Generating"];
-    readonly preparingTool: readonly ["Prep", "Preparing tool"];
-    readonly tool: readonly ["Tool", "Running tool"];
-    readonly confirming: readonly ["Ask", "Awaiting confirmation"];
-    readonly stopping: readonly ["Stop", "Stopping"];
-    readonly compacting: readonly ["Pack", "Compacting context"];
-    readonly retrying: readonly ["Retry", "Retrying"];
-    readonly ended: readonly ["Done", "Done"];
-    readonly interrupted: readonly ["Abort", "Interrupted"];
-    readonly failed: readonly ["Error", "Failed"];
-    readonly readFile: readonly ["Tool", "Running tool read_file"];
-    readonly writeFile: readonly ["Tool", "Running tool write_file"];
-    readonly command: readonly ["Tool", "Running tool bash"];
-    readonly queue: "Q";
-    readonly pending: "pending";
-    readonly context: "Context";
-    readonly contextUnknown: "Context ?";
-    readonly sessionInput: "Session input";
-    readonly output: "output";
-    readonly estimatedCost: "Cost";
-    readonly speed: "Run average";
-    readonly elapsed: "Elapsed";
-    readonly services: "Services";
-    readonly send: "Enter send";
-    readonly enqueue: "Enter queue";
-    readonly newline: "^J newline";
-    readonly sendLong: "Enter send";
-    readonly enqueueLong: "Enter queue";
-    readonly newlineLong: "Ctrl+J newline";
-    readonly interrupt: "Esc x2 stop";
-    readonly interruptAgain: "Esc stop";
-    readonly forceStop: "Esc force";
-    readonly startingHint: "Starting; please wait";
-    readonly cancelStart: "Esc x2 cancel";
-    readonly cancelStartAgain: "Esc cancel";
-    readonly copy: "Ctrl+C copy";
-    readonly copying: "Copying";
-    readonly copyFailed: "Copy failed";
-    readonly copyCleanup: "Copy failed; cleaning up";
-    readonly close: "Esc close";
-    readonly closeCompletion: "Esc menu";
-    readonly executeCommand: "Enter command";
-    readonly complete: "Tab complete";
-    readonly select: "Up/Down select";
-    readonly scroll: "PgUp/PgDn scroll";
-    readonly confirm: "Enter confirm";
-    readonly stopServices: "Ctrl+C stop services";
-    readonly exit: "Ctrl+C x2 exit";
-    readonly exitDraft: "Ctrl+C x2 clear input, x3 exit";
-    readonly governIdle: "type a task - the Orchestrator will assemble the team";
-    readonly governInterrupt: "Esc x2 interrupt (run is resumable)";
-    readonly governInterruptAgain: "Esc interrupt (run is resumable)";
-    readonly governPausePending: "pause pending: /gov pause cancel";
-    readonly help: "/help";
-    readonly shiftNewline: "Shift+Enter newline needs terminal support";
-    readonly mode: "Shift+Tab switch mode";
-    readonly update: "/update";
-    readonly waitHintSend: "Send a message to end the wait early";
-    readonly waitHintStop: "Esc x2 stops the whole run";
-    readonly idlePlaceholder: "Ask a question or describe a task...";
-    readonly runningPlaceholder: "Add a follow-up...";
-};

package/dist/ui/interaction-copy.js

@@ -1,41 +0,0 @@
-/** Built-in product text; user content retains its original language. */
-export const interactionCopy = {
-    copied: 'Copied', lines: 'lines',
-    copySent: 'Copy sent; clipboard confirmation unavailable',
-    copyReasons: { empty: 'Nothing to copy', unavailable: 'Clipboard tool unavailable',
-        write: 'Clipboard write failed', timeout: 'Clipboard tool timed out',
-        'too-large': 'Content exceeds clipboard limit', cancelled: 'Copy cancelled' },
-    stopServicesShort: '^C stop services', approveTool: 'y approve', rejectTool: 'n/Enter reject',
-    saveSettings: 'Enter save', modeLabel: 'switch mode',
-    idle: ['Idle', 'Idle'], starting: ['Start', 'Starting'], waiting: ['Wait', 'Waiting for model'],
-    thinking: ['Think', 'Thinking'], generating: ['Write', 'Generating'],
-    preparingTool: ['Prep', 'Preparing tool'], tool: ['Tool', 'Running tool'],
-    confirming: ['Ask', 'Awaiting confirmation'], stopping: ['Stop', 'Stopping'],
-    compacting: ['Pack', 'Compacting context'], retrying: ['Retry', 'Retrying'],
-    ended: ['Done', 'Done'], interrupted: ['Abort', 'Interrupted'], failed: ['Error', 'Failed'],
-    readFile: ['Tool', 'Running tool read_file'], writeFile: ['Tool', 'Running tool write_file'],
-    command: ['Tool', 'Running tool bash'],
-    queue: 'Q', pending: 'pending', context: 'Context', contextUnknown: 'Context ?',
-    sessionInput: 'Session input', output: 'output', estimatedCost: 'Cost',
-    speed: 'Run average', elapsed: 'Elapsed', services: 'Services',
-    send: 'Enter send', enqueue: 'Enter queue', newline: '^J newline',
-    sendLong: 'Enter send', enqueueLong: 'Enter queue', newlineLong: 'Ctrl+J newline',
-    interrupt: 'Esc x2 stop', interruptAgain: 'Esc stop', forceStop: 'Esc force',
-    startingHint: 'Starting; please wait', cancelStart: 'Esc x2 cancel', cancelStartAgain: 'Esc cancel',
-    copy: 'Ctrl+C copy', copying: 'Copying', copyFailed: 'Copy failed', copyCleanup: 'Copy failed; cleaning up',
-    close: 'Esc close', closeCompletion: 'Esc menu', executeCommand: 'Enter command',
-    complete: 'Tab complete', select: 'Up/Down select', scroll: 'PgUp/PgDn scroll',
-    confirm: 'Enter confirm', stopServices: 'Ctrl+C stop services', exit: 'Ctrl+C x2 exit',
-    exitDraft: 'Ctrl+C x2 clear input, x3 exit',
-    // GOVERN posture (governance-mode 10.6). The run is resumable, so Esc is not destructive.
-    governIdle: 'type a task - the Orchestrator will assemble the team',
-    governInterrupt: 'Esc x2 interrupt (run is resumable)',
-    governInterruptAgain: 'Esc interrupt (run is resumable)',
-    governPausePending: 'pause pending: /gov pause cancel',
-    help: '/help', shiftNewline: 'Shift+Enter newline needs terminal support',
-    mode: 'Shift+Tab switch mode', update: '/update',
-    // The wait card's hint row (extended-job-wait): a user staring at a 20-minute
-    // wait needs to know they are not trapped in it.
-    waitHintSend: 'Send a message to end the wait early', waitHintStop: 'Esc x2 stops the whole run',
-    idlePlaceholder: 'Ask a question or describe a task...', runningPlaceholder: 'Add a follow-up...',
-};

package/dist/ui/interaction-hints.d.ts

@@ -1,44 +0,0 @@
-import type { StatusFeedback, EscapeAction } from './status-feedback.js';
-export interface ActionHintInput {
-    cols: number;
-    interactionPhase: 'idle' | 'starting' | 'running';
-    interruptHint?: string;
-    interruptPhase?: 'ready' | 'armed' | 'stopping';
-    escapeAction?: EscapeAction;
-    feedback?: StatusFeedback;
-    selectionPending?: boolean;
-    copyInFlight?: boolean;
-    copyCleanupPending?: boolean;
-    completion?: 'none' | 'slash' | 'file';
-    services?: number;
-    overlay?: string | null;
-    hintsEnabled?: boolean;
-    toast?: string;
-    updateAvailable?: boolean;
-    exitHint?: string;
-    modeToggleKey?: string;
-    /** Draft present: the exit clause becomes the clear-then-exit ladder. */
-    hasDraft?: boolean;
-    /**
-     * The session is in a governed posture (governance-mode 10.6): the idle row teaches
-     * what the first message does, and the running row says an interrupt is resumable.
-     * ABSENT = every clause below is byte-identical to the pre-governance build.
-     */
-    governed?: boolean;
-    /**
-     * A `/gov pause` is waiting for the running stage to finish (governance-mode-v1-1 6.4):
-     * the row says so and how to undo it. Absent keeps every clause byte-identical.
-     */
-    govPausePending?: boolean;
-    /**
-     * The word after the toggle key, from `postureHintWord(nextPosture(...))`. Absent keeps
-     * the classic `switch mode`; only the wiring that knows the live posture cycle can say
-     * which posture is next, so this layer never guesses.
-     */
-    nextPostureWord?: string;
-}
-export declare function escapeClause(input: ActionHintInput): string;
-export declare function clipStatusText(text: string, cells: number): string;
-/** Ordered actions before width allocation. No interpretation of translated feedback text. */
-export declare function actionCandidates(input: ActionHintInput): string[];
-export declare function buildActionClauses(input: ActionHintInput): readonly string[];