pi-ui-extend 0.1.15 → 0.1.18

package/apps/desktop-tauri/README.md

@@ -0,0 +1,103 @@
+# Pix Desktop (Tauri)
+
+Tauri-based desktop UI for the Pi coding agent. It is a sibling workspace of the `pix` terminal app and uses the same `@earendil-works/pi-coding-agent` SDK through a Node sidecar.
+
+> **Status — current prototype.** React talks to a Rust Tauri host via `rpc_call` / `rpc_subscribe`. Rust proxies line-delimited SDK-shaped JSON to a custom Node dispatcher. Implemented: workspace picker, persistent sessions, tabbed chat with per-workspace tab restore, expanded tool-call cards, history loading, SDK/pi-tools-suite slash-command discovery with extension argument completions, path/general composer autocomplete, image attachments via paste/drop/file picker, Web Speech voice dictation, captured `!shell` commands, raw `!!` PTY terminal surface, extension UI request dialogs with select search/timeouts, toasts/widgets/status plus session-scoped lifecycle, explicit degraded handling for custom/component extension UI, real pi-tools-suite interactive command smoke coverage, desktop-native `/model`/`/compact`/`/undo`, streaming/abort, and status bar. There is intentionally no sidebar.
+
+## Architecture
+
+```
+React (Vite, port 1420)
+  │ invoke("rpc_call", { cmd }) / invoke("rpc_subscribe", { onEvent })
+  ▼
+Tauri Rust host (src-tauri/)
+  │ JSONL over stdio, SDK flat shape { id?, type, ... }
+  ▼
+Node sidecar (sidecar/src/)
+  │ custom dispatcher + @earendil-works/pi-coding-agent SDK
+  ▼
+AgentSession / SessionManager
+```
+
+The frontend never imports or calls the SDK directly. Rust owns native APIs and sidecar process management; the sidecar owns SDK runtime/session operations.
+
+## Layout
+
+```
+apps/desktop-tauri/
+├── src/                  # React frontend
+│   ├── App.tsx           # workspace picker, topbar, tabs, chat, history transform
+│   ├── App.css           # Tokyo-Night dark theme
+│   └── tools/            # tool-call renderer registry and renderers
+├── sidecar/src/          # Node SDK bridge
+│   ├── main.ts           # create runtime, switch cwd, run dispatcher
+│   ├── dispatcher.ts     # command switch and event subscription rebinding
+│   ├── pix-handlers.ts   # pix:list_sessions
+│   ├── framing.ts        # strict LF JSONL framing
+│   └── protocol.ts       # wire types
+└── src-tauri/src/        # Rust host and sidecar bridge
+```
+
+## Wire protocol
+
+This is **not JSON-RPC 2.0**. The sidecar uses the SDK-style flat JSONL protocol:
+
+- Command: `{ "id": "req-1", "type": "prompt", "message": "hi", "images": [] }`
+- Response: `{ "id": "req-1", "type": "response", "command": "prompt", "success": true, "data": ... }`
+- Event: `{ "type": "agent_start" | "message_update" | "tool_execution_*" | ... }`
+
+Implemented sidecar commands include `prompt`, `abort`, `get_state`, `get_messages`, `get_session_stats`, `get_commands`, `get_command_completions`, `extension_ui_response`, `get_models`, `set_model`, `compact`, `undo_last_turn`, `new_session`, `switch_session`, `set_session_name`, `pix:list_sessions`, and `pix:set_cwd`. The sidecar emits `extension_ui_request` events for extension `ctx.ui.*` calls, and the frontend answers dialog methods with `extension_ui_response`. The Rust host also exposes native `run_shell`, `complete_path`, and `pty_*` commands for the desktop `!cmd` flow, composer path autocomplete, and raw `!!` terminal sessions.
+
+## Setup and run
+
+From the repo root:
+
+```bash
+npm install --ignore-scripts
+npm run desktop:icons
+npm run desktop:dev
+```
+
+On first launch, choose a project folder. Pix Desktop stores the selected workspace in localStorage under `pix-desktop.workspace`, stores open tabs per cwd under `pix-desktop.tabs:<cwd>`, and resumes the saved active tab when possible.
+
+## Verification
+
+```bash
+npm run desktop:check
+```
+
+Equivalent expanded checks:
+
+```bash
+npm --prefix apps/desktop-tauri run build
+npm --prefix apps/desktop-tauri/sidecar run check
+cargo check --manifest-path apps/desktop-tauri/src-tauri/Cargo.toml
+```
+
+## Env overrides
+
+| Variable | Purpose |
+| --- | --- |
+| `PIX_SIDECAR_CMD` | Command to spawn, default `node`. |
+| `PIX_SIDECAR_ARGS` | Whitespace-separated args, overrides default `--import tsx`. |
+| `PIX_SIDECAR_PATH` | Explicit sidecar entry path. |
+| `PIX_SIDECAR_AGENT_DIR` | Pi agent dir for auth/skills/extensions, default `~/.pi/agent`. |
+| `PIX_SIDECAR_SESSION_MODE` | `persistent` by default; use `in-memory` for ephemeral tests. |
+| `RUST_LOG` | Rust tracing filter. |
+
+## Current UX notes
+
+- Tabs are the only session navigation surface; the old sidebar was removed.
+- Open tabs and the active tab are restored per workspace across Tauri restarts.
+- Typing `/` opens a slash-command menu. Desktop built-ins (`/help`, `/new`, `/clear`, `/refresh`, `/abort`) are merged with SDK-discovered extension, prompt-template, and skill commands from `get_commands`; selecting a discovered command sends it through `prompt` with arguments preserved. When an extension command exposes `getArgumentCompletions`, the frontend debounces `get_command_completions` and shows argument suggestions in the same keyboard/click popup.
+- Path/general autocomplete is handled locally through the Rust `complete_path` helper, scoped to the selected workspace. It completes `@path` mentions in normal messages, path-like `!cmd` shell tokens, and generic slash-command arguments when no richer extension/model completion is available.
+- Images can be attached from the composer with the image button, paste, or drag/drop. The frontend previews them locally, sends SDK `ImageContent[]` through the sidecar `prompt` command, and keeps file attachments as text/path mentions for now.
+- Voice dictation is available from the composer mic button when the current WebView exposes `SpeechRecognition`/`webkitSpeechRecognition`; final transcripts are appended to the composer. Unsupported/error states are shown inline. Offline Vosk parity remains future work.
+- Extension commands can request simple UI through the RPC-style `extension_ui_request` surface: `select`, `confirm`, `input`, and `editor` show modal dialogs. Select dialogs include local search, long-list scrolling, option counts, and timeout countdown/self-cancel affordances when an extension passes `dialogOpts.timeout`; `notify` shows toasts; `setWidget` renders scroll-contained text widgets above/below the composer; `setStatus` and working-indicator APIs add status-bar entries; `setHeader`/`setFooter`, component widgets, `custom()`, `setEditorComponent()`, and extension autocomplete providers now have explicit degraded desktop behavior/status instead of silent no-ops; extension widgets/status/dialogs are cleared on session/workspace switch so stale UI does not leak across tabs; `set_editor_text` fills the composer.
+- Real `pi-tools-suite` command smoke checks have exercised `/prompt-commands` (`select`, `notify`, `input` cancelled before mutation) and `/subagent-preset-config` (`select` cancelled) through the desktop sidecar path. Keep `PIX_SIDECAR_SESSION_MODE=in-memory` for these checks, but do not redirect `HOME` unless extension discovery is configured for that home; otherwise user extensions are not loaded and slash commands fall through to normal prompts.
+- Desktop-native interactive built-ins are available for commands that are not prompt-invokable: `/model` opens a model picker and `/model <provider/id>` sets directly; `/compact [instructions]` runs SDK compaction; `/undo` navigates back to the latest user turn and restores returned editor text when available.
+- Typing `!command` runs a short non-interactive shell command in the selected workspace and renders captured stdout/stderr as a shell tool card. Typing `!!command` opens an xterm.js-backed PTY panel in the current workspace for interactive/raw terminal programs; bare `!!` opens the user's shell.
+- Tool-call cards include specialized renderers for shell/file/patch/todo/web/folder operations plus repo-index tools, ast-grep/apply, question prompts, subagent orchestration, context compression, and skill activation.
+- Switching tabs/folders and closing tabs are blocked while an agent run is streaming, because the sidecar has one active SDK session subscription.
+- On session switch or workspace restore, the UI calls `get_messages` and transforms SDK messages into sanitized chat messages, filtering reasoning/image internals and attaching tool results to tool-call cards.
+- Sidecar logs must go to stderr only; stdout is reserved for JSONL protocol records.

