@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -1,34 +1,56 @@
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
-import { applyThinkingSuffix, resolveRuntimeExtensionPath } from "../shared/dm-args.js";
+import { createRequire } 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 { 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, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile } from "../../shared/settings.js";
+import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveExistingReadPaths, writeInitialProgressFile } from "../../shared/settings.js";
 import { resolvePiPackageRoot } from "../shared/dm-spawn.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 { PI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveChildCwd } from "../../shared/utils.js";
-import { buildModelCandidates, resolveSubagentModelOverride } from "../shared/model-fallback.js";
-import { resolveEffectiveThinking } from "../../shared/model-info.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 { 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 { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.js";
 import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.js";
 import { createStructuredOutputRuntime } from "../shared/structured-output.js";
-import { resolveEffectiveAcceptance } from "../shared/acceptance.js";
+import { resolveEffectiveAcceptance, validateAcceptanceInput, validateExecutionAcceptance } from "../shared/acceptance.js";
+import { createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
+import { validateImplementationToolContract } from "../shared/completion-guard.js";
 import {
-  ASYNC_DIR,
-  RESULTS_DIR,
+  DIRS,
   SUBAGENT_ASYNC_STARTED_EVENT,
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
   TEMP_ROOT_DIR,
   getAsyncConfigPath,
   resolveChildMaxSubagentDepth
 } from "../../shared/types.js";
-import { nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.js";
-import { initialTurnBudgetState } from "../shared/turn-budget.js";
+import { nestedResultsPath, nestedSummaryFromAsyncStatus, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.js";
+import { resultFilePath } from "./result-files.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
+import { usageBudgetState } from "../shared/usage-budget.js";
+import { finalizeProcessTerminal, readProcessTerminal } from "./process-terminal.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 { resolvePermissionRules } from "../shared/permissions.js";
+import { normalizeExtensionBindings, omitExtensionBindingsEnv } from "../shared/extension-bindings.js";
+import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
 const require = createRequire(import.meta.url);
 const piPackageRoot = resolvePiPackageRoot();
 function resolveJitiCliFromPackageJson(packageJsonPath) {
@@ -71,37 +93,25 @@ function resolveJitiCliPath() {
   return;
 }
 const jitiCliPath = resolveJitiCliPath();
-export function formatAsyncStartedMessage(headline) {
-  return [
-    headline,
-    "",
+export const DEFAULT_ASYNC_TIMEOUT_MS = 30 * 60 * 1000;
+export function formatAsyncStartedMessage(headline, interactive) {
+  const guidance = interactive ? [
+    "The async run is detached and running in the background.",
+    "You are in an interactive session. Return control to the user now; DM will wake you through the native completion notification when this subagent completes or needs attention. Do not run sleep/polling loops to wait for this async subagent; it does not need a wait call.",
+    "Use bg_wait only for provider, detached, or other background work that lacks a native completion notification.",
+    "If the current turn must receive results from work without a native notification before it ends, call blocking bg_wait(); ordinary async subagent runs do not need a wait call because their completion is delivered natively.",
+    'Otherwise, continue any independent work or return control to the user. Use subagent({ action: "status", id: "..." }) for a one-shot status/result or to inspect a blocked/stale run, never as a wait loop.'
+  ] : [
     "The async run is detached. Do not run sleep timers or polling loops just to wait for it.",
-    "If you have independent work, continue that work. When you have nothing left to do until the async result arrives, call wait() — it blocks until the run finishes and delivers the completion here. Only if you are certain you will get another turn (an interactive session where the user will prompt you again) can you instead stop and let DM wake you; inside a skill that must run to completion, or in a non-interactive run, there is no next turn, so use wait().",
-    'Use subagent({ action: "status", id: "..." }) when you need a one-shot status/result or to inspect a blocked/stale run. To block until completion, prefer wait(). Do not poll in a loop just to wait.'
-  ].join(`
+    "This is a non-interactive run: DM auto-drains current-session subagent work at agent_end so detached children are not abandoned. Use bg_wait only when this turn must receive provider, detached, or other background-work results that have no native completion notification.",
+    'Use subagent({ action: "status", id: "..." }) when you need a one-shot status/result or to inspect a blocked/stale run; do not poll in a loop.'
+  ];
+  return [headline, "", ...guidance].join(`
 `);
 }
 export function isAsyncAvailable() {
   return jitiCliPath !== undefined;
 }
-function isNodeExecutableName(execPath) {
-  const basename = path.basename(execPath).toLowerCase();
-  return basename === "node" || basename === "node.exe" || basename === "nodejs" || basename === "nodejs.exe";
-}
-function canUseCurrentNodeExecutable(execPath) {
-  try {
-    fs.accessSync(execPath, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveAsyncRunnerNodeCommand() {
-  if (isNodeExecutableName(process.execPath) && canUseCurrentNodeExecutable(process.execPath)) {
-    return process.execPath;
-  }
-  return process.platform === "win32" ? "node.exe" : "node";
-}
 export function resolveAsyncRunnerLogPaths(cfg) {
   const asyncDir = typeof cfg.asyncDir === "string" ? cfg.asyncDir : undefined;
   if (!asyncDir)
@@ -118,29 +128,151 @@ function closeFd(fd) {
     fs.closeSync(fd);
   } catch {}
 }
-export function resolveAsyncRunnerPath(moduleUrl = import.meta.url) {
-  const modulePath = fileURLToPath(moduleUrl);
-  const runnerStem = path.basename(modulePath).startsWith("async-execution.") ? "subagent-runner" : path.join("..", "runs", "background", "subagent-runner");
-  return resolveRuntimeExtensionPath(moduleUrl, runnerStem);
+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) {}
 }
-function spawnRunner(cfg, suffix, cwd) {
-  if (!jitiCliPath) {
-    return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
+function readRunnerStartup(startupPath, expectedState, expectedToken) {
+  if (!fs.existsSync(startupPath))
+    return;
+  try {
+    const payload = JSON.parse(fs.readFileSync(startupPath, "utf-8"));
+    if (payload.state === "error" && typeof payload.error === "string")
+      return { ok: false, error: payload.error, startupDidNotProceed: true };
+    if (payload.state !== expectedState)
+      return;
+    if (typeof payload.token !== "string" || expectedToken !== undefined && payload.token !== expectedToken) {
+      return { ok: false, error: `Async runner wrote an invalid ${expectedState} startup handshake: ${startupPath}`, startupDidNotProceed: true };
+    }
+    return { ok: true, token: payload.token };
+  } catch (error) {
+    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) {
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    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())));
+  }
+  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 };
+}
+function writeRunnerStartupControl(filePath, payload) {
+  writePrivateAtomicJson(filePath, payload);
+}
+function runnerIsAlive(pid) {
   try {
-    const cwdStats = fs.statSync(cwd);
-    if (!cwdStats.isDirectory()) {
-      return { error: `cwd is not a directory: ${cwd}` };
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function terminateRunnerBeforeProceed(pid) {
+  for (const signal of ["SIGTERM", "SIGKILL"]) {
+    if (!runnerIsAlive(pid))
+      return true;
+    try {
+      process.kill(pid, signal);
+    } catch {
+      if (!runnerIsAlive(pid))
+        return true;
     }
-  } catch {
-    return { error: `cwd does not exist: ${cwd}` };
+    const deadline = Date.now() + 1000;
+    while (runnerIsAlive(pid) && Date.now() < deadline)
+      waitForStartupInterval();
+  }
+  return !runnerIsAlive(pid);
+}
+function persistPreProceedStartupFailure(asyncDir, runId, runnerProcessInstanceId, sessionId, completionOwnerId, message) {
+  const now = Date.now();
+  try {
+    const statusPath = path.join(asyncDir, "status.json");
+    let status = {};
+    try {
+      status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    } 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 }
+    });
+  } catch {}
+}
+function isStaleExtensionContextError(error) {
+  return error instanceof Error && /extension ctx is stale|stale after session replacement or reload/i.test(error.message);
+}
+export function emitProcessTerminalEvent(ctx, proof) {
+  try {
+    ctx.dm.events.emit(SUBAGENT_PROCESS_TERMINAL_EVENT, proof);
+  } catch (error) {
+    if (isStaleExtensionContextError(error))
+      return;
+    console.error("Failed to emit subagent process-terminal event:", error);
+  }
+}
+function spawnRunner(cfg, suffix, cwd, initialStatus, initialStatusPath, onProcessTerminal, 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" };
   }
   fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
   const cfgPath = getAsyncConfigPath(suffix);
-  fs.writeFileSync(cfgPath, JSON.stringify(cfg));
-  const runner = resolveAsyncRunnerPath();
-  const nodeCommand = resolveAsyncRunnerNodeCommand();
-  const logPaths = resolveAsyncRunnerLogPaths(cfg);
+  const runnerProcessInstanceId = randomUUID();
+  const hasRevivalLease = typeof cfg.revivalLease === "object";
+  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 launchForStartup = launchConfig;
+  const launchAsyncDir = typeof launchForStartup.asyncDir === "string" ? launchForStartup.asyncDir : undefined;
+  const launchRunId = typeof launchForStartup.id === "string" ? launchForStartup.id : suffix;
+  const launchSessionId = typeof launchForStartup.sessionId === "string" ? launchForStartup.sessionId : undefined;
+  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 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 (startupProceedPath)
+    fs.rmSync(startupProceedPath, { force: true });
+  const logPaths = resolveAsyncRunnerLogPaths(launchConfig);
   let stdoutFd;
   let stderrFd;
   try {
@@ -151,12 +283,11 @@ function spawnRunner(cfg, suffix, cwd) {
     }
     const proc = spawn(nodeCommand, [jitiCliPath, runner, cfgPath], {
       cwd,
-      detached: true,
+      ...backgroundProcessOptions(),
       stdio: ["ignore", stdoutFd ?? "ignore", stderrFd ?? "ignore"],
-      windowsHide: true,
       env: {
-        ...process.env,
-        ...piPackageRoot ? { [PI_CODING_AGENT_PACKAGE_ROOT_ENV]: piPackageRoot } : {}
+        ...omitExtensionBindingsEnv(process.env),
+        ...piPackageRoot ? { [DM_CODING_AGENT_PACKAGE_ROOT_ENV]: piPackageRoot } : {}
       }
     });
     closeFd(stdoutFd);
@@ -164,11 +295,122 @@ function spawnRunner(cfg, suffix, cwd) {
     proc.on("error", (error) => {
       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;
+          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,
+              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);
+    });
     if (typeof proc.pid !== "number") {
       return { error: `async runner did not produce a pid for cwd: ${cwd}` };
     }
+    try {
+      writePrivateAtomicJson(initialStatusPath, {
+        ...initialStatus,
+        pid: proc.pid,
+        processTerminal: { version: 1, state: "pending", runId: initialStatus.runId, runnerProcessInstanceId }
+      });
+    } catch (error) {
+      const message = `Failed to persist initial async status: ${error instanceof Error ? error.message : String(error)}`;
+      const terminationObserved = terminateRunnerBeforeProceed(proc.pid);
+      return { pid: proc.pid, runnerProcessInstanceId, error: message, terminationObserved, startupDidNotProceed: true };
+    }
+    if (launchBarrierToken && startupProceedPath) {
+      try {
+        writeRunnerStartupControl(startupProceedPath, { action: "proceed", token: launchBarrierToken });
+      } catch (error) {
+        const message = `Failed to authorize async runner startup: ${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 };
+      }
+    }
     proc.unref();
-    return { pid: proc.pid };
+    if (startupPath && startupAckPath && 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 { pid: proc.pid, runnerProcessInstanceId };
   } catch (error) {
     closeFd(stdoutFd);
     closeFd(stderrFd);
@@ -225,12 +467,12 @@ export function buildAsyncRunnerSteps(id, params) {
     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];
     for (const agentName of stepAgents) {
-      if (!agents.find((x) => x.name === agentName)) {
-        return { error: `Unknown agent: ${agentName}` };
-      }
+      if (!agents.find((x) => x.name === agentName))
+        return { error: formatUnknownAgentError(agentName, diagnosticContext) };
     }
   }
   let progressInstructionCreated = false;
@@ -242,20 +484,64 @@ export function buildAsyncRunnerSteps(id, params) {
       ...s.reads !== undefined ? { reads: s.reads } : {},
       ...s.progress !== undefined ? { progress: s.progress } : {},
       ...stepSkillInput !== undefined ? { skills: stepSkillInput } : {},
-      ...s.model ? { model: s.model } : {}
+      ...s.model !== undefined ? { model: s.model } : {},
+      ...s.fast !== undefined ? { fast: s.fast } : {}
     };
   };
-  const buildSeqStep = (s, sessionFile, behaviorCwd, progressPrecreated = false, resolvedBehavior, flatIndex) => {
+  const buildSeqStep = (s, sessionFile, behaviorCwd, progressPrecreated = false, resolvedBehavior, flatIndex, parallelOutputNamespace, runFanoutPath) => {
     const a = agents.find((x) => x.name === s.agent);
+    const externalRunner = a.runner?.type === "external-cli" || a.runner?.type === "external-job";
+    const externalRunnerType = a.runner?.type;
+    if (externalRunner) {
+      const unsupported = [];
+      if (s.model !== undefined)
+        unsupported.push("model override");
+      if (s.outputSchema !== undefined)
+        unsupported.push("structured output");
+      if (s.acceptance !== undefined || params.agentContract !== undefined || s.agentContract !== undefined)
+        unsupported.push("acceptance/agent contract");
+      if (s.toolBudget !== undefined || params.toolBudget !== undefined || a.toolBudget !== undefined || params.configToolBudget !== undefined)
+        unsupported.push("tool budget");
+      if ((s.fast ?? params.fast ?? a.fast) === true)
+        unsupported.push("fast mode");
+      if (params.contextForAgent?.(s.agent) === "fork")
+        unsupported.push("fork context");
+      if (unsupported.length > 0)
+        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])));
+    } catch (error) {
+      throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+    }
     const toolBudgetInput = s.toolBudget ?? params.toolBudget ?? a.toolBudget ?? params.configToolBudget;
     const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, s.toolBudget ? "toolBudget" : a.toolBudget ? "agent.toolBudget" : "config.toolBudget");
     if (resolvedToolBudget.error)
       throw new AsyncStartValidationError(resolvedToolBudget.error);
-    const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
-    const instructionCwd = behaviorCwd ?? stepCwd;
-    const behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(a, buildStepOverrides(s), chainSkills), s.task, originalTask);
-    const skillNames = behavior.skills === false ? [] : behavior.skills;
-    const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd);
+    const resolvedToolTimeout = resolveToolTimeoutMs({
+      callValue: params.callToolTimeoutMs,
+      agentValue: a.defaultToolTimeoutMs,
+      configValue: params.configToolTimeoutMs,
+      envValue: params.toolTimeoutMsEnv ?? toolTimeoutFromEnv()
+    });
+    if (resolvedToolTimeout.error)
+      throw new AsyncStartValidationError(resolvedToolTimeout.error);
+    const launchPlan = planChildLaunch({
+      agentConfig: a,
+      stepOverrides: buildStepOverrides(s),
+      task: s.task,
+      originalTask,
+      runnerCwd,
+      runtimeCwd: ctx.cwd,
+      stepCwdInput: s.cwd,
+      behaviorCwd,
+      chainSkills,
+      outputBaseDir,
+      parallelOutputNamespace,
+      resolvedBehavior
+    });
+    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() ?? "";
@@ -271,62 +557,158 @@ ${injection}` : injection;
 
 ${memoryInjection}` : memoryInjection;
     }
