@kinqs/brainrouter-cli 0.3.5 → 0.3.7

package/dist/cli/theme.js

@@ -0,0 +1,106 @@
+import chalk from 'chalk';
+import { readPreferences } from '../state/preferencesStore.js';
+const identity = ((s) => s);
+function buildDark() {
+    return {
+        mode: 'dark',
+        primary: chalk.hex('#CC9166'),
+        secondary: chalk.magenta,
+        success: chalk.green,
+        warning: chalk.yellow,
+        danger: chalk.red,
+        info: chalk.cyan,
+        muted: chalk.gray,
+        dim: chalk.hex('#666666'),
+        heading: chalk.bold.hex('#CC9166'),
+        plain: identity,
+    };
+}
+function buildLight() {
+    return {
+        mode: 'light',
+        // Saturated orange-brown — still readable on white because chalk emits
+        // a TrueColor sequence the terminal renders as-is.
+        primary: chalk.hex('#A24E1F'),
+        secondary: chalk.hex('#7B2CBF'),
+        success: chalk.hex('#0F7B3E'),
+        warning: chalk.hex('#8A6300'),
+        danger: chalk.hex('#A4161A'),
+        info: chalk.hex('#005F8C'),
+        muted: chalk.hex('#4A4A4A'),
+        dim: chalk.hex('#7A7A7A'),
+        heading: chalk.bold.hex('#A24E1F'),
+        plain: identity,
+    };
+}
+function buildMono() {
+    return {
+        mode: 'mono',
+        primary: identity,
+        secondary: identity,
+        success: identity,
+        warning: identity,
+        danger: identity,
+        info: identity,
+        muted: identity,
+        dim: identity,
+        heading: chalk.bold,
+        plain: identity,
+    };
+}
+function normalizeMode(raw) {
+    if (!raw)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === 'dark' || v === 'light' || v === 'mono')
+        return v;
+    if (v === 'auto')
+        return 'dark';
+    return undefined;
+}
+export function buildTheme(mode) {
+    if (mode === 'light')
+        return buildLight();
+    if (mode === 'mono')
+        return buildMono();
+    return buildDark();
+}
+/**
+ * Resolve the active theme using env-var > preference > default precedence.
+ * Pass `workspaceRoot` to honor a per-workspace `/theme` setting; omit to
+ * resolve from env only (useful in test helpers where preferences storage
+ * might not be initialized).
+ */
+export function resolveTheme(workspaceRoot) {
+    const envMode = normalizeMode(process.env.BRAINROUTER_THEME);
+    if (envMode)
+        return buildTheme(envMode);
+    if (workspaceRoot) {
+        try {
+            const prefs = readPreferences(workspaceRoot);
+            const prefMode = normalizeMode(prefs.theme);
+            if (prefMode)
+                return buildTheme(prefMode);
+        }
+        catch {
+            // preferences file unreadable — fall through to default.
+        }
+    }
+    return buildTheme('dark');
+}
+/**
+ * Box-drawing characters for the startup banner and /where view. Centralized
+ * so a future ASCII-only fallback (for terminals that mangle UTF-8 box chars)
+ * is one switch instead of a sweep through render code.
+ */
+export const BOX = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    midLeft: '├',
+    midRight: '┤',
+    cross: '┼',
+};

package/dist/cli/whereView.d.ts

