@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/agent.js

@@ -5,13 +5,13 @@
 import { compactCurrentTurnToolGroups, compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
-import { getContextBudget } from "./context/budget.js";
+import { estimateToolDefinitionsTokens, getContextBudget, getMaxInputTokens, } 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";
+import { computeRetryDelayMs, isProviderStreamInterruption, providerStreamRetryLimit, sleepBeforeRetry, } from "./network/retry.js";
 import { projectMessages } from "./context/projector.js";
 import { aggressivePruneMessages, markStableCurrentToolResultsForCache, markToolResultCacheStable } from "./context/prune.js";
-import { truncateToolOutputForModel } from "./context/tool-output-truncate.js";
+import { normalizeToolResultForModel, truncateToolOutputForModel } from "./context/tool-output-truncate.js";
 import { buildDeferredToolsReminder, buildToolFreezeReminder, isPermissionModeReminder, reminderForMode } from "./prompt/reminders.js";
 import { HookBus } from "./orchestrator/hooks.js";
 import { normalizeHookInput, truncateHookText, } from "./hooks/index.js";
@@ -33,11 +33,17 @@ import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
 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 MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 2;
 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. " +
     "Do not put the final answer only in hidden reasoning.";
+class LocalContextPreflightError extends Error {
+    constructor(estimatedTokens, maxInputTokens) {
+        super(`Local request preflight: estimated prompt length ${estimatedTokens} tokens exceeds maximum prompt length ${maxInputTokens}.`);
+        this.name = "LocalContextPreflightError";
+    }
+}
 export { AgentAbortError, SubagentAbortError } from "./agent/abort-errors.js";
 // Model-facing interruption boundary. Persisted into the transcript so the
 // next turn sees an explicit stop instead of a dangling request — but it must
@@ -364,6 +370,11 @@ export class Agent {
             memoryPrompt: this.memoryPrompt,
         };
     }
+    /** Refresh the live Skill catalog after /skills reloads or changes enablement. */
+    setSkillSummaries(skills) {
+        this.skillSummaries = skills.slice();
+        this.notifyContextChanged();
+    }
     /** Current routing menu (design §4); undefined when no accessor is wired. */
     buildModelRoutingPromptSection() {
         return this.router.promptSection();
@@ -690,7 +701,11 @@ export class Agent {
                 return;
             }
             this.injectHookModelContext(promptHook.result);
-            this.appendMessage({ role: "user", content: userInput });
+            this.appendMessage({
+                role: "user",
+                content: userInput,
+                ...(options.userMessageUi ? { ui: { ...options.userMessageUi } } : {}),
+            });
         }
         await hookBus.runBeforeTurn({
             agent: this,
@@ -804,22 +819,32 @@ export class Agent {
                     description: t.description,
                     parameters: t.parameters,
                 }));
+                const toolDefinitionTokens = estimateToolDefinitionsTokens(toolDefinitions, this.providerId);
                 // LLM-driven compaction runs ahead of projector's algorithmic passes. If
                 // it succeeds, this.messages is replaced with [preserved system+meta] +
                 // [LLM summary] + [last user msg], and the projector becomes a no-op for
                 // budget. If it fails (network error, etc.), the projector's existing
                 // algorithmic fallback still kicks in.
-                await this.maybeCompactWithLLM();
+                await this.maybeCompactWithLLM(toolDefinitionTokens);
                 const bufferedStreamingToolCallIds = new Set();
