pi-ui-extend 0.1.33 → 0.1.35

package/README.md

@@ -160,6 +160,26 @@ Before committing code changes, run:
 npm run check
 ```
 
+### Keeping the bundled extension's SDK pin in sync
+
+Pix bundles the `pi-tools-suite` extension (in `external/pi-tools-suite`), which
+runs inside the Pi host process. Its `@earendil-works/*` peerDependencies must
+match the host Pi SDK version exactly, or npm can resolve a stale copy in the
+suite's own `node_modules` and cause a double-load (e.g. `0.75.4` in the suite
+vs `0.79.4` in the host).
+
+When you bump the Pi SDK in the root `package.json`, re-pin the suite and
+reinstall it:
+
+```bash
+npm run sync:sdk-pin                                          # rewrite suite peerDeps to host version
+cd external/pi-tools-suite && npm install --ignore-scripts    # update suite lockfile/node_modules
+```
+
+`npm run check` runs `npm run sync:sdk-pin:check` first, so a stale pin fails
+the check fast. Use `npm run sync:sdk-pin:check` on its own for a drift-only
+report (non-zero exit on drift).
+
 ## Configuration
 
 Useful environment variables:

package/dist/app/app.js

@@ -166,7 +166,7 @@ export class PiUiExtendApp {
             maxProjectSessions: () => this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
-            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options)),
+            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options), this.runtime === undefined ? {} : { reuseServicesFrom: this.runtime }),
             createRuntimeForSession: (sessionPath) => this.createRuntime({
                 ...this.options,
                 noSession: false,
@@ -334,6 +334,7 @@ export class PiUiExtendApp {
         });
         this.todoWidgetController = new AppTodoWidgetController({
             sessionFile: () => this.runtime?.session.sessionFile,
+            sessionId: () => this.runtime?.session.sessionId,
             isRunning: () => this.running,
             render: () => this.scheduleRender(),
         });
@@ -761,10 +762,11 @@ export class PiUiExtendApp {
         });
         this.slashCommands = this.commandController.slashCommands;
     }
-    createRuntime(options) {
+    createRuntime(options, runtimeOptions = {}) {
         return createPixRuntime(options, {
             eventBus: this.createExtensionEventBus(),
             config: this.pixConfig,
+            ...runtimeOptions,
         });
     }
     async loadStartupConfig() {

package/dist/app/constants.d.ts

@@ -19,7 +19,8 @@ export declare const REQUEST_HISTORY_VERSION = 1;
 export declare const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export declare const REQUEST_HISTORY_MAX_BYTES: number;
 export declare const REQUEST_HISTORY_MAX_ENTRY_BYTES: number;
-export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[>4;2m";
+export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[?u\u001B[c";
+export declare const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\u001B[>4;2m";
 export declare const DISABLE_TERMINAL_KEY_REPORTING = "\u001B[<u\u001B[>4;0m";
 export declare const ENABLE_BRACKETED_PASTE = "\u001B[?2004h";
 export declare const DISABLE_BRACKETED_PASTE = "\u001B[?2004l";

package/dist/app/constants.js

@@ -52,7 +52,12 @@ export const REQUEST_HISTORY_VERSION = 1;
 export const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export const REQUEST_HISTORY_MAX_BYTES = 128 * 1024;
 export const REQUEST_HISTORY_MAX_ENTRY_BYTES = 16 * 1024;
-export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[>4;2m";
+// Match pi/@earendil-works/pi-tui keyboard setup: request Kitty keyboard
+// protocol flags, query the terminal response, and use xterm modifyOtherKeys
+// only as a response-driven fallback. Enabling both protocols blindly can make
+// terminals disagree about modified Enter reporting.
+export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[?u\x1b[c";
+export const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\x1b[>4;2m";
 export const DISABLE_TERMINAL_KEY_REPORTING = "\x1b[<u\x1b[>4;0m";
 export const ENABLE_BRACKETED_PASTE = "\x1b[?2004h";
 export const DISABLE_BRACKETED_PASTE = "\x1b[?2004l";

package/dist/app/icons.js

@@ -43,7 +43,7 @@ const NERD_FONT_ICONS = {
     down: "↓",
 };
 const FALLBACK_ICONS = {
-    alert: "!",
+    alert: "⚠",
     autoFix: "*",
     check: "✓",
     checkCircle: "✓",

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

@@ -35,7 +35,7 @@ export declare class AppInputController {
     private readonly pasteHandler;
     constructor(host: InputControllerHost);
     handleChunk(chunk: Buffer): void;
-    private consumeSharedEditorShiftEnter;
+    private consumeSharedEditorInput;
     private drainInputBuffer;
     private consumeBracketedPastePayload;
     private getEscapeSequences;
@@ -45,6 +45,9 @@ export declare class AppInputController {
     private consumeCommandArrowPageSequence;
     private consumeCommandArrowPageMatch;
     private consumeTerminalEditShortcutSequence;
+    private consumeIgnoredModifiedKeySequence;
+    private consumeClipboardImagePasteSequence;
+    private consumeShiftEnterSequence;
     private consumeTerminalInterruptSequence;
     private handleArrowUp;
     private handleArrowDown;

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

@@ -1,6 +1,7 @@
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
-import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, terminalEditShortcutForControlChar } from "./terminal-edit-shortcuts.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
+const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
     inputBuffer = "";
@@ -16,7 +17,7 @@ export class AppInputController {
             this.drainInputBuffer();
             return;
         }
-        if (this.consumeSharedEditorShiftEnter(data))
+        if (this.consumeSharedEditorInput(data))
             return;
         const extensionInput = this.host.handleExtensionTerminalInput(data);
         if (extensionInput.consume)
@@ -28,17 +29,41 @@ export class AppInputController {
         this.inputBuffer += data;
         this.drainInputBuffer();
     }
-    consumeSharedEditorShiftEnter(data) {
+    consumeSharedEditorInput(data) {
         if (this.host.extensionInputUsesEditor?.() !== true)
             return false;
         if (this.host.inputEditor.isInBracketedPaste)
             return false;
-        if (!this.isShiftPressed())
-            return false;
-        if (data !== "\r" && data !== "\n")
+        if (data === "\n") {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\r" && this.isShiftPressed()) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (SHIFT_ENTER_ESCAPE_SEQUENCES.includes(data)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\x16") {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        const modifiedKey = parseTerminalModifiedKeySequence(data);
+        if (modifiedKey.kind !== "key")
             return false;
-        this.insertInputNewline();
-        return true;
+        if (terminalKeyShouldIgnore(modifiedKey.key))
+            return true;
+        if (terminalKeyIsShiftEnter(modifiedKey.key)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (terminalKeyIsClipboardImagePaste(modifiedKey.key)) {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        return false;
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {
@@ -72,11 +97,26 @@ export class AppInputController {
                 continue;
             if (terminalInterruptSequence === "pending")
                 return;
+            const shiftEnterSequence = this.consumeShiftEnterSequence();
+            if (shiftEnterSequence === "consumed")
+                continue;
+            if (shiftEnterSequence === "pending")
+                return;
+            const clipboardImagePasteSequence = this.consumeClipboardImagePasteSequence();
+            if (clipboardImagePasteSequence === "consumed")
+                continue;
+            if (clipboardImagePasteSequence === "pending")
+                return;
             const terminalEditShortcutSequence = this.consumeTerminalEditShortcutSequence();
             if (terminalEditShortcutSequence === "consumed")
                 continue;
             if (terminalEditShortcutSequence === "pending")
                 return;
+            const ignoredModifiedKeySequence = this.consumeIgnoredModifiedKeySequence();
+            if (ignoredModifiedKeySequence === "consumed")
+                continue;
+            if (ignoredModifiedKeySequence === "pending")
+                return;
             if (this.consumeEscapeSequence())
                 continue;
             if (this.isPendingEscapeSequence())
@@ -106,13 +146,9 @@ export class AppInputController {
     }
     getEscapeSequences() {
         return [
-            ["\x1b[13;2u", () => this.insertInputNewline()],
-            ["\x1b[13;2~", () => this.insertInputNewline()],
-            ["\x1b[27;2;13~", () => this.insertInputNewline()],
+            ...SHIFT_ENTER_ESCAPE_SEQUENCES.map((sequence) => [sequence, () => this.insertInputNewline()]),
             ["\x1b[13u", () => this.host.handleEnter()],
             ["\x1b[13;1u", () => this.host.handleEnter()],
-            ["\x1b\r", () => this.insertInputNewline()],
-            ["\x1b\n", () => this.insertInputNewline()],
             ["\x1b[5~", () => this.host.scrollByPage(-1)],
             ["\x1b[6~", () => this.host.scrollByPage(1)],
             ["\x1b[A", () => this.handleArrowUp()],
@@ -139,8 +175,6 @@ export class AppInputController {
             ["\x1b[201~", () => this.pasteHandler.endBracketedPaste()],
             ["\x1b[1;2H", () => { this.host.inputEditor.moveToLineStartExtend(); this.host.render(); }],
             ["\x1b[1;2F", () => { this.host.inputEditor.moveToLineEndExtend(); this.host.render(); }],
-            ["\x1b[118;5u", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
-            ["\x1b[27;5;118~", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
             ["\x1b[122;9u", () => this.undoInput()],
             ["\x1b[27;9;122~", () => this.undoInput()],
             ["\x1b[90;10u", () => this.redoInput()],
@@ -232,6 +266,43 @@ export class AppInputController {
         }
         return "consumed";
     }
+    consumeIgnoredModifiedKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyShouldIgnore(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        return "consumed";
+    }
+    consumeClipboardImagePasteSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsClipboardImagePaste(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            void this.pasteHandler.handleClipboardImagePaste();
+        return "consumed";
+    }
+    consumeShiftEnterSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsShiftEnter(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            this.insertInputNewline();
+        return "consumed";
+    }
     consumeTerminalInterruptSequence() {
         const result = parseTerminalInterruptSequence(this.inputBuffer);
         if (result.kind === "pending")
@@ -401,7 +472,15 @@ export class AppInputController {
             this.host.toggleVoiceRecording();
             return;
         }
-        if (char === "\r" || char === "\n") {
+        if (char === "\n") {
+            if (this.host.inputEditor.isInBracketedPaste) {
+                this.pasteHandler.appendBracketedPasteText("\n");
+                return;
+            }
+            this.insertInputNewline();
+            return;
+        }
+        if (char === "\r") {
             if (this.host.inputEditor.isInBracketedPaste) {
                 this.pasteHandler.appendBracketedPasteText("\n");
                 return;

package/dist/app/input/input-paste-handler.js

@@ -92,8 +92,10 @@ export class InputPasteHandler {
         return false;
     }
     handlePasteEnd(text) {
-        if (!text)
+        if (!text) {
+            void this.handleClipboardImagePaste();
             return;
+        }
         const filePath = this.plainPasteFilePath(text);
         if (filePath) {
             if (isImagePath(filePath) && Date.now() < this.suppressImagePathPasteUntil) {

package/dist/app/input/terminal-edit-shortcuts.d.ts

@@ -1,4 +1,12 @@
 export type TerminalEditShortcut = "undo" | "redo";
+export type ParsedTerminalModifiedKeyResult = {
+    readonly kind: "key";
+    readonly key: ParsedModifiedKey;
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "none";
+};
 export type TerminalEditShortcutSequenceResult = {
     readonly kind: "shortcut";
     readonly shortcut: TerminalEditShortcut;
@@ -11,6 +19,14 @@ export type TerminalEditShortcutSequenceResult = {
 } | {
     readonly kind: "none";
 };
+interface ParsedModifiedKey {
+    readonly codepoint: number;
+    readonly baseLayoutKey: number | undefined;
+    readonly modifier: number;
+    readonly eventType: number | undefined;
+    readonly length: number;
+}
+export declare function parseTerminalModifiedKeySequence(input: string): ParsedTerminalModifiedKeyResult;
 export declare function parseTerminalEditShortcutSequence(input: string): TerminalEditShortcutSequenceResult;
 export declare function parseTerminalInterruptSequence(input: string): {
     readonly kind: "interrupt";
@@ -20,4 +36,8 @@ export declare function parseTerminalInterruptSequence(input: string): {
 } | {
     readonly kind: "none";
 };
+export declare function terminalKeyIsShiftEnter(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyIsClipboardImagePaste(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyShouldIgnore(key: ParsedModifiedKey): boolean;
 export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;
+export {};

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

@@ -3,34 +3,60 @@ const CONTROL_MODIFIER_FLAG = 4;
 const COMMAND_MODIFIER_FLAG = 8;
 const LOCK_MODIFIER_MASK = 64 + 128;
 const KEY_CODE_C = 99;
+const KEY_CODE_ENTER = 13;
+const KEY_CODE_V = 118;
 const KEY_CODE_Y = 121;
 const KEY_CODE_Z = 122;
 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_CSI_U_SEQUENCE = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u/;
 const XTERM_MODIFY_OTHER_KEYS_SEQUENCE = /^\x1b\[27;(\d+);(\d+)~/;
-export function parseTerminalEditShortcutSequence(input) {
+export function parseTerminalModifiedKeySequence(input) {
     const kitty = parseKittyCsiUSequence(input);
     if (kitty)
-        return terminalEditShortcutResult(kitty);
+        return { kind: "key", key: kitty };
     const xterm = parseXtermModifyOtherKeysSequence(input);
     if (xterm)
-        return terminalEditShortcutResult(xterm);
-    if (isPotentialEditShortcutPrefix(input))
+        return { kind: "key", key: xterm };
+    if (isPotentialModifiedKeyPrefix(input))
         return { kind: "pending" };
     return { kind: "none" };
 }
+export function parseTerminalEditShortcutSequence(input) {
+    const result = parseTerminalModifiedKeySequence(input);
+    if (result.kind === "pending")
+        return { kind: "pending" };
+    if (result.kind === "none")
+        return { kind: "none" };
+    return terminalEditShortcutResult(result.key);
+}
 export function parseTerminalInterruptSequence(input) {
-    const kitty = parseKittyCsiUSequence(input);
-    if (kitty && terminalKeyIsControlC(kitty))
-        return { kind: "interrupt", length: kitty.length };
-    const xterm = parseXtermModifyOtherKeysSequence(input);
-    if (xterm && terminalKeyIsControlC(xterm))
-        return { kind: "interrupt", length: xterm.length };
-    if (isPotentialInterruptPrefix(input))
+    const result = parseTerminalModifiedKeySequence(input);
+    if (result.kind === "pending")
         return { kind: "pending" };
+    if (result.kind === "key" && terminalKeyIsControlC(result.key))
+        return { kind: "interrupt", length: result.key.length };
+    if (result.kind === "key" || isPotentialInterruptPrefix(input))
+        return { kind: "none" };
     return { kind: "none" };
 }
+export function terminalKeyIsShiftEnter(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & SHIFT_MODIFIER_FLAG) === 0)
+        return false;
+    return terminalKeyMatchesCodepoint(key, KEY_CODE_ENTER);
+}
+export function terminalKeyIsClipboardImagePaste(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if ((effectiveModifier & (CONTROL_MODIFIER_FLAG | COMMAND_MODIFIER_FLAG)) === 0)
+        return false;
+    return terminalKeyMatchesCodepoint(key, KEY_CODE_V, CYRILLIC_SMALL_EM_CODE, CYRILLIC_CAPITAL_EM_CODE);
+}
+export function terminalKeyShouldIgnore(key) {
+    return key.eventType === 3;
+}
 export function terminalEditShortcutForControlChar(char, shiftPressed) {
     if (char === "\u001a")
         return shiftPressed ? "redo" : "undo";
@@ -95,6 +121,17 @@ function interruptCodepointIsC(codepoint) {
     const normalized = normalizeLetterCodepoint(codepoint);
     return normalized === KEY_CODE_C || normalized === CYRILLIC_SMALL_ES_CODE || normalized === CYRILLIC_CAPITAL_ES_CODE;
 }
+function terminalKeyMatchesCodepoint(key, ...expectedCodepoints) {
+    return expectedCodepoints.some((codepoint) => keyMatchesCodepoint(key, codepoint));
+}
+function keyMatchesCodepoint(key, expectedCodepoint) {
+    const normalizedExpected = normalizeLetterCodepoint(expectedCodepoint);
+    const primary = normalizeLetterCodepoint(key.codepoint);
+    if (primary === normalizedExpected)
+        return true;
+    const baseLayout = key.baseLayoutKey;
+    return baseLayout !== undefined && normalizeLetterCodepoint(baseLayout) === normalizedExpected;
+}
 function terminalEditShortcutForKey(key, effectiveModifier) {
     const codepoint = editShortcutCodepoint(key);
     if (codepoint === KEY_CODE_Y)
@@ -114,16 +151,13 @@ function normalizeLetterCodepoint(codepoint) {
         return codepoint + 32;
     return codepoint;
 }
-function isPotentialEditShortcutPrefix(input) {
+function isPotentialModifiedKeyPrefix(input) {
     if (!input.startsWith("\x1b["))
         return false;
     if (input.includes("u") || input.includes("~"))
         return false;
     const body = input.slice(2);
-    if (!/^[\d:;]*$/.test(body))
-        return false;
-    const possibleStarts = ["122", "121", "90", "27;"];
-    return possibleStarts.some((start) => start.startsWith(body) || body.startsWith(start));
+    return /^[\d:;]*$/.test(body);
 }
 function isPotentialInterruptPrefix(input) {
     if (!input.startsWith("\x1b["))

package/dist/app/model/model-usage-status.d.ts

@@ -7,13 +7,14 @@ export type ModelUsageDescriptor = BaseModelUsageDescriptor & ({
 } | {
     readonly kind: "google-antigravity";
     readonly quotaModelKey: string;
-    readonly account: AntigravityQuotaAccount;
+    readonly account?: AntigravityQuotaAccount;
     readonly accounts?: readonly AntigravityQuotaAccount[];
 });
 export type ModelUsageLimitWindow = {
     readonly remainingPercent: number;
     readonly resetAt: number;
     readonly windowSeconds: number;
+    readonly hasKnownWindowDuration?: boolean;
 };
 export type ModelUsageStatus = {
     readonly modelKey: string;

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

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { formatCompactProgressBar } from "../../context-progress-bar.js";
+import { APP_ICONS } from "../icons.js";
 const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 const ZHIPU_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
@@ -35,16 +35,12 @@ export function modelUsageDescriptor(model) {
     }
     if (ANTIGRAVITY_QUOTA_PROVIDERS.has(provider)) {
         const quotaModelKey = resolveAntigravityQuotaModelKey(model);
-        const accounts = readAllAntigravityQuotaAccounts();
-        const account = readActiveAntigravityQuotaAccount(accounts);
-        if (!quotaModelKey || !account)
+        if (!quotaModelKey)
             return undefined;
         return {
             kind: "google-antigravity",
-            modelKey: `${model.provider}/${model.id}@all:${accounts.map((item) => item.cacheKey).join(",")}`,
+            modelKey: `${model.provider}/${model.id}`,
             quotaModelKey,
-            account,
-            accounts,
         };
     }
     return undefined;
@@ -395,7 +391,7 @@ export function googleAntigravityUsageStatusFromResponse(data, descriptor, now =
         modelKey: descriptor.modelKey,
         provider: "google-antigravity",
         updatedAt: now,
-        ...(descriptor.account.email ? { accountEmail: descriptor.account.email } : {}),
+        ...(descriptor.account?.email ? { accountEmail: descriptor.account.email } : {}),
         ...(weekly ? { weekly } : {}),
         ...(hourly ? { hourly } : {}),
     };
@@ -413,7 +409,9 @@ function googleAntigravityWindowFromResponse(data, quotaModelKey, now) {
 }
 async function queryGoogleAntigravityModelUsage(descriptor) {
     const now = Date.now();
-    const accounts = descriptor.accounts?.length ? descriptor.accounts : [descriptor.account];
+    const accounts = await readAllAntigravityQuotaAccounts();
+    if (accounts.length === 0)
+        return undefined;
     const windows = (await Promise.all(accounts.map(async (account) => {
         try {
             const response = await fetchGoogleAntigravityQuotaForAccount(account, now);
@@ -451,7 +449,7 @@ const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
     { label: "G3 Pro", quotaModelKey: "gemini-3.1-pro-low" },
 ];
 async function queryGoogleAntigravityAccountUsage(now) {
-    const accounts = readAllAntigravityQuotaAccounts();
+    const accounts = await readAllAntigravityQuotaAccounts();
     const results = await Promise.all(accounts.map(async (account) => {
         const accountLabel = account.email ?? maskCredential(account.refreshToken);
         try {
@@ -474,12 +472,8 @@ async function queryGoogleAntigravityAccountUsage(now) {
     }));
     return results;
 }
-function readActiveAntigravityQuotaAccount(accounts = readAllAntigravityQuotaAccounts()) {
-    const credential = readPiAuthSync().antigravity;
-    return accounts[clampAccountIndex(credential?.activeIndex, accounts.length)];
-}
-function readAllAntigravityQuotaAccounts() {
-    const credential = readPiAuthSync().antigravity;
+async function readAllAntigravityQuotaAccounts() {
+    const credential = (await readPiAuth()).antigravity;
     if (!credential)
         return [];
     const credentialClient = getGoogleOAuthClientCredentials(credential);
@@ -504,14 +498,6 @@ function readAllAntigravityQuotaAccounts() {
     }) : undefined;
     return account ? [account] : [];
 }
-function readPiAuthSync() {
-    try {
-        return JSON.parse(readFileSync(getPiAuthPath(), "utf8"));
-    }
-    catch {
-        return {};
-    }
-}
 function getAccountRefreshToken(account) {
     if (account.refreshToken)
         return account.refreshToken;
@@ -844,6 +830,7 @@ function modelUsageWindow(window, now) {
         remainingPercent: clampPercent(Math.round(100 - window.used_percent)),
         resetAt: now + Math.max(0, Math.round(window.reset_after_seconds)) * 1000,
         windowSeconds: Math.max(0, Math.round(window.limit_window_seconds)),
+        hasKnownWindowDuration: true,
     };
 }
 function accountWindowFromRateLimit(window, now) {
@@ -930,5 +917,26 @@ function maskCredential(value) {
     return `${visible.slice(0, 4)}****${visible.slice(-4)}`;
 }
 function formatUsageWindow(_prefix, window, now) {
-    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatDurationShort(window.resetAt, now)}`;
+    const warning = modelUsageWindowWillExhaustBeforeReset(window, now) ? ` ${APP_ICONS.alert}` : "";
+    return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)}${warning} ${formatDurationShort(window.resetAt, now)}`;
+}
+function modelUsageWindowWillExhaustBeforeReset(window, now) {
+    if (!window.hasKnownWindowDuration)
+        return false;
+    if (window.windowSeconds <= DAY_SECONDS)
+        return false;
+    if (window.remainingPercent <= 0)
+        return false;
+    const timeUntilResetSeconds = Math.max(0, (window.resetAt - now) / 1000);
+    const elapsedSeconds = Math.max(0, window.windowSeconds - timeUntilResetSeconds);
+    if (elapsedSeconds <= 0)
+        return false;
+    const total = 100;
+    const used = total - window.remainingPercent;
+    if (used <= 0)
+        return false;
+    const remaining = total - used;
+    const averageRate = used / elapsedSeconds;
+    const projectedSecondsUntilExhaustion = remaining / averageRate;
+    return projectedSecondsUntilExhaustion < timeUntilResetSeconds;
 }

package/dist/app/rendering/conversation-entry-renderer.d.ts

@@ -14,6 +14,7 @@ export type ConversationEntryRenderOptions = {
     availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
+    currentTimeMs?: number;
     renderInlineUserMessageMenu: (entry: Extract<Entry, {
         kind: "user";
     }>, context: InlineUserMessageMenuContext) => RenderedLine[];

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

@@ -75,7 +75,7 @@ function renderAssistantLines(text, width, options) {
     if (!displayText)
         return [];
     const { left: contentLeft, contentWidth } = horizontalPaddingLayout(width);
-    const contentLines = renderMarkdownTextLines(displayText, contentWidth, contentLeft);
+    const contentLines = renderMarkdownTextLines(displayText, contentWidth, contentLeft, { preserveWrappedWordSeparator: true });
     if (contentLines.length === 0)
         return [];
     const lines = [];

package/dist/app/rendering/conversation-tool-renderer.d.ts

@@ -8,6 +8,7 @@ export type ConversationToolRenderOptions = {
     availableThinkingLevels?: readonly string[];
     superCompactTools?: boolean;
     allThinkingExpanded?: boolean;
+    currentTimeMs?: number;
 };
 export declare function renderConversationToolEntry(entry: Extract<Entry, {
     kind: "tool";

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

@@ -56,9 +56,11 @@ export function renderThinkingEntry(entry, width, options) {
     const headerColorOverride = entry.level
         ? thinkingLevelThemeColor(entry.level, options.colors, options.availableThinkingLevels)
         : undefined;
+    const elapsed = thinkingElapsedText(entry, options.currentTimeMs ?? Date.now());
     return renderToolBlock({
         id: entry.id,
         toolName: THINKING_TOOL_NAME,
+        ...(elapsed === undefined ? {} : { headerArgs: elapsed }),
         expanded,
         status: entry.status,
         isError: false,
@@ -74,6 +76,25 @@ export function renderThinkingEntry(entry, width, options) {
         ...(headerColorOverride === undefined ? {} : { headerColorOverride }),
     });
 }
+function thinkingElapsedText(entry, currentTimeMs) {
+    if (entry.startedAt === undefined)
+        return undefined;
+    const endTimeMs = entry.finishedAt ?? currentTimeMs;
+    const elapsedMs = Math.max(0, endTimeMs - entry.startedAt);
+    return formatThinkingElapsed(elapsedMs);
+}
+function formatThinkingElapsed(elapsedMs) {
+    const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
+    const seconds = totalSeconds % 60;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 1)
+        return `${seconds}s`;
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
+    if (hours < 1)
+        return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+    return `${hours}h ${minutes.toString().padStart(2, "0")}m`;
+}
 function trimTrailingBlankLines(text) {
     return text.replace(/(?:\r?\n[ \t]*)+$/u, "");
 }