@bubblebrain-ai/bubble 0.0.28 → 0.0.30

package/dist/tui-ink/subagent-view.js

@@ -0,0 +1,163 @@
+/**
+ * Shared subagent view-model + presentation helpers, used by both the inline
+ * Subagents block (message-list.tsx) and the full-screen inspector
+ * (subagent-inspector.tsx). Pure functions only — no React.
+ */
+import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+export function latestSubagentNote(subagent) {
+    const note = subagent.error
+        || subagent.toolNotes?.filter(Boolean).at(-1)
+        || subagent.summary
+        || subagent.task
+        || "";
+    return note.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+}
+export function subagentLabel(subagent) {
+    return subagent.nickname ?? subagent.agentName ?? "subagent";
+}
+export function subagentRole(subagent) {
+    return [subagent.agentName, subagent.category ? `/${subagent.category}` : ""].join("") || "default";
+}
+export function subagentDescriptor(subagent, includeThinking = false) {
+    const route = formatSubagentRoute(subagent.route, { includeThinking });
+    const role = subagentRole(subagent);
+    return route ? `${role} @ ${route}` : role;
+}
+export function subagentStatusColor(status, theme) {
+    if (status === "completed")
+        return theme.success;
+    if (status === "failed" || status === "blocked" || status === "cancelled")
+        return theme.error;
+    if (status === "queued")
+        return theme.muted;
+    return theme.toolPending;
+}
+export function subagentSummary(subagents) {
+    if (subagents.length === 0)
+        return "no subagents";
+    const counts = new Map();
+    for (const subagent of subagents) {
+        const status = subagent.status ?? "running";
+        counts.set(status, (counts.get(status) ?? 0) + 1);
+    }
+    const order = ["running", "queued", "completed", "blocked", "failed", "cancelled"];
+    return order
+        .filter((status) => counts.has(status))
+        .map((status) => `${counts.get(status)} ${status}`)
+        .join("  ");
+}
+export function sortSubagents(subagents) {
+    const rank = {
+        running: 0,
+        blocked: 1,
+        failed: 2,
+        queued: 3,
+        cancelled: 4,
+        completed: 5,
+    };
+    return [...subagents].sort((a, b) => (rank[a.status ?? "running"] ?? 9) - (rank[b.status ?? "running"] ?? 9));
+}
+function subagentStatusRank(status) {
+    if (status === "completed" || status === "failed" || status === "blocked" || status === "cancelled" || status === "closed")
+        return 3;
+    if (status === "running")
+        return 2;
+    if (status === "queued")
+        return 1;
+    return 0;
+}
+/** Higher = more "complete"/recent snapshot of the same subagent. */
+function subagentFreshness(member) {
+    return subagentStatusRank(member.status) * 100_000
+        + (member.toolNotes?.length ?? 0) * 10
+        + (member.summary ? 1 : 0);
+}
+function memberKey(member) {
+    return member.subAgentId || `${member.nickname ?? ""}|${member.task ?? ""}`;
+}
+/**
+ * Collects every spawned subagent from the live transcript + streaming tools,
+ * grouped by their originating tool call, for the inspector. Pure.
+ *
+ * The same subagent is echoed by MULTIPLE lifecycle tool calls — its spawn_agent
+ * (a stale snapshot) plus every wait_agent/list_agents that observed it (later
+ * snapshots), all carrying metadata.subagents (agent-lifecycle formatLifecycleResult).
+ * So we dedupe by subAgentId, keep the freshest snapshot, group team/batch members
+ * by their originating tool call, and collapse a single agent's many lifecycle
+ * echoes into one "single" group keyed by the agent itself.
+ */
+export function collectSubagentGroups(messages, streamingTools) {
+    const toolCalls = [];
+    const ingest = (tcs) => {
+        if (!tcs)
+            return;
+        for (const tc of tcs)
+            if (tc.metadata?.kind === "subagent")
+                toolCalls.push(tc);
+    };
+    for (const message of messages) {
+        ingest(message.toolCalls);
+        if (message.parts) {
+            for (const part of message.parts) {
+                if (part.type === "tools")
+                    ingest(part.toolCalls);
+            }
+        }
+    }
+    ingest(streamingTools);
+    const freshest = new Map();
+    const memberToGroup = new Map();
+    const groups = new Map();
+    let order = 0;
+    for (const tc of toolCalls) {
+        const rawMembers = Array.isArray(tc.metadata?.subagents) ? tc.metadata.subagents : [];
+        const members = rawMembers.filter((m) => typeof m === "object" && m !== null);
+        if (members.length === 0)
+            continue;
+        // Track the freshest snapshot seen for each subagent.
+        for (const m of members) {
+            const key = memberKey(m);
+            const prev = freshest.get(key);
+            if (!prev || subagentFreshness(m) >= subagentFreshness(prev))
+                freshest.set(key, m);
+        }
+        const mode = tc.metadata.mode;
+        if (mode === "team" || mode === "batch" || mode === "workflow") {
+            // A team/batch/workflow tool call is the canonical group for its members.
+            const groupKey = tc.id;
+            if (!groups.has(groupKey)) {
+                const description = typeof tc.args?.description === "string" ? tc.args.description.trim()
+                    : typeof tc.args?.title === "string" ? tc.args.title.trim() : "";
+                groups.set(groupKey, { kind: mode, label: description || mode, memberKeys: [], order: order++ });
+            }
+            const group = groups.get(groupKey);
+            for (const m of members) {
+                const key = memberKey(m);
+                if (!memberToGroup.has(key)) {
+                    memberToGroup.set(key, groupKey);
+                    group.memberKeys.push(key);
+                }
+            }
+        }
+        else {
+            // Lifecycle echo (spawn/wait/list/...): one "single" group per agent,
+            // collapsing all its echoes; skip any already claimed by a team/batch.
+            for (const m of members) {
+                const key = memberKey(m);
+                if (memberToGroup.has(key))
+                    continue;
+                const groupKey = `single:${key}`;
+                memberToGroup.set(key, groupKey);
+                groups.set(groupKey, { kind: "single", label: m.nickname ?? m.task ?? "subagent", memberKeys: [key], order: order++ });
+            }
+        }
+    }
+    return [...groups.entries()]
+        .sort((a, b) => a[1].order - b[1].order)
+        .map(([id, g]) => ({
+        id,
+        kind: g.kind,
+        label: g.label,
+        members: g.memberKeys.map((k) => freshest.get(k)).filter((m) => !!m),
+    }));
+}

