@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/background/async-execution.js

@@ -3,34 +3,37 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
+import * as nodeModule from "node:module";
 import { discoverAgents, formatUnknownAgentError, unknownAgentDiagnosticContext } from "../../agents/agents.js";
-import { appendAgentRefinementOverlay } from "../../agents/agent-refinements.js";
-import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { createAtomicJsonWriter, writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { childCacheRetentionEnv } from "../../shared/child-cache-retention.js";
+import { buildEffectiveSystemPrompt } from "../shared/effective-system-prompt.js";
 import { currentCompletionOwnerId } from "../../shared/completion-owner.js";
-import { planChildLaunch, resolveStepBehavior, suppressProgressForReadOnlyTask } from "../shared/child-launch-plan.js";
-import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/dm-args.js";
-import { injectOutputPathSystemPrompt, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
-import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveExistingReadPaths, writeInitialProgressFile } from "../../shared/settings.js";
-import { resolvePiPackageRoot } from "../shared/dm-spawn.js";
+import { planChildLaunch, projectChainOutputSchemas, resolveStepBehavior, suppressProgressForReadOnlyTask } from "../shared/child-launch-plan.js";
+import { formatHerdrMachineRunnerUnsupported, resolveHerdrMachinePlacement } from "../shared/herdr-machine.js";
+import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/child-tool-plan.js";
+import { injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { applyWatchdogLaunchRules, sendRuleViolationWarning } from "../../watchdog/rules.js";
+import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveExistingReadInstructionPaths, resolveExistingReadPaths, writeInitialProgressFile } from "../../shared/settings.js";
+import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.js";
+import { DM_CODING_AGENT_PACKAGE, resolveBunPiExecutable, resolveInstalledPiPackageRoot, resolvePiPackageRoot } from "../shared/dm-spawn.js";
+import { JITI_ALIAS_ENV, resolveHostPeerAliases } from "./runner-aliases.js";
 import { preflightLaunchCwd } from "../shared/launch-cwd.js";
 import { resolveNodeExecutable } from "../../shared/node-executable.js";
 import { backgroundProcessOptions } from "../shared/background-process-options.js";
-import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.js";
-import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
+import { normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.js";
 import { DM_CODING_AGENT_PACKAGE_ROOT_ENV, PROMPT_REDACTED, resolveChildCwd } from "../../shared/utils.js";
-import { buildModelCandidates, inheritsParentModel, resolveEffectiveSubagentModel, resolveSubagentModelOverride } from "../shared/model-fallback.js";
+import { resolveEffectiveSubagentModel, resolveModelOrigin, resolveModelSelection, resolveSubagentModelOverride } from "../shared/model-resolution.js";
 import { resolveToolTimeoutMs, toolTimeoutFromEnv } from "../shared/tool-timeout.js";
 import { resolveModelScopesForAgent } from "../shared/model-scope.js";
 import { findModelInfo, resolveEffectiveThinking } from "../../shared/model-info.js";
-import { assertThinkingWithinCeiling, decodeThinkingCeiling, intersectThinkingCeilings, SUBAGENT_THINKING_CEILING_ENV } from "../../shared/thinking-ceiling.js";
-import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.js";
+import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
+import { resolveExpectedWorktreeAgentCwd, resolveWorktreeProvider, shouldDeferWorktreeCwd, WORKTREE_AGENT_CWD_PLACEHOLDER } from "../shared/worktree.js";
 import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.js";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.js";
 import { createStructuredOutputRuntime } from "../shared/structured-output.js";
-import { resolveEffectiveAcceptance, validateAcceptanceInput, validateExecutionAcceptance } from "../shared/acceptance.js";
+import { resolveAcceptanceReportMode, resolveEffectiveAcceptance, validateAcceptanceInput, validateExecutionAcceptance } from "../shared/acceptance.js";
 import { createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
-import { validateImplementationToolContract } from "../shared/completion-guard.js";
 import {
   DIRS,
   SUBAGENT_ASYNC_STARTED_EVENT,
@@ -39,20 +42,30 @@ import {
   getAsyncConfigPath,
   resolveChildMaxSubagentDepth
 } from "../../shared/types.js";
-import { nestedResultsPath, nestedSummaryFromAsyncStatus, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.js";
+import { inheritedNestedParentAddressOf, inheritedNestedRouteOf, nestedResultsPath, nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.js";
+import { SUBAGENT_PARENT_SESSION_ENV } from "../shared/child-runtime-config.js";
+import { childSessionFactoryModule } from "../shared/child-session.js";
+import { inheritedChildRuntime } from "../shared/child-launch.js";
 import { resultFilePath } from "./result-files.js";
+import { updateActiveRunIndex } from "./active-run-index.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
 import { usageBudgetState } from "../shared/usage-budget.js";
-import { finalizeProcessTerminal, readProcessTerminal } from "./process-terminal.js";
+import { finalizeProcessTerminal, initializeProcessTerminal, readProcessTerminal } from "./process-terminal.js";
+import { persistRunnerStartupFailure } from "./runner-startup-failure.js";
 import { statusStepDescription } from "./chain-append.js";
 import { SUBAGENT_PROCESS_TERMINAL_EVENT } from "../../shared/types.js";
-import { assertAgentAllowedByCapabilityCeiling, decodeSubagentCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling, SUBAGENT_CAPABILITY_CEILING_ENV } from "../shared/capability-ceiling.js";
-import { agentDefinitionDigest, launchBindingDigest } from "../../shared/launch-contract.js";
+import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
+import { resolveLaunchBinding } from "../../shared/launch-contract.js";
 import { resolvePermissionRules } from "../shared/permissions.js";
 import { normalizeExtensionBindings, omitExtensionBindingsEnv } from "../shared/extension-bindings.js";
+import { omitGitRoutingEnv } from "../shared/git-environment.js";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
-const require = createRequire(import.meta.url);
-const piPackageRoot = resolvePiPackageRoot();
+import { resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
+const require = nodeModule.createRequire(import.meta.url);
+const piPackageRoot = resolveAsyncPiPackageRoot();
+function resolveAsyncPiPackageRoot(env = process.env) {
+  return resolvePiPackageRoot() || env[DM_CODING_AGENT_PACKAGE_ROOT_ENV]?.trim() || resolveInstalledPiPackageRoot();
+}
 function resolveJitiCliFromPackageJson(packageJsonPath) {
   if (!fs.existsSync(packageJsonPath))
     return;
@@ -71,12 +84,12 @@ function resolveJitiCliFromPackageJson(packageJsonPath) {
 function resolveJitiCliPath() {
   const candidates = [
     () => require.resolve("jiti/package.json"),
-    () => piPackageRoot ? createRequire(path.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : undefined,
+    () => piPackageRoot ? nodeModule.createRequire(path.join(piPackageRoot, "package.json")).resolve("jiti/package.json") : undefined,
     () => {
       if (!process.argv[1])
         return;
       const piEntry = fs.realpathSync(process.argv[1]);
-      return createRequire(piEntry).resolve("jiti/package.json");
+      return nodeModule.createRequire(piEntry).resolve("jiti/package.json");
     },
     () => piPackageRoot ? path.join(piPackageRoot, "node_modules", "jiti", "package.json") : undefined
   ];
@@ -93,6 +106,11 @@ function resolveJitiCliPath() {
   return;
 }
 const jitiCliPath = resolveJitiCliPath();
+const asyncRunnerSourcePath = path.join(path.dirname(fileURLToPath(import.meta.url)), `subagent-runner-bootstrap${path.extname(fileURLToPath(import.meta.url))}`);
+const sourceUnderNodeModules = asyncRunnerSourcePath.split(path.sep).some((segment) => segment.toLowerCase() === "node_modules");
+function supportsNativeRunner(nodeExecutable) {
+  return Boolean(process.features.typescript) && typeof nodeModule.registerHooks === "function" && nodeExecutable === process.execPath && !sourceUnderNodeModules;
+}
 export const DEFAULT_ASYNC_TIMEOUT_MS = 30 * 60 * 1000;
 export function formatAsyncStartedMessage(headline, interactive) {
   const guidance = interactive ? [
@@ -110,7 +128,7 @@ export function formatAsyncStartedMessage(headline, interactive) {
 `);
 }
 export function isAsyncAvailable() {
-  return jitiCliPath !== undefined;
+  return resolveBunPiExecutable() !== undefined || supportsNativeRunner(resolveNodeExecutable()) || jitiCliPath !== undefined;
 }
 export function resolveAsyncRunnerLogPaths(cfg) {
   const asyncDir = typeof cfg.asyncDir === "string" ? cfg.asyncDir : undefined;
@@ -129,15 +147,8 @@ function closeFd(fd) {
   } catch {}
 }
 const RUNNER_STARTUP_TIMEOUT_MS = 1e4;
-const RUNNER_STARTUP_WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
-const RUNNER_STARTUP_WAIT_VIEW = RUNNER_STARTUP_WAIT_BUFFER ? new Int32Array(RUNNER_STARTUP_WAIT_BUFFER) : undefined;
 function waitForStartupInterval(delayMs = 20) {
-  if (RUNNER_STARTUP_WAIT_VIEW) {
-    Atomics.wait(RUNNER_STARTUP_WAIT_VIEW, 0, 0, delayMs);
-    return;
-  }
-  const waitUntil = Date.now() + delayMs;
-  while (Date.now() < waitUntil) {}
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
 function readRunnerStartup(startupPath, expectedState, expectedToken) {
   if (!fs.existsSync(startupPath))
@@ -156,23 +167,48 @@ function readRunnerStartup(startupPath, expectedState, expectedToken) {
     return { ok: false, error: `Failed to read async runner startup handshake '${startupPath}': ${error instanceof Error ? error.message : String(error)}`, startupDidNotProceed: true };
   }
 }
-function waitForRunnerStartup(startupPath, expectedState, timeoutMs, expectedToken) {
+async function waitForRunnerStartup(startupPath, expectedState, timeoutMs, expectedToken, processClosed) {
+  const confirmOpen = async (result) => {
+    if (!processClosed || result.ok === false)
+      return result;
+    const outcome = await Promise.race([processClosed.then((exit) => ({ exit })), new Promise((resolve) => setImmediate(() => resolve(undefined)))]);
+    if (!outcome)
+      return result;
+    const finalResult = readRunnerStartup(startupPath, expectedState, expectedToken);
+    if (finalResult?.ok === false)
+      return finalResult;
+    const { exitCode, signal } = outcome.exit;
+    return { ok: false, error: `Async runner exited before startup state '${expectedState}' (exit code ${exitCode ?? "unknown"}, signal ${signal ?? "none"}).`, startupDidNotProceed: true };
+  };
   const deadline = Date.now() + timeoutMs;
-  for (;; ) {
+  while (Date.now() <= deadline) {
     const result = readRunnerStartup(startupPath, expectedState, expectedToken);
     if (result)
-      return result;
-    if (Date.now() >= deadline)
-      break;
-    waitForStartupInterval(Math.min(20, Math.max(1, deadline - Date.now())));
+      return await confirmOpen(result);
+    const delay = waitForStartupInterval(Math.min(20, Math.max(1, deadline - Date.now())));
+    if (processClosed) {
+      const outcome = await Promise.race([delay.then(() => {
+        return;
+      }), processClosed.then((exit) => ({ exit }))]);
+      if (outcome) {
+        const finalResult = readRunnerStartup(startupPath, expectedState, expectedToken);
+        if (finalResult?.ok === false)
+          return finalResult;
+        const { exitCode, signal } = outcome.exit;
+        return { ok: false, error: `Async runner exited before startup state '${expectedState}' (exit code ${exitCode ?? "unknown"}, signal ${signal ?? "none"}).`, startupDidNotProceed: true };
+      }
+    } else {
+      await delay;
+    }
   }
   const finalResult = readRunnerStartup(startupPath, expectedState, expectedToken);
   if (finalResult)
     return finalResult;
   return { ok: false, error: `Timed out after ${timeoutMs}ms waiting for the async runner startup state '${expectedState}'.`, startupDidNotProceed: true };
 }
+const writePrivateStartupControlJson = createAtomicJsonWriter({ mode: 384, ignoreCleanupErrorAfterSuccess: true });
 function writeRunnerStartupControl(filePath, payload) {
-  writePrivateAtomicJson(filePath, payload);
+  writePrivateStartupControlJson(filePath, payload);
 }
 function runnerIsAlive(pid) {
   try {
@@ -182,6 +218,10 @@ function runnerIsAlive(pid) {
     return error.code === "EPERM";
   }
 }
+function waitForStartupIntervalSync(delayMs = 20) {
+  const waitUntil = Date.now() + delayMs;
+  while (Date.now() < waitUntil) {}
+}
 function terminateRunnerBeforeProceed(pid) {
   for (const signal of ["SIGTERM", "SIGKILL"]) {
     if (!runnerIsAlive(pid))
@@ -194,40 +234,92 @@ function terminateRunnerBeforeProceed(pid) {
     }
     const deadline = Date.now() + 1000;
     while (runnerIsAlive(pid) && Date.now() < deadline)
-      waitForStartupInterval();
+      waitForStartupIntervalSync();
   }
   return !runnerIsAlive(pid);
 }
-function persistPreProceedStartupFailure(asyncDir, runId, runnerProcessInstanceId, sessionId, completionOwnerId, message) {
-  const now = Date.now();
+async function terminateRunnerBeforeProceedAsync(proc, processClosed) {
+  for (const signal of ["SIGTERM", "SIGKILL"]) {
+    if (proc.pid === undefined || !runnerIsAlive(proc.pid))
+      return true;
+    try {
+      process.kill(proc.pid, signal);
+    } catch {
+      if (proc.pid === undefined || !runnerIsAlive(proc.pid))
+        return true;
+    }
+    const exited = await Promise.race([processClosed.then(() => true), waitForStartupInterval(1000).then(() => false)]);
+    if (exited || proc.pid === undefined || !runnerIsAlive(proc.pid))
+      return true;
+  }
+  return proc.pid === undefined || !runnerIsAlive(proc.pid);
+}
+async function completeRunnerStartupHandshake(startupPath, startupAckPath, startupConfirmPath, startupProceedPath, proc, processClosed, getObservedProcessExit, runnerProcessInstanceId, persistStartupFailure) {
   try {
-    const statusPath = path.join(asyncDir, "status.json");
-    let status = {};
+    const ready = await waitForRunnerStartup(startupPath, "ready", RUNNER_STARTUP_TIMEOUT_MS, undefined, processClosed);
+    if (ready.ok === false) {
+      persistStartupFailure(ready.error);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: ready.error, terminationObserved, startupDidNotProceed: true };
+    }
     try {
-      status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+      writeRunnerStartupControl(startupAckPath, { action: "ack", token: ready.token });
+    } catch (error) {
+      const message = `Failed to acknowledge async runner startup: ${error instanceof Error ? error.message : String(error)}`;
+      persistStartupFailure(message);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    const acknowledged = await waitForRunnerStartup(startupPath, "acknowledged", RUNNER_STARTUP_TIMEOUT_MS, ready.token, processClosed);
+    if (acknowledged.ok === false) {
+      persistStartupFailure(acknowledged.error);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: acknowledged.error, terminationObserved, startupDidNotProceed: true };
+    }
+    try {
+      writeRunnerStartupControl(startupConfirmPath, { action: "confirm", token: ready.token });
+    } catch (error) {
+      const message = `Failed to confirm async runner startup: ${error instanceof Error ? error.message : String(error)}`;
+      persistStartupFailure(message);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    const confirmed = await waitForRunnerStartup(startupPath, "confirmed", RUNNER_STARTUP_TIMEOUT_MS, ready.token, processClosed);
+    if (confirmed.ok === false) {
+      persistStartupFailure(confirmed.error);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: confirmed.error, terminationObserved, startupDidNotProceed: true };
+    }
+    const closedAtCommit = await Promise.race([
+      processClosed.then((exit) => exit),
+      new Promise((resolve) => setImmediate(() => resolve(undefined)))
+    ]);
+    const observedExit = closedAtCommit ?? getObservedProcessExit();
+    if (observedExit) {
+      const message = `Async runner exited after startup state 'acknowledged' before proceed (exit code ${observedExit.exitCode ?? "unknown"}, signal ${observedExit.signal ?? "none"}).`;
+      persistStartupFailure(message);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    try {
+      writeRunnerStartupControl(startupProceedPath, { action: "proceed", token: ready.token });
+    } catch (error) {
+      const message = `Failed to authorize async runner startup: ${error instanceof Error ? error.message : String(error)}`;
+      persistStartupFailure(message);
+      const terminationObserved = await terminateRunnerBeforeProceedAsync(proc, processClosed);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    try {
+      fs.rmSync(startupPath, { force: true });
     } catch {}
-    writePrivateAtomicJson(statusPath, {
-      ...status,
-      runId,
-      ...sessionId ? { sessionId } : {},
-      ...completionOwnerId ? { completionOwnerId } : {},
-      state: "failed",
-      lastUpdate: now,
-      error: message,
-      processTerminal: {
-        version: 1,
-        state: "not-started",
-        runId,
-        runnerProcessInstanceId
-      }
-    });
-    writePrivateAtomicJson(path.join(asyncDir, "process-terminal-candidate.json"), {
-      version: 1,
-      runId,
-      runnerProcessInstanceId,
-      writers: {},
-      expectedWriters: { 0: 0 }
-    });
+    return { pid: proc.pid, runnerProcessInstanceId };
+  } finally {
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+}
+function persistPreProceedStartupFailure(asyncDir, runId, runnerProcessInstanceId, sessionId, completionOwnerId, message) {
+  try {
+    persistRunnerStartupFailure({ asyncDir, runId, runnerProcessInstanceId, sessionId, completionOwnerId, message });
   } catch {}
 }
 function isStaleExtensionContextError(error) {
@@ -242,12 +334,36 @@ export function emitProcessTerminalEvent(ctx, proof) {
     console.error("Failed to emit subagent process-terminal event:", error);
   }
 }
-function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProcessTerminal, requestedCwd = cwd) {
+function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, launchParentSessionId, onProcessTerminal, onBeforeProceed, requestedCwd = cwd) {
   const cwdError = preflightLaunchCwd(requestedCwd, cwd);
   if (cwdError)
     return { error: cwdError };
-  if (!jitiCliPath) {
-    return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
+  if (launchParentSessionId !== undefined && (!launchParentSessionId || launchParentSessionId.trim() !== launchParentSessionId)) {
+    return { error: "Background runner parent session identity is invalid." };
+  }
+  const steps = cfg.steps;
+  if (!Array.isArray(steps))
+    return { error: "Background runner launch is missing its steps." };
+  const inconsistentParent = steps.some((step) => isParallelGroup(step) ? step.parallel.some((child) => child.parentSessionId !== launchParentSessionId) : (isDynamicRunnerGroup(step) ? step.parallel.parentSessionId : step.parentSessionId) !== launchParentSessionId);
+  if (inconsistentParent)
+    return { error: "Background runner steps have inconsistent parent session identities." };
+  const binaryHost = resolveBunPiExecutable();
+  const nodeExecutable = resolveNodeExecutable();
+  const nativeRunnerSupported = supportsNativeRunner(nodeExecutable);
+  const runner = asyncRunnerSourcePath;
+  const runnerIsJavaScript = path.extname(runner) === ".js";
+  const bootstrap = path.join(path.dirname(runner), `binary-bootstrap${path.extname(fileURLToPath(import.meta.url))}`);
+  if (binaryHost && !fs.existsSync(bootstrap))
+    return { error: `Background runner bootstrap not found: ${bootstrap}` };
+  if (!binaryHost && !runnerIsJavaScript && !nativeRunnerSupported && !jitiCliPath) {
+    return { error: sourceUnderNodeModules ? "Background runner source is installed under node_modules, so upstream jiti is required for TypeScript execution." : "Background runner requires enabled native TypeScript with synchronous module hooks, or installed upstream jiti for TypeScript execution." };
+  }
+  if (!binaryHost && !piPackageRoot) {
+    return { error: `Background children require a supported standalone DM host or the installed npm package (${DM_CODING_AGENT_PACKAGE}); neither is available.` };
+  }
+  const hostPeerAliases = !binaryHost && piPackageRoot ? resolveHostPeerAliases(piPackageRoot) : { aliases: {}, missing: [] };
+  if (hostPeerAliases.missing.length > 0) {
+    return { error: `Background children require the host npm package (${DM_CODING_AGENT_PACKAGE}) with its dependencies; ${piPackageRoot} does not provide ${hostPeerAliases.missing.join(", ")}.` };
   }
   fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
   const cfgPath = getAsyncConfigPath(suffix);
@@ -256,8 +372,7 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
   const launchBarrierToken = hasRevivalLease ? undefined : runnerProcessInstanceId;
   const launchConfig = { ...cfg, runnerProcessInstanceId, ...launchBarrierToken ? { launchBarrierToken } : {} };
   writePrivateAtomicJson(cfgPath, launchConfig);
-  const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.js");
-  const nodeCommand = resolveNodeExecutable();
+  const command = binaryHost ?? nodeExecutable;
   const launchForStartup = launchConfig;
   const launchAsyncDir = typeof launchForStartup.asyncDir === "string" ? launchForStartup.asyncDir : undefined;
   const launchRunId = typeof launchForStartup.id === "string" ? launchForStartup.id : suffix;
@@ -265,11 +380,14 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
   const launchCompletionOwnerId = typeof launchForStartup.completionOwnerId === "string" ? launchForStartup.completionOwnerId : undefined;
   const startupPath = typeof launchForStartup.revivalLease === "object" && launchAsyncDir ? path.join(launchAsyncDir, "runner-startup.json") : undefined;
   const startupAckPath = startupPath ? path.join(path.dirname(startupPath), "runner-startup-ack.json") : undefined;
+  const startupConfirmPath = startupPath ? path.join(path.dirname(startupPath), "runner-startup-confirm.json") : undefined;
   const startupProceedPath = launchAsyncDir && (startupPath || launchBarrierToken) ? path.join(launchAsyncDir, "runner-startup-proceed.json") : undefined;
   if (startupPath)
     fs.rmSync(startupPath, { force: true });
   if (startupAckPath)
     fs.rmSync(startupAckPath, { force: true });
+  if (startupConfirmPath)
+    fs.rmSync(startupConfirmPath, { force: true });
   if (startupProceedPath)
     fs.rmSync(startupProceedPath, { force: true });
   const logPaths = resolveAsyncRunnerLogPaths(launchConfig);
@@ -281,14 +399,36 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
       stdoutFd = fs.openSync(logPaths.stdoutPath, "a");
       stderrFd = fs.openSync(logPaths.stderrPath, "a");
     }
-    const proc = spawn(nodeCommand, [jitiCliPath, runner, cfgPath], {
+    const preload = Object.keys(hostPeerAliases.aliases).length > 0 ? ["--import", new URL("../../../runner-peer-preload.mjs", import.meta.url).href] : [];
+    const args = binaryHost ? ["--no-extensions", "--no-skills", "--no-prompt-templates", "--no-session", "--mode", "rpc", "--extension", bootstrap] : runnerIsJavaScript ? [...preload, runner, cfgPath] : nativeRunnerSupported ? [...preload, "--experimental-strip-types", runner, cfgPath] : [...preload, jitiCliPath, runner, cfgPath];
+    const runnerEnv = {
+      ...omitGitRoutingEnv(omitExtensionBindingsEnv(process.env)),
+      ...childCacheRetentionEnv(),
+      [DM_CODING_AGENT_PACKAGE_ROOT_ENV]: binaryHost ? undefined : piPackageRoot,
+      PI_PACKAGE_DIR: binaryHost ? process.env.PI_PACKAGE_DIR : piPackageRoot,
+      [JITI_ALIAS_ENV]: binaryHost ? undefined : JSON.stringify(hostPeerAliases.aliases),
+      PI_ASYNC_NATIVE_RUNNER: !binaryHost && (runnerIsJavaScript || nativeRunnerSupported) ? "1" : "0",
+      DM_SUBAGENT_RUNNER_CONFIG: binaryHost ? cfgPath : undefined
+    };
+    if (launchParentSessionId === undefined)
+      delete runnerEnv[SUBAGENT_PARENT_SESSION_ENV];
+    else
+      runnerEnv[SUBAGENT_PARENT_SESSION_ENV] = launchParentSessionId;
+    const proc = spawn(command, args, {
       cwd,
       ...backgroundProcessOptions(),
       stdio: ["ignore", stdoutFd ?? "ignore", stderrFd ?? "ignore"],
-      env: {
-        ...omitExtensionBindingsEnv(process.env),
-        ...piPackageRoot ? { [DM_CODING_AGENT_PACKAGE_ROOT_ENV]: piPackageRoot } : {}
-      }
+      env: runnerEnv
+    });
+    let observedProcessExit;
+    proc.once("exit", (exitCode, signal) => {
+      observedProcessExit = { exitCode, signal };
+    });
+    const processClosed = new Promise((resolve) => {
+      proc.once("close", (exitCode, signal) => {
+        observedProcessExit ??= { exitCode, signal };
+        resolve({ exitCode, signal });
+      });
     });
     closeFd(stdoutFd);
     closeFd(stderrFd);
@@ -296,56 +436,62 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
       console.error(`[dm-subagents] async spawn failed: ${error.message}`);
     });
     proc.once("close", (exitCode, signal) => {
-      const launch = launchConfig;
-      const asyncDir = launch.asyncDir;
-      const runId = launch.id;
-      if (typeof asyncDir !== "string" || typeof runId !== "string")
-        return;
-      finalizeProcessTerminal(asyncDir, runId, {
-        processInstanceId: runnerProcessInstanceId,
-        closeObservedAt: Date.now(),
-        exitCode,
-        signal
-      });
-      const persisted = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId });
-      if (!persisted)
-        return;
-      if (launch.nestedRoute && launch.nestedSelf) {
-        try {
-          let status;
+      const finalize = () => {
+        const launch = launchConfig;
+        const asyncDir = launch.asyncDir;
+        const runId = launch.id;
+        if (typeof asyncDir !== "string" || typeof runId !== "string")
+          return;
+        finalizeProcessTerminal(asyncDir, runId, {
+          processInstanceId: runnerProcessInstanceId,
+          closeObservedAt: Date.now(),
+          exitCode,
+          signal
+        });
+        const persisted = readProcessTerminal(asyncDir, { runId, runnerProcessInstanceId });
+        if (!persisted)
+          return;
+        if (launch.nestedRoute && launch.nestedSelf) {
           try {
-            status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
-            status.processTerminal = persisted;
-          } catch {
-            status = {
-              runId,
-              mode: "single",
-              state: persisted.state === "observed" ? "complete" : "failed",
-              startedAt: persisted.observedAt ?? Date.now(),
-              lastUpdate: Date.now(),
-              processTerminal: persisted
-            };
-          }
-          writeNestedEvent(launch.nestedRoute, {
-            type: "subagent.nested.completed",
-            ts: Date.now(),
-            parentRunId: launch.nestedSelf.parentRunId,
-            parentStepIndex: launch.nestedSelf.parentStepIndex,
-            child: nestedSummaryFromAsyncStatus(status, asyncDir, {
-              id: runId,
+            let status;
+            try {
+              status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+              status.processTerminal = persisted;
+            } catch {
+              status = {
+                runId,
+                mode: "single",
+                state: persisted.state === "observed" ? "complete" : "failed",
+                startedAt: persisted.observedAt ?? Date.now(),
+                lastUpdate: Date.now(),
+                processTerminal: persisted
+              };
+            }
+            writeNestedEvent(launch.nestedRoute, {
+              type: "subagent.nested.completed",
+              ts: Date.now(),
               parentRunId: launch.nestedSelf.parentRunId,
               parentStepIndex: launch.nestedSelf.parentStepIndex,
-              depth: launch.nestedSelf.depth,
-              path: launch.nestedSelf.path,
-              mode: status.mode,
-              ts: Date.now()
-            })
-          });
-        } catch (error) {
-          console.error("Failed to emit final nested process-terminal status:", error);
+              child: nestedSummaryFromAsyncStatus(status, asyncDir, {
+                id: runId,
+                parentRunId: launch.nestedSelf.parentRunId,
+                parentStepIndex: launch.nestedSelf.parentStepIndex,
+                depth: launch.nestedSelf.depth,
+                path: launch.nestedSelf.path,
+                mode: status.mode,
+                ts: Date.now()
+              })
+            });
+          } catch (error) {
+            console.error("Failed to emit final nested process-terminal status:", error);
+          }
         }
-      }
-      onProcessTerminal?.(persisted);
+        onProcessTerminal?.(persisted);
+      };
+      if (startupPath)
+        setImmediate(finalize);
+      else
+        finalize();
     });
     if (typeof proc.pid !== "number") {
       return { error: `async runner did not produce a pid for cwd: ${cwd}` };
@@ -356,8 +502,31 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
         pid: proc.pid,
         processTerminal: { version: 1, state: "pending", runId: initialStatus.runId, runnerProcessInstanceId }
       });
+      updateActiveRunIndex(path.dirname(initialStatusPath), initialStatus.state, initialStatus.toolCallId);
     } catch (error) {
       const message = `Failed to persist initial async status: ${error instanceof Error ? error.message : String(error)}`;
+      if (launchAsyncDir)
+        persistPreProceedStartupFailure(launchAsyncDir, launchRunId, runnerProcessInstanceId, launchSessionId, launchCompletionOwnerId, message);
+      const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    try {
+      if (!launchAsyncDir)
+        throw new Error("Async runner is missing its lifecycle directory.");
+      initializeProcessTerminal(launchAsyncDir, launchRunId, runnerProcessInstanceId);
+    } catch (error) {
+      const message = `Failed to establish async runner lifecycle sidecar: ${error instanceof Error ? error.message : String(error)}`;
+      if (launchAsyncDir)
+        persistPreProceedStartupFailure(launchAsyncDir, launchRunId, runnerProcessInstanceId, launchSessionId, launchCompletionOwnerId, message);
+      const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    try {
+      onBeforeProceed?.(runnerProcessInstanceId);
+    } catch (error) {
+      const message = `Failed to establish async runner capacity ownership: ${error instanceof Error ? error.message : String(error)}`;
+      if (launchAsyncDir)
+        persistPreProceedStartupFailure(launchAsyncDir, launchRunId, runnerProcessInstanceId, launchSessionId, launchCompletionOwnerId, message);
       const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
       return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
     }
@@ -373,42 +542,12 @@ function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProce
       }
     }
     proc.unref();
-    if (startupPath && startupAckPath && startupProceedPath) {
+    if (startupPath && startupAckPath && startupConfirmPath && startupProceedPath) {
       const persistStartupFailure = (message) => {
         if (launchAsyncDir)
           persistPreProceedStartupFailure(launchAsyncDir, launchRunId, runnerProcessInstanceId, launchSessionId, launchCompletionOwnerId, message);
       };
-      const ready = waitForRunnerStartup(startupPath, "ready", RUNNER_STARTUP_TIMEOUT_MS);
-      if (ready.ok === false) {
-        persistStartupFailure(ready.error);
-        const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
-        return { pid: proc.pid, runnerProcessInstanceId, error: ready.error, terminationObserved, startupDidNotProceed: ready.startupDidNotProceed };
-      }
-      try {
-        writeRunnerStartupControl(startupAckPath, { action: "ack", token: ready.token });
-      } catch (error) {
-        const message = `Failed to acknowledge async runner startup: ${error instanceof Error ? error.message : String(error)}`;
-        persistStartupFailure(message);
-        const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
-        return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
-      }
-      const acknowledged = waitForRunnerStartup(startupPath, "acknowledged", RUNNER_STARTUP_TIMEOUT_MS, ready.token);
-      if (acknowledged.ok === false) {
-        persistStartupFailure(acknowledged.error);
-        const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
-        return { pid: proc.pid, runnerProcessInstanceId, error: acknowledged.error, terminationObserved, startupDidNotProceed: acknowledged.startupDidNotProceed };
-      }
-      try {
-        writeRunnerStartupControl(startupProceedPath, { action: "proceed", token: ready.token });
-      } catch (error) {
-        const message = `Failed to authorize async runner startup: ${error instanceof Error ? error.message : String(error)}`;
-        persistStartupFailure(message);
-        const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
-        return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
-      }
-      try {
-        fs.rmSync(startupPath, { force: true });
-      } catch {}
+      return completeRunnerStartupHandshake(startupPath, startupAckPath, startupConfirmPath, startupProceedPath, proc, processClosed, () => observedProcessExit ?? (proc.exitCode !== null || proc.signalCode !== null ? { exitCode: proc.exitCode, signal: proc.signalCode } : undefined), runnerProcessInstanceId, persistStartupFailure);
     }
     return { pid: proc.pid, runnerProcessInstanceId };
   } catch (error) {
@@ -441,13 +580,26 @@ export function buildAsyncRunnerSteps(id, params) {
     thinkingOverridesByFlatIndex,
     maxSubagentDepth,
     worktreeBaseDir,
+    worktreeProvider,
+    worktreeBranchPrefix,
     asyncDir
   } = params;
+  const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
   const outputBaseDir = params.outputBaseDir;
   const resultMode = params.resultMode ?? "chain";
   const chainSkills = params.chainSkills ?? [];
   const availableModels = params.availableModels;
   const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
+  const launchMachine = params.machine;
+  let managedWorktreeProvider;
+  try {
+    if (chain.some((step) => ("worktree" in step) && step.worktree === true)) {
+      const resolved = resolveWorktreeProvider(worktreeProvider, worktreeBaseDir);
+      managedWorktreeProvider = shouldDeferWorktreeCwd(worktreeProvider, worktreeBaseDir) ? "worktrunk" : resolved;
+    }
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
   const progressDir = params.progressDir ?? runnerCwd;
   const graphChain = params.attachRoot ? [{
     agent: params.attachRoot.agent,
@@ -466,7 +618,6 @@ export function buildAsyncRunnerSteps(id, params) {
       return { error: error.message };
     throw error;
   }
-  const workflowGraph = buildWorkflowGraphSnapshot({ runId: id, mode: resultMode, steps: graphChain });
   const diagnosticContext = params.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path.resolve(runnerCwd), "both"));
   for (const s of chain) {
     const stepAgents = isParallelStep(s) ? s.parallel.map((t) => t.agent) : isDynamicParallelStep(s) ? [s.parallel.agent] : [s.agent];
@@ -475,6 +626,8 @@ export function buildAsyncRunnerSteps(id, params) {
         return { error: formatUnknownAgentError(agentName, diagnosticContext) };
     }
   }
+  const graphSteps = projectChainOutputSchemas(graphChain, agents);
+  const workflowGraph = buildWorkflowGraphSnapshot({ runId: id, mode: resultMode, steps: graphSteps });
   let progressInstructionCreated = false;
   const buildStepOverrides = (s) => {
     const stepSkillInput = normalizeSkillInput(s.skill);
@@ -485,18 +638,35 @@ export function buildAsyncRunnerSteps(id, params) {
       ...s.progress !== undefined ? { progress: s.progress } : {},
       ...stepSkillInput !== undefined ? { skills: stepSkillInput } : {},
       ...s.model !== undefined ? { model: s.model } : {},
-      ...s.fast !== undefined ? { fast: s.fast } : {}
+      ...s.fast !== undefined ? { fast: s.fast } : {},
+      ...s.outputSchema !== undefined ? { outputSchema: s.outputSchema } : {}
     };
   };
   const buildSeqStep = (s, sessionFile, behaviorCwd, progressPrecreated = false, resolvedBehavior, flatIndex, parallelOutputNamespace, runFanoutPath) => {
     const a = agents.find((x) => x.name === s.agent);
+    const effectiveBehavior = resolvedBehavior ?? suppressProgressForReadOnlyTask(resolveStepBehavior(a, buildStepOverrides(s), chainSkills), s.task, originalTask);
+    const requestedMachine = s.machine ?? launchMachine ?? a.machine;
     const externalRunner = a.runner?.type === "external-cli" || a.runner?.type === "external-job";
     const externalRunnerType = a.runner?.type;
+    const machineUnsupported = formatHerdrMachineRunnerUnsupported({ machine: requestedMachine, agentName: a.name, runnerType: a.runner?.type, adapter: a.runner?.type === "external-cli" ? a.runner.adapter : undefined, worktree: s.worktree });
+    if (machineUnsupported)
+      throw new AsyncStartValidationError(machineUnsupported);
+    let machine;
+    let machineEnv;
+    if (requestedMachine) {
+      try {
+        const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: s.cwd ?? params.machineCwd });
+        machine = placement.machine;
+        machineEnv = placement.env;
+      } catch (error) {
+        throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+      }
+    }
     if (externalRunner) {
       const unsupported = [];
       if (s.model !== undefined)
         unsupported.push("model override");
-      if (s.outputSchema !== undefined)
+      if (effectiveBehavior.outputSchema !== undefined)
         unsupported.push("structured output");
       if (s.acceptance !== undefined || params.agentContract !== undefined || s.agentContract !== undefined)
         unsupported.push("acceptance/agent contract");
@@ -510,7 +680,7 @@ export function buildAsyncRunnerSteps(id, params) {
         throw new AsyncStartValidationError(`Agent '${a.name}' uses runner.type='${externalRunnerType}' and does not support: ${unsupported.join(", ")}.`);
     }
     try {
-      assertAgentAllowedByCapabilityCeiling(a.name, intersectSubagentCapabilityCeilings(params.capabilityCeiling, decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV])));
+      assertAgentAllowedByCapabilityCeiling(a.name, intersectSubagentCapabilityCeilings(params.capabilityCeiling, ctx.childRuntime?.capabilityCeiling));
     } catch (error) {
       throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
     }
@@ -535,52 +705,39 @@ export function buildAsyncRunnerSteps(id, params) {
       runtimeCwd: ctx.cwd,
       stepCwdInput: s.cwd,
       behaviorCwd,
+      ...machine ? { machineCwd: machine.cwd } : {},
       chainSkills,
       outputBaseDir,
       parallelOutputNamespace,
-      resolvedBehavior
+      resolvedBehavior: effectiveBehavior
     });
     const { stepCwd, instructionCwd, readExistenceCwd, behavior, namespaceOutputPath, outputPath, skillNames } = launchPlan;
     const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd, a.skillPath, a.filePath ? path.dirname(a.filePath) : stepCwd);
     if (missingSkills.includes("dm-subagents"))
       throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-    let systemPrompt = a.systemPrompt?.trim() ?? "";
-    if (resolvedSkills.length > 0) {
-      const injection = buildSkillInjection(resolvedSkills);
-      systemPrompt = systemPrompt ? `${systemPrompt}
-
-${injection}` : injection;
-    }
-    const memoryInjection = buildAgentMemoryInjection(a, stepCwd);
-    if (memoryInjection) {
-      systemPrompt = systemPrompt ? `${systemPrompt}
-
-${memoryInjection}` : memoryInjection;
-    }
-    systemPrompt = appendAgentRefinementOverlay(systemPrompt, { cwd: stepCwd, agentName: a.name });
+    const systemPrompt = buildEffectiveSystemPrompt({ agent: a, resolvedSkills, cwd: stepCwd, ...!namespaceOutputPath && outputPath ? { outputPath } : {} });
     const readInstructions = buildChainInstructions({ ...behavior, output: false, progress: false }, instructionCwd, false, undefined, readExistenceCwd);
     const isFirstProgressAgent = behavior.progress && !progressPrecreated && !progressInstructionCreated;
     if (behavior.progress)
       progressInstructionCreated = true;
     const progressInstructions = buildChainInstructions({ ...behavior, output: false, reads: false }, progressDir, isFirstProgressAgent);
-    if (!namespaceOutputPath)
-      systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, a);
     const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Async step (${s.agent})`);
     if (validationError)
       throw new AsyncStartValidationError(validationError);
     let taskTemplate = s.task ?? "{previous}";
     taskTemplate = taskTemplate.replace(/\{task\}/g, originalTask ?? "");
-    taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
+    taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, behaviorCwd ?? runnerCwd);
     const taskText = `${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`;
     const task = namespaceOutputPath ? taskText : injectSingleOutputInstruction(taskText, outputPath, a);
     const modelScopes = resolveModelScopesForAgent(ctx.modelScope, a.name, ctx.currentModel);
-    const primaryModelFromParent = inheritsParentModel(s.model, a.model, ctx.currentModel);
-    const primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(s.model, a.model, ctx.currentModel, availableModels, a.modelProvider ?? ctx.currentModelProvider, { scope: modelScopes });
+    const modelOrigin = resolveModelOrigin({ explicitModel: s.model, agentModel: a.model, parentModel: ctx.currentModel });
+    const primaryModelFromParent = modelOrigin === "inherited";
+    const primaryModel = externalRunner ? undefined : resolveEffectiveSubagentModel(s.model, a.model, ctx.currentModel, availableModels, a.modelProvider ?? ctx.currentModelProvider, { scope: modelScopes, source: modelOrigin === "explicit" ? "explicit" : "inherited" });
     const thinkingOverride = flatIndex === undefined ? undefined : thinkingOverridesByFlatIndex?.[flatIndex];
     const effectiveThinking = externalRunner ? undefined : thinkingOverride ?? a.thinking;
     const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== undefined);
     const contextLimit = model ? findModelInfo(model, availableModels, a.modelProvider ?? ctx.currentModelProvider)?.contextWindow : undefined;
-    const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(params.thinkingCeiling, a.maxThinking, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]));
+    const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(params.thinkingCeiling, a.maxThinking, ctx.childRuntime?.thinkingCeiling);
     if (!externalRunner) {
       try {
         assertThinkingWithinCeiling({ model, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: a.name, runId: id });
@@ -590,36 +747,42 @@ ${memoryInjection}` : memoryInjection;
     }
     const agentContract = s.agentContract ?? params.agentContract;
     const permissionRules = resolvePermissionRules(ctx.permissions, a.permissions);
-    const modelCandidates = externalRunner ? [] : buildModelCandidates(primaryModel, a.fallbackModels, availableModels, a.modelProvider ?? ctx.currentModelProvider, {
-      scope: modelScopes,
-      primaryModelFromParent
-    }).flatMap((candidate) => {
-      const resolved = applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined);
-      return resolved ? [resolved] : [];
-    });
+    let selectedModel = model;
+    let requestedModel;
     if (!externalRunner) {
       try {
-        for (const candidate of modelCandidates)
-          assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: a.name, runId: id });
+        const modelEvidence = resolveModelSelection(primaryModel, availableModels, a.modelProvider ?? ctx.currentModelProvider, {
+          scope: modelScopes,
+          primaryModelFromParent,
+          origin: modelOrigin
+        });
+        requestedModel = modelEvidence.requestedModel;
+        selectedModel = applyThinkingSuffix(modelEvidence.model, effectiveThinking, thinkingOverride !== undefined);
+        assertThinkingWithinCeiling({ model: selectedModel, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: a.name, runId: id });
       } catch (error) {
         throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
       }
     }
+    const launchRuleError = applyWatchdogLaunchRules({ cwd: machine ? runnerCwd : stepCwd, agent: a.name, model: selectedModel, warn: (violation) => sendRuleViolationWarning(ctx.dm, violation) });
+    if (launchRuleError)
+      throw new AsyncStartValidationError(launchRuleError);
     const fast = s.fast ?? params.fast ?? a.fast;
+    const requiredExtensions = externalRunner ? [] : ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
     const toolPlan = resolvePiLaunchToolPlan({
       tools: a.tools,
+      excludeTools: a.excludeTools,
       allowNestedSubagents: a.allowNestedSubagents,
       extensions: a.extensions,
       subagentOnlyExtensions: a.subagentOnlyExtensions,
+      requiredExtensions,
       mcpDirectTools: a.mcpDirectTools,
       cwd: stepCwd,
       requireReadTool: Boolean(resolvedSkills.length),
-      structuredOutput: Boolean(s.outputSchema),
+      structuredOutput: Boolean(behavior.outputSchema),
       fast,
-      model,
-      modelCandidates,
+      model: selectedModel,
       capabilityCeiling: params.capabilityCeiling,
-      inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+      inheritedCapabilityCeiling: ctx.childRuntime?.capabilityCeiling,
       agentName: a.name,
       permissionRules,
       runtimeSnapshotHost: ctx.dm
@@ -628,55 +791,43 @@ ${memoryInjection}` : memoryInjection;
     if (externalRunner && permissionRules) {
       throw new AsyncStartValidationError(`Agent '${a.name}' uses runner.type='${externalRunnerType}', which cannot enforce native DM child permission rules.`);
     }
-    if (!externalRunner) {
-      const contractTools = toolPlan.explicitToolAllowlist ? toolPlan.effectiveToolAllowlist : undefined;
-      const contractError = validateImplementationToolContract({
-        agent: a.name,
-        task,
-        tools: contractTools,
-        mcpDirectTools: toolPlan.effectiveMcpTools,
-        configuredExtensions: toolPlan.configuredExtensions,
-        requestedTools: toolPlan.requestedBuiltinTools,
-        acceptanceRole: a.acceptanceRole,
-        completionGuard: a.completionGuard
-      });
-      if (contractError)
-        throw new AsyncStartValidationError(contractError);
-    }
     return {
-      parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
+      parentSessionId: launchParentSessionId,
       permissionRules,
       ...params.capabilityCeiling ? { capabilityCeiling: params.capabilityCeiling } : {},
       ...runFanoutPath ? { runFanoutPath } : {},
       agent: s.agent,
       task,
       ...a.runner ? { runner: a.runner } : {},
+      ...machine ? { machine } : {},
+      ...machineEnv ? { machineEnv } : {},
       ...params.contextForAgent ? { context: params.contextForAgent(s.agent) } : {},
       ...agentContract ? { agentContract } : {},
       phase: s.phase,
       label: s.label,
       outputName: s.as,
-      structured: Boolean(s.outputSchema),
+      structured: Boolean(behavior.outputSchema),
       cwd: stepCwd,
-      requestedCwd: s.cwd ?? stepCwd,
-      model,
+      requestedCwd: machine ? machine.cwd : s.cwd ?? stepCwd,
+      model: selectedModel,
       ...contextLimit !== undefined ? { contextLimit } : {},
       ...fast !== undefined ? { fast } : {},
-      thinking: resolveEffectiveThinking(model, effectiveThinking),
+      thinking: resolveEffectiveThinking(selectedModel, effectiveThinking),
       ...thinkingCeiling ? { thinkingCeiling } : {},
       launchResolvedExtensions,
-      ...toolPlan.mcpConfig ? { mcpConfig: toolPlan.mcpConfig } : {},
-      ...toolPlan.runtimeServerNames ? { runtimeServerNames: toolPlan.runtimeServerNames } : {},
-      modelCandidates: externalRunner ? undefined : modelCandidates,
+      ...requestedModel ? { requestedModel } : {},
       ...primaryModelFromParent ? { skipPrimaryModelVerification: true } : {},
       ...availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {},
+      ...ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {},
       tools: a.tools,
+      excludeTools: a.excludeTools,
       allowNestedSubagents: a.allowNestedSubagents,
+      allowedAgents: a.allowedAgents,
       extensions: a.extensions,
       subagentOnlyExtensions: a.subagentOnlyExtensions,
+      ...!externalRunner ? { requiredExtensions } : {},
       mcpDirectTools: a.mcpDirectTools,
       mutationTools: a.mutationTools,
-      completionGuard: a.completionGuard,
       systemPrompt,
       systemPromptMode: a.systemPromptMode,
       inheritProjectContext: a.inheritProjectContext,
@@ -705,8 +856,8 @@ ${memoryInjection}` : memoryInjection;
       acceptanceInput: s.acceptance,
       acceptanceRole: a.acceptanceRole,
       ...s.gateOn ? { gateOn: s.gateOn } : {},
-      ...s.outputSchema ? { structuredOutputSchema: s.outputSchema } : {},
-      ...s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path.join(asyncDir, "structured-output"), { captureAcceptanceReport: s.acceptance !== false }) } : {},
+      ...behavior.outputSchema ? { structuredOutputSchema: behavior.outputSchema } : {},
+      ...behavior.outputSchema ? { structuredOutput: createStructuredOutputRuntime(behavior.outputSchema, path.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(s.acceptance) }) } : {},
       ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {},
       ...s.worktree ? { worktree: true } : {}
     };
@@ -739,7 +890,9 @@ ${memoryInjection}` : memoryInjection;
         return {
           parallel: s.parallel.map((t, taskIndex) => {
             let behaviorCwd;
-            if (s.worktree) {
+            if (s.worktree && managedWorktreeProvider === "worktrunk") {
+              behaviorCwd = WORKTREE_AGENT_CWD_PLACEHOLDER;
+            } else if (s.worktree && managedWorktreeProvider === "native") {
               try {
                 behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, taskIndex, worktreeBaseDir);
               } catch {
@@ -747,7 +900,7 @@ ${memoryInjection}` : memoryInjection;
               }
             }
             const staticStep = nextFlatStep();
-            return buildSeqStep({ ...t, agentContract: t.agentContract ?? s.agentContract, gateOn: t.gateOn ?? s.gateOn }, staticStep.sessionFile, behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex], staticStep.index, { stepIndex, taskIndex }, resultMode === "parallel" ? `tasks[${taskIndex}]` : `chain[${stepIndex}].parallel[${taskIndex}]`);
+            return buildSeqStep({ ...t, machine: t.machine ?? s.machine, worktree: s.worktree, agentContract: t.agentContract ?? s.agentContract, gateOn: t.gateOn ?? s.gateOn }, staticStep.sessionFile, behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex], staticStep.index, { stepIndex, taskIndex }, resultMode === "parallel" ? `tasks[${taskIndex}]` : `chain[${stepIndex}].parallel[${taskIndex}]`);
           }),
           concurrency: s.concurrency,
           failFast: s.failFast,
@@ -794,7 +947,9 @@ ${memoryInjection}` : memoryInjection;
       }
       const sequential = s;
       let behaviorCwd;
-      if (sequential.worktree) {
+      if (sequential.worktree && managedWorktreeProvider === "worktrunk") {
+        behaviorCwd = WORKTREE_AGENT_CWD_PLACEHOLDER;
+      } else if (sequential.worktree && managedWorktreeProvider === "native") {
         try {
           behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, 0, worktreeBaseDir);
         } catch {
@@ -805,6 +960,7 @@ ${memoryInjection}` : memoryInjection;
       return buildSeqStep(sequential, staticStep.sessionFile, behaviorCwd, false, undefined, staticStep.index, undefined, `chain[${stepIndex}]`);
     });
     const steps = params.attachRoot ? [{
+      parentSessionId: launchParentSessionId,
       agent: params.attachRoot.agent,
       task: "",
       label: params.attachRoot.label ?? `Attached root ${params.attachRoot.runId}`,
@@ -858,6 +1014,9 @@ export function executeAsyncChain(id, params) {
     worktreeSetupHook,
     worktreeSetupHookTimeoutMs,
     worktreeBaseDir,
+    baseRef,
+    worktreeProvider,
+    worktreeBranchPrefix,
     controlConfig,
     controlIntercomTarget,
     childIntercomTarget,
@@ -865,19 +1024,13 @@ export function executeAsyncChain(id, params) {
   } = params;
   const resultMode = params.resultMode ?? "chain";
   const acceptanceErrors = validateExecutionAcceptance({
-    chain: chain.map((step) => {
-      if (isParallelStep(step))
-        return { parallel: step.parallel };
-      if (isDynamicParallelStep(step))
-        return { acceptance: step.acceptance, parallel: step.parallel };
-      return { acceptance: step.acceptance };
-    })
+    chain: projectChainOutputSchemas(chain, agents, (step, outputSchema) => ({ acceptance: step.acceptance, outputSchema }), (step, parallel) => Array.isArray(step.parallel) ? { parallel } : { acceptance: "acceptance" in step ? step.acceptance : undefined, parallel })
   });
   if (acceptanceErrors.length > 0)
     return formatAsyncStartError(resultMode, acceptanceErrors.join(" "));
   const capabilityCeiling = params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId);
-  const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
-  const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
+  const inheritedNestedRoute = inheritedNestedRouteOf(ctx.childRuntime);
+  const nestedAddress = inheritedNestedRoute ? inheritedNestedParentAddressOf(ctx.childRuntime) : undefined;
   const asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(DIRS.async, id);
   let runFanoutBudget;
   try {
@@ -903,6 +1056,8 @@ export function executeAsyncChain(id, params) {
     availableModels: params.availableModels,
     cwd,
     chainSkills: params.chainSkills,
+    machine: params.machine,
+    machineCwd: params.machineCwd,
     sessionFilesByFlatIndex,
     thinkingOverridesByFlatIndex,
     contextForAgent: params.contextForAgent,
@@ -914,6 +1069,8 @@ export function executeAsyncChain(id, params) {
     waitToolEnabled: params.waitToolEnabled,
     waitToolDefaultTimeoutMs: params.waitToolDefaultTimeoutMs,
     worktreeBaseDir,
+    worktreeProvider,
+    worktreeBranchPrefix,
     asyncDir,
     fast: params.fast,
     toolBudget: params.toolBudget,
@@ -961,6 +1118,7 @@ export function executeAsyncChain(id, params) {
   }
   const initialStatusAt = Date.now();
   const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+  const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
   let spawnResult = {};
   try {
     spawnResult = spawnRunner({
@@ -979,10 +1137,14 @@ export function executeAsyncChain(id, params) {
       completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
       ...capabilityCeiling ? { capabilityCeiling } : {},
       piPackageRoot,
-      piArgv1: process.argv[1],
+      childSessionFactoryModule: childSessionFactoryModule(),
+      inheritedChildRuntime: inheritedChildRuntime(ctx.childRuntime),
       worktreeSetupHook,
       worktreeSetupHookTimeoutMs,
       worktreeBaseDir,
+      baseRef,
+      worktreeProvider,
+      worktreeBranchPrefix,
       controlConfig,
       toolBudget: params.toolBudget,
       usageBudget: params.usageBudget,
@@ -1017,14 +1179,17 @@ export function executeAsyncChain(id, params) {
       chainStepCount: eventChain.length,
       ...initialParallelGroups.length ? { parallelGroups: initialParallelGroups } : {},
       steps: initialStatusSteps
-    }, path.join(asyncDir, "status.json"), (proof) => emitProcessTerminalEvent(ctx, proof));
+    }, path.join(asyncDir, "status.json"), launchParentSessionId, (proof) => emitProcessTerminalEvent(ctx, proof), (runnerProcessInstanceId) => params.activeAsyncCapacity?.markStarted(runnerProcessInstanceId));
   } catch (error) {
     params.activeAsyncCapacity?.rollback();
     const message = error instanceof Error ? error.message : String(error);
     return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${message}`);
   }
   if (spawnResult.error) {
-    if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId || spawnResult.startupDidNotProceed && spawnResult.terminationObserved)
+    if (spawnResult.startupDidNotProceed) {
+      if (!spawnResult.runnerProcessInstanceId || params.activeAsyncCapacity?.rollbackBeforeRunnerProceed(spawnResult.runnerProcessInstanceId) !== true)
+        params.activeAsyncCapacity?.rollback();
+    } else if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId)
       params.activeAsyncCapacity?.rollback();
     else
       params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
@@ -1034,7 +1199,6 @@ export function executeAsyncChain(id, params) {
     params.activeAsyncCapacity?.rollback();
     return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': runner identity unavailable`);
   }
-  params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
   if (spawnResult.pid) {
     const eventFirstStep = eventChain[0];
     if (!eventFirstStep) {
@@ -1077,7 +1241,7 @@ export function executeAsyncChain(id, params) {
             path: nestedAddress.path,
             asyncDir,
             pid: spawnResult.pid,
-            ownerIntercomTarget: process.env.DM_SUBAGENT_INTERCOM_SESSION_NAME,
+            ownerIntercomTarget: ctx.childRuntime?.intercomSessionName,
             leafIntercomTarget: childIntercomTargets?.[0],
             intercomTarget: childIntercomTargets?.[0],
             ownerState: "live",
@@ -1148,6 +1312,9 @@ export function executeAsyncSingle(id, params) {
     worktreeSetupHook,
     worktreeSetupHookTimeoutMs,
     worktreeBaseDir,
+    baseRef,
+    worktreeProvider,
+    worktreeBranchPrefix,
     controlConfig,
     controlIntercomTarget,
     childIntercomTarget,
@@ -1198,36 +1365,46 @@ export function executeAsyncSingle(id, params) {
     if (unsupported.length > 0)
       return formatAsyncStartError("single", `Agent '${agentConfig.name}' uses runner.type='${externalRunnerType}' and does not support: ${unsupported.join(", ")}.`);
   }
-  const capabilityCeiling = intersectSubagentCapabilityCeilings(params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId), decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]));
+  const capabilityCeiling = intersectSubagentCapabilityCeilings(params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId), ctx.childRuntime?.capabilityCeiling);
   try {
     assertAgentAllowedByCapabilityCeiling(agentConfig.name, capabilityCeiling);
   } catch (error) {
     return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
   }
   const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
-  const instructionCwd = params.worktree === true ? resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s0`, 0, worktreeBaseDir) : runnerCwd;
+  const requestedMachine = params.machine ?? agentConfig.machine;
+  const machineUnsupported = formatHerdrMachineRunnerUnsupported({ machine: requestedMachine, agentName: agentConfig.name, runnerType: agentConfig.runner?.type, adapter: agentConfig.runner?.type === "external-cli" ? agentConfig.runner.adapter : undefined, worktree: params.worktree });
+  if (machineUnsupported)
+    return formatAsyncStartError("single", machineUnsupported);
+  let machine;
+  let machineEnv;
+  if (requestedMachine) {
+    try {
+      const placement = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: runnerCwd, stepCwd: params.machineCwd });
+      machine = placement.machine;
+      machineEnv = placement.env;
+    } catch (error) {
+      return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+    }
+  }
+  let managedWorktreeProvider;
+  if (params.worktree === true) {
+    try {
+      const resolved = resolveWorktreeProvider(params.worktreeProvider, worktreeBaseDir);
+      managedWorktreeProvider = shouldDeferWorktreeCwd(params.worktreeProvider, worktreeBaseDir) ? "worktrunk" : resolved;
+    } catch (error) {
+      return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+    }
+  }
+  const instructionCwd = params.worktree === true && managedWorktreeProvider === "worktrunk" ? WORKTREE_AGENT_CWD_PLACEHOLDER : params.worktree === true && managedWorktreeProvider === "native" ? resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s0`, 0, worktreeBaseDir) : machine?.cwd ?? runnerCwd;
   const readExistenceCwd = params.worktree === true ? runnerCwd : instructionCwd;
   const skillNames = params.skills ?? agentConfig.skills ?? [];
   const availableModels = params.availableModels;
   const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd, agentConfig.skillPath, agentConfig.filePath ? path.dirname(agentConfig.filePath) : runnerCwd);
   if (missingSkills.includes("dm-subagents"))
     return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-  let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
-  if (resolvedSkills.length > 0) {
-    const injection = buildSkillInjection(resolvedSkills);
-    systemPrompt = systemPrompt ? `${systemPrompt}
-
-${injection}` : injection;
-  }
-  const memoryInjection = buildAgentMemoryInjection(agentConfig, runnerCwd);
-  if (memoryInjection) {
-    systemPrompt = systemPrompt ? `${systemPrompt}
-
-${memoryInjection}` : memoryInjection;
-  }
-  systemPrompt = appendAgentRefinementOverlay(systemPrompt, { cwd: runnerCwd, agentName: agentConfig.name });
-  const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
-  const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
+  const inheritedNestedRoute = inheritedNestedRouteOf(ctx.childRuntime);
+  const nestedAddress = inheritedNestedRoute ? inheritedNestedParentAddressOf(ctx.childRuntime) : undefined;
   const asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(DIRS.async, id);
   let runFanoutBudget;
   try {
@@ -1244,24 +1421,36 @@ ${memoryInjection}` : memoryInjection;
   }
   const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
   const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, instructionCwd, params.outputBaseDir ?? (artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined));
-  systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, agentConfig);
+  const systemPrompt = buildEffectiveSystemPrompt({ agent: agentConfig, resolvedSkills, cwd: runnerCwd, ...outputPath ? { outputPath } : {} });
   const outputMode = params.outputMode ?? agentConfig.outputMode ?? "inline";
   const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
   if (validationError)
     return formatAsyncStartError("single", validationError);
   const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, agentConfig);
   const reads = params.reads !== undefined ? params.reads : agentConfig.defaultReads ?? false;
-  const readPaths = Array.isArray(reads) ? resolveExistingReadPaths(reads, readExistenceCwd) : [];
+  const readPaths = Array.isArray(reads) ? machine ? externalRunner ? reads.map((read) => read === "~" || read.startsWith("~/") || path.posix.isAbsolute(read) ? read : path.posix.resolve(instructionCwd, read)) : [] : managedWorktreeProvider === "worktrunk" ? resolveExistingReadInstructionPaths(reads, instructionCwd, readExistenceCwd) : resolveExistingReadPaths(reads, readExistenceCwd) : [];
   const readsInstruction = readPaths.length > 0 ? `[Read from: ${readPaths.join(", ")}]
 
 ` : "";
   const taskText = readsInstruction + taskWithOutputInstruction;
   const modelScopes = resolveModelScopesForAgent(ctx.modelScope, agentConfig.name, ctx.currentModel);
-  const primaryModel = externalRunner ? undefined : params.modelOverrideFromParent ? params.modelOverride : resolveSubagentModelOverride(params.modelOverride ?? agentConfig.model, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: modelScopes });
+  const modelOrigin = resolveModelOrigin({
+    fromParent: params.modelOverrideFromParent,
+    storedOrigin: params.modelOrigin,
+    explicitModel: params.modelOverrideFromParent ? undefined : params.modelOverride,
+    agentModel: agentConfig.model,
+    parentModel: ctx.currentModel
+  });
+  let primaryModel;
+  try {
+    primaryModel = externalRunner ? undefined : modelOrigin === "inherited" ? params.modelOverride ?? (ctx.currentModel ? `${ctx.currentModel.provider}/${ctx.currentModel.id}` : undefined) : resolveSubagentModelOverride(params.modelOverride ?? agentConfig.model, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: modelScopes, source: modelOrigin === "explicit" ? "explicit" : "inherited" });
+  } catch (error) {
+    return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+  }
   const effectiveThinking = externalRunner ? undefined : params.thinkingOverride ?? agentConfig.thinking;
   const model = externalRunner ? undefined : applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
   const contextLimit = model ? findModelInfo(model, availableModels, agentConfig.modelProvider ?? ctx.currentModelProvider)?.contextWindow : undefined;
-  const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(params.thinkingCeiling, agentConfig.maxThinking, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]));
+  const thinkingCeiling = externalRunner ? undefined : intersectThinkingCeilings(params.thinkingCeiling, agentConfig.maxThinking, ctx.childRuntime?.thinkingCeiling);
   if (!externalRunner) {
     try {
       assertThinkingWithinCeiling({ model, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: agentConfig.name, runId: id });
@@ -1288,73 +1477,55 @@ ${memoryInjection}` : memoryInjection;
   const toolTimeoutMs = resolvedToolTimeout.toolTimeoutMs;
   const initialUsageBudget = usageBudgetState(params.usageBudget, undefined);
   const resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined);
-  const structuredOutput = params.structuredOutputSchema ? createStructuredOutputRuntime(params.structuredOutputSchema, path.join(asyncDir, "structured-output"), { captureAcceptanceReport: params.acceptance !== false }) : undefined;
-  const modelCandidates = externalRunner ? [] : buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, agentConfig.modelProvider ?? ctx.currentModelProvider, {
-    scope: modelScopes,
-    primaryModelFromParent: params.modelOverrideFromParent
-  }).flatMap((candidate) => {
-    const resolved = applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined);
-    return resolved ? [resolved] : [];
-  });
+  const structuredOutput = params.structuredOutputSchema ? createStructuredOutputRuntime(params.structuredOutputSchema, path.join(asyncDir, "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(params.acceptance) }) : undefined;
+  let selectedModel = model;
+  let requestedModel;
   if (!externalRunner) {
     try {
-      for (const candidate of modelCandidates)
-        assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: agentConfig.name, runId: id });
+      const modelEvidence = resolveModelSelection(primaryModel, availableModels, agentConfig.modelProvider ?? ctx.currentModelProvider, {
+        scope: modelScopes,
+        primaryModelFromParent: modelOrigin === "inherited",
+        origin: modelOrigin
+      });
+      requestedModel = modelEvidence.requestedModel;
+      selectedModel = applyThinkingSuffix(modelEvidence.model, effectiveThinking, params.thinkingOverride !== undefined);
+      assertThinkingWithinCeiling({ model: selectedModel, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: agentConfig.name, runId: id });
     } catch (error) {
       return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
     }
   }
+  const requiredExtensions = externalRunner ? [] : params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(ctx.parentSessionId ?? ctx.currentSessionId ?? undefined);
   const toolPlan = resolvePiLaunchToolPlan({
     tools: agentConfig.tools,
+    excludeTools: agentConfig.excludeTools,
     allowNestedSubagents: agentConfig.allowNestedSubagents,
     extensions: agentConfig.extensions,
     subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
+    requiredExtensions,
     mcpDirectTools: agentConfig.mcpDirectTools,
     cwd: runnerCwd,
     requireReadTool: Boolean(resolvedSkills.length),
     structuredOutput: Boolean(params.structuredOutputSchema),
     fast: params.fast ?? agentConfig.fast,
-    model,
-    modelCandidates,
+    model: selectedModel,
     capabilityCeiling,
-    inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+    inheritedCapabilityCeiling: ctx.childRuntime?.capabilityCeiling,
     agentName: agentConfig.name,
     permissionRules: resolvePermissionRules(ctx.permissions, agentConfig.permissions),
     runtimeSnapshotHost: ctx.dm
   });
   const launchResolvedExtensions = externalRunner ? undefined : projectLaunchResolvedChildExtensions(toolPlan);
-  if (!externalRunner) {
-    const contractTools = toolPlan.explicitToolAllowlist ? toolPlan.effectiveToolAllowlist : undefined;
-    const contractError = validateImplementationToolContract({
-      agent: agentConfig.name,
-      task: taskText,
-      tools: contractTools,
-      mcpDirectTools: toolPlan.effectiveMcpTools,
-      configuredExtensions: toolPlan.configuredExtensions,
-      requestedTools: toolPlan.requestedBuiltinTools,
-      acceptanceRole: agentConfig.acceptanceRole,
-      completionGuard: agentConfig.completionGuard
-    });
-    if (contractError)
-      return formatAsyncStartError("single", contractError);
-  }
-  const launchContractDigest = launchBindingDigest({
-    definitionDigest: agentDefinitionDigest(agentConfig),
+  const fast = params.fast ?? agentConfig.fast;
+  const launchThinking = resolveEffectiveThinking(selectedModel, effectiveThinking);
+  const { definitionDigest, launchContractDigest } = resolveLaunchBinding({
+    agent: agentConfig,
     task,
-    ...model ? { model } : {},
-    modelCandidates,
-    ...(params.fast ?? agentConfig.fast) !== undefined ? { fast: params.fast ?? agentConfig.fast } : {},
-    ...resolveEffectiveThinking(model, effectiveThinking) ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {},
-    ...thinkingCeiling ? { thinkingCeiling } : {},
+    model: selectedModel,
+    ...fast !== undefined ? { fast } : {},
+    ...launchThinking ? { thinking: launchThinking } : {},
     systemPrompt,
-    systemPromptMode: agentConfig.systemPromptMode,
-    inheritProjectContext: agentConfig.inheritProjectContext,
-    inheritGlobalContext: agentConfig.inheritGlobalContext,
-    inheritSkills: agentConfig.inheritSkills,
     skills: resolvedSkills.map((skill) => skill.name),
-    tools: toolPlan.effectiveToolAllowlist,
-    extensions: toolPlan.extensionArgs,
-    mcpDirectTools: toolPlan.effectiveMcpTools,
+    toolPlan,
     ...outputPath ? { outputPath } : {},
     outputMode,
     ...params.structuredOutputSchema ? { structuredOutputSchema: params.structuredOutputSchema } : {},
@@ -1371,10 +1542,12 @@ ${memoryInjection}` : memoryInjection;
   });
   const recoveryAgentConfig = params.recoveryAgentConfig ?? agentConfig;
   const recoveryDescriptor = {
+    ...ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {},
     version: 1,
     ...lane ? { lane } : {},
     launchContractDigest,
     ...extensionBindings ? { extensionBindings } : {},
+    ...requiredExtensions.length > 0 ? { requiredExtensions } : {},
     runFanoutBudget,
     sourceRunId: id,
     ...params.agentContract ? { agentContract: params.agentContract } : {},
@@ -1382,15 +1555,17 @@ ${memoryInjection}` : memoryInjection;
     launchResolvedExtensions,
     ...sessionFile ? { sessionFile } : {},
     cwd: runnerCwd,
-    ...model ? { model } : {},
+    ...selectedModel ? { model: selectedModel } : {},
     ...params.fast ?? recoveryAgentConfig.fast ? { fast: params.fast ?? recoveryAgentConfig.fast } : {},
     ...recoveryAgentConfig.modelProvider ? { modelProvider: recoveryAgentConfig.modelProvider } : {},
-    ...params.modelOverrideFromParent ? { modelOverrideFromParent: true } : {},
-    ...recoveryAgentConfig.fallbackModels ? { fallbackModels: [...recoveryAgentConfig.fallbackModels] } : {},
-    ...effectiveThinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {},
+    ...modelOrigin === "inherited" ? { modelOverrideFromParent: true } : {},
+    modelOrigin,
+    ...effectiveThinking ? { thinking: resolveEffectiveThinking(selectedModel, effectiveThinking) } : {},
     ...thinkingCeiling ? { thinkingCeiling } : {},
     ...recoveryAgentConfig.tools ? { tools: [...recoveryAgentConfig.tools] } : {},
+    ...recoveryAgentConfig.excludeTools ? { excludeTools: [...recoveryAgentConfig.excludeTools] } : {},
     ...recoveryAgentConfig.allowNestedSubagents !== undefined ? { allowNestedSubagents: recoveryAgentConfig.allowNestedSubagents } : {},
+    ...recoveryAgentConfig.allowedAgents !== undefined ? { allowedAgents: [...recoveryAgentConfig.allowedAgents] } : {},
     ...recoveryAgentConfig.extensions ? { extensions: [...recoveryAgentConfig.extensions] } : {},
     ...recoveryAgentConfig.subagentOnlyExtensions ? { subagentOnlyExtensions: [...recoveryAgentConfig.subagentOnlyExtensions] } : {},
     ...recoveryAgentConfig.mcpDirectTools ? { mcpDirectTools: [...recoveryAgentConfig.mcpDirectTools] } : {},
@@ -1403,7 +1578,6 @@ ${memoryInjection}` : memoryInjection;
     ...resolvedSkills.length ? { skills: resolvedSkills.map((skill) => skill.name) } : {},
     ...recoveryAgentConfig.skillPath ? { skillPath: [...recoveryAgentConfig.skillPath] } : {},
     ...recoveryAgentConfig.filePath ? { agentFilePath: recoveryAgentConfig.filePath } : {},
-    ...recoveryAgentConfig.completionGuard !== undefined ? { completionGuard: recoveryAgentConfig.completionGuard } : {},
     ...recoveryAgentConfig.memory ? { memory: { ...recoveryAgentConfig.memory } } : {},
     ...outputPath ? { outputPath } : {},
     outputMode,
@@ -1412,6 +1586,7 @@ ${memoryInjection}` : memoryInjection;
     ...controlConfig ? { controlConfig } : {},
     ...params.context ? { context: params.context } : {},
     ...params.intercomBridge !== undefined ? { intercomBridge: params.intercomBridge } : {},
+    ...params.baseRef !== undefined ? { baseRef: params.baseRef } : {},
     ...deadlineAt !== undefined ? { absoluteDeadlineAt: deadlineAt } : {},
     ...resolvedToolBudget.budget ? { initialToolBudget: resolvedToolBudget.budget } : {},
     maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, recoveryAgentConfig.maxSubagentDepth),
@@ -1429,41 +1604,46 @@ ${memoryInjection}` : memoryInjection;
       return formatAsyncStartError("single", `Failed to persist async recovery descriptor for '${id}': ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  let spawnResult = {};
+  let spawnResultOrPromise = {};
   const initialStatusAt = Date.now();
   const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
+  const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
   try {
-    spawnResult = spawnRunner({
+    spawnResultOrPromise = spawnRunner({
       id,
       steps: [
         {
-          parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
+          parentSessionId: launchParentSessionId,
           permissionRules,
           ...capabilityCeiling ? { capabilityCeiling } : {},
           agent,
           task: taskText,
           ...agentConfig.runner ? { runner: agentConfig.runner } : {},
+          ...machine ? { machine } : {},
+          ...!externalRunner && machine && params.reads !== undefined ? { remoteReads: params.reads } : {},
+          ...machineEnv ? { machineEnv } : {},
           ...params.externalJobFollowUp ? { externalJobFollowUp: params.externalJobFollowUp } : {},
           ...params.context ? { context: params.context } : {},
-          cwd: runnerCwd,
-          requestedCwd: params.requestedCwd ?? runnerCwd,
-          model,
+          cwd: machine?.cwd ?? runnerCwd,
+          requestedCwd: machine?.cwd ?? params.requestedCwd ?? runnerCwd,
+          model: selectedModel,
           ...contextLimit !== undefined ? { contextLimit } : {},
           ...params.fast ?? agentConfig.fast ? { fast: params.fast ?? agentConfig.fast } : {},
-          thinking: resolveEffectiveThinking(model, effectiveThinking),
+          thinking: resolveEffectiveThinking(selectedModel, effectiveThinking),
           ...thinkingCeiling ? { thinkingCeiling } : {},
-          modelCandidates,
-          ...params.modelOverrideFromParent ? { skipPrimaryModelVerification: true } : {},
+          ...requestedModel ? { requestedModel } : {},
+          ...modelOrigin === "inherited" ? { skipPrimaryModelVerification: true } : {},
           ...availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {},
+          ...ctx.modelResponseAliases ? { modelResponseAliases: ctx.modelResponseAliases } : {},
           tools: agentConfig.tools,
+          excludeTools: agentConfig.excludeTools,
           allowNestedSubagents: agentConfig.allowNestedSubagents,
+          allowedAgents: agentConfig.allowedAgents,
           extensions: agentConfig.extensions,
           subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
+          ...!externalRunner ? { requiredExtensions } : {},
           mcpDirectTools: agentConfig.mcpDirectTools,
-          ...toolPlan.mcpConfig ? { mcpConfig: toolPlan.mcpConfig } : {},
-          ...toolPlan.runtimeServerNames ? { runtimeServerNames: toolPlan.runtimeServerNames } : {},
           mutationTools: agentConfig.mutationTools,
-          completionGuard: agentConfig.completionGuard,
           systemPrompt,
           systemPromptMode: agentConfig.systemPromptMode,
           inheritProjectContext: agentConfig.inheritProjectContext,
@@ -1478,12 +1658,13 @@ ${memoryInjection}` : memoryInjection;
           waitToolEnabled: params.waitToolEnabled,
           waitToolDefaultTimeoutMs: params.waitToolDefaultTimeoutMs,
           ...params.agentContract ? { agentContract: params.agentContract } : {},
-          definitionDigest: agentDefinitionDigest(agentConfig),
+          definitionDigest,
           launchBindingTask: task,
           launchContractDigest,
           ...extensionBindings ? { extensionBindings } : {},
           launchResolvedExtensions,
           effectiveAcceptance: resolvedAcceptance,
+          acceptanceInput: params.acceptance,
           ...structuredOutput ? { structuredOutput } : {},
           ...params.structuredOutputSchema ? { structuredOutputSchema: params.structuredOutputSchema } : {},
           ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {},
@@ -1504,14 +1685,19 @@ ${memoryInjection}` : memoryInjection;
       completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
       ...capabilityCeiling ? { capabilityCeiling } : {},
       piPackageRoot,
-      piArgv1: process.argv[1],
+      childSessionFactoryModule: childSessionFactoryModule(),
+      inheritedChildRuntime: inheritedChildRuntime(ctx.childRuntime),
       worktreeSetupHook,
       worktreeSetupHookTimeoutMs,
       worktreeBaseDir,
+      baseRef,
+      worktreeProvider,
+      worktreeBranchPrefix,
       controlConfig,
       timeoutMs,
       deadlineAt,
       toolTimeoutMs,
+      checkpointBeforeDeadlineMs: params.checkpointBeforeDeadlineMs,
       toolBudget: params.toolBudget,
       usageBudget: params.usageBudget,
       controlIntercomTarget,
@@ -1544,85 +1730,90 @@ ${memoryInjection}` : memoryInjection;
       chainStepCount: 1,
       ...lane ? { lane } : {},
       steps: [{ agent, status: "pending", ...lane ? { lane } : {}, ...model ? { model } : {}, ...contextLimit !== undefined ? { contextLimit } : {} }]
-    }, path.join(asyncDir, "status.json"), (proof) => emitProcessTerminalEvent(ctx, proof), params.requestedCwd ?? runnerCwd);
+    }, path.join(asyncDir, "status.json"), launchParentSessionId, (proof) => emitProcessTerminalEvent(ctx, proof), (runnerProcessInstanceId) => params.activeAsyncCapacity?.markStarted(runnerProcessInstanceId), params.requestedCwd ?? runnerCwd);
   } catch (error) {
     params.activeAsyncCapacity?.rollback();
     const message = error instanceof Error ? error.message : String(error);
     return formatAsyncStartError("single", `Failed to start async run '${id}': ${message}`);
   }
-  if (spawnResult.error) {
-    if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId || spawnResult.startupDidNotProceed && spawnResult.terminationObserved)
+  const finishSpawnResult = (spawnResult) => {
+    if (spawnResult.error) {
+      if (spawnResult.startupDidNotProceed) {
+        if (!spawnResult.runnerProcessInstanceId || params.activeAsyncCapacity?.rollbackBeforeRunnerProceed(spawnResult.runnerProcessInstanceId) !== true)
+          params.activeAsyncCapacity?.rollback();
+      } else if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId)
+        params.activeAsyncCapacity?.rollback();
+      else
+        params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
+      return formatAsyncStartError("single", `Failed to start async run '${id}': ${spawnResult.error}`);
+    }
+    if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId) {
       params.activeAsyncCapacity?.rollback();
-    else
-      params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
-    return formatAsyncStartError("single", `Failed to start async run '${id}': ${spawnResult.error}`);
-  }
-  if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId) {
-    params.activeAsyncCapacity?.rollback();
-    return formatAsyncStartError("single", `Failed to start async run '${id}': runner identity unavailable`);
-  }
-  params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
-  if (spawnResult.pid) {
-    if (inheritedNestedRoute && nestedAddress) {
-      const now = Date.now();
-      try {
-        writeNestedEvent(inheritedNestedRoute, {
-          type: "subagent.nested.started",
-          ts: now,
-          parentRunId: nestedAddress.parentRunId,
-          parentStepIndex: nestedAddress.parentStepIndex,
-          child: {
-            id,
+      return formatAsyncStartError("single", `Failed to start async run '${id}': runner identity unavailable`);
+    }
+    if (spawnResult.pid) {
+      if (inheritedNestedRoute && nestedAddress) {
+        const now = Date.now();
+        try {
+          writeNestedEvent(inheritedNestedRoute, {
+            type: "subagent.nested.started",
+            ts: now,
             parentRunId: nestedAddress.parentRunId,
             parentStepIndex: nestedAddress.parentStepIndex,
-            depth: nestedAddress.depth,
-            path: nestedAddress.path,
-            asyncDir,
-            pid: spawnResult.pid,
-            ownerIntercomTarget: process.env.DM_SUBAGENT_INTERCOM_SESSION_NAME,
-            leafIntercomTarget: childIntercomTarget?.(agent, 0),
-            intercomTarget: childIntercomTarget?.(agent, 0),
-            ownerState: "live",
-            mode: "single",
-            state: "running",
-            agent,
-            agents: [agent],
-            chainStepCount: 1,
-            ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {},
-            startedAt: now,
-            lastUpdate: now,
-            ...capabilityCeiling ? { capabilityCeiling } : {}
-          }
-        });
-      } catch (error) {
-        console.error("Failed to emit nested async start event:", error);
+            child: {
+              id,
+              parentRunId: nestedAddress.parentRunId,
+              parentStepIndex: nestedAddress.parentStepIndex,
+              depth: nestedAddress.depth,
+              path: nestedAddress.path,
+              asyncDir,
+              pid: spawnResult.pid,
+              ownerIntercomTarget: ctx.childRuntime?.intercomSessionName,
+              leafIntercomTarget: childIntercomTarget?.(agent, 0),
+              intercomTarget: childIntercomTarget?.(agent, 0),
+              ownerState: "live",
+              mode: "single",
+              state: "running",
+              agent,
+              agents: [agent],
+              chainStepCount: 1,
+              ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {},
+              startedAt: now,
+              lastUpdate: now,
+              ...capabilityCeiling ? { capabilityCeiling } : {}
+            }
+          });
+        } catch (error) {
+          console.error("Failed to emit nested async start event:", error);
+        }
       }
+      ctx.dm.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+        lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+        id,
+        pid: spawnResult.pid,
+        sessionId: ctx.currentSessionId,
+        completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+        mode: "single",
+        agent,
+        task: task?.trim() ? PROMPT_REDACTED : undefined,
+        goal: (params.goal ?? task).trim() ? PROMPT_REDACTED : undefined,
+        cwd: runnerCwd,
+        asyncDir,
+        ...sessionRoot ? { sessionRoot } : {},
+        launchContractDigest,
+        launchResolvedExtensions,
+        ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {},
+        ...params.workflowKey ? { workflowKey: params.workflowKey } : {},
+        ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {},
+        ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {},
+        ...capabilityCeiling ? { capabilityCeiling } : {},
+        nestedRoute
+      });
     }
-    ctx.dm.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-      lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
-      id,
-      pid: spawnResult.pid,
-      sessionId: ctx.currentSessionId,
-      completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
-      mode: "single",
-      agent,
-      task: task?.trim() ? PROMPT_REDACTED : undefined,
-      goal: (params.goal ?? task).trim() ? PROMPT_REDACTED : undefined,
-      cwd: runnerCwd,
-      asyncDir,
-      ...sessionRoot ? { sessionRoot } : {},
-      launchContractDigest,
-      launchResolvedExtensions,
-      ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {},
-      ...params.workflowKey ? { workflowKey: params.workflowKey } : {},
-      ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {},
-      ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {},
-      ...capabilityCeiling ? { capabilityCeiling } : {},
-      nestedRoute
-    });
-  }
-  return {
-    content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`, ctx.interactive === true) }],
-    details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir, launchContractDigest, launchResolvedExtensions, ...capabilityCeiling ? { capabilityCeiling } : {}, ...params.context ? { context: params.context } : {}, ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {}, ...params.toolBudget ? { toolBudget: resolvedToolBudget.budget ?? params.toolBudget } : {}, ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {} }
+    return {
+      content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`, ctx.interactive === true) }],
+      details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir, launchContractDigest, launchResolvedExtensions, ...capabilityCeiling ? { capabilityCeiling } : {}, ...params.context ? { context: params.context } : {}, ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {}, ...params.toolBudget ? { toolBudget: resolvedToolBudget.budget ?? params.toolBudget } : {}, ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {} }
+    };
   };
+  return spawnResultOrPromise instanceof Promise ? spawnResultOrPromise.then(finishSpawnResult) : finishSpawnResult(spawnResultOrPromise);
 }