pi-ui-extend 0.1.35 → 0.1.37

package/dist/app/app.d.ts

@@ -43,6 +43,13 @@ export declare class PiUiExtendApp {
     private readonly toastNotifier;
     private readonly extensionShutdownHandler;
     private runtime;
+    /**
+     * Maps each session runtime to the isolated extension event bus it was
+     * created with. The renderer uses this to emit signals (e.g. retry state)
+     * back to the extensions running inside a specific runtime/tab, so a signal
+     * for one tab never reaches another tab's extensions.
+     */
+    private readonly extensionEventBusByRuntime;
     private readonly inputEditor;
     private lastInputEditorContentVersion;
     private readonly requestHistory;
@@ -66,6 +73,7 @@ export declare class PiUiExtendApp {
     start(): Promise<void>;
     private checkPixUpdateOnStartup;
     private bindCurrentSession;
+    private awaitCurrentSessionExtensions;
     private activateRuntime;
     private createExtensionEventBus;
     private handleTerminalBellAttention;

package/dist/app/app.js

@@ -112,6 +112,13 @@ export class PiUiExtendApp {
     };
     extensionShutdownHandler = () => { };
     runtime;
+    /**
+     * Maps each session runtime to the isolated extension event bus it was
+     * created with. The renderer uses this to emit signals (e.g. retry state)
+     * back to the extensions running inside a specific runtime/tab, so a signal
+     * for one tab never reaches another tab's extensions.
+     */
+    extensionEventBusByRuntime = new WeakMap();
     inputEditor = new InputEditor();
     lastInputEditorContentVersion = this.inputEditor.contentVersion;
     requestHistory;
@@ -166,12 +173,24 @@ export class PiUiExtendApp {
             maxProjectSessions: () => this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
-            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options), this.runtime === undefined ? {} : { reuseServicesFrom: this.runtime }),
+            createRuntimeForNewSession: () => this.createRuntime(
+            // Never reuse services across tabs. The SDK ties the extension
+            // runtime (resourceLoader.getExtensions().runtime) to the
+            // resourceLoader, and that runtime is shared by every session
+            // built from the same services. When any such session is
+            // disposed (tab close / session replacement / reload), the SDK
+            // invalidates that shared runtime, which makes every sibling
+            // session's captured `pi`/ctx stale — session_start handlers
+            // then throw "ctx is stale after session replacement or reload".
+            // Fresh services per session = fresh extension runtime = no
+            // cross-session invalidation.
+            newTabRuntimeOptions(this.options)),
             createRuntimeForSession: (sessionPath) => this.createRuntime({
                 ...this.options,
                 noSession: false,
                 sessionPath,
             }),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             activateRuntime: (runtime, options) => this.activateRuntime(runtime, options),
             disposeRuntime: (runtime) => this.terminalController.disposeRuntime(runtime),
             isRunning: () => this.running,
@@ -317,6 +336,7 @@ export class PiUiExtendApp {
             isRunning: () => this.running,
             getInput: () => this.input,
             setInput: (value) => this.setInput(value),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             resetSessionView: () => this.resetSessionView(),
             loadSessionHistory: () => this.loadSessionHistory(),
             afterSessionReplacement: (message) => this.afterSessionReplacement(message),
@@ -341,6 +361,7 @@ export class PiUiExtendApp {
         this.workspaceActions = new AppWorkspaceActionsController({
             entries: this.entries,
             runtime: () => this.runtime,
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             findUserEntry: (entryId) => this.findUserEntry(entryId),
             touchEntry: (entry) => this.touchEntry(entry),
             resetSessionView: () => this.resetSessionView(),
@@ -370,6 +391,16 @@ export class PiUiExtendApp {
             setSessionActivity: (activity) => this.setSessionActivity(activity),
             updateQueuedMessageStatus: () => this.queuedMessages.updateQueuedMessageStatus(),
             flushAutoUserMessages: () => { void this.queuedMessages.flushAutoUserMessages(); },
+            emitExtensionEvent: (channel, data) => {
+                // Emit a signal to the extensions running inside the active
+                // runtime's event bus. Used to inform extensions (terminal-bell,
+                // todo) about session lifecycle state the SDK doesn't forward to
+                // them, such as auto-retry being in progress.
+                const runtime = this.runtime;
+                if (!runtime)
+                    return;
+                this.extensionEventBusByRuntime.get(runtime)?.emit(channel, data);
+            },
             prepareWorkspaceMutation: (toolName, args) => this.workspaceActions.prepareWorkspaceMutation(toolName, args),
             workspaceMutationFromToolExecution: (input) => this.workspaceActions.workspaceMutationFromToolExecution(input),
             recordWorkspaceMutationForUserEntry: (entryId, mutation) => this.workspaceActions.recordWorkspaceMutationForUserEntry(entryId, mutation),
@@ -471,6 +502,7 @@ export class PiUiExtendApp {
             showMenu: (items, options) => this.popupMenus.menuController.show(items, options),
             getModelMenuItems: (query) => this.menuItems.getModelMenuItems(query),
             getThinkingMenuItems: (query) => this.menuItems.getThinkingMenuItems(query),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             modelRef: (model) => this.menuItems.modelRef(model),
             getFavoriteScopedModels: () => this.menuItems.getFavoriteScopedModels(),
             setSessionStatus: (session) => this.setSessionStatus(session),
@@ -518,9 +550,8 @@ export class PiUiExtendApp {
             setSessionStatus: (session) => this.setSessionStatus(session),
             showToast: (message, kind) => this.showToast(message, kind),
             render: () => this.render(),
-            resetSessionView: () => this.resetSessionView(),
-            bindCurrentSession: () => this.bindCurrentSession(),
-            loadSessionHistory: () => this.loadSessionHistory(),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
+            afterSessionReplacement: (message) => this.afterSessionReplacement(message),
             scrollToConversationEntry: (entryId) => this.scrollController.scrollToConversationEntry(entryId),
             scrollToUserMessageJumpTarget: (target) => this.scrollToUserMessageJumpTarget(target),
         }, this.popupMenus, this.commandController, this.menuItems, this.queuedMessages, this.workspaceActions);
@@ -763,10 +794,16 @@ export class PiUiExtendApp {
         this.slashCommands = this.commandController.slashCommands;
     }
     createRuntime(options, runtimeOptions = {}) {
+        const eventBus = this.createExtensionEventBus();
         return createPixRuntime(options, {
-            eventBus: this.createExtensionEventBus(),
+            eventBus,
             config: this.pixConfig,
             ...runtimeOptions,
+        }).then((runtime) => {
+            // Record the bus this runtime's extensions use, so the renderer can
+            // emit signals (retry state, etc.) targeted at this runtime's extensions.
+            this.extensionEventBusByRuntime.set(runtime, eventBus);
+            return runtime;
         });
     }
     async loadStartupConfig() {
@@ -824,11 +861,17 @@ export class PiUiExtendApp {
     async bindCurrentSession(options) {
         await this.sessionLifecycle.bindCurrentSession(options);
     }
+    async awaitCurrentSessionExtensions(runtime) {
+        await this.sessionLifecycle.awaitCurrentSessionExtensions(runtime);
+    }
     async activateRuntime(runtime, options) {
         this.runtime = runtime;
         runtime.setRebindSession(async () => {
             await this.bindCurrentSession({ awaitExtensions: false });
         });
+        runtime.setBeforeSessionInvalidate(() => {
+            this.extensionUiController.clearWidgets(this.activeExtensionUiScope());
+        });
         await this.bindCurrentSession(options);
     }
     createExtensionEventBus() {

package/dist/app/commands/command-controller.js

@@ -49,6 +49,7 @@ export class AppCommandController {
             runReloadCommand: () => this.sessionActions.runReloadCommand(),
             runNewSessionCommand: () => this.sessionActions.runNewSessionCommand(),
             runNewTabCommand: () => this.host.openNewTab(),
+            runDeleteCommand: (argumentsText) => this.sessionActions.runDeleteCommand(argumentsText),
             runCompactCommand: (customInstructions) => this.sessionActions.runCompactCommand(customInstructions),
             runForkCommand: (argumentsText) => this.navigationActions.runForkCommand(argumentsText),
             runCloneCommand: () => this.navigationActions.runCloneCommand(),

package/dist/app/commands/command-host.d.ts

@@ -7,6 +7,7 @@ export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type CommandControllerHost = {
     readonly options: AppOptions;
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     requestHistory(): AppRequestHistory;
     getInput(): string;
     setInput(value: string): void;

package/dist/app/commands/command-model-actions.d.ts

@@ -14,6 +14,7 @@ export declare class ModelCommandActions {
     runModelCommand(model: SessionModel): Promise<void>;
     runThinkingCommand(level: ThinkingLevel): Promise<void>;
     private addPersistentSystemEntry;
+    private reloadAfterModelChange;
     private saveDefaultModel;
     private saveDefaultThinking;
 }

package/dist/app/commands/command-model-actions.js

@@ -269,6 +269,17 @@ export class ModelCommandActions {
         this.host.render();
         await runtime.session.setModel(model);
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected model ${ref}` });
+        if (runtime.session.isStreaming) {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: "Skipped reload because the agent is still running. Run /reload when idle to refresh model-specific tools.",
+            });
+            this.host.toast.warning("Model changed; reload skipped while the agent is running");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        await this.reloadAfterModelChange(runtime.session, ref);
         this.host.setSessionStatus(runtime.session);
     }
     async runThinkingCommand(level) {
@@ -285,6 +296,27 @@ export class ModelCommandActions {
         appendPixSystemDisplayEntry(session, text);
         this.host.addEntry({ id: createId("system"), kind: "system", text });
     }
+    async reloadAfterModelChange(session, ref) {
+        this.host.setStatus(`reloading resources for ${ref}`);
+        this.host.render();
+        try {
+            await session.reload();
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Reloaded resources after model change to ${ref}`,
+            });
+            this.host.toast.success("Model changed and resources reloaded");
+        }
+        catch (error) {
+            this.host.addEntry({
+                id: createId("error"),
+                kind: "error",
+                text: `Model changed to ${ref}, but reload failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            this.host.toast.error("Model changed, but reload failed");
+        }
+    }
     saveDefaultModel(modelRef) {
         const saved = savePixDefaultModel(modelRef);
         if (!saved)

package/dist/app/commands/command-navigation-actions.js

@@ -50,6 +50,7 @@ export class NavigationCommandActions {
             throw new Error("No user messages to fork from");
         this.host.setStatus("forking session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.fork(entryId);
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
@@ -74,6 +75,7 @@ export class NavigationCommandActions {
         }
         this.host.setStatus("cloning session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.fork(leafId, { position: "at" });
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Clone cancelled." });
@@ -228,6 +230,7 @@ export class NavigationCommandActions {
         const resolvedSessionPath = resolve(runtime.cwd, sessionPath);
         this.host.setStatus("switching session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.switchSession(resolvedSessionPath);
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });

package/dist/app/commands/command-registry.d.ts

@@ -33,6 +33,7 @@ export type CommandRegistryActions = {
     runResumeCommand(): Promise<void>;
     runNewSessionCommand(): Promise<void>;
     runNewTabCommand(): Promise<void>;
+    runDeleteCommand(argumentsText: string): Promise<void>;
     runCompactCommand(customInstructions?: string): Promise<void>;
 };
 export declare function createSlashCommands(actions: CommandRegistryActions, host: CommandControllerHost): readonly SlashCommand[];

package/dist/app/commands/command-registry.js

@@ -247,6 +247,14 @@ export function createSlashCommands(actions, host) {
             keywords: ["tab", "session", "fresh", "new"],
             run: () => actions.runNewTabCommand(),
         },
+        {
+            name: "delete",
+            description: "Delete the current (or specified) session file plus its sidecar DCP state",
+            kind: "builtin",
+            keywords: ["remove", "destroy", "purge", "session", "sidecar", "dcp"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDeleteCommand(argumentsText),
+        },
         {
             name: "compact",
             description: "Manually compact the session context",

package/dist/app/commands/command-session-actions.d.ts

@@ -14,6 +14,8 @@ export declare class SessionCommandActions {
     runUpdateCommand(argumentsText: string): Promise<void>;
     runHotkeysCommand(): Promise<void>;
     runReloadCommand(): Promise<void>;
+    runDeleteCommand(argumentsText: string): Promise<void>;
+    private removeDcpSidecarState;
     runNewSessionCommand(): Promise<void>;
     runCompactCommand(customInstructions?: string): Promise<void>;
     private piPackageRoot;

package/dist/app/commands/command-session-actions.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rm } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
@@ -260,6 +260,7 @@ export class SessionCommandActions {
         this.host.setStatus("reloading");
         this.host.render();
         try {
+            await this.host.awaitCurrentSessionExtensions(runtime);
             await runtime.session.reload();
             this.host.setSessionStatus(runtime.session);
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Reloaded keybindings, extensions, skills, prompts, themes" });
@@ -271,12 +272,86 @@ export class SessionCommandActions {
             this.host.toast.error("Reload failed");
         }
     }
+    async runDeleteCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "delete");
+        if (!runtime)
+            return;
+        const sessionManager = runtime.session.sessionManager;
+        const currentSessionFile = sessionManager.getSessionFile();
+        const currentSessionId = sessionManager.getSessionId();
+        const targetArgument = argumentsText.trim();
+        const isCurrent = !targetArgument;
+        const targetSessionFile = targetArgument ? resolve(runtime.cwd, targetArgument) : currentSessionFile;
+        if (!targetSessionFile) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Nothing to delete: this session is in-memory and not persisted." });
+            this.host.toast.info("Nothing to delete");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        const targetSessionId = parseSessionIdFromFileName(targetSessionFile) ?? currentSessionId;
+        const confirm = await this.host.showMenu([
+            {
+                value: true,
+                label: `Yes, delete ${isCurrent ? "the current session" : basename(targetSessionFile)}`,
+                description: "This permanently removes the session file and any sidecar data. This cannot be undone.",
+                variant: "error",
+            },
+            { value: false, label: "Cancel" },
+        ], { title: "Delete session?", searchable: false, preserveStatus: true });
+        if (confirm !== true) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.setStatus("deleting session");
+        this.host.render();
+        const sidecarRemoved = await this.removeDcpSidecarState(dirname(targetSessionFile), targetSessionId).catch(() => false);
+        await rm(targetSessionFile, { force: true }).catch(() => undefined);
+        const deleteCurrent = isCurrent || targetSessionFile === currentSessionFile;
+        if (deleteCurrent) {
+            await this.host.awaitCurrentSessionExtensions(runtime);
+            const result = await runtime.newSession();
+            if (result.cancelled) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete succeeded, but new session was cancelled." });
+                this.host.setSessionStatus(runtime.session);
+                return;
+            }
+            this.host.resetSessionView();
+            this.host.loadSessionHistory();
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Deleted session ${targetSessionId}. ${sidecarRemoved ? "Sidecar DCP state removed. " : ""}Started a new session. cwd=${runtime.cwd}`,
+            });
+            if (runtime.modelFallbackMessage)
+                this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
+            this.host.setSessionStatus(runtime.session);
+        }
+        else {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Deleted session file ${targetSessionFile}${sidecarRemoved ? " and its sidecar DCP state" : ""}.`,
+            });
+            this.host.setSessionStatus(runtime.session);
+        }
+        this.host.toast.success("Session deleted");
+    }
+    async removeDcpSidecarState(sessionDir, sessionId) {
+        if (!sessionId)
+            return false;
+        const safeName = `${sessionId.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
+        const statePath = join(sessionDir, "dcp-state", safeName);
+        await rm(statePath, { force: true });
+        return true;
+    }
     async runNewSessionCommand() {
         const runtime = getIdleRuntime(this.host, "new");
         if (!runtime)
             return;
         this.host.setStatus("starting new session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.newSession();
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });
@@ -334,3 +409,8 @@ function splitUpdateArguments(argumentsText) {
     const trimmed = argumentsText.trim();
     return trimmed ? trimmed.split(/\s+/u) : [];
 }
+function parseSessionIdFromFileName(sessionFile) {
+    const base = basename(sessionFile).replace(/\.jsonl$/iu, "");
+    const separator = base.indexOf("_");
+    return separator >= 0 ? base.slice(separator + 1) : undefined;
+}

package/dist/app/extensions/extension-actions-controller.d.ts

@@ -1,9 +1,11 @@
 import type { AgentSessionRuntime, ExtensionCommandContextActions, ExtensionError } from "@earendil-works/pi-coding-agent";
+import { type PixLogDetails, type PixLogLevel } from "../logger.js";
 import type { Entry } from "../types.js";
 export type AppExtensionActionsHost = {
     isRunning(): boolean;
     getInput(): string;
     setInput(value: string): void;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     resetSessionView(): void;
     loadSessionHistory(): void;
     afterSessionReplacement(message?: string): void;
@@ -13,9 +15,11 @@ export type AppExtensionActionsHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
 };
+export type ExtensionErrorLogger = (level: PixLogLevel, event: string, details?: PixLogDetails) => void;
 export declare class AppExtensionActionsController {
     private readonly host;
-    constructor(host: AppExtensionActionsHost);
+    private readonly logExtensionError;
+    constructor(host: AppExtensionActionsHost, logExtensionError?: ExtensionErrorLogger);
     createCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
     waitForSessionIdle(runtime: AgentSessionRuntime): Promise<void>;
     handleExtensionError(error: ExtensionError): void;

package/dist/app/extensions/extension-actions-controller.js

@@ -1,19 +1,25 @@
+import { basename } from "node:path";
 import { createId } from "../id.js";
+import { logPixEvent } from "../logger.js";
 export class AppExtensionActionsController {
     host;
-    constructor(host) {
+    logExtensionError;
+    constructor(host, logExtensionError = logPixEvent) {
         this.host = host;
+        this.logExtensionError = logExtensionError;
     }
     createCommandContextActions(runtime) {
         return {
             waitForIdle: () => this.waitForSessionIdle(runtime),
             newSession: async (options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.newSession(options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement("Started a new session.");
                 return result;
             },
             fork: async (entryId, options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.fork(entryId, options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement("Forked to a new session.");
@@ -32,12 +38,14 @@ export class AppExtensionActionsController {
                 return result;
             },
             switchSession: async (sessionPath, options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.switchSession(sessionPath, options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement(`Switched session: ${sessionPath}`);
                 return result;
             },
             reload: async () => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 await runtime.session.reload();
                 this.host.setSessionStatus(runtime.session);
                 this.host.showToast("Reloaded resources", "success");
@@ -51,10 +59,35 @@ export class AppExtensionActionsController {
         }
     }
     handleExtensionError(error) {
+        const sourceText = formatExtensionErrorSource(error.extensionPath);
         const pathText = error.extensionPath ? ` (${error.extensionPath})` : "";
-        this.host.addEntry({ id: createId("error"), kind: "error", text: `Extension ${error.event} failed${pathText}: ${error.error}` });
+        this.logExtensionError("error", "extension:error", extensionErrorLogDetails(error));
+        this.host.addEntry({
+            id: createId("error"),
+            kind: "error",
+            text: `Extension ${error.event} failed${sourceText}${pathText}: ${error.error}`,
+        });
         this.host.showToast(`Extension ${error.event} failed`, "error");
         if (this.host.isRunning())
             this.host.render();
     }
 }
+function formatExtensionErrorSource(extensionPath) {
+    if (!extensionPath)
+        return "";
+    const extensionName = basename(extensionPath);
+    return extensionName && extensionName !== extensionPath ? ` [${extensionName}]` : "";
+}
+function extensionErrorLogDetails(error) {
+    const details = {
+        event: error.event,
+        error: error.error,
+    };
+    if (error.extensionPath) {
+        details.extensionPath = error.extensionPath;
+        details.extensionName = basename(error.extensionPath);
+    }
+    if (error.stack)
+        details.stack = error.stack;
+    return details;
+}

package/dist/app/input/input-controller.d.ts

@@ -46,6 +46,8 @@ export declare class AppInputController {
     private consumeCommandArrowPageMatch;
     private consumeTerminalEditShortcutSequence;
     private consumeIgnoredModifiedKeySequence;
+    private consumeModifiedArrowKeySequence;
+    private consumeEscapeKeySequence;
     private consumeClipboardImagePasteSequence;
     private consumeShiftEnterSequence;
     private consumeTerminalInterruptSequence;

package/dist/app/input/input-controller.js

@@ -1,6 +1,6 @@
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
-import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalKeyArrowDirection, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsEscape, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
 const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
@@ -112,6 +112,16 @@ export class AppInputController {
                 continue;
             if (terminalEditShortcutSequence === "pending")
                 return;
+            const modifiedArrowKeySequence = this.consumeModifiedArrowKeySequence();
+            if (modifiedArrowKeySequence === "consumed")
+                continue;
+            if (modifiedArrowKeySequence === "pending")
+                return;
+            const escapeKeySequence = this.consumeEscapeKeySequence();
+            if (escapeKeySequence === "consumed")
+                continue;
+            if (escapeKeySequence === "pending")
+                return;
             const ignoredModifiedKeySequence = this.consumeIgnoredModifiedKeySequence();
             if (ignoredModifiedKeySequence === "consumed")
                 continue;
@@ -225,7 +235,10 @@ export class AppInputController {
         }
         if (/^\x1b\[(?:8|127);\d*$/.test(this.inputBuffer))
             return "pending";
-        if (this.inputBuffer.startsWith("\x1b[27;") && !this.inputBuffer.includes("~"))
+        // modifyOtherKeys backspace looks like \x1b[27;<mod>;(8|127)~ (two semicolons, no colons).
+        // Kitty key sequences also begin with \x1b[27; (e.g. the ESC release \x1b[27;1:3u), so only
+        // treat the buffer as a pending modifyOtherKeys partial when it matches that exact shape.
+        if (/^\x1b\[27;\d+;\d*$/.test(this.inputBuffer))
             return "pending";
         return "none";
     }
@@ -277,6 +290,41 @@ export class AppInputController {
         this.inputBuffer = this.inputBuffer.slice(result.key.length);
         return "consumed";
     }
+    consumeModifiedArrowKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        const direction = terminalKeyArrowDirection(result.key);
+        if (!direction)
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (terminalKeyShouldIgnore(result.key))
+            return "consumed";
+        if (direction === "up")
+            this.handleArrowUp();
+        else if (direction === "down")
+            this.handleArrowDown();
+        else if (direction === "right")
+            this.handleArrowRight();
+        else
+            this.handleArrowLeft();
+        return "consumed";
+    }
+    consumeEscapeKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsEscape(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            void this.host.handleEscape();
+        return "consumed";
+    }
     consumeClipboardImagePasteSequence() {
         const result = parseTerminalModifiedKeySequence(this.inputBuffer);
         if (result.kind === "pending")

package/dist/app/input/terminal-edit-shortcuts.d.ts

@@ -39,5 +39,7 @@ export declare function parseTerminalInterruptSequence(input: string): {
 export declare function terminalKeyIsShiftEnter(key: ParsedModifiedKey): boolean;
 export declare function terminalKeyIsClipboardImagePaste(key: ParsedModifiedKey): boolean;
 export declare function terminalKeyShouldIgnore(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyIsEscape(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyArrowDirection(key: ParsedModifiedKey): "up" | "down" | "right" | "left" | undefined;
 export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;
 export {};