pi-ui-extend 0.1.38 → 0.1.39

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),
@@ -999,39 +1000,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/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/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,7 @@ 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";
+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}";

package/dist/markdown-format.js

@@ -1,4 +1,4 @@
-import { expandTabs, stringDisplayWidth } from "./terminal-width.js";
+import { displayGraphemes, expandTabs, stringDisplayWidth } from "./terminal-width.js";
 import { syntaxHighlightLanguageForMarkdownFence, } from "./syntax-highlight.js";
 const MIN_TRAILING_WORD_WIDTH_TO_REBALANCE = 5;
 export function formatMarkdownTables(text, maxWidth) {
@@ -211,20 +211,16 @@ function displayTokensWithRanges(text) {
     let current = "";
     let currentStart = 0;
     let currentWhitespace;
-    for (let index = 0; index < text.length;) {
-        const codePoint = text.codePointAt(index) ?? 0;
-        const char = String.fromCodePoint(codePoint);
+    for (const { text: char, start } of displayGraphemes(text)) {
         const whitespace = /\s/u.test(char);
         if (current && currentWhitespace !== whitespace) {
-            tokens.push({ text: current, start: currentStart, end: index, whitespace: currentWhitespace ?? false });
+            tokens.push({ text: current, start: currentStart, end: start, whitespace: currentWhitespace ?? false });
             current = "";
-            currentStart = index;
         }
         if (!current)
-            currentStart = index;
+            currentStart = start;
         current += char;
         currentWhitespace = whitespace;
-        index += char.length;
     }
     if (current)
         tokens.push({ text: current, start: currentStart, end: text.length, whitespace: currentWhitespace ?? false });
@@ -235,19 +231,16 @@ function wrapDisplayTokenByWidth(token, width) {
     let chunkText = "";
     let chunkStart = token.start;
     let chunkWidth = 0;
-    for (let index = token.start; index < token.end;) {
-        const codePoint = token.text.codePointAt(index - token.start) ?? 0;
-        const char = String.fromCodePoint(codePoint);
-        const charWidth = stringDisplayWidth(char);
+    for (const { text: char, width: charWidth, start } of displayGraphemes(token.text)) {
+        const absoluteStart = token.start + start;
         if (chunkText && chunkWidth + charWidth > width) {
-            chunks.push({ text: chunkText, start: chunkStart, end: index });
+            chunks.push({ text: chunkText, start: chunkStart, end: absoluteStart });
             chunkText = "";
-            chunkStart = index;
+            chunkStart = absoluteStart;
             chunkWidth = 0;
         }
         chunkText += char;
         chunkWidth += charWidth;
-        index += char.length;
     }
     chunks.push({ text: chunkText, start: chunkStart, end: token.end });
     return chunks;
@@ -506,20 +499,16 @@ function smartDisplayBreakIndex(text, width) {
     let used = 0;
     let fallbackIndex = 0;
     let breakIndex = 0;
-    for (let index = 0; index < text.length;) {
-        const codePoint = text.codePointAt(index) ?? 0;
-        const char = String.fromCodePoint(codePoint);
-        const nextIndex = index + char.length;
-        const nextUsed = used + stringDisplayWidth(char);
+    for (const { text: char, width: charWidth, start, end } of displayGraphemes(text)) {
+        const nextUsed = used + charWidth;
         if (nextUsed > width)
             break;
         used = nextUsed;
-        fallbackIndex = nextIndex;
-        if (char === "/" && index > 0)
-            breakIndex = index;
+        fallbackIndex = end;
+        if (char === "/" && start > 0)
+            breakIndex = start;
         else if (/[._:-]/u.test(char))
-            breakIndex = nextIndex;
-        index = nextIndex;
+            breakIndex = end;
     }
     return breakIndex > 0 ? breakIndex : fallbackIndex;
 }

package/dist/terminal-width.d.ts

@@ -3,6 +3,20 @@ export declare function stringDisplayWidth(text: string): number;
 export declare function sliceByDisplayWidth(text: string, width: number): string;
 export declare function displayIndexForColumn(text: string, column: number): number;
 export declare function sliceByDisplayColumns(text: string, startColumn: number, endColumn: number): string;
+export type DisplayGrapheme = {
+    text: string;
+    width: number;
+    start: number;
+    end: number;
+};
+/**
+ * Grapheme clusters of `text` with their display width and absolute string
+ * indices. Iterating graphemes (instead of code points) is required for correct
+ * width accounting: multi-codepoint emoji such as `⚠️` (U+26A0 U+FE0F), keycaps,
+ * skin-tone modifiers and regional-indicator flags are one width-2 cluster even
+ * though several of their code points have zero width.
+ */
+export declare function displayGraphemes(text: string): DisplayGrapheme[];
 export declare function padOrTrimDisplay(text: string, width: number): string;
 export declare function wrapDisplayLine(text: string, width: number): string[];
 export declare function wrapDisplayLineByWords(text: string, width: number): string[];

package/dist/terminal-width.js

@@ -1,7 +1,7 @@
 const TAB_WIDTH = 4;
 const ANSI_RESET = "\x1b[0m";
 const EMOJI_PRESENTATION_REGEX = /\p{Emoji_Presentation}/u;
-const EMOJI_REGEX = /\p{Emoji}/u;
+const REGIONAL_INDICATOR_REGEX = /[\u{1F1E6}-\u{1F1FF}]/u;
 const GRAPHEME_SEGMENTER = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(undefined, { granularity: "grapheme" }) : undefined;
 export function expandTabs(text, tabWidth = TAB_WIDTH) {
     if (!text.includes("\t"))
@@ -86,6 +86,20 @@ export function sliceByDisplayColumns(text, startColumn, endColumn) {
     const endIndex = Math.max(startIndex, displayIndexForColumn(text, endColumn));
     return text.slice(startIndex, endIndex);
 }
+/**
+ * Grapheme clusters of `text` with their display width and absolute string
+ * indices. Iterating graphemes (instead of code points) is required for correct
+ * width accounting: multi-codepoint emoji such as `⚠️` (U+26A0 U+FE0F), keycaps,
+ * skin-tone modifiers and regional-indicator flags are one width-2 cluster even
+ * though several of their code points have zero width.
+ */
+export function displayGraphemes(text) {
+    const graphemes = [];
+    for (const cluster of indexedDisplayClusters(text)) {
+        graphemes.push({ text: cluster.text, width: cluster.width, start: cluster.start, end: cluster.end });
+    }
+    return graphemes;
+}
 export function padOrTrimDisplay(text, width) {
     const safeWidth = Math.max(0, width);
     if (isPrintableAscii(text)) {
@@ -280,7 +294,22 @@ function graphemeDisplayWidth(text) {
     return width;
 }
 function isEmojiGrapheme(text) {
-    return EMOJI_PRESENTATION_REGEX.test(text) || (EMOJI_REGEX.test(text) && (text.includes("\ufe0f") || text.includes("\u20e3")));
+    // Default-presentation emoji (⛔ ✅ 🚀 ❌), supplementary pictographs, and
+    // regional-indicator flags render two cells wide in conforming terminals
+    // including iTerm2 and Zed, so they are measured at width 2.
+    if (EMOJI_PRESENTATION_REGEX.test(text))
+        return true;
+    // Keycap sequences (base + U+FE0F + U+20E3, e.g. 1️⃣) and regional-indicator
+    // pairs (🇷🇺) also occupy two cells.
+    if (text.includes("\u20e3"))
+        return true;
+    if (REGIONAL_INDICATOR_REGEX.test(text) && /[\u{1F1E6}-\u{1F1FF}]{2}/u.test(text))
+        return true;
+    // Symbols promoted to an emoji glyph only by a variation selector (⚠️ ✔️ ©️
+    // ☀️) keep their base width of 1. Their base code point is East-Asian-Width
+    // Ambiguous, and iTerm2/Zed/wcwidth render them one cell wide; counting them
+    // as 2 would misalign table columns and shorten rendered rows.
+    return false;
 }
 function codePointLength(codePoint) {
     return codePoint > 0xffff ? 2 : 1;

package/dist/theme.js

@@ -9,7 +9,7 @@ export const THEMES = {
             muted: "#7d8590",
             headerForeground: "#c9d1d9",
             headerBackground: "#161b22",
-            statusForeground: "#8b949e",
+            statusForeground: "#9ba5af",
             statusBackground: "#0f1520",
             inputForeground: "#f0f6fc",
             inputBackground: "#090d13",
@@ -64,7 +64,7 @@ export const THEMES = {
             muted: "#64748b",
             headerForeground: "#0f172a",
             headerBackground: "#e2e8f0",
-            statusForeground: "#475569",
+            statusForeground: "#566578",
             statusBackground: "#edf0f4",
             inputForeground: "#0f172a",
             inputBackground: "#f8fafc",