dsh-ssh-tui 0.8.1 → 0.8.2

package/lib/types/approval-state.d.ts

@@ -0,0 +1,75 @@
+/** The four states a tool card may show for the approval that guarded it. */
+export type ApprovalState = 'waiting' | 'approved' | 'rejected' | 'unknown';
+/** How well the state is known. Ordered from strongest to weakest. */
+export type ApprovalProvenance = 'live' | 'policy' | 'durable' | 'inferred';
+/** The approval field of one tool row. Display-only: never persisted by us. */
+export interface ToolApproval {
+    state: ApprovalState;
+    provenance: ApprovalProvenance;
+    /** True when a rule/reviewer decided it rather than a person (`policy`). */
+    auto?: boolean;
+    /** Why — the classifier's or the reviewer's reason, when one was given. */
+    reason?: string;
+}
+/**
+ * One approval fact onto a card's current field.
+ *
+ * `next` wins on state when it is at least as strong as what is already there. A
+ * live decision is not overwritten by the durable event of the *same* decision
+ * (which arrives right behind it on the live path and says strictly less), and an
+ * inference never replaces anything but an inference.
+ * @param current - the field as it stands, if any.
+ * @param next - the fact being applied.
+ * @returns the field the card should carry.
+ */
+export declare function mergeApproval(current: ToolApproval | undefined, next: ToolApproval): ToolApproval;
+/**
+ * A recorded outcome as a card state.
+ *
+ * `cancelled` and `unavailable` are deliberately **unknown**, not `rejected`: the
+ * reader's Esc, or a Host that had no approval channel, is not the human refusing
+ * the tool, and printing a refusal they did not make is exactly the kind of
+ * comfortable lie this field exists to prevent.
+ * @param outcome - the `approval/decided` outcome, as recorded.
+ * @returns the state the card shows.
+ */
+export declare function approvalStateFromOutcome(outcome: string): ApprovalState;
+/**
+ * Whether a tool result proves an approval was **refused** when no audit events
+ * survived.
+ *
+ * Only the Harness's own refusal sentences count. A generic denial (`denied by
+ * policy`, `blocked`) does *not* prove an approval was ever needed, and the whole
+ * point of the `inferred` provenance is that it is used only where the text can
+ * carry it: the phrase below is what `dsh-tools` writes when `approval.request()`
+ * came back `rejected` or `cancelled`, so it cannot appear for a tool that was
+ * refused by a rule instead.
+ *
+ * It can never produce `approved` — running successfully is not evidence that
+ * anyone approved anything (a tool with no approval requirement runs too).
+ * @param text - the tool result's text.
+ * @returns `rejected` when the text is that refusal, undefined otherwise.
+ */
+export declare function inferredApprovalFromResult(text: string): ApprovalState | undefined;
+/** A one-word label for the card chip. */
+export declare function approvalStateKey(state: ApprovalState): string;
+/**
+ * The provenance note shown beside the state.
+ *
+ * `live` and `durable` say nothing extra: a person's own decision and the log of
+ * it are the same fact at two moments. `policy` and `inferred` do, because the
+ * reader is being told something weaker and has to be able to tell.
+ */
+export declare function approvalProvenanceKey(approval: ToolApproval): string | undefined;
+/**
+ * The expanded card's own line for the approval.
+ *
+ * It names the state, the strength of the evidence, and the reason when one
+ * survived: `live`/`durable` need no apology, `policy` is marked automatic, and
+ * `inferred` says outright that the card is reading the log rather than quoting it.
+ * @param approval - the card's approval field.
+ * @returns the sentence, already translated.
+ */
+export declare function approvalDetailText(approval: ToolApproval): string;
+/** Whether two approval fields would render identically. */
+export declare function sameApproval(left: ToolApproval | undefined, right: ToolApproval | undefined): boolean;

package/lib/types/auth-failure.d.ts

@@ -76,3 +76,28 @@ export declare function classifyAuthFailure(message: string): AuthFailure | unde
  * @returns true when this is that failure.
  */
 export declare function isReasoningReplayFailure(message: string): boolean;
