@aragon-agent/cli 0.6.24 → 0.6.25

package/dist/ui/overlays/ModelDiscoveryList.js

@@ -0,0 +1,161 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Text, useInput } from 'ink';
+import { PROBE_LIMITS } from '../../agent/model-probe-limits.js';
+import { pickGlyphs } from '../glyphs.js';
+import { OverlayFrame } from '../layout/OverlayFrame.js';
+import { stripPasteFrames } from '../paste-frames.js';
+import { stripEnterFrames } from '../enter-frames.js';
+import { clipProfileText, useProfileScroll } from './ModelProfilePicker.js';
+import { rankCandidates, windowLabel, clipName, LIST_ID_CHARS } from './model-probe-view.js';
+function matches(candidate, query) {
+    const needle = query.toLocaleLowerCase();
+    return candidate.id.toLocaleLowerCase().includes(needle)
+        || candidate.name.toLocaleLowerCase().includes(needle);
+}
+/** One row: id column, name column, window right-aligned inside the frame budget. */
+function listRowText(candidate, cols) {
+    const width = Math.max(20, cols - 8);
+    const label = windowLabel(candidate.contextWindow);
+    const idWidth = Math.max(10, Math.min(LIST_ID_CHARS, width - label.length - 14));
+    const nameWidth = Math.max(4, width - idWidth - label.length - 2);
+    const id = [...candidate.id].slice(0, idWidth).join('').padEnd(idWidth);
+    // `clipName` caps the NAME COLUMN itself, so a vendor that ships a paragraph in
+    // `name` cannot push the window label out of a wide frame either.
+    const name = [...clipName(candidate.name)].slice(0, nameWidth).join('').padEnd(nameWidth);
+    return clipProfileText(`${id} ${name} ${label}`, width);
+}
+/** What the page says when there is no row to select. */
+function emptyLines(busy, provider, view) {
+    if (busy)
+        return [`Discovering ${provider} models...`];
+    if (view.kind === 'discovery' && !view.outcome.ok) {
+        return [view.outcome.detail ?? 'The model list could not be fetched.',
+            'Fix: check the base URL and key, then press r to retry.'];
+    }
+    if (view.kind === 'discovery') {
+        return ['No models returned. Press r to retry, Esc to go back.',
+            'Test the connection for a precise reason.'];
+    }
+    return ['No models discovered yet. Press r to retry, Esc to go back.'];
+}
+function buildRows(props, view, glyphs) {
+    const rows = [];
+    if (view.searchable) {
+        rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [view.searching ? `${glyphs.caret} ` : '  ', "Search: ", view.query || '(/ to search)'] }, "search"));
+    }
+    if (view.shown.length === 0) {
+        const lines = view.query.length > 0
+            ? [`No model matches "${view.query}". Esc clears the search.`]
+            : emptyLines(props.busy, props.provider, props.view);
+        for (const line of lines) {
+            rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: line }, `empty-${rows.length}`));
+        }
+    }
+    view.shown.forEach((candidate, at) => {
+        const focused = at === view.cursor && !view.searching;
+        rows.push(_jsxs(Text, { wrap: "truncate", color: at === view.cursor ? props.theme.accent : props.theme.muted, children: [focused ? `${glyphs.caret} ` : '  ', listRowText(candidate, props.cols)] }, candidate.id));
+    });
+    if (view.truncated) {
+        const total = props.view.kind === 'discovery'
+            ? props.view.outcome.total ?? view.shown.length : view.shown.length;
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: `Showing first ${PROBE_LIMITS.maxListedModels} of ${total}. Narrow with search.` }, "truncated"));
+    }
+    return rows;
+}
+/**
+ * The discovered-model page (model-profile-connection-test §3.5).
+ *
+ * Pure display plus input: it receives the discovery outcome and three intents and
+ * issues no request itself. No spinner - the census of animated sites is a closed
+ * list, and this overlay can be open while a run is in flight.
+ */
+export function ModelDiscoveryList(props) {
+    const [index, setIndex] = useState(0);
+    const [query, setQuery] = useState('');
+    const [searching, setSearching] = useState(false);
+    const glyphs = pickGlyphs(props.caps);
+    const candidates = props.view.kind === 'discovery'
+        ? props.view.outcome.models : [];
+    const ranked = rankCandidates(candidates, props.currentModel);
+    const shown = query.length > 0 ? ranked.filter((item) => matches(item, query)) : ranked;
+    const searchable = ranked.length > PROBE_LIMITS.searchThreshold;
+    const cursor = shown.length > 0 ? Math.min(index, shown.length - 1) : 0;
+    // The truncation notice is one row BELOW the last candidate, and `useProfileScroll`
+    // only guarantees the FOCUSED row is visible - the same blind spot that hid the
+    // editor's result rows (RV-P1-3). Standing on the last row therefore widens the
+    // window by one, or `Showing first 400 of ...` could never be read at all.
+    const truncatedNotice = props.view.kind === 'discovery' && props.view.outcome.truncated
+        && shown.length > 0;
+    const revealNotice = truncatedNotice && cursor >= shown.length - 1;
+    const offset = useProfileScroll(props, cursor + (searchable ? 1 : 0) + (revealNotice ? 1 : 0));
+    // Arrival, not every render: when the outcome lands, put the cursor on the model the
+    // draft already names, so "which one am I on" is answerable without scrolling.
+    const arrival = props.view.kind === 'discovery'
+        ? `${props.view.outcome.connectionId}|${ranked.length}` : 'none';
+    useEffect(() => {
+        const at = ranked.findIndex((item) => item.id === props.currentModel.trim());
+        setIndex(at > 0 ? at : 0);
+    }, [arrival]);
+    const move = (delta) => {
+        if (shown.length > 0)
+            setIndex((cursor + delta + shown.length) % shown.length);
+    };
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        if (key.escape) {
+            if (searching) {
+                setSearching(false);
+                setQuery('');
+                setIndex(0);
+                return;
+            }
+            if (props.busy) {
+                props.onCancelProbe?.();
+                return;
+            }
+            props.onBack();
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            move(-1);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            move(1);
+            return;
+        }
+        if (key.return) {
+            const picked = shown[cursor];
+            if (picked)
+                props.onChoose(picked.id);
+            return;
+        }
+        if (searching) {
+            if (key.backspace || key.delete) {
+                setQuery((value) => [...value].slice(0, -1).join(''));
+                setIndex(0);
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setQuery((value) => value + stripPasteFrames(stripEnterFrames(input)));
+                setIndex(0);
+            }
+            return;
+        }
+        if (input === '/' && searchable) {
+            setSearching(true);
+            setIndex(0);
+            return;
+        }
+        // `r` retries ONLY outside the search state: sharing the key with the query would
+        // turn one typo into a network request (§3.5 / D-16).
+        if (!key.ctrl && !key.meta && input === 'r')
+            props.onRetry();
+    });
+    const hint = props.busy ? 'Esc cancel'
+        : searching ? 'Type search | Enter choose | Esc back'
+            : `Enter choose${searchable ? ' | / search' : ''} | r retry | Esc back`;
+    return _jsx(OverlayFrame, { ...props, scrollOffset: offset, hint: hint, rows: buildRows(props, { query, shown, cursor, searchable, searching,
+            truncated: truncatedNotice }, glyphs), title: `Models | ${props.provider} (${shown.length})` });
+}

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

