@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-subagents/src/runs/foreground/execution.js

@@ -1,9 +1,8 @@
-import { spawn } from "node:child_process";
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import { discoverAgents, formatUnknownAgentError, unknownAgentDiagnosticContext } from "../../agents/agents.js";
-import { appendAgentRefinementOverlay } from "../../agents/agent-refinements.js";
-import { alignForkedSessionCwd } from "../../shared/fork-context.js";
+import { alignForkedSessionCwd } from "../../shared/fork-session-cwd.js";
+import { buildEffectiveSystemPrompt } from "../shared/effective-system-prompt.js";
 import {
   ensureArtifactsDir,
   formatOutputArtifactContent,
@@ -16,8 +15,7 @@ import {
   DEFAULT_MAX_OUTPUT,
   INTERCOM_DETACH_REQUEST_EVENT,
   INTERCOM_DETACH_RESPONSE_EVENT,
-  truncateOutput,
-  getSubagentDepthEnv
+  truncateOutput
 } from "../../shared/types.js";
 import {
   DEFAULT_CONTROL_CONFIG,
@@ -35,50 +33,34 @@ import {
   formatEmptyTerminalAssistantResponseError,
   extractToolArgsPreview,
   extractTextFromContent,
+  MAX_STREAMED_RECENT_TOOLS,
   boundStreamedRecentTools,
   boundStreamedRecentOutput,
   boundStreamedToolCalls
 } from "../../shared/utils.js";
-import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.js";
-import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
+import { resolveSkillsWithFallback } from "../../agents/skills.js";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, resolveToolTimeoutMs, toolTimeoutCallKey, toolTimeoutFromEnv } from "../shared/tool-timeout.js";
-import { evaluateCompletionMutationGuard, expectsImplementationMutation, hasMutationToolCapability, validateImplementationToolContract } from "../shared/completion-guard.js";
-import { planCompletionEvidence } from "../shared/completion-evidence.js";
-import { planAbortRecovery } from "../shared/abort-recovery.js";
-import { arbitrateCompletionGuardRescue } from "../shared/llm-intent-arbiter.js";
-import { getPiSpawnCommand } from "../shared/dm-spawn.js";
 import { preflightLaunchCwd } from "../shared/launch-cwd.js";
 import { createJsonlWriter } from "../../shared/jsonl-writer.js";
 import { createOrcaProgressTab } from "../shared/orca-progress-tabs.js";
-import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.js";
 import { resolvePermissionRules } from "../shared/permissions.js";
-import { applyThinkingSuffix, buildPiArgs, cleanupTempDir, deriveForkPromptCacheKey, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/dm-args.js";
+import { applyThinkingSuffix, deriveForkPromptCacheKey } from "../shared/child-tool-plan.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
-import { readRuntimeAcknowledgedExtensions } from "../shared/runtime-acknowledged-extensions.js";
-import { assertAgentAllowedByCapabilityCeiling, decodeSubagentCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling, SUBAGENT_CAPABILITY_CEILING_ENV } from "../shared/capability-ceiling.js";
+import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { resolveEffectiveThinking } from "../../shared/model-info.js";
-import { assertThinkingWithinCeiling, decodeThinkingCeiling, intersectThinkingCeilings, SUBAGENT_THINKING_CEILING_ENV } from "../../shared/thinking-ceiling.js";
-import { 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 { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
+import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.js";
+import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.js";
+import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
+import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
+import { planAbortRecovery } from "../shared/abort-recovery.js";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.js";
-import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import {
-  buildModelCandidates,
   formatSubagentModelVerificationError,
-  formatModelAttemptNote,
   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";
+  resolveModelSelection
+} from "../shared/model-resolution.js";
 import {
   createMutatingFailureState,
   didMutatingToolFail,
@@ -90,20 +72,24 @@ import {
   shouldEscalateMutatingFailures,
   summarizeRecentMutatingFailures
 } from "../shared/long-running-guard.js";
-import { acceptanceFailureMessage, buildSkippedAcceptanceLedger, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport, validateAcceptanceInput } from "../shared/acceptance.js";
+import { acceptanceFailureMessage, buildSkippedAcceptanceLedger, captureStagedIndexBaseline, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport, validateAcceptanceInput, typedVerifyOutput } from "../shared/acceptance.js";
 import { PROMPT_REDACTED } from "../../shared/utils.js";
-import { attachContractProjections, isAgentContractV1 } from "../shared/agent-contract.js";
-import { initialToolBudgetState, toolBudgetState } from "../shared/tool-budget.js";
+import { attachContractProjections, isAgentContract } from "../shared/agent-contract.js";
+import { initialToolBudgetState, isToolBudgetBlockedMessage, toolBudgetState } from "../shared/tool-budget.js";
 import { resolveWatchdogConfig } from "../../watchdog/settings.js";
-import { agentDefinitionDigest, launchBindingDigest } from "../../shared/launch-contract.js";
+import { resolveLaunchBinding } from "../../shared/launch-contract.js";
 import { consumeWorkflowChildPermit } from "../../shared/workflow-child-permit.js";
-import { createBoundedByteTail, createBoundedLineReader, formatProtocolOutputLimit, MAX_CHILD_STDERR_BYTES, PI_AGGREGATE_EVENT_PROJECTOR, projectChildLifecycle } from "../shared/child-protocol.js";
+import { projectChildLifecycle } from "../shared/child-lifecycle.js";
 import {
   acceptChildWatchdogEvent,
+  applyChildWatchdogMessage,
   childWatchdogIsActive,
   isChildWatchdogStatusEvent,
   resolveChildWatchdogConfig
 } from "../../watchdog/child-status.js";
+import { buildInProcessChildLaunch, createReportedChildSessionInput } from "../shared/child-launch.js";
+import { childSessionFactory, childSessionHasQueuedMessages, projectChildSessionEventForJson } from "../shared/child-session.js";
+import { reconcileAttemptUsage } from "../shared/usage-reconciliation.js";
 const artifactOutputByResult = new WeakMap;
 const acceptanceOutputByResult = new WeakMap;
 function emptyUsage() {
@@ -141,8 +127,7 @@ function persistSingleResultMetadata(input) {
     processSignal: target.processSignal,
     usage: target.usage,
     model: target.model,
-    attemptedModels: target.attemptedModels,
-    modelAttempts: target.modelAttempts,
+    requestedModel: target.requestedModel,
     durationMs: target.progressSummary?.durationMs,
     toolCount: target.progressSummary?.toolCount,
     error: target.error,
@@ -237,11 +222,6 @@ function snapshotResult(result, progress) {
     messages: result.outputMode === "file-only" && result.savedOutputPath ? undefined : result.messages ? [...result.messages] : undefined,
     usage: { ...result.usage },
     skills: result.skills ? [...result.skills] : undefined,
-    attemptedModels: result.attemptedModels ? [...result.attemptedModels] : undefined,
-    modelAttempts: result.modelAttempts ? result.modelAttempts.map((attempt) => ({
-      ...attempt,
-      usage: attempt.usage ? { ...attempt.usage } : undefined
-    })) : undefined,
     controlEvents: result.controlEvents ? result.controlEvents.map((event) => ({ ...event })) : undefined,
     progress,
     progressSummary: result.progressSummary ? { ...result.progressSummary } : undefined,
@@ -256,6 +236,41 @@ function snapshotStreamResult(result, progress) {
   snapshot.toolCalls = boundStreamedToolCalls(result);
   return snapshot;
 }
+function captureStructuredDelegationProgressState(progress, result) {
+  return {
+    currentTool: progress.currentTool,
+    currentToolArgs: progress.currentToolArgs,
+    recentOutput: [...progress.recentOutput],
+    recentTools: progress.recentTools.slice(-MAX_STREAMED_RECENT_TOOLS).map(({ tool, args }) => ({ tool, args })),
+    activityState: progress.activityState,
+    model: progress.model ?? result.model,
+    toolCount: progress.toolCount,
+    tokens: progress.tokens,
+    turnCount: progress.turnCount
+  };
+}
+function structuredDelegationProgressChanged(previous, progress, result) {
+  if (previous.currentTool !== progress.currentTool || previous.currentToolArgs !== progress.currentToolArgs || previous.activityState !== progress.activityState || previous.model !== (progress.model ?? result.model) || previous.toolCount !== progress.toolCount || previous.tokens !== progress.tokens || previous.turnCount !== progress.turnCount || previous.recentOutput.length !== progress.recentOutput.length)
+    return true;
+  for (let index = 0;index < progress.recentOutput.length; index++) {
+    if (previous.recentOutput[index] !== progress.recentOutput[index])
+      return true;
+  }
+  const recentToolsStart = Math.max(0, progress.recentTools.length - MAX_STREAMED_RECENT_TOOLS);
+  if (previous.recentTools.length !== progress.recentTools.length - recentToolsStart)
+    return true;
+  for (let index = recentToolsStart;index < progress.recentTools.length; index++) {
+    const previousTool = previous.recentTools[index - recentToolsStart];
+    const currentTool = progress.recentTools[index];
+    if (previousTool?.tool !== currentTool?.tool || previousTool?.args !== currentTool?.args)
+      return true;
+  }
+  return false;
+}
+function isCompleteUsageCounter(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+const STOPPED_BEFORE_COMPLETION_ERROR = "Subagent stopped before completion.";
 const AFTER_COMPACTION_SETTLEMENT = Symbol("afterCompactionSettlement");
 async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared) {
   const effectiveThinking = options.thinkingOverride ?? agent.thinking;
@@ -273,132 +288,77 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
   }) : undefined;
   const permissionRules = resolvePermissionRules(options.permissions, agent.permissions);
   const permissionAuditPath = permissionRules && options.artifactsDir ? path.join(options.artifactsDir, "permission-audit", `${options.runId}-${options.index ?? 0}.jsonl`) : undefined;
-  const { args, env: sharedEnv, tempDir, toolDiagnosticPath, runtimeAcknowledgedExtensionsPath, capabilityAudit, warnings } = buildPiArgs({
-    baseArgs: ["--mode", "json", "-p"],
-    task,
-    taskDelivery: shared.taskDelivery,
+  let onWatchdogStatus;
+  const launch = buildInProcessChildLaunch({
+    machine: options.machine,
+    remoteSkillNames: options.skills ?? agent.skills,
+    remoteReads: options.remoteReads,
+    extensionBindings: options.extensionBindings,
+    requiredExtensions: options.requiredExtensions,
     sessionEnabled: shared.sessionEnabled,
     sessionDir: options.sessionDir,
     sessionFile: options.sessionFile,
     model: modelArg,
-    thinking: effectiveThinking,
     systemPromptMode: agent.systemPromptMode,
     inheritProjectContext: agent.inheritProjectContext,
     inheritGlobalContext: agent.inheritGlobalContext,
     inheritSkills: agent.inheritSkills,
     requireReadTool: Boolean(shared.resolvedSkillNames?.length),
     tools: agent.tools,
+    excludeTools: agent.excludeTools,
     allowNestedSubagents: agent.allowNestedSubagents,
+    descendantAllowedAgents: agent.allowedAgents,
     extensions: agent.extensions,
     subagentOnlyExtensions: agent.subagentOnlyExtensions,
-    systemPrompt: shared.systemPrompt,
+    systemPrompt: shared.acceptancePrompt ? `${shared.systemPrompt}
+${shared.acceptancePrompt}` : shared.systemPrompt,
     mcpDirectTools: agent.mcpDirectTools,
     cwd: options.cwd ?? runtimeCwd,
-    promptFileStem: agent.name,
     intercomSessionName: options.intercomSessionName,
     sessionName: childSessionName,
     orchestratorIntercomTarget: options.orchestratorIntercomTarget,
     runId: options.runId,
     childAgentName: agent.name,
     childIndex: options.index ?? 0,
-    parentEventSink: options.nestedRoute?.eventSink,
-    parentControlInbox: options.nestedRoute?.controlInbox,
-    parentRootRunId: options.nestedRoute?.rootRunId,
-    parentCapabilityToken: options.nestedRoute?.capabilityToken,
+    nestedRoute: options.nestedRoute,
     runFanoutBudget: options.runFanoutBudget,
     parentSessionId: options.parentSessionId,
     forkCacheKey: options.context === "fork" ? deriveForkPromptCacheKey(options.parentSessionId) : undefined,
-    steerInboxDir: options.steerInboxDir,
-    steerCapabilityPath: options.steerCapabilityPath,
-    steerAckDir: options.steerAckDir,
     structuredOutput: options.structuredOutput,
     fast: options.fast ?? agent.fast,
-    modelCandidates: shared.modelCandidates,
     toolBudget: options.toolBudget,
-    allowZeroToolBudget: options.allowZeroToolBudget,
     permissionRules,
     permissionAuditPath,
     childWatchdog,
+    watchdogStatus: childWatchdog ? (event) => onWatchdogStatus?.(event) : undefined,
     waitToolEnabled: options.waitToolEnabled,
     waitToolDefaultTimeoutMs: options.waitToolDefaultTimeoutMs,
     capabilityCeiling: options.capabilityCeiling,
     thinkingCeiling: options.thinkingCeiling,
-    extensionBindings: options.extensionBindings,
-    runtimeSnapshotHost: options.runtimeSnapshotHost
+    maxSubagentDepth: options.maxSubagentDepth,
+    runtimeSnapshotHost: options.runtimeSnapshotHost,
+    inherited: options.childRuntime,
+    host: "parent"
   });
+  if (!options.machine && options.parentProviderRegistry)
+    launch.session.parentProviderRegistry = options.parentProviderRegistry;
+  const { toolPlan, capabilityAudit, warnings, launchResolvedExtensions, capture } = launch;
   if (!shared.launchWarnings.emitted && warnings.length > 0) {
     for (const warning of warnings)
       console.warn(`[dm-subagents] ${warning}`);
     shared.launchWarnings.emitted = true;
   }
   const effectiveSystemPrompt = shared.systemPrompt;
-  const toolPlan = resolvePiLaunchToolPlan({
-    tools: agent.tools,
-    allowNestedSubagents: agent.allowNestedSubagents,
-    extensions: agent.extensions,
-    subagentOnlyExtensions: agent.subagentOnlyExtensions,
-    mcpDirectTools: agent.mcpDirectTools,
-    cwd: options.cwd ?? runtimeCwd,
-    requireReadTool: Boolean(shared.resolvedSkillNames?.length),
-    structuredOutput: Boolean(options.structuredOutput),
-    fast: options.fast ?? agent.fast,
-    model: modelArg,
-    modelCandidates: shared.modelCandidates,
-    capabilityCeiling: options.capabilityCeiling,
-    inheritedCapabilityCeiling: decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]),
-    agentName: agent.name,
-    permissionRules,
-    runtimeSnapshotHost: options.runtimeSnapshotHost
-  });
-  const contractTools = toolPlan.explicitToolAllowlist ? toolPlan.effectiveToolAllowlist : undefined;
-  const contractError = validateImplementationToolContract({
-    agent: agent.name,
-    task: shared.originalTask ?? task,
-    tools: contractTools,
-    mcpDirectTools: toolPlan.effectiveMcpTools,
-    configuredExtensions: toolPlan.configuredExtensions,
-    requestedTools: toolPlan.requestedBuiltinTools,
-    acceptanceRole: agent.acceptanceRole,
-    completionGuard: agent.completionGuard
-  });
-  if (contractError) {
-    cleanupTempDir(tempDir);
-    return {
-      index: options.index ?? 0,
-      agent: agent.name,
-      task,
-      ...childSessionName ? { sessionName: childSessionName } : {},
-      messages: [],
-      finalOutput: "",
-      exitCode: 1,
-      error: contractError,
-      usage: emptyUsage(),
-      model: modelArg,
-      modelAttempts: [],
-      attemptedModels: [],
-      progressSummary: { status: "failed", toolCount: 0, tokens: 0, durationMs: 0 },
-      ...toolPlan.capabilityCeiling ? { capabilityCeiling: toolPlan.capabilityCeiling } : {},
-      ...toolPlan.capabilityAudit ? { capabilityAudit: toolPlan.capabilityAudit } : {}
-    };
-  }
-  const launchResolvedExtensions = projectLaunchResolvedChildExtensions(toolPlan);
-  const launchContractDigest = launchBindingDigest({
-    definitionDigest: agentDefinitionDigest(agent),
+  const fast = options.fast ?? agent.fast;
+  const { launchContractDigest } = resolveLaunchBinding({
+    agent,
     task: shared.originalTask ?? task,
-    ...modelArg ? { model: modelArg } : {},
-    modelCandidates: shared.modelCandidates,
-    ...(options.fast ?? agent.fast) !== undefined ? { fast: options.fast ?? agent.fast } : {},
+    model: modelArg,
+    ...fast !== undefined ? { fast } : {},
     ...resolvedThinking ? { thinking: resolvedThinking } : {},
-    ...options.thinkingCeiling ? { thinkingCeiling: options.thinkingCeiling } : {},
     systemPrompt: effectiveSystemPrompt,
-    systemPromptMode: agent.systemPromptMode,
-    inheritProjectContext: agent.inheritProjectContext,
-    inheritGlobalContext: agent.inheritGlobalContext,
-    inheritSkills: agent.inheritSkills,
     skills: shared.resolvedSkillNames ?? [],
-    tools: toolPlan.effectiveToolAllowlist,
-    extensions: toolPlan.extensionArgs,
-    mcpDirectTools: toolPlan.effectiveMcpTools,
+    toolPlan,
     ...options.outputPath ? { outputPath: options.outputPath } : {},
     outputMode: options.outputMode ?? "inline",
     ...options.structuredOutput ? { structuredOutputSchema: options.structuredOutput.schema } : {},
@@ -427,12 +387,6 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     ...capabilityAudit ? { capabilityAudit } : {}
   }, options.context);
   const startTime = Date.now();
-  if (options.structuredOutput) {
-    try {
-      if (existsSync(options.structuredOutput.outputPath))
-        unlinkSync(options.structuredOutput.outputPath);
-    } catch {}
-  }
   const controlConfig = options.controlConfig ?? DEFAULT_CONTROL_CONFIG;
   let interruptedByControl = false;
   const allControlEvents = [];
@@ -447,6 +401,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     pendingControlEvents.push(event);
     options.onControlEvent?.(event);
   };
+  let inputUsageComplete = true;
+  let outputUsageComplete = true;
+  let cacheReadUsageComplete = true;
+  let cacheWriteUsageComplete = true;
   const progress = {
     index: options.index ?? 0,
     agent: agent.name,
@@ -460,15 +418,30 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     tokens: 0,
     ...modelArg ? { model: modelArg } : {},
     ...resolvedThinking ? { thinking: resolvedThinking } : {},
-    inputTokens: 0,
-    outputTokens: 0,
     durationMs: 0,
     lastActivityAt: startTime
   };
   result.progress = progress;
+  const projectCompleteUsage = () => {
+    if (inputUsageComplete)
+      progress.inputTokens = result.usage.input;
+    else
+      delete progress.inputTokens;
+    if (outputUsageComplete)
+      progress.outputTokens = result.usage.output;
+    else
+      delete progress.outputTokens;
+    if (cacheReadUsageComplete)
+      progress.cacheRead = result.usage.cacheRead;
+    else
+      delete progress.cacheRead;
+    if (cacheWriteUsageComplete)
+      progress.cacheWrite = result.usage.cacheWrite;
+    else
+      delete progress.cacheWrite;
+  };
   const attemptTimeout = resolveAttemptTimeout(options);
   if (attemptTimeout?.remainingMs === 0) {
-    cleanupTempDir(tempDir);
     result.exitCode = 1;
     result.timedOut = true;
     result.error = attemptTimeout.message;
@@ -482,14 +455,12 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     };
     return result;
   }
-  const spawnEnv = { ...process.env, ...sharedEnv, ...getSubagentDepthEnv(options.maxSubagentDepth) };
-  const mutationSnapshot = snapshotTrackedMutations(options.cwd ?? runtimeCwd);
-  let observedMutationAttempt = false;
+  const mutationSnapshot = options.machine ? { source: "tracked-files", trackedOnly: true, cwd: options.cwd ?? runtimeCwd, dirtyFiles: [], fingerprints: {}, unavailable: "Local Git evidence is not authoritative for a pane-native remote run." } : snapshotTrackedMutations(options.cwd ?? runtimeCwd);
   let structuredOutputToolInvoked = false;
   let structuredOutputMessageStartIndex;
   let toolAvailabilityError;
   let abortedBySignal = options.signal?.aborted === true;
-  const spawnSpec = getPiSpawnCommand(args);
+  let afterCompactionSettlement = false;
   if (options.workflowChildPermitLaunch) {
     const permitError = consumeWorkflowChildPermit(options.workflowChildPermitLaunch.permit, {
       workflowRunId: options.workflowChildPermitLaunch.workflowRunId,
@@ -500,7 +471,6 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       runner: "dm"
     });
     if (permitError) {
-      cleanupTempDir(tempDir);
       result.exitCode = 1;
       result.error = permitError;
       result.finalOutput = permitError;
@@ -509,16 +479,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       return result;
     }
   }
-  let afterCompactionSettlement = false;
+  const childSessions = options.childSessionFactory ?? childSessionFactory();
   const exitCode = await new Promise((resolve) => {
-    const proc = spawn(spawnSpec.command, spawnSpec.args, {
-      cwd: options.cwd ?? runtimeCwd,
-      env: spawnEnv,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
-    let processClosed = false;
+    const jsonlWriter = createJsonlWriter(shared.jsonlPath, { pause() {}, resume() {} });
+    let session;
+    let messageBaseline;
+    let unsubscribe;
+    let sessionSettled = false;
     let lifecycleFinished = false;
     let detached = false;
     let intercomStarted = false;
@@ -527,25 +494,24 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     let removeInterruptListener;
     let activityTimer;
     let timeoutTimer;
-    let timeoutTerminationTimer;
-    let timeoutHardKillTimer;
-    let protocolHardKillTimer;
+    let timeoutHardFinishTimer;
     const clearTimeoutTimers = () => {
       if (timeoutTimer) {
         clearTimeout(timeoutTimer);
         timeoutTimer = undefined;
       }
-      if (timeoutTerminationTimer) {
-        clearTimeout(timeoutTerminationTimer);
-        timeoutTerminationTimer = undefined;
-      }
-      if (timeoutHardKillTimer) {
-        clearTimeout(timeoutHardKillTimer);
-        timeoutHardKillTimer = undefined;
+      if (timeoutHardFinishTimer) {
+        clearTimeout(timeoutHardFinishTimer);
+        timeoutHardFinishTimer = undefined;
       }
     };
+    const abortChild = () => {
+      if (!session || sessionSettled || lifecycleFinished)
+        return;
+      session.abort().catch(() => {});
+    };
     const detachForeground = (reason) => {
-      if (detached || processClosed || lifecycleFinished || options.signal?.aborted)
+      if (detached || sessionSettled || lifecycleFinished || options.signal?.aborted)
         return false;
       const receiptProgress = snapshotProgress(progress);
       receiptProgress.status = "detached";
@@ -573,17 +539,19 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       if (!accepted)
         return false;
       detached = true;
+      if (session)
+        session.detached = true;
       return true;
     };
     const FINAL_STOP_GRACE_MS = 1000;
-    const HARD_KILL_MS = 3000;
-    let childExited = false;
-    let forcedTerminationSignal = false;
+    const HARD_FINISH_MS = 3000;
+    let forcedTermination = false;
     let cleanTerminalAssistantStopReceived = false;
     let agentSettledReceived = false;
+    let queuedDrainHold = false;
     let compactionStartedReceived = false;
     let finalDrainTimer;
-    let finalHardKillTimer;
+    let finalHardFinishTimer;
     let watchdogTailTimer;
     let childWatchdogState;
     const updateChildWatchdogState = (snapshot) => {
@@ -602,39 +570,54 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         clearTimeout(finalDrainTimer);
         finalDrainTimer = undefined;
       }
-      if (finalHardKillTimer) {
-        clearTimeout(finalHardKillTimer);
-        finalHardKillTimer = undefined;
+      if (finalHardFinishTimer) {
+        clearTimeout(finalHardFinishTimer);
+        finalHardFinishTimer = undefined;
       }
     };
+    const observeQueuedDrainHold = () => {
+      if (childSessionHasQueuedMessages(session))
+        queuedDrainHold = true;
+      return queuedDrainHold;
+    };
     const startFinalDrain = () => {
       if (childWatchdogIsActive(childWatchdogState)) {
         armWatchdogTail();
         return;
       }
-      if (childExited || finalDrainTimer || lifecycleFinished || processClosed)
+      if (sessionSettled || finalDrainTimer || lifecycleFinished)
+        return;
+      if (observeQueuedDrainHold())
+        return;
+      armFinalDrainTimer();
+    };
+    const armFinalDrainTimer = () => {
+      if (sessionSettled || finalDrainTimer || lifecycleFinished)
         return;
       finalDrainTimer = setTimeout(() => {
-        if (lifecycleFinished || processClosed)
+        if (lifecycleFinished || sessionSettled)
           return;
-        const termSent = trySignalChild(proc, "SIGTERM");
-        if (!termSent)
+        if (capture.finalDrainHeld() || observeQueuedDrainHold()) {
+          finalDrainTimer = undefined;
+          armFinalDrainTimer();
           return;
-        forcedTerminationSignal = true;
+        }
+        forcedTermination = true;
         if (!cleanTerminalAssistantStopReceived && !agentSettledReceived && !assistantError) {
-          result.error = result.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Forcing termination.`;
+          result.error = result.error ?? `Subagent session did not settle within ${FINAL_STOP_GRACE_MS}ms after its terminal event. Aborting it.`;
         }
-        finalHardKillTimer = setTimeout(() => {
-          if (lifecycleFinished || processClosed)
+        abortChild();
+        finalHardFinishTimer = setTimeout(() => {
+          if (lifecycleFinished || sessionSettled)
             return;
-          forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal;
-        }, HARD_KILL_MS);
-        finalHardKillTimer.unref?.();
+          settle(undefined, true);
+        }, HARD_FINISH_MS);
+        finalHardFinishTimer.unref?.();
       }, FINAL_STOP_GRACE_MS);
       finalDrainTimer.unref?.();
     };
     function armWatchdogTail() {
-      if (!cleanTerminalAssistantStopReceived && !agentSettledReceived || watchdogTailTimer || lifecycleFinished || processClosed)
+      if (!cleanTerminalAssistantStopReceived && !agentSettledReceived || watchdogTailTimer || lifecycleFinished || sessionSettled)
         return;
       watchdogTailTimer = setTimeout(() => {
         watchdogTailTimer = undefined;
@@ -642,7 +625,6 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
           phase: "stale",
           seq: (childWatchdogState?.seq ?? 0) + 1,
           lastUpdate: Date.now(),
-          followUpPending: false,
           reason: "child watchdog tail timeout",
           timedOut: true
         });
@@ -653,6 +635,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     }
     const applyChildLifecycle = (action) => {
       if (action === "cancel-drain") {
+        cleanTerminalAssistantStopReceived = false;
+        agentSettledReceived = false;
         clearFinalDrainTimers();
         clearWatchdogTailTimer();
         return;
@@ -662,7 +646,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     };
     const childLifecycleState = { compactionRetryActive: false };
     const unsubscribeIntercomDetach = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-      if (!options.allowIntercomDetach || processClosed)
+      if (!options.allowIntercomDetach || sessionSettled)
         return;
       if (!payload || typeof payload !== "object")
         return;
@@ -689,13 +673,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       lifecycleFinished = true;
       clearFinalDrainTimers();
       clearWatchdogTailTimer();
-      clearStdioGuard();
       clearTimeoutTimers();
       clearAllToolTimeouts();
-      if (protocolHardKillTimer) {
-        clearTimeout(protocolHardKillTimer);
-        protocolHardKillTimer = undefined;
-      }
       if (activityTimer) {
         clearInterval(activityTimer);
         activityTimer = undefined;
@@ -703,7 +682,14 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       unsubscribeIntercomDetach?.();
       removeAbortListener?.();
       removeInterruptListener?.();
-      resolve(code);
+      unsubscribe?.();
+      onWatchdogStatus = undefined;
+      jsonlWriter.close().catch(() => {});
+      Promise.resolve().then(() => session?.dispose()).catch(() => {
+        return;
+      }).then(() => {
+        resolve(code);
+      });
     };
     const drainPendingControlEvents = () => {
       if (pendingControlEvents.length === 0)
@@ -831,6 +817,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         config: controlConfig,
         startedAt: startTime,
         lastActivityAt: progress.lastActivityAt,
+        turnCount: progress.turnCount,
         currentTool: progress.currentTool,
         thinking: resolvedThinking,
         now
@@ -857,8 +844,9 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       });
       return activeReason ? emitActiveLongRunning(now, activeReason) : false;
     };
+    let lastStructuredDelegationProgressState;
     const emitUpdateSnapshot = (text) => {
-      if (!options.onUpdate || processClosed)
+      if (!options.onUpdate || sessionSettled)
         return;
       const progressSnapshot = snapshotProgress(progress);
       const resultSnapshot = snapshotStreamResult(result, progressSnapshot);
@@ -874,28 +862,21 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       });
     };
     const fireUpdate = () => {
-      if (!options.onUpdate || processClosed)
+      if (!options.onUpdate || sessionSettled)
         return;
       progress.durationMs = Date.now() - startTime;
+      if (options.suppressUnchangedDelegationUpdates) {
+        if (lastStructuredDelegationProgressState && !structuredDelegationProgressChanged(lastStructuredDelegationProgressState, progress, result))
+          return;
+        lastStructuredDelegationProgressState = captureStructuredDelegationProgressState(progress, result);
+      }
       const output = result.timedOut && result.finalOutput ? result.finalOutput : getFinalOutput(result.messages ?? []);
       emitUpdateSnapshot(output || "(running...)");
     };
-    const rawStdoutTail = createBoundedByteTail();
-    const processLine = (line) => {
-      if (!line.trim())
-        return;
-      jsonlWriter.writeLine(line);
-      let evt;
-      try {
-        evt = JSON.parse(line);
-      } catch {
-        rawStdoutTail.push(`${line}
-`);
-        shared.transcriptWriter?.writeStdoutLine(line);
-        shared.orcaProgressTab?.append(`${line}
-`);
+    const processEvent = (evt) => {
+      if (lifecycleFinished)
         return;
-      }
+      jsonlWriter.writeLine(JSON.stringify(projectChildSessionEventForJson(evt)));
       shared.transcriptWriter?.writeChildEvent(evt);
       shared.orcaProgressTab?.event(evt);
       if (evt.type === "compaction_start")
@@ -904,10 +885,27 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         compactionStartedReceived = false;
         afterCompactionSettlement = false;
       }
+      if (evt.type === "turn_start" || evt.type === "agent_start" || evt.type === "auto_retry_start") {
+        queuedDrainHold = false;
+      }
       if (evt.type === "agent_start" || evt.type === "auto_retry_start") {
         compactionStartedReceived = false;
         afterCompactionSettlement = false;
       }
+      if (evt.type === "agent_start") {
+        const diagnostic = capture.toolDiagnostic();
+        if (diagnostic) {
+          const message = formatChildToolDiagnostic(diagnostic, { host: "parent" });
+          toolAvailabilityError = message;
+          result.error = message;
+          result.finalOutput = message;
+          progress.status = "failed";
+          progress.error = message;
+          fireUpdate();
+          abortChild();
+          return;
+        }
+      }
       const lifecycleAction = projectChildLifecycle(evt, false, childLifecycleState);
       if (evt.type === "agent_settled" && lifecycleAction === "start-drain") {
         agentSettledReceived = true;
@@ -959,7 +957,6 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
           result.toolBudget = toolBudgetState(options.toolBudget, progress.toolCount);
         }
         const mutates = isMutatingTool(evt.toolName, toolArgs, agent.mutationTools);
-        observedMutationAttempt = observedMutationAttempt || mutates;
         pendingToolResult = { tool: evt.toolName ?? "tool", path: activeTool?.path, mutates, startedAt: now };
         fireUpdate();
       }
@@ -978,6 +975,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       }
       if (evt.type === "message_end" && evt.message) {
         result.messages.push(evt.message);
+        if (childWatchdog) {
+          const next = applyChildWatchdogMessage(childWatchdogState, evt.message);
+          if (next)
+            updateChildWatchdogState(next);
+        }
         if (evt.message.role === "assistant") {
           result.usage.turns++;
           progress.turnCount = result.usage.turns;
@@ -985,6 +987,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
           const hasToolCall = toolCalls.length > 0;
           const terminalAssistantStop = evt.message.stopReason === "stop" && !hasToolCall;
           const u = evt.message.usage;
+          inputUsageComplete &&= isCompleteUsageCounter(u?.input);
+          outputUsageComplete &&= isCompleteUsageCounter(u?.output);
+          cacheReadUsageComplete &&= isCompleteUsageCounter(u?.cacheRead);
+          cacheWriteUsageComplete &&= isCompleteUsageCounter(u?.cacheWrite);
           if (u) {
             const window = (u.input || 0) + (u.cacheRead || 0);
             result.usage.input += u.input || 0;
@@ -993,23 +999,25 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             result.usage.cacheWrite += u.cacheWrite || 0;
             result.usage.cost += u.cost?.total || 0;
             progress.tokens = result.usage.input + result.usage.output;
-            progress.inputTokens = result.usage.input;
-            progress.outputTokens = result.usage.output;
             progress.window = window;
             progress.windowPeak = Math.max(progress.windowPeak ?? 0, window);
           }
+          projectCompleteUsage();
           if (evt.message.model) {
             progress.model = evt.message.model;
             if (!result.model)
               result.model = evt.message.model;
             if (expectedModelForVerification && !hasToolCall) {
-              const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels);
+              const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels, options.modelResponseAliases);
               if (modelVerificationError && !result.error)
                 result.error = modelVerificationError;
             }
           }
           if (evt.message.errorMessage)
             assistantError = evt.message.errorMessage;
+          else if (hasToolCall && evt.message.stopReason === "toolUse") {
+            assistantError = undefined;
+          }
           const assistantText = extractTextFromContent(evt.message.content);
           appendRecentOutput(progress, assistantText.split(`
 `).slice(-10));
@@ -1044,9 +1052,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         }
         result.messages.push(evt.message);
         const resultText = extractTextFromContent(evt.message.content);
-        if (options.toolBudget && pendingToolResult && resultText.includes("Tool budget hard limit reached")) {
+        const blockedTool = (typeof toolResultCompletion.toolName === "string" && toolResultCompletion.toolName.length > 0 ? toolResultCompletion.toolName : undefined) ?? pendingToolResult?.tool;
+        if (options.toolBudget && isToolBudgetBlockedMessage(options.toolBudget, resultText, blockedTool)) {
           result.toolBudgetBlocked = true;
-          result.toolBudget = toolBudgetState(options.toolBudget, progress.toolCount, pendingToolResult.tool);
+          result.toolBudget = toolBudgetState(options.toolBudget, Math.max(progress.toolCount, options.toolBudget.hard + 1), blockedTool);
         }
         appendRecentOutput(progress, resultText.split(`
 `).slice(-10));
@@ -1076,10 +1085,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         fireUpdate();
       }
     };
+    onWatchdogStatus = (event) => processEvent(event);
     fireUpdate();
     if (controlConfig.enabled || options.onUpdate) {
       activityTimer = setInterval(() => {
-        if (processClosed || lifecycleFinished) {
+        if (sessionSettled || lifecycleFinished) {
           return;
         }
         updateActivityState(Date.now());
@@ -1089,7 +1099,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     }
     if (attemptTimeout) {
       timeoutTimer = setTimeout(() => {
-        if (processClosed || lifecycleFinished || interruptedByControl)
+        if (sessionSettled || lifecycleFinished || interruptedByControl)
           return;
         result.timedOut = true;
         clearAllToolTimeouts();
@@ -1099,27 +1109,20 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         progress.error = attemptTimeout.message;
         progress.durationMs = Date.now() - startTime;
         fireUpdate();
-        trySignalChild(proc, "SIGINT");
-        timeoutTerminationTimer = setTimeout(() => {
-          if (processClosed || lifecycleFinished)
-            return;
-          trySignalChild(proc, "SIGTERM");
-        }, 1000);
-        timeoutTerminationTimer.unref?.();
-        timeoutHardKillTimer = setTimeout(() => {
-          if (processClosed || lifecycleFinished)
+        abortChild();
+        timeoutHardFinishTimer = setTimeout(() => {
+          if (sessionSettled || lifecycleFinished)
             return;
-          trySignalChild(proc, "SIGKILL");
+          settle(undefined, true);
         }, 4000);
-        timeoutHardKillTimer.unref?.();
+        timeoutHardFinishTimer.unref?.();
       }, attemptTimeout.remainingMs);
       timeoutTimer.unref?.();
     }
     let toolTimeoutSequence = 0;
     const activeToolTimeouts = new Map;
     const activeToolTimeoutKeysByName = new Map;
-    let toolTimeoutTerminationTimer;
-    let toolTimeoutHardKillTimer;
+    let toolTimeoutHardFinishTimer;
     const removeToolTimeoutKey = (key) => {
       const active = activeToolTimeouts.get(key);
       if (!active)
@@ -1140,17 +1143,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     const clearAllToolTimeouts = () => {
       for (const key of [...activeToolTimeouts.keys()])
         removeToolTimeoutKey(key);
-      if (toolTimeoutTerminationTimer) {
-        clearTimeout(toolTimeoutTerminationTimer);
-        toolTimeoutTerminationTimer = undefined;
-      }
-      if (toolTimeoutHardKillTimer) {
-        clearTimeout(toolTimeoutHardKillTimer);
-        toolTimeoutHardKillTimer = undefined;
+      if (toolTimeoutHardFinishTimer) {
+        clearTimeout(toolTimeoutHardFinishTimer);
+        toolTimeoutHardFinishTimer = undefined;
       }
     };
     const terminateForToolTimeout = (message) => {
-      if (processClosed || lifecycleFinished || interruptedByControl)
+      if (sessionSettled || lifecycleFinished || interruptedByControl)
         return;
       result.timedOut = true;
       result.error = message;
@@ -1159,19 +1158,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       progress.error = message;
       progress.durationMs = Date.now() - startTime;
       fireUpdate();
-      trySignalChild(proc, "SIGINT");
-      toolTimeoutTerminationTimer = setTimeout(() => {
-        if (processClosed || lifecycleFinished)
-          return;
-        trySignalChild(proc, "SIGTERM");
-      }, 1000);
-      toolTimeoutTerminationTimer.unref?.();
-      toolTimeoutHardKillTimer = setTimeout(() => {
-        if (processClosed || lifecycleFinished)
+      abortChild();
+      toolTimeoutHardFinishTimer = setTimeout(() => {
+        if (sessionSettled || lifecycleFinished)
           return;
-        trySignalChild(proc, "SIGKILL");
+        settle(undefined, true);
       }, 4000);
-      toolTimeoutHardKillTimer.unref?.();
+      toolTimeoutHardFinishTimer.unref?.();
     };
     const armToolTimeout = (event) => {
       const timeoutForTool = effectiveToolTimeoutMs(event.toolName, options.toolTimeoutMs);
@@ -1193,112 +1186,58 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       keys.push(key);
       activeToolTimeoutKeysByName.set(toolName, keys);
     };
-    const stderrTail = createBoundedByteTail();
-    const failProtocol = (limit) => {
-      if (result.protocolError)
-        return;
-      result.protocolError = limit;
-      result.error = formatProtocolOutputLimit(limit);
-      progress.status = "failed";
-      progress.error = result.error;
-      progress.durationMs = Date.now() - startTime;
-      fireUpdate();
-      if (!childExited) {
-        trySignalChild(proc, "SIGTERM");
-        protocolHardKillTimer = setTimeout(() => {
-          if (!childExited)
-            trySignalChild(proc, "SIGKILL");
-        }, 3000);
-        protocolHardKillTimer.unref?.();
-      }
-    };
-    const stdoutReader = createBoundedLineReader({
-      oversizedLineProjector: PI_AGGREGATE_EVENT_PROJECTOR,
-      onLine: processLine,
-      onLimit: failProtocol
-    });
-    const stderrReader = createBoundedLineReader({
-      stream: "stderr",
-      maxPendingLineBytes: MAX_CHILD_STDERR_BYTES,
-      onLine: (line) => shared.transcriptWriter?.writeStderrLine(line),
-      onLimit: (limit) => shared.transcriptWriter?.writeStderrLine(formatProtocolOutputLimit(limit))
-    });
-    const clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2000, hardMs: 8000 });
-    proc.stdout.on("data", (chunk) => stdoutReader.push(chunk));
-    proc.stderr.on("data", (chunk) => {
-      stderrTail.push(chunk);
-      stderrReader.push(chunk);
-      shared.orcaProgressTab?.append(chunk.toString("utf-8"));
-    });
-    proc.on("exit", () => {
-      childExited = true;
-      clearFinalDrainTimers();
-    });
-    proc.on("close", (code, signal) => {
-      if (lifecycleFinished)
+    const settle = (promptError, forced = false) => {
+      if (lifecycleFinished || sessionSettled)
         return;
-      processClosed = true;
+      sessionSettled = true;
       clearFinalDrainTimers();
-      clearStdioGuard();
-      jsonlWriter.close().catch(() => {});
-      const toolDiagnosticError = readChildToolDiagnosticError(toolDiagnosticPath);
+      const diagnostic = capture.toolDiagnostic();
+      const toolDiagnosticError = diagnostic ? formatChildToolDiagnostic(diagnostic, { host: "parent" }) : undefined;
       toolAvailabilityError = toolDiagnosticError;
-      result.runtimeAcknowledgedExtensions = readRuntimeAcknowledgedExtensions(runtimeAcknowledgedExtensionsPath);
-      cleanupTempDir(tempDir);
-      stdoutReader.end();
-      stderrReader.end();
-      const stderr = stderrTail.text();
-      const rawStdout = rawStdoutTail.text();
+      result.runtimeAcknowledgedExtensions = capture.runtimeAcknowledgedExtensions();
+      if (session?.machineEvidence)
+        result.nativeMachine = { provider: "herdr", machineId: session.machineEvidence.machineId, ...session.machineEvidence.initial ? { initialGit: session.machineEvidence.initial } : {}, ...session.machineEvidence.final ? { finalGit: session.machineEvidence.final } : {} };
       let closeError = result.error ?? toolDiagnosticError ?? assistantError;
-      const forcedDrainAfterFinalSuccess = Boolean(forcedTerminationSignal || signal) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
-      const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(result.messages ?? []);
-      if (signal)
-        result.processSignal = signal;
-      if (!closeError && forcedDrainAfterEmptyTerminal && stderr.trim()) {
-        closeError = stderr.trim();
+      const promptErrorMessage = promptError === undefined ? undefined : promptError instanceof Error ? promptError.message : String(promptError);
+      if (!closeError && promptErrorMessage !== undefined) {
+        closeError = promptErrorMessage;
       }
-      if (!closeError && isUnexplainedProcessSignal({
-        processSignal: signal,
-        interrupted: result.interrupted,
-        timedOut: result.timedOut,
-        stopped: result.stopped,
-        forcedDrainAfterFinalSuccess: forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal
-      })) {
-        closeError = formatProcessSignalError(signal);
+      if (promptErrorMessage !== undefined && closeError === promptErrorMessage && isChildModelResolutionFailure(promptErrorMessage) && (result.messages?.length ?? 0) === 0 && result.usage.turns === 0 && !launch.session.ambientExtensions) {
+        closeError = `${promptErrorMessage}
+
+${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.session.model, host: "parent", capabilityCeiling: launch.toolPlan.capabilityCeiling })}`;
       }
-      if (code !== 0 && rawStdout.trim() && !closeError && !forcedDrainAfterFinalSuccess) {
-        closeError = rawStdout.trim();
+      const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
+      const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(result.messages ?? []);
+      if (!closeError && (abortedBySignal || session?.shutDown) && !result.interrupted && !result.timedOut) {
+        closeError = session?.shutDown ? "Subagent stopped because the parent session shut down." : STOPPED_BEFORE_COMPLETION_ERROR;
       }
-      if (code !== 0 && stderr.trim() && !closeError && !forcedDrainAfterFinalSuccess) {
-        closeError = stderr.trim();
+      if (!closeError && forced && !forcedDrainAfterFinalSuccess) {
+        closeError = "Subagent session did not settle after it was aborted.";
       }
-      const finalCode = forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal ? 0 : forcedTerminationSignal || signal ? code ?? 1 : code ?? 0;
+      const finalCode = forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal ? 0 : closeError || promptError !== undefined ? 1 : 0;
       if (!result.error && closeError)
         result.error = closeError;
-      finish(finalCode);
-    });
-    proc.on("error", (error) => {
-      if (lifecycleFinished)
-        return;
-      processClosed = true;
-      clearFinalDrainTimers();
-      clearStdioGuard();
-      jsonlWriter.close().catch(() => {});
-      cleanupTempDir(tempDir);
-      stdoutReader.end();
-      stderrReader.end();
-      if (!result.error) {
-        result.error = error instanceof Error ? error.message : String(error);
+      if (session && messageBaseline !== undefined) {
+        result.usage = reconcileAttemptUsage(result.usage, session.messages, messageBaseline);
+        progress.tokens = result.usage.input + result.usage.output;
+        projectCompleteUsage();
+        progress.turnCount = result.usage.turns;
       }
-      finish(1);
-    });
+      finish(finalCode);
+    };
     if (options.signal) {
       const kill = () => {
-        if (processClosed || lifecycleFinished)
+        if (sessionSettled || lifecycleFinished)
           return;
         abortedBySignal = true;
-        proc.kill("SIGTERM");
-        setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
+        abortChild();
+        const hardTimer = setTimeout(() => {
+          if (sessionSettled || lifecycleFinished)
+            return;
+          settle(undefined, true);
+        }, 3000);
+        hardTimer.unref?.();
       };
       if (options.signal.aborted)
         kill();
@@ -1309,7 +1248,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     }
     if (options.interruptSignal) {
       const interrupt = () => {
-        if (processClosed || lifecycleFinished)
+        if (sessionSettled || lifecycleFinished)
           return;
         if (result.timedOut)
           return;
@@ -1322,12 +1261,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         result.finalOutput = "Interrupted. Waiting for explicit next action.";
         progress.activityState = undefined;
         fireUpdate();
-        trySignalChild(proc, "SIGINT");
-        setTimeout(() => {
-          if (lifecycleFinished || processClosed)
+        abortChild();
+        const hardTimer = setTimeout(() => {
+          if (sessionSettled || lifecycleFinished)
             return;
-          trySignalChild(proc, "SIGTERM");
-        }, 1000).unref?.();
+          settle(undefined, true);
+        }, 3000);
+        hardTimer.unref?.();
       };
       if (options.interruptSignal.aborted)
         interrupt();
@@ -1341,6 +1281,40 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     } catch (error) {
       appendRecentOutput(progress, [`Foreground detach callback failed: ${error instanceof Error ? error.message : String(error)}`]);
     }
+    (async () => {
+      try {
+        const input = createReportedChildSessionInput(launch, shared.transcriptWriter);
+        const created = await childSessions.create(input);
+        if (lifecycleFinished) {
+          created.dispose();
+          return;
+        }
+        session = created;
+        const steer = created.steer.bind(created);
+        const followUp = created.followUp.bind(created);
+        created.steer = async (text) => {
+          if (cleanTerminalAssistantStopReceived || agentSettledReceived)
+            queuedDrainHold = true;
+          return steer(text);
+        };
+        created.followUp = async (text) => {
+          if (cleanTerminalAssistantStopReceived || agentSettledReceived)
+            queuedDrainHold = true;
+          return followUp(text);
+        };
+        created.detached = detached;
+        unsubscribe = created.subscribe((event) => processEvent(event));
+        if (abortedBySignal || interruptedByControl || result.timedOut) {
+          abortChild();
+        }
+        options.onChildSession?.({ steer: (text) => created.steer(text), followUp: (text) => created.followUp(text) });
+        messageBaseline = created.messages.length;
+        await created.prompt(`Task: ${task}`);
+        settle(undefined);
+      } catch (error) {
+        settle(error ?? new Error("Child session failed."));
+      }
+    })();
   });
   result.exitCode = exitCode;
   if (afterCompactionSettlement) {
@@ -1361,47 +1335,30 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     };
     return result;
   }
-  if (progress.currentTool && isOrdinaryToolForMidToolExit(progress.currentTool) && !abortedBySignal && !result.timedOut && !result.stopped && !result.protocolError && !toolAvailabilityError) {
-    const processExitCode = result.exitCode;
+  if (progress.currentTool && isOrdinaryToolForMidToolExit(progress.currentTool) && !abortedBySignal && !result.timedOut && !result.stopped && !toolAvailabilityError) {
     result.exitCode = 1;
-    result.error = formatMidToolExitError({
-      toolName: progress.currentTool,
-      exitCode: processExitCode,
-      processSignal: result.processSignal
-    });
+    result.error = formatMidToolExitError({ toolName: progress.currentTool });
   }
-  result.error = formatSubagentExtensionConflictError(result.error, {
-    agent: agent.name,
-    ambientExtensionsEnabled: !launchResolvedExtensions.disableAmbientExtensions
-  });
   if (result.error && result.exitCode === 0) {
     result.exitCode = 1;
   }
   let validatedStructuredOutput = false;
-  if (options.structuredOutput && result.exitCode === 0 && !result.error) {
+  if (options.structuredOutput) {
     result.structuredOutputSchemaPath = options.structuredOutput.schemaPath;
     result.structuredOutputPath = options.structuredOutput.outputPath;
-    if (!structuredOutputToolInvoked) {
+    const structured = capture.structuredOutput();
+    if (structuredOutputToolInvoked && structured.called) {
+      result.structuredOutput = structured.value;
+      const acceptanceMode = options.structuredOutput.acceptanceReportPath ? options.structuredOutput.acceptanceReportRequired ? "required" : "optional" : undefined;
+      const acceptanceReportError = acceptanceMode === "required" && !structured.acceptanceReportProvided ? MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR : undefined;
+      result.structuredAcceptanceReport = acceptanceMode ? structured.acceptanceReport : undefined;
+      result.structuredAcceptanceReportError = acceptanceReportError;
+      writeStructuredOutputArtifacts(options.structuredOutput, structured.value, acceptanceMode ? structured.acceptanceReport : undefined);
+      validatedStructuredOutput = true;
+    } else if (result.exitCode === 0 && !result.error) {
       result.exitCode = 1;
-      result.error = MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
+      result.error = structuredOutputToolInvoked ? formatStructuredOutputRejectionError(result.messages ?? []) : MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
       result.structuredOutputFailed = true;
-    } else {
-      const structured = await readStructuredOutput({
-        schema: options.structuredOutput.schema,
-        schemaPath: options.structuredOutput.schemaPath,
-        outputPath: options.structuredOutput.outputPath
-      });
-      if (structured.error) {
-        result.exitCode = 1;
-        result.error = structured.error;
-        result.structuredOutputFailed = true;
-      } else {
-        result.structuredOutput = structured.value;
-        const acceptanceReport = readStructuredOutputAcceptanceReport(options.structuredOutput);
-        result.structuredAcceptanceReport = acceptanceReport.value;
-        result.structuredAcceptanceReportError = acceptanceReport.error;
-        validatedStructuredOutput = true;
-      }
     }
   }
   if (result.exitCode === 0 && !result.error) {
@@ -1433,7 +1390,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     tokens: progress.tokens,
     durationMs: progress.durationMs
   };
-  const mutationEvidence = collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
+  const remoteGitChanged = result.nativeMachine?.initialGit && result.nativeMachine.finalGit ? result.nativeMachine.initialGit.head !== result.nativeMachine.finalGit.head || result.nativeMachine.initialGit.dirty !== result.nativeMachine.finalGit.dirty : undefined;
+  const mutationEvidence = result.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {} } : collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
   const acceptanceOutput = getFinalOutput(result.messages ?? []);
   let fullOutput = stripAcceptanceReport(acceptanceOutput);
   if (!fullOutput.trim() && result.structuredOutput !== undefined)
@@ -1446,7 +1404,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       const outputChanged = hasSingleOutputChangedSinceSnapshot(options.outputPath, shared.outputSnapshot);
       requiredOutputMissing = outputChanged === undefined ? undefined : !outputChanged;
     } else if (options.structuredOutput) {
-      requiredOutputMissing = !existsSync(options.structuredOutput.outputPath);
+      requiredOutputMissing = !capture.structuredOutput().called;
     }
     result.timeoutRecovery = buildTimeoutRecoverySummary({
       termination: "timed-out",
@@ -1468,62 +1426,6 @@ ${fullOutput}` : `${timeoutMessage}
 
 ${result.timeoutRecovery.message}`;
   }
-  const completionGuardEnabled = isAgentContractV1(options.agentContract) ? agent.completionGuard === true : agent.completionGuard !== false;
-  const completionGuard = (result.exitCode === 0 && !result.error || toolAvailabilityError) && completionGuardEnabled ? evaluateCompletionMutationGuard({
-    agent: agent.name,
-    task: shared.originalTask ?? task,
-    messages: result.messages ?? [],
-    tools: contractTools,
-    mcpDirectTools: toolPlan.effectiveMcpTools,
-    mutationTools: agent.mutationTools,
-    toolAvailabilityError,
-    mutationEvidence
-  }) : undefined;
-  const mutationAttemptObserved = observedMutationAttempt || mutationEvidence.attemptedMutation;
-  let completionGuardTriggered = completionGuard?.triggered === true && !mutationAttemptObserved;
-  let arbiterRescued = false;
-  if (completionGuardTriggered) {
-    const arbitration = await arbitrateCompletionGuardRescue({
-      guardTriggered: true,
-      task: shared.originalTask ?? task,
-      arbiter: options.llmIntentArbiter
-    });
-    completionGuardTriggered = arbitration.triggered;
-    arbiterRescued = arbitration.rescued;
-  }
-  const completionEvidence = planCompletionEvidence({
-    guard: completionGuard,
-    guardTriggered: completionGuardTriggered,
-    completionGuardEnabled,
-    mutationCapable: hasMutationToolCapability(contractTools, toolPlan.effectiveMcpTools),
-    implementationMutationExpected: expectsImplementationMutation(agent.name, shared.originalTask ?? task),
-    mutationAttemptObserved,
-    mutationEvidence,
-    arbiterRescued,
-    agentContractV1: isAgentContractV1(options.agentContract)
-  });
-  if (completionEvidence.fileMutation) {
-    result.effects = {
-      ...result.effects ?? {},
-      fileMutation: completionEvidence.fileMutation
-    };
-  }
-  if (completionEvidence.legacyFailureError) {
-    result.exitCode = 1;
-    result.error = completionEvidence.legacyFailureError;
-    progress.status = "failed";
-    progress.error = result.error;
-    emitControlEvent(buildControlEvent({
-      from: progress.activityState,
-      to: "needs_attention",
-      runId: options.runId ?? agent.name,
-      agent: agent.name,
-      index: options.index,
-      ts: Date.now(),
-      message: `${agent.name} completed without making edits for an implementation task`,
-      reason: "completion_guard"
-    }));
-  }
   if (options.outputPath && result.exitCode === 0) {
     const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot, options.outputClaimPath);
     fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
@@ -1561,6 +1463,18 @@ ${resolvedOutput.saveError}` : resolvedOutput.saveError;
   }
   return result;
 }
+function writeStructuredOutputArtifacts(runtime, value, acceptanceReport) {
+  try {
+    mkdirSync(path.dirname(runtime.outputPath), { recursive: true });
+    writeFileSync(runtime.outputPath, JSON.stringify(value), { mode: 384 });
+    if (runtime.acceptanceReportPath) {
+      if (acceptanceReport !== undefined)
+        writeFileSync(runtime.acceptanceReportPath, JSON.stringify(acceptanceReport), { mode: 384 });
+      else
+        rmSync(runtime.acceptanceReportPath, { force: true });
+    }
+  } catch {}
+}
 async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, options) {
   const effectiveCwd = options.cwd ?? runtimeCwd;
   const cwdError = preflightLaunchCwd(options.requestedCwd ?? effectiveCwd, effectiveCwd);
@@ -1577,7 +1491,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
   }
   options = {
     ...options,
-    capabilityCeiling: intersectSubagentCapabilityCeilings(options.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(options.parentSessionId), decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]))
+    capabilityCeiling: intersectSubagentCapabilityCeilings(options.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(options.parentSessionId), options.childRuntime?.capabilityCeiling)
   };
   const childSessionName = deriveChildSessionName({ agent: agentName, task });
   const agent = agents.find((a) => a.name === agentName);
@@ -1595,7 +1509,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
   }
   options = {
     ...options,
-    thinkingCeiling: intersectThinkingCeilings(options.thinkingCeiling, agent.maxThinking, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]))
+    thinkingCeiling: intersectThinkingCeilings(options.thinkingCeiling, agent.maxThinking, options.childRuntime?.thinkingCeiling)
   };
   try {
     assertAgentAllowedByCapabilityCeiling(agent.name, options.capabilityCeiling);
@@ -1666,7 +1580,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
     dynamicGroup: options.acceptanceContext?.dynamicGroup,
     agentContract: options.agentContract
   });
-  const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance, { reportOptional: isAgentContractV1(options.agentContract), structuredOutput: Boolean(options.structuredOutput?.acceptanceReportPath) });
+  const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance, { reportOptional: isAgentContract(options.agentContract), structuredOutput: Boolean(options.structuredOutput?.acceptanceReportPath) });
   const taskWithAcceptance = acceptancePrompt ? `${task}
 ${acceptancePrompt}` : task;
   options.onEffectivePrompt?.(taskWithAcceptance);
@@ -1688,39 +1602,15 @@ ${acceptancePrompt}` : task;
       error: "Skills not found: dm-subagents"
     }, options.context));
   }
-  let systemPrompt = agent.systemPrompt?.trim() || "";
-  if (resolvedSkills.length > 0) {
-    const skillInjection = buildSkillInjection(resolvedSkills);
-    systemPrompt = systemPrompt ? `${systemPrompt}
-
-${skillInjection}` : skillInjection;
-  }
-  const memoryInjection = buildAgentMemoryInjection(agent, skillCwd);
-  if (memoryInjection) {
-    systemPrompt = systemPrompt ? `${systemPrompt}
-
-${memoryInjection}` : memoryInjection;
-  }
-  systemPrompt = appendAgentRefinementOverlay(systemPrompt, { cwd: skillCwd, agentName });
-  systemPrompt = injectOutputPathSystemPrompt(systemPrompt, options.outputPath, agent);
-  const candidates = buildModelCandidates(options.modelOverride ?? agent.model, agent.fallbackModels, options.availableModels, agent.modelProvider ?? options.preferredModelProvider, { scope: options.modelScope, primaryModelFromParent: options.modelOverrideFromParent });
-  if (options.workflowChildPermitLaunch && candidates.length > 1) {
-    const error = "Workflow child permit does not support model fallback.";
-    return redactResultPrompt(withRunContext({
-      index: options.index ?? 0,
-      agent: agent.name,
-      task,
-      exitCode: 1,
-      messages: [],
-      usage: emptyUsage(),
-      error
-    }, options.context));
-  }
+  const systemPrompt = buildEffectiveSystemPrompt({ agent, resolvedSkills, cwd: skillCwd, ...options.outputPath ? { outputPath: options.outputPath } : {} });
+  const { model: selectedModel, requestedModel } = resolveModelSelection(options.modelOverride ?? agent.model, options.availableModels, agent.modelProvider ?? options.preferredModelProvider, {
+    scope: options.modelScope,
+    primaryModelFromParent: options.modelOverrideFromParent,
+    origin: options.modelOrigin ?? (options.modelOverrideFromParent ? "inherited" : "configured")
+  });
   try {
-    for (const candidate of candidates) {
-      const model = applyThinkingSuffix(candidate, options.thinkingOverride ?? agent.thinking, options.thinkingOverride !== undefined);
-      assertThinkingWithinCeiling({ model, configThinking: options.thinkingOverride ?? agent.thinking, ceiling: options.thinkingCeiling, agent: agent.name, runId: options.runId });
-    }
+    const model = applyThinkingSuffix(selectedModel, options.thinkingOverride ?? agent.thinking, options.thinkingOverride !== undefined);
+    assertThinkingWithinCeiling({ model, configThinking: options.thinkingOverride ?? agent.thinking, ceiling: options.thinkingCeiling, agent: agent.name, runId: options.runId });
   } catch (error) {
     return redactResultPrompt(withRunContext({
       index: options.index ?? 0,
@@ -1732,8 +1622,6 @@ ${memoryInjection}` : memoryInjection;
       error: error instanceof Error ? error.message : String(error)
     }, options.context));
   }
-  const attemptedModels = [];
-  const modelAttempts = [];
   const aggregateUsage = emptyUsage();
   const attemptNotes = [];
   const launchWarnings = { emitted: false };
@@ -1784,10 +1672,11 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       result: target
     });
   };
-  let intercomDetached = false;
   let detachedReason;
+  const logicalDeadline = options.deadlineAt ?? (options.timeoutMs === undefined ? undefined : Date.now() + options.timeoutMs);
   const attemptOptions = {
     ...options,
+    deadlineAt: logicalDeadline,
     onDetachReceipt: (receipt) => {
       receipt.acceptance = buildPendingAcceptanceLedger(effectiveAcceptance);
       try {
@@ -1798,180 +1687,85 @@ ${PROMPT_REDACTED}; live Prompt Audit only.
       const accepted = options.onDetachReceipt?.(receipt) === true;
       if (accepted) {
         detachedReason = receipt.detachedReason;
-        if (receipt.detachedReason === "intercom coordination")
-          intercomDetached = true;
       }
       return accepted;
     }
   };
+  const candidate = selectedModel;
+  const verifyModel = Boolean(candidate) && !options.modelOverrideFromParent;
   let lastResult;
-  const modelsToTry = candidates.length > 0 ? candidates : [undefined];
-  let taskDeliveryOverride;
-  let abortRecoveryAttempted = false;
-  let nextAttemptTask = taskWithAcceptance;
-  modelAttemptsLoop:
-    for (let modelIndex = 0;modelIndex < modelsToTry.length; modelIndex++) {
-      const candidate = modelsToTry[modelIndex];
-      for (let startupAttemptIndex = 0;; startupAttemptIndex++) {
-        const recoveringAbort = abortRecoveryAttempted;
-        const attemptTask = nextAttemptTask;
-        const verifyModel = Boolean(candidate) && !(options.modelOverrideFromParent && modelIndex === 0);
-        const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-        const result = await runSingleAttempt(runtimeCwd, agent, attemptTask, candidate, attemptOptions, {
-          sessionEnabled,
-          systemPrompt,
-          resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
-          skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
-          jsonlPath,
-          artifactPaths: artifactPathsResult,
-          transcriptWriter,
-          attemptNotes,
-          modelCandidates: candidates.map((modelCandidate) => applyThinkingSuffix(modelCandidate, options.thinkingOverride ?? agent.thinking, options.thinkingOverride !== undefined)).filter((modelCandidate) => Boolean(modelCandidate)),
-          outputSnapshot,
-          originalTask: task,
-          taskDelivery: taskDeliveryOverride,
-          orcaProgressTab,
-          launchWarnings,
-          verifyModel
-        });
-        lastResult = result;
-        if (!recoveringAbort && startupAttemptIndex === 0) {
-          if (result.model)
-            attemptedModels.push(result.model);
-          else if (candidate)
-            attemptedModels.push(candidate);
-        }
-        sumUsage(aggregateUsage, result.usage);
-        totalToolCount += result.progressSummary?.toolCount ?? 0;
-        totalDurationMs += result.progressSummary?.durationMs ?? 0;
-        const attemptSucceeded = result.exitCode === 0 && !result.error;
-        const attempt = {
-          model: result.model ?? candidate ?? agent.model ?? "default",
-          success: attemptSucceeded,
-          exitCode: result.exitCode,
-          error: result.error,
-          usage: { ...result.usage }
-        };
-        modelAttempts.push(attempt);
-        if (!attemptSucceeded) {
-          const afterCompactionSettlement = result[AFTER_COMPACTION_SETTLEMENT];
-          const abortRecovery = planAbortRecovery({
-            messages: result.messages ?? [],
-            error: result.error,
-            processSignal: result.processSignal,
-            sessionAvailable: Boolean(options.sessionFile && existsSync(options.sessionFile)),
-            alreadyResumed: abortRecoveryAttempted,
-            stopped: result.stopped || result.detached || options.signal?.aborted,
-            interrupted: result.interrupted || intercomDetached || options.interruptSignal?.aborted,
-            timedOut: result.timedOut,
-            toolBudgetExhausted: result.toolBudgetBlocked,
-            usageBudgetExhausted: false,
-            structuredOutputFailed: result.structuredOutputFailed,
-            acceptanceFailed: false,
-            currentTool: result.progress?.currentTool,
-            afterCompactionSettlement
-          });
-          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 (abortRecovery.diagnostic) {
-            result.error = result.error ? `${result.error}
-${abortRecovery.diagnostic}` : abortRecovery.diagnostic;
-            attempt.error = result.error;
-            break modelAttemptsLoop;
-          }
-        }
-        if (recoveringAbort && !attemptSucceeded)
-          break modelAttemptsLoop;
-        if (options.workflowChildPermitLaunch && !attemptSucceeded)
-          break modelAttemptsLoop;
-        if (intercomDetached || result.timedOut)
-          break modelAttemptsLoop;
-        if (attemptSucceeded)
-          break modelAttemptsLoop;
-        const startupFailure = isRetryableSubagentStartupFailure({
-          exitCode: result.exitCode,
-          error: result.error,
-          finalOutput: result.finalOutput,
-          messageCount: result.messages?.length ?? 0,
-          toolCount: result.progressSummary?.toolCount ?? 0,
-          usage: result.usage,
-          durationMs: result.progressSummary?.durationMs ?? Number.POSITIVE_INFINITY,
-          protocolError: result.protocolError,
-          processSignal: result.processSignal,
-          detached: result.detached,
-          interrupted: result.interrupted,
-          timedOut: result.timedOut,
-          stopped: result.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, [options.signal, options.interruptSignal]);
-          if (!shouldRetry) {
-            if (options.interruptSignal?.aborted) {
-              result.exitCode = 0;
-              result.interrupted = true;
-              result.error = undefined;
-              result.finalOutput = "Interrupted. Waiting for explicit next action.";
-              if (result.progress) {
-                result.progress.status = "running";
-                result.progress.error = undefined;
-              }
-            } else {
-              const cancellationError = "Subagent startup retry cancelled before relaunch.";
-              result.error = cancellationError;
-              result.finalOutput = cancellationError;
-              attempt.error = cancellationError;
-              if (result.progress)
-                result.progress.error = cancellationError;
-            }
-            break modelAttemptsLoop;
-          }
-          if (!taskDeliveryOverride && result.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);
-          continue;
-        }
-        if (startupFailure) {
-          const startupError = formatSubagentStartupRetryExhaustedError({
-            model: attempt.model,
-            attempts: startupAttemptIndex + 1
-          });
-          result.error = startupError;
-          result.finalOutput = startupError;
-          if (result.progress) {
-            result.progress.error = startupError;
-            result.progress.status = "failed";
-          }
-          attempt.error = startupError;
-          break modelAttemptsLoop;
-        }
-        const retryableModelFailure = isRetryableModelFailureAttempt({ error: result.error, messages: result.messages, toolCount: result.progressSummary?.toolCount });
-        if (retryableModelFailure)
-          recordRetryableModelFailure(result.model ?? candidate, result.error);
-        if (isContextOverflow(result.error)) {
-          result.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;
-        }
-        if (!retryableModelFailure || modelIndex === modelsToTry.length - 1)
-          break modelAttemptsLoop;
-        attemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[modelIndex + 1]));
-        break;
-      }
+  let recoveryPrompt = task;
+  let stagedIndexBaseline;
+  if (effectiveAcceptance.preserveStagedIndex) {
+    try {
+      stagedIndexBaseline = captureStagedIndexBaseline(options.cwd ?? runtimeCwd);
+    } catch (error) {
+      return redactResultPrompt(withRunContext({
+        index: options.index ?? 0,
+        agent: agentName,
+        task,
+        exitCode: 1,
+        messages: [],
+        usage: emptyUsage(),
+        error: error instanceof Error ? error.message : String(error)
+      }, options.context));
+    }
+  }
+  for (let attemptIndex = 0;attemptIndex < 2; attemptIndex++) {
+    const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
+    const attemptResult = await runSingleAttempt(runtimeCwd, agent, recoveryPrompt, candidate, attemptOptions, {
+      sessionEnabled,
+      systemPrompt,
+      acceptancePrompt,
+      resolvedSkillNames: resolvedSkills.length > 0 ? resolvedSkills.map((skill) => skill.name) : undefined,
+      skillsWarning: missingSkills.length > 0 ? `Skills not found: ${missingSkills.join(", ")}` : undefined,
+      jsonlPath,
+      artifactPaths: artifactPathsResult,
+      transcriptWriter,
+      attemptNotes,
+      outputSnapshot,
+      originalTask: task,
+      orcaProgressTab,
+      launchWarnings,
+      verifyModel
+    });
+    lastResult = attemptResult;
+    sumUsage(aggregateUsage, attemptResult.usage);
+    totalToolCount += attemptResult.progressSummary?.toolCount ?? 0;
+    totalDurationMs += attemptResult.progressSummary?.durationMs ?? 0;
+    if (attemptResult.exitCode === 0 && !attemptResult.error)
+      break;
+    const recovery = planAbortRecovery({
+      messages: attemptResult.messages ?? [],
+      error: attemptResult.error,
+      processSignal: attemptResult.processSignal,
+      sessionAvailable: Boolean(options.sessionFile && existsSync(options.sessionFile)),
+      alreadyResumed: attemptIndex > 0,
+      stopped: attemptResult.stopped || attemptResult.detached || Boolean(detachedReason) || Boolean(options.workflowChildPermitLaunch) || options.signal?.aborted,
+      interrupted: attemptResult.interrupted || options.interruptSignal?.aborted,
+      timedOut: attemptResult.timedOut,
+      toolBudgetExhausted: attemptResult.toolBudgetBlocked,
+      usageBudgetExhausted: false,
+      structuredOutputFailed: attemptResult.structuredOutputFailed,
+      acceptanceFailed: false,
+      currentTool: attemptResult.progress?.currentTool,
+      afterCompactionSettlement: attemptResult[AFTER_COMPACTION_SETTLEMENT]
+    });
+    if (recovery.action === "resume") {
+      recoveryPrompt = recovery.prompt;
+      attemptNotes.push("[abort-recovery] compaction abort after useful progress; resuming the retained child session once on the same model.");
+      continue;
+    }
+    if (recovery.diagnostic) {
+      attemptResult.error = attemptResult.error ? `${attemptResult.error}
+${recovery.diagnostic}` : recovery.diagnostic;
     }
+    break;
+  }
+  if (!lastResult)
+    throw new Error("Subagent did not produce a result.");
+  if (isContextOverflow(lastResult.error))
+    lastResult.contextOverflow = true;
   const result = withRunContext(lastResult ?? {
     index: options.index ?? 0,
     agent: agentName,
@@ -1983,8 +1777,7 @@ ${abortRecovery.diagnostic}` : abortRecovery.diagnostic;
   }, options.context);
   result.task = task;
   result.usage = aggregateUsage;
-  result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
-  result.modelAttempts = modelAttempts.length > 0 ? modelAttempts : undefined;
+  result.requestedModel = requestedModel;
   result.progressSummary = {
     ...childSessionName ? { sessionName: childSessionName } : {},
     toolCount: totalToolCount,
@@ -2046,9 +1839,11 @@ ${message}` : message;
         reportError: result.structuredAcceptanceReportError,
         fileOutput: childWrittenOutput !== undefined && options.outputPath ? { content: childWrittenOutput, path: options.outputPath, authoritative: options.outputMode === "file-only", durable: result.savedOutputPath !== undefined } : undefined,
         cwd: options.cwd ?? runtimeCwd,
-        reportOptional: isAgentContractV1(options.agentContract),
+        stagedIndexBaseline,
+        reportOptional: isAgentContract(options.agentContract),
         artifactsDir: options.artifactsDir,
-        runId: options.runId
+        runId: options.runId,
+        watchdog: result.watchdog
       });
     }
   } catch (error) {
@@ -2057,7 +1852,11 @@ ${message}` : message;
   }
   const acceptanceFailure = acceptanceFailureMessage(result.acceptance);
   stripAcceptanceReportsFromMessages(result.messages);
-  if (acceptanceFailure && result.acceptance.explicit && result.exitCode === 0 && !result.interrupted && !result.timedOut && !isAgentContractV1(options.agentContract)) {
+  const typedGate = typedVerifyOutput(result.acceptance);
+  if (typedGate && result.structuredOutput === undefined && !acceptanceFailure && result.exitCode === 0) {
+    result.structuredOutput = typedGate.value;
+  }
+  if (acceptanceFailure && result.acceptance.explicit && result.exitCode === 0 && !result.interrupted && !result.timedOut && !isAgentContract(options.agentContract)) {
     result.exitCode = 1;
     if (result.savedOutputPath) {
       result.finalOutput = finalizeSingleOutput({
@@ -2069,7 +1868,6 @@ ${message}` : message;
         savedPath: result.savedOutputPath,
         outputReference: result.outputReference
       }).displayOutput;
-      artifactOutputByResult.set(result, result.finalOutput);
     }
     result.error = result.error ? `${result.error}
 ${acceptanceFailure}` : acceptanceFailure;
@@ -2092,7 +1890,7 @@ ${message}` : message;
       result.progress.error = result.error;
     }
   }
-  if (isAgentContractV1(options.agentContract))
+  if (isAgentContract(options.agentContract))
     attachContractProjections(result);
   redactResultPrompt(result);
   try {
@@ -2119,7 +1917,7 @@ async function runSyncCompletion(runtimeCwd, agents, agentName, task, options) {
   }
 }
 export async function runSync(runtimeCwd, agents, agentName, task, options) {
-  const strictContract = isAgentContractV1(options.agentContract);
+  const strictContract = isAgentContract(options.agentContract);
   let detachedReason;
   let publishedReceipt;
   let activeDetachAttempt;
@@ -2214,14 +2012,14 @@ export async function runSync(runtimeCwd, agents, agentName, task, options) {
     return failedResult;
   });
   let terminalCallbackInvoked = false;
-  authoritativeCompletion.then((terminalResult) => {
+  authoritativeCompletion.then(async (terminalResult) => {
     if (!detachedReason || terminalCallbackInvoked)
       return;
     terminalCallbackInvoked = true;
     terminalResult.detached = undefined;
     terminalResult.detachedReason = detachedReason;
     try {
-      options.onDetachedExit?.(terminalResult);
+      await options.onDetachedExit?.(terminalResult);
     } catch {}
   }).catch(() => {}).finally(() => {
     originSignal?.removeEventListener("abort", forwardOriginAbort);