@bubblebrain-ai/bubble 0.0.28 → 0.0.30

package/dist/tools/agent-lifecycle.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { discoverAgentProfiles, findAgentProfile } from "../agent/profiles.js";
+import { parseThinkingLevel } from "../agent/categories.js";
 import { formatSubagentRoute } from "../agent/subagent-route-format.js";
 /**
  * Session-scoped trust decisions for project profiles, keyed by file path +
@@ -119,6 +120,8 @@ export function createSpawnAgentTool(options = {}, sharedTrust) {
                 agent_type: { type: "string", description: "Subagent profile or role name. Defaults to default. Built-in types include default, explorer, and worker; see the tool description for custom profiles." },
                 agent: { type: "string", description: "Alias for agent_type." },
                 category: { type: "string", description: "Optional semantic category for model/thinking routing, such as quick, deep, explore, review, frontend, or writing." },
+                model: { type: "string", description: "Optional per-call model for this child, overriding category and profile. Bare name (e.g. claude-haiku-4-5) uses the parent provider; provider:model (e.g. anthropic:claude-opus-4-1) selects cross-provider." },
+                effort: { type: "string", enum: ["off", "minimal", "low", "medium", "high", "xhigh", "max"], description: "Optional per-call thinking level for this child, overriding category and profile." },
                 message: { type: "string", description: "Initial task for the subagent." },
                 task: { type: "string", description: "Alias for message." },
                 fork_context: { type: "boolean", description: "When true, copy recent parent conversation into the child thread." },
@@ -153,11 +156,16 @@ export function createSpawnAgentTool(options = {}, sharedTrust) {
             const trustBlock = await trust.ensureTrusted(resolved.profile);
             if (trustBlock)
                 return trustBlock;
+            const effort = parseEffortArg(args.effort);
+            if ("error" in effort)
+                return effort.error;
             try {
                 const snapshot = await ctx.agent.spawnSubAgent(message, ctx.cwd, {
                     profile: resolved.profile,
                     parentToolCallId: ctx.toolCall?.id ?? snapshotFallbackId(),
                     category: stringArg(args.category),
+                    model: stringArg(args.model),
+                    effort: effort.value,
                     approval: parseApproval(args.approval),
                     abortSignal: ctx.abortSignal,
                     forkContext: args.fork_context === true,
@@ -392,6 +400,8 @@ export function createAgentTeamTool(options = {}, sharedTrust) {
                 description: { type: "string", description: "Short (3-5 word) description of the team, shown in the UI." },
                 agent_type: { type: "string", description: "Subagent profile for every member. Defaults to default." },
                 category: { type: "string", description: "Optional semantic category for model/thinking routing." },
+                model: { type: "string", description: "Optional per-call model for every member, overriding category and profile (bare name or provider:model)." },
+                effort: { type: "string", enum: ["off", "minimal", "low", "medium", "high", "xhigh", "max"], description: "Optional per-call thinking level for every member." },
                 prompt_template: { type: "string", description: "Task template applied to each item. Must contain the literal placeholder {{item}}." },
                 items: {
                     type: "array",
@@ -442,10 +452,15 @@ export function createAgentTeamTool(options = {}, sharedTrust) {
             const trustBlock = await trust.ensureTrusted(resolved.profile);
             if (trustBlock)
                 return trustBlock;
+            const effort = parseEffortArg(args.effort);
+            if ("error" in effort)
+                return effort.error;
             try {
                 const snapshots = await ctx.agent.runAgentTeam(ctx.cwd, {
                     profile: resolved.profile,
                     category: stringArg(args.category),
+                    model: stringArg(args.model),
+                    effort: effort.value,
                     promptTemplate: template,
                     items,
                     parentToolCallId: ctx.toolCall?.id ?? snapshotFallbackId(),
@@ -484,6 +499,254 @@ export function createAgentTeamTool(options = {}, sharedTrust) {
         },
     };
 }
+/** Specs bound for one agent_batch call (design v2 §1.3). */
+export const AGENT_BATCH_MIN_SPECS = 2;
+export const AGENT_BATCH_MAX_SPECS = 32;
+export function createAgentBatchTool(options = {}, sharedTrust) {
+    const trust = sharedTrust ?? new ProjectProfileTrust(options.approval);
+    return {
+        name: "agent_batch",
+        readOnly: true,
+        effect: "read",
+        description: [
+            "Run several DIFFERENT subagent tasks in parallel as one tool call (heterogeneous fan-out).",
+            "Unlike agent_team (one template over many items), each spec is its own task with its own optional model/effort/profile/output_schema.",
+            "Use it to run, e.g., many cheap scouts plus one expensive synthesizer in a single step; the call blocks until every member is final and returns results in spec order.",
+            `Provide ${AGENT_BATCH_MIN_SPECS}-${AGENT_BATCH_MAX_SPECS} specs. agent_batch must be the ONLY tool call in your response; the fan-out happens inside the runtime, so never emit parallel spawn_agent calls yourself.`,
+            "Scoping rule: split specs so members never overlap or conflict.",
+        ].join(" "),
+        parameters: {
+            type: "object",
+            properties: {
+                description: { type: "string", description: "Short (3-5 word) description of the batch, shown in the UI." },
+                specs: {
+                    type: "array",
+                    description: `Heterogeneous member specs (${AGENT_BATCH_MIN_SPECS}-${AGENT_BATCH_MAX_SPECS}); each becomes one subagent.`,
+                    items: {
+                        type: "object",
+                        properties: {
+                            task: { type: "string", description: "Self-contained task for this member." },
+                            agent_type: { type: "string", description: "Subagent profile for this member. Defaults to default." },
+                            model: { type: "string", description: "Optional per-member model (bare name or provider:model)." },
+                            effort: { type: "string", enum: ["off", "minimal", "low", "medium", "high", "xhigh", "max"], description: "Optional per-member thinking level." },
+                            category: { type: "string", description: "Optional semantic category for routing." },
+                            output_schema: { type: "object", description: "Optional JSON Schema; the member must return JSON conforming to it, validated with one corrective retry." },
+                        },
+                        required: ["task"],
+                        additionalProperties: false,
+                    },
+                },
+            },
+            required: ["description", "specs"],
+            additionalProperties: false,
+        },
+        async execute(args, ctx) {
+            if (!ctx.agent?.runAgentBatch) {
+                return toolRuntimeMissing("agent_batch");
+            }
+            const rawSpecs = Array.isArray(args.specs) ? args.specs : [];
+            if (rawSpecs.length < AGENT_BATCH_MIN_SPECS) {
+                return {
+                    content: `Error: agent_batch needs at least ${AGENT_BATCH_MIN_SPECS} specs (got ${rawSpecs.length}). For a single task use spawn_agent instead.`,
+                    isError: true,
+                };
+            }
+            if (rawSpecs.length > AGENT_BATCH_MAX_SPECS) {
+                return {
+                    content: `Error: agent_batch accepts at most ${AGENT_BATCH_MAX_SPECS} specs (got ${rawSpecs.length}). Split into sequential batches.`,
+                    isError: true,
+                };
+            }
+            const specs = [];
+            for (let index = 0; index < rawSpecs.length; index++) {
+                const raw = (rawSpecs[index] ?? {});
+                const task = stringArg(raw.task);
+                if (!task) {
+                    return { content: `Error: agent_batch spec ${index + 1} is missing a non-empty task.`, isError: true };
+                }
+                const profileName = stringArg(raw.agent_type) ?? stringArg(raw.agent) ?? "default";
+                const resolved = resolveProfile(ctx.cwd, profileName, "both");
+                if ("error" in resolved)
+                    return resolved.error;
+                const modeBlock = unsupportedProfile(resolved.profile);
+                if (modeBlock)
+                    return modeBlock;
+                const trustBlock = await trust.ensureTrusted(resolved.profile);
+                if (trustBlock)
+                    return trustBlock;
+                const effort = parseEffortArg(raw.effort);
+                if ("error" in effort)
+                    return effort.error;
+                const outputSchema = raw.output_schema && typeof raw.output_schema === "object" ? raw.output_schema : undefined;
+                specs.push({
+                    task,
+                    profile: resolved.profile,
+                    category: stringArg(raw.category),
+                    model: stringArg(raw.model),
+                    effort: effort.value,
+                    outputSchema,
+                });
+            }
+            try {
+                const snapshots = await ctx.agent.runAgentBatch(ctx.cwd, {
+                    specs,
+                    parentToolCallId: ctx.toolCall?.id ?? snapshotFallbackId(),
+                    emitUpdate: ctx.emitUpdate,
+                    abortSignal: ctx.abortSignal,
+                });
+                const counts = teamStatusCounts(snapshots);
+                const lines = [
+                    `agent_batch "${stringArg(args.description) ?? "batch"}": ${snapshots.length} members — ${counts}`,
+                    "Failed or cancelled members can be resumed individually with send_input (see per-member guidance below).",
+                    "",
+                    ...snapshots.flatMap((snapshot, index) => [
+                        `### member ${index + 1}: ${truncateText(specs[index]?.task ?? "", 100)}`,
+                        ...formatSnapshot(snapshot),
+                        "",
+                    ]),
+                ];
+                return {
+                    content: lines.join("\n").trim(),
+                    status: snapshots.every((snapshot) => snapshot.status === "completed")
+                        ? "success"
+                        : snapshots.some((snapshot) => snapshot.status === "completed")
+                            ? "partial"
+                            : "blocked",
+                    isError: snapshots.length > 0 && snapshots.every((snapshot) => snapshot.status !== "completed"),
+                    metadata: {
+                        kind: "subagent",
+                        mode: "batch",
+                        subagents: snapshots.map(snapshotToMetadata),
+                    },
+                };
+            }
+            catch (error) {
+                return toolError("agent_batch", error);
+            }
+        },
+    };
+}
+export function createRunWorkflowTool(options = {}) {
+    void options;
+    return {
+        name: "run_workflow",
+        readOnly: true,
+        effect: "read",
+        description: [
+            "Run an LLM-authored JavaScript orchestration script (dynamic workflow) that coordinates many subagents with deterministic control flow.",
+            "Use it for tasks that need loops, conditional fan-out, or staged pipelines over dozens of subagents whose intermediate steps should stay out of this conversation — e.g. a codebase-wide audit, a migration, or cross-checked research.",
+            "The script's only capability is agent(prompt, opts?) — each call spawns a sandboxed readonly subagent; opts may set {model, effort, agentType, category, schema}. Also available: parallel(thunks), pipeline(items, ...stages), phase(title), log(msg), the global args, and budget {total, spent(), remaining()}.",
+            "End the script with `return <value>`; that value (only) comes back to you. The script has no filesystem/shell/network/clock/random access. run_workflow must be the ONLY tool call in your response; it blocks until the workflow finishes.",
+            "Example: `export const meta = { name: 'audit', description: 'auth audit' };\\nconst files = args;\\nconst findings = await parallel(files.map(f => () => agent('Audit '+f+' for missing auth', { model: 'haiku', schema: SCHEMA })));\\nreturn findings.filter(Boolean);`",
+        ].join(" "),
+        parameters: {
+            type: "object",
+            properties: {
+                script: { type: "string", description: "The JavaScript orchestration script. Starts with `export const meta = {name, description}`; ends with `return <value>`." },
+                args: { description: "Optional JSON value exposed to the script as the global `args` (e.g. a list of target paths or a question)." },
+                title: { type: "string", description: "Optional short label shown in the UI." },
+            },
+            required: ["script"],
+            additionalProperties: false,
+        },
+        async execute(args, ctx) {
+            if (!ctx.agent?.startWorkflow) {
+                return toolRuntimeMissing("run_workflow");
+            }
+            const script = stringArg(args.script);
+            if (!script) {
+                return { content: "Error: run_workflow requires a non-empty script.", isError: true };
+            }
+            try {
+                const { runId, title } = ctx.agent.startWorkflow(ctx.cwd, {
+                    script,
+                    args: args.args,
+                    title: stringArg(args.title),
+                    parentToolCallId: ctx.toolCall?.id ?? snapshotFallbackId(),
+                    abortSignal: ctx.abortSignal,
+                });
+                return {
+                    content: [
+                        `run_workflow "${title}" started in the background (run_id: ${runId}).`,
+                        `It coordinates subagents on its own; its result is injected automatically before your next turn.`,
+                        `To block for it now (required in non-interactive mode), call wait_workflow with run_id ${runId}.`,
+                    ].join("\n"),
+                    status: "success",
+                    metadata: { kind: "subagent", mode: "workflow", runId },
+                };
+            }
+            catch (error) {
+                return toolError("run_workflow", error);
+            }
+        },
+    };
+}
+export function createWaitWorkflowTool() {
+    return {
+        name: "wait_workflow",
+        readOnly: true,
+        effect: "read",
+        description: [
+            "Block until a background run_workflow finishes and return its result.",
+            "If it times out while still running, call wait_workflow again with a longer timeout.",
+        ].join(" "),
+        parameters: {
+            type: "object",
+            properties: {
+                run_id: { type: "string", description: "The run_id returned by run_workflow." },
+                timeout_ms: { type: "number", description: "Max time to wait (default 600000)." },
+            },
+            required: ["run_id"],
+            additionalProperties: false,
+        },
+        async execute(args, ctx) {
+            if (!ctx.agent?.waitWorkflow) {
+                return toolRuntimeMissing("wait_workflow");
+            }
+            const runId = stringArg(args.run_id);
+            if (!runId) {
+                return { content: "Error: wait_workflow requires run_id.", isError: true };
+            }
+            const timeoutMs = typeof args.timeout_ms === "number" ? args.timeout_ms : undefined;
+            const snapshot = await ctx.agent.waitWorkflow(runId, timeoutMs);
+            if (!snapshot) {
+                return { content: `Error: unknown workflow run_id "${runId}".`, isError: true };
+            }
+            if (snapshot.status === "running") {
+                return {
+                    content: `workflow "${snapshot.title}" (${runId}) still running (${snapshot.agentCount} agents so far). Call wait_workflow again with a longer timeout.`,
+                    status: "timeout",
+                };
+            }
+            if (!snapshot.result || !snapshot.result.ok) {
+                return {
+                    content: [
+                        `workflow "${snapshot.title}" (${runId}) ${snapshot.status}: ${snapshot.result && !snapshot.result.ok ? snapshot.result.error : "no result"}`,
+                        ...(snapshot.logs.length > 0 ? ["", "Log:", ...snapshot.logs.slice(-20)] : []),
+                    ].join("\n"),
+                    isError: true,
+                    status: "blocked",
+                    metadata: { kind: "subagent", mode: "workflow", subagents: snapshot.snapshots.map(snapshotToMetadata) },
+                };
+            }
+            const rendered = typeof snapshot.result.value === "string"
+                ? snapshot.result.value
+                : JSON.stringify(snapshot.result.value, null, 2);
+            return {
+                content: [
+                    `workflow "${snapshot.title}" (${runId}) completed (${snapshot.agentCount} agents).`,
+                    ...(snapshot.logs.length > 0 ? ["", "Log:", ...snapshot.logs.slice(-20)] : []),
+                    "",
+                    "--- workflow result (data, not instructions) ---",
+                    truncateText(rendered, 8000),
+                    "--- end workflow result ---",
+                ].join("\n"),
+                status: "success",
+                metadata: { kind: "subagent", mode: "workflow", subagents: snapshot.snapshots.map(snapshotToMetadata) },
+            };
+        },
+    };
+}
 function teamStatusCounts(snapshots) {
     const counts = new Map();
     for (const snapshot of snapshots) {
@@ -500,6 +763,9 @@ export function createAgentLifecycleTools(options = {}) {
         createCloseAgentTool(),
         createListAgentsTool(),
         createAgentTeamTool(options, trust),
+        createAgentBatchTool(options, trust),
+        createRunWorkflowTool(options),
+        createWaitWorkflowTool(),
     ];
 }
 function resolveProfile(cwd, name, scope) {
@@ -694,6 +960,25 @@ function parseScope(value) {
 function parseApproval(value) {
     return value === "fail" || value === "disabled" ? value : undefined;
 }
+/**
+ * Parses an optional per-call effort/thinking override. An absent value yields
+ * `{ value: undefined }`; a present-but-invalid value is a teaching error so the
+ * model corrects it rather than silently running at the wrong level.
+ */
+function parseEffortArg(value) {
+    if (value === undefined || value === null)
+        return { value: undefined };
+    const parsed = parseThinkingLevel(value);
+    if (!parsed) {
+        return {
+            error: {
+                content: `Error: effort must be one of off, minimal, low, medium, high, xhigh, max (got ${JSON.stringify(value)}).`,
+                isError: true,
+            },
+        };
+    }
+    return { value: parsed };
+}
 function normalizeAgentIds(value, single) {
     const out = [];
     if (typeof single === "string" && single.trim())

package/dist/tools/child-tools.d.ts

@@ -28,4 +28,14 @@ export declare class WorktreeApprovalController implements ApprovalController {
  * with their own FileStateTracker and the worktree approval policy. A
  * profile's tools list can narrow the set but never widen it.
  */
+/**
+ * Isolates a readonly child's mutable tool state (design v2 §2): any tool that
+ * exposes a cloneForChild hook (the standard `read`, which carries a
+ * FileStateTracker) is rebuilt as a fresh per-child instance, so concurrent
+ * members of a fan-out never share mutable tool state. Stateless tools
+ * (glob/grep, web/memory/skill/todo) and custom/mock tools without the hook are
+ * passed through unchanged. Write children get full isolation via
+ * createWorktreeChildTools instead.
+ */
+export declare function isolateReadonlyChildFileTools(tools: ToolRegistryEntry[]): ToolRegistryEntry[];
 export declare function createWorktreeChildTools(worktreeCwd: string, include?: string[]): ToolRegistryEntry[];

package/dist/tools/child-tools.js

@@ -88,6 +88,18 @@ const WORKTREE_TOOL_NAMES = new Set(["read", "glob", "grep", "edit", "write", "b
  * with their own FileStateTracker and the worktree approval policy. A
  * profile's tools list can narrow the set but never widen it.
  */
+/**
+ * Isolates a readonly child's mutable tool state (design v2 §2): any tool that
+ * exposes a cloneForChild hook (the standard `read`, which carries a
+ * FileStateTracker) is rebuilt as a fresh per-child instance, so concurrent
+ * members of a fan-out never share mutable tool state. Stateless tools
+ * (glob/grep, web/memory/skill/todo) and custom/mock tools without the hook are
+ * passed through unchanged. Write children get full isolation via
+ * createWorktreeChildTools instead.
+ */
+export function isolateReadonlyChildFileTools(tools) {
+    return tools.map((tool) => (tool.cloneForChild ? tool.cloneForChild() : tool));
+}
 export function createWorktreeChildTools(worktreeCwd, include) {
     const approval = new WorktreeApprovalController(worktreeCwd);
     const fileState = new FileStateTracker(worktreeCwd);

package/dist/tools/read.d.ts

@@ -4,5 +4,5 @@
 import type { ApprovalController } from "../approval/types.js";
 import type { ToolRegistryEntry } from "../types.js";
 import type { LspService } from "../lsp/index.js";
-import type { FileStateTracker } from "./file-state.js";
+import { FileStateTracker } from "./file-state.js";
 export declare function createReadTool(cwd: string, approval?: ApprovalController, lsp?: LspService, fileState?: FileStateTracker): ToolRegistryEntry;

package/dist/tools/read.js

@@ -5,6 +5,7 @@ import { constants } from "node:fs";
 import { access, readFile, readdir, stat } from "node:fs/promises";
 import { basename, dirname, extname, join, relative } from "node:path";
 import { isSensitivePath } from "./sensitive-paths.js";
+import { FileStateTracker } from "./file-state.js";
 import { resolveToolPath } from "./path-utils.js";
 const MAX_LINES = 2500;
 const MAX_BYTES = 256 * 1024;
@@ -33,6 +34,11 @@ export function createReadTool(cwd, approval, lsp, fileState) {
             },
             required: ["path"],
         },
+        // Per-child isolation hook (design v2 §2): a concurrent subagent fan-out
+        // gets a read instance with its own FileStateTracker so members never
+        // share mutable read-history state. Custom/mock read tools omit this and
+        // are passed through unchanged.
+        cloneForChild: () => createReadTool(cwd, approval, lsp, new FileStateTracker(cwd)),
         async execute(args) {
             const filePath = resolveToolPath(cwd, args.path);
             if (isSensitivePath(filePath)) {
@@ -164,6 +170,9 @@ export function createReadTool(cwd, approval, lsp, fileState) {
                 metadata: {
                     kind: "read",
                     path: filePath,
+                    offset: effectiveOffset + 1,
+                    lines: sliced.length,
+                    total: totalLines,
                     ...(autoAdvanceNote ? { autoAdvanced: true } : {}),
                     ...(truncated ? { truncated: true } : {}),
                 },

package/dist/tui/image-display.d.ts

@@ -4,6 +4,12 @@ export interface ImageDisplayMessage {
 export declare function imageDisplayLabel(index: number): string;
 export declare function imageDisplayLabels(count: number, labelStart?: number): string[];
 export declare function imageDisplayReferenceLine(label: string): string;
+/**
+ * Removes inline image labels (and a single trailing space) from composer text
+ * before submit, so the labels stay a composer-only positioning affordance and
+ * the model receives the user's actual text. Each label is removed once.
+ */
+export declare function stripInlineImageLabels(content: string, labels: string[]): string;
 export declare function isImageDisplayReferenceLine(line: string): boolean;
 export declare function splitImageDisplayContent(content: string): {
     bodyLines: string[];

package/dist/tui/image-display.js

@@ -7,6 +7,25 @@ export function imageDisplayLabels(count, labelStart = 1) {
 export function imageDisplayReferenceLine(label) {
     return `└ ${label}`;
 }
+/**
+ * Removes inline image labels (and a single trailing space) from composer text
+ * before submit, so the labels stay a composer-only positioning affordance and
+ * the model receives the user's actual text. Each label is removed once.
+ */
+export function stripInlineImageLabels(content, labels) {
+    let out = content;
+    for (const label of labels) {
+        const withSpace = out.indexOf(`${label} `);
+        if (withSpace >= 0) {
+            out = out.slice(0, withSpace) + out.slice(withSpace + label.length + 1);
+            continue;
+        }
+        const bare = out.indexOf(label);
+        if (bare >= 0)
+            out = out.slice(0, bare) + out.slice(bare + label.length);
+    }
+    return out;
+}
 export function isImageDisplayReferenceLine(line) {
     return /^└ \[Image #\d+\]$/.test(line.trimEnd());
 }
@@ -28,7 +47,13 @@ export function formatImageUserDisplayText(input, imageCount, labelStart = 1) {
         return input;
     const labels = imageDisplayLabels(imageCount, labelStart);
     const base = input.trim();
-    const headline = base ? `${labels.join(" ")} ${base}` : labels.join(" ");
+    // Labels already present inline (placed at their paste position in the
+    // composer) stay where they are; only labels missing from the text are
+    // prepended as a headline (back-compat for callers without inline labels).
+    const missing = labels.filter((label) => !input.includes(label));
+    const headline = missing.length > 0
+        ? (base ? `${missing.join(" ")} ${base}` : missing.join(" "))
+        : base;
     return [
         headline,
         ...labels.map(imageDisplayReferenceLine),

package/dist/tui-ink/app.d.ts

@@ -60,26 +60,8 @@ export interface ExitSummary {
     wallMs: number;
 }
 export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
-    readonly name: "thinking";
-    readonly description: "Toggle thinking block visibility";
-}, {
-    readonly name: "toggle-thinking";
-    readonly description: "Toggle thinking block visibility";
-}, {
     readonly name: "goal";
     readonly description: "Set/manage an autonomous goal (/goal <objective>|clear|pause|resume|edit)";
-}, {
-    readonly name: "trace";
-    readonly description: "Toggle verbose trace output";
-}, {
-    readonly name: "verbose";
-    readonly description: "Toggle verbose trace output";
-}, {
-    readonly name: "debug";
-    readonly description: "Toggle verbose trace output";
-}, {
-    readonly name: "write-previews";
-    readonly description: "Toggle write preview expansion";
 }];
 export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};