@bubblebrain-ai/bubble 0.0.34 → 0.0.36

package/README.md

@@ -2,7 +2,7 @@
 
 Bubble is a terminal coding agent. It works inside a local project folder: it reads and edits files, runs commands behind configurable approval controls, searches and navigates code with language-server intelligence, browses the web, loads reusable skills, connects MCP tools, fans work out to subagents, and keeps persistent memory across sessions.
 
-It is provider-agnostic. Bring an API key for OpenAI, Anthropic, Google, DeepSeek, Moonshot/Kimi, Zhipu, Z.AI, MiniMax, Groq, Together, Fireworks, a local OpenAI-compatible endpoint, and more — or sign in to ChatGPT with OAuth and drive the Codex models directly.
+It is provider-agnostic. Bring an API key for OpenAI, Anthropic, Google, DeepSeek, Moonshot/Kimi, Zhipu, Z.AI, MiniMax, Groq, Together, Fireworks, a local OpenAI-compatible endpoint, and more; sign in to ChatGPT with OAuth; or sign in with OAuth to use a ChatGPT or Grok subscription directly.
 
 ---
 
@@ -39,10 +39,10 @@ Start Bubble in the current directory:
 bubble
 ```
 
-On first launch, connect a model:
+On first launch, connect a provider:
 
 - Run `/login` to sign in to ChatGPT (OAuth) and use the Codex models, or
-- Run `/provider` to add any other provider with an API key.
+- Run `/provider` to select Grok Subscription or add a provider with an API key.
 
 Then just type what you want done. Bubble plans, edits files, and runs commands, asking for approval where the current permission mode requires it.
 
@@ -64,10 +64,30 @@ Bubble ships with a catalog of built-in providers. Configure them inside the app
 
 | How | What it does |
 | --- | --- |
-| `/login` | OAuth sign-in for ChatGPT; unlocks the OpenAI Codex models without an API key. |
-| `/provider` | Open a picker to connect, switch, add, or remove a provider. |
+| `/login` | OAuth sign-in for ChatGPT or Grok Subscription; `/login grok` starts the Grok flow directly. |
+| `/provider` | Open a picker to connect, switch, add, or remove a provider, including Grok Subscription. |
 | `/model` | Pick the active model and reasoning effort. |
 
+### Grok Subscription Provider
+
+A Grok subscription works as a native model provider, exactly like ChatGPT
+OAuth: sign in once in the browser and the subscription models (`grok-4.5`,
+`grok-composer-2.5-fast`) drive Bubble's own agent loop — Bubble's tools,
+skills, MCP servers, subagents, memory, permission modes, and approval UI all
+apply as usual. `/model` selects the model and reasoning effort.
+
+```bash
+bubble
+# In the TUI: /login grok
+# or choose Grok Subscription from /provider
+```
+
+`/login grok` opens the xAI sign-in page in the default browser. If you have
+already signed in with the official Grok CLI, Bubble imports that login and
+skips the browser. Tokens are stored in `~/.bubble/auth.json` alongside other
+provider credentials and refresh automatically. Use `/logout grok` to remove
+this device's login.
+
 Built-in providers include OpenAI, Anthropic, Google, DeepSeek, Moonshot (CN and international), Kimi for Coding, Zhipu AI, Z.AI, Alibaba DashScope, Doubao (Volcengine Ark), MiniMax, StepFun, Groq, Together AI, Fireworks, and a `local` profile for any OpenAI-compatible endpoint (Ollama, vLLM, LM Studio, etc.).
 
 For Doubao Seed models on Volcengine Ark, run `/provider --add doubao` and paste your Ark API key. The built-in endpoint is `https://ark.cn-beijing.volces.com/api/v3` and uses Ark's Responses API. The model picker exposes `minimal`, `low`, `medium`, and `high`, defaulting to `high`; `minimal` disables Ark thinking, while the other levels enable it.
@@ -95,7 +115,7 @@ For full control — custom base URLs, self-hosted gateways, extra models, or pi
 
 ### Reasoning effort
 
