@bubblebrain-ai/bubble 0.0.48 → 0.0.50

package/dist/agent.js

@@ -2,10 +2,10 @@
  * Agent - The core decision loop.
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
-import { compactCurrentTurnToolGroups, compactMessages, isRealUserMessage } from "./context/compact.js";
+import { compactCurrentTurnToolGroups, compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
-import { estimateContextTokens, getContextBudget } from "./context/budget.js";
+import { getContextBudget } from "./context/budget.js";
 import { buildContextUsageSnapshot } from "./context/usage.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { computeRetryDelayMs, isProviderStreamInterruption, MAX_STREAM_INTERRUPTION_RETRIES, sleepBeforeRetry, } from "./network/retry.js";
@@ -21,7 +21,12 @@ import { DEFAULT_AGENT_ROUTING, sanitizeAgentRouting } from "./agent/routing-cat
 import { SubagentRouter } from "./agent/subagent/router.js";
 import { normalizeWaitTimeout, SubagentRuntime } from "./agent/subagent/runtime.js";
 import { WorkflowLedger } from "./agent/workflow/runs.js";
-import { AgentAbortError, EMPTY_ASSISTANT_FALLBACK } from "./agent/abort-errors.js";
+import { EMPTY_ASSISTANT_FALLBACK, throwIfAborted, isAbortLikeError, isAbortError } from "./agent/abort-errors.js";
+import { appendProviderContentBlock, buildProviderRequestFingerprint } from "./agent/provider-fingerprint.js";
+import { countUserTurns, estimateResidentChars, estimateToolPayloadChars, getCurrentHeapUsed, RESIDENT_HISTORY_HEAP_HARD_LIMIT, RESIDENT_HISTORY_KEEP_RECENT_TURNS } from "./agent/resident-history.js";
+import { cancelledToolResult, createModelInterruptedMessage, findMissingRequiredArgs, isSubagentLifecycleTool, lastProviderMessage, shouldAppendModelInterruptedBoundary } from "./agent/transcript-helpers.js";
+import { createUpdateQueue } from "./agent/update-queue.js";
+export { createUpdateQueue } from "./agent/update-queue.js";
 import { isHiddenToolResult } from "./agent/tool-visibility.js";
 import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
@@ -29,8 +34,6 @@ import { buildToolPromptOptions } from "./tools/prompt-metadata.js";
 import { stopAutoServersForSession } from "./tools/server-manager.js";
 import { summarizeAgentEventForTrace, summarizeTraceError, summarizeTraceMessage, summarizeTraceToolResult, summarizeTraceValue, traceEvent, } from "./debug-trace.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 3;
-const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
-const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
 const MAX_EMPTY_ASSISTANT_RECOVERIES = 1;
 const EMPTY_ASSISTANT_RECOVERY_REMINDER = "The previous model response contained no user-visible assistant content and no tool calls. " +
     "Respond now with a concise, user-visible answer, or call an available tool if more work is required. " +
@@ -74,7 +77,23 @@ function agentEventFromHookProgress(event) {
     };
 }
 export class Agent {
-    messages = [];
+    /**
+     * Backing store for the public `messages` accessor. All whole-array
+     * rewrites (clear/compact/rewind/session switch/subagent fork) go through
+     * the setter, which notifies `onContextChanged` subscribers — that push
+     * channel is what keeps derived UI (e.g. the footer usage readout) in sync
+     * without per-path refresh calls that are easy to forget.
+     */
+    _messages = [];
+    contextChangedListeners = new Set();
+    notifyingContextChange = false;
+    get messages() {
+        return this._messages;
+    }
+    set messages(value) {
+        this._messages = value;
+        this.notifyContextChanged();
+    }
     provider;
     sessionID;
     /**
@@ -216,7 +235,7 @@ export class Agent {
             persistDir,
         });
         if (options.systemPrompt) {
-            this.messages.push({ role: "system", content: options.systemPrompt });
+            this._messages.push({ role: "system", content: options.systemPrompt });
         }
         for (const tool of options.tools) {
             this.tools.set(tool.name, tool);
@@ -345,6 +364,9 @@ export class Agent {
             // Rendered through the live accessor (design §1.5), so every host-
             // triggered prompt rebuild picks up the current catalog.
             modelRoutingPrompt: this.buildModelRoutingPromptSection(),
+            // Model switches rebuild the prompt from these options; without this the
+            // persistent memory (buildMemoryPrompt) is silently dropped on switch.
+            memoryPrompt: this.memoryPrompt,
         };
     }
     /** Current routing menu (design §4); undefined when no accessor is wired. */
@@ -359,6 +381,46 @@ export class Agent {
     renderModelRoutingPromptFor(parent) {
         return this.router.promptSectionFor(parent);
     }
+    /**
+     * Push subscription for derived-context consumers (TUI footer, hosts).
+     * Fires whenever resident context mutates in a way that changes a
+     * `getContextUsageSnapshot()` reading: whole-array message rewrites,
+     * appended messages, system-prompt replacement, or model/provider switches
+     * (window size / estimation basis). Returns an unsubscribe function.
+     */
+    onContextChanged(listener) {
+        this.contextChangedListeners.add(listener);
+        return () => {
+            this.contextChangedListeners.delete(listener);
+        };
+    }
+    notifyContextChanged() {
+        if (this.notifyingContextChange)
+            return;
+        this.notifyingContextChange = true;
+        try {
+            for (const listener of [...this.contextChangedListeners]) {
+                try {
+                    listener();
+                }
+                catch (error) {
+                    // A broken subscriber must never corrupt agent state mid-mutation,
+                    // but leave a trace — otherwise a throwing consumer (e.g. the footer
+                    // readout hitting a pathological message) fails silently forever.
+                    traceEvent("context_listener_error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    }, {
+                        sessionFile: this.sessionID,
+                        provider: this._providerId || "none",
+                        model: this.apiModel || "none",
+                    });
+                }
+            }
+        }
+        finally {
+            this.notifyingContextChange = false;
+        }
+    }
     getContextUsageSnapshot() {
         return buildContextUsageSnapshot({
             providerId: this.providerId,
@@ -431,13 +493,21 @@ export class Agent {
         return this._model;
     }
     set model(value) {
+        if (this._model === value)
+            return;
         this._model = value;
+        // Context window (and thus usage readings) is model-derived.
+        this.notifyContextChanged();
     }
     get providerId() {
         return this._providerId;
     }
     set providerId(value) {
+        if (this._providerId === value)
+            return;
         this._providerId = value;
+        // Token estimation basis is provider-specific.
+        this.notifyContextChanged();
     }
     get apiModel() {
         if (this._model.includes(":")) {
@@ -501,10 +571,14 @@ export class Agent {
     setSystemPrompt(prompt) {
         const systemMessage = { role: "system", content: prompt };
         if (this.messages[0]?.role === "system") {
+            if (this.messages[0].content === prompt)
+                return;
             this.messages[0] = systemMessage;
+            this.notifyContextChanged();
             return;
         }
         this.messages.unshift(systemMessage);
+        this.notifyContextChanged();
     }
     async *run(userInput, cwd, options = {}) {
         const abortSignal = options.abortSignal;
@@ -705,6 +779,7 @@ export class Agent {
                 const textSanitizer = createStreamingInternalReminderSanitizer();
                 const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
+                let turnSystemFingerprint;
                 let assistantAppended = false;
                 currentAssistantMsg = assistantMsg;
                 currentAssistantAppended = false;
@@ -898,6 +973,10 @@ export class Agent {
                                     }
                                 }
                                 break;
+                            case "response_metadata":
+                                turnSystemFingerprint = chunk.systemFingerprint;
+                                assistantMsg.systemFingerprint = chunk.systemFingerprint;
+                                break;
                         }
                         for (const update of this.subagents.drainToolUpdates())
                             yield emit(update);
@@ -938,7 +1017,7 @@ export class Agent {
                         if (consecutiveEmptyAssistantRecoveries < MAX_EMPTY_ASSISTANT_RECOVERIES) {
                             consecutiveEmptyAssistantRecoveries += 1;
                             this.injectSystemReminder(EMPTY_ASSISTANT_RECOVERY_REMINDER);
-                            yield emit({ type: "turn_end", usage: turnUsage, willContinue: true });
+                            yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue: true });
                             continue;
                         }
                         assistantMsg.content = EMPTY_ASSISTANT_FALLBACK;
@@ -1328,7 +1407,7 @@ export class Agent {
                         },
                     });
                     flushQueuedReminders();
-                    yield emit({ type: "turn_end", usage: turnUsage, willContinue: true });
+                    yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue: true });
                     // Auto-continue: if we have tool results, the LLM needs to respond to them.
                     // Emitting the turn boundary keeps UI renderers aligned with the persisted
                     // assistant/tool message sequence instead of merging the next answer into
@@ -1360,7 +1439,7 @@ export class Agent {
                 for (const event of stopHook.events)
                     yield emit(event);
                 const willContinue = !!hookState.forceContinuationReason;
-                yield emit({ type: "turn_end", usage: turnUsage, willContinue });
+                yield emit({ type: "turn_end", usage: turnUsage, systemFingerprint: turnSystemFingerprint, willContinue });
                 if (willContinue) {
                     delete hookState.forceContinuationReason;
                     continue;
@@ -1828,6 +1907,7 @@ export class Agent {
             model: this.apiModel || "none",
         });
         this.onMessageAppend?.(message);
+        this.notifyContextChanged();
     }
     appendInterruptedAssistantBoundary(currentAssistant, currentAssistantAppended) {
         const last = lastProviderMessage(this.messages);
@@ -1938,293 +2018,3 @@ export class Agent {
         }
     }
 }
-function findMissingRequiredArgs(schema, args) {
-    const required = schema?.required;
-    if (!required || required.length === 0)
-        return [];
-    const missing = [];
-    for (const name of required) {
-        const value = args ? args[name] : undefined;
-        // Empty strings/arrays are intentionally allowed — writing an empty file
-        // or passing an empty list can be legitimate. Only undefined/null counts
-        // as "missing", because the observed failure mode is `finalArgs: "{}"`
-        // where the field is entirely absent.
-        if (value === undefined || value === null) {
-            missing.push(name);
-        }
-    }
-    return missing;
-}
-function estimateResidentChars(messages) {
-    let total = 0;
-    for (const message of messages) {
-        switch (message.role) {
-            case "system":
-            case "meta":
-                total += message.content.length;
-                break;
-            case "tool":
-                total += message.content.length + message.toolCallId.length;
-                break;
-            case "assistant":
-                total += message.content.length + (message.reasoning?.length ?? 0);
-                total += message.toolCalls?.reduce((sum, toolCall) => sum + toolCall.id.length + toolCall.name.length + toolCall.arguments.length, 0) ?? 0;
-                break;
-            case "user":
-                if (typeof message.content === "string") {
-                    total += message.content.length;
-                }
-                else {
-                    total += message.content.reduce((sum, part) => {
-                        if (part.type === "text") {
-                            return sum + part.text.length;
-                        }
-                        return sum + part.image_url.url.length;
-                    }, 0);
-                }
-                break;
-        }
-    }
-    return total;
-}
-function appendProviderContentBlock(message, provider, block) {
-    const current = message.providerMetadata?.[provider]?.contentBlocks ?? [];
-    message.providerMetadata = {
-        ...message.providerMetadata,
-        [provider]: {
-            ...message.providerMetadata?.[provider],
-            contentBlocks: [...current, cloneProviderRawContentBlock(block)],
-        },
-    };
-}
-function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
-    const roleCounts = {};
-    let contentChars = 0;
-    let reasoningChars = 0;
-    let toolResultChars = 0;
-    let maxToolResultChars = 0;
-    let assistantToolCalls = 0;
-    let rawAnthropicBlocks = 0;
-    let rawAnthropicThinkingBlocks = 0;
-    let rawAnthropicSignatureChars = 0;
-    for (const message of messages) {
-        roleCounts[message.role] = (roleCounts[message.role] ?? 0) + 1;
-        if (message.role === "assistant") {
-            contentChars += message.content.length;
-            reasoningChars += message.reasoning?.length ?? 0;
-            assistantToolCalls += message.toolCalls?.length ?? 0;
-            const blocks = message.providerMetadata?.anthropic?.contentBlocks ?? [];
-            rawAnthropicBlocks += blocks.length;
-            for (const block of blocks) {
-                if (block.type === "thinking" || block.type === "redacted_thinking") {
-                    rawAnthropicThinkingBlocks += 1;
-                }
-                if (typeof block.signature === "string") {
-                    rawAnthropicSignatureChars += block.signature.length;
-                }
-            }
-        }
-        else if (message.role === "tool") {
-            toolResultChars += message.content.length;
-            maxToolResultChars = Math.max(maxToolResultChars, message.content.length);
-        }
-        else if (message.role === "user") {
-            contentChars += typeof message.content === "string"
-                ? message.content.length
-                : message.content.reduce((sum, part) => sum + (part.type === "text" ? part.text.length : part.image_url.url.length), 0);
-        }
-        else {
-            contentChars += message.content.length;
-        }
-    }
-    const systemMessages = messages.filter((message) => message.role === "system");
-    const bodyMessages = messages.filter((message) => message.role !== "system");
-    const systemJsonBytes = Buffer.byteLength(JSON.stringify(systemMessages), "utf8");
-    const bodyJsonBytes = Buffer.byteLength(JSON.stringify(bodyMessages), "utf8");
-    const toolSchemaJsonBytes = Buffer.byteLength(JSON.stringify(tools), "utf8");
-    return {
-        roleCounts,
-        estimatedTokens: estimateContextTokens(messages, providerId),
-        projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
-        systemJsonBytes,
-        bodyJsonBytes,
-        toolSchemaJsonBytes,
-        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
-            system: systemMessages,
-            tools,
-            tool_choice: toolChoice,
-        }), "utf8"),
-        toolChoice,
-        contentChars,
-        reasoningChars,
-        toolResultChars,
-        maxToolResultChars,
-        assistantToolCalls,
-        rawAnthropicBlocks,
-        rawAnthropicThinkingBlocks,
-        rawAnthropicSignatureChars,
-    };
-}
-function cloneProviderRawContentBlock(block) {
-    return JSON.parse(JSON.stringify(block));
-}
-function throwIfAborted(signal) {
-    if (!signal?.aborted)
-        return;
-    const reason = signal.reason;
-    if (reason instanceof Error)
-        throw reason;
-    throw new AgentAbortError(typeof reason === "string" ? reason : undefined);
-}
-function isAbortLikeError(error, signal) {
-    if (signal?.aborted)
-        return true;
-    if (error instanceof AgentAbortError)
-        return true;
-    if (error instanceof DOMException && error.name === "AbortError")
-        return true;
-    if (typeof error === "object" && error !== null && error.name === "AbortError")
-        return true;
-    return false;
-}
-function isAbortError(error, signal) {
-    return isAbortLikeError(error, signal);
-}
-function shouldAppendModelInterruptedBoundary(messages) {
-    return messages.at(-1)?.role === "tool";
-}
-function createModelInterruptedMessage(error, metadata) {
-    return {
-        role: "assistant",
-        content: `[model request interrupted before a final answer was produced: ${summarizeInterruptError(error)}]`,
-        model: metadata.model,
-        providerId: metadata.providerId,
-        modelId: metadata.modelId,
-    };
-}
-function summarizeInterruptError(error) {
-    const message = error instanceof Error
-        ? error.message
-        : typeof error === "string"
-            ? error
-            : String(error);
-    return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown error";
-}
-function lastProviderMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role === "system" || message.role === "meta")
-            continue;
-        return message;
-    }
-    return undefined;
-}
-function cancelledToolResult(toolName) {
-    return {
-        content: `Tool "${toolName}" was cancelled.`,
-        isError: true,
-        status: "cancelled",
-        metadata: { reason: "cancelled" },
-    };
-}
-/** Exported for tests: the wake latch below is easiest to pin directly. */
-export function createUpdateQueue() {
-    const items = [];
-    let waiter;
-    let abortCleanup;
-    // Latch for wakes that arrive with no parked waiter — a wake() fired while
-    // the consuming generator is suspended at a yield would otherwise be lost.
-    // Callers today each pair their wake with a synchronously-checked flag
-    // (items / settled / pendingSubagentUpdates), so no wake is currently
-    // dropped; the latch keeps that correctness inside the queue instead of
-    // depending on every future caller repeating the pairing.
-    let signaled = false;
-    return {
-        push(item) {
-            items.push(item);
-            this.wake();
-        },
-        drain() {
-            return items.splice(0, items.length);
-        },
-        hasItems() {
-            return items.length > 0;
-        },
-        wait(signal) {
-            if (items.length > 0)
-                return Promise.resolve("woken");
-            if (signaled) {
-                signaled = false;
-                return Promise.resolve("woken");
-            }
-            if (signal?.aborted)
-                return Promise.resolve("aborted");
-            return new Promise((resolve) => {
-                abortCleanup?.();
-                abortCleanup = undefined;
-                const finish = (status) => {
-                    if (waiter !== resolve)
-                        return;
-                    waiter = undefined;
-                    abortCleanup?.();
-                    abortCleanup = undefined;
-                    resolve(status);
-                };
-                if (signal) {
-                    const onAbort = () => finish("aborted");
-                    signal.addEventListener("abort", onAbort, { once: true });
-                    abortCleanup = () => signal.removeEventListener("abort", onAbort);
-                }
-                waiter = resolve;
-            });
-        },
-        wake() {
-            const resolve = waiter;
-            if (!resolve) {
-                signaled = true;
-                return;
-            }
-            waiter = undefined;
-            abortCleanup?.();
-            abortCleanup = undefined;
-            resolve("woken");
-        },
-    };
-}
-function estimateToolPayloadChars(messages) {
-    return messages.reduce((sum, message) => {
-        if (message.role !== "tool") {
-            return sum;
-        }
-        return sum + message.content.length;
-    }, 0);
-}
-function countUserTurns(messages) {
-    // Real user turns only: projected reminders and summary envelopes are
-    // user-ROLE but not user TURNS — counting them used to shrink the keep
-    // window and fire compaction almost every turn.
-    return messages.reduce((count, message) => count + (isRealUserMessage(message) ? 1 : 0), 0);
-}
-function getCurrentHeapUsed() {
-    try {
-        return process.memoryUsage().heapUsed;
-    }
-    catch {
-        return 0;
-    }
-}
-function isSubagentLifecycleTool(name) {
-    return name === "subagent"
-        || name === "spawn_agent"
-        || name === "wait_agent"
-        || name === "send_input"
-        || name === "close_agent"
-        || name === "list_agents"
-        || name === "run_workflow"
-        || name === "wait_workflow"
-        // Legacy names: still present in transcripts recorded before the tools
-        // were removed (2026-07-06); forked children must not inherit their
-        // dangling tool_calls either.
-        || name === "agent_team"
-        || name === "agent_batch";
-}

