pi-ui-extend 0.1.18 → 0.1.20

package/external/pi-tools-suite/src/lib/lsp.ts

@@ -36,11 +36,8 @@ export async function appendLspDiagnosticsToMutationResult<T extends LspEnrichab
     if (files.length === 0) return options.result;
 
     const manager = getGlobalLspManager();
-    const summaries: string[] = [];
-    for (const file of files) {
-      const summary = await manager.updateDiagnosticsForFile(options.ctx, file);
-      if (summary.trim()) summaries.push(summary);
-    }
+    const summaries = (await Promise.all(files.map((file) => manager.updateDiagnosticsForFile(options.ctx, file))))
+      .filter((summary) => summary.trim());
 
     const summary = summaries.join("\n\n");
     if (!summary.trim()) return options.result;

package/external/pi-tools-suite/src/lsp/_shared/config.ts

@@ -76,6 +76,8 @@ function parseLspItems(parsed: unknown): LspServerConfig[] {
       languageIdByExtension: cleanStringRecord(object.languageIdByExtension),
       startupTimeoutMs: cleanNumber(object.startupTimeoutMs),
       diagnosticsWaitMs: cleanNumber(object.diagnosticsWaitMs),
+      pullDiagnostics: cleanBoolean(object.pullDiagnostics),
+      waitForPublishDiagnostics: cleanBoolean(object.waitForPublishDiagnostics),
       initializationOptions: object.initializationOptions,
       settings: object.settings,
     });

package/external/pi-tools-suite/src/lsp/_shared/types.ts

@@ -30,6 +30,8 @@ export interface LspServerConfig extends MatchableConfig {
   languageIdByExtension?: Record<string, string>;
   startupTimeoutMs?: number;
   diagnosticsWaitMs?: number;
+  pullDiagnostics?: boolean;
+  waitForPublishDiagnostics?: boolean;
   initializationOptions?: unknown;
   settings?: unknown;
 }

package/external/pi-tools-suite/src/lsp/manager.ts

@@ -149,16 +149,22 @@ export class LspManager {
         }
 
         let pullDiagnosticsError: string | undefined;
