@aragon-agent/cli 0.6.34 → 0.6.35

package/dist/ui/overlays/model-profile-state.d.ts

@@ -1,7 +1,9 @@
 import { type ModelProfile, type ModelProfilesConfig, type ModelRole } from '../../config/model-profiles.js';
+import type { AgentKit } from '../../config/model-kits.js';
 import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
 import type { SubagentModelMode } from '../../team/model.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm';
+import type { KitDraft } from './kit-settings-state.js';
+export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm' | 'kits' | 'kit-edit' | 'kit-slot' | 'kit-delete';
 /**
  * Which role a PROFILE PICKER page is choosing for.
  *
@@ -9,8 +11,13 @@ export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' |
  * `'main' | 'fast'` because it is the type basis of the config layer's
  * `${role}Id` template keys - widening it would invent a `subagentId` library
  * key nothing reads. The subagent picker writes `draft.patch.team` instead.
+ *
+ * `'binding'` IS A KIT SLOT CHOOSER (agent-model-kits §4.5): a plain profile
+ * list with no `Current custom` row, no built-in rows and one `Create profile`
+ * action. A kit slot can only ever name a profile, so offering "no profile" as a
+ * choice there would be offering an invalid kit.
  */
-export type ProfilePickerRole = ModelRole | 'subagent';
+export type ProfilePickerRole = ModelRole | 'subagent' | 'binding';
 /** The picker's built-in `Fast tier model` row; never a profile id on disk. */
 export declare const SUBAGENT_FAST_ROW_ID = "__fast__";
 export interface ProfileEditorDraft {
@@ -30,13 +37,27 @@ export interface ModelProfileState {
     page: ProfilePage;
     role: ProfilePickerRole;
     editor?: ProfileEditorDraft;
-    returnPage: 'picker' | 'manager';
+    /**
+     * Where the editor and the delete confirmation hand control back.
+     *
+     * `'kit-slot'` JOINS `'picker'` (agent-model-kits §4.5): the kit slot chooser
+     * is a profile picker too, and its `Create profile` action must return to the
+     * slot it was creating for rather than to the profile manager.
+     */
+    returnPage: 'picker' | 'manager' | 'kit-slot';
     bindNew: boolean;
     dirty: boolean;
     error?: string;
     deleteId?: string;
     /** Who referenced the entry being deleted ('Main + Subagent', or ''). */
     deleteUsers?: string;
+    /**
+     * The kit editor's own draft (agent-model-kits §4.5), owned by `kitReducer`.
+     *
+     * ONE FIELD, NOT A SECOND STATE OBJECT: the page axis stays shared, so `Save`
+     * and `Esc` mean the same thing on every page of this screen.
+     */
+    kitDraft?: KitDraft;
 }
 export type ModelProfileAction = {
     type: 'page';
@@ -90,6 +111,8 @@ export declare function finishProfileEditor(editor: ProfileEditorDraft): {
 };
 /** Make an isolated root draft; opening the screen never mutates live config. */
 export declare function createModelProfileState(draft: ModelSettingsDraft): ModelProfileState;
+/** The kits whose three slots name `id`, for the delete confirmation (D-9). */
+export declare function kitsUsingProfile(profiles: ModelProfilesConfig | undefined, id: string): AgentKit[];
 /** Describe references using text so ASCII and no-color modes remain usable. */
 export declare function profileUsers(profiles: ModelProfilesConfig | undefined, id: string, subagentProfileId?: string | null): string;
 /**

package/dist/ui/overlays/model-profile-state.js

@@ -41,10 +41,38 @@ export function createModelProfileState(draft) {
     return { draft: copy, page: 'root', role: 'main', returnPage: 'manager',
         bindNew: false, dirty: false };
 }
+/** The kits whose three slots name `id`, for the delete confirmation (D-9). */
+export function kitsUsingProfile(profiles, id) {
+    return (profiles?.kits ?? []).filter((kit) => kit.mainProfileId === id
+        || kit.fastProfileId === id
+        || (kit.subagent.model === 'profile' && kit.subagent.modelProfileId === id));
+}
+/**
+ * Drop `slot` from the session kit (§4.3 row 2 / AC-38).
+ *
+ * THE DRAFT IS NARROWED HERE, NOT ONLY AT SAVE TIME. `releasedSlots` already
+ * strips the same slot from the transaction before it commits, but the ROOT PAGE
+ * paints the kit's effective value for every HELD slot - so without this line a
+ * user picks a profile and the row keeps showing the one they just replaced,
+ * which is the most confusing thing a settings screen can do. Releasing the last
+ * slot ends the kit: `held: []` is not a state any surface can render.
+ */
+function releaseHeldSlot(draft, slot) {
+    const current = draft.sessionKit;
+    if (!current || !current.held.includes(slot))
+        return draft;
+    const held = current.held.filter((item) => item !== slot);
+    return { ...draft, sessionKit: held.length ? { id: current.id, held } : null };
+}
 /** Describe references using text so ASCII and no-color modes remain usable. */
 export function profileUsers(profiles, id, subagentProfileId) {
+    // THE KITS ARE REFERENCES TOO (D-9 / RV-P2-6): "Main + kit "Deep work"" is what
+    // makes the confirmation honest, because deleting this entry also deletes that
+    // kit. The empty case must stay empty - a leading ` + ` is what a naive
+    // `join` after an unconditional push produces.
     return [profiles?.mainId === id ? 'Main' : '', profiles?.fastId === id ? 'Fast' : '',
-        subagentProfileId === id ? 'Subagent' : '']
+        subagentProfileId === id ? 'Subagent' : '',
+        ...kitsUsingProfile(profiles, id).map((kit) => `kit "${kit.name}"`)]
         .filter(Boolean).join(' + ');
 }
 /**
@@ -155,14 +183,27 @@ export function modelProfileReducer(state, action) {
                         ? { model: 'fast', modelProfileId: null }
                         : { model: 'profile', modelProfileId: action.id };
                 return { ...state, page: 'root', dirty: true, error: undefined,
-                    draft: { ...state.draft, patch: { ...state.draft.patch, team } } };
+                    draft: releaseHeldSlot({ ...state.draft,
+                        patch: { ...state.draft.patch, team } }, 'subagent') };
             }
+            // `'binding'` NEVER REACHES THIS REDUCER: a kit slot's choice is applied
+            // by `kitReducer` (`kit-main` / `kit-fast`), because the value belongs to
+            // an editor draft rather than to a `${role}Id` library key. Returning the
+            // state unchanged is the honest answer to an impossible action.
+            if (action.role === 'binding')
+                return state;
             return { ...state, page: 'root', dirty: true, error: undefined,
-                draft: { ...state.draft, profiles: { ...library, [`${action.role}Id`]: action.id },
-                    activateRoles: [...new Set([...state.draft.activateRoles, action.role])] } };
+                draft: releaseHeldSlot({ ...state.draft,
+                    profiles: { ...library, [`${action.role}Id`]: action.id },
+                    activateRoles: [...new Set([...state.draft.activateRoles, action.role])] }, action.role) };
         }
         case 'edit': return { ...state, editor: createProfileEditor(action.profile), page: 'editor',
-            returnPage: state.page === 'picker' ? 'picker' : 'manager',
+            // A PROFILE BORN IN A KIT SLOT RETURNS TO THAT SLOT (§4.5): the picker's
+            // `Create profile` action is the only way to invent one and it is offered on
+            // the kit's slot chooser - landing in the profile MANAGER there would
+            // abandon the half-built kit behind a page the user never asked for.
+            returnPage: state.page === 'picker' || state.page === 'kit-slot'
+                ? state.page : 'manager',
             bindNew: action.bindNew ?? false, error: undefined };
         case 'editor-field': return editField(state, action);
         case 'retain-key': return state.editor?.original.apiKey ? { ...state,
@@ -206,17 +247,29 @@ export function modelProfileReducer(state, action) {
             // when it named THIS entry. `removeModelProfile`'s throw stays as the
             // bottom-line defense - the UI has already unbound, so it cannot fire
             // on this path.
+            //
+            // AND THE KITS GO WITH IT (agent-model-kits D-9 / I-8): a kit naming a
+            // deleted profile can neither be applied nor repaired from any screen, so
+            // leaving it behind would be leaving a permanent error. The confirmation
+            // page has already named them, so this is the action the user agreed to.
+            const doomed = kitsUsingProfile(library, id);
+            const defaultKitKept = doomed.some((kit) => kit.id === (library.defaultKitId ?? null))
+                ? null : library.defaultKitId;
+            const sessionReleased = doomed.some((kit) => kit.id === state.draft.sessionKit?.id)
+                ? null : state.draft.sessionKit;
             const profiles = {
                 ...library,
                 mainId: library.mainId === id ? null : library.mainId,
                 fastId: library.fastId === id ? null : library.fastId,
                 entries: library.entries.filter((entry) => entry.id !== id),
+                kits: (library.kits ?? []).filter((kit) => !doomed.includes(kit)),
+                defaultKitId: defaultKitKept,
             };
             const teamReset = draftSubagentProfileId(state.draft) === id
                 ? { team: { model: 'main', modelProfileId: null } }
                 : {};
             return { ...state, page: 'manager', dirty: true,
-                draft: { ...state.draft, profiles,
+                draft: { ...state.draft, profiles, sessionKit: sessionReleased,
                     patch: { ...state.draft.patch, ...teamReset } },
                 deleteId: undefined, deleteUsers: undefined,
                 // No orphan editor for a deleted entry (3.7).

package/dist/ui/scrollback/LiveTail.d.ts

@@ -4,8 +4,8 @@
  *
  * WHY THIS FILE EXISTS. Native scroll mode cannot print an entry until it settles, so
  * the live region used to show `buildLivePreview`'s plain-text projection - and for a
- * running dispatch that projection is four grey rows saying `Team: 2/4 running`. That
- * is the "simple look" the feature was opened for. A text-only region can never fix
+ * running dispatch that projection was four grey rows saying `Team: 2/4 running`. It
+ * was the "simple look" the feature was opened for. A text-only region can never fix
  * it, which is why the region's content type changed from `readonly string[]` to a
  * fixed-height box that can hold components.
  *

package/dist/ui/scrollback/LiveTail.js

@@ -3,7 +3,7 @@ import { Box } from 'ink';
 import { EntryView, nowSecFor } from '../Transcript.js';
 import { estimateEntryRows } from '../layout/virtual-window.js';
 import { SCROLLBACK_LIMITS } from './limits.js';
-import { isExcluded } from './settled-boundary.js';
+import { isSlotless } from './tail-window.js';
 import { resolveTailAnchor } from './tail-anchor.js';
 /**
  * The last `maxEntries` printable entries, each with its predecessor.
@@ -13,7 +13,12 @@ import { resolveTailAnchor } from './tail-anchor.js';
  * separation row the transcript shows above the same card.
  */
 export function selectTailEntries(entries, maxEntries) {
-    const printable = entries.filter((entry) => !isExcluded(entry));
+    // A LIVE DISPATCH CARD TAKES NO SLOT (tui-subagent-double-roster A-2): the roster
+    // draws it and `EntryView` returns null for it, so the window must not spend one of
+    // its slots on an entry that is not on screen. `isSlotless` is `tail-window.ts`'s
+    // predicate - the one `selectTailWindow` and the print pump apply - so the box and
+    // `planOverflowPrint` cannot drift into different windows.
+    const printable = entries.filter((entry) => !isSlotless(entry));
     const limit = Number.isFinite(maxEntries) ? Math.max(0, Math.floor(maxEntries)) : 0;
     if (limit === 0)
         return [];

package/dist/ui/scrollback/live-preview.js

@@ -20,6 +20,7 @@
 import { clampLiveText } from '../live-clamp.js';
 import { wrapToRows } from '../layout/wrap-rows.js';
 import { isExcluded } from './settled-boundary.js';
+import { isLiveTeamCard, outcomePhrase, rosterCounts } from '../team-status.js';
 import { clipLine } from './writer-shapes.js';
 const MAX_TEAM_RUN_ROWS = 3;
 const TOOL_LIVE_ROWS = 6;
@@ -56,8 +57,10 @@ function toolRows(entry, cols) {
     return out;
 }
 function teamRows(entry, cols) {
-    const running = entry.runs.filter((run) => !['queued', 'done', 'failed', 'aborted'].includes(run.phase)).length;
-    const out = [fit(`Team: ${running}/${entry.runs.length} running`, cols)];
+    // ONLY A SETTLED CARD REACHES HERE (the live one projects nothing, below), so the
+    // outcome phrase - `team-status.ts`'s own sentence - replaces an always-zero fraction.
+    const counts = rosterCounts(entry.runs);
+    const out = [fit(`Team: ${outcomePhrase(counts)}`, cols)];
     for (const run of entry.runs.slice(0, MAX_TEAM_RUN_ROWS)) {
         out.push(fit(`  ${run.label} ${run.phase}`, cols));
     }
@@ -71,7 +74,11 @@ function entryRows(entry, input) {
         case 'tool':
             return toolRows(entry, cols);
         case 'team':
-            return teamRows(entry, cols);
+            // THE LIVE DISPATCH HAS ONE SURFACE (tui-subagent-double-roster A-2): this
+            // projection is the text fallback for the same slot `LiveTail` fills, so a
+            // `Team: n/m running` line here would be the second live block again, one level
+            // down. A settled card still projects normally.
+            return isLiveTeamCard(entry) ? [] : teamRows(entry, cols);
         case 'todo':
             return [fit(`Todo: ${entry.doneCount}/${entry.total}`, cols)];
         case 'compaction':

package/dist/ui/scrollback/tail-window.d.ts

@@ -27,6 +27,18 @@
  * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import type { Entry } from '../../agent/reducer.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export declare function isSlotless(entry: Entry): boolean;
 export interface TailWindow {
     /** First index of the window inside the full entry list. */
     start: number;

package/dist/ui/scrollback/tail-window.js

@@ -27,6 +27,21 @@
  * closes, and `/perf`'s `window=<start>/<n> head=<rows>` is how it stays observable.
  */
 import { isExcluded, settledCount } from './settled-boundary.js';
+import { isLiveTeamCard } from '../team-status.js';
+/**
+ * Entries that take NO slot in the window: they neither print nor take a row.
+ *
+ * A LIVE DISPATCH CARD JOINS THE NON-TERMINAL SERVICE CARD HERE
+ * (tui-subagent-double-roster A-2'): the roster draws the live dispatch and the
+ * transcript draws nothing, so the window must not spend one of its slots on an
+ * entry that is not on screen. THE PRINT PUMP AND THE BOX MUST AGREE ABOUT SLOTS:
+ * so both window functions below skip it, and `LiveTail.selectTailEntries` - the
+ * window function the box renders - imports this one instead of spelling the
+ * composition out a second time.
+ */
+export function isSlotless(entry) {
+    return isExcluded(entry) || isLiveTeamCard(entry);
+}
 /**
  * The index of the first entry that is still on screen: count backwards up to
  * `maxEntries` PRINTABLE entries. Everything before it has left the region and is the
@@ -42,7 +57,7 @@ export function tailWindowStart(entries, maxEntries) {
         return entries.length;
     let seen = 0;
     for (let i = entries.length - 1; i >= 0; i -= 1) {
-        if (isExcluded(entries[i]))
+        if (isSlotless(entries[i]))
             continue;
         seen += 1;
         if (seen === limit)
@@ -54,7 +69,7 @@ export function tailWindowStart(entries, maxEntries) {
 /** `entries.slice(start)` with the entries that never print dropped. */
 export function selectTailWindow(entries, maxEntries) {
     const start = tailWindowStart(entries, maxEntries);
-    return { start, entries: entries.slice(start).filter((entry) => !isExcluded(entry)) };
+    return { start, entries: entries.slice(start).filter((entry) => !isSlotless(entry)) };
 }
 /**
  * The print boundary: never print what the region is still showing.

package/dist/ui/scrollback/use-scrollback-view.js

@@ -52,6 +52,7 @@
  */
 import { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef } from 'react';
 import { estimateEntryRows } from '../layout/virtual-window.js';
+import { isLiveTeamCard } from '../team-status.js';
 import { buildScrollbackBudget } from './budget.js';
 import { buildLivePreview } from './live-preview.js';
 import { SCROLLBACK_LIMITS } from './limits.js';
@@ -554,6 +555,12 @@ export function useScrollbackView(args) {
         if (index < 0)
             return false;
         const entry = list[index];
+        // A LIVE DISPATCH CARD IS REFUSED, NOT PRINTED (tui-subagent-double-roster A-2').
+        // `Ctrl+O` arrives mid-dispatch, `EntryView` suppresses this card, and a copy
+        // printed here would be a FROZEN SNAPSHOT of a card the roster is still rewriting -
+        // permanently in the scrollback, because printed is forever.
+        if (isLiveTeamCard(entry))
+            return false;
         // THE COPY IS RENDERED IN A MICROTASK, NOT IN THE KEY HANDLER THAT ASKED FOR IT.
         // `Ctrl+O` arrives on the stdin stream, and an offscreen render issued from there is
         // SCHEDULED rather than flushed - the reconciler sees a pending update, the frame the

package/dist/ui/team-status.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Team status — the ONE authority that answers "what state is this child in, and
+ * how is that drawn / counted / timed" (tui-subagent-double-roster A-1).
+ *
+ * WHY THIS FILE EXISTS. The phase -> glyph / colour / count question used to be
+ * answered by nine copies in seven files, and they disagreed. The transcript card
+ * asked `isOk(run) ? toolDone : toolError`, so six of the eight phases - every
+ * child that was still working - were painted with the FAILURE glyph, and an
+ * aborted child was counted as a failed one forever. That is not a palette
+ * mistake, it is a judgement implemented in the wrong number of places.
+ *
+ * THE VOCABULARY IS THE DOMAIN'S (analysis A-1' item 3). `ChildStatus` reuses
+ * `SubagentPhase`'s own words - `queued` / `running` / `done` / `failed` /
+ * `aborted` - and never invents a second dictionary (`pending` was proposed and
+ * rejected: `SubagentPhase` does not have it, and two words for one state is how
+ * the tenth copy gets written).
+ *
+ * FIVE STATES, NOT FOUR (A-1' item 2). `aborted` is NOT a failure. The runtime
+ * distinguishes them on purpose (`Runtime.settlePhase`: aborted first, then the
+ * timeout, then the error), and a user pressing Esc must not read their own
+ * action back as "3 failed". So `aborted` takes `glyphs.warn` and
+ * `theme.noticeWarn`, which collide with neither the done tick nor the failed
+ * cross in either glyph tier.
+ *
+ * ASCII ONLY: `src/ui/**` is inside `glyphs.test.ts`'s static scan, so every
+ * symbol here is injected through `pickGlyphs(caps)`.
+ */
+import type { Entry } from '../agent/reducer.js';
+import type { SubagentRun } from '../team/types.js';
+import type { Glyphs } from './glyphs.js';
+import type { Theme } from './theme.js';
+/**
+ * The five readings a child can have on screen. A TOTAL mapping of
+ * `SubagentPhase`, which is why `childStatus` needs no guard clauses: `starting`,
+ * `thinking`, `tool` and `waiting` are all "this child is working right now", and
+ * the per-row activity column is what tells them apart.
+ */
+export type ChildStatus = 'queued' | 'running' | 'done' | 'failed' | 'aborted';
+/**
+ * The status of one child.
+ *
+ * A LOOKUP TABLE RATHER THAN A SWITCH, because the mapping is the whole content
+ * of this function: a `Record` keyed by the phase union is exhaustive at compile
+ * time (a new phase is a missing-key error) and cannot drift from the type.
+ */
+export declare function childStatus(run: SubagentRun): ChildStatus;
+/** Per-status totals of a roster. `total` is the roster size, not the sum. */
+export interface RosterCounts {
+    queued: number;
+    running: number;
+    done: number;
+    failed: number;
+    aborted: number;
+    total: number;
+}
+/**
+ * Count a roster once, by status.
+ *
+ * THE HEADER, THE CARD HEADLINE AND THE STATUS CHIP ALL READ THIS. Before it
+ * existed the header filtered `phase !== 'queued' && ...` for "running" and the
+ * card subtracted `runs.length - isOk(runs)`, so the same dispatch reported
+ * `0 running` above two rows reading `queued` and `1 failed` for a child that had
+ * never started.
+ */
+export declare function rosterCounts(runs: readonly SubagentRun[]): RosterCounts;
+/** True while the child is doing something - the only state that animates. */
+export declare function isRunningStatus(status: ChildStatus): boolean;
+/** True once the child's outcome is final, whatever it is. */
+export declare function isSettledStatus(status: ChildStatus): boolean;
+/**
+ * The static marker for a status.
+ *
+ * `running` gets `spinnerStill` because the animated `<Spinner>` is the caller's
+ * job: it needs `reducedMotion` and `caps.unicode`, and a component that owns its
+ * own `ink-spinner` is what `spinner-census.test.ts` counts. The caller swaps this
+ * glyph for the spinner when it may animate.
+ */
+export declare function statusGlyph(status: ChildStatus, glyphs: Glyphs): string;
+/**
+ * The marker padded to the tier's widest one, for the leading cell of a row.
+ *
+ * THE PADDING IS NOT COSMETIC (A-1'a): the ASCII tier spells `[ok]` (4), `[x]` (3)
+ * and `!` (1), so an unpadded marker cell starts every label at a different
+ * column and the roster stops reading as a table. `TodoPanel` pads its marker cell
+ * for the same reason. The Unicode tier's markers are all one cell wide, so the
+ * padding is a no-op there.
+ */
+export declare function statusMarkerCell(status: ChildStatus, glyphs: Glyphs): string;
+/**
+ * The colour of a status. One reading for the roster row, the card row and the
+ * card's rail marker.
+ *
+ * `aborted` deliberately does NOT share `toolError` with `failed`: an abort is the
+ * user's own Esc, and the analysis found that painting it red made a cancelled
+ * dispatch permanently unreadable in the history.
+ */
+export declare function statusColor(status: ChildStatus, theme: Theme): string | undefined;
+/**
+ * How long this child has been (or was) working, in ms.
+ *
+ * `endedAt ?? now`, NOT `endedAt ?? 0`. The transcript card used the latter, which
+ * made every RUNNING child read `0ms` while the roster beside it read `1m05s` for
+ * the same child - the pair of contradictory readouts the reporter screenshotted.
+ */
+export declare function childElapsedMs(run: SubagentRun, now: number): number;
+/**
+ * The roster header's count section, e.g. `2 running · 0 done · 1 queued`.
+ *
+ * `queued` IS COUNTED (the old `isRunning` excluded it, so a fresh dispatch
+ * announced `0 running · 0 done` above five rows that each said `queued`), and a
+ * non-zero bucket is always named even when nothing is running - a roster whose
+ * children are all `aborted` must say so rather than `0 running · 0 done`.
+ *
+ * WIDTH LADDER: narrow terminals drop the least urgent clause first, in the order
+ * `done`, `aborted`, `failed`, `queued`; `running` is never dropped. The order is
+ * a product decision, not a detail: while a dispatch is live, what is happening
+ * now outranks what has already finished, and the per-row activity column carries
+ * the finished children's own facts anyway.
+ */
+export declare function rosterHeadline(counts: RosterCounts, glyphs: Glyphs, cols: number): string;
+/**
+ * The settled card's outcome buckets, e.g. `2 ok, 1 aborted, 1 failed`.
+ *
+ * `ok` is always shown (it is the denominator a reader compares against) and a
+ * zero bucket is omitted, so a clean dispatch still reads `3 ok` and a failed one
+ * no longer claims that a cancelled child failed.
+ */
+export declare function outcomePhrase(counts: RosterCounts): string;
+/**
+ * Whether this entry is the transcript card of a dispatch that is STILL RUNNING,
+ * i.e. the second live surface the reporter saw beside the roster.
+ *
+ * ONE PREDICATE, FOUR CONSUMERS (analysis A-2'): the transcript's `case 'team'`
+ * and `estimateEntryRows` (so the virtual window and the frame agree), the tail
+ * window and `LiveTail` (so the pump's print plan and the box agree), and the
+ * `Ctrl+O` finder plus `reprintExpanded` (so a keypress cannot print a stale
+ * snapshot of a card that is still being rewritten). `state.entries` is NEVER
+ * filtered: the entry's lifecycle and `session/persist.ts`'s `interrupted`
+ * normalisation depend on it staying there.
+ */
+export declare function isLiveTeamCard(entry: Entry): boolean;