@aragon-agent/cli 0.6.34 → 0.6.35

package/dist/config/model-profiles.js

@@ -1,9 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { ADAPTER_PROVIDERS, clampContextWindow, isAutoToken } from './schema.js';
+import { normalizeKits, validateKits } from './model-kits.js';
 const CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
 /** Return a fresh empty library without initiating a disk migration. */
 export function emptyModelProfiles() {
-    return { version: 1, entries: [], mainId: null, fastId: null };
+    return { version: 1, entries: [], mainId: null, fastId: null, kits: [],
+        defaultKitId: null, kitsVersion: 1 };
 }
 /** Return independently mutable role state. */
 export function emptyModelProfileState(invalid = false) {
@@ -69,7 +71,16 @@ function validateEntry(value, index) {
     }
     return issues;
 }
-/** Validate untrusted input; diagnostics never include supplied values. */
+/**
+ * Validate untrusted input; diagnostics never include supplied values.
+ *
+ * THE KIT SECTION IS STRUCTURAL ONLY (agent-model-kits RV-P1-1). `mainId` /
+ * `fastId` above are `missing_reference` because a dangling ROLE BINDING leaves
+ * the whole library unreadable (there is no "nothing bound" recovery path once
+ * a bound id is gone), while a dangling KIT SLOT degrades at resolution time
+ * into `Profile missing` and a refused apply - the same discipline
+ * `team.modelProfileId` already follows (`schema.ts` clampTeamConfig).
+ */
 export function validateModelProfiles(value) {
     if (value === undefined)
         return [];
@@ -99,6 +110,7 @@ export function validateModelProfiles(value) {
                 message: 'Select an existing profile or Current custom.' });
         }
     }
