codsh-cli 0.1.0

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "codsh-cli";
+/** Cordis companion plugin name. */
+const name = "coding-cli-invariant";
+/** Service required before the companion can register. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the surface is a renderer and input loop over the
+* session log whose observable contract (rendered transcript, approval
+* decisions, exit code) is process-level and owned by the launcher e2e. It
+* holds no durable relation of its own — every fact it shows is derived from
+* `session/event`, whose relations `dsh-session` already audits.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+
+//#endregion
+export { apply, inject, name };

package/lib/startup.js

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
+
+//#region src/startup.ts
+/** Stable Cordis plugin name. */
+const name = "coding-cli-startup";
+/** Services required before the invocation can be resolved. */
+const inject = ["cmdlineArgs"];
+/** Service provided by this plugin and injected by the terminal runner. */
+const CODING_CLI_STARTUP_SERVICE = "codingCliStartup";
+/**
+* This app's command: the optional task positional, its flags, and its help text.
+* @returns a fresh program, so one process can parse more than once (tests).
+*/
+function codingCliCommand() {
+	return new Command().name("dsh code").description("Work through coding tasks in an interactive terminal session.").helpOption("-h, --help", "show this help").argument("[task...]", "opening task; multiple words are joined by spaces. Omit it to start at the prompt").option("--resume <session>", "reopen a session by id and continue its conversation").option("--continue", "reopen the most recent session in this working directory").option("--preset <id>", "compose the agent from this preset instead of the roster default").option("-p, --print", "render the answer to the opening task and exit without entering the prompt").addHelpText("after", `
+Examples:
+  dsh code                                   start an interactive session
+  dsh code "add a slugify helper"            start with an opening task
+  dsh code -p "what does this repo do?"      answer once and exit
+  dsh code --continue                        reopen the latest session here
+  dsh code --resume session-1234             reopen one session by id
+  dsh code --preset standard                 compose from a different preset
+`);
+}
+/**
+* Resolve the session to reopen from the two mutually exclusive continuation flags.
+* @param program - the parsed command, used to report a usage error.
+* @param options - the flags commander collected.
+* @returns the session id, `'latest'`, or the empty string.
+*/
+function resolveResume(program, options) {
+	if (options.continue === true && options.resume !== void 0) program.error("error: --continue and --resume are mutually exclusive");
+	if (options.continue === true) return "latest";
+	if (options.resume === void 0) return "";
+	if (options.resume.trim() === "") program.error("error: --resume needs a session id");
+	return options.resume;
+}
+/**
+* Parse and provide this invocation as an ordinary Cordis service. On `--help`
+* and on a usage error nothing is provided, so the runner never mounts.
+* @param ctx - plugin context carrying the command line.
+*/
+function apply(ctx) {
+	const program = codingCliCommand();
+	program.action(() => {
+		const options = program.opts();
+		const task = program.args.join(" ").trim();
+		const print = options.print === true;
+		if (print && task === "") program.error("error: --print needs a task, for example: dsh code -p \"run the tests\"");
+		const preset = options.preset ?? "";
+		if (options.preset !== void 0 && preset.trim() === "") program.error("error: --preset needs a preset id");
+		ctx.provide(CODING_CLI_STARTUP_SERVICE, {
+			task,
+			resume: resolveResume(program, options),
+			preset,
+			print
+		});
+	});
+	parseCmdline(ctx, program);
+}
+
+//#endregion
+export { CODING_CLI_STARTUP_SERVICE, apply, inject, name };

