@alisio/alisio-code 0.1.0-alpha.10 → 0.1.0-alpha.11

package/dist/tui/app.js

@@ -8,8 +8,10 @@ import { ConnectInputPrompt } from "./connect-input.js";
 import { initialPanelState, reducePanel, visibleRows } from "./panel.js";
 import { summarizeAnswers } from "./questions.js";
 import { InteractiveQueue } from "./queue.js";
+import { settingsMenuRows } from "./settings.js";
+import { SettingsMenu } from "./settings-menu.js";
 import { SkillsManager } from "./skills-manager.js";
-import { addItem, COMMANDS, configuredProviderModelItems, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, shortenPath, shortId, summarizeToolArgs, } from "./state.js";
+import { addItem, COMMANDS, configuredProviderModelItems, formatContext, formatDuration, formatTokens, hostOf, initialViewState, itemsFromHistory, lastAssistantText, mcpServerItems, mcpToolItems, parseCommand, pluginCatalogItems, pluginToggleNeedsConfirmation, providerModelItems, reduceEvent, reservedCommandNames, resolveCommand, shortenPath, shortId, slashCompletionCommands, summarizeToolArgs, } from "./state.js";
 import { editorTheme, selectListTheme, style } from "./theme.js";
 const VERSION = loadVersion(import.meta.url);
 /** Inline selection list with type-to-filter, rendered above the editor. */
@@ -229,7 +231,7 @@ export async function runTui(options) {
     app.plugins.onStatusChange = () => tui.requestRender();
     const pickerSlot = new Container();
     const attachmentsBar = new AttachmentsBar(() => pendingAttachments);
-    const editor = new Editor(tui, editorTheme, { paddingX: 1 });
+    const editor = new Editor(tui, editorTheme, { paddingX: app.config.tui.paddingX });
     const bottom = new Container();
     bottom.addChild(pickerSlot);
     bottom.addChild(attachmentsBar);
@@ -323,7 +325,7 @@ export async function runTui(options) {
         })
             .catch(() => { });
     };
