pi-ui-extend 0.1.9 → 0.1.11

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

@@ -9,13 +9,10 @@ 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";
 const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
-const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
 const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
-const GOOGLE_CLIENT_ID = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_ID ?? "";
-const GOOGLE_CLIENT_SECRET = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? "";
 const OPENAI_QUOTA_PROVIDERS = new Set(["openai", "openai-codex"]);
 const ZHIPU_QUOTA_PROVIDERS = new Set(["zai", "zhipuai-coding-plan"]);
 const ANTIGRAVITY_QUOTA_PROVIDERS = new Set(["antigravity", "google-antigravity"]);
@@ -401,8 +398,13 @@ export function googleAntigravityUsageStatusFromResponse(data, descriptor, now =
     };
 }
 async function queryGoogleAntigravityModelUsage(descriptor) {
-    const { access_token } = await refreshGoogleAccessToken(descriptor.account.refreshToken);
-    const response = await fetchGoogleAntigravityQuota(access_token, descriptor.account.projectId);
+    const now = Date.now();
+    const cachedResponse = googleQuotaResponseFromCachedQuota(descriptor.account.cachedQuota, descriptor.account.cachedQuotaUpdatedAt, now);
+    if (cachedResponse)
+        return googleAntigravityUsageStatusFromResponse(cachedResponse, descriptor, now);
+    if (!descriptor.account.accessToken)
+        return undefined;
+    const response = await fetchGoogleAntigravityQuota(descriptor.account.accessToken, descriptor.account.projectId);
     return googleAntigravityUsageStatusFromResponse(response, descriptor);
 }
 const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