+/**
+ * A gateway that refused the request itself, without saying why.
+ *
+ * The sibling of the failure above, and the one a reader actually meets most: the
+ * same thinking-mode route answers a bare envelope with a trace id and nothing else.
+ * Measured in one long session (2026-10-03, command-code, `effort: max`):
+ *
+ *     13 of 14 failed turns were this shape, 12 of them bare
+ *     they arrived in runs — eight consecutive turns over twelve minutes, then the
+ *     same route, model and key answered normally again
+ *     the harness made 14 attempts and 0 retries (a 400 is outside its retryable set)
+ *
+ * Those three facts decide what the plugin may say and may do. It may say the
+ * request body was refused (not the credential) and that the known member of this
+ * family is the reasoning-replay defect. It may *not* claim that sending again will
+ * work: the envelope carries no reason, and a run that deep may equally be a request
+ * the API will keep refusing. What it must not do is retry on its own — the sibling's
+ * case below is deterministic, and this one re-sends a whole context to find out.
+ *
+ * The envelope is deliberately narrow: a 400 whose body names a field
+ * (`unknown field "summary"`) is a different fix and is not this.
+ * @param message - the failure text the host attached to the turn.
+ * @returns true when this is a bare 400 rejection.
+ */
+export declare function isRequestRejectedFailure(message: string): boolean;

package/lib/types/color-depth.d.ts

@@ -48,3 +48,24 @@ export declare function basicSgrFor(r: number, g: number, b: number): number;
  * @returns the parameter list to emit, possibly empty.
  */
 export declare function downgradeSgr(code: string, depth: ColorDepth): string;
+/**
+ * Paint one run of text in one role's colour.
+ *
+ * The one helper the footer's whole colour grammar is built on — the meter
+ * primitives paint their filled cell with it and the status row paints the link's
+ * pips — so it lives here, beside `downgradeSgr`, rather than in a module of its
+ * own. Three rules it keeps:
+ *
+ * - it wraps *one* run, closes itself, and stops there;
+ * - re-opening the surrounding muted style is the *row owner's* job
+ *   (`muteFooterLine` in `tui.ts` reopens it after every reset), because doing it
+ *   here as well produced two identical `90m` sequences per accent and made the
+ *   output depend on which separator the caller passed;
+ * - a terminal with no colour left answers with the text unchanged, so the
+ *   `no-color` and `mono` paths need no branch of their own.
+ * @param text - the run to paint.
+ * @param token - SGR parameters for the role, as `theme.ts` emits them.
+ * @param depth - what the terminal can take.
+ * @returns the run, painted when there is colour to paint it with.
+ */
+export declare function accent(text: string, token: string, depth: ColorDepth): string;

package/lib/types/copy-text.d.ts

@@ -3,7 +3,24 @@
  */
 import type { CollapsibleBlock, Row } from './transcript-types.js';
 export declare function copyTextFromRow(row: Row | CollapsibleBlock | undefined): string;
-export declare function copyTextFromTranscript(rows: readonly Row[], focused: Row | CollapsibleBlock | null): {
+/** What a copy is aimed at: the highlighted card, or the model's last reply. */
+export type CopyTarget = 'highlight' | 'reply';
+/** The newest model reply with text, or `''` when the session has not produced one. */
+export declare function latestReplyText(rows: readonly Row[]): string;
+/**
+ * The text one copy target holds.
+ *
+ * The two targets are deliberately exclusive. They used to be one rule —
+ * "the highlighted card, else the newest reply" — and the fallback made the
+ * reply unreachable: any card left highlighted (one click on a tool card is
+ * enough) silently redirected `/copy`, with nothing on screen saying the reply
+ * had been passed over. `/copy` now names its target and defaults to the reply;
+ * `highlight` is the old rule with its own, honest, empty case.
+ * @param rows - the rows the reader can see (a `/clear` cutoff is not searched).
+ * @param focused - the highlighted row, if any.
+ * @param target - what the reader asked for; `reply` is the command's default.
+ */
+export declare function copyTextFromTranscript(rows: readonly Row[], focused: Row | CollapsibleBlock | null, target?: CopyTarget): {
     text: string;
     source: 'focused' | 'assistant' | 'empty';
 };

package/lib/types/dialogs.d.ts

@@ -52,9 +52,25 @@ export interface QuestionDialog {
     }): void;
     reject(error: unknown): void;
 }
+/**
+ * @deprecated Superseded by a Screen (`ScreenState`, `kind: 'setup'`) in B2.6.
+ *
+ * Kept as a *shape* so 0.8.x does not break an importer that names the type: nothing
+ * in this plugin constructs one any more, and the wizard has no dialog path left to
+ * reach it through. A dialog handed to the dialog path is still rejected as a
+ * question rather than silently queued.
+ */
 export interface OnboardingDialog {
     kind: 'onboarding';
 }
