@evalops/maestro 0.10.18 → 0.10.20

package/dist/agent/transport.js

@@ -44,6 +44,10 @@
  *
  * @module agent/transport
  */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
 import { isContextFirewallBlockingEnabled } from "../config/env-vars.js";
 import { createToolHookService } from "../hooks/index.js";
 import { getProviderNetworkConfig } from "../providers/network-config.js";
@@ -58,16 +62,471 @@ import { createSafetyMiddleware, } from "../safety/safety-middleware.js";
 import { SemanticJudge } from "../safety/semantic-judge.js";
 import { WorkflowStateError, WorkflowStateTracker, applyWorkflowStateHooks, isWorkflowTrackedTool, } from "../safety/workflow-state.js";
 import { getSkillArtifactMetadataFromDetails, } from "../skills/artifact-metadata.js";
-import { getOptimalConcurrency } from "../tools/parallel-execution.js";
+import { getPathScopedMutation, isParallelSafeTool, isReadOnlyTool, pathScopesOverlap, } from "../tools/parallel-execution.js";
 import { trackUsage } from "../tracking/cost-tracker.js";
 import { getTrainingHeaders } from "../training.js";
 import { getStoredCredentials } from "./keys.js";
 import { createProviderStream } from "./transport/create-provider-stream.js";
-import { getDefaultPlatformToolExecutionBridge, } from "./transport/tool-execution-bridge.js";
+import { stableStringify } from "./transport/stable-stringify.js";
+import { buildObservedResultMetadata, getDefaultPlatformToolExecutionBridge, } from "./transport/tool-execution-bridge.js";
 import { createToolExecutionPromise } from "./transport/tool-execution.js";
 import { evaluateToolSafety, } from "./transport/tool-safety-pipeline.js";
 import { createToolUpdateQueue, waitForNextExecutionOrUpdate, } from "./transport/tool-update-queue.js";
 import { calculateCost, resolveEnvCredential, } from "./transport/transport-utils.js";
