🤖 fix: run forked task tool calls in parallel again

Exempt only provably-isolated `task` tool calls from the per-stream
sequential-execution mutex, restoring parallel sub-agent launches without
reintroducing shared-working-tree races.

#2906 serializes every sibling tool execute() in a stream behind one mutex
to prevent races on shared mutable state. That also serializes parallel
`task` launches: only the first runs, the rest block on the long
foreground waitForAgentReport.

A forking `task` runs in its own isolated checkout and shares no mutable
state with sibling tools, so it is safe to run in parallel. But a `task`
that runs in the PARENT checkout (local runtime, or worktree/ssh with
isolation:"none") shares the working tree and must stay serialized.

Decide per call, by runtime mode + isolation arg, via the new
taskCallSharesParentWorkspace() helper. runtimeMode is threaded
(optionally, defaulting to serialize) from the AIService send path into
the stream-request builder. All other tools remain fully serialized.

Author: ethanndickson

src/common/types/runtime.test.ts

@@ -5,6 +5,7 @@ import {
   parseRuntimeModeAndHost,
   RUNTIME_MODE,
   runtimeModeSupportsSharedTaskWorkspace,
+  taskCallSharesParentWorkspace,
 } from "./runtime";
 
 describe("runtimeModeSupportsSharedTaskWorkspace", () => {
@@ -21,6 +22,19 @@ describe("runtimeModeSupportsSharedTaskWorkspace", () => {
   });
 });
 