-    const readInstructions = buildChainInstructions({ ...behavior, output: false, progress: false }, instructionCwd, false);
+    systemPrompt = appendAgentRefinementOverlay(systemPrompt, { cwd: stepCwd, agentName: a.name });
+    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);
-    const outputPath = resolveSingleOutputPath(behavior.output, ctx.cwd, instructionCwd, outputBaseDir);
-    systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath);
+    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);
-    const task = injectSingleOutputInstruction(`${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`, outputPath);
-    const requestedModel = behavior.model ?? a.model;
-    const primaryModel = resolveSubagentModelOverride(requestedModel, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope, source: behavior.model ? "explicit" : "inherited" });
+    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 thinkingOverride = flatIndex === undefined ? undefined : thinkingOverridesByFlatIndex?.[flatIndex];
-    const effectiveThinking = thinkingOverride ?? a.thinking;
-    const model = applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== undefined);
+    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]));
+    if (!externalRunner) {
+      try {
+        assertThinkingWithinCeiling({ model, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: a.name, runId: id });
+      } catch (error) {
+        throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+      }
+    }
+    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] : [];
+    });
+    if (!externalRunner) {
+      try {
+        for (const candidate of modelCandidates)
+          assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: a.name, runId: id });
+      } catch (error) {
+        throw new AsyncStartValidationError(error instanceof Error ? error.message : String(error));
+      }
+    }
+    const fast = s.fast ?? params.fast ?? a.fast;
+    const toolPlan = resolvePiLaunchToolPlan({
+      tools: a.tools,
+      allowNestedSubagents: a.allowNestedSubagents,
+      extensions: a.extensions,
+      subagentOnlyExtensions: a.subagentOnlyExtensions,
+      mcpDirectTools: a.mcpDirectTools,
+      cwd: stepCwd,
+      requireReadTool: Boolean(resolvedSkills.length),
+      structuredOutput: Boolean(s.outputSchema),
+      fast,
+      model,
+      modelCandidates,
+      capabilityCeiling: params.capabilityCeiling,
+      inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+      agentName: a.name,
+      permissionRules,
+      runtimeSnapshotHost: ctx.dm
+    });
+    const launchResolvedExtensions = externalRunner ? undefined : projectLaunchResolvedChildExtensions(toolPlan);
+    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,
+      permissionRules,
+      ...params.capabilityCeiling ? { capabilityCeiling: params.capabilityCeiling } : {},
+      ...runFanoutPath ? { runFanoutPath } : {},
       agent: s.agent,
       task,