package/apps/desktop-tauri/bin/pix-desktop.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * pix-desktop — CLI launcher for the Tauri-based Pix Desktop UI.
+ *
+ * Behaves like the regular `pix` CLI: launch from any project folder and
+ * Pix Desktop treats that folder as the workspace cwd, scoping sessions to
+ * it just like the terminal pix does.
+ *
+ * Usage:
+ *   cd /path/to/project
+ *   pix-desktop
+ *
+ * Environment:
+ *   PIX_DESKTOP_BIN    Path to a specific Tauri binary (overrides discovery).
+ *   PIX_DESKTOP_DEBUG  Set to "1" to log resolved binary/cwd before launch.
+ *
+ * Build the binary first via one of:
+ *   cd apps/desktop-tauri && npm run tauri:dev    # development (with hot reload)
+ *   cd apps/desktop-tauri && npm run tauri:build  # production bundle
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { platform } from "node:os";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const tauriTarget = join(here, "..", "src-tauri", "target");
+
+const exeSuffix = platform() === "win32" ? ".exe" : "";
+const macBundle = join(
+  tauriTarget,
+  "release",
+  "bundle",
+  "macos",
+  "Pix.app",
+  "Contents",
+  "MacOS",
+  "pix-desktop",
+);
+
+// Discovery order: env override → debug → release raw → release macOS bundle.
+const candidates = [
+  join(tauriTarget, "debug", `pix-desktop${exeSuffix}`),
+  join(tauriTarget, "release", `pix-desktop${exeSuffix}`),
+  macBundle,
+];
+
+if (process.env.PIX_DESKTOP_BIN) candidates.unshift(process.env.PIX_DESKTOP_BIN);
+
+const bin = candidates.find((p) => existsSync(p));
+
+if (!bin) {
+  console.error("pix-desktop: Tauri binary not found. Build it first:");
+  console.error("");
+  console.error("  cd apps/desktop-tauri && npm run tauri:dev   # development");
+  console.error("  cd apps/desktop-tauri && npm run tauri:build  # production");
+  console.error("");
+  console.error("Or set PIX_DESKTOP_BIN=/path/to/pix-desktop to point at a custom binary.");
+  process.exit(127);
+}
+
+if (process.env.PIX_DESKTOP_DEBUG) {
+  console.error(`[pix-desktop] binary: ${bin}`);
+  console.error(`[pix-desktop] cwd:    ${process.cwd()}`);
+}
+
+const child = spawn(bin, process.argv.slice(2), {
+  stdio: "inherit",
+  cwd: process.cwd(),
+  env: process.env,
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    // Re-raise the signal in the launcher so wrapping shells see it.
+    try { process.kill(process.pid, signal); } catch { /* ignore */ }
+    process.exit(128 + 15); // SIGTERM-ish
+  }
+  process.exit(code ?? 0);
+});
+
+// Forward common signals to the child so Ctrl-C cleans up the Tauri window.
+for (const sig of ["SIGINT", "SIGTERM"]) {
+  process.on(sig, () => {
+    if (!child.killed) child.kill(sig);
+  });
+}