package/dist/external-runtime/grok-runtime.js

@@ -530,7 +530,7 @@ export class GrokRuntimeManager {
         try {
             if (!this.lock)
                 temporaryLock = await this.acquireProfileLock();
-            const { profile, env, binary } = await this.prepareAndVerify();
+            const { env, binary } = await this.prepareAndVerify();
             const result = await runGrokCommand(this.spawn, binary.path, ["--no-auto-update", "--cwd", this.workspace, "models"], { cwd: this.workspace, env, maxStdoutBytes: 64 * 1024 });
             if (result.code !== 0) {
                 throw new GrokRuntimeError("protocol_error", "Grok could not list subscription models.", result.stderr);

package/dist/feishu/agent-host/run-driver.js

@@ -301,7 +301,7 @@ export class RunDriver {
             this.opts.approvalUI.cancelForChat(req.chatId, "Run ended");
         }
     }
-    async resolveProvider(session, promptCacheKey) {
+    async resolveProvider(_session, promptCacheKey) {
         const registry = this.opts.deps.providerRegistry;
         const userConfig = this.opts.deps.userConfig;
         // Read session metadata for an explicit model preference, fall back to

package/dist/lsp/service.js

@@ -436,7 +436,7 @@ const TypeScriptServer = {
     extensions: TS_EXTENSIONS,
     root: nearestRoot(NODE_ROOT_MARKERS, DENO_ROOT_MARKERS),
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const tsserverPath = resolveModule(requireFromRoot, "typescript/lib/tsserver.js")
@@ -495,7 +495,7 @@ const ESLintServer = {
     extensions: [...TS_EXTENSIONS, ".vue"],
     root: eslintRoot,
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const eslint = resolveModule(requireFromRoot, "eslint");

package/dist/model-catalog.d.ts

@@ -48,5 +48,18 @@ export declare function listDynamicModelMetadata(providerId: string): BuiltinMod
 export declare function getBuiltinModel(providerId: string, modelId: string): BuiltinModelDefinition | undefined;
 export declare function getModelDefaultReasoningLevel(providerId: string, modelId: string): ReasoningEffort | undefined;
 export declare function getBuiltinProvider(providerId: string): BuiltinProviderDefinition | undefined;
+/**
+ * Infer capability metadata 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 and a 500K context window — matching the curated
+ * grok-4.5 entry — while composer/fast/mini/flash variants have no effort
+ * control and a 200K window. Pure (id-only) so it works even before remote
+ * model discovery runs.
+ */
+export declare function inferGrokModelMetadata(modelId: string): {
+    levels: ReasoningEffort[];
+    defaultLevel?: ReasoningEffort;
+    contextWindow?: number;
+};
 export declare function getModelContextWindow(providerId: string, modelId: string): number | undefined;
 export declare function getToolOutputTokenLimit(providerId: string, modelId: string): number | undefined;

package/dist/model-catalog.js

@@ -41,13 +41,12 @@ const OPENAI_CHAT_LEVELS = ["off"];
 // Internal representation for APIs that expose thinking as enabled/disabled.
 // UI code must render supported toggle models as on/off, not as "medium" effort.
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
-// GLM-5.2 is the first GLM to accept OpenAI-style `reasoning_effort`. The API
-// enum is none/minimal/low/medium/high/xhigh/max; we expose high and max (the
-// two effort tiers worth offering a coding agent) plus "off", which disables
-// thinking outright via `thinking: {type: "disabled"}`. Order matters: "high"
-// is first so it is the default (getDefaultThinkingLevel falls back to levels[0]
-// when "medium" is absent), since GLM-5.2 is a thinking-on-by-default model.
+// GLM-5.2 accepts OpenAI-style `reasoning_effort`. We expose high and max plus
+// "off", which disables thinking outright via `thinking: {type: "disabled"}`.
 const GLM_5_2_LEVELS = ["high", "max", "off"];
+// GLM-5.3 Coding Plan normalizes efforts into exactly three real tiers. Its
+// default is max, and disabling thinking maps to low rather than turning it off.
+const GLM_5_3_LEVELS = ["low", "high", "max"];
 // Kimi K2.7 Code variants only support thinking mode (disabling it errors), so
 // "off" is not offered — the model is always in its thinking variant.
 const KIMI_THINKING_ONLY_LEVELS = ["medium"];
@@ -124,6 +123,9 @@ export const BUILTIN_MODELS = [
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai", tier: "balanced", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
+    // Coding Plan exposes GLM-5.3 before GET /models lists it (verified live
+    // 2026-08-14). The standard API is still marked "coming soon" in the docs.
+    { id: "glm-5.3", name: "GLM-5.3", providerId: "zhipuai-coding-plan", tier: "strong", reasoningLevels: GLM_5_3_LEVELS, defaultReasoningLevel: "max", contextWindow: 1000000 },
     { id: "glm-5.2", name: "GLM-5.2", providerId: "zhipuai-coding-plan", tier: "strong", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai-coding-plan", tier: "balanced", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
@@ -239,10 +241,28 @@ export function getBuiltinModel(providerId, modelId) {
         || (providerId === "openai" ? dynamicOverlay.get(overlayKey("openai-codex", modelId)) : undefined);
     if (overlayHit)
         return overlayHit;
-    return BUILTIN_MODELS.find((model) => model.providerId === providerId && model.id === modelId)
+    const staticHit = BUILTIN_MODELS.find((model) => model.providerId === providerId && model.id === modelId)
         || (providerId === "openai"
             ? BUILTIN_MODELS.find((model) => model.providerId === "openai-codex" && model.id === modelId)
             : undefined);
+    if (staticHit)
+        return staticHit;
+    // Dynamically-discovered grok models aren't in the static catalog until
+    // remote discovery runs. Synthesize their metadata from the id so reasoning
+    // levels, default effort, and context window resolve correctly on a fresh
+    // start or resumed session (before the first /model discovery).
+    if (providerId === "grok") {
+        const inferred = inferGrokModelMetadata(modelId);
+        return {
+            id: modelId,
+            name: modelId,
+            providerId: "grok",
+            reasoningLevels: inferred.levels,
+            defaultReasoningLevel: inferred.defaultLevel,
+            contextWindow: inferred.contextWindow,
+        };
+    }
+    return undefined;
 }
 export function getModelDefaultReasoningLevel(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.defaultReasoningLevel;
@@ -250,8 +270,32 @@ export function getModelDefaultReasoningLevel(providerId, modelId) {
 export function getBuiltinProvider(providerId) {
     return BUILTIN_PROVIDERS.find((provider) => provider.id === providerId);
 }
+/**
+ * Infer capability metadata 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 and a 500K context window — matching the curated
+ * grok-4.5 entry — while composer/fast/mini/flash variants have no effort
+ * control and a 200K window. Pure (id-only) so it works even before remote
+ * model discovery runs.
+ */
+export function inferGrokModelMetadata(modelId) {
+    const id = modelId.toLowerCase();
+    if (/(composer|fast|mini|flash)/.test(id)) {
+        return { levels: ["off"], contextWindow: 200000 };
+    }
+    return { levels: ["low", "medium", "high"], defaultLevel: "high", contextWindow: 500000 };
+}
 export function getModelContextWindow(providerId, modelId) {
-    return getBuiltinModel(providerId, modelId)?.contextWindow;
+    const builtin = getBuiltinModel(providerId, modelId);
+    if (builtin?.contextWindow !== undefined)
+        return builtin.contextWindow;
+    // Dynamically-discovered grok models aren't in the static catalog until
+    // discovery runs; infer the window from the id so context usage can render a
+    // percentage even before discovery (e.g. on a resumed session right after
+    // startup).
+    if (providerId === "grok")
+        return inferGrokModelMetadata(modelId).contextWindow;
+    return undefined;
 }
 export function getToolOutputTokenLimit(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.toolOutputTokenLimit;

package/dist/permissions/settings.d.ts

@@ -43,7 +43,6 @@ export interface SettingsManagerOptions {
     bubbleHome?: string;
 }
 export declare class SettingsManager {
-    private readonly cwd;
     private readonly paths;
     private raw;
     private fileDiagnostics;