package/lib/types/approval.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The terminal's approval answerer: it puts one pending tool call to the
+ * keyboard and returns the decision.
+ *
+ * `ApprovalOutcome` has no remembered grant — the vocabulary is `allowed-once`,
+ * `rejected`, `cancelled`, and `unavailable` — so "allow every call to this
+ * tool" is this surface's own state, kept here and answered as `allowed-once`
+ * without asking again.
+ * @module codsh-cli/src/approval
+ */
+import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval';
+import type { Theme } from './theme.ts';
+/** One keystroke the approval prompt accepts. */
+export type ApprovalAnswer = 'once' | 'always' | 'reject';
+/** Reads one approval keystroke from the terminal. */
+export interface ApprovalPrompt {
+    /**
+     * Ask the person about one pending call.
+     * @param toolName - the tool awaiting a decision.
+     * @param reason - the asker's explanation, when it supplied one.
+     * @param signal - aborts the prompt when the call is cancelled.
+     * @returns the chosen answer, or undefined when the prompt was aborted.
+     */
+    ask(toolName: string, reason: string | undefined, signal: AbortSignal | undefined): Promise<ApprovalAnswer | undefined>;
+}
+/**
+ * Approval state for one terminal session.
+ *
+ * The remembered set is per-process and never written to disk. An
+ * {@link ApprovalRequest} carries the tool name, reason, and call id but NOT
+ * the call arguments, so a grant cannot be narrowed to "this command" — it
+ * covers every later call to that tool. Persisting a grant that broad across
+ * runs would outlive the intent that produced it.
+ */
+export declare class TerminalApproval {
+    private readonly prompt;
+    private readonly theme;
+    private readonly write;
+    private readonly allowed;
+    constructor(prompt: ApprovalPrompt, theme: Theme, write: (line: string) => void);
+    /** Tool names granted for the rest of this process, in grant order. */
+    get remembered(): readonly string[];
+    /** Forget every remembered grant, so the next call of each tool asks again. */
+    clear(): void;
+    /**
+     * Decide one request, asking the keyboard unless the tool is already granted.
+     * @param req - the pending decision.
+     * @returns the outcome for this request.
+     */
+    decide(req: ApprovalRequest): Promise<ApprovalOutcome>;
+}
+/**
+ * Map one keystroke to an approval answer.
+ * @param key - the character typed at the prompt.
+ * @returns the answer, or undefined when the key means nothing here.
+ */
+export declare function answerForKey(key: string): ApprovalAnswer | undefined;

package/lib/types/banner.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The opening banner: what answered, where, and which keys matter.
+ * @module codsh-cli/src/banner
+ */
+import type { Theme } from './theme.ts';
+/** What the banner reports about the composed session. */
+export interface BannerFacts {
+    /** Model route answering this session. */
+    model: string;
+    /** Composed preset, absent when the deployment composes no roster. */
+    preset?: string | undefined;
+    /** Session workspace. */
+    cwd: string;
+    /** Checked-out branch, absent outside a repository. */
+    branch?: string | undefined;
+    /** Session identity, so a person can resume this exact conversation later. */
+    session: string;
+    /** Whether Escape can reach the surface; decides which interrupt is named. */
+    readsKeys: boolean;
+    /** Whether the transcript replayed a resumed conversation above the banner. */
+    resumed: boolean;
+}
+/**
+ * Render the opening banner.
+ * @param facts - what to report.
+ * @param theme - styling for the frame and the detail lines.
+ * @param columns - display columns available; a narrow terminal loses the frame.
+ * @returns the lines to print, ending with a blank separator.
+ */
+export declare function bannerLines(facts: BannerFacts, theme: Theme, columns: number): string[];

package/lib/types/completion.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Completion sources for the prompt: slash commands, and workspace files behind
+ * an `@` mention.
+ *
+ * Bare prose never completes. A sentence headed for the model would be rewritten
+ * by a completer guessing at it, so a path has to be asked for — `@` is that
+ * request, and it is also what makes the mention legible to the model, which
+ * reads the file with its own tools.
+ *
+ * Matching is fuzzy, not prefix: the person knows a fragment of the name, not
+ * where in the path it starts. A prefix match still ranks first, so the fuzzy
+ * fallback never steals an exact intention.
+ * @module codsh-cli/src/completion
+ */
+/** One completable command: its name without the slash, and what it does. */
+export interface CompletableCommand {
+    name: string;
+    description: string;
+}
+/** `readline`'s completer result: the candidates, and the substring they replace. */
+export type CompletionResult = [completions: string[], substring: string];
+/**
+ * Score `needle` against `hay` as a fuzzy subsequence.
+ *
+ * Consecutive hits and hits on a boundary (start, or after a separator) score
+ * higher, which is what ranks `src/idx` matches the way a person expects. A
+ * needle that is not a subsequence scores nothing at all.
+ * @param needle - what was typed, matched case-insensitively.
+ * @param hay - the candidate.
+ * @returns the score, or undefined when it does not match.
+ */
+export declare function fuzzyScore(needle: string, hay: string): number | undefined;
+/** Drop the cached workspace walk, so a test controls what the next Tab sees. */
+export declare function resetFileIndex(): void;
+/**
+ * Build the completer for one session.
+ *
+ * The command list is read on each use rather than captured, because a command
+ * registry is scoped and changes with the session's mode — plan mode alone adds
+ * and removes one.
+ * @param commands - reads the currently registered commands.
+ * @param cwd - the workspace `@` mentions resolve against.
+ * @returns a completer over the word under the cursor.
+ */
+export declare function createCompleter(commands: () => readonly CompletableCommand[], cwd: string): (line: string) => CompletionResult;