+                let currentRequestEstimate;
                 try {
                     markStableCurrentToolResultsForCache(this.messages);
                     const projectedMessages = projectMessages(this.messages, {
                         mode: "budgeted",
                         providerId: this.providerId,
                         modelId: this.apiModel,
-                        usageAnchorTokens: this.lastInputTokens ?? undefined,
-                        anchorMessageCount: this.lastAnchorMessageCount ?? undefined,
+                        // Projection changes message identity/count (meta rendering, pruning,
+                        // chain repair), so a resident-array anchor index is not safe here.
+                        // A fresh estimate also lets us account for current tool schemas.
+                        additionalInputTokens: toolDefinitionTokens,
                     });
+                    const requestBudget = getContextBudget(this.providerId, this.apiModel, projectedMessages, { additionalInputTokens: toolDefinitionTokens });
+                    currentRequestEstimate = requestBudget.estimatedTokens;
+                    const maxInputTokens = getMaxInputTokens(requestBudget.contextWindow);
+                    if (maxInputTokens !== undefined && currentRequestEstimate > maxInputTokens) {
+                        throw new LocalContextPreflightError(currentRequestEstimate, maxInputTokens);
+                    }
                     const providerStartedAt = Date.now();
                     let streamTextChars = 0;
                     let streamReasoningChars = 0;
@@ -1014,9 +1039,13 @@ export class Agent {
                     if (assistantAppended) {
                         throw error;
                     }
-                    if (isProviderStreamInterruption(error)
+                    const streamInterruption = isProviderStreamInterruption(error) ? error : undefined;
+                    const streamRetryLimit = streamInterruption
+                        ? providerStreamRetryLimit(streamInterruption)
+                        : 0;
+                    if (streamInterruption
                         && !isAbortLikeError(error, abortSignal)
-                        && consecutiveStreamInterruptionRetries < MAX_STREAM_INTERRUPTION_RETRIES) {
+                        && consecutiveStreamInterruptionRetries < streamRetryLimit) {
                         // The provider stream died after partial content. The half-built
                         // assistantMsg was never appended to this.messages, and the next
                         // turn_start resets the streaming display, so re-issuing the whole
@@ -1025,10 +1054,12 @@ export class Agent {
                         yield emit({
                             type: "provider_retry",
                             attempt: consecutiveStreamInterruptionRetries,
-                            maxAttempts: MAX_STREAM_INTERRUPTION_RETRIES,
-                            reason: "Provider stream interrupted mid-response.",
+                            maxAttempts: streamRetryLimit,
+                            reason: streamInterruption.message,
                         });
-                        await sleepBeforeRetry(computeRetryDelayMs(consecutiveStreamInterruptionRetries), abortSignal).catch(() => undefined);
+                        await sleepBeforeRetry(computeRetryDelayMs(consecutiveStreamInterruptionRetries, {
+                            retryAfterMs: streamInterruption.retryAfterMs,
+                        }), abortSignal).catch(() => undefined);
                         continue;
                     }
                     if (!isContextOverflowError(error)) {
@@ -1045,12 +1076,44 @@ export class Agent {
                     if (consecutiveOverflowRecoveries >= MAX_CONSECUTIVE_OVERFLOW_RECOVERIES) {
                         throw error;
                     }
-                    const droppedMessages = await this.recoverFromOverflow(consecutiveOverflowRecoveries);
+                    const messagesBeforeRecovery = this.messages;
+                    const inputTokensBeforeRecovery = this.lastInputTokens;
+                    const anchorBeforeRecovery = this.lastAnchorMessageCount;
+                    const failedRequestEstimate = currentRequestEstimate ?? getContextBudget(this.providerId, this.apiModel, projectMessages(this.messages, {
+                        mode: "budgeted",
+                        providerId: this.providerId,
+                        modelId: this.apiModel,
+                        additionalInputTokens: toolDefinitionTokens,
+                    }), { additionalInputTokens: toolDefinitionTokens }).estimatedTokens;
+                    const droppedMessages = await this.recoverFromOverflow(consecutiveOverflowRecoveries, error instanceof LocalContextPreflightError ? 0.999_999 : 0.9);
+                    const recoveredRequestEstimate = getContextBudget(this.providerId, this.apiModel, projectMessages(this.messages, {
+                        mode: "budgeted",
+                        providerId: this.providerId,
+                        modelId: this.apiModel,
+                        additionalInputTokens: toolDefinitionTokens,
+                    }), { additionalInputTokens: toolDefinitionTokens }).estimatedTokens;
+                    // Never issue a retry that is the same size or larger. Apart from
+                    // avoiding a useless retry loop, this proves that already-completed
+                    // tool calls stay historical data rather than being executed again.
+                    const madeProgress = recoveredRequestEstimate < failedRequestEstimate;
+                    const meaningfulProviderProgress = error instanceof LocalContextPreflightError
+                        || recoveredRequestEstimate <= Math.floor(failedRequestEstimate * 0.9);
+                    if (!madeProgress || !meaningfulProviderProgress) {
+                        this.messages = messagesBeforeRecovery;
+                        this.lastInputTokens = inputTokensBeforeRecovery;
+                        this.lastAnchorMessageCount = anchorBeforeRecovery;
+                        throw error;
+                    }
                     consecutiveOverflowRecoveries += 1;
                     this.compactionStats.overflow += 1;
                     this.compactionStats.fired += 1;
                     this.compactionStats.droppedMessages += droppedMessages;
-                    traceEvent("compaction_fired", { path: "overflow", droppedMessages });
+                    traceEvent("compaction_fired", {
+                        path: "overflow",
+                        droppedMessages,
+                        beforeEstimatedTokens: failedRequestEstimate,
+                        afterEstimatedTokens: recoveredRequestEstimate,
+                    });
                     yield emit({ type: "context_recovered", droppedMessages, reason: "overflow" });
                     continue;
                 }
@@ -1175,7 +1238,7 @@ export class Agent {
                             yield emit({ type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments });
                         }
                         if (isHiddenToolResult(blockedResult)) {
-                            let result = blockedResult;
+                            let result = normalizeToolResultForModel(blockedResult, this.providerId, this.apiModel);
                             await hookBus.runAfterToolCall({
                                 agent: this,
                                 cwd,
@@ -1189,6 +1252,7 @@ export class Agent {
                                     result = next;
                                 },
                             });
+                            result = normalizeToolResultForModel(result, this.providerId, this.apiModel);
                             const postToolHook = await this.runExternalHook({
                                 eventName: result.isError ? "PostToolUseFailure" : "PostToolUse",
                                 cwd,
@@ -1292,6 +1356,9 @@ export class Agent {
                                 result = resolved ?? { content: `Error: Tool "${tc.name}" returned no result`, isError: true };
                             }
                         }
+                        // Hooks receive a bounded canonical result. This prevents a tool
+                        // from handing an unbounded multi-megabyte value to PostToolUse.
+                        result = normalizeToolResultForModel(result, this.providerId, this.apiModel);
                         await hookBus.runAfterToolCall({
                             agent: this,
                             cwd,
@@ -1305,6 +1372,9 @@ export class Agent {
                                 result = next;
                             },
                         });
+                        // A hook is allowed to replace the result, so enforce the invariant
+                        // again before persistence, callbacks, UI events and provider reuse.
+                        result = normalizeToolResultForModel(result, this.providerId, this.apiModel);
                         const postToolHook = await this.runExternalHook({
                             eventName: result.isError ? "PostToolUseFailure" : "PostToolUse",
                             cwd,
@@ -1339,7 +1409,10 @@ export class Agent {
                                 truncated: truncatedOutput.truncated,
                                 originalTokens: truncatedOutput.originalTokens,
                                 finalTokens: truncatedOutput.finalTokens,
+                                originalBytes: truncatedOutput.originalBytes,
+                                finalBytes: truncatedOutput.finalBytes,
                                 limit: truncatedOutput.limit,
+                                hardByteLimit: truncatedOutput.hardByteLimit,
                             },
                         }, traceContext);
                         const toolMessage = {
@@ -1458,71 +1531,89 @@ export class Agent {
             }, traceContext);
         }
     }
-    async recoverFromOverflow(attempt) {
+    async recoverFromOverflow(attempt, maximumSizeRatio = 0.999_999) {
         const before = this.messages.length;
-        const beforeTokens = this.messages.reduce((sum, m) => sum + JSON.stringify(m).length, 0);
+        const originalMessages = this.messages;
+        const beforeBytes = serializedMessageBytes(originalMessages);
+        const commitIfSmaller = (candidate, summary) => {
+            if (!candidate
+                || serializedMessageBytes(candidate) > Math.floor(beforeBytes * maximumSizeRatio))
+                return false;
+            this.messages = candidate;
+            this.lastInputTokens = null;
+            this.lastAnchorMessageCount = null;
+            this.fileStateTracker?.invalidateReadHistory();
+            this.persistCompactionSummary(summary);
+            return true;
+        };
         if (attempt === 0) {
-            this.messages = aggressivePruneMessages(this.messages);
-            const afterTokens = this.messages.reduce((sum, m) => sum + JSON.stringify(m).length, 0);
-            if (afterTokens < beforeTokens) {
-                this.lastInputTokens = null;
-                this.lastAnchorMessageCount = null;
-                this.fileStateTracker?.invalidateReadHistory();
+            if (commitIfSmaller(aggressivePruneMessages(originalMessages))) {
                 return before - this.messages.length;
             }
         }
-        const keepRecentTurns = attempt >= 2 ? 1 : 2;
-        const llmResult = await compactMessagesWithLLM(this.messages, {
+        // Unlike ordinary pruning, overflow recovery is allowed to thin the most
+        // recent completed tool batch. Keeping it protected is exactly what made
+        // a one-turn 6MB grep result impossible to recover from.
+        const emergencyToolLimit = attempt === 0 ? 16 * 1024 : 4 * 1024;
+        const thinnedLatestTools = originalMessages.map((message) => {
+            if (message.role !== "tool")
+                return message;
+            const bounded = truncateToolOutputForModel(message.content, this.providerId, this.apiModel, { hardByteLimit: emergencyToolLimit });
+            return bounded.truncated ? { ...message, content: bounded.content } : message;
+        });
+        if (commitIfSmaller(thinnedLatestTools)) {
+            return before - this.messages.length;
+        }
+        const keepRecentTurns = attempt >= 1 ? 1 : 2;
+        const llmResult = await compactMessagesWithLLM(originalMessages, {
             provider: this.provider,
             model: this.apiModel,
             thinkingLevel: this.thinkingLevel,
             keepRecentTurns,
         });
-        if (llmResult.compacted && llmResult.messages) {
-            this.messages = llmResult.messages;
-            this.lastInputTokens = null;
-            this.lastAnchorMessageCount = null;
-            this.fileStateTracker?.invalidateReadHistory();
-            this.persistCompactionSummary(llmResult.summary);
+        if (llmResult.compacted && commitIfSmaller(llmResult.messages, llmResult.summary)) {
             return before - this.messages.length;
         }
         // Single-turn capable LLM compactor. compactMessagesWithLLM above no-ops
         // when there's only one user turn (the "single huge prompt with many tool
         // calls" case), so try the turn-internal compactor before giving up.
         const { compactWithLLM } = await import("./context/llm-compactor.js");
-        const singleTurnResult = await compactWithLLM(this.messages, {
+        const singleTurnResult = await compactWithLLM(originalMessages, {
             provider: this.provider,
             modelId: this.apiModel,
         });
-        if (singleTurnResult.compacted && singleTurnResult.messages) {
-            this.messages = singleTurnResult.messages;
-            this.lastInputTokens = null;
-            this.lastAnchorMessageCount = null;
-            this.fileStateTracker?.invalidateReadHistory();
-            this.persistCompactionSummary(singleTurnResult.summary);
+        if (singleTurnResult.compacted && commitIfSmaller(singleTurnResult.messages, singleTurnResult.summary)) {
             return before - this.messages.length;
         }
-        const fallback = compactMessages(this.messages, { keepRecentTurns });
-        if (fallback.compacted && fallback.messages) {
-            this.messages = fallback.messages;
-            this.lastInputTokens = null;
-            this.lastAnchorMessageCount = null;
-            this.fileStateTracker?.invalidateReadHistory();
-            this.persistCompactionSummary(fallback.summary);
+        const fallback = compactMessages(originalMessages, { keepRecentTurns });
+        if (fallback.compacted && commitIfSmaller(fallback.messages, fallback.summary)) {
+            return before - this.messages.length;
+        }
+        const subturn = compactCurrentTurnToolGroups(originalMessages, {
+            keepRecentGroups: attempt === 0 ? 1 : 0,
+        });
+        if (subturn.compacted && commitIfSmaller(subturn.messages, subturn.summary)) {
             return before - this.messages.length;
         }
         // Codex-style last-resort: drop the single oldest non-protected message
         // and let the retry loop try again. Cheap, but eventually narrows even an
         // intractable single-turn overflow.
-        const oldestIdx = this.messages.findIndex((m) => m.role !== "system" && m.role !== "meta");
-        if (oldestIdx >= 0 && oldestIdx < this.messages.length - 1) {
-            this.messages = [
-                ...this.messages.slice(0, oldestIdx),
-                ...this.messages.slice(oldestIdx + 1),
+        const realUserIndexes = originalMessages
+            .map((message, index) => message.role === "user" ? index : -1)
+            .filter((index) => index >= 0);
+        const oldestIdx = realUserIndexes.length > 1
+            ? realUserIndexes[0]
+            : -1;
+        const removeUntil = realUserIndexes.length > 1
+            ? realUserIndexes[1]
+            : -1;
+        if (oldestIdx >= 0 && removeUntil > oldestIdx && removeUntil < originalMessages.length) {
+            const candidate = [
+                ...originalMessages.slice(0, oldestIdx),
+                ...originalMessages.slice(removeUntil),
             ];
-            this.lastInputTokens = null;
-            this.lastAnchorMessageCount = null;
-            this.fileStateTracker?.invalidateReadHistory();
+            if (!commitIfSmaller(candidate))
+                return 0;
             return before - this.messages.length;
         }
         return 0;
@@ -1530,7 +1621,7 @@ export class Agent {
     compactResidentHistory() {
         this.maybeCompactResidentHistory();
     }
-    async maybeCompactWithLLM() {
+    async maybeCompactWithLLM(additionalInputTokens = 0) {
         if (!this.providerId || !this.apiModel)
             return;
         if (this.messages.length === 0)
@@ -1541,6 +1632,7 @@ export class Agent {
         const budget = getContextBudget(this.providerId, this.apiModel, this.messages, {
             usageAnchorTokens: this.lastInputTokens ?? undefined,
             tailMessages: tail,
+            additionalInputTokens,
         });
         if (!budget.shouldCompact)
             return;
@@ -1576,7 +1668,7 @@ export class Agent {
      * (the caller falls back to heuristic compaction in that case). Throws only
      * if the provider stream itself errors.
      */
-    async summarizeForCompaction(oldMessages, onDelta, abortSignal) {
+    async summarizeForCompaction(oldMessages, onDelta, abortSignal, userContext) {
         if (oldMessages.length === 0)
             return "";
         const { buildCompactionPromptMessages } = await import("./context/compact-llm.js");
@@ -1589,7 +1681,7 @@ export class Agent {
         const promptInput = oldMessages.map((message) => isCompactionSummaryMessage(message) && typeof message.content === "string"
             ? { ...message, content: stripFileBlocks(messageText(message)) }
             : message);
-        const promptMessages = buildCompactionPromptMessages(promptInput);
+        const promptMessages = buildCompactionPromptMessages(promptInput, userContext);
         const stream = this.provider.streamChat(promptMessages, {
             model: this.apiModel,
             temperature: 0.2,
@@ -1641,6 +1733,12 @@ export class Agent {
     listSubAgents() {
         return this.subagents.listSubAgents();
     }
+    /** Read-only child transcript for the TUI inspector. */
+    getSubAgentMessages(agentId) {
+        const record = this.subagentStore.get(agentId);
+        const messages = record?.agent?.messages ?? record?.messages ?? [];
+        return messages.map((message) => ({ ...message }));
+    }
     /** Marks a child's full summary as delivered to parent context (design §3.3). */
     markSubagentDelivered(agentId) {
         this.subagents.markSubagentDelivered(agentId);
@@ -1982,3 +2080,6 @@ export class Agent {
         }
     }
 }
+function serializedMessageBytes(messages) {
+    return Buffer.byteLength(JSON.stringify(messages), "utf8");
+}

package/dist/bin.js

@@ -1,45 +1,3 @@
 #!/usr/bin/env node
-import { spawn, spawnSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-const mainPath = fileURLToPath(new URL("./main.js", import.meta.url));
-if (process.versions.bun) {
-    await import("./main.js");
-}
-else {
-    const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
-    if (bunCheck.error) {
-        console.error([
-            "Bubble requires Bun to run.",
-            "",
-            "Install Bun, then run bubble again:",
-            "  curl -fsSL https://bun.sh/install | bash",
-            "",
-            "After installation, restart your terminal if the bun command is not found.",
-        ].join("\n"));
-        process.exit(1);
-    }
-    const child = spawn("bun", [mainPath, ...process.argv.slice(2)], {
-        stdio: "inherit",
-        env: process.env,
-    });
-    child.on("error", (error) => {
-        console.error(`Failed to start Bubble with Bun: ${error.message}`);
-        process.exit(1);
-    });
-    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
-        process.on(signal, () => {
-            if (!child.killed) {
-                child.kill(signal);
-            }
-        });
-    }
-    const result = await new Promise((resolve) => {
-        child.on("exit", (code, signal) => resolve({ code, signal }));
-    });
-    if (result.signal) {
-        process.kill(process.pid, result.signal);
-    }
-    else {
-        process.exit(result.code ?? 1);
-    }
-}
+await import("./main.js");
+export {};

package/dist/config.d.ts

@@ -17,6 +17,10 @@ export interface UserConfigData {
     defaultModel?: string;
     defaultThinkingLevel?: ThinkingLevel;
     skillPaths?: string[];
+    /** Skill names disabled from invocation/search until re-enabled in /skills. */
+    skills?: {
+        disabled?: string[];
+    };
     /**
      * Three shapes are accepted on disk so we can evolve without breaking
      * existing configs:
@@ -35,9 +39,14 @@ export interface UserConfigData {
     /** Subagent model-routing knobs: autoTier (default true), allowCrossProvider (default true). */
     agentRouting?: Partial<AgentRoutingConfig>;
     subagents?: SubagentsUserConfig;
-    /** Background tasks (design §2.3b): autoResume defaults ON; false keeps notices + reminders only. */
+    /** Background tasks: completion wakes and Grok-style foreground demotion. */
     tasks?: {
+        /** Auto-resume the Agent when an owned task finishes. Defaults ON. */
         autoResume?: boolean;
+        /** Move long foreground Execute calls into Tasks automatically. Defaults ON. */
+        autoBackground?: boolean;
+        /** Foreground wait budget before automatic demotion. Defaults to 15 seconds. */
+        foregroundWaitMs?: number;
     };
 }
 export interface SubagentsUserConfig {
@@ -56,6 +65,8 @@ export declare class UserConfig {
     getRecentModels(): string[];
     /** Auto-resume on background-task completion (design §2.3b). Default ON. */
     getTasksAutoResume(): boolean;
+    /** Grok-style foreground wait budget. `false` disables automatic demotion. */
+    getTasksAutoBackgroundAfterMs(): number | false;
     pushRecentModel(model: string): void;
     getApiKey(): string | undefined;
     setApiKey(key: string): void;
@@ -65,6 +76,8 @@ export declare class UserConfig {
     setDefaultProvider(id: string): void;
     getSkillPaths(): string[];
     setSkillPaths(paths: string[]): void;
+    getDisabledSkills(): string[];
+    setDisabledSkills(names: string[]): void;
     getTheme(): ThemeConfig;
     getThemeMode(): ThemeMode;
     getThemeOverrides(): Record<string, string>;

package/dist/config.js

@@ -8,7 +8,10 @@ import { dirname, join } from "node:path";
 import { getBubbleHome } from "./bubble-home.js";
 import { sanitizeAgentCategories } from "./agent/categories.js";
 import { sanitizeAgentRouting } from "./agent/routing-catalog.js";
-const HIDDEN_PROVIDER_IDS = new Set(["openrouter", "openai-codex"]);
+import { isProviderModelAllowed } from "./provider-model-policy.js";
+// openai-codex is an internal transport profile surfaced through the visible
+// OpenAI OAuth provider. OpenRouter is a regular user-configurable provider.
+const HIDDEN_PROVIDER_IDS = new Set(["openai-codex"]);
 function getConfigPath() {
     return join(getBubbleHome(), "config.json");
 }
@@ -20,10 +23,16 @@ function modelProviderId(model) {
         return undefined;
     return model.split(":", 1)[0];
 }
+function isAllowedConfiguredModel(model) {
+    if (!model.includes(":"))
+        return true;
+    const [providerId, ...modelParts] = model.split(":");
+    return isProviderModelAllowed(providerId, modelParts.join(":"));
+}
 function sanitizeRecentModels(models) {
     if (!models)
         return undefined;
-    return models.filter((model) => !isHiddenProviderId(modelProviderId(model)));
+    return models.filter((model) => !isHiddenProviderId(modelProviderId(model)) && isAllowedConfiguredModel(model));
 }
 function sanitizeProviders(providers) {
     if (!providers)
@@ -33,7 +42,9 @@ function sanitizeProviders(providers) {
 function sanitizeDefaultModel(model) {
     if (!model)
         return undefined;
-    return isHiddenProviderId(modelProviderId(model)) ? undefined : model;
+    return isHiddenProviderId(modelProviderId(model)) || !isAllowedConfiguredModel(model)
+        ? undefined
+        : model;
 }
 function sanitizeDefaultProvider(providerId) {
     return isHiddenProviderId(providerId) ? undefined : providerId;
@@ -143,8 +154,17 @@ export class UserConfig {
     getTasksAutoResume() {
         return this.data.tasks?.autoResume !== false;
     }
+    /** Grok-style foreground wait budget. `false` disables automatic demotion. */
+    getTasksAutoBackgroundAfterMs() {
+        if (this.data.tasks?.autoBackground === false)
+            return false;
+        const configured = this.data.tasks?.foregroundWaitMs;
+        if (typeof configured !== "number" || !Number.isFinite(configured))
+            return 15_000;
+        return Math.max(1_000, Math.min(300_000, Math.floor(configured)));
+    }
     pushRecentModel(model) {
-        if (isHiddenProviderId(modelProviderId(model))) {
+        if (isHiddenProviderId(modelProviderId(model)) || !isAllowedConfiguredModel(model)) {
             return;
         }
         const recent = this.data.recentModels ?? [];
@@ -182,6 +202,27 @@ export class UserConfig {
         this.data.skillPaths = paths.slice();
         this.save();
     }
+    getDisabledSkills() {
+        const disabled = this.data.skills?.disabled;
+        if (!Array.isArray(disabled))
+            return [];
+        return [...new Set(disabled.filter((name) => (typeof name === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name))))].sort((a, b) => a.localeCompare(b));
+    }
+    setDisabledSkills(names) {
+        const disabled = [...new Set(names.filter((name) => (/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name))))].sort((a, b) => a.localeCompare(b));
+        if (disabled.length === 0) {
+            const next = { ...(this.data.skills ?? {}) };
+            delete next.disabled;
+            if (Object.keys(next).length === 0)
+                delete this.data.skills;
+            else
+                this.data.skills = next;
+        }
+        else {
+            this.data.skills = { ...(this.data.skills ?? {}), disabled };
+        }
+        this.save();
+    }
     getTheme() {
         const theme = sanitizeTheme(this.data.theme);
         return theme ?? { mode: "auto" };

package/dist/context/budget.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "../types.js";
+import type { Message, ToolDefinition } from "../types.js";
 export declare const OUTPUT_RESERVE_TOKENS = 20000;
 export declare const AUTOCOMPACT_BUFFER_TOKENS = 13000;
 export declare const PRUNE_BUFFER_TOKENS = 50000;
@@ -15,8 +15,14 @@ export interface ContextBudgetOptions {
     usageAnchorTokens?: number;
     /** Messages appended after the anchor (their tokens are estimated and added). */
     tailMessages?: Message[];
+    /** Tokens outside the message list, primarily serialized tool definitions. */
+    additionalInputTokens?: number;
 }
 export declare function estimateMessageTokens(message: Message, providerId?: string): number;
 export declare function estimateContextTokens(messages: Message[], providerId?: string): number;
 export declare function getContextBudget(providerId: string, modelId: string, messages: Message[], options?: ContextBudgetOptions): ContextBudget;
+/** Estimate the request-space occupied by tool schemas sent on every turn. */
+export declare function estimateToolDefinitionsTokens(tools: ToolDefinition[], providerId?: string): number;
+/** Maximum estimated input size that still leaves useful room for an answer. */
+export declare function getMaxInputTokens(contextWindow: number | undefined): number | undefined;
 export declare function estimateTextTokens(text: string, providerId?: string): number;

package/dist/context/budget.js

@@ -65,16 +65,39 @@ export function getContextBudget(providerId, modelId, messages, options = {}) {
     };
 }
 function computeEstimatedTokens(providerId, messages, options) {
+    const additionalInputTokens = Math.max(0, options.additionalInputTokens ?? 0);
     if (options.usageAnchorTokens !== undefined && options.tailMessages) {
         // Anchor is authoritative (server-reported input tokens from the last
         // response). Tail goes through our estimator and may undercount on dense /
         // tool-output content, so we inflate it by a small margin before adding.
         const tailEstimate = estimateContextTokens(options.tailMessages, providerId);
-        return options.usageAnchorTokens + Math.ceil(tailEstimate * TAIL_SAFETY_MARGIN);
+        return options.usageAnchorTokens
+            + Math.ceil(tailEstimate * TAIL_SAFETY_MARGIN)
+            + additionalInputTokens;
     }
     // First turn (or anchor lost): there's no server-reported baseline at all,
     // so apply a larger safety margin to the pure estimate.
-    return Math.ceil(estimateContextTokens(messages, providerId) * FIRST_TURN_SAFETY_MARGIN);
+    return Math.ceil((estimateContextTokens(messages, providerId) + additionalInputTokens)
+        * FIRST_TURN_SAFETY_MARGIN);
+}
+/** Estimate the request-space occupied by tool schemas sent on every turn. */
+export function estimateToolDefinitionsTokens(tools, providerId) {
+    if (tools.length === 0)
+        return 0;
+    // Providers wrap this array in their own function/tool envelope. The fixed
+    // per-entry allowance covers names, discriminator keys and separators not
+    // represented by the plain JSON payload.
+    return estimateTextTokens(JSON.stringify(tools), providerId) + tools.length * 16 + 16;
+}
+/** Maximum estimated input size that still leaves useful room for an answer. */
+export function getMaxInputTokens(contextWindow) {
+    if (!contextWindow)
+        return undefined;
+    return contextWindow >= MIN_WINDOW_FOR_RESERVE
+        ? Math.max(1, contextWindow
+            - OUTPUT_RESERVE_TOKENS
+            - Math.max(AUTOCOMPACT_BUFFER_TOKENS, Math.floor(contextWindow * 0.05)))
+        : Math.max(1, Math.floor(contextWindow * 0.75));
 }
 function shouldTriggerPrune(estimatedTokens, contextWindow) {
     if (!contextWindow) {

package/dist/context/compact-llm.d.ts

@@ -21,5 +21,5 @@ export declare function compactMessagesWithLLM(messages: Message[], options: LLM
  * `oldMessages`. Shared by the non-streaming overflow path (`generateSummary`)
  * and the streaming manual `/compact` path (`Agent.summarizeForCompaction`).
  */
-export declare function buildCompactionPromptMessages(oldMessages: Message[]): ProviderMessage[];
+export declare function buildCompactionPromptMessages(oldMessages: Message[], userContext?: string): ProviderMessage[];
 export declare function serializeTranscript(messages: Message[]): string;