pi-ui-extend 0.1.38 → 0.1.41

package/dist/app/app.d.ts

@@ -94,7 +94,6 @@ export declare class PiUiExtendApp {
     private loadSessionHistory;
     private openSearchResultInNewTab;
     private scrollToUserMessageJumpTarget;
-    private findUserEntryBySessionEntryId;
     private findUserEntryByJumpText;
     private loadSessionHistoryAsync;
     private handleSessionEvent;

package/dist/app/app.js

@@ -360,6 +360,7 @@ export class PiUiExtendApp {
         });
         this.workspaceActions = new AppWorkspaceActionsController({
             entries: this.entries,
+            allEntries: () => this.sessionEvents.allEntries(),
             runtime: () => this.runtime,
             awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             findUserEntry: (entryId) => this.findUserEntry(entryId),
@@ -665,6 +666,12 @@ export class PiUiExtendApp {
             setSessionActivity: (activity) => this.setSessionActivity(activity),
             addEntry: (entry) => this.addEntry(entry),
             addSessionAbortedEntry: () => this.sessionEvents.addSessionAbortedEntry(),
+            emitSessionAborted: () => {
+                const runtime = this.runtime;
+                if (!runtime)
+                    return;
+                this.extensionEventBusByRuntime.get(runtime)?.emit("pix:session-aborted", { aborted: true });
+            },
             showToast: (message, kind) => this.showToast(message, kind),
             dismissActiveDialog: () => this.toastController.dismissActiveDialog(),
             stopVoiceInput: () => this.voiceController.stopRecording(),
@@ -999,39 +1006,39 @@ export class PiUiExtendApp {
             return true;
         this.workspaceActions.syncUserSessionEntryMetadata();
         if (target.sessionEntryId) {
-            let entry = this.findUserEntryBySessionEntryId(target.sessionEntryId);
-            while (!entry && this.sessionEvents.hasOlderSessionHistory() && !this.sessionEvents.isLoadingOlderSessionHistory()) {
-                const loaded = await this.sessionEvents.loadOlderSessionHistory({ render: false });
-                if (!loaded)
-                    break;
-                entry = this.findUserEntryBySessionEntryId(target.sessionEntryId);
-            }
-            if (entry && this.scrollController.scrollToConversationEntry(entry.id))
+            const entryId = this.sessionEvents.revealHistoryEntryForSessionEntryId(target.sessionEntryId);
+            if (entryId && this.scrollController.scrollToConversationEntry(entryId))
                 return true;
         }
         const fallbackEntry = this.findUserEntryByJumpText(target);
         return fallbackEntry ? this.scrollController.scrollToConversationEntry(fallbackEntry.id) : false;
     }
-    findUserEntryBySessionEntryId(sessionEntryId) {
-        return this.entries.find((entry) => entry.kind === "user" && entry.sessionEntryId === sessionEntryId);
-    }
     findUserEntryByJumpText(target) {
         if (!target.text)
             return undefined;
-        const userEntries = this.entries.filter((entry) => entry.kind === "user");
+        const userEntries = this.sessionEvents.allEntries().filter((entry) => entry.kind === "user");
+        let matched;
         if (target.userIndex !== undefined && target.userCount !== undefined) {
-            const visibleIndex = target.userIndex - (target.userCount - userEntries.length);
-            const entry = userEntries[visibleIndex];
+            const entry = userEntries[target.userIndex];
             if (entry && normalizeJumpTargetText(entry.text) === normalizeJumpTargetText(target.text))
-                return entry;
+                matched = entry;
+        }
+        if (!matched) {
+            const normalizedTargetText = normalizeJumpTargetText(target.text);
+            for (let index = userEntries.length - 1; index >= 0; index -= 1) {
+                const entry = userEntries[index];
+                if (entry && normalizeJumpTargetText(entry.text) === normalizedTargetText) {
+                    matched = entry;
+                    break;
+                }
+            }
         }
-        const normalizedTargetText = normalizeJumpTargetText(target.text);
-        for (let index = userEntries.length - 1; index >= 0; index -= 1) {
-            const entry = userEntries[index];
-            if (entry && normalizeJumpTargetText(entry.text) === normalizedTargetText)
-                return entry;
+        if (matched?.sessionEntryId) {
+            // Shift the sliding window onto the matched entry so it is present in the
+            // viewport for the subsequent scrollToConversationEntry call.
+            this.sessionEvents.revealHistoryEntryForSessionEntryId(matched.sessionEntryId);
         }
-        return undefined;
+        return matched;
     }
     async loadSessionHistoryAsync(options) {
         return this.sessionEvents.loadSessionHistoryAsync(options);

package/dist/app/constants.js

@@ -78,7 +78,7 @@ export const SUBAGENTS_WIDGET_MAX_ROWS = 8;
 export const DEFAULT_THINKING_TOOL_RULE = {
     previewLines: 0,
     direction: "head",
-    color: "thinkingForeground",
+    color: "assistantForeground",
 };
 export const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
 export const GIT_BRANCH_CACHE_MS = 30_000;

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

@@ -18,6 +18,7 @@ export type AppInputActionControllerHost = {
     setSessionActivity(activity: SessionActivity): void;
     addEntry(entry: Entry): void;
     addSessionAbortedEntry(): void;
+    emitSessionAborted(): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     dismissActiveDialog?(): boolean;
     stopVoiceInput(): Promise<void>;

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

@@ -88,6 +88,9 @@ export class AppInputActionController {
     }
     async abortStreamingSession(runtime, options) {
         const session = runtime.session;
+        // Relay the user-initiated abort to extensions (e.g. the terminal-bell
+        // extension) so they can suppress the attention bell for this turn.
+        this.host.emitSessionAborted();
         if (this.abortInFlight) {
             session.agent.abort();
             if (options.stopIfAlreadyAborting)

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

@@ -35,6 +35,7 @@ export declare class AppInputController {
     private readonly pasteHandler;
     constructor(host: InputControllerHost);
     handleChunk(chunk: Buffer): void;
+    private consumeBufferedSharedEditorInput;
     private consumeSharedEditorInput;
     private drainInputBuffer;
     private consumeBracketedPastePayload;

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

@@ -12,13 +12,23 @@ export class AppInputController {
     }
     handleChunk(chunk) {
         let data = chunk.toString("utf8");
+        const bufferedSharedEditorInput = this.consumeBufferedSharedEditorInput(data);
+        if (bufferedSharedEditorInput.kind === "consumed" || bufferedSharedEditorInput.kind === "pending")
+            return;
+        if (bufferedSharedEditorInput.kind === "passthrough")
+            data = bufferedSharedEditorInput.data;
         if (this.inputBuffer.startsWith("\x1b[<") || data.startsWith("\x1b[<")) {
             this.inputBuffer += data;
             this.drainInputBuffer();
             return;
         }
-        if (this.consumeSharedEditorInput(data))
+        const sharedEditorInput = this.consumeSharedEditorInput(data);
+        if (sharedEditorInput === "consumed")
+            return;
+        if (sharedEditorInput === "pending") {
+            this.inputBuffer = data;
             return;
+        }
         const extensionInput = this.host.handleExtensionTerminalInput(data);
         if (extensionInput.consume)
             return;
@@ -29,41 +39,59 @@ export class AppInputController {
         this.inputBuffer += data;
         this.drainInputBuffer();
     }
+    consumeBufferedSharedEditorInput(data) {
+        if (this.host.extensionInputUsesEditor?.() !== true)
+            return { kind: "none" };
+        if (this.inputBuffer.length === 0)
+            return { kind: "none" };
+        const buffered = `${this.inputBuffer}${data}`;
+        const result = this.consumeSharedEditorInput(buffered);
+        if (result === "pending") {
+            this.inputBuffer = buffered;
+            return { kind: "pending" };
+        }
+        this.inputBuffer = "";
+        if (result === "consumed")
+            return { kind: "consumed" };
+        return { kind: "passthrough", data: buffered };
+    }
     consumeSharedEditorInput(data) {
         if (this.host.extensionInputUsesEditor?.() !== true)
-            return false;
+            return "none";
         if (this.host.inputEditor.isInBracketedPaste)
-            return false;
+            return "none";
         if (data === "\n") {
             this.insertInputNewline();
-            return true;
+            return "consumed";
         }
         if (data === "\r" && this.isShiftPressed()) {
             this.insertInputNewline();
-            return true;
+            return "consumed";
         }
         if (SHIFT_ENTER_ESCAPE_SEQUENCES.includes(data)) {
             this.insertInputNewline();
-            return true;
+            return "consumed";
         }
         if (data === "\x16") {
             void this.pasteHandler.handleClipboardImagePaste();
-            return true;
+            return "consumed";
         }
         const modifiedKey = parseTerminalModifiedKeySequence(data);
+        if (modifiedKey.kind === "pending")
+            return "pending";
         if (modifiedKey.kind !== "key")
-            return false;
+            return "none";
         if (terminalKeyShouldIgnore(modifiedKey.key))
-            return true;
+            return "consumed";
         if (terminalKeyIsShiftEnter(modifiedKey.key)) {
             this.insertInputNewline();
-            return true;
+            return "consumed";
         }
         if (terminalKeyIsClipboardImagePaste(modifiedKey.key)) {
             void this.pasteHandler.handleClipboardImagePaste();
-            return true;
+            return "consumed";
         }
-        return false;
+        return "none";
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {

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

@@ -13,6 +13,8 @@ const GOOGLE_ANTIGRAVITY_USER_AGENT = "antigravity/1.11.9 windows/amd64";
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
+const MODEL_USAGE_WARNING_MIN_USED_PERCENT = 5;
+const MODEL_USAGE_WARNING_MIN_ELAPSED_SECONDS = 6 * HOUR_SECONDS;
 const PI_AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
 const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
 function getPiAuthPath() {
@@ -929,11 +931,11 @@ function modelUsageWindowWillExhaustBeforeReset(window, now) {
         return false;
     const timeUntilResetSeconds = Math.max(0, (window.resetAt - now) / 1000);
     const elapsedSeconds = Math.max(0, window.windowSeconds - timeUntilResetSeconds);
-    if (elapsedSeconds <= 0)
+    if (elapsedSeconds < MODEL_USAGE_WARNING_MIN_ELAPSED_SECONDS)
         return false;
     const total = 100;
     const used = total - window.remainingPercent;
-    if (used <= 0)
+    if (used < MODEL_USAGE_WARNING_MIN_USED_PERCENT)
         return false;
     const remaining = total - used;
     const averageRate = used / elapsedSeconds;

package/dist/app/process.js

@@ -37,6 +37,17 @@ export async function runProcess(command, args = [], options = {}) {
         child.once("error", (err) => {
             error = err;
         });
+        // Writing to stdin after the child has closed it raises EPIPE. This is
+        // common with clipboard helpers (xclip/xsel/wl-copy) that exit once they
+        // have read enough, or when a candidate command exits early. The child's
+        // exit status is still captured by the "close" handler, so treat EPIPE as
+        // benign and never let it surface as an unhandled "error" event.
+        child.stdin?.once("error", (err) => {
+            if (err?.code === "EPIPE")
+                return;
+            if (error === undefined)
+                error = err;
+        });
         child.once("close", (status, signal) => {
             if (timer)
                 clearTimeout(timer);

package/dist/app/rendering/conversation-tool-renderer.js

@@ -7,7 +7,6 @@ import { formatStructuredText } from "./message-content.js";
 import { formatSubagentTimestamp, isSubagentRunRenderDetails, isSubagentsToolName, subagentRunName, subagentStatusIcon, taskPreviewMap, } from "../subagents/subagents-model.js";
 import { formatTodoTaskLine, isTodoDetails, visibleTodoTasks } from "../todo/todo-model.js";
 import { renderToolBlock } from "./tool-block-renderer.js";
-import { thinkingLevelThemeColor } from "./status-line-renderer.js";
 export function renderConversationToolEntry(entry, width, options) {
     const todoLines = renderTodoToolEntry(entry, width, options);
     if (todoLines)
@@ -53,14 +52,14 @@ export function renderThinkingEntry(entry, width, options) {
     const forceExpanded = Boolean(options.allThinkingExpanded);
     const compactExpandedText = options.superCompactTools && forceExpanded ? removeBlankLines(expandedText) : expandedText;
     const expanded = forceExpanded || (entry.expanded && expandedText.trim().length > 0);
-    const headerColorOverride = entry.level
-        ? thinkingLevelThemeColor(entry.level, options.colors, options.availableThinkingLevels)
-        : undefined;
     const elapsed = thinkingElapsedText(entry, options.currentTimeMs ?? Date.now());
+    const headerArgs = [entry.level ? `(${entry.level})` : undefined, elapsed]
+        .filter((part) => part !== undefined)
+        .join(" ");
     return renderToolBlock({
         id: entry.id,
         toolName: THINKING_TOOL_NAME,
-        ...(elapsed === undefined ? {} : { headerArgs: elapsed }),
+        ...(headerArgs === "" ? {} : { headerArgs }),
         expanded,
         status: entry.status,
         isError: false,
@@ -73,7 +72,6 @@ export function renderThinkingEntry(entry, width, options) {
         superCompact: Boolean(options.superCompactTools && !forceExpanded),
         backgroundOverride: options.colors.thinkingMessageBackground,
         showGutter: true,
-        ...(headerColorOverride === undefined ? {} : { headerColorOverride }),
     });
 }
 function thinkingElapsedText(entry, currentTimeMs) {

package/dist/app/session/request-history.js

@@ -61,6 +61,8 @@ export class AppRequestHistory {
         if (this.cursor === undefined) {
             if (direction > 0)
                 return false;
+            if (this.host.getInput().length > 0)
+                return false;
             this.draft = this.host.getInput();
             this.cursor = this.entries.length - 1;
             const entry = this.entries[this.cursor];

package/dist/app/session/session-event-controller.d.ts

@@ -90,6 +90,7 @@ export declare class AppSessionEventController {
     snapshotState(): AppSessionEventControllerState;
     restoreState(state: AppSessionEventControllerState): void;
     reset(): void;
+    allEntries(): readonly Entry[];
     loadSessionHistory(): void;
     loadSessionHistoryAsync(options: {
         isCancelled: () => boolean;
@@ -99,6 +100,18 @@ export declare class AppSessionEventController {
     hasOlderSessionHistory(): boolean;
     isLoadingOlderSessionHistory(): boolean;
     loadOlderSessionHistory(options?: LoadOlderSessionHistoryOptions): Promise<boolean>;
+    /**
+     * Reveal the conversation entry for a session entry id (e.g. a user message
+     * selected from the jump menu) by shifting the sliding window directly onto
+     * it, then return its local entry id so the caller can scroll to it.
+     *
+     * Unlike paging older history in fixed increments, this works for any branch
+     * position in a single synchronous step and does not race with concurrent
+     * window re-anchors (e.g. while the agent is streaming). Returns undefined
+     * when the entry is neither in the full history window nor in the live
+     * entries (e.g. older than the loaded branch).
+     */
+    revealHistoryEntryForSessionEntryId(sessionEntryId: string): string | undefined;
     hasNewerSessionHistory(): boolean;
     isLoadingNewerSessionHistory(): boolean;
     loadNewerSessionHistory(options?: {

package/dist/app/session/session-event-controller.js

@@ -109,6 +109,9 @@ export class AppSessionEventController {
         this.assistantTextBuffer = "";
         this.olderHistoryLoader = undefined;
     }
+    allEntries() {
+        return this.historyEntries.length > 0 ? this.historyEntries : this.host.entries;
+    }
     loadSessionHistory() {
         const runtime = this.host.runtime();
         if (!runtime)
@@ -165,6 +168,30 @@ export class AppSessionEventController {
             return this.shiftHistoryWindow(-HISTORY_WINDOW_SHIFT_ENTRIES, options);
         return this.olderHistoryLoader?.loadOlder(options) ?? false;
     }
+    /**
+     * Reveal the conversation entry for a session entry id (e.g. a user message
+     * selected from the jump menu) by shifting the sliding window directly onto
+     * it, then return its local entry id so the caller can scroll to it.
+     *
+     * Unlike paging older history in fixed increments, this works for any branch
+     * position in a single synchronous step and does not race with concurrent
+     * window re-anchors (e.g. while the agent is streaming). Returns undefined
+     * when the entry is neither in the full history window nor in the live
+     * entries (e.g. older than the loaded branch).
+     */
+    revealHistoryEntryForSessionEntryId(sessionEntryId) {
+        if (this.historyEntries.length > 0) {
+            const index = this.historyEntries.findIndex((entry) => entry.kind === "user" && entry.sessionEntryId === sessionEntryId);
+            if (index === -1)
+                return undefined;
+            const targetStart = Math.max(0, Math.min(this.maxHistoryWindowStart(), index - Math.floor(this.historyWindowSize() / 2)));
+            if (targetStart !== this.historyWindowStart)
+                this.setHistoryWindowStart(targetStart);
+            return this.historyEntries[index]?.id;
+        }
+        const entry = this.host.entries.find((entry) => entry.kind === "user" && entry.sessionEntryId === sessionEntryId);
+        return entry?.id;
+    }
     hasNewerSessionHistory() {
         return this.historyEntries.length > 0 && this.historyWindowStart < this.maxHistoryWindowStart();
     }

package/dist/app/session/tabs-controller.d.ts

@@ -155,6 +155,14 @@ export declare class AppTabsController {
     private scheduleTabPrewarm;
     private prewarmTabs;
     private cleanupOldProjectSessions;
+    /**
+     * Unlink a project session file and, best-effort, its DCP sidecar state.
+     * The sidecar path is derived from the session id in the first line of the
+     * `.jsonl` (mirrors the DCP module's `safeSessionFileName`), so retention
+     * never leaves orphan sidecars behind. Everything here is best-effort:
+     * session retention must never interrupt the terminal UI.
+     */
+    private unlinkSessionAndDcpSidecar;
     private preservedSessionPaths;
     private maxProjectSessions;
 }

package/dist/app/session/tabs-controller.js

@@ -1543,12 +1543,7 @@ export class AppTabsController {
             for (const session of sessions) {
                 if (keep.has(session.path))
                     continue;
-                try {
-                    await unlink(session.path);
-                }
-                catch {
-                    // Session retention must never interrupt the terminal UI.
-                }
+                await this.unlinkSessionAndDcpSidecar(session.path);
             }
         }
         catch {
@@ -1558,6 +1553,42 @@ export class AppTabsController {
             this.retentionCleanupRunning = false;
         }
     }
+    /**
+     * Unlink a project session file and, best-effort, its DCP sidecar state.
+     * The sidecar path is derived from the session id in the first line of the
+     * `.jsonl` (mirrors the DCP module's `safeSessionFileName`), so retention
+     * never leaves orphan sidecars behind. Everything here is best-effort:
+     * session retention must never interrupt the terminal UI.
+     */
+    async unlinkSessionAndDcpSidecar(sessionPath) {
+        let sidecarPath;
+        try {
+            const firstLine = (await readFile(sessionPath, "utf8")).split("\n", 1)[0]?.trim();
+            if (firstLine) {
+                const parsed = JSON.parse(firstLine);
+                if (parsed.type === "session" && typeof parsed.id === "string" && parsed.id) {
+                    sidecarPath = join(dirname(sessionPath), "dcp-state", parsed.id.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json");
+                }
+            }
+        }
+        catch {
+            // Reading the session id is best-effort; proceed to unlink the file.
+        }
+        try {
+            await unlink(sessionPath);
+        }
+        catch {
+            // Session retention must never interrupt the terminal UI.
+        }
+        if (sidecarPath) {
+            try {
+                await unlink(sidecarPath);
+            }
+            catch {
+                // Sidecar removal is best-effort; never interrupt the terminal UI.
+            }
+        }
+    }
     preservedSessionPaths() {
         const preserved = new Set();
         const add = (sessionPath) => {

package/dist/app/workspace/workspace-actions-controller.d.ts

@@ -3,6 +3,7 @@ import type { Entry } from "../types.js";
 import { type WorkspaceMutation, type WorkspaceMutationFromToolInput, type WorkspaceMutationPreparation } from "./workspace-undo.js";
 export type AppWorkspaceActionsControllerHost = {
     readonly entries: Entry[];
+    allEntries?(): readonly Entry[];
     runtime(): AgentSessionRuntime | undefined;
     awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     findUserEntry(entryId: string): Extract<Entry, {

package/dist/app/workspace/workspace-actions-controller.js

@@ -48,8 +48,9 @@ export class AppWorkspaceActionsController {
         });
         if (branchUserEntries.length === 0)
             return;
+        const loadedEntries = this.host.allEntries?.() ?? this.host.entries;
         let branchIndex = 0;
-        for (const entry of this.host.entries) {
+        for (const entry of loadedEntries) {
             if (entry.kind !== "user")
                 continue;
             const sessionEntry = branchUserEntries[branchIndex];

package/dist/bundled-extensions/terminal-bell/index.js

@@ -15,7 +15,14 @@ const TERMINAL_BELL_ATTENTION_EVENT = "pix:terminal-bell:attention";
  * extensions, so the renderer emits this on the extension event bus.
  */
 const RETRY_ACTIVE_EVENT = "pix:retry-active";
-const DEFAULT_COMPLETION_NOTIFICATION_TITLE = "Pix - completion";
+/**
+ * Renderer-relayed signal that the user interrupted the session (Esc/Ctrl-C).
+ * Payload: `{ aborted: boolean }`. Aborting the SDK stream during tool
+ * execution does not always produce an aborted `message_update`, so the
+ * renderer relays the abort here to reliably suppress the attention bell.
+ */
+const SESSION_ABORTED_EVENT = "pix:session-aborted";
+const DEFAULT_COMPLETION_NOTIFICATION_TITLE = "Pix - complete";
 const DEFAULT_ERROR_NOTIFICATION_TITLE = "Pix - error";
 const DEFAULT_QUESTION_NOTIFICATION_TITLE = "Pix - question";
 const DEFAULT_NOTIFICATION_MESSAGE = "{sessionName}";
@@ -220,9 +227,16 @@ function notificationTitleTemplate(defaultTitle) {
 function willRetryAfterAgentEnd(event) {
     return event.willRetry === true;
 }
+function isAbortedMessageUpdate(event) {
+    return event.type === "error" && event.reason === "aborted";
+}
 function failureReasonFromMessageUpdate(event) {
     if (event.type !== "error")
         return undefined;
+    // The SDK reports a user-initiated interrupt as `{ type: "error", reason: "aborted" }`.
+    // That is not a failure the bell should announce, so treat it as "no reason".
+    if (event.reason === "aborted")
+        return undefined;
     const reason = event.error?.errorMessage;
     return typeof reason === "string" ? trimmed(reason) : undefined;
 }
@@ -387,6 +401,10 @@ export default function terminalBell(pi) {
     let deferredUntilSubagentsFinish = false;
     let liveSubagentCount = 0;
     let lastFailureReason;
+    // True when the user interrupted the session this turn (Esc/Ctrl-C). The
+    // attention bell should never ring for a user-initiated abort, so this flag
+    // suppresses any queued/pending bell until the next agent_start resets it.
+    let userAborted = false;
     // True while the session is in an auto-retry cycle (relayed via the
     // extension event bus). Suppresses the failure bell on intermediate retry
     // attempts; the final exhausted failure still rings because no retry-start
@@ -426,6 +444,13 @@ export default function terminalBell(pi) {
         // queued this bell and the timer firing, suppress the bell entirely.
         if (retryActive)
             return;
+        // Safety net: if the user aborted after the bell was queued (e.g. an
+        // aborted agent_end with no aborted message_update), suppress it.
+        if (userAborted) {
+            pendingBell = undefined;
+            deferredUntilSubagentsFinish = false;
+            return;
+        }
         try {
             if (!ctx.isIdle()) {
                 if (attempt < MAX_IDLE_RETRIES)
@@ -514,15 +539,39 @@ export default function terminalBell(pi) {
             deferredUntilSubagentsFinish = false;
         }
     });
+    pi.events.on(SESSION_ABORTED_EVENT, (data) => {
+        const aborted = data != null && typeof data === "object" && data.aborted === true;
+        if (!aborted)
+            return;
+        // The user interrupted the session. Aborting during tool execution does
+        // not always produce an aborted `message_update`, so the renderer relays
+        // the interrupt here. Suppress any pending bell until the next agent_start.
+        userAborted = true;
+        lastFailureReason = undefined;
+        clearTimer();
+        pendingBell = undefined;
+        deferredUntilSubagentsFinish = false;
+    });
     pi.on("agent_start", async () => {
         clearTimer();
         deferredUntilSubagentsFinish = false;
         lastFailureReason = undefined;
+        userAborted = false;
         retryActive = false;
         activeSubagentWaitToolCallIds.clear();
         notifiedAskUserToolCallIds.clear();
     });
     pi.on("message_update", async (event) => {
+        if (isAbortedMessageUpdate(event.assistantMessageEvent)) {
+            // The user interrupted the stream. Suppress any pending bell until
+            // the next agent_start.
+            userAborted = true;
+            lastFailureReason = undefined;
+            clearTimer();
+            pendingBell = undefined;
+            deferredUntilSubagentsFinish = false;
+            return;
+        }
         const reason = failureReasonFromMessageUpdate(event.assistantMessageEvent);
         if (reason) {
             lastFailureReason = reason;
@@ -554,6 +603,10 @@ export default function terminalBell(pi) {
             clearTimer();
             return;
         }
+        if (userAborted) {
+            clearTimer();
+            return;
+        }
         if (lastFailureReason) {
             scheduleBell(ctx, idleDelayMs, 0, renderNotificationTemplate(retryFailureMessageTemplate(), {
                 ...buildNotificationTemplateValues(ctx, pi),
@@ -569,6 +622,7 @@ export default function terminalBell(pi) {
         deferredUntilSubagentsFinish = false;
         liveSubagentCount = 0;
         lastFailureReason = undefined;
+        userAborted = false;
         retryActive = false;
         activeSubagentWaitToolCallIds.clear();
         notifiedAskUserToolCallIds.clear();

package/dist/config.js

@@ -19,7 +19,7 @@ const DEFAULT_TOOL_RENDERER = {
         color: "toolTitle",
     },
     tools: {
-        thinking: { previewLines: 0, direction: "head", color: "thinkingForeground" },
+        thinking: { previewLines: 0, direction: "head", color: "assistantForeground" },
         bash: { previewLines: 6, direction: "tail", color: "warning" },
         Bash: { previewLines: 6, direction: "tail", color: "warning" },
         shell: { previewLines: 6, direction: "tail", color: "warning" },

package/dist/default-pix-config.js

@@ -10,7 +10,7 @@ export const DEFAULT_PIX_CONFIG_JSONC = String.raw `{
   "toolRenderer": {
     "default": { "previewLines": 0, "direction": "head", "color": "toolTitle" },
     "tools": {
-      "thinking": { "previewLines": 0, "direction": "head", "color": "thinkingForeground" },
+      "thinking": { "previewLines": 0, "direction": "head", "color": "assistantForeground" },
       "bash": { "previewLines": 6, "direction": "tail", "color": "warning" },
       "Bash": { "previewLines": 6, "direction": "tail", "color": "warning" },
       "shell": { "previewLines": 6, "direction": "tail", "color": "warning" },