@aragon-agent/cli 0.6.23 → 0.6.25

package/dist/ui/overlays/QuestionOverlay.js

@@ -38,6 +38,21 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
     const [phase, setPhase] = useState('choosing');
     const [cursors, setCursors] = useState(() => initialCursors(questions));
     const [selections, setSelections] = useState(() => initialSelections(questions));
+    /**
+     * THE PER-QUESTION EXPLICIT-MARK BIT (V-1 / D-8).
+     *
+     * `initialSelections` PRE-SELECTS the recommended option on EVERY question
+     * (or the first option when there is none), so "the selection set is empty"
+     * is unreachable and can never be the test for "did the user choose?". The
+     * only reliable discriminator is the fact itself: the user pressed SPACE on
+     * this question. Without it, a user who only MOVES the cursor and presses
+     * Enter would submit the RECOMMENDED option instead of the highlighted one -
+     * a silent regression of the wizard's most common path. The bit survives
+     * Left/Right navigation exactly like `selections` and `cursors` do, and a
+     * single-choice mark is idempotent (no un-mark; Enter always has at least
+     * the marked item to submit).
+     */
+    const [markedSteps, setMarkedSteps] = useState(() => questions.map(() => false));
     const [customs, setCustoms] = useState(() => questions.map(() => ''));
     const [draft, setDraft] = useState('');
     const [offset, setOffset] = useState(0);
@@ -56,6 +71,7 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         return next;
     }));
     const chooseAt = (index, option) => setSelections((prev) => prev.map((set, i) => (i === index ? new Set([option]) : set)));