+      ...a.runner ? { runner: a.runner } : {},
+      ...params.contextForAgent ? { context: params.contextForAgent(s.agent) } : {},
+      ...agentContract ? { agentContract } : {},
       phase: s.phase,
       label: s.label,
       outputName: s.as,
       structured: Boolean(s.outputSchema),
       cwd: stepCwd,
+      requestedCwd: s.cwd ?? stepCwd,
       model,
+      ...contextLimit !== undefined ? { contextLimit } : {},
+      ...fast !== undefined ? { fast } : {},
       thinking: resolveEffectiveThinking(model, effectiveThinking),
-      modelCandidates: buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined)),
+      ...thinkingCeiling ? { thinkingCeiling } : {},
+      launchResolvedExtensions,
+      ...toolPlan.mcpConfig ? { mcpConfig: toolPlan.mcpConfig } : {},
+      ...toolPlan.runtimeServerNames ? { runtimeServerNames: toolPlan.runtimeServerNames } : {},
+      modelCandidates: externalRunner ? undefined : modelCandidates,
+      ...primaryModelFromParent ? { skipPrimaryModelVerification: true } : {},
+      ...availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {},
       tools: a.tools,
+      allowNestedSubagents: a.allowNestedSubagents,
       extensions: a.extensions,
       subagentOnlyExtensions: a.subagentOnlyExtensions,
       mcpDirectTools: a.mcpDirectTools,
