@aiwayds/dsh-tui-pi 0.1.0

package/lib/settings.js

@@ -0,0 +1,1328 @@
+/**
+ * Text-based settings browser — the terminal counterpart of the web GUI's
+ * settings surface (schema-form driven there, pi-tui overlays here).
+ *
+ * Walks `ctx.settings.describe()` (registered namespaces → serialized
+ * schemastery schemas → resolved values) and renders it as nested
+ * SettingsList overlays, one level per schema depth:
+ *
+ *   level 0   category list (searchable): general / models / plugins / agent,
+ *             then `other` for unmapped namespaces. Namespace→category comes
+ *             from a static mapping (categorizeNamespaces) mirroring the web
+ *             settings page: the web client slots namespaces into categories
+ *             client-side and the data plane carries no category field, so
+ *             the mapping is maintained here by hand; `other` is hidden when
+ *             empty.
+ *   level 1   namespace list for the chosen category (searchable);
+ *             description shows applies timing. The Models category is
+ *             special-cased: it lists configured llm-pi-ai providers (label,
+ *             model summary, API-key state) instead of the raw namespace —
+ *             the original schema surface is hidden — plus dedicated
+ *             llm-deepseek / agent-default-model rows and an add-provider
+ *             flow (built-in directory → one API key → write)
+ *   level 2+  schema walk, dispatched on node type:
+ *             - object/dict → drill in (nested list; dicts get an add-key row)
+ *             - boolean / all-literal union → Enter cycles the value
+ *             - string/number/mixed union → inline Input editor
+ *             - array / literal / const / unknown → read-only viewer
+ *             - role('secret') fields are masked and edited without prefill
+ *             - every group row resets its subtree to defaults (Esc confirms)
+ *
+ * Writes go through `settings.mutate(ns, pathOps, expectedRevision)` so the
+ * user layer is edited by path without restating sections the UI never saw;
+ * the descriptor (and with it the revision) is re-read after every committed
+ * write, and failed writes revert the on-screen row and surface the error.
+ */
+import { getPath, nodeAtPath, rehydrateSchema, } from '@deepseek-ai/dsh-client-schema-form';
+import { settingsNamespace } from '@deepseek-ai/dsh-settings';
+import { getKeybindings, Input, SettingsList, } from '@earendil-works/pi-tui';
+import { ansiBg, ansiFg, BOLD, RESET } from "./theme/index.js";
+import { clipToWidth, visibleWidth } from "./text.js";
+import { wrapFramedOverlay } from "./frame.js";
+import { catalogEntry, deriveKeyRef, providerProfileFor, providerRowView, unconfiguredCatalogEntries, } from "./provider-catalog.js";
+/**
+ * Static namespace→category mapping, mirroring the web settings page's
+ * client-side slot structure (see the module header): the data plane carries
+ * no category field, so the slots are maintained here by hand. Namespaces not
+ * listed anywhere fall into the trailing `other` category.
+ *
+ * Labels are English-only: pi-tui's SettingsList search matches the label
+ * text, so English queries (model, shell, permission, …) hit directly.
+ */
+export const CATEGORY_MAP = [
+    { id: 'general', label: 'General', namespaces: ['permission', 'dsh-tui'] },
+    { id: 'models', label: 'Models', namespaces: ['llm-deepseek', 'llm-pi-ai', 'agent-default-model'] },
+    { id: 'plugins', label: 'Plugins', namespaces: ['shell', 'agent-loop', 'web-search-deepseek'] },
+    { id: 'agent', label: 'Agent Presets', namespaces: ['agent-presets'] },
+];
+/** Cap for a category row's member-name description line. */
+export const CATEGORY_DESC_MAX = 60;
+/** Branded namespaces the Models category reads and writes. */
+const NS_LLM_PI_AI = settingsNamespace('llm-pi-ai');
+const NS_LLM_DEEPSEEK = settingsNamespace('llm-deepseek');
+const NS_AGENT_DEFAULT_MODEL = settingsNamespace('agent-default-model');
+/**
+ * Group a describe() namespace list into ordered categories — general, models,
+ * plugins, agent, then `other` for everything unmapped. Categories with no
+ * members are dropped, including `other` when nothing falls into it.
+ *
+ * Defensive: duplicate namespaces in the input count once (a namespace
+ * registered twice must not be listed twice), and the `mapped` guard resolves
+ * CATEGORY_MAP overlap — a namespace listed in several categories goes to the
+ * first one, by category order.
+ */
+export function categorizeNamespaces(nses) {
+    const categories = [];
+    const mapped = new Set();
+    const input = new Set(nses);
+    for (const def of CATEGORY_MAP) {
+        const members = [...new Set(def.namespaces)].filter(ns => input.has(ns) && !mapped.has(ns));
+        if (members.length === 0)
+            continue;
+        for (const ns of members)
+            mapped.add(ns);
+        categories.push({ id: def.id, label: def.label, namespaces: members });
+    }
+    const others = [...input].filter(ns => !mapped.has(ns));
+    if (others.length > 0)
+        categories.push({ id: 'other', label: 'Other', namespaces: others });
+    return categories;
+}
+/**
+ * Description line for a category row: member names joined with ", ", capped
+ * at `max` columns. Namespace names are ASCII, so visible width equals char
+ * count here; the width-aware clip is used anyway so the cap semantics stay
+ * uniform with every other truncation in the TUI (an exactly-fitting string
+ * is kept whole, an ellipsis appears only when a column is free).
+ */
+export function categoryDescription(namespaces, max = 60) {
+    const joined = [...new Set(namespaces)].join(', ');
+    return clipToWidth(joined, max);
+}
+// ----------------------------------------------------------------- pure helpers --
+/** Human display for a resolved value (row value column; never re-scans anything). */
+export function formatValue(value) {
+    if (value === undefined)
+        return '(unset)';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return value.length === 0 ? '[]' : `[${value.length} items]`;
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        return keys.length === 0 ? '{}' : `{${keys.length} keys}`;
+    }
+    return String(value);
+}
+/** Display string for one union literal (the SettingsList cycle vocabulary). */
+export function displayValue(value) {
+    return value === null ? 'null' : String(value);
+}
+/** Extract literal branches of a union node (`literal`/`const` members). */
+export function unionLiterals(node) {
+    const list = node.list ?? [];
+    const values = [];
+    let all = list.length > 0;
+    for (const member of list) {
+        if (member.type === 'literal' || member.type === 'const')
+            values.push(member.value);
+        else
+            all = false;
+    }
+    return { values, all };
+}
+export function parseNumberInput(text) {
+    if (text.trim() === '')
+        return { kind: 'unset' };
+    // Literal decimal subset: hex/octal/binary prefixes and trailing garbage
+    // are rejected; decimal scientific notation stays (1e3 = 1000).
+    if (!/^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(text.trim())) {
+        return { kind: 'error', error: `expected a number, got "${text}"` };
+    }
+    const n = Number(text);
+    if (!Number.isFinite(n))
+        return { kind: 'error', error: `expected a number, got "${text}"` };
+    return { kind: 'value', value: n };
+}
+export function parseStringInput(text) {
+    if (text.trim() === '')
+        return { kind: 'unset' };
+    // Keep the user's text verbatim — only the emptiness check trims.
+    return { kind: 'value', value: text };
+}
+/** Mixed (non-literal) union editing: JSON values, else a raw string branch. */
+export function parseUnionInput(text, node) {
+    if (text.trim() === '')
+        return { kind: 'unset' };
+    try {
+        return { kind: 'value', value: JSON.parse(text) };
+    }
+    catch { /* not JSON — fall through to the string-branch path */ }
+    const hasStringBranch = (node.list ?? []).some(member => member.type === 'string' || (member.type === 'literal' && typeof member.value === 'string'));
+    if (hasStringBranch)
+        return { kind: 'value', value: text };
+    return { kind: 'error', error: 'expected a JSON value (number, boolean, string, …)' };
+}
+/** Seed value for a newly added dict key, from the inner schema. */
+export function defaultValueFor(node) {
+    const meta = (node.meta ?? {});
+    if (meta.default !== undefined)
+        return meta.default;
+    switch (node.type) {
+        case 'boolean': return false;
+        case 'number': return 0;
+        case 'string': return '';
+        case 'array': return [];
+        case 'object':
+        case 'dict': return {};
+        case 'union': {
+            const { values } = unionLiterals(node);
+            return values.length > 0 ? values[0] : null;
+        }
+        default: return null;
+    }
+}
+function fieldMeta(node) {
+    return (node.meta ?? {});
+}
+/** Description line for one field row (static — built once per row). */
+export function fieldDescription(node, userOverride) {
+    const meta = fieldMeta(node);
+    const parts = [];
+    const raw = meta.description ?? meta.comment;
+    if (typeof raw === 'string')
+        parts.push(raw);
+    else if (raw !== undefined && typeof raw === 'object') {
+        parts.push(raw['en'] ?? raw[''] ?? Object.values(raw)[0] ?? '');
+    }
+    if (meta.required === true)
+        parts.push('required');
+    if (meta.default !== undefined)
+        parts.push(`default: ${formatValue(meta.default)}`);
+    if (meta.min !== undefined)
+        parts.push(`min: ${meta.min}`);
+    if (meta.max !== undefined)
+        parts.push(`max: ${meta.max}`);
+    if (meta.step !== undefined)
+        parts.push(`step: ${meta.step}`);
+    if (meta.pattern !== undefined)
+        parts.push(`pattern: ${meta.pattern.source}`);
+    if (meta.role === 'secret')
+        parts.push('secret');
+    if (meta.disabled === true)
+        parts.push('disabled');
+    for (const badge of meta.badges ?? []) {
+        if (typeof badge.text === 'string')
+            parts.push(badge.text);
+    }
+    if (userOverride)
+        parts.push('user-set');
+    return parts.filter(part => part !== '').join(' · ');
+}
+/** Inline value editor: title, current-value line, error/notice line, Input. */
+export class EditField {
+    tui;
+    options;
+    input;
+    error;
+    /** Non-error commit message (success with a follow-up hint, see CommitResult). */
+    notice;
+    /** Set while a commit write is in flight; extra Enter presses are ignored. */
+    pending = false;
+    /** Guards onDone: exactly one terminal transition (submit success/keep/escape). */
+    done = false;
+    fg;
+    fgMuted;
+    fgDanger;
+    /** Popup-surface background for the secret mask line. */
+    maskBg;
+    constructor(tui, options, theme) {
+        this.tui = tui;
+        this.options = options;
+        this.fg = text => ansiFg(theme.palette.accent) + text + RESET;
+        this.fgMuted = text => ansiFg(theme.palette.fgMuted) + text + RESET;
+        this.fgDanger = text => ansiFg(theme.palette.danger) + text + RESET;
+        // Same canvasSubtle backdrop the browser's listTheme paints on every row.
+        this.maskBg = text => ansiBg(theme.palette.canvasSubtle) + text + RESET;
+        this.input = new Input();
+        this.input.setValue(options.initial);
+        this.input.cursor = options.initial.length;
+        // Not the TUI's focused component (the overlay list is) — flip the flag
+        // so Input renders its cursor marker inside the submenu.
+        this.input.focused = true;
+        this.input.onSubmit = (text) => {
+            if (this.pending)
+                return;
+            const parsed = options.parse(text);
+            if (parsed.kind === 'error') {
+                this.error = parsed.error;
+                this.notice = undefined;
+                this.tui.requestRender();
+                return;
+            }
+            if (parsed.kind === 'keep') {
+                this.finish();
+                return;
+            }
+            this.pending = true;
+            void options.onCommit(parsed).then(result => {
+                this.pending = false;
+                if (this.done) {
+                    // Esc already closed the editor while the write was in flight —
+                    // the component renders for nobody, so a late failure is surfaced
+                    // through onError instead of this.error.
+                    if (result?.error !== undefined)
+                        options.onError?.(result.error);
+                    return;
+                }
+                if (result?.error !== undefined) {
+                    this.error = result.error;
+                    this.notice = undefined;
+                    this.tui.requestRender();
+                }
+                else if (result?.notice !== undefined) {
+                    // Success with a hint: stay open so the hint is readable (Enter
+                    // re-runs the commit idempotently, Esc exits) — no ✘ marker.
+                    this.error = undefined;
+                    this.notice = result.notice;
+                    this.tui.requestRender();
+                }
+                else {
+                    this.finish();
+                }
+            });
+        };
+        this.input.onEscape = () => {
+            // Closing during a pending write is allowed (the write is already in
+            // the serialized chain — its outcome is undeliverable through this
+            // component either way); the done flag keeps onDone single-shot.
+            this.finish();
+        };
+    }
+    /** Terminal transition — runs the caller's onDone exactly once. */
+    finish() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.options.onDone();
+    }
+    invalidate() { }
+    render(width) {
+        const lines = [];
+        lines.push(this.fg(BOLD + `✎ ${this.options.title}` + RESET));
+        lines.push(this.fgMuted(this.options.subtitle));
+        if (this.error !== undefined)
+            lines.push(this.fgDanger(`✘ ${this.error}`));
+        else if (this.notice !== undefined)
+            lines.push(this.fgMuted(this.notice));
+        lines.push('');
+        if (this.options.secret === true) {
+            lines.push(this.maskLine(width));
+        }
+        else {
+            lines.push(...this.input.render(width));
+        }
+        return lines;
+    }
+    /**
+     * Masked input line for secret fields: a dot row (one dot per visible
+     * column of the value, capped to the popup width) with a `▎` marker at the
+     * cursor position. The real cursor is not rendered — the marker only hints
+     * at the editing position; input semantics live in the internal Input.
+     */
+    maskLine(width) {
+        const maxDots = Math.max(0, width - 2);
+        const dots = '•'.repeat(Math.min(maxDots, visibleWidth(this.input.getValue())));
+        const cursor = Math.min(this.input.cursor, dots.length);
+        return this.maskBg(dots.slice(0, cursor) + '▎' + dots.slice(cursor));
+    }
+    handleInput(data) {
+        this.input.handleInput(data);
+    }
+}
+/** Two-line confirmation for destructive resets (Enter confirms, Esc cancels). */
+class ConfirmReset {
+    theme;
+    label;
+    onConfirm;
+    onCancel;
+    /** Set while the confirmed write is in flight; extra Enter presses are ignored. */
+    pending = false;
+    constructor(theme, label, onConfirm, onCancel) {
+        this.theme = theme;
+        this.label = label;
+        this.onConfirm = onConfirm;
+        this.onCancel = onCancel;
+    }
+    invalidate() { }
+    render(_width) {
+        const fg = (hex) => (text) => ansiFg(hex) + text + RESET;
+        return [
+            fg(this.theme.palette.attention)(BOLD + `↺ ${this.label}` + RESET),
+            '',
+            fg(this.theme.palette.fgMuted)(this.pending
+                ? '  resetting…'
+                : '  Enter: reset to defaults · Esc: cancel'),
+        ];
+    }
+    handleInput(data) {
+        // While the confirmed write is in flight the commit is already in the
+        // serialized chain and cannot be undone — pretending Esc cancels would
+        // be a lie, so every key is ignored until the write settles.
+        if (this.pending)
+            return;
+        if (getKeybindings().matches(data, 'tui.select.confirm')) {
+            this.pending = true;
+            this.onConfirm();
+        }
+        else if (getKeybindings().matches(data, 'tui.select.cancel')) {
+            this.onCancel();
+        }
+    }
+}
+/** Read-only JSON view for array / literal / unknown nodes. */
+class ReadOnlyViewer {
+    theme;
+    label;
+    json;
+    onClose;
+    constructor(theme, label, json, onClose) {
+        this.theme = theme;
+        this.label = label;
+        this.json = json;
+        this.onClose = onClose;
+    }
+    invalidate() { }
+    render(width) {
+        const fg = (hex) => (text) => ansiFg(hex) + text + RESET;
+        const lines = [
+            fg(this.theme.palette.accent)(BOLD + `ⓘ ${this.label}` + RESET),
+            '',
+        ];
+        const text = JSON.stringify(this.json, null, 2);
+        const max = Math.max(2, width - 2);
+        for (const line of text.split('\n').slice(0, 40)) {
+            lines.push(fg(this.theme.palette.fgMuted)(clipToWidth(line, max)));
+        }
+        lines.push('');
+        lines.push(fg(this.theme.palette.fgSubtle)('  read-only in the TUI — edit the settings document to change it · Esc to close'));
+        return lines;
+    }
+    handleInput(data) {
+        if (getKeybindings().matches(data, 'tui.select.cancel')
+            || getKeybindings().matches(data, 'tui.select.confirm')) {
+            this.onClose();
+        }
+    }
+}
+/**
+ * Swappable shell around the Models category's SettingsList. Provider rows
+ * change structurally — a new provider row must appear after an add, and
+ * SettingsList.updateValue cannot express that — so the shell swaps in a
+ * freshly built list while staying the category list's stable submenu
+ * component.
+ */
+class ModelsCategoryView {
+    list;
+    swap(list) {
+        this.list = list;
+    }
+    invalidate() {
+        this.list?.invalidate();
+    }
+    render(width) {
+        return this.list === undefined ? [] : this.list.render(width);
+    }
+    handleInput(data) {
+        this.list?.handleInput(data);
+    }
+}
+/**
+ * Add-provider flow for the Models category — the terminal counterpart of
+ * pi-agent's /login, trimmed to the information a user actually needs: pick
+ * a provider from the built-in directory (searchable, oauth-selector-style
+ * title line), enter exactly one API key, done. The key editor reuses
+ * EditField (pending guard, late-error sink); the picker is a searchable
+ * SettingsList of the unconfigured directory entries.
+ */
+class AddProviderFlow {
+    tui;
+    theme;
+    list;
+    empty;
+    onExit;
+    fg;
+    fgMuted;
+    constructor(tui, theme, listTheme, options) {
+        this.tui = tui;
+        this.theme = theme;
+        this.empty = options.entries.length === 0;
+        this.onExit = options.onExit;
+        this.fg = text => ansiFg(theme.palette.accent) + text + RESET;
+        this.fgMuted = text => ansiFg(theme.palette.fgMuted) + text + RESET;
+        this.list = new SettingsList(options.entries.map(entry => ({
+            id: entry.id,
+            label: entry.name,
+            currentValue: '',
+            description: entry.hint,
+            submenu: (_current, done) => this.keyEditor(entry, options, done),
+        })), 12, listTheme, () => { }, () => options.onExit(), { enableSearch: true });
+    }
+    /** Key editor for one directory entry; commits through the write chain. */
+    keyEditor(entry, options, done) {
+        const ref = deriveKeyRef(entry.id);
+        return new EditField(this.tui, {
+            title: `API key for ${entry.name}`,
+            subtitle: `stored as ${ref} — never written to settings.yaml`,
+            initial: '',
+            // Never echo the key — masked dot row (B2).
+            secret: true,
+            parse: text => {
+                // Unlike an edit of a stored secret, the key is required here: a
+                // route with no key address cannot serve a request.
+                if (text.trim() === '')
+                    return { kind: 'error', error: 'API key must not be empty' };
+                return { kind: 'value', value: text.trim() };
+            },
+            onCommit: async (outcome) => {
+                if (outcome.kind !== 'value')
+                    return undefined;
+                return options.onCommit(entry, String(outcome.value));
+            },
+            // Enter and Esc both leave the flow (the commit is already in the
+            // serialized chain either way); the Models list refreshes on the way
+            // out so the new row is visible immediately.
+            onDone: () => {
+                done();
+                options.onExit();
+            },
+            onError: message => options.onError(message),
+        }, this.theme);
+    }
+    invalidate() {
+        this.list.invalidate();
+    }
+    render(width) {
+        const title = this.fg(BOLD + 'Select provider to configure:' + RESET);
+        if (this.empty) {
+            return [
+                title,
+                '',
+                this.fgMuted('All built-in providers are already configured.'),
+                this.fgMuted('  Esc to close'),
+            ];
+        }
+        return [title, '', ...this.list.render(width)];
+    }
+    handleInput(data) {
+        if (this.empty) {
+            if (getKeybindings().matches(data, 'tui.select.cancel'))
+                this.onExit();
+            return;
+        }
+        this.list.handleInput(data);
+    }
+}
+/**
+ * Open the modal settings browser. Resolves when it closes with the number of
+ * committed writes, or -1 when no namespace is registered (nothing to show).
+ */
+export async function openSettingsBrowser(options) {
+    const settings = options.ctx.get('settings');
+    if (settings === undefined)
+        throw new Error('settings service is not available');
+    const browser = new SettingsBrowser({ ...options, settings });
+    return browser.open();
+}
+class SettingsBrowser {
+    ctx;
+    tui;
+    theme;
+    listTheme;
+    settings;
+    restoreFocus;
+    onError;
+    descriptors = [];
+    /** Rehydrated schema roots, cached per namespace (schemas never change). */
+    roots = new Map();
+    changes = { value: 0 };
+    overlay;
+    catList;
+    nsList;
+    modelsView;
+    modelsExit;
+    /**
+     * Credential refs just stored by the add flow (possibly several in one
+     * browser session) — their rows read as key set via the merged env.
+     */
+    justStoredRefs = new Set();
+    /**
+     * Credential-document configuration snapshot, prefetched once per Models
+     * category open: ref → a value would resolve (`describe().configured`).
+     * Row building stays synchronous — the prefetch only fills this map and
+     * re-swaps the list when it settles.
+     */
+    credentialConfigured = new Map();
+    writeChain = Promise.resolve();
+    closed;
+    closeResolve;
+    constructor(options) {
+        this.ctx = options.ctx;
+        this.tui = options.tui;
+        this.theme = options.theme;
+        this.settings = options.settings;
+        this.restoreFocus = options.restoreFocus;
+        this.onError = options.onError;
+        // Assigned here, not as a field initializer: a later field declaration
+        // would `defineProperty(…, undefined)` over the promise's resolve.
+        this.closed = new Promise(resolve => { this.closeResolve = resolve; });
+        const p = options.theme.palette;
+        const fg = (hex) => (text) => ansiFg(hex) + text + RESET;
+        // canvasSubtle backdrop for every browser line. Raw lines (the search
+        // Input row, the bare "" separators from settings-list.js renderMainList,
+        // AddProviderFlow's title/blank lines, EditField's title/subtitle/error/
+        // notice rows) carry no theme styling of their own — the framed overlay
+        // (frame.ts fillLine) paints the full-width backdrop under them, so the
+        // popup stays one solid panel surface.
+        const bg = (hex) => (text) => ansiBg(hex) + text + RESET;
+        this.listTheme = {
+            label: (text, selected) => bg(p.canvasSubtle)(fg(p.fgDefault)(selected ? BOLD + text + RESET : text)),
+            value: (text, selected) => bg(p.canvasSubtle)(fg(selected ? p.accent : p.fgMuted)(text)),
+            description: text => bg(p.canvasSubtle)(fg(p.fgSubtle)(text)),
+            cursor: bg(p.canvasSubtle)(fg(p.accent)(BOLD + '▸ ')),
+            hint: text => bg(p.canvasSubtle)(fg(p.fgSubtle)(text)),
+        };
+    }
+    async open() {
+        this.refresh();
+        if (this.categories().length === 0)
+            return -1;
+        const list = this.categoryList();
+        this.catList = list;
+        // The framed overlay adds 4 rows (borders + spacers) on top of the list;
+        // the cap must leave them room or the bottom border is sliced off on
+        // small terminals (24 rows: ~15 list rows + 4 frame rows ≤ 19).
+        this.overlay = this.tui.showOverlay(wrapFramedOverlay(this.theme, list), { width: '80%', maxHeight: '80%' });
+        await this.closed;
+        return this.changes.value;
+    }
+    close() {
+        this.overlay?.hide();
+        this.overlay = undefined;
+        this.catList = undefined;
+        this.nsList = undefined;
+        this.modelsView = undefined;
+        this.modelsExit = undefined;
+        this.justStoredRefs.clear();
+        this.restoreFocus();
+        this.closeResolve();
+    }
+    /** Re-read descriptors (and with them revisions) from the service. */
+    refresh() {
+        this.descriptors = this.settings.describe();
+    }
+    descriptor(ns) {
+        return this.descriptors.find(d => d.ns === ns);
+    }
+    root(ns) {
+        const cached = this.roots.get(ns);
+        if (cached !== undefined)
+            return cached;
+        const desc = this.descriptor(ns);
+        if (desc === undefined)
+            return undefined;
+        const root = rehydrateSchema(desc.schema);
+        this.roots.set(ns, root);
+        return root;
+    }
+    // ------------------------------------------------------------ category level --
+    categories() {
+        return categorizeNamespaces(this.descriptors.map(d => d.ns));
+    }
+    categorySummary(cat) {
+        return `${cat.namespaces.length} namespaces`;
+    }
+    categoryDescription(cat) {
+        return categoryDescription(cat.namespaces, CATEGORY_DESC_MAX);
+    }
+    categoryList() {
+        const items = this.categories().map(cat => ({
+            id: cat.id,
+            label: cat.label,
+            currentValue: this.categorySummary(cat),
+            description: this.categoryDescription(cat),
+            submenu: cat.id === 'models'
+                ? (_current, done) => this.openModelsSubmenu(done)
+                : (_current, done) => {
+                    const list = this.namespaceList(this.descriptors.filter(d => cat.namespaces.includes(d.ns)), done);
+                    this.nsList = list;
+                    return list;
+                },
+        }));
+        const list = new SettingsList(items, 10, this.listTheme, () => { }, () => this.close(), { enableSearch: true });
+        return list;
+    }
+    refreshCategoryList() {
+        if (this.catList === undefined)
+            return;
+        this.refresh();
+        for (const cat of this.categories()) {
+            this.catList.updateValue(cat.id, this.categorySummary(cat));
+        }
+    }
+    // ------------------------------------------------------------ namespace level --
+    nsSummary(desc) {
+        const root = this.root(desc.ns);
+        if (root !== undefined && root.type === 'object') {
+            return `${Object.keys(root.dict ?? {}).length} fields`;
+        }
+        return formatValue(desc.value);
+    }
+    nsDescription(desc) {
+        const parts = [`applies: ${desc.applies}`];
+        if (desc.user !== undefined)
+            parts.push('user-set');
+        return parts.join(' · ');
+    }
+    /** Namespace list for one category; Esc pops back to the category level. */
+    namespaceList(descriptors, onExit) {
+        const items = descriptors.map(desc => ({
+            id: desc.ns,
+            label: desc.ns,
+            currentValue: this.nsSummary(desc),
+            description: this.nsDescription(desc),
+            submenu: (_current, done) => {
+                const section = this.sectionList(desc.ns, [], () => {
+                    this.refreshNsList();
+                    done();
+                });
+                return section.list;
+            },
+        }));
+        const list = new SettingsList(items, 10, this.listTheme, () => { }, () => {
+            this.refreshCategoryList();
+            onExit();
+        }, { enableSearch: true });
+        return list;
+    }
+    refreshNsList() {
+        if (this.nsList === undefined)
+            return;
+        this.refresh();
+        for (const desc of this.descriptors) {
+            this.nsList.updateValue(desc.ns, this.nsSummary(desc));
+        }
+    }
+    // ------------------------------------------------------------ models category --
+    /**
+     * The Models category does not expose the raw llm-pi-ai namespace: it
+     * lists one row per configured provider (label, model summary, API-key
+     * state), keeps dedicated rows for llm-deepseek and agent-default-model
+     * (each drilling into its original field editor), and ends with the
+     * Add-provider action. The list is rebuilt on every return because adding
+     * a provider changes it structurally.
+     */
+    openModelsSubmenu(done) {
+        this.modelsExit = () => {
+            this.refreshCategoryList();
+            done();
+        };
+        const view = new ModelsCategoryView();
+        this.modelsView = view;
+        view.swap(this.buildModelsList());
+        // The status column reads env + just-stored refs synchronously; the
+        // credentials document (`.credentials.yaml`) needs one async probe per
+        // ref, prefetched here so rows built later show the real state.
+        this.prefetchCredentialStatus();
+        return view;
+    }
+    /**
+     * Probe the credentials service for every provider ref the llm-pi-ai
+     * namespace references and remember the outcome. Called when the Models
+     * category opens (and again on each re-open, so keys added through other
+     * surfaces show up); row building stays synchronous. A settling probe
+     * re-swaps the Models list only while the category is still open.
+     */
+    prefetchCredentialStatus() {
+        const credentials = this.ctx.get('credentials');
+        if (credentials?.describe === undefined)
+            return;
+        const view = this.modelsView;
+        if (view === undefined)
+            return;
+        const piDesc = this.descriptor(NS_LLM_PI_AI);
+        const providers = (piDesc?.value ?? {});
+        const refs = [...new Set(Object.values(providers.providers ?? {})
+                .map(p => (typeof p === 'object' && p !== null ? p.apiKeyEnv : undefined))
+                .filter((ref) => typeof ref === 'string' && ref !== ''))];
+        if (refs.length === 0)
+            return;
+        void Promise.all(refs.map(async (ref) => {
+            try {
+                const info = await credentials.describe(ref);
+                this.credentialConfigured.set(ref, info.configured === true);
+            }
+            catch {
+                // A failing probe must not break the Models view — the row keeps
+                // its env-based read.
+            }
+        })).then(() => {
+            if (this.modelsView === view)
+                this.refreshModelsView();
+        });
+    }
+    /**
+     * Rebuild the Models list in place after a structural change.
+     * `justStoredRefs` survives the rebuild (cleared on close): the merged env
+     * marks the just-added rows as configured — the keys are stored in the
+     * credentials document, not in process.env — and stays accurate as long as
+     * the credentials do. Idempotent: each call re-reads descriptors and swaps
+     * one freshly built list.
+     */
+    refreshModelsView() {
+        const view = this.modelsView;
+        if (view === undefined)
+            return;
+        this.refresh();
+        view.swap(this.buildModelsList());
+    }
+    /**
+     * Environment view handed to providerRowView: process.env, plus every
+     * ref the add flow stored this session and every ref the credential probe
+     * found configured — both live in the credentials document, not in
+     * process.env, so their rows would otherwise read `API key missing`.
+     */
+    mergedEnv() {
+        const extra = {};
+        for (const ref of this.justStoredRefs)
+            extra[ref] = 'stored';
+        for (const [ref, configured] of this.credentialConfigured) {
+            if (configured)
+                extra[ref] = 'stored';
+        }
+        return Object.keys(extra).length === 0 ? process.env : { ...process.env, ...extra };
+    }
+    /**
+     * Live configurable-provider directory: route key → catalog-served? The
+     * llm service owns the catalog distinction for routes the static catalog
+     * does not name, so a web-added gateway row still gets an honest summary.
+     * Only llm-pi-ai's own directory entries are consulted — another namespace's
+     * configurable providers (e.g. llm-deepseek) configure a different surface.
+     * Structural face kept local like the credentials seam; absent or failing
+     * service degrades to an empty map (rows then fall back to the static
+     * catalog).
+     */
+    providerDirectory() {
+        const llm = this.ctx.get('llm');
+        if (llm?.listConfigurableProviders === undefined)
+            return new Map();
+        try {
+            return new Map(llm.listConfigurableProviders()
+                .filter(entry => entry.settingsNs === NS_LLM_PI_AI)
+                .map(entry => [entry.provider, entry.declared !== true]));
+        }
+        catch {
+            return new Map();
+        }
+    }
+    buildModelsList() {
+        const exit = this.modelsExit ?? (() => { });
+        const items = [];
+        const directory = this.providerDirectory();
+        const piDesc = this.descriptor(NS_LLM_PI_AI);
+        if (piDesc !== undefined) {
+            const providers = (piDesc.value ?? {});
+            const entries = Object.entries(providers.providers ?? {});
+            entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+            // Keys stored by the add flow live in the credentials document, not
+            // in process.env — merge them all so their rows read as configured
+            // right away (a second provider added in the same session too), and
+            // merge the prefetched credential state so keys stored earlier (e.g.
+            // through the web Models page) read as set instead of missing.
+            const env = this.mergedEnv();
+            for (const [id, profile] of entries) {
+                // The static catalog names the routes the TUI can add; the live llm
+                // directory tells catalog-served from hand-declared for every other
+                // configured route (e.g. one added through the web Models page), so
+                // the summary does not claim `0 models` for a route the catalog
+                // actually serves.
+                const entry = catalogEntry(id) ?? {
+                    id,
+                    name: id,
+                    hint: '',
+                    catalogRoute: directory.get(id) ?? false,
+                };
+                const view = providerRowView(id, entry, profile, env);
+                items.push({
+                    id: `provider:${id}`,
+                    label: view.label,
+                    currentValue: view.summary,
+                    description: view.status,
+                    // Read-only: the raw llm-pi-ai fields are deliberately not editable
+                    // here — Enter shows the stored profile, nothing more. A "re-store
+                    // the key" action (reusing keyEditor's EditField, credentials.set
+                    // only) was considered for rows whose key never landed (B3) but
+                    // needs a multi-action submenu component (~60 lines); skipped —
+                    // the commit failure text names the manual fallback instead.
+                    submenu: (_current, done) => new ReadOnlyViewer(this.theme, `providers.${id}`, profile, done),
+                });
+            }
+        }
+        const deepseekDesc = this.descriptor(NS_LLM_DEEPSEEK);
+        if (deepseekDesc !== undefined) {
+            items.push({
+                id: 'llm-deepseek',
+                label: 'DeepSeek (official)',
+                currentValue: this.nsSummary(deepseekDesc),
+                description: this.nsDescription(deepseekDesc),
+                submenu: (_current, done) => {
+                    const section = this.sectionList(deepseekDesc.ns, [], () => {
+                        this.refreshModelsView();
+                        done();
+                    });
+                    return section.list;
+                },
+            });
+        }
+        const agentDesc = this.descriptor(NS_AGENT_DEFAULT_MODEL);
+        if (agentDesc !== undefined) {
+            items.push({
+                id: 'agent-default-model',
+                label: 'Default model',
+                currentValue: this.defaultModelSummary(agentDesc),
+                description: this.nsDescription(agentDesc),
+                submenu: (_current, done) => {
+                    const section = this.sectionList(agentDesc.ns, [], () => {
+                        this.refreshModelsView();
+                        done();
+                    });
+                    return section.list;
+                },
+            });
+        }
+        if (piDesc !== undefined) {
+            const providers = (piDesc.value ?? {});
+            const configured = new Set(Object.keys(providers.providers ?? {}));
+            items.push({
+                id: '\u0000add-provider',
+                label: '+ Add provider…',
+                currentValue: '',
+                description: 'configure a built-in provider with its API key',
+                submenu: (_current, done) => new AddProviderFlow(this.tui, this.theme, this.listTheme, {
+                    entries: unconfiguredCatalogEntries(configured),
+                    onCommit: (entry, key) => this.commitNewProvider(entry, key),
+                    onExit: () => {
+                        done();
+                        this.refreshModelsView();
+                    },
+                    onError: message => this.onError(message),
+                }),
+            });
+        }
+        return new SettingsList(items, 12, this.listTheme, () => { }, 
+        // exit() (the modelsExit hook) already refreshes the category list —
+        // calling it again here would double-refresh (C8).
+        () => { exit(); }, { enableSearch: true });
+    }
+    /** Value column of the Default model row: provider/model · think level. */
+    defaultModelSummary(desc) {
+        const value = desc.value;
+        const provider = value?.provider;
+        const model = value?.model;
+        if (typeof provider === 'string' && provider !== '' && typeof model === 'string' && model !== '') {
+            const effort = value?.reasoningEffort;
+            return typeof effort === 'string' && effort !== ''
+                ? `${provider}/${model} · think ${effort}`
+                : `${provider}/${model}`;
+        }
+        return formatValue(desc.value);
+    }
+    // ------------------------------------------------------------- section levels --
+    /**
+     * Build the SettingsList for one schema node at `path` of `ns`.
+     * `onExit` runs when the list is popped (Esc) — it must refresh the parent
+     * level and call the parent's submenu `done()`.
+     */
+    sectionList(ns, path, onExit) {
+        const root = this.root(ns);
+        const desc = this.descriptor(ns);
+        const node = root !== undefined && path.length > 0
+            ? (nodeAtPath(root, path) ?? root)
+            : root;
+        const rows = node === undefined ? [] : this.buildRows(ns, node, path, desc?.value);
+        const refresh = () => { this.refreshRows(rows, list); };
+        const items = rows.map(row => this.rowItem(row, refresh));
+        const list = new SettingsList(items, 12, this.listTheme, (id, newValue) => { void this.onCycle(rows, list, id, newValue); }, () => {
+            refresh();
+            onExit();
+        }, { enableSearch: true });
+        return { list, refresh };
+    }
+    buildRows(ns, node, path, value) {
+        const rows = [];
+        if (node.type === 'object' || node.type === 'dict') {
+            rows.push({
+                id: '\u0000reset',
+                ns,
+                path,
+                label: `↺ Reset ${path.length === 0 ? 'this namespace' : path.join('.')} to defaults`,
+                kind: 'reset',
+                node,
+                value: undefined,
+                display: '',
+            });
+            if (node.type === 'dict') {
+                rows.push({
+                    id: '\u0000add',
+                    ns,
+                    path,
+                    label: '+ Add key…',
+                    kind: 'addkey',
+                    node,
+                    value: undefined,
+                    display: '',
+                });
+            }
+        }
+        if (node.type === 'object') {
+            for (const [key, child] of Object.entries(node.dict ?? {})) {
+                if (fieldMeta(child).hidden === true)
+                    continue;
+                rows.push(this.fieldRow(ns, child, [...path, key], key));
+            }
+        }
+        else if (node.type === 'dict') {
+            const entries = Object.entries((getPath(value, path) ?? {}));
+            entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+            const inner = node.inner ?? node;
+            for (const [key] of entries) {
+                rows.push(this.fieldRow(ns, inner, [...path, key], key));
+            }
+        }
+        return rows;
+    }
+    fieldRow(ns, node, path, label) {
+        const desc = this.descriptor(ns);
+        const meta = fieldMeta(node);
+        const value = getPath(desc?.value, path);
+        const secret = meta.role === 'secret';
+        const kind = this.rowKindFor(node);
+        const row = {
+            // JSON-encoded path: a dict key containing '.' must not collide with
+            // the nested-path row id of the same spelling.
+            id: JSON.stringify(path),
+            ns,
+            path,
+            label,
+            kind,
+            node,
+            value,
+            display: this.computeDisplay(kind, node, value, secret),
+            secret,
+        };
+        if (kind === 'cycle') {
+            row.values = this.cycleValues(node);
+            row.toRaw = display => this.cycleToRaw(node, display);
+        }
+        return row;
+    }
+    rowKindFor(node) {
+        switch (node.type) {
+            case 'object':
+            case 'dict': return 'drill';
+            case 'array': return 'readonly';
+            case 'boolean': return 'cycle';
+            case 'string': return 'input';
+            case 'number': return 'input';
+            case 'union': return unionLiterals(node).all ? 'cycle' : 'input';
+            case 'transform': return node.inner === undefined ? 'readonly' : this.rowKindFor(node.inner);
+            default: return 'readonly'; // literal, const, is, intersect, tuple, …
+        }
+    }
+    cycleValues(node) {
+        if (node.type === 'boolean')
+            return ['true', 'false'];
+        return unionLiterals(node).values.map(displayValue);
+    }
+    cycleToRaw(node, display) {
+        if (node.type === 'boolean')
+            return display === 'true';
+        const { values } = unionLiterals(node);
+        const literal = values.find(value => displayValue(value) === display);
+        if (literal === undefined)
+            throw new Error(`unexpected cycle value: ${display}`);
+        return literal;
+    }
+    computeDisplay(kind, node, value, secret) {
+        if (secret)
+            return value === undefined || value === null || value === '' ? '(unset)' : '••••••';
+        switch (kind) {
+            case 'drill': {
+                if (node.type === 'object')
+                    return `{${Object.keys(node.dict ?? {}).length} fields}`;
+                if (node.type === 'dict') {
+                    const entries = Object.keys((value ?? {}));
+                    return `dict · ${entries.length} ${entries.length === 1 ? 'entry' : 'entries'}`;
+                }
+                return formatValue(value);
+            }
+            default: return formatValue(value);
+        }
+    }
+    /** SettingItem for one row; drill/input/reset/addkey attach their submenus. */
+    rowItem(row, refresh) {
+        const base = {
+            id: row.id,
+            label: row.label,
+            currentValue: row.display,
+            description: this.rowDescription(row),
+        };
+        switch (row.kind) {
+            case 'cycle': return { ...base, values: row.values };
+            case 'drill': return {
+                ...base,
+                submenu: (_current, done) => {
+                    const child = this.sectionList(row.ns, row.path, () => { refresh(); done(); });
+                    return child.list;
+                },
+            };
+            case 'input': return { ...base, submenu: (_current, done) => this.inputSubmenu(row, refresh, done) };
+            case 'addkey': return { ...base, submenu: (_current, done) => this.addKeySubmenu(row, refresh, done) };
+            case 'reset': return {
+                ...base,
+                submenu: (_current, done) => this.resetSubmenu(row, refresh, done),
+            };
+            // Read-only rows still open the JSON viewer — Enter shows the value in
+            // full instead of silently doing nothing (the module header's promise).
+            default: return {
+                ...base,
+                submenu: (_current, done) => new ReadOnlyViewer(this.theme, row.path.join('.'), row.value, done),
+            };
+        }
+    }
+    rowDescription(row) {
+        if (row.kind === 'reset' || row.kind === 'addkey')
+            return '';
+        const desc = this.descriptor(row.ns);
+        const userOverride = desc?.user !== undefined && this.hasPath(desc.user, row.path);
+        return fieldDescription(row.node, userOverride);
+    }
+    hasPath(user, path) {
+        if (path.length === 0)
+            return user !== undefined;
+        let current = user;
+        for (const key of path) {
+            if (Array.isArray(current)) {
+                current = current[Number(key)];
+                continue;
+            }
+            if (typeof current !== 'object' || current === null)
+                return false;
+            current = current[key];
+        }
+        return true;
+    }
+    /** Recompute every row's value/display from a fresh descriptor. */
+    refreshRows(rows, list) {
+        const ns = rows[0]?.ns;
+        if (ns === undefined)
+            return;
+        this.refresh();
+        const desc = this.descriptor(ns);
+        if (desc === undefined)
+            return;
+        for (const row of rows) {
+            if (row.kind === 'reset' || row.kind === 'addkey')
+                continue;
+            row.value = getPath(desc.value, row.path);
+            row.display = this.computeDisplay(row.kind, row.node, row.value, row.secret === true);
+            list.updateValue(row.id, row.display);
+        }
+    }
+    // ------------------------------------------------------------------- write path --
+    /** Serialized settings write; resolves with an error message, or undefined. */
+    write(ns, ops) {
+        const task = this.writeChain.then(async () => {
+            try {
+                // Revision read at execution time: the previous write in the chain has
+                // already refreshed descriptors, so rapid consecutive writes never
+                // conflict with themselves.
+                await this.settings.mutate(ns, [...ops], this.descriptor(ns)?.revision);
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+            this.changes.value += 1;
+            this.refresh();
+            return undefined;
+        });
+        this.writeChain = task.then(() => undefined, () => undefined);
+        return task;
+    }
+    /**
+     * Add-provider commit: write the llm-pi-ai profile through the serialized
+     * settings chain (revision read at execution time), then store the key
+     * through the credentials seam — the same two writes the web Models page
+     * performs. A missing credentials service still commits the profile (it
+     * names the derived ref; the key then has to come from the environment).
+     *
+     * Outcome surface: a write failure is an `error`; a committed profile whose
+     * key could not be stored is an `error` with the manual fallback spelled
+     * out (B3); a committed profile with no credentials service at all is a
+     * `notice` (success + hint, no ✘ — C11).
+     */
+    async commitNewProvider(entry, key) {
+        const ref = deriveKeyRef(entry.id);
+        const error = await this.write(NS_LLM_PI_AI, [{
+                op: 'set',
+                path: ['providers', entry.id],
+                value: providerProfileFor(entry),
+            }]);
+        if (error !== undefined)
+            return { error };
+        const credentials = this.ctx.get('credentials');
+        if (credentials === undefined) {
+            // No credential store in this process — the row is configured and the
+            // key must come from the environment; this is a success with a hint,
+            // never an error. Enter re-runs the commit idempotently.
+            return { notice: `provider added — no credentials service in this process: export ${ref} to use it` };
+        }
+        try {
+            await credentials.set(ref, key);
+        }
+        catch (cause) {
+            // The profile is committed but the key did not land: the row already
+            // counts as configured, so the user needs the manual path. The error
+            // stays retryable in place — Enter re-runs the whole commit (B3).
+            return {
+                error: `API key not stored: ${cause instanceof Error ? cause.message : String(cause)}`
+                    + ` — provider added; export ${ref}=<key> to use it`,
+            };
+        }
+        this.justStoredRefs.add(ref);
+        // Settle-time rebuild: if Esc closed the editor while the write was in
+        // flight, the onExit refresh already ran against stale descriptors and
+        // nothing else would repaint the new row. Idempotent (B5); on the normal
+        // path the onExit refresh repeats it harmlessly.
+        if (this.modelsView !== undefined)
+            this.refreshModelsView();
+        return undefined;
+    }
+    onCycle(rows, list, id, newValue) {
+        const row = rows.find(r => r.id === id);
+        if (row === undefined || row.kind !== 'cycle' || row.toRaw === undefined)
+            return;
+        let raw;
+        try {
+            raw = row.toRaw(newValue);
+        }
+        catch {
+            this.refreshRows(rows, list);
+            return;
+        }
+        void this.write(row.ns, [{ op: 'set', path: row.path, value: raw }]).then(error => {
+            // Success and failure alike re-read the descriptor: the service's
+            // resolved value is the single source of truth for the row display,
+            // never a local snapshot (which concurrent writes may have aged).
+            if (error !== undefined)
+                this.onError(error);
+            this.refreshRows(rows, list);
+        });
+    }
+    /** Build the edit submenu for a leaf row; commits write to settings. */
+    inputSubmenu(row, refresh, done) {
+        const meta = fieldMeta(row.node);
+        const initial = row.secret === true || row.value === undefined || row.value === null
+            ? ''
+            : String(row.value);
+        return new EditField(this.tui, {
+            title: row.path.join('.'),
+            subtitle: row.secret === true
+                ? 'secret — leave empty to keep the current value'
+                : `current: ${row.display}${meta.required === true ? ' · required' : ''}`,
+            initial,
+            // role('secret') rows get the masked dot-row renderer too (B2).
+            secret: row.secret === true,
+            parse: text => this.parseFor(row, text),
+            onCommit: outcome => this.commitInput(row, refresh, outcome),
+            onDone: done,
+            onError: message => this.onError(message),
+        }, this.theme);
+    }
+    parseFor(row, text) {
+        // Whitespace-only input on a secret also means "keep" — an accidental
+        // space must not unset (delete) the stored secret; clearing a secret is
+        // the reset row's job, not the editor's empty submit.
+        if (row.secret === true && text.trim() === '')
+            return { kind: 'keep' };
+        switch (row.node.type) {
+            case 'number': return parseNumberInput(text);
+            case 'string': return parseStringInput(text);
+            case 'union': return parseUnionInput(text, row.node);
+            case 'transform':
+                return row.node.inner === undefined
+                    ? { kind: 'error', error: `cannot edit ${row.node.type} value` }
+                    : this.parseFor({ ...row, node: row.node.inner }, text);
+            default: return { kind: 'error', error: `cannot edit ${row.node.type} value` };
+        }
+    }
+    async commitInput(row, refresh, outcome) {
+        if (outcome.kind !== 'value' && outcome.kind !== 'unset')
+            return undefined;
+        const ops = outcome.kind === 'unset'
+            ? [{ op: 'unset', path: row.path }]
+            : [{ op: 'set', path: row.path, value: outcome.value }];
+        const error = await this.write(row.ns, ops);
+        if (error === undefined)
+            refresh();
+        return error === undefined ? undefined : { error };
+    }
+    /** Add-key editor for dict sections; commits a default-valued entry. */
+    addKeySubmenu(row, refresh, done) {
+        const inner = row.node.inner ?? row.node;
+        const existing = (getPath(this.descriptor(row.ns)?.value, row.path) ?? {});
+        return new EditField(this.tui, {
+            title: `+ key in ${row.path.length === 0 ? '…' : row.path.join('.')}`,
+            subtitle: `default: ${formatValue(defaultValueFor(inner))} · Enter to add · Esc to cancel`,
+            initial: '',
+            parse: text => {
+                const key = text.trim();
+                if (key === '')
+                    return { kind: 'error', error: 'key must not be empty' };
+                if (key in existing)
+                    return { kind: 'error', error: `key "${key}" already exists` };
+                return { kind: 'value', value: key };
+            },
+            onCommit: async (outcome) => {
+                if (outcome.kind !== 'value')
+                    return undefined;
+                const key = String(outcome.value);
+                const error = await this.write(row.ns, [{ op: 'set', path: [...row.path, key], value: defaultValueFor(inner) }]);
+                if (error === undefined)
+                    refresh();
+                return error === undefined ? undefined : { error };
+            },
+            onDone: done,
+            onError: message => this.onError(message),
+        }, this.theme);
+    }
+    /** Reset-to-defaults confirmation for group/namespace rows. */
+    resetSubmenu(row, refresh, done) {
+        return new ConfirmReset(this.theme, row.path.length === 0
+            ? `Reset "${row.ns}" to defaults`
+            : `Reset ${row.path.join('.')} to defaults`, () => {
+            void this.write(row.ns, [{ op: 'unset', path: row.path }]).then(error => {
+                if (error !== undefined)
+                    this.onError(error);
+                else
+                    refresh();
+                done();
+            });
+        }, () => done());
+    }
+}
+//# sourceMappingURL=settings.js.map