@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/src/command-screens.js

@@ -0,0 +1,601 @@
+import { executeCommand } from './commands.js';
+import { PERMISSION_OPTIONS } from './permissions.js';
+import { editProviderSettings } from './provider-settings.js';
+import { retireRemovedCodexAccounts, retireUnsavedCodexAccounts } from './codex-auth.js';
+import { droppedAnthropicAccounts, retireAnthropicAccounts } from './anthropic-console-auth.js';
+import { importProvidersFromRemote } from './provider-import.js';
+import { DEFAULT_HARNESS, listGraphs } from './graphs.js';
+import { graphStorageDirectory } from './graph-account.js';
+import { configuredGraphSelection, currentGraphSubject, saveGraphSelection } from './graph-selection.js';
+import { getMembership, loadAccessibleGraph, requireGraphMembership, ANDORRA_GRAPH_SELECTION } from './membership.js';
+import { FREE_CUSTOM_GRAPH_LIMIT, FREE_GRAPH_LIMIT_MESSAGE, readGraphQuota } from './graph-quota.js';
+import { GraphProviderUnavailableError } from './graph-provider-portability.js';
+import { confirmAndApplyModelOverride } from './model-override.js';
+import { reconcileSubagentPair } from './config.js';
+import { applyModelContextWindow, createAdapter, providerLabel, providerModels, recordProviderModel } from './providers.js';
+import { configDirectory } from './config.js';
+import { listBundles, installBundle, removeBundle, removeBundleTransactional, setBundleEnabled, validateMcpServer } from './extensions.js';
+import { join } from 'node:path';
+export function isScreenCommand(line) {
+    return ['/model', '/providers', '/graph', '/usage', '/permissions', '/skills', '/plugins', '/mcp', '/subagent'].includes(line.trim());
+}
+/**
+ * The picker entry that clears the saved external-subagent pair.
+ *
+ * A provider id may hold only word characters and dashes, so this sentinel is outside that
+ * domain: a provider named the same as the sentinel would be read as the clear action.
+ */
+const CLEAR_SUBAGENT_SELECTION = '*clear*';
+export async function runCommandScreen(line, state, ui, persist, signal, adapterFactory = createAdapter, graphAccess = { load: loadAccessibleGraph, requirePaid: requireGraphMembership, membership: getMembership }, openGraphBuilder, graphSubject = currentGraphSubject) {
+    const unchanged = { clear: false };
+    if (!isScreenCommand(line) || signal.aborted)
+        return unchanged;
+    const command = line.trim();
+    const provider = state.config.providers.find(item => item.id === state.config.provider);
+    const save = async (draft) => {
+        signal.throwIfAborted();
+        // A Codex account slot belongs to the entry that named it, and only a committed save can say
+        // that entry is gone: retiring ahead of the write would sign the account out for a deletion
+        // the disk then refused.
+        const previousProviders = [...state.config.providers];
+        // The saved subagent pair follows the providers: a provider edit that removes the provider
+        // the pair names, or the model it selected, would otherwise be refused for a setting the
+        // editor never touched, and the edit could not be saved at all.
+        const reconciled = reconcileSubagentPair(draft);
+        try {
+            await persist(reconciled);
+        }
+        catch {
+            // The write was refused, so an entry this draft added never became configured. A sign-in made
+            // while adding it created its slot home already, and nothing else can reach that account; the
+            // homes of the entries that are configured stay untouched.
+            await retireUnsavedCodexAccounts(reconciled.providers, state.config.providers, { signal });
+            await retireAnthropicAccounts(droppedAnthropicAccounts(reconciled.providers, state.config.providers)).catch(() => { });
+            if (!signal.aborted)
+                await ui.showScreen('Selection not saved', [
+                    'The configuration could not be saved. Your current selection is unchanged.',
+                    'Check the configuration directory permissions and available disk space, then try again.',
+                ], { signal });
+            return unchanged;
+        }
+        // Keep the object referenced by the CLI's run callback; commit only after disk succeeds.
+        Object.assign(state.config, reconciled);
+        await retireRemovedCodexAccounts(previousProviders, reconciled.providers, { signal }).catch(() => { });
+        await retireAnthropicAccounts(droppedAnthropicAccounts(previousProviders, reconciled.providers)).catch(() => { });
+        // A pair the reconciliation dropped is gone from the saved configuration, and it must be
+        // gone from the live one too: a later save would otherwise write the stale pair back.
+        if (reconciled.externalSubagent === undefined)
+            delete state.config.externalSubagent;
+        return { clear: true };
+    };
+    try {
+        if (command === '/permissions') {
+            const current = state.permissions ?? (state.yolo ? 'full-access' : 'ask-for-approval');
+            const selected = await ui.select('Update Model Permissions', PERMISSION_OPTIONS.map((option, index) => ({ id: option.id, label: `${index + 1}. ${option.label}${option.id === current ? ' (current)' : ''}`, description: option.description })), { selectedId: current, description: 'Remembered for this workspace. Restricted commands require the Codex CLI OS sandbox.', signal });
+            if (selected === undefined || signal.aborted)
+                return unchanged;
+            await executeCommand(`/permissions ${selected}`, state, persist, signal);
+            return unchanged;
+        }
+        if (command === '/subagent') {
+            if (!state.config.providers.length) {
+                await ui.showScreen('Add a provider', ['The external subagent setting names a configured provider and one of its models.', 'Open /providers and choose Add provider first.'], { signal });
+                return unchanged;
+            }
+            const current = state.config.externalSubagent;
+            const providerPicked = await ui.select('External subagent provider', [
+                ...state.config.providers.map(item => {
+                    const models = providerModels(item);
+                    return { id: item.id, label: `${providerLabel(item, state.config.providers)} (${item.type})`, description: `Models: ${models.slice(0, 4).join(', ')}${models.length > 4 ? '…' : ''}`, ...(current?.provider === item.id ? { bold: true } : {}) };
+                }),
+                // The clear entry sits outside the provider id domain, which is word characters and
+                // dashes: a provider may legally be named __clear__, and the picker would then read
+                // the provider as the clear action.
+                ...(current === undefined ? [] : [{ id: CLEAR_SUBAGENT_SELECTION, label: 'Clear the setting', description: 'External hosts will be asked to pick a provider/model on every run.', separator: true }]),
+            ], { ...(current ? { selectedId: current.provider } : {}), description: 'The provider and model external hosts (Claude CLI, Codex CLI) must use to run Andorra as a subagent. Mandatory: without a saved pair they receive PROVIDER_NOT_SET.', signal });
+            if (providerPicked === undefined || signal.aborted)
+                return unchanged;
+            if (providerPicked === CLEAR_SUBAGENT_SELECTION) {
+                const cleared = structuredClone(state.config);
+                delete cleared.externalSubagent;
+                signal.throwIfAborted();
+                try {
+                    await persist(cleared);
+                }
+                catch {
+                    if (!signal.aborted)
+                        await ui.showScreen('Selection not saved', ['The configuration could not be saved. Your current selection is unchanged.'], { signal });
+                    return unchanged;
+                }
+                delete state.config.externalSubagent;
+                return unchanged;
+            }
+            const target = state.config.providers.find(item => item.id === providerPicked);
+            // Discovery is best effort: a provider whose endpoint will not list models still offers its
+            // configured ones, so the setting never depends on the endpoint answering.
+            let discovered = [];
+            try {
+                const listed = await ui.loadScreen('Models', async (loadSignal) => {
+                    const adapter = adapterFactory(target);
+                    if (!adapter.listModels)
+                        throw new Error('Model discovery unavailable');
+                    return adapter.listModels(loadSignal);
+                }, { description: `Loading available models from ${providerLabel(target, state.config.providers)}`, signal });
+                discovered = [...new Set(listed)].filter(id => typeof id === 'string' && id.trim().length > 0);
+            }
+            catch {
+                discovered = [];
+            }
+            if (signal.aborted)
+                return unchanged;
+            const configured = providerModels(target);
+            const available = [...new Set([...discovered, ...configured])];
+            if (!available.length) {
+                await ui.showScreen('No models available', [
+                    `${target.id} returned no models and has none configured.`,
+                    'Use /subagent <provider> <model> to set an exact model id, or configure the provider in /providers.',
+                ], { signal });
+                return unchanged;
+            }
+            const modelPicked = await ui.select('External subagent model', available.map(id => ({
+                id, label: configured.includes(id) && !discovered.includes(id) ? `${id} (configured)` : id,
+                ...(current?.provider === target.id && current.model === id ? { bold: true } : {}),
+            })), { selectedId: current?.provider === target.id ? current.model : target.model, description: `Provider: ${providerLabel(target, state.config.providers)}`, signal });
+            if (modelPicked === undefined || signal.aborted)
+                return unchanged;
+            const draft = structuredClone(state.config);
+            const picked = draft.providers.find(item => item.id === target.id);
+            if (picked?.models !== undefined && !picked.models.includes(modelPicked)) {
+                // The provider lists its models explicitly and the pick came from the endpoint own
+                // listing, so the provider learns it: the saved pair names a model it does not have
+                // otherwise, and the configuration would refuse it.
+                picked.models = [...picked.models, modelPicked];
+            }
+            draft.externalSubagent = { provider: target.id, model: modelPicked };
+            signal.throwIfAborted();
+            try {
+                await persist(draft);
+            }
+            catch {
+                if (!signal.aborted)
+                    await ui.showScreen('Selection not saved', ['The configuration could not be saved. Your current selection is unchanged.'], { signal });
+                return unchanged;
+            }
+            Object.assign(state.config, draft);
+            return unchanged;
+        }
+        if (command === '/skills' || command === '/plugins' || command === '/mcp') {
+            return await runExtensionScreen(command, state, ui, async (draft) => {
+                signal.throwIfAborted();
+                await persist(draft);
+                Object.assign(state.config, draft);
+                return { clear: true };
+            }, signal);
+        }
+        if (command === '/model' && !provider) {
+            await ui.showScreen('Add a provider', ['Open /providers and choose Add provider first.'], { signal });
+            return unchanged;
+        }
+        if (command === '/model') {
+            let models;
+            try {
+                models = await ui.loadScreen('Models', async (loadSignal) => {
+                    const adapter = adapterFactory(provider);
+                    if (!adapter.listModels)
+                        throw new Error('Model discovery unavailable');
+                    return adapter.listModels(loadSignal);
+                }, { description: `Loading available models from ${providerLabel(provider, state.config.providers)}`, signal });
+            }
+            catch (error) {
+                if (!signal.aborted && !(error instanceof Error && error.name === 'AbortError'))
+                    await ui.showScreen('Models unavailable', [
+                        `Could not load models from ${provider.id}.`,
+                        'Check the provider endpoint, credentials, and connection in /providers (Right Arrow or e to edit).',
+                        'Return to the conversation and enter /model to retry, or /model <id> to set an exact model ID.',
+                    ], { signal });
+                return unchanged;
+            }
+            if (models === undefined || signal.aborted)
+                return unchanged;
+            const discovered = [...new Set(models)].filter(id => typeof id === 'string' && id.trim().length > 0);
+            if (!discovered.length) {
+                await ui.showScreen('No models available', [
+                    `${provider.id} returned an empty model list.`,
+                    'Start or load a model on the server, or check your account access.',
+                    'Use /providers to edit the provider, then /model to retry.',
+                ], { signal });
+                return unchanged;
+            }
+            // A model the user configured for this provider stays selectable even when the endpoint did not
+            // list it, so switching among saved models never depends on discovery agreeing with them.
+            const configured = providerModels(provider).filter(id => !discovered.includes(id));
+            const available = [...discovered, ...configured];
+            const selected = await ui.select('Models', available.map(id => ({ id, label: configured.includes(id) ? `${id} (configured)` : id })), {
+                selectedId: provider.model, description: `Provider: ${providerLabel(provider, state.config.providers)} | Current model: ${provider.model}`, signal,
+            });
+            if (selected === undefined || signal.aborted)
+                return unchanged;
+            if (!available.includes(selected))
+                throw new Error('Invalid model selection');
+            // The graph override runs even when the chosen model is the provider's current one: a graph
+            // whose providers are gone is repaired by exactly this flow, and the header sends the user
+            // here — a no-op for "no change" would strand a provider that offers only that model.
+            let overrideApplied = false;
+            if (state.graph) {
+                // The graph is saved before the config draft: a declined or failed override leaves both untouched.
+                const outcome = await confirmAndApplyModelOverride({
+                    graphId: state.graph,
+                    target: { provider: state.config.provider, model: selected },
+                    configProviders: state.config.providers.map(item => ({ id: item.id, type: item.type, model: item.model })),
+                    // The override replaces every provider reference in the graph, so binding the graph to
+                    // this machine's providers first is work the rewrite discards — and it is what refused
+                    // the repair on exactly the graphs that need it, the ones naming providers that are gone.
+                    loadGraph: (id, graphSignal) => graphAccess.load(id, graphSignal, undefined, { bindProviders: false }),
+                    resolveDirectory: async () => graphStorageDirectory(undefined, await graphSubject()),
+                    confirm: async (question) => {
+                        const choice = await ui.select('Override graph models?', [
+                            { id: 'override', label: `Override every node with ${state.config.provider}/${selected}`, description: 'Saves the graph; every node and delegation follows this model.' },
+                            { id: 'keep', label: 'Keep the models selected in the graph', description: 'Cancels this model change; nothing is saved.' },
+                        ], { description: question, signal });
+                        return choice === 'override';
+                    },
+                    signal,
+                });
+                if (outcome.status === 'declined')
+                    return unchanged;
+                if (outcome.status === 'failed') {
+                    if (!signal.aborted)
+                        await ui.showScreen('Model not changed', [outcome.text], { signal });
+                    return unchanged;
+                }
+                overrideApplied = outcome.status === 'applied';
+            }
+            // No provider setting changes when the model already is the current one; the override above
+            // is the only work there was to do. An applied rewrite still clears, so the caller refreshes
+            // the graph and the header hint exactly as a model change does.
+            if (selected === provider.model)
+                return overrideApplied ? { clear: true } : unchanged;
+            const draft = structuredClone(state.config);
+            const next = draft.providers.find(item => item.id === draft.provider);
+            // The previous active model stays configured and the choice joins it, so both remain offered;
+            // recording must precede the switch or the list would never hold the model it replaces.
+            recordProviderModel(next, selected);
+            next.model = selected;
+            applyModelContextWindow(next, selected);
+            delete next.reasoningEffort;
+            return await save(draft);
+        }
+        if (command === '/providers') {
+            while (!signal.aborted) {
+                const selected = await ui.select('Providers', [
+                    ...state.config.providers.map(item => ({ id: item.id, label: providerLabel(item, state.config.providers) })),
+                    { id: ':add', label: '+ Add provider' },
+                    { id: ':import', label: 'Import from remote connection' },
+                ], { selectedId: state.config.provider, editPrefix: ':edit:', footer: 'Up/Down Move | Enter Select | Right/e Edit | Esc Back', signal });
+                if (selected === undefined || signal.aborted)
+                    return unchanged;
+                if (selected === ':import') {
+                    // The importer returns a draft of its own or nothing; like the editor, only a returned
+                    // draft reaches the save path, so an escaped import never writes.
+                    const draft = await importProvidersFromRemote(state.config, ui, signal);
+                    if (draft)
+                        return await save(draft);
+                    continue;
+                }
+                if (selected === ':add' || selected.startsWith(':edit:')) {
+                    const id = selected === ':add' ? undefined : selected.slice(6);
+                    if (id && !state.config.providers.some(item => item.id === id))
+                        throw new Error('Invalid provider selection');
+                    const draft = await editProviderSettings(state.config, id, ui, signal);
+                    if (draft)
+                        return await save(draft);
+                    continue;
+                }
+                if (selected === state.config.provider)
+                    return unchanged;
+                if (!state.config.providers.some(item => item.id === selected))
+                    throw new Error('Invalid provider selection');
+                const draft = structuredClone(state.config);
+                draft.provider = selected;
+                return await save(draft);
+            }
+            return unchanged;
+        }
+        if (command === '/graph') {
+            const subject = await graphSubject();
+            await graphAccess.requirePaid(signal);
+            const directory = await graphStorageDirectory(undefined, subject);
+            const saved = await listGraphs(directory);
+            if (signal.aborted)
+                return unchanged;
+            // A free account that already holds its one custom graph cannot create another; the entry stays
+            // so the reason is one keypress away.
+            const access = await graphAccess.membership?.(signal);
+            const free = access !== undefined && !access.paid && !access.unavailable && access.subject !== undefined;
+            const atLimit = free && (await readGraphQuota(directory, saved)).customGraphs >= FREE_CUSTOM_GRAPH_LIMIT;
+            const items = [{
+                    id: DEFAULT_HARNESS.id,
+                    label: 'Default',
+                    description: 'Software Engineer only. Reads project instructions and completes the task without an Orchestrator.',
+                }, { id: ANDORRA_GRAPH_SELECTION, label: 'Andorra', description: free ? 'Premium workflow: Orchestrator -> Software Engineer -> Done' : 'Paid workflow: Orchestrator -> Software Engineer -> Done' }, ...saved.filter(graph => graph.id !== 'default').map(graph => ({ id: graph.id, label: `${graph.name} (${graph.id}@${graph.revision})`, description: 'Saved custom graph' })), { id: ':divider', label: '', separator: true }, { id: ':create', label: 'Create new graph', description: atLimit ? 'Free tier includes 1 custom graph. Upgrade to Premium for more graphs.' : 'Open the web graph builder' }, { id: ':edit', label: 'Edit Graphs', bold: true, description: 'Open saved graphs in the web graph builder' }];
+            while (!signal.aborted) {
+                const selected = await ui.select('Graph', items, { selectedId: state.graph ?? DEFAULT_HARNESS.id, description: 'Choose and save your default graph for this account, or create one in the web builder. After saving, reopen /graph to select it.', signal });
+                if (selected === undefined || signal.aborted)
+                    return unchanged;
+                if (selected === ':create' && atLimit) {
+                    await ui.showScreen('Graph limit reached', [FREE_GRAPH_LIMIT_MESSAGE, 'Open Edit Graphs to change the graph you have.'], { signal });
+                    continue;
+                }
+                if (selected === ':create' || selected === ':edit') {
+                    if (!openGraphBuilder)
+                        throw new Error('Graph builder is unavailable in this session. Run andorra graph.');
+                    await openGraphBuilder(signal, selected === ':edit' ? 'edit' : 'new');
+                    return unchanged;
+                }
+                // Switching graphs discards the work the previous graph accumulated for this session, so
+                // the confirmation states what is lost before anything is applied. Choosing "Keep current
+                // graph" returns to the list with state untouched; reselecting the graph already in use
+                // never asks and never clears.
+                const changed = selected !== (state.graph ?? 'default');
+                if (changed) {
+                    const name = selected === 'default' ? DEFAULT_HARNESS.name
+                        : selected === ANDORRA_GRAPH_SELECTION ? 'Andorra'
+                            : saved.find(graph => graph.id === selected).name;
+                    const confirmation = await ui.select(`Switch to ${name}?`, [
+                        { id: 'switch', label: `Switch to ${name}`, description: 'Use this graph for subsequent tasks and start fresh.' },
+                        { id: 'back', label: 'Keep current graph', description: 'Return to the graph list. Nothing changes.' },
+                    ], { selectedId: 'back', description: `Switching graphs clears the previous graph progress and starts fresh. This session's context and todo list are cleared; session usage totals are retained.`, signal });
+                    if (signal.aborted)
+                        return unchanged;
+                    if (confirmation !== 'switch') {
+                        if (confirmation === 'back')
+                            continue;
+                        return unchanged;
+                    }
+                }
+                // A graph that cannot bind to this machine's providers stays selectable: the user chose
+                // what a task will run, and it is the run — after the graph is in place — that refuses
+                // those references. The failure is held as a warning the saved selection is reported
+                // under; membership and storage errors still refuse the selection outright.
+                let unavailable;
+                if (selected !== 'default') {
+                    if (selected !== ANDORRA_GRAPH_SELECTION && !saved.some(graph => graph.id === selected))
+                        throw new Error('Invalid graph selection');
+                    try {
+                        await graphAccess.load(selected, signal);
+                    }
+                    catch (error) {
+                        if (!(error instanceof GraphProviderUnavailableError) || signal.aborted)
+                            throw error;
+                        unavailable = error.message;
+                    }
+                    if (signal.aborted)
+                        return unchanged;
+                }
+                if (await graphSubject() !== subject)
+                    throw new Error('Account changed. Reopen /graph to select a graph for the current account.');
+                if (signal.aborted)
+                    return unchanged;
+                if (configuredGraphSelection(state.config, subject) !== selected || state.config.graph !== undefined) {
+                    const draft = structuredClone(state.config);
+                    saveGraphSelection(draft, selected, subject);
+                    const result = await save(draft);
+                    if (!result.clear)
+                        return unchanged;
+                    delete state.config.graph;
+                }
+                if (selected === 'default')
+                    delete state.graph;
+                else
+                    state.graph = selected;
+                if (unavailable !== undefined)
+                    await ui.showScreen('Graph selected', [
+                        unavailable,
+                        'The graph is selected anyway. A task on it starts only once it can run on this machine, or after /model overrides every node with one provider you have.',
+                    ], { signal });
+                return { clear: changed };
+            }
+            return unchanged;
+        }
+        // Cache traffic is provider-reported; leave the lines out rather than implying
+        // a measured 0% hit rate when the provider does not report cache counts. A
+        // reported read with no input total still shows the count, just without a rate.
+        const cacheLines = (usage) => [
+            ...(usage.cacheRead
+                ? [`Cache-read tokens: ${usage.cacheRead.toLocaleString()}${usage.inputTokens > 0 ? ` (${Math.round(usage.cacheRead / usage.inputTokens * 100)}% of input)` : ''}`] : []),
+            ...(usage.cacheWrite ? [`Cache-write tokens: ${usage.cacheWrite.toLocaleString()}`] : []),
+        ];
+        const lines = [
+            'Session usage', `Model requests: ${state.usage.requests.toLocaleString()}`,
+            `Input tokens: ${state.usage.inputTokens.toLocaleString()}`, `Output tokens: ${state.usage.outputTokens.toLocaleString()}`,
+            ...cacheLines(state.usage),
+            `Total tokens: ${(state.usage.inputTokens + state.usage.outputTokens).toLocaleString()}`, '',
+            'Tokens are provider-reported. Missing usage is not estimated.', 'Cost: unavailable; no pricing assumptions.',
+        ];
+        if (state.lastRun) {
+            const last = state.lastRun;
+            lines.push('', 'Last run', `ID: ${last.id}`, `Status: ${last.status}`, ...(last.reason ? [`Reason: ${last.reason}`] : []), `Provider/model: ${last.provider}/${last.model}`, `Tool calls: ${last.toolCalls.toLocaleString()}`, `Model requests: ${last.usage.requests.toLocaleString()}`, `Input tokens: ${last.usage.inputTokens.toLocaleString()}`, `Output tokens: ${last.usage.outputTokens.toLocaleString()}`, ...cacheLines(last.usage));
+        }
+        else
+            lines.push('', 'No runs completed in this session.');
+        await ui.showScreen('Usage', lines, { signal });
+        return unchanged;
+    }
+    catch (error) {
+        if (signal.aborted || (error instanceof Error && error.name === 'AbortError'))
+            return unchanged;
+        throw error;
+    }
+}
+async function runExtensionScreen(command, state, ui, save, signal) {
+    let changed = false;
+    const ask = async (prompt, secret = false) => {
+        if (!ui.question)
+            throw new Error('This terminal does not support management input.');
+        return (await ui.question(prompt, { signal, cancelOnEscape: true, history: false, secret })).trim();
+    };
+    const confirm = (title, description) => ui.select(title, [
+        { id: 'cancel', label: 'Cancel' }, { id: 'confirm', label: 'Confirm' },
+    ], { selectedId: 'cancel', description, signal });
+    while (!signal.aborted) {
+        try {
+            if (command === '/mcp') {
+                const servers = Object.entries(state.config.mcpServers ?? {});
+                const selected = await ui.select('MCP servers', [
+                    { id: ':add', label: 'Add MCP server' },
+                    ...servers.map(([id, server]) => ({ id, label: `${server.enabled === false ? '[disabled]' : '[enabled]'} ${id}`,
+                        description: server.transport === 'stdio' ? `stdio | ${server.command}` : `HTTP | ${new URL(server.url).origin}` })),
+                ], { description: `Saved in ${join(configDirectory(), 'config.json')}. Changes apply to subsequent tasks.`, signal });
+                if (selected === undefined)
+                    break;
+                let id = selected;
+                let action = 'edit';
+                if (selected === ':add') {
+                    id = await ask('Server name (letters, numbers, underscores and hyphens):');
+                    if (!/^[\w-]+$/.test(id) || ['__proto__', 'constructor', 'prototype'].includes(id))
+                        throw new Error('Use a nonempty server name containing only letters, numbers, underscores or hyphens, without reserved object names.');
+                    if (Object.hasOwn(state.config.mcpServers ?? {}, id))
+                        throw new Error('A server with that name already exists. Select it to edit.');
+                }
+                else {
+                    const server = state.config.mcpServers?.[id];
+                    if (!server)
+                        throw new Error('Invalid server selection');
+                    action = await ui.select(id, [
+                        { id: 'toggle', label: server.enabled === false ? 'Enable' : 'Disable' },
+                        { id: 'edit', label: 'Edit server' }, { id: 'delete', label: 'Delete server' },
+                    ], { description: 'MCP servers execute commands or make network requests when their tools are used.', signal });
+                    if (action === undefined)
+                        continue;
+                }
+                const draft = structuredClone(state.config);
+                draft.mcpServers ??= {};
+                if (action === 'delete') {
+                    if (await confirm('Delete MCP server?', id) !== 'confirm')
+                        continue;
+                    delete draft.mcpServers[id];
+                }
+                else if (action === 'toggle') {
+                    draft.mcpServers[id].enabled = draft.mcpServers[id].enabled === false;
+                }
+                else if (action === 'edit') {
+                    const old = draft.mcpServers[id];
+                    const transport = await ui.select('MCP transport', [
+                        { id: 'stdio', label: 'Local command (stdio)' }, { id: 'http', label: 'Streamable HTTP' },
+                    ], { selectedId: old?.transport, signal });
+                    if (transport === undefined)
+                        continue;
+                    const retain = (answer, previous) => answer || previous || '';
+                    let server;
+                    if (transport === 'stdio') {
+                        const prior = old?.transport === 'stdio' ? old : undefined;
+                        const executable = retain(await ask(`Command${prior ? ` (blank keeps ${prior.command})` : ''}:`), prior?.command);
+                        const args = JSON.parse(retain(await ask('Arguments as JSON array (blank keeps current, default []):'), JSON.stringify(prior?.args ?? [])));
+                        const env = JSON.parse(retain(await ask('Environment as JSON object (blank keeps current, default {}; prefer environment variable references):', true), JSON.stringify(prior?.env ?? {})));
+                        server = { transport, command: executable, args, env, enabled: old?.enabled ?? true };
+                    }
+                    else if (transport === 'http') {
+                        const prior = old?.transport === 'http' ? old : undefined;
+                        const url = retain(await ask('HTTP endpoint URL (blank keeps current):'), prior?.url);
+                        const headers = JSON.parse(retain(await ask('Headers as JSON object (use ${ENV_VAR} for secrets; blank keeps current, default {}):', true), JSON.stringify(prior?.headers ?? {})));
+                        server = { transport, url, headers, enabled: old?.enabled ?? true };
+                    }
+                    else
+                        throw new Error('Invalid transport selection');
+                    draft.mcpServers[id] = validateMcpServer(server);
+                }
+                else
+                    throw new Error('Invalid server action');
+                changed = (await save(draft)).clear || changed;
+            }
+            else {
+                const kind = command === '/skills' ? 'skills' : 'plugins';
+                const title = kind === 'skills' ? 'Skills' : 'Plugins';
+                const notices = [];
+                const bundles = await listBundles(kind, state.config, { notices, signal });
+                const selected = await ui.select(title, [
+                    { id: ':install', label: `Install ${kind === 'skills' ? 'skill' : 'plugin'}` },
+                    { id: ':list', label: `List ${kind}` },
+                    ...bundles.map(bundle => ({ id: `:bundle:${bundle.id}`, label: `${bundle.enabled ? '[enabled]' : '[disabled]'} ${bundle.name}`, description: bundle.description })),
+                ], { description: `Local directory: ${join(configDirectory(), kind)}. Changes apply to subsequent tasks.${notices.length ? ' ' + notices.join(' ') : ''}`, signal });
+                if (selected === undefined)
+                    break;
+                if (selected === ':list') {
+                    await ui.showScreen(title, [...notices, ...(bundles.length ? bundles.flatMap(bundle => [
+                            `${bundle.name} (${bundle.id}) — ${bundle.enabled ? 'enabled' : 'disabled'}`, bundle.description, bundle.path, '',
+                        ]) : [`No ${kind} installed. Choose Install to add one.`])], { signal });
+                    continue;
+                }
+                const draft = structuredClone(state.config);
+                if (selected === ':install') {
+                    const source = await ask('Local directory or https://github.com/owner/repo[/tree/ref/path] (optional #ref):');
+                    if (!source)
+                        continue;
+                    if (await confirm(`Install ${kind}?`, `Source: ${source}. Only install extensions you trust; enabled content can add instructions and MCP tools.`) !== 'confirm')
+                        continue;
+                    let pending;
+                    let accepted = false;
+                    let installed;
+                    try {
+                        installed = await ui.loadScreen(`Installing ${kind}`, loadSignal => (pending = installBundle(kind, source, draft, loadSignal)), { signal, description: source });
+                        accepted = installed !== undefined;
+                    }
+                    finally {
+                        if (!accepted && pending) {
+                            const discarded = await pending.catch(() => undefined);
+                            if (discarded)
+                                await removeBundle(kind, discarded.id, structuredClone(draft));
+                        }
+                    }
+                    if (!installed)
+                        continue;
+                    try {
+                        await save(draft);
+                    }
+                    catch (error) {
+                        try {
+                            await removeBundle(kind, installed.id, structuredClone(draft));
+                        }
+                        catch {
+                            changed = true;
+                            throw new Error('Configuration save failed and installation rollback failed. The extension remains on disk; return to the manager to remove it.');
+                        }
+                        throw new Error('Configuration save failed. The installation was rolled back; check directory permissions and disk space, then retry.');
+                    }
+                    changed = true;
+                    await ui.showScreen(`${title} installed`, [installed.name, installed.path, 'Available to subsequent tasks.'], { signal });
+                }
+                else {
+                    const bundle = bundles.find(item => `:bundle:${item.id}` === selected);
+                    if (!bundle)
+                        throw new Error('Invalid extension selection');
+                    const action = await ui.select(bundle.name, [
+                        { id: 'toggle', label: bundle.enabled ? 'Disable' : 'Enable' },
+                        { id: 'remove', label: 'Uninstall' },
+                    ], { description: bundle.description, signal });
+                    if (action === undefined)
+                        continue;
+                    if (action === 'toggle')
+                        setBundleEnabled(kind, bundle.id, !bundle.enabled, draft);
+                    else if (action === 'remove') {
+                        if (await confirm('Uninstall extension?', `${bundle.name}: ${bundle.path}`) !== 'confirm')
+                            continue;
+                        await removeBundleTransactional(kind, bundle.id, draft, async () => { await save(draft); changed = true; });
+                        continue;
+                    }
+                    else
+                        throw new Error('Invalid extension action');
+                    changed = (await save(draft)).clear || changed;
+                }
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                break;
+            if (error instanceof Error && error.name === 'AbortError')
+                continue;
+            await ui.showScreen('Management action failed', [error instanceof SyntaxError ? 'Invalid JSON. Enter a JSON array for arguments or a JSON object for environment/headers.' : error instanceof Error ? error.message : 'Unknown error', 'Return to the manager to retry.'], { signal });
+        }
+    }
+    return { clear: changed };
+}