agent-sh 0.8.0 → 0.10.0

package/dist/settings.d.ts

@@ -50,20 +50,46 @@ export interface Settings {
     historyMaxBytes?: number;
     /** Number of prior history entries to load on startup (default: 50). */
     historyStartupEntries?: number;
-    /** Max nuclear entries kept in-context before flushing to history file (default: 200). */
-    nuclearMaxEntries?: number;
+    /** Auto-compact threshold as fraction of conversation budget (0-1, default 0.5). */
+    autoCompactThreshold?: number;
     /** Max command output lines shown inline in TUI. */
     maxCommandOutputLines?: number;
     /** Max read tool output lines shown inline in TUI (0 = hide). */
     readOutputMaxLines?: number;
-    /** Max diff lines shown before "ctrl+o to expand". */
+    /** Max diff lines rendered in the TUI (Infinity = no limit). */
     diffMaxLines?: number;
+    /** Tool protocol:
+     *   "api" — all tools sent with full schema.
+     *   "deferred" — extensions dispatched through `use_extension(name, args)` meta-tool.
+     *   "deferred-lookup" — extensions loaded on demand via `load_tool(names[])`; once loaded, callable as first-class tools.
+     *   "inline" — tools described as text.
+     */
+    toolMode?: "api" | "deferred" | "deferred-lookup" | "inline";
     /** Additional directories to scan for skills (supports ~ expansion). */
     skillPaths?: string[];
+    /**
+     * Enable the "diagnose" tool — lets the agent evaluate JavaScript
+     * expressions against its own runtime state. Powerful for introspection
+     * (e.g. this.conversation.turns.length) but grants arbitrary code
+     * execution within the agent process. Off by default because the
+     * agent already has unrestricted bash access — this is a convenience,
+     * not a new capability.
+     */
+    diagnose?: boolean;
     /** Show a startup banner when agent-sh launches. */
     startupBanner?: boolean;
     /** Show a subtle agent-sh indicator in the shell prompt. */
     promptIndicator?: boolean;
+    /** Names of built-in extensions to disable (e.g. ["command-suggest"]). */
+    disabledBuiltins?: string[];
+    /**
+     * Names of user extensions in ~/.agent-sh/extensions/ to skip when
+     * auto-discovering. Match by basename without extension for files
+     * (e.g. "peer-mesh" matches peer-mesh.ts), or by directory name for
+     * directory-style extensions (e.g. "superash" matches superash/index.ts).
+     * Beats having to rename files to .disabled every time.
+     */
+    disabledExtensions?: string[];
 }
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */
@@ -81,6 +107,17 @@ export declare function getSettings(): Settings & typeof DEFAULTS;
 export declare function getExtensionSettings<T extends Record<string, unknown>>(namespace: string, defaults: T): T;
 /** Reset cached settings (for testing or after external edit). */
 export declare function reloadSettings(): void;
+/**
+ * Deep-merge a patch into ~/.agent-sh/settings.json on disk.
+ *
+ * Reads the raw file (preserving unknown keys), merges the patch, writes back
+ * with 2-space indentation, and clears the cache so subsequent getSettings()
+ * calls see the new values.
+ *
+ * Used by runtime controls (`/model`, `/backend`) that want their selection
+ * to persist as the default across restarts.
+ */
+export declare function updateSettings(patch: Record<string, unknown>): void;
 /**
  * Expand $ENV_VAR references in a string.
  * Supports $VAR and ${VAR} syntax.

package/dist/settings.js

@@ -14,23 +14,27 @@ const DEFAULTS = {
     historySize: 500,
     providers: {},
     defaultProvider: undefined,
-    defaultBackend: "agent-sh",
+    defaultBackend: "ash",
+    toolMode: "api",
     contextWindowSize: 20,
-    contextBudget: 16384,
-    shellTruncateThreshold: 10,
-    shellHeadLines: 5,
-    shellTailLines: 5,
-    recallExpandMaxLines: 100,
+    contextBudget: 32768,
+    shellTruncateThreshold: 20,
+    shellHeadLines: 10,
+    shellTailLines: 10,
+    recallExpandMaxLines: 500,
     shellContextRatio: 0.35,
-    historyMaxBytes: 102400,
-    historyStartupEntries: 50,
-    nuclearMaxEntries: 200,
+    historyMaxBytes: 104857600, // 100MB — history is only accessed via search/expand, never loaded wholesale
+    historyStartupEntries: 100,
+    autoCompactThreshold: 0.5,
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,
-    diffMaxLines: 20,
+    diffMaxLines: Infinity,
     skillPaths: [],
+    diagnose: false,
     startupBanner: true,
     promptIndicator: true,
+    disabledBuiltins: [],
+    disabledExtensions: [],
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -71,6 +75,49 @@ export function getExtensionSettings(namespace, defaults) {
 export function reloadSettings() {
     cached = null;
 }
+/**
+ * Deep-merge a patch into ~/.agent-sh/settings.json on disk.
+ *
+ * Reads the raw file (preserving unknown keys), merges the patch, writes back
+ * with 2-space indentation, and clears the cache so subsequent getSettings()
+ * calls see the new values.
+ *
+ * Used by runtime controls (`/model`, `/backend`) that want their selection
+ * to persist as the default across restarts.
+ */
+export function updateSettings(patch) {
+    let existing = {};
+    try {
+        const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+        existing = JSON.parse(raw);
+    }
+    catch {
+        // file missing or unreadable — start fresh
+    }
+    const merged = deepMerge(existing, patch);
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        cached = null;
+    }
+    catch (err) {
+        console.error(`[agent-sh] Warning: failed to update ${SETTINGS_PATH}: ${err.message}`);
+    }
+}
+function deepMerge(target, source) {
+    const out = { ...target };
+    for (const [key, val] of Object.entries(source)) {
+        const existing = out[key];
+        if (val !== null && typeof val === "object" && !Array.isArray(val) &&
+            existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+            out[key] = deepMerge(existing, val);
+        }
+        else {
+            out[key] = val;
+        }
+    }
+    return out;
+}
 /**
  * Expand $ENV_VAR references in a string.
  * Supports $VAR and ${VAR} syntax.

package/dist/{input-handler.d.ts → shell/input-handler.d.ts}

@@ -1,4 +1,4 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 /**
  * Narrow contract between InputHandler and its host (Shell).
  * InputHandler never touches the PTY or EventBus directly —
@@ -28,7 +28,8 @@ export declare class InputHandler {
     private history;
     private historyIndex;
     private savedBuffer;
-    private promptWrappedLines;
+    private cursorRowsBelow;
+    private cursorTermCol;
     private escapeTimer;
     private bus;
     private onShowAgentInfo;

package/dist/{input-handler.js → shell/input-handler.js}

@@ -1,10 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { visibleLen } from "./utils/ansi.js";
-import { palette as p } from "./utils/palette.js";
-import { LineEditor } from "./utils/line-editor.js";
-import { CONFIG_DIR, getSettings } from "./settings.js";
-const HISTORY_FILE = path.join(CONFIG_DIR, "history");
+import { visibleLen } from "../utils/ansi.js";
+import { palette as p } from "../utils/palette.js";
+import { LineEditor } from "../utils/line-editor.js";
+import { CONFIG_DIR, getSettings } from "../settings.js";
+const HISTORY_FILE = path.join(CONFIG_DIR, "input-history");
 export class InputHandler {
     ctx;
     lineBuffer = "";
@@ -20,7 +20,8 @@ export class InputHandler {
     history = [];
     historyIndex = -1; // -1 = not browsing history
     savedBuffer = ""; // buffer saved when entering history
-    promptWrappedLines = 0; // extra lines from terminal wrapping
+    cursorRowsBelow = 0; // rows from prompt top to cursor row
+    cursorTermCol = 1; // 1-indexed terminal column of cursor
     escapeTimer = null;
     bus;
     onShowAgentInfo;
@@ -72,9 +73,10 @@ export class InputHandler {
     /** Write the mode prompt line with cursor at the correct position. */
     writeModePromptLine(showBuffer = true) {
         const termW = process.stdout.columns || 80;
-        // Move cursor to the start of the prompt area (first line of wrapped content)
-        if (this.promptWrappedLines > 0) {
-            process.stdout.write(`\x1b[${this.promptWrappedLines}A`);
+        // Move cursor to the start of the prompt area.
+        // We know exactly how many rows below the top the cursor currently sits.
+        if (this.cursorRowsBelow > 0) {
+            process.stdout.write(`\x1b[${this.cursorRowsBelow}A`);
         }
         // Clear from here to end of screen — removes current + all wrapped lines below
         process.stdout.write("\r\x1b[J");
@@ -86,38 +88,39 @@ export class InputHandler {
         const icon = this.activeMode?.promptIcon ?? "❯";
         const promptPrefix = infoPrefix + p.warning + p.bold + icon + " " + p.reset;
         const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1; // icon + space
-        if (!showBuffer || !this.editor.buffer.includes("\n")) {
-            // Single-line: simple rendering
-            const bufferText = showBuffer ? p.accent + this.editor.buffer + p.reset : "";
-            process.stdout.write(promptPrefix + bufferText);
-            const bufferVisLen = showBuffer ? this.editor.buffer.length : 0;
-            const totalVisLen = promptVisLen + bufferVisLen;
-            this.promptWrappedLines = totalVisLen > 0 ? Math.floor((totalVisLen - 1) / termW) : 0;
-            // Position cursor within the buffer
-            if (showBuffer && this.editor.cursor < this.editor.buffer.length) {
-                const charsAfterCursor = this.editor.buffer.length - this.editor.cursor;
-                process.stdout.write(`\x1b[${charsAfterCursor}D`);
-            }
+        const display = showBuffer ? this.editor.displayText : "";
+        const dCursor = showBuffer ? this.editor.displayCursor : 0;
+        if (!showBuffer) {
+            // No buffer — just write the prompt prefix, cursor stays at end
+            process.stdout.write(promptPrefix);
+            const N = promptVisLen;
+            this.cursorRowsBelow = N > 0 ? Math.ceil(N / termW) - 1 : 0;
+            this.cursorTermCol = N === 0 ? 1 : (N % termW === 0 ? termW : (N % termW) + 1);
+        }
+        else if (!display.includes("\n")) {
+            // Single-line: write up to cursor, save, write rest, restore.
+            // The terminal handles all wrapping — no manual row/col math needed.
+            const before = display.slice(0, dCursor);
+            const after = display.slice(dCursor);
+            process.stdout.write(promptPrefix + p.accent + before + p.reset +
+                "\x1b7" + // DECSC — save cursor position
+                p.accent + after + p.reset +
+                "\x1b8" // DECRC — restore cursor position
+            );
+            // Clearing on next redraw needs total rows, so measure the full
+            // content width — not just up to the cursor.
+            const totalVisLen = promptVisLen + visibleLen(display);
+            this.cursorRowsBelow = totalVisLen > 0 ? Math.ceil(totalVisLen / termW) - 1 : 0;
+            const cursorVisCol = promptVisLen + visibleLen(before);
+            this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
         }
         else {
-            // Multi-line: render each line with continuation indent
-            const lines = this.editor.buffer.split("\n");
+            // Multi-line: render each line with continuation indent.
+            // Same save/restore strategy — cursor position is never computed.
+            const lines = display.split("\n");
             const indent = " ".repeat(promptVisLen);
-            let totalTermLines = 0;
-            for (let li = 0; li < lines.length; li++) {
-                const prefix = li === 0 ? promptPrefix : indent;
-                const prefixVisLen = li === 0 ? promptVisLen : promptVisLen;
-                const lineText = lines[li];
-                process.stdout.write(prefix + p.accent + lineText + p.reset);
-                if (li < lines.length - 1)
-                    process.stdout.write("\n");
-                // Count terminal lines this logical line occupies
-                const lineVisLen = prefixVisLen + lineText.length;
-                totalTermLines += lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
-            }
-            this.promptWrappedLines = totalTermLines - 1;
-            // Position cursor: find which line and column the cursor is on
-            let charsRemaining = this.editor.cursor;
+            // Locate cursor: which logical line and offset within it.
+            let charsRemaining = dCursor;
             let cursorLine = 0;
             for (let li = 0; li < lines.length; li++) {
                 if (charsRemaining <= lines[li].length) {
@@ -127,13 +130,35 @@ export class InputHandler {
                 charsRemaining -= lines[li].length + 1; // +1 for \n
                 cursorLine = li + 1;
             }
-            // Move from end position to cursor position
-            const linesFromEnd = lines.length - 1 - cursorLine;
-            if (linesFromEnd > 0) {
-                process.stdout.write(`\x1b[${linesFromEnd}A`);
+            let output = "";
+            let cursorRowFromTop = 0;
+            let rowsSoFar = 0;
+            for (let li = 0; li < lines.length; li++) {
+                const prefix = li === 0 ? promptPrefix : indent;
+                const lineText = lines[li];
+                const lineVisLen = promptVisLen + visibleLen(lineText);
+                const lineTermRows = lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+                if (li === cursorLine) {
+                    // Split this line at the cursor.
+                    const before = lineText.slice(0, charsRemaining);
+                    const after = lineText.slice(charsRemaining);
+                    output += prefix + p.accent + before + p.reset;
+                    output += "\x1b7"; // DECSC — save cursor position
+                    output += p.accent + after + p.reset;
+                    const beforeVisCol = promptVisLen + visibleLen(before);
+                    cursorRowFromTop = rowsSoFar + (beforeVisCol > 0 ? Math.ceil(beforeVisCol / termW) - 1 : 0);
+                    this.cursorTermCol = beforeVisCol === 0 ? 1 : (beforeVisCol % termW === 0 ? termW : (beforeVisCol % termW) + 1);
+                }
+                else {
+                    output += prefix + p.accent + lineText + p.reset;
+                }
+                if (li < lines.length - 1)
+                    output += "\n";
+                rowsSoFar += lineTermRows;
             }
-            const cursorCol = (cursorLine === 0 ? promptVisLen : promptVisLen) + charsRemaining;
-            process.stdout.write(`\r\x1b[${cursorCol}C`);
+            process.stdout.write(output + "\x1b8"); // DECRC — restore cursor position
+            // Total rows (not cursor row) so next redraw clears the whole area.
+            this.cursorRowsBelow = rowsSoFar - 1 > 0 ? rowsSoFar - 1 : 0;
         }
     }
     handleInput(data) {
@@ -249,26 +274,29 @@ export class InputHandler {
         this.activeMode = mode;
         this.editor.clear();
         // Enable kitty keyboard protocol (progressive enhancement flag 1)
-        // so Shift+Enter sends \x1b[13;2u instead of plain \r
-        process.stdout.write("\x1b[>1u");
+        // so Shift+Enter sends \x1b[13;2u instead of plain \r.
+        // Enable bracket paste mode so pasted text doesn't trigger submit.
+        process.stdout.write("\x1b[>1u\x1b[?2004h");
         this.writeModePromptLine(false);
     }
     exitMode() {
         this.dismissAutocomplete();
         this.activeMode = null;
         this.editor.clear();
-        // Disable kitty keyboard protocol
-        process.stdout.write("\x1b[<u");
+        // Disable kitty keyboard protocol and bracket paste mode
+        process.stdout.write("\x1b[<u\x1b[?2004l");
         this.clearPromptArea();
+        this.cursorRowsBelow = 0;
+        this.cursorTermCol = 1;
         this.printPrompt();
     }
     /** Move to the start of the prompt area and clear everything below. */
     clearPromptArea() {
-        if (this.promptWrappedLines > 0) {
-            process.stdout.write(`\x1b[${this.promptWrappedLines}A`);
+        if (this.cursorRowsBelow > 0) {
+            process.stdout.write(`\x1b[${this.cursorRowsBelow}A`);
         }
         process.stdout.write("\r\x1b[J");
-        this.promptWrappedLines = 0;
+        this.cursorRowsBelow = 0;
     }
     printPrompt() {
         this.ctx.redrawPrompt();
@@ -294,7 +322,7 @@ export class InputHandler {
         this.updateAutocomplete();
     }
     updateAutocomplete() {
-        const buf = this.editor.buffer;
+        const buf = this.editor.text;
         let command = null;
         let commandArgs = null;
         if (buf.startsWith("/")) {
@@ -342,16 +370,10 @@ export class InputHandler {
         if (this.autocompleteLines > 0) {
             process.stdout.write(`\x1b[${this.autocompleteLines}A`);
         }
-        // Reposition cursor: must match the layout in writeModePromptLine()
-        const agentInfo = this.onShowAgentInfo();
-        const indicator = this.activeMode?.indicator ?? "●";
-        const infoPrefix = agentInfo.info
-            ? `${agentInfo.info} ${indicator} `
-            : `${indicator} `;
-        const icon = this.activeMode?.promptIcon ?? "❯";
-        const promptVisLen = visibleLen(infoPrefix) + visibleLen(icon) + 1;
-        const col = promptVisLen + this.editor.cursor;
-        process.stdout.write(`\r\x1b[${col}C`);
+        // Restore cursor column — use explicit column set instead of DECRC
+        // because writing \n above may have scrolled the terminal, which
+        // invalidates the absolute position saved by DECSC.
+        process.stdout.write(`\x1b[${this.cursorTermCol}G`);
     }
     applyAutocomplete() {
         if (!this.autocompleteActive || this.autocompleteItems.length === 0)
@@ -359,18 +381,16 @@ export class InputHandler {
         const selected = this.autocompleteItems[this.autocompleteIndex];
         if (!selected)
             return;
-        const atPos = this.editor.buffer.lastIndexOf("@");
+        const atPos = this.editor.text.lastIndexOf("@");
         const isFileAc = atPos >= 0 &&
-            (atPos === 0 || this.editor.buffer[atPos - 1] === " ") &&
-            !this.editor.buffer.slice(atPos + 1).includes(" ");
+            (atPos === 0 || this.editor.text[atPos - 1] === " ") &&
+            !this.editor.text.slice(atPos + 1).includes(" ");
         if (isFileAc) {
-            this.editor.buffer =
-                this.editor.buffer.slice(0, atPos) + "@" + selected.name;
+            this.editor.setText(this.editor.text.slice(0, atPos) + "@" + selected.name);
         }
         else {
-            this.editor.buffer = selected.name;
+            this.editor.setText(selected.name);
         }
-        this.editor.cursor = this.editor.buffer.length;
         this.clearAutocompleteLines();
         this.autocompleteActive = false;
         this.autocompleteItems = [];
@@ -388,11 +408,12 @@ export class InputHandler {
     clearAutocompleteLines() {
         if (this.autocompleteLines <= 0)
             return;
-        process.stdout.write("\x1b7"); // save cursor
+        // Use CSI B (cursor down, bounded) instead of \n to avoid scroll
         for (let i = 0; i < this.autocompleteLines; i++) {
-            process.stdout.write("\n\x1b[2K"); // move down, clear line
+            process.stdout.write("\x1b[B\x1b[2K"); // move down, clear line
         }
-        process.stdout.write("\x1b8"); // restore cursor
+        // Move back up and restore column with relative movement (scroll-safe)
+        process.stdout.write(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
         this.autocompleteLines = 0;
     }
     handleModeInput(data) {
@@ -419,8 +440,8 @@ export class InputHandler {
             switch (act.action) {
                 case "changed": {
                     // If the buffer is exactly a trigger char for a different mode, switch to it
-                    const switchMode = this.modes.get(this.editor.buffer);
-                    if (this.editor.buffer.length === 1 && switchMode && switchMode !== this.activeMode) {
+                    const switchMode = this.modes.get(this.editor.text);
+                    if (this.editor.text.length === 1 && switchMode && switchMode !== this.activeMode) {
                         this.dismissAutocomplete();
                         this.clearPromptArea();
                         this.activeMode = switchMode;
@@ -437,10 +458,10 @@ export class InputHandler {
                     if (this.autocompleteActive) {
                         this.applyAutocomplete();
                     }
-                    // Use editor.buffer (not act.buffer) so autocomplete selections
+                    // Use editor.text (not act.buffer) so autocomplete selections
                     // take effect — act.buffer is a stale snapshot from before
-                    // applyAutocomplete() updated the buffer.
-                    const query = this.editor.buffer.trim();
+                    // applyAutocomplete() updated the editor.
+                    const query = this.editor.text.trim();
                     if (query) {
                         // Add to history (avoid consecutive duplicates)
                         if (this.history.length === 0 || this.history[this.history.length - 1] !== query) {
@@ -452,17 +473,24 @@ export class InputHandler {
                     this.savedBuffer = "";
                     this.clearAutocompleteLines();
                     this.clearPromptArea();
-                    process.stdout.write("\x1b[<u"); // disable kitty keyboard protocol
+                    process.stdout.write("\x1b[<u\x1b[?2004l"); // disable kitty + bracket paste
                     const currentMode = this.activeMode;
                     this.activeMode = null;
                     this.editor.clear();
+                    this.cursorRowsBelow = 0;
+                    this.cursorTermCol = 1;
                     this.dismissAutocomplete();
                     if (query && query.startsWith("/")) {
                         const spaceIdx = query.indexOf(" ");
                         const name = spaceIdx === -1 ? query : query.slice(0, spaceIdx);
                         const args = spaceIdx === -1 ? "" : query.slice(spaceIdx + 1).trim();
                         this.bus.emit("command:execute", { name, args });
-                        this.ctx.freshPrompt();
+                        if (currentMode.returnToSelf) {
+                            this.enterMode(currentMode);
+                        }
+                        else {
+                            this.ctx.freshPrompt();
+                        }
                     }
                     else if (query) {
                         this.pendingReturnMode = currentMode.returnToSelf ? currentMode.id : null;
@@ -506,14 +534,13 @@ export class InputHandler {
                     }
                     else if (this.history.length > 0) {
                         if (this.historyIndex === -1) {
-                            this.savedBuffer = this.editor.buffer;
+                            this.savedBuffer = this.editor.text;
                             this.historyIndex = this.history.length - 1;
                         }
                         else if (this.historyIndex > 0) {
                             this.historyIndex--;
                         }
-                        this.editor.buffer = this.history[this.historyIndex];
-                        this.editor.cursor = this.editor.buffer.length;
+                        this.editor.setText(this.history[this.historyIndex]);
                         this.clearAutocompleteLines();
                         this.writeModePromptLine();
                     }
@@ -531,13 +558,12 @@ export class InputHandler {
                     else if (this.historyIndex !== -1) {
                         if (this.historyIndex < this.history.length - 1) {
                             this.historyIndex++;
-                            this.editor.buffer = this.history[this.historyIndex];
+                            this.editor.setText(this.history[this.historyIndex]);
                         }
                         else {
                             this.historyIndex = -1;
-                            this.editor.buffer = this.savedBuffer;
+                            this.editor.setText(this.savedBuffer);
                         }
-                        this.editor.cursor = this.editor.buffer.length;
                         this.clearAutocompleteLines();
                         this.writeModePromptLine();
                     }

package/dist/{output-parser.d.ts → shell/output-parser.d.ts}

@@ -1,4 +1,4 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 /**
  * Parses PTY output to detect command boundaries, track cwd,
  * and emit shell events. Owns the command lifecycle state.

package/dist/{output-parser.js → shell/output-parser.js}

@@ -1,4 +1,4 @@
-import { stripAnsi } from "./utils/ansi.js";
+import { stripAnsi } from "../utils/ansi.js";
 /**
  * Parses PTY output to detect command boundaries, track cwd,
  * and emit shell events. Owns the command lifecycle state.

package/dist/{shell.d.ts → shell/shell.d.ts}

@@ -1,8 +1,13 @@
-import type { EventBus } from "./event-bus.js";
+import type { EventBus } from "../event-bus.js";
 import { type InputContext } from "./input-handler.js";
+export interface ShellHandlers {
+    define: (name: string, fn: (...args: any[]) => any) => void;
+    call: (name: string, ...args: any[]) => any;
+}
 export declare class Shell implements InputContext {
     private ptyProcess;
     private bus;
+    private handlers;
     private inputHandler;
     private outputParser;
     private paused;
@@ -14,6 +19,7 @@ export declare class Shell implements InputContext {
     private tmpDir?;
     constructor(opts: {
         bus: EventBus;
+        handlers: ShellHandlers;
         onShowAgentInfo?: () => {
             info: string;
             model?: string;
@@ -43,7 +49,7 @@ export declare class Shell implements InputContext {
      * Routed through shell:redraw-prompt pipe so extensions (e.g. overlay)
      * can suppress it by setting `handled: true`.
      */
-    freshPrompt(): void;
+    freshPrompt(): boolean;
     onCommandEntered(command: string, cwd: string): void;
     private setupOutput;
     private setupInput;