@bubblebrain-ai/bubble 0.0.15 → 0.0.16

package/README.md

@@ -62,6 +62,30 @@ Bubble stores user configuration, sessions, permissions, skills, and memory unde
 
 In the app, use `/login` or provider commands to configure model access.
 
+### ChatGPT Network Configuration
+
+ChatGPT OAuth and GPT/Codex requests respect standard proxy variables:
+
+```bash
+export HTTPS_PROXY=http://proxy.example.com:8080
+export HTTP_PROXY=http://proxy.example.com:8080
+export NO_PROXY=localhost,127.0.0.1
+```
+
+If your network uses a corporate or custom HTTPS CA, start Bubble with:
+
+```bash
+NODE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+```
+
+You can also use `BUBBLE_EXTRA_CA_CERTS` for Bubble's ChatGPT requests:
+
+```bash
+BUBBLE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+```
+
+Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+
 ## Memory
 
 Bubble maintains persistent memory automatically from prior sessions. Useful commands:

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,173 @@
+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/lsp 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/internal-reminder-sanitizer.d.ts

@@ -0,0 +1,7 @@
+export declare function formatInternalReminderBlock(kind: string, content: string): string;
+export declare function formatInternalContextBlock(kind: string, content: string): string;
+export declare function sanitizeInternalReminderBlocks(text: string): string;
+export declare function createStreamingInternalReminderSanitizer(): {
+    push(delta: string): string;
+    flush(): string;
+};

package/dist/agent/internal-reminder-sanitizer.js

