@aragon-agent/cli 0.6.23 → 0.6.25

package/dist/ui/overlays/model-probe-view.js

@@ -0,0 +1,225 @@
+/**
+ * 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 { PROBE_LIMITS } from '../../agent/model-probe-limits.js';
+import { resolveDraftKey } from '../../agent/model-probe.js';
+import { profileEndpointSummary } from './ModelProfilePicker.js';
+export const EDITOR_FIELDS = ['name', 'provider', 'model', 'contextWindow', 'baseUrl',
+    'credentialMode', 'apiKey'];
+export const EDITOR_LABELS = ['Name', 'Provider', 'Model', 'Context window', 'Base URL',
+    'Credential mode', 'API key'];
+function idleView(hasKey) {
+    return { kind: 'idle', reason: hasKey ? 'no_result' : 'no_key' };
+}
+function hasKey(target) {
+    return Boolean(target.apiKey && target.apiKey.trim().length > 0);
+}
+/** Whether pressing a probe action can produce anything at all (AC-12 / AC-15). */
+export function canProbe(view) {
+    return !(view.kind === 'idle' && (view.reason === 'no_key' || view.reason === 'unavailable'));
+}
+function testView(test, target, probe) {
+    if (!probe)
+        return { kind: 'idle', reason: 'unavailable' };
+    if (test.phase === 'testing') {
+        return test.targetId === probe.targetFingerprint(target)
+            ? { kind: 'testing' } : idleView(hasKey(target));
+    }
+    if (test.phase === 'tested') {
+        return test.outcome.targetId === probe.targetFingerprint(target)
+            ? { kind: 'result', outcome: test.outcome } : idleView(hasKey(target));
+    }
+    return idleView(hasKey(target));
+}
+function discoveryView(state, target, probe) {
+    if (!probe)
+        return { kind: 'idle' };
+    if (state.phase === 'discovering') {
+        return state.connectionId === probe.connectionFingerprint(target) ? { kind: 'discovering' }
+            : { kind: 'idle' };
+    }
+    if (state.phase === 'discovered') {
+        return state.outcome.connectionId === probe.connectionFingerprint(target)
+            ? { kind: 'discovery', outcome: state.outcome } : { kind: 'idle' };
+    }
+    return { kind: 'idle' };
+}
+/**
+ * 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 function visibleProbeViews(test, discovery, target, probe) {
+    return { test: testView(test, target, probe), discovery: discoveryView(discovery, target, probe) };
+}
+/** The exact target a draft would use - the resolved key included (§4.2.1). */
+export function editorProbeTarget(editor, apiKeys) {
+    return {
+        provider: editor.provider,
+        model: editor.model,
+        baseUrl: editor.baseUrl.trim().length > 0 ? editor.baseUrl.trim() : null,
+        apiKey: resolveDraftKey({ credentialMode: editor.credentialMode, draftKey: editor.apiKey,
+            existingKey: editor.original.apiKey, sharedKey: apiKeys[editor.provider] }),
+    };
+}
+/** `812 ms` / `1.4 s` - one decimal only once a second has passed. */
+export function latencyLabel(ms) {
+    const safe = Number.isFinite(ms) && ms >= 0 ? ms : 0;
+    return safe < 1000 ? `${Math.round(safe)} ms` : `${(safe / 1000).toFixed(1)} s`;
+}
+/** `128K` / `1M` / `auto` - `auto` when the vendor did not report a window. */
+export function windowLabel(window) {
+    if (!window || !Number.isFinite(window))
+        return 'auto';
+    if (window >= 1_000_000) {
+        const millions = window / 1_000_000;
+        return `${Number.isInteger(millions) ? millions : millions.toFixed(1)}M`;
+    }
+    if (window >= 1000)
+        return `${Math.round(window / 1000)}K`;
+    return String(Math.round(window));
+}
+/**
+ * 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 function rankCandidates(models, currentModel) {
+    const seen = new Set();
+    const unique = [];
+    for (const model of models) {
+        if (model.id.length === 0 || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        unique.push(model);
+    }
+    const wanted = currentModel.trim().toLowerCase();
+    if (wanted.length === 0)
+        return unique;
+    const matches = (model) => model.id.toLowerCase() === wanted;
+    const prefixed = (model) => model.id.toLowerCase().startsWith(wanted);
+    return [...unique.filter(matches), ...unique.filter((model) => !matches(model) && prefixed(model)),
+        ...unique.filter((model) => !matches(model) && !prefixed(model))];
+}
+function usagePart(outcome) {
+    if (!outcome.usage)
+        return '';
+    return ` | ${outcome.usage.inputTokens} in / ${outcome.usage.outputTokens} out`;
+}
+function fixLine(outcome) {
+    if (outcome.kind === 'auth')
+        return 'Fix: edit API key, or set Credential mode to Shared.';
+    if (outcome.kind !== 'model_not_found')
+        return undefined;
+    const reach = outcome.availableModels;
+    return `Fix: choose Discover models.${reach === undefined ? ''
+        : ` This key can reach ${reach} models.`}`;
+}
+function resultLines(outcome, target) {
+    const name = `${target.provider}:${target.model.trim()}`;
+    if (outcome.ok) {
+        const head = `Last test: ${name} OK in ${latencyLabel(outcome.latencyMs)}${usagePart(outcome)}`;
+        const reply = outcome.reply ? `Reply: "${outcome.reply}"` : undefined;
+        const reach = outcome.reply || outcome.availableModels === undefined ? undefined
+            : `This key can reach ${outcome.availableModels} models.`;
+        const second = reply ?? reach;
+        return second ? [head, second] : [head];
+    }
+    const head = `Last test: FAILED - ${outcome.detail ?? 'The connection test failed.'}`;
+    const fix = fixLine(outcome);
+    return fix ? [head, fix] : [head];
+}
+/** At most TWO rows: the verdict, then what to do about it (§3.1 / D-11). */
+export function probeLines(view, target) {
+    if (view.kind === 'result')
+        return resultLines(view.outcome, target).slice(0, 2);
+    if (view.kind === 'idle') {
+        if (view.reason === 'unavailable')
+            return ['Connection test is unavailable in this session.'];
+        if (view.reason === 'no_key')
+            return ['No key yet: set API key, or use Credential mode Shared.'];
+        return ['Not tested for this profile yet.'];
+    }
+    return [];
+}
+/** Colour for the result rows; the status WORDS carry the meaning without colour. */
+export function probeTone(view) {
+    if (view.kind !== 'result')
+        return 'muted';
+    return view.outcome.ok ? 'ok' : 'fail';
+}
+function fieldValue(editor, field) {
+    if (field === 'apiKey') {
+        if (editor.credentialMode === 'replace') {
+            return editor.apiKey ? 'Configured (replacement)' : '(type replacement)';
+        }
+        return editor.credentialMode === 'keep' ? 'Configured (unchanged)' : 'Shared / environment';
+    }
+    if (field === 'credentialMode')
+        return editor.credentialMode;
+    return editor[field] || (field === 'name' ? '(defaults to model)'
+        : field === 'contextWindow' ? '(auto)' : field === 'baseUrl'
+            ? '(provider default)' : '(required)');
+}
+function actionValue(action, view) {
+    if (action === 'retain' || action === 'apply' || action === 'cancel')
+        return '';
+    if (view.kind === 'idle' && view.reason === 'unavailable')
+        return '(unavailable)';
+    if (view.kind === 'idle' && view.reason === 'no_key')
+        return '(no key)';
+    if (action === 'test' && view.kind === 'testing')
+        return 'testing...';
+    return action === 'test' ? 'Enter or Ctrl+R' : 'Enter or Ctrl+F';
+}
+function actionRow(action, label, view) {
+    return { kind: 'action', action, label, value: actionValue(action, view) };
+}
+/** THE single source of the editor's rows - fields, actions, notes AND results. */
+export function editorRows(input) {
+    const { editor, retain, probe, target } = input;
+    const rows = EDITOR_FIELDS.map((field, at) => ({ kind: 'field', field,
+        label: EDITOR_LABELS[at], value: fieldValue(editor, field) }));
+    if (retain)
+        rows.push(actionRow('retain', 'Retain key for new endpoint', probe));
+    rows.push(actionRow('test', 'Test connection', probe), actionRow('discover', 'Discover models', probe), actionRow('apply', 'Apply to settings draft', probe), actionRow('cancel', 'Cancel editing', probe));
+    rows.push({ kind: 'note', muted: true,
+        label: `Target: ${editor.provider} ${profileEndpointSummary(editor.baseUrl)}` });
+    if (input.fastOnly) {
+        rows.push({ kind: 'note', muted: true,
+            label: 'Window applies when this profile is bound as Main.' });
+    }
+    const tone = probeTone(probe);
+    for (const line of probeLines(probe, target)) {
+        rows.push({ kind: 'result', label: line, tone });
+    }
+    return rows;
+}
+/** Rows the cursor can land on; index arithmetic now derives from the row model. */
+export function isFocusable(row) {
+    return row.kind === 'field' || row.kind === 'action';
+}
+/** The focusable rows, in order - the index space `useProfileScroll` follows. */
+export function focusableRows(rows) {
+    return rows.filter(isFocusable);
+}
+/** Result rows currently on screen, so the viewport can be widened to include them. */
+export function resultRowCount(rows) {
+    return rows.filter((row) => row.kind === 'result').length;
+}
+/** Longest id shown in one list row, inside the 40-column budget. */
+export const LIST_ID_CHARS = 28;
+/** A model's one-line name, bounded by `maxNameChars`. */
+export function clipName(name) {
+    const points = [...name];
+    return points.length <= PROBE_LIMITS.maxNameChars ? name
+        : `${points.slice(0, PROBE_LIMITS.maxNameChars - 3).join('')}...`;
+}

