@aragon-agent/cli 0.6.33 → 0.6.35

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));
@@ -2102,12 +2158,36 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // `ctrl+o log` hint, the keystroke would silently expand AN OLDER TOOL
             // CARD, and nothing would error. The terminal one-row record is skipped -
             // it has nothing to reveal, and expanding it would consume the press.
-            const last = [...stateRef.current.entries]
+            //
+            // TWO TIERS, AND THE ORDER IS THE WHOLE FIX (tui-final-reply-truncated-
+            // unscrollable B1). The closed list above answers "which card is this key for",
+            // and it must keep answering it EXACTLY as before: a settled answer is almost
+            // always the newest entry, so adding `assistant` to THIS filter would take the
+            // press away from the tool card the user just watched finish. Only when no card
+            // is asking for the key does it fall through to the Agent's last answer - which
+            // is the escape hatch `docs/plans/tui-full-height-live-region/spec.md` §13
+            // (known limitation 2) already promised and never wired up.
+            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,
+            // so falling through there would consume the press and show nothing.
+            const answer = card === undefined && native
+                ? [...entries].reverse().find((e) => e.kind === 'assistant' && !e.streaming)
+                : undefined;
+            const last = card ?? answer;
             // Native mode cannot rewrite what is already printed, so it PRINTS an expanded
             // copy as a new block instead of toggling the old one (spec 4.7).
             if (last && native) {
@@ -2206,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.
@@ -2219,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.
@@ -2322,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.
@@ -2339,6 +2445,10 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
         itemCount: state.todos?.items.length ?? 0,
         panelEnabled: cfg.todo.panel,
         teamRowsNatural: teamLayout.rowCount,
+        // The top give-way measures a window entry's height, and an expanded tool card is a
+        // different height from a collapsed one - a forgotten value would print rows the region
+        // is not drawing.
+        expandedToolIds: state.expandedToolIds,
     });
     scrollbackViewRef.current = scrollbackView;
     // The two hooks `cli.tsx` calls from OUTSIDE React: the exit summary (every exit
@@ -2369,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 ?? '',
@@ -2436,9 +2549,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
                 contentCols: nativeBudget.contentCols,
                 // The tail window, joined here because it belongs to the VIEW pipeline rather
                 // than to the band: `window=<start>/<n>` is what makes the visible-vs-printed
-                // gap observable (known limitation 5).
+                // gap observable (known limitation 5), and `head=` counts the rows the top
+                // give-way printed for it, so the mechanism is never invisible.
                 windowStart: scrollbackView.windowStart,
                 windowEntries: scrollbackView.tailEntries.length,
+                headRows: scrollbackView.headRows,
             }
             : null,
         // A getter: the bridge's `frameReady` and geometry change outside React renders.
@@ -2500,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,
@@ -2534,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
@@ -2544,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,
                 },
             }
@@ -2584,7 +2704,7 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // fallback for a frame with no preview rows. The WHOLE list is passed: the window
             // belongs to `tail-window.ts`, and `prev` must come from the same list.
             tail: nativeBudget.band.previewRows > 0
-                ? (_jsx(LiveTail, { entries: state.entries, maxEntries: SCROLLBACK_LIMITS.liveTailMaxEntries, rows: nativeBudget.band.previewRows, cols: nativeBudget.previewCols, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: cfg.density, nowSec: nowSec, theme: theme, caps: caps }))
+                ? (_jsx(LiveTail, { entries: state.entries, maxEntries: SCROLLBACK_LIMITS.liveTailMaxEntries, rows: nativeBudget.band.previewRows, cols: nativeBudget.previewCols, expandedToolIds: state.expandedToolIds, thinkingVisible: state.thinkingVisible, reducedMotion: viewReducedMotion, density: cfg.density, nowSec: nowSec, theme: theme, caps: caps, measuredRows: scrollbackView.measuredTailRows }))
                 : undefined, team: nativeTeam, rail: nativeRail, composer: composer, status: statusNode, details: detailsNode, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), theme: theme }));
     }
     return (_jsx(AppShell, { inactive: tooSmall, placeholder: _jsxs(Text, { wrap: "truncate", color: theme.noticeWarn, children: [glyphs.warn, " Terminal too small - needs at least 40 columns and 12 rows."] }), rows: rows, cols: cols, header: header, viewport: viewport, viewportRows: frameBudget.viewportRows, composer: composer, composerSlotRows: frameBudget.composerSlotRows, statusRows: frameBudget.statusRows, details: detailsNode, status: statusNode }));

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,30 +19,51 @@
  * 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
  * the terminal makes Ink erase the user's scrollback.
  *