+      mutationTools: a.mutationTools,
       completionGuard: a.completionGuard,
       systemPrompt,
       systemPromptMode: a.systemPromptMode,
       inheritProjectContext: a.inheritProjectContext,
+      inheritGlobalContext: a.inheritGlobalContext,
       inheritSkills: a.inheritSkills,
       skills: resolvedSkills.map((r) => r.name),
       outputPath,
+      ...namespaceOutputPath ? { namespaceOutputPath: true } : {},
       outputMode: behavior.outputMode,
       sessionFile,
       maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, a.maxSubagentDepth),
+      timeoutMs: a.defaultTimeoutMs ?? DEFAULT_ASYNC_TIMEOUT_MS,
+      toolTimeoutMs: resolvedToolTimeout.toolTimeoutMs,
+      waitToolEnabled: params.waitToolEnabled,
+      waitToolDefaultTimeoutMs: params.waitToolDefaultTimeoutMs,
       effectiveAcceptance: resolveEffectiveAcceptance({
         explicit: s.acceptance,
         agentName: s.agent,
-        task: s.task,
+        acceptanceRole: a.acceptanceRole,
+        task,
         mode: resultMode,
         async: true,
-        dynamic: false
+        dynamic: false,
+        agentContract
       }),
+      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")) } : {},
-      ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}
+      ...s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path.join(asyncDir, "structured-output"), { captureAcceptanceReport: s.acceptance !== false }) } : {},
+      ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {},
+      ...s.worktree ? { worktree: true } : {}
     };
   };
   let flatStepIndex = 0;
@@ -365,7 +747,7 @@ ${memoryInjection}` : memoryInjection;
               }
             }
             const staticStep = nextFlatStep();
-            return buildSeqStep(t, staticStep.sessionFile, behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex], staticStep.index);
+            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}]`);
           }),
           concurrency: s.concurrency,
           failFast: s.failFast,
@@ -382,9 +764,10 @@ ${memoryInjection}` : memoryInjection;
         }
         const maxItems = s.expand.maxItems ?? params.dynamicFanoutMaxItems ?? 0;
         const dynamicFlatSteps = Array.from({ length: maxItems }, () => nextFlatStep());
+        const parallel = buildSeqStep({ ...s.parallel, agentContract: s.parallel.agentContract ?? s.agentContract, gateOn: s.parallel.gateOn ?? s.gateOn }, undefined, undefined, progressPrecreated, behavior, undefined, { stepIndex });
         return {
           expand: s.expand,
-          parallel: buildSeqStep(s.parallel, undefined, undefined, progressPrecreated, behavior),
+          parallel,
           collect: s.collect,
           concurrency: s.concurrency,
           failFast: s.failFast,
@@ -395,15 +778,31 @@ ${memoryInjection}` : memoryInjection;
           effectiveAcceptance: resolveEffectiveAcceptance({
             explicit: s.acceptance,
             agentName: s.parallel.agent,
-            task: s.parallel.task,
+            acceptanceRole: agent.acceptanceRole,
+            task: parallel.task,
             mode: resultMode,
             async: true,
-            dynamicGroup: true
-          })
+            dynamicGroup: true,
+            agentContract: s.agentContract ?? params.agentContract
+          }),
+          acceptanceInput: s.acceptance,
+          acceptanceRole: agent.acceptanceRole,
+          ...s.agentContract ?? params.agentContract ? { agentContract: s.agentContract ?? params.agentContract } : {},
+          ...s.gateOn ? { gateOn: s.gateOn } : {},
+          ...parallel.thinkingCeiling ? { thinkingCeiling: parallel.thinkingCeiling } : {}
         };
       }
+      const sequential = s;
+      let behaviorCwd;
+      if (sequential.worktree) {
+        try {
+          behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, 0, worktreeBaseDir);
+        } catch {
+          behaviorCwd = undefined;
+        }
+      }
       const staticStep = nextFlatStep();
-      return buildSeqStep(s, staticStep.sessionFile, undefined, false, undefined, staticStep.index);
+      return buildSeqStep(sequential, staticStep.sessionFile, behaviorCwd, false, undefined, staticStep.index, undefined, `chain[${stepIndex}]`);
     });
     const steps = params.attachRoot ? [{
       agent: params.attachRoot.agent,
@@ -417,8 +816,24 @@ ${memoryInjection}` : memoryInjection;
         index: params.attachRoot.index
       },
       inheritProjectContext: false,
+      inheritGlobalContext: false,
       inheritSkills: false
     }, ...builtSteps] : builtSteps;
+    for (const step of steps) {
+      if (!("parallel" in step) || !Array.isArray(step.parallel))
+        continue;
+      const seen = new Map;
+      for (let index = 0;index < step.parallel.length; index++) {
+        const task = step.parallel[index];
+        if (!task.outputPath)
+          continue;
+        const previous = seen.get(task.outputPath);
+        if (previous) {
+          throw new AsyncStartValidationError(`Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${task.outputPath}. Use distinct output paths.`);
+        }
+        seen.set(task.outputPath, { index, agent: task.agent });
+      }
+    }
     return { steps, runnerCwd, workflowGraph, eventChain: graphChain, ...originalTask !== undefined ? { originalTask } : {} };
   } catch (error) {
     if (error instanceof UnavailableSubagentSkillError || error instanceof AsyncStartValidationError)
@@ -449,11 +864,26 @@ export function executeAsyncChain(id, params) {
     nestedRoute
   } = 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 };
+    })
+  });
+  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 asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(ASYNC_DIR, id);
+  const asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(DIRS.async, id);
+  let runFanoutBudget;
   try {
+    runFanoutBudget = params.runFanoutBudget ?? createRunFanoutBudget(id, 64);
     fs.mkdirSync(asyncDir, { recursive: true });
+    writeRunFanoutBudgetDescriptor(asyncDir, runFanoutBudget);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
@@ -468,20 +898,31 @@ export function executeAsyncChain(id, params) {
     attachRoot: params.attachRoot,
     resultMode,
     agents,
+    unknownAgentDiagnosticContext: params.unknownAgentDiagnosticContext,
     ctx,
     availableModels: params.availableModels,
     cwd,
     chainSkills: params.chainSkills,
     sessionFilesByFlatIndex,
     thinkingOverridesByFlatIndex,
+    contextForAgent: params.contextForAgent,
     progressDir: params.progressDir ?? (artifactsDir ? path.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path.join(asyncDir, "progress") : undefined),
+    agentContract: params.agentContract,
     outputBaseDir: artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined,
     dynamicFanoutMaxItems: params.dynamicFanoutMaxItems,
     maxSubagentDepth,
+    waitToolEnabled: params.waitToolEnabled,
+    waitToolDefaultTimeoutMs: params.waitToolDefaultTimeoutMs,
     worktreeBaseDir,
     asyncDir,
+    fast: params.fast,
     toolBudget: params.toolBudget,
-    configToolBudget: params.configToolBudget
+    configToolBudget: params.configToolBudget,
+    callToolTimeoutMs: params.callToolTimeoutMs,
+    configToolTimeoutMs: params.configToolTimeoutMs,
+    toolTimeoutMsEnv: params.toolTimeoutMsEnv ?? toolTimeoutFromEnv(),
+    capabilityCeiling,
+    thinkingCeiling: params.thinkingCeiling
   });
   if ("error" in built) {
     try {
@@ -491,10 +932,10 @@ export function executeAsyncChain(id, params) {
   }
   const { steps, runnerCwd, workflowGraph, eventChain } = built;
   const deadlineAt = params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined;
-  const initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : undefined;
+  const initialUsageBudget = usageBudgetState(params.usageBudget, undefined);
   let childTargetIndex = 0;
   const childIntercomTargets = childIntercomTarget ? steps.flatMap((step) => {
-    if (!("parallel" in step) && step.importAsyncRoot) {
+    if (!("parallel" in step) && "importAsyncRoot" in step && step.importAsyncRoot) {
       childTargetIndex++;
       return [undefined];
     }
@@ -505,14 +946,27 @@ export function executeAsyncChain(id, params) {
       }
       return step.parallel.map((task) => childIntercomTarget(task.agent, childTargetIndex++));
     }
-    return [childIntercomTarget(step.agent, childTargetIndex++)];
+    return "agent" in step ? [childIntercomTarget(step.agent, childTargetIndex++)] : [undefined];
   }) : undefined;
+  const initialStatusSteps = eventChain.flatMap((step) => isParallelStep(step) ? step.parallel.map((task) => ({ agent: task.agent, ...statusStepDescription(task.task) ? { description: statusStepDescription(task.task) } : {}, ...task.label ? { label: task.label } : {}, ...task.as ? { outputName: task.as } : {}, status: "pending" })) : isDynamicParallelStep(step) ? [{ agent: `expand:${step.parallel.agent}`, label: step.label ?? step.parallel.label ?? `Dynamic fanout (${step.collect.as})`, outputName: step.collect.as, status: "pending" }] : [{ agent: step.agent, ...statusStepDescription(step.task) ? { description: statusStepDescription(step.task) } : {}, ...step.label ? { label: step.label } : {}, ...step.as ? { outputName: step.as } : {}, status: "pending" }]);
+  const initialParallelGroups = [];
+  let initialFlatIndex = 0;
+  for (let stepIndex = 0;stepIndex < eventChain.length; stepIndex++) {
+    const step = eventChain[stepIndex];
+    if (isParallelStep(step))
+      initialParallelGroups.push({ start: initialFlatIndex, count: step.parallel.length, stepIndex });
+    else if (isDynamicParallelStep(step))
+      initialParallelGroups.push({ start: initialFlatIndex, count: 1, stepIndex });
+    initialFlatIndex += isParallelStep(step) ? step.parallel.length : 1;
+  }
+  const initialStatusAt = Date.now();
+  const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
   let spawnResult = {};
   try {
     spawnResult = spawnRunner({
       id,
       steps,
-      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(RESULTS_DIR, `${id}.json`),
+      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : resultFilePath(DIRS.results, id),
       cwd: runnerCwd,
       placeholder: "{previous}",
       maxOutput,
@@ -522,14 +976,16 @@ export function executeAsyncChain(id, params) {
       sessionDir: sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined,
       asyncDir,
       sessionId: ctx.currentSessionId,
+      completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+      ...capabilityCeiling ? { capabilityCeiling } : {},
       piPackageRoot,
       piArgv1: process.argv[1],
       worktreeSetupHook,
       worktreeSetupHookTimeoutMs,
       worktreeBaseDir,
       controlConfig,
-      turnBudget: params.turnBudget,
       toolBudget: params.toolBudget,
+      usageBudget: params.usageBudget,
       controlIntercomTarget,
       childIntercomTargets,
       resultMode,
@@ -537,7 +993,10 @@ export function executeAsyncChain(id, params) {
       timeoutMs: params.timeoutMs,
       deadlineAt,
       globalConcurrencyLimit: params.globalConcurrencyLimit,
+      runFanoutBudget,
       workflowGraph,
+      ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {},
+      ...params.workflowKey ? { workflowKey: params.workflowKey } : {},
       nestedRoute: nestedRoute ?? inheritedNestedRoute,
       nestedSelf: inheritedNestedRoute && nestedAddress ? {
         parentRunId: nestedAddress.parentRunId,
@@ -545,17 +1004,45 @@ export function executeAsyncChain(id, params) {
         depth: nestedAddress.depth,
         path: nestedAddress.path
       } : undefined
-    }, id, runnerCwd);
+    }, id, runnerCwd, {
+      lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+      runId: id,
+      ...ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {},
+      ...initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {},
+      mode: resultMode,
+      state: "running",
+      startedAt: initialStatusAt,
+      lastUpdate: initialStatusAt,
+      currentStep: 0,
+      chainStepCount: eventChain.length,
+      ...initialParallelGroups.length ? { parallelGroups: initialParallelGroups } : {},
+      steps: initialStatusSteps
+    }, path.join(asyncDir, "status.json"), (proof) => emitProcessTerminalEvent(ctx, proof));
   } 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)
+      params.activeAsyncCapacity?.rollback();
+    else
+      params.activeAsyncCapacity?.markStarted(spawnResult.runnerProcessInstanceId);
     return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${spawnResult.error}`);
   }
+  if (!spawnResult.pid || !spawnResult.runnerProcessInstanceId) {
+    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) {
+      return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': event chain has no steps`);
+    }
     const firstAgents = isParallelStep(eventFirstStep) ? eventFirstStep.parallel.map((t) => t.agent) : isDynamicParallelStep(eventFirstStep) ? [eventFirstStep.parallel.agent] : [eventFirstStep.agent];
