@bastani/atomic 0.9.26 → 0.9.27-alpha.1

package/dist/builtin/subagents/src/extension/index.bundle.mjs

@@ -8001,6 +8001,25 @@ function presentCancelledStatus(status, cause) {
 }
 
 // dist/builtin/subagents/src/runs/shared/parallel-utils.ts
+function createExecutionScheduler(limit) {
+  let active = 0;
+  const queued = [];
+  const pump = () => {
+    while (active < limit && queued.length > 0) {
+      const dispatch = queued.shift();
+      active++;
+      const release = () => {
+        active--;
+        pump();
+      };
+      dispatch().then(release, release);
+    }
+  };
+  return (dispatch) => {
+    queued.push(dispatch);
+    pump();
+  };
+}
 async function mapConcurrent(items, limit, fn) {
   const safeLimit = Math.max(1, Math.floor(limit) || 1);
   const results = new Array(items.length);
@@ -11703,6 +11722,119 @@ function resolveRequestedCwd(runtimeCwd, requestedCwd) {
   return requestedCwd ? path11.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
 
+// dist/builtin/subagents/src/runs/foreground/subagent-executor-input.ts
+function validateExecutionInput(params, agents, hasTasks, hasSingle, parallelAgentConfigs) {
+  if (Number(hasTasks) + Number(hasSingle) !== 1) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Provide exactly one mode. Agents: ${agents.map((a) => a.name).join(", ") || "none"}`
+        }
+      ],
+      isError: true,
+      details: { mode: "single", results: [] }
+    };
+  }
+  if (hasSingle) {
+    const reads = params.reads;
+    if (reads !== undefined && reads !== false && (!Array.isArray(reads) || reads.some((entry) => typeof entry !== "string"))) {
+      return {
+        content: [{ type: "text", text: "reads must be an array of file path strings or false" }],
+        isError: true,
+        details: { mode: "single", results: [] }
+      };
+    }
+  }
+  if (hasSingle && params.agent && !agents.find((agent) => agent.name === params.agent)) {
+    return {
+      content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
+      isError: true,
+      details: { mode: "single", results: [] }
+    };
+  }
+  if (hasTasks && params.tasks) {
+    for (let i = 0;i < params.tasks.length; i++) {
+      const task = params.tasks[i];
+      const agent = parallelAgentConfigs?.[i] ?? agents.find((candidate) => candidate.name === task.agent);
+      if (!agent || agent.name !== task.agent) {
+        return {
+          content: [{ type: "text", text: `Unknown agent: ${task.agent} (task ${i + 1})` }],
+          isError: true,
+          details: { mode: "parallel", results: [] }
+        };
+      }
+    }
+  }
+  return null;
+}
+function getRequestedModeLabel(params) {
+  if ((params.tasks?.length ?? 0) > 0)
+    return "parallel";
+  if (params.agent)
+    return "single";
+  return "single";
+}
+function applyAgentDefaultContext(params, agents) {
+  if (params.context !== undefined)
+    return params;
+  const byName = new Map(agents.map((agent) => [agent.name, agent]));
+  const names = [];
+  if (params.agent)
+    names.push(params.agent);
+  for (const task of params.tasks ?? [])
+    names.push(task.agent);
+  return names.some((name) => byName.get(name)?.defaultContext === "fork") ? { ...params, context: "fork" } : params;
+}
+function buildRequestedModeError(params, message) {
+  return withForkContext({
+    content: [{ type: "text", text: message }],
+    isError: true,
+    details: { mode: getRequestedModeLabel(params), results: [] }
+  }, params.context);
+}
+function expandTopLevelTaskCounts(tasks) {
+  const expanded = [];
+  for (let taskIndex = 0;taskIndex < tasks.length; taskIndex++) {
+    const task = tasks[taskIndex];
+    const rawCount = task.count;
+    if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
+      return { error: `tasks[${taskIndex}].count must be an integer >= 1` };
+    }
+    const { count: _count, ...concreteTask } = task;
+    for (let repeat = 0;repeat < (rawCount ?? 1); repeat++)
+      expanded.push({ ...concreteTask });
+  }
+  return { tasks: expanded };
+}
+function normalizeRepeatedParallelCounts(params) {
+  if (!params.tasks)
+    return { params };
+  const expandedTasks = expandTopLevelTaskCounts(params.tasks);
+  if (expandedTasks.error)
+    return { error: buildRequestedModeError(params, expandedTasks.error) };
+  return { params: { ...params, tasks: expandedTasks.tasks } };
+}
+function withForkContext(result, context) {
+  if (context !== "fork" || !result.details)
+    return result;
+  return {
+    ...result,
+    details: {
+      ...result.details,
+      context: "fork"
+    }
+  };
+}
+function toExecutionErrorResult(params, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return withForkContext({
+    content: [{ type: "text", text: message }],
+    isError: true,
+    details: { mode: getRequestedModeLabel(params), results: [] }
+  }, params.context);
+}
+
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-live-update.ts
 var liveResultIndices = new WeakMap;
 function markLiveResultIndices(result, indices) {
@@ -11720,95 +11852,410 @@ function getParentAskHandoff(result) {
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-types.ts
 var BURST_TASK_DISCOVERY_CWD = Symbol("burstTaskDiscoveryCwd");
+var BURST_EXECUTION_SCHEDULE = Symbol("burstExecutionSchedule");
 function isManagementActionsRestricted(deps) {
   return deps.childPolicy ? deps.childPolicy.managementActions === "restricted" : deps.allowMutatingManagementActions === false;
 }
 
-// dist/builtin/subagents/src/runs/foreground/subagent-executor-burst.ts
-var SHARED_FIELDS = [
-  "concurrency",
-  "worktree",
-  "context",
-  "share",
-  "control",
-  "sessionDir",
-  "maxOutput",
-  "artifacts",
-  "includeProgress",
-  "agentScope"
-];
-function incompatibleField(items) {
-  const first = items[0].params;
-  for (const field of SHARED_FIELDS) {
-    for (let index = 1;index < items.length; index++) {
-      if (!isDeepStrictEqual(first[field], items[index].params[field]))
-        return field;
-    }
-  }
-  return;
-}
-function incompatibleFieldResult(field) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Cannot coalesce sibling subagent calls: incompatible top-level field '${field}'.`
-      }
-    ],
-    isError: true,
-    details: { mode: "parallel", results: [] }
-  };
+// dist/builtin/subagents/src/runs/foreground/task-output-retention.ts
+import { mkdtempSync, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join11 } from "node:path";
+var INLINE_TASK_OUTPUT_MAX_BYTES = 16 * 1024;
+var MAX_RETAINED_TASK_OUTPUTS = 256;
+var retained = new Map;
+var copyRoot;
+function retentionKey(ownerId, taskId) {
+  return `${ownerId}\x00${taskId}`;
 }
-function incompatibleWorktreeCwdResult() {
-  return {
-    content: [
-      {
-        type: "text",
-        text: "Cannot coalesce sibling subagent calls: incompatible top-level field 'cwd' for worktree."
-      }
-    ],
-    isError: true,
-    details: { mode: "parallel", results: [] }
-  };
+function fileSafe(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "_");
 }