package/dist/ui/overlays/model-profile-state.d.ts

@@ -1,11 +1,25 @@
 import { type ModelProfile, type ModelProfilesConfig, type ModelRole } from '../../config/model-profiles.js';
 import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'delete-confirm' | 'discard-confirm';
+import type { SubagentModelMode } from '../../team/model.js';
+export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm';
+/**
+ * Which role a PROFILE PICKER page is choosing for.
+ *
+ * `'subagent'` is a PICKER-ONLY role (subagent-model 6.2): `ModelRole` stays
+ * `'main' | 'fast'` because it is the type basis of the config layer's
+ * `${role}Id` template keys - widening it would invent a `subagentId` library
+ * key nothing reads. The subagent picker writes `draft.patch.team` instead.
+ */
+export type ProfilePickerRole = ModelRole | 'subagent';
+/** The picker's built-in `Fast tier model` row; never a profile id on disk. */
+export declare const SUBAGENT_FAST_ROW_ID = "__fast__";
 export interface ProfileEditorDraft {
     original: ModelProfile;
     name: string;
     provider: string;
     model: string;
+    /** Text exactly as typed; `''` renders `(auto)` and parses to AUTO (§6.5). */
+    contextWindow: string;
     baseUrl: string;
     credentialMode: 'keep' | 'replace' | 'shared';
     apiKey: string;
@@ -14,21 +28,23 @@ export interface ProfileEditorDraft {
 export interface ModelProfileState {
     draft: ModelSettingsDraft;
     page: ProfilePage;
-    role: ModelRole;
+    role: ProfilePickerRole;
     editor?: ProfileEditorDraft;
     returnPage: 'picker' | 'manager';
     bindNew: boolean;
     dirty: boolean;
     error?: string;
     deleteId?: string;
+    /** Who referenced the entry being deleted ('Main + Subagent', or ''). */
+    deleteUsers?: string;
 }
 export type ModelProfileAction = {
     type: 'page';
     page: ProfilePage;
-    role?: ModelRole;
+    role?: ProfilePickerRole;
 } | {
     type: 'select';
-    role: ModelRole;
+    role: ProfilePickerRole;
     id: string | null;
 } | {
     type: 'edit';
@@ -44,6 +60,14 @@ export type ModelProfileAction = {
     type: 'merge-editor';
 } | {
     type: 'cancel-editor';
+}
+/**
+ * The ONE write path for a discovered model (§6.3 / D-2 / D-3): only `model`
+ * changes - never the credential, never the context window, never the draft.
+ */
+ | {
+    type: 'choose-model';
+    model: string;
 } | {
     type: 'duplicate';
     id: string;
@@ -67,7 +91,40 @@ export declare function finishProfileEditor(editor: ProfileEditorDraft): {
 /** Make an isolated root draft; opening the screen never mutates live config. */
 export declare function createModelProfileState(draft: ModelSettingsDraft): ModelProfileState;
 /** Describe references using text so ASCII and no-color modes remain usable. */
-export declare function profileUsers(profiles: ModelProfilesConfig | undefined, id: string): string;
+export declare function profileUsers(profiles: ModelProfilesConfig | undefined, id: string, subagentProfileId?: string | null): string;
+/**
+ * The team section a draft would save: the patch first, then the disk baseline
+ * (subagent-model §3.6). The explicit-`undefined` test is what makes an
+ * explicit `null` in the patch win over the baseline - `??` would fold it away.
+ */
+export declare function draftTeam(draft: ModelSettingsDraft): {
+    model: SubagentModelMode;
+    modelProfileId: string | null;
+};
+/** The profile id the draft's team section binds, for reference checks (3.7). */
+export declare function draftSubagentProfileId(draft: ModelSettingsDraft): string | null;
+/** The projected picker selection for the subagent role (6.2). */
+export declare function subagentSelectedId(draft: ModelSettingsDraft): string | null;
+/** What the settings root row and `/team model` show for the current mode. */
+export interface SubagentModelSummaryInput {
+    mode: SubagentModelMode;
+    modelProfileId: string | null;
+    /** `<provider>:<model>` of the connection the main role runs on. */
+    mainConnection: string;
+    /** The fast tier's `<provider>:<model>`, or null when it does not resolve. */
+    fastConnection: string | null;
+    profiles: ModelProfilesConfig | undefined;
+    /**
+     * KEY EXISTENCE AS THE SETTINGS SCREEN SEES IT (V-10): derived from the
+     * config-file keys, exactly like the `name()` row and `fastTierLine` beside
+     * it. A key that exists ONLY as an environment variable is invisible here,
+     * so an env-key user may see `(off ...)` / `[Missing API key]` where the
+     * runtime would succeed - the accepted approximation both sibling lines
+     * already ship.
+     */
+    hasKey: (providerId: string) => boolean;
+}
+export declare function subagentModelSummary(input: SubagentModelSummaryInput): string;
 /** Adopt persisted fields only, resolving the old fast inheritance once. */
 export declare function createCustomProfile(draft: ModelSettingsDraft, role: ModelRole): ModelProfile;
 /** All child actions modify only the root draft; persistence belongs to Save. */

package/dist/ui/overlays/model-profile-state.js

@@ -1,17 +1,29 @@
 import { randomUUID } from 'node:crypto';
 import { emptyModelProfiles, duplicateModelProfile, normalizeModelProfiles, validateModelProfiles } from '../../config/model-profiles.js';
+import { parseContextWindowInput } from '../../config/schema.js';
+/** The picker's built-in `Fast tier model` row; never a profile id on disk. */
+export const SUBAGENT_FAST_ROW_ID = '__fast__';
 /** Keep the original secret separate from the empty replacement field. */
 export function createProfileEditor(profile) {
     return { original: { ...profile }, name: profile.name, provider: profile.provider,
         model: profile.model, baseUrl: profile.baseUrl ?? '', apiKey: '',
+        contextWindow: profile.contextWindow === null ? '' : String(profile.contextWindow),
         credentialMode: profile.apiKey ? 'keep' : 'shared', endpointChanged: false };
 }
 /** Validate locally before merging the child form into the root transaction. */
 export function finishProfileEditor(editor) {
+    // STRICT IN THE UI, TOLERANT ON DISK (§6.5 / invariant 4): a typo is refused
+    // here with an inline error and the focus jump its `field` enables; it never
+    // reaches the draft. The message prefix matches the editor's LABELS row.
+    const window = parseContextWindowInput(editor.contextWindow);
+    if (window.kind === 'invalid') {
+        return { error: 'Context window: use a number or auto.', field: 'contextWindow' };
+    }
     const profile = { id: editor.original.id, name: editor.name.trim(),
         provider: editor.provider, model: editor.model.trim(), baseUrl: editor.baseUrl.trim() || null,
         apiKey: editor.credentialMode === 'keep' ? editor.original.apiKey
-            : editor.credentialMode === 'replace' ? editor.apiKey.trim() : null };
+            : editor.credentialMode === 'replace' ? editor.apiKey.trim() : null,
+        contextWindow: window.kind === 'auto' ? null : window.value };
     const library = { ...emptyModelProfiles(), entries: [profile] };
     const issue = validateModelProfiles(library)[0];
     if (issue)
@@ -30,10 +42,52 @@ export function createModelProfileState(draft) {
         bindNew: false, dirty: false };
 }
 /** Describe references using text so ASCII and no-color modes remain usable. */
-export function profileUsers(profiles, id) {
-    return [profiles?.mainId === id ? 'Main' : '', profiles?.fastId === id ? 'Fast' : '']
+export function profileUsers(profiles, id, subagentProfileId) {
+    return [profiles?.mainId === id ? 'Main' : '', profiles?.fastId === id ? 'Fast' : '',
+        subagentProfileId === id ? 'Subagent' : '']
         .filter(Boolean).join(' + ');
 }
+/**
+ * The team section a draft would save: the patch first, then the disk baseline
+ * (subagent-model §3.6). The explicit-`undefined` test is what makes an
+ * explicit `null` in the patch win over the baseline - `??` would fold it away.
+ */
+export function draftTeam(draft) {
+    const patch = draft.patch.team;
+    const baseline = draft.baseline.team;
+    return {
+        model: patch?.model !== undefined ? patch.model : baseline?.model ?? 'main',
+        modelProfileId: patch?.modelProfileId !== undefined ? patch.modelProfileId
+            : baseline?.modelProfileId ?? null,
+    };
+}
+/** The profile id the draft's team section binds, for reference checks (3.7). */
+export function draftSubagentProfileId(draft) {
+    return draftTeam(draft).model === 'profile' ? draftTeam(draft).modelProfileId : null;
+}
+/** The projected picker selection for the subagent role (6.2). */
+export function subagentSelectedId(draft) {
+    const team = draftTeam(draft);
+    if (team.model === 'profile')
+        return team.modelProfileId;
+    return team.model === 'fast' ? SUBAGENT_FAST_ROW_ID : null;
+}
+export function subagentModelSummary(input) {
+    if (input.mode === 'main')
+        return `Same as main (${input.mainConnection})`;
+    if (input.mode === 'fast') {
+        return input.fastConnection
+            ? `Fast tier (${input.fastConnection})`
+            : 'Fast tier (off - falls back to main)';
+    }
+    const entry = input.modelProfileId
+        ? input.profiles?.entries.find((candidate) => candidate.id === input.modelProfileId)
+        : undefined;
+    if (!entry)
+        return 'Profile missing - falls back to main';
+    const missing = !entry.apiKey && !input.hasKey(entry.provider);
+    return `${entry.name}  ${entry.provider}:${entry.model}${missing ? ' [Missing API key]' : ''}`;
+}
 /** Adopt persisted fields only, resolving the old fast inheritance once. */
 export function createCustomProfile(draft, role) {
     const file = draft.baseline;
@@ -45,7 +99,11 @@ export function createCustomProfile(draft, role) {
             || (provider === (file.provider || 'anthropic') ? file.baseUrl : null)
             : file.baseUrl) || null;
     return { id: randomUUID(), name: '', provider, model, baseUrl,
-        apiKey: role === 'fast' && !model ? null : file.apiKeys?.[provider] || null };
+        apiKey: role === 'fast' && !model ? null : file.apiKeys?.[provider] || null,
+        // Carry the user's existing top-level correction into the first profile
+        // (§6.5): binding an AUTO profile would otherwise silently retire it
+        // (tradeoff B's migration risk, mitigated exactly here).
+        contextWindow: file.contextWindow ?? null };
 }
 function editField(state, action) {
     if (!state.editor)
@@ -85,9 +143,24 @@ export function modelProfileReducer(state, action) {
         case 'reload': return createModelProfileState(action.draft);
         case 'page': return { ...state, page: action.page, role: action.role ?? state.role,
             error: undefined };
-        case 'select': return { ...state, page: 'root', dirty: true, error: undefined,
-            draft: { ...state.draft, profiles: { ...library, [`${action.role}Id`]: action.id },
-                activateRoles: [...new Set([...state.draft.activateRoles, action.role])] } };
+        case 'select': {
+            // THE SUBAGENT BRANCH (D-5): selection writes the DRAFT's team patch -
+            // `profiles` and `activateRoles` are untouched, because 'subagent' is a
+            // picker-only role with no `${role}Id` library key (6.2). Save is the
+            // one place the patch ever reaches disk (I-5).
+            if (action.role === 'subagent') {
+                const team = action.id === null
+                    ? { model: 'main', modelProfileId: null }
+                    : action.id === SUBAGENT_FAST_ROW_ID
+                        ? { model: 'fast', modelProfileId: null }
+                        : { model: 'profile', modelProfileId: action.id };
+                return { ...state, page: 'root', dirty: true, error: undefined,
+                    draft: { ...state.draft, patch: { ...state.draft.patch, team } } };
+            }
+            return { ...state, page: 'root', dirty: true, error: undefined,
+                draft: { ...state.draft, profiles: { ...library, [`${action.role}Id`]: action.id },
+                    activateRoles: [...new Set([...state.draft.activateRoles, action.role])] } };
+        }
         case 'edit': return { ...state, editor: createProfileEditor(action.profile), page: 'editor',
             returnPage: state.page === 'picker' ? 'picker' : 'manager',
             bindNew: action.bindNew ?? false, error: undefined };
@@ -95,6 +168,16 @@ export function modelProfileReducer(state, action) {
         case 'retain-key': return state.editor?.original.apiKey ? { ...state,
             editor: { ...state.editor, credentialMode: 'keep', apiKey: '' } } : state;
         case 'merge-editor': return mergeEditor(state);
+        case 'choose-model': {
+            // Legal ONLY from the list page (§7). `editor-field` would do the same thing,
+            // but routing the list page through the generic field action would also let a
+            // future `editField` side effect (key reset, endpoint flag) fire on a choice
+            // that never touched the endpoint.
+            if (!state.editor || state.page !== 'models')
+                return state;
+            return { ...state, page: 'editor', error: undefined,
+                editor: { ...state.editor, model: action.model } };
+        }
         case 'cancel-editor': return { ...state, editor: undefined, page: state.returnPage,
             error: undefined };
         case 'duplicate': {
@@ -107,13 +190,37 @@ export function modelProfileReducer(state, action) {
                 : state;
         }
         case 'delete': {
-            const users = profileUsers(library, action.id);
-            return users ? { ...state, error: `Used by ${users}. Select another profile first.` }
-                : { ...state, page: 'delete-confirm', deleteId: action.id, error: undefined };
+            // UNBIND-AND-DELETE (D-6): being referenced no longer refuses the flow.
+            // The references - subagent included - are computed here, shown on the
+            // confirm page, and cleared by `confirm-delete` inside the draft.
+            const users = profileUsers(library, action.id, draftSubagentProfileId(state.draft));
+            return { ...state, page: 'delete-confirm', deleteId: action.id,
+                deleteUsers: users, error: undefined };
+        }
+        case 'confirm-delete': {
+            const id = state.deleteId;
+            if (!id)
+                return state;
+            // THE DRAFT-SIDE UNBIND: Main/Fast bindings pointing at the entry are
+            // nulled here (not refused) and the subagent binding resets to main
+            // when it named THIS entry. `removeModelProfile`'s throw stays as the
+            // bottom-line defense - the UI has already unbound, so it cannot fire
+            // on this path.
+            const profiles = {
+                ...library,
+                mainId: library.mainId === id ? null : library.mainId,
+                fastId: library.fastId === id ? null : library.fastId,
+                entries: library.entries.filter((entry) => entry.id !== id),
+            };
+            const teamReset = draftSubagentProfileId(state.draft) === id
+                ? { team: { model: 'main', modelProfileId: null } }
+                : {};
+            return { ...state, page: 'manager', dirty: true,
+                draft: { ...state.draft, profiles,
+                    patch: { ...state.draft.patch, ...teamReset } },
+                deleteId: undefined, deleteUsers: undefined,
+                // No orphan editor for a deleted entry (3.7).
+                editor: state.editor?.original.id === id ? undefined : state.editor };
         }
-        case 'confirm-delete': return { ...state, page: 'manager', dirty: true,
-            draft: { ...state.draft, profiles: { ...library,
-                    entries: library.entries.filter((entry) => entry.id !== state.deleteId) } },
-            deleteId: undefined };
     }
 }

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

@@ -0,0 +1,30 @@
+/**
+ * The probe task hook (model-profile-connection-test §6.2).
+ *
+ * IT LIVES IN `SettingsScreen`, ONCE, AND NOWHERE ELSE. The editor unmounts whenever
+ * the page changes (`SettingsScreen` renders it only for `page === 'editor'`), so a
+ * hook inside the editor would abort its own discovery the moment `Discover models`
+ * switched to the list page - the feature cancelling itself.
+ *
+ * TWO SLOTS, ONE IN FLIGHT. A test verdict and a discovered list answer different
+ * questions, so they are stored separately: opening the list must not erase a verdict
+ * the user still wants to read when they press Esc back (AC-27). Starting either task
+ * aborts whatever is running - one request at a time.
+ *
+ * `test()` AND `discover()` NEVER REJECT. The only callers are Ink input handlers,
+ * which have nowhere to await a `catch`; the hook folds every exception into an
+ * `unknown` failure so no frame can be left on `testing` forever.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import type { ModelProbe, ProbeTarget } from '../../agent/model-probe.js';
+import type { ProbeDiscoveryPhase, ProbeTestPhase } from './model-probe-view.js';
+export interface ModelProbeTasks {
+    test: ProbeTestPhase;
+    discovery: ProbeDiscoveryPhase;
+    busy: boolean;
+    startTest(target: ProbeTarget): void;
+    startDiscovery(target: ProbeTarget): void;
+    cancel(): void;
+}
+export declare function useModelProbe(probe?: ModelProbe): ModelProbeTasks;

package/dist/ui/overlays/use-model-probe.js

@@ -0,0 +1,109 @@
+/**
+ * The probe task hook (model-profile-connection-test §6.2).
+ *
+ * IT LIVES IN `SettingsScreen`, ONCE, AND NOWHERE ELSE. The editor unmounts whenever
+ * the page changes (`SettingsScreen` renders it only for `page === 'editor'`), so a
+ * hook inside the editor would abort its own discovery the moment `Discover models`
+ * switched to the list page - the feature cancelling itself.
+ *
+ * TWO SLOTS, ONE IN FLIGHT. A test verdict and a discovered list answer different
+ * questions, so they are stored separately: opening the list must not erase a verdict
+ * the user still wants to read when they press Esc back (AC-27). Starting either task
+ * aborts whatever is running - one request at a time.
+ *
+ * `test()` AND `discover()` NEVER REJECT. The only callers are Ink input handlers,
+ * which have nowhere to await a `catch`; the hook folds every exception into an
+ * `unknown` failure so no frame can be left on `testing` forever.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+const TEST_FAILED_DETAIL = 'The connection test could not run.';
+const DISCOVERY_FAILED_DETAIL = 'The model list could not be fetched.';
+function unknownTest(targetId) {
+    return { ok: false, targetId, latencyMs: 0, kind: 'unknown', detail: TEST_FAILED_DETAIL };
+}
+function unknownDiscovery(connectionId) {
+    return { ok: false, connectionId, kind: 'unknown', detail: DISCOVERY_FAILED_DETAIL,
+        models: [], truncated: false, total: 0 };
+}
+/** Run one probe, guaranteeing the promise settles and no rejection escapes. */
+function settle(work, onValue, onFailure) {
+    let pending;
+    try {
+        pending = work();
+    }
+    catch {
+        onFailure();
+        return;
+    }
+    void pending.then(onValue, onFailure);
+}
+export function useModelProbe(probe) {
+    const [test, setTest] = useState({ phase: 'idle' });
+    const [discovery, setDiscovery] = useState({ phase: 'idle' });
+    const controller = useRef(null);
+    const inFlight = useRef(null);
+    const abortCurrent = useCallback(() => {
+        controller.current?.abort();
+        controller.current = null;
+        inFlight.current = null;
+    }, []);
+    useEffect(() => abortCurrent, [abortCurrent]);
+    const begin = useCallback((kind) => {
+        abortCurrent();
+        const next = new AbortController();
+        controller.current = next;
+        inFlight.current = kind;
+        return next;
+    }, [abortCurrent]);
+    /**
+     * Land one run's result and drop the in-flight refs with it.
+     *
+     * Clearing them here is what keeps `cancel()` honest: it is the ONLY caller of
+     * `abortCurrent`, and an Escape on a settled slot (a frame where `busy` is stale)
+     * must not erase a verdict the user is still reading.
+     */
+    const finish = useCallback((run, commit) => {
+        if (run.signal.aborted)
+            return;
+        controller.current = null;
+        inFlight.current = null;
+        commit();
+    }, []);
+    const startTest = useCallback((target) => {
+        if (!probe)
+            return;
+        const run = begin('test');
+        const targetId = probe.targetFingerprint(target);
+        setTest({ phase: 'testing', targetId });
+        settle(() => probe.test({ ...target, signal: run.signal }), (outcome) => {
+            finish(run, () => setTest({ phase: 'tested', outcome }));
+        }, () => {
+            finish(run, () => setTest({ phase: 'tested', outcome: unknownTest(targetId) }));
+        });
+    }, [probe, begin, finish]);
+    const startDiscovery = useCallback((target) => {
+        if (!probe)
+            return;
+        const run = begin('discovery');
+        const connectionId = probe.connectionFingerprint(target);
+        setDiscovery({ phase: 'discovering', connectionId });
+        settle(() => probe.discover({ ...target, signal: run.signal }), (outcome) => {
+            finish(run, () => setDiscovery({ phase: 'discovered', outcome }));
+        }, () => {
+            finish(run, () => setDiscovery({ phase: 'discovered',
+                outcome: unknownDiscovery(connectionId) }));
+        });
+    }, [probe, begin, finish]);
+    const cancel = useCallback(() => {
+        const kind = inFlight.current;
+        abortCurrent();
+        if (kind === 'test')
+            setTest({ phase: 'idle' });
+        if (kind === 'discovery')
+            setDiscovery({ phase: 'idle' });
+    }, [abortCurrent]);
+    const busy = test.phase === 'testing' || discovery.phase === 'discovering';
+    return { test, discovery, busy, startTest, startDiscovery, cancel };
+}