@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/background/subagent-runner.js

@@ -1,8 +1,9 @@
-import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { performance } from "node:perf_hooks";
 import { pathToFileURL } from "node:url";
+import { installRunnerHttpDispatcher } from "./runner-http-dispatcher.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { writeAsyncResultFile, writePendingAsyncResultFile } from "./result-files.js";
 import { createFileCoalescer } from "../../shared/file-coalescer.js";
@@ -10,16 +11,16 @@ import { createCapacityResilientJsonWriter } from "../../shared/capacity-resilie
 import { isStorageCapacityError } from "../../shared/file-system-retry.js";
 import { updateActiveRunIndex } from "./active-run-index.js";
 import { createChildTranscriptWriter } from "../../shared/child-transcript.js";
-import { closeSteerInbox, consumeInterruptRequest, consumeSteerRequests, deliverInterruptRequest, deliverStopRequest, deliverTimeoutRequest, enqueueStepSteer, steerAcksDir, steerCapabilityPath, stepSteerInboxDir, watchAsyncControlInbox } from "./control-channel.js";
+import { closeSteerInbox, consumeInterruptRequest, consumeSteerRequests, consumeStopRequestPayloads, deliverInterruptRequest, deliverStopRequest, deliverTimeoutRequest, watchAsyncControlInbox } from "./control-channel.js";
 import { appendJsonl as appendRawJsonl, formatOutputArtifactContent, getArtifactPaths, writeArtifact, writeMetadata } from "../../shared/artifacts.js";
-import { DM_CODING_AGENT_PACKAGE, getPiSpawnCommand, resolveInstalledPiPackageRoot } from "../shared/dm-spawn.js";
+import { DM_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/dm-spawn.js";
 import { preflightLaunchCwd } from "../shared/launch-cwd.js";
 import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, injectOutputPathSystemPrompt, injectSingleOutputInstruction, resolveSingleOutput } from "../shared/single-output.js";
