@bubblebrain-ai/bubble 0.0.34 → 0.0.35

package/dist/agent/workflow/runtime.js

@@ -50,16 +50,28 @@ globalThis.agent = async (prompt, opts) => {
   const raw = await __agent(JSON.stringify({ prompt: String(prompt ?? ""), opts: opts || {} }));
   return JSON.parse(raw);
 };
-globalThis.parallel = (thunks) => Promise.all((thunks || []).map((t) => {
-  try { return Promise.resolve(t()).catch(() => null); } catch (_e) { return Promise.resolve(null); }
-}));
-globalThis.pipeline = (items, ...stages) => Promise.all((items || []).map(async (item, i) => {
-  let v = item;
-  for (const stage of stages) {
-    try { v = await stage(v, item, i); } catch (_e) { return null; }
+globalThis.parallel = (thunks) => {
+  if (!Array.isArray(thunks)) throw new TypeError("parallel() expects an array of functions");
+  if (thunks.some((t) => typeof t !== "function")) {
+    throw new TypeError("parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)");
   }
-  return v;
-}));
+  return Promise.all(thunks.map((t) => {
+    try { return Promise.resolve(t()).catch(() => null); } catch (_e) { return Promise.resolve(null); }
+  }));
+};
+globalThis.pipeline = (items, ...stages) => {
+  if (!Array.isArray(items)) throw new TypeError("pipeline() expects an array as the first argument");
+  if (stages.some((s) => typeof s !== "function")) {
+    throw new TypeError("pipeline() stages must be functions: pipeline(items, item => ..., result => ...)");
+  }
+  return Promise.all(items.map(async (item, i) => {
+    let v = item;
+    for (const stage of stages) {
+      try { v = await stage(v, item, i); } catch (_e) { return null; }
+    }
+    return v;
+  }));
+};
 globalThis.phase = (t) => __phase(String(t ?? ""));
 globalThis.log = (m) => __log(String(m ?? ""));
 globalThis.budget = {
@@ -71,18 +83,68 @@ globalThis.budget = {
 /** Removes ambient nondeterminism so a run is reproducible (design §4.3). */
 const DETERMINISM_GATING = `
 delete globalThis.Date;
+Object.defineProperty(globalThis, "Date", {
+  configurable: false,
+  get() { throw new Error("Workflow scripts must be deterministic: Date.now()/new Date() are unavailable — pass timestamps in via args"); },
+});
 delete globalThis.WeakRef;
 delete globalThis.FinalizationRegistry;
-Math.random = () => { throw new Error("Math.random is disabled in workflows (nondeterministic)"); };
+Math.random = () => { throw new Error("Workflow scripts must be deterministic: Math.random() is unavailable"); };
 `;
 /** Turns `export const meta = …` / `export function …` into plain declarations. */
 function stripExports(script) {
     return script.replace(/(^|\n)\s*export\s+(const|let|var|function|class|async)\b/g, "$1$2");
 }
+/** Lines injected before the script body in the wrapped source (keep in sync with buildWrappedWorkflowSource). */
+const WRAPPER_LINE_OFFSET = 2;
+/** The EXACT source runWorkflow executes — the syntax probe must compile this, not the raw script. */
+export function buildWrappedWorkflowSource(script) {
+    return [
+        "globalThis.__wfdone = false; globalThis.__wfresult = null; globalThis.__wferror = null;",
+        "(async () => {",
+        stripExports(script),
+        "})().then(",
+        "  (r) => { globalThis.__wfresult = r === undefined ? null : r; globalThis.__wfdone = true; },",
+        "  (e) => { globalThis.__wferror = (e && e.message) ? String(e.message) : String(e); globalThis.__wfdone = true; }",
+        ");",
+    ].join("\n");
+}
+/**
+ * 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 async function precompileWorkflowScript(script) {
+    const QuickJS = await getQuickJS();
+    const vm = QuickJS.newContext();
+    try {
+        const result = vm.evalCode(buildWrappedWorkflowSource(script), "workflow.js", { compileOnly: true });
+        if (result.error) {
+            const message = vm.dump(result.error);
+            result.error.dispose();
+            return { ok: false, error: `workflow script error: ${formatError(message)}` };
+        }
+        result.value.dispose();
+        return { ok: true };
+    }
+    finally {
+        try {
+            vm.dispose();
+        }
+        catch { /* teardown must not mask the verdict */ }
+    }
+}
 export async function runWorkflow(options) {
     const QuickJS = await getQuickJS();
     const vm = QuickJS.newContext();
     const pending = new Set();
+    // Deferreds for in-flight agent() calls. If the run ends while agents are
+    // still flying (user abort, stall, compute deadline), these were never
+    // settled and their VM-side handles are still alive — disposing the VM
+    // with them alive trips QuickJS's JS_FreeRuntime assertion and Aborts the
+    // (process-wide, cached) wasm module, poisoning every later workflow.
+    const liveDeferreds = new Set();
     const state = { disposed: false };
     let agentCount = 0;
     const maxAgents = options.maxAgents ?? DEFAULT_MAX_AGENTS;
@@ -93,23 +155,14 @@ export async function runWorkflow(options) {
     vm.runtime.setInterruptHandler(() => Date.now() - computeStart > computeDeadline);
     try {
         vm.unwrapResult(vm.evalCode(DETERMINISM_GATING)).dispose();
-        installHostFunctions(vm, options, pending, () => agentCount, () => { agentCount += 1; }, maxAgents, state);
+        installHostFunctions(vm, options, pending, () => agentCount, () => { agentCount += 1; }, maxAgents, state, liveDeferreds);
         // args as a deterministic injected global.
         const argsJson = JSON.stringify(options.args ?? null);
         vm.unwrapResult(vm.evalCode(`globalThis.args = ${argsJson};`)).dispose();
         vm.unwrapResult(vm.evalCode(PRELUDE)).dispose();
-        const body = stripExports(options.script);
-        const wrapped = [
-            "globalThis.__wfdone = false; globalThis.__wfresult = null; globalThis.__wferror = null;",
-            "(async () => {",
-            body,
-            "})().then(",
-            "  (r) => { globalThis.__wfresult = r === undefined ? null : r; globalThis.__wfdone = true; },",
-            "  (e) => { globalThis.__wferror = (e && e.message) ? String(e.message) : String(e); globalThis.__wfdone = true; }",
-            ");",
-        ].join("\n");
+        const wrapped = buildWrappedWorkflowSource(options.script);
         computeStart = Date.now();
-        const evalResult = vm.evalCode(wrapped);
+        const evalResult = vm.evalCode(wrapped, "workflow.js");
         if (evalResult.error) {
             const message = vm.dump(evalResult.error);
             evalResult.error.dispose();
@@ -154,7 +207,17 @@ export async function runWorkflow(options) {
     }
     finally {
         state.disposed = true;
-        vm.dispose();
+        for (const deferred of liveDeferreds) {
+            try {
+                deferred.dispose();
+            }
+            catch { /* already settled/disposed */ }
+        }
+        liveDeferreds.clear();
+        try {
+            vm.dispose();
+        }
+        catch { /* a dispose failure must not mask the run's result */ }
     }
 }
 function abortRace(signal) {
@@ -164,10 +227,11 @@ function abortRace(signal) {
         return Promise.resolve();
     return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
 }
-function installHostFunctions(vm, options, pending, getCount, bumpCount, maxAgents, state) {
+function installHostFunctions(vm, options, pending, getCount, bumpCount, maxAgents, state, liveDeferreds) {
     vm.newFunction("__agent", (specHandle) => {
         const spec = JSON.parse(vm.getString(specHandle));
         const deferred = vm.newPromise();
+        liveDeferreds.add(deferred);
         // Settling the VM promise touches the context, which may have been disposed
         // if the run was aborted while host work was still in flight — guard it.
         const settle = (fn) => {
@@ -203,11 +267,14 @@ function installHostFunctions(vm, options, pending, getCount, bumpCount, maxAgen
             })).finally(() => { pending.delete(p); });
             pending.add(p);
         }
-        deferred.settled.then(() => { if (!state.disposed)
-            try {
-                vm.runtime.executePendingJobs();
-            }
-            catch { /* disposed */ } });
+        deferred.settled.then(() => {
+            liveDeferreds.delete(deferred);
+            if (!state.disposed)
+                try {
+                    vm.runtime.executePendingJobs();
+                }
+                catch { /* disposed */ }
+        });
         return deferred.handle;
     }).consume((f) => vm.setProp(vm.global, "__agent", f));
     vm.newFunction("__phase", (h) => {
@@ -231,7 +298,22 @@ function installHostFunctions(vm, options, pending, getCount, bumpCount, maxAgen
 }
 function formatError(value) {
     if (value && typeof value === "object" && "message" in value) {
-        return String(value.message);
+        const obj = value;
+        const message = String(obj.message);
+        const line = extractScriptLine(obj);
+        return line === undefined ? message : `${message} (script line ${line})`;
     }
     return String(value);
 }
+/** Maps a QuickJS error location back onto the raw script's line numbering. */
+function extractScriptLine(obj) {
+    if (typeof obj.lineNumber === "number" && Number.isFinite(obj.lineNumber)) {
+        return Math.max(1, obj.lineNumber - WRAPPER_LINE_OFFSET);
+    }
+    if (typeof obj.stack === "string") {
+        const match = obj.stack.match(/workflow\.js:(\d+)/);
+        if (match)
+            return Math.max(1, Number(match[1]) - WRAPPER_LINE_OFFSET);
+    }
+    return undefined;
+}

package/dist/agent.d.ts

@@ -16,10 +16,9 @@ import type { SkillSummary } from "./skills/types.js";
 import type { FileStateTracker } from "./tools/file-state.js";
 export { AgentAbortError, SubagentAbortError } from "./agent/abort-errors.js";
 export declare const INTERRUPTED_ASSISTANT_CONTENT = "Interrupted by user. The prior request was stopped and should not be resumed unless the user asks.";
-/** Runtime tuning for the subagent scheduler and per-child budgets. */
+/** Runtime tuning for the subagent scheduler. */
 export interface AgentSubagentRuntimeConfig {
     maxActiveSubagents?: number;
-    childTokenCap?: number;
     launchBurst?: number;
     launchIntervalMs?: number;
     rateLimitMaxAttempts?: number;
@@ -223,47 +222,6 @@ export declare class Agent {
     }): Promise<SubagentThreadSnapshot>;
     closeSubAgent(agentId: string): Promise<SubagentThreadSnapshot>;
     listSubAgents(): SubagentThreadSnapshot[];
-    /**
-     * Homogeneous map fan-out (design §1.2): one profile, one template, N items.
-     * Every member goes through the same admission and the same scheduler
-     * dispatch as spawn_agent; the tool blocks until all members are final.
-     */
-    runAgentTeam(cwd: string, options: {
-        profile: AgentProfile;
-        category?: string;
-        model?: string;
-        effort?: ThinkingLevel;
-        promptTemplate: string;
-        items: string[];
-        parentToolCallId: string;
-        emitUpdate?: (update: ToolUpdate) => void;
-        abortSignal?: AbortSignal;
-        approval?: "fail" | "disabled";
-    }): Promise<SubagentThreadSnapshot[]>;
-    /**
-     * Heterogeneous fan-out (design v2 §1.3): N independent specs, each with its
-     * own task, profile, and per-call model/effort, dispatched concurrently as a
-     * SINGLE tool call. Unlike runAgentTeam (one template over N items), members
-     * differ. Like the team, every member goes through the same scheduler
-     * dispatch and the tool blocks until all are final, returning in spec order.
-     * Keeping fan-out inside one tool call (rather than N parallel spawn_agent
-     * tool_calls) avoids the provider parallel-tool_call bug (Kimi 400 / lost
-     * responses).
-     */
-    runAgentBatch(cwd: string, options: {
-        specs: Array<{
-            task: string;
-            profile: AgentProfile;
-            category?: string;
-            model?: string;
-            effort?: ThinkingLevel;
-            outputSchema?: unknown;
-        }>;
-        parentToolCallId: string;
-        emitUpdate?: (update: ToolUpdate) => void;
-        abortSignal?: AbortSignal;
-        approval?: "fail" | "disabled";
-    }): Promise<SubagentThreadSnapshot[]>;
     /**
      * Dynamic workflow (option C): runs an LLM-authored JS orchestration script in
      * a QuickJS sandbox. Each agent() call in the script becomes a real scheduled
@@ -280,6 +238,9 @@ export declare class Agent {
         parentToolCallId: string;
         emitUpdate?: (update: ToolUpdate) => void;
         abortSignal?: AbortSignal;
+        ensureProfileTrusted?: (profile: AgentProfile) => Promise<{
+            content: string | unknown;
+        } | undefined>;
     }): Promise<{
         result: {
             ok: true;
@@ -304,6 +265,9 @@ export declare class Agent {
         title?: string;
         parentToolCallId: string;
         abortSignal?: AbortSignal;
+        ensureProfileTrusted?: (profile: AgentProfile) => Promise<{
+            content: string | unknown;
+        } | undefined>;
     }): {
         runId: string;
         title: string;

package/dist/agent.js

@@ -21,7 +21,7 @@ import { appendOutputSchemaInstructions, buildSchemaCorrectionPrompt, validateSt
 import { runWorkflow, WorkflowConcurrencyGate } from "./agent/workflow/runtime.js";
 import { buildWorkflowDeliveryNotice } from "./agent/workflow/control.js";
 import { getSubtaskPolicy } from "./agent/subtask-policy.js";
-import { composeAbortSignals, computeChildTokenCap, DEFAULT_CHILD_TOKEN_CAP, PARENT_POOL_RESERVE_RATIO } from "./agent/budget-ledger.js";
+import { composeAbortSignals } from "./agent/budget-ledger.js";
 import { assignAgentNickname, builtinAgentProfiles, discoverAgentProfiles, findAgentProfile, validateAgentProfileTools } from "./agent/profiles.js";
 import { snapshotSubagentThread, subagentResultFromThread } from "./agent/subagent-control.js";
 import { SubagentStore } from "./agent/subagent-store.js";
@@ -179,7 +179,6 @@ export class Agent {
         });
         this.childRunner = new ChildRunner({
             allTools: () => [...this.tools.values()],
-            budgetLedger: () => this.budgetLedger,
             emit: (record, options, status, event, message) => this.emitSubagentLifecycle(record, options, status, event, message),
             runLifecycleHook: (record, cwd, eventName, status, error, abortSignal) => this.runSubagentLifecycleHookFor(record, cwd, eventName, status, error, abortSignal),
             finalizeBlocked: (record, error, options) => this.finalizeSubagentBlocked(record, error, options),
@@ -388,7 +387,7 @@ export class Agent {
         this.messages.unshift(systemMessage);
     }
     async *run(userInput, cwd, options = {}) {
-        const abortSignal = composeAbortSignals([options.abortSignal, this.budgetLedger?.signal]);
+        const abortSignal = options.abortSignal;
         const inputController = options.inputController;
         const traceContext = {
             cwd,
@@ -911,14 +910,14 @@ export class Agent {
                         }
                         let tc = parsedCalls[index];
                         let blockedResult;
-                        // agent_team must be the only tool call in its response (design
-                        // §1.2): concurrent calls race the scheduler and the aggregated
-                        // reply; the rejection teaches the model how to re-issue.
-                        if (tc.name === "agent_team" && parsedCalls.length > 1) {
+                        // run_workflow must be the only tool call in its response: it starts
+                        // a background orchestration whose result lands next turn, and
+                        // sibling calls racing it defeat the serialized fan-out contract.
+                        if (tc.name === "run_workflow" && parsedCalls.length > 1) {
                             blockedResult = {
                                 content: [
-                                    "agent_team must be the only tool call in your response.",
-                                    "Re-issue agent_team alone — one call, nothing else in the same message — and run any other tools or additional teams sequentially after it returns.",
+                                    "run_workflow must be the only tool call in your response.",
+                                    "Re-issue run_workflow alone — one call, nothing else in the same message — and run other tools after it returns.",
                                 ].join(" "),
                                 isError: true,
                                 status: "blocked",
@@ -1580,141 +1579,6 @@ export class Agent {
             .filter((record) => !record.workflowInternal)
             .map((record) => this.snapshotSubagent(record));
     }
-    /**
-     * Homogeneous map fan-out (design §1.2): one profile, one template, N items.
-     * Every member goes through the same admission and the same scheduler
-     * dispatch as spawn_agent; the tool blocks until all members are final.
-     */
-    async runAgentTeam(cwd, options) {
-        // Team budget pre-check (§6): items × per-member cap must fit in what
-        // remains of a limited pool after the parent's reserve. On limit-free
-        // hosts the only bound is the items cap enforced by the tool.
-        const limit = this.budgetLedger?.poolLimit;
-        if (this.budgetLedger && limit !== undefined) {
-            const reserve = Math.floor(limit * PARENT_POOL_RESERVE_RATIO);
-            const available = Math.max(0, (this.budgetLedger.remaining() ?? 0) - reserve);
-            const memberCap = Math.min(this.subagentsConfig.childTokenCap ?? DEFAULT_CHILD_TOKEN_CAP, options.profile.maxTokens ?? Number.POSITIVE_INFINITY);
-            const affordable = Math.floor(available / memberCap);
-            if (options.items.length > affordable) {
-                throw new Error([
-                    `agent_team rejected: the remaining token budget affords at most ${affordable} member${affordable === 1 ? "" : "s"}`,
-                    `but ${options.items.length} were requested. Reduce items or run smaller batches sequentially.`,
-                ].join(" "));
-            }
-        }
-        const approval = options.approval ?? options.profile.approval;
-        const route = this.resolveRouteForSubagent(options.profile, options.category, { model: options.model, effort: options.effort });
-        const records = options.items.map((item) => this.createSubagentThreadRecord({
-            profile: options.profile,
-            task: options.promptTemplate.split("{{item}}").join(item),
-            parentToolCallId: options.parentToolCallId,
-            parentToolName: "agent_team",
-            route,
-        }));
-        const promises = records.map((record) => {
-            this.subagentStore.set(record);
-            const admissionError = this.admitSubagentProfile(record, approval);
-            if (admissionError) {
-                this.finalizeSubagentBlocked(record, admissionError, { directEmit: options.emitUpdate });
-                return Promise.resolve();
-            }
-            // Member events flow through the team tool's own emitUpdate
-            // (directEmit): while a foreground tool runs, the parent loop blocks in
-            // updateQueue.wait and the queued channel is not drained until the tool
-            // settles — queueUpdates would freeze the TUI for the whole team (§1.2).
-            record.promise = this.dispatchSubagentRun(record, record.task, cwd, {
-                approval,
-                abortSignal: options.abortSignal,
-                directEmit: options.emitUpdate,
-            });
-            void record.promise.finally(() => this.subagentStore.notifyWaiters(record));
-            return record.promise;
-        });
-        await Promise.all(promises);
-        // The aggregated reply carries every member's full summary.
-        for (const record of records)
-            this.subagentStore.markDelivered(record.agentId);
-        return records.map((record) => this.snapshotSubagent(record));
-    }
-    /**
-     * Heterogeneous fan-out (design v2 §1.3): N independent specs, each with its
-     * own task, profile, and per-call model/effort, dispatched concurrently as a
-     * SINGLE tool call. Unlike runAgentTeam (one template over N items), members
-     * differ. Like the team, every member goes through the same scheduler
-     * dispatch and the tool blocks until all are final, returning in spec order.
-     * Keeping fan-out inside one tool call (rather than N parallel spawn_agent
-     * tool_calls) avoids the provider parallel-tool_call bug (Kimi 400 / lost
-     * responses).
-     */
-    async runAgentBatch(cwd, options) {
-        // Budget pre-check mirrors runAgentTeam: members × per-member cap must fit
-        // in what remains of a limited pool after the parent's reserve.
-        const limit = this.budgetLedger?.poolLimit;
-        if (this.budgetLedger && limit !== undefined) {
-            const reserve = Math.floor(limit * PARENT_POOL_RESERVE_RATIO);
-            const available = Math.max(0, (this.budgetLedger.remaining() ?? 0) - reserve);
-            const memberCap = this.subagentsConfig.childTokenCap ?? DEFAULT_CHILD_TOKEN_CAP;
-            const affordable = Math.floor(available / memberCap);
-            if (options.specs.length > affordable) {
-                throw new Error([
-                    `agent_batch rejected: the remaining token budget affords at most ${affordable} member${affordable === 1 ? "" : "s"}`,
-                    `but ${options.specs.length} were requested. Reduce specs or run smaller batches sequentially.`,
-                ].join(" "));
-            }
-        }
-        const records = options.specs.map((spec) => {
-            const approval = options.approval ?? spec.profile.approval;
-            const task = spec.outputSchema !== undefined
-                ? appendOutputSchemaInstructions(spec.task, spec.outputSchema)
-                : spec.task;
-            const record = this.createSubagentThreadRecord({
-                profile: spec.profile,
-                task,
-                parentToolCallId: options.parentToolCallId,
-                parentToolName: "agent_batch",
-                route: this.resolveRouteForSubagent(spec.profile, spec.category, { model: spec.model, effort: spec.effort }),
-            });
-            return { record, approval, spec };
-        });
-        const promises = records.map(({ record, approval }) => {
-            this.subagentStore.set(record);
-            const admissionError = this.admitSubagentProfile(record, approval);
-            if (admissionError) {
-                this.finalizeSubagentBlocked(record, admissionError, { directEmit: options.emitUpdate });
-                return Promise.resolve();
-            }
-            record.promise = this.dispatchSubagentRun(record, record.task, cwd, {
-                approval,
-                abortSignal: options.abortSignal,
-                directEmit: options.emitUpdate,
-            });
-            void record.promise.finally(() => this.subagentStore.notifyWaiters(record));
-            return record.promise;
-        });
-        await Promise.all(promises);
-        // Structured-output validation + one corrective retry (design v2 §1.2):
-        // a member whose schema'd summary does not validate gets a single
-        // send_input correction, reusing the existing resume path.
-        for (const { record, spec } of records) {
-            if (spec.outputSchema === undefined)
-                continue;
-            if (record.status !== "completed")
-                continue;
-            if (validateStructuredSummary(record.summary, spec.outputSchema).ok)
-                continue;
-            const correction = buildSchemaCorrectionPrompt(spec.outputSchema, record.summary);
-            try {
-                await this.sendSubAgentInput(record.agentId, correction, cwd, { abortSignal: options.abortSignal });
-                await record.promise?.catch(() => undefined);
-            }
-            catch {
-                // resume failed; leave the original summary and surface the mismatch below
-            }
-        }
-        for (const { record } of records)
-            this.subagentStore.markDelivered(record.agentId);
-        return records.map(({ record }) => this.snapshotSubagent(record));
-    }
     /**
      * Dynamic workflow (option C): runs an LLM-authored JS orchestration script in
      * a QuickJS sandbox. Each agent() call in the script becomes a real scheduled
@@ -1732,6 +1596,7 @@ export class Agent {
             parentToolCallId: options.parentToolCallId,
             abortSignal: options.abortSignal,
             directEmit: options.emitUpdate,
+            ensureProfileTrusted: options.ensureProfileTrusted,
         });
     }
     /**
@@ -1766,6 +1631,7 @@ export class Agent {
             parentToolCallId: options.parentToolCallId,
             abortSignal: abortController.signal,
             queueUpdates: true,
+            ensureProfileTrusted: options.ensureProfileTrusted,
         }).then((out) => {
             record.agentCount = out.agentCount;
             record.snapshots = out.snapshots;
@@ -1842,22 +1708,13 @@ export class Agent {
         const profiles = discoverAgentProfiles(cwd, "both").profiles;
         const runRecords = [];
         const logs = [];
-        // Per-run isolation (option C review): a token ceiling that aborts only this
-        // run (never the parent) and a concurrency sub-cap below the global limit so
-        // a workflow can't starve interactive subagents.
-        const poolLimit = this.budgetLedger?.poolLimit;
-        const runTokenCeiling = poolLimit !== undefined
-            ? Math.max(1, Math.floor(poolLimit * (1 - PARENT_POOL_RESERVE_RATIO)))
-            : Number.POSITIVE_INFINITY;
-        const runSpent = () => runRecords.reduce((sum, r) => sum + (r.usage ? r.usage.promptTokens + r.usage.completionTokens : 0), 0);
+        // Per-run isolation (option C review): a concurrency sub-cap below the
+        // global limit so a workflow can't starve interactive subagents.
         const interactiveReserve = 2;
         const globalCap = Math.max(1, this.subagentsConfig.maxActiveSubagents ?? 8);
         const workflowConcurrency = Math.max(1, globalCap - interactiveReserve);
         const gate = new WorkflowConcurrencyGate(workflowConcurrency);
         const dispatchAgent = async (spec) => {
-            if (runSpent() >= runTokenCeiling) {
-                return { ok: false, error: "workflow token ceiling reached; not launching more agents" };
-            }
             const baseProfile = findAgentProfile(profiles, spec.opts.agentType ?? "default")
                 ?? findAgentProfile(profiles, "default");
             if (!baseProfile)
@@ -1895,8 +1752,25 @@ export class Agent {
                 route,
                 workflowInternal: true,
             });
+            record.expectsStructuredOutput = spec.opts.schema !== undefined;
+            const memberLabel = typeof spec.opts.label === "string" ? spec.opts.label.trim().slice(0, 40) : "";
+            if (memberLabel)
+                record.nickname = memberLabel;
             runRecords.push(record);
             this.subagentStore.set(record);
+            // Project-local profiles pass the same first-use trust gate as
+            // spawn_agent: a .bubble/agents profile must never gain a side door
+            // into execution just because a script named it (Codex review on #58).
+            // Checked AFTER the record exists so a rejected member still shows up
+            // in the run's counts/snapshots as blocked instead of vanishing.
+            if (options.ensureProfileTrusted) {
+                const blocked = await options.ensureProfileTrusted(baseProfile);
+                if (blocked) {
+                    const message = typeof blocked.content === "string" ? blocked.content : `profile "${baseProfile.name}" requires user approval`;
+                    this.finalizeSubagentBlocked(record, message, { directEmit: options.directEmit, queueUpdates: options.queueUpdates });
+                    return { ok: false, error: message };
+                }
+            }
             const admissionError = this.admitSubagentProfile(record, profile.approval);
             if (admissionError) {
                 this.finalizeSubagentBlocked(record, admissionError, { directEmit: options.directEmit, queueUpdates: options.queueUpdates });
@@ -1925,8 +1799,11 @@ export class Agent {
                 return { ok: true, value: record.summary };
             }
             // Structured output: validate, one corrective retry, then fall back to raw.
+            // The schema: log lines are the telemetry that decides whether the
+            // deferred terminate-style structured-output tool ever gets reopened.
             let validated = validateStructuredSummary(record.summary, spec.opts.schema);
             if (!validated.ok) {
+                logs.push(`schema: ${record.nickname} first output failed validation; sending one corrective retry`);
                 try {
                     await this.sendSubAgentInput(record.agentId, buildSchemaCorrectionPrompt(spec.opts.schema, record.summary), cwd, { abortSignal: options.abortSignal });
                     await record.promise?.catch(() => undefined);
@@ -1935,6 +1812,9 @@ export class Agent {
                 catch {
                     // resume failed; fall through to raw summary
                 }
+                logs.push(validated.ok
+                    ? `schema: ${record.nickname} corrective retry produced valid output`
+                    : `schema: ${record.nickname} corrective retry still invalid; returning raw summary`);
             }
             return { ok: true, value: validated.ok ? validated.value : record.summary };
         };
@@ -1945,14 +1825,11 @@ export class Agent {
             onLog: (message) => logs.push(message),
             onPhase: (title) => logs.push(`— phase: ${title} —`),
             budget: {
-                total: this.budgetLedger?.poolLimit ?? null,
+                // The ledger is pure accounting (no pool limit); scripts see an
+                // unlimited budget unless a future host contract reintroduces one.
+                total: null,
                 spent: () => runRecords.reduce((sum, r) => sum + (r.usage ? r.usage.promptTokens + r.usage.completionTokens : 0), 0),
-                remaining: () => {
-                    const limit = this.budgetLedger?.poolLimit;
-                    if (limit === undefined)
-                        return Number.POSITIVE_INFINITY;
-                    return Math.max(0, (this.budgetLedger?.remaining() ?? 0));
-                },
+                remaining: () => Number.POSITIVE_INFINITY,
             },
             signal: options.abortSignal,
         });
@@ -2013,13 +1890,6 @@ export class Agent {
     dispatchSubagentRun(record, input, cwd, options) {
         record.status = "queued";
         record.updatedAt = Date.now();
-        record.tokenCap = computeChildTokenCap({
-            ledger: this.budgetLedger,
-            subAgentId: record.agentId,
-            activeChildren: this.subagentScheduler.activeCount(),
-            configCap: this.subagentsConfig.childTokenCap,
-            profileMaxTokens: record.profile.maxTokens,
-        });
         const queueSignal = composeAbortSignals([options.abortSignal, record.abortController.signal]);
         return this.subagentScheduler.dispatch({
             agentId: record.agentId,
@@ -2028,7 +1898,7 @@ export class Agent {
             run: (ctx) => this.runSubagentThread(record, input, cwd, { ...options, attempt: ctx.attempt }),
             onCancelledWhileQueued: (reason) => {
                 record.status = "cancelled";
-                record.finalReason = classifySubagentAbortReason(reason, options.abortSignal, this.budgetLedger);
+                record.finalReason = classifySubagentAbortReason(reason, options.abortSignal);
                 record.error = reason instanceof Error ? reason.message : reason ? String(reason) : "Cancelled while queued.";
                 record.updatedAt = Date.now();
                 // The run never started, so no SubagentStart fired and no SubagentStop follows.
@@ -2780,5 +2650,11 @@ function isSubagentLifecycleTool(name) {
         || name === "send_input"
         || name === "close_agent"
         || name === "list_agents"
-        || name === "agent_team";
+        || name === "run_workflow"
+        || name === "wait_workflow"
+        // Legacy names: still present in transcripts recorded before the tools
+        // were removed (2026-07-06); forked children must not inherit their
+        // dangling tool_calls either.
+        || name === "agent_team"
+        || name === "agent_batch";
 }

package/dist/config.d.ts

@@ -36,8 +36,6 @@ export interface UserConfigData {
 export interface SubagentsUserConfig {
     /** Global cap on concurrently running children. Default 8. */
     maxActiveSubagents?: number;
-    /** Absolute per-child soft token cap. Default 200000. */
-    childTokenCap?: number;
 }
 export declare class UserConfig {
     private data;
@@ -66,7 +64,7 @@ export declare class UserConfig {
     getAgentCategories(): AgentCategoriesConfig;
     getSubagents(): SubagentsUserConfig;
 }
-export declare function shouldProbeTerminalTheme(config: ThemeConfig): boolean;
+export declare function shouldProbeTerminalTheme(_config: ThemeConfig): boolean;
 export declare function effectiveThemeModeForTerminal(config: ThemeConfig, detectedTheme: Exclude<ThemeMode, "auto">): ThemeMode;
 /** Mask an API key for safe display. */
 export declare function maskKey(key: string): string;

package/dist/config.js

@@ -45,9 +45,6 @@ function sanitizeSubagentsConfig(value) {
     if (typeof raw.maxActiveSubagents === "number" && Number.isFinite(raw.maxActiveSubagents)) {
         out.maxActiveSubagents = Math.max(1, Math.floor(raw.maxActiveSubagents));
     }
-    if (typeof raw.childTokenCap === "number" && Number.isFinite(raw.childTokenCap)) {
-        out.childTokenCap = Math.max(1_000, Math.floor(raw.childTokenCap));
-    }
     return Object.keys(out).length > 0 ? out : undefined;
 }
 function sanitizeTheme(value) {
@@ -211,8 +208,12 @@ export class UserConfig {
         return sanitizeSubagentsConfig(this.data.subagents) ?? {};
     }
 }
-export function shouldProbeTerminalTheme(config) {
-    return config.mode === "auto" || isLegacyBareDarkTheme(config);
+export function shouldProbeTerminalTheme(_config) {
+    // Always probe: even a forced theme needs the real terminal background to
+    // decide between inheriting it (theme matches the terminal) and painting
+    // its own canvas (forced theme mismatching the terminal, where the
+    // palette's foregrounds would otherwise be unreadable).
+    return true;
 }
 export function effectiveThemeModeForTerminal(config, detectedTheme) {
     if (isLegacyBareDarkTheme(config) && detectedTheme === "light")