pi-ui-extend 0.1.9 → 0.1.13

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

@@ -1,4 +1,4 @@
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import http from "node:http";
@@ -8,13 +8,26 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { savePixDictationLanguage } from "../../config.js";
 import { APP_ICONS } from "../icons.js";
+import { commandExists } from "../process.js";
 const SAMPLE_RATE = 16_000;
 const require = createRequire(import.meta.url);
 const projectRoot = fileURLToPath(new URL("../..", import.meta.url));
 const modelsRoot = join(projectRoot, "models", "vosk");
 const VOSK_PACKAGE_SPEC = "vosk@0.3.39";
 const VOICE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS = 100;
 let voskInstallPromise;
+const defaultVoiceControllerDeps = {
+    tryLoadVosk,
+    ensureModel,
+    selectRecorderCommand,
+    spawn,
+    savePixDictationLanguage,
+};
+let voiceControllerDeps = defaultVoiceControllerDeps;
+export function setVoiceControllerTestDeps(overrides) {
+    voiceControllerDeps = overrides ? { ...defaultVoiceControllerDeps, ...overrides } : defaultVoiceControllerDeps;
+}
 export class AppVoiceController {
     host;
     modelDefinitions;
@@ -29,6 +42,7 @@ export class AppVoiceController {
     progressTimer;
     lastSystemProgressMessage;
     partialTranscript;
+    partialTranscriptTimer;
     startGeneration = 0;
     constructor(host, dictationConfig) {
         this.host = host;
@@ -113,7 +127,7 @@ export class AppVoiceController {
         const generation = this.startGeneration + 1;
         this.startGeneration = generation;
         try {
-            const initialVosk = tryLoadVosk();
+            const initialVosk = voiceControllerDeps.tryLoadVosk();
             const vosk = initialVosk.ok
                 ? initialVosk.module
                 : await this.installAndLoadVosk(initialVosk.error, generation);
@@ -122,15 +136,15 @@ export class AppVoiceController {
             vosk.setLogLevel?.(-1);
             this.state = "downloading";
             this.host.render();
-            const modelPath = await ensureModel(language, this.modelDefinition(language));
+            const modelPath = await voiceControllerDeps.ensureModel(language, this.modelDefinition(language));
             if (!this.isCurrentStart(generation))
                 return;
             this.state = "loading";
             this.host.render();
             const model = this.cachedModel(language, modelPath, vosk);
-            const recorder = selectRecorderCommand();
+            const recorder = await voiceControllerDeps.selectRecorderCommand();
             const recognizer = new vosk.Recognizer({ model, sampleRate: SAMPLE_RATE });
-            const audioProcess = spawn(recorder.command, recorder.args, { stdio: ["ignore", "pipe", "pipe"] });
+            const audioProcess = voiceControllerDeps.spawn(recorder.command, recorder.args, { stdio: ["ignore", "pipe", "pipe"] });
             this.recognizer = recognizer;
             this.audioProcess = audioProcess;
             this.state = "listening";
@@ -169,7 +183,7 @@ export class AppVoiceController {
     }
     saveLanguageSelection(language) {
         try {
-            savePixDictationLanguage(language);
+            voiceControllerDeps.savePixDictationLanguage(language);
         }
         catch (error) {
             this.host.showToast(`Could not save voice language: ${errorMessage(error)}`, "warning");
@@ -283,14 +297,27 @@ export class AppVoiceController {
         if (text === this.partialTranscript)
             return;
         this.partialTranscript = text;
-        this.host.setPartialTranscript(text);
+        this.schedulePartialTranscriptEmit();
     }
     clearPartialTranscript() {
         if (!this.partialTranscript)
             return;
         this.partialTranscript = undefined;
+        if (this.partialTranscriptTimer) {
+            clearTimeout(this.partialTranscriptTimer);
+            this.partialTranscriptTimer = undefined;
+        }
         this.host.setPartialTranscript(undefined);
     }
+    schedulePartialTranscriptEmit() {
+        if (this.partialTranscriptTimer)
+            return;
+        this.partialTranscriptTimer = setTimeout(() => {
+            this.partialTranscriptTimer = undefined;
+            this.host.setPartialTranscript(this.partialTranscript);
+        }, VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS);
+        this.partialTranscriptTimer.unref?.();
+    }
     isCurrentStart(generation) {
         return this.startGeneration === generation;
     }
@@ -367,11 +394,11 @@ async function downloadFile(url, destination, redirects = 3) {
     });
 }
 async function extractZip(zipPath, destination) {
-    if (commandExists("unzip")) {
+    if (await commandExists("unzip")) {
         await runCommand("unzip", ["-q", zipPath, "-d", destination]);
         return;
     }
-    if (process.platform === "darwin" && commandExists("ditto")) {
+    if (process.platform === "darwin" && await commandExists("ditto")) {
         await runCommand("ditto", ["-x", "-k", zipPath, destination]);
         return;
     }
@@ -535,7 +562,7 @@ function isVoskModule(value) {
     const record = value;
     return typeof record.Model === "function" && typeof record.Recognizer === "function";
 }
-function selectRecorderCommand() {
+async function selectRecorderCommand() {
     const commands = [
         {
             command: "rec",
@@ -566,15 +593,11 @@ function selectRecorderCommand() {
             description: "arecord",
         });
     }
-    const command = commands.find((candidate) => commandExists(candidate.command));
-    if (!command)
-        throw new Error("audio recorder not found: install SoX (`rec`/`sox`), ffmpeg, or arecord");
-    return command;
-}
-function commandExists(command) {
-    if (process.platform === "win32")
-        return spawnSync("where", [command], { stdio: "ignore" }).status === 0;
-    return spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" }).status === 0;
+    for (const candidate of commands) {
+        if (await commandExists(candidate.command))
+            return candidate;
+    }
+    throw new Error("audio recorder not found: install SoX (`rec`/`sox`), ffmpeg, or arecord");
 }
 function transcriptText(result) {
     const parsed = typeof result === "string" ? parseResultString(result) : result;

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

@@ -79,9 +79,18 @@ export type OpenAIUsageResponse = {
     rate_limit: OpenAIRateLimit | null;
     additional_rate_limits?: OpenAIAdditionalRateLimit[];
 };
+type AntigravityCachedQuotaBucket = {
+    remainingFraction?: number;
+    resetTime?: string;
+    modelCount?: number;
+};
+type AntigravityCachedQuota = Record<string, AntigravityCachedQuotaBucket | undefined>;
 type AntigravityQuotaAccount = {
     readonly email?: string;
     readonly refreshToken: string;
+    readonly accessToken?: string;
+    readonly cachedQuota?: AntigravityCachedQuota;
+    readonly cachedQuotaUpdatedAt?: number;
     readonly projectId: string;
     readonly accountIndex?: number;
     readonly accountCount?: number;

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,11 @@ 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 queuedMessageLines = (queuedEntry) => {
+        const icon = queuedEntry.queueSource === "deferred" ? APP_ICONS.pause : APP_ICONS.timerSand;
+        const contentLines = wrapText(`${icon} ${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) {