-    let busy = false, controller, pending, picker;
+    let busy = false, controller, pending, picker, settingsMenu;
     const showPicker = (next) => {
         picker = next;
         pickerSlot.clear();
@@ -333,6 +335,7 @@ export async function runTui(options) {
     };
     const closePicker = () => {
         picker = undefined;
+        settingsMenu = undefined;
         pickerSlot.clear();
         tui.setFocus(editor);
         tui.requestRender();
@@ -922,6 +925,125 @@ export async function runTui(options) {
         };
         openCatalog();
     };
+    /**
+     * Navigation rows at the bottom of `/settings`: they route to the existing managers and one-shot
+     * actions exactly like the old picker, so every prior entry stays reachable. `compact` and
+     * `stats` finish here and re-open the settings list (mirroring managePlugins' openCatalog loop);
+     * rows that delegate to another manager (provider/model, connect, plugins, skills, MCP) leave
+     * the list and that manager owns its Esc/back behavior.
+     */
+    const SETTINGS_NAVIGATION = [
+        {
+            id: "model",
+            label: "Provider & model",
+            description: "Switch the active provider and model",
+        },
+        {
+            id: "connect",
+            label: "Connect provider",
+            description: "Configure a provider and choose its active model",
+        },
+        {
+            id: "compact",
+            label: "Compact context now",
+            description: "Summarize older history with the current model, then return here",
+        },
+        { id: "plugins", label: "Plugins", description: "Browse and manage project plugins" },
+        { id: "skills", label: "Skills", description: "Browse and manage effective skills" },
+        { id: "mcp", label: "MCP servers", description: "Browse and manage MCP servers" },
+        {
+            id: "stats",
+            label: "Session statistics",
+            description: "View session statistics, then return here",
+        },
+    ];
+    /**
+     * Central `/settings` (`/prefs`) menu: an OpenCode-style list of REAL, wired preferences
+     * (compaction, context fallback, MCP consent, limits, editor padding) with a live type-to-search
+     * filter, Enter/Space to cycle a value, a `(n/total)` counter, and a footer describing the
+     * highlighted row. Esc returns to the editor. Every setting persists to the GLOBAL user config
+     * through `app.updateSetting` (or the MCP consent path) and is applied to the running process
+     * where supported; rows rebuild from the live config after each change.
+     */
+    const openSettings = () => {
+        const providerName = app.providers.get(activeProvider?.id ?? "")?.name;
+        const current = view.model
+            ? providerName
+                ? `${providerName} · ${view.model}`
+                : view.model
+            : "";
+        const build = () => settingsMenuRows({
+            config: app.config,
+            mcpAllowPersisted: app.mcpAllowPersisted(),
+            readOnly: !!options.readOnly,
+        }, SETTINGS_NAVIGATION);
+        const applySetting = (row, value) => {
+            const settle = () => settingsMenu?.refresh(build());
+            if (row.id === "mcp.allow") {
+                const consent = value === true ? app.rememberGlobalMcpConsent() : app.revokeGlobalMcpConsent();
+                void consent
+                    .then(() => notice(value === true
+                    ? "MCP consent remembered globally (mcp.allow); enabled servers will auto-connect on every start. Use /mcp to connect them now."
+                    : "Global MCP consent revoked: runtime permission dropped and configured servers disconnected."))
+                    .catch(error)
+                    .finally(settle);
+                return;
+            }
+            const stored = row.id === "limits.timeoutMs" ? Number(value) * 1000 : value;
+            void app
+                // Setting ids are the exact SettableSettingKey paths SETTINGS_DEFINITIONS is built from.
+                .updateSetting(row.id, stored)
+                .then(() => {
+                if (row.id === "tui.paddingX")
+                    editor.setPaddingX(Number(value));
+                // Rebuild the slash provider: the toggle gates the skill:<id> entries immediately.
+                if (row.id === "tui.skillSlashCommands")
+                    editor.setAutocompleteProvider(buildSlashCompletionProvider());
+            })
+                .catch(error)
+                .finally(settle);
+        };
+        const navigate = (row) => {
+            switch (row.action) {
+                case "model":
+                    closePicker();
+                    return void chooseModel();
+                case "connect":
+                    closePicker();
+                    return void connect();
+                case "compact":
+                    closePicker();
+                    void task((signal) => app.runner.compact(session, { signal }))
+                        .catch(error)
+                        .then(openSettings);
+                    return;
+                case "plugins":
+                    closePicker();
+                    return managePlugins();
+                case "skills":
+                    closePicker();
+                    return manageSkills();
+                case "mcp":
+                    closePicker();
+                    return manageMcp();
+                case "stats":
+                    closePicker();
+                    info(statsReport());
+                    openSettings();
+                    return;
+                default:
+                    return openSettings();
+            }
+        };
+        const menu = new SettingsMenu("Settings", build(), applySetting, navigate, closePicker, [
+            current ? `Current: ${current}` : "",
+            ...(options.readOnly ? ["Read-only run: changes are not persisted"] : []),
+        ]
+            .filter(Boolean)
+            .join("\n") || undefined);
+        settingsMenu = menu;
+        showPicker(menu);
+    };
     const workspaceSessions = () => app.store.list().filter((s) => s.workspace === app.workspace && s.provider === app.provider.id);
     const firstPrompt = (id) => {
         const first = app.store.messages(id).find((m) => m.role === "user" && !m.summary);
@@ -1025,6 +1147,7 @@ export async function runTui(options) {
         "plugins",
         "skills",
         "mcp",
+        "settings",
         "compact",
         "clear",
         "resume",
@@ -1081,6 +1204,8 @@ export async function runTui(options) {
                     return manageSkills();
                 case "mcp":
                     return manageMcp();
+                case "settings":
+                    return openSettings();
                 case "compact":
                     return await task((signal) => app.runner.compact(session, { focus: parsed.args || undefined, signal }));
                 case "copy": {
@@ -1149,33 +1274,46 @@ export async function runTui(options) {
     editor.onSubmit = (text) => {
         void handleSubmit(text);
     };
-    editor.setAutocompleteProvider(new CombinedAutocompleteProvider([
-        ...COMMANDS,
-        ...[...app.prompts.templates.values()].map((t) => ({
-            name: t.name,
-            description: `${t.description} (template)`,
-            ...(t.argumentHint ? { argumentHint: t.argumentHint } : {}),
-        })),
-        ...[...app.plugins.commandInfo.entries()]
-            .filter(([name]) => !resolveCommand(name))
-            .map(([name, c]) => ({
-            name,
-            description: c.description ?? `plugin ${c.plugin}`,
-            ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
-        })),
-    ].map((c) => ({
-        name: c.name,
-        description: c.description,
-        ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
-        ...(c.name === "resume"
-            ? {
-                getArgumentCompletions: (prefix) => workspaceSessions()
-                    .filter((s) => s.id.startsWith(prefix))
-                    .slice(0, 20)
-                    .map((s) => ({ value: s.id, label: shortId(s.id), description: s.model })),
-            }
-            : {}),
-    })), app.workspace));
+    /**
+     * Builds the editor slash-autocomplete provider from the live config: `tui.skillSlashCommands`
+     * gates the standalone `skill:<id>` entries (the `/skills` manager always keeps its argument
+     * completion), so rebuilding after a settings save takes effect without a restart.
+     */
+    const buildSlashCompletionProvider = () => {
+        const sources = [
+            ...COMMANDS,
+            ...[...app.prompts.templates.values()].map((t) => ({
+                name: t.name,
+                description: `${t.description} (template)`,
+                ...(t.argumentHint ? { argumentHint: t.argumentHint } : {}),
+            })),
+            ...[...app.plugins.commandInfo.entries()]
+                .filter(([name]) => !resolveCommand(name))
+                .map(([name, c]) => ({
+                name,
+                description: c.description ?? `plugin ${c.plugin}`,
+                ...(c.argumentHint ? { argumentHint: c.argumentHint } : {}),
+            })),
+        ];
+        return new CombinedAutocompleteProvider(slashCompletionCommands(sources, {
+            sessions: (prefix) => workspaceSessions()
+                .filter((s) => s.id.startsWith(prefix))
+                .map((s) => ({ value: s.id, label: shortId(s.id), description: s.model })),
+            skills: app
+                .skillCatalog()
+                .map(({ id, name, displayId, description, scope, enabled, locked, effective }) => ({
+                id,
+                name,
+                displayId,
+                description,
+                scope,
+                enabled,
+                locked,
+                effective,
+            })),
+        }, { skillEntries: app.config.tui.skillSlashCommands !== false }), app.workspace);
+    };
+    editor.setAutocompleteProvider(buildSlashCompletionProvider());
     // Interactive services for plugins: choices (e.g. worktree isolation) and session views.
     app.plugins.setInteractiveUI({
         // No session/label/signal on SelectRequest: queued FIFO like everything else, never withdrawn

package/dist/tui/settings-menu.d.ts

@@ -0,0 +1,40 @@
+/**
+ * OpenCode-style settings menu for the TUI: two-column rows (name + current value), live
+ * type-to-search, Enter/Space to change a setting (or navigate), Esc to leave, a `(n/total)`
+ * counter and a footer with the highlighted row's description.
+ *
+ * This component is a thin shell: all decision logic (key decoding, filtering, cycling, counter)
+ * lives in the pure `settings.ts` module, which is fully unit-tested without pi-tui.
+ */
+import { type Component } from "@earendil-works/pi-tui";
+import { type SettingRow } from "./settings.ts";
+export declare class SettingsMenu implements Component {
+    private title;
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    private onChange;
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    private onNavigate;
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    private onCancel;
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    private detail?;
+    private full;
+    private filtered;
+    private state;
+    constructor(title: string, rows: SettingRow[], 
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    onChange: (row: SettingRow, value: unknown) => void, 
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    onNavigate: (row: SettingRow) => void, 
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    onCancel: () => void, 
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    detail?: string | undefined);
+    /** Rebuild rows from the live config after a write; keeps the filter and re-selects the row. */
+    refresh(rows: SettingRow[]): void;
+    /** Update the displayed value of one row without rebuilding the whole list. */
+    updateValue(id: string, value: unknown): void;
+    invalidate(): void;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}

package/dist/tui/settings-menu.js

@@ -0,0 +1,132 @@
+/**
+ * OpenCode-style settings menu for the TUI: two-column rows (name + current value), live
+ * type-to-search, Enter/Space to change a setting (or navigate), Esc to leave, a `(n/total)`
+ * counter and a footer with the highlighted row's description.
+ *
+ * This component is a thin shell: all decision logic (key decoding, filtering, cycling, counter)
+ * lives in the pure `settings.ts` module, which is fully unit-tested without pi-tui.
+ */
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { filterSettingRows, formatSettingValue, initialSettingsMenuState, reduceSettingsInput, settingsCounter, settingsKeyAction, } from "./settings.js";
+import { style } from "./theme.js";
+const MAX_VISIBLE = 10;
+const wrapText = (text, width) => {
+    const rows = [];
+    let row = "";
+    for (const word of text.split(/\s+/)) {
+        if (row && [...`${row} ${word}`].length > width) {
+            rows.push(row);
+            row = word;
+        }
+        else
+            row = row ? `${row} ${word}` : word;
+    }
+    if (row)
+        rows.push(row);
+    return rows;
+};
+export class SettingsMenu {
+    title;
+    onChange;
+    onNavigate;
+    onCancel;
+    detail;
+    full;
+    filtered;
+    state = initialSettingsMenuState();
+    constructor(title, rows, 
+    /** A setting value changed: persist and apply it. The host re-refreshes on success/failure. */
+    onChange, 
+    /** A navigation row was activated (Enter/Space): route to its manager. */
+    onNavigate, 
+    /** Esc pressed: leave the menu (the host returns to the editor). */
+    onCancel, 
+    /** Optional dim lines under the title (e.g. the current provider/model). */
+    detail) {
+        this.title = title;
+        this.onChange = onChange;
+        this.onNavigate = onNavigate;
+        this.onCancel = onCancel;
+        this.detail = detail;
+        this.full = rows;
+        this.filtered = rows;
+    }
+    /** Rebuild rows from the live config after a write; keeps the filter and re-selects the row. */
+    refresh(rows) {
+        const previous = this.filtered[this.state.selected]?.id;
+        this.full = rows;
+        this.filtered = filterSettingRows(rows, this.state.filter);
+        const index = previous ? this.filtered.findIndex((row) => row.id === previous) : -1;
+        this.state = { ...this.state, selected: index >= 0 ? index : 0 };
+    }
+    /** Update the displayed value of one row without rebuilding the whole list. */
+    updateValue(id, value) {
+        for (const row of this.full)
+            if (row.id === id)
+                row.current = value;
+    }
+    invalidate() { }
+    handleInput(data) {
+        const action = settingsKeyAction(data, this.state);
+        const { state, effect } = reduceSettingsInput(this.state, action, this.filtered);
+        this.state = state;
+        // Re-apply the live filter so typing narrows the list before the next render/input.
+        this.filtered = filterSettingRows(this.full, state.filter);
+        switch (effect.type) {
+            case "change":
+                // Optimistically reflect the new value; the host refreshes from the config on success.
+                effect.row.current = effect.value;
+                this.onChange(effect.row, effect.value);
+                break;
+            case "navigate":
+                this.onNavigate(effect.row);
+                break;
+            case "cancel":
+                this.onCancel();
+                break;
+            case "none":
+                break;
+        }
+    }
+    render(width) {
+        const lines = [truncateToWidth(style.bold(style.yellow(this.title)), width)];
+        if (this.detail?.trim())
+            for (const line of wrapText(this.detail, Math.max(20, width - 2)))
+                lines.push(truncateToWidth(style.dim(`  ${line}`), width));
+        if (this.state.filter)
+            lines.push(truncateToWidth(style.dim(`  filter: ${this.state.filter}`), width));
+        const rows = this.filtered;
+        if (!rows.length) {
+            lines.push(truncateToWidth(style.yellow(this.full.length ? "  No matching settings" : "  No settings available"), width));
+            lines.push("");
+            lines.push(truncateToWidth(style.dim("  Type to search · Esc to cancel"), width));
+            return lines;
+        }
+        // Two-column layout: labels padded to the widest row (capped), values right beside them.
+        const maxLabel = Math.min(36, Math.max(...rows.map((row) => [...row.label].length)));
+        const start = Math.max(0, Math.min(this.state.selected - Math.floor(MAX_VISIBLE / 2), rows.length - MAX_VISIBLE));
+        const visible = rows.slice(start, start + MAX_VISIBLE);
+        for (let i = 0; i < visible.length; i++) {
+            const row = visible[i];
+            if (!row)
+                continue;
+            const selected = start + i === this.state.selected;
+            const label = row.label.padEnd(maxLabel);
+            const value = row.kind === "setting" ? formatSettingValue(row, row.current) : "";
+            const rendered = selected
+                ? `${style.cyan("›")} ${style.bold(style.cyan(label))}${value ? `  ${style.bold(style.cyan(value))}` : ""}`
+                : `  ${label}${value ? `  ${value}` : ""}`;
+            lines.push(truncateToWidth(rendered, width));
+        }
+        lines.push(truncateToWidth(style.dim(`  ${settingsCounter(rows, this.state.selected)}`), width));
+        const selectedRow = rows[this.state.selected];
+        if (selectedRow?.description) {
+            lines.push("");
+            for (const wrapped of wrapText(selectedRow.description, Math.max(20, width - 4)))
+                lines.push(truncateToWidth(style.gray(`  ${wrapped}`), width));
+            lines.push("");
+        }
+        lines.push(truncateToWidth(style.dim("  Type to search · Enter/Space to change · Esc to cancel"), width));
+        return lines;
+    }
+}

package/dist/tui/settings.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Pure settings-menu logic for the TUI: row building, filtering, value cycling, counter and
+ * keyboard reduction. No terminal or pi-tui imports here — the `SettingsMenu` component in
+ * `settings-menu.ts` is a thin shell over this module.
+ *
+ * Only settings Alisio actually supports are defined here. The row set is the honest, wired
+ * list: every "setting" row maps to a real config key persisted through the atomic
+ * `setConfigValue` writer (or the MCP consent path) and is applied to the running process.
+ */
+export type SettingValueType = "boolean" | "number" | "percent" | "enum";
+export interface SettingRow {
+    /** Config key (or MCP consent id) this row edits; navigation rows carry their action id. */
+    id: string;
+    label: string;
+    description: string;
+    /** Group the row belongs to; also matched by the filter ("type" of the row). */
+    category: string;
+    kind: "setting" | "navigation";
+    /** Current raw value for setting rows (read live from the config at build time). */
+    current?: unknown;
+    /** Ordered candidate values cycled by Enter/Space; wraps around at the ends. */
+    values?: unknown[];
+    valueType?: SettingValueType;
+    /** Displayed but not editable in this run (e.g. under `--read-only`). */
+    readOnly?: boolean;
+    /** Navigation target id for navigation rows; the host maps it to a concrete action. */
+    action?: string;
+}
+export interface SettingsNavigationAction {
+    id: string;
+    label: string;
+    description: string;
+}
+/** Ordered candidates of the `websearch.provider` enum, aligned exactly with the config schema. */
+export declare const WEBSEARCH_PROVIDERS: readonly ["searxng", "duckduckgo-instant", "tavily", "brave", "serpapi", "native"];
+/**
+ * The config surface the menu reads. A structural view of the loaded config: rows are built only
+ * from the documented fields below, so unknown keys in a real config are ignored by construction.
+ */
+export interface SettingsConfigView {
+    compaction: {
+        auto: boolean;
+        threshold: number;
+        keepTurns: number;
+        maxOutputTokens: number;
+    };
+    context: {
+        claudeMdFallback: boolean;
+        maxBytes: number;
+    };
+    limits: {
+        maxTurns: number;
+        maxOutputTokens: number;
+        maxContextChars: number;
+        timeoutMs: number;
+    };
+    tui: {
+        paddingX: number;
+        skillSlashCommands: boolean;
+    };
+    mcp: {
+        allow?: boolean;
+    };
+    websearch: {
+        provider?: (typeof WEBSEARCH_PROVIDERS)[number];
+    };
+    pluginHooks: {
+        timeoutMs: number;
+    };
+}
+export interface SettingsMenuInput {
+    config: SettingsConfigView;
+    /** Whether global MCP consent (`mcp.allow`) is persisted for this user right now. */
+    mcpAllowPersisted: boolean;
+    /** `--read-only` run: every row is shown but none can be changed. */
+    readOnly: boolean;
+}
+/** The config view with the schema defaults; also the canonical fixture for tests. */
+export declare const defaultConfig: SettingsConfigView;
+interface SettingDefinition {
+    id: string;
+    label: string;
+    category: string;
+    description: string;
+    valueType: SettingValueType;
+    values: unknown[];
+    read: (config: SettingsConfigView, mcpAllowPersisted: boolean) => unknown;
+}
+/**
+ * Every real, wired setting the menu offers. `read` maps the live config to the current value;
+ * the keys are exactly the ones `setConfigValue` accepts (`compaction.*`, `context.*`, `limits.*`,
+ * `pluginHooks.timeoutMs`, `tui.*` and `websearch.provider`), and `mcp.allow` flows through the
+ * application's consent path instead. `limits.timeoutMs` is displayed in seconds (the values are
+ * seconds); the app host multiplies by 1000 before persisting the milliseconds.
+ */
+export declare const SETTINGS_DEFINITIONS: readonly SettingDefinition[];
+/**
+ * Builds the full settings menu: the real, wired setting rows followed by the navigation rows the
+ * host wires to the existing managers (`/model`, `/connect`, `/plugins`, `/skills`, `/mcp`, ...).
+ * Under `--read-only` every setting row is marked read-only: nothing can be persisted.
+ */
+export declare function settingsMenuRows(input: SettingsMenuInput, navigation: SettingsNavigationAction[]): SettingRow[];
+/** Whether a row matches every whitespace-separated filter term, on label/id/category/description. */
+export declare function matchSettingRow(row: SettingRow, terms: string[]): boolean;
+/** Filters rows by name, id, category (type) and description; an empty query returns everything. */
+export declare function filterSettingRows(rows: SettingRow[], filter: string): SettingRow[];
+/** The value shown in the right-hand column of a setting row. */
+export declare function formatSettingValue(row: SettingRow, value: unknown): string;
+/**
+ * The next candidate after the current value in the row's ordered `values`, wrapping around.
+ * A current value that is not in the list (hand-edited config) moves to the next candidate at or
+ * above it for numbers, or wraps to the first candidate otherwise. Never mutates the row.
+ */
+export declare function cycleSettingValue(row: SettingRow, current: unknown): unknown | undefined;
+/** OpenCode-style `(n/total)` counter; empty when there are no rows to count. */
+export declare function settingsCounter(rows: SettingRow[], selected: number): string;
+export interface SettingsMenuState {
+    /** Live type-to-search filter (matched against name, id, category and description). */
+    filter: string;
+    /** Index into the FILTERED row list. */
+    selected: number;
+}
+export declare const initialSettingsMenuState: () => SettingsMenuState;
+/**
+ * Normalized keyboard actions for the settings menu, decoded from raw terminal input with plain
+ * string matching so the logic stays testable without pi-tui. The component just forwards
+ * `handleInput(data)` here and maps the resulting effect to its callbacks.
+ */
+export type SettingsKeyAction = {
+    kind: "move";
+    direction: "up" | "down" | "start" | "end" | "pageUp" | "pageDown";
+} | {
+    kind: "type";
+    char: string;
+} | {
+    kind: "backspace";
+}
+/** Enter, or Space while the filter is empty (Space with an active filter types a space). */
+ | {
+    kind: "change";
+} | {
+    kind: "cancel";
+} | {
+    kind: "ignore";
+};
+export declare function settingsKeyAction(data: string, state: SettingsMenuState): SettingsKeyAction;
+export type SettingsMenuEffect = {
+    type: "change";
+    row: SettingRow;
+    value: unknown;
+} | {
+    type: "navigate";
+    row: SettingRow;
+} | {
+    type: "cancel";
+} | {
+    type: "none";
+};
+/**
+ * Pure keyboard reducer over the menu state. `rows` is the current FILTERED list (navigation rows
+ * and settings rows alike); Enter/Space changes a setting or navigates, Esc cancels, typing
+ * filters, Backspace edits the filter, and movement keys move/clamp the selection.
+ */
+export declare function reduceSettingsInput(state: SettingsMenuState, action: SettingsKeyAction, rows: SettingRow[]): {
+    state: SettingsMenuState;
+    effect: SettingsMenuEffect;
+};
+export {};

package/dist/tui/settings.js

@@ -0,0 +1,330 @@
+/** Ordered candidates of the `websearch.provider` enum, aligned exactly with the config schema. */
+export const WEBSEARCH_PROVIDERS = [
+    "searxng",
+    "duckduckgo-instant",
+    "tavily",
+    "brave",
+    "serpapi",
+    "native",
+];
+/** The config view with the schema defaults; also the canonical fixture for tests. */
+export const defaultConfig = {
+    compaction: { auto: true, threshold: 0.85, keepTurns: 2, maxOutputTokens: 16_000 },
+    context: { claudeMdFallback: false, maxBytes: 32 * 1024 },
+    limits: { maxTurns: 20, maxOutputTokens: 4_096, maxContextChars: 160_000, timeoutMs: 300_000 },
+    tui: { paddingX: 1, skillSlashCommands: true },
+    mcp: { allow: false },
+    websearch: { provider: undefined },
+    pluginHooks: { timeoutMs: 15_000 },
+};
+/** Strictly ascending number sequence with exact step arithmetic (0.85 stays 0.85). */
+function stepValues(start, end, step) {
+    const values = [];
+    for (let value = start; value <= end + 1e-9; value += step)
+        values.push(Number(value.toFixed(3)));
+    return values;
+}
+/**
+ * Every real, wired setting the menu offers. `read` maps the live config to the current value;
+ * the keys are exactly the ones `setConfigValue` accepts (`compaction.*`, `context.*`, `limits.*`,
+ * `pluginHooks.timeoutMs`, `tui.*` and `websearch.provider`), and `mcp.allow` flows through the
+ * application's consent path instead. `limits.timeoutMs` is displayed in seconds (the values are
+ * seconds); the app host multiplies by 1000 before persisting the milliseconds.
+ */
+export const SETTINGS_DEFINITIONS = [
+    {
+        id: "compaction.auto",
+        label: "Auto-compact",
+        category: "Compaction",
+        valueType: "boolean",
+        values: [false, true],
+        read: (config) => config.compaction.auto,
+        description: "Summarize older history automatically when context usage crosses the threshold. Off keeps history verbatim until you run /compact manually.",
+    },
+    {
+        id: "compaction.threshold",
+        label: "Compaction threshold",
+        category: "Compaction",
+        valueType: "percent",
+        values: stepValues(0.5, 0.95, 0.05),
+        read: (config) => config.compaction.threshold,
+        description: "Share of the model context window that triggers auto-compaction (or of the char-budget fallback when the window is unknown). Applied from the next run.",
+    },
+    {
+        id: "compaction.keepTurns",
+        label: "Keep latest turns",
+        category: "Compaction",
+        valueType: "number",
+        values: stepValues(0, 20, 1),
+        read: (config) => config.compaction.keepTurns,
+        description: "Recent user turns kept verbatim after an auto or manual compaction. 0 summarizes everything; the newest turns above the cap are kept intact.",
+    },
+    {
+        id: "compaction.maxOutputTokens",
+        label: "Compaction max output tokens",
+        category: "Compaction",
+        valueType: "number",
+        values: [8_000, 12_000, 16_000, 24_000, 32_000],
+        read: (config) => config.compaction.maxOutputTokens,
+        description: "Output token budget for the summarizer call. A summary cut by this budget is kept as partial; raise it for very long sessions.",
+    },
+    {
+        id: "context.claudeMdFallback",
+        label: "CLAUDE.md fallback",
+        category: "Context",
+        valueType: "boolean",
+        values: [false, true],
+        read: (config) => config.context.claudeMdFallback,
+        description: "Use a directory's CLAUDE.md when it has no AGENTS.md (agents.md convention). Loaded as project instructions from the next turn.",
+    },
+    {
+        id: "context.maxBytes",
+        label: "AGENTS.md max bytes",
+        category: "Context",
+        valueType: "number",
+        // 4 KiB steps aligned to the default (32 KiB is on-grid); 1024 stays reachable by hand-edit.
+        values: stepValues(4096, 1_048_576, 4096),
+        read: (config) => config.context.maxBytes,
+        description: "Total AGENTS.md bytes injected. The closest instruction files are kept up to this budget; raise it for very large repositories.",
+    },
+    {
+        id: "websearch.provider",
+        label: "Web search provider",
+        category: "Web",
+        valueType: "enum",
+        values: [...WEBSEARCH_PROVIDERS],
+        read: (config) => config.websearch.provider,
+        description: "Backend used by websearch tools. Unset falls back to a plugin extension, then a public SearXNG instance; `native` runs search server-side and must be supported by the active provider.",
+    },
+    {
+        id: "mcp.allow",
+        label: "Remember MCP consent",
+        category: "MCP",
+        valueType: "boolean",
+        values: [false, true],
+        read: (_config, mcpAllowPersisted) => mcpAllowPersisted,
+        description: "Persist process/network consent for MCP servers in your user configuration (mcp.allow). On: every start grants permission and auto-connects enabled servers; use /mcp to connect now. Off: revokes the persisted consent and disconnects servers.",
+    },
+    {
+        id: "limits.maxTurns",
+        label: "Max turns",
+        category: "Limits",
+        valueType: "number",
+        values: [5, 10, 15, 20, 30, 50, 100],
+        read: (config) => config.limits.maxTurns,
+        description: "Maximum agent-loop turns per run before the run ends. Applied from the next run; longer tasks may need a higher budget.",
+    },
+    {
+        id: "limits.maxOutputTokens",
+        label: "Agent max output tokens",
+        category: "Limits",
+        valueType: "number",
+        values: [1_024, 2_048, 4_096, 8_192, 16_384],
+        read: (config) => config.limits.maxOutputTokens,
+        description: "Per-call output token budget for agent turns. A cut response shows a notice suggesting a higher value. Applied from the next run.",
+    },
+    {
+        id: "limits.maxContextChars",
+        label: "Context char budget",
+        category: "Limits",
+        valueType: "number",
+        values: [80_000, 120_000, 160_000, 240_000, 320_000],
+        read: (config) => config.limits.maxContextChars,
+        description: "Hard context limit in characters (instruction files + transcript + tool list) per run; the budget fallback that auto-compaction measures when the model window is unknown. Applied from the next run.",
+    },
+    {
+        id: "limits.timeoutMs",
+        label: "Run timeout",
+        category: "Limits",
+        valueType: "number",
+        // Displayed in seconds; the app host multiplies by 1000 before persisting milliseconds.
+        values: stepValues(30, 600, 30),
+        read: (config) => config.limits.timeoutMs / 1000,
+        description: "Per-run timeout. A run over the limit is aborted; raise it for very long autonomous tasks.",
+    },
+    {
+        id: "pluginHooks.timeoutMs",
+        label: "Plugin hook timeout",
+        category: "Plugins",
+        valueType: "number",
+        values: stepValues(1000, 120_000, 1000),
+        read: (config) => config.pluginHooks.timeoutMs,
+        description: "Host-enforced plugin hook timeout. Hooks (compaction, session start/end) are aborted when they exceed it; raise it for plugins that summarize slowly.",
+    },
+    {
+        id: "tui.paddingX",
+        label: "Editor padding",
+        category: "TUI",
+        valueType: "number",
+        values: [0, 1, 2, 3, 4],
+        read: (config) => config.tui.paddingX,
+        description: "Horizontal padding (columns) around the editor input box. Applied immediately to the current editor.",
+    },
+    {
+        id: "tui.skillSlashCommands",
+        label: "Skill slash commands",
+        category: "TUI",
+        valueType: "boolean",
+        values: [false, true],
+        read: (config) => config.tui.skillSlashCommands,
+        description: "Offer effective skills as first-class `skill:<id>` editor autocomplete entries. Off hides those entries; the `/skills` manager and its argument completion stay available. Applied immediately to the editor.",
+    },
+];
+/**
+ * Builds the full settings menu: the real, wired setting rows followed by the navigation rows the
+ * host wires to the existing managers (`/model`, `/connect`, `/plugins`, `/skills`, `/mcp`, ...).
+ * Under `--read-only` every setting row is marked read-only: nothing can be persisted.
+ */
+export function settingsMenuRows(input, navigation) {
+    const rows = [];
+    for (const def of SETTINGS_DEFINITIONS) {
+        rows.push({
+            id: def.id,
+            label: def.label,
+            category: def.category,
+            description: def.description,
+            kind: "setting",
+            current: def.read(input.config, input.mcpAllowPersisted),
+            values: [...def.values],
+            valueType: def.valueType,
+            ...(input.readOnly ? { readOnly: true } : {}),
+        });
+    }
+    rows.push(...navigation.map((entry) => ({
+        id: entry.id,
+        label: entry.label,
+        description: entry.description,
+        category: "Go to",
+        kind: "navigation",
+        action: entry.id,
+    })));
+    return rows;
+}
+/** Whether a row matches every whitespace-separated filter term, on label/id/category/description. */
+export function matchSettingRow(row, terms) {
+    const haystack = [row.label, row.id, row.category, row.description].join(" ").toLowerCase();
+    return terms.every((term) => haystack.includes(term));
+}
+/** Filters rows by name, id, category (type) and description; an empty query returns everything. */
+export function filterSettingRows(rows, filter) {
+    const terms = filter.toLowerCase().split(/\s+/).filter(Boolean);
+    if (!terms.length)
+        return rows;
+    return rows.filter((row) => matchSettingRow(row, terms));
+}
+/** The value shown in the right-hand column of a setting row. */
+export function formatSettingValue(row, value) {
+    if (row.valueType === "percent" && typeof value === "number")
+        return `${Math.round(value * 100)}%`;
+    if (row.valueType === "boolean")
+        return value === true ? "true" : "false";
+    return value === undefined || value === null ? "" : String(value);
+}
+/**
+ * The next candidate after the current value in the row's ordered `values`, wrapping around.
+ * A current value that is not in the list (hand-edited config) moves to the next candidate at or
+ * above it for numbers, or wraps to the first candidate otherwise. Never mutates the row.
+ */
+export function cycleSettingValue(row, current) {
+    const values = row.values;
+    if (!values?.length || row.readOnly)
+        return undefined;
+    const index = values.findIndex((value) => Object.is(value, current));
+    if (index >= 0)
+        return values[(index + 1) % values.length];
+    if (typeof current === "number" && values.every((value) => typeof value === "number"))
+        return values.find((value) => value >= current) ?? values[0];
+    return values[0];
+}
+/** OpenCode-style `(n/total)` counter; empty when there are no rows to count. */
+export function settingsCounter(rows, selected) {
+    if (!rows.length)
+        return "";
+    const clamped = Math.min(Math.max(0, selected), rows.length - 1);
+    return `(${clamped + 1}/${rows.length})`;
+}
+export const initialSettingsMenuState = () => ({ filter: "", selected: 0 });
+const PAGE_SIZE = 10;
+export function settingsKeyAction(data, state) {
+    if (!data)
+        return { kind: "ignore" };
+    if (data === "\x1b" || data === "\x1b[")
+        return { kind: "cancel" };
+    if (data === "\r" || data === "\n")
+        return { kind: "change" };
+    if (data === " " && !state.filter)
+        return { kind: "change" };
+    if (data === "\x1b[A")
+        return { kind: "move", direction: "up" };
+    if (data === "\x1b[B")
+        return { kind: "move", direction: "down" };
+    if (data === "\x1b[H" || data === "\x1b[1~")
+        return { kind: "move", direction: "start" };
+    if (data === "\x1b[F" || data === "\x1b[4~")
+        return { kind: "move", direction: "end" };
+    if (data === "\x1b[5~")
+        return { kind: "move", direction: "pageUp" };
+    if (data === "\x1b[6~")
+        return { kind: "move", direction: "pageDown" };
+    if (data === "\x7f" || data === "\b" || data === "\x08" || data === "\x1b[3~")
+        return { kind: "backspace" };
+    if (data.length === 1 && data >= " " && data <= "~")
+        return { kind: "type", char: data };
+    return { kind: "ignore" };
+}
+/**
+ * Pure keyboard reducer over the menu state. `rows` is the current FILTERED list (navigation rows
+ * and settings rows alike); Enter/Space changes a setting or navigates, Esc cancels, typing
+ * filters, Backspace edits the filter, and movement keys move/clamp the selection.
+ */
+export function reduceSettingsInput(state, action, rows) {
+    switch (action.kind) {
+        case "cancel":
+            return { state, effect: { type: "cancel" } };
+        case "change": {
+            const row = rows[state.selected];
+            if (!row)
+                return { state, effect: { type: "none" } };
+            if (row.kind === "navigation")
+                return { state, effect: { type: "navigate", row } };
+            const value = cycleSettingValue(row, row.current);
+            if (value === undefined)
+                return { state, effect: { type: "none" } };
+            return { state, effect: { type: "change", row, value } };
+        }
+        case "type": {
+            const filter = `${state.filter}${action.char}`;
+            return { state: { filter, selected: 0 }, effect: { type: "none" } };
+        }
+        case "backspace": {
+            const filter = state.filter.slice(0, -1);
+            return {
+                state: { filter, selected: 0 },
+                effect: { type: "none" },
+            };
+        }
+        case "move": {
+            if (!rows.length)
+                return { state, effect: { type: "none" } };
+            const last = rows.length - 1;
+            const selected = action.direction === "up"
+                ? state.selected === 0
+                    ? last
+                    : state.selected - 1
+                : action.direction === "down"
+                    ? state.selected === last
+                        ? 0
+                        : state.selected + 1
+                    : action.direction === "start"
+                        ? 0
+                        : action.direction === "end"
+                            ? last
+                            : action.direction === "pageUp"
+                                ? Math.max(0, state.selected - PAGE_SIZE)
+                                : Math.min(last, state.selected + PAGE_SIZE);
+            return { state: { ...state, selected }, effect: { type: "none" } };
+        }
+        case "ignore":
+            return { state, effect: { type: "none" } };
+    }
+}

package/dist/tui/state.d.ts

@@ -124,6 +124,77 @@ export declare function parseCommand(input: string): {
     name: string;
     args: string;
 } | undefined;
+/** Minimal structural view of a skill for slash autocompletion (subset of the core catalog entry). */
+export interface SkillCompletionEntry {
+    id: string;
+    name: string;
+    displayId: string;
+    description: string;
+    /** Catalog scope of the skill: user | project | config | plugin (drives the [u]/[p]/[c]/[l] marker). */
+    scope?: string;
+    enabled: boolean;
+    locked: boolean;
+    effective: boolean;
+}
+export interface SlashCompletionItem {
+    value: string;
+    label: string;
+    description?: string;
+}
+export declare const SKILL_COMPLETION_DESCRIPTION_LIMIT = 80;
+/**
+ * OpenCode-style scope marker for a skill's slash entry, mirroring the catalog scopes the /skills
+ * manager shows: user, project, config and plugin (plugin skills are locked by their owner plugin).
+ */
+export declare const skillScopeMarker: (skill: SkillCompletionEntry) => string | undefined;
+/**
+ * Description for a skill's first-class `skill:<id>` slash entry: scope marker, status hint, then
+ * the skill description truncated to the shared limit. The marker and status are prepended before
+ * truncating, so they survive the cap just like the /skills argument completions.
+ */
+export declare function skillSlashDescription(skill: SkillCompletionEntry): string;
+/**
+ * Suggested completions for `/skills <prefix>`: every entry the /skills manager shows, filtered by
+ * prefix (case-insensitive) on name or description. Selecting a suggestion only fills the argument;
+ * submitting still opens the skills manager.
+ */
+export declare function skillCompletions(catalog: SkillCompletionEntry[], prefix: string, limit?: number): SlashCompletionItem[];
+export interface SlashCompletionSource {
+    name: string;
+    description?: string;
+    argumentHint?: string;
+    aliases?: string[];
+}
+export interface SlashCompletionContext {
+    /** Live session rows for `/resume`: already filtered to the typed prefix and mapped. */
+    sessions?: (prefix: string) => SlashCompletionItem[];
+    /** Effective skill catalog backing `/skills` (the same entries the skills manager shows). */
+    skills: SkillCompletionEntry[];
+}
+/**
+ * Builds the editor slash-autocomplete command list. Aliases get their own entries with the same
+ * description and argument completions, because the provider matches commands by fuzzy name.
+ * Effective skills are appended as first-class `skill:<id>` entries so `/ski…`, `/skill:b…` and
+ * even `/branch…` all surface them; submitting already routes `skill:` commands to skill load, so
+ * selecting an entry only needs to insert the command name. `options.skillEntries: false` gates
+ * ONLY those standalone `skill:` entries (e.g. the `tui.skillSlashCommands` toggle): the `/skills`
+ * manager and its argument completion keep working, since `context.skills` still feeds both.
+ */
+export interface SlashCompletionOptions {
+    /** Include first-class `skill:<id>` entries for effective skills (default true). */
+    skillEntries?: boolean;
+}
+export declare function slashCompletionCommands(sources: SlashCompletionSource[], context: SlashCompletionContext, options?: SlashCompletionOptions): ({
+    getArgumentCompletions: (prefix: string) => SlashCompletionItem[];
+    name: string;
+    description: string | undefined;
+    argumentHint?: string | undefined;
+} | {
+    getArgumentCompletions?: undefined;
+    name: string;
+    description: string | undefined;
+    argumentHint?: string | undefined;
+})[];
 export declare function summarizeToolArgs(name: string, args: string): string;
 export interface DiffLine {
     sign: "+" | "-";

package/dist/tui/state.js

@@ -223,6 +223,11 @@ export const COMMANDS = [
         aliases: ["skill"],
     },
     { name: "mcp", description: "Browse and manage MCP servers" },
+    {
+        name: "settings",
+        description: "Open the settings menu",
+        aliases: ["prefs"],
+    },
     { name: "copy", description: "Copy the last assistant response to the clipboard" },
     {
         name: "ask",
@@ -245,6 +250,87 @@ export function parseCommand(input) {
         return undefined;
     return { name: match[1], args: (match[2] ?? "").trim() };
 }
+export const SKILL_COMPLETION_DESCRIPTION_LIMIT = 80;
+/** Status hint prefixes (no color): shadowed < disabled < locked states shown by /skills. */
+const skillStatus = (skill) => !skill.effective
+    ? "shadowed"
+    : !skill.enabled
+        ? "disabled"
+        : skill.locked
+            ? "locked by plugin"
+            : undefined;
+/**
+ * OpenCode-style scope marker for a skill's slash entry, mirroring the catalog scopes the /skills
+ * manager shows: user, project, config and plugin (plugin skills are locked by their owner plugin).
+ */
+export const skillScopeMarker = (skill) => {
+    const marker = { user: "[u]", project: "[p]", config: "[c]", plugin: "[l]" }[skill.scope];
+    return marker ?? (skill.scope ? `[${skill.scope}]` : undefined);
+};
+/**
+ * Description for a skill's first-class `skill:<id>` slash entry: scope marker, status hint, then
+ * the skill description truncated to the shared limit. The marker and status are prepended before
+ * truncating, so they survive the cap just like the /skills argument completions.
+ */
+export function skillSlashDescription(skill) {
+    const marker = skillScopeMarker(skill);
+    const status = skillStatus(skill);
+    if (!marker && !status)
+        return truncatePlain(skill.description, SKILL_COMPLETION_DESCRIPTION_LIMIT);
+    return truncatePlain(`${[marker, status].filter(Boolean).join(" ")}${status ? " · " : " "}${skill.description}`, SKILL_COMPLETION_DESCRIPTION_LIMIT);
+}
+/**
+ * Suggested completions for `/skills <prefix>`: every entry the /skills manager shows, filtered by
+ * prefix (case-insensitive) on name or description. Selecting a suggestion only fills the argument;
+ * submitting still opens the skills manager.
+ */
+export function skillCompletions(catalog, prefix, limit = 20) {
+    const query = prefix.trim().toLowerCase();
+    const items = query
+        ? catalog.filter((skill) => [skill.displayId, skill.name, skill.description].join(" ").toLowerCase().includes(query))
+        : catalog;
+    return items.slice(0, limit).map((skill) => {
+        const status = skillStatus(skill);
+        return {
+            value: skill.id,
+            label: skill.displayId,
+            description: truncatePlain(status ? `${status} · ${skill.description}` : skill.description, SKILL_COMPLETION_DESCRIPTION_LIMIT),
+        };
+    });
+}
+function argumentCompletionsFor(source, context) {
+    const sessions = context.sessions;
+    if (source.name === "resume" && sessions)
+        return {
+            getArgumentCompletions: (prefix) => sessions(prefix).slice(0, 20),
+        };
+    if (source.name === "skills")
+        return {
+            getArgumentCompletions: (prefix) => skillCompletions(context.skills, prefix, 20),
+        };
+    return {};
+}
+export function slashCompletionCommands(sources, context, options = {}) {
+    const entries = sources.flatMap((source) => {
+        const entry = (name) => ({
+            name,
+            description: source.description,
+            ...(source.argumentHint ? { argumentHint: source.argumentHint } : {}),
+            ...argumentCompletionsFor(source, context),
+        });
+        return [
+            entry(source.name),
+            ...(source.aliases ?? []).filter((a) => a !== source.name).map(entry),
+        ];
+    });
+    if (options.skillEntries !== false)
+        for (const skill of context.skills)
+            entries.push({
+                name: `skill:${skill.id}`,
+                description: skillSlashDescription(skill),
+            });
+    return entries;
+}
 function parseArgs(args) {
     try {
         const value = JSON.parse(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.11",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.1.0-alpha.8",
+    "@alisio/core": "0.1.0-alpha.9",
     "@alisio/plugin-deepseek": "0.1.0-alpha.7",
     "@alisio/plugin-memory": "0.1.0-alpha.6",
     "@alisio/plugin-openai-compatible": "0.1.0-alpha.7",