@bubblebrain-ai/bubble 0.0.46 → 0.0.47

package/dist/tui-ink/sync-output.js

@@ -0,0 +1,35 @@
+/**
+ * Synchronized-output wrapper (CSI ?2026, "sync updates").
+ *
+ * Every frame Ink writes gets bracketed in begin/end synchronized-output so
+ * the terminal composites it atomically instead of painting mid-erase state —
+ * the primary source of visible flicker during streaming. This is exactly
+ * what pi's main-screen renderer does per paint batch; alt-screen is NOT
+ * required for it.
+ *
+ * Terminals that don't implement mode 2026 ignore unknown DEC private modes,
+ * so emitting unconditionally is safe; BUBBLE_NO_SYNC_OUTPUT=1 is the escape
+ * hatch for anything that misbehaves. Only string chunks are bracketed —
+ * Ink writes frames as strings; binary writes pass through untouched.
+ */
+export const BEGIN_SYNC = "\x1b[?2026h";
+export const END_SYNC = "\x1b[?2026l";
+export function wrapSynchronizedOutput(stream) {
+    if (!stream.isTTY || process.env.BUBBLE_NO_SYNC_OUTPUT === "1")
+        return stream;
+    return new Proxy(stream, {
+        get(target, prop) {
+            if (prop === "write") {
+                return (chunk, ...rest) => typeof chunk === "string" && chunk.length > 0
+                    ? target.write(BEGIN_SYNC + chunk + END_SYNC, ...rest)
+                    : target.write(chunk, ...rest);
+            }
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+        set(target, prop, value) {
+            Reflect.set(target, prop, value);
+            return true;
+        },
+    });
+}

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

@@ -56,7 +56,6 @@ export interface Theme {
     userMessageBorder: string;
     userMessageBg: string;
     userMessageText: string;
-    userRail: string;
     /** Painted band backgrounds for diff lines inside user-message cards. */
     diffAdd: string;
     diffRemove: string;

package/dist/tui-ink/theme.js

@@ -46,7 +46,6 @@ export const darkTheme = {
     userMessageBorder: "#8A7FC6",
     userMessageBg: "#2a2a34",
     userMessageText: "#f3f3f7",
-    userRail: "#8A7FC6",
     diffAdd: "#1a3d1a",
     diffRemove: "#3d1a1a",
     diffAddFg: "green",
@@ -95,7 +94,6 @@ export const lightTheme = {
     userMessageBorder: "#356FD2",
     userMessageBg: "#F1F3F0",
     userMessageText: "#234B93",
-    userRail: "#356FD2",
     diffAdd: "#D7E8D8",
     diffRemove: "#F7DADC",
     diffAddFg: "#2F7D4A",

package/dist/tui-ink/trace-groups.js

@@ -387,7 +387,7 @@ function isFailedSubagent(subagent) {
     return subagent.status === "failed" || subagent.status === "blocked" || subagent.status === "cancelled";
 }
 function isToolPending(tool) {
-    return tool.result === undefined && tool.resultCollapsed !== true;
+    return tool.result === undefined;
 }
 function isDirectoryLikeGlob(pattern) {
     const normalized = pattern.trim();

package/dist/types.d.ts

@@ -130,7 +130,6 @@ export interface ToolResultMetadata {
     searchSignature?: string;
     searchFamily?: string;
     reason?: string;
-    arbiterNote?: string;
     diff?: string;
     addedLines?: number;
     removedLines?: number;
@@ -235,6 +234,15 @@ export interface ToolRegistryEntry extends ToolDefinition {
      * fan-out never share it (design v2 §2). Tools without it are shared as-is.
      */
     cloneForChild?: () => ToolRegistryEntry;
+    /**
+     * Optional availability predicate, evaluated on EVERY model call. When it
+     * returns false the tool is omitted from the provider's function list
+     * entirely — the model cannot see or call it — and reappears on the next
+     * call once the predicate flips. For state-gated tools (e.g. update_goal
+     * without an active goal) this removes the affordance itself instead of
+     * relying on description wording, which strong models ignore.
+     */
+    enabled?: () => boolean;
     /** 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. */
@@ -314,6 +322,17 @@ export interface TokenUsage {
     reasoningTokens?: number;
     totalTokens?: number;
 }
+/**
+ * Priced token usage (see model-pricing.ts). Lives here rather than in
+ * model-pricing.ts because turn_end events carry it and model-pricing
+ * already imports from this module.
+ */
+export interface UsageCost {
+    currency: "USD" | "CNY";
+    cost: number;
+    /** True when the provider gave no cache breakdown and everything was billed at the miss rate. */
+    estimated: boolean;
+}
 export interface Provider {
     streamChat(messages: ProviderMessage[], options: {
         model: string;
@@ -410,6 +429,7 @@ export type AgentEvent = {
 } | {
     type: "turn_end";
     usage?: TokenUsage;
+    cost?: UsageCost;
     willContinue?: boolean;
 } | {
     type: "context_recovered";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -9,6 +9,18 @@
   "bin": {
     "bubble": "dist/bin.js"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/sdk/index.d.ts",
+      "default": "./dist/sdk/index.js"
+    },
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "default": "./dist/sdk/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "!dist/**/__tests__/**",
@@ -18,6 +30,8 @@
   "scripts": {
     "build": "rm -rf dist && tsc && chmod +x dist/bin.js dist/main.js",
     "dev": "tsc && bun dist/main.js",
+    "refresh-models": "NODE_USE_ENV_PROXY=1 node scripts/generate-model-data.mjs",
+    "eval": "bun evals/run.ts",
     "prepack": "npm run build",
     "start": "bun dist/main.js",
     "test": "vitest run",
@@ -31,7 +45,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/react": "^19.2.14",
     "@vue/language-server": "^3.2.7",
-    "better-sqlite3": "^12.9.0",
+    "better-sqlite3": "^13.0.1",
     "chalk": "^5.3.0",
     "diff": "^9.0.0",
     "ink": "^7.0.3",

package/dist/agent/discovery-barrier.d.ts

@@ -1,21 +0,0 @@
-import type { ContentPart, ParsedToolCall, ToolResult, ToolResultMetadata } from "../types.js";
-export interface DiscoveryBarrierOptions {
-    cwd: string;
-    input: string | ContentPart[];
-    enabled: boolean;
-}
-export declare class DiscoveryBarrier {
-    private readonly cwd;
-    private readonly enabled;
-    private readonly knownPaths;
-    private readonly userMentionedPaths;
-    constructor(options: DiscoveryBarrierOptions);
-    isEnabled(): boolean;
-    shouldBufferStreamingToolCall(name: string): boolean;
-    orderToolCalls<T extends ParsedToolCall>(toolCalls: T[]): T[];
-    beforeToolCall(toolCall: ParsedToolCall): ToolResult | undefined;
-    afterToolCall(toolCall: ParsedToolCall, result: ToolResult): void;
-    observeMetadata(metadata: ToolResultMetadata | undefined): void;
-}
-export declare function isHiddenToolResult(result: ToolResult | undefined): result is ToolResult;
-export declare function isHiddenToolMetadata(metadata: ToolResultMetadata | undefined): boolean;

package/dist/agent/discovery-barrier.js

@@ -1,173 +0,0 @@
-import { existsSync, realpathSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { analyzeToolIntent } from "./tool-intent.js";
-import { resolveToolPath } from "../tools/path-utils.js";
-export class DiscoveryBarrier {
-    cwd;
-    enabled;
-    knownPaths = new Set();
-    userMentionedPaths = new Set();
-    constructor(options) {
-        this.cwd = options.cwd;
-        this.enabled = options.enabled;
-        for (const path of extractUserMentionedPaths(options.input)) {
-            this.userMentionedPaths.add(canonicalPath(this.cwd, path));
-        }
-    }
-    isEnabled() {
-        return this.enabled;
-    }
-    shouldBufferStreamingToolCall(name) {
-        return this.enabled && (name === "read" || name === "bash" || name === "lsp");
-    }
-    orderToolCalls(toolCalls) {
-        if (!this.enabled || toolCalls.length < 2)
-            return toolCalls;
-        const discovery = [];
-        const rest = [];
-        for (const toolCall of toolCalls) {
-            if (isDiscoveryToolCall(toolCall))
-                discovery.push(toolCall);
-            else
-                rest.push(toolCall);
-        }
-        if (discovery.length === 0 || rest.length === 0)
-            return toolCalls;
-        return [...discovery, ...rest];
-    }
-    beforeToolCall(toolCall) {
-        if (!this.enabled)
-            return undefined;
-        const target = pathSensitiveReadTarget(toolCall);
-        if (!target)
-            return undefined;
-        const canonical = canonicalPath(this.cwd, target.path);
-        if (this.knownPaths.has(canonical) || this.userMentionedPaths.has(canonical))
-            return undefined;
-        return {
-            content: `Blocked speculative ${target.kind}. The path "${target.path}" has not been discovered in this repository context ` +
-                "and was not explicitly requested by the user. Run glob/grep discovery first, then read only returned paths. " +
-                "Do not infer from this blocked call whether the path exists.",
-            isError: true,
-            status: "blocked",
-            metadata: {
-                kind: "internal",
-                reason: "speculative_read_blocked",
-                hiddenFromTranscript: true,
-                path: canonical,
-                requestedPath: target.path,
-                toolName: toolCall.name,
-            },
-        };
-    }
-    afterToolCall(toolCall, result) {
-        if (!this.enabled || result.metadata?.hiddenFromTranscript === true)
-            return;
-        this.observeMetadata(result.metadata);
-        if (isSuccessfulAccessResult(result)) {
-            const target = pathSensitiveReadTarget(toolCall);
-            if (target)
-                this.knownPaths.add(canonicalPath(this.cwd, target.path));
-        }
-    }
-    observeMetadata(metadata) {
-        if (!metadata)
-            return;
-        for (const path of metadataPaths(metadata)) {
-            this.knownPaths.add(canonicalPath(this.cwd, path));
-        }
-    }
-}
-export function isHiddenToolResult(result) {
-    return result?.metadata?.hiddenFromTranscript === true;
-}
-export function isHiddenToolMetadata(metadata) {
-    return metadata?.hiddenFromTranscript === true;
-}
-function isDiscoveryToolCall(toolCall) {
-    if (toolCall.name === "glob" || toolCall.name === "grep")
-        return true;
-    return analyzeToolIntent(toolCall).family === "search";
-}
-function pathSensitiveReadTarget(toolCall) {
-    if (toolCall.name === "read") {
-        const path = stringArg(toolCall.parsedArgs.path ?? toolCall.parsedArgs.file);
-        return path ? { kind: "read", path } : undefined;
-    }
-    if (toolCall.name === "bash") {
-        const intent = analyzeToolIntent(toolCall);
-        const path = intent.read?.path;
-        return path ? { kind: "bash read", path } : undefined;
-    }
-    if (toolCall.name === "lsp") {
-        const path = stringArg(toolCall.parsedArgs.filePath);
-        return path ? { kind: "lsp", path } : undefined;
-    }
-    return undefined;
-}
-function metadataPaths(metadata) {
-    const paths = new Set();
-    addPathValue(paths, metadata.path);
-    addPathValue(paths, metadata.paths);
-    return [...paths];
-}
-function addPathValue(out, value) {
-    if (typeof value === "string" && value.trim()) {
-        out.add(value);
-        return;
-    }
-    if (!Array.isArray(value))
-        return;
-    for (const item of value) {
-        if (typeof item === "string" && item.trim())
-            out.add(item);
-    }
-}
-function isSuccessfulAccessResult(result) {
-    return !result.isError
-        && result.status !== "blocked"
-        && result.status !== "cancelled"
-        && result.status !== "command_error"
-        && result.status !== "timeout";
-}
-function canonicalPath(cwd, value) {
-    const absolute = resolveToolPath(cwd, value);
-    try {
-        if (existsSync(absolute))
-            return realpathSync.native(absolute);
-    }
-    catch {
-        // Fall back to lexical resolution for unreadable or racing paths.
-    }
-    return resolve(absolute);
-}
-function extractUserMentionedPaths(input) {
-    const text = typeof input === "string"
-        ? input
-        : input
-            .filter((part) => part.type === "text")
-            .map((part) => part.text)
-            .join("\n");
-    const paths = new Set();
-    const regex = /(?:^|[\s`'"])(~?\.{0,2}\/[^\s`'"]+|[\w@.-]+\.[A-Za-z0-9][\w.-]*)(?=$|[\s`'",.;:!?，。；：！？）)])/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        const value = match[1]?.trim();
-        if (value && isLikelyFilePath(value))
-            paths.add(stripTrailingPunctuation(value));
-    }
-    return [...paths];
-}
-function isLikelyFilePath(value) {
-    const stripped = stripTrailingPunctuation(value);
-    if (stripped.startsWith("./") || stripped.startsWith("../") || stripped.startsWith("~/") || stripped.startsWith("/")) {
-        return true;
-    }
-    return /\.[A-Za-z0-9][\w.-]*$/.test(basename(stripped));
-}
-function stripTrailingPunctuation(value) {
-    return value.replace(/[.,;:!?，。；：！？）)]+$/u, "");
-}
-function stringArg(value) {
-    return typeof value === "string" ? value.trim() : "";
-}

package/dist/agent/evidence-tracker.d.ts

@@ -1,15 +0,0 @@
-import type { ParsedToolCall, ToolResult } from "../types.js";
-export interface InvestigationCoverage {
-    configLoadPaths: boolean;
-    envReads: boolean;
-    persistencePaths: boolean;
-    exposurePaths: boolean;
-    maskingSignals: boolean;
-}
-export declare class EvidenceTracker {
-    private coverage;
-    observe(toolCall: Pick<ParsedToolCall, "name" | "parsedArgs">, result: ToolResult): void;
-    snapshot(): InvestigationCoverage;
-    key(): string;
-    isCoreCoverageComplete(): boolean;
-}

package/dist/agent/evidence-tracker.js

@@ -1,93 +0,0 @@
-const DEFAULT_COVERAGE = {
-    configLoadPaths: false,
-    envReads: false,
-    persistencePaths: false,
-    exposurePaths: false,
-    maskingSignals: false,
-};
-const CONFIG_PATTERNS = [
-    /\bconfig\.(json|ya?ml|toml|ini)\b/i,
-    /\bsettings\.(json|ya?ml|toml)\b/i,
-    /\bauth\.json\b/i,
-    /\buserconfig\b/i,
-    /\breadfilesync\b/i,
-];
-const ENV_PATTERNS = [
-    /\bprocess\.env\b/i,
-    /\bimport\.meta\.env\b/i,
-    /\bgetenv\(/i,
-    /\bloadenv\b/i,
-    /\bdotenv\b/i,
-    /\b\.env\b/i,
-];
-const PERSISTENCE_PATTERNS = [
-    /\bwritefilesync\b/i,
-    /\bwritefile\b/i,
-    /\bauth\.json\b/i,
-    /\bconfig\.json\b/i,
-    /\blocalstorage\b/i,
-    /\bsqlite\b/i,
-    /\bkeychain\b/i,
-    /\bcredential\b/i,
-    /\bstore\b/i,
-];
-const EXPOSURE_PATTERNS = [
-    /\bconsole\.log\b/i,
-    /\blogger\./i,
-    /\bres\.json\b/i,
-    /\breturn\s+\{/i,
-    /\bwindow\./i,
-    /\bdocument\./i,
-    /\bserialize\b/i,
-    /\bresponse\b/i,
-];
-const MASKING_PATTERNS = [
-    /\bmask(key|ed)?\b/i,
-    /\bredact(ed|ion)?\b/i,
-    /\bhidden\b/i,
-    /\bobfuscated\b/i,
-    /\*\*\*\*/i,
-    /\.\.\./i,
-];
-export class EvidenceTracker {
-    coverage = { ...DEFAULT_COVERAGE };
-    observe(toolCall, result) {
-        const haystack = [
-            typeof toolCall.parsedArgs.path === "string" ? toolCall.parsedArgs.path : "",
-            typeof toolCall.parsedArgs.command === "string" ? toolCall.parsedArgs.command : "",
-            typeof toolCall.parsedArgs.pattern === "string" ? toolCall.parsedArgs.pattern : "",
-            result.content,
-        ].join("\n");
-        if (!this.coverage.configLoadPaths && matchesAny(CONFIG_PATTERNS, haystack)) {
-            this.coverage.configLoadPaths = true;
-        }
-        if (!this.coverage.envReads && matchesAny(ENV_PATTERNS, haystack)) {
-            this.coverage.envReads = true;
-        }
-        if (!this.coverage.persistencePaths && matchesAny(PERSISTENCE_PATTERNS, haystack)) {
-            this.coverage.persistencePaths = true;
-        }
-        if (!this.coverage.exposurePaths && matchesAny(EXPOSURE_PATTERNS, haystack)) {
-            this.coverage.exposurePaths = true;
-        }
-        if (!this.coverage.maskingSignals && matchesAny(MASKING_PATTERNS, haystack)) {
-            this.coverage.maskingSignals = true;
-        }
-    }
-    snapshot() {
-        return { ...this.coverage };
-    }
-    key() {
-        const coverage = this.snapshot();
-        return Object.values(coverage).map((value) => (value ? "1" : "0")).join("");
-    }
-    isCoreCoverageComplete() {
-        return this.coverage.configLoadPaths
-            && this.coverage.envReads
-            && this.coverage.persistencePaths
-            && this.coverage.exposurePaths;
-    }
-}
-function matchesAny(patterns, haystack) {
-    return patterns.some((pattern) => pattern.test(haystack));
-}

package/dist/agent/execution-governor.d.ts

@@ -1,36 +0,0 @@
-import type { ParsedToolCall, ToolRegistryEntry, ToolResult } from "../types.js";
-import type { TaskType } from "./task-classifier.js";
-export interface GovernorDecision {
-    blockedResult?: ToolResult;
-}
-export declare class ExecutionGovernor {
-    private budget;
-    private history;
-    private totalSteps;
-    private searchSteps;
-    private readSteps;
-    private mutationVersion;
-    private reminderQueue;
-    private warnedFamilies;
-    private warnedSignatures;
-    private softTotalWarned;
-    private softSearchWarned;
-    private softReadWarned;
-    constructor(taskType: TaskType);
-    consumePendingReminders(): string[];
-    snapshot(): {
-        totalSteps: number;
-        searchSteps: number;
-        readSteps: number;
-        searchFrozen: boolean;
-        explorationFrozen: boolean;
-        phase: "observe";
-    };
-    filterToolDefinitions(toolDefinitions: ToolRegistryEntry[]): ToolRegistryEntry[];
-    beforeToolCall(toolCall: ParsedToolCall): GovernorDecision;
-    afterToolResult(toolCall: ParsedToolCall, result: ToolResult): void;
-    private trailingNoProgressCount;
-    private hasCurrentMutationObservation;
-    private warnOnce;
-    private maybeWarnOnSoftBudgets;
-}