pi-ui-extend 0.1.35 → 0.1.37

package/dist/app/input/terminal-edit-shortcuts.js

@@ -4,6 +4,7 @@ const COMMAND_MODIFIER_FLAG = 8;
 const LOCK_MODIFIER_MASK = 64 + 128;
 const KEY_CODE_C = 99;
 const KEY_CODE_ENTER = 13;
+const KEY_CODE_ESCAPE = 27;
 const KEY_CODE_V = 118;
 const KEY_CODE_Y = 121;
 const KEY_CODE_Z = 122;
@@ -11,12 +12,22 @@ const CYRILLIC_SMALL_ES_CODE = 1089;
 const CYRILLIC_CAPITAL_ES_CODE = 1057;
 const CYRILLIC_SMALL_EM_CODE = 1084;
 const CYRILLIC_CAPITAL_EM_CODE = 1052;
+const KITTY_ARROW_CODEPOINTS = {
+    A: -1,
+    B: -2,
+    C: -3,
+    D: -4,
+};
 const KITTY_CSI_U_SEQUENCE = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u/;
+const KITTY_ARROW_SEQUENCE = /^\x1b\[1;(\d+)(?::(\d+))?([ABCD])/;
 const XTERM_MODIFY_OTHER_KEYS_SEQUENCE = /^\x1b\[27;(\d+);(\d+)~/;
 export function parseTerminalModifiedKeySequence(input) {
     const kitty = parseKittyCsiUSequence(input);
     if (kitty)
         return { kind: "key", key: kitty };
+    const kittyArrow = parseKittyArrowSequence(input);
+    if (kittyArrow)
+        return { kind: "key", key: kittyArrow };
     const xterm = parseXtermModifyOtherKeysSequence(input);
     if (xterm)
         return { kind: "key", key: xterm };
@@ -57,6 +68,26 @@ export function terminalKeyIsClipboardImagePaste(key) {
 export function terminalKeyShouldIgnore(key) {
     return key.eventType === 3;
 }
+export function terminalKeyIsEscape(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if (effectiveModifier !== 0)
+        return false;
+    return key.codepoint === KEY_CODE_ESCAPE;
+}
+export function terminalKeyArrowDirection(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if (effectiveModifier !== 0)
+        return undefined;
+    if (key.codepoint === KITTY_ARROW_CODEPOINTS.A)
+        return "up";
+    if (key.codepoint === KITTY_ARROW_CODEPOINTS.B)
+        return "down";
+    if (key.codepoint === KITTY_ARROW_CODEPOINTS.C)
+        return "right";
+    if (key.codepoint === KITTY_ARROW_CODEPOINTS.D)
+        return "left";
+    return undefined;
+}
 export function terminalEditShortcutForControlChar(char, shiftPressed) {
     if (char === "\u001a")
         return shiftPressed ? "redo" : "undo";
@@ -82,6 +113,24 @@ function parseKittyCsiUSequence(input) {
         length: match[0].length,
     };
 }
+function parseKittyArrowSequence(input) {
+    const match = KITTY_ARROW_SEQUENCE.exec(input);
+    if (!match)
+        return undefined;
+    const modifierValue = Number.parseInt(match[1] ?? "", 10);
+    const eventType = match[2] ? Number.parseInt(match[2], 10) : undefined;
+    const arrow = match[3];
+    const codepoint = arrow ? KITTY_ARROW_CODEPOINTS[arrow] : undefined;
+    if (!Number.isFinite(modifierValue) || codepoint === undefined)
+        return undefined;
+    return {
+        codepoint,
+        baseLayoutKey: undefined,
+        modifier: modifierValue - 1,
+        eventType: Number.isFinite(eventType) ? eventType : undefined,
+        length: match[0].length,
+    };
+}
 function parseXtermModifyOtherKeysSequence(input) {
     const match = XTERM_MODIFY_OTHER_KEYS_SEQUENCE.exec(input);
     if (!match)

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

@@ -66,7 +66,7 @@ export class AppVoiceController {
             case "installing":
                 return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "downloading":
-                return `${APP_ICONS.down}${languageLabel}`;
+                return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "loading":
                 return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "listening":

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

@@ -7,6 +7,7 @@ import type { Entry, SlashCommand, UserMessageJumpMenuValue } from "../types.js"
 import type { AppWorkspaceActionsController } from "../workspace/workspace-actions-controller.js";
 export type AppPopupActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     getBuiltinSlashCommands(): readonly SlashCommand[];
     isRunning(): boolean;
     setInput(value: string): void;
@@ -15,9 +16,7 @@ export type AppPopupActionControllerHost = {
     setSessionStatus(session: AgentSession | undefined): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
-    resetSessionView(): void;
-    bindCurrentSession(): Promise<void>;
-    loadSessionHistory(): void;
+    afterSessionReplacement(message?: string): void;
     scrollToConversationEntry(entryId: string): boolean;
     scrollToUserMessageJumpTarget(target: UserMessageJumpMenuValue): Promise<boolean>;
 };

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

@@ -228,6 +228,7 @@ export class AppPopupActionController {
         this.host.setStatus("switching session");
         this.host.render();
         try {
+            await this.host.awaitCurrentSessionExtensions(runtime);
             const result = await runtime.switchSession(session.path);
             if (result.cancelled) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });
@@ -235,12 +236,8 @@ export class AppPopupActionController {
                 this.host.render();
                 return true;
             }
-            this.host.resetSessionView();
-            await this.host.bindCurrentSession();
-            this.host.loadSessionHistory();
             const name = runtime.session.sessionName ?? session.id.slice(0, 8);
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `Resumed session "${name}"` });
-            this.host.setSessionStatus(runtime.session);
+            this.host.afterSessionReplacement(`Resumed session "${name}"`);
         }
         catch (error) {
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Resume failed: ${error instanceof Error ? error.message : String(error)}` });

package/dist/app/rendering/message-content.js

@@ -1,3 +1,4 @@
+import { stripDcpControlMetadata } from "../../markdown-format.js";
 import { isRecord } from "../guards.js";
 const MAX_FORMAT_STRING_CHARS = 256 * 1024;
 const MAX_RENDERED_CONTENT_CHARS = 512 * 1024;
@@ -79,11 +80,11 @@ export function renderContent(content) {
         if (!pushPart(stringifyUnknown(item)))
             break;
     }
-    return parts.join("\n");
+    return stripDcpControlMetadata(parts.join("\n"));
 }
 export function renderUserMessageContent(content) {
     if (typeof content === "string")
-        return content;
+        return stripDcpControlMetadata(content);
     if (!Array.isArray(content))
         return stringifyUnknown(content);
     const textParts = [];
@@ -103,7 +104,7 @@ export function renderUserMessageContent(content) {
         }
         textParts.push(stringifyUnknown(item));
     }
-    const text = textParts.join("\n").replace(/\[Image \d+(?:: [^\]]+)?\]/g, "").trimEnd();
+    const text = stripDcpControlMetadata(textParts.join("\n")).replace(/\[Image \d+(?:: [^\]]+)?\]/g, "").trimEnd();
     if (imageCount === 0)
         return text;
     const imageText = userImageLabels(imageCount);

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

@@ -75,24 +75,10 @@ export class AppRenderController {
         this.deps.mouseController.statusVoiceMicTarget = undefined;
         this.deps.mouseController.statusVoiceLanguageTarget = undefined;
         this.deps.mouseController.tabLineTargets.length = 0;
-        const frameLines = {
-            tabs: [],
-            conversation: [],
-            inputStatus: [],
-        };
-        const inputStatusStartRow = toScreenRow(inputSeparatorRow);
-        const regionForOverlayRow = (row) => {
-            if (row >= statusRow)
-                return "inputStatus";
-            if (topReservedRows > 0 && row <= topReservedRows)
-                return "tabs";
-            if (row >= inputStatusStartRow)
-                return "inputStatus";
-            return "conversation";
-        };
-        const appendFrameOutput = (region, row, output) => {
+        const frameRows = new Map();
+        const appendFrameOutput = (row, output) => {
             if (row >= 1 && row <= rows)
-                frameLines[region].push(output);
+                frameRows.set(row, `${frameRows.get(row) ?? ""}${output}`);
         };
         const setRenderedBackground = (row, background) => {
             if (background !== undefined)
@@ -101,14 +87,14 @@ export class AppRenderController {
         if (topReservedRows > 0) {
             this.deps.mouseController.tabLineTargets.push(...tabLayout.targets.map((target) => ({ ...target, row: tabRow })));
             this.deps.mouseController.renderedRowTexts.set(tabRow, tabLayout.text);
-            appendFrameOutput("tabs", tabRow, this.renderFrameRow(tabRow, this.deps.tabLineRenderer.render(tabRow, tabLayout, columns)));
+            appendFrameOutput(tabRow, this.renderFrameRow(tabRow, this.deps.tabLineRenderer.render(tabRow, tabLayout, columns)));
             if (topReservedRows > 1) {
                 this.deps.mouseController.tabLineTargets.push(...tabLayout.targets
                     .filter((target) => target.kind === "new-tab")
                     .map((target) => ({ ...target, row: tabBottomRow })));
                 const bottomText = this.deps.tabLineRenderer.bottomText(tabLayout, columns);
                 this.deps.mouseController.renderedRowTexts.set(tabBottomRow, bottomText);
-                appendFrameOutput("tabs", tabBottomRow, this.renderFrameRow(tabBottomRow, this.deps.tabLineRenderer.renderBottom(tabBottomRow, tabLayout, columns)));
+                appendFrameOutput(tabBottomRow, this.renderFrameRow(tabBottomRow, this.deps.tabLineRenderer.renderBottom(tabBottomRow, tabLayout, columns)));
             }
         }
         else {
@@ -125,12 +111,12 @@ export class AppRenderController {
                 this.deps.mouseController.renderedImageTargets.set(row, rendered.imageTargets);
             this.deps.mouseController.renderedRowTexts.set(row, rendered?.text ?? "");
             setRenderedBackground(row, rendered?.backgroundOverride);
-            appendFrameOutput("conversation", row, this.renderFrameRow(row, this.deps.screenStyler.styleBaseLine(row, rendered, conversationColumns)));
+            appendFrameOutput(row, this.renderFrameRow(row, this.deps.screenStyler.styleBaseLine(row, rendered, conversationColumns)));
         }
         const loadingConversationOverlay = this.renderConversationLoadingOverlay(this.deps.loadingConversationOverlayText?.(), conversationColumns, topReservedRows, bodyHeight);
         if (loadingConversationOverlay) {
             this.deps.mouseController.renderedRowTexts.set(loadingConversationOverlay.row, loadingConversationOverlay.text);
-            appendFrameOutput("conversation", loadingConversationOverlay.row, this.renderFrameRow(loadingConversationOverlay.row, loadingConversationOverlay.output));
+            appendFrameOutput(loadingConversationOverlay.row, this.renderFrameRow(loadingConversationOverlay.row, loadingConversationOverlay.output));
         }
         const aboveEditorStartRow = inputSeparatorRow + 1;
         for (let index = 0; index < aboveEditorLines.length; index += 1) {
@@ -144,14 +130,14 @@ export class AppRenderController {
                 this.deps.mouseController.renderedImageTargets.set(row, rendered.line.imageTargets);
             this.deps.mouseController.renderedRowTexts.set(row, rendered.text);
             setRenderedBackground(row, rendered.line?.backgroundOverride);
-            appendFrameOutput("inputStatus", row, this.renderFrameRow(row, rendered.output(row)));
+            appendFrameOutput(row, this.renderFrameRow(row, rendered.output(row)));
         }
         if (inputSeparatorRow > 1) {
             const separatorText = inputFrameLine(columns, "top");
             const row = toScreenRow(inputSeparatorRow);
             if (row < statusRow) {
                 this.deps.mouseController.renderedRowTexts.set(row, separatorText);
-                appendFrameOutput("inputStatus", row, this.renderFrameRow(row, this.deps.screenStyler.styleLine(row, separatorText, columns, {
+                appendFrameOutput(row, this.renderFrameRow(row, this.deps.screenStyler.styleLine(row, separatorText, columns, {
                     foreground: this.deps.theme.colors.tabBorder,
                 })));
             }
@@ -164,7 +150,7 @@ export class AppRenderController {
             this.deps.mouseController.renderedRowTexts.set(row, inputLine);
             const tagColor = this.deps.theme.colors.accent;
             const styledLine = this.deps.screenStyler.styleInputLine(row, inputLine, tagSpans, suggestionSpans, columns, tagColor, this.deps.theme.colors.muted);
-            appendFrameOutput("inputStatus", row, this.renderFrameRow(row, styledLine));
+            appendFrameOutput(row, this.renderFrameRow(row, styledLine));
         }
         if (renderedInput.scrollBar && columns > 0) {
             const scrollBar = renderedInput.scrollBar;
@@ -172,7 +158,7 @@ export class AppRenderController {
                 const row = toScreenRow(inputStartRow + renderedInput.editorStartRowOffset + offset);
                 const isThumb = offset >= scrollBar.top && offset < scrollBar.top + scrollBar.height;
                 const marker = isThumb ? " " : "│";
-                appendFrameOutput("inputStatus", row, `\x1b[${row};${columns}H${colorize(marker, {
+                appendFrameOutput(row, `\x1b[${row};${columns}H${colorize(marker, {
                     foreground: this.deps.theme.colors.inputBorder,
                     ...(isThumb ? { background: this.deps.theme.colors.inputBorder } : {}),
                 })}`);
@@ -182,7 +168,7 @@ export class AppRenderController {
             const separatorText = inputFrameLine(columns, "bottom");
             const row = toScreenRow(inputBottomSeparatorRow);
             this.deps.mouseController.renderedRowTexts.set(row, separatorText);
-            appendFrameOutput("inputStatus", row, this.renderFrameRow(row, this.deps.screenStyler.styleLine(row, separatorText, columns, {
+            appendFrameOutput(row, this.renderFrameRow(row, this.deps.screenStyler.styleLine(row, separatorText, columns, {
                 foreground: this.deps.theme.colors.tabBorder,
             })));
         }
@@ -198,16 +184,16 @@ export class AppRenderController {
                 this.deps.mouseController.renderedImageTargets.set(row, rendered.line.imageTargets);
             this.deps.mouseController.renderedRowTexts.set(row, rendered.text);
             setRenderedBackground(row, rendered.line?.backgroundOverride);
-            appendFrameOutput("inputStatus", row, this.renderFrameRow(row, rendered.output(row)));
+            appendFrameOutput(row, this.renderFrameRow(row, rendered.output(row)));
         }
         const statusLayout = this.deps.statusLineRenderer.layout(columns);
         this.updateStatusMouseState(statusLayout, statusRow);
-        appendFrameOutput("inputStatus", statusRow, this.renderFrameRow(statusRow, this.deps.statusLineRenderer.render(statusRow, statusLayout, columns)));
+        appendFrameOutput(statusRow, this.renderFrameRow(statusRow, this.deps.statusLineRenderer.render(statusRow, statusLayout, columns)));
         const voiceProgressOverlay = this.renderVoiceProgressOverlay(this.deps.voiceProgressOverlayText(), columns, statusRow);
         if (voiceProgressOverlay) {
             this.deps.mouseController.renderedRowTexts.set(voiceProgressOverlay.row, voiceProgressOverlay.text);
             setRenderedBackground(voiceProgressOverlay.row, this.deps.theme.colors.info);
-            appendFrameOutput(regionForOverlayRow(voiceProgressOverlay.row), voiceProgressOverlay.row, this.renderFrameRow(voiceProgressOverlay.row, voiceProgressOverlay.output));
+            appendFrameOutput(voiceProgressOverlay.row, this.renderFrameRow(voiceProgressOverlay.row, voiceProgressOverlay.output));
         }
         if (defaultOverlayLines.length > 0 && popupMenuPlacement === "default") {
             const overlayStartRow = Math.max(1, inputSeparatorRow - defaultOverlayLines.length);
@@ -219,7 +205,7 @@ export class AppRenderController {
                 this.deps.mouseController.renderedTargets.set(row, line?.target ?? fallbackTarget);
                 this.deps.mouseController.renderedRowTexts.set(row, this.deps.popupMenus.overlayPlainText(line ?? { text: "" }, columns));
                 setRenderedBackground(row, line?.backgroundOverride);
-                appendFrameOutput(regionForOverlayRow(row), row, this.renderFrameRow(row, this.deps.popupMenus.styleOverlayLine(row, line ?? { text: "" }, columns)));
+                appendFrameOutput(row, this.renderFrameRow(row, this.deps.popupMenus.styleOverlayLine(row, line ?? { text: "" }, columns)));
             }
         }
         if (underTabsOverlayLines.length > 0 && popupMenuPlacement === "under-tabs") {
@@ -231,7 +217,7 @@ export class AppRenderController {
                 this.deps.mouseController.renderedTargets.set(row, line?.target ?? fallbackTarget);
                 this.deps.mouseController.renderedRowTexts.set(row, this.deps.popupMenus.overlayPlainText(line ?? { text: "" }, columns));
                 setRenderedBackground(row, line?.backgroundOverride);
-                appendFrameOutput(regionForOverlayRow(row), row, this.renderFrameRow(row, this.deps.popupMenus.styleOverlayLine(row, line ?? { text: "" }, columns)));
+                appendFrameOutput(row, this.renderFrameRow(row, this.deps.popupMenus.styleOverlayLine(row, line ?? { text: "" }, columns)));
             }
         }
         for (const toastOverlay of renderToastOverlays(visibleToastStates(this.deps.toastController), columns, Math.max(0, statusRow - topReservedRows - 1), this.deps.theme)) {
@@ -240,7 +226,7 @@ export class AppRenderController {
             if (toastOverlay.target)
                 this.deps.mouseController.renderedTargets.set(row, toastOverlay.target);
             this.deps.mouseController.renderedRowTexts.set(row, overlayText(rowText, toastOverlay.column, toastOverlay.text));
-            appendFrameOutput(regionForOverlayRow(row), row, `\x1b[${row};${toastOverlay.column}H${toastOverlay.output}`);
+            appendFrameOutput(row, `\x1b[${row};${toastOverlay.column}H${toastOverlay.output}`);
         }
         if (topReservedRows === 0) {
             const newTabTarget = tabLayout.targets.find((target) => target.kind === "new-tab");
@@ -248,7 +234,7 @@ export class AppRenderController {
                 const plusColumn = newTabTarget.endColumn - stringDisplayWidth(APP_ICONS.plus);
                 const rowText = this.deps.mouseController.renderedRowTexts.get(tabRow) ?? "";
                 this.deps.mouseController.renderedRowTexts.set(tabRow, overlayText(rowText, plusColumn, APP_ICONS.plus));
-                appendFrameOutput(regionForOverlayRow(tabRow), tabRow, `\x1b[${tabRow};${plusColumn}H${colorize(APP_ICONS.plus, {
+                appendFrameOutput(tabRow, `\x1b[${tabRow};${plusColumn}H${colorize(APP_ICONS.plus, {
                     foreground: this.deps.theme.colors.info,
                     bold: true,
                 })}`);
@@ -258,11 +244,8 @@ export class AppRenderController {
         const cursor = renderedInput.cursorVisible ? `\x1b[${cursorRow};${renderedInput.cursorColumn}H${SHOW_CURSOR}` : "";
         if (this.deps.mouseController.consumeClickFlashDirty?.())
             this.outputBuffer.reset();
-        const output = this.outputBuffer.diffFrame({
-            tabs: frameLines.tabs.join(""),
-            conversation: frameLines.conversation.join(""),
-            inputStatus: frameLines.inputStatus.join(""),
-        });
+        const frame = [...frameRows.entries()].map(([row, output]) => ({ row, output }));
+        const output = this.outputBuffer.diffFrame(frame);
         process.stdout.write(`${DISABLE_TERMINAL_WRAP}${HIDE_CURSOR}${output}${this.renderClickFlashOverlay(columns, rows)}${cursor}`);
     }
     renderFrameRow(row, output) {

package/dist/app/rendering/status-line-renderer.d.ts

@@ -71,6 +71,7 @@ export declare class StatusLineRenderer {
     private pushVoiceWidgetSegment;
     private pushWorkspaceSegments;
     private pushModelUsageSegments;
+    private pushResetDurationSegments;
     private modelUsageHasWarning;
     private modelUsageResetLength;
     private pushSegment;

package/dist/app/rendering/status-line-renderer.js

@@ -501,8 +501,20 @@ export class StatusLineRenderer {
             if (warningStart !== undefined) {
                 this.pushSegment(segments, warningStart, APP_ICONS.alert.length, this.host.theme.colors.warning);
             }
-            const resetLength = this.modelUsageResetLength(modelUsageLabel, resetStart - labelStart);
-            this.pushSegment(segments, resetStart, resetLength, this.host.theme.colors.muted);
+            const localResetStart = resetStart - labelStart;
+            const resetLength = this.modelUsageResetLength(modelUsageLabel, localResetStart);
+            const resetText = modelUsageLabel.slice(localResetStart, localResetStart + resetLength);
+            this.pushResetDurationSegments(segments, resetStart, resetText);
+        }
+    }
+    pushResetDurationSegments(segments, resetStart, resetText) {
+        const colors = this.host.theme.colors;
+        const muted = colors.muted;
+        const bright = colors.statusForeground;
+        for (const match of resetText.matchAll(/\d+|\D+/gu)) {
+            const text = match[0];
+            const localStart = match.index ?? 0;
+            this.pushSegment(segments, resetStart + localStart, text.length, /\d/.test(text) ? bright : muted);
         }
     }
     modelUsageHasWarning(modelUsageLabel, localStart) {

package/dist/app/runtime.js

@@ -226,7 +226,12 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
         const effectiveModelRef = resolvePixRuntimeModelRef(options, sessionManager, config);
         const parsedModel = effectiveModelRef ? parseModelRef(effectiveModelRef) : undefined;
         const initialThinkingLevel = resolvePixRuntimeInitialThinkingLevel(options, sessionManager, config);
-        const services = reusableServices && sameRuntimeServiceTarget(reusableServices, cwd, agentDir)
+        // Only reuse services for the initial session. Session replacements
+        // (switchSession/newSession/fork) must get fresh services so extensions
+        // are re-loaded with a fresh pi — otherwise handlers capture the old,
+        // invalidated pi and throw stale-ctx errors on the next session_start.
+        const isInitialSession = !sessionStartEvent || sessionStartEvent.reason === "startup";
+        const services = isInitialSession && reusableServices && sameRuntimeServiceTarget(reusableServices, cwd, agentDir)
             ? reusableServices
             : await createPixRuntimeServices({
                 cwd,
@@ -266,7 +271,12 @@ export async function createPixRuntime(options, runtimeOptions = {}) {
         return {
             ...created,
             services,
-            diagnostics: services.diagnostics,
+            // Snapshot diagnostics per-runtime. When services are reused across
+            // tabs (reuseServicesFrom), services.diagnostics is a shared array —
+            // giving each runtime its own copy prevents one tab's creation
+            // errors (model-not-found, extension flags, provider registration)
+            // from leaking into another tab's diagnostics surface.
+            diagnostics: [...(services.diagnostics ?? [])],
         };
     };
     return await createAgentSessionRuntime(createRuntime, {

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

@@ -992,6 +992,8 @@ function selectedConversationLineText(rendered, text, startColumn, endColumn) {
     const selectsWholeLine = startColumn <= 1 && endColumn >= text.length + 1;
     if (selectsWholeLine && rendered?.copyText !== undefined)
         return rendered.copyText;
+    if (rendered?.copyText !== undefined)
+        return sliceByDisplayColumns(rendered.copyText, startColumn, endColumn).trimEnd();
     return sliceByDisplayColumns(text, startColumn, endColumn).trimEnd();
 }
 function orderedConversationSelection(anchor, current) {

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

@@ -41,6 +41,13 @@ export type AppSessionEventControllerHost = {
     setSessionActivity(activity: SessionActivity): void;
     updateQueuedMessageStatus(): void;
     flushAutoUserMessages(): void;
+    /**
+     * Emit a signal onto the active runtime's extension event bus. The SDK
+     * strips retry/streaming state from the events it forwards to extensions,
+     * so this is how the renderer informs extensions (terminal-bell, todo)
+     * about lifecycle state such as an auto-retry being in progress.
+     */
+    emitExtensionEvent(channel: string, data: unknown): void;
     prepareWorkspaceMutation(toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
     recordWorkspaceMutationForUserEntry(entryId: string, mutation: WorkspaceMutation): void;
     workspaceMutationFromToolExecution(input: {

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

@@ -4,8 +4,12 @@ import { customMessageEntry, loadSessionHistoryEntries, loadSessionHistoryEntrie
 import { sessionHistoryDisplayMessages, sessionHistoryDisplayMessagesFromEntries, sessionHistoryFullBranchEntries } from "./pix-system-message.js";
 import { THINKING_TOOL_NAME } from "../constants.js";
 import { isRecord } from "../guards.js";
-const DCP_MESSAGE_REFERENCE_PREFIX = "[dcp-id]: # (m";
-const DCP_BLOCK_REFERENCE_PREFIX = "[dcp-block-id]: # (b";
+/**
+ * Event bus channel the renderer emits to inform extensions that the session is
+ * in an auto-retry cycle. Payload: `{ active: boolean }`. Extensions cannot see
+ * retry state via the SDK's extension events, so the renderer relays it here.
+ */
+const RETRY_ACTIVE_EVENT = "pix:retry-active";
 const MAX_HISTORY_WINDOW_ENTRIES = 360;
 const HISTORY_WINDOW_TARGET_ENTRIES = 300;
 const HISTORY_WINDOW_SHIFT_ENTRIES = 50;
@@ -265,11 +269,13 @@ export class AppSessionEventController {
             case "auto_retry_start":
                 this.host.setSessionActivity("running");
                 this.host.setStatus(`retry ${event.attempt}/${event.maxAttempts}`);
+                this.host.emitExtensionEvent(RETRY_ACTIVE_EVENT, { active: true });
                 break;
             case "auto_retry_end":
                 this.host.setSessionActivity(this.host.runtime()?.session.isStreaming ? "running" : "idle");
                 this.host.restoreSessionStatus();
                 this.host.flushAutoUserMessages();
+                this.host.emitExtensionEvent(RETRY_ACTIVE_EVENT, { active: false });
                 this.host.showToast(event.success ? "Retry succeeded" : `Retry failed: ${event.finalError}`, event.success ? "success" : "error");
                 break;
             default:
@@ -1021,23 +1027,14 @@ function shouldDropAssistantStreamLine(line, hasVisibleText) {
 function shouldHoldAssistantStreamTail(text, hasVisibleText) {
     if (text.trim().length === 0)
         return !hasVisibleText;
-    return isPotentialDcpMetadataLine(text);
+    return false;
 }
 function shouldHoldAssistantStreamWhitespaceTail(text, hasVisibleText) {
     return hasVisibleText && text.trim().length === 0;
 }
 function isHiddenMarkdownMetadataLine(line) {
-    return isMarkdownReferenceDefinition(line) || isPotentialDcpMetadataLine(line);
+    return isMarkdownReferenceDefinition(line);
 }
 function isMarkdownReferenceDefinition(line) {
     return /^ {0,3}\[[^\]\n]+\]:[ \t]*\S.*$/u.test(line);
 }
-function isPotentialDcpMetadataLine(line) {
-    const content = line.replace(/^ {0,3}/u, "");
-    if (content.length === 0)
-        return false;
-    return isPotentialDcpReference(content, DCP_MESSAGE_REFERENCE_PREFIX) || isPotentialDcpReference(content, DCP_BLOCK_REFERENCE_PREFIX);
-}
-function isPotentialDcpReference(content, markerPrefix) {
-    return markerPrefix.startsWith(content) || (content.startsWith(markerPrefix) && /^\d*\)?$/u.test(content.slice(markerPrefix.length)));
-}

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

@@ -61,6 +61,7 @@ export declare class AppSessionLifecycleController {
     constructor(host: AppSessionLifecycleHost);
     start(): Promise<void>;
     bindCurrentSession(options?: BindCurrentSessionOptions): Promise<void>;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime | undefined): Promise<void>;
     unsubscribeSession(): void;
     afterSessionReplacement(message?: string): void;
     private loadReplacementHistory;

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

@@ -85,6 +85,13 @@ export class AppSessionLifecycleController {
         }
         await bindPromise;
     }
+    async awaitCurrentSessionExtensions(runtime = this.host.runtime()) {
+        if (!runtime)
+            return;
+        if (this.extensionBindRuntime !== runtime || this.extensionBindSession !== runtime.session)
+            return;
+        await this.extensionBindPromise;
+    }
     unsubscribeSession() {
         this.unsubscribe?.();
     }

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

@@ -18,6 +18,7 @@ export type AppTabsControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     createRuntimeForNewSession(): Promise<AgentSessionRuntime>;
     createRuntimeForSession(sessionPath: string): Promise<AgentSessionRuntime>;
+    awaitCurrentSessionExtensions?(runtime?: AgentSessionRuntime): Promise<void>;
     activateRuntime(runtime: AgentSessionRuntime, options?: BindCurrentSessionOptions): Promise<void>;
     disposeRuntime(runtime: AgentSessionRuntime): Promise<void>;
     isRunning(): boolean;

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

@@ -730,6 +730,7 @@ export class AppTabsController {
         this.activeTabId = tab.id;
         this.host.setStatus("starting new session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions?.(runtime);
         const result = await runtime.newSession();
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });

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

@@ -138,6 +138,7 @@ export class AppTerminalController {
         timer.unref();
     }
     onResize = () => {
+        this.host.resetRenderOutputBuffer();
         this.host.render();
     };
     onInputData = (chunk) => {

package/dist/app/terminal/terminal-output-buffer.d.ts

@@ -1,20 +1,22 @@
 export declare const DISABLE_TERMINAL_OUTPUT_BUFFER_ENV = "PIX_DISABLE_TERMINAL_OUTPUT_BUFFER";
 export declare const TERMINAL_OUTPUT_BUFFER_ENV = "PIX_TERMINAL_OUTPUT_BUFFER";
-declare const FRAME_REGIONS: readonly ["tabs", "conversation", "inputStatus"];
-export type TerminalOutputFrameRegion = typeof FRAME_REGIONS[number];
-export type TerminalOutputRegion = TerminalOutputFrameRegion | "statusLine";
-export type TerminalOutputFrame = Partial<Record<TerminalOutputFrameRegion, string>>;
+export type TerminalOutputFrameRow = {
+    row: number;
+    output: string;
+};
+export type TerminalOutputFrame = readonly TerminalOutputFrameRow[];
+export type TerminalOutputRegion = "statusLine";
 export type TerminalOutputBufferOptions = {
     enabled?: boolean;
     env?: Record<string, string | undefined>;
 };
 export declare class TerminalOutputBuffer {
     private readonly enabled;
-    private readonly previousByRegion;
+    private readonly previousByRow;
+    private previousStatusLine;
     constructor(options?: TerminalOutputBufferOptions);
     diffFrame(frame: TerminalOutputFrame): string;
     diff(region: TerminalOutputRegion, output: string): string;
     reset(): void;
 }
 export declare function terminalOutputBufferDisabled(env?: Record<string, string | undefined>): boolean;
-export {};

package/dist/app/terminal/terminal-output-buffer.js

@@ -1,41 +1,49 @@
 export const DISABLE_TERMINAL_OUTPUT_BUFFER_ENV = "PIX_DISABLE_TERMINAL_OUTPUT_BUFFER";
 export const TERMINAL_OUTPUT_BUFFER_ENV = "PIX_TERMINAL_OUTPUT_BUFFER";
-const FRAME_REGIONS = ["tabs", "conversation", "inputStatus"];
+const ANSI_RESET = "\x1b[0m";
+const CLEAR_LINE_PREFIX = (row) => `\x1b[${row};1H${ANSI_RESET}\x1b[2K`;
 export class TerminalOutputBuffer {
     enabled;
-    previousByRegion = new Map();
+    previousByRow = new Map();
+    previousStatusLine;
     constructor(options = {}) {
         this.enabled = options.enabled ?? !terminalOutputBufferDisabled(options.env ?? process.env);
     }
     diffFrame(frame) {
-        const outputByRegion = {
-            tabs: frame.tabs ?? "",
-            conversation: frame.conversation ?? "",
-            inputStatus: frame.inputStatus ?? "",
-        };
         if (!this.enabled)
-            return FRAME_REGIONS.map((region) => outputByRegion[region]).join("");
+            return frame.map((entry) => entry.output).join("");
         const chunks = [];
-        for (const region of FRAME_REGIONS) {
-            const output = outputByRegion[region];
-            if (this.previousByRegion.get(region) === output)
+        const seenRows = new Set();
+        for (const { row, output } of frame) {
+            seenRows.add(row);
+            if (this.previousByRow.get(row) === output)
                 continue;
-            this.previousByRegion.set(region, output);
+            this.previousByRow.set(row, output);
             if (output.length > 0)
                 chunks.push(output);
         }
+        for (const row of this.previousByRow.keys()) {
+            if (seenRows.has(row))
+                continue;
+            this.previousByRow.delete(row);
+            chunks.push(CLEAR_LINE_PREFIX(row));
+        }
         return chunks.join("");
     }
     diff(region, output) {
         if (!this.enabled)
             return output;
-        if (this.previousByRegion.get(region) === output)
-            return "";
-        this.previousByRegion.set(region, output);
+        if (region === "statusLine") {
+            if (this.previousStatusLine === output)
+                return "";
+            this.previousStatusLine = output;
+            return output;
+        }
         return output;
     }
     reset() {
-        this.previousByRegion.clear();
+        this.previousByRow.clear();
+        this.previousStatusLine = undefined;
     }
 }
 export function terminalOutputBufferDisabled(env = process.env) {

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

@@ -4,6 +4,7 @@ import { type WorkspaceMutation, type WorkspaceMutationFromToolInput, type Works
 export type AppWorkspaceActionsControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     findUserEntry(entryId: string): Extract<Entry, {
         kind: "user";
     }> | undefined;