+    const firstTask = isParallelStep(eventFirstStep) ? eventFirstStep.parallel[0]?.task : isDynamicParallelStep(eventFirstStep) ? eventFirstStep.parallel.task : eventFirstStep.task;
+    const workflowGoal = params.goal ?? (params.task?.trim() || firstTask);
     const parallelGroups = [];
     const flatAgents = [];
     let flatStepStart = 0;
@@ -601,41 +1088,50 @@ export function executeAsyncChain(id, params) {
             chainStepCount: eventChain.length,
             parallelGroups,
             ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {},
-            ...initialTurnBudget ? { turnBudget: initialTurnBudget } : {},
             startedAt: now,
-            lastUpdate: now
+            lastUpdate: now,
+            ...capabilityCeiling ? { capabilityCeiling } : {}
           }
         });
       } catch (error) {
         console.error("Failed to emit nested async start event:", error);
       }
     }
-    ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+    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: resultMode,
       agent: firstAgents[0],
       agents: flatAgents,
-      task: isParallelStep(eventFirstStep) ? eventFirstStep.parallel[0]?.task?.slice(0, 50) : isDynamicParallelStep(eventFirstStep) ? eventFirstStep.parallel.task?.slice(0, 50) : eventFirstStep.task?.slice(0, 50),
+      task: firstTask?.trim() ? PROMPT_REDACTED : undefined,
+      goal: workflowGoal?.trim() ? PROMPT_REDACTED : undefined,
       chain: eventChain.map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent),
       chainStepCount: eventChain.length,
       parallelGroups,
       workflowGraph,
       cwd: runnerCwd,
       asyncDir,
+      ...sessionRoot ? { sessionRoot } : {},
       ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {},
-      ...initialTurnBudget ? { turnBudget: initialTurnBudget } : {},
+      ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {},
+      ...capabilityCeiling ? { capabilityCeiling } : {},
+      ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {},
+      ...params.workflowKey ? { workflowKey: params.workflowKey } : {},
       nestedRoute
     });
   }
   const chainDesc = chain.map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent).join(" -> ");
   return {
-    content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`) }],
-    details: { mode: resultMode, runId: id, results: [], asyncId: id, asyncDir, workflowGraph, ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}, ...params.turnBudget ? { turnBudget: params.turnBudget } : {}, ...params.toolBudget ? { toolBudget: params.toolBudget } : {} }
+    content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`, ctx.interactive === true) }],
+    details: { mode: resultMode, runId: id, results: [], asyncId: id, asyncDir, workflowGraph, ...capabilityCeiling ? { capabilityCeiling } : {}, ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {}, ...params.workflowKey ? { workflowKey: params.workflowKey } : {}, ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}, ...params.toolBudget ? { toolBudget: params.toolBudget } : {}, ...initialUsageBudget ? { usageBudget: initialUsageBudget } : {} }
   };
 }
+export function workflowAwaitedAsyncResultPath(asyncDir) {
+  return path.join(asyncDir, "workflow-result.json");
+}
 export function executeAsyncSingle(id, params) {
   const {
     agent,
@@ -657,11 +1153,63 @@ export function executeAsyncSingle(id, params) {
     childIntercomTarget,
     nestedRoute
   } = params;
+  let lane;
+  try {
+    lane = normalizeWorkflowLaneMetadata(params.lane, "lane");
+    assertWorkflowLaneKey(lane, params.workflowKey, "lane");
+  } catch (error) {
+    return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+  }
   const task = params.task ?? "";
+  let extensionBindings;
+  try {
+    extensionBindings = normalizeExtensionBindings(params.extensionBindings)?.value;
+  } catch (error) {
+    return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+  }
+  const acceptanceErrors = validateAcceptanceInput(params.acceptance);
+  if (acceptanceErrors.length > 0)
+    return formatAsyncStartError("single", acceptanceErrors.join(" "));
+  const externalRunner = agentConfig.runner?.type === "external-cli" || agentConfig.runner?.type === "external-job";
+  const externalRunnerType = agentConfig.runner?.type;
+  const permissionRules = resolvePermissionRules(ctx.permissions, agentConfig.permissions);
+  if (externalRunner) {
+    const unsupported = [];
+    if (params.modelOverride !== undefined)
+      unsupported.push("model override");
+    if ((params.fast ?? agentConfig.fast) === true)
+      unsupported.push("fast mode");
+    if (params.thinkingOverride !== undefined)
+      unsupported.push("thinking override");
+    if (params.structuredOutputSchema !== undefined)
+      unsupported.push("structured output");
+    if (params.acceptance !== undefined || params.agentContract !== undefined)
+      unsupported.push("acceptance/agent contract");
+    if (params.toolBudget !== undefined || agentConfig.toolBudget !== undefined || params.configToolBudget !== undefined)
+      unsupported.push("tool budget");
+    if (params.context === "fork")
+      unsupported.push("fork context");
+    if ((params.skills?.length ?? 0) > 0)
+      unsupported.push("skills");
+    if (permissionRules)
+      unsupported.push("native DM child permissions");
+    if (extensionBindings !== undefined)
+      unsupported.push("extension bindings");
+    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]));
+  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 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);
+  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() ?? "";
@@ -677,11 +1225,15 @@ ${injection}` : injection;
 
 ${memoryInjection}` : memoryInjection;
   }
+  systemPrompt = appendAgentRefinementOverlay(systemPrompt, { cwd: runnerCwd, agentName: agentConfig.name });
   const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
   const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