package/dist/app/app.d.ts

@@ -44,6 +44,7 @@ export declare class PiUiExtendApp {
     private readonly extensionShutdownHandler;
     private runtime;
     private readonly inputEditor;
+    private lastInputEditorContentVersion;
     private readonly requestHistory;
     /** Shortcut: get/set the editor text as a plain string. */
     private get input();
@@ -101,6 +102,7 @@ export declare class PiUiExtendApp {
     private clearToastTimers;
     private render;
     private scheduleRender;
+    private syncScrollAfterInputEditorChange;
     private renderStatusLine;
     private terminalColumns;
     private terminalRows;

package/dist/app/app.js

@@ -110,6 +110,7 @@ export class PiUiExtendApp {
     extensionShutdownHandler = () => { };
     runtime;
     inputEditor = new InputEditor();
+    lastInputEditorContentVersion = this.inputEditor.contentVersion;
     requestHistory;
     /** Shortcut: get/set the editor text as a plain string. */
     get input() { return this.inputEditor.text; }
@@ -126,6 +127,8 @@ export class PiUiExtendApp {
     constructor(options) {
         this.options = options;
         this.theme = THEMES[options.themeName];
+        this.pixConfig = loadPixConfig(this.options.cwd);
+        setAppIconTheme(this.pixConfig.iconTheme.name);
         const app = this;
         this.blinkController = new AppBlinkController({
             render: () => this.render(),
@@ -157,6 +160,7 @@ export class PiUiExtendApp {
         });
         this.tabsController = new AppTabsController({
             options: this.options,
+            maxProjectSessions: this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
             createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options)),
@@ -175,8 +179,8 @@ export class PiUiExtendApp {
             loadSessionHistory: () => this.loadSessionHistory(),
             loadSessionHistoryAsync: (options) => this.loadSessionHistoryAsync(options),
             syncUserSessionEntryMetadata: () => this.workspaceActions.syncUserSessionEntryMetadata(),
-            captureInputState: () => ({ text: this.inputEditor.text, cursor: this.inputEditor.cursor }),
-            restoreInputState: (state) => this.restoreTabInputState(state.text, state.cursor),
+            captureInputState: () => this.inputEditor.draftState,
+            restoreInputState: (state) => this.restoreTabInputState(state),
             closeMenusForTabSwitch: () => this.popupMenus.closeMenusForTabSwitch(),
             captureDeferredUserMessages: () => this.queuedMessages.captureDeferredUserMessages(),
             restoreDeferredUserMessages: (messages) => this.queuedMessages.restoreDeferredUserMessages(messages),
@@ -184,8 +188,6 @@ export class PiUiExtendApp {
             showToast: (message, kind) => this.showToast(message, kind),
             render: () => this.render(),
         });
-        this.pixConfig = loadPixConfig(this.options.cwd);
-        setAppIconTheme(this.pixConfig.iconTheme.name);
         this.terminalBellSoundController = new TerminalBellSoundController();
         this.promptEnhancer = new AppPromptEnhancerController({
             runtime: () => this.runtime,
@@ -224,10 +226,12 @@ export class PiUiExtendApp {
         const popupMenuRenderer = new PopupMenuRenderer({
             theme: this.theme,
             screenStyler: this.screenStyler,
+            modelColors: this.pixConfig.modelColors,
             get entries() { return app.entries; },
             get session() { return app.runtime?.session; },
             get resumeLoading() { return app.resumeLoading; },
             get resumeSessionCount() { return app.resumeSessions.length; },
+            get userMessageJumpLoading() { return app.menuItems.isUserMessageJumpLoading(); },
         });
         this.popupMenus = new AppPopupMenuController({
             get entries() { return app.entries; },
@@ -430,6 +434,7 @@ export class PiUiExtendApp {
         this.commandController = new AppCommandController({
             options: this.options,
             runtime: () => this.runtime,
+            requestHistory: () => this.requestHistory,
             getInput: () => this.input,
             setInput: (value) => this.setInput(value),
             promptEnhancerModelRef: () => this.pixConfig.promptEnhancer.modelRef,
@@ -614,6 +619,7 @@ export class PiUiExtendApp {
             addEntry: (entry) => this.addEntry(entry),
             addSessionAbortedEntry: () => this.sessionEvents.addSessionAbortedEntry(),
             showToast: (message, kind) => this.showToast(message, kind),
+            dismissActiveDialog: () => this.toastController.dismissActiveDialog(),
             stopVoiceInput: () => this.voiceController.stopRecording(),
             isShellCommandRunning: () => this.shellController.isRunning(),
             runChatShellCommand: (command) => this.shellController.run(command),
@@ -814,10 +820,10 @@ export class PiUiExtendApp {
         this.popupMenus.resetInputMenuDismissals();
         this.autocompleteController.dispose();
     }
-    restoreTabInputState(text, cursor) {
+    restoreTabInputState(state) {
         this.requestHistory.resetNavigation();
         this.popupMenus.resetInputMenuDismissals();
-        this.inputEditor.setText(text, cursor);
+        this.inputEditor.setDraftState(state);
         this.autocompleteController.dispose();
     }
     async clearPersistedInputDraft() {
@@ -1007,6 +1013,7 @@ export class PiUiExtendApp {
             this.scheduledRenderTimer = undefined;
         }
         this.autocompleteController.observeInput();
+        this.syncScrollAfterInputEditorChange();
         this.renderController.render();
     }
     scheduleRender() {
@@ -1014,10 +1021,18 @@ export class PiUiExtendApp {
             return;
         this.scheduledRenderTimer = setTimeout(() => {
             this.scheduledRenderTimer = undefined;
+            this.syncScrollAfterInputEditorChange();
             this.renderController.render();
         }, COALESCED_RENDER_DELAY_MS);
         this.scheduledRenderTimer.unref?.();
     }
+    syncScrollAfterInputEditorChange() {
+        const contentVersion = this.inputEditor.contentVersion;
+        if (contentVersion === this.lastInputEditorContentVersion)
+            return;
+        this.lastInputEditorContentVersion = contentVersion;
+        this.scrollController.scrollToBottom();
+    }
     renderStatusLine() {
         this.renderController.renderStatusLine();
     }

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

@@ -54,6 +54,7 @@ export class AppCommandController {
             runCloneCommand: () => this.navigationActions.runCloneCommand(),
             runTreeCommand: (argumentsText) => this.navigationActions.runTreeCommand(argumentsText),
             runJumpCommand: (argumentsText) => this.navigationActions.runJumpCommand(argumentsText),
+            runHistoryCommand: (argumentsText) => this.navigationActions.runHistoryCommand(argumentsText),
             runSearchCommand: (argumentsText) => this.navigationActions.runSearchCommand(argumentsText),
             runUnsupportedBuiltinCommand: (commandName, message) => this.navigationActions.runUnsupportedBuiltinCommand(commandName, message),
             runResumePathCommand: (sessionPath) => this.navigationActions.runResumePathCommand(sessionPath),

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

@@ -1,11 +1,13 @@
 import type { AgentSession, AgentSessionRuntime, SessionInfo } from "@earendil-works/pi-coding-agent";
 import type { SessionSearchResult } from "../session/session-search.js";
+import type { AppRequestHistory } from "../session/request-history.js";
 import type { ActivePopupMenu, AppOptions, Entry, ModelMenuValue, PixMenuItem, PixMenuOptions, PopupMenuPlacement, ScopedSessionModel, SessionModel, ThinkingMenuValue } from "../types.js";
 import type { ToastNotifier } from "../../ui.js";
 export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type CommandControllerHost = {
     readonly options: AppOptions;
     runtime(): AgentSessionRuntime | undefined;
+    requestHistory(): AppRequestHistory;
     getInput(): string;
     setInput(value: string): void;
     promptEnhancerModelRef(): string;

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

@@ -2,6 +2,14 @@ import type { SessionInfo } from "@earendil-works/pi-coding-agent";
 import type { CommandControllerHost } from "./command-host.js";
 import { type ResumeSessionLoaderOptions } from "../session/resume-session-loader.js";
 import type { PopupMenuPlacement } from "../types.js";
+export declare function formatHistoryMenuLabel(text: string): string;
+export declare function historyHighlightRanges(ranges: readonly {
+    start: number;
+    end: number;
+}[], text: string): {
+    start: number;
+    end: number;
+}[];
 export declare class NavigationCommandActions {
     private readonly host;
     private readonly resumeSessionLoader;
@@ -11,6 +19,7 @@ export declare class NavigationCommandActions {
     runCloneCommand(): Promise<void>;
     runTreeCommand(argumentsText: string): Promise<void>;
     runJumpCommand(argumentsText: string): Promise<void>;
+    runHistoryCommand(argumentsText: string): Promise<void>;
     runSearchCommand(argumentsText: string): Promise<void>;
     runUnsupportedBuiltinCommand(commandName: string, message: string): Promise<void>;
     runResumePathCommand(sessionPath: string): Promise<void>;

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

@@ -11,6 +11,24 @@ function nextTick() {
         setImmediate(resolve);
     });
 }
+export function formatHistoryMenuLabel(text) {
+    return sanitizeText(text).replace(/\n/g, " ↵ ");
+}
+export function historyHighlightRanges(ranges, text) {
+    return ranges.map((range) => ({
+        start: historyLabelIndex(range.start, text),
+        end: historyLabelIndex(range.end, text),
+    })).filter((range) => range.end > range.start);
+}
+function historyLabelIndex(index, text) {
+    const before = text.slice(0, Math.max(0, Math.min(index, text.length)));
+    const newlineCount = before.split("\n").length - 1;
+    return before.length + newlineCount * 2;
+}
+function formatHistoryMenuDescription(text) {
+    const lines = sanitizeText(text).split("\n");
+    return lines.length > 1 ? `${lines.length} lines` : undefined;
+}
 export class NavigationCommandActions {
     host;
     resumeSessionLoader;
@@ -98,12 +116,53 @@ export class NavigationCommandActions {
         const runtime = getRuntime(this.host, "jump");
         if (!runtime)
             return;
-        this.host.setStatus("scanning session messages…");
-        this.host.render();
-        await this.host.refreshUserMessageJumpMenuItems();
         this.host.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
         this.host.setDirectPopupMenuQuery(argumentsText.trim());
         this.host.render();
+        try {
+            await this.host.refreshUserMessageJumpMenuItems();
+        }
+        catch (error) {
+            this.host.toast.error(`Could not load jump messages: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.host.render();
+        }
+    }
+    async runHistoryCommand(argumentsText) {
+        const query = argumentsText.trim();
+        const matches = this.host.requestHistory().searchMatches(query, 100);
+        if (matches.length === 0) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: query ? `No command history found for: ${query}` : "Command history is empty." });
+            this.host.toast.info(query ? "No matching command history" : "Command history is empty");
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.render();
+            return;
+        }
+        const selected = await this.host.showMenu(matches.map((match) => {
+            const description = formatHistoryMenuDescription(match.value);
+            return {
+                value: match.value,
+                label: formatHistoryMenuLabel(match.value),
+                labelHighlightRanges: match.matchedText === match.label ? historyHighlightRanges(match.matchedRanges, match.value) : [],
+                ...(description === undefined ? {} : { description }),
+            };
+        }), {
+            title: query ? `Search command history: ${query}` : "Command history",
+            placeholder: "Filter history",
+            emptyText: "No matching command history",
+            searchable: true,
+            minScorePerCharacter: 8,
+            preferKeyboardLayoutMatches: true,
+        });
+        if (!selected) {
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            return;
+        }
+        this.host.setInput(selected);
+        this.host.toast.info("Restored command from history");
+        this.host.setSessionStatus(this.host.runtime()?.session);
+        this.host.render();
     }
     async runSearchCommand(argumentsText) {
         const runtime = getIdleRuntime(this.host, "search");

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

@@ -25,6 +25,7 @@ export type CommandRegistryActions = {
     runCloneCommand(): Promise<void>;
     runTreeCommand(argumentsText: string): Promise<void>;
     runJumpCommand(argumentsText: string): Promise<void>;
+    runHistoryCommand(argumentsText: string): Promise<void>;
     runSearchCommand(argumentsText: string): Promise<void>;
     runUnsupportedBuiltinCommand(commandName: string, message: string): Promise<void>;
     runReloadCommand(): Promise<void>;

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

@@ -185,6 +185,14 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runJumpCommand(argumentsText),
         },
+        {
+            name: "history",
+            description: "Search command history and restore a match",
+            kind: "builtin",
+            keywords: ["command", "request", "prompt", "find", "recent"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runHistoryCommand(argumentsText),
+        },
         {
             name: "search",
             description: "Search sessions and open a match in a new tab",

package/dist/app/constants.d.ts

@@ -42,7 +42,6 @@ export declare const GIT_BRANCH_CACHE_MS = 30000;
 export declare const TODO_TOOL_NAME = "todo";
 export declare const TODO_ACTIONS: readonly ["create", "update", "batch_create", "batch_update", "list", "get", "delete", "clear", "export", "import"];
 export declare const TODO_STATUSES: readonly ["pending", "in_progress", "deferred", "completed", "deleted"];
-export declare const TODO_PRIORITIES: readonly ["low", "medium", "high", "urgent"];
 export declare const SUBAGENT_STATUSES: readonly ["planned", "running", "retrying", "done", "failed", "stopped"];
 export declare const SUBAGENT_ACTIVE_STATUSES: readonly ["planned", "running", "retrying"];
 export declare const SUBAGENT_TERMINAL_STATUSES: readonly ["done", "failed", "stopped"];

package/dist/app/constants.js

@@ -90,7 +90,6 @@ export const TODO_ACTIONS = [
     "import",
 ];
 export const TODO_STATUSES = ["pending", "in_progress", "deferred", "completed", "deleted"];
-export const TODO_PRIORITIES = ["low", "medium", "high", "urgent"];
 export const SUBAGENT_STATUSES = ["planned", "running", "retrying", "done", "failed", "stopped"];
 export const SUBAGENT_ACTIVE_STATUSES = ["planned", "running", "retrying"];
 export const SUBAGENT_TERMINAL_STATUSES = ["done", "failed", "stopped"];

package/dist/app/icons.d.ts

@@ -12,6 +12,7 @@ declare const NERD_FONT_ICONS: {
     readonly deleted: "󰅙";
     readonly deferred: "󰍷";
     readonly info: "󰋼";
+    readonly lightbulb: "󰌵";
     readonly microphone: "󰍬";
     readonly plus: "󰐕";
     readonly pause: "󰏤";

package/dist/app/icons.js

@@ -18,6 +18,7 @@ const NERD_FONT_ICONS = {
     deleted: "\u{f0159}",
     deferred: "\u{f0377}",
     info: "\u{f02fc}",
+    lightbulb: "\u{f0335}",
     microphone: "\u{f036c}",
     plus: "\u{f0415}",
     pause: "\u{f03e4}",
@@ -44,6 +45,7 @@ const FALLBACK_ICONS = {
     deleted: "×",
     deferred: "↷",
     info: "i",
+    lightbulb: "💡",
     microphone: "m",
     plus: "+",
     pause: "⏸",

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

@@ -19,6 +19,7 @@ export type AppInputActionControllerHost = {
     addEntry(entry: Entry): void;
     addSessionAbortedEntry(): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    dismissActiveDialog?(): boolean;
     stopVoiceInput(): Promise<void>;
     isShellCommandRunning(): boolean;
     runChatShellCommand(command: string): Promise<InteractiveShellCommandResult>;

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

@@ -80,10 +80,11 @@ export class AppInputActionController {
         }
     }
     closeActiveGlobalUi() {
-        if (!this.popupMenus.syncActivePopupMenu())
-            return false;
-        this.popupMenus.cancelActivePopupMenu();
-        return true;
+        if (this.popupMenus.syncActivePopupMenu()) {
+            this.popupMenus.cancelActivePopupMenu();
+            return true;
+        }
+        return this.host.dismissActiveDialog?.() ?? false;
     }
     async abortStreamingSession(runtime, options) {
         const session = runtime.session;

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

@@ -37,6 +37,7 @@ export declare class AppInputController {
     handleChunk(chunk: Buffer): void;
     private consumeSharedEditorShiftEnter;
     private drainInputBuffer;
+    private consumeBracketedPastePayload;
     private getEscapeSequences;
     private isPendingEscapeSequence;
     private consumeEscapeSequence;

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

@@ -42,6 +42,8 @@ export class AppInputController {
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {
+            if (this.consumeBracketedPastePayload())
+                continue;
             const mouseMatch = /^\x1b\[<(\d+);(-?\d+);(-?\d+)([mM])/.exec(this.inputBuffer);
             if (mouseMatch) {
                 this.inputBuffer = this.inputBuffer.slice(mouseMatch[0].length);
@@ -85,6 +87,23 @@ export class AppInputController {
                 this.handleChar(char);
         }
     }
+    consumeBracketedPastePayload() {
+        if (!this.host.inputEditor.isInBracketedPaste)
+            return false;
+        const endSequence = "\x1b[201~";
+        const endIndex = this.inputBuffer.indexOf(endSequence);
+        if (endIndex === 0)
+            return false;
+        const payloadEnd = endIndex === -1
+            ? safeBracketedPastePayloadLength(this.inputBuffer, endSequence)
+            : endIndex;
+        if (payloadEnd === 0)
+            return false;
+        const payload = this.inputBuffer.slice(0, payloadEnd);
+        this.inputBuffer = this.inputBuffer.slice(payloadEnd);
+        this.pasteHandler.appendBracketedPasteText(normalizeBracketedPastePayload(payload));
+        return true;
+    }
     getEscapeSequences() {
         return [
             ["\x1b[13;2u", () => this.insertInputNewline()],
@@ -425,3 +444,13 @@ export class AppInputController {
         return this.host.isShiftPressed?.() ?? isNativeShiftPressed();
     }
 }
+function normalizeBracketedPastePayload(payload) {
+    return payload.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function safeBracketedPastePayloadLength(buffer, endSequence) {
+    for (let length = Math.min(buffer.length, endSequence.length - 1); length > 0; length--) {
+        if (endSequence.startsWith(buffer.slice(buffer.length - length)))
+            return buffer.length - length;
+    }
+    return buffer.length;
+}

package/dist/app/input/input-paste-handler.d.ts

@@ -7,7 +7,7 @@ export type InputPasteHost = {
 };
 export declare class InputPasteHandler {
     private readonly host;
-    private pasteBuffer;
+    private pasteBufferParts;
     private readonly recentPasteFingerprints;
     private suppressImagePathPasteUntil;
     constructor(host: InputPasteHost);

package/dist/app/input/input-paste-handler.js

@@ -7,7 +7,7 @@ import { normalizePastedTextForDuplicateKey } from "../rendering/render-text.js"
 const PASTE_FINGERPRINT_PREFIX_CHARS = 64 * 1024;
 export class InputPasteHandler {
     host;
-    pasteBuffer = "";
+    pasteBufferParts = [];
     recentPasteFingerprints = new Map();
     suppressImagePathPasteUntil = 0;
     constructor(host) {
@@ -31,15 +31,16 @@ export class InputPasteHandler {
     }
     beginBracketedPaste() {
         this.host.inputEditor.beginBracketedPaste();
-        this.pasteBuffer = "";
+        this.pasteBufferParts = [];
     }
     appendBracketedPasteText(text) {
-        this.pasteBuffer += text;
+        if (text)
+            this.pasteBufferParts.push(text);
     }
     endBracketedPaste() {
         this.host.inputEditor.endBracketedPaste();
-        const text = this.pasteBuffer;
-        this.pasteBuffer = "";
+        const text = this.pasteBufferParts.join("");
+        this.pasteBufferParts = [];
         this.handlePasteEnd(text);
     }
     async handleClipboardImagePaste() {