@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/ui/overlays/SettingsScreen.js

@@ -8,7 +8,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * The API key is never printed: it renders as dots while editing and masked
  * otherwise.
  */
-import { useState } from 'react';
+import { useEffect, useReducer, useRef, useState } from 'react';
 import { Text, useInput } from 'ink';
 import { DEFAULT_MAX_OUTPUT_TOKENS, resolveOutputTokens, } from '@aragon-agent/core';
 import { ADAPTER_PROVIDERS, THINKING_LEVELS, maskSecret, parseMaxTokensInput, parseThresholdInput, } from '../../config/schema.js';
@@ -17,6 +17,11 @@ import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
+import { emptyModelProfiles } from '../../config/model-profiles.js';
+import { registerSecret } from '../../logging/secret-registry.js';
+import { ModelProfilePicker, useProfileScroll } from './ModelProfilePicker.js';
+import { ModelProfileEditor } from './ModelProfileEditor.js';
+import { createModelProfileState, createCustomProfile, modelProfileReducer, profileUsers } from './model-profile-state.js';
 const SHOW_THINKING_OPTIONS = ['off', 'on'];
 const LIVE_OUTPUT_OPTIONS = ['off', 'on'];
 const FAST_ENABLED_OPTIONS = ['off', 'on'];
@@ -238,7 +243,11 @@ export function effectiveCapLine(values) {
         return `Effective: ${resolution.value}  (auto)`;
     return `Effective: ${resolution.value}`;
 }