- * TWO SLOTS ARE NOT BOTTOM-ALIGNED, AND ONLY TWO (D3 / D4 / I-F7):
+ * THE BAND'S PREVIEW BOX IS TOP-ALIGNED; THE OTHER SLOTS ARE FIXED
+ * (D3 / D4 / I-F7; tui-first-reply-bottom-aligned, plan A-prime):
  *  - `header` is the fixed 1-row slot at the very top. It is NOT printed into the
  *    scrollback any more: at `H = rows - 1` any printed row is pushed off the screen by
  *    the next frame, so "print the header" would mean "the header is never visible".
- *  - `opener` is the empty-session card, and it is the one thing inside the band that is
- *    TOP-aligned: a 12-row card bottom-aligned in a 24-row column would leave 12 blank
- *    rows in the upper half of the screen - the original defect, still inside the
- *    region, where the `gap` assertion could not see it. `opener` and `tail` are
- *    mutually exclusive by construction (`App` keys them off `entries.length === 0`),
- *    and they share one box because two boxes would be one more height to get wrong.
+ *  - the band's preview box is TOP-aligned unconditionally, which is why the alignment is
+ *    no longer a function of `opener`. `opener` is a 12-row card in a 24-row column, so
+ *    bottom-aligning it left 12 blank rows in the upper half of the screen - the original
+ *    defect, still inside the region, where the `gap` assertion could not see it
+ *    (RV-P0-1). `tail` had the same shape for a short conversation: four rows pressed
+ *    against the composer with every unused row ABOVE them, which is the defect plan
+ *    A-prime fixes. `tail` therefore decides its own alignment one level down
+ *    (`scrollback/tail-anchor.ts`): top while its content fits, and the old `flex-end`
+ *    only on the frames where the content overflows and the newest row must stay visible.
+ *    `opener` and `tail` share this box because two boxes would be one more height to
+ *    get wrong, and they are mutually exclusive by construction (`App` keys them off
+ *    `entries.length === 0`).
  *
  * `liveTailLines` STAYS. It is the plain-text fallback for the frames where the real
  * tail is not mounted (and the floor of the measurement path); `tail` wins when both
- * are given, so the two can never be drawn on top of each other.
+ * are given, so the two can never be drawn on top of each other. It is sliced to
+ * `budget.liveTailRows` below, which is the same number as `band.previewRows`: that slice
+ * is what makes the unconditional `flex-start` safe here, because a fallback taller than
+ * the box would clip its NEWEST line - the one direction this box must never clip.
  */
 import React from 'react';
 import type { Theme } from './theme.js';