+    issues.push(...validateKits(value.kits));
     return issues;
 }
 /**
@@ -116,19 +128,29 @@ export function normalizeProfileContextWindow(value) {
         return null;
     return clampContextWindow(value, null);
 }
-/** Normalize a valid library into a safe field whitelist; throws a fixed error if invalid. */
+/**
+ * Normalize a valid library into a safe field whitelist; throws a fixed error if invalid.
+ *
+ * THE THREE KIT KEYS ARE LISTED EXPLICITLY, NEVER `...spread` (R-2): this
+ * literal IS the whitelist (F-3), so a key missing from it disappears at the
+ * next write - a save that only touched `thinking` would silently delete every
+ * kit the user owns. `normalizeKits` is TOTAL, so a hand-edited kit degrades
+ * instead of taking the library (and the credentials in it) with it.
+ */
 export function normalizeModelProfiles(value) {
     if (validateModelProfiles(value).length)
         throw new Error('Invalid model profiles.');
     if (value === undefined)
         return emptyModelProfiles();
     const library = value;
+    const { kits, defaultKitId, kitsVersion } = normalizeKits(library.kits, library.defaultKitId);
     return { version: 1, mainId: library.mainId, fastId: library.fastId,
         entries: library.entries.map((entry) => ({ id: entry.id, name: entry.name.trim()
                 || [...entry.model.trim()].slice(0, 80).join(''), provider: entry.provider,
             model: entry.model.trim(), baseUrl: entry.baseUrl?.trim() || null,
             apiKey: entry.apiKey?.trim() || null,
-            contextWindow: normalizeProfileContextWindow(entry.contextWindow) })) };
+            contextWindow: normalizeProfileContextWindow(entry.contextWindow) })),
+        kits, defaultKitId, kitsVersion };
 }
 /** Create an entry with a stable UUID and a frozen default name. */
 export function createModelProfile(input) {
@@ -139,9 +161,28 @@ export function createModelProfile(input) {
 export function duplicateModelProfile(entry) {
     return { ...entry, id: randomUUID(), name: `${[...entry.name].slice(0, 73).join('')} (copy)` };
 }
-/** Remove an unused entry; binding references must be changed explicitly first. */
+/** Ids of the kits whose three slots name `id`, for the reference message. */
+export function kitNamesForProfile(library, id) {
+    return (library.kits ?? []).filter((kit) => kit.mainProfileId === id
+        || kit.fastProfileId === id
+        || (kit.subagent.model === 'profile' && kit.subagent.modelProfileId === id))
+        .map((kit) => kit.name);
+}
+/**
+ * Remove an unused entry; binding references must be changed explicitly first.
+ *
+ * The message NAMES the kits that would be orphaned (D-9): a throw that only
+ * says "still in use" sends the user hunting through three separate screens for
+ * the reference it means, and the kits are the reference nobody thinks of.
+ * (The UI never reaches this throw - it unbinds, and deletes the kits, inside
+ * the draft first - so this is the library-level backstop, F-25.)
+ */
 export function removeModelProfile(library, id) {
     if (library.mainId === id || library.fastId === id)
         throw new Error('Profile is still in use.');
+    const kits = kitNamesForProfile(library, id);
+    if (kits.length) {
+        throw new Error(`Profile is used by kit ${kits.map((name) => `"${name}"`).join(', ')}.`);
+    }
     return { ...library, entries: library.entries.filter((entry) => entry.id !== id) };
 }

package/dist/config/schema.d.ts

@@ -1044,6 +1044,22 @@ export interface CliConfig {
     modelSettingsRestartRequired?: boolean;
     modelProfiles?: import('./model-profiles.js').ModelProfilesConfig;
     modelProfileState?: import('./model-profiles.js').ModelProfilesRuntime;
+    /**
+     * The SESSION kit (agent-model-kits D-5 / §7.2). RUNTIME-ONLY.
+     *
+     * IT IS NOT IN `PersistedConfig` AND IT NEVER WILL BE (I-5 / I-14): `ctrl+K`
+     * and `/kit use` promise "this session only", and that promise is worth more
+     * than a saved convenience - it is what makes "one keystroke changed my
+     * defaults" structurally impossible rather than merely unlikely.
+     *
+     * `held` is the only fact worth storing: WHICH slots still belong to the kit.
+     * The bindings are derivable, and a stored copy of them would be a second
+     * truth (I-7: every held slot must have been written into the live config).
+     */
+    sessionKit?: {
+        id: string;
+        held: import('./model-kits.js').KitSlot[];
+    };
     apiKeyOverrideTarget?: {
         provider: string;
         baseUrl: string | null;

package/dist/input/keymap.js

@@ -7,7 +7,15 @@
  * does not own so the caller can drop unknown control bytes instead of
  * inserting them into the buffer.
  */
-/** Map a Ctrl-modified key to an intent, if any. */
+/**
+ * Map a Ctrl-modified key to an intent, if any.
+ *
+ * `Ctrl+K` IS DELIBERATELY NOT HERE (agent-model-kits D-15). That byte belongs
+ * to the Agent-kit picker on the main screen, and this recognizer runs BEFORE
+ * `PromptInput`'s `if (key.ctrl) return` - so keeping the binding would delete
+ * the user's draft in one listener while the other opened the overlay. The
+ * capability moved to `Alt+K` (`fromMeta`) instead of being dropped.
+ */
 function fromCtrl(input, key) {
     if (key.leftArrow)
         return 'wordLeft';
@@ -22,8 +30,6 @@ function fromCtrl(input, key) {
             return 'deleteWordBack';
         case 'u':
             return 'killToStart';
-        case 'k':
-            return 'killToEnd';
         default:
             return null;
     }
@@ -34,6 +40,11 @@ function fromMeta(input) {
         return 'wordLeft';
     if (input === 'f')
         return 'wordRight';
+    // `killToEnd` LIVES HERE NOW (agent-model-kits D-15). `Alt+K` keeps the
+    // capability, and it keeps the kill family together: `M-k` is kill-sentence in
+    // the Emacs tradition this keymap already borrows `Ctrl+W` and `Alt+B/F` from.
+    if (input === 'k')
+        return 'killToEnd';
     if (input === '\x7f' || input === '\b')
         return 'deleteWordBack';
     return null;
@@ -63,7 +74,10 @@ function fromRaw(input) {
             return 'deleteWordBack';
         case '\x15': // Ctrl+U (raw)
             return 'killToStart';
-        case '\x0b': // Ctrl+K (raw)
+        case '\x1bk':
+            // Alt+K (raw ESC + k). `\x0b` (Ctrl+K) is deliberately ABSENT: it belongs
+            // to the Agent-kit picker, and a case for it here would be a dead binding
+            // that still looks alive to every future reader.
             return 'killToEnd';
         default:
             return null;

package/dist/ui/App.js

@@ -47,6 +47,7 @@ import { TODO_LIMITS } from '../todo/limits.js';
 import { ScrollViewport } from './layout/ScrollViewport.js';
 import { buildTodoRailLayout } from './layout/todo-layout.js';
 import { buildTeamPanelLayout } from './layout/team-panel.js';
+import { isLiveTeamCard, rosterCounts } from './team-status.js';
 import { advanceBudget, decideFollowThrough, emptyBudget, } from '../todo/follow-through.js';
 import { useTerminalSize } from './layout/useTerminalSize.js';
 import { useHeightStore } from './use-height-store.js';
@@ -62,6 +63,9 @@ import { publishSessionView } from './session-bridge.js';
 import { OverlayFrame, overlayPageSize } from './layout/OverlayFrame.js';
 import { helpRows } from './overlays/HelpOverlay.js';
 import { ModelPicker } from './overlays/ModelPicker.js';
+import { KitPicker } from './overlays/KitPicker.js';
+import { INACTIVE_KIT } from '../config/kit-resolution.js';
+import { kitApplyMessage, kitNoteMessages } from '../agent/kit-apply.js';
 import { createModelProbe } from '../agent/model-probe.js';
 import { SettingsScreen, compactionSettingsFrom, fastSettingsFrom, } from './overlays/SettingsScreen.js';
 import { ConfirmDialog } from './overlays/ConfirmDialog.js';
@@ -1724,6 +1728,39 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         dispatch({ type: 'setOverlay', overlay: null });
         toast('info', `Model set to ${provider}:${model}.`);
     };
+    /**
+     * `ctrl+K` chose a row (agent-model-kits §4.7 / AC-25).
+     *
+     * `null` is `Current setup`, which is the RELEASE action, not a no-op: it runs
+     * `clearSessionKit` so the live connections go back to the file's bindings.
+     * Both paths close the overlay, and both report through the same toast funnel -
+     * including every `KitNote`, because a kit that turns the fast tier on spends
+     * money and must never do it silently (§4.2 / F-23).
+     */
+    const handleKitChoose = (kitId) => {
+        // NO KIT PORT, NO CRASH: a legacy host can still press the key, and the only
+        // honest answer is a sentence rather than a stack trace.
+        const port = controller;
+        if (typeof port.applySessionKit !== 'function' || typeof port.clearSessionKit !== 'function') {
+            dispatch({ type: 'setOverlay', overlay: null });
+            toast('error', 'This build cannot switch kits.');
+            return;
+        }
+        const result = kitId === null
+            ? controller.clearSessionKit() : controller.applySessionKit(kitId);
+        dispatch({ type: 'setOverlay', overlay: null });
+        // The config is already updated synchronously, so this reads the kit that is
+        // in effect RIGHT NOW rather than the id the user asked for - if the apply
+        // fell back to anything, the toast says so.
+        const applied = controller.getActiveKit().name;
+        const text = !result.ok ? kitApplyMessage(result)
+            : kitId === null ? "Kit released; using the config file's settings."
+                : `Kit ${applied} applied for this session.`;
+        const notes = kitNoteMessages(result.notes);
+        // A NOTE IS A WARNING, NOT A SUCCESS (F-23): the toast colour is the only
+        // signal a user gets that applying a kit can start spending money.
+        toast(result.ok ? (notes.length ? 'warn' : 'success') : 'error', [text, ...notes].join(' '));
+    };
     const closeConfirm = () => {
         setConfirmState(null);
         dispatch({ type: 'setOverlay', overlay: null });
@@ -1967,6 +2004,24 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             setStatusExpanded(value => !value);
             return;
         }
+        // Ctrl+K: the Agent-kit picker (agent-model-kits D-15 / §4.7).
+        //
+        // NOT AN INPUT FRAME, unlike Ctrl+I below. Ctrl+I collides with the Tab byte,
+        // so a stdin translator has to disambiguate it; 0x0B is unambiguous in every
+        // encoding this app supports (utf8 byte, win32-input-mode's pass-through of
+        // control chars, and CSI-u's `ctrlByte` fold), so the raw byte IS the key.
+        //
+        // `killToEnd` HAS MOVED TO Alt+K FIRST (keymap.ts): `PromptInput`'s
+        // recognizer runs before its `key.ctrl` early-return, so leaving the old
+        // binding would delete the draft in one listener while this one opened the
+        // overlay. Two listeners both see the event; `return` only leaves one.
+        const isCtrlK = (key.ctrl && (input === 'k' || input === 'K')) || input === '\x0b';
+        if (isCtrlK) {
+            if (tooSmall || stateRef.current.overlay)
+                return;
+            dispatch({ type: 'setOverlay', overlay: 'kit' });
+            return;
+        }
         // Ctrl+I arrives as INDEX_KEY_FRAME, never as key.ctrl + 'i': legacy
         // terminals encode it as the Tab byte and the stdin filter's translators
         // are the only layer that can tell them apart (see input/limits.ts).
@@ -2004,7 +2059,8 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const overlay = stateRef.current.overlay;
             // Modes A only. `model` / `confirm` manage their own keys; registering an
             // arrow handler for them would double every keypress (R-12).
-            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan' || overlay === 'queue';
+            const controlled = overlay === 'help' || overlay === 'settings' || overlay === 'plan'
+                || overlay === 'queue' || overlay === 'kit';
             if (key.pageUp) {
                 if (controlled)
                     setOverlayScroll((n) => Math.max(0, n - overlayPage));
@@ -2114,10 +2170,16 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             const entries = stateRef.current.entries;
             const card = [...entries]
                 .reverse()
-                .find((e) => e.kind === 'tool' ||
-                e.kind === 'team' ||
-                e.kind === 'compaction' ||
-                (e.kind === 'service' && !e.terminal));
+                .find((e) => 
+            // THE LIVE DISPATCH CARD IS NOT EXPANDABLE (tui-subagent-double-roster
+            // A-2'): it is suppressed on screen, so expanding it would print a frozen
+            // copy of a card that is still being rewritten. Once it settles it becomes
+            // an ordinary history card and this key reaches it again.
+            !isLiveTeamCard(e) &&
+                (e.kind === 'tool' ||
+                    e.kind === 'team' ||
+                    e.kind === 'compaction' ||
+                    (e.kind === 'service' && !e.terminal)));
             // NATIVE MODE ONLY. The fallback exists because native mode cannot scroll inside the
             // frame - the answer's head is reachable only if it is printed. Full-screen mode has a
             // viewport that already reaches it, and it has no `expanded` rendering for an answer,
@@ -2224,6 +2286,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const overlay = state.overlay;
     const settingsDraft = useMemo(() => overlay === 'settings'
         ? controller.createModelSettingsDraft() : undefined, [controller, overlay]);
+    // THE FILE'S BINDINGS, FOR THE KIT PICKER'S FIRST ROW (§4.6 / D-13). While a
+    // session kit is held the live config mirrors the KIT (I-6), so `Current setup`
+    // can only describe what choosing it restores by reading the file - one read per
+    // opening, the same price `settingsDraft` one line up already pays.
+    const kitDiskConfig = useMemo(() => overlay === 'kit'
+        ? controller.createModelSettingsDraft().baseline : undefined, [controller, overlay]);
     // ONE PROBE PER APP (model-profile-connection-test 5 row 9): the port needs the
     // controller's provider registry, which the overlay has no business owning.
     // Built only while the settings overlay is open, so no other screen pays for it.
@@ -2237,6 +2305,22 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         return createModelProbe({ registry: controller.getProviderRegistry() });
     }, [controller, overlay]);
     const hasKey = controller.hasApiKey();
+    // THE ACTIVE KIT, DERIVED PER FRAME (D-5 / F-22): `controller.getActiveKit()` is
+    // pure, so it cannot go stale the way a cached copy would after `ctrl+K`,
+    // `/model` or a saved default. Absent when no kit is in effect, which is what
+    // keeps the status row byte-identical for users who own none (I-9).
+    //
+    // A TEST DOUBLE OR AN EMBEDDED HOST MAY PREDATE THIS PORT: the same tolerance
+    // the probe port gets one screen over ("absent means the rows read
+    // unresolved") applies here - no kit, no crash.
+    const activeKit = typeof controller.getActiveKit === 'function'
+        ? controller.getActiveKit() : INACTIVE_KIT;
+    const kitChip = activeKit.source === 'none' ? undefined : {
+        name: activeKit.name,
+        modified: activeKit.modified,
+        otherNames: (cfg.modelProfiles?.kits ?? [])
+            .filter((kit) => kit.id !== activeKit.id).map((kit) => kit.name),
+    };
     const empty = state.entries.length === 0;
     // RENDER SCOPE, so the chip and the composer hint agree with what the Ctrl+C
     // handler will do on the very next keystroke.
@@ -2340,7 +2424,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     // ALWAYS CALLED, INERT WHEN `enabled` IS FALSE: hooks cannot be conditional, and
     // an inert hook is what keeps `scrollMode: 'app'` byte-identical (I-S9).
     const viewCols = native ? Math.max(1, cols - 1) : cols;
-    const header = (_jsx(Header, { columns: viewCols, statusExpanded: statusExpanded, scrolledLines: scrolledLines, overlayOpen: overlay !== null, cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: pickHeaderVariant(cols), theme: theme, caps: caps }));
+    const header = (_jsx(Header, { columns: viewCols, statusExpanded: statusExpanded, scrolledLines: scrolledLines, overlayOpen: overlay !== null, cwd: controller.getCwd(), provider: cfg.provider, model: cfg.model, hasKey: hasKey, variant: pickHeaderVariant(cols), theme: theme, caps: caps, 
+        // ALWAYS TRUE (agent-model-kits §4.7 / RV-P1-2): the requirement is that
+        // `ctrl+G` reveals `ctrl+K`, and the user with an empty library needs that
+        // hint most - the picker itself carries the "create one in /settings" row.
+        kitHint: true }));
     // The header and the opener are SLOTS OF THE SHELL, not printed bytes (D3/D4): at
     // `H = rows - 1` a printed row is pushed off the screen by the very next frame, so
     // `printBanner()` was a way of making the banner invisible. Neither is passed here.
@@ -2391,7 +2479,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const openerCols = nativeBudget ? nativeBudget.previewCols : contentCols;
     const opener = empty ? (_jsx(SessionOpener, { variant: pickOpenerVariant(openerRows, openerCols), version: version, cwd: controller.getCwd(), hasKey: hasKey, viewportRows: openerRows, theme: theme, caps: caps })) : null;
     const overlayMaxRows = nativeBudget ? nativeBudget.overlayRows : viewportBudget;
-    const overlayNode = overlay === 'queue' ? (_jsx(QueueOverlay, { pending: state.pendingSteering, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: viewCols, rows: helpRows(theme, caps, native), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { isActive: !tooSmall, registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'settings' ? (_jsx(SettingsScreen, { isActive: !tooSmall, initial: {
+    const overlayNode = overlay === 'queue' ? (_jsx(QueueOverlay, { pending: state.pendingSteering, cols: viewCols, maxRows: overlayMaxRows, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'help' ? (_jsx(OverlayFrame, { title: "Help", hint: `Esc close ${glyphs.midDot} PgUp/PgDn scroll`, maxRows: overlayMaxRows, cols: viewCols, rows: helpRows(theme, caps, native), scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps })) : overlay === 'model' ? (_jsx(ModelPicker, { isActive: !tooSmall, registry: controller.getModelRegistry(), currentProvider: cfg.provider, currentModel: cfg.model, maxRows: overlayMaxRows, cols: viewCols, theme: theme, caps: caps, onSelect: handleModelSelect })) : overlay === 'kit' ? (_jsx(KitPicker, { isActive: !tooSmall, library: cfg.modelProfiles, config: cfg, ...(kitDiskConfig ? { diskConfig: kitDiskConfig } : {}), active: activeKit, 
+        // ONLY THE APPLY IS BLOCKED while work is in flight (§4.7): a list a
+        // user cannot even OPEN reads as a broken key.
+        busy: controller.isModelSettingsBusy(), maxRows: overlayMaxRows, cols: viewCols, scrollOffset: overlayScroll, onScrollClamp: setOverlayScroll, theme: theme, caps: caps, onChoose: handleKitChoose, onClose: () => dispatch({ type: 'setOverlay', overlay: null }) })) : overlay === 'settings' ? (_jsx(SettingsScreen, { isActive: !tooSmall, initial: {
             provider: cfg.provider,
             model: cfg.model,
             baseUrl: cfg.baseUrl ?? '',
@@ -2524,8 +2615,12 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         compacting: compactionLive || !!state.compaction?.inFlight,
         mode: state.agentMode, pendingMode: state.pendingAgentMode,
         servicesActive: { live: liveServices }, ecoRung: governor.rung,
-        teamActive: state.team ? { running: state.team.runs.filter(item => !['queued', 'done', 'failed', 'aborted'].includes(item.phase)).length,
-            total: state.team.runs.length } : undefined,
+        // THE STATUS-DETAIL ROW COUNTS LIKE THE ROSTER AND THE CHIP (A-1): this was the
+        // last inline phase filter, left behind when the StatusBar chip converged, and it
+        // feeds the `Team n/m` on the second status row.
+        teamActive: state.team
+            ? { running: rosterCounts(state.team.runs).running, total: state.team.runs.length }
+            : undefined,
         todoActive: state.todos ? { done: state.todos.doneCount, total: state.todos.total } : undefined,
         fastActive: state.fast?.live ? { inFlight: state.fast.inFlight } : undefined,
         ...feedbackProjection,
@@ -2558,7 +2653,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
     const rail = fullscreenRailVisible && state.todos ? (_jsx(TodoPanel, { snapshot: state.todos, width: railWidth, rows: railRows, running: running, reducedMotion: viewReducedMotion, theme: theme, caps: caps })) : null;
     const viewport = (_jsxs(ScrollViewport, { active: overlay === null && !tooSmall, overlay: overlayNode, footer: _jsxs(_Fragment, { children: [team, _jsx(QueuePanel, { layout: queueLayout, theme: theme })] }), rail: rail, scrollbar: terminal?.scrollbar, resetKey: scrollResetKey, intent: scrollIntent, pinToBottomNonce: pinToBottomNonce, onScrolledLinesChange: setScrolledLines, onViewportShiftChange: onViewportShiftChange, onGeometryChange: onGeometryChange, geometryKey: `${rows}:${cols}:${viewportBudget}:${frameBudget.composerSlotRows}:${frameBudget.statusRows}:${contentCols}:${overlay}:${tooSmall}`, tailRowsRef: tailSink, hold: selectionHold, resumeMs: cfg.scrollResumeMs, showScrollIndicator: true, cols: contentCols, theme: theme, caps: caps, children: [opener, _jsx(TranscriptList, { entries: transcriptEntries, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: density, nowSec: nowSec, theme: theme, caps: caps, windowSize: transcriptWindow, cols: contentCols, heights: heights, mountedSink: mountedCount, tailSink: tailSink })] }));
     const detailsNode = _jsx(BottomStatusRow, { plan: details, columns: viewCols, theme: theme });
-    const statusNode = (_jsx(StatusBar, { columns: viewCols, speedKnown: speedKnown, ...feedbackProjection, interruptPhase: interruptGesture.current.phase, pendingSteering: state.pendingSteering, runPhase: state.runPhase, activeTool: state.activeTool, ...(wait ? { wait } : {}), runOutcome: state.runOutcome, reducedMotion: reducedMotion, ...(sessionId ? { sessionId } : {}), waitingForConfirmation: !!humanRequest || !!confirmState, stopping: interruptGesture.current.phase === 'stopping', interruptHint: interruptGesture.current.phase === 'stopping'
+    const statusNode = (_jsx(StatusBar, { columns: viewCols, speedKnown: speedKnown, ...feedbackProjection, interruptPhase: interruptGesture.current.phase, pendingSteering: state.pendingSteering, runPhase: state.runPhase, activeTool: state.activeTool, ...(wait ? { wait } : {}), runOutcome: state.runOutcome, reducedMotion: reducedMotion, ...(sessionId ? { sessionId } : {}), ...(kitChip ? { kit: kitChip } : {}), waitingForConfirmation: !!humanRequest || !!confirmState, stopping: interruptGesture.current.phase === 'stopping', interruptHint: interruptGesture.current.phase === 'stopping'
             ? 'Esc force-stop' : 'Esc x2 interrupt', model: cfg.model, provider: cfg.provider, usageTotal: state.usageTotal, 
         // ONE OBJECT INSTEAD OF FOUR PARALLEL PROPS (§4.3). The four were a
         // projection of "many sources of truth" into the props layer, and a
@@ -2568,9 +2663,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         // `contextWindow` override reach the bar.
         context: state.context, status: state.status, elapsedMs: elapsedMs, thinkingLevel: cfg.thinkingLevel, tokPerSec: tokPerSec, theme: theme, caps: caps, scrolledLines: scrolledLines, redrawNonce: redrawNonce, agentMode: state.agentMode, pendingAgentMode: state.pendingAgentMode, ecoRung: governor.rung, ...(state.team
             ? {
+                // `rosterCounts`, NOT a fourth inline phase filter (A-1): the chip and
+                // the roster header above it must never disagree.
                 teamActive: {
-                    running: state.team.runs.filter((r) => r.phase !== 'queued' && r.phase !== 'done' &&
-                        r.phase !== 'failed' && r.phase !== 'aborted').length,
+                    running: rosterCounts(state.team.runs).running,
                     total: state.team.runs.length,
                 },
             }

package/dist/ui/Header.d.ts

@@ -15,6 +15,14 @@ interface HeaderProps {
     statusExpanded?: boolean;
     scrolledLines?: number;
     overlayOpen?: boolean;
+    /**
+     * Whether the expanded status row teaches `ctrl+K` (agent-model-kits §4.7).
+     *
+     * DEFAULTS TO TRUE because that is the requirement - `ctrl+G` must reveal the
+     * kit key - and because a default of `false` would leave the one caller that
+     * forgets the prop silently teaching nothing.
+     */
+    kitHint?: boolean;
 }
-export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns, statusExpanded, scrolledLines, overlayOpen }: HeaderProps): React.ReactElement;
+export declare function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns, statusExpanded, scrolledLines, overlayOpen, kitHint }: HeaderProps): React.ReactElement;
 export {};

package/dist/ui/Header.js

@@ -3,13 +3,19 @@ import { basename } from 'node:path';
 import { Box, Text } from 'ink';
 import { Logo } from './Logo.js';
 import { planHeaderHints, HEADER_HINT_LIMITS } from './layout/header-hints.js';
-export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false }) {
+export function Header({ cwd, provider, model, hasKey, variant, theme, caps, columns = 80, statusExpanded = false, scrolledLines = 0, overlayOpen = false, kitHint = true }) {
     // The right-hand hints are planned, not assembled (tui-branch-terminal-shortcut
     // 3.9 / D-11). `plan.text` is exactly `plan.cells` wide and already carries the
     // scroll chip's own trailing spacing, so this component can no longer clip a
     // hint by guessing one cell short - and the ladder that decides which hints
     // survive a narrow terminal lives in a pure function with its own tests.
-    const plan = planHeaderHints({ columns, statusExpanded, overlayOpen, scrolledLines });
+    //
+    // `kitHint` is the `^K switch kit` clause (agent-model-kits §4.7): `App`
+    // passes `true` always, because the requirement is that `ctrl+G` reveals the
+    // key - and the user with no kits needs that hint most.
+    const plan = planHeaderHints({
+        columns, statusExpanded, overlayOpen, scrolledLines, kitHint,
+    });
     // THE TWO HALVES ARE SEPARATED BY CELLS, NOT BY LUCK (defect 12). The left half
     // is `wrap="truncate"`, which draws its ellipsis in the LAST cell it owns; with
     // the right half starting in the very next cell a narrow terminal read

package/dist/ui/PromptInput.js

@@ -596,7 +596,7 @@ export function PromptInput({ cols: colsProp, terminalRows: terminalRowsProp, st
             return;
         }
         if (key.ctrl)
-            return; // App owns Ctrl+C / L / T / O.
+            return; // App owns Ctrl+C / L / T / O, and now Ctrl+K (the kit picker).
         if (key.return) {
             if (key.meta || key.shift) {
                 insert('\n');

package/dist/ui/ScrollbackShell.d.ts

@@ -19,11 +19,22 @@
  * default mode showed neither. The band is a row pool inside the live region:
  *
  *   +---------------------------------------------+-----------------+
- *   | team roster      (height = band.teamRows)    | TODO rail       |
+ *   | tail window      (height = band.previewRows) | TODO rail       |
  *   +---------------------------------------------+ (height =       |
- *   | tail window      (height = band.previewRows) |  band.railRows) |
+ *   | team roster      (height = band.teamRows)    |  band.railRows) |
  *   +---------------------------------------------+-----------------+
  *
+ * THE ROSTER IS THE LEFT COLUMN'S BOTTOM SLOT, not its top one
+ * (tui-subagent-double-roster A-3). `band.ts` allocates the same two heights either
+ * way - only the drawing order changed - so every row number, and every test that
+ * asserts one, is untouched. What moves is the reading: the roster is transient
+ * status about the run in progress, so it belongs against the composer (where the
+ * user's eyes already are, and where full-screen mode's viewport `footer` puts it),
+ * and the conversation's own tail stays above it. As a bonus the rows a short tail
+ * does not use now fall between the tail and the roster instead of between the tail
+ * and the input box, which is the "blank space above the composer" shape the
+ * plan-A-prime work removed one level up.
+ *
  * Every box in it has an explicit `height` and `width` plus `overflow="hidden"`, and
  * that is a correctness requirement rather than tidiness: a box that grows with its
  * content would make the region taller than `budget.liveRows`, and a frame as tall as
@@ -76,7 +87,11 @@ export interface ScrollbackShellProps {
     opener?: React.ReactNode;
     /** Real components for the tail window (`LiveTail`). */
     tail?: React.ReactNode;
-    /** The subagent roster, drawn at the top of the band's left column. */
+    /**
+     * The subagent roster: the BOTTOM slot of the band's left column, i.e. the row
+     * closest to the composer. It is the only live subagent surface during a
+     * dispatch - the transcript's `team` card is suppressed while it is active.
+     */
     team?: React.ReactNode;
     /** The TODO rail, drawn as the band's right-hand column. */
     rail?: React.ReactNode;

package/dist/ui/ScrollbackShell.js

@@ -14,6 +14,6 @@ export function ScrollbackShell({ budget, header, overlay, liveTailLines, opener
     // The overlay and the band are alternatives, not siblings: the band reports
     // `bandRows = remaining` for an overlay frame, so drawing both would double the
     // region's height and take the frame to the terminal height (the `ESC[3J` case).
-    const top = band.reason === 'overlay' ? (_jsx(Box, { flexDirection: "column", height: budget.overlayRows, flexShrink: 0, overflow: "hidden", children: overlay })) : band.bandRows > 0 ? (_jsxs(Box, { flexDirection: "row", height: band.bandRows, flexShrink: 0, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", width: budget.previewCols, flexShrink: 0, overflow: "hidden", children: [band.teamRows > 0 && (_jsx(Box, { height: band.teamRows, flexShrink: 0, overflow: "hidden", children: team })), band.previewRows > 0 && (_jsx(Box, { flexDirection: "column", height: band.previewRows, flexShrink: 0, justifyContent: "flex-start", overflow: "hidden", children: leftColumn ?? tailLines.map((line, index) => (_jsx(Text, { wrap: "truncate", color: theme.muted, children: line }, index))) }))] }), band.railRows > 0 && (_jsx(Box, { height: band.railRows, width: band.railCols, flexShrink: 0, overflow: "hidden", children: rail }))] })) : null;
+    const top = band.reason === 'overlay' ? (_jsx(Box, { flexDirection: "column", height: budget.overlayRows, flexShrink: 0, overflow: "hidden", children: overlay })) : band.bandRows > 0 ? (_jsxs(Box, { flexDirection: "row", height: band.bandRows, flexShrink: 0, overflow: "hidden", children: [_jsxs(Box, { flexDirection: "column", width: budget.previewCols, flexShrink: 0, overflow: "hidden", children: [band.previewRows > 0 && (_jsx(Box, { flexDirection: "column", height: band.previewRows, flexShrink: 0, justifyContent: "flex-start", overflow: "hidden", children: leftColumn ?? tailLines.map((line, index) => (_jsx(Text, { wrap: "truncate", color: theme.muted, children: line }, index))) })), band.teamRows > 0 && (_jsx(Box, { height: band.teamRows, flexShrink: 0, overflow: "hidden", children: team }))] }), band.railRows > 0 && (_jsx(Box, { height: band.railRows, width: band.railCols, flexShrink: 0, overflow: "hidden", children: rail }))] })) : null;
     return (_jsxs(Box, { flexDirection: "column", height: budget.liveRows, width: width, overflow: "hidden", flexShrink: 0, children: [budget.headerRows > 0 && (_jsx(Box, { height: budget.headerRows, flexShrink: 0, overflow: "hidden", children: header })), top, _jsx(Box, { flexDirection: "column", height: budget.composerSlotRows, justifyContent: "flex-end", flexShrink: 0, overflow: "hidden", children: composer }), _jsx(Box, { height: budget.statusRows > 0 ? 1 : 0, flexShrink: 0, overflow: "hidden", children: status }), budget.statusRows === 2 && (_jsx(Box, { height: 1, flexShrink: 0, overflow: "hidden", children: details }))] }));
 }

package/dist/ui/StatusBar.d.ts

@@ -50,6 +50,19 @@ export interface StatusBarProps {
      * existing test render exactly what they rendered before (I-6).
      */
     sessionId?: string;
+    /**
+     * The agent kit in effect, or absent when there is none (agent-model-kits
+     * §4.8 / D-12).
+     *
+     * OPTIONAL AND ABSENT BY DEFAULT, for the same reason `sessionId` is: with no
+     * kit the plan is hidden, `kitCells` is 0, and this row's output is
+     * byte-identical to the pre-feature build (I-9).
+     */
+    kit?: {
+        name: string;
+        modified: boolean;
+        otherNames: readonly string[];
+    } | null;
     agentMode?: AgentMode;
     pendingAgentMode?: AgentMode | null;
     teamActive?: {

package/dist/ui/StatusBar.js

@@ -6,6 +6,7 @@ import { pickGlyphs } from './glyphs.js';
 import { liveSpinner } from './ActivityLine.js';
 import { planPrimaryStatusFields } from './layout/status-layout.js';
 import { planSessionChip } from './layout/session-chip.js';
+import { planKitChip } from './layout/kit-chip.js';
 /** An invisible leading byte change forces Ink to repaint on Ctrl+L. */
 const redrawChar = (nonce) => nonce % 2 ? String.fromCharCode(0x00a0) : ' ';
 export function StatusBar(props) {
@@ -21,8 +22,14 @@ export function StatusBar(props) {
         ...(props.sessionId ? { sessionId: props.sessionId } : {}),
     });
     const chipCells = chip.visible ? chip.cells + chip.gap : 0;
+    // THE KIT CHIP IS PLANNED SECOND, OUT OF WHAT THE SESSION CHIP LEFT (D-12):
+    // the session id is never truncated, so it is not the thing that gives way.
+    // With no kit the plan is hidden and `kitCells` is 0, which keeps this row
+    // byte-identical to the build before the feature (I-9).
+    const kit = planKitChip({ columns: cols - chipCells, kit: props.kit });
+    const kitCells = kit.visible ? kit.cells + kit.gap : 0;
     const plan = planPrimaryStatusFields({
-        reserveRight: chipCells,
+        reserveRight: chipCells + kitCells,
         columns: cols, phase, pendingCount: props.pendingSteering?.length ?? 0,
         context: props.context, usageTotal: props.usageTotal,
         thinkingLevel: props.thinkingLevel, elapsedMs: props.elapsedMs, tokPerSec: props.tokPerSec,
@@ -39,7 +46,7 @@ export function StatusBar(props) {
     const tones = { normal: props.theme.primary, muted: props.theme.muted,
         warning: props.theme.noticeWarn, error: props.theme.noticeError,
         accent: props.theme.accent };
-    return _jsxs(Box, { width: cols, height: 1, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }) }), _jsx(Box, { width: Math.max(0, cols - 1 - chipCells), flexShrink: 0, flexDirection: "row", overflow: "hidden", children: plan.fields.map((item, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: props.theme.muted, children: plan.separator }) }), _jsx(Box, { width: item.cells, flexShrink: 0, children: _jsx(Text, { color: tones[item.tone], wrap: "truncate", children: item.id === 'phase' && active
+    return _jsxs(Box, { width: cols, height: 1, flexShrink: 0, flexDirection: "row", overflow: "hidden", children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { children: redrawChar(props.redrawNonce ?? 0) }) }), _jsx(Box, { width: Math.max(0, cols - 1 - chipCells - kitCells), flexShrink: 0, flexDirection: "row", overflow: "hidden", children: plan.fields.map((item, index) => _jsxs(React.Fragment, { children: [index > 0 && _jsx(Box, { width: plan.separatorCells, flexShrink: 0, children: _jsx(Text, { color: props.theme.muted, children: plan.separator }) }), _jsx(Box, { width: item.cells, flexShrink: 0, children: _jsx(Text, { color: tones[item.tone], wrap: "truncate", children: item.id === 'phase' && active
                                     ? _jsxs(_Fragment, { children: [spinner ?? glyph, item.text.slice(glyph.length)] })
-                                    : item.text }) })] }, item.id)) }), chip.visible && _jsx(Box, { width: chipCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: chip.text }) })] });
+                                    : item.text }) })] }, item.id)) }), kit.visible && _jsx(Box, { width: kitCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: kit.text }) }), chip.visible && _jsx(Box, { width: chipCells, flexShrink: 0, justifyContent: "flex-end", overflow: "hidden", children: _jsx(Text, { color: props.theme.muted, wrap: "truncate", children: chip.text }) })] });
 }

package/dist/ui/TeamPanel.d.ts

@@ -15,6 +15,18 @@
  * with the other transient rows — toast, composer, status bar — rather than
  * inside the scrolling transcript, where it would be interleaved with history
  * and scroll out of sight exactly when the user wants to watch it.
+ *
+ * IT IS THE ONLY LIVE SUBAGENT SURFACE (tui-subagent-double-roster A-2). The
+ * transcript's `team` card is suppressed while its dispatch is active
+ * (`team-status.ts::isLiveTeamCard`), so this roster is what the user watches
+ * during a dispatch and the card becomes the history afterwards. Native mode
+ * draws it as the BOTTOM slot of the band's left column (`ScrollbackShell`),
+ * i.e. directly above the composer; full-screen mode draws it in the viewport
+ * footer, which is already above the composer.
+ *
+ * EVERY PHASE -> GLYPH / COLOUR / COUNT DECISION COMES FROM `team-status.ts`.
+ * The local copies this file used to carry are gone on purpose: the transcript
+ * card kept a second copy and the two disagreed about what "running" looks like.
  */
 import React from 'react';
 import type { Theme } from './theme.js';