@@ -417,10 +419,12 @@ async function queryGoogleAntigravityAccountUsage(now) {
     const results = await Promise.all(accounts.map(async (account) => {
         const accountLabel = account.email ?? maskCredential(account.refreshToken);
         try {
-            const { access_token } = await refreshGoogleAccessToken(account.refreshToken);
-            const response = await fetchGoogleAntigravityQuota(access_token, account.projectId);
-            const windows = GOOGLE_ACCOUNT_QUOTA_WINDOWS.map((window) => googleAccountWindowFromResponse(response, window.label, window.quotaModelKey, now))
-                .filter((window) => window !== undefined);
+            const response = account.cachedQuota ? googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now) : undefined;
+            const windows = response ? googleAccountWindowsFromResponse(response, now) : [];
+            if (windows.length === 0 && account.accessToken) {
+                const liveResponse = await fetchGoogleAntigravityQuota(account.accessToken, account.projectId);
+                windows.push(...googleAccountWindowsFromResponse(liveResponse, now));
+            }
             return {
                 account: accountLabel,
                 windows,
@@ -449,15 +453,20 @@ function readAllAntigravityQuotaAccounts() {
         return [];
     const accounts = storedAntigravityAccounts(credential);
     if (accounts.length > 0) {
+        const activeIndex = clampAccountIndex(credential.activeIndex, accounts.length);
+        const activeAccess = antigravityAccessFromCredential(credential);
         return accounts.map((account, accountIndex) => antigravityQuotaAccount(account, {
             ...(credential.email ? { fallbackEmail: credential.email } : {}),
+            ...(accountIndex === activeIndex && activeAccess ? { accessToken: activeAccess.accessToken } : {}),
             accountIndex,
             accountCount: accounts.length,
         })).filter((account) => account !== undefined);
     }
     const fallbackAccount = antigravityAccountFromCredential(credential);
+    const fallbackAccess = antigravityAccessFromCredential(credential);
     const account = fallbackAccount ? antigravityQuotaAccount(fallbackAccount, {
         ...(credential.email ? { fallbackEmail: credential.email } : {}),
+        ...(fallbackAccess ? { accessToken: fallbackAccess.accessToken } : {}),
     }) : undefined;
     return account ? [account] : [];
 }
@@ -480,12 +489,15 @@ function antigravityAccountFromCredential(credential) {
     const refresh = splitAntigravityRefresh(credential.refresh);
     if (!refresh.refreshToken)
         return undefined;
+    const activeStoredAccount = credential.accounts?.[clampAccountIndex(credential.activeIndex, credential.accounts.length)];
     return {
         refreshToken: refresh.refreshToken,
         projectId: refresh.projectId || refresh.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID,
         enabled: true,
         ...(credential.email ? { email: credential.email } : {}),
         ...(refresh.managedProjectId ? { managedProjectId: refresh.managedProjectId } : {}),
+        ...(activeStoredAccount?.cachedQuota ? { cachedQuota: activeStoredAccount.cachedQuota } : {}),
+        ...(typeof activeStoredAccount?.cachedQuotaUpdatedAt === "number" ? { cachedQuotaUpdatedAt: activeStoredAccount.cachedQuotaUpdatedAt } : {}),
     };
 }
 function antigravityQuotaAccount(account, options = {}) {
@@ -498,11 +510,65 @@ function antigravityQuotaAccount(account, options = {}) {
         refreshToken,
         projectId,
         cacheKey: email ? email.toLowerCase() : shortHash(refreshToken),
+        ...(options.accessToken ? { accessToken: options.accessToken } : {}),
+        ...(account.cachedQuota ? { cachedQuota: account.cachedQuota } : {}),
+        ...(typeof account.cachedQuotaUpdatedAt === "number" ? { cachedQuotaUpdatedAt: account.cachedQuotaUpdatedAt } : {}),
         ...(email ? { email } : {}),
         ...(typeof options.accountIndex === "number" ? { accountIndex: options.accountIndex } : {}),
         ...(typeof options.accountCount === "number" ? { accountCount: options.accountCount } : {}),
     };
 }
+function googleQuotaResponseFromCachedQuota(cachedQuota, cachedQuotaUpdatedAt, now = Date.now()) {
+    if (!cachedQuota)
+        return undefined;
+    const models = {};
+    addCachedQuotaModels(models, cachedQuota.claude, ["claude-opus-4-6-thinking", "claude-sonnet-4-6"], cachedQuotaUpdatedAt, now);
+    addCachedQuotaModels(models, cachedQuota["gemini-flash"], ["gemini-2.5-flash", "gemini-3-flash"], cachedQuotaUpdatedAt, now);
+    addCachedQuotaModels(models, cachedQuota["gemini-pro"], ["gemini-3.1-pro-low"], cachedQuotaUpdatedAt, now);
+    return Object.keys(models).length > 0 ? { models } : undefined;
+}
+function addCachedQuotaModels(models, quota, quotaModelKeys, cachedQuotaUpdatedAt, now) {
+    if (!quota || !Number.isFinite(quota.remainingFraction))
+        return;
+    const remainingFraction = quota.remainingFraction;
+    const resetTime = cachedQuotaResetTimeForDisplay(quota.resetTime, cachedQuotaUpdatedAt, now);
+    for (const quotaModelKey of quotaModelKeys) {
+        models[quotaModelKey] = {
+            quotaInfo: {
+                remainingFraction,
+                ...(resetTime ? { resetTime } : {}),
+            },
+        };
+    }
+}
+function cachedQuotaResetTimeForDisplay(resetTime, cachedQuotaUpdatedAt, now) {
+    if (!resetTime)
+        return undefined;
+    const resetAt = Date.parse(resetTime);
+    if (!Number.isFinite(resetAt) || resetAt > now)
+        return resetTime;
+    const cachedAt = normalizeTimestampMillis(cachedQuotaUpdatedAt);
+    if (!Number.isFinite(cachedAt) || resetAt <= cachedAt)
+        return resetTime;
+    return new Date(now + (resetAt - cachedAt)).toISOString();
+}
+function normalizeTimestampMillis(value) {
+    if (!Number.isFinite(value))
+        return Number.NaN;
+    const timestamp = value;
+    return timestamp < 1_000_000_000_000 ? timestamp * 1000 : timestamp;
+}
+function antigravityAccessFromCredential(credential) {
+    if (credential.type !== "oauth" || !credential.access || isExpired(credential))
+        return undefined;
+    const [accessToken = "", projectId = ""] = credential.access.split("|");
+    if (!accessToken)
+        return undefined;
+    return {
+        accessToken,
+        ...(projectId ? { projectId } : {}),
+    };
+}
 function splitAntigravityRefresh(refresh) {
     const [refreshToken = "", projectId = "", managedProjectId = ""] = refresh.split("|");
     return {
@@ -519,26 +585,6 @@ function clampAccountIndex(index, accountCount) {
 function shortHash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
-async function refreshGoogleAccessToken(refreshToken) {
-    if (!GOOGLE_CLIENT_ID || !GOOGLE_CLIENT_SECRET) {
-        throw new Error("Antigravity Google OAuth credentials are not configured; set PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID and PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET.");
-    }
-    const response = await fetchWithTimeout(GOOGLE_TOKEN_REFRESH_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-            client_id: GOOGLE_CLIENT_ID,
-            client_secret: GOOGLE_CLIENT_SECRET,
-            refresh_token: refreshToken,
-            grant_type: "refresh_token",
-        }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Google token refresh failed (${response.status}): ${errorText}`);
-    }
-    return response.json();
-}
 async function fetchGoogleAntigravityQuota(accessToken, projectId) {
     const response = await fetchWithTimeout(GOOGLE_QUOTA_API_URL, {
         method: "POST",
@@ -633,18 +679,51 @@ function selectOpenAIRateLimitForModel(data, modelKey) {
             return false;
         return openAIModelMatchesAdditionalLimit(modelKey, limit);
     });
+    // Prefer exact named per-model buckets when the API exposes them, but keep the
+    // top-level bucket as a fallback. Some Codex responses currently expose a
+    // usable selected-model/account bucket only at the top level while also
+    // listing unrelated named additional buckets; hiding the fallback makes the
+    // status bar disappear completely for those models.
     return additionalLimit?.rate_limit ?? data.rate_limit;
 }
 function openAIModelMatchesAdditionalLimit(modelKey, limit) {
-    const normalizedModel = normalizeOpenAILimitName(modelKey.split("/").at(-1) ?? modelKey);
-    const normalizedLimitName = normalizeOpenAILimitName(limit.limit_name);
-    const normalizedMeteredFeature = limit.metered_feature ? normalizeOpenAILimitName(limit.metered_feature) : "";
-    return (!!normalizedLimitName && (normalizedModel.includes(normalizedLimitName) || normalizedLimitName.includes(normalizedModel)))
-        || (!!normalizedMeteredFeature && (normalizedModel.includes(normalizedMeteredFeature) || normalizedMeteredFeature.includes(normalizedModel)));
+    const modelId = modelKey.split("/").at(-1) ?? modelKey;
+    return openAIModelIdMatchesLimitCandidate(modelId, limit.limit_name)
+        || (limit.metered_feature ? openAIModelIdMatchesLimitCandidate(modelId, limit.metered_feature) : false);
+}
+function openAIModelIdMatchesLimitCandidate(modelId, candidate) {
+    const modelTokens = openAILimitTokens(modelId);
+    const candidateTokens = openAILimitTokens(candidate);
+    if (modelTokens.length === 0 || candidateTokens.length === 0)
+        return false;
+    if (containsTokenSequence(candidateTokens, modelTokens))
+        return true;
+    // Support compact names such as o4mini while avoiding prefix matches such as
+    // gpt-5 accidentally matching gpt-5.5.
+    return normalizeOpenAILimitName(candidate) === normalizeOpenAILimitName(modelId);
 }
 function normalizeOpenAILimitName(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/gu, "");
 }
+function openAILimitTokens(value) {
+    return value.toLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 0);
+}
+function containsTokenSequence(tokens, sequence) {
+    if (sequence.length > tokens.length)
+        return false;
+    for (let start = 0; start <= tokens.length - sequence.length; start += 1) {
+        let matches = true;
+        for (let offset = 0; offset < sequence.length; offset += 1) {
+            if (tokens[start + offset] !== sequence[offset]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return true;
+    }
+    return false;
+}
 function selectWeeklyWindow(windows) {
     return windows
         .filter((window) => window.limit_window_seconds >= 6 * DAY_SECONDS)
@@ -683,6 +762,11 @@ function googleAccountWindowFromResponse(data, label, quotaModelKey, now) {
         windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
     };
 }
+function googleAccountWindowsFromResponse(data, now) {
+    return GOOGLE_ACCOUNT_QUOTA_WINDOWS
+        .map((window) => googleAccountWindowFromResponse(data, window.label, window.quotaModelKey, now))
+        .filter((window) => window !== undefined);
+}
 function clampPercent(percent) {
     return Math.max(0, Math.min(100, percent));
 }
@@ -706,6 +790,8 @@ function formatQuotaBar(percent, width) {
     return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
 }
 function formatDurationLong(resetAt, now) {
+    if (resetAt <= now)
+        return "reset";
     const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
     const days = Math.floor(totalMinutes / 1440);
     const hours = Math.floor((totalMinutes % 1440) / 60);
@@ -717,6 +803,8 @@ function formatDurationLong(resetAt, now) {
     return `${minutes}m`;
 }
 function formatDurationShort(resetAt, now) {
+    if (resetAt <= now)
+        return "reset";
     const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
     const days = Math.floor(totalMinutes / 1440);
     const hours = Math.floor((totalMinutes % 1440) / 60);
@@ -737,6 +825,8 @@ function formatUsageWindow(_prefix, window, now) {
     return `${window.remainingPercent}% ${formatCompactProgressBar(window.remainingPercent)} ${formatResetCountdown(window.resetAt, now)}`;
 }
 function formatResetCountdown(resetAt, now) {
+    if (resetAt <= now)
+        return "reset";
     const totalMinutes = Math.max(0, Math.ceil((resetAt - now) / 60_000));
     const days = Math.floor(totalMinutes / 1440);
     const hours = Math.floor((totalMinutes % 1440) / 60);

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

@@ -148,7 +148,7 @@ export class AppPopupActionController {
         this.host.render();
         try {
             if (selected.value === "copy") {
-                this.workspaceActions.copyUserMessage(selected.entryId);
+                await this.workspaceActions.copyUserMessage(selected.entryId);
                 return true;
             }
             if (selected.value === "fork") {

package/dist/app/process.d.ts

@@ -0,0 +1,17 @@
+export type AsyncProcessResult = {
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+    timedOut?: boolean;
+};
+export type RunProcessOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string;
+    timeoutMs?: number;
+    maxBufferBytes?: number;
+};
+export declare function runProcess(command: string, args?: readonly string[], options?: RunProcessOptions): Promise<AsyncProcessResult>;
+export declare function commandExists(command: string, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/app/process.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+const DEFAULT_MAX_BUFFER_BYTES = 1024 * 1024;
+export async function runProcess(command, args = [], options = {}) {
+    const maxBufferBytes = Math.max(1, options.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES);
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let error;
+        let timedOut = false;
+        const child = spawn(command, [...args], {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const append = (current, chunk) => {
+            const next = `${current}${chunk.toString("utf8")}`;
+            return next.length > maxBufferBytes ? next.slice(-maxBufferBytes) : next;
+        };
+        const timer = options.timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, options.timeoutMs);
+        timer?.unref?.();
+        child.stdout.on("data", (chunk) => {
+            stdout = append(stdout, chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = append(stderr, chunk);
+        });
+        child.once("error", (err) => {
+            error = err;
+        });
+        child.once("close", (status, signal) => {
+            if (timer)
+                clearTimeout(timer);
+            resolve({
+                status,
+                signal,
+                stdout,
+                stderr,
+                ...(error === undefined ? {} : { error }),
+                ...(timedOut ? { timedOut } : {}),
+            });
+        });
+        if (options.input === undefined)
+            child.stdin.end();
+        else
+            child.stdin.end(options.input);
+    });
+}
+export async function commandExists(command, env = process.env) {
+    if (process.platform === "win32") {
+        const names = [command, command.replace(/\.exe$/iu, ".cmd"), command.replace(/\.exe$/iu, ".bat")];
+        for (const name of names) {
+            const result = await runProcess("where", [name], { env, maxBufferBytes: 256 });
+            if (result.status === 0)
+                return true;
+        }
+        return false;
+    }
+    const result = await runProcess("sh", ["-lc", `command -v ${shellQuote(command)}`], { env, maxBufferBytes: 256 });
+    return result.status === 0;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

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

@@ -1,6 +1,7 @@
 import { applyOutputFilters } from "../../config.js";
 import { renderMarkdownTextLines } from "../../markdown-format.js";
 import { attachImageClickTargets } from "../screen/image-click-targets.js";
+import { APP_ICONS } from "../icons.js";
 import { horizontalPaddingLayout, padHorizontalText, wrapText } from "./render-text.js";
 import { renderConversationShellEntry } from "./conversation-shell-renderer.js";
 import { renderConversationToolEntry, renderThinkingEntry } from "./conversation-tool-renderer.js";
@@ -14,10 +15,11 @@ export function renderConversationEntry(entry, width, options) {
         ...(syntaxHighlight === undefined ? {} : { syntaxHighlight }),
         ...(entryId === undefined ? {} : { target: { kind: "user-message", id: entryId } }),
     });
-    const queuedLine = (text, entryId) => ({
+    const queuedLine = (text, entryId, segments) => ({
         text: padHorizontalText(text, width),
         variant: "muted",
         backgroundOverride: options.colors.userMessageBackground,
+        ...(segments && segments.length > 0 ? { segments: segments.map((segment) => ({ ...segment, start: segment.start + userContentLeft, end: segment.end + userContentLeft })) } : {}),
         target: { kind: "queue-message", id: entryId },
     });
     const userMessageLines = (userEntry) => {
@@ -29,11 +31,20 @@ export function renderConversationEntry(entry, width, options) {
         lines.push(userLine("", userEntry.id));
         return attachImageClickTargets(lines, userEntry.id, userEntry.images, { foreground: options.colors.info, underline: true });
     };
-    const queuedMessageLines = (queuedEntry) => [
-        queuedLine("", queuedEntry.id),
-        ...wrapText(`↳ queued ${queuedEntry.mode}: ${queuedEntry.text}`, userContentWidth).map((text) => queuedLine(text, queuedEntry.id)),
-        queuedLine("", queuedEntry.id),
-    ];
+    const queuedMessagePrefix = (queuedEntry) => {
+        const label = queuedEntry.queueSource === "sdk-steering"
+            ? "steer"
+            : queuedEntry.queueSource === "sdk-follow-up"
+                ? "follow"
+                : "queued";
+        return `${APP_ICONS.timerSand} ${label}:`;
+    };
+    const queuedMessageLines = (queuedEntry) => {
+        const icon = APP_ICONS.timerSand;
+        const prefix = queuedMessagePrefix(queuedEntry);
+        const contentLines = wrapText(`${prefix} ${queuedEntry.text}`, userContentWidth);
+        return contentLines.map((text, index) => queuedLine(text, queuedEntry.id, index === 0 ? [{ start: 0, end: icon.length, foreground: options.colors.info }] : undefined));
+    };
     switch (entry.kind) {
         case "system":
             return wrapText(`system: ${entry.text}`, width).map((text) => ({ text, variant: "muted" }));

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

@@ -49,12 +49,13 @@ export function renderThinkingEntry(entry, width, options) {
     const rule = resolveThinkingToolRule(options.pixConfig);
     const markdownText = entry.text ? formatMarkdownTables(entry.text, Math.max(1, width - 2)) : "";
     const expandedText = trimTrailingBlankLines(markdownText);
-    const compactExpandedText = options.superCompactTools ? removeBlankLines(expandedText) : expandedText;
     const forceExpanded = Boolean(options.allThinkingExpanded);
+    const compactExpandedText = options.superCompactTools && forceExpanded ? removeBlankLines(expandedText) : expandedText;
+    const expanded = forceExpanded || (entry.expanded && expandedText.trim().length > 0);
     return renderToolBlock({
         id: entry.id,
         toolName: THINKING_TOOL_NAME,
-        expanded: entry.expanded || forceExpanded,
+        expanded,
         status: entry.status,
         isError: false,
         output: markdownText,

package/dist/app/rendering/editor-layout-renderer.d.ts

@@ -10,6 +10,7 @@ export type EditorLayoutRendererHost = {
     readonly subagentsPanelExpanded: boolean;
     readonly subagentsWidgetState: SubagentsWidgetState | undefined;
     readonly voicePartialText: string | undefined;
+    readonly autocompleteSuggestion: string | undefined;
     renderExtensionInputComponent(width: number): string[] | undefined;
     extensionInputUsesEditor(): boolean;
     widgetTuiHandle(): WidgetTuiHandle;

package/dist/app/rendering/editor-layout-renderer.js

@@ -145,7 +145,7 @@ export class EditorLayoutRenderer {
             ? this.limitExtensionInputLines(extensionLines, Math.max(0, maxRows - (usesEditor ? 1 : 0)))
             : [];
         const editorMaxRows = usesEditor ? Math.max(1, maxRows - customLines.length) : 1;
-        const rendered = this.host.inputEditor.render(contentWidth, editorMaxRows, "", "");
+        const rendered = this.host.inputEditor.render(contentWidth, editorMaxRows, "", "", usesEditor ? this.host.autocompleteSuggestion ?? "" : "");
         const visibleLines = rendered.visualLines.slice(rendered.scrollOffset, rendered.scrollOffset + editorMaxRows);
         const scrollBar = usesEditor
             ? inputScrollBarMetrics(rendered.visualLines.length, visibleLines.length, rendered.scrollOffset)
@@ -157,6 +157,12 @@ export class EditorLayoutRenderer {
                 end: span.end + left,
             })))
             : [];
+        const editorSuggestionSpans = usesEditor
+            ? visibleLines.map((vl) => (vl.suggestionSpans ?? []).map((span) => ({
+                start: span.start + left,
+                end: span.end + left,
+            })))
+            : [];
         const paddedCustomLines = customLines.map((line) => frameInputLine(padHorizontalText(line, width)));
         return {
             lines: [...paddedCustomLines, ...editorLines],
@@ -172,6 +178,10 @@ export class EditorLayoutRenderer {
                 ...paddedCustomLines.map(() => []),
                 ...editorTagSpans,
             ],
+            suggestionSpans: [
+                ...paddedCustomLines.map(() => []),
+                ...editorSuggestionSpans,
+            ],
         };
     }
     limitExtensionInputLines(lines, maxRows) {

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

@@ -1,4 +1,10 @@
 import { isRecord } from "../guards.js";
+const MAX_FORMAT_STRING_CHARS = 256 * 1024;
+const MAX_RENDERED_CONTENT_CHARS = 512 * 1024;
+const MAX_STRUCTURED_DEPTH = 8;
+const MAX_STRUCTURED_ARRAY_ITEMS = 200;
+const MAX_STRUCTURED_OBJECT_KEYS = 200;
+const TRUNCATED_MARKER = "\n[… truncated …]";
 export function stringifyUnknown(value) {
     if (typeof value === "string")
         return value;
@@ -13,7 +19,7 @@ export function stringifyUnknown(value) {
             return name;
     }
     try {
-        return JSON.stringify(value, null, 2);
+        return JSON.stringify(normalizeStructuredValue(value), null, 2);
     }
     catch {
         return String(value);
@@ -24,8 +30,10 @@ export function formatStructuredText(value) {
         const trimmed = value.trim();
         if (!trimmed)
             return "(empty)";
+        if (trimmed.length > MAX_FORMAT_STRING_CHARS)
+            return truncateText(value, MAX_FORMAT_STRING_CHARS);
         try {
-            return JSON.stringify(JSON.parse(trimmed), null, 2);
+            return JSON.stringify(normalizeStructuredValue(JSON.parse(trimmed)), null, 2);
         }
         catch {
             return value;
@@ -36,25 +44,40 @@ export function formatStructuredText(value) {
 export function renderContent(content) {
     const parts = [];
     let imageCount = 0;
+    let renderedChars = 0;
+    const pushPart = (part) => {
+        const remaining = MAX_RENDERED_CONTENT_CHARS - renderedChars;
+        if (remaining <= 0)
+            return false;
+        const next = part.length > remaining ? truncateText(part, remaining) : part;
+        parts.push(next);
+        renderedChars += next.length;
+        return part.length <= remaining;
+    };
     for (const item of content) {
         if (!isRecord(item)) {
-            parts.push(stringifyUnknown(item));
+            if (!pushPart(stringifyUnknown(item)))
+                break;
             continue;
         }
         if (isImageContent(item)) {
             imageCount += 1;
-            parts.push(imageContentLabel(item, imageCount));
+            if (!pushPart(imageContentLabel(item, imageCount)))
+                break;
             continue;
         }
         if (typeof item.text === "string") {
-            parts.push(item.text);
+            if (!pushPart(item.text))
+                break;
             continue;
         }
         if (typeof item.thinking === "string") {
-            parts.push(item.thinking);
+            if (!pushPart(item.thinking))
+                break;
             continue;
         }
-        parts.push(stringifyUnknown(item));
+        if (!pushPart(stringifyUnknown(item)))
+            break;
     }
     return parts.join("\n");
 }
@@ -113,3 +136,38 @@ export function submittedUserDisplayText(displayText, promptText, images) {
         return userImageLabels(images.length);
     return promptText.trimEnd();
 }
+function truncateText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, Math.max(0, maxChars))}${TRUNCATED_MARKER}`;
+}
+function normalizeStructuredValue(value, depth = 0, seen = new WeakSet()) {
+    if (typeof value === "string")
+        return truncateText(value, MAX_FORMAT_STRING_CHARS);
+    if (!value || typeof value !== "object")
+        return value;
+    if (depth >= MAX_STRUCTURED_DEPTH)
+        return "[… truncated: depth limit …]";
+    if (seen.has(value))
+        return "[… circular …]";
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const items = value.slice(0, MAX_STRUCTURED_ARRAY_ITEMS).map((item) => normalizeStructuredValue(item, depth + 1, seen));
+        if (value.length > MAX_STRUCTURED_ARRAY_ITEMS)
+            items.push(`[… ${value.length - MAX_STRUCTURED_ARRAY_ITEMS} more items …]`);
+        return items;
+    }
+    if (value instanceof Error)
+        return value.message || value.name;
+    const output = {};
+    let count = 0;
+    for (const [key, child] of Object.entries(value)) {
+        if (count >= MAX_STRUCTURED_OBJECT_KEYS) {
+            output["…"] = "truncated: object key limit";
+            break;
+        }
+        output[key] = normalizeStructuredValue(child, depth + 1, seen);
+        count += 1;
+    }
+    return output;
+}

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

@@ -68,8 +68,11 @@ export class AppRenderController {
         this.deps.mouseController.statusThinkingTarget = undefined;
         this.deps.mouseController.statusContextTarget = undefined;
         this.deps.mouseController.statusModelUsageTarget = undefined;
+        this.deps.mouseController.statusDraftQueueTarget = undefined;
+        this.deps.mouseController.statusUserJumpTarget = undefined;
         this.deps.mouseController.statusThinkingExpandTarget = undefined;
         this.deps.mouseController.statusCompactToolsTarget = undefined;
+        this.deps.mouseController.statusTerminalBellSoundTarget = undefined;
         this.deps.mouseController.statusSessionTarget = undefined;
         this.deps.mouseController.statusPromptEnhancerTarget = undefined;
         this.deps.mouseController.statusVoiceMicTarget = undefined;
@@ -165,10 +168,11 @@ export class AppRenderController {
         for (let index = 0; index < renderedInput.lines.length; index += 1) {
             const inputLine = renderedInput.lines[index] ?? "";
             const tagSpans = renderedInput.tagSpans[index];
+            const suggestionSpans = renderedInput.suggestionSpans?.[index] ?? [];
             const row = toScreenRow(inputStartRow + index);
             this.deps.mouseController.renderedRowTexts.set(row, inputLine);
             const tagColor = this.deps.theme.colors.accent;
-            const styledLine = this.deps.screenStyler.styleInputLine(row, inputLine, tagSpans, columns, tagColor, this.deps.theme.colors.inputBorder);
+            const styledLine = this.deps.screenStyler.styleInputLine(row, inputLine, tagSpans, suggestionSpans, columns, tagColor, this.deps.theme.colors.muted, this.deps.theme.colors.inputBorder);
             appendFrameOutput("inputStatus", row, this.renderFrameRow(row, styledLine));
         }
         if (renderedInput.scrollBar && columns > 0) {
@@ -291,6 +295,7 @@ export class AppRenderController {
         this.deps.mouseController.statusThinkingTarget = this.deps.statusLineRenderer.thinkingTarget(statusLayout.text, statusRow);
         this.deps.mouseController.statusContextTarget = this.deps.statusLineRenderer.contextTarget(statusLayout.text, statusRow, statusLayout);
         this.deps.mouseController.statusModelUsageTarget = this.deps.statusLineRenderer.modelUsageTarget(statusLayout.text, statusRow, statusLayout);
+        this.deps.mouseController.statusDraftQueueTarget = this.deps.statusLineRenderer.draftQueueTarget?.(statusLayout, statusRow);
         this.deps.mouseController.statusUserJumpTarget = this.deps.statusLineRenderer.userJumpTarget?.(statusLayout, statusRow);
         this.deps.mouseController.statusThinkingExpandTarget = this.deps.statusLineRenderer.thinkingExpandTarget?.(statusLayout, statusRow);
         this.deps.mouseController.statusCompactToolsTarget = this.deps.statusLineRenderer.compactToolsTarget?.(statusLayout, statusRow);

package/dist/app/rendering/render-text.d.ts

@@ -1,10 +1,13 @@
 import type { Theme } from "../../theme.js";
 import type { ToolStatusEntry } from "../types.js";
 export declare function sanitizeText(text: string): string;
+export declare function alertIconPrefixLength(text: string): number | undefined;
 export declare function normalizePastedTextForDuplicateKey(text: string): string;
 export declare function shortHash(text: string): string;
 export declare function hasLspDiagnosticsAfterMutation(output: string): boolean;
 export declare function hasToolLspDiagnosticsAfterMutation(entry: ToolStatusEntry): boolean;
+export declare function lspDiagnosticSeverityForLine(line: string): "error" | "warning" | "hint" | undefined;
+export declare function toolLspDiagnosticsAfterMutationSeverity(entry: ToolStatusEntry): "error" | "warning" | undefined;
 export declare function toolStatusIcon(entry: ToolStatusEntry): string;
 export declare function toolStatusIconColor(entry: ToolStatusEntry, colors: Theme["colors"]): string;
 export declare function wrapLine(text: string, width: number): string[];