-Models that support it expose a reasoning-effort control: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Set it with `/model <id> --reasoning-effort <level>` in the app, or at launch with `--reasoning` (medium) or `--reasoning-effort <level>`.
+Models that support it expose a reasoning-effort control: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `ultra`. Set it with `/model <id> --reasoning-effort <level>` in the app, or at launch with `--reasoning` (medium) or `--reasoning-effort <level>`.
 
 ## Permission modes
 
@@ -191,7 +211,7 @@ Options (default):
   -r, --resume             Resume a previous session (latest by default)
   --session <name>         Session name to create or resume
   --reasoning              Enable reasoning mode at medium effort
-  --reasoning-effort <l>   Set reasoning effort: off|minimal|low|medium|high|xhigh|max
+  --reasoning-effort <l>   Set reasoning effort: off|minimal|low|medium|high|xhigh|max|ultra
   --plan                   Start in plan mode (read-only investigation; propose before executing)
   --dangerously-skip-permissions
                            Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)

package/dist/agent/abort-errors.d.ts

@@ -7,8 +7,8 @@ export declare class AgentAbortError extends Error {
  * message strings.
  */
 export declare class SubagentAbortError extends AgentAbortError {
-    readonly subagentReason: "interrupt" | "user_close" | "budget";
-    constructor(message: string, subagentReason: "interrupt" | "user_close" | "budget");
+    readonly subagentReason: "interrupt" | "user_close";
+    constructor(message: string, subagentReason: "interrupt" | "user_close");
 }
 /** Shown when the model produced no user-visible content despite recovery attempts. */
 export declare const EMPTY_ASSISTANT_FALLBACK = "The model returned no user-visible response. Please retry, or switch models if this keeps happening.";

package/dist/agent/budget-ledger.d.ts

@@ -1,61 +1,20 @@
 import type { TokenUsage } from "../types.js";
-import type { SubagentTokenCap } from "./subagent-control.js";
 export interface BudgetUsageSource {
     runId: string;
     subAgentId?: string;
 }
-export interface BudgetSnapshot {
-    spent: number;
-    limit?: number;
-    exhausted: boolean;
-}
 /**
  * Shared token ledger for a parent and all of its children, with per-source
- * accounting so the runtime can enforce per-child caps (design doc §6).
- * The shared pool limit is optional — both production hosts construct the
- * ledger without one — so per-child caps must never be derived solely from
- * "pool remaining"; see computeChildTokenCap.
+ * accounting. Pure bookkeeping: nothing is ever stopped for token usage —
+ * a child's only resource bound is the model context window, absorbed by
+ * compaction (design doc §6, revised 2026-07-06).
  */
 export declare class BudgetLedger {
-    private readonly limit?;
     private spent;
     private readonly spentBySource;
-    private readonly controller;
-    constructor(limit?: number | undefined);
-    get signal(): AbortSignal;
     recordUsage(usage: TokenUsage, source: BudgetUsageSource): void;
     /** Tokens attributed to one child (or the parent when subAgentId is omitted). */
     spentBy(subAgentId?: string): number;
-    /** Pool tokens remaining, or undefined when the pool has no limit. */
-    remaining(): number | undefined;
-    get poolLimit(): number | undefined;
-    snapshot(): BudgetSnapshot;
+    totalSpent(): number;
 }
-/** Default absolute per-child soft cap; applies even on limit-free hosts. */
-export declare const DEFAULT_CHILD_TOKEN_CAP = 200000;
-/** Share of a limited pool reserved for the parent's own turns. */
-export declare const PARENT_POOL_RESERVE_RATIO = 0.2;
-/** Hard cap sits at least this many tokens above the soft cap (≈ 2 turns). */
-export declare const CHILD_HARD_CAP_FLOOR = 20000;
-/**
- * Per-child token cap, fixed at dispatch (design doc §6). The soft cap is an
- * absolute number (config default 200k) so it is effective on limit-free
- * hosts; when the pool *is* limited, the fair share of what remains after the
- * parent's reserve further bounds it. The cap never shrinks mid-run because
- * siblings spawned later.
- */
-export declare function computeChildTokenCap(options: {
-    ledger?: BudgetLedger;
-    subAgentId: string;
-    activeChildren: number;
-    configCap?: number;
-    profileMaxTokens?: number;
-}): SubagentTokenCap;
-/**
- * Hard cap recomputed at each turn-boundary check: at least ~2 of this
- * child's average turns above the soft cap, never below the absolute floor
- * (design doc §6 — replaces the fixed 25% ratio that could be smaller than a
- * single turn).
- */
-export declare function childHardCap(soft: number, avgTurnTokens: number): number;
 export declare function composeAbortSignals(signals: Array<AbortSignal | undefined>): AbortSignal | undefined;

package/dist/agent/budget-ledger.js

@@ -1,96 +1,26 @@
 const PARENT_SOURCE_KEY = "__parent__";
 /**
  * Shared token ledger for a parent and all of its children, with per-source
- * accounting so the runtime can enforce per-child caps (design doc §6).
- * The shared pool limit is optional — both production hosts construct the
- * ledger without one — so per-child caps must never be derived solely from
- * "pool remaining"; see computeChildTokenCap.
+ * accounting. Pure bookkeeping: nothing is ever stopped for token usage —
+ * a child's only resource bound is the model context window, absorbed by
+ * compaction (design doc §6, revised 2026-07-06).
  */
 export class BudgetLedger {
-    limit;
     spent = 0;
     spentBySource = new Map();
-    controller = new AbortController();
-    constructor(limit) {
-        this.limit = limit;
-    }
-    get signal() {
-        return this.controller.signal;
-    }
     recordUsage(usage, source) {
         const delta = usage.promptTokens + usage.completionTokens;
         this.spent += delta;
         const key = source.subAgentId ?? PARENT_SOURCE_KEY;
         this.spentBySource.set(key, (this.spentBySource.get(key) ?? 0) + delta);
-        if (this.limit !== undefined && this.spent >= this.limit && !this.controller.signal.aborted) {
-            this.controller.abort(budgetAbortError("Budget exhausted"));
-        }
     }
     /** Tokens attributed to one child (or the parent when subAgentId is omitted). */
     spentBy(subAgentId) {
         return this.spentBySource.get(subAgentId ?? PARENT_SOURCE_KEY) ?? 0;
     }
-    /** Pool tokens remaining, or undefined when the pool has no limit. */
-    remaining() {
-        if (this.limit === undefined)
-            return undefined;
-        return Math.max(0, this.limit - this.spent);
-    }
-    get poolLimit() {
-        return this.limit;
+    totalSpent() {
+        return this.spent;
     }
-    snapshot() {
-        return {
-            spent: this.spent,
-            limit: this.limit,
-            exhausted: this.limit !== undefined && this.spent >= this.limit,
-        };
-    }
-}
-/** Default absolute per-child soft cap; applies even on limit-free hosts. */
-export const DEFAULT_CHILD_TOKEN_CAP = 200_000;
-/** Share of a limited pool reserved for the parent's own turns. */
-export const PARENT_POOL_RESERVE_RATIO = 0.2;
-/** Hard cap sits at least this many tokens above the soft cap (≈ 2 turns). */
-export const CHILD_HARD_CAP_FLOOR = 20_000;
-/**
- * Per-child token cap, fixed at dispatch (design doc §6). The soft cap is an
- * absolute number (config default 200k) so it is effective on limit-free
- * hosts; when the pool *is* limited, the fair share of what remains after the
- * parent's reserve further bounds it. The cap never shrinks mid-run because
- * siblings spawned later.
- */
-export function computeChildTokenCap(options) {
-    let soft = options.configCap ?? DEFAULT_CHILD_TOKEN_CAP;
-    if (options.profileMaxTokens !== undefined && options.profileMaxTokens > 0) {
-        soft = Math.min(soft, options.profileMaxTokens);
-    }
-    const limit = options.ledger?.poolLimit;
-    if (options.ledger && limit !== undefined) {
-        const reserve = Math.floor(limit * PARENT_POOL_RESERVE_RATIO);
-        const available = Math.max(0, (options.ledger.remaining() ?? 0) - reserve);
-        const share = Math.floor(available / (options.activeChildren + 1));
-        soft = Math.max(1, Math.min(soft, share));
-    }
-    return {
-        soft,
-        hard: soft + CHILD_HARD_CAP_FLOOR,
-        baseline: options.ledger?.spentBy(options.subAgentId) ?? 0,
-    };
-}
-/**
- * Hard cap recomputed at each turn-boundary check: at least ~2 of this
- * child's average turns above the soft cap, never below the absolute floor
- * (design doc §6 — replaces the fixed 25% ratio that could be smaller than a
- * single turn).
- */
-export function childHardCap(soft, avgTurnTokens) {
-    return soft + Math.max(CHILD_HARD_CAP_FLOOR, Math.ceil(avgTurnTokens * 2));
-}
-function budgetAbortError(message) {
-    const error = new Error(message);
-    error.name = "AbortError";
-    return error;
 }
 export function composeAbortSignals(signals) {
     const active = signals.filter((signal) => !!signal);

package/dist/agent/categories.d.ts

@@ -1,18 +1,50 @@
-import type { ThinkingLevel } from "../types.js";
+import type { ModelTier } from "../model-catalog.js";
+import { type ThinkingLevel } from "../types.js";
 export interface AgentCategoryConfig {
     model?: string;
+    /**
+     * Resolve the model by tier within the parent provider's catalog
+     * (docs/model-routing-design.md §3.1). Mutually exclusive with `model`;
+     * `model` wins if both are set.
+     */
+    tier?: ModelTier | "inherit";
     thinkingLevel?: ThinkingLevel;
     maxConcurrent?: number;
 }
 export type AgentCategoriesConfig = Record<string, AgentCategoryConfig>;
+/**
+ * Field-level provenance for the model-determining fields (§3.3): a value is
+ * "user" ONLY when the user's config object literally contained that key.
+ * thinkingLevel/maxConcurrent overrides carry no routing authority, so a
+ * partially-overridden builtin category keeps its builtin tier under the
+ * rank guard.
+ */
+export interface AgentCategoryProvenance {
+    tierSource?: "builtin" | "user";
+    modelSource?: "builtin" | "user";
+}
+export interface MergedAgentCategory {
+    config: AgentCategoryConfig;
+    provenance: AgentCategoryProvenance;
+}
 export interface ModelRoute {
     providerId: string;
     model: string;
     thinkingLevel: ThinkingLevel;
 }
+/** Which precedence layer decided the model at the category level. */
+export type CategoryModelSource = "builtin-tier" | "user-category";
+/** Which precedence layer decided the FINAL model (§3.4, chain-tracked). */
+export type RouteModelSource = "inherit" | CategoryModelSource | "profile" | "callsite";
 export interface ResolvedSubagentRoute extends ModelRoute {
     category?: string;
     inherited: boolean;
+    /** Set when the category layer decided the model (undefined = inherit). */
+    categoryModelSource?: CategoryModelSource;
+    /** True iff providerId+model equal the parent's — regardless of effort (§3.4). */
+    modelInherited?: boolean;
+    /** Assigned while applying the precedence chain, never inferred from final values. */
+    modelSource?: RouteModelSource;
 }
 export type CategoryResolution = {
     route: ResolvedSubagentRoute;
@@ -23,10 +55,42 @@ export interface ResolvedModelSelection {
     providerId: string;
     model: string | "inherit";
 }
+/** Catalog entry visible to tier resolution (built by routing-catalog.ts). */
+export interface TierCatalogEntry {
+    id: string;
+    tier?: ModelTier;
+    /** models.json user-authored ordering; wins over everything (§3.2). */
+    routingPriority?: number;
+    /** Index in the builtin catalog order, when the id is builtin. */
+    builtinIndex?: number;
+}
+/** Context for rank-guarded automatic tier routing (§3.2). */
+export interface TierRoutingContext {
+    /** Tier of the parent's own model, if annotated. */
+    parentTier?: ModelTier;
+    /** Same-provider catalog the tier is resolved against. */
+    models: TierCatalogEntry[];
+    /** agentRouting.autoTier kill switch (default true). */
+    autoTier: boolean;
+}
+export declare const TIER_RANK: Record<ModelTier, number>;
 export declare function builtinAgentCategories(): AgentCategoriesConfig;
 export declare function mergeAgentCategories(userCategories?: AgentCategoriesConfig): AgentCategoriesConfig;
+/**
+ * Field-level merge with provenance (§3.3). The merge itself is identical to
+ * mergeAgentCategories; provenance records whether the user literally wrote
+ * `tier` / `model`, so builtin tiers flowing through a partial override never
+ * masquerade as user intent.
+ */
+export declare function mergeAgentCategoriesWithProvenance(userCategories?: AgentCategoriesConfig): Record<string, MergedAgentCategory>;
 export declare function sanitizeAgentCategories(value: unknown): AgentCategoriesConfig;
-export declare function resolveSubagentRoute(category: string | undefined, parent: ModelRoute, categories?: AgentCategoriesConfig): CategoryResolution;
+export declare function resolveSubagentRoute(category: string | undefined, parent: ModelRoute, categories?: AgentCategoriesConfig, tierContext?: TierRoutingContext): CategoryResolution;
+/**
+ * Deterministic within-tier ordering (§3.2): user routingPriority, then
+ * builtin catalog order, then normalized id — never a remote response's
+ * array order.
+ */
+export declare function selectTierCandidates(models: TierCatalogEntry[], tier: ModelTier): TierCatalogEntry[];
 export declare function resolveModelRoute(model: string | undefined, parentProviderId: string): ResolvedModelSelection;
 export declare function resolveSameProviderModelRoute(model: string | undefined, parentProviderId: string): {
     model: string | "inherit";

package/dist/agent/categories.js

@@ -1,16 +1,9 @@
-const THINKING_LEVELS = new Set([
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-]);
+import { THINKING_LEVELS } from "../types.js";
+export const TIER_RANK = { fast: 0, balanced: 1, strong: 2 };
 const BUILTIN_CATEGORIES = {
-    quick: { model: "inherit", thinkingLevel: "low", maxConcurrent: 3 },
+    quick: { model: "inherit", tier: "fast", thinkingLevel: "low", maxConcurrent: 3 },
+    explore: { model: "inherit", tier: "fast", thinkingLevel: "low", maxConcurrent: 3 },
     deep: { model: "inherit", thinkingLevel: "high", maxConcurrent: 2 },
-    explore: { model: "inherit", thinkingLevel: "low", maxConcurrent: 3 },
     review: { model: "inherit", thinkingLevel: "high", maxConcurrent: 2 },
     frontend: { model: "inherit", thinkingLevel: "high", maxConcurrent: 1 },
     writing: { model: "inherit", thinkingLevel: "medium", maxConcurrent: 2 },
@@ -28,6 +21,36 @@ export function mergeAgentCategories(userCategories) {
     }
     return merged;
 }
+/**
+ * Field-level merge with provenance (§3.3). The merge itself is identical to
+ * mergeAgentCategories; provenance records whether the user literally wrote
+ * `tier` / `model`, so builtin tiers flowing through a partial override never
+ * masquerade as user intent.
+ */
+export function mergeAgentCategoriesWithProvenance(userCategories) {
+    const sanitizedUser = sanitizeAgentCategories(userCategories);
+    const out = {};
+    for (const [name, config] of Object.entries(builtinAgentCategories())) {
+        out[name] = {
+            config: { ...config },
+            provenance: {
+                tierSource: config.tier !== undefined ? "builtin" : undefined,
+                modelSource: config.model !== undefined && config.model !== "inherit" ? "builtin" : undefined,
+            },
+        };
+    }
+    for (const [name, config] of Object.entries(sanitizedUser)) {
+        const existing = out[name] ?? { config: {}, provenance: {} };
+        out[name] = {
+            config: { ...existing.config, ...config },
+            provenance: {
+                tierSource: config.tier !== undefined ? "user" : existing.provenance.tierSource,
+                modelSource: config.model !== undefined ? "user" : existing.provenance.modelSource,
+            },
+        };
+    }
+    return out;
+}
 export function sanitizeAgentCategories(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return {};
@@ -41,6 +64,9 @@ export function sanitizeAgentCategories(value) {
         if (typeof record.model === "string" && record.model.trim()) {
             config.model = record.model.trim();
         }
+        if (isCategoryTier(record.tier)) {
+            config.tier = record.tier;
+        }
         if (isThinkingLevel(record.thinkingLevel)) {
             config.thinkingLevel = record.thinkingLevel;
         }
@@ -51,27 +77,99 @@ export function sanitizeAgentCategories(value) {
     }
     return out;
 }
-export function resolveSubagentRoute(category, parent, categories) {
+export function resolveSubagentRoute(category, parent, categories, tierContext) {
     const normalizedCategory = normalizeCategoryName(category);
     if (!normalizedCategory) {
         return { route: { ...parent, inherited: true } };
     }
-    const merged = mergeAgentCategories(categories);
-    const config = merged[normalizedCategory];
-    if (!config) {
+    const merged = mergeAgentCategoriesWithProvenance(categories);
+    const entry = merged[normalizedCategory];
+    if (!entry) {
         return { error: `Unknown subagent category "${normalizedCategory}".` };
     }
+    const { config, provenance } = entry;
+    // Explicit model binding wins over tier (config surface contract §3.1).
     const modelSelection = parseModelSelection(config.model, parent.providerId);
+    if (modelSelection.model !== "inherit") {
+        return {
+            route: {
+                category: normalizedCategory,
+                providerId: modelSelection.providerId,
+                model: modelSelection.model,
+                thinkingLevel: config.thinkingLevel ?? parent.thinkingLevel,
+                inherited: false,
+                categoryModelSource: provenance.modelSource === "user" ? "user-category" : "builtin-tier",
+            },
+        };
+    }
+    // Tier binding: rank-guarded for builtin-sourced tiers, free for
+    // user-authored ones (§3.2).
+    const tierModel = resolveTierModel(config.tier, provenance.tierSource, tierContext);
+    if (tierModel) {
+        return {
+            route: {
+                category: normalizedCategory,
+                providerId: parent.providerId,
+                model: tierModel,
+                thinkingLevel: config.thinkingLevel ?? parent.thinkingLevel,
+                inherited: false,
+                categoryModelSource: provenance.tierSource === "user" ? "user-category" : "builtin-tier",
+            },
+        };
+    }
     return {
         route: {
             category: normalizedCategory,
-            providerId: modelSelection.providerId,
-            model: modelSelection.model === "inherit" ? parent.model : modelSelection.model,
+            providerId: parent.providerId,
+            model: parent.model,
             thinkingLevel: config.thinkingLevel ?? parent.thinkingLevel,
-            inherited: modelSelection.model === "inherit" && config.thinkingLevel === undefined,
+            inherited: config.thinkingLevel === undefined,
         },
     };
 }
+/**
+ * Rank-guarded tier -> model resolution (§3.2). Returns undefined whenever
+ * the route must inherit: no tier context wired, kill switch off (builtin
+ * tiers only), unknown parent tier, missing target tier, or a target that is
+ * not strictly cheaper than the parent.
+ */
+function resolveTierModel(tier, tierSource, tierContext) {
+    if (!tier || tier === "inherit" || !tierContext)
+        return undefined;
+    const candidates = selectTierCandidates(tierContext.models, tier);
+    if (candidates.length === 0)
+        return undefined;
+    if (tierSource !== "user") {
+        // Builtin-sourced tier: downgrade-only, enforced by rank comparison.
+        if (!tierContext.autoTier)
+            return undefined;
+        if (!tierContext.parentTier)
+            return undefined;
+        if (TIER_RANK[tier] >= TIER_RANK[tierContext.parentTier])
+            return undefined;
+    }
+    return candidates[0].id;
+}
+/**
+ * Deterministic within-tier ordering (§3.2): user routingPriority, then
+ * builtin catalog order, then normalized id — never a remote response's
+ * array order.
+ */
+export function selectTierCandidates(models, tier) {
+    return models
+        .filter((entry) => entry.tier === tier)
+        .sort((a, b) => {
+        const priorityA = a.routingPriority ?? Number.POSITIVE_INFINITY;
+        const priorityB = b.routingPriority ?? Number.POSITIVE_INFINITY;
+        if (priorityA !== priorityB)
+            return priorityA - priorityB;
+        const builtinA = a.builtinIndex ?? Number.POSITIVE_INFINITY;
+        const builtinB = b.builtinIndex ?? Number.POSITIVE_INFINITY;
+        if (builtinA !== builtinB)
+            return builtinA - builtinB;
+        return a.id.localeCompare(b.id);
+    });
+}
 export function resolveModelRoute(model, parentProviderId) {
     return parseModelSelection(model, parentProviderId);
 }
@@ -95,7 +193,10 @@ function parseModelSelection(model, parentProviderId) {
     return { providerId: parentProviderId, model };
 }
 function isThinkingLevel(value) {
-    return typeof value === "string" && THINKING_LEVELS.has(value);
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
+}
+function isCategoryTier(value) {
+    return value === "fast" || value === "balanced" || value === "strong" || value === "inherit";
 }
 function cloneCategories(categories) {
     return Object.fromEntries(Object.entries(categories).map(([name, config]) => [name, { ...config }]));

package/dist/agent/child-runner.d.ts

@@ -8,7 +8,6 @@
  * turn-boundary budget enforcement, the handoff completeness guard, and the
  * mapping of failures to SubagentFinalReason.
  */
-import { BudgetLedger } from "./budget-ledger.js";
 import type { SubagentRunOutcome } from "./subagent-scheduler.js";
 import type { SubagentFinalReason, SubagentThreadRecord } from "./subagent-control.js";
 import type { AgentEvent, Message, ToolRegistryEntry, ToolResult, ToolUpdate } from "../types.js";
@@ -24,7 +23,6 @@ export interface ChildRunOptions {
 }
 export interface ChildRunnerHost {
     allTools(): ToolRegistryEntry[];
-    budgetLedger(): BudgetLedger | undefined;
     emit(record: SubagentThreadRecord, options: ChildRunOptions, status: ToolUpdate["status"], event?: AgentEvent, message?: string): void;
     runLifecycleHook(record: SubagentThreadRecord, cwd: string, eventName: "SubagentStart" | "SubagentStop", status?: string, error?: string, abortSignal?: AbortSignal): Promise<void>;
     finalizeBlocked(record: SubagentThreadRecord, error: string, options: ChildRunOptions): void;
@@ -47,7 +45,7 @@ export declare function sanitizeSubagentSummary(value: string): string;
  * to a trivial question is a complete handoff.
  */
 export declare function needsExplicitFinalSummary(record: SubagentThreadRecord, executedAnyTool: boolean): boolean;
-export declare function classifySubagentAbortReason(reason: unknown, parentSignal: AbortSignal | undefined, ledger: BudgetLedger | undefined): SubagentFinalReason;
+export declare function classifySubagentAbortReason(reason: unknown, parentSignal: AbortSignal | undefined): SubagentFinalReason;
 /**
  * Drops trailing "[model request interrupted ...]" boundary messages so a
  * rate-limit re-entry resumes from clean history (design §4.5).

package/dist/agent/child-runner.js

@@ -9,7 +9,7 @@
  * mapping of failures to SubagentFinalReason.
  */
 import { AgentAbortError, EMPTY_ASSISTANT_FALLBACK, SubagentAbortError } from "./abort-errors.js";
-import { childHardCap, composeAbortSignals } from "./budget-ledger.js";
+import { composeAbortSignals } from "./budget-ledger.js";
 import { isOnlyProviderProtocolArtifacts, stripProviderProtocolArtifacts } from "../provider-artifacts.js";
 import { isRateLimitError } from "../network/errors.js";
 import { isProviderTransportError } from "../network/provider-transport.js";
@@ -68,13 +68,6 @@ export class ChildRunner {
         let turnSummaryBuffer = "";
         let turnHadToolCall = false;
         let executedAnyTool = false;
-        // Per-child budget enforcement happens at turn boundaries (design §6):
-        // turn_end already carries usage, and a reminder injected here is seen by
-        // the very next provider call — unlike chunk-level aborts.
-        const cap = record.tokenCap;
-        let runTokens = 0;
-        let runTurns = 0;
-        let budgetSoftWarned = false;
         // Re-entry after a rate limit: the input was applied on attempt 1, so the
         // child history must not gain a second copy, and any stale interruption
         // boundary from the failed call is stripped (design §4.5).
@@ -110,21 +103,6 @@ export class ChildRunner {
                 }
                 if (event.type === "turn_end" && event.usage) {
                     record.usage = mergeUsage(record.usage, event.usage);
-                    runTokens += event.usage.promptTokens + event.usage.completionTokens;
-                    runTurns += 1;
-                    if (cap) {
-                        if (!budgetSoftWarned && runTokens >= cap.soft) {
-                            budgetSoftWarned = true;
-                            // The hard cap is fixed when the warning fires: soft + ~2 of
-                            // this child's average turns (absolute floor), so the child
-                            // gets a real chance to wrap up before the kill (design §6).
-                            cap.hard = childHardCap(cap.soft, runTokens / Math.max(1, runTurns));
-                            subAgent.injectSystemReminder(buildChildBudgetWrapUpReminder(runTokens, cap.soft));
-                        }
-                        else if (budgetSoftWarned && runTokens >= cap.hard) {
-                            record.abortController.abort(new SubagentAbortError(`Subagent ${record.agentId} exceeded its hard token cap (${cap.hard}).`, "budget"));
-                        }
-                    }
                 }
                 if (event.type === "turn_end") {
                     const turnSummary = stripProviderProtocolArtifacts(turnSummaryBuffer).trim();
@@ -176,7 +154,7 @@ export class ChildRunner {
             const cancelled = error instanceof AgentAbortError || error?.name === "AbortError";
             record.status = cancelled ? "cancelled" : "failed";
             record.finalReason = cancelled
-                ? classifySubagentAbortReason(record.abortController.signal.aborted ? record.abortController.signal.reason : error, options.abortSignal, this.host.budgetLedger())
+                ? classifySubagentAbortReason(record.abortController.signal.aborted ? record.abortController.signal.reason : error, options.abortSignal)
                 : "failed_transient";
             record.summary = sanitizeSubagentSummary(record.summary);
             record.error = error?.message || String(error);
@@ -267,23 +245,21 @@ export function needsExplicitFinalSummary(record, executedAnyTool) {
         return false;
     if (record.summary === EMPTY_ASSISTANT_FALLBACK)
         return true;
-    if (estimateHandoffTokens(record.summary) < HANDOFF_TOKEN_FLOOR)
+    // A schema-bearing child's handoff is a compact JSON value; short is
+    // complete by construction, and a restate turn would risk breaking the JSON.
+    if (!record.expectsStructuredOutput && estimateHandoffTokens(record.summary) < HANDOFF_TOKEN_FLOOR)
         return true;
     return isIntermediateHandoff(record.summary);
 }
-export function classifySubagentAbortReason(reason, parentSignal, ledger) {
+export function classifySubagentAbortReason(reason, parentSignal) {
     if (reason instanceof SubagentAbortError) {
         switch (reason.subagentReason) {
             case "interrupt":
                 return "cancelled_interrupt";
             case "user_close":
                 return "cancelled_user";
-            case "budget":
-                return "cancelled_budget";
         }
     }
-    if (ledger?.snapshot().exhausted)
-        return "cancelled_budget";
     if (parentSignal?.aborted)
         return "cancelled_parent_abort";
     return "cancelled_user";
@@ -302,13 +278,6 @@ export function stripTrailingModelInterruptedBoundary(messages) {
         break;
     }
 }
-function buildChildBudgetWrapUpReminder(spentTokens, softCap) {
-    return [
-        `Token budget notice: this subagent has used ~${Math.round(spentTokens)} tokens, crossing its ${softCap}-token budget.`,
-        "Wrap up now: stop opening new lines of investigation and produce your complete final handoff",
-        "(findings, conclusions, unfinished items) in your next message.",
-    ].join(" ");
-}
 export function summarizeSubagentToolEnd(event) {
     const metadata = (event.result.metadata ?? {});
     const reason = readString(metadata.reason);