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

package/dist/core/extensions/builtin/html-render/tool.js

@@ -0,0 +1,74 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { defineTool } from "../../types.js";
+import { injectHtmlRenderBootstrap } from "./bootstrap.js";
+import { inlineLocalImages } from "./images.js";
+// The same input limit as the desktop's html_render. Images belong as absolute
+// file paths, which are inlined after the check, so the document itself stays
+// small: it travels in the tool call and again in the result details.
+const MAX_HTML_CHARACTERS = 512_000;
+const Params = Type.Object({
+    html: Type.String({
+        description: "A complete, self-contained HTML document.",
+        minLength: 1,
+        maxLength: MAX_HTML_CHARACTERS,
+    }),
+    title: Type.String({ description: "Short name for the page.", minLength: 1, maxLength: 200 }),
+    height: Type.Optional(Type.Integer({
+        description: "Frame height hint in CSS pixels, 80-2000. Defaults to the page's natural height.",
+    })),
+});
+const OUTPUT_DIR = ".senpi/html-pages";
+const clampHeight = (height) => height === undefined ? undefined : Math.min(2000, Math.max(80, Math.round(height)));
+export const showHtmlPageTool = defineTool({
+    name: "show_html_page",
+    label: "Show HTML Page",
+    description: "Show a finished self-contained HTML page (chart, table, diagram, mockup) to the reader. " +
+        "No network: inline every script, style and image (data: URIs). A <script src>, stylesheet link, font, image " +
+        "or fetch that points at a URL (a CDN included) is refused, and the page comes out blank or broken. " +
+        "Local images written as absolute file paths " +
+        "are inlined automatically after a byte check. In the desktop thread this renders inline above your " +
+        "reply; elsewhere it is written to a file you can open in the desktop.",
+    promptSnippet: "show_html_page: show a self-contained HTML page (chart/table/diagram) to the reader",
+    promptGuidelines: [
+        "No network: inline every script, style and image (data: URIs); a CDN <script src> or remote font is refused and leaves the page blank.",
+        "Absolute-path local images are inlined after a magic-byte check; a renamed non-image is refused.",
+    ],
+    parameters: Params,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        const inlined = await inlineLocalImages(params.html);
+        const prepared = injectHtmlRenderBootstrap(inlined.html);
+        const height = clampHeight(params.height);
+        const dir = join(ctx.cwd, OUTPUT_DIR);
+        await mkdir(dir, { recursive: true });
+        const safeName = params.title
+            .replace(/[\\/:*?"<>|\p{Cc}]+/gu, " ")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 60) || "page";
+        const path = join(dir, `${safeName}-${Date.now().toString(36)}.html`);
+        await writeFile(path, prepared, "utf8");
+        const missing = inlined.missing.length === 0 ? undefined : inlined.missing;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Wrote the page to ${path}. Open it in the desktop to see it rendered with your theme. ` +
+                        (missing === undefined
+                            ? "Local images were inlined."
+                            : `Some local images could not be read and were left as written: ${missing.join(", ")}.`),
+                },
+            ],
+            details: {
+                path,
+                title: params.title,
+                height,
+                prepared: true,
+                ...(missing ? { missingImages: missing } : {}),
+                html: params.html,
+            },
+        };
+    },
+});
+//# sourceMappingURL=tool.js.map

package/dist/core/extensions/builtin/index.js

@@ -19,6 +19,7 @@ import helpExtension from "./help/index.js";
 import herdrExtension from "./herdr/index.js";
 import historySearchExtension from "./history-search/index.js";
 import hooksExtension from "./hooks/index.js";
+import htmlRenderExtension from "./html-render/index.js";
 import imageGenExtension from "./imagegen/index.js";
 import importReproExtension from "./import-repro.js";
 import lookAtExtension from "./look-at/index.js";
@@ -103,6 +104,9 @@ export const builtinExtensions = [
     { id: "cache-keepalive", factory: cacheKeepAliveExtension },
     { id: "ttsr", factory: ttsrExtension },
     { id: "btw", factory: btwExtension },
+    // HTML page rendering for standalone senpi (TUI/local); the desktop thread reaches the
+    // same capability through the desktop's MCP server instead.
+    { id: "html-render", factory: htmlRenderExtension },
     // Provider-neutral account listing; sits before the provider lanes so their
     // dedicated commands (claude-account, cursor accounts) keep their own names.
     { id: "account", factory: accountExtension },

package/dist/core/extensions/builtin/permission-system/index.js

@@ -52,6 +52,8 @@ export default function permissionSystemExtension(pi) {
     let activePreset = null;
     let initialApprovedCount = 0;
     let setupError = null;
+    // The `permission-preset` flag value the rules were last loaded from; absent until session_start.
+    let loadedPresetFlag;
     const nextRequestID = createRequestIDFactory();
     pi.registerFlag("permission", {
         description: "Set permission rules (format: tool=action or tool:pattern=action)",
@@ -74,10 +76,12 @@ export default function permissionSystemExtension(pi) {
         }
         applyToolDenials();
     });
-    const loadPermissionRules = (cwd) => {
+    // `sessionApproved` carries this session's "Always" answers, not yet written to disk, across a reload.
+    const loadPermissionRules = (cwd, sessionApproved = []) => {
         const settingsManager = SettingsManager.create(cwd);
         const permissionFlag = pi.getFlag("permission");
         const permissionPresetFlag = pi.getFlag("permission-preset");
+        loadedPresetFlag = { value: permissionPresetFlag };
         cliRuleset = typeof permissionFlag === "string" ? parsePermissionFlag(permissionFlag) : [];
         const cliPreset = typeof permissionPresetFlag === "string" ? parsePermissionPresetFlag(permissionPresetFlag) : undefined;
         if (typeof permissionPresetFlag === "string" && !cliPreset) {
@@ -88,22 +92,44 @@ export default function permissionSystemExtension(pi) {
         activePreset = loadedSettings.preset;
         const approved = loadedSettings.approved;
         parserRegistry = createBuiltinParserRegistry();
-        service = new PermissionService(staticRuleset, approved, createEventEmitter(pi));
+        service = new PermissionService(staticRuleset, [...approved, ...sessionApproved], createEventEmitter(pi));
         initialApprovedCount = approved.length;
     };
-    const applyToolDenials = () => {
+    const applyToolDenials = (onlyWhenNarrowed = false) => {
         const allTools = pi.getAllTools().map((tool) => tool.name);
         const disabledTools = disabled(allTools, staticRuleset);
-        const activeTools = pi
-            .getActiveTools()
-            .filter((toolName) => INTERNAL_PERMISSION_TOOLS.has(toolName) || !disabledTools.has(toolName));
+        const currentTools = pi.getActiveTools();
+        const activeTools = currentTools.filter((toolName) => INTERNAL_PERMISSION_TOOLS.has(toolName) || !disabledTools.has(toolName));
+        if (onlyWhenNarrowed && activeTools.length === currentTools.length)
+            return;
         pi.setActiveTools(activeTools);
     };
+    // A host moves a live session to another preset (an attach naming one) by changing the flag;
+    // the rules follow from the next tool call on, and a failed reload refuses calls like session_start.
+    const followPresetFlag = (cwd) => {
+        if (loadedPresetFlag === undefined || loadedPresetFlag.value === pi.getFlag("permission-preset"))
+            return;
+        const sessionApproved = service ? service.getApproved().slice(initialApprovedCount) : [];
+        setupError = null;
+        try {
+            loadPermissionRules(cwd, sessionApproved);
+        }
+        catch (error) {
+            setupError = getReason(error);
+            return;
+        }
+        applyToolDenials(true);
+    };
     pi.on("tool_call", async (event, ctx) => {
+        followPresetFlag(ctx.cwd);
         if (setupError !== null) {
             return { block: true, reason: `Permission setup failed: ${setupError}` };
         }
-        if (!service || !parserRegistry) {
+        // Pinned for this call: a preset change while it waits on a prompt must not move its reply
+        // to another service or its decision to another preset.
+        const activeService = service;
+        const callPreset = activePreset;
+        if (!activeService || !parserRegistry) {
             return undefined;
         }
         const toolOwnedRequests = parserRegistry.has(event.toolName)
@@ -130,18 +156,18 @@ export default function permissionSystemExtension(pi) {
                     ...(event.parentToolCallId === undefined ? {} : { parentCallID: event.parentToolCallId }),
                 },
             };
-            const auto = activePreset === "auto"
+            const auto = callPreset === "auto"
                 ? await decideAuto(event.toolName, event.input, permissionRequest, ctx.cwd)
                 : undefined;
-            const askResultPromise = service
+            const askResultPromise = activeService
                 .ask(request, {
                 autoApproveAsk: permissionRequest.autoApproveAsk ?? false,
                 approveBlanketAsk: auto?.approveBlanketAsk ?? false,
-                presetBound: activePreset === "auto",
+                presetBound: callPreset === "auto",
                 ...(permissionRequest.ruleAliases ? { ruleAliases: permissionRequest.ruleAliases } : {}),
             })
                 .then(() => ({ ok: true }), (error) => ({ ok: false, error }));
-            const isPending = service.list().some((pendingRequest) => pendingRequest.id === request.id);
+            const isPending = activeService.list().some((pendingRequest) => pendingRequest.id === request.id);
             if (!isPending) {
                 const askResult = await askResultPromise;
                 if (!askResult.ok) {
@@ -151,16 +177,16 @@ export default function permissionSystemExtension(pi) {
             }
             if (ctx.hasUI) {
                 const reply = await showPermissionPrompt(ctx, request);
-                service.reply(reply);
+                activeService.reply(reply);
             }
             else {
-                service.reply(handleNoUI(request, {
+                activeService.reply(handleNoUI(request, {
                     emitEvent: (eventName, data) => {
                         if (eventName !== "permission_asked") {
                             pi.events.emit(eventName, data);
                         }
                     },
-                    presetBound: activePreset === "auto",
+                    presetBound: callPreset === "auto",
                 }));
             }
             const askResult = await askResultPromise;

package/dist/core/extensions/session-control-types.d.ts

@@ -25,9 +25,30 @@ export interface SessionControlWakeEvent {
     readonly delivery_ids?: readonly string[];
 }
 export type ExternalDeliverAs = "steer" | "followUp";
+/**
+ * Who sent a delivery, for the surfaces a human reads: another session (by id, with the name it had
+ * when it sent), the command line, or an external chat. The model reads `text`; this is not shown
+ * to it.
+ */
+export type SessionControlSender = {
+    readonly kind: "agent";
+    readonly session_id: string;
+    readonly name?: string;
+} | {
+    readonly kind: "command_line";
+    readonly user?: string;
+} | {
+    readonly kind: "external";
+    readonly platform: string;
+    readonly author?: string;
+};
 export interface AdmitExternalMessageInput {
     readonly delivery_id: string;
     readonly text: string;
+    /** Who sent it; a delivery without one renders as a generic remote message. */
+    readonly sender?: SessionControlSender;
+    /** The message as its sender wrote it, for human surfaces; `text` keeps the provenance the model reads. */
+    readonly display_text?: string;
     readonly deliverAs: ExternalDeliverAs;
     /** The `turn_epoch` the sender observed; a steer is admitted only while it is still current. */
     readonly expected_turn_id?: number;
@@ -117,7 +138,11 @@ export interface SessionControlDeliveryDetails {
     readonly delivery_id: string;
     readonly source: "session_control";
     readonly deliverAs: ExternalDeliverAs;
+    readonly sender?: SessionControlSender;
+    readonly display_text?: string;
 }
+/** The sender a delivery's `details` names, when it names a well-formed one. */
+export declare function sessionControlSenderOf(details: unknown): SessionControlSender | undefined;
 /** Whether a custom-message `details` value proves it came through session-control admission. */
 export declare function isSessionControlDeliveryDetails(value: unknown): value is SessionControlDeliveryDetails;
 //# sourceMappingURL=session-control-types.d.ts.map

package/dist/core/extensions/session-control-types.js

@@ -10,6 +10,22 @@
  */
 /** `customType` of the transcript entry an admitted delivery becomes. */
 export const SESSION_CONTROL_DELIVERY_TYPE = "session_control_delivery";
+/** The sender a delivery's `details` names, when it names a well-formed one. */
+export function sessionControlSenderOf(details) {
+    if (!isSessionControlDeliveryDetails(details) || typeof details.sender !== "object" || details.sender === null)
+        return undefined;
+    const sender = { ...details.sender };
+    const optional = (key) => (typeof sender[key] === "string" ? { [key]: sender[key] } : {});
+    if (sender.kind === "agent" && typeof sender.session_id === "string") {
+        return { kind: "agent", session_id: sender.session_id, ...optional("name") };
+    }
+    if (sender.kind === "command_line")
+        return { kind: "command_line", ...optional("user") };
+    if (sender.kind === "external" && typeof sender.platform === "string") {
+        return { kind: "external", platform: sender.platform, ...optional("author") };
+    }
+    return undefined;
+}
 /** Whether a custom-message `details` value proves it came through session-control admission. */
 export function isSessionControlDeliveryDetails(value) {
     if (typeof value !== "object" || value === null)

package/dist/core/external-admission.js

@@ -173,7 +173,13 @@ function deliveryMessage(input) {
         customType: SESSION_CONTROL_DELIVERY_TYPE,
         content: input.text,
         display: true,
-        details: { delivery_id: input.delivery_id, source: "session_control", deliverAs: input.deliverAs },
+        details: {
+            delivery_id: input.delivery_id,
+            source: "session_control",
+            deliverAs: input.deliverAs,
+            ...(input.sender === undefined ? {} : { sender: input.sender }),
+            ...(input.display_text === undefined ? {} : { display_text: input.display_text }),
+        },
         timestamp: Date.now(),
     };
 }

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/index.d.ts

@@ -1,4 +1,4 @@
-export { sanitizeTerminalLabel } from "@earendil-works/pi-tui";
+export { sanitizeTerminalLabel, visibleWidth } from "@earendil-works/pi-tui";
 export { type Args, parseArgs } from "./cli/args.ts";
 export { runHostCommand } from "./cli/host-command.ts";
 export { CONFIG_DIR_NAME, getAgentDir, getDocsPath, getExamplesPath, getPackageDir, getReadmePath, VERSION, } from "./config.ts";

package/dist/index.js

@@ -1,5 +1,5 @@
 // Core session management
-export { sanitizeTerminalLabel } from "@earendil-works/pi-tui";
+export { sanitizeTerminalLabel, visibleWidth } from "@earendil-works/pi-tui";
 export { parseArgs } from "./cli/args.js";
 // The shared-daemon command surface: one JSON line, one exit code, for launchers without a shell
 export { runHostCommand } from "./cli/host-command.js";

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;