+import { runSetupCommand } from "../shared/worktree-setup-command.js";
 import {
   DEFAULT_MAX_OUTPUT,
   SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
-  truncateOutput,
-  getSubagentDepthEnv
+  truncateOutput
 } from "../../shared/types.js";
 import {
   DEFAULT_CONTROL_CONFIG,
@@ -40,33 +41,27 @@ import {
   DEFAULT_GLOBAL_CONCURRENCY_LIMIT,
   Semaphore
 } from "../shared/parallel-utils.js";
-import { applyThinkingSuffix, buildPiArgs, cleanupTempDir, deriveForkPromptCacheKey, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/dm-args.js";
+import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/child-tool-plan.js";
+import { buildRunnerChildLaunch } from "./runner-child-launch.js";
+import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
+import { runChildSession } from "./run-child-session.js";
+import { loadRunnerChildSessionFactory } from "./runner-child-sessions.js";
+import { SUBAGENT_CHILD_ENV } from "../shared/child-runtime-config.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
-import { readRuntimeAcknowledgedExtensions } from "../shared/runtime-acknowledged-extensions.js";
+import { alignForkedSessionCwd } from "../../shared/fork-session-cwd.js";
 import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.js";
-import { createStructuredOutputRuntime, MISSING_STRUCTURED_OUTPUT_CALL_ERROR, readStructuredOutput, readStructuredOutputAcceptanceReport } from "../shared/structured-output.js";
-import { formatMidToolExitError, formatProcessSignalError, isOrdinaryToolForMidToolExit, isUnexplainedProcessSignal } from "../shared/process-signal.js";
-import { readChildToolDiagnosticError } from "../shared/tool-availability.js";
+import { clearStructuredOutputCaptures, createStructuredOutputFileCapture, createStructuredOutputRuntime, formatStructuredOutputRejectionError, MISSING_STRUCTURED_OUTPUT_CALL_ERROR, readStructuredOutput, readStructuredOutputAcceptanceReport } from "../shared/structured-output.js";
+import { formatMidToolExitError, isOrdinaryToolForMidToolExit, isUnexplainedProcessSignal } from "../shared/process-signal.js";
+import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.js";
 import { collectDynamicResults, DynamicFanoutError, materializeDynamicParallelStep, validateDynamicCollection } from "../shared/dynamic-fanout.js";
 import { claimRunFanoutBatch, getRunFanoutBudgetSnapshot } from "../shared/run-fanout-budget.js";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent } from "../shared/nested-events.js";
-import { formatModelAttemptNote, formatSubagentModelVerificationError, isContextOverflow, isRetryableModelFailureAttempt, recordRetryableModelFailure } from "../shared/model-fallback.js";
-import {
-  SUBAGENT_STARTUP_RETRY_DELAYS_MS,
-  formatSubagentExtensionConflictError,
-  formatSubagentStartupRetryExhaustedError,
-  formatSubagentStartupRetryNote,
-  isRetryableSubagentStartupFailure,
-  waitForSubagentStartupRetry
-} from "../shared/subagent-startup-retry.js";
-import { markProcessTerminalCandidateLeaseRelease, writeProcessTerminalCandidate } from "./process-terminal.js";
-import { createOwnedProcessTreeController } from "./owned-process-tree.js";
-import { createSteeringStatus, recordSteeringRequest, steeringStatus, terminalSteeringNoticeState, updateSteeringTarget } from "./steering.js";
-import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.js";
-import { PROMPT_REDACTED, detectSubagentError, extractTextFromContent, extractToolArgsPreview, formatEmptyTerminalAssistantResponseError, getFinalOutput, hasEmptyTerminalAssistantResponse, readStatus } from "../../shared/utils.js";
-import { evaluateCompletionMutationGuard, expectsImplementationMutation, hasMutationToolCapability, validateImplementationToolContract } from "../shared/completion-guard.js";
-import { planCompletionEvidence, projectSettlementDiagnostic } from "../shared/completion-evidence.js";
+import { isContextOverflow } from "../shared/model-resolution.js";
+import { processTerminalPath, writeProcessTerminalCandidate } from "./process-terminal.js";
+import { persistRunnerStartupFailure } from "./runner-startup-failure.js";
+import { createSteeringStatus, recordSteeringRequest, steeringStatus, terminalSteeringNoticeState, unconsumedSteerReason, updateSteeringTarget } from "./steering.js";
+import { PROMPT_REDACTED, detectSubagentError, extractTextFromContent, extractToolArgsPreview, formatEmptyTerminalAssistantResponseError, getAgentDir, hasEmptyTerminalAssistantResponse, readStatus } from "../../shared/utils.js";
 import { planAbortRecovery } from "../shared/abort-recovery.js";
 import {
   createMutatingFailureState,
@@ -83,46 +78,46 @@ import { parseSessionTokens } from "../../shared/session-tokens.js";
 import {
   cleanupWorktrees,
   createWorktrees,
+  withWorktreeTransaction,
+  WorktreeSetupError,
   diffWorktrees,
   findWorktreeTaskCwdConflict,
   formatWorktreeDiffSummary,
-  formatWorktreeTaskCwdConflict
+  formatWorktreeTaskCwdConflict,
+  WORKTREE_AGENT_CWD_PLACEHOLDER
 } from "../shared/worktree.js";
 import { findModelInfo, resolveEffectiveThinking } from "../../shared/model-info.js";
-import { assertThinkingWithinCeiling, decodeThinkingCeiling, SUBAGENT_THINKING_CEILING_ENV } from "../../shared/thinking-ceiling.js";
-import { launchBindingDigest } from "../../shared/launch-contract.js";
+import { assertThinkingWithinCeiling } from "../../shared/thinking-ceiling.js";
+import { resolveLaunchBinding } from "../../shared/launch-contract.js";
 import { writeInitialProgressFile } from "../../shared/settings.js";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { acceptanceFailureMessage, aggregateAcceptanceReport, buildSkippedAcceptanceLedger, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport } from "../shared/acceptance.js";
-import { attachContractProjections, isAgentContractV1 } from "../shared/agent-contract.js";
+import { acceptanceFailureMessage, aggregateAcceptanceReport, buildSkippedAcceptanceLedger, captureStagedIndexBaseline, evaluateAcceptance, formatAcceptancePrompt, resolveAcceptanceReportMode, resolveEffectiveAcceptance, stripAcceptanceReport, typedVerifyOutput } from "../shared/acceptance.js";
+import { attachContractProjections, isAgentContract } from "../shared/agent-contract.js";
 import { waitForImportedAsyncRoot } from "./chain-root-attachment.js";
-import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
 import { appendRunnerStepsToStatus, consumeChainAppendRequests, countPendingChainAppendRequests, statusStepDescription } from "./chain-append.js";
 import { asyncStatusChildIdentity } from "../shared/child-identity.js";
 import { initialToolBudgetState, toolBudgetState } from "../shared/tool-budget.js";
-import { effectiveToolTimeoutMs, formatToolTimeoutMessage, toolTimeoutCallKey } from "../shared/tool-timeout.js";
+import { toolTimeoutCallKey } from "../shared/tool-timeout.js";
 import { usageBudgetExceededMessage, usageBudgetState } from "../shared/usage-budget.js";
-import { formatParallelHandoffError, formatParallelHandoffReference, parallelHandoffPath, writeParallelHandoffGroup, writePendingParallelHandoff } from "../shared/parallel-handoff.js";
+import { formatParallelHandoffError, formatParallelHandoffReference, parallelHandoffPath, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
 import { resolveWatchdogConfig } from "../../watchdog/settings.js";
-import { createBoundedByteTail, createBoundedLineReader, formatProtocolOutputLimit, MAX_CHILD_STDERR_BYTES, PI_AGGREGATE_EVENT_PROJECTOR, projectChildLifecycle } from "../shared/child-protocol.js";
-import { acquireSessionLease } from "../shared/session-lease.js";
 import { buildExternalCliPrompt, runExternalCli } from "../shared/external-cli-runner.js";
 import { resolveClaudeCodeLaunch } from "../shared/claude-code-adapter.js";
 import { resolveCodexExecLaunch } from "../shared/codex-exec-adapter.js";
 import { resolveCursorAgentLaunch } from "../shared/cursor-agent-adapter.js";
 import { resolveExternalCliRunnerStatus } from "../shared/external-cli-contract.js";
+import { formatHerdrMachineHint, prepareHerdrMachineExternalCliRun } from "../shared/herdr-machine.js";
+import { HerdrExternalNeedsAttentionError, createHerdrExternalAdapter, prepareInternalHerdrExternalAdapter } from "../shared/herdr-external-adapters.js";
 import { runExternalJob } from "../shared/external-job-runner.js";
 import { createOrcaProgressTab } from "../shared/orca-progress-tabs.js";
-import { decodeSubagentCapabilityCeiling, SUBAGENT_CAPABILITY_CEILING_ENV } from "../shared/capability-ceiling.js";
 import {
-  CHILD_WATCHDOG_CONFIG_ENV,
   acceptChildWatchdogEvent,
-  childWatchdogIsActive,
-  decodeChildWatchdogConfig,
+  applyChildWatchdogMessage,
   isChildWatchdogStatusEvent,
   resolveChildWatchdogConfig
 } from "../../watchdog/child-status.js";
 const INTERCOM_DETACH_RECEIPT = "Detached for intercom coordination before task completion.";
+process.env[SUBAGENT_CHILD_ENV] = "1";
 function persistStepArtifacts(input) {
   const errors = {};
   if (input.artifactConfig?.includeOutput !== false) {
@@ -205,9 +200,6 @@ function appendDiagnosticJsonl(filePath, line, droppedEventType) {
   }
   state.diagnosticsTruncated = true;
 }
-function shouldPersistChildEvent(event) {
-  return event.type !== "message_update";
-}
 function isBlockingSupervisorTool(toolName, args) {
   if (!args || typeof args !== "object" || Array.isArray(args))
     return false;
@@ -231,47 +223,18 @@ function findLatestSessionFile(sessionDir) {
 function emptyUsage() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
-function tokenUsageFromAttempts(attempts) {
-  if (!attempts || attempts.length === 0)
-    return null;
-  let input = 0;
-  let output = 0;
-  for (const attempt of attempts) {
-    input += attempt.usage?.input ?? 0;
-    output += attempt.usage?.output ?? 0;
-  }
+function tokenUsageFromUsage(usage) {
+  const input = usage?.input ?? 0;
+  const output = usage?.output ?? 0;
   const total = input + output;
   return total > 0 ? { input, output, total } : null;
 }
-function costSummaryFromAttempts(attempts) {
-  if (!attempts || attempts.length === 0)
-    return;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let costUsd = 0;
-  for (const attempt of attempts) {
-    inputTokens += attempt.usage?.input ?? 0;
-    outputTokens += attempt.usage?.output ?? 0;
-    costUsd += attempt.usage?.cost ?? 0;
-  }
+function costSummaryFromUsage(usage) {
+  const inputTokens = usage?.input ?? 0;
+  const outputTokens = usage?.output ?? 0;
+  const costUsd = usage?.cost ?? 0;
   return inputTokens > 0 || outputTokens > 0 || costUsd > 0 ? { inputTokens, outputTokens, costUsd } : undefined;
 }
-function usageFromAttempts(attempts) {
-  if (!attempts || attempts.length === 0)
-    return;
-  const usage = emptyUsage();
-  for (const attempt of attempts) {
-    if (!attempt.usage)
-      continue;
-    usage.input += attempt.usage.input;
-    usage.output += attempt.usage.output;
-    usage.cacheRead += attempt.usage.cacheRead;
-    usage.cacheWrite += attempt.usage.cacheWrite;
-    usage.cost += attempt.usage.cost;
-    usage.turns += attempt.usage.turns;
-  }
-  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0 ? usage : undefined;
-}
 function appendRecentStepOutput(step, lines) {
   const nonEmpty = lines.filter((line) => line.trim());
   if (nonEmpty.length === 0)
@@ -282,12 +245,6 @@ function appendRecentStepOutput(step, lines) {
     step.recentOutput.splice(0, step.recentOutput.length - 50);
   }
 }
-function assistantStartsToolCall(message) {
-  return Array.isArray(message.content) && message.content.some((part) => part.type === "toolCall");
-}
-function isTerminalAssistantStop(message) {
-  return message.stopReason === "stop" && !assistantStartsToolCall(message);
-}
 function omitUndefinedProperties(value) {
   for (const key in value) {
     if (value[key] === undefined)
@@ -338,549 +295,6 @@ function formatChildFailureDiagnostic(input) {
   return `${baseError.slice(0, Math.max(0, errorLimit))}${context ? `
 ${context}` : ""}`;
 }
-function runPiStreaming(args, cwd, outputFile, env, piPackageRoot, piArgv1, maxSubagentDepth, childEventContext, registerInterrupt, onChildEvent, transcriptWriter, registerTimeout, timeoutMessage, registerStop, stopMessage, onWriterProcess, toolTimeoutMs, runDeadlineAt, orcaProgressTab, expectedModelForVerification, modelVerificationRegistry, mutationTools) {
-  return new Promise((resolve) => {
-    const startedAt = Date.now();
-    const processInstanceId = randomUUID();
-    onWriterProcess?.({ state: "spawning" });
-    const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
-    const spawnEnv = { ...process.env, ...env ?? {}, ...getSubagentDepthEnv(maxSubagentDepth) };
-    const spawnSpec = getPiSpawnCommand(args, {
-      ...piPackageRoot ? { piPackageRoot } : {},
-      ...piArgv1 ? { argv1: piArgv1 } : {}
-    });
-    const child = spawn(spawnSpec.command, spawnSpec.args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: spawnEnv,
-      windowsHide: true,
-      detached: process.platform !== "win32"
-    });
-    let processTreeController;
-    const stderrTail = createBoundedByteTail();
-    const rawStdoutTail = createBoundedByteTail();
-    const messages = [];
-    const usage = emptyUsage();
-    let model;
-    let writerRegistrationError;
-    if (typeof child.pid === "number") {
-      processTreeController = createOwnedProcessTreeController(child.pid);
-      try {
-        onWriterProcess?.({ state: "running", pid: child.pid });
-      } catch (writerError) {
-        writerRegistrationError = `Failed to record revived DM writer ownership: ${writerError instanceof Error ? writerError.message : String(writerError)}`;
-        trySignalChild(child, "SIGKILL");
-      }
-    }
-    let error = writerRegistrationError;
-    let assistantError;
-    let interrupted = false;
-    let timedOut = false;
-    let stopped = false;
-    let observedMutationAttempt = false;
-    let structuredOutputToolInvoked = false;
-    let structuredOutputMessageStartIndex;
-    let currentTool;
-    let currentToolArgs;
-    let currentPath;
-    let toolCount = 0;
-    let activeToolSequence = 0;
-    const activeToolCalls = new Map;
-    const activeToolKeysByName = new Map;
-    const refreshCurrentTool = () => {
-      const active = [...activeToolCalls.values()].at(-1);
-      currentTool = active?.tool;
-      currentToolArgs = active?.args;
-      currentPath = active?.path;
-    };
-    const recordActiveToolCall = (event) => {
-      const key = toolTimeoutCallKey(event, ++activeToolSequence);
-      const active = omitUndefinedProperties({
-        key,
-        tool: event.toolName,
-        args: extractToolArgsPreview(event.args ?? {}),
-        path: resolveCurrentPath(event.toolName, event.args)
-      });
-      activeToolCalls.set(key, active);
-      const keys = activeToolKeysByName.get(active.tool) ?? [];
-      keys.push(key);
-      activeToolKeysByName.set(active.tool, keys);
-      refreshCurrentTool();
-    };
-    const removeActiveToolCall = (event) => {
-      const key = typeof event.toolCallId === "string" && event.toolCallId.length > 0 ? `id:${event.toolCallId}` : typeof event.toolName === "string" ? activeToolKeysByName.get(event.toolName)?.[0] : activeToolCalls.size === 1 ? [...activeToolCalls.keys()][0] : undefined;
-      if (!key)
-        return;
-      const active = activeToolCalls.get(key);
-      if (!active)
-        return;
-      activeToolCalls.delete(key);
-      const keys = activeToolKeysByName.get(active.tool)?.filter((candidate) => candidate !== key) ?? [];
-      if (keys.length > 0)
-        activeToolKeysByName.set(active.tool, keys);
-      else
-        activeToolKeysByName.delete(active.tool);
-      refreshCurrentTool();
-    };
-    const childWatchdogConfig = decodeChildWatchdogConfig(env?.[CHILD_WATCHDOG_CONFIG_ENV]);
-    let childWatchdogState;
-    const childLifecycleState = { compactionRetryActive: false };
-    let applyChildLifecycle = (_action) => {};
-    const updateChildWatchdogState = (snapshot) => {
-      childWatchdogState = snapshot;
-    };
-    const writeOutputLine = (line) => {
-      if (!line.trim())
-        return;
-      outputStream.write(`${line}
-`);
-      orcaProgressTab?.append(`${line}
-`);
-    };
-    const writeOutputText = (text) => {
-      for (const line of text.split(`
-`)) {
-        writeOutputLine(line);
-      }
-    };
-    const appendChildEvent = (event) => {
-      if (!childEventContext)
-        return;
-      if (!shouldPersistChildEvent(event))
-        return;
-      appendDiagnosticJsonl(childEventContext.eventsPath, JSON.stringify({
-        ...event,
-        subagentSource: "child",
-        subagentRunId: childEventContext.runId,
-        subagentStepIndex: childEventContext.stepIndex,
-        subagentAgent: childEventContext.agent,
-        observedAt: Date.now()
-      }), typeof event.type === "string" ? event.type : undefined);
-    };
-    const appendChildLine = (type, line) => {
-      appendChildEvent({ type, line });
-      if (type === "subagent.child.stdout")
-        transcriptWriter?.writeStdoutLine(line);
-      else
-        transcriptWriter?.writeStderrLine(line);
-    };
-    const processStdoutLine = (line) => {
-      if (!line.trim())
-        return;
-      let event;
-      try {
-        event = JSON.parse(line);
-      } catch {
-        rawStdoutTail.push(`${line}
-`);
-        writeOutputLine(line);
-        appendChildLine("subagent.child.stdout", line);
-        return;
-      }
-      appendChildEvent(event);
-      transcriptWriter?.writeChildEvent(event);
-      if (event.type === "compaction_start")
-        compactionStartedReceived = true;
-      if (event.type === "compaction_end" && event.willRetry === true) {
-        compactionStartedReceived = false;
-        afterCompactionSettlement = false;
-      }
-      if (event.type === "agent_start" || event.type === "auto_retry_start") {
-        compactionStartedReceived = false;
-        afterCompactionSettlement = false;
-      }
-      const lifecycleAction = projectChildLifecycle(event, false, childLifecycleState);
-      if (event.type === "agent_settled" && lifecycleAction === "start-drain") {
-        agentSettledReceived = true;
-        afterCompactionSettlement = compactionStartedReceived;
-      }
-      applyChildLifecycle(lifecycleAction);
-      if (isChildWatchdogStatusEvent(event)) {
-        if (!childWatchdogConfig)
-          return;
-        const next = acceptChildWatchdogEvent({
-          current: childWatchdogState,
-          event,
-          ...childEventContext ? {
-            runId: childEventContext.runId,
-            agent: childEventContext.agent,
-            childIndex: childEventContext.stepIndex
-          } : {}
-        });
-        if (!next)
-          return;
-        updateChildWatchdogState(next);
-        onChildEvent?.(event);
-        if (childWatchdogIsActive(next)) {
-          if (finalDrainTimer) {
-            clearTimeout(finalDrainTimer);
-            finalDrainTimer = undefined;
-          }
-          if (finalHardKillTimer) {
-            clearTimeout(finalHardKillTimer);
-            finalHardKillTimer = undefined;
-          }
-          armWatchdogTail();
-        } else {
-          clearWatchdogTailTimer();
-          if (cleanTerminalAssistantStopReceived || agentSettledReceived)
-            startFinalDrain();
-        }
-        return;
-      }
-      onChildEvent?.(event);
-      if (event.type === "tool_execution_end") {
-        clearActiveToolTimeout(event);
-        removeActiveToolCall(event);
-        return;
-      }
-      if (event.type === "tool_execution_start" && event.toolName) {
-        toolCount += 1;
-        armToolTimeout({ toolCallId: event.toolCallId, toolName: event.toolName });
-        recordActiveToolCall({ toolCallId: event.toolCallId, toolName: event.toolName, args: event.args });
-        if (event.toolName === "structured_output") {
-          structuredOutputToolInvoked = true;
-          structuredOutputMessageStartIndex = messages.length;
-        }
-        observedMutationAttempt = observedMutationAttempt || isMutatingTool(event.toolName, event.args, mutationTools);
-        const toolArgs = extractToolArgsPreview(event.args ?? {});
-        writeOutputLine(toolArgs ? `${event.toolName}: ${toolArgs}` : event.toolName);
-        return;
-      }
-      if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
-        if (event.type === "tool_result_end") {
-          clearActiveToolTimeout(event);
-          removeActiveToolCall({
-            toolCallId: event.message.toolCallId ?? event.toolCallId,
-            toolName: event.message.toolName ?? event.toolName
-          });
-        }
-        messages.push(event.message);
-        const text = extractTextFromContent(event.message.content);
-        if (text)
-          writeOutputText(text);
-        if (event.type !== "message_end" || event.message.role !== "assistant")
-          return;
-        const hasToolCall = assistantStartsToolCall(event.message);
-        if (event.message.model) {
-          model = event.message.model;
-          if (expectedModelForVerification && !hasToolCall) {
-            const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, event.message.model, modelVerificationRegistry);
-            if (modelVerificationError && !error)
-              error = modelVerificationError;
-          }
-        }
-        if (event.message.errorMessage)
-          assistantError = event.message.errorMessage;
-        const eventUsage = event.message.usage;
-        if (eventUsage) {
-          usage.turns++;
-          usage.input += eventUsage.input ?? eventUsage.inputTokens ?? 0;
-          usage.output += eventUsage.output ?? eventUsage.outputTokens ?? 0;
-          usage.cacheRead += eventUsage.cacheRead ?? 0;
-          usage.cacheWrite += eventUsage.cacheWrite ?? 0;
-          usage.cost += eventUsage.cost?.total ?? 0;
-        }
-        if (isTerminalAssistantStop(event.message)) {
-          if (!event.message.errorMessage && extractTextFromContent(event.message.content).trim())
-            assistantError = undefined;
-          cleanTerminalAssistantStopReceived ||= !event.message.errorMessage;
-          clearAllToolTimeouts();
-          activeToolCalls.clear();
-          activeToolKeysByName.clear();
-          refreshCurrentTool();
-          applyChildLifecycle(projectChildLifecycle(event, true, childLifecycleState));
-        }
-      }
-    };
-    const FINAL_STOP_GRACE_MS = 1000;
-    const HARD_KILL_MS = 3000;
-    let childExited = false;
-    let forcedTerminationSignal = false;
-    let cleanTerminalAssistantStopReceived = false;
-    let agentSettledReceived = false;
-    let compactionStartedReceived = false;
-    let afterCompactionSettlement = false;
-    let finalDrainTimer;
-    let finalHardKillTimer;
-    let watchdogTailTimer;
-    let protocolHardKillTimer;
-    let protocolError;
-    let settled = false;
-    applyChildLifecycle = (action) => {
-      if (action === "cancel-drain") {
-        if (finalDrainTimer) {
-          clearTimeout(finalDrainTimer);
-          finalDrainTimer = undefined;
-        }
-        if (finalHardKillTimer) {
-          clearTimeout(finalHardKillTimer);
-          finalHardKillTimer = undefined;
-        }
-        clearWatchdogTailTimer();
-        return;
-      }
-      if (action === "start-drain")
-        startFinalDrain();
-    };
-    const failProtocol = (limit) => {
-      if (protocolError)
-        return;
-      protocolError = limit;
-      error = formatProtocolOutputLimit(limit);
-      if (!childExited) {
-        trySignalChild(child, "SIGTERM");
-        protocolHardKillTimer = setTimeout(() => {
-          if (!settled)
-            trySignalChild(child, "SIGKILL");
-        }, 3000);
-        protocolHardKillTimer.unref?.();
-      }
-    };
-    const stdoutReader = createBoundedLineReader({
-      oversizedLineProjector: PI_AGGREGATE_EVENT_PROJECTOR,
-      onLine: processStdoutLine,
-      onLimit: failProtocol
-    });
-    const stderrReader = createBoundedLineReader({
-      stream: "stderr",
-      maxPendingLineBytes: MAX_CHILD_STDERR_BYTES,
-      onLine: (line) => appendChildLine("subagent.child.stderr", line),
-      onLimit: (limit) => appendChildLine("subagent.child.stderr", formatProtocolOutputLimit(limit))
-    });
-    const clearStdioGuard = attachPostExitStdioGuard(child, { idleMs: 2000, hardMs: 8000 });
-    child.stdout.on("data", (chunk) => stdoutReader.push(chunk));
-    child.stderr.on("data", (chunk) => {
-      stderrTail.push(chunk);
-      stderrReader.push(chunk);
-      outputStream.write(chunk);
-      orcaProgressTab?.append(chunk.toString("utf-8"));
-    });
-    registerInterrupt?.(() => {
-      if (settled || timedOut || stopped)
-        return;
-      interrupted = true;
-      if (!error)
-        error = "Interrupted. Waiting for explicit next action.";
-      trySignalChild(child, "SIGINT");
-      setTimeout(() => {
-        if (!settled && !timedOut && !stopped)
-          trySignalChild(child, "SIGTERM");
-      }, 1000).unref?.();
-    });
-    const terminateForTimeout = (message) => {
-      if (settled || timedOut || stopped)
-        return;
-      timedOut = true;
-      timeoutMessage = message;
-      interrupted = false;
-      error = message;
-      if (processTreeController)
-        processTreeController.terminate();
-      else
-        trySignalChild(child, "SIGTERM");
-    };
-    let toolTimeoutSequence = 0;
-    const activeToolTimeouts = new Map;
-    const activeToolTimeoutKeysByName = new Map;
-    const removeToolTimeoutKey = (key) => {
-      const active = activeToolTimeouts.get(key);
-      if (!active)
-        return;
-      clearTimeout(active.timer);
-      activeToolTimeouts.delete(key);
-      const keys = activeToolTimeoutKeysByName.get(active.toolName)?.filter((candidate) => candidate !== key) ?? [];
-      if (keys.length > 0)
-        activeToolTimeoutKeysByName.set(active.toolName, keys);
-      else
-        activeToolTimeoutKeysByName.delete(active.toolName);
-    };
-    const clearActiveToolTimeout = (event) => {
-      const key = typeof event.toolCallId === "string" && event.toolCallId.length > 0 ? `id:${event.toolCallId}` : typeof event.toolName === "string" ? activeToolTimeoutKeysByName.get(event.toolName)?.[0] : activeToolTimeouts.size === 1 ? [...activeToolTimeouts.keys()][0] : undefined;
-      if (key)
-        removeToolTimeoutKey(key);
-    };
-    const clearAllToolTimeouts = () => {
-      for (const key of [...activeToolTimeouts.keys()])
-        removeToolTimeoutKey(key);
-    };
-    const armToolTimeout = (event) => {
-      const timeoutForTool = effectiveToolTimeoutMs(event.toolName, toolTimeoutMs);
-      if (timeoutForTool === undefined)
-        return;
-      const runRemaining = runDeadlineAt === undefined ? undefined : Math.max(0, runDeadlineAt - Date.now());
-      if (runRemaining !== undefined && timeoutForTool >= runRemaining)
-        return;
-      const key = toolTimeoutCallKey(event, ++toolTimeoutSequence);
-      const toolName = event.toolName;
-      const timer = setTimeout(() => {
-        removeToolTimeoutKey(key);
-        terminateForTimeout(formatToolTimeoutMessage(toolName, timeoutForTool));
-      }, timeoutForTool);
-      timer.unref?.();
-      activeToolTimeouts.set(key, { toolName, timer });
-      const keys = activeToolTimeoutKeysByName.get(toolName) ?? [];
-      keys.push(key);
-      activeToolTimeoutKeysByName.set(toolName, keys);
-    };
-    registerTimeout?.(() => terminateForTimeout(timeoutMessage ?? "Subagent timed out."));
-    registerStop?.(() => {
-      if (settled || timedOut || stopped)
-        return;
-      stopped = true;
-      interrupted = false;
-      error = stopMessage ?? "Subagent stopped by user.";
-      if (processTreeController)
-        processTreeController.terminate();
-      else
-        trySignalChild(child, "SIGTERM");
-    });
-    const clearDrainTimers = () => {
-      clearAllToolTimeouts();
-      if (finalDrainTimer) {
-        clearTimeout(finalDrainTimer);
-        finalDrainTimer = undefined;
-      }
-      if (finalHardKillTimer) {
-        clearTimeout(finalHardKillTimer);
-        finalHardKillTimer = undefined;
-      }
-      clearWatchdogTailTimer();
-      if (protocolHardKillTimer) {
-        clearTimeout(protocolHardKillTimer);
-        protocolHardKillTimer = undefined;
-      }
-    };
-    function startFinalDrain() {
-      if (childWatchdogIsActive(childWatchdogState)) {
-        armWatchdogTail();
-        return;
-      }
-      if (childExited || finalDrainTimer || settled)
-        return;
-      finalDrainTimer = setTimeout(() => {
-        if (settled)
-          return;
-        const termSent = trySignalChild(child, "SIGTERM");
-        if (!termSent)
-          return;
-        forcedTerminationSignal = true;
-        if (!cleanTerminalAssistantStopReceived && !agentSettledReceived && !error && !assistantError) {
-          error = `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`;
-        }
-        finalHardKillTimer = setTimeout(() => {
-          if (settled)
-            return;
-          forcedTerminationSignal = trySignalChild(child, "SIGKILL") || forcedTerminationSignal;
-        }, HARD_KILL_MS);
-        finalHardKillTimer.unref?.();
-      }, FINAL_STOP_GRACE_MS);
-      finalDrainTimer.unref?.();
-    }
-    function clearWatchdogTailTimer() {
-      if (watchdogTailTimer) {
-        clearTimeout(watchdogTailTimer);
-        watchdogTailTimer = undefined;
-      }
-    }
-    function armWatchdogTail() {
-      if (!cleanTerminalAssistantStopReceived && !agentSettledReceived || watchdogTailTimer || settled)
-        return;
-      watchdogTailTimer = setTimeout(() => {
-        watchdogTailTimer = undefined;
-        updateChildWatchdogState({
-          phase: "stale",
-          seq: (childWatchdogState?.seq ?? 0) + 1,
-          lastUpdate: Date.now(),
-          followUpPending: false,
-          reason: "child watchdog tail timeout",
-          timedOut: true
-        });
-        startFinalDrain();
-      }, childWatchdogConfig?.watchdogTailTimeoutMs ?? 120000);
-      watchdogTailTimer.unref?.();
-    }
-    child.on("exit", () => {
-      childExited = true;
-      clearDrainTimers();
-    });
-    child.on("close", async (exitCode, signal) => {
-      settled = true;
-      const processCloseObservedAt = Date.now();
-      const processTree = processTreeController ? await processTreeController.finishAfterWriterClose() : { state: "unknown", reason: "verification-failed", diagnostic: "Writer PID was unavailable." };
-      try {
-        onWriterProcess?.({ state: "none" });
-      } catch {}
-      registerInterrupt?.(undefined);
-      registerTimeout?.(undefined);
-      registerStop?.(undefined);
-      clearDrainTimers();
-      clearStdioGuard();
-      stdoutReader.end();
-      stderrReader.end();
-      outputStream.end();
-      const stderr = stderrTail.text();
-      const finalOutput = getFinalOutput(messages) || rawStdoutTail.text().trim();
-      const finalError = error ?? assistantError;
-      const forcedDrainAfterFinalSuccess = Boolean(forcedTerminationSignal || signal) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !finalError;
-      const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(messages);
-      const forcedDrainError = forcedDrainAfterEmptyTerminal && stderr.trim() ? stderr.trim() : undefined;
-      const signalError = isUnexplainedProcessSignal({
-        processSignal: signal,
-        interrupted,
-        timedOut,
-        stopped,
-        forcedDrainAfterFinalSuccess: forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal
-      }) ? formatProcessSignalError(signal) : undefined;
-      resolve(omitUndefinedProperties({
-        stderr,
-        exitCode: timedOut || stopped ? 1 : interrupted || forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal ? 0 : forcedTerminationSignal || signal ? exitCode ?? 1 : exitCode,
-        messages,
-        usage,
-        toolCount,
-        durationMs: Date.now() - startedAt,
-        model,
-        error: stopped ? stopMessage ?? "Subagent stopped by user." : timedOut ? timeoutMessage ?? "Subagent timed out." : interrupted || forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal ? undefined : finalError ?? forcedDrainError ?? signalError,
-        protocolError,
-        finalOutput: (timedOut || stopped) && !finalOutput.trim() ? stopped ? stopMessage ?? "Subagent stopped by user." : timeoutMessage ?? "Subagent timed out." : finalOutput,
-        outputState: finalOutput.trim() ? "present" : "absent",
-        interrupted,
-        timedOut,
-        stopped,
-        observedMutationAttempt,
-        structuredOutputToolInvoked,
-        structuredOutputMessageStartIndex,
-        watchdog: childWatchdogState,
-        processInstanceId,
-        processCloseObservedAt,
-        processSignal: signal,
-        processTree,
-        currentTool,
-        currentToolArgs,
-        currentPath,
-        afterCompactionSettlement: afterCompactionSettlement || undefined
-      }));
-    });
-    child.on("error", (spawnError) => {
-      settled = true;
-      try {
-        onWriterProcess?.({ state: "none" });
-      } catch {}
-      registerInterrupt?.(undefined);
-      registerTimeout?.(undefined);
-      registerStop?.(undefined);
-      clearDrainTimers();
-      clearStdioGuard();
-      stdoutReader.end();
-      stderrReader.end();
-      outputStream.end();
-      const stderr = stderrTail.text();
-      const finalOutput = getFinalOutput(messages) || rawStdoutTail.text().trim();
-      const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);
-      resolve(omitUndefinedProperties({ stderr, exitCode: 1, messages, usage, toolCount, durationMs: Date.now() - startedAt, model, error: stopped ? stopMessage ?? "Subagent stopped by user." : timedOut ? timeoutMessage ?? "Subagent timed out." : error ?? assistantError ?? spawnErrorMessage, protocolError, finalOutput: (timedOut || stopped) && !finalOutput.trim() ? stopped ? stopMessage ?? "Subagent stopped by user." : timeoutMessage ?? "Subagent timed out." : finalOutput, outputState: finalOutput.trim() ? "present" : "absent", timedOut, stopped, observedMutationAttempt, structuredOutputToolInvoked, structuredOutputMessageStartIndex, watchdog: childWatchdogState, processInstanceId, processTree: { state: "unknown", reason: "verification-failed", diagnostic: spawnErrorMessage } }));
-    });
-  });
-}
 function resolvePiPackageRootFallback() {
   const root = resolveInstalledPiPackageRoot();
   if (root)
@@ -969,7 +383,68 @@ function writeRunLog(logPath, input, write = (filePath, content) => fs.writeFile
   write(logPath, lines.join(`
 `));
 }
-async function runSingleStepInner(step, ctx) {
+function expectedMissingGitEvidence(error) {
+  if (typeof error?.code !== "number")
+    return false;
+  const stderr = error.stderr;
+  const detail = Buffer.isBuffer(stderr) ? stderr.toString("utf-8") : String(stderr ?? "");
+  return /not a git repository|Needed a single revision/i.test(detail);
+}
+async function readGitFingerprint(cwd, signal, onError) {
+  try {
+    const runGit = async (args) => {
+      const result = await runSetupCommand("git", args, {
+        cwd,
+        signal,
+        maxBuffer: 16777216,
+        deadlineAt: Date.now() + 30000,
+        acceptedExitCodes: Array.from({ length: 256 }, (_, code) => code)
+      });
+      if (result.error)
+        throw result.error;
+      if (result.status !== 0) {
+        throw Object.assign(new Error(result.stderr || `git exited with ${result.status}`), { code: result.status, stderr: result.stderr });
+      }
+      return result.stdoutBuffer;
+    };
+    const headOutput = await runGit(["rev-parse", "--verify", "HEAD"]);
+    const head = headOutput.toString("utf-8").trim();
+    if (!head)
+      return;
+    const status = await runGit(["status", "--porcelain=v1", "-z", "--untracked-files=normal"]);
+    return `${head}\x00${status.toString("base64")}`;
+  } catch (error) {
+    if (error?.code === "PROCESS_TREE_UNVERIFIED")
+      throw error;
+    if (!signal.aborted && !expectedMissingGitEvidence(error))
+      onError(error);
+    return;
+  }
+}
+function decorateHerdrMachineResult(result, machine, adapter) {
+  let stderrTail = "";
+  try {
+    const stderr = fs.readFileSync(result.externalProcess.stderrPath, "utf-8");
+    stderrTail = stderr.slice(-4096);
+  } catch {}
+  const hint = result.exitCode === 0 ? undefined : formatHerdrMachineHint(machine, `${result.error ?? ""}
+${stderrTail}
+exit code ${result.exitCode}`);
+  const error = hint ? `${result.error ?? `Remote command exited with code ${result.exitCode}.`}
+${hint}` : result.error;
+  const note = result.exitCode === 0 && adapter?.endsWith("-writer") ? `Changes made by this run live on ${machine.label ?? machine.id} at ${machine.cwd}; the local checkout is unchanged.` : undefined;
+  const output = note ? result.output.trim() ? `${result.output.trimEnd()}
+
+${note}` : note : result.output;
+  return { ...result, output, ...error !== undefined ? { error } : {} };
+}
+export async function settleHerdrExternalRunnerError(error, adapter, evidence, retain) {
+  await retain();
+  if (!(error instanceof HerdrExternalNeedsAttentionError))
+    throw error;
+  return createHerdrExternalAdapter(adapter).normalize(evidence, error.message);
+}
+export async function runSingleStepInner(step, ctx) {
   if (step.importAsyncRoot) {
     let importTimedOut = false;
     let importStopped = false;
@@ -1018,8 +493,7 @@ async function runSingleStepInner(step, ctx) {
         sessionFile: imported.sessionFile,
         intercomTarget: imported.intercomTarget,
         model: imported.model,
-        attemptedModels: imported.attemptedModels,
-        modelAttempts: imported.modelAttempts,
+        requestedModel: imported.requestedModel,
         contextOverflow: imported.contextOverflow,
         totalCost: imported.totalCost,
         usage: imported.usage,
@@ -1035,58 +509,34 @@ async function runSingleStepInner(step, ctx) {
       ctx.registerStop?.(undefined);
     }
   }
-  const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema ? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output")) : undefined);
+  const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema ? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output"), { acceptanceReport: resolveAcceptanceReportMode(step.acceptanceInput) }) : undefined);
   const placeholderRegex = new RegExp(ctx.placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
   let task = step.task.replace(placeholderRegex, () => ctx.previousOutput);
   if (ctx.outputs)
     task = resolveOutputReferences(task, ctx.outputs);
-  const taskForCompletionGuard = task;
   let resolvedTaskToolPlan;
   if (!step.runner) {
     resolvedTaskToolPlan = resolvePiLaunchToolPlan(omitUndefinedProperties({
       tools: step.tools,
+      excludeTools: step.excludeTools,
       allowNestedSubagents: step.allowNestedSubagents,
       extensions: step.extensions,
       subagentOnlyExtensions: step.subagentOnlyExtensions,
       fast: step.fast,
       model: step.model,
-      modelCandidates: step.modelCandidates,
       mcpDirectTools: step.mcpDirectTools,
-      mcpConfig: step.mcpConfig,
-      runtimeServerNames: step.runtimeServerNames,
       cwd: step.cwd ?? ctx.cwd,
       requireReadTool: Boolean(step.skills?.length),
       structuredOutput: Boolean(effectiveStructuredOutput),
       capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
-      inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+      inheritedCapabilityCeiling: ctx.inheritedChildRuntime?.capabilityCeiling,
+      requiredExtensions: step.requiredExtensions ?? ctx.inheritedChildRuntime?.requiredExtensions,
       permissionRules: step.permissionRules
     }));
-    const contractTools = resolvedTaskToolPlan.explicitToolAllowlist ? resolvedTaskToolPlan.effectiveToolAllowlist : undefined;
-    const contractError = validateImplementationToolContract({
-      agent: step.agent,
-      task: taskForCompletionGuard,
-      tools: contractTools,
-      mcpDirectTools: resolvedTaskToolPlan.effectiveMcpTools,
-      configuredExtensions: resolvedTaskToolPlan.configuredExtensions,
-      requestedTools: resolvedTaskToolPlan.requestedBuiltinTools,
-      acceptanceRole: step.acceptanceRole,
-      completionGuard: step.completionGuard
-    });
-    if (contractError) {
-      return omitUndefinedProperties({
-        agent: step.agent,
-        context: step.context,
-        output: contractError,
-        error: contractError,
-        exitCode: 1,
-        capabilityCeiling: resolvedTaskToolPlan.capabilityCeiling,
-        capabilityAudit: resolvedTaskToolPlan.capabilityAudit
-      });
-    }
   }
   const childSessionName = step.sessionName ?? deriveChildSessionName({ agent: step.agent, task, label: step.label });
-  if (step.effectiveAcceptance) {
-    const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance, { reportOptional: isAgentContractV1(step.agentContract), structuredOutput: Boolean(step.structuredOutput?.acceptanceReportPath) });
+  if (step.effectiveAcceptance && (step.runner?.type === "external-cli" || step.runner?.type === "external-job")) {
+    const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance, { reportOptional: isAgentContract(step.agentContract), structuredOutput: Boolean(step.structuredOutput?.acceptanceReportPath) });
     if (acceptancePrompt)
       task = `${task}
 ${acceptancePrompt}`;
@@ -1118,11 +568,81 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
   }
   transcriptWriter?.writeInitialUserMessage(`${PROMPT_REDACTED}; live Prompt Audit only.`);
   if (step.runner?.type === "external-cli") {
-    const externalCwd = step.cwd ?? ctx.cwd;
+    const externalCwd = step.machine?.cwd ?? step.cwd ?? ctx.cwd;
+    const externalAbortSignal = combinedAbortSignal([ctx.timeoutSignal, ctx.stopSignal]);
+    if (!step.machine && externalAbortSignal)
+      await ctx.prepareExternalActivity?.(externalCwd, externalAbortSignal);
+    if (externalAbortSignal?.aborted) {
+      const stopped = ctx.stopSignal?.aborted === true;
+      const message = stopped ? ctx.stopMessage ?? "Subagent stopped by user." : ctx.timeoutMessage ?? "Subagent timed out.";
+      return omitUndefinedProperties({ agent: step.agent, context: step.context, output: message, error: message, exitCode: 1, stopped: stopped || undefined, timedOut: stopped ? undefined : true });
+    }
+    if (step.machine) {
+      const runner = resolveExternalCliRunnerStatus({ ...step.runner, machine: step.machine });
+      const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
+      const placedRunId = `${ctx.id}-${ctx.flatIndex}`;
+      const session = await prepareInternalHerdrExternalAdapter({ adapter: step.runner.adapter, machine: step.machine, runId: placedRunId }, {});
+      let timedOut = false, stopped = false, retain = false;
+      const evidenceInput = { runId: placedRunId, requestId: `prompt-${ctx.flatIndex}`, task: buildExternalCliPrompt(step.systemPrompt ?? "", task), cwd: externalCwd, nativeSessionId: session.launch.nativeSessionId };
+      let resolveInterruption, rejectInterruption;
+      const interruption = new Promise((resolve, reject) => {
+        resolveInterruption = resolve;
+        rejectInterruption = reject;
+      });
+      ctx.registerTimeout?.(() => {
+        timedOut = true;
+        retain = true;
+        resolveInterruption("timeout");
+      });
+      ctx.registerStop?.(() => {
+        stopped = true;
+        session.abort().then(() => resolveInterruption("stop"), rejectInterruption);
+      });
+      try {
+        let settled;
+        try {
+          const raced = await Promise.race([session.promptAndSettle(evidenceInput).then((value) => ({ kind: "settled", value })), interruption.then((kind) => ({ kind }))]);
+          if (raced.kind === "settled")
+            settled = raced.value;
+          else if (raced.kind === "timeout")
+            settled = createHerdrExternalAdapter(step.runner.adapter).normalize(evidenceInput, "Placed external run timed out; truthful pane retained for inspection.");
+          else
+            return { agent: step.agent, context: step.context, output: "Placed external run stopped by user.", outputState: "present", exitCode: 1, stopped: true, runner, execution: { status: "stopped", success: false, exitCode: 1, stopped: true } };
+        } catch (error) {
+          retain = true;
+          settled = await settleHerdrExternalRunnerError(error, step.runner.adapter, evidenceInput, () => session.retain());
+        }
+        const output = settled.output;
+        try {
+          fs.writeFileSync(ctx.outputFile, output, "utf-8");
+        } catch {}
+        const resolvedOutput = step.outputPath ? resolveSingleOutput(step.outputPath, output, outputSnapshot, step.outputClaimPath) : { fullOutput: output };
+        const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, resolvedOutput.fullOutput) : undefined;
+        const finalizedOutput = finalizeSingleOutput(omitUndefinedProperties({ fullOutput: resolvedOutput.fullOutput, outputPath: step.outputPath, outputMode: step.outputMode, exitCode: 1, preserveSavedOutput: true, savedPath: resolvedOutput.savedPath, outputReference, saveError: resolvedOutput.saveError }));
+        const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false ? persistStepArtifacts({ artifactPaths, artifactConfig: ctx.artifactConfig, output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })), metadata: { runId: ctx.id, agent: step.agent, task: PROMPT_REDACTED, runner, placement: session.owner.identity, settlement: settled.settlement, outcome: settled.outcome, timestamp: Date.now() } }) : {};
+        return omitUndefinedProperties({ agent: step.agent, ...childSessionName ? { sessionName: childSessionName } : {}, context: step.context, output: finalizedOutput.displayOutput, outputState: output.trim() ? "present" : "absent", exitCode: 1, error: resolvedOutput.fatalError ? resolvedOutput.saveError : undefined, timedOut, stopped, artifactPaths, outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join(`
+`) || undefined, metadataSaveError: artifactErrors.metadataSaveError, runner, execution: { status: "partial", success: false, exitCode: 1 } });
+      } catch (error) {
+        retain = true;
+        throw error;
+      } finally {
+        ctx.registerTimeout?.(undefined);
+        ctx.registerStop?.(undefined);
+        if (retain)
+          await session.retain();
+        else
+          await session.dispose();
+      }
+    }
     const adapterLaunch = step.runner.adapter === "codex-exec" || step.runner.adapter === "codex-exec-writer" ? resolveCodexExecLaunch({ adapter: step.runner.adapter, command: step.runner.command, asyncDir: path.dirname(ctx.outputFile), stepIndex: ctx.flatIndex }) : step.runner.adapter === "claude-code" || step.runner.adapter === "claude-code-writer" ? resolveClaudeCodeLaunch({ adapter: step.runner.adapter, command: step.runner.command }) : step.runner.adapter === "cursor-agent" || step.runner.adapter === "cursor-agent-writer" ? resolveCursorAgentLaunch({ adapter: step.runner.adapter, command: step.runner.command, cwd: externalCwd, asyncDir: path.dirname(ctx.outputFile), stepIndex: ctx.flatIndex }) : undefined;
-    const runner = resolveExternalCliRunnerStatus({ ...step.runner, ...adapterLaunch ? { args: adapterLaunch.args } : {} });
+    const runner = resolveExternalCliRunnerStatus({ ...step.runner, ...adapterLaunch ? { args: adapterLaunch.args } : {}, ...step.machine ? { machine: step.machine } : {} });
     const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
-    const external = await runExternalCli(omitUndefinedProperties({
+    const onExternalOutput = (chunk) => {
+      if (chunk.length > 0)
+        ctx.onExternalStreamActivity?.();
+      ctx.orcaProgressTab?.append(chunk.toString("utf-8"));
+    };
+    const externalInput = omitUndefinedProperties({
       command: adapterLaunch?.command ?? runner.command,
       args: adapterLaunch?.args ?? runner.args,
       cwd: externalCwd,
@@ -1140,9 +660,13 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       timeoutMessage: ctx.timeoutMessage,
       stopMessage: ctx.stopMessage,
       onProcess: ctx.onExternalProcess,
-      onStdout: (chunk) => ctx.orcaProgressTab?.append(chunk.toString("utf-8")),
-      onStderr: (chunk) => ctx.orcaProgressTab?.append(chunk.toString("utf-8"))
-    }));
+      onStdout: onExternalOutput,
+      onStderr: onExternalOutput
+    });
+    const preparedExternal = prepareHerdrMachineExternalCliRun(externalInput, step.machine ? { machine: step.machine, ...step.machineEnv ? { env: step.machineEnv } : {} } : undefined, { localCwd: ctx.cwd });
+    const ran = await runExternalCli(preparedExternal.input);
+    const externalProcess = preparedExternal.decorateProcess(ran.externalProcess);
+    const external = step.machine ? decorateHerdrMachineResult(ran, step.machine, step.runner.adapter) : ran;
     try {
       fs.writeFileSync(ctx.outputFile, external.output, "utf-8");
     } catch {}
@@ -1164,7 +688,7 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
       artifactPaths,
       artifactConfig: ctx.artifactConfig,
       output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, error: external.error, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })),
-      metadata: { runId: ctx.id, agent: step.agent, task: PROMPT_REDACTED, runner, externalProcess: external.externalProcess, exitCode: external.exitCode, error: external.error, timestamp: Date.now() }
+      metadata: { runId: ctx.id, agent: step.agent, task: PROMPT_REDACTED, runner, externalProcess, exitCode: external.exitCode, error: external.error, timestamp: Date.now() }
     }) : {};
     return omitUndefinedProperties({
       agent: step.agent,
@@ -1180,9 +704,10 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
       artifactPaths,
       outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join(`
 `) || undefined,
+      artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
       metadataSaveError: artifactErrors.metadataSaveError,
       runner,
-      externalProcess: external.externalProcess
+      externalProcess
     });
   }
   if (step.runner?.type === "external-job") {
@@ -1246,6 +771,7 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
       artifactPaths,
       outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join(`
 `) || undefined,
+      artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
       metadataSaveError: artifactErrors.metadataSaveError,
       runner,
       externalJob: external.externalJob
@@ -1255,58 +781,51 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
   const cwdError = preflightLaunchCwd(step.requestedCwd ?? effectiveCwd, effectiveCwd);
   if (cwdError)
     return { agent: step.agent, output: cwdError, error: cwdError, exitCode: 1, context: step.context };
-  const candidates = step.modelCandidates !== undefined ? step.modelCandidates.length > 0 ? step.modelCandidates : [undefined] : step.model ? [step.model] : [undefined];
-  const attemptedModels = [];
+  if (step.context === "fork" && step.sessionFile && fs.existsSync(step.sessionFile)) {
+    alignForkedSessionCwd(step.sessionFile, effectiveCwd);
+  }
+  const candidate = step.model;
   let capabilityAudit;
   let launchResolvedExtensions = step.launchResolvedExtensions;
-  const modelAttempts = [];
-  const writerProcesses = [];
-  let writerAttemptCount = 0;
-  const attemptNotes = [];
   let finalRequiredOutputMissing;
   const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
   let finalResult;
   let finalOutputSnapshot;
   let structuredAcceptanceReport;
   let structuredAcceptanceReportError;
-  let completionGuardTriggeredFinal = false;
   let toolBudget = step.toolBudget ? initialToolBudgetState(step.toolBudget) : undefined;
   let toolBudgetBlocked = false;
   let actualLaunchContractDigest = step.launchContractDigest;
-  const mutationSnapshot = snapshotTrackedMutations(step.cwd ?? ctx.cwd);
+  const mutationSnapshot = step.machine ? { source: "tracked-files", trackedOnly: true, cwd: step.cwd ?? ctx.cwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(step.cwd ?? ctx.cwd);
   let finalMutationEvidence = collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
-  let modelIndex = 0;
-  let startupAttemptIndex = 0;
-  let taskDeliveryOverride;
   let contextOverflow = false;
   let launchWarningsEmitted = false;
-  let abortRecoveryAttempted = false;
-  let nextAttemptTask = task;
-  modelAttemptsLoop:
-    while (modelIndex < candidates.length) {
+  const aggregateUsage = emptyUsage();
+  let launched = false;
+  let recoveryTask = task;
+  let stagedIndexBaseline;
+  singleLaunch:
+    for (let attemptIndex = 0;attemptIndex < 2; attemptIndex++) {
       if (ctx.timeoutSignal?.aborted || ctx.stopSignal?.aborted || ctx.skipAcceptance?.())
-        break;
-      const recoveringAbort = abortRecoveryAttempted;
-      const attemptTask = nextAttemptTask;
-      const candidate = candidates[modelIndex];
-      const expectedModelForVerification = candidate && !(step.skipPrimaryModelVerification && modelIndex === 0) ? candidate : undefined;
+        break singleLaunch;
+      const expectedModelForVerification = candidate && !step.skipPrimaryModelVerification ? candidate : undefined;
       try {
-        assertThinkingWithinCeiling({ model: candidate, configThinking: step.thinking, ceiling: step.thinkingCeiling ?? decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]), agent: step.agent, runId: ctx.id });
+        assertThinkingWithinCeiling({ model: candidate, configThinking: step.thinking, ceiling: step.thinkingCeiling, agent: step.agent, runId: ctx.id });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return omitUndefinedProperties({ agent: step.agent, output: message, error: message, exitCode: 1, context: step.context, thinkingCeiling: step.thinkingCeiling });
       }
+      const attemptModel = omitUndefinedProperties({ model: candidate, thinking: resolveEffectiveThinking(candidate, step.thinking) });
       ctx.onAttemptStart?.(omitUndefinedProperties({
-        model: candidate,
-        thinking: resolveEffectiveThinking(candidate, step.thinking),
+        ...attemptModel,
         contextLimit: findModelInfo(candidate, step.modelVerificationRegistry)?.contextWindow
       }));
       const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
       if (effectiveStructuredOutput) {
-        try {
-          if (fs.existsSync(effectiveStructuredOutput.outputPath))
-            fs.unlinkSync(effectiveStructuredOutput.outputPath);
-        } catch {}
+        const cleanupError = clearStructuredOutputCaptures(effectiveStructuredOutput);
+        if (cleanupError) {
+          return omitUndefinedProperties({ agent: step.agent, output: cleanupError, error: cleanupError, exitCode: 1, context: step.context });
+        }
       }
       const watchdogConfig = resolveWatchdogConfig(step.cwd ?? ctx.cwd);
       const extensionBindings = normalizeExtensionBindings(step.extensionBindings)?.value;
@@ -1316,61 +835,25 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
         runId: ctx.id,
         childIndex: ctx.flatIndex
       }) : undefined;
-      const { args, env, tempDir, toolDiagnosticPath, runtimeAcknowledgedExtensionsPath, capabilityAudit: attemptCapabilityAudit, warnings } = buildPiArgs(omitUndefinedProperties({
-        parentSessionId: step.parentSessionId,
-        forkCacheKey: step.context === "fork" ? deriveForkPromptCacheKey(step.parentSessionId) : undefined,
-        baseArgs: ["--mode", "json", "-p"],
-        task: attemptTask,
-        taskDelivery: taskDeliveryOverride,
-        sessionEnabled,
-        sessionDir,
-        sessionFile: step.sessionFile,
-        model: candidate,
-        inheritProjectContext: step.inheritProjectContext,
-        inheritGlobalContext: step.inheritGlobalContext,
-        inheritSkills: step.inheritSkills,
-        requireReadTool: Boolean(step.skills?.length),
-        tools: step.tools,
-        allowNestedSubagents: step.allowNestedSubagents,
-        extensions: step.extensions,
-        subagentOnlyExtensions: step.subagentOnlyExtensions,
-        fast: step.fast,
-        modelCandidates: step.modelCandidates,
-        systemPrompt: step.systemPrompt ?? "",
-        systemPromptMode: step.systemPromptMode,
-        mcpDirectTools: step.mcpDirectTools,
-        mcpConfig: step.mcpConfig,
-        runtimeServerNames: step.runtimeServerNames,
-        capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
-        cwd: step.cwd ?? ctx.cwd,
-        promptFileStem: step.agent,
-        intercomSessionName: ctx.childIntercomTarget,
-        sessionName: childSessionName,
-        orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
-        runId: ctx.id,
-        childAgentName: step.agent,
-        childIndex: ctx.flatIndex,
-        parentEventSink: ctx.nestedRoute?.eventSink,
-        parentControlInbox: ctx.nestedRoute?.controlInbox,
-        parentRootRunId: ctx.nestedRoute?.rootRunId,
-        parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
-        runFanoutBudget: ctx.runFanoutBudget ? {
-          ...ctx.runFanoutBudget,
-          ...step.runFanoutPath ? { parentPath: `${ctx.runFanoutBudget.parentPath ? `${ctx.runFanoutBudget.parentPath}/` : ""}${step.runFanoutPath}` } : {}
-        } : undefined,
-        steerInboxDir: ctx.steerInboxDir,
-        steerCapabilityPath: ctx.steerCapabilityPath,
-        steerAckDir: ctx.steerAckDir,
-        structuredOutput: effectiveStructuredOutput,
-        toolBudget: step.toolBudget,
-        permissionRules: step.permissionRules,
-        permissionAuditPath: step.permissionRules && ctx.artifactsDir ? path.join(ctx.artifactsDir, "permission-audit", `${ctx.id}-${ctx.flatIndex}.jsonl`) : undefined,
-        childWatchdog,
-        waitToolEnabled: step.waitToolEnabled,
-        waitToolDefaultTimeoutMs: step.waitToolDefaultTimeoutMs,
-        thinkingCeiling: step.thinkingCeiling,
-        extensionBindings
-      }));
+      let watchdogSink;
+      let launch;
+      try {
+        launch = buildRunnerChildLaunch(step, ctx, {
+          sessionEnabled,
+          sessionDir,
+          model: candidate,
+          sessionName: childSessionName,
+          structuredOutput: effectiveStructuredOutput,
+          childWatchdog,
+          watchdogStatus: (event) => watchdogSink?.(event)
+        });
+      } catch (error) {
+        throw error;
+      }
+      if (effectiveStructuredOutput && launch.config.structuredOutput) {
+        launch.config.structuredOutput.capture = createStructuredOutputFileCapture(effectiveStructuredOutput);
+      }
+      const { warnings, capabilityAudit: attemptCapabilityAudit } = launch;
       if (!launchWarningsEmitted && warnings.length > 0) {
         for (const warning of warnings)
           console.warn(`[dm-subagents] ${warning}`);
@@ -1379,83 +862,116 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
       if (step.definitionDigest) {
         const toolPlan = resolvedTaskToolPlan ?? resolvePiLaunchToolPlan(omitUndefinedProperties({
           tools: step.tools,
+          excludeTools: step.excludeTools,
           allowNestedSubagents: step.allowNestedSubagents,
           extensions: step.extensions,
           subagentOnlyExtensions: step.subagentOnlyExtensions,
           fast: step.fast,
           model: step.model,
-          modelCandidates: step.modelCandidates,
           mcpDirectTools: step.mcpDirectTools,
-          mcpConfig: step.mcpConfig,
-          runtimeServerNames: step.runtimeServerNames,
           cwd: step.cwd ?? ctx.cwd,
           requireReadTool: Boolean(step.skills?.length),
           structuredOutput: Boolean(effectiveStructuredOutput),
           capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
-          inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
+          inheritedCapabilityCeiling: ctx.inheritedChildRuntime?.capabilityCeiling,
+          requiredExtensions: step.requiredExtensions ?? ctx.inheritedChildRuntime?.requiredExtensions,
           permissionRules: step.permissionRules
         }));
         launchResolvedExtensions = projectLaunchResolvedChildExtensions(toolPlan);
-        actualLaunchContractDigest = launchBindingDigest(omitUndefinedProperties({
+        actualLaunchContractDigest = resolveLaunchBinding({
           definitionDigest: step.definitionDigest,
-          task: step.launchBindingTask ?? task,
-          ...candidate ? { model: candidate } : {},
-          modelCandidates: candidates,
-          ...step.fast !== undefined ? { fast: step.fast } : {},
-          ...resolveEffectiveThinking(candidate, step.thinking) ? { thinking: resolveEffectiveThinking(candidate, step.thinking) } : {},
-          ...step.thinkingCeiling ? { thinkingCeiling: step.thinkingCeiling } : {},
-          systemPrompt: step.systemPrompt ?? "",
           systemPromptMode: step.systemPromptMode,
           inheritProjectContext: step.inheritProjectContext,
           inheritGlobalContext: step.inheritGlobalContext,
           inheritSkills: step.inheritSkills,
+          task: step.launchBindingTask ?? task,
+          model: candidate,
+          fast: step.fast,
+          thinking: resolveEffectiveThinking(candidate, step.thinking),
+          systemPrompt: step.systemPrompt ?? "",
           skills: step.skills,
-          tools: toolPlan.effectiveToolAllowlist,
-          extensions: toolPlan.extensionArgs,
-          mcpDirectTools: toolPlan.effectiveMcpTools,
-          ...step.outputPath ? { outputPath: step.outputPath } : {},
-          ...step.outputMode ? { outputMode: step.outputMode } : {},
-          ...step.structuredOutputSchema ? { structuredOutputSchema: step.structuredOutputSchema } : {},
-          ...extensionBindings ? { extensionBindings } : {}
-        }));
+          toolPlan,
+          outputPath: step.outputPath,
+          outputMode: step.outputMode,
+          structuredOutputSchema: step.structuredOutputSchema,
+          extensionBindings
+        }).launchContractDigest;
       }
       capabilityAudit = attemptCapabilityAudit;
-      writerAttemptCount += 1;
-      const run = await runPiStreaming(args, step.cwd ?? ctx.cwd, ctx.outputFile, env, ctx.piPackageRoot, ctx.piArgv1, step.maxSubagentDepth, { eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent }, ctx.registerInterrupt, ctx.onChildEvent, transcriptWriter, ctx.registerTimeout, ctx.timeoutMessage, ctx.registerStop, ctx.stopMessage, ctx.onWriterProcess, ctx.toolTimeoutMs, ctx.deadlineAt, ctx.orcaProgressTab, expectedModelForVerification, step.modelVerificationRegistry, step.mutationTools);
-      if (run.processCloseObservedAt !== undefined) {
-        writerProcesses.push({
-          processInstanceId: run.processInstanceId,
-          kind: "dm-writer",
-          attempt: writerAttemptCount - 1,
-          closeObservedAt: run.processCloseObservedAt,
-          exitCode: run.exitCode,
-          signal: run.processSignal ?? null,
-          processTree: run.processTree
-        });
+      fs.writeFileSync(ctx.outputFile, "", "utf-8");
+      if (step.effectiveAcceptance?.preserveStagedIndex && stagedIndexBaseline === undefined) {
+        try {
+          stagedIndexBaseline = captureStagedIndexBaseline(step.cwd ?? ctx.cwd);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { agent: step.agent, output: message, error: message, exitCode: 1, context: step.context };
+        }
       }
-      const toolAvailabilityError = run.exitCode === 0 && !run.error ? readChildToolDiagnosticError(toolDiagnosticPath) : undefined;
-      const runtimeAcknowledgedExtensions = readRuntimeAcknowledgedExtensions(runtimeAcknowledgedExtensionsPath);
-      cleanupTempDir(tempDir);
-      const midToolExitError = run.currentTool && isOrdinaryToolForMidToolExit(run.currentTool) && !run.interrupted && !run.timedOut && !run.stopped && !run.protocolError && !toolAvailabilityError ? formatMidToolExitError({
-        toolName: run.currentTool,
-        exitCode: run.exitCode,
-        processSignal: run.processSignal
-      }) : undefined;
+      const run = await runChildSession(omitUndefinedProperties({
+        factory: ctx.childSessions,
+        launch,
+        prompt: `Task: ${recoveryTask}`,
+        childWatchdog,
+        childEventContext: { runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent },
+        appendChildEvent: (event) => appendDiagnosticJsonl(eventsPath, JSON.stringify(event), typeof event.type === "string" ? event.type : undefined),
+        writeOutputLine: (line) => {
+          try {
+            fs.appendFileSync(ctx.outputFile, `${line}
+`, "utf-8");
+          } catch {}
+          ctx.orcaProgressTab?.append(`${line}
+`);
+        },
+        registerInterrupt: ctx.registerInterrupt,
+        registerTimeout: ctx.registerTimeout,
+        registerStop: ctx.registerStop,
+        registerSteer: ctx.registerSteer,
+        onSteerOutcome: ctx.onSteerOutcome,
+        registerWatchdogStatus: (sink) => {
+          watchdogSink = sink;
+        },
+        timeoutMessage: ctx.timeoutMessage,
+        stopMessage: ctx.stopMessage,
+        onChildEvent: ctx.onChildEvent,
+        onContextWindow: (contextLimit) => ctx.onAttemptStart?.({ ...attemptModel, contextLimit }),
+        transcriptWriter,
+        toolTimeoutMs: ctx.toolTimeoutMs,
+        runDeadlineAt: ctx.deadlineAt,
+        expectedModelForVerification,
+        modelVerificationRegistry: step.modelVerificationRegistry,
+        modelResponseAliases: step.modelResponseAliases,
+        mutationTools: step.mutationTools
+      }));
+      launched = true;
+      aggregateUsage.input += run.usage.input;
+      aggregateUsage.output += run.usage.output;
+      aggregateUsage.cacheRead += run.usage.cacheRead;
+      aggregateUsage.cacheWrite += run.usage.cacheWrite;
+      aggregateUsage.cost += run.usage.cost;
+      aggregateUsage.turns += run.usage.turns;
+      const terminalDiagnosticsEligible = !run.interrupted && !run.stopped && !run.timedOut;
+      const toolDiagnostic = run.exitCode === 0 && !run.error ? launch.capture.toolDiagnostic() : undefined;
+      const toolAvailabilityError = toolDiagnostic ? formatChildToolDiagnostic(toolDiagnostic) : undefined;
+      const runtimeAcknowledgedExtensions = launch.capture.runtimeAcknowledgedExtensions();
+      const midToolExitError = run.currentTool && isOrdinaryToolForMidToolExit(run.currentTool) && !run.interrupted && !run.timedOut && !run.stopped && !toolAvailabilityError ? formatMidToolExitError({ toolName: run.currentTool }) : undefined;
       let structuredOutput;
       let structuredError;
       let validatedStructuredOutput = false;
-      if (effectiveStructuredOutput && run.exitCode === 0 && !run.error && !toolAvailabilityError && !midToolExitError) {
-        if (!run.structuredOutputToolInvoked) {
+      if (effectiveStructuredOutput) {
+        const otherwiseSuccessful = terminalDiagnosticsEligible && run.exitCode === 0 && !run.error && !toolAvailabilityError && !midToolExitError;
+        if (!run.structuredOutputToolInvoked && otherwiseSuccessful) {
           structuredError = MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
-        } else {
+        } else if (run.structuredOutputToolInvoked) {
           const structured = await readStructuredOutput({
             schema: effectiveStructuredOutput.schema,
             schemaPath: effectiveStructuredOutput.schemaPath,
             outputPath: effectiveStructuredOutput.outputPath
           });
-          if (structured.error)
-            structuredError = structured.error;
-          else {
+          if (structured.error) {
+            if (otherwiseSuccessful) {
+              structuredError = structured.error === MISSING_STRUCTURED_OUTPUT_CALL_ERROR ? formatStructuredOutputRejectionError(run.messages) : structured.error;
+            }
+          } else {
             structuredOutput = structured.value;
             const acceptanceReport = readStructuredOutputAcceptanceReport(effectiveStructuredOutput);
             structuredAcceptanceReport = acceptanceReport.value;
@@ -1465,63 +981,21 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
         }
       }
       const errorMessages = validatedStructuredOutput ? run.messages.slice(run.structuredOutputMessageStartIndex ?? run.messages.length) : run.messages;
-      const hiddenError = run.exitCode === 0 && !run.error && !toolAvailabilityError && !structuredError && !midToolExitError ? detectSubagentError(errorMessages) : null;
+      const hiddenError = terminalDiagnosticsEligible && run.exitCode === 0 && !run.error && !toolAvailabilityError && !structuredError && !midToolExitError ? detectSubagentError(errorMessages) : null;
       const terminalEmptyAfterUsefulWork = !validatedStructuredOutput && hasEmptyTerminalAssistantResponse(run.messages) && (run.toolCount > 0 || Boolean(run.finalOutput.trim()));
-      const emptyOutputError = run.exitCode === 0 && !run.error && !toolAvailabilityError && !structuredError && !validatedStructuredOutput && (!run.finalOutput.trim() || terminalEmptyAfterUsefulWork) && (!hiddenError?.hasError || hasEmptyTerminalAssistantResponse(run.messages)) ? formatEmptyTerminalAssistantResponseError(run.messages) : undefined;
-      const completionGuardEnabled = isAgentContractV1(step.agentContract) ? step.completionGuard === true : step.completionGuard !== false;
-      const completionToolPlan = resolvedTaskToolPlan;
-      const completionTools = completionToolPlan ? completionToolPlan.explicitToolAllowlist ? completionToolPlan.effectiveToolAllowlist : undefined : step.tools;
-      const mutationEvidence = collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
+      const emptyOutputError = terminalDiagnosticsEligible && run.exitCode === 0 && !run.error && !toolAvailabilityError && !structuredError && !validatedStructuredOutput && (!run.finalOutput.trim() || terminalEmptyAfterUsefulWork) && (!hiddenError?.hasError || hasEmptyTerminalAssistantResponse(run.messages)) ? formatEmptyTerminalAssistantResponseError(run.messages) : undefined;
+      const remoteGitChanged = run.nativeMachine?.initialGit && run.nativeMachine.finalGit ? run.nativeMachine.initialGit.head !== run.nativeMachine.finalGit.head || run.nativeMachine.initialGit.dirty !== run.nativeMachine.finalGit.dirty : undefined;
+      const mutationEvidence = run.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {} } : collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
       finalMutationEvidence = mutationEvidence;
-      const completionMutationEvidence = ctx.trackedMutationEvidenceForCompletionGuard === false ? undefined : mutationEvidence;
-      const completionGuard = run.exitCode === 0 && !run.error && !structuredError && !hiddenError?.hasError && !midToolExitError && !emptyOutputError && completionGuardEnabled ? evaluateCompletionMutationGuard(omitUndefinedProperties({
-        agent: step.agent,
-        task: taskForCompletionGuard,
-        messages: run.messages,
-        tools: completionTools,
-        mcpDirectTools: completionToolPlan?.effectiveMcpTools ?? step.mcpDirectTools,
-        mutationTools: step.mutationTools,
-        toolAvailabilityError,
-        mutationEvidence: completionMutationEvidence
-      })) : undefined;
-      const mutationAttemptObserved = run.observedMutationAttempt === true || completionMutationEvidence?.attemptedMutation === true;
-      const completionEvidence = planCompletionEvidence({
-        guard: completionGuard,
-        completionGuardEnabled,
-        mutationCapable: hasMutationToolCapability(completionTools, completionToolPlan?.effectiveMcpTools ?? step.mcpDirectTools),
-        implementationMutationExpected: expectsImplementationMutation(step.agent, taskForCompletionGuard),
-        mutationAttemptObserved,
-        mutationEvidence: completionMutationEvidence,
-        agentContractV1: isAgentContractV1(step.agentContract)
-      });
+      const mutationAttemptObserved = run.observedMutationAttempt === true || mutationEvidence.attemptedMutation === true;
       const finalOutputHasPersistableFileContent = run.exitCode === 0 && !run.error && !emptyOutputError && Boolean(stripAcceptanceReport(run.finalOutput).trim());
       const requiredOutput = step.outputMode === "file-only" && step.outputPath ? { kind: "file-only", path: step.outputPath, missing: !fs.existsSync(step.outputPath) && !finalOutputHasPersistableFileContent } : effectiveStructuredOutput ? { kind: "structured", path: effectiveStructuredOutput.outputPath, missing: !fs.existsSync(effectiveStructuredOutput.outputPath) } : undefined;
       finalRequiredOutputMissing = requiredOutput?.missing;
-      const missingRequiredOutputError = formatRequiredOutputError(requiredOutput);
+      const missingRequiredOutputError = terminalDiagnosticsEligible ? formatRequiredOutputError(requiredOutput) : undefined;
       const missingRequiredOutputAfterMutation = Boolean(missingRequiredOutputError) && (mutationAttemptObserved || Boolean(mutationEvidence.changedFiles.length));
-      const effectiveExitCode = toolAvailabilityError || completionEvidence.legacyFailureError || midToolExitError || structuredError || emptyOutputError || missingRequiredOutputError ? 1 : hiddenError?.hasError ? hiddenError.exitCode ?? 1 : run.error && run.exitCode === 0 ? 1 : run.exitCode;
-      const signalError = run.exitCode !== 0 && isUnexplainedProcessSignal(omitUndefinedProperties({
-        processSignal: run.processSignal,
-        interrupted: run.interrupted,
-        timedOut: run.timedOut,
-        stopped: run.stopped
-      })) ? formatProcessSignalError(run.processSignal) : undefined;
-      const underlyingError = toolAvailabilityError ?? midToolExitError ?? structuredError ?? run.error ?? signalError ?? (run.exitCode !== 0 && run.stderr.trim() ? run.stderr.trim() : undefined) ?? ((emptyOutputError || missingRequiredOutputError) && run.stderr.trim() ? run.stderr.trim() : undefined) ?? emptyOutputError ?? (missingRequiredOutputAfterMutation ? missingRequiredOutputError : undefined) ?? (hiddenError?.hasError ? hiddenError.details ? `${hiddenError.errorType} failed (exit ${effectiveExitCode}): ${hiddenError.details}` : `${hiddenError.errorType} failed with exit code ${effectiveExitCode}` : undefined);
-      const error = formatSubagentExtensionConflictError(underlyingError ?? missingRequiredOutputError ?? completionEvidence.legacyFailureError, {
-        agent: step.agent,
-        ambientExtensionsEnabled: launchResolvedExtensions?.disableAmbientExtensions === false
-      });
-      const attempt = omitUndefinedProperties({
-        model: candidate ?? run.model ?? step.model ?? "default",
-        success: effectiveExitCode === 0 && !error,
-        exitCode: effectiveExitCode,
-        error,
-        usage: run.usage
-      });
-      modelAttempts.push(attempt);
-      if (!recoveringAbort && candidate && startupAttemptIndex === 0)
-        attemptedModels.push(candidate);
-      completionGuardTriggeredFinal = completionEvidence.guardTriggered && !underlyingError && !missingRequiredOutputError;
+      const effectiveExitCode = toolAvailabilityError || midToolExitError || structuredError || emptyOutputError || missingRequiredOutputError ? 1 : hiddenError?.hasError ? hiddenError.exitCode ?? 1 : run.error && run.exitCode === 0 ? 1 : run.exitCode;
+      const underlyingError = toolAvailabilityError ?? midToolExitError ?? structuredError ?? run.error ?? emptyOutputError ?? (missingRequiredOutputAfterMutation ? missingRequiredOutputError : undefined) ?? (hiddenError?.hasError ? hiddenError.details ? `${hiddenError.errorType} failed (exit ${effectiveExitCode}): ${hiddenError.details}` : `${hiddenError.errorType} failed with exit code ${effectiveExitCode}` : undefined);
+      const error = underlyingError ?? missingRequiredOutputError;
       finalOutputSnapshot = outputSnapshot;
       if (step.toolBudget) {
         const toolMessages = run.messages.filter((message) => message.role === "toolResult");
@@ -1529,21 +1003,23 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
         toolBudgetBlocked = Boolean(blockedMessage);
         toolBudget = toolBudgetState(step.toolBudget, toolMessages.length, blockedMessage ? blockedMessage.toolName : undefined);
       }
-      const settlementDiagnostic = projectSettlementDiagnostic(completionEvidence, {
-        terminalFailed: effectiveExitCode !== 0,
+      const settlementDiagnostic = effectiveExitCode !== 0 ? {
         finalTextPresent: Boolean(stripAcceptanceReport(run.finalOutput).trim()),
-        mutationObserved: mutationEvidence.attemptedMutation,
-        requiredOutput,
+        mutation: { attempted: mutationAttemptObserved, observed: mutationEvidence.attemptedMutation },
+        ...requiredOutput ? { requiredOutput } : {},
         afterCompactionSettlement: run.afterCompactionSettlement === true
-      });
-      const fileMutationEffect = completionEvidence.fileMutation ?? (missingRequiredOutputAfterMutation ? { status: "observed", expected: completionEvidence.mutationExpected, attempted: true, evidence: mutationEvidence } : undefined);
-      finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput, runtimeAcknowledgedExtensions, ...step.agentContract ? { agentContract: step.agentContract } : {}, ...fileMutationEffect || settlementDiagnostic ? { effects: { ...fileMutationEffect ? { fileMutation: fileMutationEffect } : {}, ...settlementDiagnostic ? { settlementDiagnostic } : {} } } : {} };
-      const abortRecovery = !attempt.success ? planAbortRecovery({
+      } : undefined;
+      const fileMutationEffect = missingRequiredOutputAfterMutation ? { status: "observed", attempted: true, evidence: mutationEvidence } : undefined;
+      finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error, structuredOutput, structuredOutputFailed: structuredError ? true : undefined, runtimeAcknowledgedExtensions, ...step.agentContract ? { agentContract: step.agentContract } : {}, ...fileMutationEffect || settlementDiagnostic ? { effects: { ...fileMutationEffect ? { fileMutation: fileMutationEffect } : {}, ...settlementDiagnostic ? { settlementDiagnostic } : {} } } : {} };
+      if (run.stopped || run.timedOut || ctx.timeoutSignal?.aborted || ctx.stopSignal?.aborted || ctx.skipAcceptance?.())
+        break singleLaunch;
+      if (effectiveExitCode === 0 && !error)
+        break singleLaunch;
+      const recovery = planAbortRecovery({
         messages: run.messages,
         error,
-        processSignal: run.processSignal,
         sessionAvailable: Boolean(step.sessionFile && fs.existsSync(step.sessionFile)),
-        alreadyResumed: abortRecoveryAttempted,
+        alreadyResumed: attemptIndex > 0,
         stopped: run.stopped || ctx.stopSignal?.aborted || ctx.skipAcceptance?.(),
         interrupted: run.interrupted,
         timedOut: run.timedOut || ctx.timeoutSignal?.aborted,
@@ -1553,90 +1029,24 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError : external.error;
         acceptanceFailed: false,
         currentTool: run.currentTool,
         afterCompactionSettlement: run.afterCompactionSettlement
-      }) : undefined;
-      if (abortRecovery?.action === "settle" && abortRecovery.diagnostic) {
-        attempt.error = attempt.error ? `${abortRecovery.diagnostic}
-${attempt.error.slice(0, 8000)}` : abortRecovery.diagnostic;
-        if (finalResult)
-          finalResult.abortRecoveryDiagnostic = abortRecovery.diagnostic;
-      }
-      if (run.stopped || run.timedOut || ctx.timeoutSignal?.aborted || ctx.stopSignal?.aborted || ctx.skipAcceptance?.())
-        break modelAttemptsLoop;
-      if (abortRecovery?.action === "settle" && abortRecovery.diagnostic)
-        break modelAttemptsLoop;
-      if (attempt.success)
-        break modelAttemptsLoop;
-      if (recoveringAbort)
-        break modelAttemptsLoop;
-      if (abortRecovery?.action === "resume") {
-        abortRecoveryAttempted = true;
-        nextAttemptTask = abortRecovery.prompt;
-        attemptNotes.push("[abort-recovery] provider/transport abort after useful progress; resuming the retained child session once.");
-        continue;
-      }
-      if (completionEvidence.guardTriggered)
-        break modelAttemptsLoop;
-      const startupFailure = isRetryableSubagentStartupFailure(omitUndefinedProperties({
-        exitCode: effectiveExitCode,
-        error,
-        finalOutput: run.finalOutput,
-        messageCount: run.messages.length,
-        toolCount: run.toolCount,
-        usage: run.usage,
-        durationMs: run.durationMs,
-        protocolError: run.protocolError,
-        processSignal: run.processSignal,
-        observedMutationAttempt: run.observedMutationAttempt,
-        interrupted: run.interrupted,
-        timedOut: run.timedOut,
-        stopped: run.stopped
-      }));
-      const retryDelayMs = SUBAGENT_STARTUP_RETRY_DELAYS_MS[startupAttemptIndex];
-      if (startupFailure && retryDelayMs !== undefined) {
-        const retryNote = formatSubagentStartupRetryNote({
-          model: attempt.model,
-          attempt: startupAttemptIndex + 1,
-          maxAttempts: SUBAGENT_STARTUP_RETRY_DELAYS_MS.length + 1,
-          delayMs: retryDelayMs
-        });
-        const shouldRetry = await waitForSubagentStartupRetry(retryDelayMs, [ctx.timeoutSignal, ctx.stopSignal]);
-        if (!shouldRetry || ctx.skipAcceptance?.())
-          break modelAttemptsLoop;
-        if (!taskDeliveryOverride && run.processSignal === "SIGKILL") {
-          taskDeliveryOverride = "file";
-          attemptNotes.push("[startup-retry] retrying with file task delivery to keep the task text out of the child process argv.");
-        }
-        attempt.error = retryNote;
-        attemptNotes.push(retryNote);
-        startupAttemptIndex += 1;
-        continue;
+      });
+      if (recovery.action === "resume") {
+        recoveryTask = recovery.prompt;
+        continue singleLaunch;
       }
-      if (startupFailure) {
-        const startupError = formatSubagentStartupRetryExhaustedError({
-          model: attempt.model,
-          attempts: startupAttemptIndex + 1
-        });
-        attempt.error = startupError;
-        finalResult.error = startupError;
-        finalResult.finalOutput = startupError;
-        break modelAttemptsLoop;
+      if (recovery.diagnostic) {
+        finalResult.abortRecoveryDiagnostic = recovery.diagnostic;
       }
-      const retryableModelFailure = isRetryableModelFailureAttempt({ error, messages: run.messages, toolCount: run.toolCount });
-      if (retryableModelFailure)
-        recordRetryableModelFailure(candidate ?? run.model ?? step.model, error);
       if (isContextOverflow(error)) {
         contextOverflow = true;
-        attemptNotes.push(`[fallback] ${attempt.model} failed: context overflow — the input exceeds this model's context window. Reduce the task input or use a model with a larger context window.`);
-        break modelAttemptsLoop;
+        break singleLaunch;
       }
-      if (!retryableModelFailure || modelIndex === candidates.length - 1)
-        break modelAttemptsLoop;
-      attemptNotes.push(formatModelAttemptNote(attempt, candidates[modelIndex + 1]));
-      modelIndex += 1;
-      startupAttemptIndex = 0;
+      break singleLaunch;
     }
   const rawOutput = finalResult?.finalOutput ?? "";
-  const outputForPersistence = stripAcceptanceReport(rawOutput);
+  let outputForPersistence = stripAcceptanceReport(rawOutput);
+  if (!outputForPersistence.trim() && finalResult?.structuredOutput !== undefined)
+    outputForPersistence = JSON.stringify(finalResult.structuredOutput, null, 2);
   const resolvedOutput = step.outputPath && finalResult?.exitCode === 0 ? resolveSingleOutput(step.outputPath, outputForPersistence, finalOutputSnapshot, step.outputClaimPath) : { fullOutput: outputForPersistence };
   if (resolvedOutput.fatalError) {
     if (finalResult) {
@@ -1648,12 +1058,6 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError;
   const output = stripAcceptanceReport(resolvedOutput.fullOutput);
   const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, output) : undefined;
   let outputForSummary = output;
-  if (attemptNotes.length > 0) {
-    outputForSummary = `${attemptNotes.join(`
-`)}
-
-${outputForSummary}`.trim();
-  }
   if (finalResult?.stopped && !outputForSummary.trim()) {
     outputForSummary = ctx.stopMessage ?? "Subagent stopped by user.";
   }
@@ -1692,18 +1096,24 @@ ${timeoutRecovery.message}` : timeoutRecovery.message;
     reportError: structuredAcceptanceReportError,
     fileOutput: childWrittenOutput !== undefined && step.outputPath ? { content: childWrittenOutput, path: step.outputPath, authoritative: step.outputMode === "file-only", durable: resolvedOutput.savedPath !== undefined } : undefined,
     cwd: step.cwd ?? ctx.cwd,
+    stagedIndexBaseline,
     signal: combinedAbortSignal([ctx.timeoutSignal, ctx.stopSignal]),
     abortMessage: ctx.stopSignal?.aborted ? ctx.stopMessage ?? "Subagent stopped by user." : ctx.timeoutMessage ?? "Subagent timed out.",
-    reportOptional: isAgentContractV1(step.agentContract),
+    reportOptional: isAgentContract(step.agentContract),
     artifactsDir: ctx.artifactsDir,
-    runId: ctx.id
+    runId: ctx.id,
+    watchdog: finalResult?.watchdog
   })) : undefined;
   const stoppedAfterAcceptance = finalResult?.stopped === true || ctx.stopSignal?.aborted === true;
   const timedOutAfterAcceptance = !stoppedAfterAcceptance && (finalResult?.timedOut === true || ctx.timeoutSignal?.aborted === true);
   const effectiveAcceptance = step.effectiveAcceptance ? stoppedAfterAcceptance ? buildSkippedAcceptanceLedger(step.effectiveAcceptance, { id: "stopped", message: "Acceptance was not evaluated because the subagent was stopped." }) : timedOutAfterAcceptance ? buildSkippedAcceptanceLedger(step.effectiveAcceptance, { id: "timeout", message: "Acceptance was not evaluated because the subagent timed out." }) : acceptance : undefined;
   const acceptanceFailure = effectiveAcceptance ? acceptanceFailureMessage(effectiveAcceptance) : undefined;
-  const acceptanceCanFailRun = acceptanceFailure && effectiveAcceptance?.explicit && (finalResult?.exitCode ?? 1) === 0 && !finalResult?.interrupted && !timedOutAfterAcceptance && !stoppedAfterAcceptance && !isAgentContractV1(step.agentContract);
+  const acceptanceCanFailRun = acceptanceFailure && effectiveAcceptance?.explicit && (finalResult?.exitCode ?? 1) === 0 && !finalResult?.interrupted && !timedOutAfterAcceptance && !stoppedAfterAcceptance && !isAgentContract(step.agentContract);
   const effectiveFinalExitCode = timedOutAfterAcceptance || stoppedAfterAcceptance ? 1 : acceptanceCanFailRun ? 1 : finalResult?.exitCode ?? 1;
+  const typedGate = typedVerifyOutput(effectiveAcceptance);
+  if (typedGate && finalResult && finalResult.structuredOutput === undefined && effectiveFinalExitCode === 0) {
+    finalResult = { ...finalResult, structuredOutput: typedGate.value };
+  }
   const intercomDetachReceipt = finalResult?.finalOutput === INTERCOM_DETACH_RECEIPT;
   const baseFinalError = stoppedAfterAcceptance ? ctx.stopMessage ?? "Subagent stopped by user." : timedOutAfterAcceptance ? finalResult?.error ?? ctx.timeoutMessage ?? "Subagent timed out." : acceptanceCanFailRun ? finalResult?.error ? `${finalResult.error}
 ${acceptanceFailure}` : acceptanceFailure : finalResult?.error ?? (intercomDetachReceipt ? INTERCOM_DETACH_RECEIPT : undefined);
@@ -1713,7 +1123,7 @@ ${acceptanceFailure}` : acceptanceFailure : finalResult?.error ?? (intercomDetac
     abortRecoveryDiagnostic: effectiveFinalExitCode !== 0 ? finalResult?.abortRecoveryDiagnostic : undefined,
     requiredOutput: effectiveFinalExitCode !== 0 ? finalResult?.effects?.settlementDiagnostic?.requiredOutput : undefined
   });
-  const usage = usageFromAttempts(modelAttempts);
+  const usage = launched ? aggregateUsage : undefined;
   const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false ? persistStepArtifacts({
     artifactPaths,
     artifactConfig: ctx.artifactConfig,
@@ -1729,8 +1139,8 @@ ${acceptanceFailure}` : acceptanceFailure : finalResult?.error ?? (intercomDetac
       task: PROMPT_REDACTED,
       exitCode: effectiveFinalExitCode,
       model: finalResult?.model,
-      attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
-      modelAttempts,
+      nativeMachine: finalResult?.nativeMachine,
+      requestedModel: step.requestedModel,
       usage,
       error: effectiveFinalError,
       acceptance: effectiveAcceptance,
@@ -1754,42 +1164,41 @@ ${acceptanceFailure}` : acceptanceFailure : finalResult?.error ?? (intercomDetac
     outputState,
     exitCode: effectiveFinalExitCode,
     error: effectiveFinalError,
-    protocolError: finalResult?.protocolError,
     sessionFile: step.sessionFile,
     intercomTarget: ctx.childIntercomTarget,
     model: finalResult?.model,
-    attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
-    modelAttempts,
+    nativeMachine: finalResult?.nativeMachine,
+    thinking: resolveEffectiveThinking(finalResult?.model, step.thinking),
+    requestedModel: step.requestedModel,
     contextOverflow: contextOverflow || undefined,
-    totalCost: costSummaryFromAttempts(modelAttempts),
+    totalCost: costSummaryFromUsage(usage),
     usage,
     artifactPaths,
+    savedOutputPath: finalizedOutput.savedPath,
     outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join(`
 `) || undefined,
+    artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
     metadataSaveError: artifactErrors.metadataSaveError,
     transcriptPath: transcriptWriter ? artifactPaths?.transcriptPath : undefined,
     transcriptError: transcriptWriter?.getError(),
     interrupted: timedOutAfterAcceptance || stoppedAfterAcceptance ? false : finalResult?.interrupted,
     timedOut: timedOutAfterAcceptance ? true : finalResult?.timedOut,
     stopped: stoppedAfterAcceptance ? true : finalResult?.stopped,
-    processSignal: finalResult?.processSignal,
     timeoutRecovery,
     toolBudget,
     toolBudgetBlocked: toolBudgetBlocked || undefined,
-    completionGuardTriggered: completionGuardTriggeredFinal,
     ...finalResult?.effects ? { effects: finalResult.effects } : {},
-    structuredOutput: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : finalResult?.structuredOutput,
-    structuredOutputPath: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : effectiveStructuredOutput?.outputPath,
-    structuredOutputSchemaPath: timedOutAfterAcceptance || stoppedAfterAcceptance ? undefined : effectiveStructuredOutput?.schemaPath,
+    structuredOutput: finalResult?.structuredOutput,
+    structuredOutputFailed: finalResult?.structuredOutputFailed,
+    structuredOutputPath: effectiveStructuredOutput?.outputPath,
+    structuredOutputSchemaPath: effectiveStructuredOutput?.schemaPath,
     acceptance: effectiveAcceptance,
     watchdog: finalResult?.watchdog,
     ...capabilityAudit ? { capabilityCeiling: capabilityAudit.ceiling, capabilityAudit } : {},
     launchResolvedExtensions,
-    ...finalResult?.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: finalResult.runtimeAcknowledgedExtensions } : {},
-    writerProcesses,
-    writerAttemptCount
+    ...finalResult?.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: finalResult.runtimeAcknowledgedExtensions } : {}
   });
-  return isAgentContractV1(step.agentContract) ? attachContractProjections(result) : result;
+  return isAgentContract(step.agentContract) ? attachContractProjections(result) : result;
 }
 async function runSingleStep(step, ctx) {
   if (!step.importAsyncRoot)
@@ -1832,6 +1241,10 @@ function requiredStatusStep(statusPayload, index) {
 function setStatusWorktreeReference(statusStep, worktree) {
   statusStep.worktreePath = worktree.path;
   statusStep.branch = worktree.branch;
+  if (worktree.provider)
+    statusStep.provider = worktree.provider;
+  if (worktree.naming)
+    statusStep.naming = worktree.naming;
 }
 function markParallelGroupSetupFailure(input) {
   for (let taskIndex = 0;taskIndex < input.group.parallel.length; taskIndex++) {
@@ -1840,12 +1253,15 @@ function markParallelGroupSetupFailure(input) {
     const task = input.group.parallel[taskIndex];
     if (!task)
       throw new Error(`Missing parallel task at index ${taskIndex}`);
-    statusStep.status = "failed";
+    const stopped = statusStep.stopped || statusStep.stopRequested || input.statusPayload.stopped;
+    const paused = !stopped && input.statusPayload.state === "paused";
+    statusStep.status = stopped ? "stopped" : paused ? "paused" : "failed";
     statusStep.startedAt = input.failedAt;
     statusStep.endedAt = input.failedAt;
     statusStep.durationMs = 0;
-    statusStep.exitCode = 1;
-    input.results.push(omitUndefinedProperties({ agent: task.agent, context: task.context, output: input.setupError, success: false, exitCode: 1, sessionFile: task.sessionFile }));
+    statusStep.exitCode = paused ? 0 : 1;
+    statusStep.error ??= input.setupError;
+    input.results.push(omitUndefinedProperties({ agent: task.agent, context: task.context, output: input.setupError, error: input.setupError, success: false, exitCode: paused ? 0 : 1, sessionFile: task.sessionFile, stopped: stopped || undefined, interrupted: paused || undefined, timedOut: input.statusPayload.timedOut || undefined }));
   }
   input.statusPayload.currentStep = input.groupStartFlatIndex;
   input.statusPayload.lastUpdate = input.failedAt;
@@ -1886,12 +1302,24 @@ function markParallelGroupRunning(input) {
     count: input.group.parallel.length
   }));
 }
+function bindWorktreeCwd(step, worktreeCwd) {
+  const bind = (value) => value === null || value === undefined ? value : value.replaceAll(WORKTREE_AGENT_CWD_PLACEHOLDER, worktreeCwd);
+  return {
+    ...step,
+    task: bind(step.task) ?? step.task,
+    ...step.systemPrompt !== undefined ? { systemPrompt: bind(step.systemPrompt) } : {},
+    ...step.outputPath !== undefined ? { outputPath: bind(step.outputPath) } : {},
+    ...step.launchBindingTask !== undefined ? { launchBindingTask: bind(step.launchBindingTask) } : {},
+    ...step.requestedCwd !== undefined ? { requestedCwd: bind(step.requestedCwd) } : {}
+  };
+}
 function prepareParallelTaskRun(task, cwd, worktreeSetup, taskIndex) {
   if (!worktreeSetup)
     return { taskForRun: task, taskCwd: cwd };
   const { cwd: _taskCwd, ...taskForRun } = task;
+  const boundTask = bindWorktreeCwd(taskForRun, worktreeSetup.worktrees[taskIndex].agentCwd);
   return {
-    taskForRun,
+    taskForRun: boundTask,
     taskCwd: worktreeSetup.worktrees[taskIndex].agentCwd
   };
 }
@@ -1916,8 +1344,12 @@ function missingRequiredOutputAfterUsefulMutation(result) {
   return effects?.settlementDiagnostic?.requiredOutput?.missing === true && (effects.settlementDiagnostic.mutation.attempted || effects.fileMutation?.attempted === true || Boolean(effects.fileMutation?.evidence?.changedFiles.length));
 }
 function partialExecutionWithUsefulMutation(result) {
+  if (result.execution?.status !== "partial")
+    return false;
+  if (result.runner?.type === "external-cli" && result.runner.machine)
+    return true;
   const fileMutation = result.effects?.fileMutation;
-  return result.execution?.status === "partial" && (fileMutation?.attempted === true || Boolean(fileMutation?.evidence?.changedFiles.length));
+  return fileMutation?.attempted === true || Boolean(fileMutation?.evidence?.changedFiles.length);
 }
 function partialEvidenceResult(result) {
   return missingRequiredOutputAfterUsefulMutation(result) || partialExecutionWithUsefulMutation(result);
@@ -1944,7 +1376,10 @@ function combinedAbortSignal(signals) {
 }
 async function runSingleStepWithTimeout(step, ctx, parentDeadlineAt) {
   if (step.timeoutMs === undefined)
-    return runSingleStep(step, ctx);
+    return runSingleStep(step, parentDeadlineAt === undefined ? ctx : {
+      ...ctx,
+      deadlineAt: ctx.deadlineAt === undefined ? parentDeadlineAt : Math.min(ctx.deadlineAt, parentDeadlineAt)
+    });
   const parentRemainingMs = parentDeadlineAt === undefined ? undefined : Math.max(0, parentDeadlineAt - Date.now());
   const timeoutMs = parentRemainingMs === undefined ? step.timeoutMs : Math.min(step.timeoutMs, parentRemainingMs);
   const timeoutMessage = parentRemainingMs !== undefined && parentRemainingMs <= step.timeoutMs ? ctx.timeoutMessage : `Subagent timed out after ${step.timeoutMs}ms.`;
@@ -1979,7 +1414,7 @@ async function runSingleStepWithTimeout(step, ctx, parentDeadlineAt) {
     ctx.registerTimeout?.(undefined);
   }
 }
-async function runSubagent(config, onWriterProcess) {
+export async function runSubagent(config, childSessions) {
   const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } = config;
   const globalSemaphore = new Semaphore(config.globalConcurrencyLimit ?? DEFAULT_GLOBAL_CONCURRENCY_LIMIT);
   let previousOutput = "";
@@ -1997,13 +1432,15 @@ async function runSubagent(config, onWriterProcess) {
   const activeChildInterrupts = new Map;
   const activeChildTimeouts = new Map;
   const activeChildStops = new Map;
+  const activeChildSteers = new Map;
+  const queuedStepSteers = new Map;
   const childStopRequests = new Map;
   const pendingStepSteers = [];
-  const steeringCapabilities = new Map;
   let interrupted = false;
   let currentActivityState;
   let activityTimer;
   let timeoutTimer;
+  let checkpointTimer;
   let timedOut = false;
   let stopped = false;
   let usageBudgetExceeded = false;
@@ -2011,6 +1448,9 @@ async function runSubagent(config, onWriterProcess) {
   const stopMessage = "Subagent stopped by user.";
   const timeoutAbortController = new AbortController;
   const stopAbortController = new AbortController;
+  const setupInterruptController = new AbortController;
+  const runStopSignal = AbortSignal.any([timeoutAbortController.signal, stopAbortController.signal]);
+  const setupSignal = AbortSignal.any([timeoutAbortController.signal, stopAbortController.signal, setupInterruptController.signal]);
   let previousCumulativeTokens = { input: 0, output: 0, total: 0 };
   let latestSessionFile;
   const flatSteps = flattenSteps(steps);
@@ -2050,7 +1490,7 @@ async function runSubagent(config, onWriterProcess) {
           model: task.model,
           ...task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {},
           thinking: task.thinking,
-          attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+          requestedModel: task.requestedModel,
           recentTools: [],
           recentOutput: []
         }));
@@ -2104,7 +1544,7 @@ async function runSubagent(config, onWriterProcess) {
         model: step.model,
         ...step.contextLimit !== undefined ? { contextLimit: step.contextLimit } : {},
         thinking: step.thinking,
-        attemptedModels: step.modelCandidates && step.modelCandidates.length > 0 ? step.modelCandidates : step.model ? [step.model] : undefined,
+        requestedModel: step.requestedModel,
         recentTools: [],
         recentOutput: []
       }));
@@ -2168,22 +1608,32 @@ async function runSubagent(config, onWriterProcess) {
     },
     onError: (error, filePath) => console.error(`Failed to update async run index '${filePath}':`, error)
   });
-  const queueActiveRunIndex = () => {
-    const state = statusPayload.state;
+  const queueActiveRunIndex = (status) => {
+    const state = status.state;
     if (state === lastIndexedStatusState && indexPersistence.pendingCount() === 0)
       return;
-    indexPersistence.write(asyncDir, { state, toolCallId: statusPayload.toolCallId }, (_filePath, payload) => {
+    indexPersistence.write(asyncDir, { state, toolCallId: status.toolCallId }, (_filePath, payload) => {
       const indexPayload = payload;
       updateActiveRunIndex(asyncDir, indexPayload.state, indexPayload.toolCallId, { retryCapacityErrors: true });
     });
   };
+  let finalResultCommitted = false;
+  let finalResultPublication;
   const runPersistence = createCapacityResilientJsonWriter({
     keepAlive: true,
-    onSuccess: (filePath) => {
+    onSuccess: (filePath, payload) => {
       if (filePath === statusPath)
-        queueActiveRunIndex();
+        queueActiveRunIndex(payload);
+      if (filePath === resultPath && finalResultPublication) {
+        finalResultCommitted = true;
+        finalResultPublication.resolve();
+      }
     },
-    onError: (error, filePath) => console.error(`Failed to persist async run state '${filePath}':`, error)
+    onError: (error, filePath) => {
+      console.error(`Failed to persist async run state '${filePath}':`, error);
+      if (filePath === resultPath)
+        finalResultPublication?.reject(error);
+    }
   });
   try {
     fs.mkdirSync(asyncDir, { recursive: true });
@@ -2192,7 +1642,7 @@ async function runSubagent(config, onWriterProcess) {
       throw error;
     console.error(`Failed to prepare async run storage '${asyncDir}' while storage is full:`, error);
   }
-  runPersistence.write(statusPath, statusPayload);
+  runPersistence.write(statusPath, { ...statusPayload });
   let pendingParallelUsageCost = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
   const currentUsageTotals = () => {
     const cost = results.reduce((sum, result) => ({
@@ -2210,6 +1660,11 @@ async function runSubagent(config, onWriterProcess) {
     setOptionalProperty(statusPayload, "usageBudget", usageBudgetState(config.usageBudget, currentUsageTotals()));
     return statusPayload.usageBudget;
   };
+  let continuationUsageUncertain = config.steps.some(isDynamicRunnerGroup) || flatSteps.some((step) => Boolean(step.runner || step.importAsyncRoot));
+  const continuationUsageBudgetExhausted = () => {
+    const exhausted = refreshUsageBudget()?.exhausted === true;
+    return exhausted ? true : config.usageBudget && continuationUsageUncertain ? undefined : false;
+  };
   const emitNestedSelfEvent = (type) => {
     if (!config.nestedRoute || !config.nestedSelf)
       return;
@@ -2278,7 +1733,6 @@ async function runSubagent(config, onWriterProcess) {
       updateNode(node);
     statusPayload.workflowGraph = graph;
   };
-  let finalResultCommitted = false;
   const statusResultState = () => {
     if (statusPayload.state === "running" || statusPayload.state === "queued")
       return;
@@ -2335,9 +1789,8 @@ async function runSubagent(config, onWriterProcess) {
         success: statusResultSuccess(state, step),
         sessionFile: step.sessionFile,
         model: step.model,
-        attemptedModels: step.attemptedModels,
-        modelAttempts: step.modelAttempts,
-        usage: usageFromAttempts(step.modelAttempts),
+        thinking: step.thinking,
+        requestedModel: step.requestedModel,
         contextOverflow: step.contextOverflow
       })),
       exitCode: state === "complete" || state === "paused" ? 0 : 1,
@@ -2351,14 +1804,16 @@ async function runSubagent(config, onWriterProcess) {
     }), (filePath, payload) => writePendingAsyncResultFile(filePath, payload));
   };
   const writeStatusPayloadNow = () => {
+    if (finalResultPublication)
+      return;
     refreshWorkflowGraph();
     writeRecoverableStatusResult();
-    runPersistence.write(statusPath, statusPayload);
+    runPersistence.write(statusPath, { ...statusPayload });
     emitNestedSelfEvent(statusPayload.state === "running" || statusPayload.state === "queued" ? "subagent.nested.updated" : "subagent.nested.completed");
   };
   const statusWriteCoalescer = createFileCoalescer(writeStatusPayloadNow, 100);
   const writeStatusPayload = (immediate = true) => {
-    if (immediate || statusPayload.state !== "running" || statusPayload.activityState !== undefined) {
+    if (immediate || statusPayload.state !== "running") {
       if (!statusWriteCoalescer.flush(statusPath))
         writeStatusPayloadNow();
       return;
@@ -2483,6 +1938,17 @@ async function runSubagent(config, onWriterProcess) {
     if (stopped || childStopRequests.has(flatIndex))
       stop();
   };
+  const registerStepSteer = (flatIndex, steer) => {
+    if (!steer) {
+      activeChildSteers.delete(flatIndex);
+      return;
+    }
+    activeChildSteers.set(flatIndex, steer);
+    const queued = queuedStepSteers.get(flatIndex);
+    queuedStepSteers.delete(flatIndex);
+    for (const request of queued ?? [])
+      steerLiveChild(flatIndex, request);
+  };
   const interruptActiveChildren = () => {
     for (const interrupt of [...activeChildInterrupts.values()])
       interrupt();
@@ -2502,6 +1968,7 @@ async function runSubagent(config, onWriterProcess) {
       yield* nestedRuns(child.steps?.flatMap((step) => step.children ?? []));
     }
   };
+  const isNestedControlDescendant = (run) => !config.nestedSelf || run.path.some((entry) => entry.runId === id);
   const interruptNestedAsyncDescendants = () => {
     if (!config.nestedRoute)
       return;
@@ -2518,7 +1985,7 @@ async function runSubagent(config, onWriterProcess) {
       return;
     }
     for (const run of nestedRuns(registry.children)) {
-      if (run.state !== "running" && run.state !== "queued")
+      if (!isNestedControlDescendant(run) || run.state !== "running" && run.state !== "queued")
         continue;
       const nestedAsyncDir = run.asyncDir ?? resolveNestedAsyncDir(config.nestedRoute.rootRunId, run);
       if (!nestedAsyncDir)
@@ -2552,7 +2019,7 @@ async function runSubagent(config, onWriterProcess) {
       return;
     }
     for (const run of nestedRuns(registry.children)) {
-      if (run.state !== "running" && run.state !== "queued")
+      if (!isNestedControlDescendant(run) || run.state !== "running" && run.state !== "queued")
         continue;
       const nestedAsyncDir = run.asyncDir ?? resolveNestedAsyncDir(config.nestedRoute.rootRunId, run);
       if (!nestedAsyncDir)
@@ -2586,7 +2053,7 @@ async function runSubagent(config, onWriterProcess) {
       return;
     }
     for (const run of nestedRuns(registry.children)) {
-      if (run.state !== "running" && run.state !== "queued")
+      if (!isNestedControlDescendant(run) || run.state !== "running" && run.state !== "queued")
         continue;
       const nestedAsyncDir = run.asyncDir ?? resolveNestedAsyncDir(config.nestedRoute.rootRunId, run);
       if (!nestedAsyncDir)
@@ -2645,6 +2112,7 @@ async function runSubagent(config, onWriterProcess) {
     }
     const appendedSteps = requests.flatMap((request) => request.steps);
     steps.push(...appendedSteps);
+    flatSteps.push(...flattenSteps(appendedSteps));
     const now = Date.now();
     const pendingAppends = countPendingChainAppendRequests(asyncDir);
     const added = appendRunnerStepsToStatus({
@@ -2680,9 +2148,64 @@ async function runSubagent(config, onWriterProcess) {
     setOptionalProperty(groupNode, "error", error);
     setOptionalProperty(groupNode, "acceptanceStatus", acceptance?.status ?? groupNode.acceptanceStatus);
   };
+  const EXTERNAL_GIT_PROBE_MIN_INTERVAL_MS = 2000;
+  const externalActivityEvidence = new Map;
+  const gitProbesByCwd = new Map;
+  let periodicGitProbeFailure;
+  const reportedGitProbeErrors = new Set;
+  const reportGitProbeError = (externalCwd, error) => {
+    if (reportedGitProbeErrors.has(externalCwd))
+      return;
+    reportedGitProbeErrors.add(externalCwd);
+    const detail = error instanceof Error ? error.message : String(error);
+    console.error(`[dm-subagents] Git activity evidence unavailable for '${externalCwd.slice(-300)}'; check the cwd and Git installation: ${detail.slice(0, 500)}`);
+  };
+  const readSharedGitFingerprint = (externalCwd) => {
+    const inFlight = gitProbesByCwd.get(externalCwd);
+    if (inFlight)
+      return inFlight;
+    const probe = readGitFingerprint(externalCwd, runStopSignal, (error) => reportGitProbeError(externalCwd, error)).finally(() => gitProbesByCwd.delete(externalCwd));
+    gitProbesByCwd.set(externalCwd, probe);
+    return probe;
+  };
+  const recordPeriodicGitProbeFailure = (index, error) => {
+    if (periodicGitProbeFailure)
+      return;
+    const cause = error instanceof Error ? error : new Error(String(error));
+    const message = `PROCESS_TREE_UNVERIFIED: ${cause.message}`;
+    periodicGitProbeFailure = { index, error: cause, message };
+    statusPayload.error = message;
+    const step = statusPayload.steps[index];
+    if (step)
+      step.error = message;
+    statusPayload.lastUpdate = Date.now();
+    writeStatusPayload();
+    appendJsonl(eventsPath, JSON.stringify({
+      type: "subagent.run.process_tree_unverified",
+      ts: statusPayload.lastUpdate,
+      runId: id,
+      index,
+      code: "PROCESS_TREE_UNVERIFIED",
+      message
+    }));
+  };
+  const prepareExternalActivity = async (index, externalCwd, signal) => {
+    if (!controlConfig.enabled)
+      return;
+    const resolvedCwd = path.resolve(externalCwd);
+    const evidence = { cwd: resolvedCwd, lastProbeStartedAt: performance.now() };
+    externalActivityEvidence.set(index, evidence);
+    evidence.fingerprint = await readGitFingerprint(resolvedCwd, signal, (error) => reportGitProbeError(resolvedCwd, error));
+  };
+  const recordExternalStreamActivity = (index) => {
+    const evidence = externalActivityEvidence.get(index) ?? {};
+    externalActivityEvidence.set(index, evidence);
+    evidence.lastStreamActivityAt = Date.now();
+  };
   const stepOutputActivityAt = (index) => {
     const step = statusPayload.steps[index];
     let lastActivityAt = step?.lastActivityAt ?? step?.startedAt ?? overallStartTime;
+    lastActivityAt = Math.max(lastActivityAt, externalActivityEvidence.get(index)?.lastStreamActivityAt ?? 0);
     const outputPath = path.join(asyncDir, `output-${index}.log`);
     try {
       lastActivityAt = Math.max(lastActivityAt, fs.statSync(outputPath).mtimeMs);
@@ -2934,23 +2457,15 @@ async function runSubagent(config, onWriterProcess) {
         return { index, state: "scheduled" };
       if (step.status !== "running")
         return { index, state: "failed", reason: `child is ${step.status}` };
-      if (steeringCapabilities.get(index)?.supported === false)
-        return { index, state: "failed", reason: "child DM session does not support steering" };
       return { index, state: "routed" };
     });
     recordSteeringLifecycle(request, targetStates);
     emitSteeringEvent("subagent.steer.requested", request, undefined, { targets: targetStates });
     for (const target of targetStates) {
       if (target.state === "routed") {
-        try {
-          enqueueStepSteer(asyncDir, target.index, request);
-          updateSteeringLifecycleTarget(request.id, target.index, "routed", now);
-          emitSteeringEvent("subagent.steer.routed", request, target.index);
-        } catch (error) {
-          markSteeringAttention(target.index);
-          updateSteeringLifecycleTarget(request.id, target.index, "failed", now, { reason: error instanceof Error ? error.message : String(error) });
-          emitSteeringEvent("subagent.steer.failed", request, target.index, { reason: error instanceof Error ? error.message : String(error) });
-        }
+        updateSteeringLifecycleTarget(request.id, target.index, "routed", now);
+        emitSteeringEvent("subagent.steer.routed", request, target.index);
+        steerLiveChild(target.index, request);
       } else if (target.state === "failed") {
         markSteeringAttention(target.index);
         emitSteeringEvent("subagent.steer.failed", request, target.index, { reason: target.reason });
@@ -2962,28 +2477,43 @@ async function runSubagent(config, onWriterProcess) {
     statusPayload.lastUpdate = now;
     writeStatusPayload();
   };
-  const consumeSteerAck = (ack) => {
+  const applySteerDelivery = (requestId, index, delivery) => {
     const lifecycle = steeringStatus(statusPayload);
-    const request = lifecycle.recent.find((candidate) => candidate.id === ack.requestId);
-    if (!request || !request.targets.some((target) => target.index === ack.index))
+    const request = lifecycle.recent.find((candidate) => candidate.id === requestId);
+    const target = request?.targets.find((candidate) => candidate.index === index);
+    if (!request || !target)
+      return;
+    if (target.state === "delivered" || target.state === "late" || target.state === "failed")
       return;
-    const late = fs.existsSync(steeringMarkerPath(ack.requestId));
+    if (target.state === delivery.state)
+      return;
+    const late = fs.existsSync(steeringMarkerPath(requestId));
     const now = Date.now();
-    if (ack.state === "delivered") {
-      updateSteeringLifecycleTarget(ack.requestId, ack.index, late ? "late" : "delivered", now, omitUndefinedProperties({ reason: late ? "acknowledged after recovery commit" : undefined }));
-      emitSteeringEvent("subagent.steer.delivered", { type: "steer", id: ack.requestId, ts: now, message: ack.message }, ack.index, { late, deliveryStatus: "delivered", message: ack.message });
-    } else if (ack.state === "queued") {
-      updateSteeringLifecycleTarget(ack.requestId, ack.index, "queued", now);
-      emitSteeringEvent("subagent.steer.queued", { type: "steer", id: ack.requestId, ts: now, message: ack.message }, ack.index, { deliveryStatus: "queued", message: ack.message });
+    if (delivery.state === "delivered") {
+      updateSteeringLifecycleTarget(requestId, index, late ? "late" : "delivered", now, omitUndefinedProperties({ reason: late ? "acknowledged after recovery commit" : undefined }));
+      emitSteeringEvent("subagent.steer.delivered", { type: "steer", id: requestId, ts: now, message: delivery.message }, index, { late, deliveryStatus: "delivered", message: delivery.message });
+    } else if (delivery.state === "queued") {
+      updateSteeringLifecycleTarget(requestId, index, "queued", now);
+      emitSteeringEvent("subagent.steer.queued", { type: "steer", id: requestId, ts: now, message: delivery.message }, index, { deliveryStatus: "queued", message: delivery.message });
     } else {
-      markSteeringAttention(ack.index);
-      updateSteeringLifecycleTarget(ack.requestId, ack.index, "failed", now, { reason: ack.message });
-      emitSteeringEvent("subagent.steer.failed", { type: "steer", id: ack.requestId, ts: now, message: ack.message }, ack.index, { reason: ack.message });
+      markSteeringAttention(index);
+      updateSteeringLifecycleTarget(requestId, index, "failed", now, { reason: delivery.message });
+      emitSteeringEvent("subagent.steer.failed", { type: "steer", id: requestId, ts: now, message: delivery.message }, index, { reason: delivery.message });
     }
-    emitTerminalSteeringNotice(ack.requestId, `Steering failed for run ${id}: ${ack.message}`);
+    emitTerminalSteeringNotice(requestId, `Steering failed for run ${id}: ${delivery.message}`);
     statusPayload.lastUpdate = now;
     writeStatusPayload();
   };
+  const steerLiveChild = (index, request) => {
+    const steer = activeChildSteers.get(index);
+    if (!steer) {
+      const queued = queuedStepSteers.get(index) ?? [];
+      queued.push(request);
+      queuedStepSteers.set(index, queued);
+      return;
+    }
+    steer(request).then((delivery) => applySteerDelivery(request.id, index, delivery), (error) => applySteerDelivery(request.id, index, { state: "failed", message: error instanceof Error ? error.message : String(error) }));
+  };
   const flushPendingStepSteers = (flatIndex) => {
     const remaining = [];
     for (const request of pendingStepSteers.splice(0)) {
@@ -3010,6 +2540,7 @@ async function runSubagent(config, onWriterProcess) {
     const step = statusPayload.steps[flatIndex];
     if (!step)
       return;
+    const previousActivityState = step.activityState;
     const now = Date.now();
     statusPayload.currentStep = flatIndex;
     if (isChildWatchdogStatusEvent(event)) {
@@ -3029,6 +2560,16 @@ async function runSubagent(config, onWriterProcess) {
       writeStatusPayload(false);
       return;
     }
+    if (event.type === "message_end") {
+      const next = applyChildWatchdogMessage(step.watchdog, event.message);
+      if (next)
+        step.watchdog = next;
+      if (next && event.message?.role === "custom") {
+        statusPayload.lastUpdate = now;
+        writeStatusPayload(false);
+        return;
+      }
+    }
     if (event.type === "tool_execution_start" && event.toolName) {
       const mutates = isMutatingTool(event.toolName, event.args, flatSteps[flatIndex]?.mutationTools);
       const currentPath = resolveCurrentPath(event.toolName, event.args);
@@ -3064,6 +2605,7 @@ async function runSubagent(config, onWriterProcess) {
           tokens: step.tokens?.total,
           toolCount: step.toolCount,
           currentTool: step.currentTool,
+          toolCallId: event.toolCallId,
           currentToolDurationMs: 0,
           currentPath: step.currentPath
         })));
@@ -3138,6 +2680,11 @@ async function runSubagent(config, onWriterProcess) {
 `).slice(-10));
       step.turnCount = (step.turnCount ?? 0) + 1;
       const usage = event.message.usage;
+      if (config.usageBudget) {
+        const known = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+        if (!known(usage?.input ?? usage?.inputTokens) || !known(usage?.output ?? usage?.outputTokens))
+          continuationUsageUncertain = true;
+      }
       if (usage) {
         const input = usage.input ?? usage.inputTokens ?? 0;
         const output = usage.output ?? usage.outputTokens ?? 0;
@@ -3157,9 +2704,9 @@ async function runSubagent(config, onWriterProcess) {
     statusPayload.lastActivityAt = now;
     statusPayload.lastUpdate = now;
     maybeEmitActiveLongRunning(flatIndex, now);
-    writeStatusPayload(false);
+    writeStatusPayload(step.activityState !== previousActivityState);
   };
-  const updateRunnerActivityState = (now) => {
+  const updateRunnerActivityState = (now, skipExternalProbeIndex) => {
     if (!controlConfig.enabled)
       return false;
     let changed = false;
@@ -3178,11 +2725,37 @@ async function runSubagent(config, onWriterProcess) {
         config: controlConfig,
         startedAt: step.startedAt ?? overallStartTime,
         lastActivityAt,
+        turnCount: flatSteps[index]?.runner?.type === "external-cli" ? 1 : step.turnCount,
         currentTool: step.currentTool,
         thinking: step.thinking,
         now
       }));
       if (idleState === "needs_attention") {
+        const evidence = externalActivityEvidence.get(index);
+        if (index !== skipExternalProbeIndex && evidence?.cwd && evidence.fingerprint) {
+          if (evidence.probeInFlight)
+            continue;
+          if (performance.now() - (evidence.lastProbeStartedAt ?? 0) >= EXTERNAL_GIT_PROBE_MIN_INTERVAL_MS) {
+            evidence.lastProbeStartedAt = performance.now();
+            const baseline = evidence.fingerprint;
+            evidence.probeInFlight = readSharedGitFingerprint(evidence.cwd).then((fingerprint) => {
+              if (requiredStatusStep(statusPayload, index).status !== "running")
+                return;
+              if (fingerprint && fingerprint !== baseline) {
+                evidence.fingerprint = fingerprint;
+                evidence.lastStreamActivityAt = Date.now();
+                updateRunnerActivityState(Date.now());
+              } else {
+                updateRunnerActivityState(Date.now(), index);
+              }
+            }).catch((error) => {
+              recordPeriodicGitProbeFailure(index, error);
+            }).finally(() => {
+              delete evidence.probeInFlight;
+            });
+            continue;
+          }
+        }
         const previous = step.activityState;
         step.activityState = "needs_attention";
         if (previous !== "needs_attention") {
@@ -3227,11 +2800,88 @@ async function runSubagent(config, onWriterProcess) {
     }, 1000);
     activityTimer.unref?.();
   }
+  const publishSetupUnknown = (progress) => {
+    if (!progress.unknown)
+      return;
+    const proof = {
+      version: 1,
+      state: "unknown",
+      runId: id,
+      runnerProcessInstanceId: config.runnerProcessInstanceId ?? "unknown",
+      reason: "process-tree-unverified",
+      diagnostic: `Worktree setup settlement unknown: ${progress.unknown}; manual reconciliation required; ${parallelHandoffPath(asyncDir)}`
+    };
+    statusPayload.processTerminal = proof;
+    writeAtomicJson(processTerminalPath(asyncDir), proof);
+  };
+  const finalizeWorktree = async (setup, stepIndex, flatStartIndex, action, deadlineAt) => {
+    let admitted = false;
+    try {
+      await Promise.all([...externalActivityEvidence.values()].map((evidence) => evidence.probeInFlight).filter((probe) => probe !== undefined));
+      if (periodicGitProbeFailure)
+        throw periodicGitProbeFailure.error;
+      await withWorktreeTransaction(() => {
+        if (deadlineAt !== undefined && Date.now() >= deadlineAt)
+          throw new Error("Run deadline expired before worktree cleanup");
+        admitted = true;
+        action();
+      });
+    } catch (error) {
+      if (admitted)
+        throw error;
+      const reason = `Worktree finalization retained; manual reconciliation required: ${error instanceof Error ? error.message : String(error)}`;
+      statusPayload.parallelHandoff = writeParallelHandoffGroup({
+        manifestPath: parallelHandoffPath(asyncDir),
+        runId: id,
+        mode: (config.resultMode ?? statusPayload.mode) === "parallel" ? "parallel" : (config.resultMode ?? statusPayload.mode) === "single" ? "single" : "chain",
+        source: "async",
+        cwd,
+        stepIndex,
+        flatStartIndex,
+        setup,
+        diffs: [],
+        results: [],
+        cleanup: { state: "partial", pruned: false, errors: [reason], tasks: setup.worktrees.map((worktree) => ({
+          index: worktree.index,
+          path: worktree.path,
+          branch: worktree.branch,
+          provider: worktree.provider,
+          naming: worktree.naming,
+          worktreeRemoved: false,
+          branchRemoved: false,
+          preserved: true,
+          reason
+        })) }
+      });
+      previousOutput = [previousOutput, reason, formatParallelHandoffReference(statusPayload.parallelHandoff)].filter(Boolean).join(`
+
+`);
+      writeStatusPayload();
+    }
+  };
+  const cleanupRemainingWorktree = (setup, stepIndex, flatStartIndex) => finalizeWorktree(setup, stepIndex, flatStartIndex, () => {
+    const cleanup = cleanupWorktrees(setup);
+    statusPayload.parallelHandoff = writeParallelHandoffGroup({
+      manifestPath: parallelHandoffPath(asyncDir),
+      runId: id,
+      mode: (config.resultMode ?? statusPayload.mode) === "parallel" ? "parallel" : (config.resultMode ?? statusPayload.mode) === "single" ? "single" : "chain",
+      source: "async",
+      cwd,
+      stepIndex,
+      flatStartIndex,
+      setup,
+      diffs: [],
+      results: [],
+      cleanup
+    });
+    writeStatusPayload();
+  }, config.deadlineAt);
   const interruptRunner = () => {
     consumeInterruptRequest(asyncDir);
     if (interrupted || statusPayload.state !== "running")
       return;
     interrupted = true;
+    setupInterruptController.abort();
     const now = Date.now();
     statusPayload.state = "paused";
     currentActivityState = undefined;
@@ -3256,17 +2906,18 @@ async function runSubagent(config, onWriterProcess) {
     interruptActiveChildren();
   };
   const stopRunner = () => {
-    if (stopped || timedOut || interrupted || statusPayload.state !== "running")
+    if (stopped || timedOut || statusPayload.state !== "running" && statusPayload.state !== "paused")
       return;
     stopped = true;
+    interrupted = false;
     const now = Date.now();
     statusPayload.stopped = true;
     statusPayload.error = stopMessage;
     currentActivityState = undefined;
     delete statusPayload.activityState;
     statusPayload.lastUpdate = now;
-    for (const step of statusPayload.steps) {
-      if (step.status !== "running" && step.status !== "pending")
+    for (const [index, step] of statusPayload.steps.entries()) {
+      if (step.status !== "running" && step.status !== "pending" && step.status !== "paused")
         continue;
       step.status = "stopped";
       step.error = stopMessage;
@@ -3276,6 +2927,9 @@ async function runSubagent(config, onWriterProcess) {
       step.endedAt = now;
       step.durationMs = step.startedAt ? now - step.startedAt : 0;
       step.lastActivityAt = now;
+      const result = results[index];
+      if (result?.interrupted)
+        results[index] = { ...result, output: stopMessage, error: stopMessage, exitCode: 1, success: false, interrupted: false, stopped: true };
     }
     writeStatusPayload();
     appendJsonl(eventsPath, JSON.stringify({
@@ -3340,30 +2994,35 @@ async function runSubagent(config, onWriterProcess) {
         deliverSteerRequest(request);
         pendingStepSteers.push(request);
       }
-    },
-    onSteerCapability: (capability) => {
-      steeringCapabilities.set(capability.index, capability);
-      if (!capability.supported) {
-        const now = Date.now();
-        const lifecycle = steeringStatus(statusPayload);
-        for (const request of lifecycle.recent) {
-          if (!request.targets.some((target) => target.index === capability.index && (target.state === "routed" || target.state === "scheduled")))
-            continue;
-          markSteeringAttention(capability.index);
-          updateSteeringLifecycleTarget(request.id, capability.index, "failed", now, { reason: "child DM session does not support steering" });
-          emitSteeringEvent("subagent.steer.failed", { type: "steer", id: request.id, ts: request.requestedAt, message: "child DM session does not support steering" }, capability.index, { reason: "child DM session does not support steering" });
-          emitTerminalSteeringNotice(request.id, `Steering failed for run ${id}: child ${capability.index} does not support steering.`);
-        }
-        statusPayload.lastUpdate = now;
-        writeStatusPayload();
-      }
-    },
-    onSteerAck: consumeSteerAck
+    }
   });
   if (config.deadlineAt !== undefined) {
     const remainingMs = Math.max(0, config.deadlineAt - Date.now());
     timeoutTimer = setTimeout(timeoutRunner, remainingMs);
     timeoutTimer.unref?.();
+    const checkpointBeforeDeadlineMs = config.checkpointBeforeDeadlineMs;
+    const checkpointDelayMs = checkpointBeforeDeadlineMs === undefined || !Number.isInteger(checkpointBeforeDeadlineMs) || checkpointBeforeDeadlineMs <= 0 ? undefined : remainingMs - checkpointBeforeDeadlineMs;
+    if (checkpointDelayMs !== undefined && checkpointDelayMs >= 1000) {
+      const deadlineAt = config.deadlineAt;
+      checkpointTimer = setTimeout(() => {
+        checkpointTimer = undefined;
+        if (timedOut || stopped || interrupted)
+          return;
+        if (!statusPayload.steps.some((step) => step.status === "running"))
+          return;
+        const now = Date.now();
+        const seconds = Math.round(Math.max(0, deadlineAt - now) / 1000);
+        deliverSteerRequest({
+          type: "steer",
+          id: `deadline-checkpoint-${now}`,
+          ts: now,
+          mode: "steer",
+          source: "deadline-checkpoint",
+          message: `Deadline checkpoint from the runner: this run is killed in about ${seconds} seconds. Finish the current tool call only, then stop and reply with a handoff: changed files, build/test state, remaining work, and commit/PR state. Do not start new work.`
+        });
+      }, checkpointDelayMs);
+      checkpointTimer.unref?.();
+    }
   }
   appendJsonl(eventsPath, JSON.stringify({
     type: "subagent.run.started",
@@ -3406,10 +3065,7 @@ async function runSubagent(config, onWriterProcess) {
           const thinkingOverride = step.thinkingOverrides?.[itemIndex];
           const model = thinkingOverride ? applyThinkingSuffix(step.parallel.model, thinkingOverride, true) : step.parallel.model;
           const configThinking = thinkingOverride ? thinkingOverride : step.parallel.thinking;
-          const candidates = step.parallel.modelCandidates !== undefined ? step.parallel.modelCandidates.length > 0 ? step.parallel.modelCandidates.map((candidate) => thinkingOverride ? applyThinkingSuffix(candidate, thinkingOverride, true) ?? candidate : candidate) : [undefined] : model ? [model] : [undefined];
-          for (const candidate of candidates) {
-            assertThinkingWithinCeiling({ model: candidate, configThinking, ceiling: step.parallel.thinkingCeiling ?? decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]), agent: step.parallel.agent, runId: id });
-          }
+          assertThinkingWithinCeiling({ model, configThinking, ceiling: step.parallel.thinkingCeiling, agent: step.parallel.agent, runId: id });
         }
         if (materialized.collectedOnEmpty)
           await validateDynamicCollection(step.collect.outputSchema, materialized.collectedOnEmpty);
@@ -3477,14 +3133,14 @@ async function runSubagent(config, onWriterProcess) {
           cwd,
           signal: combinedAbortSignal([timeoutAbortController.signal, stopAbortController.signal]),
           abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? "Subagent timed out.",
-          reportOptional: isAgentContractV1(step.agentContract)
+          reportOptional: isAgentContract(step.agentContract)
         })) : undefined;
         const groupStopped = stopped || stopAbortController.signal.aborted;
         const groupTimedOut = !groupStopped && (timedOut || timeoutAbortController.signal.aborted);
         const effectiveGroupAcceptance = groupTimedOut || groupStopped ? undefined : groupAcceptance;
         if (placeholder && effectiveGroupAcceptance)
           placeholder.acceptance = effectiveGroupAcceptance;
-        const groupAcceptanceFailure = effectiveGroupAcceptance && (!isAgentContractV1(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
+        const groupAcceptanceFailure = effectiveGroupAcceptance && (!isAgentContract(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
         if (groupTimedOut || groupStopped || groupAcceptanceFailure) {
           const errorMessage = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? "Subagent timed out." : groupAcceptanceFailure;
           statusPayload.state = groupStopped ? "stopped" : "failed";
@@ -3538,11 +3194,7 @@ async function runSubagent(config, onWriterProcess) {
           ...step.sessionFiles?.[itemIndex] ? { sessionFile: step.sessionFiles[itemIndex] } : {},
           ...thinkingOverride ? {
             ...model ? { model } : {},
-            ...thinking ? { thinking } : {},
-            ...step.parallel.modelCandidates ? { modelCandidates: step.parallel.modelCandidates.flatMap((candidate) => {
-              const resolved = applyThinkingSuffix(candidate, thinkingOverride, true);
-              return resolved ? [resolved] : [];
-            }) } : {}
+            ...thinking ? { thinking } : {}
           } : {},
           structuredOutputSchema: step.parallel.structuredOutputSchema ?? step.parallel.structuredOutput?.schema
         });
@@ -3569,7 +3221,7 @@ async function runSubagent(config, onWriterProcess) {
           ...task.contextLimit !== undefined ? { contextLimit: task.contextLimit } : {},
           ...task.thinking ? { thinking: task.thinking } : {},
           ...task.thinkingCeiling ? { thinkingCeiling: task.thinkingCeiling } : {},
-          ...task.modelCandidates && task.modelCandidates.length > 0 ? { attemptedModels: task.modelCandidates } : task.model ? { attemptedModels: [task.model] } : {},
+          ...task.requestedModel ? { requestedModel: task.requestedModel } : {},
           recentTools: [],
           recentOutput: []
         });
@@ -3687,11 +3339,9 @@ async function runSubagent(config, onWriterProcess) {
           flatIndex: fi,
           flatStepCount: Math.max(statusPayload.steps.length, 1),
           outputFile: path.join(asyncDir, `output-${fi}.log`),
-          steerInboxDir: stepSteerInboxDir(asyncDir, fi),
-          steerCapabilityPath: steerCapabilityPath(asyncDir, fi),
-          steerAckDir: steerAcksDir(asyncDir, fi),
           piPackageRoot: config.piPackageRoot,
-          piArgv1: config.piArgv1,
+          childSessions,
+          inheritedChildRuntime: config.inheritedChildRuntime,
           childIntercomTarget: config.childIntercomTargets?.[fi],
           orchestratorIntercomTarget: config.controlIntercomTarget,
           nestedRoute: config.nestedRoute,
@@ -3700,25 +3350,28 @@ async function runSubagent(config, onWriterProcess) {
           registerInterrupt: (interrupt) => registerStepInterrupt(fi, interrupt),
           registerTimeout: (interrupt) => registerStepTimeout(fi, interrupt),
           registerStop: (stop) => registerStepStop(fi, stop),
+          registerSteer: (steer) => registerStepSteer(fi, steer),
+          onSteerOutcome: (request, delivery) => applySteerDelivery(request.id, fi, delivery),
           timeoutSignal: timeoutAbortController.signal,
           stopSignal: stopAbortController.signal,
-          trackedMutationEvidenceForCompletionGuard: false,
           timeoutMessage,
           stopMessage,
           toolTimeoutMs: task.toolTimeoutMs ?? config.toolTimeoutMs,
           onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking, attempt.contextLimit),
           onChildEvent: (event) => updateStepFromChildEvent(fi, event),
-          onWriterProcess,
           onExternalProcess: (process) => updateExternalProcess(fi, process),
+          prepareExternalActivity: (externalCwd, signal) => prepareExternalActivity(fi, externalCwd, signal),
+          onExternalStreamActivity: () => recordExternalStreamActivity(fi),
           onExternalJob: (externalJob) => updateExternalJob(fi, externalJob),
           skipAcceptance: () => timedOut || stopped || childStopRequests.has(fi),
-          usageBudgetExhausted: () => refreshUsageBudget()?.exhausted === true,
+          usageBudgetExhausted: continuationUsageBudgetExhausted,
+          usageBudget: config.usageBudget,
           orcaProgressTab
         }), config.deadlineAt);
         const taskEndTime = Date.now();
         const childInterrupted = singleResult.interrupted === true;
         const childStopped = singleResult.stopped === true;
-        requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.exitCode === 0 ? "complete" : "failed";
+        requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
         requiredStatusStep(statusPayload, fi).endedAt = taskEndTime;
         requiredStatusStep(statusPayload, fi).durationMs = taskEndTime - taskStartTime;
         requiredStatusStep(statusPayload, fi).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
@@ -3733,8 +3386,7 @@ async function runSubagent(config, onWriterProcess) {
         setOptionalProperty(requiredStatusStep(statusPayload, fi), "sessionName", singleResult.sessionName);
         setOptionalProperty(requiredStatusStep(statusPayload, fi), "model", singleResult.model);
         setOptionalProperty(requiredStatusStep(statusPayload, fi), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, fi).thinking));
-        setOptionalProperty(requiredStatusStep(statusPayload, fi), "attemptedModels", singleResult.attemptedModels);
-        setOptionalProperty(requiredStatusStep(statusPayload, fi), "modelAttempts", singleResult.modelAttempts);
+        setOptionalProperty(requiredStatusStep(statusPayload, fi), "requestedModel", singleResult.requestedModel);
         setOptionalProperty(requiredStatusStep(statusPayload, fi), "contextOverflow", singleResult.contextOverflow);
         setOptionalProperty(requiredStatusStep(statusPayload, fi), "totalCost", singleResult.totalCost);
         if (singleResult.totalCost) {
@@ -3798,8 +3450,7 @@ async function runSubagent(config, onWriterProcess) {
           output: pr.output,
           outputState: pr.outputState,
           error: pr.error,
-          protocolError: pr.protocolError,
-          success: pr.stopped !== true && pr.interrupted !== true && pr.exitCode === 0,
+          success: pr.stopped !== true && pr.interrupted !== true && pr.exitCode === 0 && pr.execution?.status !== "partial",
           exitCode: pr.interrupted === true ? 0 : pr.exitCode,
           skipped: pr.skipped,
           interrupted: pr.interrupted,
@@ -3810,12 +3461,14 @@ async function runSubagent(config, onWriterProcess) {
           sessionFile: pr.sessionFile,
           intercomTarget: pr.intercomTarget,
           model: pr.model,
-          attemptedModels: pr.attemptedModels,
-          modelAttempts: pr.modelAttempts,
+          thinking: pr.thinking,
+          requestedModel: pr.requestedModel,
           contextOverflow: pr.contextOverflow,
           totalCost: pr.totalCost,
           usage: pr.usage,
           artifactPaths: pr.artifactPaths,
+          outputSaveError: pr.outputSaveError,
+          artifactOutputSaveFailed: pr.artifactOutputSaveFailed,
           transcriptPath: pr.transcriptPath,
           transcriptError: pr.transcriptError,
           effects: pr.effects,
@@ -3823,6 +3476,7 @@ async function runSubagent(config, onWriterProcess) {
           review: pr.review,
           timeoutRecovery: pr.timeoutRecovery,
           structuredOutput: pr.structuredOutput,
+          structuredOutputFailed: pr.structuredOutputFailed,
           structuredOutputPath: pr.structuredOutputPath,
           structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
           acceptance: pr.acceptance,
@@ -3835,7 +3489,7 @@ async function runSubagent(config, onWriterProcess) {
       refreshUsageBudget();
       const collection = collectDynamicResults(step, materialized.items, parallelResults);
       const failures = parallelResults.filter((result) => result.exitCode !== 0 && result.exitCode !== -1);
-      const acceptanceFailures = parallelResults.map((result, originalIndex) => ({ result, originalIndex, task: dynamicSteps[originalIndex] })).filter(({ result, task }) => isAgentContractV1(task?.agentContract ?? step.agentContract) && task?.gateOn === "acceptance" && result.acceptance?.status === "rejected");
+      const acceptanceFailures = parallelResults.map((result, originalIndex) => ({ result, originalIndex, task: dynamicSteps[originalIndex] })).filter(({ result, task }) => isAgentContract(task?.agentContract ?? step.agentContract) && task?.gateOn === "acceptance" && result.acceptance?.status === "rejected");
       if (acceptanceFailures.length > 0) {
         const message = acceptanceFailures.map(({ result, originalIndex }) => `Dynamic item ${originalIndex + 1} (${result.agent}, key ${materialized.items[originalIndex]?.key ?? originalIndex}) acceptance rejected: ${(result.acceptance ? acceptanceFailureMessage(result.acceptance) : undefined) ?? "acceptance rejected"}`).join(`
 `);
@@ -3863,12 +3517,12 @@ async function runSubagent(config, onWriterProcess) {
             cwd,
             signal: combinedAbortSignal([timeoutAbortController.signal, stopAbortController.signal]),
             abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? "Subagent timed out.",
-            reportOptional: isAgentContractV1(step.agentContract)
+            reportOptional: isAgentContract(step.agentContract)
           })) : undefined;
           const groupStopped = stopped || stopAbortController.signal.aborted;
           const groupTimedOut = !groupStopped && (timedOut || timeoutAbortController.signal.aborted);
           const effectiveGroupAcceptance = groupTimedOut || groupStopped ? undefined : groupAcceptance;
-          const groupAcceptanceFailure = effectiveDynamicGroupAcceptance.explicit && effectiveGroupAcceptance && (!isAgentContractV1(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
+          const groupAcceptanceFailure = effectiveDynamicGroupAcceptance.explicit && effectiveGroupAcceptance && (!isAgentContract(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
           const groupError = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? "Subagent timed out." : groupAcceptanceFailure;
           markDynamicGraphGroup(stepIndex, groupError ? groupStopped ? "stopped" : "failed" : "completed", groupError, effectiveGroupAcceptance);
           if (groupError) {
@@ -3945,14 +3599,22 @@ async function runSubagent(config, onWriterProcess) {
           break;
         }
         try {
-          worktreeSetup = createWorktrees(cwd, `${id}-s${stepIndex}`, group.parallel.length, omitUndefinedProperties({
+          worktreeSetup = await createWorktrees(cwd, `${id}-s${stepIndex}`, group.parallel.length, omitUndefinedProperties({
+            signal: setupSignal,
+            deadlineAt: config.deadlineAt,
             agents: group.parallel.map((task) => task.agent),
+            labels: group.parallel.map((task) => task.lane?.key ?? config.workflowKey ?? task.outputName ?? task.label),
+            tasks: group.parallel.map((task) => task.task),
+            provider: config.worktreeProvider,
+            baseRef: config.baseRef,
+            branchPrefix: config.worktreeBranchPrefix,
             setupHook: config.worktreeSetupHook ? omitUndefinedProperties({ hookPath: config.worktreeSetupHook, timeoutMs: config.worktreeSetupHookTimeoutMs }) : undefined,
             baseDir: config.worktreeBaseDir,
-            beforeCreate: (plannedSetup) => {
-              for (const worktree of plannedSetup.worktrees)
+            onProgress: (progress) => {
+              publishSetupUnknown(progress);
+              for (const worktree of progress.setup.worktrees)
                 setStatusWorktreeReference(requiredStatusStep(statusPayload, groupStartFlatIndex + worktree.index), worktree);
-              const pendingHandoff = writePendingParallelHandoff({
+              const pendingHandoff = writeWorktreeSetupHandoff({
                 manifestPath: parallelHandoffPath(asyncDir),
                 runId: id,
                 mode: (config.resultMode ?? statusPayload.mode) === "parallel" ? "parallel" : "chain",
@@ -3960,16 +3622,32 @@ async function runSubagent(config, onWriterProcess) {
                 cwd,
                 stepIndex,
                 flatStartIndex: groupStartFlatIndex,
-                setup: plannedSetup,
+                progress,
                 laneBindings: handoffWorkflowKey || config.lane ? [{ index: groupStartFlatIndex, taskIndex: 0, ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {}, ...handoffChildRunId ? { runId: handoffChildRunId } : {}, ...config.lane ? { lane: config.lane } : {} }] : undefined
               });
+              if (!pendingHandoff)
+                return;
               statusPayload.parallelHandoff = pendingHandoff;
               statusPayload.lastUpdate = Date.now();
               writeStatusPayload();
             }
           }));
+          if (config.deadlineAt !== undefined && Date.now() >= config.deadlineAt)
+            timeoutRunner();
+          if (setupSignal.aborted)
+            throw new Error(stopped ? stopMessage : timedOut ? timeoutMessage ?? "Subagent timed out." : "Subagent paused during worktree setup.");
         } catch (error) {
+          if (worktreeSetup)
+            await cleanupRemainingWorktree(worktreeSetup, stepIndex, groupStartFlatIndex);
+          if (config.deadlineAt !== undefined && Date.now() >= config.deadlineAt)
+            timeoutRunner();
           const setupError = error instanceof Error ? error.message : String(error);
+          if (error instanceof WorktreeSetupError)
+            publishSetupUnknown(error.snapshot);
+          for (let index = groupStartFlatIndex;index < groupStartFlatIndex + group.parallel.length; index++) {
+            if (childStopRequests.has(index))
+              markChildStopped(index);
+          }
           const failedAt = Date.now();
           markParallelGroupSetupFailure({
             statusPayload,
@@ -4099,11 +3777,9 @@ async function runSubagent(config, onWriterProcess) {
             flatIndex: fi,
             flatStepCount: Math.max(statusPayload.steps.length, 1),
             outputFile: path.join(asyncDir, `output-${fi}.log`),
-            steerInboxDir: stepSteerInboxDir(asyncDir, fi),
-            steerCapabilityPath: steerCapabilityPath(asyncDir, fi),
-            steerAckDir: steerAcksDir(asyncDir, fi),
             piPackageRoot: config.piPackageRoot,
-            piArgv1: config.piArgv1,
+            childSessions,
+            inheritedChildRuntime: config.inheritedChildRuntime,
             childIntercomTarget: config.childIntercomTargets?.[fi],
             orchestratorIntercomTarget: config.controlIntercomTarget,
             nestedRoute: config.nestedRoute,
@@ -4112,19 +3788,22 @@ async function runSubagent(config, onWriterProcess) {
             registerInterrupt: (interrupt) => registerStepInterrupt(fi, interrupt),
             registerTimeout: (interrupt) => registerStepTimeout(fi, interrupt),
             registerStop: (stop) => registerStepStop(fi, stop),
+            registerSteer: (steer) => registerStepSteer(fi, steer),
+            onSteerOutcome: (request, delivery) => applySteerDelivery(request.id, fi, delivery),
             timeoutSignal: timeoutAbortController.signal,
             stopSignal: stopAbortController.signal,
-            trackedMutationEvidenceForCompletionGuard: Boolean(worktreeSetup),
             timeoutMessage,
             stopMessage,
             toolTimeoutMs: taskForRun.toolTimeoutMs ?? config.toolTimeoutMs,
             onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking, attempt.contextLimit),
             onChildEvent: (event) => updateStepFromChildEvent(fi, event),
-            onWriterProcess,
             onExternalProcess: (process) => updateExternalProcess(fi, process),
+            prepareExternalActivity: (externalCwd, signal) => prepareExternalActivity(fi, externalCwd, signal),
+            onExternalStreamActivity: () => recordExternalStreamActivity(fi),
             onExternalJob: (externalJob) => updateExternalJob(fi, externalJob),
             skipAcceptance: () => timedOut || stopped || childStopRequests.has(fi),
-            usageBudgetExhausted: () => refreshUsageBudget()?.exhausted === true,
+            usageBudgetExhausted: continuationUsageBudgetExhausted,
+            usageBudget: config.usageBudget,
             orcaProgressTab
           }), config.deadlineAt);
           if (task.sessionFile) {
@@ -4134,7 +3813,7 @@ async function runSubagent(config, onWriterProcess) {
           const taskDuration = taskEndTime - taskStartTime;
           const childInterrupted = singleResult.interrupted === true;
           const childStopped = singleResult.stopped === true;
-          requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.exitCode === 0 ? "complete" : "failed";
+          requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
           requiredStatusStep(statusPayload, fi).endedAt = taskEndTime;
           requiredStatusStep(statusPayload, fi).durationMs = taskDuration;
           requiredStatusStep(statusPayload, fi).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
@@ -4149,8 +3828,7 @@ async function runSubagent(config, onWriterProcess) {
           setOptionalProperty(requiredStatusStep(statusPayload, fi), "sessionName", singleResult.sessionName);
           setOptionalProperty(requiredStatusStep(statusPayload, fi), "model", singleResult.model);
           setOptionalProperty(requiredStatusStep(statusPayload, fi), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, fi).thinking));
-          setOptionalProperty(requiredStatusStep(statusPayload, fi), "attemptedModels", singleResult.attemptedModels);
-          setOptionalProperty(requiredStatusStep(statusPayload, fi), "modelAttempts", singleResult.modelAttempts);
+          setOptionalProperty(requiredStatusStep(statusPayload, fi), "requestedModel", singleResult.requestedModel);
           setOptionalProperty(requiredStatusStep(statusPayload, fi), "contextOverflow", singleResult.contextOverflow);
           setOptionalProperty(requiredStatusStep(statusPayload, fi), "totalCost", singleResult.totalCost);
           if (singleResult.totalCost) {
@@ -4196,19 +3874,6 @@ async function runSubagent(config, onWriterProcess) {
           }));
           if (stopped || childStopped)
             appendTerminalChildStatusEvent(fi, taskEndTime);
-          if (singleResult.completionGuardTriggered) {
-            const event = buildControlEvent(omitUndefinedProperties({
-              from: requiredStatusStep(statusPayload, fi).activityState,
-              to: "needs_attention",
-              runId: id,
-              agent: task.agent,
-              index: fi,
-              ts: taskEndTime,
-              message: `${task.agent} completed without making edits for an implementation task`,
-              reason: "completion_guard"
-            }));
-            appendControlEvent(event);
-          }
           if (singleResult.exitCode !== 0 && failFast && !childStopped)
             aborted = true;
           return stopped || childStopped ? { ...singleResult, output: stopMessage, error: stopMessage, exitCode: 1, interrupted: false, timedOut: false, stopped: true, skipped: false } : timedOut ? { ...singleResult, output: singleResult.output || (timeoutMessage ?? "Subagent timed out."), error: singleResult.error ?? timeoutMessage ?? "Subagent timed out.", exitCode: 1, interrupted: false, timedOut: true, skipped: false } : { ...singleResult, skipped: false };
@@ -4217,7 +3882,7 @@ async function runSubagent(config, onWriterProcess) {
         for (let t = 0;t < group.parallel.length; t++) {
           const fi = groupStartFlatIndex + t;
           const sessionTokens = config.sessionDir ? parseSessionTokens(path.join(config.sessionDir, `parallel-${t}`)) : null;
-          const fallbackTokens = tokenUsageFromAttempts(parallelResults[t]?.modelAttempts);
+          const fallbackTokens = tokenUsageFromUsage(parallelResults[t]?.usage);
           const observedTokens = requiredStatusStep(statusPayload, fi).tokens;
           const taskTokens = sessionTokens ?? (fallbackTokens ? { ...fallbackTokens, ...observedTokens?.window !== undefined ? { window: observedTokens.window } : {}, ...observedTokens?.windowPeak !== undefined ? { windowPeak: observedTokens.windowPeak } : {} } : null);
           if (!taskTokens)
@@ -4244,8 +3909,7 @@ async function runSubagent(config, onWriterProcess) {
             output: pr.output,
             outputState: pr.outputState,
             error: pr.error,
-            protocolError: pr.protocolError,
-            success: pr.stopped !== true && pr.interrupted !== true && pr.exitCode === 0,
+            success: pr.stopped !== true && pr.interrupted !== true && pr.exitCode === 0 && pr.execution?.status !== "partial",
             exitCode: pr.interrupted === true ? 0 : pr.exitCode,
             skipped: pr.skipped,
             interrupted: pr.interrupted,
@@ -4256,12 +3920,14 @@ async function runSubagent(config, onWriterProcess) {
             sessionFile: pr.sessionFile,
             intercomTarget: pr.intercomTarget,
             model: pr.model,
-            attemptedModels: pr.attemptedModels,
-            modelAttempts: pr.modelAttempts,
+            thinking: pr.thinking,
+            requestedModel: pr.requestedModel,
             contextOverflow: pr.contextOverflow,
             totalCost: pr.totalCost,
             usage: pr.usage,
             artifactPaths: pr.artifactPaths,
+            outputSaveError: pr.outputSaveError,
+            artifactOutputSaveFailed: pr.artifactOutputSaveFailed,
             transcriptPath: pr.transcriptPath,
             transcriptError: pr.transcriptError,
             effects: pr.effects,
@@ -4269,6 +3935,7 @@ async function runSubagent(config, onWriterProcess) {
             review: pr.review,
             timeoutRecovery: pr.timeoutRecovery,
             structuredOutput: pr.structuredOutput,
+            structuredOutputFailed: pr.structuredOutputFailed,
             structuredOutputPath: pr.structuredOutputPath,
             structuredOutputSchemaPath: pr.structuredOutputSchemaPath,
             acceptance: pr.acceptance,
@@ -4293,66 +3960,69 @@ async function runSubagent(config, onWriterProcess) {
           exitCode: r.exitCode,
           error: r.error,
           model: r.model,
-          attemptedModels: r.attemptedModels
+          requestedModel: r.requestedModel
         })));
         if (worktreeSetup) {
-          const captured = captureParallelWorktreeDiffs(worktreeSetup, asyncDir, stepIndex, group);
-          if (captured.summary)
-            previousOutput = `${previousOutput}
+          const setup = worktreeSetup;
+          worktreeFinalized = true;
+          await finalizeWorktree(setup, stepIndex, groupStartFlatIndex, () => {
+            const captured = captureParallelWorktreeDiffs(setup, asyncDir, stepIndex, group);
+            if (captured.summary)
+              previousOutput = `${previousOutput}
 
 ${captured.summary}`;
-          worktreeFinalized = true;
-          const manifestPath = parallelHandoffPath(asyncDir);
-          const handoff = {
-            manifestPath,
-            runId: id,
-            mode: (config.resultMode ?? statusPayload.mode) === "parallel" ? "parallel" : "chain",
-            source: "async",
-            cwd,
-            stepIndex,
-            flatStartIndex: groupStartFlatIndex,
-            setup: worktreeSetup,
-            diffs: captured.diffs,
-            results: parallelResults.map((result) => ({
-              agent: result.agent,
-              ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {},
-              ...handoffChildRunId ? { runId: handoffChildRunId } : {},
-              ...config.lane ? { lane: config.lane } : {},
-              status: result.stopped || result.exitCode !== 0 && isUnexplainedProcessSignal(omitUndefinedProperties({
-                processSignal: result.processSignal,
-                interrupted: result.interrupted,
-                timedOut: result.timedOut,
-                stopped: result.stopped
-              })) ? "stopped" : result.interrupted ? "paused" : result.exitCode === 0 ? "completed" : "failed",
-              summary: result.output || result.error || "(no output)",
-              ...result.artifactPaths?.outputPath ? { outputPath: result.artifactPaths.outputPath } : {},
-              ...result.structuredOutput !== undefined ? { structuredOutput: result.structuredOutput } : {},
-              ...result.structuredOutputPath ? { structuredOutputPath: result.structuredOutputPath } : {},
-              ...result.sessionFile ? { sessionPath: result.sessionFile } : {}
-            }))
-          };
-          try {
-            writeParallelHandoffGroup(handoff);
-            const cleanup = cleanupWorktrees(worktreeSetup, { kind: "preserve", capturedDiffs: captured.diffs, handoffManifestPath: manifestPath });
-            statusPayload.parallelHandoff = writeParallelHandoffGroup({ ...handoff, cleanup });
-            previousOutput = `${previousOutput}
+            const manifestPath = parallelHandoffPath(asyncDir);
+            const handoff = {
+              manifestPath,
+              runId: id,
+              mode: (config.resultMode ?? statusPayload.mode) === "parallel" ? "parallel" : "chain",
+              source: "async",
+              cwd,
+              stepIndex,
+              flatStartIndex: groupStartFlatIndex,
+              setup,
+              diffs: captured.diffs,
+              results: parallelResults.map((result) => ({
+                agent: result.agent,
+                ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {},
+                ...handoffChildRunId ? { runId: handoffChildRunId } : {},
+                ...config.lane ? { lane: config.lane } : {},
+                status: result.stopped || result.exitCode !== 0 && isUnexplainedProcessSignal(omitUndefinedProperties({
+                  processSignal: result.processSignal,
+                  interrupted: result.interrupted,
+                  timedOut: result.timedOut,
+                  stopped: result.stopped
+                })) ? "stopped" : result.interrupted ? "paused" : result.exitCode === 0 ? "completed" : "failed",
+                summary: result.output || result.error || "(no output)",
+                ...result.artifactPaths?.outputPath ? { outputPath: result.artifactPaths.outputPath } : {},
+                ...result.structuredOutput !== undefined ? { structuredOutput: result.structuredOutput } : {},
+                ...result.structuredOutputPath ? { structuredOutputPath: result.structuredOutputPath } : {},
+                ...result.sessionFile ? { sessionPath: result.sessionFile } : {}
+              }))
+            };
+            try {
+              writeParallelHandoffGroup(handoff);
+              const cleanup = cleanupWorktrees(setup, { kind: "preserve", capturedDiffs: captured.diffs, handoffManifestPath: manifestPath });
+              statusPayload.parallelHandoff = writeParallelHandoffGroup({ ...handoff, cleanup });
+              previousOutput = `${previousOutput}
 
 ${formatParallelHandoffReference(statusPayload.parallelHandoff)}`;
-          } catch (error) {
-            previousOutput = `${previousOutput}
+            } catch (error) {
+              previousOutput = `${previousOutput}
 
 ${formatParallelHandoffError(error)}`;
-          }
-          writeStatusPayload();
+            }
+            writeStatusPayload();
+          });
         }
         appendJsonl(eventsPath, JSON.stringify({
           type: "subagent.parallel.completed",
           ts: Date.now(),
           runId: id,
           stepIndex,
-          success: parallelResults.every((r) => r.exitCode === 0 || r.exitCode === -1) && parallelResults.every((result, index) => !(isAgentContractV1(group.parallel[index]?.agentContract) && group.parallel[index]?.gateOn === "acceptance" && result.acceptance?.status === "rejected"))
+          success: parallelResults.every((r) => r.exitCode === 0 || r.exitCode === -1) && parallelResults.every((result, index) => !(isAgentContract(group.parallel[index]?.agentContract) && group.parallel[index]?.gateOn === "acceptance" && result.acceptance?.status === "rejected"))
         }));
-        const acceptanceGateFailure = parallelResults.map((result, index) => ({ result, index, task: group.parallel[index] })).find(({ result, task }) => isAgentContractV1(task?.agentContract) && task?.gateOn === "acceptance" && result.acceptance?.status === "rejected");
+        const acceptanceGateFailure = parallelResults.map((result, index) => ({ result, index, task: group.parallel[index] })).find(({ result, task }) => isAgentContract(task?.agentContract) && task?.gateOn === "acceptance" && result.acceptance?.status === "rejected");
         if (acceptanceGateFailure) {
           statusPayload.error = (acceptanceGateFailure.result.acceptance ? acceptanceFailureMessage(acceptanceGateFailure.result.acceptance) : undefined) ?? "Parallel acceptance gate rejected the step.";
           writeStatusPayload();
@@ -4363,7 +4033,7 @@ ${formatParallelHandoffError(error)}`;
         }
       } finally {
         if (worktreeSetup && !worktreeFinalized)
-          cleanupWorktrees(worktreeSetup);
+          await cleanupRemainingWorktree(worktreeSetup, stepIndex, groupStartFlatIndex);
       }
     } else {
       const seqStep = step;
@@ -4390,16 +4060,24 @@ ${formatParallelHandoffError(error)}`;
       let singleWorktreeSetup;
       if (seqStep.worktree) {
         try {
-          singleWorktreeSetup = createWorktrees(cwd, `${id}-s${stepIndex}`, 1, omitUndefinedProperties({
+          singleWorktreeSetup = await createWorktrees(cwd, `${id}-s${stepIndex}`, 1, omitUndefinedProperties({
+            signal: setupSignal,
+            deadlineAt: config.deadlineAt,
             agents: [seqStep.agent],
+            labels: [seqStep.lane?.key ?? config.workflowKey ?? seqStep.outputName ?? seqStep.label],
+            tasks: [seqStep.task],
+            provider: config.worktreeProvider,
+            baseRef: config.baseRef,
+            branchPrefix: config.worktreeBranchPrefix,
             setupHook: config.worktreeSetupHook ? omitUndefinedProperties({ hookPath: config.worktreeSetupHook, timeoutMs: config.worktreeSetupHookTimeoutMs }) : undefined,
             baseDir: config.worktreeBaseDir,
-            beforeCreate: (plannedSetup) => {
-              const worktree = plannedSetup.worktrees[0];
+            onProgress: (progress) => {
+              publishSetupUnknown(progress);
+              const worktree = progress.setup.worktrees[0];
               if (worktree) {
                 setStatusWorktreeReference(requiredStatusStep(statusPayload, flatIndex), worktree);
               }
-              const pendingHandoff = writePendingParallelHandoff({
+              const pendingHandoff = writeWorktreeSetupHandoff({
                 manifestPath: parallelHandoffPath(asyncDir),
                 runId: id,
                 mode: "single",
@@ -4407,20 +4085,46 @@ ${formatParallelHandoffError(error)}`;
                 cwd,
                 stepIndex,
                 flatStartIndex: flatIndex,
-                setup: plannedSetup,
+                progress,
                 laneBindings: handoffWorkflowKey || config.lane ? [{ index: flatIndex, taskIndex: 0, ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {}, ...handoffChildRunId ? { runId: handoffChildRunId } : {}, ...config.lane ? { lane: config.lane } : {} }] : undefined
               });
+              if (!pendingHandoff)
+                return;
               statusPayload.parallelHandoff = pendingHandoff;
               statusPayload.lastUpdate = Date.now();
               writeStatusPayload();
             }
           }));
         } catch (error) {
-          if (singleWorktreeSetup)
-            cleanupWorktrees(singleWorktreeSetup);
-          throw error;
+          if (error instanceof WorktreeSetupError)
+            publishSetupUnknown(error.snapshot);
+          if (config.deadlineAt !== undefined && Date.now() >= config.deadlineAt)
+            timeoutRunner();
+          const message = error instanceof Error ? error.message : String(error);
+          if (childStopRequests.has(flatIndex))
+            markChildStopped(flatIndex);
+          const statusStep = requiredStatusStep(statusPayload, flatIndex);
+          statusStep.status = stopped || childStopRequests.has(flatIndex) ? "stopped" : interrupted ? "paused" : "failed";
+          statusStep.error ??= message;
+          statusStep.exitCode = interrupted ? 0 : 1;
+          statusStep.endedAt = Date.now();
+          results.push(stopped ? stoppedStepResult(seqStep.agent, seqStep.context, seqStep.sessionName) : childStopRequests.has(flatIndex) ? childStopResult(flatIndex, seqStep.agent, seqStep.context) : timedOut ? timedOutStepResult(seqStep.agent, seqStep.context, seqStep.sessionName) : interrupted ? pausedStepResult(seqStep.agent, seqStep.context, seqStep.sessionName) : { agent: seqStep.agent, output: message, error: message, exitCode: 1, success: false });
+          statusPayload.error ??= message;
+          writeStatusPayload();
+          flatIndex++;
+          break;
         }
       }
+      if (singleWorktreeSetup && config.deadlineAt !== undefined && Date.now() >= config.deadlineAt)
+        timeoutRunner();
+      if (singleWorktreeSetup && (timedOut || stopped || interrupted || childStopRequests.has(flatIndex))) {
+        await cleanupRemainingWorktree(singleWorktreeSetup, stepIndex, flatIndex);
+        results.push(stopped ? stoppedStepResult(seqStep.agent, seqStep.context, seqStep.sessionName) : childStopRequests.has(flatIndex) ? childStopResult(flatIndex, seqStep.agent, seqStep.context) : timedOut ? timedOutStepResult(seqStep.agent, seqStep.context, seqStep.sessionName) : pausedStepResult(seqStep.agent, seqStep.context, seqStep.sessionName));
+        if (interrupted)
+          requiredStatusStep(statusPayload, flatIndex).status = "paused";
+        flatIndex++;
+        continue;
+      }
       const singleCwd = singleWorktreeSetup?.worktrees[0]?.agentCwd ?? cwd;
       const stepStartTime = Date.now();
       statusPayload.currentStep = flatIndex;
@@ -4443,7 +4147,7 @@ ${formatParallelHandoffError(error)}`;
         agent: seqStep.agent
       }));
       flushPendingStepSteers(flatIndex);
-      const executionStep = singleWorktreeSetup ? { ...seqStep, cwd: singleCwd } : seqStep;
+      const executionStep = singleWorktreeSetup ? bindWorktreeCwd({ ...seqStep, cwd: singleCwd }, singleCwd) : seqStep;
       let singleResult;
       try {
         singleResult = await runSingleStepWithTimeout(executionStep, compactOptional({
@@ -4459,11 +4163,9 @@ ${formatParallelHandoffError(error)}`;
           flatIndex,
           flatStepCount: Math.max(statusPayload.steps.length, 1),
           outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
-          steerInboxDir: stepSteerInboxDir(asyncDir, flatIndex),
-          steerCapabilityPath: steerCapabilityPath(asyncDir, flatIndex),
-          steerAckDir: steerAcksDir(asyncDir, flatIndex),
           piPackageRoot: config.piPackageRoot,
-          piArgv1: config.piArgv1,
+          childSessions,
+          inheritedChildRuntime: config.inheritedChildRuntime,
           childIntercomTarget: config.childIntercomTargets?.[flatIndex],
           orchestratorIntercomTarget: config.controlIntercomTarget,
           nestedRoute: config.nestedRoute,
@@ -4472,6 +4174,8 @@ ${formatParallelHandoffError(error)}`;
           registerInterrupt: (interrupt) => registerStepInterrupt(flatIndex, interrupt),
           registerTimeout: (interrupt) => registerStepTimeout(flatIndex, interrupt),
           registerStop: (stop) => registerStepStop(flatIndex, stop),
+          registerSteer: (steer) => registerStepSteer(flatIndex, steer),
+          onSteerOutcome: (request, delivery) => applySteerDelivery(request.id, flatIndex, delivery),
           timeoutSignal: timeoutAbortController.signal,
           stopSignal: stopAbortController.signal,
           timeoutMessage,
@@ -4479,16 +4183,18 @@ ${formatParallelHandoffError(error)}`;
           toolTimeoutMs: seqStep.toolTimeoutMs ?? config.toolTimeoutMs,
           onAttemptStart: (attempt) => updateStepModel(flatIndex, attempt.model, attempt.thinking, attempt.contextLimit),
           onChildEvent: (event) => updateStepFromChildEvent(flatIndex, event),
-          onWriterProcess,
           onExternalProcess: (process) => updateExternalProcess(flatIndex, process),
+          prepareExternalActivity: (externalCwd, signal) => prepareExternalActivity(flatIndex, externalCwd, signal),
+          onExternalStreamActivity: () => recordExternalStreamActivity(flatIndex),
           onExternalJob: (externalJob) => updateExternalJob(flatIndex, externalJob),
           skipAcceptance: () => timedOut || stopped || childStopRequests.has(flatIndex),
-          usageBudgetExhausted: () => refreshUsageBudget()?.exhausted === true,
+          usageBudgetExhausted: continuationUsageBudgetExhausted,
+          usageBudget: config.usageBudget,
           orcaProgressTab
         }), config.deadlineAt);
       } catch (error) {
         if (singleWorktreeSetup)
-          cleanupWorktrees(singleWorktreeSetup);
+          await cleanupRemainingWorktree(singleWorktreeSetup, stepIndex, flatIndex);
         throw error;
       }
       if (seqStep.sessionFile) {
@@ -4507,18 +4213,20 @@ ${formatParallelHandoffError(error)}`;
         output: stopped || childStopped ? stopMessage : timedOut ? singleResult.output || (timeoutMessage ?? "Subagent timed out.") : singleResult.output,
         outputState: singleResult.outputState,
         error: stopped || childStopped ? stopMessage : timedOut ? timeoutMessage ?? "Subagent timed out." : singleResult.error,
-        protocolError: singleResult.protocolError,
-        success: !stopped && !childStopped && !timedOut && singleResult.interrupted !== true && singleResult.exitCode === 0,
+        success: !stopped && !childStopped && !timedOut && singleResult.interrupted !== true && singleResult.exitCode === 0 && singleResult.execution?.status !== "partial",
         exitCode: stopped || childStopped ? 1 : timedOut ? 1 : singleResult.interrupted === true ? 0 : singleResult.exitCode,
         sessionFile: singleResult.sessionFile,
         intercomTarget: singleResult.intercomTarget,
         model: singleResult.model,
-        attemptedModels: singleResult.attemptedModels,
-        modelAttempts: singleResult.modelAttempts,
+        thinking: singleResult.thinking,
+        requestedModel: singleResult.requestedModel,
         contextOverflow: singleResult.contextOverflow,
         totalCost: singleResult.totalCost,
         usage: singleResult.usage,
         artifactPaths: singleResult.artifactPaths,
+        savedOutputPath: singleResult.savedOutputPath,
+        outputSaveError: singleResult.outputSaveError,
+        artifactOutputSaveFailed: singleResult.artifactOutputSaveFailed,
         transcriptPath: singleResult.transcriptPath,
         transcriptError: singleResult.transcriptError,
         effects: singleResult.effects,
@@ -4526,6 +4234,7 @@ ${formatParallelHandoffError(error)}`;
         review: singleResult.review,
         timeoutRecovery: singleResult.timeoutRecovery,
         structuredOutput: singleResult.structuredOutput,
+        structuredOutputFailed: singleResult.structuredOutputFailed,
         structuredOutputPath: singleResult.structuredOutputPath,
         structuredOutputSchemaPath: singleResult.structuredOutputSchemaPath,
         acceptance: singleResult.acceptance,
@@ -4560,7 +4269,7 @@ ${formatParallelHandoffError(error)}`;
       if (cumulativeTokens) {
         previousCumulativeTokens = cumulativeTokens;
       } else {
-        const fallbackTokens = tokenUsageFromAttempts(singleResult.modelAttempts);
+        const fallbackTokens = tokenUsageFromUsage(singleResult.usage);
         const observedTokens = requiredStatusStep(statusPayload, flatIndex).tokens;
         stepTokens = fallbackTokens ? { ...fallbackTokens, ...observedTokens?.window !== undefined ? { window: observedTokens.window } : {}, ...observedTokens?.windowPeak !== undefined ? { windowPeak: observedTokens.windowPeak } : {} } : null;
         if (stepTokens) {
@@ -4575,7 +4284,7 @@ ${formatParallelHandoffError(error)}`;
       }
       const stepEndTime = Date.now();
       const childInterrupted = singleResult.interrupted === true;
-      requiredStatusStep(statusPayload, flatIndex).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.exitCode === 0 ? "complete" : "failed";
+      requiredStatusStep(statusPayload, flatIndex).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
       requiredStatusStep(statusPayload, flatIndex).endedAt = stepEndTime;
       requiredStatusStep(statusPayload, flatIndex).durationMs = stepEndTime - stepStartTime;
       requiredStatusStep(statusPayload, flatIndex).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
@@ -4590,8 +4299,7 @@ ${formatParallelHandoffError(error)}`;
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "sessionName", singleResult.sessionName);
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "model", singleResult.model);
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, flatIndex).thinking));
-      setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "attemptedModels", singleResult.attemptedModels);
-      setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "modelAttempts", singleResult.modelAttempts);
+      setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "requestedModel", singleResult.requestedModel);
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "contextOverflow", singleResult.contextOverflow);
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "totalCost", singleResult.totalCost);
       setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "error", stopped || childStopped ? stopMessage : timedOut ? timeoutMessage ?? "Subagent timed out." : singleResult.error);
@@ -4635,66 +4343,56 @@ ${formatParallelHandoffError(error)}`;
       if (stopped || childStopped)
         appendTerminalChildStatusEvent(flatIndex, stepEndTime);
       if (singleWorktreeSetup && !singleResult.detached) {
-        const diffs = diffWorktrees(singleWorktreeSetup, [seqStep.agent], path.join(asyncDir, "worktree-diffs", `step-${stepIndex}`));
-        const diffSummary = formatWorktreeDiffSummary(diffs);
-        const manifestPath = parallelHandoffPath(asyncDir);
-        const handoff = {
-          manifestPath,
-          runId: id,
-          mode: "single",
-          source: "async",
-          cwd,
-          stepIndex,
-          flatStartIndex: flatIndex,
-          setup: singleWorktreeSetup,
-          diffs,
-          results: [{
-            agent: singleResult.agent,
-            ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {},
-            ...handoffChildRunId ? { runId: handoffChildRunId } : {},
-            ...config.lane ? { lane: config.lane } : {},
-            status: singleResult.stopped ? "stopped" : singleResult.interrupted ? "paused" : singleResult.exitCode === 0 ? "completed" : "failed",
-            summary: singleResult.output || singleResult.error || "(no output)",
-            ...singleResult.artifactPaths?.outputPath ? { outputPath: singleResult.artifactPaths.outputPath } : {},
-            ...singleResult.structuredOutput !== undefined ? { structuredOutput: singleResult.structuredOutput } : {},
-            ...singleResult.structuredOutputPath ? { structuredOutputPath: singleResult.structuredOutputPath } : {},
-            ...singleResult.sessionFile ? { sessionPath: singleResult.sessionFile } : {}
-          }]
-        };
-        try {
-          writeParallelHandoffGroup(handoff);
-          const cleanup = cleanupWorktrees(singleWorktreeSetup, {
-            kind: "preserve",
-            capturedDiffs: diffs,
-            handoffManifestPath: manifestPath,
-            ...config.parentWorkflowRunId && singleResult.sessionFile && fs.existsSync(singleResult.sessionFile) && !singleResult.stopped ? { cleanupBlocker: "retained child resume requires managed worktree cwd" } : {}
-          });
-          statusPayload.parallelHandoff = writeParallelHandoffGroup({ ...handoff, cleanup });
-          previousOutput = [previousOutput, diffSummary, formatParallelHandoffReference(statusPayload.parallelHandoff)].filter(Boolean).join(`
+        const setup = singleWorktreeSetup;
+        await finalizeWorktree(setup, stepIndex, flatIndex, () => {
+          const diffs = diffWorktrees(setup, [seqStep.agent], path.join(asyncDir, "worktree-diffs", `step-${stepIndex}`));
+          const diffSummary = formatWorktreeDiffSummary(diffs);
+          const manifestPath = parallelHandoffPath(asyncDir);
+          const handoff = {
+            manifestPath,
+            runId: id,
+            mode: "single",
+            source: "async",
+            cwd,
+            stepIndex,
+            flatStartIndex: flatIndex,
+            setup,
+            diffs,
+            results: [{
+              agent: singleResult.agent,
+              ...handoffWorkflowKey ? { workflowKey: handoffWorkflowKey } : {},
+              ...handoffChildRunId ? { runId: handoffChildRunId } : {},
+              ...config.lane ? { lane: config.lane } : {},
+              status: singleResult.stopped ? "stopped" : singleResult.interrupted ? "paused" : singleResult.exitCode === 0 ? "completed" : "failed",
+              summary: singleResult.output || singleResult.error || "(no output)",
+              ...singleResult.artifactPaths?.outputPath ? { outputPath: singleResult.artifactPaths.outputPath } : {},
+              ...singleResult.structuredOutput !== undefined ? { structuredOutput: singleResult.structuredOutput } : {},
+              ...singleResult.structuredOutputPath ? { structuredOutputPath: singleResult.structuredOutputPath } : {},
+              ...singleResult.sessionFile ? { sessionPath: singleResult.sessionFile } : {}
+            }]
+          };
+          try {
+            writeParallelHandoffGroup(handoff);
+            const cleanup = cleanupWorktrees(setup, {
+              kind: "preserve",
+              capturedDiffs: diffs,
+              handoffManifestPath: manifestPath,
+              ...config.parentWorkflowRunId && singleResult.sessionFile && fs.existsSync(singleResult.sessionFile) && !singleResult.stopped ? { cleanupBlocker: "retained child resume requires managed worktree cwd" } : {}
+            });
+            statusPayload.parallelHandoff = writeParallelHandoffGroup({ ...handoff, cleanup });
+            previousOutput = [previousOutput, diffSummary, formatParallelHandoffReference(statusPayload.parallelHandoff)].filter(Boolean).join(`
 
 `);
-        } catch (error) {
-          previousOutput = [previousOutput, diffSummary, formatParallelHandoffError(error)].filter(Boolean).join(`
+          } catch (error) {
+            previousOutput = [previousOutput, diffSummary, formatParallelHandoffError(error)].filter(Boolean).join(`
 
 `);
-        }
-        writeStatusPayload();
-      }
-      if (singleResult.completionGuardTriggered) {
-        const event = buildControlEvent(omitUndefinedProperties({
-          from: requiredStatusStep(statusPayload, flatIndex).activityState,
-          to: "needs_attention",
-          runId: id,
-          agent: seqStep.agent,
-          index: flatIndex,
-          ts: stepEndTime,
-          message: `${seqStep.agent} completed without making edits for an implementation task`,
-          reason: "completion_guard"
-        }));
-        appendControlEvent(event);
+          }
+          writeStatusPayload();
+        });
       }
       flatIndex++;
-      if (isAgentContractV1(seqStep.agentContract) && seqStep.gateOn === "acceptance" && singleResult.acceptance?.status === "rejected") {
+      if (isAgentContract(seqStep.agentContract) && seqStep.gateOn === "acceptance" && singleResult.acceptance?.status === "rejected") {
         statusPayload.error = acceptanceFailureMessage(singleResult.acceptance) ?? "Chain acceptance gate rejected the step.";
         writeStatusPayload();
         break;
@@ -4704,6 +4402,33 @@ ${formatParallelHandoffError(error)}`;
       }
     }
   }
+  await Promise.all([...externalActivityEvidence.values()].map((evidence) => evidence.probeInFlight).filter((probe) => probe !== undefined));
+  if (periodicGitProbeFailure) {
+    stopped = false;
+    timedOut = false;
+    interrupted = false;
+    delete statusPayload.stopped;
+    delete statusPayload.timedOut;
+    statusPayload.error = periodicGitProbeFailure.message;
+    const step = statusPayload.steps[periodicGitProbeFailure.index];
+    if (step) {
+      step.status = "failed";
+      step.error = periodicGitProbeFailure.message;
+      step.exitCode = 1;
+      delete step.stopped;
+      delete step.timedOut;
+    }
+    const result = results[periodicGitProbeFailure.index];
+    if (result) {
+      result.success = false;
+      result.exitCode = 1;
+      result.error = periodicGitProbeFailure.message;
+      result.output = periodicGitProbeFailure.message;
+      result.stopped = false;
+      result.timedOut = false;
+      result.interrupted = false;
+    }
+  }
   let summary = results.map((r) => `${r.agent}:
 ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(`
 
@@ -4763,9 +4488,16 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
     clearTimeout(timeoutTimer);
     timeoutTimer = undefined;
   }
-  if (!timedOut && !stopped && !interrupted && config.timeoutMs !== undefined && results.some((result) => result.timedOut === true && result.error === timeoutMessage)) {
+  if (checkpointTimer) {
+    clearTimeout(checkpointTimer);
+    checkpointTimer = undefined;
+  }
+  if (!timedOut && !stopped && !interrupted && config.timeoutMs !== undefined && timeoutMessage !== undefined && results.some((result) => result.timedOut === true && result.error?.startsWith(timeoutMessage))) {
     timedOut = true;
   }
+  disposeControlInbox();
+  for (const request of consumeStopRequestPayloads(asyncDir))
+    stopChildStep(request);
   const signalTerminated = !stopped && !timedOut && !interrupted && results.some((result) => result.exitCode !== 0 && isUnexplainedProcessSignal(omitUndefinedProperties({
     processSignal: result.processSignal,
     interrupted: result.interrupted,
@@ -4773,9 +4505,12 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
     stopped: result.stopped
   })));
   const partialWithEvidence = !stopped && !signalTerminated && !timedOut && !usageBudgetExceeded && !interrupted && results.some(partialEvidenceResult) && !results.some(concreteFailureResult);
+  statusWriteCoalescer.flush(statusPath);
+  const publication = new Promise((resolve, reject) => {
+    finalResultPublication = { resolve, reject };
+  });
   statusPayload.state = stopped || signalTerminated ? "stopped" : timedOut || usageBudgetExceeded ? "failed" : interrupted ? "paused" : results.every((r) => r.success) ? "complete" : partialWithEvidence ? "partial" : "failed";
   closeSteerInbox(asyncDir, statusPayload.state, (filePath, payload) => runPersistence.write(filePath, payload));
-  disposeControlInbox();
   for (const request of consumeSteerRequests(asyncDir))
     deliverSteerRequest(request);
   const effectiveSessionFile = sessionFile ?? latestSessionFile;
@@ -4786,7 +4521,7 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
       if (target.state !== "scheduled" && target.state !== "routed" && target.state !== "queued")
         continue;
       changed = true;
-      const reason = target.state === "queued" ? "run ended before queued follow-up delivery" : "child terminated before steering delivery";
+      const reason = target.state === "queued" ? unconsumedSteerReason() : "child terminated before steering delivery";
       updateSteeringLifecycleTarget(request.id, target.index, "failed", Date.now(), { reason });
       markSteeringAttention(target.index);
       emitSteeringEvent("subagent.steer.failed", { type: "steer", id: request.id, ts: request.requestedAt, message: reason }, target.index, { reason });
@@ -4814,7 +4549,7 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
     statusPayload.activityState = "needs_attention";
     statusPayload.error = partialResult?.error ?? statusPayload.error;
     for (const step of statusPayload.steps) {
-      if (step.status === "failed")
+      if (step.status === "failed" || step.status === "partial")
         step.activityState = "needs_attention";
     }
   }
@@ -4837,7 +4572,8 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
       statusPayload.error = `Step failed: ${failedStep.agent}`;
     }
   }
-  writeStatusPayload();
+  let childSessionDisposal;
+  const disposeChildSessions = () => childSessionDisposal ??= childSessions.dispose().catch((error) => console.error("Failed to dispose runner child sessions:", error));
   try {
     runPersistence.write(resultPath, {
       lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
@@ -4860,7 +4596,6 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
         output: r.output,
         outputState: r.outputState,
         error: r.error,
-        protocolError: r.protocolError,
         success: r.success,
         skipped: r.skipped || undefined,
         interrupted: r.interrupted || undefined,
@@ -4872,13 +4607,15 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
         sessionFile: r.sessionFile,
         intercomTarget: r.intercomTarget,
         model: r.model,
-        attemptedModels: r.attemptedModels,
-        modelAttempts: r.modelAttempts,
+        thinking: r.thinking,
+        requestedModel: r.requestedModel,
         contextOverflow: r.contextOverflow,
         totalCost: r.totalCost,
         usage: r.usage,
         artifactPaths: r.artifactPaths,
+        savedOutputPath: r.savedOutputPath,
         outputSaveError: r.outputSaveError,
+        artifactOutputSaveFailed: r.artifactOutputSaveFailed,
         metadataSaveError: r.metadataSaveError,
         truncated: r.truncated,
         transcriptPath: r.transcriptPath,
@@ -4894,6 +4631,7 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
         review: r.review,
         effects: r.effects,
         structuredOutput: r.structuredOutput,
+        structuredOutputFailed: r.structuredOutputFailed,
         structuredOutputPath: r.structuredOutputPath,
         structuredOutputSchemaPath: r.structuredOutputSchemaPath,
         acceptance: r.acceptance,
@@ -4934,16 +4672,19 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
     }, (filePath, payload) => {
       writeAsyncResultFile(filePath, payload);
     });
-    finalResultCommitted = true;
+    if (!finalResultCommitted)
+      await Promise.all([publication, disposeChildSessions()]);
   } catch (err) {
     const message = `Failed to write result file ${resultPath}: ${err instanceof Error ? err.message : String(err)}`;
     console.error(message, err);
     statusPayload.state = "failed";
     statusPayload.error = message;
     statusPayload.lastUpdate = Date.now();
+  } finally {
+    finalResultPublication = undefined;
   }
   writeStatusPayload();
-  orcaProgressTab?.finish(statusPayload.state === "complete" ? "completed" : statusPayload.state === "stopped" ? "stopped" : "failed", effectiveSessionFile);
+  await orcaProgressTab?.finish(statusPayload.state === "complete" ? "completed" : statusPayload.state === "stopped" ? "stopped" : "failed", effectiveSessionFile);
   appendJsonl(eventsPath, JSON.stringify({
     type: "subagent.run.completed",
     lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
@@ -4975,16 +4716,18 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
   }), (filePath, content) => runPersistence.write(filePath, { content }, (_path, payload) => {
     fs.writeFileSync(_path, payload.content, "utf-8");
   }));
-  if (runPersistence.pendingCount() === 0)
-    runPersistence.dispose();
-  if (indexPersistence.pendingCount() === 0)
-    indexPersistence.dispose();
+  await disposeChildSessions();
+  while (runPersistence.pendingCount() + indexPersistence.pendingCount() > 0) {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  runPersistence.dispose();
+  indexPersistence.dispose();
   if (config.runnerProcessInstanceId) {
     const writers = {};
     const expectedWriters = {};
-    for (const [index, result] of results.entries()) {
-      writers[String(index)] = result.writerProcesses ?? [];
-      expectedWriters[String(index)] = result.writerAttemptCount ?? 0;
+    for (const index of results.keys()) {
+      writers[String(index)] = [];
+      expectedWriters[String(index)] = 0;
     }
     const candidate = {
       version: 1,
@@ -5002,117 +4745,38 @@ ${r.output || (r.exitCode !== 0 ? r.error : undefined) || "(no output)"}`).join(
     }
   }
 }
-async function waitForStartupControl(controlPath, token, action, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() <= deadline) {
-    if (fs.existsSync(controlPath)) {
-      let payload;
-      try {
-        payload = JSON.parse(fs.readFileSync(controlPath, "utf-8"));
-      } catch (error) {
-        throw new Error(`Failed to read runner startup control '${controlPath}': ${error instanceof Error ? error.message : String(error)}`);
-      }
-      if (payload.token !== token)
-        throw new Error("Runner startup control token does not match.");
-      if (payload.action === action)
-        return;
-      if (payload.action !== "ack" && payload.action !== "proceed")
-        throw new Error("Runner startup control action is invalid.");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 20));
-  }
-  throw new Error(`Timed out after ${timeoutMs}ms waiting for runner startup control '${action}'.`);
-}
-async function runConfiguredSubagent(config) {
-  let lease;
-  let startupCommitted = config.revivalLease === undefined && config.launchBarrierToken === undefined;
-  const startupPath = path.join(config.asyncDir, "runner-startup.json");
-  const startupAckPath = path.join(config.asyncDir, "runner-startup-ack.json");
-  const startupProceedPath = path.join(config.asyncDir, "runner-startup-proceed.json");
-  const releaseOnExit = () => {
-    try {
-      lease?.release();
-    } catch {}
-  };
-  process.once("exit", releaseOnExit);
+export async function runConfiguredSubagentExecution(config, options) {
+  let childSessions;
   try {
-    if (config.launchBarrierToken) {
-      await waitForStartupControl(startupProceedPath, config.launchBarrierToken, "proceed");
-      startupCommitted = true;
-      try {
-        fs.rmSync(startupProceedPath, { force: true });
-      } catch {}
-    } else if (config.revivalLease) {
-      lease = acquireSessionLease(config.revivalLease);
-      config.revivalLeaseToken = lease.owner.token;
-      writeAtomicJson(startupPath, { state: "ready", token: lease.owner.token, pid: process.pid, owner: lease.owner });
-      await waitForStartupControl(startupAckPath, lease.owner.token, "ack");
-      writeAtomicJson(startupPath, { state: "acknowledged", token: lease.owner.token, pid: process.pid });
-      await waitForStartupControl(startupProceedPath, lease.owner.token, "proceed");
-      startupCommitted = true;
-      for (const controlPath of [startupAckPath, startupProceedPath]) {
-        try {
-          fs.rmSync(controlPath, { force: true });
-        } catch {}
-      }
-    }
-    await runSubagent(config, lease ? (writer) => lease.updateWriter(writer) : undefined);
+    if (!options?.loadPiCodingAgent)
+      installRunnerHttpDispatcher({ agentDir: getAgentDir(), cwd: process.cwd() });
+    childSessions = await loadRunnerChildSessionFactory(config, options);
   } catch (error) {
-    if (!startupCommitted) {
-      try {
-        writeAtomicJson(startupPath, { state: "error", pid: process.pid, error: error instanceof Error ? error.message : String(error) });
-      } catch {}
+    try {
+      persistRunnerStartupFailure({
+        asyncDir: config.asyncDir,
+        runId: config.id,
+        runnerProcessInstanceId: config.runnerProcessInstanceId ?? "unknown-runner-instance",
+        message: `Subagent runner startup failed: ${error instanceof Error ? error.message : String(error)}`,
+        ...config.sessionId ? { sessionId: config.sessionId } : {},
+        ...config.completionOwnerId ? { completionOwnerId: config.completionOwnerId } : {},
+        candidate: {
+          ...config.revivalLease?.sessionFile ? { sessionFile: config.revivalLease.sessionFile } : {},
+          ...config.revivalLeaseToken ? { revivalLeaseToken: config.revivalLeaseToken } : {}
+        }
+      });
+    } catch (persistenceError) {
+      console.error("Failed to persist runner setup failure:", persistenceError);
     }
     throw error;
-  } finally {
-    process.off("exit", releaseOnExit);
-    if (lease) {
-      let acknowledged = false;
-      try {
-        acknowledged = lease.release();
-      } catch (error) {
-        console.error("Failed to release session revival lease:", error);
-      }
-      try {
-        markProcessTerminalCandidateLeaseRelease(config.asyncDir, lease.owner.token, acknowledged);
-      } catch (error) {
-        console.error("Failed to record session revival lease release:", error);
-      }
-    }
   }
-}
-function startConfiguredSubagent(config) {
-  runConfiguredSubagent(config).catch((runErr) => {
-    console.error("Subagent runner error:", runErr);
-    process.exit(1);
-  });
-}
-const configArg = process.argv[2];
-if (configArg) {
   try {
-    const configJson = fs.readFileSync(configArg, "utf-8");
-    const config = JSON.parse(configJson);
-    try {
-      fs.unlinkSync(configArg);
-    } catch {}
-    startConfiguredSubagent(config);
-  } catch (err) {
-    console.error("Subagent runner error:", err);
-    process.exit(1);
-  }
-} else {
-  let input = "";
-  process.stdin.setEncoding("utf-8");
-  process.stdin.on("data", (chunk) => {
-    input += chunk;
-  });
-  process.stdin.on("end", () => {
+    await runSubagent(config, childSessions);
+  } finally {
     try {
-      const config = JSON.parse(input);
-      startConfiguredSubagent(config);
-    } catch (err) {
-      console.error("Subagent runner error:", err);
-      process.exit(1);
+      await childSessions.dispose();
+    } catch (error) {
+      console.error("Failed to dispose runner child sessions:", error);
     }
-  });
+  }
 }