@bubblebrain-ai/bubble 0.0.28 → 0.0.29

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.29",
   "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",