@@ -1,12 +1,29 @@
 import React from 'react';
+import type { ProbeTarget } from '../../agent/model-probe.js';
 import { type ProfileFrameProps } from './ModelProfilePicker.js';
 import { type ProfileEditorDraft, type ModelProfileAction } from './model-profile-state.js';
+import { type ProbeView } from './model-probe-view.js';
 interface ModelProfileEditorProps extends ProfileFrameProps {
     editor: ProfileEditorDraft;
     users: string;
     error?: string;
     dispatch: React.Dispatch<ModelProfileAction>;
+    /**
+     * The rendered probe state and its three intents. ALL OPTIONAL: a standalone or
+     * embedded mount has no probe port, and the two action rows then read
+     * `(unavailable)` instead of pretending to work (§6.1 / AC-15).
+     */
+    probeView?: ProbeView;
+    probeBusy?: boolean;
+    probeTarget?: ProbeTarget;
+    onTest?: () => void;
+    onDiscover?: () => void;
+    onCancelProbe?: () => void;
 }
-/** Replacement key input starts empty; retention across targets is explicit. */
+/**
+ * The profile form. Row semantics come from `editorRows()` - never from index
+ * arithmetic - so `apiKey` stays at index 6 and the two probe actions sit at the end
+ * of the action block, after `retain` (P0-1 / I-4).
+ */
 export declare function ModelProfileEditor(props: ModelProfileEditorProps): React.ReactElement;
 export {};