package/lib/types/console.d.ts

@@ -0,0 +1,152 @@
+/**
+ * The process-facing terminal, in two shapes.
+ *
+ * On a terminal this surface owns the keyboard: raw mode, its own key decoding,
+ * and a managed region of rows at the bottom holding the input box. That is what
+ * an inline completion menu and a multi-line prompt require — `readline` reports
+ * no lone Escape, draws no menu, and decides for itself what Enter means.
+ *
+ * Off a terminal it is a line reader over `readline`, because a pipe has no
+ * cursor to manage and every line in a script is a separate instruction. Both
+ * shapes answer the same reads, which is what keeps piped runs and tests on the
+ * same code path as a person typing.
+ * @module codsh-cli/src/console
+ */
+import type { Key } from './keys.ts';
+/** The output stream this surface writes to. */
+export interface OutputStream extends NodeJS.WritableStream {
+    readonly columns?: number;
+    readonly isTTY?: boolean;
+}
+/** The input stream this surface reads from. */
+export interface InputStream extends NodeJS.ReadableStream {
+    readonly isTTY?: boolean;
+    setRawMode?(mode: boolean): unknown;
+}
+/** Where the cursor belongs among a region's rows. */
+export interface RegionCursor {
+    row: number;
+    column: number;
+}
+/** Line input and output over one pair of process streams. */
+export declare class TerminalConsole {
+    private readonly input;
+    private readonly output;
+    private readonly rl;
+    private readonly decoder;
+    private readonly pending;
+    private readonly waiters;
+    private keyHandler;
+    /** Keys decoded before any handler registered — type-ahead is never dropped. */
+    private readonly earlyKeys;
+    private escapeTimer;
+    private ended;
+    /** Rows currently drawn in the bottom region. */
+    private regionRows;
+    /** Where among those rows the cursor was left. */
+    private regionCursor;
+    /** Whether the region currently holds input focus, which shows the cursor. */
+    private regionFocus;
+    constructor(input: InputStream, output: OutputStream);
+    /** Display columns available for one line, never below {@link MIN_COLUMNS}. */
+    get columns(): number;
+    /** Whether the output stream is a terminal. */
+    get isTty(): boolean;
+    /**
+     * Whether this surface owns the keyboard.
+     *
+     * That needs both streams on a terminal: raw mode is what delivers a key
+     * before its line, and there is no point managing rows on a stream with no
+     * cursor.
+     */
+    get readsKeys(): boolean;
+    /** Whether input has finished. */
+    get finished(): boolean;
+    /**
+     * Register a handler for terminal window changes.
+     * @param handler - called after each resize while registered.
+     * @returns a disposer that removes it.
+     */
+    onResize(handler: () => void): () => void;
+    /**
+     * Clear the visible screen.
+     *
+     * The scrollback survives — this wipes the viewport the way a shell's clear
+     * does. The managed region is forgotten with it, so the caller redraws.
+     */
+    clearScreen(): void;
+    /**
+     * Route decoded keys to a handler.
+     * @param handler - receives every key while registered.
+     * @returns a disposer that removes it.
+     */
+    onKey(handler: (key: Key) => void): () => void;
+    /**
+     * Decode one read and dispatch its keys.
+     * @param chunk - the bytes the terminal delivered.
+     */
+    private onBytes;
+    /** Hand one key to the handler, or hold it until one registers. */
+    private deliver;
+    /** Wait briefly for the rest of a held sequence, then resolve it as Escape. */
+    private armEscapeFlush;
+    /**
+     * Hand one input line to the longest-waiting read, or queue it.
+     * @param line - the line the reader produced.
+     */
+    private offer;
+    /** Mark input finished and release every waiting read. */
+    private end;
+    /**
+     * Write one finished line above the managed region.
+     *
+     * The region is erased first and redrawn after, so the transcript stays
+     * append-only while the input box keeps its place at the bottom.
+     * @param line - the line, without its terminator.
+     */
+    write(line: string): void;
+    /**
+     * Replace the managed region at the bottom of the screen.
+     *
+     * This is the whole live area: an input box, a completion menu, a working
+     * indicator. Everything the transcript keeps goes through {@link write}
+     * instead, because a terminal cannot revise a row that has scrolled. Off a
+     * terminal the call is ignored — a redirected transcript must not collect
+     * frames of a box nobody can see.
+     * @param rows - the rows to display, top to bottom.
+     * @param cursor - where to leave the terminal cursor among them.
+     * @param focus - whether the region holds input focus. Without it the cursor
+     *   stays hidden: a block cursor parked on a display row (the status line,
+     *   a streaming line) reads as content colliding with it.
+     */
+    setRegion(rows: readonly string[], cursor: RegionCursor, focus?: boolean): void;
+    /** Remove the region, leaving the cursor where the next write will land. */
+    clearRegion(): void;
+    /** Move to the region's first row and erase everything from there down. */
+    private eraseRegion;
+    /**
+     * Draw rows from the cursor down and place the cursor among them.
+     * @param rows - the rows to draw.
+     * @param cursor - the target position.
+     * @param focus - whether to show the cursor at that position afterwards.
+     */
+    private drawRegion;
+    /** Ring the terminal bell; a pipe gets nothing to beep with. */
+    bell(): void;
+    /**
+     * Set the terminal window title.
+     * @param title - the title text; control bytes are the terminal's to reject.
+     */
+    setTitle(title: string): void;
+    /**
+     * Read one line from a piped stream.
+     *
+     * Only the non-terminal shape reads this way; with the keyboard owned, input
+     * arrives as keys and the caller drives an editor instead.
+     * @param signal - aborts the pending read.
+     * @returns the line, or undefined when input ended or the read aborted.
+     */
+    readLine(signal?: AbortSignal): Promise<string | undefined>;
+    /** Restore the terminal and stop reading. */
+    close(): void;
+}

