@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/modes/rpc/jsonl.js

@@ -0,0 +1,88 @@
+/** Strict LF-framed JSONL reader (Pi-style).
+ *
+ *  - Only `\n` (0x0A) splits frames - a generic line reader that also splits
+ *    on Unicode separators would corrupt payloads.
+ *  - Byte-buffer based: half packets accumulate until the next LF.
+ *  - A single frame is bounded (`maxLineBytes`); oversized frames are skipped
+ *    and reported via `onOversize`. The buffer is trimmed so a hostile peer
+ *    cannot grow memory without bound - trimmed bytes belong to an oversized
+ *    frame, which is discarded up to its terminating LF. */
+export function createJsonlReader(stream, opts = {}) {
+    const maxLineBytes = opts.maxLineBytes ?? 16 * 1024 * 1024;
+    const reader = stream.getReader();
+    const lines = (async function* () {
+        const decoder = new TextDecoder("utf-8");
+        let buffer = new Uint8Array(0);
+        // True while the buffered bytes belong to a frame already known to
+        // exceed the bound: everything up to the next LF is discarded.
+        let inOversize = false;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value.length === 0)
+                    continue;
+                // Append the chunk.
+                const next = new Uint8Array(buffer.length + value.length);
+                next.set(buffer, 0);
+                next.set(value, buffer.length);
+                buffer = next;
+                // Split on LF only.
+                let start = 0;
+                for (let i = 0; i < buffer.length; i++) {
+                    if (buffer[i] !== 0x0a)
+                        continue;
+                    const lineLen = i - start;
+                    if (inOversize) {
+                        // The LF terminates the truncated oversized frame: discard it.
+                        inOversize = false;
+                    }
+                    else if (lineLen <= maxLineBytes) {
+                        yield decoder.decode(buffer.subarray(start, i));
+                    }
+                    else {
+                        // The frame ended at this LF (it is complete but oversized).
+                        opts.onOversize?.(lineLen);
+                    }
+                    start = i + 1;
+                }
+                buffer = buffer.slice(start);
+                // Memory bound: a partial frame longer than the bound can never
+                // become a valid line - drop it, discard up to the next LF.
+                if (buffer.length > maxLineBytes) {
+                    inOversize = true;
+                    buffer = new Uint8Array(0);
+                }
+            }
+            // Trailing frame without a final LF.
+            if (buffer.length > 0) {
+                if (!inOversize && buffer.length <= maxLineBytes) {
+                    yield decoder.decode(buffer);
+                }
+                else if (!inOversize) {
+                    opts.onOversize?.(buffer.length);
+                }
+            }
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                /* already released */
+            }
+        }
+    })();
+    return {
+        lines,
+        async cancel() {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                /* stream already closed */
+            }
+        },
+    };
+}

package/dist/modes/rpc/rpc-mode.d.ts

@@ -0,0 +1,18 @@
+import type { ModelRuntime } from "@chengchenccc/ai";
+/** Minimal RPC mode: stdin JSONL commands, stdout JSONL outputs only, stderr
+ *  for logs. One process = at most one execute = one Run = one outcome, then
+ *  the process exits. No Session lifecycle, no HTTP, no registry. */
+export interface RpcModeOptions {
+    modelRuntime: ModelRuntime;
+    stdin?: ReadableStream<Uint8Array>;
+    /** stdout writer; the RPC mode ONLY writes JSONL lines here. */
+    writeLine?: (line: string) => void;
+    log?: (line: string) => void;
+}
+export interface RpcModeController {
+    readonly promise: Promise<number>;
+    /** Abort the live Run (SIGINT/SIGTERM path): outcome settles aborted. */
+    stop(): void;
+}
+export declare function runRpcMode(opts: RpcModeOptions): RpcModeController;
+//# sourceMappingURL=rpc-mode.d.ts.map

package/dist/modes/rpc/rpc-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-mode.d.ts","sourceRoot":"","sources":["../../../src/modes/rpc/rpc-mode.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmCrD;;qEAEqE;AAErE,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACnC,gEAAgE;IAChE,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAClC,yEAAyE;IACzE,IAAI,IAAI,IAAI,CAAC;CACd;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,iBAAiB,CA0VlE"}

package/dist/modes/rpc/rpc-mode.js