@@ -0,0 +1,171 @@
+const INTERNAL_TAG_PREFIX = "<bubble_internal_";
+const INTERNAL_TAG_NAMES = ["reminder", "context"];
+const LEGACY_RUNTIME_MARKERS = [
+    "Runtime reminder:\n",
+    "Runtime context:\n",
+];
+const STREAM_MARKERS = [
+    INTERNAL_TAG_PREFIX,
+    ...LEGACY_RUNTIME_MARKERS,
+];
+const LEGACY_REMINDER_END_PHRASES = [
+    "Debugging workflow: find the failing boundary.",
+    "Code explanation workflow: answer directly.",
+    "Verify the specific failure path after the change.",
+    "Run a narrow verification command or explain why it cannot be run.",
+    "Keep summaries secondary to findings.",
+    "Avoid proposing changes unless the user asks for them.",
+    "Keep the first pass read-only unless the user asks for changes or runtime verification.",
+    "Avoid drifting into code changes unless the user explicitly asks to execute.",
+    "On rejection, remain in plan mode and iterate.",
+    "Do not perform destructive operations, credential exposure, or unrelated reversions just because approvals are bypassed.",
+    "Execute the requested change end to end; do not stop at analysis unless blocked or the user explicitly asks for discussion only.",
+    "If current evidence is sufficient, summarize your findings now.",
+    "- If you cannot determine the cause, ask the user for clarification.",
+    "- Skip the \"investigate the codebase\" step that applies to larger changes.",
+    "Do not put the final answer only in hidden reasoning.",
+];
+export function formatInternalReminderBlock(kind, content) {
+    return formatInternalBlock("reminder", kind, content);
+}
+export function formatInternalContextBlock(kind, content) {
+    return formatInternalBlock("context", kind, content);
+}
+export function sanitizeInternalReminderBlocks(text) {
+    if (!text)
+        return text;
+    const sanitizer = createStreamingInternalReminderSanitizer();
+    return sanitizer.push(text) + sanitizer.flush();
+}
+export function createStreamingInternalReminderSanitizer() {
+    let pending = "";
+    const drain = (final) => {
+        let out = "";
+        while (pending.length > 0) {
+            const block = consumeInternalBlockAtStart(pending, final);
+            if (block?.hold)
+                break;
+            if (block?.consume !== undefined) {
+                pending = pending.slice(block.consume);
+                continue;
+            }
+            const markerIndex = findEarliestCompleteMarker(pending);
+            if (markerIndex >= 0) {
+                if (markerIndex > 0) {
+                    out += pending.slice(0, markerIndex);
+                    pending = pending.slice(markerIndex);
+                    continue;
+                }
+                // A marker is present but the block is not yet complete enough to
+                // consume. Hold it in streaming mode; drop it on final flush.
+                if (final) {
+                    pending = "";
+                }
+                break;
+            }
+            if (!final) {
+                const partialIndex = findEarliestMarkerPrefixSuffix(pending);
+                if (partialIndex >= 0) {
+                    out += pending.slice(0, partialIndex);
+                    pending = pending.slice(partialIndex);
+                    break;
+                }
+            }
+            out += pending;
+            pending = "";
+        }
+        return out;
+    };
+    return {
+        push(delta) {
+            if (!delta)
+                return "";
+            pending += delta;
+            return drain(false);
+        },
+        flush() {
+            return drain(true);
+        },
+    };
+}
+function formatInternalBlock(type, kind, content) {
+    const safeKind = kind.replace(/[^a-zA-Z0-9_-]/g, "-");
+    return `<bubble_internal_${type} kind="${safeKind}">\n${content}\n</bubble_internal_${type}>`;
+}
+function consumeInternalBlockAtStart(text, final) {
+    if (text.startsWith(INTERNAL_TAG_PREFIX)) {
+        return consumeStructuredInternalBlock(text, final);
+    }
+    if (text.startsWith("Runtime reminder:\n")) {
+        return consumeLegacyRuntimeReminder(text, final);
+    }
+    if (text.startsWith("Runtime context:\n")) {
+        return final ? { consume: text.length } : { hold: true };
+    }
+    return undefined;
+}
+function consumeStructuredInternalBlock(text, final) {
+    for (const tagName of INTERNAL_TAG_NAMES) {
+        const openMatch = text.match(new RegExp(`^<bubble_internal_${tagName}\\b[^>]*>`));
+        if (!openMatch)
+            continue;
+        const closeTag = `</bubble_internal_${tagName}>`;
+        const closeIndex = text.indexOf(closeTag, openMatch[0].length);
+        if (closeIndex < 0) {
+            return final ? { consume: text.length } : { hold: true };
+        }
+        return { consume: consumeTrailingLineBreaks(text, closeIndex + closeTag.length) };
+    }
+    if (isPrefixOf(INTERNAL_TAG_PREFIX, text)) {
+        return final ? { consume: text.length } : { hold: true };
+    }
+    return undefined;
+}
+function consumeLegacyRuntimeReminder(text, final) {
+    for (const phrase of LEGACY_REMINDER_END_PHRASES) {
+        const endIndex = text.indexOf(phrase, LEGACY_RUNTIME_MARKERS[0].length);
+        if (endIndex >= 0) {
+            return { consume: consumeTrailingLineBreaks(text, endIndex + phrase.length) };
+        }
+    }
+    if (final) {
+        return { consume: text.length };
+    }
+    return { hold: true };
+}
+function consumeTrailingLineBreaks(text, index) {
+    let next = index;
+    while (text[next] === "\n")
+        next += 1;
+    return next;
+}
+function findEarliestCompleteMarker(text) {
+    let earliest = -1;
+    for (const marker of STREAM_MARKERS) {
+        const index = text.indexOf(marker);
+        if (index >= 0 && (earliest < 0 || index < earliest)) {
+            earliest = index;
+        }
+    }
+    return earliest;
+}
+function findEarliestMarkerPrefixSuffix(text) {
+    let earliest = -1;
+    for (const marker of STREAM_MARKERS) {
+        const max = Math.min(marker.length - 1, text.length);
+        for (let length = max; length > 0; length -= 1) {
+            const suffix = text.slice(text.length - length);
+            if (isPrefixOf(marker, suffix)) {
+                const index = text.length - length;
+                if (earliest < 0 || index < earliest) {
+                    earliest = index;
+                }
+                break;
+            }
+        }
+    }
+    return earliest;
+}
+function isPrefixOf(value, possiblePrefix) {
+    return value.startsWith(possiblePrefix);
+}

package/dist/agent/task-classifier.js

