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

package/dist/tui/app.js

@@ -5,11 +5,15 @@ import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_IMAGE_BYTES, pasteImageFromClipboard,
 import { copyText, nodeSpawn } from "./clipboard.js";
 import { AttachmentsBar, BannerBlock, clock, Footer, Header, QuestionPanel, Switch, TranscriptSync, TreePanel, } from "./components.js";
 import { ConnectInputPrompt } from "./connect-input.js";
+import { bounded, EXIT_PENDING_CAP_MS, EXIT_SESSION_END_CAP_MS } from "./exit.js";
+import { BRANCH_REFRESH_MS, createBranchCache } from "./git-branch.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. */
@@ -151,6 +155,21 @@ export async function runTui(options) {
         }, ms);
         tui.requestRender();
     };
+    // Git branch of the workspace for the header. Reading refs is a read operation, so it stays on
+    // under --read-only; the TTL cache means git is spawned at most once per ~10s, never per frame,
+    // and a missing repo/git or a slow spawn simply yields no branch segment.
+    const branchCache = createBranchCache();
+    let branchName;
+    const refreshBranch = () => {
+        void branchCache.read(app.workspace).then((branch) => {
+            if (branch !== branchName) {
+                branchName = branch;
+                tui.requestRender();
+            }
+        });
+    };
+    refreshBranch();
+    const branchTimer = setInterval(refreshBranch, BRANCH_REFRESH_MS);
     const headerInfo = () => {
         const policy = app.runner.policy, ask = app.runner.approvals;
         return {
@@ -160,6 +179,7 @@ export async function runTui(options) {
             provider: app.providers.get(activeProvider?.id ?? "")?.name,
             cwd: shortenPath(app.workspace, homedir()),
             session: shortId(session),
+            branch: branchName,
             write: policy.write ? "on" : ask ? "ask" : "off",
             process: policy.process ? "on" : ask ? "ask" : "off",
             mcp: app.mcpRuntimePermission() === "granted",
@@ -229,7 +249,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 +343,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 +353,7 @@ export async function runTui(options) {
     };
     const closePicker = () => {
         picker = undefined;
+        settingsMenu = undefined;
         pickerSlot.clear();
         tui.setFocus(editor);
         tui.requestRender();
@@ -476,7 +497,7 @@ export async function runTui(options) {
     const endSession = async (reason) => {
         if (!view.stats.runs || !app.plugins.hasSessionEndHooks)
             return;
-        flashHint("Running session-end plugin hooks (bounded by pluginHooks.sessionEndTimeoutMs)…", 60_000);
+        flashHint("Running session-end plugin hooks…", 60_000);
         tui.renderNow?.();
         try {
             const { failures } = await app.endSession(session, reason);
@@ -496,8 +517,12 @@ export async function runTui(options) {
             return;
         stopping = true;
         controller?.abort(new Error("Exiting"));
-        await Promise.race([pending?.catch(() => { }), new Promise((r) => setTimeout(r, 3000))]);
-        await endSession("exit");
+        // Exit must feel instant: an in-flight turn gets up to 3s (the abort above settles it
+        // immediately in practice), then session-end hooks get a short cap — /clear still honors
+        // the full pluginHooks.sessionEndTimeoutMs. app.close() later in the main path is itself
+        // parallel and capped, so the whole exit path is bounded end to end.
+        await bounded(pending?.catch(() => { }), EXIT_PENDING_CAP_MS);
+        await bounded(endSession("exit"), EXIT_SESSION_END_CAP_MS);
         resolveExit();
     };
     const askInput = (input) => new Promise((resolve) => {
@@ -922,6 +947,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 +1169,7 @@ export async function runTui(options) {
         "plugins",
         "skills",
         "mcp",
+        "settings",
         "compact",
         "clear",
         "resume",
@@ -1081,6 +1226,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 +1296,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
@@ -1402,6 +1562,7 @@ export async function runTui(options) {
     }
     finally {
         clearInterval(ticker);
+        clearInterval(branchTimer);
         clearTimeout(hintTimer);
         process.off("SIGTERM", onSignal);
         process.off("SIGHUP", onSignal);

package/dist/tui/components.d.ts

@@ -17,6 +17,8 @@ export interface HeaderInfo {
     provider?: string;
     cwd: string;
     session: string;
+    /** Git branch (or short SHA on a detached HEAD) of the session workspace; undefined when unavailable. */
+    branch?: string;
     write: PermissionState;
     process: PermissionState;
     mcp: boolean;

package/dist/tui/components.js

@@ -1,5 +1,7 @@
 import { Container, getCapabilities, Image, Key, Markdown, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { terminalCapabilities } from "../banner.js";
 import { attachmentCaption, MAX_ATTACHMENTS_PER_MESSAGE, } from "./attachments.js";
+import { branchDisplay } from "./git-branch.js";
 import { initialQuestionState, reduceQuestions, } from "./questions.js";
 import { contextLevel, contextPercent, editSummary, fitSegments, formatContext, formatDuration, formatTokens, } from "./state.js";
 import { imageTheme, levelColor, markdownTheme, style } from "./theme.js";
@@ -53,6 +55,19 @@ export class Header {
         const line2 = line([
             { text: i.cwd, priority: 6, paint: style.cyan },
             { text: `session ${i.session}`, priority: 4, paint: style.gray },
+            // Priority 3 (below session's 4): the branch is ambient context, so on narrow terminals it
+            // drops first — before the session ID and permissions. At equal priority fitSegments drops
+            // the FIRST lowest-priority segment, which would mis-drop the session when branch sits
+            // after it, so the branch keeps a strictly lower priority instead.
+            ...(i.branch
+                ? [
+                    {
+                        text: branchDisplay(i.branch, terminalCapabilities({ env: process.env, columns: width, tty: true }).unicode),
+                        priority: 3,
+                        paint: style.cyan,
+                    },
+                ]
+                : []),
             ...perms,
         ], width);
         return fit([line1, line2, style.gray("─".repeat(Math.max(0, width)))], width);

package/dist/tui/exit.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interactive-exit bounds: `/exit`, double Ctrl+C on an empty input, Ctrl+D and SIGINT/SIGTERM
+ * must feel instant, so each shutdown step is raced against a cap instead of awaiting teardown
+ * without limits. The plugin host's own hook timeout (`pluginHooks.sessionEndTimeoutMs`) still
+ * applies to `/clear`; exit deliberately uses shorter user-facing caps on the same hooks.
+ */
+export declare const EXIT_PENDING_CAP_MS = 3000;
+export declare const EXIT_SESSION_END_CAP_MS = 1500;
+/** Resolves when `work` settles or after `capMs`, whichever comes first; never rejects. */
+export declare function bounded(work: Promise<unknown> | undefined, capMs: number): Promise<void>;

package/dist/tui/exit.js

@@ -0,0 +1,15 @@
+/**
+ * Interactive-exit bounds: `/exit`, double Ctrl+C on an empty input, Ctrl+D and SIGINT/SIGTERM
+ * must feel instant, so each shutdown step is raced against a cap instead of awaiting teardown
+ * without limits. The plugin host's own hook timeout (`pluginHooks.sessionEndTimeoutMs`) still
+ * applies to `/clear`; exit deliberately uses shorter user-facing caps on the same hooks.
+ */
+export const EXIT_PENDING_CAP_MS = 3_000;
+export const EXIT_SESSION_END_CAP_MS = 1_500;
+/** Resolves when `work` settles or after `capMs`, whichever comes first; never rejects. */
+export function bounded(work, capMs) {
+    return Promise.race([
+        Promise.resolve(work).catch(() => { }),
+        new Promise((resolve) => setTimeout(resolve, capMs)),
+    ]).then(() => undefined);
+}

package/dist/tui/git-branch.d.ts

@@ -0,0 +1,48 @@
+import { execFile } from "node:child_process";
+/** Hard cap for branch names shown in the header, so a hostile/long ref never breaks layout. */
+export declare const BRANCH_MAX_LENGTH = 24;
+/** How long a resolved branch is reused before git is asked again (avoids spawning per frame). */
+export declare const BRANCH_TTL_MS = 10000;
+/** Re-check cadence; matches the cache TTL so the header follows branch switches within ~10s. */
+export declare const BRANCH_REFRESH_MS = 10000;
+/** Bounded spawn: a slow or hung git must never stall the TUI. */
+export declare const BRANCH_TIMEOUT_MS = 800;
+type Spawn = typeof execFile;
+/**
+ * Strips ANSI escapes and control characters, then truncates to `BRANCH_MAX_LENGTH` chars with an
+ * ellipsis. Branch names come from the workspace repository, not from user input, but a hostile or
+ * corrupted ref must never inject escape sequences or overflow the header line.
+ */
+export declare function sanitizeBranchName(name: string): string;
+/** Header segment text: `⎇ main` on unicode terminals, `branch main` otherwise. */
+export declare function branchDisplay(branch: string, unicode: boolean): string;
+export interface ReadBranchOptions {
+    timeoutMs?: number;
+    /** Injectable for tests; defaults to node:child_process execFile. */
+    spawn?: Spawn;
+}
+/**
+ * Reads the branch of the git repository at `workspace` (read-only ref query, safe under
+ * `--read-only`). Returns the branch name, the short commit SHA on a detached HEAD, or `undefined`
+ * when the directory is missing, is not a git repository, git itself is unavailable, or the call
+ * times out. All failures are silent: stderr is captured and never printed.
+ */
+export declare function readGitBranch(workspace: string, options?: ReadBranchOptions): Promise<string | undefined>;
+export interface BranchCache {
+    /** Cached branch for `workspace`, or a fresh read when the entry expired; dedupes in-flight reads. */
+    read(workspace: string): Promise<string | undefined>;
+    clear(workspace: string): void;
+}
+export interface BranchCacheOptions {
+    ttlMs?: number;
+    timeoutMs?: number;
+    spawn?: Spawn;
+    /** Injectable clock for expiry tests. */
+    now?: () => number;
+}
+/**
+ * TTL cache keyed by workspace so the TUI never spawns git on every frame: one read per workspace
+ * per `ttlMs` (hits and misses are both cached), with a single in-flight promise per key.
+ */
+export declare function createBranchCache(options?: BranchCacheOptions): BranchCache;
+export {};

package/dist/tui/git-branch.js

@@ -0,0 +1,99 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+/** Hard cap for branch names shown in the header, so a hostile/long ref never breaks layout. */
+export const BRANCH_MAX_LENGTH = 24;
+/** How long a resolved branch is reused before git is asked again (avoids spawning per frame). */
+export const BRANCH_TTL_MS = 10_000;
+/** Re-check cadence; matches the cache TTL so the header follows branch switches within ~10s. */
+export const BRANCH_REFRESH_MS = BRANCH_TTL_MS;
+/** Bounded spawn: a slow or hung git must never stall the TUI. */
+export const BRANCH_TIMEOUT_MS = 800;
+/**
+ * Strips ANSI escapes and control characters, then truncates to `BRANCH_MAX_LENGTH` chars with an
+ * ellipsis. Branch names come from the workspace repository, not from user input, but a hostile or
+ * corrupted ref must never inject escape sequences or overflow the header line.
+ */
+export function sanitizeBranchName(name) {
+    const clean = name
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/[\u0000-\u001f\u007f]/g, "")
+        .trim();
+    const chars = [...clean];
+    return chars.length > BRANCH_MAX_LENGTH
+        ? `${chars.slice(0, BRANCH_MAX_LENGTH - 1).join("")}…`
+        : clean;
+}
+/** Header segment text: `⎇ main` on unicode terminals, `branch main` otherwise. */
+export function branchDisplay(branch, unicode) {
+    return `${unicode ? "⎇" : "branch"} ${branch}`;
+}
+function runGit(spawn, args, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        spawn("git", args, { cwd, timeout: timeoutMs, windowsHide: true }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+/**
+ * Reads the branch of the git repository at `workspace` (read-only ref query, safe under
+ * `--read-only`). Returns the branch name, the short commit SHA on a detached HEAD, or `undefined`
+ * when the directory is missing, is not a git repository, git itself is unavailable, or the call
+ * times out. All failures are silent: stderr is captured and never printed.
+ */
+export async function readGitBranch(workspace, options = {}) {
+    const timeoutMs = options.timeoutMs ?? BRANCH_TIMEOUT_MS;
+    if (!existsSync(workspace))
+        return undefined;
+    const spawn = options.spawn ?? execFile;
+    try {
+        const ref = (await runGit(spawn, ["rev-parse", "--abbrev-ref", "HEAD"], workspace, timeoutMs)).trim();
+        if (ref && ref !== "HEAD")
+            return sanitizeBranchName(ref);
+        if (ref === "HEAD") {
+            const sha = (await runGit(spawn, ["rev-parse", "--short", "HEAD"], workspace, timeoutMs)).trim();
+            return sha ? sanitizeBranchName(sha) : undefined;
+        }
+        return undefined;
+    }
+    catch {
+        // Not a repository, git missing, or timed out: the header simply shows no branch segment.
+        return undefined;
+    }
+}
+/**
+ * TTL cache keyed by workspace so the TUI never spawns git on every frame: one read per workspace
+ * per `ttlMs` (hits and misses are both cached), with a single in-flight promise per key.
+ */
+export function createBranchCache(options = {}) {
+    const ttlMs = options.ttlMs ?? BRANCH_TTL_MS;
+    const now = options.now ?? Date.now;
+    const entries = new Map();
+    const inflight = new Map();
+    const read = (workspace) => {
+        const hit = entries.get(workspace);
+        if (hit && hit.expires > now())
+            return Promise.resolve(hit.branch);
+        const pending = inflight.get(workspace);
+        if (pending)
+            return pending;
+        const promise = readGitBranch(workspace, {
+            timeoutMs: options.timeoutMs,
+            spawn: options.spawn,
+        })
+            .then((branch) => {
+            entries.set(workspace, { branch, expires: now() + ttlMs });
+            inflight.delete(workspace);
+            return branch;
+        })
+            .catch(() => {
+            inflight.delete(workspace);
+            return undefined;
+        });
+        inflight.set(workspace, promise);
+        return promise;
+    };
+    return { read, clear: (workspace) => void entries.delete(workspace) };
+}

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[];
+}