-function taskExpandedLength(task) {
-  const count = task.count;
-  return typeof count === "number" && Number.isInteger(count) && count >= 1 ? count : 1;
+function privateCopyRoot() {
+  if (copyRoot)
+    return copyRoot;
+  const root = mkdtempSync(join11(tmpdir2(), "atomic-subagent-output-"));
+  copyRoot = root;
+  process.once("exit", () => rmSync2(root, { recursive: true, force: true }));
+  return root;
 }
-function originatingCallCwd(item) {
-  return resolveRequestedCwd(item.ctx.cwd, item.params.cwd);
+function removeCopy(entry) {
+  if (entry?.path)
+    rmSync2(entry.path, { force: true });
 }
-function originatingTaskCwd(callCwd, taskCwd) {
-  return resolveRequestedCwd(callCwd, taskCwd);
+function fullOutputText(child, text) {
+  if (child.outputMode !== "file-only" || !child.outputReference)
+    return text;
+  try {
+    return readFileSync8(child.outputReference.path, "utf-8");
+  } catch {
+    return text;
+  }
 }
-function topLevelSingleTask(item) {
-  if (!item.params.agent)
+function writePrivateCopy(ownerId, taskId, text) {
+  try {
+    const path = join11(privateCopyRoot(), `${fileSafe(ownerId)}-${fileSafe(taskId)}.md`);
+    writeFileSync4(path, text, { encoding: "utf-8", mode: 384 });
+    return path;
+  } catch {
     return;
-  const callCwd = originatingCallCwd(item);
-  return {
-    agent: item.params.agent,
-    task: item.params.task ?? "",
-    cwd: originatingTaskCwd(callCwd, undefined),
-    [BURST_TASK_DISCOVERY_CWD]: callCwd,
-    ...item.params.output !== undefined ? { output: item.params.output } : {},
-    ...item.params.outputMode !== undefined ? { outputMode: item.params.outputMode } : {},
-    ...item.params.reads !== undefined ? { reads: item.params.reads } : {},
-    ...item.params.progress !== undefined ? { progress: item.params.progress } : {},
-    ...item.params.model !== undefined ? { model: item.params.model } : {},
-    ...item.params.modelConstraints !== undefined ? { modelConstraints: item.params.modelConstraints } : {},
-    ...item.params.taskNeeds !== undefined ? { taskNeeds: item.params.taskNeeds } : {},
-    ...item.params.skill !== undefined ? { skill: item.params.skill } : {},
-    ...item.params.group !== undefined ? { group: item.params.group } : {}
-  };
+  }
 }
-function existingParallelTask(item, task) {
-  const callCwd = originatingCallCwd(item);
-  return {
-    ...task,
-    cwd: originatingTaskCwd(callCwd, task.cwd),
-    [BURST_TASK_DISCOVERY_CWD]: callCwd,
-    ...task.group === undefined && item.params.group !== undefined ? { group: item.params.group } : {}
-  };
+function retainTaskOutput(child, text, ref) {
+  const bytes = Buffer.from(text);
+  const path = writePrivateCopy(ref.ownerId, ref.taskId, fullOutputText(child, text));
+  const key = retentionKey(ref.ownerId, ref.taskId);
+  removeCopy(retained.get(key));
+  retained.delete(key);
+  retained.set(key, {
+    ...path ? { path } : {},
+    ...child.outputReference ? { requestedPath: child.outputReference.path } : {},
+    ...child.outputSaveError ? { saveError: child.outputSaveError } : {},
+    head: new TextDecoder().decode(bytes.subarray(0, INLINE_TASK_OUTPUT_MAX_BYTES)),
+    totalBytes: bytes.byteLength
+  });
+  while (retained.size > MAX_RETAINED_TASK_OUTPUTS) {
+    const oldest = retained.keys().next().value;
+    if (oldest === undefined)
+      break;
+    removeCopy(retained.get(oldest));
+    retained.delete(oldest);
+  }
+}
+function retainedTaskOutput(ownerId, taskId) {
+  return retained.get(retentionKey(ownerId, taskId));
+}
+
+// dist/builtin/subagents/src/runs/foreground/task-execution.ts
+function subagentTaskResultLabel(result) {
+  return result.kind === "cancelled" && result.cause === "user" ? "killed (non-resumable)" : result.kind;
+}
+function subagentTaskResponseText(response) {
+  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
+  const killed = outcomes.filter((outcome) => outcome.kind === "admitted" && outcome.observation.kind === "settled" && subagentTaskResultLabel(outcome.observation.result) === "killed (non-resumable)");
+  return `${killed.length ? `${killed.length} killed. These children cannot be resumed. Underlying host response:
+` : ""}${JSON.stringify(response)}`;
+}
+function settledOutputsFromResponse(response) {
+  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
+  return outcomes.flatMap((outcome) => outcome.kind === "admitted" && outcome.observation.kind === "settled" ? [{ taskId: outcome.observation.taskId, result: outcome.observation.result }] : []);
+}
+function settledOutputsFromRecords(records) {
+  return records.flatMap((record) => record.execution.kind === "settled" ? [{ taskId: record.ref.taskId, result: record.execution.result }] : []);
+}
+function settledOutputSection(taskId, label, output) {
+  const truncated = output.shown < output.total ? `, first ${output.shown} shown${output.path ? "; read the full output file for the rest" : ""}` : "";
+  const lines = [`Output of ${taskId} (${label}, ${output.total} bytes${truncated}):`];
+  if (output.requestedPath)
+    lines.push(`Requested output: ${output.requestedPath}`);
+  if (output.saveError)
+    lines.push(`Output file error: ${output.saveError}`);
+  if (output.path)
+    lines.push(`Full output: ${output.path}`);
+  lines.push(output.head);
+  return lines.join(`
+`);
+}
+async function readSettledOutput(host, settled) {
+  const output = settled.result.output;
+  if (!output)
+    return;
+  const label = subagentTaskResultLabel(settled.result);
+  const kept = retainedTaskOutput(output.ownerId, output.taskId);
+  if (kept) {
+    return settledOutputSection(settled.taskId, label, {
+      ...kept,
+      shown: Math.min(kept.totalBytes, INLINE_TASK_OUTPUT_MAX_BYTES),
+      total: kept.totalBytes
+    });
+  }
+  const unavailable = (reason) => `Output of ${settled.taskId} (${label}) is unavailable: ${reason}`;
+  const lease = host.resolveTask(settled.taskId);
+  if (!lease.ok)
+    return unavailable(lease.error.message);
+  try {
+    const page = await host.ownerBinding.supervisor.readTaskOutput(lease.value, {
+      start: "0",
+      maximumBytes: INLINE_TASK_OUTPUT_MAX_BYTES
+    });
+    if (!page.ok)
+      return unavailable(page.error.message);
+    const decoder = new TextDecoder;
+    const head = page.value.chunks.map((chunk) => decoder.decode(chunk.bytes, { stream: true })).join("") + decoder.decode();
+    const shown = page.value.chunks.reduce((sum, chunk) => sum + chunk.bytes.byteLength, 0);
+    return settledOutputSection(settled.taskId, label, { head, shown, total: Number(output.byteCount) });
+  } catch (error) {
+    return unavailable(error instanceof Error ? error.message : String(error));
+  }
+}
+async function settledTaskOutputText(host, settled) {
+  if (!host || settled.length === 0)
+    return "";
+  const sections = await Promise.all(settled.map((entry) => readSettledOutput(host, entry)));
+  const present = sections.filter((section) => section !== undefined);
+  return present.length ? `
+
+${present.join(`
+
+`)}` : "";
+}
+function taskToolResult(response, host) {
+  return {
+    content: [{ type: "text", text: subagentTaskResponseText(response) }],
+    details: {
+      mode: "single",
+      results: [],
+      taskResponse: response,
+      taskRecords: taskResponseRecords(response, host)
+    },
+    ...response.kind === "unstarted" ? { isError: true } : {}
+  };
+}
+async function taskToolResultWithOutput(response, host) {
+  const result = taskToolResult(response, host);
+  const outputText = await settledTaskOutputText(host, settledOutputsFromResponse(response));
+  if (!outputText)
+    return result;
+  return {
+    ...result,
+    content: [{ type: "text", text: `${subagentTaskResponseText(response)}${outputText}` }]
+  };
+}
+async function parallelTaskToolResultWithOutput(response, host) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `${subagentTaskResponseText(response)}${await settledTaskOutputText(host, settledOutputsFromResponse(response))}`
+      }
+    ],
+    details: {
+      mode: "parallel",
+      results: [],
+      taskResponse: response,
+      taskRecords: taskResponseRecords(response, host)
+    }
+  };
+}
+function taskResponseRecords(response, host) {
+  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
+  const ids = new Set(outcomes.flatMap((outcome) => outcome.kind === "admitted" ? [outcome.observation.taskId] : []));
+  const watched = host?.watchOwnerTasks();
+  if (!watched?.ok)
+    return [];
+  try {
+    return watched.value.snapshot.tasks.filter((task) => ids.has(task.ref.taskId));
+  } finally {
+    watched.value.dispose();
+  }
+}
+async function runAgentTask(input) {
+  let yieldWait;
+  let pendingYield = false;
+  let parentObserving = input.wait?.kind === "foreground";
+  const registered = Promise.withResolvers();
+  input.options.modelRoute?.assertCurrent();
+  const started = await input.host.startAgentTask({
+    kind: "agent",
+    agent: input.agent,
+    task: input.intentTask ?? input.task,
+    cwd: input.options.cwd ?? input.cwd,
+    ...input.options.modelRoute ? { routerSelection: input.options.modelRoute.routerSelection } : {}
+  }, `${input.options.runId}:${input.options.index ?? 0}`, (context) => {
+    const cleaned = Promise.withResolvers();
+    let executionBound = false;
+    const result = registered.promise.then(async () => {
+      try {
+        input.options.modelRoute?.assertCurrent();
+        const child = await input.runtime.runSync(input.cwd, input.agents, input.agent, input.task, {
+          ...input.options,
+          signal: context.signal,
+          taskExecution: {
+            signal: context.signal,
+            reportActivity: context.reportActivity,
+            bindTranscript: (session) => context.bindTranscript({
+              getSessionId: () => session.getSessionId(),
+              getEntries: () => session.getEntries(),
+              ...session.subscribe ? { subscribe: session.subscribe.bind(session) } : {},
+              ...session.getStreamingMessage ? { getStreamingMessage: session.getStreamingMessage.bind(session) } : {},
+              ...input.options.intercomSessionName ? {
+                completionSource: {
+                  runId: input.options.runId,
+                  intercomTarget: input.options.intercomSessionName
+                }
+              } : {}
+            }),
+            onExecution: (execution) => {
+              executionBound = true;
+              execution.cleanup.then(cleaned.resolve, (error) => cleaned.resolve({
+                kind: "failed",
+                resources: [{ resource: "agent-session", code: "CleanupFailed", message: String(error) }]
+              }));
+            },
+            yieldTaskWait: () => {
+              parentObserving = false;
+              if (yieldWait)
+                yieldWait("intercom-coordination");
+              else
+                pendingYield = true;
+            },
+            isParentObserving: () => parentObserving
+          }
+        });
+        if (child.model !== undefined || child.thinking !== undefined)
+          context.reportActivity({
+            reportId: "terminal-model",
+            change: { kind: "model", model: child.model, thinking: child.thinking }
+          });
+        input.onTerminal?.(child);
+        const text = input.outputText?.(child) ?? getSingleResultOutput(child);
+        retainTaskOutput(child, text, context.ref);
+        const bytes = Buffer.from(text);
+        context.reportActivity({
+          reportId: "terminal-output",
+          change: { kind: "output", offset: "0", bytesBase64: bytes.toString("base64") }
+        });
+        const output = {
+          ownerId: context.ref.ownerId,
+          taskId: context.ref.taskId,
+          artifactId: `output:${context.ref.taskId}`,
+          byteCount: String(bytes.length),
+          omittedRanges: []
+        };
+        if (child.status === "killed")
+          return { kind: "cancelled", cause: "user", output };
+        if (child.interrupted)
+          return {
+            kind: "cancelled",
+            cause: input.options.interruptSignal?.aborted ? "parent-handoff" : "owner-close",
+            output
+          };
+        return child.status === "ok" ? { kind: "completed", output } : {
+          kind: "failed",
+          code: "AgentFailed",
+          message: child.error ?? child.envelope ?? "Agent failed",
+          output
+        };
+      } finally {
+        if (!executionBound)
+          cleaned.resolve({ kind: "reaped" });
+      }
+    });
+    return { result, cleanup: cleaned.promise };
+  }, input.schedule);
+  if (!started.ok)
+    return { kind: "unstarted", reason: { kind: "rejected", error: started.error } };
+  const yieldForIntercom = () => {
+    parentObserving = false;
+    if (yieldWait)
+      yieldWait("intercom-coordination");
+    else
+      pendingYield = true;
+  };
+  input.options.intercomDetachSignal?.addEventListener("abort", yieldForIntercom, { once: true });
+  if (input.options.intercomDetachSignal?.aborted)
+    yieldForIntercom();
+  const observation = input.host.observeAgentLaunch(started.value.taskId, input.wait, (yieldRegistered) => {
+    yieldWait = yieldRegistered;
+    if (pendingYield)
+      yieldRegistered("intercom-coordination");
+    registered.resolve();
+  });
+  registered.resolve();
+  const observed = await observation.finally(() => {
+    parentObserving = false;
+    input.options.intercomDetachSignal?.removeEventListener("abort", yieldForIntercom);
+  });
+  if (!observed.ok)
+    throw new Error(`${observed.error.code}: ${observed.error.message}`);
+  return { kind: "admitted", observation: observed.value };
+}
+
+// dist/builtin/subagents/src/runs/foreground/subagent-executor-burst.ts
+var SHARED_FIELDS = [
+  "concurrency",
+  "worktree",
+  "context",
+  "share",
+  "control",
+  "sessionDir",
+  "maxOutput",
+  "artifacts",
+  "includeProgress",
+  "agentScope"
+];
+function incompatibleField(items) {
+  const first = items[0].params;
+  for (const field of SHARED_FIELDS) {
+    for (let index = 1;index < items.length; index++) {
+      if (!isDeepStrictEqual(first[field], items[index].params[field]))
+        return field;
+    }
+  }
+  return;
+}
+function incompatibleFieldResult(field) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Cannot coalesce sibling subagent calls: incompatible top-level field '${field}'.`
+      }
+    ],
+    isError: true,
+    details: { mode: "parallel", results: [] }
+  };
+}
+function incompatibleWorktreeCwdResult() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Cannot coalesce sibling subagent calls: incompatible top-level field 'cwd' for worktree."
+      }
+    ],
+    isError: true,
+    details: { mode: "parallel", results: [] }
+  };
+}
+function taskExpandedLength(task) {
+  const count = task.count;
+  return typeof count === "number" && Number.isInteger(count) && count >= 1 ? count : 1;
+}
+function originatingCallCwd(item) {
+  return resolveRequestedCwd(item.ctx.cwd, item.params.cwd);
+}
+function originatingTaskCwd(callCwd, taskCwd) {
+  return resolveRequestedCwd(callCwd, taskCwd);
+}
+function topLevelSingleTask(item) {
+  if (!item.params.agent)
+    return;
+  const callCwd = originatingCallCwd(item);
+  return {
+    agent: item.params.agent,
+    task: item.params.task ?? "",
+    cwd: originatingTaskCwd(callCwd, undefined),
+    [BURST_TASK_DISCOVERY_CWD]: callCwd,
+    ...item.params.output !== undefined ? { output: item.params.output } : {},
+    ...item.params.outputMode !== undefined ? { outputMode: item.params.outputMode } : {},
+    ...item.params.reads !== undefined ? { reads: item.params.reads } : {},
+    ...item.params.progress !== undefined ? { progress: item.params.progress } : {},
+    ...item.params.model !== undefined ? { model: item.params.model } : {},
+    ...item.params.modelConstraints !== undefined ? { modelConstraints: item.params.modelConstraints } : {},
+    ...item.params.taskNeeds !== undefined ? { taskNeeds: item.params.taskNeeds } : {},
+    ...item.params.skill !== undefined ? { skill: item.params.skill } : {},
+    ...item.params.group !== undefined ? { group: item.params.group } : {}
+  };
+}
+function existingParallelTask(item, task) {
+  const callCwd = originatingCallCwd(item);
+  return {
+    ...task,
+    cwd: originatingTaskCwd(callCwd, task.cwd),
+    [BURST_TASK_DISCOVERY_CWD]: callCwd,
+    ...task.group === undefined && item.params.group !== undefined ? { group: item.params.group } : {}
+  };
 }
 function mergeBurst(items) {
   const field = incompatibleField(items);
@@ -11835,6 +12282,7 @@ function mergeBurst(items) {
     params: {
       ...commonCwd ? { cwd: commonCwd } : {},
       tasks,
+      wait: first.wait,
       concurrency: first.concurrency,
       worktree: first.worktree,
       context: first.context,
@@ -11930,6 +12378,19 @@ function projectResult(result, route, live = false) {
     }
   };
 }
+function isSingleResponse(outcome) {
+  return outcome.kind === "admitted" || outcome.reason.kind === "rejected";
+}
+async function projectOwnerResult(result, route, item, ctx) {
+  const response = result.details?.taskResponse;
+  if (response?.kind !== "parallel")
+    return;
+  const slots = response.slots.slice(route.start, route.start + route.length).map((slot, ordinal) => ({ ...slot, ordinal }));
+  const host = ctx.getAgentTaskHost?.();
+  const own = slots.length === 1 ? slots[0].outcome : undefined;
+  const projected = item.params.agent !== undefined && own !== undefined && isSingleResponse(own) ? await taskToolResultWithOutput(own, host) : await parallelTaskToolResultWithOutput({ kind: "parallel", slots }, host);
+  return withForkContext(projected, item.params.context ?? result.details?.context);
+}
 function resolveItem(item, result) {
   if (item.settled)
     return;
@@ -11965,19 +12426,30 @@ function observeLaterAbort(item) {
   }
   return cleanup;
 }
+function groupByWait(items) {
+  const groups = [];
+  for (const item of items) {
+    const group = groups.find((candidate) => isDeepStrictEqual(candidate[0].params.wait, item.params.wait));
+    if (group)
+      group.push(item);
+    else
+      groups.push([item]);
+  }
+  return groups;
+}
 function createExecutionBurstDispatcher(input) {
   let queue = [];
   let flushScheduled = false;
-  const run = async (items) => {
+  const run = async (items, finish, schedule) => {
     if (items.length === 1) {
       const item = items[0];
-      input.setActive(true);
+      const params = schedule ? { ...item.params, [BURST_EXECUTION_SCHEDULE]: schedule } : item.params;
       try {
-        item.resolve(await input.execute(item.id, item.params, item.signal, item.onUpdate, item.ctx));
+        item.resolve(await input.execute(item.id, params, item.signal, item.onUpdate, item.ctx));
       } catch (error) {
         item.reject(error instanceof Error ? error : new Error(String(error)));
       } finally {
-        input.setActive(false);
+        finish();
       }
       return;
     }
@@ -11991,8 +12463,11 @@ function createExecutionBurstDispatcher(input) {
       for (const item of items)
         resolveItem(item, merged.error);
       cleanupLaterAborts();
+      finish();
       return;
     }
+    if (schedule)
+      merged.params[BURST_EXECUTION_SCHEDULE] = schedule;
     const first = items[0];
     const display = registerBurstDisplay(items.map((item) => item.id), merged.routes.reduce((total, route) => total + route.length, 0));
     const onUpdate = (update) => {
@@ -12003,27 +12478,38 @@ function createExecutionBurstDispatcher(input) {
           item.onUpdate?.(projectResult(update, merged.routes[index], true));
       }
     };
-    input.setActive(true);
     try {
       const result = await input.execute(first.id, merged.params, first.signal, onUpdate, first.ctx);
       updateBurstDisplay(display, result);
-      for (let index = 0;index < items.length; index++) {
-        resolveItem(items[index], projectResult(result, merged.routes[index]));
-      }
+      const projections = await Promise.all(items.map(async (item, index) => await projectOwnerResult(result, merged.routes[index], item, first.ctx) ?? projectResult(result, merged.routes[index])));
+      for (let index = 0;index < items.length; index++)
+        resolveItem(items[index], projections[index]);
     } catch (error) {
       const rejection = error instanceof Error ? error : new Error(String(error));
       for (const item of items)
         rejectItem(item, rejection);
     } finally {
-      input.setActive(false);
       cleanupLaterAborts();
+      finish();
     }
   };
+  const runBurst = (items) => {
+    const groups = groupByWait(items);
+    const schedule = groups.length > 1 ? createExecutionScheduler(Math.min(...items.map((item) => resolveTopLevelParallelConcurrency(item.params.concurrency, input.concurrencyLimit)))) : undefined;
+    let remaining = groups.length;
+    input.setActive(true);
+    const finish = () => {
+      if (--remaining === 0)
+        input.setActive(false);
+    };
+    for (const group of groups)
+      run(group, finish, schedule);
+  };
   const flush = () => {
     flushScheduled = false;
     const items = queue;
     queue = [];
-    run(items);
+    runBurst(items);
   };
   return (id, params, signal, onUpdate, ctx) => {
     if (input.isActive())
@@ -12162,144 +12648,31 @@ Create and maintain progress at: ${path12.join(progressDir, "progress.md")}`;
 }
 function buildTaskInstructions(behavior, cwd, isFirstProgressAgent) {
   const prefixParts = [];
-  const suffixParts = [];
-  const readInstruction = buildReadInstruction(behavior.reads, cwd);
-  if (readInstruction)
-    prefixParts.push(readInstruction);
-  if (behavior.output) {
-    const outputPath = path12.isAbsolute(behavior.output) ? behavior.output : path12.join(cwd, behavior.output);
-    prefixParts.push(`[Write to: ${outputPath}]`);
-  }
-  if (behavior.progress) {
-    const progressPath = path12.join(cwd, "progress.md");
-    if (isFirstProgressAgent)
-      suffixParts.push(`Create and maintain progress at: ${progressPath}`);
-    else
-      suffixParts.push(`Update progress at: ${progressPath}`);
-  }
-  const prefix = prefixParts.length > 0 ? `${prefixParts.join(`
-`)}
-
-` : "";
-  const suffix = suffixParts.length > 0 ? `
-
----
-${suffixParts.join(`
-`)}` : "";
-  return { prefix, suffix };
-}
-
-// dist/builtin/subagents/src/runs/foreground/subagent-executor-input.ts
-function validateExecutionInput(params, agents, hasTasks, hasSingle, parallelAgentConfigs) {
-  if (Number(hasTasks) + Number(hasSingle) !== 1) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Provide exactly one mode. Agents: ${agents.map((a) => a.name).join(", ") || "none"}`
-        }
-      ],
-      isError: true,
-      details: { mode: "single", results: [] }
-    };
-  }
-  if (hasSingle) {
-    const reads = params.reads;
-    if (reads !== undefined && reads !== false && (!Array.isArray(reads) || reads.some((entry) => typeof entry !== "string"))) {
-      return {
-        content: [{ type: "text", text: "reads must be an array of file path strings or false" }],
-        isError: true,
-        details: { mode: "single", results: [] }
-      };
-    }
-  }
-  if (hasSingle && params.agent && !agents.find((agent) => agent.name === params.agent)) {
-    return {
-      content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
-      isError: true,
-      details: { mode: "single", results: [] }
-    };
-  }
-  if (hasTasks && params.tasks) {
-    for (let i = 0;i < params.tasks.length; i++) {
-      const task = params.tasks[i];
-      const agent = parallelAgentConfigs?.[i] ?? agents.find((candidate) => candidate.name === task.agent);
-      if (!agent || agent.name !== task.agent) {
-        return {
-          content: [{ type: "text", text: `Unknown agent: ${task.agent} (task ${i + 1})` }],
-          isError: true,
-          details: { mode: "parallel", results: [] }
-        };
-      }
-    }
-  }
-  return null;
-}
-function getRequestedModeLabel(params) {
-  if ((params.tasks?.length ?? 0) > 0)
-    return "parallel";
-  if (params.agent)
-    return "single";
-  return "single";
-}
-function applyAgentDefaultContext(params, agents) {
-  if (params.context !== undefined)
-    return params;
-  const byName = new Map(agents.map((agent) => [agent.name, agent]));
-  const names = [];
-  if (params.agent)
-    names.push(params.agent);
-  for (const task of params.tasks ?? [])
-    names.push(task.agent);
-  return names.some((name) => byName.get(name)?.defaultContext === "fork") ? { ...params, context: "fork" } : params;
-}
-function buildRequestedModeError(params, message) {
-  return withForkContext({
-    content: [{ type: "text", text: message }],
-    isError: true,
-    details: { mode: getRequestedModeLabel(params), results: [] }
-  }, params.context);
-}
-function expandTopLevelTaskCounts(tasks) {
-  const expanded = [];
-  for (let taskIndex = 0;taskIndex < tasks.length; taskIndex++) {
-    const task = tasks[taskIndex];
-    const rawCount = task.count;
-    if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
-      return { error: `tasks[${taskIndex}].count must be an integer >= 1` };
-    }
-    const { count: _count, ...concreteTask } = task;
-    for (let repeat = 0;repeat < (rawCount ?? 1); repeat++)
-      expanded.push({ ...concreteTask });
-  }
-  return { tasks: expanded };
-}
-function normalizeRepeatedParallelCounts(params) {
-  if (!params.tasks)
-    return { params };
-  const expandedTasks = expandTopLevelTaskCounts(params.tasks);
-  if (expandedTasks.error)
-    return { error: buildRequestedModeError(params, expandedTasks.error) };
-  return { params: { ...params, tasks: expandedTasks.tasks } };
-}
-function withForkContext(result, context) {
-  if (context !== "fork" || !result.details)
-    return result;
-  return {
-    ...result,
-    details: {
-      ...result.details,
-      context: "fork"
-    }
-  };
-}
-function toExecutionErrorResult(params, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return withForkContext({
-    content: [{ type: "text", text: message }],
-    isError: true,
-    details: { mode: getRequestedModeLabel(params), results: [] }
-  }, params.context);
+  const suffixParts = [];
+  const readInstruction = buildReadInstruction(behavior.reads, cwd);
+  if (readInstruction)
+    prefixParts.push(readInstruction);
+  if (behavior.output) {
+    const outputPath = path12.isAbsolute(behavior.output) ? behavior.output : path12.join(cwd, behavior.output);
+    prefixParts.push(`[Write to: ${outputPath}]`);
+  }
+  if (behavior.progress) {
+    const progressPath = path12.join(cwd, "progress.md");
+    if (isFirstProgressAgent)
+      suffixParts.push(`Create and maintain progress at: ${progressPath}`);
+    else
+      suffixParts.push(`Update progress at: ${progressPath}`);
+  }
+  const prefix = prefixParts.length > 0 ? `${prefixParts.join(`
+`)}
+
+` : "";
+  const suffix = suffixParts.length > 0 ? `
+
+---
+${suffixParts.join(`
+`)}` : "";
+  return { prefix, suffix };
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-context.ts
@@ -13374,400 +13747,102 @@ function formatWorktreeDiffSummary(diffs) {
       lines.push(diff.diffStat);
     }
     lines.push("");
-  }
-  const patchesDir = path18.dirname(changed[0].patchPath);
-  lines.push(`Full patches: ${patchesDir}`);
-  return lines.join(`
-`).trimEnd();
-}
-
-// dist/builtin/subagents/src/runs/foreground/detached-cleanup-barrier.ts
-function createDetachedCleanupBarrier(onReady) {
-  const recovered = new Set;
-  let expected;
-  let cleaned = false;
-  const finishIfReady = () => {
-    if (cleaned || !expected || ![...expected].every((index) => recovered.has(index)))
-      return;
-    cleaned = true;
-    onReady();
-  };
-  return {
-    recover(index) {
-      recovered.add(index);
-      finishIfReady();
-    },
-    defer(indices) {
-      if (indices.length === 0)
-        return false;
-      expected = new Set(indices);
-      finishIfReady();
-      return true;
-    }
-  };
-}
-
-// dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts
-import { join as join19 } from "node:path";
-
-// dist/builtin/subagents/src/runs/foreground/subagent-executor-worktree.ts
-import * as path19 from "node:path";
-function buildParallelModeError(message) {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true,
-    details: { mode: "parallel", results: [] }
-  };
-}
-function createParallelWorktreeSetup(enabled, cwd, runId, tasks, setupHook, setupHookTimeoutMs) {
-  if (!enabled)
-    return {};
-  try {
-    return {
-      setup: createWorktrees(cwd, runId, tasks.length, {
-        agents: tasks.map((task) => task.agent),
-        setupHook: setupHook ? { hookPath: setupHook, timeoutMs: setupHookTimeoutMs } : undefined
-      })
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { errorResult: buildParallelModeError(message) };
-  }
-}
-function buildParallelWorktreeTaskCwdError(tasks, sharedCwd) {
-  const conflict = findWorktreeTaskCwdConflict(tasks, sharedCwd);
-  if (!conflict)
-    return;
-  return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
-}
-function resolveParallelTaskCwd(task, paramsCwd, worktreeSetup, index) {
-  if (worktreeSetup)
-    return worktreeSetup.worktrees[index].agentCwd;
-  return resolveChildCwd(paramsCwd, task.cwd);
-}
-function buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks) {
-  if (!worktreeSetup)
-    return "";
-  const diffsDir = path19.join(artifactsDir, "worktree-diffs");
-  const diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
-  return formatWorktreeDiffSummary(diffs);
-}
-function findDuplicateParallelOutputPath(input) {
-  const seen = new Map;
-  for (let index = 0;index < input.tasks.length; index++) {
-    const behavior = input.behaviors[index];
-    if (!behavior?.output)
-      continue;
-    const task = input.tasks[index];
-    const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
-    const outputPath = resolveSingleOutputPath(behavior.output, input.ctxCwd, taskCwd);
-    if (!outputPath)
-      continue;
-    const previous = seen.get(outputPath);
-    if (previous) {
-      return `Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${outputPath}. Use distinct output paths.`;
-    }
-    seen.set(outputPath, { index, agent: task.agent });
-  }
-  return;
-}
-
-// dist/builtin/subagents/src/runs/foreground/task-output-retention.ts
-import { mkdtempSync, readFileSync as readFileSync11, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join18 } from "node:path";
-var INLINE_TASK_OUTPUT_MAX_BYTES = 16 * 1024;
-var MAX_RETAINED_TASK_OUTPUTS = 256;
-var retained = new Map;
-var copyRoot;
-function retentionKey(ownerId, taskId) {
-  return `${ownerId}\x00${taskId}`;
-}
-function fileSafe(value) {
-  return value.replace(/[^A-Za-z0-9._-]+/g, "_");
-}
-function privateCopyRoot() {
-  if (copyRoot)
-    return copyRoot;
-  const root = mkdtempSync(join18(tmpdir2(), "atomic-subagent-output-"));
-  copyRoot = root;
-  process.once("exit", () => rmSync3(root, { recursive: true, force: true }));
-  return root;
-}
-function removeCopy(entry) {
-  if (entry?.path)
-    rmSync3(entry.path, { force: true });
-}
-function fullOutputText(child, text) {
-  if (child.outputMode !== "file-only" || !child.outputReference)
-    return text;
-  try {
-    return readFileSync11(child.outputReference.path, "utf-8");
-  } catch {
-    return text;
-  }
-}
-function writePrivateCopy(ownerId, taskId, text) {
-  try {
-    const path = join18(privateCopyRoot(), `${fileSafe(ownerId)}-${fileSafe(taskId)}.md`);
-    writeFileSync8(path, text, { encoding: "utf-8", mode: 384 });
-    return path;
-  } catch {
-    return;
-  }
-}
-function retainTaskOutput(child, text, ref) {
-  const bytes = Buffer.from(text);
-  const path = writePrivateCopy(ref.ownerId, ref.taskId, fullOutputText(child, text));
-  const key = retentionKey(ref.ownerId, ref.taskId);
-  removeCopy(retained.get(key));
-  retained.delete(key);
-  retained.set(key, {
-    ...path ? { path } : {},
-    ...child.outputReference ? { requestedPath: child.outputReference.path } : {},
-    ...child.outputSaveError ? { saveError: child.outputSaveError } : {},
-    head: new TextDecoder().decode(bytes.subarray(0, INLINE_TASK_OUTPUT_MAX_BYTES)),
-    totalBytes: bytes.byteLength
-  });
-  while (retained.size > MAX_RETAINED_TASK_OUTPUTS) {
-    const oldest = retained.keys().next().value;
-    if (oldest === undefined)
-      break;
-    removeCopy(retained.get(oldest));
-    retained.delete(oldest);
-  }
-}
-function retainedTaskOutput(ownerId, taskId) {
-  return retained.get(retentionKey(ownerId, taskId));
-}
-
-// dist/builtin/subagents/src/runs/foreground/task-execution.ts
-function subagentTaskResultLabel(result) {
-  return result.kind === "cancelled" && result.cause === "user" ? "killed (non-resumable)" : result.kind;
-}
-function subagentTaskResponseText(response) {
-  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
-  const killed = outcomes.filter((outcome) => outcome.kind === "admitted" && outcome.observation.kind === "settled" && subagentTaskResultLabel(outcome.observation.result) === "killed (non-resumable)");
-  return `${killed.length ? `${killed.length} killed. These children cannot be resumed. Underlying host response:
-` : ""}${JSON.stringify(response)}`;
-}
-function settledOutputsFromResponse(response) {
-  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
-  return outcomes.flatMap((outcome) => outcome.kind === "admitted" && outcome.observation.kind === "settled" ? [{ taskId: outcome.observation.taskId, result: outcome.observation.result }] : []);
-}
-function settledOutputsFromRecords(records) {
-  return records.flatMap((record) => record.execution.kind === "settled" ? [{ taskId: record.ref.taskId, result: record.execution.result }] : []);
-}
-function settledOutputSection(taskId, label, output) {
-  const truncated = output.shown < output.total ? `, first ${output.shown} shown${output.path ? "; read the full output file for the rest" : ""}` : "";
-  const lines = [`Output of ${taskId} (${label}, ${output.total} bytes${truncated}):`];
-  if (output.requestedPath)
-    lines.push(`Requested output: ${output.requestedPath}`);
-  if (output.saveError)
-    lines.push(`Output file error: ${output.saveError}`);
-  if (output.path)
-    lines.push(`Full output: ${output.path}`);
-  lines.push(output.head);
-  return lines.join(`
-`);
-}
-async function readSettledOutput(host, settled) {
-  const output = settled.result.output;
-  if (!output)
-    return;
-  const label = subagentTaskResultLabel(settled.result);
-  const kept = retainedTaskOutput(output.ownerId, output.taskId);
-  if (kept) {
-    return settledOutputSection(settled.taskId, label, {
-      ...kept,
-      shown: Math.min(kept.totalBytes, INLINE_TASK_OUTPUT_MAX_BYTES),
-      total: kept.totalBytes
-    });
-  }
-  const unavailable = (reason) => `Output of ${settled.taskId} (${label}) is unavailable: ${reason}`;
-  const lease = host.resolveTask(settled.taskId);
-  if (!lease.ok)
-    return unavailable(lease.error.message);
-  try {
-    const page = await host.ownerBinding.supervisor.readTaskOutput(lease.value, {
-      start: "0",
-      maximumBytes: INLINE_TASK_OUTPUT_MAX_BYTES
-    });
-    if (!page.ok)
-      return unavailable(page.error.message);
-    const decoder = new TextDecoder;
-    const head = page.value.chunks.map((chunk) => decoder.decode(chunk.bytes, { stream: true })).join("") + decoder.decode();
-    const shown = page.value.chunks.reduce((sum, chunk) => sum + chunk.bytes.byteLength, 0);
-    return settledOutputSection(settled.taskId, label, { head, shown, total: Number(output.byteCount) });
-  } catch (error) {
-    return unavailable(error instanceof Error ? error.message : String(error));
-  }
-}
-async function settledTaskOutputText(host, settled) {
-  if (!host || settled.length === 0)
-    return "";
-  const sections = await Promise.all(settled.map((entry) => readSettledOutput(host, entry)));
-  const present = sections.filter((section) => section !== undefined);
-  return present.length ? `
-
-${present.join(`
-
-`)}` : "";
+  }
+  const patchesDir = path18.dirname(changed[0].patchPath);
+  lines.push(`Full patches: ${patchesDir}`);
+  return lines.join(`
+`).trimEnd();
 }
-function taskToolResult(response, host) {
+
+// dist/builtin/subagents/src/runs/foreground/detached-cleanup-barrier.ts
+function createDetachedCleanupBarrier(onReady) {
+  const recovered = new Set;
+  let expected;
+  let cleaned = false;
+  const finishIfReady = () => {
+    if (cleaned || !expected || ![...expected].every((index) => recovered.has(index)))
+      return;
+    cleaned = true;
+    onReady();
+  };
   return {
-    content: [{ type: "text", text: subagentTaskResponseText(response) }],
-    details: {
-      mode: "single",
-      results: [],
-      taskResponse: response,
-      taskRecords: taskResponseRecords(response, host)
+    recover(index) {
+      recovered.add(index);
+      finishIfReady();
     },
-    ...response.kind === "unstarted" ? { isError: true } : {}
+    defer(indices) {
+      if (indices.length === 0)
+        return false;
+      expected = new Set(indices);
+      finishIfReady();
+      return true;
+    }
   };
 }
-async function taskToolResultWithOutput(response, host) {
-  const result = taskToolResult(response, host);
-  const outputText = await settledTaskOutputText(host, settledOutputsFromResponse(response));
-  if (!outputText)
-    return result;
+
+// dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts
+import { join as join19 } from "node:path";
+
+// dist/builtin/subagents/src/runs/foreground/subagent-executor-worktree.ts
+import * as path19 from "node:path";
+function buildParallelModeError(message) {
   return {
-    ...result,
-    content: [{ type: "text", text: `${subagentTaskResponseText(response)}${outputText}` }]
+    content: [{ type: "text", text: message }],
+    isError: true,
+    details: { mode: "parallel", results: [] }
   };
 }
-function taskResponseRecords(response, host) {
-  const outcomes = response.kind === "parallel" ? response.slots.map((slot) => slot.outcome) : [response];
-  const ids = new Set(outcomes.flatMap((outcome) => outcome.kind === "admitted" ? [outcome.observation.taskId] : []));
-  const watched = host?.watchOwnerTasks();
-  if (!watched?.ok)
-    return [];
+function createParallelWorktreeSetup(enabled, cwd, runId, tasks, setupHook, setupHookTimeoutMs) {
+  if (!enabled)
+    return {};
   try {
-    return watched.value.snapshot.tasks.filter((task) => ids.has(task.ref.taskId));
-  } finally {
-    watched.value.dispose();
+    return {
+      setup: createWorktrees(cwd, runId, tasks.length, {
+        agents: tasks.map((task) => task.agent),
+        setupHook: setupHook ? { hookPath: setupHook, timeoutMs: setupHookTimeoutMs } : undefined
+      })
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { errorResult: buildParallelModeError(message) };
   }
 }
-async function runAgentTask(input) {
-  let yieldWait;
-  let pendingYield = false;
-  let parentObserving = input.wait?.kind === "foreground";
-  const registered = Promise.withResolvers();
-  input.options.modelRoute?.assertCurrent();
-  const started = await input.host.startAgentTask({
-    kind: "agent",
-    agent: input.agent,
-    task: input.intentTask ?? input.task,
-    cwd: input.options.cwd ?? input.cwd,
-    ...input.options.modelRoute ? { routerSelection: input.options.modelRoute.routerSelection } : {}
-  }, `${input.options.runId}:${input.options.index ?? 0}`, (context) => {
-    const cleaned = Promise.withResolvers();
-    let executionBound = false;
-    const result = registered.promise.then(async () => {
-      try {
-        input.options.modelRoute?.assertCurrent();
-        const child = await input.runtime.runSync(input.cwd, input.agents, input.agent, input.task, {
-          ...input.options,
-          signal: context.signal,
-          taskExecution: {
-            signal: context.signal,
-            reportActivity: context.reportActivity,
-            bindTranscript: (session) => context.bindTranscript({
-              getSessionId: () => session.getSessionId(),
-              getEntries: () => session.getEntries(),
-              ...session.subscribe ? { subscribe: session.subscribe.bind(session) } : {},
-              ...session.getStreamingMessage ? { getStreamingMessage: session.getStreamingMessage.bind(session) } : {},
-              ...input.options.intercomSessionName ? {
-                completionSource: {
-                  runId: input.options.runId,
-                  intercomTarget: input.options.intercomSessionName
-                }
-              } : {}
-            }),
-            onExecution: (execution) => {
-              executionBound = true;
-              execution.cleanup.then(cleaned.resolve, (error) => cleaned.resolve({
-                kind: "failed",
-                resources: [{ resource: "agent-session", code: "CleanupFailed", message: String(error) }]
-              }));
-            },
-            yieldTaskWait: () => {
-              parentObserving = false;
-              if (yieldWait)
-                yieldWait("intercom-coordination");
-              else
-                pendingYield = true;
-            },
-            isParentObserving: () => parentObserving
-          }
-        });
-        if (child.model !== undefined || child.thinking !== undefined)
-          context.reportActivity({
-            reportId: "terminal-model",
-            change: { kind: "model", model: child.model, thinking: child.thinking }
-          });
-        input.onTerminal?.(child);
-        const text = input.outputText?.(child) ?? getSingleResultOutput(child);
-        retainTaskOutput(child, text, context.ref);
-        const bytes = Buffer.from(text);
-        context.reportActivity({
-          reportId: "terminal-output",
-          change: { kind: "output", offset: "0", bytesBase64: bytes.toString("base64") }
-        });
-        const output = {
-          ownerId: context.ref.ownerId,
-          taskId: context.ref.taskId,
-          artifactId: `output:${context.ref.taskId}`,
-          byteCount: String(bytes.length),
-          omittedRanges: []
-        };
-        if (child.status === "killed")
-          return { kind: "cancelled", cause: "user", output };
-        if (child.interrupted)
-          return {
-            kind: "cancelled",
-            cause: input.options.interruptSignal?.aborted ? "parent-handoff" : "owner-close",
-            output
-          };
-        return child.status === "ok" ? { kind: "completed", output } : {
-          kind: "failed",
-          code: "AgentFailed",
-          message: child.error ?? child.envelope ?? "Agent failed",
-          output
-        };
-      } finally {
-        if (!executionBound)
-          cleaned.resolve({ kind: "reaped" });
-      }
-    });
-    return { result, cleanup: cleaned.promise };
-  }, input.schedule);
-  if (!started.ok)
-    return { kind: "unstarted", reason: { kind: "rejected", error: started.error } };
-  const yieldForIntercom = () => {
-    parentObserving = false;
-    if (yieldWait)
-      yieldWait("intercom-coordination");
-    else
-      pendingYield = true;
-  };
-  input.options.intercomDetachSignal?.addEventListener("abort", yieldForIntercom, { once: true });
-  if (input.options.intercomDetachSignal?.aborted)
-    yieldForIntercom();
-  const observation = input.host.observeAgentLaunch(started.value.taskId, input.wait, (yieldRegistered) => {
-    yieldWait = yieldRegistered;
-    if (pendingYield)
-      yieldRegistered("intercom-coordination");
-    registered.resolve();
-  });
-  registered.resolve();
-  const observed = await observation.finally(() => {
-    parentObserving = false;
-    input.options.intercomDetachSignal?.removeEventListener("abort", yieldForIntercom);
-  });
-  if (!observed.ok)
-    throw new Error(`${observed.error.code}: ${observed.error.message}`);
-  return { kind: "admitted", observation: observed.value };
+function buildParallelWorktreeTaskCwdError(tasks, sharedCwd) {
+  const conflict = findWorktreeTaskCwdConflict(tasks, sharedCwd);
+  if (!conflict)
+    return;
+  return formatWorktreeTaskCwdConflict(conflict, sharedCwd);
+}
+function resolveParallelTaskCwd(task, paramsCwd, worktreeSetup, index) {
+  if (worktreeSetup)
+    return worktreeSetup.worktrees[index].agentCwd;
+  return resolveChildCwd(paramsCwd, task.cwd);
+}
+function buildParallelWorktreeSuffix(worktreeSetup, artifactsDir, tasks) {
+  if (!worktreeSetup)
+    return "";
+  const diffsDir = path19.join(artifactsDir, "worktree-diffs");
+  const diffs = diffWorktrees(worktreeSetup, tasks.map((task) => task.agent), diffsDir);
+  return formatWorktreeDiffSummary(diffs);
+}
+function findDuplicateParallelOutputPath(input) {
+  const seen = new Map;
+  for (let index = 0;index < input.tasks.length; index++) {
+    const behavior = input.behaviors[index];
+    if (!behavior?.output)
+      continue;
+    const task = input.tasks[index];
+    const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
+    const outputPath = resolveSingleOutputPath(behavior.output, input.ctxCwd, taskCwd);
+    if (!outputPath)
+      continue;
+    const previous = seen.get(outputPath);
+    if (previous) {
+      return `Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${outputPath}. Use distinct output paths.`;
+    }
+    seen.set(outputPath, { index, agent: task.agent });
+  }
+  return;
 }
 
 // dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts
@@ -13822,23 +13897,7 @@ function runUnboundParallelTask(options, agent, task, schedule, run) {
 async function runForegroundParallelTasks(input) {
   const intercomDetachController = new AbortController;
   const host = input.ctx.getAgentTaskHost?.();
-  let active = 0;
-  const queued = [];
-  const pump = () => {
-    while (active < input.concurrencyLimit && queued.length > 0) {
-      const dispatch = queued.shift();
-      active++;
-      const release = () => {
-        active--;
-        pump();
-      };
-      dispatch().then(release, release);
-    }
-  };
-  const schedule = (dispatch) => {
-    queued.push(dispatch);
-    pump();
-  };
+  const schedule = input.schedule ?? createExecutionScheduler(input.concurrencyLimit);
   return mapConcurrent(input.tasks, input.tasks.length, async (task, index) => {
     const behavior = input.behaviors[index];
     const effectiveSkills = behavior?.skills;
@@ -14578,6 +14637,7 @@ async function runParallelPath(data, deps) {
     }
     const results = await runForegroundParallelTasks({
       wait: params.wait,
+      schedule: params[BURST_EXECUTION_SCHEDULE],
       onTaskTerminal: (index) => detachedCleanup.recover(index),
       onDetachedExit: (index, result) => {
         try {
@@ -14646,20 +14706,7 @@ async function runParallelPath(data, deps) {
         }))
       };
       worktreeCleanupDeferred = detachedCleanup.defer(response.slots.flatMap(({ ordinal, outcome }) => outcome.kind === "admitted" && outcome.observation.kind === "yielded" ? [ordinal] : []));
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${subagentTaskResponseText(response)}${await settledTaskOutputText(ctx.getAgentTaskHost(), settledOutputsFromResponse(response))}`
-          }
-        ],
-        details: {
-          mode: "parallel",
-          results: [],
-          taskResponse: response,
-          taskRecords: taskResponseRecords(response, ctx.getAgentTaskHost())
-        }
-      };
+      return parallelTaskToolResultWithOutput(response, ctx.getAgentTaskHost());
     }
     for (let i = 0;i < results.length; i++) {
       const run = results[i];
@@ -15557,6 +15604,7 @@ async function runSinglePath(data, deps) {
         intentTask: handoffTaskContext,
         options: runOptions,
         wait: params.wait,
+        schedule: params[BURST_EXECUTION_SCHEDULE],
         runtime: deps.runtime,
         onTerminal: (child) => {
           settledChild = child;
@@ -15572,8 +15620,10 @@ async function runSinglePath(data, deps) {
       if (!parentAsk || !settledChild?.interrupted)
         return await taskToolResultWithOutput(response, ctx.getAgentTaskHost());
       r = settledChild;
-    } else
-      r = await deps.runtime.runSync(ctx.cwd, agents, params.agent, task, runOptions);
+    } else {
+      const schedule = params[BURST_EXECUTION_SCHEDULE];
+      r = schedule ? await runUnboundParallelTask(runOptions, params.agent, task, schedule, (options) => deps.runtime.runSync(ctx.cwd, agents, params.agent, task, options)) : await deps.runtime.runSync(ctx.cwd, agents, params.agent, task, runOptions);
+    }
   } catch (error) {
     cleanupTransientProgress(progressDir, artifactConfig.enabled);
     throw error;
@@ -15911,6 +15961,7 @@ function createSubagentExecutor(rawDeps) {
   };
   const executeWithBurstCollection = createExecutionBurstDispatcher({
     execute,
+    concurrencyLimit: deps.config.parallel?.concurrency,
     isActive: () => deps.state.subagentInProgress === true,
     setActive: (active) => {
       deps.state.subagentInProgress = active;