pi-ui-extend 0.1.17 → 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/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() {

package/dist/app/model/model-usage-status.js

@@ -815,9 +815,9 @@ function formatDurationShort(resetAt, now) {
     const hours = Math.floor((totalMinutes % 1440) / 60);
     const minutes = totalMinutes % 60;
     if (days > 0)
-        return `${days}d ${hours}h`;
+        return `${days}d${hours}h`;
     if (hours > 0)
-        return `${hours}h ${minutes}m`;
+        return `${hours}h${minutes}m`;
     return `${minutes}m`;
 }
 function maskCredential(value) {
@@ -826,29 +826,6 @@ function maskCredential(value) {
         return visible ? "****" : "unknown";
     return `${visible.slice(0, 4)}****${visible.slice(-4)}`;
 }
-function formatUsageWindow(prefix, window, now) {
-    const resetLabel = prefix === "H" ? formatResetTime(window.resetAt, now) : formatGlobalResetLabel(window.resetAt, now);
-    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${resetLabel}`;
-}
-function formatGlobalResetLabel(resetAt, now) {
-    if (resetAt <= now)
-        return "reset";
-    return resetAt - now <= DAY_SECONDS * 1000 ? formatResetTime(resetAt, now) : formatResetDate(resetAt, now);
-}
-function formatResetTime(resetAt, now) {
-    if (resetAt <= now)
-        return "reset";
-    return new Date(resetAt).toLocaleTimeString("ru-RU", {
-        hour: "2-digit",
-        minute: "2-digit",
-        hourCycle: "h23",
-    });
-}
-function formatResetDate(resetAt, now) {
-    if (resetAt <= now)
-        return "reset";
-    return new Date(resetAt).toLocaleDateString("ru-RU", {
-        day: "2-digit",
-        month: "2-digit",
-    });
+function formatUsageWindow(_prefix, window, now) {
+    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatDurationShort(window.resetAt, now)}`;
 }

package/dist/app/rendering/render-controller.js

@@ -293,15 +293,19 @@ export class AppRenderController {
         this.deps.mouseController.statusThinkingTarget = this.deps.statusLineRenderer.thinkingTarget(statusLayout.text, statusRow);
         this.deps.mouseController.statusContextTarget = this.deps.statusLineRenderer.contextTarget(statusLayout.text, statusRow, statusLayout);
         this.deps.mouseController.statusModelUsageTarget = this.deps.statusLineRenderer.modelUsageTarget(statusLayout.text, statusRow, statusLayout);
-        this.deps.mouseController.statusDraftQueueTarget = widgetLayout ? this.deps.statusLineRenderer.draftQueueTarget?.(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusUserJumpTarget = widgetLayout ? this.deps.statusLineRenderer.userJumpTarget?.(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusThinkingExpandTarget = widgetLayout ? this.deps.statusLineRenderer.thinkingExpandTarget?.(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusCompactToolsTarget = widgetLayout ? this.deps.statusLineRenderer.compactToolsTarget?.(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusTerminalBellSoundTarget = widgetLayout ? this.deps.statusLineRenderer.terminalBellSoundTarget?.(widgetLayout, widgetRow) : undefined;
+        if (widgetLayout) {
+            this.deps.mouseController.statusDraftQueueTarget = this.deps.statusLineRenderer.draftQueueTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusUserJumpTarget = this.deps.statusLineRenderer.userJumpTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusThinkingExpandTarget = this.deps.statusLineRenderer.thinkingExpandTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusCompactToolsTarget = this.deps.statusLineRenderer.compactToolsTarget?.(widgetLayout, widgetRow);
+            this.deps.mouseController.statusTerminalBellSoundTarget = this.deps.statusLineRenderer.terminalBellSoundTarget?.(widgetLayout, widgetRow);
+        }
         this.deps.mouseController.statusSessionTarget = this.deps.statusLineRenderer.sessionTarget(statusLayout.text, statusRow, statusLayout.sessionLabel, statusLayout.workspaceLabel);
-        this.deps.mouseController.statusPromptEnhancerTarget = widgetLayout ? this.deps.statusLineRenderer.promptEnhancerTarget(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusVoiceMicTarget = widgetLayout ? this.deps.statusLineRenderer.voiceMicTarget(widgetLayout, widgetRow) : undefined;
-        this.deps.mouseController.statusVoiceLanguageTarget = widgetLayout ? this.deps.statusLineRenderer.voiceLanguageTarget(widgetLayout, widgetRow) : undefined;
+        if (widgetLayout) {
+            this.deps.mouseController.statusPromptEnhancerTarget = this.deps.statusLineRenderer.promptEnhancerTarget(widgetLayout, widgetRow);
+            this.deps.mouseController.statusVoiceMicTarget = this.deps.statusLineRenderer.voiceMicTarget(widgetLayout, widgetRow);
+            this.deps.mouseController.statusVoiceLanguageTarget = this.deps.statusLineRenderer.voiceLanguageTarget(widgetLayout, widgetRow);
+        }
         this.deps.mouseController.renderedRowTexts.set(statusRow, statusLayout.text);
     }
     renderVoiceProgressOverlay(message, width, rows) {

package/dist/app/screen/mouse-controller.d.ts

@@ -154,6 +154,7 @@ export declare class AppMouseController {
     private handleStatusContextClick;
     private handleStatusModelUsageClick;
     private handleStatusUserJumpClick;
+    private handleInputBorderStatusClick;
     private openStatusUserJumpMenu;
     private handleStatusDraftQueueClick;
     private handleStatusThinkingExpandClick;

package/dist/app/screen/mouse-controller.js

@@ -57,6 +57,8 @@ export class AppMouseController {
         if (this.handleInputScrollBar(event))
             return;
         this.showClickFlashOnPress(event);
+        if (event.button === 0 && !event.released && this.handleInputBorderStatusClick(event))
+            return;
         if (this.handleMouseSelection(event))
             return;
         if (this.withClickFlash(event, () => this.handleImageClick(event)))
@@ -73,24 +75,8 @@ export class AppMouseController {
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusModelUsageClick(event)))
             return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusDraftQueueClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusUserJumpClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusThinkingExpandClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusCompactToolsClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusTerminalBellSoundClick(event)))
-            return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusSessionClick(event)))
             return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusPromptEnhancerClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusVoiceMicClick(event)))
-            return;
-        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusVoiceLanguageClick(event)))
-            return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleExtensionInputClick(event)))
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleInputClick(event)))
@@ -290,6 +276,7 @@ export class AppMouseController {
             this.statusUserJumpTarget,
             this.statusThinkingExpandTarget,
             this.statusCompactToolsTarget,
+            this.statusTerminalBellSoundTarget,
             this.statusSessionTarget,
             this.statusPromptEnhancerTarget,
             this.statusVoiceMicTarget,
@@ -476,6 +463,16 @@ export class AppMouseController {
         void this.openStatusUserJumpMenu();
         return true;
     }
+    handleInputBorderStatusClick(event) {
+        return this.handleStatusDraftQueueClick(event)
+            || this.handleStatusUserJumpClick(event)
+            || this.handleStatusThinkingExpandClick(event)
+            || this.handleStatusCompactToolsClick(event)
+            || this.handleStatusTerminalBellSoundClick(event)
+            || this.handleStatusPromptEnhancerClick(event)
+            || this.handleStatusVoiceMicClick(event)
+            || this.handleStatusVoiceLanguageClick(event);
+    }
     async openStatusUserJumpMenu() {
         try {
             const refreshPromise = this.host.refreshUserMessageJumpMenuItems?.();

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

@@ -5,16 +5,24 @@ import { parse as parseJsonc } from "jsonc-parser";
 
 import { DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC } from "./default-pi-tools-suite-config.js";
 
+export interface TelegramMirrorConfig {
+	enabled: boolean;
+	botToken: string;
+	chatId: number;
+}
+
 export interface PiToolsSuiteConfig {
 	enabled: boolean;
 	disabledModules: string[];
 	todoThinking: boolean;
+	telegramMirror?: TelegramMirrorConfig;
 }
 
 type MutableConfig = {
 	enabled: boolean;
 	disabledModules: Set<string>;
 	todoThinking: boolean;
+	telegramMirror: TelegramMirrorConfig | undefined;
 };
 
 type Env = Record<string, string | undefined>;
@@ -52,6 +60,27 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
+function normalizeTelegramMirror(raw: unknown): TelegramMirrorConfig | undefined {
+	if (!isRecord(raw)) return undefined;
+	const botToken = typeof raw.botToken === "string" ? raw.botToken.trim() : "";
+	if (!botToken) return undefined;
+
+	let chatId: number | undefined;
+	if (typeof raw.chatId === "number" && Number.isFinite(raw.chatId) && Number.isInteger(raw.chatId)) {
+		chatId = raw.chatId;
+	} else if (typeof raw.chatId === "string") {
+		const trimmed = raw.chatId.trim();
+		if (/^-?\d+$/.test(trimmed)) {
+			const parsed = Number(trimmed);
+			if (Number.isFinite(parsed) && Number.isInteger(parsed)) chatId = parsed;
+		}
+	}
+	if (chatId === undefined) return undefined;
+
+	const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
+	return { enabled, botToken, chatId };
+}
+
 function boolFromEnv(value: string | undefined): boolean | undefined {
 	if (value === undefined) return undefined;
 	const normalized = value.trim().toLowerCase();
@@ -125,6 +154,9 @@ function mergeConfigLayer(config: MutableConfig, raw: Record<string, unknown>, k
 		}
 	}
 
+	const telegramMirror = normalizeTelegramMirror(raw.telegramMirror);
+	if (telegramMirror) config.telegramMirror = telegramMirror;
+
 	return config;
 }
 
@@ -166,6 +198,7 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		enabled: true,
 		disabledModules: new Set([...DEFAULT_DISABLED_MODULES].filter((name) => knownModules.has(name))),
 		todoThinking: false,
+		telegramMirror: undefined,
 	};
 	const userConfigPath = getPiToolsSuiteUserConfigPath(options.homeDir);
 
@@ -184,5 +217,15 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		enabled: config.enabled,
 		disabledModules: [...config.disabledModules].sort(),
 		todoThinking: config.todoThinking,
+		...(config.telegramMirror ? { telegramMirror: config.telegramMirror } : {}),
 	};
 }