package/lib/types/custom-commands.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Custom slash commands from Markdown files.
+ *
+ * A file named `review.md` under a commands root becomes `/review`: its
+ * frontmatter `description` labels it in the completion menu, and its body is
+ * the prompt submitted when the command runs — with `$ARGUMENTS` replaced by
+ * whatever followed the name. They are canned prompts, not handlers: execution
+ * goes through the same submission path as a typed message.
+ * @module codsh-cli/src/custom-commands
+ */
+/** One loaded command. */
+export interface CustomCommand {
+    /** The name typed after the slash. */
+    name: string;
+    /** Menu label, from frontmatter or a fallback naming the file. */
+    description: string;
+    /** The prompt body, with `$ARGUMENTS` placeholders intact. */
+    template: string;
+}
+/** What loading produced: the commands, and what was skipped and why. */
+export interface CustomCommandLoad {
+    commands: CustomCommand[];
+    /** One line per skipped file, for the surface to show once at startup. */
+    warnings: string[];
+}
+/**
+ * Parse one command file: optional `---` frontmatter with a `description`
+ * line, then the prompt body.
+ * @param source - the file content.
+ * @returns the description (empty when absent) and the body.
+ */
+export declare function parseCommandFile(source: string): {
+    description: string;
+    body: string;
+};
+/**
+ * Fill a template with the typed arguments.
+ * @param template - the prompt body.
+ * @param typed - what followed the command name, possibly empty.
+ * @returns the prompt to submit: placeholders replaced, or the arguments
+ *   appended when the template never asked for them.
+ */
+export declare function expandTemplate(template: string, typed: string): string;
+/**
+ * Load every command under the given roots, later roots shadowing earlier.
+ *
+ * A missing root is normal (most setups define no custom commands); an
+ * unreadable or misnamed file is a warning, never a failed startup — a broken
+ * canned prompt should cost that prompt, not the session.
+ * @param roots - directories to scan, lowest precedence first.
+ * @param taken - names already registered, which a file cannot shadow.
+ * @returns the loaded commands and the warnings to show once.
+ */
+export declare function loadCustomCommands(roots: readonly string[], taken: ReadonlySet<string>): Promise<CustomCommandLoad>;