+describe("taskCallSharesParentWorkspace", () => {
+  it("matches the runtime/isolation sharing matrix", () => {
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.LOCAL, undefined)).toBe(true);
+    expect(taskCallSharesParentWorkspace(undefined, undefined)).toBe(true);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.WORKTREE, undefined)).toBe(false);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.WORKTREE, "none")).toBe(true);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.WORKTREE, "fork")).toBe(false);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.SSH, "none")).toBe(true);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.DOCKER, undefined)).toBe(false);
+    expect(taskCallSharesParentWorkspace(RUNTIME_MODE.DEVCONTAINER, undefined)).toBe(false);
+  });
+});
+
 describe("parseRuntimeModeAndHost", () => {
   it("parses SSH mode with host", () => {
     expect(parseRuntimeModeAndHost("ssh user@host")).toEqual({

src/common/types/runtime.ts

@@ -47,6 +47,26 @@ export function runtimeModeSupportsSharedTaskWorkspace(mode: RuntimeMode | undef
   return mode != null && SHARED_TASK_WORKSPACE_RUNTIME_MODES.includes(mode);
 }
 
+/**
+ * Whether a `task` tool call will run in the PARENT workspace's checkout (shared working tree)
+ * instead of an isolated fork. Sibling tool calls that mutate the shared tree must be serialized
+ * against such a task; forking task calls are isolated and safe to run in parallel.
+ *
+ * - local (or unknown runtime): forking is a no-op / unknown — treat as shared (serialize).
+ * - worktree/ssh: shares only when the model opts in via `isolation: "none"`.
+ * - docker/devcontainer: always fork, so never shared.
+ *
+ * `isolation` is typed `unknown` so callers can pass raw, pre-validation tool args.
+ */
+export function taskCallSharesParentWorkspace(
+  mode: RuntimeMode | undefined,
+  isolation: unknown
+): boolean {
+  if (mode == null || mode === RUNTIME_MODE.LOCAL) return true;
+  if (!runtimeModeSupportsSharedTaskWorkspace(mode)) return false;
+  return isolation === "none";
+}
+
 /**
  * Runtime IDs that can be enabled/disabled in Settings → Runtimes.
  * Note: includes "coder" which is a UI-level choice (not a RuntimeMode).

src/node/services/aiService.ts

@@ -2671,7 +2671,8 @@ export class AIService extends EventEmitter {
             }
           : undefined,
         runtimeTempDir,
-        modelFallback
+        modelFallback,
+        runtimeType
       );
       recordStartupPhaseTiming("startStreamMs", startStreamStartedAt);
 

src/node/services/streamManager.ts

@@ -57,6 +57,7 @@ import { stripWorkflowRunRecordsFromModelMessages } from "@/node/utils/messages/
 import { normalizeToCanonical } from "@/common/utils/ai/models";
 import { MUX_GATEWAY_SESSION_EXPIRED_MESSAGE } from "@/common/constants/muxGatewayOAuth";
 import { getModelStats, getModelStatsResolved } from "@/common/utils/tokens/modelStats";
+import type { RuntimeMode } from "@/common/types/runtime";
 import { withSequentialExecution } from "@/node/services/tools/withSequentialExecution";
 import type { ResolvedCallSettingsOverrides } from "@/common/config/schemas/modelParameters";
 import { resolveModelForMetadata } from "@/common/utils/providers/modelEntries";
@@ -488,6 +489,7 @@ interface WorkspaceStreamInfo {
   metadataModel: string;
   /** Effective thinking level after model policy clamping */
   thinkingLevel?: string;
+  runtimeMode?: RuntimeMode;
   initialMetadata?: Partial<MuxMetadata>;
   toolModelUsages: PersistedToolModelUsage[];
   request: StreamRequestConfig;
@@ -1288,7 +1290,8 @@ export class StreamManager extends EventEmitter {
     headers?: Record<string, string | undefined>,
     anthropicCacheTtlOverride?: AnthropicCacheTtl,
     onChunk?: StreamTextOnChunk,
-    onStepMessages?: (messages: ModelMessage[]) => void
+    onStepMessages?: (messages: ModelMessage[]) => void,
+    runtimeMode?: RuntimeMode
   ): StreamRequestConfig {
     const finalProviderOptions = providerOptions;
 
@@ -1335,7 +1338,7 @@ export class StreamManager extends EventEmitter {
       system: finalSystem,
       // Keep provider-level parallel tool planning enabled, but serialize sibling
       // execute() handlers inside this stream so shared mutable state cannot race.
-      tools: withSequentialExecution(finalTools),
+      tools: withSequentialExecution(finalTools, runtimeMode),
       providerOptions: finalProviderOptions,
       headers,
       maxOutputTokens: effectiveMaxOutputTokens,
@@ -1469,7 +1472,8 @@ export class StreamManager extends EventEmitter {
     anthropicCacheTtlOverride?: AnthropicCacheTtl,
     onChunk?: StreamTextOnChunk,
     onStepMessages?: (messages: ModelMessage[]) => void,
-    modelFallback?: ModelFallbackOptions
+    modelFallback?: ModelFallbackOptions,
+    runtimeMode?: RuntimeMode
   ): WorkspaceStreamInfo {
     // abortController is created and linked to the caller-provided abortSignal in startStream().
 
@@ -1489,7 +1493,8 @@ export class StreamManager extends EventEmitter {
       headers,
       anthropicCacheTtlOverride,
       onChunk,
-      onStepMessages
+      onStepMessages,
+      runtimeMode
     );
 
     // Start streaming - this can throw immediately if API key is missing
@@ -1517,6 +1522,7 @@ export class StreamManager extends EventEmitter {
       model: modelString,
       metadataModel,
       thinkingLevel,
+      runtimeMode,
       initialMetadata,
       toolModelUsages: [],
       didRetryPreviousResponseIdAtStep: false,
@@ -2133,7 +2139,8 @@ export class StreamManager extends EventEmitter {
       prepared.data.headers,
       prepared.data.anthropicCacheTtl,
       streamInfo.request.onChunk,
-      streamInfo.request.onStepMessages
+      streamInfo.request.onStepMessages,
+      streamInfo.runtimeMode
     );
     // createStreamResult may eagerly prepare the first fallback step and update
     // latestMessages. Clear stale source-step messages before starting it so a
@@ -3527,7 +3534,8 @@ export class StreamManager extends EventEmitter {
     onChunk?: StreamTextOnChunk,
     onStepMessages?: (messages: ModelMessage[]) => void,
     providedRuntimeTempDir?: string,
-    modelFallback?: ModelFallbackOptions
+    modelFallback?: ModelFallbackOptions,
+    runtimeMode?: RuntimeMode
   ): Promise<Result<StreamToken, SendMessageError>> {
     const typedWorkspaceId = workspaceId as WorkspaceId;
 
@@ -3610,7 +3618,8 @@ export class StreamManager extends EventEmitter {
           anthropicCacheTtlOverride,
           onChunk,
           onStepMessages,
-          modelFallback
+          modelFallback,
+          runtimeMode
         );
 
         // Guard against a narrow race: