@code-yeongyu/senpi 2026.10.10-3 → 2026.10.10-4

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

@@ -1564,10 +1564,10 @@ export class InteractiveMode {
             return;
         }
         const seeded = seedKeybindingsFile(configPath, this.keybindings);
-        const edit = await editFileInExternalEditor({
+        const edit = await this.withTerminalHandedOver(() => editFileInExternalEditor({
             command: editorCommand,
             path: configPath,
-        });
+        }));
         if (edit.status === "launch-failed") {
             // The editor never ran, so a file we just seeded carries no user content.
             if (seeded)
@@ -3123,6 +3123,11 @@ export class InteractiveMode {
                     return state !== undefined;
                 },
                 notice: (line) => this.showWarning(line),
+                selectModel: (model) => InteractiveMode.applyModelSelection(this, model),
+                selectThinkingLevel: (level, remember) => InteractiveMode.applyThinkingLevel(this, level, remember),
+                interruptTurn: async () => {
+                    await this.abortAndFireQueuedMessages();
+                },
             },
         };
     }
@@ -5820,17 +5825,25 @@ export class InteractiveMode {
     async handleOpenExternalEditor() {
         const editorCmd = this.settingsManager.getExternalEditorCommand();
         const content = this.getExpandedEditorText();
+        const result = await this.withTerminalHandedOver(() => editInExternalEditor({
+            command: editorCmd,
+            content,
+        }));
+        if (result.status === "complete") {
+            this.editor.setText(result.content);
+        }
+    }
+    /**
+     * Runs `work` (an external program that draws on the terminal itself) with the terminal handed
+     * back: the TUI stops, fd 1 and fd 2 point at the terminal again, and both are taken over again
+     * afterwards. An editor launched without this would draw into the debug log (#2815).
+     */
+    async withTerminalHandedOver(work) {
         this.pauseQuestionMouseCapture();
         this.ui.stop();
         restoreInteractiveStderr();
         try {
-            const result = await editInExternalEditor({
-                command: editorCmd,
-                content,
-            });
-            if (result.status === "complete") {
-                this.editor.setText(result.content);
-            }
+            return await work();
         }
         finally {
             takeOverInteractiveStderr();
@@ -6574,18 +6587,26 @@ export class InteractiveMode {
      */
     selectThinkingLevel(level, persist) {
         try {
-            if (persist)
-                this.session.setThinkingLevel(level);
-            else
-                this.session.setSessionThinkingLevel(level);
-            this.footer.invalidate();
-            this.updateEditorBorderColor();
-            this.showStatus(persist ? `Default thinking level: ${level}` : `Thinking level: ${level}`);
+            InteractiveMode.applyThinkingLevel(this, level, persist);
         }
         catch (error) {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
+    /**
+     * The level switch itself; the control endpoint's `set_thinking_level` runs it too.
+     * Static and called through the class, so a handler invoked on a partial `this`
+     * reaches exactly the members the switch uses.
+     */
+    static applyThinkingLevel(mode, level, persist) {
+        if (persist)
+            mode.session.setThinkingLevel(level);
+        else
+            mode.session.setSessionThinkingLevel(level);
+        mode.footer.invalidate();
+        mode.updateEditorBorderColor();
+        mode.showStatus(persist ? `Default thinking level: ${level}` : `Thinking level: ${level}`);
+    }
     async showThinkingSelector() {
         const availableLevels = this.session.getAvailableThinkingLevels();
         this.showSelector((done) => {
@@ -6652,24 +6673,32 @@ export class InteractiveMode {
         done?.();
         this.ui?.requestRender();
         try {
-            const systemPromptChange = await this.session.setModel(model);
-            this.footer.invalidate();
-            // A model switch ends any external-owner delegation episode.
-            this.externalOwnerCompactionNoticeShown = false;
-            this.footer?.setCompactionDelegated?.(false);
-            this.updateEditorBorderColor();
-            const systemPromptStr = systemPromptChange?.systemPromptName
-                ? ` (optimized system prompt applied: ${systemPromptChange.systemPromptName})`
-                : "";
-            this.showStatus(`Model: ${model.id}${systemPromptStr}`);
-            this.showRiskyMainModelWarning(model);
-            void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
-            this.checkDaxnutsEasterEgg(model);
+            await InteractiveMode.applyModelSelection(this, model);
         }
         catch (error) {
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }
+    /**
+     * The `/model` switch itself; the control endpoint's `set_model` runs it too, and reports a throw.
+     * Static and called through the class for the same reason as `applyThinkingLevel`.
+     */
+    static async applyModelSelection(mode, model) {
+        const systemPromptChange = await mode.session.setModel(model);
+        mode.footer.invalidate();
+        // A model switch ends any external-owner delegation episode.
+        mode.externalOwnerCompactionNoticeShown = false;
+        mode.footer?.setCompactionDelegated?.(false);
+        mode.updateEditorBorderColor();
+        const systemPromptStr = systemPromptChange?.systemPromptName
+            ? ` (optimized system prompt applied: ${systemPromptChange.systemPromptName})`
+            : "";
+        mode.showStatus(`Model: ${model.id}${systemPromptStr}`);
+        mode.showRiskyMainModelWarning(model);
+        void mode.maybeWarnAboutAnthropicSubscriptionAuth(model);
+        mode.checkDaxnutsEasterEgg(model);
+        return systemPromptChange;
+    }
     async resolveFavoriteModelsForUi(patterns, candidateModels) {
         const candidateIds = new Set(candidateModels.map(getModelFullId));
         const warnings = [];

package/dist/modes/interactive/interactive-stderr-guard.d.ts

@@ -1,3 +1,11 @@
+/** Hidden fd 1/fd 2 output above this size is dropped, so a child printing forever cannot fill the disk (#2815). */
+export declare const HIDDEN_OUTPUT_LOG_MAX_BYTES: number;
+/**
+ * Keeps the debug log under `maxBytes` while fd 1 and fd 2 are redirected into it: past the cap the
+ * file is cut back to its most recent tail behind one marker line. The redirected descriptors are
+ * opened for append, so writers keep appending at the new end. Returns whether it cut.
+ */
+export declare function capHiddenOutputLog(logPath: string, maxBytes?: number): boolean;
 /** Load the fd-level capture once, before the first takeover; a no-op where it is unsupported. */
 export declare function prepareInteractiveStderrCapture(): Promise<void>;
 export declare function takeOverInteractiveStderr(): void;

package/dist/modes/interactive/interactive-stderr-guard.js

@@ -5,10 +5,48 @@ import { getDebugLogPath } from "../../config.js";
 import { restoreStderr, takeOverStderr } from "../../core/output-guard.js";
 import { redactSensitiveOutput } from "../../core/sensitive-output.js";
 import { loadStderrFdSyscalls, redirectStderrFd, } from "./stderr-fd-redirect.js";
+import { redirectStdoutFd } from "./stdout-fd-redirect.js";
 const consoleLevels = ["error", "info", "warn"];
 let interactiveConsoleState;
 let stderrFdSyscalls;
 let stderrFdRedirect;
+let stdoutFdRedirect;
+let hiddenOutputCapTimer;
+/** Hidden fd 1/fd 2 output above this size is dropped, so a child printing forever cannot fill the disk (#2815). */
+export const HIDDEN_OUTPUT_LOG_MAX_BYTES = 32 * 1024 * 1024;
+/** The most recent hidden output kept when the cap is hit. */
+const HIDDEN_OUTPUT_LOG_KEPT_TAIL_BYTES = 256 * 1024;
+const HIDDEN_OUTPUT_CAP_CHECK_MS = 5_000;
+/**
+ * Keeps the debug log under `maxBytes` while fd 1 and fd 2 are redirected into it: past the cap the
+ * file is cut back to its most recent tail behind one marker line. The redirected descriptors are
+ * opened for append, so writers keep appending at the new end. Returns whether it cut.
+ */
+export function capHiddenOutputLog(logPath, maxBytes = HIDDEN_OUTPUT_LOG_MAX_BYTES) {
+    let size;
+    try {
+        size = fs.statSync(logPath).size;
+    }
+    catch {
+        return false;
+    }
+    if (size <= maxBytes)
+        return false;
+    const keep = Math.min(HIDDEN_OUTPUT_LOG_KEPT_TAIL_BYTES, maxBytes);
+    const tail = Buffer.alloc(keep);
+    const fd = fs.openSync(logPath, "r");
+    let read;
+    try {
+        read = fs.readSync(fd, tail, 0, keep, size - keep);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.truncateSync(logPath, 0);
+    fs.appendFileSync(logPath, `[${new Date().toISOString()}] debug log cut at ${size} bytes (cap ${maxBytes}); the last ${keep} bytes follow\n`);
+    fs.appendFileSync(logPath, tail.subarray(0, read));
+    return true;
+}
 function appendHiddenInteractiveStderr(text) {
     if (text.length === 0) {
         return;
@@ -68,7 +106,37 @@ function takeOverStderrFd() {
         stderrFdRedirect = undefined;
     }
 }
+// Only a terminal stdout is the TUI's screen; a piped stdout is some caller's protocol and stays as it is.
+function takeOverStdoutFd() {
+    if (!stderrFdSyscalls || stdoutFdRedirect || !process.stdout.isTTY)
+        return;
+    try {
+        appendHiddenInteractiveStderr("native stdout (fd 1) writes outside the TUI captured below until it releases the terminal");
+        stdoutFdRedirect = redirectStdoutFd(stderrFdSyscalls, getDebugLogPath());
+    }
+    catch {
+        stdoutFdRedirect = undefined;
+    }
+}
+function startHiddenOutputCap() {
+    if (hiddenOutputCapTimer || (!stderrFdRedirect && !stdoutFdRedirect))
+        return;
+    hiddenOutputCapTimer = setInterval(() => {
+        try {
+            capHiddenOutputLog(getDebugLogPath());
+        }
+        catch {
+            // The cap is best effort; a failed check retries on the next tick.
+        }
+    }, HIDDEN_OUTPUT_CAP_CHECK_MS);
+    hiddenOutputCapTimer.unref?.();
+}
 function restoreStderrFd() {
+    if (hiddenOutputCapTimer)
+        clearInterval(hiddenOutputCapTimer);
+    hiddenOutputCapTimer = undefined;
+    stdoutFdRedirect?.restore();
+    stdoutFdRedirect = undefined;
     stderrFdRedirect?.restore();
     stderrFdRedirect = undefined;
 }
@@ -76,6 +144,8 @@ export function takeOverInteractiveStderr() {
     takeOverStderr(appendHiddenInteractiveStderr, redactSensitiveOutput);
     takeOverInteractiveConsole();
     takeOverStderrFd();
+    takeOverStdoutFd();
+    startHiddenOutputCap();
 }
 export function restoreInteractiveStderr() {
     restoreStderrFd();

package/dist/modes/interactive/session-control-commands.d.ts

@@ -2,7 +2,8 @@ import type { AgentSession } from "../../core/agent-session.ts";
 import type { AdmissionHoldReason, QuestionRequest, QuestionResponse, SessionControlDrainResult } from "../../core/extensions/types.ts";
 import type { ControlFeed } from "./session-control-feed.ts";
 import { type ControlCommand, type ControlConnection } from "./session-control-server.ts";
-export interface TuiControlSurface {
+import { type TuiSessionControls } from "./session-control-session-commands.ts";
+export interface TuiControlSurface extends TuiSessionControls {
     draftHold(): AdmissionHoldReason | undefined;
     blockingQuestion(): boolean;
     pendingQuestionIds(): readonly string[];

package/dist/modes/interactive/session-control-commands.js

@@ -1,17 +1,30 @@
 /**
- * The terminal control endpoint's command surface: read-mostly by design. It answers who it is,
- * which one session it holds and that session's state and messages, renames it, streams its feed,
- * wakes its inbox drain, and relays an answer to a question the session itself asked. Nothing here
- * can prompt, steer, queue a follow-up, open a session, run a command or change a model - one
- * delivery authority (the registrant's drain) applies messages, through admission, and only there.
- * Every other command is answered `unsupported` as data.
+ * The terminal control endpoint's command surface. It answers who it is, which one session it holds
+ * and that session's state and messages, renames it, streams its feed, wakes its inbox drain, relays
+ * an answer to a question the session itself asked, and applies the pane's own session controls (a
+ * model, a thinking level, an interrupt - `session-control-session-commands.ts`). Nothing here can
+ * prompt, steer, queue a follow-up, open a session or run a command - one delivery authority (the
+ * registrant's drain) applies messages, through admission, and only there. Every other command is
+ * answered `unsupported` as data; `get_protocol_info` lists the accepted ones in `commands`.
  */
 import { VERSION } from "../../config.js";
 import { engineBuildIdentity } from "../../core/engine-build-identity.js";
 import { answeredUiRequestId, settledQuestionStatus, unansweredQuestionIds } from "../rpc/extension-ui-response.js";
 import { buildRpcSessionState } from "../rpc/rpc-session-state.js";
 import { failure, success } from "./session-control-server.js";
+import { runSessionControlCommand, SESSION_CONTROL_COMMANDS, } from "./session-control-session-commands.js";
 export const TUI_CONTROL_CAPABILITY = "tui_control";
+const TUI_CONTROL_COMMANDS = [
+    "get_protocol_info",
+    "list_sessions",
+    "get_state",
+    "get_messages",
+    "set_session_name",
+    "subscribe",
+    "wake",
+    "extension_ui_response",
+    ...SESSION_CONTROL_COMMANDS,
+];
 export async function runControlCommand(context, connection, command) {
     const { id, type } = command;
     const { session } = context;
@@ -27,6 +40,7 @@ export async function runControlCommand(context, connection, command) {
                 generation: 0,
                 engineVersion: build.text,
                 engineOrdinal: build.ordinal,
+                commands: TUI_CONTROL_COMMANDS,
             });
         }
         case "list_sessions":
@@ -63,7 +77,7 @@ export async function runControlCommand(context, connection, command) {
         case "extension_ui_response":
             return answerQuestion(context.surface, command);
         default:
-            return failure(id, type, "unsupported");
+            return (await runSessionControlCommand(session, context.surface, command)) ?? failure(id, type, "unsupported");
     }
 }
 function sessionRow(session) {

package/dist/modes/interactive/session-control-session-commands.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The terminal control endpoint's session controls: a model switch, a thinking level and an interrupt.
+ * Each one runs the pane's own path (`/model`, the thinking-level selector, Esc) through the surface,
+ * so validation, the footer and persistence are the ones the user gets typing it there.
+ */
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+import type { AgentSession } from "../../core/agent-session.ts";
+import { type ControlCommand } from "./session-control-server.ts";
+export interface TuiSessionControls {
+    /** The `/model` path: switches, updates the footer and records the default; throws a refusal. */
+    selectModel(model: Model<string>): Promise<{
+        readonly systemPromptName?: string;
+    } | undefined>;
+    /** The thinking-level selector: `remember` is its Ctrl+S (the model's remembered level). */
+    selectThinkingLevel(level: ThinkingLevel, remember: boolean): void;
+    /** Esc on a running turn: queued input returns to the editor, the turn aborts and settles. */
+    interruptTurn(): Promise<void>;
+}
+export declare const SESSION_CONTROL_COMMANDS: readonly ["get_available_models", "get_available_thinking_levels", "set_model", "set_thinking_level", "interrupt"];
+export declare function runSessionControlCommand(session: AgentSession, controls: TuiSessionControls, command: ControlCommand): Promise<object | undefined>;
+//# sourceMappingURL=session-control-session-commands.d.ts.map

package/dist/modes/interactive/session-control-session-commands.js

@@ -0,0 +1,47 @@
+import { availableModelsData, interruptRunningTurn, unsupportedThinkingLevel, } from "../rpc/session-control-actions-data.js";
+import { failure, success } from "./session-control-server.js";
+export const SESSION_CONTROL_COMMANDS = [
+    "get_available_models",
+    "get_available_thinking_levels",
+    "set_model",
+    "set_thinking_level",
+    "interrupt",
+];
+export async function runSessionControlCommand(session, controls, command) {
+    const { id, type } = command;
+    switch (type) {
+        case "get_available_models":
+            return success(id, type, await availableModelsData(session));
+        case "get_available_thinking_levels":
+            return success(id, type, { levels: session.getAvailableThinkingLevels() });
+        case "set_model":
+            return await setModel(session, controls, command);
+        case "set_thinking_level": {
+            const level = session.getAvailableThinkingLevels().find((candidate) => candidate === command.level);
+            if (level === undefined)
+                return failure(id, type, unsupportedThinkingLevel(command.level));
+            controls.selectThinkingLevel(level, command.scope !== "turn");
+            return success(id, type);
+        }
+        case "interrupt":
+            return success(id, type, await interruptRunningTurn(session, command.turnId, () => controls.interruptTurn()));
+        default:
+            return undefined;
+    }
+}
+async function setModel(session, controls, command) {
+    const { id, type } = command;
+    const models = await session.modelRegistry.getAvailable();
+    const model = models.find((candidate) => candidate.provider === command.provider && candidate.id === command.modelId);
+    if (model === undefined) {
+        return failure(id, type, `Model not found: ${String(command.provider)}/${String(command.modelId)}`);
+    }
+    try {
+        const change = await controls.selectModel(model);
+        return success(id, type, { ...model, systemPromptName: change?.systemPromptName });
+    }
+    catch (error) {
+        return failure(id, type, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=session-control-session-commands.js.map

package/dist/modes/interactive/stdout-fd-redirect.d.ts

@@ -0,0 +1,12 @@
+import type { StderrFdSyscalls } from "./stderr-fd-redirect.ts";
+type StdoutLike = NodeJS.WriteStream;
+export interface StdoutFdRedirect {
+    restore(): void;
+}
+/**
+ * Point fd 1 at `logPath` (append, 0600) and re-point `stdout` at a duplicate of the terminal.
+ * Returns `undefined`, leaving fd 1 and `stdout` untouched, when any step fails.
+ */
+export declare function redirectStdoutFd(syscalls: StderrFdSyscalls, logPath: string, stdout?: StdoutLike): StdoutFdRedirect | undefined;
+export {};
+//# sourceMappingURL=stdout-fd-redirect.d.ts.map

package/dist/modes/interactive/stdout-fd-redirect.js

@@ -0,0 +1,114 @@
+/**
+ * File-descriptor-level stdout capture for the interactive TUI (#2815).
+ *
+ * The TUI draws on fd 1. Anything else that writes fd 1 directly while the TUI owns the screen (a
+ * `writeSync(1, ...)`, a child spawned with `stdio: "inherit"`, Bun's native `console.log`, a Worker's
+ * console) scrolls the real terminal behind the renderer's back. The renderer's cursor math then goes
+ * stale and the editor is pushed below the visible screen. Mirroring the fd 2 capture
+ * (`stderr-fd-redirect.ts`, #2284): while the TUI owns the screen, fd 1 is pointed at the debug log
+ * with `dup2`, and `process.stdout` (the renderer's only writer) is re-pointed at a duplicate of the
+ * terminal descriptor, so its writes, size and resize events keep coming from the terminal itself.
+ * The original fd 1 is put back before the terminal is released.
+ *
+ * Only the interactive TUI installs this. Print, JSON and RPC modes use stdout as their protocol and
+ * never call it. Windows has no `dup`/`dup2` here (`loadStderrFdSyscalls` returns undefined), so
+ * the JS-level guard stays the only protection there.
+ */
+import { closeSync, createWriteStream, openSync } from "node:fs";
+import { isatty, WriteStream as TtyWriteStream } from "node:tty";
+const STDOUT_FD = 1;
+// One duplicate of the terminal per process: every takeover after a suspend or an external editor
+// reuses it, so a long session does not accumulate descriptors.
+let terminal;
+// Our `write` wrappers, and the `write` that was in place before the first of them. A release can leave
+// an inactive wrapper installed (the renderer's own guard is removed after it); the next takeover wraps
+// the base write instead, so suspend/resume cycles never stack wrappers.
+const ownWrites = new WeakSet();
+let baseWrite;
+function terminalHandle(syscalls) {
+    if (terminal)
+        return terminal;
+    const fd = syscalls.dup(STDOUT_FD);
+    if (fd < 0)
+        return undefined;
+    const stream = isatty(fd) ? new TtyWriteStream(fd) : createWriteStream("", { fd, autoClose: false });
+    terminal = { fd, stream };
+    return terminal;
+}
+/**
+ * Point fd 1 at `logPath` (append, 0600) and re-point `stdout` at a duplicate of the terminal.
+ * Returns `undefined`, leaving fd 1 and `stdout` untouched, when any step fails.
+ */
+export function redirectStdoutFd(syscalls, logPath, stdout = process.stdout) {
+    const handle = terminalHandle(syscalls);
+    if (!handle)
+        return undefined;
+    let target;
+    try {
+        target = openSync(logPath, "a", 0o600);
+    }
+    catch {
+        return undefined;
+    }
+    const moved = syscalls.dup2(target, STDOUT_FD);
+    closeSync(target);
+    if (moved < 0)
+        return undefined;
+    try {
+        return installTerminalWriter(syscalls, handle, stdout);
+    }
+    catch {
+        // Never leave fd 1 pointed at the log without a way back.
+        syscalls.dup2(handle.fd, STDOUT_FD);
+        return undefined;
+    }
+}
+function installTerminalWriter(syscalls, handle, stdout) {
+    let active = true;
+    if (!ownWrites.has(stdout.write))
+        baseWrite = stdout.write;
+    const originalWrite = baseWrite ?? stdout.write;
+    const write = function (...args) {
+        if (!active)
+            return originalWrite.apply(stdout, args);
+        return handle.stream.write.apply(handle.stream, args);
+    };
+    ownWrites.add(write);
+    stdout.write = write;
+    // fd 1 is a file now, so the stream's own size reads would come back empty: read the terminal's.
+    const sizeProperties = ["columns", "rows"];
+    const ownDescriptors = new Map(sizeProperties.map((name) => [name, Object.getOwnPropertyDescriptor(stdout, name)]));
+    for (const name of sizeProperties) {
+        Object.defineProperty(stdout, name, {
+            configurable: true,
+            enumerable: true,
+            get: () => handle.stream[name],
+        });
+    }
+    const onWindowChange = () => {
+        handle.stream._refreshSize?.();
+        stdout.emit("resize");
+    };
+    process.on("SIGWINCH", onWindowChange);
+    return {
+        restore() {
+            if (!active)
+                return;
+            active = false;
+            process.removeListener("SIGWINCH", onWindowChange);
+            syscalls.dup2(handle.fd, STDOUT_FD);
+            // A wrapper installed on top of ours (the renderer's own guard) keeps calling `write`, which
+            // now forwards to the original stdout on the restored fd 1.
+            if (stdout.write === write)
+                stdout.write = originalWrite;
+            for (const name of sizeProperties) {
+                const descriptor = ownDescriptors.get(name);
+                if (descriptor)
+                    Object.defineProperty(stdout, name, descriptor);
+                else
+                    delete stdout[name];
+            }
+        },
+    };
+}
+//# sourceMappingURL=stdout-fd-redirect.js.map

package/dist/modes/rpc/connection-handler.js

@@ -16,7 +16,6 @@
  */
 import * as crypto from "node:crypto";
 import { basename, dirname, extname } from "node:path";
-import { modelSupportsAssistantPrefill } from "@earendil-works/pi-ai";
 import { VERSION } from "../../config.js";
 import { authMethodStatus, buildLoginProviderInfos } from "../../core/auth-providers.js";
 import { ContinueFromLeafError } from "../../core/continue-from-leaf.js";
@@ -27,7 +26,6 @@ import { emitProviderAccountsChanged, subscribeProviderAccountEvents, } from "..
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "../../core/extensions/builtin/anthropic-subscription/account-management.js";
 import { isMcpControlInventoryChanged, MCP_CONTROL_INVENTORY_CHANGED_EVENT, MCP_CONTROL_INVENTORY_REQUEST_EVENT, } from "../../core/extensions/builtin/mcp/control-inventory.js";
 import { applyFastMode, resolveServiceTierMemoryModel, } from "../../core/extensions/builtin/service-tier.js";
-import { getSupportedThinkingLevels } from "../../core/thinking-levels.js";
 import { theme } from "../interactive/theme/theme.js";
 import { DURABLE_CLIENT_MESSAGE_ID_CAPABILITY } from "./client-admission-record.js";
 import { ClientAdmissions } from "./client-admissions.js";
@@ -45,6 +43,7 @@ import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListD
 import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError, sessionRetryFallbackError, } from "./rpc-input-validation.js";
 import { buildRpcSessionState } from "./rpc-session-state.js";
 import { RPC_ERROR_MEDIA_NOT_FOUND } from "./rpc-types.js";
+import { availableModelsData, interruptRunningTurn, unsupportedThinkingLevel } from "./session-control-actions-data.js";
 import { SessionExtensionUiRequests } from "./session-extension-ui-requests.js";
 export { buildRpcSessionState } from "./rpc-session-state.js";
 /** The tool call a dialog is about, as wire fields (absent when the dialog is not a permission request). */
@@ -809,6 +808,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 });
                 return success(id, "abort");
             }
+            case "interrupt":
+                return success(id, "interrupt", await interruptRunningTurn(session, command.turnId, () => session.abort()));
             case "abort_compaction": {
                 session.abortCompaction();
                 return success(id, "abort_compaction");
@@ -891,18 +892,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 }
                 return success(id, "cycle_model", result);
             }
-            case "get_available_models": {
-                const models = await session.modelRegistry.modelRuntime.getAvailable();
-                return success(id, "get_available_models", {
-                    models: models.map((model) => ({
-                        ...model,
-                        supportedThinkingLevels: getSupportedThinkingLevels(model),
-                        supportsAssistantPrefill: modelSupportsAssistantPrefill(model, {
-                            thinkingEnabled: session.thinkingLevel !== "off",
-                        }),
-                    })),
-                });
-            }
+            case "get_available_models":
+                return success(id, "get_available_models", await availableModelsData(session));
             // =================================================================
             // Thinking
             // =================================================================
@@ -912,7 +903,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                     // neighbour, so applying first would leave a REJECTED request's clamped level in
                     // place. A failed command must not change session state.
                     if (!session.getAvailableThinkingLevels().includes(command.level)) {
-                        return error(id, "set_thinking_level", `Thinking level ${command.level} is not supported by the active model.`);
+                        return error(id, "set_thinking_level", unsupportedThinkingLevel(command.level));
                     }
                     session.setSessionThinkingLevel(command.level);
                 }

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

@@ -73,6 +73,10 @@ type RpcSessionCommand = {
 } & ClientMessageIdentity) | {
     id?: string;
     type: "abort";
+} | {
+    id?: string;
+    type: "interrupt";
+    turnId?: string;
 } | {
     id?: string;
     type: "abort_compaction";
@@ -832,6 +836,15 @@ export type RpcResponse = {
     type: "response";
     command: "abort";
     success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "interrupt";
+    success: true;
+    data: {
+        interrupted: boolean;
+        turnId?: string;
+    };
 } | {
     id?: string;
     type: "response";

package/dist/modes/rpc/session-control-actions-data.d.ts

@@ -0,0 +1,17 @@
+import type { AgentSession } from "../../core/agent-session.ts";
+export declare function availableModelsData(session: AgentSession): Promise<{
+    models: readonly object[];
+}>;
+/** The refusal of a level the active model cannot run; callers match this text. */
+export declare function unsupportedThinkingLevel(level: unknown): string;
+export interface InterruptOutcome {
+    readonly interrupted: boolean;
+    readonly turnId?: string;
+}
+/**
+ * `interrupt { turnId? }`: stops the running turn and only that. An idle session answers
+ * `interrupted: false`; so does a `turnId` naming a turn that is no longer the running one, which
+ * then answers the running turn's id. `stop` resolves once the turn has stopped.
+ */
+export declare function interruptRunningTurn(session: AgentSession, requestedTurnId: unknown, stop: () => Promise<void>): Promise<InterruptOutcome>;
+//# sourceMappingURL=session-control-actions-data.d.ts.map

package/dist/modes/rpc/session-control-actions-data.js

@@ -0,0 +1,38 @@
+/**
+ * The session-control answers a multi-session host and a terminal control endpoint share, so a caller
+ * reads the same shapes from either: the model catalog, the thinking-level refusal, and the
+ * `interrupt` outcome.
+ */
+import { modelSupportsAssistantPrefill } from "@earendil-works/pi-ai";
+import { getSupportedThinkingLevels } from "../../core/thinking-levels.js";
+export async function availableModelsData(session) {
+    const models = await session.modelRegistry.modelRuntime.getAvailable();
+    return {
+        models: models.map((model) => ({
+            ...model,
+            supportedThinkingLevels: getSupportedThinkingLevels(model),
+            supportsAssistantPrefill: modelSupportsAssistantPrefill(model, {
+                thinkingEnabled: session.thinkingLevel !== "off",
+            }),
+        })),
+    };
+}
+/** The refusal of a level the active model cannot run; callers match this text. */
+export function unsupportedThinkingLevel(level) {
+    return `Thinking level ${String(level)} is not supported by the active model.`;
+}
+/**
+ * `interrupt { turnId? }`: stops the running turn and only that. An idle session answers
+ * `interrupted: false`; so does a `turnId` naming a turn that is no longer the running one, which
+ * then answers the running turn's id. `stop` resolves once the turn has stopped.
+ */
+export async function interruptRunningTurn(session, requestedTurnId, stop) {
+    if (!session.isStreaming && session.retryAttempt === 0)
+        return { interrupted: false };
+    const turnId = String(session.externalAdmission.turnEpoch);
+    if (typeof requestedTurnId === "string" && requestedTurnId !== turnId)
+        return { interrupted: false, turnId };
+    await stop();
+    return { interrupted: true, turnId };
+}
+//# sourceMappingURL=session-control-actions-data.js.map