@aragon-agent/cli 0.6.33 → 0.6.35

package/dist/ui/Transcript.js

@@ -12,6 +12,7 @@ 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 { 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';
@@ -42,6 +43,12 @@ export function nowSecFor(entry, nowSec) {
     // 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
@@ -96,8 +103,21 @@ function EntryViewImpl({ entry, prev, expanded, thinkingVisible, reducedMotion,
                 // 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':
-            return frame(glyphs.teamAgent, teamCardColor(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 }));
+        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 '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, live: entry.live, interrupted: entry.interrupted, theme: theme, caps: caps }));
         case 'retry':

package/dist/ui/entries/TeamCard.d.ts

@@ -15,6 +15,7 @@ import React from 'react';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { SubagentRun } from '../../team/types.js';
+import { type RosterCounts } from '../team-status.js';
 export interface TeamCardProps {
     requested: number;
     runs: SubagentRun[];
@@ -25,9 +26,24 @@ export interface TeamCardProps {
     reducedMotion?: boolean;
     theme: Theme;
     caps: TermCapabilities;
+    /**
+     * Wall-clock seconds, set only while the dispatch is live (`nowSecFor`). WITHOUT
+     * IT a running child's elapsed time came from `(endedAt ?? 0) - startedAt` - a
+     * negative number clamped to `0ms`, the readout that contradicted the roster
+     * beside it (A-1 / E4).
+     */
+    nowSec?: number;
 }
-/** The card's aggregate colour: any failure dominates. */
-export declare function teamCardColor(runs: SubagentRun[], active: boolean, aborted: boolean, theme: Theme): string | undefined;
+/**
+ * The card's aggregate colour.
+ *
+ * FAILURES DOMINATE, THEN A CANCELLATION, THEN A DISPATCH THAT NEVER SETTLED.
+ * The old version asked `runs.some((r) => !isOk(r))`, so an entry whose children
+ * were still working - and one the user had cancelled - was painted `toolError`
+ * (A-1 / E8). `RosterCounts` is passed IN rather than recomputed, so this colour
+ * and the headline cannot disagree inside one card.
+ */
+export declare function teamCardColor(counts: RosterCounts, active: boolean, aborted: boolean, theme: Theme): string | undefined;
 declare function TeamCardImpl(props: TeamCardProps): React.ReactElement;
 /**
  * `React.memo` with the DEFAULT comparator (tui-render-performance L2 / R3).

package/dist/ui/entries/TeamCard.js

@@ -18,37 +18,71 @@ import Spinner from 'ink-spinner';
 import { pickGlyphs } from '../glyphs.js';
 import { railBorderProps } from '../layout/Gutter.js';
 import { formatDuration } from '../../agent/usage.js';
-function isOk(run) {
-    return run.phase === 'done' && !run.error;
-}
-/** The card's aggregate colour: any failure dominates. */
-export function teamCardColor(runs, active, aborted, theme) {
+import { childElapsedMs, childStatus, outcomePhrase, rosterCounts, statusColor, statusMarkerCell, } from '../team-status.js';
+/**
+ * The card's aggregate colour.
+ *
+ * FAILURES DOMINATE, THEN A CANCELLATION, THEN A DISPATCH THAT NEVER SETTLED.
+ * The old version asked `runs.some((r) => !isOk(r))`, so an entry whose children
+ * were still working - and one the user had cancelled - was painted `toolError`
+ * (A-1 / E8). `RosterCounts` is passed IN rather than recomputed, so this colour
+ * and the headline cannot disagree inside one card.
+ */
+export function teamCardColor(counts, active, aborted, theme) {
     if (active)
         return theme.toolRunning;
-    if (aborted || runs.some((r) => !isOk(r)))
+    if (counts.failed > 0)
         return theme.toolError;
+    if (aborted || counts.aborted > 0 || counts.queued > 0 || counts.running > 0) {
+        return theme.noticeWarn;
+    }
     return theme.toolDone;
 }
+/** `nowSec` is seconds (`App`'s 1 Hz clock); a card measures in milliseconds. */
+function liveClockMs(nowSec) {
+    return nowSec === undefined ? Date.now() : nowSec * 1000;
+}
+/**
+ * The elapsed column for one child: a MEASUREMENT, or an empty cell.
+ *
+ * `liveNow` is defined only while the dispatch is live, and that distinction is the
+ * whole point. A child restored by `/resume` keeps its `startedAt` and has no
+ * `endedAt` - `session/persist.ts` settles the ENTRY, it does not invent an end time
+ * for the run - so a figure computed against `Date.now()` would claim hours of work
+ * that never happened, next to an `interrupted (session resumed)` headline that says
+ * the opposite. An unmeasurable duration is left blank instead.
+ */
+function elapsedCell(run, liveNow) {
+    const end = run.endedAt ?? liveNow;
+    if (run.startedAt === undefined || end === undefined)
+        return '';
+    return formatDuration(childElapsedMs(run, end));
+}
 function TeamCardImpl(props) {
     const { requested, runs, aborted, durationMs, active, expanded, reducedMotion, theme, caps } = props;
     const glyphs = pickGlyphs(caps);
-    const color = teamCardColor(runs, active, aborted, theme);
-    const ok = runs.filter(isOk).length;
-    const failed = runs.length - ok;
+    // ONE COUNTING AUTHORITY (A-1): `ok`/`failed` used to be `isOk(...)` and
+    // `runs.length - ok`, which counted a cancelled child - and a still-working one -
+    // as a failed one (E3 / E8).
+    const counts = rosterCounts(runs);
+    const color = teamCardColor(counts, active, aborted, theme);
+    // A CLOCK ONLY WHILE THE DISPATCH IS LIVE: a settled card has nothing left to time,
+    // and a clock in the settled path is how a resumed dispatch came to read like a run
+    // that is still going (`elapsedCell`).
+    const liveNow = active ? liveClockMs(props.nowSec) : undefined;
     // A dispatch entry restored from `/resume` is settled and aborted but has no
     // duration: nothing measured it, because the process it belonged to is gone.
     // Saying so plainly beats rendering `0.0s (0 ok, 3 failed)`, which reads like
     // a dispatch that ran and lost (§5.3 / P1-5).
     const interrupted = !active && aborted && durationMs === undefined;
-    const settled = runs.filter((r) => r.phase === 'done' || r.phase === 'failed' || r.phase === 'aborted').length;
     const headline = interrupted
         ? 'interrupted (session resumed)'
         : active
-            ? `${runs.length - settled} running`
-            : `${formatDuration(durationMs ?? 0)}  (${ok} ok, ${failed} failed)`;
+            ? `${counts.queued + counts.running} running`
+            : `${formatDuration(durationMs ?? 0)}  (${outcomePhrase(counts)})`;
     const count = `${runs.length} ${runs.length === 1 ? 'subagent' : 'subagents'}`;
     const dropped = requested > runs.length ? `  (${runs.length} of ${requested} requested)` : '';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: isOk(run) ? theme.toolDone : theme.toolError, children: isOk(run) ? glyphs.toolDone : glyphs.toolError }), _jsxs(Text, { color: theme.primary, children: [' ', run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? 0) - run.startedAt)) : '', `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] }), run.retry && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', "retry ", run.retry.attempt, "/", run.retry.maxRetries] }))] }, run.label))), expanded &&
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.accent, bold: true, children: "team" }), _jsxs(Text, { color: theme.muted, children: [' ', count, dropped, '  '] }), active && !reducedMotion && caps.unicode ? (_jsxs(Text, { color: color, children: [_jsx(Spinner, { type: "dots" }), " ", headline] })) : (_jsxs(Text, { color: color, children: [active ? `${glyphs.spinnerStill} ` : '', headline] }))] }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, paddingLeft: 1, ...railBorderProps(glyphs.railVertical, theme.border), children: [runs.map((run) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: statusColor(childStatus(run), theme), children: statusMarkerCell(childStatus(run), glyphs) }), _jsxs(Text, { color: theme.primary, children: [' ', run.label.padEnd(8).slice(0, 8)] }), _jsxs(Text, { color: theme.muted, children: [' ', run.description, '  ', elapsedCell(run, liveNow), `  ${run.turns} turns`, run.filesTouched.length > 0 ? `  ${run.filesTouched.length} files` : '', run.error ? `  ${run.error}` : ''] }), run.retry && (_jsxs(Text, { color: theme.noticeWarn, bold: true, children: ['  ', "retry ", run.retry.attempt, "/", run.retry.maxRetries] }))] }, run.label))), expanded &&
                         runs.map((run) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: theme.accent, children: [run.label, " ", glyphs.midDot, " ", run.description] }), _jsx(Text, { color: theme.muted, children: run.summary ?? '(no summary)' })] }, `s-${run.label}`))), !expanded && !active && runs.length > 0 && (_jsxs(Text, { color: theme.muted, children: ["+", runs.length, " ", runs.length === 1 ? 'summary' : 'summaries', " (Ctrl+O)"] })), expanded && _jsx(Text, { color: theme.muted, children: "(Ctrl+O to collapse)" })] })] }));
 }
 /**

package/dist/ui/layout/header-hints.d.ts

@@ -46,7 +46,7 @@ export declare const HEADER_HINT_LIMITS: {
      */
     readonly separatorCells: 2;
 };
-export type HeaderHintId = 'branch' | 'index' | 'detail';
+export type HeaderHintId = 'branch' | 'index' | 'kit' | 'detail';
 export interface HeaderHintClause {
     id: HeaderHintId;
     text: string;
@@ -74,4 +74,14 @@ export declare function planHeaderHints(input: {
     statusExpanded: boolean;
     overlayOpen: boolean;
     scrolledLines: number;
+    /**
+     * Whether the `^K switch kit` clause exists at all (default `true`).
+     *
+     * `App` ALWAYS PASSES TRUE, including for a user with no kits: the whole point
+     * of the requirement is discoverability of `ctrl+K`, and an empty library is
+     * exactly the state that needs it (the picker's own `No kits yet` row tells
+     * them where to create one). `false` exists for tests and for the future
+     * switch, and it degrades the six expanded rungs back into today's four.
+     */
+    kitHint?: boolean;
 }): HeaderHintPlan;

package/dist/ui/layout/header-hints.js

@@ -49,6 +49,15 @@ export const HEADER_HINT_LIMITS = {
 /** The verbatim clause text (spec 3.8, appendix A). */
 const BRANCH_CLAUSE = { collapsed: '^L branch', expanded: '^L new branch' };
 const INDEX_CLAUSE = { collapsed: '^I Index', expanded: '^I build index' };
+/**
+ * THE KIT CLAUSE HAS NO COLLAPSED FORM (agent-model-kits D-11).
+ *
+ * The requirement says the `ctrl+k` hint appears AFTER `ctrl+G`; the collapsed
+ * row is the narrowest budget in the header, and `^K` is a low-frequency action.
+ * Spending 13 columns of the everyday row on it would push `provider:model`
+ * leftward on every launch for a key pressed twice a session.
+ */
+const KIT_CLAUSE = { expanded: '^K switch kit' };
 const DETAIL_CLAUSE = { collapsed: '^G more', expanded: '^G less' };
 /** L3 gives the key name and nothing else: discoverability at the last width. */
 const BRANCH_KEY_ONLY = '^L';
@@ -77,7 +86,7 @@ export function planHeaderHints(input) {
         const detail = input.statusExpanded ? DETAILS_ON : DETAILS_OFF;
         return buildPlan([{ id: 'detail', text: detail }], scrollCells, true);
     }
-    const ladder = ladderFor(input.statusExpanded);
+    const ladder = ladderFor(input.statusExpanded, input.kitHint !== false);
     // THE SEPARATOR IS SPENT OUT OF THE SAME ROW (defect 12): left half + gap + this
     // column have to add up to `columns`, so the gap comes off the budget instead of
     // being assumed free.
@@ -94,8 +103,18 @@ export function planHeaderHints(input) {
     // shrinks (to zero), and `overflow="hidden"` keeps that from overflowing.
     return buildPlan(ladder[ladder.length - 1] ?? [], scrollCells, false);
 }
-/** The four rungs, widest first. Built per call because the widths are text-derived. */
-function ladderFor(statusExpanded) {
+/**
+ * The rungs, widest first. Built per call because the widths are text-derived.
+ *
+ * THE EXPANDED ORDER `branch -> index -> kit -> detail` IS A REGRESSION
+ * CONSTRAINT, NOT A PREFERENCE (RV-P1-2). With `kit` AFTER `index`, rungs E2,
+ * E4, E5 and E6 are exactly today's four expanded rungs, so every existing
+ * width assertion for 48-78 columns keeps its old answer and `^I` never
+ * disappears from a row where it used to fit. Putting `^K` first would have cost
+ * `^I` everything from 64 to 78 columns - a permanent loss, paid for a
+ * low-frequency key.
+ */
+function ladderFor(statusExpanded, kitHint) {
     const branch = {
         id: 'branch',
         text: statusExpanded ? BRANCH_CLAUSE.expanded : BRANCH_CLAUSE.collapsed,
@@ -108,8 +127,21 @@ function ladderFor(statusExpanded) {
         id: 'detail',
         text: statusExpanded ? DETAIL_CLAUSE.expanded : DETAIL_CLAUSE.collapsed,
     };
+    const base = [
+        [branch, index, detail],
+        [branch, detail],
+        [{ id: 'branch', text: BRANCH_KEY_ONLY }, detail],
+        [detail],
+    ];
+    // THE COLLAPSED LADDER IS UNTOUCHED (D-11): `^K` has no collapsed form, so a
+    // user who never presses `ctrl+G` sees the row they always saw (I-9).
+    if (!statusExpanded || !kitHint)
+        return base;
+    const kit = { id: 'kit', text: KIT_CLAUSE.expanded };
     return [
+        [branch, index, kit, detail],
         [branch, index, detail],
+        [branch, kit, detail],
         [branch, detail],
         [{ id: 'branch', text: BRANCH_KEY_ONLY }, detail],
         [detail],

package/dist/ui/layout/kit-chip.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The status bar's kit chip: pure width planning, no JSX
+ * (agent-model-kits §4.8 / D-12).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY A PLANNER, AND WHY IT IS THE SAME SHAPE AS `session-chip.ts`: the status
+ * row is measured cell by cell, and anything appended "just to the right" eats
+ * `phase` - the one field a user needs while a run is in flight. The chip
+ * therefore competes for the SAME budget as every other field, and the rung that
+ * survives is computed rather than hand-tuned.
+ *
+ * ONE COMPARISON, NOT A THRESHOLD TABLE: `columns - (cells + gap) >=
+ * minStatusCells`. The width table in the spec is what that comparison WORKS
+ * OUT TO. `minStatusCells` is deliberately the same 34 as the session chip's -
+ * both answer "how much room must the left half keep", and two numbers for one
+ * question is how a "fit" and a "don't fit" end up disagreeing.
+ */
+export declare const KIT_CHIP_LIMITS: {
+    /** Blank cells between the chip and the field run. */
+    readonly gapCells: 2;
+    /** The floor the left half must keep; asserted equal to the session chip's. */
+    readonly minStatusCells: 34;
+    /** Below this the `kit` label is dropped before the name is shortened. */
+    readonly labelMinCols: 72;
+    /** The shortest unique prefix worth showing; below it the chip hides. */
+    readonly minNameChars: 4;
+};
+export interface KitChipPlan {
+    visible: boolean;
+    text: string;
+    cells: number;
+    gap: number;
+}
+export interface KitChipInput {
+    columns: number;
+    /**
+     * The kit in effect, or absent/null when there is none.
+     *
+     * ABSENT IS NOT EMPTY: with no kit the plan is hidden and the row's output is
+     * byte-identical to the pre-feature build (I-9).
+     */
+    kit?: {
+        name: string;
+        modified: boolean;
+        otherNames: readonly string[];
+    } | null | undefined;
+}
+/** Plan the chip for `columns` and this session's kit. */
+export declare function planKitChip(input: KitChipInput): KitChipPlan;

package/dist/ui/layout/kit-chip.js

@@ -0,0 +1,81 @@
+/**
+ * The status bar's kit chip: pure width planning, no JSX
+ * (agent-model-kits §4.8 / D-12).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY A PLANNER, AND WHY IT IS THE SAME SHAPE AS `session-chip.ts`: the status
+ * row is measured cell by cell, and anything appended "just to the right" eats
+ * `phase` - the one field a user needs while a run is in flight. The chip
+ * therefore competes for the SAME budget as every other field, and the rung that
+ * survives is computed rather than hand-tuned.
+ *
+ * ONE COMPARISON, NOT A THRESHOLD TABLE: `columns - (cells + gap) >=
+ * minStatusCells`. The width table in the spec is what that comparison WORKS
+ * OUT TO. `minStatusCells` is deliberately the same 34 as the session chip's -
+ * both answer "how much room must the left half keep", and two numbers for one
+ * question is how a "fit" and a "don't fit" end up disagreeing.
+ */
+import stringWidth from 'string-width';
+export const KIT_CHIP_LIMITS = {
+    /** Blank cells between the chip and the field run. */
+    gapCells: 2,
+    /** The floor the left half must keep; asserted equal to the session chip's. */
+    minStatusCells: 34,
+    /** Below this the `kit` label is dropped before the name is shortened. */
+    labelMinCols: 72,
+    /** The shortest unique prefix worth showing; below it the chip hides. */
+    minNameChars: 4,
+};
+const HIDDEN = { visible: false, text: '', cells: 0, gap: 0 };
+/** The shortest prefix of `name` that no sibling name also starts with. */
+function uniqueLength(name, others) {
+    const points = [...name];
+    const start = Math.min(KIT_CHIP_LIMITS.minNameChars, points.length);
+    const shared = (length) => {
+        const prefix = points.slice(0, length).join('');
+        return others.some((other) => [...other].slice(0, length).join('') === prefix);
+    };
+    let length = start;
+    while (length < points.length && shared(length))
+        length += 1;
+    return Math.max(length, start);
+}
+/** Plan the chip for `columns` and this session's kit. */
+export function planKitChip(input) {
+    const kit = input.kit;
+    if (!kit)
+        return HIDDEN;
+    const name = kit.name.trim();
+    if (!name)
+        return HIDDEN;
+    const columns = Number.isFinite(input.columns) ? Math.floor(input.columns) : 80;
+    const gap = KIT_CHIP_LIMITS.gapCells;
+    const fits = (text) => columns - (stringWidth(text) + gap) >= KIT_CHIP_LIMITS.minStatusCells;
+    const mark = kit.modified ? '~' : '';
+    const plan = (text) => ({ visible: true, text, cells: stringWidth(text), gap });
+    // Widest rung first, then drop the label, then shorten the name, then hide.
+    // THE ORDER IS THE DECISION: a reader cares WHICH kit is in effect before they
+    // care that it is a kit, so the name is the last thing to go.
+    //
+    // `KIT_CHIP_LIMITS.labelMinCols` NEEDS NO BRANCH: a labelled rung is 45 cells
+    // for a 40-character name, so `fits` already rejects it below ~81 columns. The
+    // constant is the documented intent (labels belong to wide rows), measured
+    // rather than hard-coded into the ladder.
+    const points = [...name];
+    const shortest = uniqueLength(name, kit.otherNames);
+    const rungs = [];
+    if (kit.modified)
+        rungs.push(`kit ${name}~`);
+    rungs.push(`kit ${name}`);
+    if (kit.modified)
+        rungs.push(`${name}~`);
+    rungs.push(name);
+    for (let length = points.length - 1; length >= shortest; length -= 1) {
+        rungs.push(`${points.slice(0, length).join('')}${mark}`);
+    }
+    for (const text of rungs)
+        if (fits(text))
+            return plan(text);
+    return HIDDEN;
+}

package/dist/ui/layout/virtual-window.js

@@ -38,6 +38,7 @@ import { COMPACTION_LIMITS } from '../../compaction/limits.js';
 import { GUTTER_WIDTH } from './Gutter.js';
 import { expandTabs } from '../display-tab.js';
 import { USER_ENTRY_MAX_ROWS } from '../composer-limits.js';
+import { isLiveTeamCard } from '../team-status.js';
 export const VIRTUAL_LIMITS = {
     /**
      * Entries kept mounted on each side of the visible band.
@@ -315,6 +316,14 @@ export function estimateEntryRows(entry, cols, density, expanded, thinkingVisibl
             return separation + 1 + shown + 1;
         }
         case 'team':
+            // A LIVE DISPATCH CARD IS NOT DRAWN AT ALL (tui-subagent-double-roster A-2):
+            // the roster is the only live subagent surface, so this entry owes the window
+            // ZERO rows. Estimating it at its real height while `EntryView` renders nothing
+            // would make `selectWindow` reserve four rows for a card that is not on screen -
+            // blank space at the bottom of every dispatch frame, and a window boundary that
+            // disagrees with what the printer measures.
+            if (isLiveTeamCard(entry))
+                return 0;
             return separation + 1 + entry.runs.length + (expanded ? entry.runs.length * 3 + 1 : 1);
         case 'todo':
             return separation + 1 + entry.items.length;

package/dist/ui/overlays/HelpOverlay.js

@@ -46,6 +46,12 @@ function allKeyRows(times) {
         ['Ctrl+R', 'Redraw the frame'],
         ['Ctrl+T', 'Show/hide thinking (off by default)'],
         ['Ctrl+I', 'Build the project index (bundled skill; asks first; needs keyboard enhancement)'],
+        // THE KIT KEYS (agent-model-kits D-11 / D-15): `Ctrl+K` moved to the picker
+        // and `killToEnd` moved to `Alt+K`. BOTH rows are listed, because an existing
+        // user will press the old key by muscle memory and needs to find out where it
+        // went - and because `^K` is only advertised in the expanded header row.
+        ['Ctrl+K', 'Agent kits: pick a preset for this session (see /kit)'],
+        ['Alt+K', 'Delete from the cursor to the end of the line (was Ctrl+K)'],
         ['Ctrl+G', 'Expand/collapse status details; disabled while an overlay is open'],
         ['PgUp / PgDn', 'Scroll a page (transcript, or this overlay)'],
         ['Shift+Up / Shift+Down', 'Scroll the transcript a line (full-screen mode)'],
@@ -85,6 +91,7 @@ const COMMANDS = [
     ['/max-tokens [n|auto]', 'Output token cap; no argument reports the effective one'],
     ['/team [on|off|max n]', 'Team subagents: status, switch, fan-out width'],
     ['/fast [on|off|model|review]', 'Fast model tier: status, switch, model, review cadence'],
+    ['/kit [list|use <name>]', 'Agent kits: what is in effect, list them, use one for this session'],
     [
         '/todo [on|off|panel|follow|clear|continue]',
         'Todo planning: status, switches, the rail, follow-through',

package/dist/ui/overlays/KitEditor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Settings > Kit pack > editor (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FOUR ROWS AND TWO ACTIONS, and every slot is an explicit decision (D-8): the
+ * Main slot is required, the Fast slot is a two-state choice (`off` is a
+ * decision, not an omission), and the Subagent slot reuses the existing
+ * `Same as main` / `Fast tier model` vocabulary so the summary sentence the root
+ * page already prints (`Fast tier (off - falls back to main)`) needs no second
+ * wording. Nothing is written until the ROOT page's Save.
+ */
+import React from 'react';
+import type { ModelProfileState } from './model-profile-state.js';
+import type { KitAction, KitDraft } from './kit-settings-state.js';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+interface KitEditorProps extends ProfileFrameProps {
+    draft: KitDraft;
+    state: ModelProfileState;
+    dispatch: React.Dispatch<KitAction>;
+}
+export declare function KitEditor(props: KitEditorProps): React.ReactElement;
+export {};

package/dist/ui/overlays/KitEditor.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Settings > Kit pack > editor (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * FOUR ROWS AND TWO ACTIONS, and every slot is an explicit decision (D-8): the
+ * Main slot is required, the Fast slot is a two-state choice (`off` is a
+ * decision, not an omission), and the Subagent slot reuses the existing
+ * `Same as main` / `Fast tier model` vocabulary so the summary sentence the root
+ * page already prints (`Fast tier (off - falls back to main)`) needs no second
+ * wording. Nothing is written until the ROOT page's Save.
+ */
+import { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+const ROWS = ['name', 'main', 'subagent', 'fast', 'save', 'cancel'];
+function slotLabel(draft, state) {
+    const entries = state.draft.profiles?.entries ?? [];
+    const name = (id) => {
+        const entry = id ? entries.find((item) => item.id === id) : undefined;
+        // `Profile missing` rather than a blank: a kit can be pointed at a profile
+        // that was removed on disk, and the editor is where that gets fixed.
+        return entry ? `${entry.provider}:${entry.model}  (${entry.name})` : id ? 'Profile missing'
+            : '(not set)';
+    };
+    const subagent = draft.subagent.model === 'main' ? 'Same as main'
+        : draft.subagent.model === 'fast' ? 'Fast tier model'
+            : name(draft.subagent.modelProfileId);
+    return { main: name(draft.mainProfileId), fast: name(draft.fastProfileId),
+        subagent };
+}
+export function KitEditor(props) {
+    const glyphs = pickGlyphs(props.caps);
+    const { draft, dispatch } = props;
+    const [index, setIndex] = useState(0);
+    const row = ROWS[index];
+    const offset = useProfileScroll(props, index);
+    const labels = slotLabel(draft, props.state);
+    const filled = [draft.mainProfileId, draft.fastProfileId,
+        draft.subagent.model !== 'profile' || draft.subagent.modelProfileId]
+        .filter(Boolean).length;
+    function activate(target) {
+        if (target === 'main')
+            dispatch({ type: 'kit-slot', slot: 'main' });
+        if (target === 'fast')
+            dispatch({ type: 'kit-slot', slot: 'fast' });
+        if (target === 'subagent')
+            dispatch({ type: 'kit-slot', slot: 'subagent' });
+        if (target === 'save')
+            dispatch({ type: 'kit-save' });
+        if (target === 'cancel')
+            dispatch({ type: 'kit-cancel' });
+    }
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            dispatch({ type: 'kit-cancel' });
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            setIndex((index - 1 + ROWS.length) % ROWS.length);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setIndex((index + 1) % ROWS.length);
+            return;
+        }
+        if (key.return) {
+            activate(row);
+            return;
+        }
+        if (row !== 'name' || key.ctrl || key.meta)
+            return;
+        // THE NAME IS THE ONLY TEXT FIELD, and control characters are stripped by the
+        // reducer rather than refused here - a pasted name with a newline should
+        // become a name, not an error the user cannot see.
+        const text = stripPasteFrames(stripEnterFrames(input));
+        if (key.backspace || key.delete) {
+            dispatch({ type: 'kit-name', value: [...draft.name].slice(0, -1).join('') });
+            return;
+        }
+        if (text)
+            dispatch({ type: 'kit-name', value: `${draft.name}${text}` });
+    });
+    const lines = [`Name          ${draft.name}`,
+        `Main profile  ${labels.main}`,
+        `Subagent      ${labels.subagent}`,
+        `Fast tier     ${draft.fastProfileId ? labels.fast : 'off (this kit turns it off)'}`,
+        `Save          (${filled} slots set)`, 'Cancel'];
+    const rows = lines.map((line, at) => (_jsx(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: `${at === index ? glyphs.caret : ' '} ${clipProfileText(line, props.cols - 8)}` }, at)));
+    if (draft.error) {
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.noticeError, children: clipProfileText(draft.error, props.cols - 8) }, "error"));
+    }
+    return _jsx(OverlayFrame, { ...props, title: draft.id ? 'Edit kit' : 'New kit', hint: "Enter choose | type to rename | Esc back", rows: rows, scrollOffset: offset });
+}

package/dist/ui/overlays/KitManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Settings > Kit pack: the manager page (agent-model-kits §4.5 / D-9).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * CRUD LIVES HERE AND NOWHERE ELSE: `New kit` and `e` open the editor, `d` asks
+ * a confirmation that NAMES the consequences, `s` runs exit A (three slots plus
+ * the persisted pointer, because a default that only moved a pointer would not
+ * be in effect at the next launch - RV-P0-3), and `Enter` applies a kit to the
+ * transaction draft. Nothing on this page writes the config file.
+ */
+import React from 'react';
+import { type ProfileFrameProps } from './ModelProfilePicker.js';
+import type { KitAction, KitManagerRow } from './kit-settings-state.js';
+interface KitManagerProps extends ProfileFrameProps {
+    rows: KitManagerRow[];
+    error?: string;
+    dispatch: React.Dispatch<KitAction>;
+    /** Leave the kit pages entirely: `Esc` here means "back to Settings". */
+    onBack: () => void;
+}
+export declare function KitManager(props: KitManagerProps): React.ReactElement;
+export {};