@@ -60,13 +81,17 @@ export interface ScrollbackShellProps {
     /** Plain preview rows: the fallback when `tail` is absent (and what `/perf` counts). */
     liveTailLines: readonly string[];
     /**
-     * The empty-session card. Mutually exclusive with `tail`, TOP-aligned, and the only
-     * thing in this shell that is not bottom-aligned or a fixed slot (RV-P0-1).
+     * The empty-session card. Mutually exclusive with `tail`, TOP-aligned like the rest of
+     * the band's preview box (RV-P0-1).
      */
     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

@@ -6,13 +6,14 @@ export function ScrollbackShell({ budget, header, overlay, liveTailLines, opener
         return (_jsx(Box, { flexDirection: "column", height: budget.liveRows, width: width, overflow: "hidden", flexShrink: 0, children: budget.liveRows > 0 ? placeholder : null }));
     }
     const band = budget.band;
-    // `opener ?? tail ?? lines` is ONE slot, not three: whichever is mounted decides the
-    // alignment of the box, so the two can never both be drawn and fight for the height.
+    // `opener ?? tail ?? lines` is ONE slot, not three: they are mutually exclusive, so
+    // the two can never both be drawn and fight for the height. This box's alignment is
+    // fixed (`flex-start`); `tail` alone may fall back to `flex-end` when it overflows.
     const leftColumn = opener ?? tail;
     const tailLines = liveTailLines.slice(-budget.liveTailRows);
     // 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: opener ? 'flex-start' : 'flex-end', 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';

package/dist/ui/TeamPanel.js

@@ -2,26 +2,11 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs } from './glyphs.js';
+import { childElapsedMs, childStatus, isRunningStatus, rosterCounts, rosterHeadline, statusColor, statusMarkerCell, } from './team-status.js';
 import { formatDuration } from '../agent/usage.js';
 import { describeToolActivity, sanitizeActivity } from '../team/activity.js';
 import { TEAM_LIMITS } from '../team/limits.js';
 import { buildTeamPanelLayout } from './layout/team-panel.js';
-function isRunning(run) {
-    return run.phase === 'starting' || run.phase === 'thinking' || run.phase === 'tool' ||
-        run.phase === 'waiting';
-}
-function isSettled(run) {
-    return run.phase === 'done' || run.phase === 'failed' || run.phase === 'aborted';
-}
-function statusColor(run, theme) {
-    if (run.phase === 'failed' || run.phase === 'aborted')
-        return theme.toolError;
-    if (run.phase === 'done')
-        return theme.toolDone;
-    if (isRunning(run))
-        return theme.toolRunning;
-    return theme.muted;
-}
 /**
  * How many characters the activity column may spend at this width (P0-1).
  *
@@ -172,10 +157,12 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
         return null;
     const glyphs = pickGlyphs(caps);
     const at = now ?? Date.now();
-    const running = snapshot.runs.filter(isRunning).length;
-    const done = snapshot.runs.filter(isSettled).length;
+    // ONE COUNTING AUTHORITY (A-1): `queued` used to fall between `isRunning` and
+    // `isSettled`, so a fresh dispatch read `0 running  0 done` above rows that each
+    // said `queued`.
+    const counts = rosterCounts(snapshot.runs);
     const elapsed = formatDuration(Math.max(0, at - snapshot.startedAt));
-    const header = (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { wrap: "truncate", color: theme.accent, bold: true, children: [glyphs.teamAgent, " team", '  ', _jsxs(Text, { color: theme.muted, children: [running, " running ", glyphs.midDot, " ", done, " done ", glyphs.midDot, " ", elapsed] })] }), snapshot.messageCount > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.teamMail, " ", snapshot.messageCount] }))] }));
+    const header = (_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Text, { wrap: "truncate", color: theme.accent, bold: true, children: [glyphs.teamAgent, " team", '  ', _jsxs(Text, { color: theme.muted, children: [rosterHeadline(counts, glyphs, cols), " ", glyphs.midDot, " ", elapsed] })] }), snapshot.messageCount > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [glyphs.teamMail, " ", snapshot.messageCount] }))] }));
     // Short terminals or a long draft leave only the shared header projection,
     // which still answers whether anything is running and for how long.
     if (projection.collapsed) {
@@ -187,13 +174,14 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
     // the requirement permits.
     const { visible, hiddenTotal, hiddenRunning } = projection;
     return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [header, visible.map((run) => {
-                const color = statusColor(run, theme);
+                const status = childStatus(run);
+                const color = statusColor(status, theme);
                 // One spinner per RUNNING row, and the row cap is 5 precisely because
                 // five is the documented maximum number of simultaneous spinners. Both
                 // `reducedMotion` and a non-Unicode terminal fall back to the same
                 // static marker, exactly as `AssistantEntry` and `ToolCard` already do.
-                const animate = isRunning(run) && !reducedMotion && caps.unicode;
-                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : marker(run, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityWithBadge(run, cols, at)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(Math.max(0, (run.endedAt ?? at) - run.startedAt)) : ''] })] }, run.label));
+                const animate = isRunningStatus(status) && !reducedMotion && caps.unicode;
+                return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: color, children: [' ', animate ? _jsx(Spinner, { type: "dots" }) : statusMarkerCell(status, glyphs), ' '] }), _jsx(Text, { color: theme.primary, children: run.label.padEnd(8).slice(0, 8) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, overflow: "hidden", children: _jsx(Text, { wrap: "truncate", color: theme.muted, children: run.description.replace(/\s+/g, ' ') }) }), _jsx(Box, { flexShrink: 1, overflow: "hidden", children: _jsxs(Text, { wrap: "truncate", color: color, children: ['  ', activityWithBadge(run, cols, at)] }) }), _jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', run.startedAt ? formatDuration(childElapsedMs(run, at)) : ''] })] }, run.label));
             }), hiddenTotal > 0 && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', "+", hiddenTotal, " more", hiddenRunning > 0 ? ` (${hiddenRunning} running)` : ''] })), (() => {
                 // The panel's supervisor line (AC-5): one row, only when the
                 // supervisor has actually acted - the per-row badges above already
@@ -202,12 +190,3 @@ export function TeamPanel({ snapshot, rows, cols, reducedMotion, theme, caps, no
                 return line ? (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: ['  ', line] })) : null;
             })(), snapshot.lastMessage && (_jsxs(Text, { wrap: "truncate", color: theme.muted, children: [' ', glyphs.teamMail, " ", snapshot.lastMessage.from, " ", glyphs.arrowRight, " ", snapshot.lastMessage.to, ": ", snapshot.lastMessage.subject.replace(/\s+/g, ' ')] }))] }));
 }
-function marker(run, glyphs) {
-    if (run.phase === 'done')
-        return glyphs.toolDone;
-    if (run.phase === 'failed' || run.phase === 'aborted')
-        return glyphs.toolError;
-    if (run.phase === 'queued')
-        return glyphs.toolPending;
-    return glyphs.spinnerStill;
-}