@@ -49,9 +49,17 @@ const EXPLANATION_PATTERNS = [
 ];
 const ORIENTATION_PATTERNS = [
     /\bwhat is this project\b/i,
+    /\bwhat is this (repo|repository)\b/i,
     /\borient/i,
     /\boverview\b/i,
-    /这个项目.*(干嘛|做什么)|看下这个项目|项目.*概览/i,
+    /\b(repo|repository|project) overview\b/i,
+    /这个项目.*(干嘛|做什么)|这项目.*(干嘛|做什么)|这个\s*repo.*(干嘛|做什么)|看下(这个|这)?项目|项目.*概览|快速了解.*项目/i,
+];
+const CONCRETE_ORIENTATION_EXCLUSIONS = [
+    /项目[中里内]\s*[,，]?\s*\S{2,}/i,
+    /帮我.*(实现|开发|改|加|调整|优化|修复)/i,
+    /(实现|开发|改一下|加一个|调整|优化|修复|支持|报错|失败|不对|有问题|bug|commit|push)/i,
+    /(?:\.[a-z][\w-]*|\b[A-Z]{2,}\b)/,
 ];
 const PRODUCT_PATTERNS = [
     /\bproduct\b/i,
@@ -77,15 +85,15 @@ export function classifyTask(input) {
     if (DEBUG_PATTERNS.some((pattern) => pattern.test(text))) {
         return "debugging";
     }
-    if (ORIENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+    if (IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "implementation";
+    }
+    if (isLikelyRepoOrientation(text)) {
         return "repo_orientation";
     }
     if (EXPLANATION_PATTERNS.some((pattern) => pattern.test(text))) {
         return "code_explanation";
     }
-    if (IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
-        return "implementation";
-    }
     if (PRODUCT_PATTERNS.some((pattern) => pattern.test(text))) {
         return "product_discussion";
     }
@@ -94,3 +102,13 @@ export function classifyTask(input) {
     }
     return "general";
 }
+function isLikelyRepoOrientation(text) {
+    const normalized = text.trim().replace(/\s+/g, " ");
+    if (!ORIENTATION_PATTERNS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    if (CONCRETE_ORIENTATION_EXCLUSIONS.some((pattern) => pattern.test(normalized))) {
+        return false;
+    }
+    return normalized.length <= 80;
+}

package/dist/agent.js

@@ -19,6 +19,8 @@ import { getSubtaskPolicy } from "./agent/subtask-policy.js";
 import { composeAbortSignals } from "./agent/budget-ledger.js";
 import { assignAgentNickname, builtinAgentProfiles, mergeUsage, selectToolsForAgentProfile, validateAgentProfileTools } from "./agent/profiles.js";
 import { snapshotSubagentThread, subagentResultFromThread } from "./agent/subagent-control.js";
+import { isHiddenToolResult } from "./agent/discovery-barrier.js";
+import { createStreamingInternalReminderSanitizer, sanitizeInternalReminderBlocks } from "./agent/internal-reminder-sanitizer.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { isOnlyProviderProtocolArtifacts, stripProviderProtocolArtifacts } from "./provider-artifacts.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
@@ -374,6 +376,7 @@ export class Agent {
                     modelId: this.apiModel,
                 };
                 const streamingToolCalls = new Map();
+                const reasoningSanitizer = createStreamingInternalReminderSanitizer();
                 let turnUsage;
                 let assistantAppended = false;
                 currentAssistantMsg = assistantMsg;
@@ -410,6 +413,8 @@ export class Agent {
                 // budget. If it fails (network error, etc.), the projector's existing
                 // algorithmic fallback still kicks in.
                 await this.maybeCompactWithLLM();
+                const bufferedStreamingToolCallIds = new Set();
+                const discoveryBarrier = hookState.discoveryBarrier;
                 try {
                     const projectedMessages = projectMessages(this.messages, {
                         mode: "budgeted",
@@ -445,23 +450,34 @@ export class Agent {
                                 yield emit({ type: "text_delta", content: chunk.content });
                                 break;
                             case "reasoning_delta":
-                                debugReasoningStream({
-                                    stage: "agent_receive",
-                                    providerId: this._providerId,
-                                    modelId: this.apiModel,
-                                    turnStep: step,
-                                    beforeLength: assistantMsg.reasoning?.length ?? 0,
-                                    delta: summarizeDebugText(chunk.content),
-                                    afterLength: (assistantMsg.reasoning?.length ?? 0) + chunk.content.length,
-                                });
-                                assistantMsg.reasoning = (assistantMsg.reasoning || "") + chunk.content;
-                                streamReasoningChars += chunk.content.length;
-                                yield emit({ type: "reasoning_delta", content: chunk.content });
+                                {
+                                    const sanitizedDelta = reasoningSanitizer.push(chunk.content);
+                                    if (sanitizedDelta) {
+                                        debugReasoningStream({
+                                            stage: "agent_receive",
+                                            providerId: this._providerId,
+                                            modelId: this.apiModel,
+                                            turnStep: step,
+                                            beforeLength: assistantMsg.reasoning?.length ?? 0,
+                                            delta: summarizeDebugText(sanitizedDelta),
+                                            afterLength: (assistantMsg.reasoning?.length ?? 0) + sanitizedDelta.length,
+                                        });
+                                        assistantMsg.reasoning = (assistantMsg.reasoning || "") + sanitizedDelta;
+                                        streamReasoningChars += sanitizedDelta.length;
+                                        yield emit({ type: "reasoning_delta", content: sanitizedDelta });
+                                    }
+                                }
                                 break;
                             case "tool_call":
+                                if (discoveryBarrier?.isEnabled()
+                                    && (bufferedStreamingToolCallIds.has(chunk.id) || discoveryBarrier.shouldBufferStreamingToolCall(chunk.name))) {
+                                    bufferedStreamingToolCallIds.add(chunk.id);
+                                }
                                 if (chunk.isStart) {
                                     streamingToolCalls.set(chunk.id, { id: chunk.id, name: chunk.name, args: "" });
-                                    yield emit({ type: "tool_call_start", id: chunk.id, name: chunk.name });
+                                    if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                        yield emit({ type: "tool_call_start", id: chunk.id, name: chunk.name });
+                                    }
                                 }
                                 if (!streamingToolCalls.has(chunk.id)) {
                                     streamingToolCalls.set(chunk.id, { id: chunk.id, name: chunk.name, args: "" });
@@ -478,13 +494,15 @@ export class Agent {
                                     }
                                     if (chunk.arguments) {
                                         streamToolCallDeltas += 1;
-                                        yield emit({
-                                            type: "tool_call_delta",
-                                            id: currentToolCall.id,
-                                            name: currentToolCall.name,
-                                            argumentsDelta: chunk.arguments,
-                                            arguments: currentToolCall.args,
-                                        });
+                                        if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                            yield emit({
+                                                type: "tool_call_delta",
+                                                id: currentToolCall.id,
+                                                name: currentToolCall.name,
+                                                argumentsDelta: chunk.arguments,
+                                                arguments: currentToolCall.args,
+                                            });
+                                        }
                                     }
                                 }
                                 if (chunk.isEnd && currentToolCall) {
@@ -494,12 +512,14 @@ export class Agent {
                                         arguments: currentToolCall.args,
                                         ...(currentToolCall.argsCorrupt ? { argsCorrupt: true } : {}),
                                     });
-                                    yield emit({
-                                        type: "tool_call_end",
-                                        id: currentToolCall.id,
-                                        name: currentToolCall.name,
-                                        arguments: currentToolCall.args,
-                                    });
+                                    if (!bufferedStreamingToolCallIds.has(chunk.id)) {
+                                        yield emit({
+                                            type: "tool_call_end",
+                                            id: currentToolCall.id,
+                                            name: currentToolCall.name,
+                                            arguments: currentToolCall.args,
+                                        });
+                                    }
                                     streamingToolCalls.delete(chunk.id);
                                 }
                                 break;
@@ -520,6 +540,21 @@ export class Agent {
                         for (const update of this.drainSubagentToolUpdates())
                             yield emit(update);
                     }
+                    const flushedReasoning = reasoningSanitizer.flush();
+                    if (flushedReasoning) {
+                        debugReasoningStream({
+                            stage: "agent_receive_flush",
+                            providerId: this._providerId,
+                            modelId: this.apiModel,
+                            turnStep: step,
+                            beforeLength: assistantMsg.reasoning?.length ?? 0,
+                            delta: summarizeDebugText(flushedReasoning),
+                            afterLength: (assistantMsg.reasoning?.length ?? 0) + flushedReasoning.length,
+                        });
+                        assistantMsg.reasoning = (assistantMsg.reasoning || "") + flushedReasoning;
+                        streamReasoningChars += flushedReasoning.length;
+                        yield emit({ type: "reasoning_delta", content: flushedReasoning });
+                    }
                     traceEvent("provider_stream_end", {
                         elapsedMs: Date.now() - providerStartedAt,
                         textChars: streamTextChars,
@@ -590,6 +625,16 @@ export class Agent {
                             parsedCalls.push({ ...tc, parsedArgs: {}, argsCorrupt: true });
                         }
                     }
+                    const orderedCalls = hookState.discoveryBarrier?.orderToolCalls(parsedCalls) ?? parsedCalls;
+                    if (orderedCalls !== parsedCalls) {
+                        parsedCalls.splice(0, parsedCalls.length, ...orderedCalls);
+                        assistantMsg.toolCalls = parsedCalls.map((tc) => ({
+                            id: tc.id,
+                            name: tc.name,
+                            arguments: tc.arguments,
+                            ...(tc.argsCorrupt ? { argsCorrupt: true } : {}),
+                        }));
+                    }
                     const executedResults = [];
                     const appendCancelledToolMessages = (startIndex) => {
                         for (let pendingIndex = startIndex; pendingIndex < parsedCalls.length; pendingIndex++) {
@@ -634,6 +679,51 @@ export class Agent {
                             arguments: tc.arguments,
                         };
                         flushGovernorReminders();
+                        if (bufferedStreamingToolCallIds.has(tc.id) && !isHiddenToolResult(blockedResult)) {
+                            yield emit({ type: "tool_call_start", id: tc.id, name: tc.name });
+                            if (tc.arguments) {
+                                yield emit({
+                                    type: "tool_call_delta",
+                                    id: tc.id,
+                                    name: tc.name,
+                                    argumentsDelta: tc.arguments,
+                                    arguments: tc.arguments,
+                                });
+                            }
+                            yield emit({ type: "tool_call_end", id: tc.id, name: tc.name, arguments: tc.arguments });
+                        }
+                        if (isHiddenToolResult(blockedResult)) {
+                            let result = blockedResult;
+                            await hookBus.runAfterToolCall({
+                                agent: this,
+                                cwd,
+                                input: userInput,
+                                state: hookState,
+                                queueReminder,
+                                flushReminders: flushGovernorReminders,
+                                toolCall: tc,
+                                result,
+                                replaceResult: (next) => {
+                                    result = next;
+                                },
+                            });
+                            traceEvent("speculative_read_blocked", {
+                                id: tc.id,
+                                name: tc.name,
+                                args: summarizeTraceValue(tc.parsedArgs),
+                                result: summarizeTraceToolResult(result),
+                            }, traceContext);
+                            this.appendMessage({
+                                role: "tool",
+                                toolCallId: tc.id,
+                                content: result.content,
+                                metadata: result.metadata,
+                                isError: result.isError,
+                            });
+                            executedResults.push(result);
+                            flushGovernorReminders();
+                            continue;
+                        }
                         const toolStartedAt = Date.now();
                         traceEvent("tool_execute_start", {
                             id: tc.id,
@@ -1435,6 +1525,9 @@ export class Agent {
         }
     }
     appendMessage(message) {
+        if (message.role === "assistant" && message.reasoning) {
+            message.reasoning = sanitizeInternalReminderBlocks(message.reasoning);
+        }
         this.messages.push(message);
         traceEvent("agent_message_append", {
             message: summarizeTraceMessage(message),