@bubblebrain-ai/bubble 0.0.48 → 0.0.50

package/dist/permissions/settings.js

@@ -25,7 +25,6 @@ const KNOWN_MODES = new Set([
     "bypassPermissions",
 ]);
 export class SettingsManager {
-    cwd;
     paths;
     raw = {
         user: null,
@@ -34,7 +33,6 @@ export class SettingsManager {
     };
     fileDiagnostics = [];
     constructor(cwd, options = {}) {
-        this.cwd = cwd;
         const bubbleHome = options.bubbleHome ?? getBubbleHome();
         this.paths = {
             user: join(bubbleHome, "settings.json"),

package/dist/provider-grok.d.ts

@@ -9,21 +9,10 @@
  */
 import type { OAuthCredentials } from "./oauth/types.js";
 import { type ChatGptFetch } from "./network/chatgpt-transport.js";
-import type { ThinkingLevel } from "./types.js";
+import { type ThinkingLevel } from "./types.js";
 export declare const GROK_SUBSCRIPTION_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
 export declare const GROK_CLIENT_VERSION = "0.2.93";
 export declare function isGrokSubscriptionBaseUrl(baseURL: string): boolean;
-/**
- * Infer reasoning levels for a Grok model id the /models endpoint returned
- * without metadata. Flagship reasoning models (grok-N.M) expose
- * low/medium/high with thinking always on — matching the curated grok-4.5
- * entry — while composer/fast/mini/flash variants have no effort control and
- * map to the plain "off" ladder.
- */
-export declare function inferGrokReasoningLevels(modelId: string): {
-    levels: ThinkingLevel[];
-    defaultLevel?: ThinkingLevel;
-};
 export declare function buildGrokSubscriptionHeaders(): Record<string, string>;
 export interface GrokAuthAdapter {
     getCredentials: () => OAuthCredentials | undefined | Promise<OAuthCredentials | undefined>;
@@ -36,17 +25,26 @@ export interface GrokAuthAdapter {
  * proactively refreshes) the stored OAuth credentials per request instead.
  */
 export declare function createGrokSubscriptionFetch(auth: GrokAuthAdapter, baseFetch?: ChatGptFetch): ChatGptFetch;
+export interface GrokModelDescriptor {
+    id: string;
+    name?: string;
+    /** Server-declared context window (the /models `context_window` field). */
+    contextWindow?: number;
+    /** Server-declared reasoning effort ladder, sorted ascending. */
+    reasoningEfforts?: ThinkingLevel[];
+    /** Server-declared default effort (the /models `reasoning_effort` field). */
+    defaultReasoningEffort?: ThinkingLevel;
+}
 /**
  * Fetch the model list for a Grok subscription account. The CLI chat proxy
  * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
  * rides the same refreshing fetch used for chat requests instead of a raw
- * global fetch. Throws on a non-2xx so callers fall back to the curated
- * catalog when the proxy exposes no /models endpoint.
+ * global fetch. The /models payload carries richer metadata than id+name —
+ * `context_window`, `reasoning_efforts`, and the default `reasoning_effort` —
+ * which this surfaces so discovery can stop inferring them. Throws on a
+ * non-2xx so callers fall back to the curated catalog.
  */
 export declare function fetchGrokSubscriptionModels(baseURL: string, auth: GrokAuthAdapter, options?: {
     timeoutMs?: number;
     fetch?: ChatGptFetch;
-}): Promise<Array<{
-    id: string;
-    name?: string;
-}>>;
+}): Promise<GrokModelDescriptor[]>;

package/dist/provider-grok.js

@@ -8,6 +8,7 @@
  * OAuth bearer fresh across long sessions.
  */
 import { getChatGptFetch } from "./network/chatgpt-transport.js";
+import { THINKING_LEVELS } from "./types.js";
 export const GROK_SUBSCRIPTION_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
 // The proxy rejects requests below a minimum client version; identify as the
 // same pinned CLI build Bubble verifies elsewhere.
@@ -17,20 +18,6 @@ export function isGrokSubscriptionBaseUrl(baseURL) {
     const normalized = baseURL.trim().replace(/\/+$/, "");
     return normalized === GROK_SUBSCRIPTION_BASE_URL || normalized.startsWith(`${GROK_SUBSCRIPTION_BASE_URL}/`);
 }
-/**
- * Infer reasoning levels for a Grok model id the /models endpoint returned
- * without metadata. Flagship reasoning models (grok-N.M) expose
- * low/medium/high with thinking always on — matching the curated grok-4.5
- * entry — while composer/fast/mini/flash variants have no effort control and
- * map to the plain "off" ladder.
- */
-export function inferGrokReasoningLevels(modelId) {
-    const id = modelId.toLowerCase();
-    if (/(composer|fast|mini|flash)/.test(id)) {
-        return { levels: ["off"] };
-    }
-    return { levels: ["low", "medium", "high"], defaultLevel: "high" };
-}
 export function buildGrokSubscriptionHeaders() {
     return {
         "User-Agent": "grok-cli",
@@ -75,8 +62,10 @@ export function createGrokSubscriptionFetch(auth, baseFetch = getChatGptFetch())
  * Fetch the model list for a Grok subscription account. The CLI chat proxy
  * gates on the grok-cli identity headers plus a fresh OAuth bearer, so this
  * rides the same refreshing fetch used for chat requests instead of a raw
- * global fetch. Throws on a non-2xx so callers fall back to the curated
- * catalog when the proxy exposes no /models endpoint.
+ * global fetch. The /models payload carries richer metadata than id+name —
+ * `context_window`, `reasoning_efforts`, and the default `reasoning_effort` —
+ * which this surfaces so discovery can stop inferring them. Throws on a
+ * non-2xx so callers fall back to the curated catalog.
  */
 export async function fetchGrokSubscriptionModels(baseURL, auth, options = {}) {
     const fetchImpl = createGrokSubscriptionFetch(auth, options.fetch);
@@ -91,8 +80,27 @@ export async function fetchGrokSubscriptionModels(baseURL, auth, options = {}) {
     const entries = payload.data ?? payload.models ?? [];
     return entries
         .filter((entry) => typeof entry?.id === "string" && entry.id.trim().length > 0)
-        .map((entry) => ({
-        id: entry.id,
-        name: typeof entry.name === "string" ? entry.name : undefined,
-    }));
+        .map((entry) => {
+        const id = entry.id;
+        const rawEfforts = Array.isArray(entry.reasoning_efforts) ? entry.reasoning_efforts : [];
+        const reasoningEfforts = rawEfforts
+            .map((effort) => (effort && typeof effort === "object" && typeof effort.value === "string"
+            ? effort.value
+            : undefined))
+            .filter((value) => typeof value === "string" && THINKING_LEVELS.includes(value))
+            .sort((a, b) => THINKING_LEVELS.indexOf(a) - THINKING_LEVELS.indexOf(b));
+        const defaultReasoningEffort = typeof entry.reasoning_effort === "string"
+            && THINKING_LEVELS.includes(entry.reasoning_effort)
+            ? entry.reasoning_effort
+            : undefined;
+        return {
+            id,
+            name: typeof entry.name === "string" ? entry.name : undefined,
+            contextWindow: typeof entry.context_window === "number" && entry.context_window > 0
+                ? entry.context_window
+                : undefined,
+            reasoningEfforts: reasoningEfforts.length > 0 ? reasoningEfforts : undefined,
+            defaultReasoningEffort,
+        };
+    });
 }

package/dist/provider-registry.d.ts

@@ -77,6 +77,7 @@ export declare class ProviderRegistry {
     private modelConfig;
     private authStorage;
     private modelDiscoveryCache;
+    private readonly discoveryDiskCachePath;
     private modelDiscoveryInFlight;
     private modelDiscoveryGeneration;
     /** Last membership seen per discovery key — survives cache eviction/TTL so
@@ -85,6 +86,14 @@ export declare class ProviderRegistry {
     private routingRevision;
     private identityFingerprints;
     constructor(config: UserConfig);
+    /** The on-disk cache is production-only; disable it under the test runner so
+     *  tests sharing one isolated BUBBLE_HOME never contaminate each other. */
+    private get discoveryDiskCacheEnabled();
+    /** Restore a prior successful discovery so dynamic models resolve without a
+     *  network round-trip right after startup (no fetch on every launch). */
+    private loadDiscoveryDiskCache;
+    /** Persist successful discoveries so the next launch can reuse them. */
+    private saveDiscoveryDiskCache;
     /**
      * Monotonic counter of semantic routing-world changes: provider set,
      * credential identity, provider key/config, discovery membership.

package/dist/provider-registry.js

@@ -5,12 +5,15 @@
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
 import { createHash } from "node:crypto";
-import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, listBuiltinModels, replaceDynamicModelMetadata, } from "./model-catalog.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "./bubble-home.js";
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, inferGrokModelMetadata, listBuiltinModels, replaceDynamicModelMetadata, } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
 import { fetchGeminiModels } from "./provider-ai-sdk.js";
 import { extractChatGptAccountId, fetchOpenAICodexModelCatalog } from "./provider-openai-codex.js";
-import { fetchGrokSubscriptionModels, inferGrokReasoningLevels } from "./provider-grok.js";
+import { fetchGrokSubscriptionModels } from "./provider-grok.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 import { refreshGrok } from "./oauth/grok.js";
 /** True for providers speaking the OpenAI chat-completions protocol (the default). */
@@ -60,6 +63,8 @@ export function sanitizeProviderHeaders(value) {
 }
 const MODEL_DISCOVERY_SUCCESS_TTL_MS = 60_000;
 const MODEL_DISCOVERY_FAILURE_TTL_MS = 10_000;
+/** How long a successful discovery survives on disk before a fresh fetch. */
+const MODEL_DISCOVERY_DISK_TTL_MS = 24 * 60 * 60 * 1000;
 /** Discovery must never delay startup or a model picker for long. */
 const MODEL_DISCOVERY_TIMEOUT_MS = 5_000;
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
@@ -74,6 +79,7 @@ export class ProviderRegistry {
     modelConfig;
     authStorage;
     modelDiscoveryCache = new Map();
+    discoveryDiskCachePath = join(getBubbleHome(), "model-discovery-cache.json");
     modelDiscoveryInFlight = new Map();
     modelDiscoveryGeneration = new Map();
     /** Last membership seen per discovery key — survives cache eviction/TTL so
@@ -91,6 +97,72 @@ export class ProviderRegistry {
                 this.identityFingerprints.set(authKey, fingerprint);
         }
         this.authStorage.onMutation((authKey) => this.handleAuthMutation(authKey));
+        this.loadDiscoveryDiskCache();
+    }
+    /** The on-disk cache is production-only; disable it under the test runner so
+     *  tests sharing one isolated BUBBLE_HOME never contaminate each other. */
+    get discoveryDiskCacheEnabled() {
+        const v = process.env.VITEST?.trim().toLowerCase();
+        return v !== "true" && v !== "1";
+    }
+    /** Restore a prior successful discovery so dynamic models resolve without a
+     *  network round-trip right after startup (no fetch on every launch). */
+    loadDiscoveryDiskCache() {
+        if (!this.discoveryDiskCacheEnabled)
+            return;
+        try {
+            if (!existsSync(this.discoveryDiskCachePath))
+                return;
+            const parsed = JSON.parse(readFileSync(this.discoveryDiskCachePath, "utf8"));
+            const now = Date.now();
+            for (const [key, entry] of Object.entries(parsed)) {
+                if (!entry || typeof entry.expiresAt !== "number" || entry.expiresAt <= now)
+                    continue;
+                if (!entry.result || !Array.isArray(entry.result.models))
+                    continue;
+                this.modelDiscoveryCache.set(key, {
+                    result: entry.result,
+                    expiresAt: entry.expiresAt,
+                    identityKey: entry.identityKey ?? "unknown",
+                    providerId: entry.providerId ?? "",
+                    authType: entry.authType,
+                    protocol: entry.protocol,
+                });
+                // Rebuild the dynamic overlay so context window / reasoning levels
+                // resolve from the cached catalog at startup, not only on /model open.
+                if (entry.providerId) {
+                    this.applyDynamicDiscoveryMetadata({ id: entry.providerId, authType: entry.authType, protocol: entry.protocol }, entry.result);
+                }
+            }
+        }
+        catch {
+            // Missing/corrupt cache is fine; the next discovery re-fetches.
+        }
+    }
+    /** Persist successful discoveries so the next launch can reuse them. */
+    saveDiscoveryDiskCache() {
+        if (!this.discoveryDiskCacheEnabled)
+            return;
+        try {
+            const data = {};
+            for (const [key, entry] of this.modelDiscoveryCache) {
+                if (entry.result.error)
+                    continue;
+                data[key] = {
+                    result: entry.result,
+                    expiresAt: Date.now() + MODEL_DISCOVERY_DISK_TTL_MS,
+                    identityKey: entry.identityKey,
+                    providerId: entry.providerId,
+                    authType: entry.authType,
+                    protocol: entry.protocol,
+                };
+            }
+            mkdirSync(dirname(this.discoveryDiskCachePath), { recursive: true });
+            writeFileSync(this.discoveryDiskCachePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+        }
+        catch {
+            // Persistence is best-effort.
+        }
     }
     /**
      * Monotonic counter of semantic routing-world changes: provider set,
@@ -386,7 +458,19 @@ export class ProviderRegistry {
         if (!options.forceRefresh) {
             const cached = this.modelDiscoveryCache.get(key);
             if (cached && cached.expiresAt > now) {
-                const result = { ...cached.result, source: "cache" };
+                // A disk cache can outlive the application version that wrote it. Keep
+                // the current curated catalog authoritative over stale cached metadata,
+                // then retain cached remote-only ids for non-authoritative union results.
+                // This lets newly-added builtins surface immediately after an upgrade
+                // without waiting up to 24 hours or requiring a manual Ctrl+R refresh.
+                const local = this.localModelsForProvider(provider);
+                const localIds = new Set(local.map((model) => model.id));
+                const models = cached.result.source === "static"
+                    ? local
+                    : cached.result.authoritative
+                        ? cached.result.models
+                        : [...local, ...cached.result.models.filter((model) => !localIds.has(model.id))];
+                const result = { ...cached.result, models, source: "cache" };
                 const current = this.getConfigured().find((item) => item.id === provider.id);
                 if (!current || this.modelDiscoveryKey(current) === key) {
                     this.applyDynamicDiscoveryMetadata(provider, result);
@@ -420,7 +504,12 @@ export class ProviderRegistry {
                 result: { ...result, source: result.source === "cache" ? "remote" : result.source },
                 expiresAt: Date.now() + (result.error ? MODEL_DISCOVERY_FAILURE_TTL_MS : MODEL_DISCOVERY_SUCCESS_TTL_MS),
                 identityKey: this.discoveryIdentity(provider),
+                providerId: provider.id,
+                authType: provider.authType,
+                protocol: provider.protocol,
             });
+            if (!result.error)
+                this.saveDiscoveryDiskCache();
             this.lastDiscoveryMembership.set(key, {
                 ids: result.models.map((model) => model.id),
                 authoritative: result.authoritative,
@@ -541,13 +630,27 @@ export class ProviderRegistry {
                 const extras = remote
                     .filter((entry) => !known.has(entry.id) && isLikelyChatModelId(entry.id))
                     .map((entry) => {
-                    const inferred = inferGrokReasoningLevels(entry.id);
+                    const inferred = inferGrokModelMetadata(entry.id);
+                    // Prefer the server-declared effort ladder and context window over
+                    // id-based inference; fall back to inference only when the endpoint
+                    // omitted them (or for ids that don't match a known family).
+                    const levels = entry.reasoningEfforts && entry.reasoningEfforts.length > 0
+                        ? entry.reasoningEfforts
+                        : inferred.levels;
+                    const defaultLevel = entry.defaultReasoningEffort && levels.includes(entry.defaultReasoningEffort)
+                        ? entry.defaultReasoningEffort
+                        : inferred.defaultLevel;
                     return {
                         id: entry.id,
                         name: entry.name || entry.id,
                         providerId: currentProvider.id,
-                        reasoningLevels: inferred.levels,
-                        ...(inferred.defaultLevel ? { defaultReasoningLevel: inferred.defaultLevel } : {}),
+                        reasoningLevels: levels,
+                        ...(defaultLevel ? { defaultReasoningLevel: defaultLevel } : {}),
+                        ...(entry.contextWindow !== undefined
+                            ? { contextWindow: entry.contextWindow }
+                            : inferred.contextWindow !== undefined
+                                ? { contextWindow: inferred.contextWindow }
+                                : {}),
                     };
                 })
                     .sort((a, b) => a.id.localeCompare(b.id));

package/dist/provider-transform.js

@@ -114,16 +114,15 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {
-        // GLM-5.2 is the only GLM that also accepts `reasoning_effort` (we expose
-        // high/max, which map 1:1 onto the API enum). "off" disables thinking via
-        // `thinking: {type: "disabled"}` — otherwise the server default (thinking
-        // on, effort max) would make "off" a no-op. The effort field rides inside
-        // the body alongside `thinking`, so it goes in extraBody, not the
-        // OpenRouter-style `reasoningEffort` config field.
-        if (modelId === "glm-5.2") {
+        // GLM-5.2+ also accept `reasoning_effort`. GLM-5.2 can disable thinking;
+        // GLM-5.3 requires thinking and Coding Plan normalizes its effort into
+        // low/high/max. The catalog clamps 5.3 choices before this serialization
+        // boundary. The effort field rides inside the body alongside `thinking`,
+        // so it goes in extraBody, not the OpenRouter-style config field.
+        if (modelId === "glm-5.2" || modelId === "glm-5.3") {
             return {
                 effectiveThinkingLevel,
-                extraBody: effectiveThinkingLevel === "off"
+                extraBody: modelId === "glm-5.2" && effectiveThinkingLevel === "off"
                     ? { thinking: { type: "disabled" } }
                     : {
                         thinking: { type: "enabled", clear_thinking: false },

package/dist/provider.js

@@ -397,6 +397,9 @@ function extractBalancedJson(s, start) {
  * execute safely.
  */
 export async function* translateOpenAIFullResponse(response) {
+    if (typeof response?.system_fingerprint === "string" && response.system_fingerprint) {
+        yield { type: "response_metadata", systemFingerprint: response.system_fingerprint };
+    }
     const usageChunk = usageToStreamChunk(response?.usage);
     if (usageChunk)
         yield usageChunk;
@@ -502,6 +505,7 @@ export async function* translateOpenAIStream(stream, options = {}) {
     let reasoningBuffer = "";
     let textBuffer = "";
     let rawChunkSeq = 0;
+    let systemFingerprint;
     // DeepSeek (and some inference re-hosts) sometimes deliver reasoning twice:
     // once via a dedicated `reasoning_content` / `thinking` field, and again
     // embedded as `<think>...</think>` inside `delta.content`. Track whether we
@@ -553,6 +557,13 @@ export async function* translateOpenAIStream(stream, options = {}) {
         const delta = choice?.delta;
         const usage = chunk.usage ?? choice?.usage;
         const finishReason = choice?.finish_reason;
+        if (typeof chunk?.system_fingerprint === "string"
+            && chunk.system_fingerprint
+            && chunk.system_fingerprint !== systemFingerprint) {
+            const nextSystemFingerprint = chunk.system_fingerprint;
+            systemFingerprint = nextSystemFingerprint;
+            yield { type: "response_metadata", systemFingerprint: nextSystemFingerprint };
+        }
         debugReasoningStream({
             stage: "provider_raw",
             providerId: options.debugProviderId,

package/dist/session-log.js

@@ -203,6 +203,7 @@ function normalizeMessageToEntries(message, id, timestamp) {
                     providerId: message.providerId,
                     modelId: message.modelId,
                     usage: message.usage,
+                    systemFingerprint: message.systemFingerprint,
                     error: message.error,
                     providerMetadata: sanitizeAssistantProviderMetadata(cloneProviderMetadata(message.providerMetadata)),
                 },

package/dist/slash-commands/commands.js

@@ -16,7 +16,7 @@ import { collectUsageStatsBundle, formatStatsText } from "../stats/usage.js";
 import { buildMemoryPrompt, getMemoryStatus, isMemoryDisabled, resetMemory, searchMemory, } from "../memory/index.js";
 import { feishuCommand } from "./feishu.js";
 import { GROK_LOCAL_COMMAND_HELP } from "../external-runtime/grok-input-policy.js";
-import { isGrokSubscriptionProviderId, } from "../external-runtime/grok-provider.js";
+import { isGrokSubscriptionProviderId } from "../external-runtime/grok-provider.js";
 import { classifyExternalRuntimeBinding } from "../external-runtime/session-policy.js";
 const VALID_SCOPES = ["user", "project", "local"];
 const VALID_LISTS = ["allow", "deny"];
@@ -107,7 +107,7 @@ function persistSelectedModel(model, ctx) {
     }
 }
 function syncSystemPrompt(ctx, model) {
-    const { providerId, modelId } = decodeModel(model);
+    const { providerId } = decodeModel(model);
     const toolPromptOptions = typeof ctx.agent.getSystemPromptToolOptions === "function"
         ? ctx.agent.getSystemPromptToolOptions()
         : {};
@@ -412,14 +412,14 @@ const builtinSlashCommandEntries = [
     {
         name: "skills",
         description: "Open the searchable skills picker",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             ctx.openPicker("skill");
         },
     },
     {
         name: "help",
         description: "Show available slash commands",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             if (hasExternalRuntimeSession(ctx)) {
                 const grok = isGrokSessionActive(ctx);
                 return [
@@ -448,14 +448,14 @@ const builtinSlashCommandEntries = [
     {
         name: "context",
         description: "Show current context window usage and breakdown",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             return `${formatContextUsage(ctx.agent.getContextUsageSnapshot())}\n\n${formatMcpContextStatus(ctx)}`;
         },
     },
     {
         name: "quit",
         description: "Exit the application",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             ctx.exit();
         },
     },
@@ -482,8 +482,12 @@ const builtinSlashCommandEntries = [
     {
         name: "clear",
         description: "Clear the current conversation history",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             ctx.agent.messages = ctx.agent.messages.filter((m) => m.role === "system" || m.role === "meta");
+            // The resident history just shrank: drop the incremental usage anchor
+            // too (same as /compact and /rewind), or budget accounting keeps
+            // measuring against the pre-clear message count.
+            ctx.agent.resetContextUsageAnchor();
             ctx.sessionManager?.appendMarker("conversation_clear", "");
             ctx.sessionManager?.clearTitleMetadata?.();
             if (ctx.agent.getTodos().length > 0) {
@@ -845,7 +849,7 @@ const builtinSlashCommandEntries = [
     {
         name: "plan",
         description: "Toggle plan mode on/off (Tab switches Build/Plan)",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             const next = ctx.agent.mode === "plan" ? "default" : "plan";
             ctx.agent.setMode(next);
             return next === "plan"
@@ -1069,7 +1073,7 @@ const builtinSlashCommandEntries = [
     {
         name: "compact",
         description: "Manually compact the current session context",
-        async handler(args, ctx) {
+        async handler(_args, ctx) {
             if (!ctx.sessionManager) {
                 return "Compaction requires session persistence. Start an interactive session first.";
             }

package/dist/tools/grep.js

@@ -54,7 +54,7 @@ export function createGrepTool(cwd) {
             }
             rgArgs.push(searchPath);
             return new Promise((resolve) => {
-                execFile("rg", rgArgs, { cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                execFile("rg", rgArgs, { cwd, maxBuffer: 10 * 1024 * 1024 }, (_error, stdout, _stderr) => {
                     // rg returns exit code 1 when no matches found, which is not an error for us
                     const lines = stdout.split("\n").filter((l) => l.trim() !== "");
                     const matches = [];

package/dist/tui-ink/app-helpers.d.ts

@@ -0,0 +1,43 @@
+import type { Agent } from "../agent.js";
+import { type ProviderRegistry } from "../provider-registry.js";
+import type { BackgroundTaskInfo } from "../tasks/manager.js";
+import { type DisplayMessage } from "./display-history.js";
+export declare const TASK_WAKE_DEBOUNCE_MS = 2000;
+export declare function buildTips(agent: Agent, registry: ProviderRegistry, grokActive?: boolean): string[];
+/**
+ * Slash-command results arrive as plain strings; recognize the /model
+ * confirmations by shape so they render as accent-colored UI notices — the
+ * same treatment the picker path applies — instead of assistant prose.
+ */
+export declare function slashResultNoticeKind(result: string): DisplayMessage["syntheticKind"] | undefined;
+/** Status-row summary for running background tasks (design §2.5). */
+export declare function taskRowSummary(tasks: BackgroundTaskInfo[], nowTick: number): string;
+export declare function friendlyCwd(cwd: string): string;
+export declare function sessionBasename(sessionFile: string | undefined): string | undefined;
+export declare function truncate(value: string, max: number): string;
+export declare function formatCompactTokens(n: number): string;
+export declare function formatContextUsageLabel(snapshot: {
+    usedTokens: number;
+    contextWindow?: number;
+}): string;
+/**
+ * Streaming tool arguments arrive as an incomplete JSON buffer. We can't
+ * JSON.parse() until the closing brace lands, but the user wants to see the
+ * short identifying fields (path, command, …) as soon as the model emits
+ * them so the tool row header reflects what's happening.
+ *
+ * Intentionally limited to short, single-line fields. Long fields like
+ * `content` are *not* surfaced live: rendering thousands of partial lines
+ * per delta floods the terminal and the partial value can break around
+ * unescaped sequences. The final value lands when the tool actually
+ * executes and tool_start delivers canonical args.
+ */
+export declare function parsePartialArgs(buffer: string, previous: Record<string, any>): Record<string, any>;
+/**
+ * Coerce a freshly-constructed DisplayMessage into one that carries a stable
+ * `key`. Centralizes the safety net so callers don't have to remember to call
+ * nextDisplayMessageKey on every push.
+ */
+export declare function withMessageKey(message: DisplayMessage): DisplayMessage;
+export declare const STREAMING_FLUSH_INTERVAL_MS = 40;
+export declare function clampWindowStartForIndex(total: number, selectedIndex: number, maxVisible: number): number;