-  const asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(ASYNC_DIR, id);
+  const asyncDir = inheritedNestedRoute ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id) : path.join(DIRS.async, id);
+  let runFanoutBudget;
   try {
+    runFanoutBudget = params.runFanoutBudget ?? createRunFanoutBudget(id, 64);
     fs.mkdirSync(asyncDir, { recursive: true });
+    writeRunFanoutBudgetDescriptor(asyncDir, runFanoutBudget);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
@@ -691,82 +1243,287 @@ ${memoryInjection}` : memoryInjection;
     };
   }
   const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
-  const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd, params.outputBaseDir ?? (artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined));
-  systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath);
-  const outputMode = params.outputMode ?? "inline";
+  const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, instructionCwd, params.outputBaseDir ?? (artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined));
+  systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, agentConfig);
+  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);
-  const primaryModel = resolveSubagentModelOverride(params.modelOverride ?? agentConfig.model, ctx.currentModel, availableModels, ctx.currentModelProvider);
-  const effectiveThinking = params.thinkingOverride ?? agentConfig.thinking;
-  const model = applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
+  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 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 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]));
+  if (!externalRunner) {
+    try {
+      assertThinkingWithinCeiling({ model, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: agentConfig.name, runId: id });
+    } catch (error) {
+      return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+    }
+  }
   const toolBudgetInput = params.toolBudget ?? agentConfig.toolBudget ?? params.configToolBudget;
   const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget ? "toolBudget" : agentConfig.toolBudget ? "agent.toolBudget" : "config.toolBudget");
   if (resolvedToolBudget.error)
     return formatAsyncStartError("single", resolvedToolBudget.error);
-  const deadlineAt = params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined;
-  const initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : undefined;
+  const deadlineAt = params.absoluteDeadlineAt ?? (params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined);
+  const timeoutMs = params.absoluteDeadlineAt !== undefined && deadlineAt !== undefined ? deadlineAt - Date.now() : params.timeoutMs;
+  if (timeoutMs !== undefined && timeoutMs <= 0)
+    return formatAsyncStartError("single", "The source run's absolute deadline expired before recovery could launch.");
+  const resolvedToolTimeout = resolveToolTimeoutMs({
+    callValue: params.toolTimeoutMs,
+    agentValue: agentConfig.defaultToolTimeoutMs,
+    configValue: params.configToolTimeoutMs,
+    envValue: params.toolTimeoutMsEnv ?? toolTimeoutFromEnv()
+  });
+  if (resolvedToolTimeout.error)
+    return formatAsyncStartError("single", resolvedToolTimeout.error);
+  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] : [];
+  });
+  if (!externalRunner) {
+    try {
+      for (const candidate of modelCandidates)
+        assertThinkingWithinCeiling({ model: candidate, configThinking: effectiveThinking, ceiling: thinkingCeiling, agent: agentConfig.name, runId: id });
+    } catch (error) {
+      return formatAsyncStartError("single", error instanceof Error ? error.message : String(error));
+    }
+  }
+  const toolPlan = resolvePiLaunchToolPlan({
+    tools: agentConfig.tools,
+    allowNestedSubagents: agentConfig.allowNestedSubagents,
+    extensions: agentConfig.extensions,
+    subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
+    mcpDirectTools: agentConfig.mcpDirectTools,
+    cwd: runnerCwd,
+    requireReadTool: Boolean(resolvedSkills.length),
+    structuredOutput: Boolean(params.structuredOutputSchema),
+    fast: params.fast ?? agentConfig.fast,
+    model,
+    modelCandidates,
+    capabilityCeiling,
+    inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+    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),
+    task,
+    ...model ? { model } : {},
+    modelCandidates,
+    ...(params.fast ?? agentConfig.fast) !== undefined ? { fast: params.fast ?? agentConfig.fast } : {},
+    ...resolveEffectiveThinking(model, effectiveThinking) ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {},
+    ...thinkingCeiling ? { thinkingCeiling } : {},
+    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,
+    ...outputPath ? { outputPath } : {},
+    outputMode,
+    ...params.structuredOutputSchema ? { structuredOutputSchema: params.structuredOutputSchema } : {},
+    ...extensionBindings ? { extensionBindings } : {}
+  });
+  const resolvedAcceptance = resolveEffectiveAcceptance({
+    explicit: params.acceptance,
+    agentName: agent,
+    acceptanceRole: agentConfig.acceptanceRole,
+    task,
+    mode: "single",
+    async: true,
+    agentContract: params.agentContract
+  });
+  const recoveryAgentConfig = params.recoveryAgentConfig ?? agentConfig;
+  const recoveryDescriptor = {
+    version: 1,
+    ...lane ? { lane } : {},
+    launchContractDigest,
+    ...extensionBindings ? { extensionBindings } : {},
+    runFanoutBudget,
+    sourceRunId: id,
+    ...params.agentContract ? { agentContract: params.agentContract } : {},
+    agent,
+    launchResolvedExtensions,
+    ...sessionFile ? { sessionFile } : {},
+    cwd: runnerCwd,
+    ...model ? { model } : {},
+    ...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) } : {},
+    ...thinkingCeiling ? { thinkingCeiling } : {},
+    ...recoveryAgentConfig.tools ? { tools: [...recoveryAgentConfig.tools] } : {},
+    ...recoveryAgentConfig.allowNestedSubagents !== undefined ? { allowNestedSubagents: recoveryAgentConfig.allowNestedSubagents } : {},
+    ...recoveryAgentConfig.extensions ? { extensions: [...recoveryAgentConfig.extensions] } : {},
+    ...recoveryAgentConfig.subagentOnlyExtensions ? { subagentOnlyExtensions: [...recoveryAgentConfig.subagentOnlyExtensions] } : {},
+    ...recoveryAgentConfig.mcpDirectTools ? { mcpDirectTools: [...recoveryAgentConfig.mcpDirectTools] } : {},
+    ...recoveryAgentConfig.mutationTools ? { mutationTools: [...recoveryAgentConfig.mutationTools] } : {},
+    ...recoveryAgentConfig.systemPrompt ? { systemPrompt: recoveryAgentConfig.systemPrompt } : {},
+    systemPromptMode: recoveryAgentConfig.systemPromptMode,
+    inheritProjectContext: recoveryAgentConfig.inheritProjectContext,
+    inheritGlobalContext: recoveryAgentConfig.inheritGlobalContext,
+    inheritSkills: recoveryAgentConfig.inheritSkills,
+    ...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,
+    ...params.structuredOutputSchema ? { structuredOutputSchema: params.structuredOutputSchema } : {},
+    ...params.acceptance !== undefined ? { acceptance: params.acceptance } : {},
+    ...controlConfig ? { controlConfig } : {},
+    ...params.context ? { context: params.context } : {},
+    ...params.intercomBridge !== undefined ? { intercomBridge: params.intercomBridge } : {},
+    ...deadlineAt !== undefined ? { absoluteDeadlineAt: deadlineAt } : {},
+    ...resolvedToolBudget.budget ? { initialToolBudget: resolvedToolBudget.budget } : {},
+    maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, recoveryAgentConfig.maxSubagentDepth),
+    ...maxOutput ? { maxOutput } : {},
+    share: shareEnabled,
+    ...resolvedSessionDir ? { sessionDir: resolvedSessionDir } : {},
+    ...artifactsDir ? { artifactsDir } : {},
+    artifactConfig,
+    ...capabilityCeiling ? { capabilityCeiling } : {}
+  };
+  if (!externalRunner) {
+    try {
+      writePrivateAtomicJson(path.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor);
+    } catch (error) {
+      return formatAsyncStartError("single", `Failed to persist async recovery descriptor for '${id}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   let spawnResult = {};
+  const initialStatusAt = Date.now();
+  const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
   try {
     spawnResult = spawnRunner({
       id,
       steps: [
         {
           parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
+          permissionRules,
+          ...capabilityCeiling ? { capabilityCeiling } : {},
           agent,
-          task: taskWithOutputInstruction,
+          task: taskText,
+          ...agentConfig.runner ? { runner: agentConfig.runner } : {},
+          ...params.externalJobFollowUp ? { externalJobFollowUp: params.externalJobFollowUp } : {},
+          ...params.context ? { context: params.context } : {},
           cwd: runnerCwd,
+          requestedCwd: params.requestedCwd ?? runnerCwd,
           model,
+          ...contextLimit !== undefined ? { contextLimit } : {},
+          ...params.fast ?? agentConfig.fast ? { fast: params.fast ?? agentConfig.fast } : {},
           thinking: resolveEffectiveThinking(model, effectiveThinking),
-          modelCandidates: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined)),
+          ...thinkingCeiling ? { thinkingCeiling } : {},
+          modelCandidates,
+          ...params.modelOverrideFromParent ? { skipPrimaryModelVerification: true } : {},
+          ...availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {},
           tools: agentConfig.tools,
+          allowNestedSubagents: agentConfig.allowNestedSubagents,
           extensions: agentConfig.extensions,
           subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
           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,
+          inheritGlobalContext: agentConfig.inheritGlobalContext,
           inheritSkills: agentConfig.inheritSkills,
           skills: resolvedSkills.map((r) => r.name),
           outputPath,
+          ...params.outputClaimPath ? { outputClaimPath: params.outputClaimPath } : {},
           outputMode,
-          sessionFile,
+          ...!externalRunner && sessionFile ? { sessionFile } : {},
           maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
-          effectiveAcceptance: resolveEffectiveAcceptance({
-            explicit: params.acceptance,
-            agentName: agent,
-            task,
-            mode: "single",
-            async: true
-          }),
-          ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}
+          waitToolEnabled: params.waitToolEnabled,
+          waitToolDefaultTimeoutMs: params.waitToolDefaultTimeoutMs,
+          ...params.agentContract ? { agentContract: params.agentContract } : {},
+          definitionDigest: agentDefinitionDigest(agentConfig),
+          launchBindingTask: task,
+          launchContractDigest,
+          ...extensionBindings ? { extensionBindings } : {},
+          launchResolvedExtensions,
+          effectiveAcceptance: resolvedAcceptance,
+          ...structuredOutput ? { structuredOutput } : {},
+          ...params.structuredOutputSchema ? { structuredOutputSchema: params.structuredOutputSchema } : {},
+          ...resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {},
+          ...params.worktree === true ? { worktree: true } : {},
+          ...lane ? { lane } : {}
         }
       ],
-      resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(RESULTS_DIR, `${id}.json`),
+      resultPath: params.parentWorkflowRunId !== undefined && (params.revivalLease !== undefined || params.workflowAwaitAsync === true) ? workflowAwaitedAsyncResultPath(asyncDir) : inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : resultFilePath(DIRS.results, id),
       cwd: runnerCwd,
       placeholder: "{previous}",
       maxOutput,
       artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
       artifactConfig,
       share: shareEnabled,
-      sessionDir: sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined,
+      sessionDir: resolvedSessionDir,
       asyncDir,
       sessionId: ctx.currentSessionId,
+      completionOwnerId: ctx.completionOwnerId ?? currentCompletionOwnerId(),
+      ...capabilityCeiling ? { capabilityCeiling } : {},
       piPackageRoot,
       piArgv1: process.argv[1],
       worktreeSetupHook,
       worktreeSetupHookTimeoutMs,
       worktreeBaseDir,
       controlConfig,
-      timeoutMs: params.timeoutMs,
+      timeoutMs,
       deadlineAt,
-      turnBudget: params.turnBudget,
+      toolTimeoutMs,
       toolBudget: params.toolBudget,
+      usageBudget: params.usageBudget,
       controlIntercomTarget,
       childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
       resultMode: "single",
+      launchContractDigest,
+      launchResolvedExtensions,
+      runFanoutBudget,
+      ...params.parentWorkflowRunId ? { parentWorkflowRunId: params.parentWorkflowRunId } : {},
+      ...params.workflowKey ? { workflowKey: params.workflowKey } : {},
+      ...lane ? { lane } : {},
+      ...params.revivalLease ? { revivalLease: params.revivalLease } : {},
       nestedRoute: nestedRoute ?? inheritedNestedRoute,
       nestedSelf: inheritedNestedRoute && nestedAddress ? {
         parentRunId: nestedAddress.parentRunId,
@@ -774,14 +1531,37 @@ ${memoryInjection}` : memoryInjection;
         depth: nestedAddress.depth,
         path: nestedAddress.path
       } : undefined
-    }, id, runnerCwd);
+    }, id, runnerCwd, {
+      lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+      runId: id,
+      ...ctx.currentSessionId ? { sessionId: ctx.currentSessionId } : {},
+      ...initialCompletionOwnerId ? { completionOwnerId: initialCompletionOwnerId } : {},
+      mode: "single",
+      state: "running",
+      startedAt: initialStatusAt,
+      lastUpdate: initialStatusAt,
+      currentStep: 0,
+      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);
   } 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)
+      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();
@@ -808,33 +1588,41 @@ ${memoryInjection}` : memoryInjection;
             agent,
             agents: [agent],
             chainStepCount: 1,
-            ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {},
-            ...initialTurnBudget ? { turnBudget: initialTurnBudget } : {},
+            ...timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {},
             startedAt: now,
-            lastUpdate: now
+            lastUpdate: now,
+            ...capabilityCeiling ? { capabilityCeiling } : {}
           }
         });
       } catch (error) {
         console.error("Failed to emit nested async start event:", error);
       }
     }
-    ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+    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?.slice(0, 50),
+      task: task?.trim() ? PROMPT_REDACTED : undefined,
+      goal: (params.goal ?? task).trim() ? PROMPT_REDACTED : undefined,
       cwd: runnerCwd,
       asyncDir,
-      ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {},
-      ...initialTurnBudget ? { turnBudget: initialTurnBudget } : {},
+      ...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}]`) }],
-    details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir, ...params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}, ...params.turnBudget ? { turnBudget: params.turnBudget } : {}, ...params.toolBudget ? { toolBudget: params.toolBudget } : {} }
+    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 } : {} }
   };
 }