-export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, retrySummary, }) {
+export function SettingsScreen(props) {
+    return props.draft ? _jsx(ProfileSettingsScreen, { ...props, draft: props.draft })
+        : _jsx(LegacySettingsScreen, { ...props });
+}
+function LegacySettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset, onScrollClamp, theme, caps, onSave, retrySummary, }) {
     const [values, setValues] = useState(initial);
     const [index, setIndex] = useState(0);
     const glyphs = pickGlyphs(caps);
@@ -278,7 +287,7 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
             return;
         }
         if (key.return) {
-            onSave(values);
+            onSave?.(values);
             return;
         }
         if (field.kind === 'enum') {
@@ -373,3 +382,338 @@ export function SettingsScreen({ initial, apiKeys, maxRows, cols, scrollOffset,
     rows.push(_jsx(Text, { wrap: "truncate", color: theme.muted, children: "Enter saves. Keys persist to the config file (0600)." }, "__save"));
     return (_jsx(OverlayFrame, { title: "Settings", hint: `${glyphs.arrowUp}${glyphs.arrowDown} field ${glyphs.midDot} ${glyphs.arrowLeft}${glyphs.arrowRight} change ${glyphs.midDot} Enter save ${glyphs.midDot} Esc close`, maxRows: maxRows, cols: cols, rows: rows, scrollOffset: scrollOffset, onScrollClamp: onScrollClamp, theme: theme, caps: caps }));
 }
+const PROFILE_FIELDS = FIELDS.filter((field) => ![
+    'provider', 'model', 'baseUrl', 'apiKey', 'fastProvider', 'fastModel', 'fastEnabled',
+].includes(field.key));
+function profileSettingsValues(initial, draft) {
+    const file = draft.baseline;
+    return { ...initial, provider: file.provider ?? initial.provider,
+        model: file.model ?? initial.model,
+        baseUrl: file.baseUrl ?? '', apiKey: '', fastModel: file.fast?.model ?? '',
+        fastProvider: file.fast?.provider || FAST_INHERIT_PROVIDER };
+}
+/** Only fields changed by the user belong in a settings transaction. */
+export function readDirtySettings(initial, values) {
+    const patch = {};
+    const dirty = (key) => initial[key] !== values[key];
+    if (dirty('provider'))
+        patch.provider = values.provider;
+    if (dirty('model'))
+        patch.model = values.model.trim();
+    if (dirty('baseUrl'))
+        patch.baseUrl = values.baseUrl.trim();
+    if (dirty('apiKey') && values.apiKey.trim()) {
+        patch.apiKeys = { [values.provider]: values.apiKey.trim() };
+    }
+    if (dirty('thinkingLevel'))
+        patch.thinkingLevel = values.thinkingLevel;
+    if (dirty('showThinking'))
+        patch.showThinking = values.showThinking === 'on';
+    if (dirty('liveToolOutput'))
+        patch.liveToolOutput = values.liveToolOutput === 'on';
+    if (dirty('logLevel'))
+        patch.log = { level: values.logLevel };
+    if (dirty('maxTokens')) {
+        const parsed = parseMaxTokensInput(values.maxTokens);
+        if (parsed.kind === 'invalid')
+            throw new Error('Max tokens: use a number or auto.');
+        patch.maxTokens = parsed.kind === 'auto' ? null : parsed.value;
+    }
+    const fast = {};
+    const parsedFast = readFastSettings(values);
+    if (dirty('fastModel'))
+        fast.model = parsedFast.model;
+    if (dirty('fastProvider'))
+        fast.provider = parsedFast.provider;
+    if (dirty('fastEnabled'))
+        fast.enabled = parsedFast.enabled;
+    if (dirty('fastReview')) {
+        if (parsedFast.review === undefined)
+            throw new Error('Fast review: use a turn count or off.');
+        fast.review = parsedFast.review;
+        if (parsedFast.reviewEveryTurns !== undefined) {
+            fast.reviewEveryTurns = parsedFast.reviewEveryTurns;
+        }
+    }
+    if (dirty('fastReviewBudget')) {
+        if (parsedFast.reviewMaxPerSession === undefined) {
+            throw new Error('Fast budget: use a number.');
+        }
+        fast.reviewMaxPerSession = parsedFast.reviewMaxPerSession;
+    }
+    if (Object.keys(fast).length)
+        patch.fast = fast;
+    const compaction = {};
+    const parsedCompaction = readCompactionSettings(values);
+    const mapping = { compactionEnabled: 'enabled', compactionThreshold: 'threshold',
+        compactionKeepTurns: 'keepRecentTurns', compactionSubagents: 'subagents',
+        compactionArchive: 'archive' };
+    for (const [field, key] of Object.entries(mapping)) {
+        if (!dirty(field))
+            continue;
+        const value = parsedCompaction[key];
+        if (value === undefined) {
+            const label = FIELDS.find((item) => item.key === field).label;
+            throw new Error(`${label}: use a number.`);
+        }
+        Object.assign(compaction, { [key]: value });
+    }
+    if (Object.keys(compaction).length)
+        patch.compaction = compaction;
+    return patch;
+}
+function saveError(result) {
+    if (result.persisted)
+        return 'Saved; not fully applied. Close and restart. Save disabled.';
+    const errors = {
+        busy: 'Busy. Wait for running work to finish, then save again.',
+        conflict: 'Config changed elsewhere. Reload before saving.',
+        read_failed: 'Cannot read config. Repair with aragon config edit, then reload.',
+        write_failed: 'Could not save. Your changes are still here; retry Save.',
+        invalid: 'Invalid settings. Review the highlighted field and retry.',
+    };
+    return errors[result.code ?? ''] ?? 'Could not save. Review settings and retry.';
+}
+function useProfileSettingsState(props) {
+    const [state, dispatch] = useReducer(modelProfileReducer, props.draft, createModelProfileState);
+    const [initial, setInitial] = useState(() => profileSettingsValues(props.initial, props.draft));
+    const [values, setValues] = useState(initial);
+    const [index, setIndex] = useState(0);
+    const [error, setError] = useState();
+    const [persisted, setPersisted] = useState(false);
+    const [confirmIndex, setConfirmIndex] = useState(0);
+    const [reloadPending, setReloadPending] = useState(false);
+    const offset = useProfileScroll(props, index);
+    const previousPage = useRef(state.page);
+    useEffect(() => {
+        const previous = previousPage.current;
+        previousPage.current = state.page;
+        if (state.page !== 'root' || previous === 'discard-confirm')
+            return;
+        setIndex(0);
+        props.onScrollClamp?.(0);
+    }, [state.page]);
+    const library = state.draft.profiles ?? emptyModelProfiles();
+    const glyphs = pickGlyphs(props.caps);
+    const dirty = state.dirty || Object.keys(values).some((key) => values[key] !== initial[key]);
+    const fields = [FIELDS.find((item) => item.key === 'fastEnabled'),
+        ...FIELDS.filter((item) => library.mainId === null
+            && ['provider', 'model', 'baseUrl', 'apiKey'].includes(item.key)),
+        ...FIELDS.filter((item) => library.fastId === null
+            && ['fastModel', 'fastProvider'].includes(item.key)), ...PROFILE_FIELDS];
+    const count = fields.length + 5;
+    const field = fields[index - 3];
+    const readError = state.draft.readError;
+    const confirming = state.page === 'delete-confirm' || state.page === 'discard-confirm';
+    return { state, dispatch, initial, setInitial, values, setValues, index, setIndex,
+        error, setError, persisted, setPersisted, confirmIndex, setConfirmIndex,
+        reloadPending, setReloadPending, offset, library, glyphs, dirty, fields, count,
+        field, readError, confirming };
+}
+function saveProfileSettings(props, view) {
+    const { persisted, readError, initial, values, fields, state, setError, setIndex, setPersisted } = view;
+    if (persisted || readError || !props.onProfileSave)
+        return;
+    let patch;
+    try {
+        patch = readDirtySettings(initial, values);
+    }
+    catch (failure) {
+        const message = failure.message;
+        setError(message);
+        const at = fields.findIndex((item) => message.startsWith(`${item.label}:`));
+        if (at >= 0)
+            setIndex(at + 3);
+        return;
+    }
+    const result = props.onProfileSave({
+        ...state.draft, patch: { ...state.draft.patch, ...patch },
+    });
+    if (!result.ok) {
+        setError(saveError(result));
+        setPersisted(result.persisted);
+    }
+}
+function reloadProfileSettings(props, view) {
+    const { dispatch, setInitial, setValues, setError, setIndex, setReloadPending } = view;
+    if (!props.onReload)
+        return;
+    const next = props.onReload();
+    dispatch({ type: 'reload', draft: next });
+    const live = next.liveBaseline;
+    const refreshed = { ...props.initial, provider: live.provider, model: live.model,
+        baseUrl: live.baseUrl ?? '', thinkingLevel: live.thinkingLevel,
+        showThinking: live.showThinking ? 'on' : 'off',
+        liveToolOutput: live.liveToolOutput ? 'on' : 'off',
+        maxTokens: live.maxTokens === undefined ? '' : String(live.maxTokens),
+        logLevel: live.log?.level ?? props.initial.logLevel,
+        ...(live.fast ? fastSettingsFrom(live.fast) : {}),
+        ...(live.compaction ? compactionSettingsFrom(live.compaction) : {}),
+    };
+    const nextValues = profileSettingsValues(refreshed, next);
+    setInitial(nextValues);
+    setValues(nextValues);
+    setError(undefined);
+    setIndex(0);
+    setReloadPending(false);
+}
+function cancelProfileSettings(props, view, reloading = false) {
+    const { persisted, dirty, setReloadPending, setConfirmIndex, dispatch } = view;
+    if (persisted) {
+        props.onClose?.();
+        return;
+    }
+    if (!dirty) {
+        if (reloading)
+            reloadProfileSettings(props, view);
+        else
+            props.onClose?.();
+        return;
+    }
+    setReloadPending(reloading);
+    setConfirmIndex(0);
+    dispatch({ type: 'page', page: 'discard-confirm' });
+}
+function activateRootSetting(props, view) {
+    const { index, count, readError, persisted, dispatch } = view;
+    if (index === count - 1) {
+        cancelProfileSettings(props, view, true);
+        return;
+    }
+    if (readError || persisted)
+        return;
+    if (index < 2)
+        dispatch({ type: 'page', page: 'picker', role: index === 0 ? 'main' : 'fast' });
+    else if (index === 2)
+        dispatch({ type: 'page', page: 'manager' });
+    else
+        saveProfileSettings(props, view);
+}
+function useRootSettingsInput(props, view) {
+    const { index, count, field, readError, persisted, values, state, setIndex, setValues } = view;
+    useInput((input, key) => {
+        if (key.escape) {
+            cancelProfileSettings(props, view);
+            return;
+        }
+        if (key.ctrl && input === 's') {
+            saveProfileSettings(props, view);
+            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) {
+            activateRootSetting(props, view);
+            return;
+        }
+        if (!field || readError || persisted || key.ctrl || key.meta)
+            return;
+        if (field.kind === 'enum') {
+            if (!key.leftArrow && !key.rightArrow)
+                return;
+            const options = field.options;
+            const at = options.indexOf(String(values[field.key]));
+            setValues({ ...values, ...(field.key === 'provider' ? { apiKey: '' } : {}),
+                [field.key]: options[(at + (key.leftArrow ? -1 : 1) + options.length) % options.length] });
+            return;
+        }
+        const text = stripPasteFrames(stripEnterFrames(input));
+        const value = key.backspace || key.delete
+            ? [...String(values[field.key])].slice(0, -1).join('') : String(values[field.key]) + text;
+        if (field.key === 'apiKey')
+            registerSecret(value);
+        if (key.backspace || key.delete || text)
+            setValues({ ...values, [field.key]: value });
+    }, { isActive: state.page === 'root' });
+}
+function useSettingsConfirmationInput(props, view) {
+    const { state, dispatch, confirmIndex, setConfirmIndex, reloadPending, confirming } = view;
+    useInput((_input, key) => {
+        if (key.escape) {
+            dispatch({ type: 'page', page: state.page === 'delete-confirm'
+                    ? 'manager' : 'root' });
+            return;
+        }
+        if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.tab) {
+            setConfirmIndex((confirmIndex + 1) % 2);
+            return;
+        }
+        if (!key.return)
+            return;
+        if (state.page === 'delete-confirm') {
+            dispatch(confirmIndex === 1 ? { type: 'confirm-delete' }
+                : { type: 'page', page: 'manager' });
+        }
+        else if (confirmIndex === 0)
+            dispatch({ type: 'page', page: 'root' });
+        else if (reloadPending)
+            reloadProfileSettings(props, view);
+        else
+            props.onClose?.();
+    }, { isActive: confirming });
+}
+function renderSettingsConfirmation(props, view) {
+    const { state, library, confirmIndex, glyphs } = view;
+    const deleting = state.page === 'delete-confirm';
+    const name = library.entries.find((entry) => entry.id === state.deleteId)?.name ?? '';
+    const labels = deleting ? ['Cancel', 'Delete'] : ['Continue', 'Discard'];
+    return _jsx(OverlayFrame, { ...props, title: deleting ? `Delete ${name}?` : 'Discard unsaved changes?', hint: "Enter choose | Esc continue", rows: labels
+            .map((label, at) => _jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [confirmIndex === at ? `${glyphs.caret} ` : '  ', label] }, label)), scrollOffset: 0 });
+}
+function renderProfileSubpage(props, view) {
+    const { state, library, dispatch, setConfirmIndex } = view;
+    if (state.page === 'editor' && state.editor)
+        return _jsx(ModelProfileEditor, { ...props, editor: state.editor, users: profileUsers(library, state.editor.original.id), error: state.error, dispatch: dispatch });
+    if (state.page === 'picker' || state.page === 'manager')
+        return _jsx(ModelProfilePicker, { ...props, profiles: library, savedProfiles: state.draft.baseline.modelProfiles, role: state.role, customProfile: createCustomProfile(state.draft, state.role), manager: state.page === 'manager', error: state.error, onSelect: (id) => dispatch({ type: 'select', role: state.role, id }), onCreate: () => dispatch({ type: 'edit', profile: createCustomProfile(state.draft, state.role),
+                bindNew: state.page === 'picker' }), onEdit: (profile) => dispatch({ type: 'edit', profile }), onDuplicate: (id) => dispatch({ type: 'duplicate', id }), onDelete: (id) => { setConfirmIndex(0); dispatch({ type: 'delete', id }); }, onCancel: () => dispatch({ type: 'page', page: 'root' }) });
+    return null;
+}
+function buildRootSettingsRows(props, view) {
+    const { library, fields, values, persisted, readError, index, glyphs, state } = view;
+    const name = (id) => {
+        const entry = library.entries.find((candidate) => candidate.id === id);
+        if (!entry)
+            return 'Current custom';
+        const missing = !entry.apiKey && !props.apiKeys[entry.provider];
+        return `${entry.name}  ${entry.provider}:${entry.model}${missing ? ' [Missing API key]' : ''}`;
+    };
+    const lines = [`Main profile      ${name(library.mainId)}`,
+        `Fast profile      ${name(library.fastId)}`,
+        `Manage profiles   ${library.entries.length} saved`,
+        ...fields.map((item) => `${item.label.padEnd(18)}${item.key === 'apiKey'
+            ? values.apiKey ? 'Configured (replacement)' : props.apiKeys[values.provider]
+                ? 'Configured (type to replace)' : '(type to set)'
+            : values[item.key] || (item.key === 'maxTokens' ? 'auto' : '(not set)')}`),
+        persisted || readError ? 'Save (disabled)' : 'Save settings', 'Reload settings'];
+    const rows = lines.map((line, at) => _jsxs(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: [at === index ? `${glyphs.caret} ` : '  ', line] }, at));
+    rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: effectiveCapLine(values) }, "effective"));
+    const overrides = state.draft.liveBaseline.modelProfileState;
+    if (overrides?.main.overriddenFields.length || overrides?.fast.overriddenFields.length) {
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: "Startup overrides active; explicit selection applies now. Restart uses startup overrides." }, "overrides"));
+    }
+    if (props.retrySummary)
+        rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: ["API retries: ", props.retrySummary] }, "retry"));
+    return rows;
+}
+function ProfileSettingsScreen(props) {
+    const view = useProfileSettingsState(props);
+    useRootSettingsInput(props, view);
+    useSettingsConfirmationInput(props, view);
+    if (view.confirming)
+        return renderSettingsConfirmation(props, view);
+    const subpage = renderProfileSubpage(props, view);
+    if (subpage)
+        return subpage;
+    const { error, readError, dirty, persisted, index, offset } = view;
+    return _jsx(OverlayFrame, { ...props, rows: buildRootSettingsRows(props, view), scrollOffset: offset, title: error ?? (readError ? 'Cannot read config. Repair with aragon config edit; Reload.'
+            : dirty ? 'Settings | Unsaved changes' : 'Settings'), hint: persisted ? 'Esc close; restart to apply' : index < 3
+            ? 'Enter select/edit | Ctrl+S save | Esc cancel'
+            : 'Enter save/action | Ctrl+S save | Esc cancel' });
+}

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