@@ -0,0 +1,81 @@
+import type { Goal } from '../state/goalStore.js';
+import { type PlanState } from '../state/taskStore.js';
+import { type WorkflowMeta } from '../state/workflowArtifacts.js';
+import { type ChildSessionRecord } from '../orchestration/orchestrator.js';
+import type { RecalledRecord } from '../memory/briefing.js';
+import { type EffortLevel, type ExecutionMode, type ReviewPolicy } from '../state/preferencesStore.js';
+import { type Theme } from './theme.js';
+/**
+ * `/where` — single-screen "where am I right now" answer.
+ *
+ * Pre-0.3.6 the user had to chain `/workspace`, `/goal status`, `/plan`,
+ * `/workflows`, `/agents`, `/briefing` to reconstruct the same picture. That
+ * was four screen-fuls of output, half of which restated info already in
+ * the others. The `/where` view collapses it into one block, ordered by
+ * "what's most likely to be in your head as a question right now":
+ *
+ *   1. WORKSPACE  — where am I writing files?
+ *   2. WORKFLOW   — which durable folder is bound?
+ *   3. GOAL       — what's the agent contractually trying to do?
+ *   4. PLAN       — what are the in-flight steps?
+ *   5. RECALL     — what memory rows did the briefing surface last turn?
+ *   6. AGENTS     — any spawned children still alive?
+ *
+ * Sections are individually optional — a fresh workspace with no goal, no
+ * plan, no children renders only the WORKSPACE block instead of five empty
+ * boxes. That keeps the view useful at every stage of a session, not just
+ * after you've built up state.
+ *
+ * Pure renderer: input is a snapshot, output is a string. The wrapper in
+ * commands/ui.ts gathers the snapshot at call time. Tests assert against
+ * the rendered output directly.
+ */
+export interface WhereInputs {
+    workspaceRoot: string;
+    sessionKey: string;
+    model: string;
+    mcpProfile: string;
+    mcpTransport: string;
+    mcpOnline: boolean;
+    /**
+     * 10c: identity of the currently-active MCP. When `'brainrouter'`, /where
+     * adds a distinct `brain` line ("brain    🟢 online · cloud") under the
+     * mcp row. When `'third-party'` the line is omitted. `'unknown'` (pre-
+     * detection) is also omitted so we don't show stale state.
+     */
+    mcpIdentity?: 'brainrouter' | 'third-party' | 'unknown';
+    accessMode: string;
+    executionMode: ExecutionMode;
+    reviewPolicy: ReviewPolicy;
+    effort: EffortLevel;
+    effortSource: 'env' | 'preference' | 'default';
+    workflowSlug?: string;
+    workflowMeta?: WorkflowMeta;
+    goal?: Goal;
+    plan: PlanState;
+    recalledRecords: RecalledRecord[];
+    briefingSources: string[];
+    childSessions: ChildSessionRecord[];
+}
+/**
+ * Render the full /where block. Sections are dropped when empty; a fresh
+ * workspace with no goal / plan / children renders just WORKSPACE.
+ */
+export declare function renderWhere(inputs: WhereInputs, theme: Theme): string;
+/**
+ * Gather the snapshot the renderer needs. Single function so the command
+ * handler is two lines (gather + render + print).
+ */
+export declare function gatherWhereInputs(args: {
+    workspaceRoot: string;
+    sessionKey: string;
+    model: string;
+    mcpProfile: string;
+    mcpTransport: string;
+    mcpOnline: boolean;
+    /** 10c: pass through from `mcpClient.getIdentity()` when available. */
+    mcpIdentity?: 'brainrouter' | 'third-party' | 'unknown';
+    accessMode: string;
+    recalledRecords: RecalledRecord[];
+    briefingSources: string[];
+}): WhereInputs;

package/dist/cli/whereView.js