package/lib/types/editor.d.ts

@@ -0,0 +1,186 @@
+/**
+ * The prompt's editing model: a multi-line buffer, a cursor, history, and the
+ * completion menu.
+ *
+ * Pure state. It takes keys and answers with what changed, so every behaviour
+ * here is testable without a terminal — the rendering and the raw-mode plumbing
+ * are somebody else's job.
+ * @module codsh-cli/src/editor
+ */
+import type { CompletableCommand, CompletionResult } from './completion.ts';
+import type { Key } from './keys.ts';
+/** One entry offered in the completion menu. */
+export interface Candidate {
+    /** The text that replaces the token when accepted. */
+    value: string;
+    /** What it does, shown beside it. Empty for a path, which explains itself. */
+    detail: string;
+}
+/** What the editor is showing right now. */
+export interface EditorView {
+    /** Buffer lines; always at least one, possibly empty. */
+    lines: readonly string[];
+    /** Cursor line index. */
+    row: number;
+    /** Cursor column within that line, in code points. */
+    column: number;
+    /** Candidates to offer, empty when the menu is closed. */
+    candidates: readonly Candidate[];
+    /** Which candidate is selected, meaningless when there are none. */
+    selected: number;
+    /** The token under the cursor, which is what the candidates matched. */
+    token: string;
+}
+/** What the caller must do after a key. */
+export type EditorAction = {
+    kind: 'none';
+} | {
+    kind: 'submit';
+    text: string;
+} | {
+    kind: 'interrupt';
+} | {
+    kind: 'eof';
+} | {
+    kind: 'escape';
+};
+/** How the editor finds candidates for the token under the cursor. */
+export interface EditorSources {
+    /** The commands currently registered. */
+    commands(): readonly CompletableCommand[];
+    /** Path candidates for an `@` mention, as the completer produces them. */
+    paths(token: string): CompletionResult;
+    /**
+     * Argument candidates for one command's first argument.
+     *
+     * `/plan off`, `/permission workspace-write`, `/model <id>` — the values a
+     * command takes are the command's own knowledge, so the editor asks rather
+     * than guessing. Absent or empty means the argument is free-form.
+     * @param command - the command name without its slash.
+     * @param typed - what has been typed of the argument so far.
+     * @returns candidates to offer, best first.
+     */
+    commandArguments?(command: string, typed: string): readonly Candidate[];
+}
+/** A multi-line prompt editor. */
+export declare class Editor {
+    private readonly sources;
+    private lines;
+    private row;
+    private column;
+    private candidates;
+    private selected;
+    private readonly history;
+    /** Where the caller is in history; equals `history.length` when not browsing. */
+    private browsing;
+    /** The buffer set aside while history is being browsed. */
+    private stashed;
+    constructor(sources: EditorSources);
+    /** What to render. */
+    get view(): EditorView;
+    /** The buffer as one string. */
+    get text(): string;
+    /** Whether nothing has been typed. */
+    get empty(): boolean;
+    /**
+     * Replace the buffer with earlier text, cursor at its end.
+     *
+     * This is recall-for-editing: the second Escape puts the previous submission
+     * back so it can be corrected and resent.
+     * @param text - the text to edit, possibly multi-line.
+     */
+    prefill(text: string): void;
+    /** Submissions this session recorded, oldest first, for persistence. */
+    get pastSubmissions(): readonly string[];
+    /**
+     * Preload history from an earlier session.
+     *
+     * Applied before any live submission, so recall starts where the last
+     * session ended rather than empty.
+     * @param entries - past submissions, oldest first.
+     */
+    seedHistory(entries: readonly string[]): void;
+    /**
+     * Apply one key.
+     * @param key - the decoded keystroke.
+     * @returns what the caller must do about it.
+     */
+    handle(key: Key): EditorAction;
+    /** The line the cursor is on. */
+    private line;
+    /** Replace the cursor's line. */
+    private setLine;
+    /**
+     * Insert text at the cursor, splitting lines on newlines.
+     * @param text - the text to insert.
+     * @returns always `none`; insertion never completes a read.
+     */
+    private insert;
+    /**
+     * Submit, or accept the highlighted candidate when the menu is open.
+     * @returns the submission, or `none` when a candidate was taken instead.
+     */
+    private accept;
+    /** Record a submission for history, collapsing an immediate repeat. */
+    private remember;
+    /**
+     * Open the menu, or move through it when it is already open.
+     * @returns always `none`.
+     */
+    private complete;
+    /**
+     * Replace the token under the cursor with the selected candidate.
+     * @returns always `none`.
+     */
+    private take;
+    /** Where the token under the cursor begins, in code points. */
+    private tokenStart;
+    /** The token under the cursor. */
+    private token;
+    /**
+     * Recompute the candidate list for the token under the cursor.
+     *
+     * Recomputed on every edit rather than only on Tab, which is what makes the
+     * menu appear as a command is typed instead of after a key that asks for it.
+     */
+    private refresh;
+    /** Remove the character before the cursor, joining lines at a boundary. */
+    private backspace;
+    /** Remove the character after the cursor, joining lines at a boundary. */
+    private forwardDelete;
+    /** Move up a line, or back through history from the first line. */
+    private moveUp;
+    /** Move down a line, or forward through history from the last line. */
+    private moveDown;
+    /**
+     * Step through history.
+     * @param delta - -1 for older, 1 for newer.
+     * @returns always `none`.
+     */
+    private recall;
+    /** Move the cursor one position left, wrapping to the previous line. */
+    private moveLeft;
+    /** Move the cursor one position right, wrapping to the next line. */
+    private moveRight;
+    /**
+     * Put the cursor at a column on the current line.
+     * @param column - the target column.
+     * @returns always `none`.
+     */
+    private jump;
+    /** Drop everything after the cursor on this line. */
+    private killLine;
+    /** Drop everything before the cursor on this line. */
+    private killInput;
+    /** Move the cursor to the start of the word before it. */
+    private wordLeft;
+    /** Move the cursor past the end of the word after it. */
+    private wordRight;
+    /** Drop the word before the cursor. */
+    private killWord;
+    /**
+     * Close the menu, or report Escape when there is none to close.
+     * @returns `none` when a menu was dismissed, otherwise `escape`.
+     */
+    private cancel;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `codsh` — the interactive terminal surface. The bundle
+ * patch rides over dsh-base without Host, HTTP, or browser plugins; this runner
+ * composes one Agent from the roster's preset, renders its session log to the
+ * terminal, answers approvals and questions from the keyboard, and drives the
+ * conversation until the person leaves.
+ *
+ * The surface shares the process with the Agent, so it reads `ctx.agents`
+ * directly. The API gateway exists to carry out-of-process clients and would
+ * add a serialization hop with no reader on the other side.
+ *
+ * @module codsh
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Stable Cordis plugin name. */
+export declare const name = "coding-cli-runner";
+/** Core services required before the surface can compose an agent. */
+export declare const inject: string[];
+/** Plugin config: the invocation resolved from this app's injected provider service. */
+export interface Config {
+    /** Opening task, or the empty string to start at the prompt. */
+    task: string;
+    /** Session to reopen: an id, `'latest'`, or the empty string for a new session. */
+    resume: string;
+    /** Preset id overriding the roster default, or the empty string to accept it. */
+    preset: string;
+    /** Render the answer to `task` and exit rather than entering the prompt. */
+    print: boolean;
+    /** Ring the terminal bell when a decision waits or a long turn ends. */
+    bell: boolean;
+    /** How long a `!` passthrough command may run before it is killed. */
+    bangTimeoutMs: number;
+    /** Output lines a `!` passthrough keeps before summarizing the rest. */
+    bangOutputLines: number;
+}
+export declare const Config: z<Config>;
+/** The process streams the surface binds to; tests substitute captures. */
+export declare const internals: {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WriteStream;
+};
+/**
+ * Mount the interactive terminal surface.
+ * @param ctx - plugin context carrying core services and the launcher-provided exit request.
+ * @param config - validated invocation config.
+ */
+export declare function apply(ctx: Context, config: Config): void;