@@ -0,0 +1,74 @@
+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';
+export interface ProfileEditorDraft {
+    original: ModelProfile;
+    name: string;
+    provider: string;
+    model: string;
+    baseUrl: string;
+    credentialMode: 'keep' | 'replace' | 'shared';
+    apiKey: string;
+    endpointChanged: boolean;
+}
+export interface ModelProfileState {
+    draft: ModelSettingsDraft;
+    page: ProfilePage;
+    role: ModelRole;
+    editor?: ProfileEditorDraft;
+    returnPage: 'picker' | 'manager';
+    bindNew: boolean;
+    dirty: boolean;
+    error?: string;
+    deleteId?: string;
+}
+export type ModelProfileAction = {
+    type: 'page';
+    page: ProfilePage;
+    role?: ModelRole;
+} | {
+    type: 'select';
+    role: ModelRole;
+    id: string | null;
+} | {
+    type: 'edit';
+    profile: ModelProfile;
+    bindNew?: boolean;
+} | {
+    type: 'editor-field';
+    field: keyof Omit<ProfileEditorDraft, 'original' | 'endpointChanged'>;
+    value: string;
+} | {
+    type: 'retain-key';
+} | {
+    type: 'merge-editor';
+} | {
+    type: 'cancel-editor';
+} | {
+    type: 'duplicate';
+    id: string;
+} | {
+    type: 'delete';
+    id: string;
+} | {
+    type: 'confirm-delete';
+} | {
+    type: 'reload';
+    draft: ModelSettingsDraft;
+};
+/** Keep the original secret separate from the empty replacement field. */
+export declare function createProfileEditor(profile: ModelProfile): ProfileEditorDraft;
+/** Validate locally before merging the child form into the root transaction. */
+export declare function finishProfileEditor(editor: ProfileEditorDraft): {
+    profile?: ModelProfile;
+    error?: string;
+    field?: string;
+};
+/** 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;
+/** 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. */
+export declare function modelProfileReducer(state: ModelProfileState, action: ModelProfileAction): ModelProfileState;

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