package/dist/tui-ink/terminal-env.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Whether we're running inside a terminal multiplexer (tmux or GNU screen).
+ *
+ * Ink commits settled transcript rows to native scrollback via <Static> and
+ * repaints only the short live region in place. When that live region SHRINKS
+ * (a turn settles, a steer commits, a run is interrupted), Ink erases the prior
+ * frame with a cursor-up + clear. Under a multiplexer that erase cannot reach
+ * rows that have already scrolled out of the pane, leaving a blank gap — so
+ * those transitions fall back to a full screen+scrollback reprint to stay clean.
+ *
+ * On a normal terminal that reprint is unnecessary (Ink's in-place erase works)
+ * and visible as a one-frame full-screen flash, so we skip it. This predicate is
+ * the gate. Pure + injectable for tests.
+ */
+export declare function isMultiplexedTerminal(env?: NodeJS.ProcessEnv): boolean;

package/dist/tui-ink/terminal-env.js

@@ -0,0 +1,22 @@
+/**
+ * Whether we're running inside a terminal multiplexer (tmux or GNU screen).
+ *
+ * Ink commits settled transcript rows to native scrollback via <Static> and
+ * repaints only the short live region in place. When that live region SHRINKS
+ * (a turn settles, a steer commits, a run is interrupted), Ink erases the prior
+ * frame with a cursor-up + clear. Under a multiplexer that erase cannot reach
+ * rows that have already scrolled out of the pane, leaving a blank gap — so
+ * those transitions fall back to a full screen+scrollback reprint to stay clean.
+ *
+ * On a normal terminal that reprint is unnecessary (Ink's in-place erase works)
+ * and visible as a one-frame full-screen flash, so we skip it. This predicate is
+ * the gate. Pure + injectable for tests.
+ */
+export function isMultiplexedTerminal(env = process.env) {
+    if (env.TMUX)
+        return true; // inside tmux
+    if (env.STY)
+        return true; // inside GNU screen
+    const term = env.TERM ?? "";
+    return /^(screen|tmux)(-|\.|$)/.test(term); // e.g. screen-256color, tmux-256color
+}

package/dist/tui-ink/use-terminal-size.js

@@ -1,5 +1,31 @@
 import { useEffect, useState } from "react";
 import { useStdout } from "ink";
+const subscribers = new Set();
+let attachedStream = null;
+function notifyAll() {
+    for (const cb of subscribers)
+        cb();
+}
+function detach() {
+    if (!attachedStream)
+        return;
+    const off = attachedStream.off ?? attachedStream.removeListener;
+    off?.call(attachedStream, "resize", notifyAll);
+    attachedStream = null;
+}
+function subscribe(stream, cb) {
+    subscribers.add(cb);
+    if (attachedStream !== stream) {
+        detach();
+        stream.on("resize", notifyAll);
+        attachedStream = stream;
+    }
+    return () => {
+        subscribers.delete(cb);
+        if (subscribers.size === 0)
+            detach();
+    };
+}
 export function useTerminalSize() {
     const { stdout } = useStdout();
     const [size, setSize] = useState(() => ({
@@ -9,13 +35,14 @@ export function useTerminalSize() {
     useEffect(() => {
         if (!stdout)
             return;
-        const onResize = () => {
-            setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
-        };
-        stdout.on("resize", onResize);
-        return () => {
-            stdout.off("resize", onResize);
+        const update = () => {
+            setSize((prev) => {
+                const next = { columns: stdout.columns || 80, rows: stdout.rows || 24 };
+                return prev.columns === next.columns && prev.rows === next.rows ? prev : next;
+            });
         };
+        update(); // sync in case the size changed between initial state and mount
+        return subscribe(stdout, update);
     }, [stdout]);
     return size;
 }

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

@@ -0,0 +1,18 @@
+/** Current verdict — true when ambiguous-width chars occupy 2 terminal cells. */
+export declare function ambiguousIsWide(): boolean;
+/** Deterministic override for tests (force CJK-wide / narrow). */
+export declare function setAmbiguousWide(v: boolean): void;
+export declare function visualWidth(str: string): number;
+export declare function graphemeWidth(grapheme: string): number;
+/**
+ * Probe the real terminal once at startup, before Ink owns the TTY: print a
+ * single ambiguous-width glyph at column 1, ask where the cursor landed via the
+ * DSR cursor-position report (`CSI 6n` → `ESC [ row ; col R`), and read back the
+ * glyph's rendered width. Width 2 → ambiguous-wide; width 1 → narrow.
+ *
+ * An explicit env override wins and skips the probe entirely. A non-TTY (pipe,
+ * CI) or an unresponsive terminal (the `setTimeout` fires) leaves the locale
+ * guess untouched. The probe glyph is erased before returning so the first Ink
+ * paint sees a clean line.
+ */
+export declare function detectAmbiguousWidth(timeoutMs?: number): Promise<void>;

package/dist/tui-ink/width.js

@@ -0,0 +1,130 @@
+import stringWidth from "string-width";
+/**
+ * One verdict for the whole TUI: does THIS terminal render East Asian
+ * *Ambiguous*-width characters as 2 cells?
+ *
+ * Ambiguous-width (Unicode EastAsianWidth=A) covers the curly quotes “ ”, the
+ * em dash —, the ● bullet, the ellipsis …, box-drawing ─│┼ and more. `string-
+ * width`'s default counts them as 1, but a terminal can render them as 2 — and
+ * crucially that choice is a property of the *terminal + font*, NOT the locale:
+ * this project's own author hits wide rendering under `LANG=en_US`. When our
+ * width math disagrees with the terminal, a line we packed to "exactly fits"
+ * overflows and the terminal applies its own hard wrap, dropping the overflow
+ * tail onto a stray physical row (the lone "顺" + vertical-gap corruption).
+ *
+ * So the verdict is resolved, in priority order:
+ *   1. explicit env override `BUBBLE_AMBIGUOUS_WIDTH=wide|narrow`,
+ *   2. a one-shot CSI 6n cursor probe of the real terminal at startup,
+ *   3. a CJK-locale guess as the last resort.
+ *
+ * EVERYTHING that measures display width for wrapping, cursor mapping, padding,
+ * truncation or gutter budgeting must go through `visualWidth`/`graphemeWidth`
+ * here, so the entire UI shares the single verdict and stays self-consistent.
+ */
+let ambiguousWide = initialGuess();
+function envOverride() {
+    const v = process.env.BUBBLE_AMBIGUOUS_WIDTH?.trim().toLowerCase();
+    if (!v)
+        return undefined;
+    if (/^(wide|double|full|2)$/.test(v))
+        return true;
+    if (/^(narrow|single|half|1)$/.test(v))
+        return false;
+    return undefined;
+}
+function localeIsCJK() {
+    const lang = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || "";
+    return /(^|[._-])(zh|ja|ko)/i.test(lang);
+}
+function initialGuess() {
+    const override = envOverride();
+    return override !== undefined ? override : localeIsCJK();
+}
+/** Current verdict — true when ambiguous-width chars occupy 2 terminal cells. */
+export function ambiguousIsWide() {
+    return ambiguousWide;
+}
+/** Deterministic override for tests (force CJK-wide / narrow). */
+export function setAmbiguousWide(v) {
+    ambiguousWide = v;
+}
+export function visualWidth(str) {
+    if (!str)
+        return 0;
+    return stringWidth(str, { ambiguousIsNarrow: !ambiguousWide });
+}
+export function graphemeWidth(grapheme) {
+    if (!grapheme)
+        return 0;
+    return stringWidth(grapheme, { ambiguousIsNarrow: !ambiguousWide });
+}
+/**
+ * Probe the real terminal once at startup, before Ink owns the TTY: print a
+ * single ambiguous-width glyph at column 1, ask where the cursor landed via the
+ * DSR cursor-position report (`CSI 6n` → `ESC [ row ; col R`), and read back the
+ * glyph's rendered width. Width 2 → ambiguous-wide; width 1 → narrow.
+ *
+ * An explicit env override wins and skips the probe entirely. A non-TTY (pipe,
+ * CI) or an unresponsive terminal (the `setTimeout` fires) leaves the locale
+ * guess untouched. The probe glyph is erased before returning so the first Ink
+ * paint sees a clean line.
+ */
+export async function detectAmbiguousWidth(timeoutMs = 150) {
+    if (envOverride() !== undefined)
+        return; // explicit choice already applied
+    const { stdin, stdout } = process;
+    if (!stdout.isTTY || !stdin.isTTY || typeof stdin.setRawMode !== "function")
+        return;
+    const wasRaw = stdin.isRaw ?? false;
+    const wasFlowing = stdin.readableFlowing ?? false;
+    const measured = await new Promise((resolve) => {
+        let buf = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(wasRaw);
+            }
+            catch {
+                // teardown best-effort
+            }
+            if (!wasFlowing)
+                stdin.pause();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buf += chunk.toString("latin1");
+            const m = /\x1b\[\d+;(\d+)R/.exec(buf);
+            if (m)
+                finish(Number(m[1]) - 1); // col is 1-based; col-1 = glyph width
+        };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on("data", onData);
+            // \r → column 1, print the probe glyph (U+201C “), then request the cursor
+            // column. The reported column minus 1 is the glyph's rendered cell width.
+            stdout.write("\r“\x1b[6n");
+        }
+        catch {
+            finish(null);
+        }
+    });
+    if (measured === 2)
+        ambiguousWide = true;
+    else if (measured === 1)
+        ambiguousWide = false;
+    // measured === null → probe failed; keep the locale-based guess.
+    try {
+        if (stdout.isTTY)
+            stdout.write("\r\x1b[K"); // wipe the probe glyph
+    }
+    catch {
+        // stdout best-effort
+    }
+}

package/dist/types.d.ts

@@ -182,6 +182,8 @@ export interface ToolContext {
             profile: import("./agent/profiles.js").AgentProfile;
             parentToolCallId: string;
             category?: string;
+            model?: string;
+            effort?: ThinkingLevel;
             route?: import("./agent/categories.js").ResolvedSubagentRoute;
             approval?: "fail" | "disabled";
             description?: string;
@@ -202,6 +204,8 @@ export interface ToolContext {
         runAgentTeam?: (cwd: string, options: {
             profile: import("./agent/profiles.js").AgentProfile;
             category?: string;
+            model?: string;
+            effort?: ThinkingLevel;
             promptTemplate: string;
             items: string[];
             parentToolCallId: string;
@@ -209,11 +213,42 @@ export interface ToolContext {
             abortSignal?: AbortSignal;
             approval?: "fail" | "disabled";
         }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
+        runAgentBatch?: (cwd: string, options: {
+            specs: Array<{
+                task: string;
+                profile: import("./agent/profiles.js").AgentProfile;
+                category?: string;
+                model?: string;
+                effort?: ThinkingLevel;
+                outputSchema?: unknown;
+            }>;
+            parentToolCallId: string;
+            emitUpdate?: (update: ToolUpdate) => void;
+            abortSignal?: AbortSignal;
+            approval?: "fail" | "disabled";
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
+        startWorkflow?: (cwd: string, options: {
+            script: string;
+            args?: unknown;
+            title?: string;
+            parentToolCallId: string;
+            abortSignal?: AbortSignal;
+        }) => {
+            runId: string;
+            title: string;
+        };
+        waitWorkflow?: (runId: string, timeoutMs?: number) => Promise<import("./agent/workflow/control.js").WorkflowRunSnapshot | undefined>;
     };
     emitUpdate?: (update: ToolUpdate) => void;
 }
 export interface ToolRegistryEntry extends ToolDefinition {
     execute: ToolExecutor;
+    /**
+     * Optional per-child isolation hook: returns a fresh instance with its own
+     * mutable state (e.g. a FileStateTracker) so concurrent subagents in a
+     * fan-out never share it (design v2 §2). Tools without it are shared as-is.
+     */
+    cloneForChild?: () => ToolRegistryEntry;
     /** Optional one-line summary for the Available tools section. */
     promptSnippet?: string;
     /** Optional tool-specific rules appended to the system prompt when this tool is active. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -36,6 +36,7 @@
     "openai": "^4.77.0",
     "picomatch": "^4.0.4",
     "qrcode-terminal": "^0.12.0",
+    "quickjs-emscripten": "^0.32.0",
     "react": "^19.2.6",
     "shiki": "^4.0.2",
     "string-width": "^8.2.1",