@bubblebrain-ai/bubble 0.0.33 → 0.0.35

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/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);

package/dist/agent/profiles.d.ts

@@ -20,8 +20,6 @@ export interface AgentProfile {
     category?: string;
     tools: AgentProfileTools;
     maxTurns?: number;
-    /** Optional per-child token cap declared by the profile (may only lower the runtime default). */
-    maxTokens?: number;
     approval: AgentProfileApproval;
     nicknameCandidates?: string[];
     prompt: string;

package/dist/agent/profiles.js

@@ -23,8 +23,6 @@ const SUBAGENT_DENY_TOOLS = new Set([
     "send_input",
     "close_agent",
     "list_agents",
-    "agent_team",
-    "agent_batch",
     "run_workflow",
     "wait_workflow",
 ]);
@@ -323,7 +321,6 @@ function parseAgentProfileFile(raw, source, filePath) {
         category: stringValue(frontmatter.category),
         tools: toolsValue(frontmatter.tools),
         maxTurns: numberValue(frontmatter.maxTurns),
-        maxTokens: numberValue(frontmatter.maxTokens),
         approval: approvalValue(frontmatter.approval),
         nicknameCandidates: stringArray(frontmatter.nicknameCandidates) ?? stringArray(frontmatter.nicknames),
         prompt: parsed.body.trim(),

package/dist/agent/subagent-control.d.ts

@@ -8,17 +8,8 @@ export type SubagentThreadStatus = "queued" | "running" | "completed" | "failed"
  * rendered in lifecycle tool replies (design doc §3.1) — a resume hint is
  * emitted iff the runtime judged the run resumable, never as a blanket string.
  */
-export type SubagentFinalReason = "completed" | "failed_transient" | "failed_fatal" | "rate_limited_exhausted" | "blocked" | "cancelled_interrupt" | "cancelled_user" | "cancelled_budget" | "cancelled_parent_abort";
+export type SubagentFinalReason = "completed" | "failed_transient" | "failed_fatal" | "rate_limited_exhausted" | "blocked" | "cancelled_interrupt" | "cancelled_user" | "cancelled_parent_abort";
 export declare function isResumableReason(reason: SubagentFinalReason): boolean;
-/** Per-child token budget, fixed at dispatch time (design doc §6). */
-export interface SubagentTokenCap {
-    /** Soft cap: crossing it injects a wrap-up reminder into the child. */
-    soft: number;
-    /** Hard cap: crossing it aborts this child only. Updated at turn checks. */
-    hard: number;
-    /** Ledger tokens already attributed to this child when the run started. */
-    baseline: number;
-}
 export interface SubagentThreadSnapshot {
     agentId: string;
     runId: string;
@@ -40,7 +31,6 @@ export interface SubagentThreadSnapshot {
     deliveredAt?: number;
     /** 1-based position in the scheduler queue while status is "queued". */
     queuePosition?: number;
-    tokenCap?: SubagentTokenCap;
     /** Present for write_worktree children: where the isolated checkout lives. */
     worktree?: SubagentWorktree;
 }
@@ -63,8 +53,11 @@ export interface SubagentThreadRecord {
     createdAt: number;
     updatedAt: number;
     deliveredAt?: number;
-    tokenCap?: SubagentTokenCap;
     worktree?: SubagentWorktree;
+    /** True when the child was asked for schema-validated structured output:
+     * a compact JSON handoff is complete by construction, so the token-floor
+     * restate turn must not fire on it. */
+    expectsStructuredOutput?: boolean;
     /** True for agents spawned inside a run_workflow: kept out of list_agents /
      * wait_agent and not persisted (design v2 appendix; option C). */
     workflowInternal?: boolean;

package/dist/agent/subagent-control.js

@@ -9,7 +9,6 @@ export function isResumableReason(reason) {
         case "completed":
         case "failed_fatal":
         case "blocked":
-        case "cancelled_budget":
             return false;
     }
 }
@@ -33,7 +32,6 @@ export function snapshotSubagentThread(record) {
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
         deliveredAt: record.deliveredAt,
-        tokenCap: record.tokenCap ? { ...record.tokenCap } : undefined,
         worktree: record.worktree ? { ...record.worktree } : undefined,
     };
 }

package/dist/agent/subagent-store.d.ts

@@ -7,7 +7,7 @@
  * Persistence (design §7): final-state children are written to
  * `<persistDir>/<agentId>.json` as snapshot + compacted message history, so a
  * later process can resume them via send_input. The on-disk schema carries
- * `finalReason` / `resumable` / `deliveredAt` / `tokenCap` — the fields the
+ * `finalReason` / `resumable` / `deliveredAt` — the fields the
  * reply protocol and delivery dedup depend on. Child transcripts never mix
  * into the parent transcript.
  */

package/dist/agent/subagent-store.js

@@ -7,7 +7,7 @@
  * Persistence (design §7): final-state children are written to
  * `<persistDir>/<agentId>.json` as snapshot + compacted message history, so a
  * later process can resume them via send_input. The on-disk schema carries
- * `finalReason` / `resumable` / `deliveredAt` / `tokenCap` — the fields the
+ * `finalReason` / `resumable` / `deliveredAt` — the fields the
  * reply protocol and delivery dedup depend on. Child transcripts never mix
  * into the parent transcript.
  */
@@ -84,7 +84,6 @@ export class SubagentStore {
                 createdAt: record.createdAt,
                 updatedAt: record.updatedAt,
                 deliveredAt: record.deliveredAt,
-                tokenCap: record.tokenCap,
                 messages: record.agent?.messages ?? record.messages,
             };
             writeFileSync(join(this.persistDir, `${record.agentId}.json`), JSON.stringify(payload));
@@ -135,7 +134,6 @@ export class SubagentStore {
                     createdAt: parsed.createdAt,
                     updatedAt: parsed.updatedAt,
                     deliveredAt: parsed.deliveredAt,
-                    tokenCap: parsed.tokenCap,
                     abortController: new AbortController(),
                     waiters: new Set(),
                     messages: parsed.messages,

package/dist/agent/workflow/control.d.ts

@@ -34,4 +34,11 @@ export interface WorkflowRunSnapshot {
     snapshots: SubagentThreadSnapshot[];
 }
 /** System-reminder injected at the next turn when a background workflow finishes. */
+/**
+ * Failed members must surface in EVERY channel that renders a finished
+ * workflow (delivery notice and wait_workflow): agent() converts failures to
+ * null inside the script, so without this line a "completed" workflow could
+ * silently omit items whose agents never delivered.
+ */
+export declare function workflowMemberWarning(snapshot: WorkflowRunSnapshot): string | undefined;
 export declare function buildWorkflowDeliveryNotice(snapshot: WorkflowRunSnapshot): string;

package/dist/agent/workflow/control.js

@@ -1,8 +1,24 @@
 /** Background dynamic-workflow run state + parent-facing snapshot (option C Phase 4). */
 /** System-reminder injected at the next turn when a background workflow finishes. */
+/**
+ * Failed members must surface in EVERY channel that renders a finished
+ * workflow (delivery notice and wait_workflow): agent() converts failures to
+ * null inside the script, so without this line a "completed" workflow could
+ * silently omit items whose agents never delivered.
+ */
+export function workflowMemberWarning(snapshot) {
+    const failed = snapshot.snapshots.filter((agent) => agent.status !== "completed" && agent.status !== "closed");
+    if (failed.length === 0)
+        return undefined;
+    const names = failed.map((agent) => `${agent.nickname} (${agent.status}${agent.error ? `: ${truncate(agent.error, 120)}` : ""})`).join("; ");
+    return `warning: ${failed.length} of ${snapshot.agentCount} agents did not complete — ${names}. Their agent() calls returned null; treat those items as missing, not done.`;
+}
 export function buildWorkflowDeliveryNotice(snapshot) {
     const head = `workflow "${snapshot.title}" (${snapshot.runId}) ${snapshot.status} — ${snapshot.agentCount} agent${snapshot.agentCount === 1 ? "" : "s"}.`;
     const lines = [head];
+    const warning = workflowMemberWarning(snapshot);
+    if (warning)
+        lines.push(warning);
     if (snapshot.result?.ok) {
         const rendered = typeof snapshot.result.value === "string"
             ? snapshot.result.value
@@ -12,7 +28,12 @@ export function buildWorkflowDeliveryNotice(snapshot) {
     else if (snapshot.result && !snapshot.result.ok) {
         lines.push(`error: ${snapshot.result.error}`);
     }
-    lines.push("Do not re-run this workflow; integrate its result.");
+    if (snapshot.result && !snapshot.result.ok) {
+        lines.push("The workflow failed. If the error is in the script, fix it and issue a corrected run_workflow; do not integrate partial results as if complete.");
+    }
+    else {
+        lines.push("Do not re-run this workflow; integrate its result.");
+    }
     return lines.join("\n");
 }
 function truncate(value, max) {

package/dist/agent/workflow/runtime.d.ts

@@ -18,9 +18,8 @@ export interface WorkflowAgentOpts {
     category?: string;
     agentType?: string;
     schema?: unknown;
+    /** Display name for this member in progress views (wired to the record nickname). */
     label?: string;
-    phase?: string;
-    isolation?: string;
 }
 export interface WorkflowAgentSpec {
     prompt: string;
@@ -72,4 +71,18 @@ export declare class WorkflowConcurrencyGate {
     acquire(): Promise<void>;
     release(): void;
 }
+/** The EXACT source runWorkflow executes — the syntax probe must compile this, not the raw script. */
+export declare function buildWrappedWorkflowSource(script: string): string;
+/**
+ * Submit-time syntax check: compiles the exact transformed source with
+ * QuickJS's compile-only flag (same engine, zero grammar divergence) so the
+ * model gets a teaching error as the immediate tool result instead of one
+ * full turn later through the background-run delivery path.
+ */
+export declare function precompileWorkflowScript(script: string): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
 export declare function runWorkflow(options: RunWorkflowOptions): Promise<RunWorkflowResult>;