@@ -0,0 +1,119 @@
+import { randomUUID } from 'node:crypto';
+import { emptyModelProfiles, duplicateModelProfile, normalizeModelProfiles, validateModelProfiles } from '../../config/model-profiles.js';
+/** 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: '',
+        credentialMode: profile.apiKey ? 'keep' : 'shared', endpointChanged: false };
+}
+/** Validate locally before merging the child form into the root transaction. */
+export function finishProfileEditor(editor) {
+    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 };
+    const library = { ...emptyModelProfiles(), entries: [profile] };
+    const issue = validateModelProfiles(library)[0];
+    if (issue)
+        return { error: issue.message, field: issue.path.split('.').at(-1) };
+    return { profile: normalizeModelProfiles(library).entries[0] };
+}
+/** Make an isolated root draft; opening the screen never mutates live config. */
+export function createModelProfileState(draft) {
+    const copy = structuredClone(draft);
+    if (validateModelProfiles(copy.profiles).length
+        || validateModelProfiles(copy.baseline.modelProfiles).length) {
+        copy.profiles = undefined;
+        copy.readError = 'invalid_profiles';
+    }
+    return { draft: copy, page: 'root', role: 'main', returnPage: 'manager',
+        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' : '']
+        .filter(Boolean).join(' + ');
+}
+/** Adopt persisted fields only, resolving the old fast inheritance once. */
+export function createCustomProfile(draft, role) {
+    const file = draft.baseline;
+    const provider = (role === 'fast' ? file.fast?.provider : undefined)
+        || file.provider || 'anthropic';
+    const model = role === 'fast' ? file.fast?.model ?? '' : file.model ?? '';
+    const baseUrl = role === 'fast' && !model ? null
+        : (role === 'fast' ? file.fast?.baseUrl
+            || (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 };
+}
+function editField(state, action) {
+    if (!state.editor)
+        return state;
+    const editor = { ...state.editor, [action.field]: action.value };
+    if (action.field === 'provider' || action.field === 'baseUrl') {
+        editor.apiKey = '';
+        editor.credentialMode = 'shared';
+        editor.endpointChanged = true;
+    }
+    if (action.field === 'credentialMode' && action.value !== 'replace')
+        editor.apiKey = '';
+    return { ...state, editor, error: undefined };
+}
+function mergeEditor(state) {
+    if (!state.editor)
+        return state;
+    const result = finishProfileEditor(state.editor);
+    if (!result.profile)
+        return { ...state, error: result.error };
+    const library = state.draft.profiles ?? emptyModelProfiles();
+    const exists = library.entries.some((entry) => entry.id === result.profile.id);
+    if (!exists && library.entries.length >= 200)
+        return { ...state,
+            error: 'Maximum 200 profiles. Delete an unused profile first.' };
+    const profiles = { ...library, entries: exists
+            ? library.entries.map((entry) => entry.id === result.profile.id ? result.profile : entry)
+            : [...library.entries, result.profile] };
+    const merged = { ...state, draft: { ...state.draft, profiles }, dirty: true,
+        editor: undefined, page: state.returnPage, error: undefined };
+    return state.bindNew ? modelProfileReducer(merged, { type: 'select', role: state.role, id: result.profile.id }) : merged;
+}
+/** All child actions modify only the root draft; persistence belongs to Save. */
+export function modelProfileReducer(state, action) {
+    const library = state.draft.profiles ?? emptyModelProfiles();
+    switch (action.type) {
+        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 'edit': return { ...state, editor: createProfileEditor(action.profile), page: 'editor',
+            returnPage: state.page === 'picker' ? 'picker' : 'manager',
+            bindNew: action.bindNew ?? false, error: undefined };
+        case 'editor-field': return editField(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 'cancel-editor': return { ...state, editor: undefined, page: state.returnPage,
+            error: undefined };
+        case 'duplicate': {
+            if (library.entries.length >= 200)
+                return { ...state,
+                    error: 'Maximum 200 profiles. Delete an unused profile first.' };
+            const original = library.entries.find((entry) => entry.id === action.id);
+            return original ? { ...state, dirty: true, draft: { ...state.draft,
+                    profiles: { ...library, entries: [...library.entries, duplicateModelProfile(original)] } } }
+                : 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 };
+        }
+        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/render-cache.d.ts

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -50,7 +50,7 @@ export interface RenderCacheStats {
     misses: number;
 }
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`

package/dist/ui/render-cache.js

@@ -12,7 +12,7 @@
  *   - `Markdown` re-split and re-regexed the whole answer into one React element
  *     per line on every render.
  *
- * Everything cached here is a function of its INPUT STRING ALONE. Theme and
+ * Cached text depends on its input and, for highlighting, the color level. Theme and
  * glyphs are applied at render time and are never cached, because a themed
  * React element in a cache makes `/theme` a no-op until the entry evicts (K-5) —
  * exactly the class of silent bug this package writes comments to avoid.
@@ -22,6 +22,7 @@
  * caches would miss precisely when a scroll brings an old entry back.
  */
 import { highlight } from 'cli-highlight';
+import { syntaxColorLevel } from './color-runtime.js';
 import { parseMarkdownBlocks } from './markdown-blocks.js';
 import { pickGlyphs } from './glyphs.js';
 export const RENDER_CACHE_LIMITS = {
@@ -113,7 +114,7 @@ const markdownCache = new LruCache(RENDER_CACHE_LIMITS.markdownEntries, RENDER_C
  */
 const lineCache = new LruCache(RENDER_CACHE_LIMITS.linesEntries, RENDER_CACHE_LIMITS.markdownBytes);
 /**
- * Syntax-highlight `code`, memoised on `(lang, code)`.
+ * Syntax-highlight `code`, memoised on `(colorLevel, lang, code)`.
  *
  * `cli-highlight` emits chalk-level ANSI that does not depend on `theme.*`, so
  * unlike a rendered element this string IS safe to cache across a `/theme`
@@ -129,7 +130,7 @@ export function highlightCached(code, lang) {
     // ripgrep, which silently hides every definition in it from the tool this
     // codebase navigates itself with. NUL rather than a space because a space
     // still lets ("a b", "ts") and ("b", "ts a") collide on one key.
-    const key = `${lang}\u0000${code}`;
+    const key = `${syntaxColorLevel()}\u0000${lang}\u0000${code}`;
     const hit = highlightCache.get(key);
     if (hit !== undefined)
         return hit;

package/dist/ui/run-status-row.d.ts

@@ -1,24 +1,12 @@
-/**
- * The run status row's width plan (tui-scrollbar-edge-and-run-row §3.3.3).
- *
- * While a run is in flight, ONE row above the input box carries the spinner, the
- * phrase and the `steer / interrupt / exit` hint clauses, and `planRunRow` decides
- * what survives when the line is too narrow. It is a pure function with no React
- * and no I/O so the whole ladder can be tested as arithmetic.
- *
- * THE ALLOCATION IS PER CLAUSE, NOT PER STRING, and that is the whole point.
- * The idle hint row this one replaces owned the full line width and ended in
- * `wrap="truncate"`; handing the label half the line and truncating the joined
- * hint would cut `interrupt` to `inter...` at 38 columns - a regression of the
- * "running hint is NEVER abbreviated" rule `Composer.hintText` documents. So:
- *
- *  - clauses are dropped WHOLE, from the tail (`exit`, then `stop N`), and
- *  - `steer` and `interrupt` (REQUIRED_CLAUSES) are never dropped or cut mid-word
- *    while the row is enabled, and
- *  - the only thing allowed to end in an ellipsis is the label.
+/** Compatibility planner for former composer run rows. The current UI uses
+ * status-layout.ts and interaction-hints.ts; keep this pure API for existing callers.
  */
-/** Everything the label needs, kept in one shape so there is one place that names it. */
+import type { StatusLayoutInput } from './layout/status-layout.js';
+/** Shared activity facts; omitted phase fields retain the legacy phrase behavior. */
 export interface RunActivity {
+    phase?: StatusLayoutInput['phase'];
+    outcome?: StatusLayoutInput['runOutcome'];
+    activeTool?: StatusLayoutInput['activeTool'];
     /** Epoch ms the current run began - the phrase sequence's seed. */
     startedAt: number;
     /** `Date.now() - startedAt`, already computed by App's 200 ms ticker. */