+    const markAt = (index) => setMarkedSteps((prev) => prev.map((marked, i) => (i === index ? true : marked)));
     const buildAnswers = () => questions.map((q, i) => {
         const chosen = [...(selections[i] ?? new Set())].sort((a, b) => a - b);
         const labels = chosen.map((index) => q.options[index]?.label ?? '').filter((l) => l.length > 0);
@@ -159,8 +175,21 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
             goBack();
             return;
         }
-        if (input === ' ' && question.allowMultiple) {
-            toggleAt(step, cursor);
+        // SPACE, BY QUESTION SHAPE (D-8). The strict `input === ' '` keeps a
+        // multi-character paste frame from ever matching (R-8); the Other row is
+        // a no-op in both shapes because it needs TEXT, and Enter is its key.
+        if (input === ' ' && !question.options[cursor]?.isOther) {
+            if (question.allowMultiple) {
+                toggleAt(step, cursor);
+                return;
+            }
+            // SINGLE CHOICE: mark the highlighted item and STAY - the terminal
+            // convention of "space selects, enter confirms". The mark is recorded
+            // both in the selection set (so `[x]` renders) and in the explicit
+            // mark bit (so a later Enter submits THIS item even after the cursor
+            // has moved on).
+            chooseAt(step, cursor);
+            markAt(step);
             return;
         }
         if (key.return) {
@@ -170,8 +199,15 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
                 setPhase('typingOther');
                 return;
             }
-            if (!question.allowMultiple)
-                chooseAt(step, cursor);
+            // A single-choice Enter submits the CURSOR item unless the user has
+            // explicitly space-marked this question, in which case the marked item
+            // wins even if the cursor has since moved (V-1's regression guard:
+            // cursor + Enter alone keeps today's behavior, recommended preselect
+            // and all).
+            if (!question.allowMultiple) {
+                if (!markedSteps[step])
+                    chooseAt(step, cursor);
+            }
             else if (!(selections[step] ?? new Set()).has(cursor))
                 toggleAt(step, cursor);
             advance();
@@ -183,7 +219,9 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         ? `type your answer ${glyphs.midDot} ${glyphs.enterKey} commit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
         : phase === 'review'
             ? `${glyphs.enterKey} submit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
-            : `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} ${glyphs.enterKey} next${question.allowMultiple ? ` ${glyphs.midDot} space toggle` : ''} ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`;
+            : question.options[cursor]?.isOther
+                ? `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} ${glyphs.enterKey} to type ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
+                : `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} space select ${glyphs.midDot} ${glyphs.enterKey} next ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`;
     const rowTexts = [];
     const optionStarts = [];
     const push = (text) => { rowTexts.push(...wrapToRows(text, Math.max(1, cols - 4))); };
@@ -208,8 +246,11 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         setOffset(previous => focus < previous ? focus : focus >= previous + height
             ? focus - height + 1 : previous);
     }, [focus, maxRows, cols, step, phase]);
+    // `space select` shows for BOTH shapes (AC-10) - 42 characters on the
+    // single-choice shape without `cancel`, a deliberate 5-column growth inside
+    // the `cols <= 48` budget this hint exists for (V-12).
     const shortHint = phase === 'typingOther' ? 'Enter commit | Left back | Esc cancel'
         : phase === 'review' ? 'Enter submit | Left back | Esc cancel'
-            : question.allowMultiple ? '^v choose Space toggle Enter next Esc' : 'Up/Down choose Enter next Esc cancel';
+            : '^v choose Space select Enter next Esc';
     return _jsx(OverlayFrame, { title: `${title}${position}`, hint: cols <= 48 ? shortHint : hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, rows: rowTexts.map((line, index) => _jsx(Text, { wrap: "truncate", children: line || ' ' }, index)), scrollOffset: offset, onScrollClamp: setOffset });
 }

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

@@ -14,6 +14,7 @@ import { type LogLevelName } from '../../logging/levels.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
 import type { ModelSettingsDraft, ModelSettingsPatch, ModelSettingsSaveResult } from '../../config/model-profile-store.js';
+import type { ModelProbe } from '../../agent/model-probe.js';
 export interface SettingsValues {
     provider: string;
     model: string;
@@ -36,6 +37,15 @@ export interface SettingsValues {
      */
     liveToolOutput: 'on' | 'off';
     maxTokens: string;
+    /**
+     * The top-level context-window override, as text (profile-context-window
+     * §6.3). EDITED ONLY WHILE MAIN IS UNBOUND: once a profile is bound as Main
+     * the profile owns the denominator, this row hides, and the editor becomes
+     * the only surface that writes the key - two entries on one key can only
+     * drift. Empty renders as `auto` because an empty field IS AUTO here, the
+     * reading `maxTokens` established.
+     */
+    contextWindow: string;
     apiKey: string;
     /**
      * Only the LEVEL is editable here. The rest of `LogConfig` — and above all
@@ -104,6 +114,13 @@ interface SettingsScreenProps {
     onProfileSave?: (draft: ModelSettingsDraft) => ModelSettingsSaveResult;
     onClose?: () => void;
     onReload?: () => ModelSettingsDraft;
+    /**
+     * The connection probe port (model-profile-connection-test 6.1). Absent in an
+     * embedded or test mount, where the two probe rows read `(unavailable)` - an
+     * EXPLICIT degradation this feature adds, not the silent no-op of the
+     * optional callbacks above.
+     */
+    probe?: ModelProbe;
     /**
      * `API retries` READ-ONLY row (llm-api-retry-backoff §6.9), e.g. `10` or `off`.
      *

package/dist/ui/overlays/SettingsScreen.js

@@ -11,7 +11,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useReducer, useRef, useState } from 'react';
 import { Text, useInput } from 'ink';
 import { DEFAULT_MAX_OUTPUT_TOKENS, resolveOutputTokens, } from '@aragon-agent/core';
-import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseMaxTokensInput, parseThresholdInput, } from '../../config/schema.js';
+import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseContextWindowInput, parseMaxTokensInput, parseThresholdInput, } from '../../config/schema.js';
 import { LOG_LEVEL_NAMES } from '../../logging/levels.js';
 import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
@@ -21,7 +21,26 @@ import { emptyModelProfiles } from '../../config/model-profiles.js';
 import { registerSecret } from '../../logging/secret-registry.js';
 import { ModelProfilePicker, useProfileScroll } from './ModelProfilePicker.js';
 import { ModelProfileEditor } from './ModelProfileEditor.js';
-import { createModelProfileState, createCustomProfile, modelProfileReducer, profileUsers } from './model-profile-state.js';
+import { ModelDiscoveryList } from './ModelDiscoveryList.js';
+import { useModelProbe } from './use-model-probe.js';
+import { canProbe, editorProbeTarget, visibleProbeViews } from './model-probe-view.js';
+import { createModelProfileState, createCustomProfile, modelProfileReducer, profileUsers, draftTeam, draftSubagentProfileId, subagentModelSummary, subagentSelectedId } from './model-profile-state.js';
+/**
+ * THE ROOT PAGE'S ROW INDEXES, AS NAMES (subagent-model V-5).
+ *
+ * Five offset sites used to agree by accident on the number 3; the Subagent
+ * model row moves every one of them. Each site below now cites its constant,
+ * so adding a row later is a one-line change instead of a silent regression
+ * that focuses an error message on the wrong field.
+ */
+const ROOT_MAIN = 0;
+const ROOT_FAST = 1;
+const ROOT_SUBAGENT = 2;
+const ROOT_MANAGE = 3;
+const ROOT_FIRST_FIELD = 4;
+/** Stand-in target while no editor exists; no probe row is rendered then. */
+const NO_PROFILE_TARGET = { provider: '', model: '', baseUrl: null,
+    apiKey: null };
 const SHOW_THINKING_OPTIONS = ['off', 'on'];
 const LIVE_OUTPUT_OPTIONS = ['off', 'on'];
 const FAST_ENABLED_OPTIONS = ['off', 'on'];
@@ -172,6 +191,11 @@ const FIELDS = [
     // `.padEnd(18)` enforces below and that IF-H7 records as silently overflowing.
     { key: 'liveToolOutput', label: 'Live output', kind: 'enum', options: LIVE_OUTPUT_OPTIONS },
     { key: 'maxTokens', label: 'Max tokens', kind: 'text' },
+    // DIRECTLY UNDER `Max tokens`: the two token rows read together. `Context
+    // window` is 14 characters, inside the 18-column label budget `.padEnd(18)`
+    // enforces below (IF-H7). Only ever RENDERED while Main is unbound - see
+    // `SettingsValues.contextWindow` and the unbound-group filter below.
+    { key: 'contextWindow', label: 'Context window', kind: 'text' },
     // The fast tier sits AFTER `Max tokens` and BEFORE `API key`, because the key
     // row is the one a user scrolls to deliberately and putting five rows past it
     // would bury it (fast-model-tier §4.5). The rationale survives a fifth row;
@@ -348,6 +372,11 @@ function LegacySettingsScreen({ isActive = true, initial, apiKeys, maxRows, cols
         // setting, which is the one thing this field can never be.
         if (f.key === 'maxTokens' && raw.length === 0)
             return 'auto';
+        // An empty window field is AUTO, not "unset" - the same reading, and the
+        // second of the TWO render points that must agree (P2-1: the profile
+        // screen's row fallback below is the other).
+        if (f.key === 'contextWindow' && raw.length === 0)
+            return 'auto';
         // `(not set)` and NOT `(same as main)`, which is the honest reading of §3.2
         // rule 3: an empty `fast.model` does not inherit, it means the tier is
         // unconfigured. `(same as main)` is a fact the derived line below states
@@ -385,15 +414,23 @@ function LegacySettingsScreen({ isActive = true, initial, apiKeys, maxRows, cols
     rows.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: "Enter saves. Keys persist to the config file (0600)." }, "__save"));
     return (_jsx(OverlayFrame, { title: "Settings", hint: `${glyphs.arrowUp}${glyphs.arrowDown} field ${glyphs.midDot} ${glyphs.arrowLeft}${glyphs.arrowRight} change ${glyphs.midDot} Enter save ${glyphs.midDot} Esc close`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: focusedOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
 }
+// `contextWindow` joins the exclusion list so a bound Main can never leak a
+// SECOND copy of the row through PROFILE_FIELDS - the root row belongs to the
+// unbound group below, exclusively (AC-11).
 const PROFILE_FIELDS = FIELDS.filter((field) => ![
     'provider', 'model', 'baseUrl', 'apiKey', 'fastProvider', 'fastModel', 'fastEnabled',
+    'contextWindow',
 ].includes(field.key));
 function profileSettingsValues(initial, draft) {
     const file = draft.baseline;
     return { ...initial, provider: file.provider ?? initial.provider,
         model: file.model ?? initial.model,
         baseUrl: file.baseUrl ?? '', apiKey: '', fastModel: file.fast?.model ?? '',
-        fastProvider: file.fast?.provider || FAST_INHERIT_PROVIDER };
+        fastProvider: file.fast?.provider || FAST_INHERIT_PROVIDER,
+        // SEEDED FROM THE FILE VALUE, like its provider/model/baseUrl siblings
+        // (AC-11 / P2-3): when env holds an override the file value is not the
+        // effective one, and this screen edits the FILE.
+        contextWindow: file.contextWindow == null ? 'auto' : String(file.contextWindow) };
 }
 /** Only fields changed by the user belong in a settings transaction. */
 export function readDirtySettings(initial, values) {
@@ -422,6 +459,15 @@ export function readDirtySettings(initial, values) {
             throw new Error('Max tokens: use a number or auto.');
         patch.maxTokens = parsed.kind === 'auto' ? null : parsed.value;
     }
+    if (dirty('contextWindow')) {
+        // TYPO CHANGES NOTHING: the message's `Context window:` prefix is what
+        // `saveProfileSettings`'s focus logic matches to jump to this row. The
+        // silent clamp on a value mirrors `config set contextWindow`.
+        const parsed = parseContextWindowInput(values.contextWindow);
+        if (parsed.kind === 'invalid')
+            throw new Error('Context window: use a number or auto.');
+        patch.contextWindow = parsed.kind === 'auto' ? null : parsed.value;
+    }
     const fast = {};
     const parsedFast = readFastSettings(values);
     if (dirty('fastModel'))
@@ -487,6 +533,15 @@ function useProfileSettingsState(props) {
     const [confirmIndex, setConfirmIndex] = useState(0);
     const [reloadPending, setReloadPending] = useState(false);
     const offset = useProfileScroll(props, index);
+    // THE PROBE LIVES HERE, NOT IN THE EDITOR (RV-P0-1): this component survives a
+    // page switch, the editor does not, and a hook inside the editor would abort its
+    // own discovery the moment `Discover models` opens the list page.
+    const probe = useModelProbe(props.probe);
+    const probeTarget = state.editor
+        ? editorProbeTarget(state.editor, props.apiKeys) : undefined;
+    // TWO SLOTS: a verdict and a discovered list answer different questions, and
+    // opening the list must not erase a verdict the user still wants to read.
+    const probeViews = visibleProbeViews(probe.test, probe.discovery, probeTarget ?? NO_PROFILE_TARGET, props.probe);
     const previousPage = useRef(state.page);
     useEffect(() => {
         const previous = previousPage.current;
@@ -501,17 +556,19 @@ function useProfileSettingsState(props) {
     const dirty = state.dirty || Object.keys(values).some((key) => values[key] !== initial[key]);
     const fields = [FIELDS.find((item) => item.key === 'fastEnabled'),
         ...FIELDS.filter((item) => library.mainId === null
-            && ['provider', 'model', 'baseUrl', 'apiKey'].includes(item.key)),
+            && ['provider', 'model', 'baseUrl', 'contextWindow', 'apiKey'].includes(item.key)),
         ...FIELDS.filter((item) => library.fastId === null
             && ['fastModel', 'fastProvider'].includes(item.key)), ...PROFILE_FIELDS];
-    const count = fields.length + 5;
-    const field = fields[index - 3];
+    // SIX FIXED ROWS now (Main, Fast, SUBAGENT, Manage, Save, Reload) around
+    // the `fields` block - see the ROOT_* constants for the five offset sites.
+    const count = fields.length + 6;
+    const field = fields[index - ROOT_FIRST_FIELD];
     const readError = state.draft.readError;
     const confirming = state.page === 'delete-confirm' || state.page === 'discard-confirm';
     return { state, dispatch, initial, setInitial, values, setValues, index, setIndex,
         error, setError, persisted, setPersisted, confirmIndex, setConfirmIndex,
         reloadPending, setReloadPending, offset, library, glyphs, dirty, fields, count,
-        field, readError, confirming };
+        field, readError, confirming, probe, probeTarget, probeViews };
 }
 function saveProfileSettings(props, view) {
     const { persisted, readError, initial, values, fields, state, setError, setIndex, setPersisted } = view;
@@ -526,7 +583,7 @@ function saveProfileSettings(props, view) {
         setError(message);
         const at = fields.findIndex((item) => message.startsWith(`${item.label}:`));
         if (at >= 0)
-            setIndex(at + 3);
+            setIndex(at + ROOT_FIRST_FIELD);
         return;
     }
     const result = props.onProfileSave({
@@ -549,6 +606,7 @@ function reloadProfileSettings(props, view) {
         showThinking: live.showThinking ? 'on' : 'off',
         liveToolOutput: live.liveToolOutput ? 'on' : 'off',
         maxTokens: live.maxTokens === undefined ? '' : String(live.maxTokens),
+        contextWindow: live.contextWindow == null ? 'auto' : String(live.contextWindow),
         logLevel: live.log?.level ?? props.initial.logLevel,
         ...(live.fast ? fastSettingsFrom(live.fast) : {}),
         ...(live.compaction ? compactionSettingsFrom(live.compaction) : {}),
@@ -585,9 +643,15 @@ function activateRootSetting(props, view) {
     }
     if (readError || persisted)
         return;
-    if (index < 2)
-        dispatch({ type: 'page', page: 'picker', role: index === 0 ? 'main' : 'fast' });
-    else if (index === 2)
+    if (index === ROOT_MAIN || index === ROOT_FAST) {
+        dispatch({ type: 'page', page: 'picker', role: index === ROOT_MAIN ? 'main' : 'fast' });
+    }
+    else if (index === ROOT_SUBAGENT) {
+        // The user-owned cost switch (D-5): its own picker mode, writing
+        // `draft.patch.team` rather than a `${role}Id` library key.
+        dispatch({ type: 'page', page: 'picker', role: 'subagent' });
+    }
+    else if (index === ROOT_MANAGE)
         dispatch({ type: 'page', page: 'manager' });
     else
         saveProfileSettings(props, view);
@@ -669,16 +733,65 @@ function renderSettingsConfirmation(props, view) {
     const { state, library, confirmIndex, glyphs } = view;
     const deleting = state.page === 'delete-confirm';
     const name = library.entries.find((entry) => entry.id === state.deleteId)?.name ?? '';
-    const labels = deleting ? ['Cancel', 'Delete'] : ['Continue', 'Discard'];
-    return _jsx(OverlayFrame, { ...props, title: deleting ? `Delete ${name}?` : 'Discard unsaved changes?', hint: "Enter choose | Esc continue", rows: labels
-            .map((label, at) => _jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [confirmIndex === at ? `${glyphs.caret} ` : '  ', label] }, label)), scrollOffset: confirmIndex });
+    // UNBIND-AND-DELETE (D-6): a referenced entry stays deletable in ONE flow,
+    // and the button names what will happen.
+    const labels = deleting
+        ? ['Cancel', state.deleteUsers ? 'Unbind and delete' : 'Delete']
+        : ['Continue', 'Discard'];
+    const rows = labels
+        .map((label, at) => _jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [confirmIndex === at ? `${glyphs.caret} ` : '  ', label] }, label));
+    // V-8: A RENDER-ONLY ROW, pushed AFTER the buttons. `confirmIndex` stays a
+    // 0..1 index over the two buttons and `scrollOffset` follows it, so this
+    // line must never sit between them or take an array slot of its own.
+    if (deleting && state.deleteUsers) {
+        rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: ["Used by ", state.deleteUsers, ". The binding(s) will be cleared."] }, "users"));
+    }
+    return _jsx(OverlayFrame, { ...props, title: deleting ? `Delete ${name}?` : 'Discard unsaved changes?', hint: "Enter choose | Esc continue", rows: rows, scrollOffset: confirmIndex });
+}
+/** Zero-network guard: no key (or no probe port) means no request at all. */
+function startTest(view) {
+    if (view.probeTarget && canProbe(view.probeViews.test)) {
+        view.probe.startTest(view.probeTarget);
+    }
+}
+/** Discover from the draft, then show the list page: the state stays here. */
+function startDiscovery(view, dispatch) {
+    if (!view.probeTarget || !canProbe(view.probeViews.test))
+        return;
+    view.probe.startDiscovery(view.probeTarget);
+    dispatch({ type: 'page', page: 'models' });
+}
+/**
+ * Whether the fast tier resolves FOR DISPLAY while the subagent picker is
+ * open (D-5): the built-in `Fast tier model` row then annotates itself with
+ * `(fast tier off)`, so choosing it is never a surprise fallback. The same
+ * enabled + model + config-file-key approximation `fastTierLine` uses - and
+ * the same env-key blindness (V-10), accepted for consistency with it.
+ */
+function fastTierUnavailable(props, view) {
+    const { values } = view;
+    if (values.fastEnabled !== 'on')
+        return true;
+    if (values.fastModel.trim().length === 0)
+        return true;
+    const provider = values.fastProvider === FAST_INHERIT_PROVIDER
+        || values.fastProvider.trim().length === 0 ? values.provider : values.fastProvider;
+    return (props.apiKeys[provider] ?? '').length === 0;
 }
 function renderProfileSubpage(props, view) {
     const { state, library, dispatch, setConfirmIndex } = view;
     if (state.page === 'editor' && state.editor)
-        return _jsx(ModelProfileEditor, { ...props, editor: state.editor, users: profileUsers(library, state.editor.original.id), error: state.error, dispatch: dispatch });
+        return _jsx(ModelProfileEditor, { ...props, editor: state.editor, users: profileUsers(library, state.editor.original.id, draftSubagentProfileId(state.draft)), error: state.error, dispatch: dispatch, probeView: view.probeViews.test, probeBusy: view.probe.busy, probeTarget: view.probeTarget, onTest: () => startTest(view), onDiscover: () => startDiscovery(view, dispatch), onCancelProbe: view.probe.cancel });
+    // A DISCOVERY IS A PAGE, NOT A POPUP: the list is where the answer belongs, and
+    // the probe state it renders keeps running because it lives one level up.
+    if (state.page === 'models' && state.editor)
+        return _jsx(ModelDiscoveryList, { ...props, provider: state.editor.provider, currentModel: state.editor.model, view: view.probeViews.discovery, busy: view.probe.discovery.phase === 'discovering', onChoose: (model) => dispatch({ type: 'choose-model', model }), onRetry: () => startDiscovery(view, dispatch), onBack: () => dispatch({ type: 'page', page: 'editor' }), onCancelProbe: view.probe.cancel });
+    // A NEW PROFILE SEEDED FROM THE MAIN CONNECTION while the subagent picker is
+    // open: 'subagent' is picker-only (6.2), so the seed role falls back to
+    // 'main' while `state.role` keeps driving the select that binds it.
+    const createRole = state.role === 'subagent' ? 'main' : state.role;
     if (state.page === 'picker' || state.page === 'manager')
-        return _jsx(ModelProfilePicker, { ...props, profiles: library, savedProfiles: state.draft.baseline.modelProfiles, role: state.role, customProfile: createCustomProfile(state.draft, state.role), manager: state.page === 'manager', error: state.error, onSelect: (id) => dispatch({ type: 'select', role: state.role, id }), onCreate: () => dispatch({ type: 'edit', profile: createCustomProfile(state.draft, state.role),
+        return _jsx(ModelProfilePicker, { ...props, profiles: library, savedProfiles: state.draft.baseline.modelProfiles, role: state.role, customProfile: createCustomProfile(state.draft, createRole), manager: state.page === 'manager', error: state.error, selectedIdOverride: state.role === 'subagent' ? subagentSelectedId(state.draft) : undefined, subagentProfileId: draftSubagentProfileId(state.draft), fastTierOff: state.role === 'subagent' && fastTierUnavailable(props, view), onSelect: (id) => dispatch({ type: 'select', role: state.role, id }), onCreate: () => dispatch({ type: 'edit', profile: createCustomProfile(state.draft, createRole),
                 bindNew: state.page === 'picker' }), onEdit: (profile) => dispatch({ type: 'edit', profile }), onDuplicate: (id) => dispatch({ type: 'duplicate', id }), onDelete: (id) => { setConfirmIndex(0); dispatch({ type: 'delete', id }); }, onCancel: () => dispatch({ type: 'page', page: 'root' }) });
     return null;
 }
@@ -691,13 +804,34 @@ function buildRootSettingsRows(props, view) {
         const missing = !entry.apiKey && !props.apiKeys[entry.provider];
         return `${entry.name}  ${entry.provider}:${entry.model}${missing ? ' [Missing API key]' : ''}`;
     };
+    // THE SUBAGENT MODEL ROW (D-5), third on the page, summarized from the
+    // same draft/baseline sources every other derived row here reads. The fast
+    // tier check mirrors `fastTierLine`'s approximation (enabled + model + a
+    // config-file key) so the two derived lines can never disagree.
+    const team = draftTeam(state.draft);
+    const mainBound = library.entries.find((entry) => entry.id === library.mainId);
+    const mainConnection = mainBound
+        ? `${mainBound.provider}:${mainBound.model}`
+        : `${values.provider}:${values.model}`;
+    const fastModel = values.fastModel.trim();
+    const fastProvider = values.fastProvider === FAST_INHERIT_PROVIDER
+        || values.fastProvider.trim().length === 0 ? values.provider : values.fastProvider;
+    const fastConnection = values.fastEnabled === 'on' && fastModel.length > 0
+        && (props.apiKeys[fastProvider] ?? '').length > 0
+        ? `${fastProvider}:${fastModel}` : null;
+    const subagentLine = subagentModelSummary({ mode: team.model,
+        modelProfileId: team.modelProfileId, mainConnection, fastConnection,
+        profiles: state.draft.profiles,
+        hasKey: (id) => (props.apiKeys[id] ?? '').length > 0 });
     const lines = [`Main profile      ${name(library.mainId)}`,
         `Fast profile      ${name(library.fastId)}`,
+        `Subagent model    ${subagentLine}`,
         `Manage profiles   ${library.entries.length} saved`,
         ...fields.map((item) => `${item.label.padEnd(18)}${item.key === 'apiKey'
             ? values.apiKey ? 'Configured (replacement)' : props.apiKeys[values.provider]
                 ? 'Configured (type to replace)' : '(type to set)'
-            : values[item.key] || (item.key === 'maxTokens' ? 'auto' : '(not set)')}`),
+            : values[item.key] || (item.key === 'maxTokens' || item.key === 'contextWindow'
+                ? 'auto' : '(not set)')}`),
         persisted || readError ? 'Save (disabled)' : 'Save settings', 'Reload settings'];
     const rows = lines.map((line, at) => _jsxs(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: [at === index ? `${glyphs.caret} ` : '  ', line] }, at));
     rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: effectiveCapLine(values) }, "effective"));
@@ -720,7 +854,7 @@ function ProfileSettingsScreen(props) {
         return subpage;
     const { error, readError, dirty, persisted, index, offset } = view;
     return _jsx(OverlayFrame, { ...props, rows: buildRootSettingsRows(props, view), scrollOffset: offset, title: error ?? (readError ? 'Cannot read config. Repair with aragon config edit; Reload.'
-            : dirty ? 'Settings | Unsaved changes' : 'Settings'), hint: persisted ? 'Esc close; restart to apply' : index < 3
+            : dirty ? 'Settings | Unsaved changes' : 'Settings'), hint: persisted ? 'Esc close; restart to apply' : index < ROOT_FIRST_FIELD
             ? 'Enter select/edit | Ctrl+S save | Esc cancel'
             : 'Enter save/action | Ctrl+S save | Esc cancel' });
 }

package/dist/ui/overlays/model-probe-view.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The probe's VIEW MODEL (model-profile-connection-test §3.2 / §6.3).
+ *
+ * Pure functions only: the editor's row list, the result sentences, the candidate
+ * ordering and the two number formatters. Rendering and input both read
+ * `editorRows()`, so "which row am I on" has exactly one definition and inserting a
+ * row can no longer shift `apiKey` off index 6 by arithmetic.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import type { ProbeOutcome, ProbeTarget, ModelCandidate, DiscoveryOutcome, ModelProbe } from '../../agent/model-probe.js';
+import type { ProfileEditorDraft } from './model-profile-state.js';
+export declare const EDITOR_FIELDS: readonly ["name", "provider", "model", "contextWindow", "baseUrl", "credentialMode", "apiKey"];
+export type EditorField = typeof EDITOR_FIELDS[number];
+export declare const EDITOR_LABELS: string[];
+export type EditorAction = 'retain' | 'test' | 'discover' | 'apply' | 'cancel';
+export type EditorRow = {
+    kind: 'field';
+    field: EditorField;
+    label: string;
+    value: string;
+} | {
+    kind: 'action';
+    action: EditorAction;
+    label: string;
+    value: string;
+} | {
+    kind: 'note';
+    label: string;
+    muted: true;
+} | {
+    kind: 'result';
+    label: string;
+    tone: 'ok' | 'fail' | 'muted';
+};
+/** What the current target's probe looks like to a renderer (editor surface). */
+export type ProbeView = {
+    kind: 'idle';
+    reason: 'no_result' | 'no_key' | 'unavailable';
+} | {
+    kind: 'testing';
+} | {
+    kind: 'result';
+    outcome: ProbeOutcome;
+};
+/** The list page's own surface: a discovery is a page, not a result row. */
+export type DiscoveryView = {
+    kind: 'idle';
+} | {
+    kind: 'discovering';
+} | {
+    kind: 'discovery';
+    outcome: DiscoveryOutcome;
+};
+/**
+ * The hook's two INDEPENDENT slots, declared here so this module stays React-free.
+ *
+ * They are separate on purpose: a test outcome and a discovered list describe the
+ * same connection but answer different questions, and a single slot would make
+ * "run a test, then open the list, then come back" lose the verdict (AC-27).
+ */
+export type ProbeTestPhase = {
+    phase: 'idle';
+} | {
+    phase: 'testing';
+    targetId: string;
+} | {
+    phase: 'tested';
+    outcome: ProbeOutcome;
+};
+export type ProbeDiscoveryPhase = {
+    phase: 'idle';
+} | {
+    phase: 'discovering';
+    connectionId: string;
+} | {
+    phase: 'discovered';
+    outcome: DiscoveryOutcome;
+};
+export interface ProbeViews {
+    test: ProbeView;
+    discovery: DiscoveryView;
+}
+/** Whether pressing a probe action can produce anything at all (AC-12 / AC-15). */
+export declare function canProbe(view: ProbeView): boolean;
+/**
+ * Filter both slots down to what the CURRENT target may honestly claim (§4.6).
+ *
+ * A `OK 812 ms` that describes a model the user has since edited is worse than no
+ * result at all, so a fingerprint mismatch degrades to `idle` - no effect, no
+ * reset call, no cross-page synchronisation.
+ */
+export declare function visibleProbeViews(test: ProbeTestPhase, discovery: ProbeDiscoveryPhase, target: ProbeTarget, probe?: ModelProbe): ProbeViews;
+/** The exact target a draft would use - the resolved key included (§4.2.1). */
+export declare function editorProbeTarget(editor: ProfileEditorDraft, apiKeys: Record<string, string | undefined>): ProbeTarget;
+/** `812 ms` / `1.4 s` - one decimal only once a second has passed. */
+export declare function latencyLabel(ms: number): string;
+/** `128K` / `1M` / `auto` - `auto` when the vendor did not report a window. */
+export declare function windowLabel(window?: number): string;
+/**
+ * Clean and order a discovered list: one row per id, and the model the draft
+ * already names first, so "which one am I on" is answerable without scrolling.
+ */
+export declare function rankCandidates(models: readonly ModelCandidate[], currentModel: string): ModelCandidate[];
+/** At most TWO rows: the verdict, then what to do about it (§3.1 / D-11). */
+export declare function probeLines(view: ProbeView, target: ProbeTarget): string[];
+/** Colour for the result rows; the status WORDS carry the meaning without colour. */
+export declare function probeTone(view: ProbeView): 'ok' | 'fail' | 'muted';
+export interface EditorRowsInput {
+    editor: ProfileEditorDraft;
+    retain: boolean;
+    probe: ProbeView;
+    target: ProbeTarget;
+    /** The `Window applies ...` honesty line for a Fast-only entry (§3.2 / RV-P1-7). */
+    fastOnly?: boolean;
+}
+/** THE single source of the editor's rows - fields, actions, notes AND results. */
+export declare function editorRows(input: EditorRowsInput): EditorRow[];
+/** Rows the cursor can land on; index arithmetic now derives from the row model. */
+export declare function isFocusable(row: EditorRow): boolean;
+/** The focusable rows, in order - the index space `useProfileScroll` follows. */
+export declare function focusableRows(rows: readonly EditorRow[]): EditorRow[];
+/** Result rows currently on screen, so the viewport can be widened to include them. */
+export declare function resultRowCount(rows: readonly EditorRow[]): number;
+/** Longest id shown in one list row, inside the 40-column budget. */
+export declare const LIST_ID_CHARS = 28;
+/** A model's one-line name, bounded by `maxNameChars`. */
+export declare function clipName(name: string): string;