package/dist/ui/overlays/ModelProfileEditor.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Text, useInput } from 'ink';
 import { ADAPTER_PROVIDERS } from '../../config/schema.js';
@@ -7,54 +7,47 @@ import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
 import { pickGlyphs } from '../glyphs.js';
-import { profileEndpointSummary, useProfileScroll } from './ModelProfilePicker.js';
+import { useProfileScroll } from './ModelProfilePicker.js';
 import { finishProfileEditor } from './model-profile-state.js';
-// `Context window` sits right after Model: the window is an attribute of the
-// model+endpoint the two rows above name. 14 characters, inside the 18-column
-// label budget `LABELS.map(...padEnd(18))` enforces below.
-const FIELDS = ['name', 'provider', 'model', 'contextWindow', 'baseUrl', 'credentialMode',
-    'apiKey'];
-const LABELS = ['Name', 'Provider', 'Model', 'Context window', 'Base URL', 'Credential mode',
-    'API key'];
-function useEditorInput(props, navigation) {
+import { EDITOR_FIELDS, editorRows, editorProbeTarget, focusableRows, resultRowCount } from './model-probe-view.js';
+function useEditorInput(props, focus) {
     const { editor, dispatch } = props;
-    const { index, setIndex, retain, count } = navigation;
+    const { index, setIndex, count, focusable } = focus;
     function commit() {
         const result = finishProfileEditor(editor);
         if (result.field) {
-            const at = FIELDS.indexOf(result.field);
+            // Field rows are the first focusables, in `EDITOR_FIELDS` order, so the jump an
+            // invalid field asks for is a lookup rather than an offset guess.
+            const at = EDITOR_FIELDS.indexOf(result.field);
             if (at >= 0)
                 setIndex(at);
         }
         dispatch({ type: 'merge-editor' });
     }
-    useInput((input, key) => {
-        if (props.isActive === false)
-            return;
-        if (key.escape) {
-            dispatch({ type: 'cancel-editor' });
-            return;
-        }
-        if (key.upArrow || (key.tab && key.shift)) {
-            setIndex((index - 1 + count) % count);
+    function activate(row) {
+        if (!row)
             return;
-        }
-        if (key.downArrow || key.tab) {
-            setIndex((index + 1) % count);
+        if (row.kind === 'field') {
+            commit();
             return;
         }
-        if (key.return) {
-            if (retain && index === FIELDS.length)
-                dispatch({ type: 'retain-key' });
-            else if (index === count - 1)
-                dispatch({ type: 'cancel-editor' });
-            else
-                commit();
+        if (row.kind !== 'action')
             return;
-        }
-        const field = FIELDS[index];
-        if (!field || key.ctrl || key.meta)
+        if (row.action === 'retain')
+            dispatch({ type: 'retain-key' });
+        if (row.action === 'test')
+            props.onTest?.();
+        if (row.action === 'discover')
+            props.onDiscover?.();
+        if (row.action === 'apply')
+            commit();
+        if (row.action === 'cancel')
+            dispatch({ type: 'cancel-editor' });
+    }
+    function editField(row, input, key) {
+        if (row.kind !== 'field')
             return;
+        const field = row.field;
         if (field === 'provider' || field === 'credentialMode') {
             if (!key.leftArrow && !key.rightArrow)
                 return;
@@ -75,45 +68,101 @@ function useEditorInput(props, navigation) {
             registerSecret(value);
         if (key.backspace || key.delete || text)
             dispatch({ type: 'editor-field', field, value });
+    }
+    useInput((input, key) => {
+        if (props.isActive === false)
+            return;
+        // Accelerators work on EVERY row (§3.3): the action rows are the primary entry,
+        // these are only the shortcut. Both keys are unused by `App`'s global branch.
+        if (key.ctrl && input === 'r') {
+            props.onTest?.();
+            return;
+        }
+        if (key.ctrl && input === 'f') {
+            props.onDiscover?.();
+            return;
+        }
+        if (key.escape) {
+            // THREE-LEVEL Esc (§3.4): a probe in flight is cancelled first and the draft
+            // survives; only the second press discards the form.
+            if (props.probeBusy) {
+                props.onCancelProbe?.();
+                return;
+            }
+            dispatch({ type: 'cancel-editor' });
+            return;
+        }
+        if (key.upArrow || (key.tab && key.shift)) {
+            setIndex((index - 1 + count) % count);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setIndex((index + 1) % count);
+            return;
+        }
+        if (key.return) {
+            activate(focusable[index]);
+            return;
+        }
+        if (key.ctrl || key.meta)
+            return;
+        const row = focusable[index];
+        if (row)
+            editField(row, input, key);
     });
 }
-function buildEditorRows(props, navigation) {
-    const { editor } = props;
-    const { index, retain } = navigation;
+function rowColor(props, row) {
+    if (row.kind === 'result') {
+        return row.tone === 'ok' ? props.theme.toolDone
+            : row.tone === 'fail' ? props.theme.noticeError : props.theme.muted;
+    }
+    return undefined;
+}
+function buildRows(props, focus) {
     const glyphs = pickGlyphs(props.caps);
-    const values = FIELDS.map((field) => {
-        if (field === 'apiKey')
-            return editor.credentialMode === 'replace'
-                ? editor.apiKey ? 'Configured (replacement)' : '(type replacement)'
-                : editor.credentialMode === 'keep' ? 'Configured (unchanged)' : 'Shared / environment';
-        if (field === 'credentialMode')
-            return editor.credentialMode;
-        // `(auto)` EXPLICITLY, or an empty window field would fall through to
-        // `(required)` - and AUTO is this field's natural state, never a gap.
-        return editor[field] || (field === 'name' ? '(defaults to model)'
-            : field === 'contextWindow' ? '(auto)' : field === 'baseUrl'
-                ? '(provider default)' : '(required)');
+    const focused = focus.focusable[focus.index];
+    return focus.rows.map((row, at) => {
+        if (row.kind === 'note') {
+            return _jsx(Text, { wrap: "truncate", color: props.theme.muted, children: row.label }, at);
+        }
+        if (row.kind === 'result') {
+            return _jsx(Text, { wrap: "truncate", color: rowColor(props, row), children: row.label }, at);
+        }
+        const line = row.value.length > 0 ? `${row.label.padEnd(18)}${row.value}` : row.label;
+        const isFocused = row === focused;
+        return _jsxs(Text, { wrap: "truncate", color: isFocused ? props.theme.accent : props.theme.muted, children: [isFocused ? `${glyphs.caret} ` : '  ', line] }, at);
     });
-    const lines = LABELS.map((label, at) => `${label.padEnd(18)}${values[at]}`);
-    if (retain)
-        lines.push('Retain key for new endpoint');
-    lines.push('Apply to settings draft', 'Cancel editing');
-    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(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: ["Target: ", editor.provider, " ", profileEndpointSummary(editor.baseUrl)] }, "target"));
-    // HONESTY FOR THE FAST-ONLY ENTRY (§6.5): a window saved on a profile that
-    // only ever serves the Fast role does not take effect today, and saying so
-    // beats letting the user believe it does.
-    if (props.users === 'Fast') {
-        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: "Window applies when this profile is bound as Main." }, "window-scope"));
-    }
-    return rows;
 }
-/** Replacement key input starts empty; retention across targets is explicit. */
+function editorHint(props) {
+    if (props.probeBusy)
+        return 'Esc cancel the probe | draft is kept';
+    return 'Enter apply to draft | Ctrl+R test | Ctrl+F discover | Esc cancel';
+}
+/**
+ * The profile form. Row semantics come from `editorRows()` - never from index
+ * arithmetic - so `apiKey` stays at index 6 and the two probe actions sit at the end
+ * of the action block, after `retain` (P0-1 / I-4).
+ */
 export function ModelProfileEditor(props) {
     const [index, setIndex] = useState(0);
-    const retain = props.editor.endpointChanged && Boolean(props.editor.original.apiKey);
-    const navigation = { index, setIndex, retain, count: FIELDS.length + (retain ? 1 : 0) + 2 };
-    const offset = useProfileScroll(props, index);
-    useEditorInput(props, navigation);
-    return _jsx(OverlayFrame, { ...props, rows: buildEditorRows(props, navigation), scrollOffset: offset, title: props.error ?? `Edit profile${props.users ? ` | Used by ${props.users}` : ''}`, hint: "Enter apply to draft | Esc cancel" });
+    const editor = props.editor;
+    const retain = editor.endpointChanged && Boolean(editor.original.apiKey);
+    const probe = props.probeView ?? { kind: 'idle', reason: 'unavailable' };
+    const target = props.probeTarget ?? editorProbeTarget(editor, {});
+    const rows = editorRows({ editor, retain, probe, target, fastOnly: props.users === 'Fast' });
+    const focusable = focusableRows(rows);
+    const count = Math.max(1, focusable.length);
+    const clamped = Math.min(index, count - 1);
+    // The result rows sit BELOW the action block, so following the focused row alone
+    // would leave the verdict off-screen right after the user asked for it (§4.9 / AC-21).
+    // How many action rows there are comes from the row model, never from a constant: a
+    // sixth action would otherwise move this window boundary onto a FIELD row.
+    const actionRows = focusable.filter((row) => row.kind === 'action').length;
+    const results = resultRowCount(rows);
+    const inActions = clamped >= count - actionRows;
+    const viewFocus = results > 0 && inActions ? Math.max(clamped, rows.length - 1) : clamped;
+    const offset = useProfileScroll(props, viewFocus);
+    useEditorInput(props, { index: clamped, setIndex, count, rows, focusable });
+    return _jsx(OverlayFrame, { ...props, rows: buildRows(props, { index: clamped, setIndex, count,
+            rows, focusable }), scrollOffset: offset, title: props.error ?? `Edit profile${props.users ? ` | Used by ${props.users}` : ''}`, hint: editorHint(props) });
 }

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;
@@ -113,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

@@ -21,6 +21,9 @@ 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 { 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).
@@ -35,6 +38,9 @@ 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'];
@@ -527,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;
@@ -553,7 +568,7 @@ function useProfileSettingsState(props) {
     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;
@@ -733,6 +748,19 @@ function renderSettingsConfirmation(props, view) {
     }
     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
@@ -753,7 +781,11 @@ function fastTierUnavailable(props, view) {
 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, draftSubagentProfileId(state.draft)), 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.

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;