+/**
+ * @deprecated Superseded by `ScreenState` (`screen.ts`) in B2.1.
+ *
+ * Kept as a *shape* rather than a dialog so the single judgement entry
+ * (`screenFromDialog`) can recognise one if it is ever handed to the dialog path,
+ * and so 0.8.x does not break an importer that names the type. Nothing in this
+ * plugin constructs one any more: every caller opens a Screen.
+ */
 export interface InspectDialog {
     kind: 'inspect';
     title: string;
@@ -81,7 +97,80 @@ export interface InspectDialog {
      */
     notice?: string;
 }
-export type Dialog = ConfirmDialog | QuestionDialog | OnboardingDialog | InspectDialog;
+/**
+ * A dialog that owns the keyboard for the length of one human action.
+ *
+ * Deliberately does **not** include the inspect shape: since B2.1 an inspect body
+ * is a *Screen*, not a dialog — it replaces the workspace instead of borrowing rows
+ * from it, and it never enters `dialogQueue` (`screenFromDialog` converts the legacy
+ * shape, and `docs/decisions/b2-architecture-decisions.md` AD-1…AD-3 freeze why).
+ */
+export type Dialog = ConfirmDialog | QuestionDialog | OnboardingDialog;
+/**
+ * The dialogs the *live* dialog path can actually receive.
+ *
+ * `OnboardingDialog` is in the union only for 0.8.x importers; the wizard is a Screen
+ * now, so the queue, the role and the painter only ever see these two (B2.6 §17).
+ */
+export type SurfaceDialog = Extract<Dialog, {
+    kind: 'confirm' | 'questions';
+}>;
+/** Whether this is a dialog the live path can own (see {@link SurfaceDialog}). */
+export declare function isSurfaceDialog(dialog: Dialog): dialog is SurfaceDialog;
+/**
+ * What kind of human action a surface is asking for.
+ *
+ * The dialog *shape* deliberately does not say this: `/model` and
+ * `ask_user_question` both open a `questions` dialog, and the two mean opposite
+ * things — one changes the operating environment, the other is the task stopping
+ * to wait for a person. Reading the shape as the meaning is what made the status
+ * row claim the agent was waiting while a picker was open, and call an approval
+ * idle. The opener declares the role instead.
+ */
+export type InteractionKind = 'question' | 'plan-review' | 'approval' | 'confirm';
+/**
+ * Who owns the keyboard, and what that means for the task.
+ *
+ * - `interaction` — the agent (or the action the reader asked for) is blocked on a
+ *   human decision, and only `ask` distinguishes the three that stall a turn from
+ *   a confirmation that blocks a local command;
+ * - `picker` — control plane: it changes the environment and leaves the agent
+ *   exactly as busy or idle as it already was.
+ *
+ * There used to be a third, `dedicated`, for "a surface with the whole screen and its
+ * own state machine". B2.6 gave the two things that meant — the inspect overlay and
+ * the setup wizard — the Screen contract instead, and with no producer left the role
+ * was removed rather than kept as a path nothing could reach.
+ */
+export type SurfaceRole = {
+    kind: 'interaction';
+    ask: InteractionKind;
+} | {
+    kind: 'picker';
+};
+/** The roles as values, so no call site invents its own object. */
+export declare const PICKER_ROLE: SurfaceRole;
+export declare function interactionRole(ask: InteractionKind): SurfaceRole;
+/**
+ * Whether a role means the task is stopped waiting for the human.
+ *
+ * A local `confirm` (deleting a preset, repairing the profile) owns the keyboard
+ * too, but the agent is not waiting on it — reporting it as a wait is the same
+ * class of mistake as reporting a picker as one.
+ */
+export declare function stallsTask(role: SurfaceRole | undefined): boolean;
+/**
+ * Which surface gets the keyboard first when more than one is waiting (B1.2).
+ *
+ * Only one transient surface is ever drawn, so this is not a z-order: it decides
+ * who is *next in line*. A task interaction outranks a picker (someone is blocked on
+ * it, and the agent cannot proceed), and a picker outranks whatever the reader was
+ * about to type. Equal ranks keep their arrival order, so a queue of two pickers
+ * still behaves exactly as it did before.
+ *
+ * A Screen is not in this ordering at all: it is not a surface (B2.6 §1).
+ */
+export declare function surfacePriority(role: SurfaceRole): number;
 export interface DialogAnswer {
     selected: string[];
     custom?: string;
@@ -165,3 +254,24 @@ export declare function questionSubmit(dialog: QuestionDialog, input: string): Q
 export declare function confirmAnswer(text: string): 'y' | 'n' | 'cancel' | undefined;
 /** The inspect overlay closes on any of these, and ignores the rest. */
 export declare function inspectClosesOn(text: string): boolean;
+/**
+ * Fit an interaction's rendered lines into the rows the frame can give it.
+ *
+ * The interaction layer is composed *over* the transcript (see `paintFrame`), and
+ * the space above the composer is whatever the terminal has left after the footer,
+ * the composer and the header. On a short terminal that can be fewer rows than a
+ * question list needs — and clipping the *bottom* would hide the options and the
+ * key hint, which is exactly the part that has to stay reachable. So the window
+ * keeps the focused row visible and marks what it dropped.
+ *
+ * @param lines - the interaction as its renderer drew it, top to bottom.
+ * @param cap - how many rows the frame has for it.
+ * @param focusLine - index of the row that must stay visible (the highlighted
+ *   option, or the prompt when there is no list).
+ * @returns the rows to place, top to bottom, at most `cap` of them.
+ */
+export declare function windowInteractionLines(lines: readonly string[], cap: number, focusLine?: number): {
+    lines: string[];
+    hiddenAbove: number;
+    hiddenBelow: number;
+};

package/lib/types/display-sock.d.ts

@@ -223,6 +223,19 @@ export declare class DisplayHost {
      */
     private probeTerminal;
     private settleProbe;
+    /**
+     * How many bytes are queued for the terminal and still undelivered.
+     *
+     * The Host composes every frame, and on a resize it is the only one that can
+     * decide whether there is room for another one: the socket the frames travel on
+     * belongs to this object. Without the number the Host can only *guess* how fast
+     * the link is (from the measured round trip) and pace itself conservatively,
+     * which is what made a drag lag behind the pointer on a fast link. With it, the
+     * rule becomes the honest one: paint the new size now, unless the previous frame
+     * has not left yet.
+     * @returns queued bytes, or undefined when no display is attached.
+     */
+    pendingBytes(): number | undefined;
     sendStdout(bytes: Buffer | string): boolean;
     sendGoodbye(): void;
     /**
@@ -422,6 +435,8 @@ export interface DisplayRelayOptions {
     /** Re-measure cadences (tests); defaults to {@link RTT_RECHECK_FIRST_MS} / {@link RTT_RECHECK_MS}. */
     rttFirstRecheckMs?: number;
     rttRecheckMs?: number;
+    /** Terminal-size poll cadence (tests); default {@link SIZE_RECHECK_MS}. */
+    sizeRecheckMs?: number;
     /** Typing captured before this relay existed; sent to the Host after HELLO. */
     seed?: string;
     /**

package/lib/types/footer-accents.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The one accent helper the footer's colour grammar is built on.
+ *
+ * It lives alone because two modules need it and neither may own the other: the
+ * meter primitives paint their filled cell with it, and the budget paints the
+ * link's pips. A helper this small is not worth a module in general; here it is
+ * worth avoiding a cycle, and it gives the colour grammar one place to be
+ * described:
+ *
+ * - an accent wraps exactly one run of text, closes itself, and stops there;
+ * - re-opening the row's muted style is the *row owner's* job
+ *   (`muteFooterLine` in `tui.ts` reopens it after every reset), because doing
+ *   it here as well produced two identical `90m` sequences per accent and made
+ *   the primitive's output depend on which separator the caller passed;
+ * - a terminal with no colour left answers with the text unchanged, so the
+ *   `no-color` and `mono` paths need no branch of their own.
+ *
+ * @module dsh-ssh-tui/footer-accents
+ */
+import { type ColorDepth } from './color-depth.js';
+/** Wrap one run in one accent, or return it unchanged when the terminal has none. */
+export declare function accent(text: string, token: string, depth: ColorDepth): string;

package/lib/types/footer-budget.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Responsive budget policy: how much of the row survives at which width.
+ *
+ * The row is one ordered list of chips, and this module owns the *degradation
+ * ladder* every chip answers to — a single integer level, tried from 0 upward,
+ * where each step removes cells in the order of the information priority the row
+ * was designed around. Nothing outside this module may decide that a chip is
+ * dropped, shortened, or spelled differently.
+ *
+ * @module dsh-ssh-tui/footer-budget
+ */
+import { type ColorDepth } from './color-depth.js';
+import { type PaintLinkKind } from './paint.js';
+import type { QuotaPeriod } from './quota.js';
+import type { ThroughputView } from './throughput.js';
+import { type ContextPressureView } from './footer-format.js';
+export type FooterActivityKind = 'plan-review' | 'waiting' | 'approval' | 'compacting' | 'retry' | 'agent' | 'tools' | 'plan-open' | 'plan-pending' | 'goal' | 'thinking' | 'reply' | 'waiting-llm' | 'idle';
+/**
+ * How the default row paints its link.
+ *
+ * Deliberately the same four-pip vocabulary `formatLinkQualityChip` established:
+ * the thresholds behind it (`linkQualityOf`) were validated against real SSH
+ * probes, and a UI pass that re-derived its own numbers would put two
+ * contradictory opinions about the same link on the same screen.
+ */
+export interface FooterStripLink {
+    kind: PaintLinkKind;
+    intervalMs: number;
+    /** Measured round-trip, when the CSI-6n probe answered. */
+    rttMs?: number;
+    probed: boolean;
+}
+/**
+ * The activity chip's input: the verb, and when it started.
+ *
+ * Deliberately *not* the subject — not the command being run, not the file being
+ * edited, not the path being searched. The status row answers "what is happening"
+ * (`终端`, `edit`, `thinking`); *which* command, on *which* file, is the
+ * transcript card's job, one line up, where the reader can actually read it. A
+ * command in the chip also spent the row's cells on the least load-bearing thing
+ * on it: a `pytest -x tests/ --maxfail=1` pushed the quota and context meters
+ * towards the drop edge, and `/status`-like detail in a status row is exactly the
+ * telemetry dump this row was rebuilt to stop being.
+ */
+export interface FooterStripActivity {
+    kind: FooterActivityKind;
+    text: string;
+    /** Wall clock the action started; drives the `· 28s` suffix. */
+    startedAt?: number;
+    now?: number;
+}
+export interface FooterStripQuota {
+    /** 0–100, remaining. `undefined` paints the empty bar with `?%`. */
+    remainingPercent?: number;
+    period?: QuotaPeriod;
+}
+/** Everything the default status row paints, in the order a glance reads it. */
+export interface FooterStripInput {
+    link: FooterStripLink;
+    activity: FooterStripActivity;
+    throughput?: ThroughputView;
+    running: boolean;
+    quota?: FooterStripQuota;
+    context?: ContextPressureView;
+    /**
+     * Session-cumulative tokens, **only** when the harness published the total
+     * itself. Absent means the chip is not painted at all: a total assembled from
+     * the billed parts is a different accounting, and `/status` is where the two are
+     * told apart (`sessionTokenTotal` returns which one it had).
+     */
+    totalTokens?: number;
+    /**
+     * The install warning that leads the row, when the profile is missing rows.
+     *
+     * It is on the *same* ladder as everything else rather than being fitted around
+     * it: it used to be composed into a chip strip by `fitFooterChips` and the rest
+     * of the row fitted into what was left, which meant two convergence algorithms
+     * on one line and a width hand-computed at the call site. It keeps the highest
+     * priority, so it is still the last thing a narrow terminal gives up, and only
+     * its text degrades — to the glyph, and off the row only at the very end.
+     */
+    warning?: {
+        long: string;
+        short: string;
+    };
+    /**
+     * The Host-local echo: the last thing this Host confirmed to the reader
+     * (`/theme` switched, a preset saved, a copy landed).
+     *
+     * Not history (AD-13) and not telemetry: it is an acknowledgement, so it is the
+     * lowest-priority chip on the row — the first thing a narrow terminal gives up, and
+     * never at the cost of the link, the activity, the quota or the context reading.
+     */
+    echo?: string;
+    /** Whether the terminal must be painted with ASCII glyphs. */
+    ascii?: boolean;
+    /** Colour depth the accents are downgraded for. */
+    depth?: ColorDepth;
+    /** Paint accents at all. False is the `no-color` terminal. */
+    color?: boolean;
+}
+/**
+ * A chip on the default row: one signal, painted at one of nine densities.
+ *
+ * The level is a *degradation ladder*, not a size class. Level 0 is the full
+ * form a 160-column terminal shows; each step buys cells from the least
+ * load-bearing part of the row. The order is the whole design: the session
+ * total goes first, then the activity's subject, then the meters give up cells
+ * before they give up their number, and the link keeps its dots almost to the
+ * end — because those dots are the one component that says whether the session
+ * is alive. A narrow terminal ends up *quieter*, never denser.
+ */
+export interface FooterStripChip {
+    id: string;
+    /** Component order. Lower is more load-bearing. */
+    priority: number;
+    /** The chip at one degradation level; `''` drops the chip at that level. */
+    render: (level: number) => string;
+}
+/**
+ * The deepest degradation level any chip understands.
+ *
+ * Sixteen levels, one per cell of budget, in the priority order the row was
+ * designed around. A coarser ladder left the 72–99 range showing the same row as
+ * a 100-column terminal, which is the failure mode this exists to avoid: the
+ * narrow terminal must get *less*, not merely a compressed copy.
+ */
+export declare const FOOTER_STRIP_MAX_LEVEL = 17;
+/** The default row's group separator, matching the pre-strip footer. */
+export declare const FOOTER_STRIP_SEPARATOR = " \u2502 ";
+/**
+ * The activity chip's text: `⠹ edit · 28s`, `⠹ thinking · 18s`, `idle`.
+ *
+ * The spinner is passed in rather than computed here so the row has exactly one
+ * clock (`SPINNER` in `tui.ts`), which is what keeps the glyph in step with the
+ * transcript's own live rows.
+ * @param activity - the current operational state.
+ * @param spinner - the frame to show in front of a working state, if any.
+ * @param level - degradation level; the glyph and the clock go before the verb.
+ */
+export declare function activityMeter(activity: FooterStripActivity, spinner: string, level?: number): string;
+/**
+ * Build the default status row: the ordered chips, degraded to fit `width`.
+ *
+ * Order is the information priority the row is built around — link health, what
+ * is happening, how fast tokens are arriving, what quota is left, how full the
+ * context is, and finally how big the session has grown. Turns, steps, model
+ * time, tool time and cache hit left this row on purpose: they are session
+ * analytics, they answer no question a live operator is asking, and they are all
+ * still in `/status`.
+ *
+ * Nothing here paints threshold colour on throughput: the harness publishes no
+ * performance classification, and inventing one would paint a healthy reasoning
+ * model red for being deliberate.
+ * @param input - the signals, already resolved by the caller.
+ * @param width - cells available on the row.
+ * @param separator - the (already accented) group separator.
+ * @param spinner - current animation frame for working states.
+ * @returns the row, never wider than `width`.
+ */
+export declare function runtimeStrip(input: FooterStripInput, width: number, separator?: string, spinner?: string): string;
+/**
+ * What a Screen's compact runtime strip reports, in the order it is read.
+ *
+ * A Screen replaces the whole workspace, so the footer's two rows are gone with
+ * it. This is the subset that has to survive: the reader must still be able to
+ * answer "is the agent running", "is anything waiting", "is the link alive". It
+ * deliberately carries no throughput, no session total, no cwd and no subagent
+ * metadata — those are workspace facts about *work*, and a Screen is a place you
+ * visit while the work continues (AD-8).
+ */
+export interface ScreenStripInput {
+    activity: FooterStripActivity;
+    /** Human interactions waiting behind this screen: a question or an approval. */
+    waiting: boolean;
+    /** Messages the reader queued for the agent. */
+    queued: number;
+    /** Agent-initiated questions the reader has not answered yet. */
+    queuedQuestions: number;
+    link: FooterStripLink;
+    context?: ContextPressureView;
+    quota?: FooterStripQuota;
+    ascii?: boolean;
+    color?: boolean;
+    depth?: ColorDepth;
+}
+/**
+ * The Screen strip: the status row's own chips, a subset, fitted from the back.
+ *
+ * Rendered with the *same* chip functions the status row uses (`linkChipText`,
+ * `activityMeter`, `contextChip`, `quotaChip`), so a Screen cannot drift into a
+ * second visual language or a second reading of the same state. Fitting is the
+ * opposite of the workspace row's: that row spends its cells on the tail first and
+ * degrades everything together, while the Screen strip holds its highest-priority
+ * group and drops whole groups from the end (quota, context, link, queued) — the
+ * reader is here for the report, and a strip that re-read as it scrolled would be
+ * worse than a shorter one.
+ * @param input - the runtime facts, all read from the same fields the footer reads.
+ * @param width - cells available on the row.
+ * @param separator - the (already accented) group separator.
+ * @param spinner - current animation frame for working states.
+ * @returns the row, never wider than `width`.
+ */
+export declare function screenRuntimeStrip(input: ScreenStripInput, width: number, separator?: string, spinner?: string): string;