-        try {
-          const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
-          if (pulledDiagnostics !== undefined) {
-            const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
-            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
-            lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
-            continue;
+        if (match.server.pullDiagnostics !== false) {
+          try {
+            const pulledDiagnostics = await client.pullDiagnostics(file, diagnosticsWaitMs, ctx.signal);
+            if (pulledDiagnostics !== undefined) {
+              const diagnostics = diagnosticsWithLocalFallback(match.server.id, file, text, pulledDiagnostics);
+              this.diagnostics.set(match.server.id, match.root, filePathToUri(file), diagnostics, doc.version);
+              lines.push(formatLspDiagnostics(match.server.id, file, diagnostics, match.root));
+              continue;
+            }
+          } catch (error) {
+            pullDiagnosticsError = (error as Error).message;
           }
-        } catch (error) {
-          pullDiagnosticsError = (error as Error).message;
+        }
+
+        if (match.server.waitForPublishDiagnostics === false || diagnosticsWaitMs <= 0) {
+          continue;
         }
 
         const entry = await this.diagnostics.waitForFile(

package/external/pi-tools-suite/src/telegram-mirror/ipc.ts

@@ -237,6 +237,7 @@ export class IpcSocket {
 		this.closed = true;
 		this.clearTimers();
 		for (const pending of this.pendingRequests.values()) {
+			clearTimeout(pending.timer);
 			pending.reject(new Error("socket closed"));
 		}
 		this.pendingRequests.clear();

package/external/pi-tools-suite/src/todo/index.ts

@@ -4,12 +4,15 @@ import { autoClearCompletedTodos } from "./state/auto-clear.js";
 import { loadPersistedPlan, syncPersistedPlan } from "./state/persistence.js";
 import { replayFromBranch } from "./state/replay.js";
 import { ACTIVE_STATUSES, isTaskBlocked, selectVisibleTasks } from "./state/selectors.js";
+import { applyTaskMutation } from "./state/state-reducer.js";
 import { getState, replaceState } from "./state/store.js";
 import { DEFAULT_PROMPT_GUIDELINES, DEFAULT_PROMPT_SNIPPET, publishTodoState, registerTodosCommand, registerTodoTool } from "./todo.js";
-import type { TaskMutationParams } from "./tool/types.js";
+import type { Task, TaskMutationParams } from "./tool/types.js";
+
+type AgentMessageLike = { role?: unknown; stopReason?: unknown; content?: unknown };
 
 const TODO_NUDGE_LIMIT = 8;
-const TODO_NUDGE_INITIAL_DELAY_MS = 5_000;
+const TODO_NUDGE_INITIAL_DELAY_MS = 0;
 const TODO_NUDGE_IDLE_RETRY_DELAY_MS = 100;
 const TODO_NUDGE_MAX_IDLE_ATTEMPTS = 40;
 const ASK_USER_TOOL_NAMES = new Set(["ask_user", "ask_user_question", "question"]);
@@ -119,6 +122,7 @@ export default function (pi: ExtensionAPI) {
 	let nudgeTimer: ReturnType<typeof setTimeout> | undefined;
 	const pendingAskUserToolCallIds = new Set<string>();
 	let suppressNextNudgeForThinkingSwitch = false;
+	let inProgressAtAgentStart = new Set<number>();
 
 	function registerTodoToolWithCurrentPrompt(): void {
 		const thinkingPrompt = todoThinkingEnabled ? buildThinkingPromptParts(currentModel) : {};
@@ -193,6 +197,60 @@ export default function (pi: ExtensionAPI) {
 		setter.call(pi, level);
 	}
 
+	function isCompletedAssistantReply(message: AgentMessageLike | undefined): boolean {
+		if (message?.role !== "assistant") return false;
+		if (message.stopReason === "aborted" || message.stopReason === "error" || message.stopReason === "length") return false;
+		if (!Array.isArray(message.content)) return false;
+		return message.content.some((block) => typeof (block as { type?: unknown }).type === "string");
+	}
+
+	function hasCompletedAssistantReply(messages: readonly unknown[] | undefined): boolean {
+		if (!Array.isArray(messages)) return false;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const message = messages[i] as AgentMessageLike | undefined;
+			if (message?.role !== "assistant") continue;
+			return isCompletedAssistantReply(message);
+		}
+		return false;
+	}
+
+	function findOptimisticallyCompletableTask(tasks: readonly Task[]): Task | undefined {
+		const visible = tasks.filter((task) => task.status !== "deleted");
+		const byId = new Map(visible.map((task) => [task.id, task]));
+		const unfinished = visible.filter((task) => ACTIVE_STATUSES.has(task.status) && !isTaskBlocked(task, byId));
+		if (unfinished.length !== 1) return undefined;
+		const [task] = unfinished;
+		if (task.status !== "in_progress") return undefined;
+		if (inProgressAtAgentStart.has(task.id)) return undefined;
+		return task;
+	}
+
+	function applyInternalTodoMutation(action: "update", params: TaskMutationParams, ctx: ExtensionContext): boolean {
+		const result = applyTaskMutation(getState(), action, params);
+		if (result.op.kind === "error") {
+			console.warn(`rpiv-todo: failed internal ${action} mutation — ${result.op.message}`);
+			return false;
+		}
+		const autoClear = autoClearCompletedTodos(result.state);
+		replaceState(autoClear.state);
+		publishTodoState(pi as any, ctx, action, params as Record<string, unknown>);
+		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(autoClear.state, { action, params });
+		try {
+			const sync = syncPersistedPlan(ctx.cwd, autoClear.state);
+			if (sync?.completed) console.log(`rpiv-todo: completed persisted plan and removed ${sync.path}`);
+		} catch (err) {
+			console.warn(`rpiv-todo: failed to sync persisted plan — ${(err as Error).message}`);
+		}
+		return true;
+	}
+
+	function maybeRecoverCompletedCurrentTask(messages: readonly unknown[] | undefined, ctx: ExtensionContext): boolean {
+		if (!hasCompletedAssistantReply(messages)) return false;
+		const task = findOptimisticallyCompletableTask(getState().tasks);
+		if (!task) return false;
+		return applyInternalTodoMutation("update", { action: "update", id: task.id, status: "completed" }, ctx);
+	}
+
 	function clearNudgeTimer(): void {
 		if (!nudgeTimer) return;
 		clearTimeout(nudgeTimer);
@@ -288,16 +346,35 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("agent_start", async () => {
 		pendingAskUserToolCallIds.clear();
+		inProgressAtAgentStart = new Set(selectVisibleTasks(getState()).filter((task) => task.status === "in_progress").map((task) => task.id));
 	});
 
-	pi.on("agent_end", async (_event, ctx) => {
+	pi.on("message_end", async (event, ctx) => {
+		if (!isCompletedAssistantReply((event as { message?: AgentMessageLike } | undefined)?.message)) return;
+		if (maybeRecoverCompletedCurrentTask([(event as { message?: AgentMessageLike }).message], ctx)) {
+			lastNudgedSignature = undefined;
+			clearNudgeTimer();
+		}
+	});
+
+	pi.on("agent_end", async (event, ctx) => {
+		const completedAssistantReply = hasCompletedAssistantReply((event as { messages?: readonly unknown[] } | undefined)?.messages);
+
 		if (suppressNextNudgeForThinkingSwitch) {
 			suppressNextNudgeForThinkingSwitch = false;
+			if (!completedAssistantReply) {
+				clearNudgeTimer();
+				return;
+			}
+		}
+
+		if (pendingAskUserToolCallIds.size > 0) {
 			clearNudgeTimer();
 			return;
 		}
 
-		if (pendingAskUserToolCallIds.size > 0) {
+		if (completedAssistantReply && maybeRecoverCompletedCurrentTask((event as { messages?: readonly unknown[] } | undefined)?.messages, ctx)) {
+			lastNudgedSignature = undefined;
 			clearNudgeTimer();
 			return;
 		}

package/external/pi-tools-suite/src/todo/tool/response-envelope.ts

@@ -165,5 +165,10 @@ function appendWorkflowReminder(text: string, op: Op, state: TaskState): string
 			"Reminder: pending todos exist but none is in_progress. Before starting work, call todo update on exactly one task with status in_progress and activeForm.",
 		);
 	}
+	if (hasInProgress) {
+		lines.push(
+			"Reminder: before you stop, update any finished todo items to completed. Treat the final user-facing report step like any other todo: once it is done, mark it completed immediately.",
+		);
+	}
 	return lines.join("\n\n");
 }

package/external/pi-tools-suite/src/tool-descriptions.ts

@@ -77,7 +77,7 @@ export function asyncSubagentToolDescriptions(options: ToolDescriptionSetOptions
 				repoDiscovery
 					? "Use for broad independent tracks, review axes, or hypotheses even though repo_* tools are available."
 					: "Use first for broad codebase discovery split into tracks, review axes, or incident-triage hypotheses when repo_* tools are unavailable.",
-				"Use action=spawn/status/wait/result/stop/cleanup with the matching options; spawned runs are registered under project .pi/subagents while the main session is alive so status/wait/stop can omit runDir for the latest run and result can resolve runDir by agentId.",
+				"Use action=spawn/status/wait/result/stop/cleanup with the matching options; spawned runs are registered under project .pi/subagents while the main session is alive so status/wait/stop can omit runDir for the latest run and result can resolve runDir by agentId. The parent session receives a follow-up system/custom message for each background agent when it finishes or fails, so the parent can stop after spawning instead of polling for completion.",
 				"Collect compact results only when the parent task needs them.",
 				"Spawned agents run in isolated background pi processes with extensions disabled to prevent recursive sub-agent spawning.",
 				"Each agent has a wall-clock watchdog timeout (default 30 minutes); spawn timeoutSeconds or task timeoutSeconds can shorten it for tests or bounded probes.",
@@ -110,7 +110,7 @@ export function asyncSubagentToolDescriptions(options: ToolDescriptionSetOptions
 				"For synthetic tests or intentionally bounded probes, pass timeoutSeconds slightly above the expected runtime so hung sub-agents are stopped automatically.",
 				"For subagents action='spawn', default to leaving subagentType unset and let the lightweight router choose from configured role descriptions. Do not choose a role just because a built-in example seems to fit; the router has the current user config and presets. Set subagentType explicitly only when the user named the role, image inspection requires vision, tests need deterministic routing, or there is another concrete technical reason to bypass the router.",
 				"Use subagentType='vision' with imagePaths and optional focus when a text-only/blind parent model needs a visual description of screenshots, UI state, diagrams, or other images.",
-				"If the user asks to start, run, launch, or test parallel sub-agents, call action='spawn' and then stop; do not immediately call action='wait'.",
+				"If the user asks to start, run, launch, or test parallel sub-agents, call action='spawn' and then stop; completion/failure notifications will wake the parent so do not immediately call action='status' or action='wait' just to see whether agents finished.",
 				"Use action='status' for a non-blocking progress check or to recover after reload/crash.",
 				"After spawn, project-local .pi/subagents/registry.json records latest runDir and agentId mappings until normal main-session shutdown; if runDir is missing after compaction/reload, call status without runDir or result with agentId instead of failing solely because runDir was lost.",
 				"Use action='wait' only when the user asks to wait/collect now, or your next parent step depends on completion.",
@@ -253,14 +253,14 @@ export const TODO_TOOL_DESCRIPTION: ToolDescription = {
 	promptSnippet: "Track/sync non-trivial multi-step work; include final report item; resync when requirements change; keep one task in_progress",
 	promptGuidelines: [
 		"Use `todo` for complex work with 3+ steps, explicit user task lists, or new non-trivial requirements. Skip single trivial tasks and purely conversational requests.",
-		"For any multi-step implementation/debugging plan, include a final todo item in the initial create/batch_create plan for the user-facing final report. Give that final-report todo explicit description/acceptance criteria covering changed files/behavior, verification commands/results, remaining manual actions, and never substitute a compression/housekeeping note for the final report.",
+		"For any multi-step implementation/debugging plan, include a final todo item in the initial create/batch_create plan for the user-facing final report. Treat it like any other todo item: as soon as that step is finished, mark it completed immediately. Give it explicit description/acceptance criteria covering changed files/behavior, verification commands/results, remaining manual actions, and never substitute a compression/housekeeping note for the final report.",
 		"When the user adds, removes, cancels, reprioritizes, or changes the goal, scope, requirements, constraints, or chosen approach, use `todo` before continuing to synchronize the plan: update still-relevant tasks, defer or delete obsolete tasks, add new required tasks, and adjust dependencies/order.",
 		"When your own investigation or verification discovers new facts that make the current todo plan stale, incomplete, impossible, unsafe, or no longer the best approach, use `todo` to revise the plan immediately instead of following outdated tasks.",
 		"Update todos as part of the workflow, not as end-of-task cleanup: whenever you start, finish, block, split, abandon, or materially change a step, call `todo` immediately before continuing.",
 		"Before any non-trivial read/edit/test/tool work on a planned task, mark exactly one task in_progress with activeForm (present-continuous label); do this immediately after creating a plan if no task is active. Mark it completed immediately after the required verification, never in batches.",
 		"If implementation is partial, tests fail, or a blocker remains, keep the task in_progress and add/update a blocker task instead of completing it.",
 		"Never use `clear`, `delete`, or batch deletion to hide unfinished, stale, or forgotten todos. Defer obsolete items or update them with the reason; only delete when the user explicitly asks or the item was created by mistake.",
-		"Before giving a final response for work that used todos, ensure every visible todo is completed, deferred, or intentionally still in_progress with a blocker/explanation.",
+		"Before giving a final response for work that used todos, ensure every visible todo is completed, deferred, or intentionally still in_progress with a blocker/explanation. Do not leave any just-finished todo item in_progress after you stop.",
 		"Keep subjects short and imperative; put details in description only when needed. Use parentId for large plans; use blockedBy on create and addBlockedBy/removeBlockedBy on update for dependencies.",
 		"Use batch_create/batch_update for large explicit plans, but still keep exactly one visible task in_progress unless the user asks otherwise.",
 		"When starting a new plan that supersedes existing unfinished todos, use batch_create with replace:true instead of appending; only omit replace when intentionally extending the current plan.",

package/package.json

@@ -1,15 +1,10 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "private": false,
   "type": "module",
-  "workspaces": [
-    "apps/desktop-tauri",
-    "apps/desktop-tauri/sidecar"
-  ],
   "bin": {
-    "pix": "./bin/pix.mjs",
-    "pix-desktop": "./apps/desktop-tauri/bin/pix-desktop.mjs"
+    "pix": "./bin/pix.mjs"
   },
   "exports": {
     ".": {
@@ -63,13 +58,7 @@
     "generate-schemas": "tsx scripts/generate-schemas.ts",
     "generate-schemas:check": "tsx scripts/generate-schemas.ts --check",
     "generate-schemas:watch": "tsx watch scripts/generate-schemas.ts",
-    "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas",
-    "desktop:install": "npm --prefix apps/desktop-tauri install",
-    "desktop:dev": "npm --prefix apps/desktop-tauri run tauri:dev",
-    "desktop:build": "npm --prefix apps/desktop-tauri run tauri:build",
-    "desktop:check": "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",
-    "desktop:icons": "npm --prefix apps/desktop-tauri run icons",
-    "desktop": "node apps/desktop-tauri/bin/pix-desktop.mjs"
+    "prepublishOnly": "npm run check && npm run build:pix && npm run generate-schemas"
   },
   "dependencies": {
     "@earendil-works/pi-tui": "0.77.0",

package/schemas/pi-tools-suite.json

@@ -20,6 +20,17 @@
       "type": "boolean",
       "description": "Enable per-todo thinking levels and automatic thinking switch/restore when tasks become in-progress/completed."
     },
+    "lookupModel": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "null"
+        }
+      ],
+      "description": "Vision-capable provider/model used by GLM's lookup tool; unset or null disables lookup."
+    },
     "terminalBell": {
       "type": "object",
       "properties": {
@@ -862,6 +873,14 @@
                 "description": "Wait time for diagnostics after file change.",
                 "minimum": 0
               },
+              "pullDiagnostics": {
+                "type": "boolean",
+                "description": "When false, skip textDocument/diagnostic pull requests and rely on published diagnostics. Useful for servers where pull diagnostics is slow or incomplete."
+              },
+              "waitForPublishDiagnostics": {
+                "type": "boolean",
+                "description": "When false, do not wait for a fresh textDocument/publishDiagnostics notification after file change. diagnosticsWaitMs still bounds the wait when enabled."
+              },
               "initializationOptions": {
                 "description": "LSP initialization options passed to the server."
               },

package/apps/desktop-tauri/README.md

@@ -1,103 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-#!/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);
-  });
-}