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

package/dist/core/provider-timeout-retry.js

@@ -42,23 +42,34 @@ export function createProviderTimeoutRetryPlan({ message, streamRetryTimeoutMs,
         watchdogTimeoutMs: reconcileWatchdogTimeoutMs(streamRetryTimeoutMs, streamStartTimeoutMs),
     };
 }
-export async function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, }) {
-    const continuation = continueRun();
-    const ownedSignal = getActiveSignal();
-    if (timeoutMs === undefined || ownedSignal === undefined) {
-        await continuation;
-        return;
-    }
-    const timer = setTimeout(() => {
-        if (getActiveSignal() === ownedSignal) {
-            abortActive();
-        }
-    }, timeoutMs);
+export async function runBoundedRetryContinuation({ continueRun, getActiveSignal, abortActive, timeoutMs, onStreamStarted, }) {
+    // The watchdog bounds only the wait for the retried request to start streaming: a retry that streams
+    // and then works for a long time (a long answer, tool calls, further turns) is not a wedged retry.
+    let streamStarted = false;
+    let timer;
+    const unsubscribe = timeoutMs === undefined
+        ? undefined
+        : onStreamStarted?.(() => {
+            streamStarted = true;
+            clearTimeout(timer);
+        });
     try {
+        const continuation = continueRun();
+        const ownedSignal = getActiveSignal();
+        if (timeoutMs === undefined || ownedSignal === undefined || streamStarted) {
+            await continuation;
+            return;
+        }
+        timer = setTimeout(() => {
+            if (!streamStarted && getActiveSignal() === ownedSignal) {
+                abortActive();
+            }
+        }, timeoutMs);
         await continuation;
     }
     finally {
         clearTimeout(timer);
+        unsubscribe?.();
     }
 }
 //# sourceMappingURL=provider-timeout-retry.js.map

package/dist/core/reload-veto.d.ts

@@ -1,4 +1,4 @@
 import type { ExtensionRunner } from "./extensions/runner.ts";
 import type { ReloadVetoDecision } from "./extensions/types.ts";
-export declare function checkSessionReloadVeto(runner: Pick<ExtensionRunner, "hasHandlers" | "emit">, isPromptStartPending: () => boolean): Promise<ReloadVetoDecision>;
+export declare function checkSessionReloadVeto(runner: Pick<ExtensionRunner, "hasHandlers" | "emit">, isPromptStartPending: () => boolean, isSessionStartDispatching?: () => boolean): Promise<ReloadVetoDecision>;
 //# sourceMappingURL=reload-veto.d.ts.map

package/dist/core/reload-veto.js

@@ -1,13 +1,19 @@
-export async function checkSessionReloadVeto(runner, isPromptStartPending) {
+export async function checkSessionReloadVeto(runner, isPromptStartPending, isSessionStartDispatching = () => false) {
     if (isPromptStartPending()) {
         return { cancelled: true, reason: "A prompt is being admitted." };
     }
+    if (isSessionStartDispatching()) {
+        return { cancelled: true, reason: "A session is starting." };
+    }
     const result = runner.hasHandlers("session_before_reload")
         ? await runner.emit({ type: "session_before_reload" })
         : undefined;
     if (isPromptStartPending()) {
         return { cancelled: true, reason: "A prompt is being admitted." };
     }
+    if (isSessionStartDispatching()) {
+        return { cancelled: true, reason: "A session is starting." };
+    }
     if (result?.cancel !== true)
         return { cancelled: false };
     return result.reason === undefined ? { cancelled: true } : { cancelled: true, reason: result.reason };

package/dist/core/resource-loader.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { detectCapabilities, getTerminalColorMode } from "@earendil-works/pi-tui";
@@ -171,6 +171,10 @@ function buildGlobalDefaultExtensionShim(modulePath) {
 function getGlobalDefaultExtensionShimPath(agentDir, extensionId) {
     return join(agentDir, "extensions", `${extensionId}.js`);
 }
+function isGlobalDefaultExtensionShimLocation(extensionPath, agentDir) {
+    const resolvedExtensionPath = resolve(extensionPath);
+    return globalDefaultExtensionIds.some((extensionId) => resolvedExtensionPath === resolve(getGlobalDefaultExtensionShimPath(agentDir, extensionId)));
+}
 function findGeneratedGlobalDefaultExtensionId(extensionPath, agentDir) {
     if (resolve(agentDir) !== resolve(getAgentDir())) {
         return undefined;
@@ -183,7 +187,61 @@ function findGeneratedGlobalDefaultExtensionId(extensionPath, agentDir) {
     }
     return undefined;
 }
+/** The module a generated shim re-exports, when it is a generated shim whose target no longer exists. */
+// Exactly what `buildGlobalDefaultExtensionShim` writes: one export line after the banner, nothing else.
+const GENERATED_SHIM_EXPORT_LINE = /^export \{ default \} from ("[^"\n]*");\n?$/;
+/**
+ * The module a generated shim re-exports, when the file is exactly a generated shim (an accepted banner
+ * followed by the single export line and nothing else) and that module no longer exists. A file that
+ * carries the banner but also anything a person wrote is never treated as a shim.
+ */
+function deadGeneratedShimTarget(content) {
+    const banner = LEGACY_GENERATED_GLOBAL_EXTENSION_BANNERS.find((candidate) => content.startsWith(candidate));
+    if (banner === undefined)
+        return undefined;
+    const specifier = GENERATED_SHIM_EXPORT_LINE.exec(content.slice(banner.length))?.[1];
+    if (specifier === undefined)
+        return undefined;
+    let target;
+    try {
+        const parsed = JSON.parse(specifier);
+        target = parsed.startsWith("file:") ? fileURLToPath(parsed) : parsed;
+    }
+    catch {
+        return undefined;
+    }
+    return existsSync(target) ? undefined : target;
+}
+function removeDeadGeneratedShim(shimPath) {
+    let content;
+    try {
+        content = readFileSync(shimPath, "utf-8");
+    }
+    catch {
+        return;
+    }
+    if (deadGeneratedShimTarget(content) === undefined)
+        return;
+    try {
+        unlinkSync(shimPath);
+    }
+    catch {
+        // The loader skips a dead generated shim on its own; a failed removal only retries next start.
+    }
+}
+// A generated shim whose target is gone stands for "load the default extension" from an install that no
+// longer exists. Importing it can only fail with "Cannot find module", so it is skipped without an error.
+const skipDeadGeneratedShim = () => { };
 function resolveGeneratedGlobalDefaultExtensionFactory(extensionPath, agentDir) {
+    if (isGlobalDefaultExtensionShimLocation(extensionPath, agentDir)) {
+        try {
+            if (deadGeneratedShimTarget(readFileSync(extensionPath, "utf-8")) !== undefined)
+                return skipDeadGeneratedShim;
+        }
+        catch {
+            // Unreadable: let the regular load report it.
+        }
+    }
     const extensionId = findGeneratedGlobalDefaultExtensionId(extensionPath, agentDir);
     if (!extensionId) {
         return undefined;
@@ -591,10 +649,13 @@ export class DefaultResourceLoader {
         mkdirSync(extensionsDir, { recursive: true });
         for (const extensionId of globalDefaultExtensionIds) {
             const modulePath = getGlobalDefaultExtensionModulePath(extensionId);
+            const targetPath = getGlobalDefaultExtensionShimPath(this.agentDir, extensionId);
             if (!existsSync(modulePath)) {
+                // This engine has no on-disk builtin to point a shim at (a compiled binary). A shim an
+                // earlier install generated, whose target is gone, can only fail to load: remove it (#2765).
+                removeDeadGeneratedShim(targetPath);
                 continue;
             }
-            const targetPath = getGlobalDefaultExtensionShimPath(this.agentDir, extensionId);
             const shim = buildGlobalDefaultExtensionShim(modulePath);
             if (existsSync(targetPath)) {
                 const existing = readFileSync(targetPath, "utf-8");

package/dist/core/session-rebind.js

@@ -47,11 +47,26 @@ export async function rebindSessionFile(sourcePath, targetCwd, sessionDir, optio
     const target = join(targetDir, basename(source));
     if (target !== source && !existsSync(source) && existsSync(target))
         return target;
-    const { header } = readHeaderLine(source);
+    const header = readHeaderBeforeLock(source, target);
+    if (header === undefined)
+        return target;
     return withSessionMoveLock(source, header.id, () => moveSessionFile(source, target, cwd), {
         ...(options.moveLockWaitMs === undefined ? {} : { waitMs: options.moveLockWaitMs }),
     });
 }
+// The lock is keyed by the session id, so the header is read before the lock is held. A concurrent rebind can finish
+// the move between the existence check and this read; the mover writes the target before it removes the source, so a
+// missing source next to an existing target means the move is already done (`undefined`).
+function readHeaderBeforeLock(source, target) {
+    try {
+        return readHeaderLine(source).header;
+    }
+    catch (error) {
+        if (error.code === "ENOENT" && target !== source && existsSync(target))
+            return undefined;
+        throw error;
+    }
+}
 function moveSessionFile(source, target, cwd) {
     if (target !== source && !existsSync(source) && existsSync(target))
         return target;

package/dist/modes/interactive/components/extension-editor.js

@@ -4,6 +4,7 @@
  */
 import { Container, Editor, getKeybindings, Spacer, Text, } from "@earendil-works/pi-tui";
 import { editInExternalEditor } from "../external-editor.js";
+import { restoreInteractiveStderr, takeOverInteractiveStderr } from "../interactive-stderr-guard.js";
 import { getEditorTheme, theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint } from "./keybinding-hints.js";
@@ -79,6 +80,8 @@ export class ExtensionEditorComponent extends Container {
     async handleOpenExternalEditor() {
         const content = this.editor.getText();
         this.tui.stop();
+        // The editor draws on the real terminal: hand fd 1 and fd 2 back first, as the main editor path does.
+        restoreInteractiveStderr();
         try {
             const result = await editInExternalEditor({
                 command: this.externalEditorCommand,
@@ -89,6 +92,7 @@ export class ExtensionEditorComponent extends Container {
             }
         }
         finally {
+            takeOverInteractiveStderr();
             this.tui.start();
             this.tui.requestRender(true);
         }

package/dist/modes/interactive/components/remote-delivery-message.d.ts

@@ -1,8 +1,11 @@
-import { type MessageRenderer } from "../../../core/extensions/types.ts";
+import { type MessageRenderer, type SessionControlSender } from "../../../core/extensions/types.ts";
 /**
- * A message another session delivered renders as its own provenance block - never as the user's
- * own input, so a reader always sees which text came from outside this terminal.
+ * A message another session delivered renders as its own block - never as the user's own input, so
+ * a reader always sees which text came from outside this terminal. A delivery that names its sender
+ * shows one label line ("Sent by another agent · <name>") over the message as it was written; one
+ * that does not keeps the generic heading over the text the model read.
  */
 export declare const renderRemoteDelivery: MessageRenderer;
+export declare function senderLabel(sender: SessionControlSender): string;
 export declare function builtInMessageRenderer(customType: string): MessageRenderer | undefined;
 //# sourceMappingURL=remote-delivery-message.d.ts.map

package/dist/modes/interactive/components/remote-delivery-message.js

@@ -1,12 +1,22 @@
 import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { SESSION_CONTROL_DELIVERY_TYPE } from "../../../core/extensions/types.js";
+import { isSessionControlDeliveryDetails, SESSION_CONTROL_DELIVERY_TYPE, sessionControlSenderOf, } from "../../../core/extensions/types.js";
 import { getMarkdownTheme } from "../theme/theme.js";
 /**
- * A message another session delivered renders as its own provenance block - never as the user's
- * own input, so a reader always sees which text came from outside this terminal.
+ * A message another session delivered renders as its own block - never as the user's own input, so
+ * a reader always sees which text came from outside this terminal. A delivery that names its sender
+ * shows one label line ("Sent by another agent · <name>") over the message as it was written; one
+ * that does not keeps the generic heading over the text the model read.
  */
 export const renderRemoteDelivery = (message, _options, theme) => {
     const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+    const sender = sessionControlSenderOf(message.details);
+    const shown = sender === undefined ? undefined : displayTextOf(message.details);
+    if (sender !== undefined && shown !== undefined) {
+        box.addChild(new Text(theme.fg("dim", senderLabel(sender)), 0, 0));
+        box.addChild(new Spacer(1));
+        box.addChild(new Markdown(shown, 0, 0, getMarkdownTheme(), { color: (line) => theme.fg("customMessageText", line) }));
+        return box;
+    }
     const label = theme.fg("customMessageLabel", theme.bold("remote message"));
     box.addChild(new Text(`${label}${theme.fg("dim", ` · delivery ${deliveryIdOf(message.details)}`)}`, 0, 0));
     box.addChild(new Spacer(1));
@@ -19,9 +29,28 @@ export const renderRemoteDelivery = (message, _options, theme) => {
     box.addChild(new Markdown(text, 0, 0, getMarkdownTheme(), { color: (line) => theme.fg("customMessageText", line) }));
     return box;
 };
+export function senderLabel(sender) {
+    switch (sender.kind) {
+        case "agent":
+            return sender.name === undefined || sender.name.trim() === ""
+                ? "Sent by another agent"
+                : `Sent by another agent · ${sender.name}`;
+        case "command_line":
+            return "Sent from the command line";
+        case "external":
+            return sender.author === undefined || sender.author.trim() === ""
+                ? `Sent from ${sender.platform}`
+                : `Sent from ${sender.platform} · ${sender.author}`;
+    }
+}
 export function builtInMessageRenderer(customType) {
     return customType === SESSION_CONTROL_DELIVERY_TYPE ? renderRemoteDelivery : undefined;
 }
+function displayTextOf(details) {
+    return isSessionControlDeliveryDetails(details) && typeof details.display_text === "string"
+        ? details.display_text
+        : undefined;
+}
 function deliveryIdOf(details) {
     if (typeof details !== "object" || details === null || !("delivery_id" in details))
         return "unknown";

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

@@ -623,6 +623,12 @@ export declare class InteractiveMode {
     private setToolsExpanded;
     private toggleThinkingBlockVisibility;
     private handleOpenExternalEditor;
+    /**
+     * 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).
+     */
+    private withTerminalHandedOver;
     clearEditor(): void;
     showError(errorMessage: string): void;
     private getProviderErrors;
@@ -696,10 +702,21 @@ export declare class InteractiveMode {
      * records it as the model's remembered level (the Ctrl+S path of the selector).
      */
     private selectThinkingLevel;
+    /**
+     * 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.
+     */
+    private static applyThinkingLevel;
     private showThinkingSelector;
     private handleModelCommand;
     private findExactModelMatch;
     private selectModelFromUi;
+    /**
+     * 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`.
+     */
+    private static applyModelSelection;
     private resolveFavoriteModelsForUi;
     private getFavoriteModelIdsForUi;
     private captureFavoritePatternSnapshot;

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) {