+
+/**
+ * Load only the telegram-mirror section from the pi-tools-suite config layers.
+ * Returns undefined when the section is missing or invalid (botToken empty /
+ * chatId non-integer).
+ */
+export function loadTelegramMirrorConfig(options: { cwd?: string; env?: Env; homeDir?: string } = {}): TelegramMirrorConfig | undefined {
+	return loadPiToolsSuiteConfig([], options).telegramMirror;
+}

package/external/pi-tools-suite/src/dcp/commands.ts

@@ -198,7 +198,7 @@ function handleContext(ctx: ExtensionCommandContext, state: DcpState): void {
 
   lines.push("")
   lines.push("Session Stats:")
-  lines.push(`  Tool calls tracked: ${fmt(state.toolCalls.size)}`)
+  lines.push(`  Tool calls tracked: ${fmt(state.totalToolCallCount)} (${fmt(state.toolCalls.size)} in memory)`)
   lines.push(`  Pruned tools: ${fmt(state.prunedToolIds.size)}`)
   lines.push(`  Compression blocks: ${state.compressionBlocks.filter((b) => b.active).length}`)
   lines.push(`  Tokens saved (estimated): ${fmt(state.tokensSaved)}`)

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

@@ -9,6 +9,7 @@ import {
 	resetState,
 	createInputFingerprint,
 	serializeState,
+	hashSerializedState,
 	restoreState,
 	type DcpState,
 } from "./state.js"
@@ -44,12 +45,26 @@ import { safeGetContextUsage } from "../context-usage.js"
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Hash of the last persisted dcp-state snapshot. Used to skip appending
+ * identical snapshots when saveState is called repeatedly without state change.
+ */
+let lastPersistedStateHash: string | undefined
+
 /**
  * Persist the current DCP runtime state as a custom session entry so it
  * survives session restarts and pi process restarts.
+ *
+ * Deduplication: serializes, hashes, and skips the append when the hash
+ * matches the previously persisted snapshot. This avoids writing identical
+ * multi-KB entries on every context event / nudge reapply.
  */
 function saveState(pi: ExtensionAPI, state: DcpState): void {
-	pi.appendEntry("dcp-state", serializeState(state))
+	const serialized = serializeState(state)
+	const hash = hashSerializedState(serialized)
+	if (hash === lastPersistedStateHash) return
+	lastPersistedStateHash = hash
+	pi.appendEntry("dcp-state", serialized)
 }
 
 function annotateMessagesWithBranchEntryIds(messages: any[], ctx: ExtensionContext): void {
@@ -147,6 +162,9 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 		// Reset to a clean slate first.
 		resetState(state)
 
+		// Reset dedup hash so the first save after restore always writes.
+		lastPersistedStateHash = undefined
+
 		// Re-apply config baseline so manual mode survives a session_start reset.
 		if (config.manualMode.enabled) {
 			state.manualMode = true
@@ -197,6 +215,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				timestamp: 0,
 				tokenEstimate: 0,
 			})
+			state.totalToolCallCount++
 		}
 	})
 
@@ -228,6 +247,7 @@ export default async function dcpModule(pi: ExtensionAPI): Promise<void> {
 				outputText,
 				outputDetails: event.details,
 			})
+			state.totalToolCallCount++
 		}
 
 	})