pi-ui-extend 0.1.36 → 0.1.37

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/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) {