+function hashReusableToolResultSnapshot(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function readGitSnapshotBuffer(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1_000,
+    });
+}
+function readGitSnapshotPart(cwd, args) {
+    return readGitSnapshotBuffer(cwd, args).toString("utf8").trim();
+}
+function hashGitSnapshotPart(cwd, args) {
+    return hashReusableToolResultSnapshot(readGitSnapshotBuffer(cwd, args));
+}
+function hashUntrackedGitFiles(root) {
+    const files = readGitSnapshotBuffer(root, [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "-z",
+    ])
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean)
+        .sort();
+    const hash = createHash("sha256");
+    for (const file of files) {
+        hash.update(file);
+        hash.update("\0");
+        hash.update(readFileSync(resolvePath(root, file)));
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}
+function hasDirtyGitSubmodules(root) {
+    try {
+        return (readGitSnapshotPart(root, [
+            "submodule",
+            "foreach",
+            "--recursive",
+            "--quiet",
+            "git status --porcelain=v1 --untracked-files=all",
+        ]).length > 0);
+    }
+    catch {
+        return true;
+    }
+}
+function computeReusableToolResultSnapshot(cwd) {
+    try {
+        const root = readGitSnapshotPart(cwd, ["rev-parse", "--show-toplevel"]);
+        const head = readGitSnapshotPart(cwd, ["rev-parse", "--verify", "HEAD"]);
+        const status = readGitSnapshotPart(root, [
+            "status",
+            "--porcelain=v1",
+            "--untracked-files=all",
+        ]);
+        if (hasDirtyGitSubmodules(root)) {
+            return undefined;
+        }
+        const unstagedDiff = hashGitSnapshotPart(root, [
+            "diff",
+            "--no-ext-diff",
+            "--binary",
+        ]);
+        const stagedDiff = hashGitSnapshotPart(root, [
+            "diff",
+            "--cached",
+            "--no-ext-diff",
+            "--binary",
+        ]);
+        const untracked = hashUntrackedGitFiles(root);
+        return `git:${hashReusableToolResultSnapshot(`${root}\n${head}\n${status}\n${unstagedDiff}\n${stagedDiff}\n${untracked}`)}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+const GIT_SNAPSHOT_REUSABLE_TOOL_NAMES = new Set([
+    "read",
+    "ls",
+    "list",
+    "glob",
+    "find",
+    "grep",
+    "search",
+    "parallel_ripgrep",
+    "diff",
+    "status",
+]);
+const REPO_PATH_ARGUMENTS_BY_TOOL = new Map([
+    ["read", ["path", "file_path"]],
+    ["ls", ["path", "dir", "directory"]],
+    ["list", ["path", "dir", "directory"]],
+    ["glob", ["path", "cwd", "root", "glob"]],
+    ["find", ["path", "cwd", "root", "glob"]],
+    ["grep", ["path", "paths", "glob"]],
+    ["search", ["path", "paths", "glob"]],
+    ["parallel_ripgrep", ["path", "paths", "glob"]],
+    ["diff", ["path", "paths", "cwd"]],
+    ["status", ["path", "paths", "cwd"]],
+]);
+const GIT_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX = "git:";
+const RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX = "run:";
+const REQUIRED_REPO_PATH_ARGUMENT_TOOLS = new Set(["read", "ls", "list"]);
+function collectStringValues(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectStringValues(item));
+    }
+    return [];
+}
+function isRepoRelativePathArgument(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    if (trimmed.startsWith("/") ||
+        trimmed.startsWith("~") ||
+        trimmed.startsWith("\\\\") ||
+        /^[A-Za-z]:[\\/]/.test(trimmed)) {
+        return false;
+    }
+    return !trimmed.split(/[\\/]+/).includes("..");
+}
+function isGitIgnoredRepoPath(cwd, repoPath) {
+    try {
+        readGitSnapshotPart(cwd, ["check-ignore", "--quiet", "--", repoPath]);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "status" in error &&
+            error.status === 1) {
+            return false;
+        }
+        return true;
+    }
+}
+function isToolCallIncludingIgnoredPaths(toolCall) {
+    const toolName = toolCall.name.toLowerCase();
+    const args = toolCall.arguments;
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        return false;
+    }
+    const record = args;
+    if (toolName === "status") {
+        return record.includeIgnored === true || record.include_ignored === true;
+    }
+    if (toolName === "search" || toolName === "parallel_ripgrep") {
+        return record.useGitIgnore === false || record.use_git_ignore === false;
+    }
+    return false;
+}
+function hasRepoScopedReusableArguments(toolCall, cwd) {
+    const toolName = toolCall.name.toLowerCase();
+    if (isToolCallIncludingIgnoredPaths(toolCall)) {
+        return false;
+    }
+    const argumentNames = REPO_PATH_ARGUMENTS_BY_TOOL.get(toolName) ?? [];
+    if (argumentNames.length === 0) {
+        return true;
+    }
+    const args = toolCall.arguments;
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        return !REQUIRED_REPO_PATH_ARGUMENT_TOOLS.has(toolName);
+    }
+    const pathValues = argumentNames.flatMap((name) => collectStringValues(args[name]));
+    if (pathValues.length === 0 &&
+        REQUIRED_REPO_PATH_ARGUMENT_TOOLS.has(toolName)) {
+        return false;
+    }
+    return pathValues.every((pathValue) => isRepoRelativePathArgument(pathValue) &&
+        !isGitIgnoredRepoPath(cwd, pathValue));
+}
+function isGitSnapshotReusableToolCall(tool, toolCall, cwd) {
+    if (tool.source !== undefined ||
+        tool.annotations?.openWorldHint === true ||
+        tool.executionLocation === "client") {
+        return false;
+    }
+    if (!GIT_SNAPSHOT_REUSABLE_TOOL_NAMES.has(tool.name.toLowerCase())) {
+        return false;
+    }
+    if (!isReadOnlyTool(tool.name, tool.annotations, tool.source)) {
+        return false;
+    }
+    return hasRepoScopedReusableArguments(toolCall, cwd);
+}
+const reusableToolDefinitionIdentities = new WeakMap();
+let reusableToolDefinitionIdentityCounter = 0;
+function getReusableToolDefinitionIdentity(value) {
+    const existing = reusableToolDefinitionIdentities.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    reusableToolDefinitionIdentityCounter += 1;
+    reusableToolDefinitionIdentities.set(value, reusableToolDefinitionIdentityCounter);
+    return reusableToolDefinitionIdentityCounter;
+}
+function getReusableToolFunctionIdentity(value) {
+    return typeof value === "function"
+        ? getReusableToolDefinitionIdentity(value)
+        : undefined;
+}
+function getReusableToolRegistrySignature(tools) {
+    return stableStringify(tools.map((tool) => ({
+        allowedCallers: tool.allowedCallers,
+        annotations: tool.annotations,
+        deferApiDefinition: tool.deferApiDefinition,
+        description: tool.description,
+        executeIdentity: getReusableToolFunctionIdentity(tool.execute),
+        executionLocation: tool.executionLocation,
+        getActivityDescriptionIdentity: getReusableToolFunctionIdentity(tool.getActivityDescription),
+        getDisplayNameIdentity: getReusableToolFunctionIdentity(tool.getDisplayName),
+        getToolUseSummaryIdentity: getReusableToolFunctionIdentity(tool.getToolUseSummary),
+        inputExamples: tool.inputExamples,
+        label: tool.label,
+        maxRetries: tool.maxRetries,
+        name: tool.name,
+        parameters: tool.parameters,
+        retryDelayMs: tool.retryDelayMs,
+        shouldRetryIdentity: getReusableToolFunctionIdentity(tool.shouldRetry),
+        source: tool.source,
+        toolIdentity: getReusableToolDefinitionIdentity(tool),
+        toolType: tool.toolType,
+    })));
+}
+function createToolMetadataCache(tools, reusableToolResultCwd = process.cwd()) {
+    const definitions = new Map(tools.map((tool) => [tool.name, tool]));
+    return {
+        definitions,
+        reusableToolResultCwd,
+        lookupCount: 0,
+        get(toolName) {
+            this.lookupCount += 1;
+            return definitions.get(toolName);
+        },
+    };
+}
+function getToolDefinition(lookup, toolName) {
+    if ("get" in lookup && !Array.isArray(lookup)) {
+        return lookup.get(toolName);
+    }
+    return lookup.find((candidate) => candidate.name === toolName);
+}
+function getReusableToolResultCacheKey(toolCall, tools) {
+    const tool = getToolDefinition(tools, toolCall.name);
+    const cwd = "reusableToolResultCwd" in tools
+        ? tools.reusableToolResultCwd
+        : process.cwd();
+    if (!tool || tool.annotations?.destructiveHint === true) {
+        return undefined;
+    }
+    if (!isReadOnlyTool(tool.name, tool.annotations, tool.source)) {
+        return undefined;
+    }
+    const toolName = tool.name.toLowerCase();
+    const cacheKey = `${toolCall.name}:${stableStringify(toolCall.arguments)}`;
+    if (isGitSnapshotReusableToolCall(tool, toolCall, cwd)) {
+        return `${GIT_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX}${cacheKey}`;
+    }
+    if (tool.source !== undefined ||
+        GIT_SNAPSHOT_REUSABLE_TOOL_NAMES.has(toolName) ||
+        tool.annotations?.openWorldHint === true ||
+        tool.executionLocation === "client") {
+        return undefined;
+    }
+    return `${RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX}${cacheKey}`;
+}
+function isReadOnlyToolCallForCacheInvalidation(toolCall, tools) {
+    const tool = getToolDefinition(tools, toolCall.name);
+    return tool
+        ? isReadOnlyTool(tool.name, tool.annotations, tool.source)
+        : false;
+}
+function cloneToolResultForCache(message) {
+    return {
+        ...message,
+        content: message.content.map((item) => ({ ...item })),
+    };
+}
+function cloneToolOutcomeForCall(outcome, toolCall, timestamp) {
+    return {
+        message: {
+            ...outcome.message,
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: outcome.message.content.map((item) => ({ ...item })),
+            timestamp,
+        },
+        isError: outcome.isError,
+    };
+}
+function resolvePlatformToolExecutionBridge(option) {
+    if (option === false) {
+        return undefined;
+    }
+    return option ?? getDefaultPlatformToolExecutionBridge();
+}
+async function recordReusableToolExecutionBridgeOutput({ bridge, plan, outcome, durationMs, signal, }) {
+    if (!bridge || !plan) {
+        return outcome;
+    }
+    const observed = plan.kind === "observe"
+        ? await bridge.recordObservation(plan, outcome.message, signal)
+        : undefined;
+    const governedOutput = plan.kind === "governed"
+        ? await bridge.recordGovernedOutput(plan, outcome.message, durationMs, signal)
+        : undefined;
+    return {
+        ...outcome,
+        ...buildObservedResultMetadata(plan, observed ?? governedOutput),
+    };
+}
+function hasReusableToolResultState(cacheKey, cache, pending, policyCheckedKeys, pendingSafetyChecks) {
+    return (cache.has(cacheKey) ||
+        pending.has(cacheKey) ||
+        policyCheckedKeys.has(cacheKey) ||
+        (pendingSafetyChecks.get(cacheKey) ?? 0) > 0);
+}
+function incrementPendingReusableToolSafetyCheck(cacheKey, pendingSafetyChecks) {
+    if (!cacheKey) {
+        return;
+    }
+    pendingSafetyChecks.set(cacheKey, (pendingSafetyChecks.get(cacheKey) ?? 0) + 1);
+}
+function decrementPendingReusableToolSafetyCheck(cacheKey, pendingSafetyChecks) {
+    if (!cacheKey) {
+        return;
+    }
+    const nextCount = (pendingSafetyChecks.get(cacheKey) ?? 0) - 1;
+    if (nextCount <= 0) {
+        pendingSafetyChecks.delete(cacheKey);
+        return;
+    }
+    pendingSafetyChecks.set(cacheKey, nextCount);
+}
+function clearReusableToolResultState(cache, pending, policyCheckedKeys, pendingSafetyChecks, cacheGeneration) {
+    cache.clear();
+    pending.clear();
+    policyCheckedKeys.clear();
+    pendingSafetyChecks.clear();
+    cacheGeneration.value += 1;
+}
+function clearRunScopedReusableToolResultState(cache, pending, policyCheckedKeys, pendingSafetyChecks, cacheGeneration) {
+    let cleared = false;
+    for (const key of cache.keys()) {
+        if (key.startsWith(RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX)) {
+            cache.delete(key);
+            cleared = true;
+        }
+    }
+    for (const key of pending.keys()) {
+        if (key.startsWith(RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX)) {
+            pending.delete(key);
+            cleared = true;
+        }
+    }
+    for (const key of policyCheckedKeys) {
+        if (key.startsWith(RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX)) {
+            policyCheckedKeys.delete(key);
+            cleared = true;
+        }
+    }
+    for (const key of pendingSafetyChecks.keys()) {
+        if (key.startsWith(RUN_SCOPED_REUSABLE_TOOL_RESULT_KEY_PREFIX)) {
+            pendingSafetyChecks.delete(key);
+            cleared = true;
+        }
+    }
+    if (cleared) {
+        cacheGeneration.value += 1;
+    }
+}
+function invalidateReusableToolResultsAfterMutation(toolCall, tools, cache, pending, policyCheckedKeys, pendingSafetyChecks, cacheGeneration) {
+    if (isReadOnlyToolCallForCacheInvalidation(toolCall, tools)) {
+        return;
+    }
+    clearReusableToolResultState(cache, pending, policyCheckedKeys, pendingSafetyChecks, cacheGeneration);
+}
+function hasPendingMutatingToolExecution(pendingExecutions, tools) {
+    return pendingExecutions.some((execution) => !isReadOnlyToolCallForCacheInvalidation(execution.toolCall, tools));
+}
+function trackReusableToolResult(cacheKey, executionPromise, cache, pending, policyCheckedKeys, cacheGeneration) {
+    const trackedGeneration = cacheGeneration?.value;
+    const trackedPromise = executionPromise
+        .then((outcome) => {
+        if (!outcome.isError &&
+            outcome.message.isError !== true &&
+            (cacheGeneration === undefined ||
+                cacheGeneration.value === trackedGeneration)) {
+            cache.set(cacheKey, {
+                message: cloneToolResultForCache(outcome.message),
+            });
+        }
+        else {
+            policyCheckedKeys?.delete(cacheKey);
+        }
+        return outcome;
+    })
+        .catch((error) => {
+        policyCheckedKeys?.delete(cacheKey);
+        throw error;
+    })
+        .finally(() => {
+        if (pending.get(cacheKey) === trackedPromise) {
+            pending.delete(cacheKey);
+        }
+    });
+    pending.set(cacheKey, trackedPromise);
+    return trackedPromise;
+}
+class AgentEventQueue {
+    constructor() {
+        this.events = [];
+    }
+    push(event) {
+        this.events.push(event);
+        if (this.wake) {
+            const wake = this.wake;
+            this.pending = undefined;
+            this.wake = undefined;
+            wake();
+        }
+    }
+    shift() {
+        return this.events.shift();
+    }
+    wait() {
+        if (this.events.length > 0) {
+            return Promise.resolve();
+        }
+        if (!this.pending) {
+            this.pending = new Promise((resolve) => {
+                this.wake = resolve;
+            });
+        }
+        return this.pending;
+    }
+    clearPendingWaiter() {
+        this.pending = undefined;
+        this.wake = undefined;
+    }
+}
+function isDynamicToolApprovalEvent(event) {
+    return (event.type === "action_approval_required" ||
+        event.type === "action_approval_resolved");
+}
 function getGovernedToolResultEventMetadata(details) {
     if (!details || typeof details !== "object") {
         return {};
@@ -152,6 +611,11 @@ export class ProviderTransport {
         this.toolCallsThisMinute = 0;
         /** Last minute window start time */
         this.minuteWindowStart = 0;
+        this.reusableToolResults = new Map();
+        this.pendingReusableToolResults = new Map();
+        this.policyCheckedReusableToolResultKeys = new Set();
+        this.pendingReusableToolSafetyChecks = new Map();
+        this.reusableToolResultCacheGeneration = { value: 0 };
         this.clock = options.clock ?? systemClock;
         this.sessionTokenCounter = options.sessionTokenCounter;
         this.auditLogger = options.auditLogger;
@@ -187,6 +651,23 @@ export class ProviderTransport {
             },
         });
     }
+    refreshReusableToolResultState(tools, cwd) {
+        const registrySignature = getReusableToolRegistrySignature(tools);
+        const snapshot = computeReusableToolResultSnapshot(cwd);
+        if (snapshot === undefined) {
+            clearReusableToolResultState(this.reusableToolResults, this.pendingReusableToolResults, this.policyCheckedReusableToolResultKeys, this.pendingReusableToolSafetyChecks, this.reusableToolResultCacheGeneration);
+            this.reusableToolResultSnapshot = undefined;
+            this.reusableToolRegistrySignature = registrySignature;
+            return;
+        }
+        if (this.reusableToolResultSnapshot !== snapshot ||
+            (this.reusableToolRegistrySignature !== undefined &&
+                this.reusableToolRegistrySignature !== registrySignature)) {
+            clearReusableToolResultState(this.reusableToolResults, this.pendingReusableToolResults, this.policyCheckedReusableToolResultKeys, this.pendingReusableToolSafetyChecks, this.reusableToolResultCacheGeneration);
+        }
+        this.reusableToolResultSnapshot = snapshot;
+        this.reusableToolRegistrySignature = registrySignature;
+    }
     /**
      * Continue from current context without a new user message.
      *
@@ -233,8 +714,12 @@ export class ProviderTransport {
                 })
                 : undefined);
         this.workflowState.reset();
+        const scriptedReplayRun = model.provider === "scripted-replay";
+        const codexAppServerRun = model.api === "openai-codex-app-server";
         let credential;
-        if (this.options.getAuthContext) {
+        if (this.options.getAuthContext &&
+            !scriptedReplayRun &&
+            !codexAppServerRun) {
             credential = await this.options.getAuthContext(model.provider);
         }
         if (!credential && this.options.getApiKey) {
@@ -248,6 +733,22 @@ export class ProviderTransport {
                 };
             }
         }
+        if (!credential && scriptedReplayRun) {
+            credential = {
+                provider: model.provider,
+                token: "scripted-replay",
+                type: "api-key",
+                source: "env",
+            };
+        }
+        if (!credential && codexAppServerRun) {
+            credential = {
+                provider: model.provider,
+                token: "codex-app-server",
+                type: "api-key",
+                source: "env",
+            };
+        }
         if (!credential) {
             const envCredential = resolveEnvCredential(model.provider);
             if (envCredential) {
@@ -284,6 +785,18 @@ export class ProviderTransport {
                 baseUrl: `${this.options.corsProxyUrl}/?url=${encodeURIComponent(model.baseUrl)}`,
             };
         }
+        const dynamicToolEventQueue = new AgentEventQueue();
+        const reusableToolResultCwd = this.options.cwd ?? process.cwd();
+        const toolMetadataCache = createToolMetadataCache(tools, reusableToolResultCwd);
+        this.refreshReusableToolResultState(tools, reusableToolResultCwd);
+        const reusableToolResults = this.reusableToolResults;
+        const pendingReusableToolResults = this.pendingReusableToolResults;
+        const policyCheckedReusableToolResultKeys = this.policyCheckedReusableToolResultKeys;
+        const pendingReusableToolSafetyChecks = this.pendingReusableToolSafetyChecks;
+        const reusableToolResultCacheGeneration = this.reusableToolResultCacheGeneration;
+        clearRunScopedReusableToolResultState(reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks, reusableToolResultCacheGeneration);
+        const pendingDynamicToolExecutions = [];
+        const platformToolExecutionBridge = resolvePlatformToolExecutionBridge(this.options.platformToolExecutionBridge);
         const trainingHeaders = getTrainingHeaders();
         const headers = trainingHeaders || model.headers || credential?.headers
             ? {
@@ -292,6 +805,269 @@ export class ProviderTransport {
                 ...(credential?.headers ?? {}),
             }
             : undefined;
+        const executeDynamicTool = async (toolCall) => {
+            const capturedResults = [];
+            const dynamicToolError = (message) => ({
+                content: [{ type: "text", text: message }],
+                isError: true,
+            });
+            const toAgentToolResult = (outcome) => {
+                if (!outcome) {
+                    return dynamicToolError("Dynamic tool execution was blocked");
+                }
+                const message = "message" in outcome ? outcome.message : outcome;
+                return {
+                    content: message.content,
+                    isError: "message" in outcome ? outcome.isError : message.isError,
+                    details: message.details,
+                    ...("message" in outcome && outcome.toolExecutionId
+                        ? { toolExecutionId: outcome.toolExecutionId }
+                        : {}),
+                    ...("message" in outcome && outcome.approvalRequestId
+                        ? { approvalRequestId: outcome.approvalRequestId }
+                        : {}),
+                };
+            };
+            const emitDynamicToolResult = (message, effectiveToolCall, isError, metadata) => {
+                try {
+                    applyWorkflowStateHooks({
+                        toolCall: effectiveToolCall,
+                        result: message,
+                        tracker: this.workflowState,
+                        isError,
+                    });
+                    capturedResults.push({
+                        message,
+                        isError,
+                        ...metadata,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof WorkflowStateError) {
+                        capturedResults.push({
+                            message: {
+                                role: "toolResult",
+                                toolCallId: effectiveToolCall.id,
+                                toolName: effectiveToolCall.name,
+                                content: [{ type: "text", text: error.message }],
+                                isError: true,
+                                timestamp: this.clock.now(),
+                            },
+                            isError: true,
+                            ...metadata,
+                        });
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                return [];
+            };
+            try {
+                const reusableToolResultKey = getReusableToolResultCacheKey(toolCall, toolMetadataCache);
+                const alreadyHadReusableToolResultState = reusableToolResultKey !== undefined &&
+                    hasReusableToolResultState(reusableToolResultKey, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks);
+                incrementPendingReusableToolSafetyCheck(reusableToolResultKey, pendingReusableToolSafetyChecks);
+                const shouldSkipLoopDetection = (candidateToolCall) => {
+                    const candidateKey = getReusableToolResultCacheKey(candidateToolCall, toolMetadataCache);
+                    return (candidateKey !== undefined &&
+                        candidateKey === reusableToolResultKey &&
+                        alreadyHadReusableToolResultState &&
+                        !hasPendingMutatingToolExecution(pendingDynamicToolExecutions, toolMetadataCache) &&
+                        hasReusableToolResultState(candidateKey, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks));
+                };
+                let safetyVerdict;
+                let rateLimitUpdate;
+                try {
+                    const safetyIterator = evaluateToolSafety({
+                        toolCall,
+                        tools,
+                        userMessage,
+                        cfg,
+                        signal,
+                        clock: this.clock,
+                        safetyMiddleware: this.safetyMiddleware,
+                        workflowState: this.workflowState,
+                        adaptiveThresholds: this.adaptiveThresholds,
+                        auditLogger: this.auditLogger,
+                        approvalService: this.options.approvalService,
+                        toolExecutionBridge: platformToolExecutionBridge,
+                        hookService,
+                        firewall,
+                        rateLimitState: {
+                            recentToolTimestamps: this.recentToolTimestamps,
+                            toolCallsThisMinute: this.toolCallsThisMinute,
+                            minuteWindowStart: this.minuteWindowStart,
+                            rateWindowMs: ProviderTransport.TOOL_RATE_WINDOW_MS,
+                            rateLimit: ProviderTransport.TOOL_RATE_LIMIT,
+                        },
+                        shouldSkipLoopDetection,
+                        emitToolResult: emitDynamicToolResult,
+                    });
+                    while (true) {
+                        const safetyStep = await safetyIterator.next();
+                        if (safetyStep.done) {
+                            ({ verdict: safetyVerdict, rateLimitUpdate } = safetyStep.value);
+                            break;
+                        }
+                        if (isDynamicToolApprovalEvent(safetyStep.value)) {
+                            dynamicToolEventQueue.push(safetyStep.value);
+                        }
+                    }
+                }
+                finally {
+                    decrementPendingReusableToolSafetyCheck(reusableToolResultKey, pendingReusableToolSafetyChecks);
+                }
+                if (!safetyVerdict || !rateLimitUpdate) {
+                    return dynamicToolError("Safety pipeline did not return a verdict.");
+                }
+                this.toolCallsThisMinute = rateLimitUpdate.toolCallsThisMinute;
+                this.minuteWindowStart = rateLimitUpdate.minuteWindowStart;
+                if (safetyVerdict.outcome === "blocked") {
+                    return toAgentToolResult(capturedResults.at(-1));
+                }
+                const { effectiveToolCall, validatedArgs, toolDef: tool, sanitizedExecutionArgs, } = safetyVerdict;
+                if (tool.executionLocation === "client") {
+                    return dynamicToolError(`Client-side tool execution is not available for Codex app-server dynamic tool "${tool.name}".`);
+                }
+                const policyCheckedReusableToolResultKey = getReusableToolResultCacheKey(effectiveToolCall, toolMetadataCache);
+                const canReuseToolResult = reusableToolResultKey !== undefined &&
+                    policyCheckedReusableToolResultKey === reusableToolResultKey;
+                if (canReuseToolResult && reusableToolResultKey) {
+                    policyCheckedReusableToolResultKeys.add(reusableToolResultKey);
+                }
+                const canServeReusableToolResult = canReuseToolResult &&
+                    !hasPendingMutatingToolExecution(pendingDynamicToolExecutions, toolMetadataCache);
+                if (canServeReusableToolResult) {
+                    const cachedEntry = reusableToolResults.get(reusableToolResultKey);
+                    if (cachedEntry) {
+                        const cacheHitStart = this.clock.now();
+                        const cachedOutcome = await recordReusableToolExecutionBridgeOutput({
+                            bridge: platformToolExecutionBridge,
+                            plan: safetyVerdict.toolExecutionBridgePlan,
+                            outcome: {
+                                message: {
+                                    ...cachedEntry.message,
+                                    toolCallId: toolCall.id,
+                                    toolName: toolCall.name,
+                                    content: cachedEntry.message.content.map((item) => ({
+                                        ...item,
+                                    })),
+                                    timestamp: this.clock.now(),
+                                },
+                                isError: false,
+                            },
+                            durationMs: this.clock.now() - cacheHitStart,
+                            signal,
+                        });
+                        emitDynamicToolResult(cachedOutcome.message, effectiveToolCall, cachedOutcome.isError, {
+                            toolExecutionId: cachedOutcome.toolExecutionId,
+                            approvalRequestId: cachedOutcome.approvalRequestId,
+                        });
+                        return toAgentToolResult(capturedResults.at(-1) ?? cachedOutcome);
+                    }
+                    const pendingReusable = pendingReusableToolResults.get(reusableToolResultKey);
+                    if (pendingReusable) {
+                        const cacheHitStart = this.clock.now();
+                        const cachedOutcome = await recordReusableToolExecutionBridgeOutput({
+                            bridge: platformToolExecutionBridge,
+                            plan: safetyVerdict.toolExecutionBridgePlan,
+                            outcome: cloneToolOutcomeForCall(await pendingReusable, toolCall, this.clock.now()),
+                            durationMs: this.clock.now() - cacheHitStart,
+                            signal,
+                        });
+                        emitDynamicToolResult(cachedOutcome.message, effectiveToolCall, cachedOutcome.isError, {
+                            toolExecutionId: cachedOutcome.toolExecutionId,
+                            approvalRequestId: cachedOutcome.approvalRequestId,
+                        });
+                        return toAgentToolResult(capturedResults.at(-1) ?? cachedOutcome);
+                    }
+                }
+                const toolUpdateQueue = createToolUpdateQueue();
+                const executionPromise = createToolExecutionPromise({
+                    toolCall,
+                    effectiveToolCall,
+                    tool,
+                    validatedArgs,
+                    sanitizedExecutionArgs,
+                    cfg,
+                    signal,
+                    clock: this.clock,
+                    safetyMiddleware: this.safetyMiddleware,
+                    adaptiveThresholds: this.adaptiveThresholds,
+                    auditLogger: this.auditLogger,
+                    hookService,
+                    toolRetryService: this.options.toolRetryService,
+                    toolRetryConfig: this.options.toolRetryConfig,
+                    clientToolService: this.options.clientToolService,
+                    toolExecutionBridge: platformToolExecutionBridge,
+                    toolExecutionBridgePlan: safetyVerdict.toolExecutionBridgePlan,
+                    toolUpdateQueue,
+                });
+                const trackedExecutionPromise = canReuseToolResult && reusableToolResultKey
+                    ? trackReusableToolResult(reusableToolResultKey, executionPromise, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, reusableToolResultCacheGeneration)
+                    : executionPromise;
+                const pendingExecution = {
+                    toolCall: effectiveToolCall,
+                    promise: trackedExecutionPromise,
+                };
+                pendingDynamicToolExecutions.push(pendingExecution);
+                const pendingExecutions = [pendingExecution];
+                let outcome;
+                try {
+                    while (pendingExecutions.length > 0) {
+                        const next = await waitForNextExecutionOrUpdate(pendingExecutions, toolUpdateQueue);
+                        if (next.kind === "update") {
+                            if (next.event.type === "tool_retry_required") {
+                                this.options.toolRetryService?.skip(next.event.request.id, "Codex app-server dynamic tool callbacks cannot prompt for retry", "runtime");
+                            }
+                            continue;
+                        }
+                        outcome = next.outcome;
+                    }
+                }
+                finally {
+                    const pendingIndex = pendingDynamicToolExecutions.indexOf(pendingExecution);
+                    if (pendingIndex >= 0) {
+                        pendingDynamicToolExecutions.splice(pendingIndex, 1);
+                    }
+                }
+                if (!outcome) {
+                    return dynamicToolError("Dynamic tool execution did not complete.");
+                }
+                invalidateReusableToolResultsAfterMutation(effectiveToolCall, toolMetadataCache, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks, reusableToolResultCacheGeneration);
+                try {
+                    applyWorkflowStateHooks({
+                        toolCall: effectiveToolCall,
+                        result: outcome.message,
+                        tracker: this.workflowState,
+                        isError: outcome.isError,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof WorkflowStateError) {
+                        return toAgentToolResult({
+                            message: {
+                                role: "toolResult",
+                                toolCallId: effectiveToolCall.id,
+                                toolName: effectiveToolCall.name,
+                                content: [{ type: "text", text: error.message }],
+                                isError: true,
+                                timestamp: this.clock.now(),
+                            },
+                            isError: true,
+                            toolExecutionId: outcome.toolExecutionId,
+                            approvalRequestId: outcome.approvalRequestId,
+                        });
+                    }
+                    throw error;
+                }
+                return toAgentToolResult(outcome);
+            }
+            finally {
+                this.safetyMiddleware.clearCredentials();
+            }
+        };
         const streamOptions = {
             apiKey,
             maxTokens: model.maxTokens,
@@ -300,7 +1076,9 @@ export class ProviderTransport {
             headers,
             requestBody: credential?.requestBody,
             sessionId: cfg.session?.id,
+            cwd: this.options.cwd,
             taskBudget: cfg.taskBudget,
+            executeDynamicTool,
         };
         let hasMoreToolCalls = true;
         const allMessages = [...context.messages];
@@ -355,7 +1133,8 @@ export class ProviderTransport {
             let currentAssistantMessage = null;
             let completedAssistantMessage = null;
             const toolCallsToExecute = [];
-            let toolResults = [];
+            const toolResults = [];
+            const pendingProviderToolResultMessages = [];
             let steeringAfterTools = null;
             let pendingNextTurn = false;
             let encounteredError = false;
@@ -382,6 +1161,8 @@ export class ProviderTransport {
                     // Reset state for retry
                     currentAssistantMessage = null;
                     toolCallsToExecute.length = 0;
+                    toolResults.length = 0;
+                    pendingProviderToolResultMessages.length = 0;
                     pendingNextTurn = false;
                     const backoffMs = Math.min(networkConfig.backoffInitial * 2 ** (streamAttempt - 1), networkConfig.backoffMax);
                     logger.info("Retrying stream after idle timeout", {
@@ -397,8 +1178,34 @@ export class ProviderTransport {
                     attempt: streamAttempt,
                 });
                 const stream = createProviderStream(model, currentContext, streamOptions, { reasoning: cfg.reasoning, reasoningSummary: cfg.reasoningSummary });
+                const streamIterator = stream[Symbol.asyncIterator]();
+                let nextStreamEvent = streamIterator.next();
                 try {
-                    for await (const event of stream) {
+                    while (true) {
+                        const queuedDynamicToolEvent = dynamicToolEventQueue.shift();
+                        if (queuedDynamicToolEvent) {
+                            yield queuedDynamicToolEvent;
+                            continue;
+                        }
+                        const dynamicToolEventReady = dynamicToolEventQueue.wait();
+                        const nextEvent = await Promise.race([
+                            dynamicToolEventReady.then(() => ({
+                                type: "dynamicTool",
+                            })),
+                            nextStreamEvent.then((result) => ({
+                                type: "provider",
+                                result,
+                            })),
+                        ]);
+                        if (nextEvent.type === "dynamicTool") {
+                            continue;
+                        }
+                        dynamicToolEventQueue.clearPendingWaiter();
+                        if (nextEvent.result.done) {
+                            break;
+                        }
+                        const event = nextEvent.result.value;
+                        nextStreamEvent = streamIterator.next();
                         if (event.type === "start") {
                             currentAssistantMessage = event.partial;
                             if (currentAssistantMessage) {
@@ -425,6 +1232,51 @@ export class ProviderTransport {
                             }
                             continue;
                         }
+                        if (event.type === "provider_tool_execution_start") {
+                            if (!firstModelOutputSeen) {
+                                cfg.queryProfiler?.checkpoint("model:first-token");
+                                firstModelOutputSeen = true;
+                            }
+                            yield {
+                                type: "tool_execution_start",
+                                toolCallId: event.toolCallId,
+                                toolExecutionId: event.toolExecutionId,
+                                toolName: event.toolName,
+                                displayName: event.displayName,
+                                summaryLabel: event.summaryLabel,
+                                args: event.args,
+                            };
+                            continue;
+                        }
+                        if (event.type === "provider_tool_execution_update") {
+                            yield {
+                                type: "tool_execution_update",
+                                toolCallId: event.toolCallId,
+                                toolExecutionId: event.toolExecutionId,
+                                toolName: event.toolName,
+                                displayName: event.displayName,
+                                summaryLabel: event.summaryLabel,
+                                args: event.args,
+                                partialResult: event.partialResult,
+                            };
+                            continue;
+                        }
+                        if (event.type === "provider_tool_execution_end") {
+                            toolResults.push(event.result);
+                            pendingProviderToolResultMessages.push(event.result);
+                            yield {
+                                type: "tool_execution_end",
+                                toolCallId: event.toolCallId,
+                                toolExecutionId: event.toolExecutionId,
+                                approvalRequestId: event.approvalRequestId,
+                                toolName: event.toolName,
+                                displayName: event.displayName,
+                                summaryLabel: event.summaryLabel,
+                                result: event.result,
+                                isError: event.isError,
+                            };
+                            continue;
+                        }
                         if (event.type === "toolcall_end") {
                             if (!firstModelOutputSeen) {
                                 cfg.queryProfiler?.checkpoint("model:first-token");
@@ -477,6 +1329,11 @@ export class ProviderTransport {
                                     }
                                 }
                             }
+                            for (const message of pendingProviderToolResultMessages) {
+                                yield { type: "message_start", message };
+                                yield { type: "message_end", message };
+                            }
+                            pendingProviderToolResultMessages.length = 0;
                             pendingNextTurn = toolCallsToExecute.length > 0;
                             continue;
                         }
@@ -490,9 +1347,17 @@ export class ProviderTransport {
                             break;
                         }
                     }
+                    for (let event = dynamicToolEventQueue.shift(); event; event = dynamicToolEventQueue.shift()) {
+                        yield event;
+                    }
+                    dynamicToolEventQueue.clearPendingWaiter();
                     streamSuccess = true;
                 }
                 catch (error) {
+                    while (dynamicToolEventQueue.shift()) {
+                        // Drop queued dynamic tool events from the abandoned stream attempt.
+                    }
+                    dynamicToolEventQueue.clearPendingWaiter();
                     if (isStreamIdleTimeoutError(error) &&
                         streamAttempt <= maxStreamRetries) {
                         logger.warn("Stream idle timeout, will retry", {
@@ -508,7 +1373,6 @@ export class ProviderTransport {
                 }
             } // end while retry loop
             if (toolCallsToExecute.length > 0) {
-                toolResults = [];
                 const toolUpdateQueue = createToolUpdateQueue();
                 const pendingExecutions = [];
                 const rawConcurrency = this.options.maxConcurrentToolExecutions ?? 2;
@@ -517,12 +1381,285 @@ export class ProviderTransport {
                     : 2;
                 const hasWorkflowTrackedTool = toolCallsToExecute.some((call) => isWorkflowTrackedTool(call.name));
                 const requiresSerializedTurn = hasWorkflowTrackedTool && toolCallsToExecute.length > 1;
-                // Calculate optimal concurrency - higher for read-only batches
-                let concurrencyLimit = getOptimalConcurrency(toolCallsToExecute, tools, {
-                    baseConcurrency: configuredConcurrency,
-                    maxReadOnlyConcurrency: 8, // Allow up to 8x parallel for read-only
-                    enabled: true,
+                const toolDefinitionsByName = toolMetadataCache.definitions;
+                const isReadOnlyToolCall = (toolCall) => {
+                    const toolDef = toolDefinitionsByName.get(toolCall.name);
+                    return toolDef
+                        ? isReadOnlyTool(toolDef.name, toolDef.annotations, toolDef.source)
+                        : false;
+                };
+                const isParallelSafeToolCall = (toolCall, toolDef = toolDefinitionsByName.get(toolCall.name)) => toolDef
+                    ? isParallelSafeTool(toolDef.name, toolDef.annotations, toolDef.source)
+                    : false;
+                const readOnlyToolCalls = toolCallsToExecute.filter(isReadOnlyToolCall);
+                const readOnlyConcurrencyLimit = readOnlyToolCalls.length > 0
+                    ? Math.min(8, Math.max(configuredConcurrency, readOnlyToolCalls.length))
+                    : configuredConcurrency;
+                const parallelSafeMutationConcurrencyLimit = Math.min(8, configuredConcurrency);
+                const concurrencyLimitForTool = (defaultLimit, toolDef) => {
+                    const sourceMaxConcurrency = toolDef?.source?.type === "mcp"
+                        ? toolDef.source.parallelMaxConcurrency
+                        : undefined;
+                    return Math.min(defaultLimit, typeof sourceMaxConcurrency === "number" &&
+                        Number.isFinite(sourceMaxConcurrency) &&
+                        sourceMaxConcurrency > 0
+                        ? Math.floor(sourceMaxConcurrency)
+                        : defaultLimit);
+                };
+                const readOnlyConcurrencyLimitForTool = (toolDef) => concurrencyLimitForTool(readOnlyConcurrencyLimit, toolDef);
+                const parallelSafeMutationConcurrencyLimitForTool = (toolDef) => concurrencyLimitForTool(parallelSafeMutationConcurrencyLimit, toolDef);
+                let concurrencyLimit = configuredConcurrency;
+                const pendingMutationScopes = new Map();
+                const pendingExecutionWaveIndexes = new Map();
+                const pendingExecutionScheduling = new Map();
+                const toolSchedulingDecisions = new Map();
+                const toolPhaseStartMs = this.clock.now();
+                let currentWaveIndex = 0;
+                const mutationPathBase = this.options.cwd ?? process.cwd();
+                const toolSchedulingMetadata = new Map();
+                const nextWaveIndex = () => {
+                    currentWaveIndex += 1;
+                    return currentWaveIndex;
+                };
+                const pendingWaveIndex = () => pendingExecutions.length > 0
+                    ? (pendingExecutionWaveIndexes.get(pendingExecutions[0]) ??
+                        currentWaveIndex)
+                    : nextWaveIndex();
+                const schedulerWaitMs = () => Math.max(0, this.clock.now() - toolPhaseStartMs);
+                const isMcpParallelOptIn = (toolDef) => toolDef.source?.type === "mcp" &&
+                    toolDef.source.supportsParallelToolCalls === true &&
+                    toolDef.annotations?.destructiveHint !== true;
+                const buildToolPhaseSummary = () => {
+                    const rawDecisions = [...toolSchedulingDecisions.values()].sort((left, right) => left.emittedIndex - right.emittedIndex);
+                    if (rawDecisions.length === 0) {
+                        return undefined;
+                    }
+                    const waveCounts = new Map();
+                    for (const decision of rawDecisions) {
+                        if (decision.waveIndex !== undefined) {
+                            waveCounts.set(decision.waveIndex, (waveCounts.get(decision.waveIndex) ?? 0) + 1);
+                        }
+                    }
+                    const decisions = rawDecisions.map((decision) => {
+                        const isSingleModelToolCall = rawDecisions.length === 1;
+                        const waveSize = decision.waveIndex !== undefined
+                            ? (waveCounts.get(decision.waveIndex) ?? 1)
+                            : 1;
+                        const outcome = decision.cacheHit === true
+                            ? "cached"
+                            : decision.decision === "skipped"
+                                ? "skipped"
+                                : decision.decision === "delayed" ||
+                                    decision.blockedByMutation === true
+                                    ? "delayed"
+                                    : decision.decision === "parallelized" ||
+                                        (waveSize > 1 && decision.decision === "scheduled")
+                                        ? "parallelized"
+                                        : "serialized";
+                        const reason = outcome === "cached"
+                            ? "cache_hit"
+                            : decision.blockedByMutation === true
+                                ? decision.reason
+                                : decision.reason === "workflow_state_serialized"
+                                    ? "workflow_state_serialized"
+                                    : decision.mcpOptIn === true
+                                        ? "mcp_parallel_opt_in"
+                                        : decision.reason.startsWith("read_only")
+                                            ? outcome === "parallelized"
+                                                ? "read_only_parallel_safe"
+                                                : isSingleModelToolCall
+                                                    ? "single_read_only_call"
+                                                    : decision.reason
+                                            : decision.reason.startsWith("path_scoped_mutation")
+                                                ? "path_scoped_mutation"
+                                                : decision.reason;
+                        return {
+                            toolCallId: decision.callId,
+                            toolName: decision.toolName,
+                            emittedIndex: decision.emittedIndex,
+                            outcome,
+                            decision: outcome,
+                            reason,
+                            waveIndex: decision.waveIndex !== undefined
+                                ? Math.max(0, decision.waveIndex - 1)
+                                : undefined,
+                            waitMs: Math.max(0, Math.round(decision.schedulerWaitMs ?? 0)),
+                            schedulerWaitMs: Math.max(0, Math.round(decision.schedulerWaitMs ?? 0)),
+                            mcpOptIn: decision.mcpOptIn,
+                            cacheHit: decision.cacheHit,
+                            blockedByMutation: decision.blockedByMutation,
+                        };
+                    });
+                    const parallelizedCallCount = decisions.filter((decision) => decision.outcome === "parallelized").length;
+                    const delayedCallCount = decisions.filter((decision) => decision.outcome === "delayed").length;
+                    const batchShapingFeedback = decisions.length === 1 &&
+                        decisions[0]?.reason === "single_read_only_call"
+                        ? {
+                            avoidableSingleton: true,
+                            reason: "single_read_only_call",
+                            hint: "When you need several independent reads or searches, emit them together in one assistant message so Maestro can batch them safely.",
+                        }
+                        : undefined;
+                    const serializationReasons = Object.fromEntries([...decisions]
+                        .filter((decision) => decision.outcome === "serialized" ||
+                        decision.outcome === "delayed")
+                        .reduce((counts, decision) => {
+                        counts.set(decision.reason, (counts.get(decision.reason) ?? 0) + 1);
+                        return counts;
+                    }, new Map()));
+                    return {
+                        type: "tool_phase_summary",
+                        modelToolCallCount: rawDecisions.length,
+                        modelEmittedToolCallCount: rawDecisions.length,
+                        schedulableWaveCount: waveCounts.size,
+                        parallelizedCallCount,
+                        actuallyParallelizedCallCount: parallelizedCallCount,
+                        serializedCallCount: decisions.filter((decision) => decision.outcome === "serialized" ||
+                            decision.outcome === "delayed").length,
+                        delayedCallCount,
+                        blockedByMutationCount: decisions.filter((decision) => decision.blockedByMutation === true).length,
+                        mcpOptInCallCount: decisions.filter((decision) => decision.mcpOptIn === true).length,
+                        mcpOptInUseCount: decisions.filter((decision) => decision.mcpOptIn === true).length,
+                        cacheHitCount: decisions.filter((decision) => decision.cacheHit === true).length,
+                        totalToolWaitMs: decisions.reduce((total, decision) => total + decision.waitMs, 0),
+                        toolWaitTimeMs: decisions.reduce((total, decision) => total + decision.waitMs, 0),
+                        serializationReasons,
+                        decisions,
+                        batchShapingFeedback,
+                    };
+                };
+                const getMutationScope = (toolCall, toolDef = toolMetadataCache.get(toolCall.name)) => getPathScopedMutation(toolCall, toolDef, mutationPathBase);
+                const sameMutationScope = (left, right) => {
+                    if (!left || !right) {
+                        return left === right;
+                    }
+                    const leftArgumentKeys = left.argumentKeys ?? [];
+                    const rightArgumentKeys = right.argumentKeys ?? [];
+                    return (left.source === right.source &&
+                        left.paths.length === right.paths.length &&
+                        left.paths.every((path, index) => path === right.paths[index]) &&
+                        leftArgumentKeys.length === rightArgumentKeys.length &&
+                        leftArgumentKeys.every((argumentKey, index) => argumentKey === rightArgumentKeys[index]));
+                };
+                const pendingMutationCount = () => pendingExecutions.filter((execution) => {
+                    const toolDef = toolMetadataCache.definitions.get(execution.toolCall.name);
+                    return (!!toolDef &&
+                        !isReadOnlyTool(toolDef.name, toolDef.annotations, toolDef.source));
+                }).length;
+                const mergeToolSchedulingMetadata = (toolCallId, metadata) => {
+                    toolSchedulingMetadata.set(toolCallId, metadata);
+                    return metadata;
+                };
+                const pathScopeSchedulingReason = (scope, canJoinPathScope) => {
+                    if (pendingExecutions.length === 0 || pendingMutationCount() === 0) {
+                        return "path_scope_available";
+                    }
+                    if (canJoinPathScope) {
+                        return "path_scope_disjoint";
+                    }
+                    const hasPathOverlap = pendingExecutions.some((execution) => {
+                        const pendingScope = pendingMutationScopes.get(execution);
+                        return pendingScope
+                            ? pathScopesOverlap(scope, pendingScope)
+                            : false;
+                    });
+                    return hasPathOverlap ? "path_scope_overlap" : "pending_mutation";
+                };
+                const buildToolSchedulingMetadata = ({ toolDef, readOnly, parallelSafe, scope, cache, canJoinPathScope, laneConcurrencyLimit = concurrencyLimit, }) => {
+                    const pendingMutations = pendingMutationCount();
+                    const base = {
+                        classification: "unknown",
+                        reason: "unknown_tool",
+                        concurrencyLimit: laneConcurrencyLimit,
+                        queueDepth: pendingExecutions.length,
+                        pendingMutations,
+                        cache,
+                    };
+                    if (!toolDef) {
+                        return base;
+                    }
+                    if (requiresSerializedTurn) {
+                        return {
+                            ...base,
+                            classification: "workflow_serialized",
+                            reason: "workflow_state_tracker",
+                        };
+                    }
+                    if (readOnly) {
+                        return {
+                            ...base,
+                            classification: "read_only",
+                            reason: "read_only_tool",
+                        };
+                    }
+                    if (scope) {
+                        return {
+                            ...base,
+                            classification: "path_scoped_mutation",
+                            reason: pathScopeSchedulingReason(scope, canJoinPathScope),
+                            pathScope: scope.paths,
+                            pathScopeSource: scope.source,
+                            pathArgumentKeys: scope.argumentKeys,
+                        };
+                    }
+                    if (parallelSafe && !readOnly) {
+                        return {
+                            ...base,
+                            classification: "parallel_safe_mutation",
+                            reason: "mcp_parallel_opt_in",
+                        };
+                    }
+                    if (pendingMutations > 0) {
+                        return {
+                            ...base,
+                            classification: "serialized_mutation",
+                            reason: "pending_mutation",
+                        };
+                    }
+                    return {
+                        ...base,
+                        classification: "serialized_mutation",
+                        reason: "mutating_tool",
+                    };
+                };
+                const hasPendingUnscopedMutation = () => pendingExecutions.some((execution) => {
+                    const toolDef = toolMetadataCache.get(execution.toolCall.name);
+                    return (!!toolDef &&
+                        !isReadOnlyTool(toolDef.name, toolDef.annotations, toolDef.source) &&
+                        !pendingMutationScopes.has(execution));
                 });
+                const mutationBlockReason = (scope) => scope && !hasPendingUnscopedMutation()
+                    ? "mutation_scope_overlap"
+                    : "mutation_unknown_write_set";
+                const isPendingParallelSafeMutation = (execution) => {
+                    const toolDef = toolMetadataCache.get(execution.toolCall.name);
+                    return (!!toolDef &&
+                        !isReadOnlyTool(toolDef.name, toolDef.annotations, toolDef.source) &&
+                        isParallelSafeTool(toolDef.name, toolDef.annotations, toolDef.source) &&
+                        !pendingMutationScopes.has(execution));
+                };
+                const canJoinParallelSafeMutationWave = (toolCall, toolDef = toolMetadataCache.get(toolCall.name)) => !!toolDef &&
+                    !isReadOnlyTool(toolDef.name, toolDef.annotations, toolDef.source) &&
+                    isParallelSafeTool(toolDef.name, toolDef.annotations, toolDef.source) &&
+                    pendingExecutions.length > 0 &&
+                    pendingExecutions.every(isPendingParallelSafeMutation);
+                const canJoinPathScopedMutationIsland = (scope) => !!scope &&
+                    pendingExecutions.length > 0 &&
+                    pendingExecutions.every((execution) => {
+                        const pendingScope = pendingMutationScopes.get(execution);
+                        return pendingScope
+                            ? !pathScopesOverlap(scope, pendingScope)
+                            : false;
+                    });
+                const laneConcurrencyLimit = ({ readOnly, scope, parallelSafe, toolDef, }) => requiresSerializedTurn
+                    ? 1
+                    : readOnly
+                        ? readOnlyConcurrencyLimitForTool(toolDef)
+                        : scope
+                            ? configuredConcurrency
+                            : parallelSafe
+                                ? parallelSafeMutationConcurrencyLimitForTool(toolDef)
+                                : 1;
                 // Override: workflow-tracked tools require serialization
                 if (configuredConcurrency > 1 && requiresSerializedTurn) {
                     concurrencyLimit = 1;
@@ -533,6 +1670,7 @@ export class ProviderTransport {
                 }
                 let steeringTriggered = false;
                 let remainingToolCalls = [];
+                let mutatingToolCompletedInCurrentBatch = false;
                 const checkSteering = async () => {
                     if (steeringTriggered || !getSteeringMessages) {
                         return;
@@ -561,6 +1699,7 @@ export class ProviderTransport {
                             toolName: toolCall.name,
                             result: message,
                             isError,
+                            scheduling: toolSchedulingMetadata.get(toolCall.id),
                         },
                     ];
                 };
@@ -591,8 +1730,44 @@ export class ProviderTransport {
                         throw error;
                     }
                 };
+                const emittedIndexForToolCall = (toolCall) => {
+                    const emittedIndex = toolCallsToExecute.findIndex((candidate) => candidate.id === toolCall.id);
+                    return emittedIndex >= 0
+                        ? emittedIndex
+                        : toolSchedulingDecisions.size;
+                };
                 const emitSkippedToolCall = (toolCall) => {
                     const sanitizedSkippedArgs = this.safetyMiddleware.sanitizeForLogging(toolCall.arguments);
+                    const existingScheduling = toolSchedulingMetadata.get(toolCall.id);
+                    const toolDef = toolMetadataCache.get(toolCall.name);
+                    const skippedToolCallReadOnly = isReadOnlyToolCall(toolCall);
+                    const skippedToolCallParallelSafe = isParallelSafeToolCall(toolCall, toolDef);
+                    const mutationScope = getMutationScope(toolCall, toolDef);
+                    const reusableToolResultKey = getReusableToolResultCacheKey(toolCall, toolMetadataCache);
+                    const schedulingMetadata = mergeToolSchedulingMetadata(toolCall.id, existingScheduling ??
+                        buildToolSchedulingMetadata({
+                            toolDef,
+                            readOnly: skippedToolCallReadOnly,
+                            parallelSafe: skippedToolCallParallelSafe,
+                            scope: mutationScope,
+                            cache: reusableToolResultKey === undefined ? "disabled" : "miss",
+                            canJoinPathScope: canJoinPathScopedMutationIsland(mutationScope),
+                            laneConcurrencyLimit: laneConcurrencyLimit({
+                                readOnly: skippedToolCallReadOnly,
+                                parallelSafe: skippedToolCallParallelSafe,
+                                scope: mutationScope,
+                                toolDef,
+                            }),
+                        }));
+                    const schedulingDecision = {
+                        callId: toolCall.id,
+                        toolName: toolCall.name,
+                        emittedIndex: emittedIndexForToolCall(toolCall),
+                        decision: "skipped",
+                        reason: "steering_interrupted",
+                        schedulerWaitMs: schedulerWaitMs(),
+                    };
+                    toolSchedulingDecisions.set(toolCall.id, schedulingDecision);
                     const skippedResult = {
                         role: "toolResult",
                         toolCallId: toolCall.id,
@@ -612,31 +1787,69 @@ export class ProviderTransport {
                             toolCallId: toolCall.id,
                             toolName: toolCall.name,
                             args: sanitizedSkippedArgs,
+                            scheduling: schedulingMetadata,
                         },
                         ...emitToolResult(skippedResult, toolCall, true),
                     ];
                 };
-                const scheduleResolveIfNeeded = async () => {
-                    if (pendingExecutions.length < concurrencyLimit) {
-                        return [];
+                const recordSafetyBlockedToolCall = (toolCall) => {
+                    const existing = toolSchedulingDecisions.get(toolCall.id);
+                    if (existing) {
+                        return existing;
                     }
+                    const scheduling = {
+                        callId: toolCall.id,
+                        toolName: toolCall.name,
+                        emittedIndex: emittedIndexForToolCall(toolCall),
+                        decision: "skipped",
+                        reason: "safety_blocked",
+                        schedulerWaitMs: schedulerWaitMs(),
+                    };
+                    toolSchedulingDecisions.set(toolCall.id, scheduling);
+                    return scheduling;
+                };
+                const emitSafetyPipelineToolResult = (message, toolCall, isError, metadata) => {
+                    if (isError) {
+                        recordSafetyBlockedToolCall(toolCall);
+                    }
+                    return emitToolResult(message, toolCall, isError, metadata);
+                };
+                const resolveNextPendingExecution = async () => {
                     const events = [];
-                    while (pendingExecutions.length >= concurrencyLimit) {
+                    while (true) {
                         const next = await waitForNextExecutionOrUpdate(pendingExecutions, toolUpdateQueue);
                         if (next.kind === "update") {
                             events.push(next.event);
                             continue;
                         }
                         const outcome = next.outcome;
+                        pendingMutationScopes.delete(next.execution);
+                        pendingExecutionWaveIndexes.delete(next.execution);
+                        pendingExecutionScheduling.delete(next.execution);
+                        const completedToolWasMutating = getReusableToolResultCacheKey(next.execution.toolCall, toolMetadataCache) === undefined;
+                        invalidateReusableToolResultsAfterMutation(next.execution.toolCall, toolMetadataCache, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks, reusableToolResultCacheGeneration);
+                        mutatingToolCompletedInCurrentBatch ||= completedToolWasMutating;
                         events.push(...emitToolResult(outcome.message, next.execution.toolCall, outcome.isError, {
                             toolExecutionId: outcome.toolExecutionId,
                             approvalRequestId: outcome.approvalRequestId,
                         }));
                         await checkSteering();
-                        break;
+                        return events;
+                    }
+                };
+                const drainPendingExecutions = async (targetPendingCount = 0) => {
+                    const events = [];
+                    while (pendingExecutions.length > targetPendingCount) {
+                        events.push(...(await resolveNextPendingExecution()));
                     }
                     return events;
                 };
+                const scheduleResolveIfNeeded = async () => {
+                    if (pendingExecutions.length < concurrencyLimit) {
+                        return [];
+                    }
+                    return drainPendingExecutions(concurrencyLimit - 1);
+                };
                 for (let toolIndex = 0; toolIndex < toolCallsToExecute.length; toolIndex++) {
                     if (steeringTriggered) {
                         remainingToolCalls = toolCallsToExecute.slice(toolIndex);
@@ -645,43 +1858,138 @@ export class ProviderTransport {
                     const toolCall = toolCallsToExecute[toolIndex];
                     if (!toolCall)
                         continue;
-                    // Run safety pipeline (rate limiting, hooks, firewall, approval, validation)
-                    const safetyIterator = evaluateToolSafety({
-                        toolCall,
-                        tools,
-                        userMessage,
-                        cfg,
-                        signal,
-                        clock: this.clock,
-                        safetyMiddleware: this.safetyMiddleware,
-                        workflowState: this.workflowState,
-                        adaptiveThresholds: this.adaptiveThresholds,
-                        auditLogger: this.auditLogger,
-                        approvalService: this.options.approvalService,
-                        toolExecutionBridge: this.options.platformToolExecutionBridge === false
-                            ? undefined
-                            : (this.options.platformToolExecutionBridge ??
-                                getDefaultPlatformToolExecutionBridge()),
-                        hookService,
-                        firewall,
-                        rateLimitState: {
-                            recentToolTimestamps: this.recentToolTimestamps,
-                            toolCallsThisMinute: this.toolCallsThisMinute,
-                            minuteWindowStart: this.minuteWindowStart,
-                            rateWindowMs: ProviderTransport.TOOL_RATE_WINDOW_MS,
-                            rateLimit: ProviderTransport.TOOL_RATE_LIMIT,
-                        },
-                        emitToolResult,
+                    let schedulingDelayReason;
+                    let blockedByMutation = false;
+                    const noteMutationDelay = (reason) => {
+                        schedulingDelayReason ??= reason;
+                        blockedByMutation = true;
+                    };
+                    const originalToolCallReadOnly = isReadOnlyToolCall(toolCall);
+                    const originalMutationScope = originalToolCallReadOnly
+                        ? undefined
+                        : getMutationScope(toolCall);
+                    const originalToolDef = toolDefinitionsByName.get(toolCall.name);
+                    const originalToolCallParallelSafe = isParallelSafeToolCall(toolCall, originalToolDef);
+                    const originalCanJoinPathScope = canJoinPathScopedMutationIsland(originalMutationScope);
+                    const originalJoinsParallelSafeMutationWave = !originalToolCallReadOnly &&
+                        canJoinParallelSafeMutationWave(toolCall);
+                    let preDrainSchedulingMetadata;
+                    if (!originalToolCallReadOnly &&
+                        pendingExecutions.length > 0 &&
+                        pendingMutationCount() > 0 &&
+                        !originalCanJoinPathScope &&
+                        !originalJoinsParallelSafeMutationWave) {
+                        preDrainSchedulingMetadata = buildToolSchedulingMetadata({
+                            toolDef: originalToolDef,
+                            readOnly: originalToolCallReadOnly,
+                            parallelSafe: originalToolCallParallelSafe,
+                            scope: originalMutationScope,
+                            cache: "disabled",
+                            canJoinPathScope: originalCanJoinPathScope,
+                            laneConcurrencyLimit: laneConcurrencyLimit({
+                                readOnly: originalToolCallReadOnly,
+                                parallelSafe: originalToolCallParallelSafe,
+                                scope: originalMutationScope,
+                                toolDef: originalToolDef,
+                            }),
+                        });
+                        if (hasPendingMutatingToolExecution(pendingExecutions, toolMetadataCache)) {
+                            noteMutationDelay(mutationBlockReason(originalMutationScope));
+                        }
+                        const events = await drainPendingExecutions();
+                        for (const event of events) {
+                            yield event;
+                        }
+                        if (steeringTriggered) {
+                            if (preDrainSchedulingMetadata) {
+                                mergeToolSchedulingMetadata(toolCall.id, preDrainSchedulingMetadata);
+                            }
+                            remainingToolCalls = toolCallsToExecute.slice(toolIndex);
+                            break;
+                        }
+                    }
+                    const reusableToolResultKey = getReusableToolResultCacheKey(toolCall, toolMetadataCache);
+                    const alreadyHadReusableToolResultState = reusableToolResultKey !== undefined &&
+                        hasReusableToolResultState(reusableToolResultKey, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks);
+                    incrementPendingReusableToolSafetyCheck(reusableToolResultKey, pendingReusableToolSafetyChecks);
+                    const shouldSkipLoopDetection = (candidateToolCall) => {
+                        const candidateKey = getReusableToolResultCacheKey(candidateToolCall, toolMetadataCache);
+                        return (candidateKey !== undefined &&
+                            candidateKey === reusableToolResultKey &&
+                            alreadyHadReusableToolResultState &&
+                            !hasPendingMutatingToolExecution(pendingExecutions, toolMetadataCache) &&
+                            !mutatingToolCompletedInCurrentBatch &&
+                            hasReusableToolResultState(candidateKey, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, pendingReusableToolSafetyChecks));
+                    };
+                    const nextInitialSchedulingMetadata = buildToolSchedulingMetadata({
+                        toolDef: originalToolDef,
+                        readOnly: originalToolCallReadOnly,
+                        parallelSafe: originalToolCallParallelSafe,
+                        scope: originalMutationScope,
+                        cache: reusableToolResultKey === undefined
+                            ? "disabled"
+                            : alreadyHadReusableToolResultState
+                                ? "candidate"
+                                : "miss",
+                        canJoinPathScope: canJoinPathScopedMutationIsland(originalMutationScope),
+                        laneConcurrencyLimit: laneConcurrencyLimit({
+                            readOnly: originalToolCallReadOnly,
+                            parallelSafe: originalToolCallParallelSafe,
+                            scope: originalMutationScope,
+                            toolDef: originalToolDef,
+                        }),
                     });
+                    const initialSchedulingMetadata = mergeToolSchedulingMetadata(toolCall.id, preDrainSchedulingMetadata
+                        ? {
+                            ...nextInitialSchedulingMetadata,
+                            classification: preDrainSchedulingMetadata.classification,
+                            reason: preDrainSchedulingMetadata.reason,
+                            queueDepth: preDrainSchedulingMetadata.queueDepth,
+                            pendingMutations: preDrainSchedulingMetadata.pendingMutations,
+                        }
+                        : nextInitialSchedulingMetadata);
+                    // Run safety pipeline (rate limiting, hooks, firewall, approval, validation)
                     let safetyVerdict;
                     let rateLimitUpdate;
-                    while (true) {
-                        const safetyStep = await safetyIterator.next();
-                        if (safetyStep.done) {
-                            ({ verdict: safetyVerdict, rateLimitUpdate } = safetyStep.value);
-                            break;
+                    try {
+                        const safetyIterator = evaluateToolSafety({
+                            toolCall,
+                            tools,
+                            userMessage,
+                            cfg,
+                            signal,
+                            clock: this.clock,
+                            safetyMiddleware: this.safetyMiddleware,
+                            workflowState: this.workflowState,
+                            adaptiveThresholds: this.adaptiveThresholds,
+                            auditLogger: this.auditLogger,
+                            approvalService: this.options.approvalService,
+                            toolExecutionBridge: platformToolExecutionBridge,
+                            hookService,
+                            firewall,
+                            rateLimitState: {
+                                recentToolTimestamps: this.recentToolTimestamps,
+                                toolCallsThisMinute: this.toolCallsThisMinute,
+                                minuteWindowStart: this.minuteWindowStart,
+                                rateWindowMs: ProviderTransport.TOOL_RATE_WINDOW_MS,
+                                rateLimit: ProviderTransport.TOOL_RATE_LIMIT,
+                            },
+                            shouldSkipLoopDetection,
+                            schedulingMetadata: initialSchedulingMetadata,
+                            emitToolResult: emitSafetyPipelineToolResult,
+                        });
+                        while (true) {
+                            const safetyStep = await safetyIterator.next();
+                            if (safetyStep.done) {
+                                ({ verdict: safetyVerdict, rateLimitUpdate } =
+                                    safetyStep.value);
+                                break;
+                            }
+                            yield safetyStep.value;
                         }
-                        yield safetyStep.value;
+                    }
+                    finally {
+                        decrementPendingReusableToolSafetyCheck(reusableToolResultKey, pendingReusableToolSafetyChecks);
                     }
                     if (!safetyVerdict || !rateLimitUpdate) {
                         throw new Error("Safety pipeline did not return a verdict.");
@@ -698,7 +2006,244 @@ export class ProviderTransport {
                         continue;
                     }
                     const { effectiveToolCall, validatedArgs, toolDef: tool, sanitizedExecutionArgs, } = safetyVerdict;
+                    const effectiveToolCallReadOnly = isReadOnlyTool(tool.name, tool.annotations, tool.source) &&
+                        tool.annotations?.destructiveHint !== true;
+                    const effectiveToolCallParallelSafe = isParallelSafeTool(tool.name, tool.annotations, tool.source);
+                    if (effectiveToolCallReadOnly &&
+                        hasPendingMutatingToolExecution(pendingExecutions, toolMetadataCache)) {
+                        noteMutationDelay("pending_mutation");
+                        const events = await drainPendingExecutions();
+                        for (const event of events) {
+                            yield event;
+                        }
+                        if (steeringTriggered) {
+                            remainingToolCalls = toolCallsToExecute.slice(toolIndex);
+                            break;
+                        }
+                    }
+                    const effectiveMutationScope = effectiveToolCallReadOnly
+                        ? undefined
+                        : getMutationScope(effectiveToolCall, tool);
+                    const joinsPathScopedMutationIsland = !requiresSerializedTurn &&
+                        canJoinPathScopedMutationIsland(effectiveMutationScope);
+                    const joinsParallelSafeMutationWave = !requiresSerializedTurn &&
+                        !effectiveToolCallReadOnly &&
+                        canJoinParallelSafeMutationWave(effectiveToolCall, tool);
+                    if (!effectiveToolCallReadOnly &&
+                        pendingExecutions.length > 0 &&
+                        !joinsPathScopedMutationIsland &&
+                        !joinsParallelSafeMutationWave) {
+                        if (hasPendingMutatingToolExecution(pendingExecutions, toolMetadataCache)) {
+                            noteMutationDelay(mutationBlockReason(effectiveMutationScope));
+                        }
+                        const events = await drainPendingExecutions();
+                        for (const event of events) {
+                            yield event;
+                        }
+                        if (steeringTriggered) {
+                            remainingToolCalls = toolCallsToExecute.slice(toolIndex);
+                            break;
+                        }
+                    }
+                    concurrencyLimit = requiresSerializedTurn
+                        ? 1
+                        : effectiveToolCallReadOnly
+                            ? readOnlyConcurrencyLimitForTool(tool)
+                            : effectiveMutationScope
+                                ? configuredConcurrency
+                                : effectiveToolCallParallelSafe
+                                    ? parallelSafeMutationConcurrencyLimitForTool(tool)
+                                    : 1;
+                    const effectiveSchedulingMetadata = buildToolSchedulingMetadata({
+                        toolDef: tool,
+                        readOnly: effectiveToolCallReadOnly,
+                        parallelSafe: effectiveToolCallParallelSafe,
+                        scope: effectiveMutationScope,
+                        cache: reusableToolResultKey === undefined
+                            ? "disabled"
+                            : alreadyHadReusableToolResultState
+                                ? "candidate"
+                                : "miss",
+                        canJoinPathScope: joinsPathScopedMutationIsland,
+                        laneConcurrencyLimit: laneConcurrencyLimit({
+                            readOnly: effectiveToolCallReadOnly,
+                            parallelSafe: effectiveToolCallParallelSafe,
+                            scope: effectiveMutationScope,
+                            toolDef: tool,
+                        }),
+                    });
+                    const previousSchedulingMetadata = toolSchedulingMetadata.get(toolCall.id);
+                    const preservePreHookBlockedSchedulingReason = (previousSchedulingMetadata?.reason === "path_scope_overlap" ||
+                        previousSchedulingMetadata?.reason === "pending_mutation") &&
+                        sameMutationScope(originalMutationScope, effectiveMutationScope);
+                    mergeToolSchedulingMetadata(toolCall.id, preservePreHookBlockedSchedulingReason
+                        ? {
+                            ...effectiveSchedulingMetadata,
+                            classification: previousSchedulingMetadata.classification,
+                            reason: previousSchedulingMetadata.reason,
+                            queueDepth: previousSchedulingMetadata.queueDepth,
+                            pendingMutations: previousSchedulingMetadata.pendingMutations,
+                        }
+                        : effectiveSchedulingMetadata);
                     // Use hook-modified (pre-validation) args for hook inputs
+                    const policyCheckedReusableToolResultKey = getReusableToolResultCacheKey(effectiveToolCall, toolMetadataCache);
+                    const canReuseToolResult = reusableToolResultKey !== undefined &&
+                        policyCheckedReusableToolResultKey === reusableToolResultKey;
+                    if (canReuseToolResult && reusableToolResultKey) {
+                        policyCheckedReusableToolResultKeys.add(reusableToolResultKey);
+                    }
+                    const canServeReusableToolResult = canReuseToolResult &&
+                        !hasPendingMutatingToolExecution(pendingExecutions, toolMetadataCache) &&
+                        !mutatingToolCompletedInCurrentBatch;
+                    if (canServeReusableToolResult) {
+                        const cachedEntry = reusableToolResults.get(reusableToolResultKey);
+                        if (cachedEntry) {
+                            const scheduling = {
+                                callId: toolCall.id,
+                                toolName: toolCall.name,
+                                emittedIndex: toolIndex,
+                                decision: "cached",
+                                reason: "reusable_tool_result_ready",
+                                schedulerWaitMs: schedulerWaitMs(),
+                                cacheHit: true,
+                            };
+                            toolSchedulingDecisions.set(toolCall.id, scheduling);
+                            const cacheHitStart = this.clock.now();
+                            const cachedOutcome = await recordReusableToolExecutionBridgeOutput({
+                                bridge: platformToolExecutionBridge,
+                                plan: safetyVerdict.toolExecutionBridgePlan,
+                                outcome: {
+                                    message: {
+                                        ...cachedEntry.message,
+                                        toolCallId: toolCall.id,
+                                        toolName: toolCall.name,
+                                        content: cachedEntry.message.content.map((item) => ({
+                                            ...item,
+                                        })),
+                                        timestamp: this.clock.now(),
+                                    },
+                                    isError: false,
+                                },
+                                durationMs: this.clock.now() - cacheHitStart,
+                                signal,
+                            });
+                            mergeToolSchedulingMetadata(toolCall.id, {
+                                classification: "cache_reuse",
+                                reason: "cache_hit",
+                                concurrencyLimit,
+                                queueDepth: pendingExecutions.length,
+                                pendingMutations: pendingMutationCount(),
+                                cache: "hit",
+                            });
+                            for (const event of emitToolResult(cachedOutcome.message, toolCall, cachedOutcome.isError, {
+                                toolExecutionId: cachedOutcome.toolExecutionId,
+                                approvalRequestId: cachedOutcome.approvalRequestId,
+                            })) {
+                                yield event;
+                            }
+                            await checkSteering();
+                            if (steeringTriggered) {
+                                remainingToolCalls = toolCallsToExecute.slice(toolIndex + 1);
+                                break;
+                            }
+                            continue;
+                        }
+                        const pendingReusable = pendingReusableToolResults.get(reusableToolResultKey);
+                        if (pendingReusable) {
+                            mergeToolSchedulingMetadata(toolCall.id, {
+                                classification: "cache_reuse",
+                                reason: "cache_pending",
+                                concurrencyLimit,
+                                queueDepth: pendingExecutions.length,
+                                pendingMutations: pendingMutationCount(),
+                                cache: "pending_hit",
+                            });
+                            const waveIndex = pendingWaveIndex();
+                            const scheduling = {
+                                callId: toolCall.id,
+                                toolName: toolCall.name,
+                                emittedIndex: toolIndex,
+                                waveIndex,
+                                decision: "cached",
+                                reason: "reusable_tool_result_pending",
+                                schedulerWaitMs: schedulerWaitMs(),
+                                cacheHit: true,
+                            };
+                            toolSchedulingDecisions.set(toolCall.id, scheduling);
+                            const pendingExecution = {
+                                toolCall,
+                                promise: (async () => {
+                                    const cacheHitStart = this.clock.now();
+                                    return recordReusableToolExecutionBridgeOutput({
+                                        bridge: platformToolExecutionBridge,
+                                        plan: safetyVerdict.toolExecutionBridgePlan,
+                                        outcome: cloneToolOutcomeForCall(await pendingReusable, toolCall, this.clock.now()),
+                                        durationMs: this.clock.now() - cacheHitStart,
+                                        signal,
+                                    });
+                                })(),
+                            };
+                            pendingExecutions.push(pendingExecution);
+                            pendingExecutionWaveIndexes.set(pendingExecution, waveIndex);
+                            pendingExecutionScheduling.set(pendingExecution, scheduling);
+                            const events = await scheduleResolveIfNeeded();
+                            for (const event of events) {
+                                yield event;
+                            }
+                            if (steeringTriggered) {
+                                remainingToolCalls = toolCallsToExecute.slice(toolIndex + 1);
+                                break;
+                            }
+                            continue;
+                        }
+                    }
+                    const pendingBeforeSchedule = pendingExecutions.length;
+                    const waveIndex = pendingBeforeSchedule > 0 ? pendingWaveIndex() : nextWaveIndex();
+                    const mcpOptIn = isMcpParallelOptIn(tool) && !effectiveToolCallReadOnly;
+                    const decision = schedulingDelayReason !== undefined
+                        ? "delayed"
+                        : pendingBeforeSchedule > 0
+                            ? "parallelized"
+                            : requiresSerializedTurn ||
+                                (!effectiveToolCallReadOnly &&
+                                    !effectiveMutationScope &&
+                                    !effectiveToolCallParallelSafe)
+                                ? "serialized"
+                                : "scheduled";
+                    const reason = schedulingDelayReason ??
+                        (effectiveToolCallReadOnly
+                            ? requiresSerializedTurn
+                                ? "workflow_state_serialized"
+                                : pendingBeforeSchedule > 0
+                                    ? "read_only_wave"
+                                    : "read_only_wave_start"
+                            : requiresSerializedTurn
+                                ? "workflow_state_serialized"
+                                : joinsPathScopedMutationIsland
+                                    ? "path_scoped_mutation_disjoint"
+                                    : joinsParallelSafeMutationWave && mcpOptIn
+                                        ? "mcp_parallel_opt_in"
+                                        : joinsParallelSafeMutationWave
+                                            ? "parallel_safe_mutation_wave"
+                                            : mcpOptIn
+                                                ? pendingBeforeSchedule > 0
+                                                    ? "mcp_parallel_opt_in"
+                                                    : "mcp_parallel_opt_in_wave_start"
+                                                : effectiveMutationScope
+                                                    ? "path_scoped_mutation_wave_start"
+                                                    : "serialized_tool");
+                    const scheduling = {
+                        callId: toolCall.id,
+                        toolName: toolCall.name,
+                        emittedIndex: toolIndex,
+                        waveIndex,
+                        decision,
+                        reason,
+                        schedulerWaitMs: schedulerWaitMs(),
+                        mcpOptIn,
+                        blockedByMutation,
+                    };
+                    toolSchedulingDecisions.set(toolCall.id, scheduling);
                     // For client tools, set up the execution promise first, then emit event
                     // This prevents race conditions where the client responds before we're listening
                     let clientToolExecPromise;
@@ -731,18 +2276,24 @@ export class ProviderTransport {
                         toolRetryService: this.options.toolRetryService,
                         toolRetryConfig: this.options.toolRetryConfig,
                         clientToolService: this.options.clientToolService,
-                        toolExecutionBridge: this.options.platformToolExecutionBridge === false
-                            ? undefined
-                            : (this.options.platformToolExecutionBridge ??
-                                getDefaultPlatformToolExecutionBridge()),
+                        toolExecutionBridge: platformToolExecutionBridge,
                         toolExecutionBridgePlan: safetyVerdict.toolExecutionBridgePlan,
                         toolUpdateQueue,
                         clientToolExecPromise,
                     });
-                    pendingExecutions.push({
+                    const trackedExecutionPromise = canReuseToolResult && reusableToolResultKey
+                        ? trackReusableToolResult(reusableToolResultKey, executionPromise, reusableToolResults, pendingReusableToolResults, policyCheckedReusableToolResultKeys, reusableToolResultCacheGeneration)
+                        : executionPromise;
+                    const pendingExecution = {
                         toolCall,
-                        promise: executionPromise,
-                    });
+                        promise: trackedExecutionPromise,
+                    };
+                    pendingExecutions.push(pendingExecution);
+                    pendingExecutionWaveIndexes.set(pendingExecution, waveIndex);
+                    pendingExecutionScheduling.set(pendingExecution, scheduling);
+                    if (effectiveMutationScope) {
+                        pendingMutationScopes.set(pendingExecution, effectiveMutationScope);
+                    }
                     const events = await scheduleResolveIfNeeded();
                     for (const event of events) {
                         yield event;
@@ -753,21 +2304,10 @@ export class ProviderTransport {
                     }
                 }
                 while (pendingExecutions.length > 0) {
-                    const next = await waitForNextExecutionOrUpdate(pendingExecutions, toolUpdateQueue);
-                    if (next.kind === "update") {
-                        yield next.event;
-                        continue;
-                    }
-                    const outcome = next.outcome;
-                    for (const event of emitToolResult(outcome.message, next.execution.toolCall, outcome.isError, {
-                        toolExecutionId: outcome.toolExecutionId,
-                        approvalRequestId: outcome.approvalRequestId,
-                    })) {
+                    for (const event of await resolveNextPendingExecution()) {
                         yield event;
                     }
-                    await checkSteering();
                 }
-                this.safetyMiddleware.clearCredentials();
                 if (steeringTriggered && remainingToolCalls.length > 0) {
                     for (const toolCall of remainingToolCalls) {
                         for (const event of emitSkippedToolCall(toolCall)) {
@@ -775,6 +2315,11 @@ export class ProviderTransport {
                         }
                     }
                 }
+                const toolPhaseSummary = buildToolPhaseSummary();
+                if (toolPhaseSummary) {
+                    yield toolPhaseSummary;
+                }
+                this.safetyMiddleware.clearCredentials();
                 if (!steeringTriggered && getSteeringMessages) {
                     const steering = await getSteeringMessages();
                     if (steering.length > 0) {