@@ -0,0 +1,245 @@
+import path from 'node:path';
+import { formatBudget, readGoal } from '../state/goalStore.js';
+import { readPlan } from '../state/taskStore.js';
+import { getCurrentWorkflow, listWorkflows } from '../state/workflowArtifacts.js';
+import { listSessions } from '../orchestration/orchestrator.js';
+import { readPreferences, resolveEffort } from '../state/preferencesStore.js';
+import { BOX } from './theme.js';
+const RECALL_LIMIT = 5;
+const PLAN_LIMIT = 8;
+const CHILDREN_LIMIT = 6;
+function indent(line, depth = 2) {
+    return ' '.repeat(depth) + line;
+}
+function renderHeader(title, theme) {
+    return theme.heading(`${BOX.midLeft}${BOX.horizontal} ${title}`);
+}
+function renderWorkspace(inputs, theme) {
+    const base = path.basename(inputs.workspaceRoot) || inputs.workspaceRoot;
+    const dim = theme.muted;
+    // /where is the "tell me everything" surface, so we show the effort level
+    // regardless of whether it's at default — unlike the statusline, which
+    // hides medium to keep the prompt quiet. Tag the source in parens when
+    // env beat the preference so users can see why the value differs from
+    // what they set with /effort.
+    const effortLine = inputs.effortSource === 'env'
+        ? `effort  ${inputs.effort}  ${dim('(env)')}`
+        : `effort  ${inputs.effort}`;
+    const lines = [
+        renderHeader('Workspace', theme),
+        indent(theme.plain(`${base}  ${dim('(' + inputs.workspaceRoot + ')')}`)),
+        indent(dim(`session ${inputs.sessionKey.slice(0, 8)}  ·  model ${inputs.model}  ·  mode ${inputs.accessMode}`)),
+        indent(dim(`exec    ${inputs.executionMode}  ·  review ${inputs.reviewPolicy}  ·  ${effortLine}`)),
+        indent(dim(`mcp     ${inputs.mcpProfile}  ·  ${inputs.mcpTransport}  ·  ${inputs.mcpOnline ? 'online' : 'offline'}`)),
+    ];
+    // 10c: distinct `brain` line for the BrainRouter cloud brain. Shown
+    // unconditionally regardless of state when identity is brainrouter (vs.
+    // the statusline which hides online to stay quiet). Third-party MCPs
+    // skip the line entirely; `unknown` is pre-detection so we wait.
+    if (inputs.mcpIdentity === 'brainrouter') {
+        const brainState = inputs.mcpOnline ? '🟢 online' : '🔴 offline · cloud unreachable';
+        lines.push(indent(dim(`brain   ${brainState}`)));
+    }
+    return lines;
+}
+function renderWorkflow(inputs, theme) {
+    if (!inputs.workflowSlug)
+        return [];
+    const meta = inputs.workflowMeta;
+    const dim = theme.muted;
+    const lines = [renderHeader('Workflow', theme)];
+    lines.push(indent(theme.info(inputs.workflowSlug) + (meta ? '  ' + dim(`(${meta.kind} · ${meta.status})`) : '')));
+    if (meta)
+        lines.push(indent(dim(`title: ${meta.title}`)));
+    return lines;
+}
+function renderGoal(inputs, theme) {
+    const goal = inputs.goal;
+    if (!goal)
+        return [];
+    const dim = theme.muted;
+    const cap = formatBudget(goal.budget.maxIterations);
+    const used = goal.budget.iterationsUsed;
+    const statusColor = goal.status === 'complete' ? theme.success :
+        goal.status === 'blocked' ? theme.danger :
+            goal.status === 'usage_limited' ? theme.warning :
+                goal.status === 'paused' ? theme.warning :
+                    theme.info;
+    const lines = [renderHeader('Goal', theme)];
+    lines.push(indent(statusColor(goal.status.toUpperCase().replace('_', ' '))));
+    // Wrap the goal text at a sensible width so long objectives don't
+    // produce one giant unreadable line.
+    lines.push(indent(theme.plain(wrapText(goal.text, 76))));
+    const tokenLine = goal.budget.maxTokens
+        ? `  ·  tokens ${(goal.budget.tokensUsed ?? 0).toLocaleString()}/${goal.budget.maxTokens.toLocaleString()}`
+        : '';
+    lines.push(indent(dim(`iterations ${used}/${cap}${tokenLine}`)));
+    if (goal.blockedReason)
+        lines.push(indent(dim(`reason: ${goal.blockedReason}`)));
+    return lines;
+}
+function renderPlan(inputs, theme) {
+    if (!inputs.plan.items.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader('Plan', theme)];
+    if (inputs.plan.explanation) {
+        lines.push(indent(dim(inputs.plan.explanation)));
+    }
+    for (const item of inputs.plan.items.slice(0, PLAN_LIMIT)) {
+        const mark = item.status === 'completed' ? theme.success('✓') :
+            item.status === 'in_progress' ? theme.warning('⏳') :
+                dim('☐');
+        const text = item.status === 'completed' ? dim(item.step) : theme.plain(item.step);
+        lines.push(indent(`${mark} ${text}`));
+    }
+    if (inputs.plan.items.length > PLAN_LIMIT) {
+        lines.push(indent(dim(`…and ${inputs.plan.items.length - PLAN_LIMIT} more`)));
+    }
+    return lines;
+}
+function renderRecall(inputs, theme) {
+    if (!inputs.recalledRecords.length && !inputs.briefingSources.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader('Recent recall', theme)];
+    if (inputs.briefingSources.length) {
+        lines.push(indent(dim(`sources: ${inputs.briefingSources.join(', ')}`)));
+    }
+    for (const rec of inputs.recalledRecords.slice(0, RECALL_LIMIT)) {
+        const typeTag = rec.type ? theme.secondary(`[${rec.type}] `) : '';
+        const score = typeof rec.priority === 'number' ? dim(` (p=${rec.priority.toFixed(2)})`) : '';
+        const snippet = (rec.content ?? '').replace(/\s+/g, ' ').trim().slice(0, 100);
+        lines.push(indent(`${typeTag}${theme.plain(snippet || rec.recordId)}${score}`));
+    }
+    if (inputs.recalledRecords.length > RECALL_LIMIT) {
+        lines.push(indent(dim(`…and ${inputs.recalledRecords.length - RECALL_LIMIT} more`)));
+    }
+    return lines;
+}
+function renderChildren(inputs, theme) {
+    // Live children = anything currently pending or running. Stale/completed
+    // are visible in /agents; /where stays focused on what's blocking attention.
+    const live = inputs.childSessions.filter((s) => s.status === 'pending' || s.status === 'running');
+    if (!live.length)
+        return [];
+    const dim = theme.muted;
+    const lines = [renderHeader(`Active children (${live.length})`, theme)];
+    for (const s of live.slice(0, CHILDREN_LIMIT)) {
+        const statusColor = s.status === 'running' ? theme.success : theme.warning;
+        const role = theme.secondary(s.role);
+        const id = theme.info(s.id);
+        const promptPreview = s.prompt
+            ? '  ' + dim(s.prompt.replace(/\s+/g, ' ').slice(0, 80))
+            : '';
+        lines.push(indent(`${statusColor(s.status)}  ${id}  ${role}${promptPreview}`));
+    }
+    if (live.length > CHILDREN_LIMIT) {
+        lines.push(indent(dim(`…and ${live.length - CHILDREN_LIMIT} more`)));
+    }
+    return lines;
+}
+function wrapText(text, width) {
+    if (text.length <= width)
+        return text;
+    const words = text.split(/\s+/);
+    const lines = [];
+    let current = '';
+    for (const word of words) {
+        if (!current) {
+            current = word;
+            continue;
+        }
+        if (current.length + 1 + word.length > width) {
+            lines.push(current);
+            current = word;
+        }
+        else {
+            current += ' ' + word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.join('\n' + ' '.repeat(2));
+}
+/**
+ * Render the full /where block. Sections are dropped when empty; a fresh
+ * workspace with no goal / plan / children renders just WORKSPACE.
+ */
+export function renderWhere(inputs, theme) {
+    const sections = [];
+    sections.push(renderWorkspace(inputs, theme));
+    const workflow = renderWorkflow(inputs, theme);
+    if (workflow.length)
+        sections.push(workflow);
+    const goal = renderGoal(inputs, theme);
+    if (goal.length)
+        sections.push(goal);
+    const plan = renderPlan(inputs, theme);
+    if (plan.length)
+        sections.push(plan);
+    const recall = renderRecall(inputs, theme);
+    if (recall.length)
+        sections.push(recall);
+    const children = renderChildren(inputs, theme);
+    if (children.length)
+        sections.push(children);
+    return sections.map((lines) => lines.join('\n')).join('\n\n');
+}
+/**
+ * Gather the snapshot the renderer needs. Single function so the command
+ * handler is two lines (gather + render + print).
+ */
+export function gatherWhereInputs(args) {
+    const workflowSlug = (() => {
+        // 9d-bugfix: session-scoped binding so a fresh CLI shows no workflow
+        // even when an earlier session in the same workspace had one bound.
+        try {
+            return getCurrentWorkflow(args.workspaceRoot, args.sessionKey);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const workflowMeta = workflowSlug
+        ? listWorkflows(args.workspaceRoot).find((w) => w.slug === workflowSlug)
+        : undefined;
+    const goal = (() => {
+        try {
+            return readGoal(args.workspaceRoot, args.sessionKey) ?? undefined;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const plan = (() => {
+        try {
+            return readPlan(args.workspaceRoot, args.sessionKey);
+        }
+        catch {
+            return { items: [], updatedAt: '' };
+        }
+    })();
+    const childSessions = (() => {
+        try {
+            return listSessions(args.workspaceRoot);
+        }
+        catch {
+            return [];
+        }
+    })();
+    const prefs = readPreferences(args.workspaceRoot);
+    const resolvedEffort = resolveEffort(args.workspaceRoot);
+    return {
+        ...args,
+        executionMode: prefs.executionMode,
+        reviewPolicy: prefs.reviewPolicy,
+        effort: resolvedEffort.effort,
+        effortSource: resolvedEffort.source,
+        workflowSlug,
+        workflowMeta,
+        goal,
+        plan,
+        childSessions,
+    };
+}

package/dist/cli/wizard/modelsApi.d.ts

@@ -0,0 +1,72 @@
+import type { Theme } from '../theme.js';
+import type { ProviderEntry } from './providers.js';
+/**
+ * Fetch the live model list from an OpenAI-compatible `/v1/models`
+ * endpoint and return them as a sorted, deduped string array.
+ *
+ * Every OpenAI-compatible server we ship a provider entry for honours
+ * `GET <endpoint>/models` (OpenAI, DeepSeek, OpenRouter, LM Studio,
+ * Ollama, vLLM, gateway proxies like LiteLLM). The response shape is
+ * `{ object: 'list', data: [{ id: string, owned_by?: string, ... }] }`.
+ *
+ * We derive the `/models` URL from the provider's chat endpoint by
+ * stripping the trailing `/chat/completions` path segment. That works
+ * for every endpoint shape we care about:
+ *
+ *   https://api.openai.com/v1/chat/completions    → /v1/models
+ *   http://localhost:1234/v1/chat/completions     → /v1/models
+ *   https://openrouter.ai/api/v1/chat/completions → /api/v1/models
+ *
+ * 5-second timeout — if the call hangs or fails, the wizard falls
+ * back to the provider's curated static catalog so users on a slow
+ * link / behind a captive portal aren't blocked.
+ */
+export declare function fetchOpenAiCompatibleModels(provider: ProviderEntry, apiKey: string, endpointOverride?: string): Promise<{
+    ok: true;
+    models: string[];
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function deriveModelsUrl(chatEndpoint: string): string;
+/**
+ * Open the model picker — live `/v1/models` fetch with the provider's
+ * static catalog as the offline fallback. Returns the selected model id,
+ * or `undefined` when the user cancels.
+ *
+ * Used by both the onboarding wizard's Model step
+ * (`cli/wizard/runner.ts → runModelStep`) and the in-REPL `/model`
+ * quick-swap command (`cli/commands/ui.ts → /model`). Keeping a single
+ * implementation means a future enrichment (recently-used badge,
+ * cost-per-token hint, model-size group headers) lights up everywhere
+ * at once.
+ *
+ * `currentModel` (when supplied) defaults the picker cursor onto the
+ * currently active row — important for `/model` where the user almost
+ * always wants to confirm what's currently selected before changing.
+ */
+export interface SelectModelOptions {
+    theme: Theme;
+    provider: ProviderEntry;
+    apiKey: string;
+    /** Override the provider's default chat endpoint (custom-endpoint flow). */
+    endpointOverride?: string;
+    /** Active model id — cursor opens on this row when present. */
+    currentModel?: string;
+    /** Picker title (default: "Model"). */
+    title?: string;
+    /** Optional badge rendered next to the title. */
+    badge?: string;
+    /** Erase the picker frame after a selection (true for wizard, false for in-REPL). */
+    eraseOnClose?: boolean;
+}
+export interface SelectModelResult {
+    model: string;
+    /** Where the picker got its list from — surfaces in the success message. */
+    source: 'live' | 'static' | 'fallback';
+    /** Number of models the live call returned (0 when source !== 'live'). */
+    liveCount: number;
+    /** Live-call error message when source !== 'live' (omitted on live success). */
+    liveError?: string;
+}
+export declare function selectModel(opts: SelectModelOptions): Promise<SelectModelResult | undefined>;

package/dist/cli/wizard/modelsApi.js

@@ -0,0 +1,166 @@
+import { runPicker } from '../ink/runPicker.js';
+/**
+ * Fetch the live model list from an OpenAI-compatible `/v1/models`
+ * endpoint and return them as a sorted, deduped string array.
+ *
+ * Every OpenAI-compatible server we ship a provider entry for honours
+ * `GET <endpoint>/models` (OpenAI, DeepSeek, OpenRouter, LM Studio,
+ * Ollama, vLLM, gateway proxies like LiteLLM). The response shape is
+ * `{ object: 'list', data: [{ id: string, owned_by?: string, ... }] }`.
+ *
+ * We derive the `/models` URL from the provider's chat endpoint by
+ * stripping the trailing `/chat/completions` path segment. That works
+ * for every endpoint shape we care about:
+ *
+ *   https://api.openai.com/v1/chat/completions    → /v1/models
+ *   http://localhost:1234/v1/chat/completions     → /v1/models
+ *   https://openrouter.ai/api/v1/chat/completions → /api/v1/models
+ *
+ * 5-second timeout — if the call hangs or fails, the wizard falls
+ * back to the provider's curated static catalog so users on a slow
+ * link / behind a captive portal aren't blocked.
+ */
+export async function fetchOpenAiCompatibleModels(provider, apiKey, endpointOverride) {
+    const chatEndpoint = endpointOverride ?? provider.endpoint;
+    const modelsUrl = deriveModelsUrl(chatEndpoint);
+    const headers = { 'Content-Type': 'application/json' };
+    // Cloud providers always want a Bearer header. Local endpoints (LM
+    // Studio, Ollama) accept anything OR nothing, but sending the key
+    // through doesn't hurt — they ignore it.
+    if (apiKey.trim().length > 0) {
+        headers['Authorization'] = `Bearer ${apiKey.trim()}`;
+    }
+    else if (provider.local) {
+        // Some local servers reject requests with NO Authorization header
+        // even though they don't validate the value. A literal "local"
+        // bearer is the convention for LM Studio / Ollama config snippets.
+        headers['Authorization'] = 'Bearer local';
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5_000);
+    try {
+        const res = await fetch(modelsUrl, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            return { ok: false, error: `HTTP ${res.status} ${res.statusText} — ${text.slice(0, 200)}` };
+        }
+        const data = await res.json();
+        const list = Array.isArray(data?.data) ? data.data : [];
+        const ids = list
+            .map((m) => (typeof m?.id === 'string' ? m.id : null))
+            .filter((s) => !!s);
+        if (ids.length === 0) {
+            return { ok: false, error: 'endpoint returned an empty model list' };
+        }
+        return { ok: true, models: dedupeAndSort(ids) };
+    }
+    catch (err) {
+        if (err?.name === 'AbortError') {
+            return { ok: false, error: 'timed out after 5s' };
+        }
+        return { ok: false, error: String(err?.message ?? err) };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function deriveModelsUrl(chatEndpoint) {
+    // Replace a trailing `/chat/completions` (with optional trailing
+    // slash) with `/models`. If the endpoint doesn't end in
+    // `/chat/completions` (already a base URL, custom path), append
+    // `/models` directly.
+    const trimmed = chatEndpoint.replace(/\/+$/, '');
+    if (trimmed.endsWith('/chat/completions')) {
+        return trimmed.slice(0, -'/chat/completions'.length) + '/models';
+    }
+    return trimmed + '/models';
+}
+function dedupeAndSort(ids) {
+    return Array.from(new Set(ids)).sort((a, b) => a.localeCompare(b));
+}
+export async function selectModel(opts) {
+    const { provider, apiKey, endpointOverride, currentModel, theme } = opts;
+    let modelsList = provider.models;
+    let source = 'static';
+    let liveCount = 0;
+    let liveError;
+    let subtitleHint = `Pick the chat model for ${provider.label}.`;
+    // Live fetch is gated on either having a key (cloud) or running local.
+    // Skipping the fetch entirely when neither is true avoids a guaranteed
+    // 401 / network error on the loading frame.
+    if (apiKey.trim().length > 0 || provider.local) {
+        const fetched = await fetchOpenAiCompatibleModels(provider, apiKey, endpointOverride);
+        if (fetched.ok) {
+            const live = fetched.models;
+            // Default model floats to the top so "(default)" stays in the
+            // natural-first position the user expects. Then the currently-
+            // active model floats next (cursor lands here below).
+            const reordered = floatToTop(live, [provider.defaultModel]);
+            modelsList = reordered;
+            source = 'live';
+            liveCount = live.length;
+            subtitleHint = `Pick a model — ${live.length} returned by ${provider.label}'s /v1/models endpoint. Use "Other" to type any name.`;
+        }
+        else {
+            source = 'fallback';
+            liveError = fetched.error;
+            subtitleHint = `Pick a model. (Live list unavailable — ${fetched.error}. Showing curated short-list.) Use "Other" to type any name.`;
+        }
+    }
+    const finalList = modelsList.length > 0 ? modelsList : [provider.defaultModel];
+    const rows = finalList.map((m) => ({
+        id: m,
+        label: m,
+        value: m === currentModel ? 'current' :
+            m === provider.defaultModel ? 'default' : '',
+    }));
+    // Cursor priority: currently-active model > provider default > top.
+    let initialCursor = 0;
+    if (currentModel) {
+        const idx = finalList.indexOf(currentModel);
+        if (idx >= 0)
+            initialCursor = idx;
+    }
+    if (initialCursor === 0 && !currentModel) {
+        const idx = finalList.indexOf(provider.defaultModel);
+        if (idx >= 0)
+            initialCursor = idx;
+    }
+    const result = await runPicker({
+        theme,
+        title: opts.title ?? 'Model',
+        subtitle: subtitleHint,
+        badge: opts.badge,
+        rows,
+        initialCursor,
+        allowOther: true,
+        otherLabel: 'Other model',
+        otherDescription: 'Type any model name supported by this endpoint',
+        eraseOnClose: opts.eraseOnClose ?? false,
+    });
+    if (result.kind === 'cancelled')
+        return undefined;
+    const model = (result.kind === 'other' ? result.text.trim() : result.id) || provider.defaultModel;
+    return { model, source, liveCount, liveError };
+}
+function floatToTop(list, priority) {
+    const seen = new Set();
+    const front = [];
+    for (const p of priority) {
+        if (list.includes(p) && !seen.has(p)) {
+            front.push(p);
+            seen.add(p);
+        }
+    }
+    for (const m of list) {
+        if (!seen.has(m)) {
+            front.push(m);
+            seen.add(m);
+        }
+    }
+    return front;
+}