@@ -0,0 +1,326 @@
+import { existsSync, statSync } from "node:fs";
+import { debugLog } from "@chengchenccc/agent-contract";
+import { MessageSchema } from "@chengchenccc/message";
+import { assemblePluginRuntime } from "../../core/plugins/plugin-resolve.js";
+import { approvalTimeoutMs, withApprovalDeadline, } from "../../core/runtime/approval.js";
+import { createOmaRuntime } from "../../core/runtime/create-runtime.js";
+import { buildSystemPrompt, readMemorySummary } from "../../core/runtime/prompts.js";
+import { appendSessionCompaction, appendSessionMessages, loadSessionMessages, newSessionId, } from "../../core/session/session-file.js";
+import { readWorkspaceSystemPrompt, scanWorkspaceSkillRoots, } from "../../core/settings/workspace-context.js";
+import { codingAgentCommandSchema, eventOutputSchema, outcomeOutputSchema, responseOutputSchema, } from "../../protocol/index.js";
+import { createJsonlReader } from "./jsonl.js";
+function redactError(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function runRpcMode(opts) {
+    const stdin = opts.stdin ?? Bun.stdin.stream();
+    const write = opts.writeLine ?? ((line) => process.stdout.write(line));
+    const log = opts.log ?? ((line) => process.stderr.write(`${line}\n`));
+    // Serialized output: whole lines, in order, never interleaved.
+    let writeChain = Promise.resolve();
+    const emit = (output) => {
+        const line = JSON.stringify(output);
+        writeChain = writeChain.then(() => {
+            write(`${line}\n`);
+        });
+    };
+    const emitResponse = (id, command, success, error) => {
+        emit(responseOutputSchema.parse({
+            id,
+            type: "response",
+            command,
+            success,
+            ...(success ? {} : { error: error ?? "command failed" }),
+        }));
+    };
+    let runtime = null;
+    let currentRunId = null;
+    let executed = false;
+    let finished = false;
+    const reader = createJsonlReader(stdin);
+    /** runId → (callId → resolver). Late/unknown resolutions fail soft. */
+    const pendingApprovalsByRun = new Map();
+    const promise = (async () => {
+        try {
+            for await (const line of reader.lines) {
+                if (finished) {
+                    // The Run settled: the process exits. One more line is read so a
+                    // protocol-violating second execute gets an explicit rejection;
+                    // anything else (or EOF) just ends the process.
+                    if (line.trim()) {
+                        try {
+                            const command = codingAgentCommandSchema.parse(JSON.parse(line));
+                            if (command.type === "execute") {
+                                emitResponse(command.id, "execute", false, "a process accepts at most one execute command");
+                            }
+                        }
+                        catch {
+                            /* ignored: the process is exiting */
+                        }
+                    }
+                    break;
+                }
+                if (!line.trim())
+                    continue;
+                let command;
+                try {
+                    command = codingAgentCommandSchema.parse(JSON.parse(line));
+                }
+                catch {
+                    // Malformed JSON: a failure response keeps the protocol clean; the
+                    // peer settles the Run failed on an uncorrelated response.
+                    log(`malformed command (${line.length} bytes)`);
+                    emit(responseOutputSchema.parse({
+                        id: "",
+                        type: "response",
+                        command: "execute",
+                        success: false,
+                        error: "malformed JSON command",
+                    }));
+                    continue;
+                }
+                switch (command.type) {
+                    case "execute": {
+                        if (executed) {
+                            // Protocol invariant: one process → at most one execute.
+                            emitResponse(command.id, "execute", false, "a process accepts at most one execute command");
+                            break;
+                        }
+                        executed = true; // consumed synchronously: no double-execute race
+                        // Acceptance is AWAITED so the success response is always the
+                        // first output; the loop itself runs concurrently below so
+                        // steer/abort written after acceptance stay routable.
+                        await acceptExecute(command);
+                        break;
+                    }
+                    case "steer":
+                        handleSteer(command);
+                        break;
+                    case "abort":
+                        handleAbort(command);
+                        break;
+                    case "resolve_approval": {
+                        const resolve = pendingApprovalsByRun.get(command.runId)?.get(command.callId);
+                        if (resolve) {
+                            resolve({ decision: command.decision });
+                            emitResponse(command.id, "resolve_approval", true);
+                        }
+                        else {
+                            emitResponse(command.id, "resolve_approval", false, `no pending approval ${command.callId}`);
+                        }
+                        break;
+                    }
+                }
+            }
+            if (!finished) {
+                log(`stdin closed before an outcome was produced (executed=${executed})`);
+                return 1;
+            }
+            return await writeChain.then(() => 0);
+        }
+        catch (err) {
+            log(`rpc mode failed: ${redactError(err)}`);
+            return 1;
+        }
+    })();
+    /** Validate + assemble the Runtime, START the loop, and emit the execute
+     *  response ONLY once the loop is live (agent_start). Awaited by the
+     *  reader so the acceptance response is always the first output AND
+     *  implies steer/abort are routable; the outcome runs CONCURRENTLY via
+     *  driveOutcome, keeping steer/abort routable for the whole run. */
+    async function acceptExecute(command) {
+        const input = command.input;
+        debugLog("oma", `execute_received runId=${input.run.runId}`);
+        const err = await validateExecute(input, opts.modelRuntime);
+        if (err) {
+            emitResponse(command.id, "execute", false, err);
+            return;
+        }
+        const runId = input.run.runId;
+        // Session (ADR 0003 decision 6): the child owns its session file; the
+        // product forwards the branch's opaque reference. Resume loads the
+        // transcript as the loop's seed history (validated at the file
+        // boundary); a ref whose file is missing/empty degrades to a fresh
+        // session (the first-turn bridge already lives in the input message).
+        const resumeId = input.run.cliSessionRef;
+        const sessionId = resumeId ?? newSessionId();
+        const loaded = resumeId ? loadSessionMessages(resumeId) : [];
+        // A corrupt line must degrade that entry (log + skip), never brick the
+        // whole resume: MessageSchema.parse throws on the first bad shape.
+        const parsedTranscript = [];
+        for (const [i, message] of loaded.entries()) {
+            try {
+                parsedTranscript.push({
+                    productEntryId: `session:${i}`,
+                    message: MessageSchema.parse(message),
+                });
+            }
+            catch {
+                console.warn(`[rpc] skipping malformed session line ${i} for ${resumeId}`);
+            }
+        }
+        const sessionTranscript = parsedTranscript.length > 0 ? parsedTranscript : undefined;
+        let effectiveInput;
+        let segment;
+        try {
+            // cwd-based meta (ADR 0003 decision 6): skills and the system prompt
+            // live in workspace files (.oma/skills + AGENTS.md/SOUL.md/USER.md).
+            // Explicit run-input values (Loop scopes) win over the cwd fallback.
+            const cwdSkills = scanWorkspaceSkillRoots(input.workspace.root);
+            const cwdPrompt = readWorkspaceSystemPrompt(input.workspace.root);
+            effectiveInput = input.run.systemPrompt
+                ? input
+                : {
+                    ...input,
+                    run: {
+                        ...input.run,
+                        systemPrompt: buildSystemPrompt({
+                            workspacePrompt: cwdPrompt,
+                            memorySummary: readMemorySummary(input.workspace.root),
+                            cwd: input.workspace.root,
+                        }),
+                    },
+                };
+            // Plugin components (spec): policy resolved in the mode layer — RPC
+            // NEVER loads project-scope code; user-scope needs enablement only.
+            const pluginRt = await assemblePluginRuntime(input.workspace.root, "rpc");
+            for (const w of pluginRt.warnings)
+                debugLog("oma", `plugin: ${w}`);
+            // HITL approval pipe (spec): emit approval_request on stdout, park the
+            // resolver, resolve on the resolve_approval command; deadline = deny.
+            const pendingApprovals = new Map();
+            pendingApprovalsByRun.set(runId, pendingApprovals);
+            let approvalSeq = 10_000;
+            const rpcApproval = (req) => new Promise((resolve) => {
+                pendingApprovals.set(req.callId, resolve);
+                emit(eventOutputSchema.parse({
+                    type: "event",
+                    runId,
+                    // Own id space (10k+): the runtime's envelope seq is internal;
+                    // consumers key on type + data.callId, not global id order.
+                    event: {
+                        id: approvalSeq++,
+                        type: "approval_request",
+                        data: {
+                            callId: req.callId,
+                            toolName: req.toolName,
+                            reason: req.reason ?? `${req.toolName} requested approval (${req.source})`,
+                            input: req.input,
+                        },
+                    },
+                }));
+            });
+            runtime = await createOmaRuntime({
+                runId,
+                modelId: input.run.model.modelId,
+                workspaceRoot: input.workspace.root,
+                workspaceAccess: input.workspace.access,
+                modelRuntime: opts.modelRuntime,
+                skillRoots: input.run.skillRoots?.length ? input.run.skillRoots : cwdSkills,
+                ...(pluginRt.plugins.length || pluginRt.mcpServers.length
+                    ? { pluginComponents: { plugins: pluginRt.plugins, mcpServers: pluginRt.mcpServers } }
+                    : {}),
+                ...(input.run.permissionMode ? { permissionMode: input.run.permissionMode } : {}),
+                approvalHandler: (req) => withApprovalDeadline(rpcApproval(req), approvalTimeoutMs()),
+                sessionTranscript,
+                onEvent: (event) => {
+                    if (!finished)
+                        emit(eventOutputSchema.parse({ type: "event", runId, event }));
+                },
+            });
+            // run() resolves when the loop is live: acceptance ⟹ routable.
+            segment = await runtime.run(effectiveInput);
+            debugLog("oma", `runtime_assembled runId=${runId} skills=${(input.run.skillRoots?.length ? input.run.skillRoots : cwdSkills).length} access=${input.workspace.access}`);
+        }
+        catch (caught) {
+            emitResponse(command.id, "execute", false, `runtime assembly failed: ${redactError(caught)}`);
+            return;
+        }
+        // Acceptance: the runtime is assembled, event forwarding is registered,
+        // the loop is live, and steer/abort route to it.
+        currentRunId = runId;
+        debugLog("oma", `loop_live runId=${runId}`);
+        emitResponse(command.id, "execute", true, undefined);
+        void driveOutcome(runtime, segment, runId, sessionId, effectiveInput.input.message);
+    }
+    /** Await the outcome, emit the outcome envelope, flush, close the runtime,
+     *  then END the reader so the process exits on its own (one Run → one
+     *  outcome → exit) - no dependency on the parent closing stdin. */
+    async function driveOutcome(runtime, segment, runId, sessionId, inputMessage) {
+        let outcome;
+        try {
+            outcome = await segment.outcome;
+        }
+        catch (caught) {
+            outcome = { status: "failed", error: redactError(caught) };
+        }
+        // Persist the turn into the child's session file (user + assistant/tool
+        // messages) so the next run resumes the transcript (ADR 0003).
+        if (outcome.status === "completed" && outcome.messages?.length) {
+            appendSessionMessages(sessionId, process.cwd(), [inputMessage, ...outcome.messages]);
+            for (const summary of await runtime.compactions()) {
+                appendSessionCompaction(sessionId, summary);
+            }
+        }
+        const outcomeWithRef = {
+            ...outcome,
+            cliSessionRef: sessionId,
+        };
+        finished = true;
+        await runtime.close().catch(() => { });
+        debugLog("oma", `runtime_closed runId=${runId}`);
+        emit(outcomeOutputSchema.parse({ type: "outcome", runId, outcome: outcomeWithRef }));
+        debugLog("oma", `outcome runId=${runId} status=${outcome.status}`);
+        await writeChain;
+        // Unblock the reader: the pending stdin read resolves done and the main
+        // promise returns; main() exits with the code. Never a hard process.exit
+        // before the outcome is written and the runtime closed.
+        await reader.cancel();
+        debugLog("oma", `rpc_exit runId=${runId}`);
+    }
+    function handleSteer(command) {
+        debugLog("oma", `steer_received runId=${command.runId}`);
+        if (!executed || command.runId !== currentRunId || !runtime) {
+            emitResponse(command.id, "steer", false, `no live run for runId: ${command.runId} (current: ${currentRunId ?? "none"})`);
+            return;
+        }
+        try {
+            void runtime.steer(command.input).then(() => emitResponse(command.id, "steer", true), (err) => emitResponse(command.id, "steer", false, redactError(err)));
+        }
+        catch (caught) {
+            emitResponse(command.id, "steer", false, redactError(caught));
+        }
+    }
+    function handleAbort(command) {
+        debugLog("oma", `abort_received runId=${command.runId}`);
+        if (!executed || command.runId !== currentRunId || !runtime) {
+            emitResponse(command.id, "abort", false, `no live run for runId: ${command.runId} (current: ${currentRunId ?? "none"})`);
+            return;
+        }
+        void runtime.stop().then(() => emitResponse(command.id, "abort", true), (err) => emitResponse(command.id, "abort", false, redactError(err)));
+    }
+    return {
+        promise,
+        stop() {
+            if (runtime)
+                void runtime.stop().catch(() => { });
+        },
+    };
+}
+/** Execute acceptance preflight: payload schema valid (already parsed),
+ *  model valid/available in the runtime catalog, workspace valid. */
+async function validateExecute(input, modelRuntime) {
+    if (input.run.model.backendKind !== "oma") {
+        return `unsupported backend kind: ${input.run.model.backendKind}`;
+    }
+    if (!existsSync(input.workspace.root) || !statSync(input.workspace.root).isDirectory()) {
+        return `workspace root is not a directory: ${input.workspace.root}`;
+    }
+    const catalog = await modelRuntime.getCatalog();
+    const model = catalog.models.find((m) => `${m.providerId}/${m.modelId}` === input.run.model.modelId);
+    if (!model)
+        return `model not found in catalog: ${input.run.model.modelId}`;
+    if (model.available === false)
+        return `model unavailable: ${input.run.model.modelId}`;
+    return null;
+}

package/dist/modes/tui/settings-overlay.d.ts

@@ -0,0 +1,23 @@
+import { Container } from "@chengchenccc/tui";
+import type { ProjectSettings } from "../../core/settings/project-settings.js";
+/** Modal settings editor (omp SettingsSelector-container-inspired but lean):
+ *  a SelectList of rows; Enter toggles booleans or opens a text Input for
+ *  numeric/string values; Esc closes. Changes are held in a local copy. */
+export declare class SettingsOverlay extends Container {
+    private readonly onDone;
+    private readonly settings;
+    private list;
+    private readonly listSlot;
+    private editing;
+    constructor(settings: ProjectSettings, onDone: () => void);
+    getSettings(): ProjectSettings;
+    private displayValue;
+    private itemFor;
+    private rebuild;
+    private handleSelect;
+    private beginEdit;
+    private commitEdit;
+    handleInput(data: string): void;
+    render(width: number): string[];
+}
+//# sourceMappingURL=settings-overlay.d.ts.map

package/dist/modes/tui/settings-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings-overlay.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/settings-overlay.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAKV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAmD/E;;2EAE2E;AAC3E,qBAAa,eAAgB,SAAQ,SAAS;IAQ1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,IAAI,CAAc;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,OAAO,CAAkD;gBAG/D,QAAQ,EAAE,eAAe,EACR,MAAM,EAAE,MAAM,IAAI;IAOrC,WAAW,IAAI,eAAe;IAI9B,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,OAAO;IAiBf,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,UAAU;IAgBlB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQtB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;CAUzC"}

package/dist/modes/tui/settings-overlay.js

@@ -0,0 +1,136 @@
+import { applyBackgroundToLine, Container, Input, SelectList, truncateToWidth, } from "@chengchenccc/tui";
+const OVERLAY_BG = (s) => `\u001b[48;5;235m${s}\u001b[0m`;
+function overlayLines(lines, width) {
+    const innerWidth = Math.max(1, width - 2);
+    return lines.map((line) => {
+        const content = truncateToWidth(line, innerWidth, "", true);
+        return `\u001b[36m\u2502\u001b[0m${applyBackgroundToLine(content, innerWidth, OVERLAY_BG)}\u001b[36m\u2502\u001b[0m`;
+    });
+}
+const THEME = {
+    selectedPrefix: (s) => `\u001b[36m${s}\u001b[0m`,
+    selectedText: (s) => `\u001b[1m${s}\u001b[0m`,
+    description: (s) => `\u001b[2m${s}\u001b[0m`,
+    scrollInfo: (s) => `\u001b[2m${s}\u001b[0m`,
+    noMatch: (s) => `\u001b[2m${s}\u001b[0m`,
+};
+const ROWS = [
+    { key: "maxSteps", label: "maxSteps", kind: "number" },
+    { key: "modelTimeoutMs", label: "modelTimeoutMs", kind: "number" },
+    { key: "mcpTimeoutMs", label: "mcpTimeoutMs", kind: "number" },
+    { key: "bashTimeoutMs", label: "bashTimeoutMs", kind: "number" },
+    { key: "maxToolTimeoutMs", label: "maxToolTimeoutMs", kind: "number" },
+    { key: "memoryExtract", label: "memoryExtract", kind: "boolean" },
+    { key: "memoryModel", label: "memoryModel", kind: "string" },
+    { key: "titleEnabled", label: "titleEnabled", kind: "boolean" },
+    { key: "disableWeb", label: "disableWeb", kind: "boolean" },
+    { key: "enableClaude", label: "enableClaude", kind: "boolean" },
+    { key: "enableCodex", label: "enableCodex", kind: "boolean" },
+    { key: "enableAgents", label: "enableAgents", kind: "boolean" },
+];
+function rowValue(settings, key) {
+    const v = settings[key];
+    if (typeof v === "boolean")
+        return v ? "on" : "off";
+    if (v === undefined || v === null || v === "")
+        return "(unset)";
+    if (Array.isArray(v))
+        return v.length > 0 ? `${v.length} dirs` : "(none)";
+    return String(v);
+}
+/** Modal settings editor (omp SettingsSelector-container-inspired but lean):
+ *  a SelectList of rows; Enter toggles booleans or opens a text Input for
+ *  numeric/string values; Esc closes. Changes are held in a local copy. */
+export class SettingsOverlay extends Container {
+    onDone;
+    settings;
+    list;
+    listSlot = new Container();
+    editing = null;
+    constructor(settings, onDone) {
+        super();
+        this.onDone = onDone;
+        this.settings = { ...settings };
+        this.rebuild();
+    }
+    getSettings() {
+        return this.settings;
+    }
+    displayValue(key) {
+        return rowValue(this.settings, key);
+    }
+    itemFor(row) {
+        return {
+            value: row.key,
+            label: row.label,
+            description: `${row.kind} · ${this.displayValue(row.key)}`,
+        };
+    }
+    rebuild() {
+        this.list = new SelectList(ROWS.map((row) => this.itemFor(row)), 12, THEME, { minPrimaryColumnWidth: 16, maxPrimaryColumnWidth: 24 });
+        this.list.onSelect = (item) => {
+            const row = ROWS.find((r) => r.key === item.value);
+            if (row)
+                this.handleSelect(row);
+        };
+        this.list.onCancel = () => this.onDone();
+        this.listSlot.clear();
+        this.listSlot.addChild(this.list);
+        this.invalidate();
+    }
+    handleSelect(row) {
+        if (row.kind === "boolean") {
+            const current = this.settings[row.key];
+            const next = typeof current === "boolean" ? !current : true;
+            Reflect.set(this.settings, row.key, next);
+            this.rebuild();
+            return;
+        }
+        this.beginEdit(row);
+    }
+    beginEdit(row) {
+        const input = new Input();
+        input.setValue(this.displayValue(row.key) === "(unset)" ? "" : String(this.settings[row.key]));
+        input.onSubmit = () => {
+            this.commitEdit(row, input.getValue());
+        };
+        input.onEscape = () => {
+            this.editing = null;
+            this.invalidate();
+        };
+        this.editing = { row, input };
+        this.invalidate();
+    }
+    commitEdit(row, raw) {
+        let value = raw.trim();
+        if (row.kind === "number") {
+            const parsed = Number(raw.trim());
+            if (!Number.isFinite(parsed)) {
+                this.editing = null;
+                this.invalidate();
+                return;
+            }
+            value = parsed;
+        }
+        Reflect.set(this.settings, row.key, value);
+        this.editing = null;
+        this.rebuild();
+    }
+    handleInput(data) {
+        if (this.editing) {
+            this.editing.input.handleInput(data);
+            return;
+        }
+        this.list.handleInput(data);
+    }
+    render(width) {
+        const lines = [];
+        lines.push("  settings — enter to edit, esc to close");
+        if (this.editing) {
+            lines.push(`  edit ${this.editing.row.label} (${this.editing.row.kind}):`);
+            lines.push(...this.editing.input.render(Math.max(1, width - 4)));
+        }
+        lines.push(...this.list.render(Math.max(1, width - 2)));
+        return overlayLines(lines, width);
+    }
+}

package/dist/modes/tui/tui-commands-session.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDef, TuiSessionContext } from "./tui-commands.js";
+export declare function buildSessionCommands(ctx: TuiSessionContext): CommandDef[];
+//# sourceMappingURL=tui-commands-session.d.ts.map

package/dist/modes/tui/tui-commands-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-commands-session.d.ts","sourceRoot":"","sources":["../../../src/modes/tui/tui-commands-session.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGvE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,iBAAiB,GAAG,UAAU,EAAE,CAiMzE"}