@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -1,7 +1,12 @@
 import { spawn } from "node:child_process";
 import { existsSync, unlinkSync } 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 {
   ensureArtifactsDir,
+  formatOutputArtifactContent,
   getArtifactPaths,
   writeArtifact,
   writeMetadata
@@ -19,29 +24,61 @@ import {
   buildControlEvent,
   claimControlNotification,
   deriveActivityState,
+  shouldEmitOpenToolAttention,
   shouldNotifyControlEvent
 } from "../shared/subagent-control.js";
 import {
   getFinalOutput,
   findLatestSessionFile,
   detectSubagentError,
+  hasEmptyTerminalAssistantResponse,
+  formatEmptyTerminalAssistantResponseError,
   extractToolArgsPreview,
-  extractTextFromContent
+  extractTextFromContent,
+  boundStreamedRecentTools,
+  boundStreamedRecentOutput,
+  boundStreamedToolCalls
 } from "../../shared/utils.js";
 import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.js";
 import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
-import { evaluateCompletionMutationGuard } from "../shared/completion-guard.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 { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/dm-args.js";
-import { readStructuredOutput } from "../shared/structured-output.js";
-import { captureSingleOutputSnapshot, formatSavedOutputReference, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { resolvePermissionRules } from "../shared/permissions.js";
+import { applyThinkingSuffix, buildPiArgs, cleanupTempDir, deriveForkPromptCacheKey, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/dm-args.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 { 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 { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.js";
+import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import {
   buildModelCandidates,
+  formatSubagentModelVerificationError,
   formatModelAttemptNote,
-  isRetryableModelFailure
+  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 {
   createMutatingFailureState,
   didMutatingToolFail,
@@ -53,14 +90,37 @@ import {
   shouldEscalateMutatingFailures,
   summarizeRecentMutatingFailures
 } from "../shared/long-running-guard.js";
-import { acceptanceFailureMessage, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport } from "../shared/acceptance.js";
-import { appendTurnBudgetSystemPrompt, formatTurnBudgetOutput, initialTurnBudgetState, shouldAbortForTurnBudget, turnBudgetExceededMessage, turnBudgetSoftNote, turnBudgetState } from "../shared/turn-budget.js";
+import { acceptanceFailureMessage, buildSkippedAcceptanceLedger, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport, validateAcceptanceInput } 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 { resolveWatchdogConfig } from "../../watchdog/settings.js";
+import { agentDefinitionDigest, launchBindingDigest } 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 {
+  acceptChildWatchdogEvent,
+  childWatchdogIsActive,
+  isChildWatchdogStatusEvent,
+  resolveChildWatchdogConfig
+} from "../../watchdog/child-status.js";
 const artifactOutputByResult = new WeakMap;
 const acceptanceOutputByResult = new WeakMap;
 function emptyUsage() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
+function withRunContext(result, context) {
+  if (!context)
+    return result;
+  result.context = context;
+  return result;
+}
+function redactResultPrompt(result) {
+  result.task = PROMPT_REDACTED;
+  if (result.progress)
+    result.progress.task = PROMPT_REDACTED;
+  return result;
+}
 function sumUsage(target, source) {
   target.input += source.input;
   target.output += source.output;
@@ -69,6 +129,40 @@ function sumUsage(target, source) {
   target.cost += source.cost;
   target.turns += source.turns;
 }
+function persistSingleResultMetadata(input) {
+  if (!input.enabled || !input.metadataPath)
+    return;
+  const target = input.result;
+  writeMetadata(input.metadataPath, {
+    runId: input.runId,
+    agent: input.agent,
+    task: PROMPT_REDACTED,
+    exitCode: target.exitCode,
+    processSignal: target.processSignal,
+    usage: target.usage,
+    model: target.model,
+    attemptedModels: target.attemptedModels,
+    modelAttempts: target.modelAttempts,
+    durationMs: target.progressSummary?.durationMs,
+    toolCount: target.progressSummary?.toolCount,
+    error: target.error,
+    agentContract: target.agentContract,
+    launchContractDigest: target.launchContractDigest,
+    launchResolvedExtensions: target.launchResolvedExtensions,
+    runtimeAcknowledgedExtensions: target.runtimeAcknowledgedExtensions,
+    execution: target.execution,
+    acceptance: target.acceptance,
+    capabilityCeiling: target.capabilityCeiling,
+    capabilityAudit: target.capabilityAudit,
+    review: target.review,
+    effects: target.effects,
+    transcriptPath: target.transcriptPath,
+    transcriptError: target.transcriptError,
+    skills: target.skills,
+    skillsWarning: target.skillsWarning,
+    timestamp: Date.now()
+  });
+}
 function formatTimeoutMessage(timeoutMs) {
   return `Subagent timed out after ${timeoutMs}ms.`;
 }
@@ -82,17 +176,32 @@ function resolveAttemptTimeout(options) {
     message: formatTimeoutMessage(options.timeoutMs)
   };
 }
-function buildSkippedAcceptanceLedger(acceptance, input) {
+function buildPendingAcceptanceLedger(acceptance) {
   return {
-    status: acceptance.level === "none" ? "not-required" : "rejected",
+    status: "pending",
+    evidenceStatus: "pending",
     explicit: acceptance.explicit,
     effectiveAcceptance: acceptance,
     inferredReason: acceptance.inferredReason,
     criteria: acceptance.criteria,
-    runtimeChecks: acceptance.level === "none" ? [] : [{ id: input.id, status: "failed", message: input.message }],
+    runtimeChecks: [],
     verifyRuns: []
   };
 }
+function buildInterruptedAcceptanceLedger(acceptance) {
+  const pending = buildPendingAcceptanceLedger(acceptance);
+  if (acceptance.level === "none") {
+    pending.status = "not-required";
+    pending.evidenceStatus = "not-required";
+  } else {
+    pending.runtimeChecks = [{
+      id: "interrupted",
+      status: "not-applicable",
+      message: "Acceptance was not evaluated because the subagent was interrupted."
+    }];
+  }
+  return pending;
+}
 function appendRecentOutput(progress, lines) {
   if (lines.length === 0)
     return;
@@ -115,14 +224,16 @@ function stripAcceptanceReportsFromMessages(messages) {
 function snapshotProgress(progress) {
   return {
     ...progress,
+    task: PROMPT_REDACTED,
     skills: progress.skills ? [...progress.skills] : undefined,
-    recentTools: progress.recentTools.map((tool) => ({ ...tool })),
-    recentOutput: [...progress.recentOutput]
+    recentTools: boundStreamedRecentTools(progress.recentTools),
+    recentOutput: boundStreamedRecentOutput(progress.recentOutput)
   };
 }
 function snapshotResult(result, progress) {
   return {
     ...result,
+    task: PROMPT_REDACTED,
     messages: result.outputMode === "file-only" && result.savedOutputPath ? undefined : result.messages ? [...result.messages] : undefined,
     usage: { ...result.usage },
     skills: result.skills ? [...result.skills] : undefined,
@@ -139,12 +250,33 @@ function snapshotResult(result, progress) {
     outputReference: result.outputReference ? { ...result.outputReference } : undefined
   };
 }
+function snapshotStreamResult(result, progress) {
+  const snapshot = snapshotResult(result, progress);
+  snapshot.messages = undefined;
+  snapshot.toolCalls = boundStreamedToolCalls(result);
+  return snapshot;
+}
+const AFTER_COMPACTION_SETTLEMENT = Symbol("afterCompactionSettlement");
 async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared) {
   const effectiveThinking = options.thinkingOverride ?? agent.thinking;
   const modelArg = applyThinkingSuffix(model, effectiveThinking, options.thinkingOverride !== undefined);
-  const { args, env: sharedEnv, tempDir } = buildPiArgs({
+  assertThinkingWithinCeiling({ model: modelArg, configThinking: effectiveThinking, ceiling: options.thinkingCeiling, agent: agent.name, runId: options.runId });
+  const expectedModelForVerification = shared.verifyModel ? modelArg : undefined;
+  const resolvedThinking = resolveEffectiveThinking(modelArg, effectiveThinking);
+  const childSessionName = deriveChildSessionName({ agent: agent.name, task: shared.originalTask ?? task });
+  const watchdogConfig = resolveWatchdogConfig(options.cwd ?? runtimeCwd);
+  const childWatchdog = watchdogConfig.ok ? resolveChildWatchdogConfig({
+    config: watchdogConfig.config,
+    agent: agent.name,
+    runId: options.runId,
+    childIndex: options.index ?? 0
+  }) : 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,
     sessionEnabled: shared.sessionEnabled,
     sessionDir: options.sessionDir,
     sessionFile: options.sessionFile,
@@ -152,16 +284,19 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     thinking: effectiveThinking,
     systemPromptMode: agent.systemPromptMode,
     inheritProjectContext: agent.inheritProjectContext,
+    inheritGlobalContext: agent.inheritGlobalContext,
     inheritSkills: agent.inheritSkills,
     requireReadTool: Boolean(shared.resolvedSkillNames?.length),
     tools: agent.tools,
+    allowNestedSubagents: agent.allowNestedSubagents,
     extensions: agent.extensions,
     subagentOnlyExtensions: agent.subagentOnlyExtensions,
-    systemPrompt: appendTurnBudgetSystemPrompt(shared.systemPrompt, options.turnBudget),
+    systemPrompt: 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,
@@ -170,24 +305,127 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     parentControlInbox: options.nestedRoute?.controlInbox,
     parentRootRunId: options.nestedRoute?.rootRunId,
     parentCapabilityToken: options.nestedRoute?.capabilityToken,
+    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,
-    toolBudget: options.toolBudget
+    fast: options.fast ?? agent.fast,
+    modelCandidates: shared.modelCandidates,
+    toolBudget: options.toolBudget,
+    allowZeroToolBudget: options.allowZeroToolBudget,
+    permissionRules,
+    permissionAuditPath,
+    childWatchdog,
+    waitToolEnabled: options.waitToolEnabled,
+    waitToolDefaultTimeoutMs: options.waitToolDefaultTimeoutMs,
+    capabilityCeiling: options.capabilityCeiling,
+    thinkingCeiling: options.thinkingCeiling,
+    extensionBindings: options.extensionBindings,
+    runtimeSnapshotHost: options.runtimeSnapshotHost
+  });
+  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 result = {
+  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),
+    task: shared.originalTask ?? task,
+    ...modelArg ? { model: modelArg } : {},
+    modelCandidates: shared.modelCandidates,
+    ...(options.fast ?? agent.fast) !== undefined ? { fast: options.fast ?? agent.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,
+    ...options.outputPath ? { outputPath: options.outputPath } : {},
+    outputMode: options.outputMode ?? "inline",
+    ...options.structuredOutput ? { structuredOutputSchema: options.structuredOutput.schema } : {},
+    ...options.extensionBindings ? { extensionBindings: options.extensionBindings } : {}
+  });
+  const result = withRunContext({
+    index: options.index ?? 0,
+    agent: agent.name,
+    task: shared.originalTask ?? task,
+    ...childSessionName ? { sessionName: childSessionName } : {},
+    ...options.agentContract ? { agentContract: options.agentContract } : {},
+    launchContractDigest,
+    launchResolvedExtensions,
     exitCode: 0,
+    outputState: "absent",
     messages: [],
     usage: emptyUsage(),
     model: modelArg,
+    ...resolvedThinking ? { thinking: resolvedThinking } : {},
     artifactPaths: shared.artifactPaths,
     transcriptPath: shared.transcriptWriter ? shared.artifactPaths?.transcriptPath : undefined,
     skills: shared.resolvedSkillNames,
     skillsWarning: shared.skillsWarning,
-    ...options.turnBudget ? { turnBudget: initialTurnBudgetState(options.turnBudget) } : {},
-    ...options.toolBudget ? { toolBudget: initialToolBudgetState(options.toolBudget) } : {}
-  };
+    ...options.toolBudget ? { toolBudget: initialToolBudgetState(options.toolBudget) } : {},
+    ...options.capabilityCeiling ? { capabilityCeiling: options.capabilityCeiling } : {},
+    ...capabilityAudit ? { capabilityAudit } : {}
+  }, options.context);
   const startTime = Date.now();
   if (options.structuredOutput) {
     try {
@@ -212,6 +450,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
   const progress = {
     index: options.index ?? 0,
     agent: agent.name,
+    ...childSessionName ? { sessionName: childSessionName } : {},
     status: "running",
     task,
     skills: shared.resolvedSkillNames,
@@ -219,12 +458,17 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     recentOutput: [...shared.attemptNotes],
     toolCount: 0,
     tokens: 0,
+    ...modelArg ? { model: modelArg } : {},
+    ...resolvedThinking ? { thinking: resolvedThinking } : {},
+    inputTokens: 0,
+    outputTokens: 0,
     durationMs: 0,
     lastActivityAt: startTime
   };
   result.progress = progress;
   const attemptTimeout = resolveAttemptTimeout(options);
   if (attemptTimeout?.remainingMs === 0) {
+    cleanupTempDir(tempDir);
     result.exitCode = 1;
     result.timedOut = true;
     result.error = attemptTimeout.message;
@@ -239,9 +483,34 @@ 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;
+  let structuredOutputToolInvoked = false;
+  let structuredOutputMessageStartIndex;
+  let toolAvailabilityError;
+  let abortedBySignal = options.signal?.aborted === true;
+  const spawnSpec = getPiSpawnCommand(args);
+  if (options.workflowChildPermitLaunch) {
+    const permitError = consumeWorkflowChildPermit(options.workflowChildPermitLaunch.permit, {
+      workflowRunId: options.workflowChildPermitLaunch.workflowRunId,
+      childKey: options.workflowChildPermitLaunch.childKey,
+      agent: agent.name,
+      launchContractDigest,
+      context: options.context ?? "fresh",
+      runner: "dm"
+    });
+    if (permitError) {
+      cleanupTempDir(tempDir);
+      result.exitCode = 1;
+      result.error = permitError;
+      result.finalOutput = permitError;
+      progress.status = "failed";
+      progress.error = permitError;
+      return result;
+    }
+  }
+  let afterCompactionSettlement = false;
   const exitCode = await new Promise((resolve) => {
-    const spawnSpec = getPiSpawnCommand(args);
     const proc = spawn(spawnSpec.command, spawnSpec.args, {
       cwd: options.cwd ?? runtimeCwd,
       env: spawnEnv,
@@ -249,9 +518,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       windowsHide: true
     });
     const jsonlWriter = createJsonlWriter(shared.jsonlPath, proc.stdout);
-    let buf = "";
     let processClosed = false;
-    let settled = false;
+    let lifecycleFinished = false;
     let detached = false;
     let intercomStarted = false;
     let assistantError;
@@ -261,19 +529,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     let timeoutTimer;
     let timeoutTerminationTimer;
     let timeoutHardKillTimer;
-    let turnBudgetSoftReached = false;
-    let turnBudgetTerminationTimer;
-    let turnBudgetHardKillTimer;
-    const clearTurnBudgetTimers = () => {
-      if (turnBudgetTerminationTimer) {
-        clearTimeout(turnBudgetTerminationTimer);
-        turnBudgetTerminationTimer = undefined;
-      }
-      if (turnBudgetHardKillTimer) {
-        clearTimeout(turnBudgetHardKillTimer);
-        turnBudgetHardKillTimer = undefined;
-      }
-    };
+    let protocolHardKillTimer;
     const clearTimeoutTimers = () => {
       if (timeoutTimer) {
         clearTimeout(timeoutTimer);
@@ -288,27 +544,59 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         timeoutHardKillTimer = undefined;
       }
     };
-    const detachForIntercom = () => {
-      detached = true;
-      processClosed = true;
-      result.detached = true;
-      result.detachedReason = "intercom coordination";
-      progress.status = "detached";
-      progress.durationMs = Date.now() - startTime;
-      result.progressSummary = {
-        toolCount: progress.toolCount,
-        tokens: progress.tokens,
-        durationMs: progress.durationMs
+    const detachForeground = (reason) => {
+      if (detached || processClosed || lifecycleFinished || options.signal?.aborted)
+        return false;
+      const receiptProgress = snapshotProgress(progress);
+      receiptProgress.status = "detached";
+      receiptProgress.durationMs = Date.now() - startTime;
+      const receipt = snapshotResult(result, receiptProgress);
+      receipt.exitCode = -2;
+      receipt.detached = true;
+      receipt.detachedReason = reason;
+      receipt.finalOutput = reason === "intercom coordination" ? "Detached for intercom coordination before task completion." : reason === "user request" ? "Detached at user request before task completion." : `Detached for ${reason} before task completion.`;
+      receipt.outputMode = options.outputMode ?? "inline";
+      if (options.outputPath) {
+        receipt.outputSaveError = reason === "user request" ? "Output file was not finalized because the subagent detached at user request." : `Output file was not finalized because the subagent detached for ${reason}.`;
+      }
+      receipt.progressSummary = {
+        toolCount: receiptProgress.toolCount,
+        tokens: receiptProgress.tokens,
+        durationMs: receiptProgress.durationMs
       };
-      finish(-2);
+      let accepted = false;
+      try {
+        accepted = options.onDetachReceipt?.(receipt) === true;
+      } catch {
+        return false;
+      }
+      if (!accepted)
+        return false;
+      detached = true;
+      return true;
     };
     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 finalDrainTimer;
     let finalHardKillTimer;
+    let watchdogTailTimer;
+    let childWatchdogState;
+    const updateChildWatchdogState = (snapshot) => {
+      childWatchdogState = snapshot;
+      result.watchdog = snapshot;
+      progress.watchdog = snapshot;
+    };
+    const clearWatchdogTailTimer = () => {
+      if (watchdogTailTimer) {
+        clearTimeout(watchdogTailTimer);
+        watchdogTailTimer = undefined;
+      }
+    };
     const clearFinalDrainTimers = () => {
       if (finalDrainTimer) {
         clearTimeout(finalDrainTimer);
@@ -320,20 +608,24 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       }
     };
     const startFinalDrain = () => {
-      if (childExited || finalDrainTimer || settled || processClosed || detached)
+      if (childWatchdogIsActive(childWatchdogState)) {
+        armWatchdogTail();
+        return;
+      }
+      if (childExited || finalDrainTimer || lifecycleFinished || processClosed)
         return;
       finalDrainTimer = setTimeout(() => {
-        if (settled || processClosed || detached)
+        if (lifecycleFinished || processClosed)
           return;
         const termSent = trySignalChild(proc, "SIGTERM");
         if (!termSent)
           return;
         forcedTerminationSignal = true;
-        if (!cleanTerminalAssistantStopReceived && !assistantError) {
-          result.error = result.error ?? `Subagent process did not exit within ${FINAL_STOP_GRACE_MS}ms after its final message. Forcing termination.`;
+        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.`;
         }
         finalHardKillTimer = setTimeout(() => {
-          if (settled || processClosed || detached)
+          if (lifecycleFinished || processClosed)
             return;
           forcedTerminationSignal = trySignalChild(proc, "SIGKILL") || forcedTerminationSignal;
         }, HARD_KILL_MS);
@@ -341,25 +633,69 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       }, FINAL_STOP_GRACE_MS);
       finalDrainTimer.unref?.();
     };
+    function armWatchdogTail() {
+      if (!cleanTerminalAssistantStopReceived && !agentSettledReceived || watchdogTailTimer || lifecycleFinished || processClosed)
+        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();
+        fireUpdate();
+      }, childWatchdog?.watchdogTailTimeoutMs ?? 120000);
+      watchdogTailTimer.unref?.();
+    }
+    const applyChildLifecycle = (action) => {
+      if (action === "cancel-drain") {
+        clearFinalDrainTimers();
+        clearWatchdogTailTimer();
+        return;
+      }
+      if (action === "start-drain")
+        startFinalDrain();
+    };
+    const childLifecycleState = { compactionRetryActive: false };
     const unsubscribeIntercomDetach = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-      if (!options.allowIntercomDetach || detached || processClosed || !intercomStarted)
+      if (!options.allowIntercomDetach || processClosed)
         return;
       if (!payload || typeof payload !== "object")
         return;
-      const requestId = payload.requestId;
+      const event = payload;
+      const requestId = event.requestId;
       if (typeof requestId !== "string" || requestId.length === 0)
         return;
-      options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: true });
-      detachForIntercom();
+      const hasRoute = event.runId !== undefined || event.agent !== undefined || event.childIndex !== undefined;
+      if (hasRoute) {
+        if (typeof event.runId === "string" && event.runId !== options.runId)
+          return;
+        if (typeof event.agent === "string" && event.agent !== agent.name)
+          return;
+        if (typeof event.childIndex === "number" && event.childIndex !== (options.index ?? 0))
+          return;
+      } else if (!intercomStarted)
+        return;
+      const accepted = detachForeground("intercom coordination");
+      options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted, runId: options.runId, agent: agent.name, childIndex: options.index ?? 0 });
     });
     const finish = (code) => {
-      if (settled)
+      if (lifecycleFinished)
         return;
-      settled = true;
+      lifecycleFinished = true;
       clearFinalDrainTimers();
+      clearWatchdogTailTimer();
       clearStdioGuard();
       clearTimeoutTimers();
-      clearTurnBudgetTimers();
+      clearAllToolTimeouts();
+      if (protocolHardKillTimer) {
+        clearTimeout(protocolHardKillTimer);
+        protocolHardKillTimer = undefined;
+      }
       if (activityTimer) {
         clearInterval(activityTimer);
         activityTimer = undefined;
@@ -378,6 +714,58 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     };
     let activeLongRunningNotified = false;
     let pendingToolResult;
+    let activeToolSequence = 0;
+    const activeToolCalls = new Map;
+    const activeToolKeysByName = new Map;
+    const latestActiveToolCall = () => [...activeToolCalls.values()].sort((left, right) => right.startedAt - left.startedAt)[0];
+    const refreshCurrentTool = () => {
+      const active = latestActiveToolCall();
+      if (!active) {
+        progress.currentTool = undefined;
+        progress.currentToolArgs = undefined;
+        progress.currentToolStartedAt = undefined;
+        progress.currentPath = undefined;
+        return;
+      }
+      progress.currentTool = active.tool;
+      progress.currentToolArgs = active.args;
+      progress.currentToolStartedAt = active.startedAt;
+      progress.currentPath = active.path;
+    };
+    const recordActiveToolCall = (event, args, now) => {
+      const key = toolTimeoutCallKey(event, ++activeToolSequence);
+      const path = resolveCurrentPath(event.toolName, args);
+      const active = {
+        key,
+        tool: event.toolName,
+        args: extractToolArgsPreview(args),
+        startedAt: now,
+        ...path !== undefined ? { path } : {}
+      };
+      activeToolCalls.set(key, active);
+      const keys = activeToolKeysByName.get(active.tool) ?? [];
+      keys.push(key);
+      activeToolKeysByName.set(active.tool, keys);
+      refreshCurrentTool();
+      return active;
+    };
+    const removeActiveToolCallKey = (key) => {
+      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);
+      return active;
+    };
+    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;
+      return key ? removeActiveToolCallKey(key) : undefined;
+    };
+    const openToolAttentionTarget = (now) => [...activeToolCalls.values()].filter((active) => shouldEmitOpenToolAttention({ config: controlConfig, currentTool: active.tool, currentToolStartedAt: active.startedAt, now })).sort((left, right) => left.startedAt - right.startedAt)[0];
     const mutatingFailures = createMutatingFailureState();
     const mutatingFailureWindowMs = 5 * 60000;
     const currentToolDurationMs = (now) => progress.currentToolStartedAt ? Math.max(0, now - progress.currentToolStartedAt) : undefined;
@@ -403,7 +791,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         currentTool: input.currentTool ?? progress.currentTool,
         currentToolDurationMs: input.currentToolDurationMs ?? currentToolDurationMs(now),
         currentPath: input.currentPath ?? progress.currentPath,
-        recentFailureSummary: input.recentFailureSummary
+        recentFailureSummary: input.recentFailureSummary,
+        taskPreview: task
       });
       emitControlEvent(event);
       return previous !== "needs_attention";
@@ -430,56 +819,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         currentTool: progress.currentTool,
         currentToolDurationMs: currentToolDurationMs(now),
         currentPath: progress.currentPath,
-        elapsedMs: now - startTime
+        elapsedMs: now - startTime,
+        taskPreview: task
       }));
       return true;
     };
-    const requestTurnBudgetAbort = (turnCount) => {
-      const budget = options.turnBudget;
-      if (!budget || result.timedOut || result.turnBudgetExceeded || interruptedByControl || processClosed || settled || detached)
-        return;
-      const message = turnBudgetExceededMessage(budget, turnCount);
-      result.turnBudgetExceeded = true;
-      result.wrapUpRequested = true;
-      result.turnBudget = turnBudgetState(budget, turnCount, true);
-      result.error = message;
-      result.finalOutput = message;
-      progress.status = "failed";
-      progress.error = message;
-      progress.durationMs = Date.now() - startTime;
-      fireUpdate();
-      trySignalChild(proc, "SIGINT");
-      turnBudgetTerminationTimer = setTimeout(() => {
-        if (processClosed || settled || detached || result.timedOut)
-          return;
-        trySignalChild(proc, "SIGTERM");
-      }, 1000);
-      turnBudgetTerminationTimer.unref?.();
-      turnBudgetHardKillTimer = setTimeout(() => {
-        if (processClosed || settled || detached || result.timedOut)
-          return;
-        trySignalChild(proc, "SIGKILL");
-      }, 4000);
-      turnBudgetHardKillTimer.unref?.();
-    };
-    const updateTurnBudget = (turnCount, terminalAssistantStop) => {
-      const budget = options.turnBudget;
-      if (!budget || result.timedOut || result.turnBudgetExceeded)
-        return;
-      if (turnCount < budget.maxTurns) {
-        result.turnBudget = { ...budget, outcome: "within-budget", turnCount };
-        return;
-      }
-      if (!turnBudgetSoftReached) {
-        turnBudgetSoftReached = true;
-        result.wrapUpRequested = true;
-        appendRecentOutput(progress, [turnBudgetSoftNote(budget, turnCount)]);
-      }
-      result.turnBudget = turnBudgetState(budget, turnCount, false);
-      if (shouldAbortForTurnBudget(budget, turnCount, terminalAssistantStop)) {
-        requestTurnBudgetAbort(turnCount);
-      }
-    };
     const updateActivityState = (now) => {
       if (!controlConfig.enabled)
         return false;
@@ -487,11 +831,24 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         config: controlConfig,
         startedAt: startTime,
         lastActivityAt: progress.lastActivityAt,
+        currentTool: progress.currentTool,
+        thinking: resolvedThinking,
         now
       });
       if (idleState === "needs_attention") {
         return progress.activityState === "needs_attention" ? false : emitNeedsAttention(now);
       }
+      const toolAttentionTarget = progress.activityState !== "needs_attention" ? openToolAttentionTarget(now) : undefined;
+      if (toolAttentionTarget) {
+        const durationMs = Math.max(0, now - toolAttentionTarget.startedAt);
+        return emitNeedsAttention(now, {
+          message: `${agent.name} has had tool '${toolAttentionTarget.tool}' open for ${Math.floor(durationMs / 1000)}s`,
+          reason: "tool_open_threshold",
+          currentTool: toolAttentionTarget.tool,
+          currentPath: toolAttentionTarget.path,
+          currentToolDurationMs: durationMs
+        });
+      }
       const activeReason = nextLongRunningTrigger(controlConfig, {
         startedAt: startTime,
         now,
@@ -504,7 +861,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       if (!options.onUpdate || processClosed)
         return;
       const progressSnapshot = snapshotProgress(progress);
-      const resultSnapshot = snapshotResult(result, progressSnapshot);
+      const resultSnapshot = snapshotStreamResult(result, progressSnapshot);
       const controlEvents = drainPendingControlEvents();
       options.onUpdate({
         content: [{ type: "text", text }],
@@ -520,9 +877,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       if (!options.onUpdate || processClosed)
         return;
       progress.durationMs = Date.now() - startTime;
-      const output = (result.timedOut || result.turnBudgetExceeded) && result.finalOutput ? result.finalOutput : getFinalOutput(result.messages);
+      const output = result.timedOut && result.finalOutput ? result.finalOutput : getFinalOutput(result.messages ?? []);
       emitUpdateSnapshot(output || "(running...)");
     };
+    const rawStdoutTail = createBoundedByteTail();
     const processLine = (line) => {
       if (!line.trim())
         return;
@@ -531,49 +889,91 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       try {
         evt = JSON.parse(line);
       } catch {
+        rawStdoutTail.push(`${line}
+`);
         shared.transcriptWriter?.writeStdoutLine(line);
+        shared.orcaProgressTab?.append(`${line}
+`);
         return;
       }
       shared.transcriptWriter?.writeChildEvent(evt);
+      shared.orcaProgressTab?.event(evt);
+      if (evt.type === "compaction_start")
+        compactionStartedReceived = true;
+      if (evt.type === "compaction_end" && evt.willRetry === true) {
+        compactionStartedReceived = false;
+        afterCompactionSettlement = false;
+      }
+      if (evt.type === "agent_start" || evt.type === "auto_retry_start") {
+        compactionStartedReceived = false;
+        afterCompactionSettlement = false;
+      }
+      const lifecycleAction = projectChildLifecycle(evt, false, childLifecycleState);
+      if (evt.type === "agent_settled" && lifecycleAction === "start-drain") {
+        agentSettledReceived = true;
+        afterCompactionSettlement = compactionStartedReceived;
+      }
+      applyChildLifecycle(lifecycleAction);
+      if (isChildWatchdogStatusEvent(evt)) {
+        if (!childWatchdog)
+          return;
+        const next = acceptChildWatchdogEvent({
+          current: childWatchdogState,
+          event: evt,
+          runId: options.runId,
+          agent: agent.name,
+          childIndex: options.index ?? 0
+        });
+        if (!next)
+          return;
+        updateChildWatchdogState(next);
+        if (childWatchdogIsActive(next)) {
+          clearFinalDrainTimers();
+          armWatchdogTail();
+        } else {
+          clearWatchdogTailTimer();
+          if (cleanTerminalAssistantStopReceived || agentSettledReceived)
+            startFinalDrain();
+        }
+        fireUpdate();
+        return;
+      }
       const now = Date.now();
       progress.durationMs = now - startTime;
       progress.lastActivityAt = now;
       updateActivityState(now);
       if (evt.type === "tool_execution_start") {
         const toolArgs = evt.args && typeof evt.args === "object" && !Array.isArray(evt.args) ? evt.args : {};
-        let shouldDetachForBlockingIntercom = false;
+        const activeTool = evt.toolName !== undefined ? recordActiveToolCall(evt, toolArgs, now) : undefined;
+        if (evt.toolName !== undefined)
+          armToolTimeout(evt);
+        if (options.structuredOutput && evt.toolName === "structured_output") {
+          structuredOutputToolInvoked = true;
+          structuredOutputMessageStartIndex = result.messages?.length ?? 0;
+        }
         if (options.allowIntercomDetach && (evt.toolName === "intercom" || evt.toolName === "contact_supervisor")) {
           intercomStarted = true;
-          shouldDetachForBlockingIntercom = evt.toolName === "intercom" && toolArgs.action === "ask" || evt.toolName === "contact_supervisor" && (toolArgs.reason === "need_decision" || toolArgs.reason === "interview_request");
         }
         progress.toolCount++;
         if (options.toolBudget) {
           result.toolBudget = toolBudgetState(options.toolBudget, progress.toolCount);
         }
-        progress.currentTool = evt.toolName;
-        progress.currentToolArgs = extractToolArgsPreview(toolArgs);
-        progress.currentToolStartedAt = now;
-        progress.currentPath = resolveCurrentPath(evt.toolName, toolArgs);
-        const mutates = isMutatingTool(evt.toolName, toolArgs);
+        const mutates = isMutatingTool(evt.toolName, toolArgs, agent.mutationTools);
         observedMutationAttempt = observedMutationAttempt || mutates;
-        pendingToolResult = { tool: evt.toolName ?? "tool", path: progress.currentPath, mutates, startedAt: now };
+        pendingToolResult = { tool: evt.toolName ?? "tool", path: activeTool?.path, mutates, startedAt: now };
         fireUpdate();
-        if (shouldDetachForBlockingIntercom && !detached && !processClosed) {
-          detachForIntercom();
-        }
       }
       if (evt.type === "tool_execution_end") {
-        if (progress.currentTool) {
+        clearActiveToolTimeout(evt);
+        const endedTool = removeActiveToolCall(evt);
+        if (endedTool) {
           progress.recentTools.push({
-            tool: progress.currentTool,
-            args: progress.currentToolArgs || "",
+            tool: endedTool.tool,
+            args: endedTool.args,
             endMs: now
           });
         }
-        progress.currentTool = undefined;
-        progress.currentToolArgs = undefined;
-        progress.currentToolStartedAt = undefined;
-        progress.currentPath = undefined;
+        refreshCurrentTool();
         fireUpdate();
       }
       if (evt.type === "message_end" && evt.message) {
@@ -581,21 +981,33 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         if (evt.message.role === "assistant") {
           result.usage.turns++;
           progress.turnCount = result.usage.turns;
-          const stopReason = evt.message.stopReason;
-          const hasToolCall = Array.isArray(evt.message.content) && evt.message.content.some((part) => part.type === "toolCall");
-          const terminalAssistantStop = stopReason === "stop" && !hasToolCall;
-          updateTurnBudget(result.usage.turns, terminalAssistantStop);
+          const toolCalls = Array.isArray(evt.message.content) ? evt.message.content.filter((part) => part.type === "toolCall") : [];
+          const hasToolCall = toolCalls.length > 0;
+          const terminalAssistantStop = evt.message.stopReason === "stop" && !hasToolCall;
           const u = evt.message.usage;
           if (u) {
+            const window = (u.input || 0) + (u.cacheRead || 0);
             result.usage.input += u.input || 0;
             result.usage.output += u.output || 0;
             result.usage.cacheRead += u.cacheRead || 0;
             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);
+          }
+          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);
+              if (modelVerificationError && !result.error)
+                result.error = modelVerificationError;
+            }
           }
-          if (!result.model && evt.message.model)
-            result.model = evt.message.model;
           if (evt.message.errorMessage)
             assistantError = evt.message.errorMessage;
           const assistantText = extractTextFromContent(evt.message.content);
@@ -605,13 +1017,31 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             if (!evt.message.errorMessage && assistantText.trim())
               assistantError = undefined;
             cleanTerminalAssistantStopReceived ||= !evt.message.errorMessage;
-            startFinalDrain();
+            clearAllToolTimeouts();
+            activeToolCalls.clear();
+            activeToolKeysByName.clear();
+            refreshCurrentTool();
+            applyChildLifecycle(projectChildLifecycle(evt, true, childLifecycleState));
           }
         }
         updateActivityState(now);
         fireUpdate();
       }
       if (evt.type === "tool_result_end" && evt.message) {
+        const toolResultCompletion = {
+          toolCallId: evt.message.toolCallId ?? evt.toolCallId,
+          toolName: evt.message.toolName ?? evt.toolName
+        };
+        clearActiveToolTimeout(toolResultCompletion);
+        const endedTool = removeActiveToolCall(toolResultCompletion);
+        if (endedTool) {
+          progress.recentTools.push({
+            tool: endedTool.tool,
+            args: endedTool.args,
+            endMs: now
+          });
+          refreshCurrentTool();
+        }
         result.messages.push(evt.message);
         const resultText = extractTextFromContent(evt.message.content);
         if (options.toolBudget && pendingToolResult && resultText.includes("Tool budget hard limit reached")) {
@@ -646,23 +1076,23 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         fireUpdate();
       }
     };
-    if (controlConfig.enabled) {
+    fireUpdate();
+    if (controlConfig.enabled || options.onUpdate) {
       activityTimer = setInterval(() => {
-        if (processClosed || settled || detached)
+        if (processClosed || lifecycleFinished) {
           return;
-        const now = Date.now();
-        if (updateActivityState(now)) {
-          progress.durationMs = now - startTime;
-          fireUpdate();
         }
+        updateActivityState(Date.now());
+        fireUpdate();
       }, 1000);
       activityTimer.unref?.();
     }
     if (attemptTimeout) {
       timeoutTimer = setTimeout(() => {
-        if (processClosed || settled || detached || interruptedByControl)
+        if (processClosed || lifecycleFinished || interruptedByControl)
           return;
         result.timedOut = true;
+        clearAllToolTimeouts();
         result.error = attemptTimeout.message;
         result.finalOutput = attemptTimeout.message;
         progress.status = "failed";
@@ -671,13 +1101,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         fireUpdate();
         trySignalChild(proc, "SIGINT");
         timeoutTerminationTimer = setTimeout(() => {
-          if (processClosed || settled || detached)
+          if (processClosed || lifecycleFinished)
             return;
           trySignalChild(proc, "SIGTERM");
         }, 1000);
         timeoutTerminationTimer.unref?.();
         timeoutHardKillTimer = setTimeout(() => {
-          if (processClosed || settled || detached)
+          if (processClosed || lifecycleFinished)
             return;
           trySignalChild(proc, "SIGKILL");
         }, 4000);
@@ -685,70 +1115,178 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
       }, attemptTimeout.remainingMs);
       timeoutTimer.unref?.();
     }
-    let stderrBuf = "";
-    const clearStdioGuard = attachPostExitStdioGuard(proc, { idleMs: 2000, hardMs: 8000 });
-    proc.stdout.on("data", (d) => {
-      buf += d.toString();
-      const lines = buf.split(`
-`);
-      buf = lines.pop() || "";
-      lines.forEach(processLine);
+    let toolTimeoutSequence = 0;
+    const activeToolTimeouts = new Map;
+    const activeToolTimeoutKeysByName = new Map;
+    let toolTimeoutTerminationTimer;
+    let toolTimeoutHardKillTimer;
+    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);
+      if (toolTimeoutTerminationTimer) {
+        clearTimeout(toolTimeoutTerminationTimer);
+        toolTimeoutTerminationTimer = undefined;
+      }
+      if (toolTimeoutHardKillTimer) {
+        clearTimeout(toolTimeoutHardKillTimer);
+        toolTimeoutHardKillTimer = undefined;
+      }
+    };
+    const terminateForToolTimeout = (message) => {
+      if (processClosed || lifecycleFinished || interruptedByControl)
+        return;
+      result.timedOut = true;
+      result.error = message;
+      result.finalOutput = message;
+      progress.status = "failed";
+      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)
+          return;
+        trySignalChild(proc, "SIGKILL");
+      }, 4000);
+      toolTimeoutHardKillTimer.unref?.();
+    };
+    const armToolTimeout = (event) => {
+      const timeoutForTool = effectiveToolTimeoutMs(event.toolName, options.toolTimeoutMs);
+      if (timeoutForTool === undefined)
+        return;
+      const elapsed = Date.now() - startTime;
+      const runRemaining = attemptTimeout ? Math.max(0, attemptTimeout.remainingMs - elapsed) : undefined;
+      if (runRemaining !== undefined && timeoutForTool >= runRemaining)
+        return;
+      const key = toolTimeoutCallKey(event, ++toolTimeoutSequence);
+      const toolName = event.toolName;
+      const timer = setTimeout(() => {
+        removeToolTimeoutKey(key);
+        terminateForToolTimeout(formatToolTimeoutMessage(toolName, timeoutForTool));
+      }, timeoutForTool);
+      timer.unref?.();
+      activeToolTimeouts.set(key, { toolName, timer });
+      const keys = activeToolTimeoutKeysByName.get(toolName) ?? [];
+      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))
     });
-    proc.stderr.on("data", (d) => {
-      stderrBuf += d.toString();
+    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)
+        return;
+      processClosed = true;
       clearFinalDrainTimers();
       clearStdioGuard();
       jsonlWriter.close().catch(() => {});
+      const toolDiagnosticError = readChildToolDiagnosticError(toolDiagnosticPath);
+      toolAvailabilityError = toolDiagnosticError;
+      result.runtimeAcknowledgedExtensions = readRuntimeAcknowledgedExtensions(runtimeAcknowledgedExtensionsPath);
       cleanupTempDir(tempDir);
-      if (buf.trim())
-        processLine(buf);
-      if (stderrBuf.trim())
-        shared.transcriptWriter?.writeStderrText(stderrBuf);
-      if (!result.error && assistantError)
-        result.error = assistantError;
-      const forcedDrainAfterFinalSuccess = forcedTerminationSignal && cleanTerminalAssistantStopReceived && !result.error;
-      if (code !== 0 && stderrBuf.trim() && !result.error && !forcedDrainAfterFinalSuccess) {
-        result.error = stderrBuf.trim();
+      stdoutReader.end();
+      stderrReader.end();
+      const stderr = stderrTail.text();
+      const rawStdout = rawStdoutTail.text();
+      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 finalCode = forcedDrainAfterFinalSuccess ? 0 : forcedTerminationSignal || signal ? code ?? 1 : code ?? 0;
-      if (detached) {
-        result.exitCode = result.error && finalCode === 0 ? 1 : finalCode;
-        progress.status = result.exitCode === 0 ? "completed" : "failed";
-        progress.durationMs = Date.now() - startTime;
-        if (result.error)
-          progress.error = result.error;
-        result.progressSummary = {
-          toolCount: progress.toolCount,
-          tokens: progress.tokens,
-          durationMs: progress.durationMs
-        };
-        const finalOutput = getFinalOutput(result.messages);
-        result.finalOutput = finalOutput.trim() || result.error || result.finalOutput || "Detached child exited without final output.";
-        if (result.artifactPaths && options.artifactConfig?.enabled !== false && options.artifactConfig?.includeOutput !== false) {
-          try {
-            writeArtifact(result.artifactPaths.outputPath, result.finalOutput);
-          } catch {}
-        }
-        options.onDetachedExit?.(snapshotResult(result, snapshotProgress(progress)));
-        finish(-2);
-        return;
+      if (!closeError && isUnexplainedProcessSignal({
+        processSignal: signal,
+        interrupted: result.interrupted,
+        timedOut: result.timedOut,
+        stopped: result.stopped,
+        forcedDrainAfterFinalSuccess: forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal
+      })) {
+        closeError = formatProcessSignalError(signal);
       }
-      processClosed = true;
+      if (code !== 0 && rawStdout.trim() && !closeError && !forcedDrainAfterFinalSuccess) {
+        closeError = rawStdout.trim();
+      }
+      if (code !== 0 && stderr.trim() && !closeError && !forcedDrainAfterFinalSuccess) {
+        closeError = stderr.trim();
+      }
+      const finalCode = forcedDrainAfterFinalSuccess && !forcedDrainAfterEmptyTerminal ? 0 : forcedTerminationSignal || signal ? code ?? 1 : code ?? 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);
-      if (stderrBuf.trim())
-        shared.transcriptWriter?.writeStderrText(stderrBuf);
+      stdoutReader.end();
+      stderrReader.end();
       if (!result.error) {
         result.error = error instanceof Error ? error.message : String(error);
       }
@@ -756,12 +1294,9 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     });
     if (options.signal) {
       const kill = () => {
-        if (processClosed || detached)
+        if (processClosed || lifecycleFinished)
           return;
-        if (options.allowIntercomDetach && intercomStarted && !detached) {
-          detachForIntercom();
-          return;
-        }
+        abortedBySignal = true;
         proc.kill("SIGTERM");
         setTimeout(() => !proc.killed && proc.kill("SIGKILL"), 3000);
       };
@@ -774,12 +1309,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     }
     if (options.interruptSignal) {
       const interrupt = () => {
-        if (processClosed || detached || settled)
+        if (processClosed || lifecycleFinished)
           return;
         if (result.timedOut)
           return;
         interruptedByControl = true;
         clearTimeoutTimers();
+        clearAllToolTimeouts();
         progress.status = "running";
         progress.durationMs = Date.now() - startTime;
         result.interrupted = true;
@@ -788,7 +1324,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         fireUpdate();
         trySignalChild(proc, "SIGINT");
         setTimeout(() => {
-          if (settled || processClosed || detached)
+          if (lifecycleFinished || processClosed)
             return;
           trySignalChild(proc, "SIGTERM");
         }, 1000).unref?.();
@@ -800,8 +1336,16 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         removeInterruptListener = () => options.interruptSignal?.removeEventListener("abort", interrupt);
       }
     }
+    try {
+      options.onDetachReady?.((reason = "user request") => detachForeground(reason));
+    } catch (error) {
+      appendRecentOutput(progress, [`Foreground detach callback failed: ${error instanceof Error ? error.message : String(error)}`]);
+    }
   });
   result.exitCode = exitCode;
+  if (afterCompactionSettlement) {
+    result[AFTER_COMPACTION_SETTLEMENT] = true;
+  }
   if (interruptedByControl) {
     result.exitCode = 0;
     result.interrupted = true;
@@ -817,42 +1361,62 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     };
     return result;
   }
-  if (result.detached) {
-    result.exitCode = 0;
-    result.finalOutput = "Detached for intercom coordination.";
-    return result;
+  if (progress.currentTool && isOrdinaryToolForMidToolExit(progress.currentTool) && !abortedBySignal && !result.timedOut && !result.stopped && !result.protocolError && !toolAvailabilityError) {
+    const processExitCode = result.exitCode;
+    result.exitCode = 1;
+    result.error = formatMidToolExitError({
+      toolName: progress.currentTool,
+      exitCode: processExitCode,
+      processSignal: result.processSignal
+    });
   }
+  result.error = formatSubagentExtensionConflictError(result.error, {
+    agent: agent.name,
+    ambientExtensionsEnabled: !launchResolvedExtensions.disableAmbientExtensions
+  });
   if (result.error && result.exitCode === 0) {
     result.exitCode = 1;
   }
-  if (result.exitCode === 0 && !result.error) {
-    const errInfo = detectSubagentError(result.messages);
-    if (errInfo.hasError) {
-      result.exitCode = errInfo.exitCode ?? 1;
-      result.error = errInfo.details ? `${errInfo.errorType} failed (exit ${errInfo.exitCode}): ${errInfo.details}` : `${errInfo.errorType} failed with exit code ${errInfo.exitCode}`;
-    }
-  }
-  if (result.exitCode === 0 && !result.error) {
-    const finalText = getFinalOutput(result.messages);
-    const missingStructuredOutput = options.structuredOutput ? !existsSync(options.structuredOutput.outputPath) : false;
-    if (!finalText?.trim() && (!options.structuredOutput || missingStructuredOutput)) {
-      result.exitCode = 1;
-      result.error = "Subagent produced no output (possible model cold-start or empty response).";
-    }
-  }
+  let validatedStructuredOutput = false;
   if (options.structuredOutput && result.exitCode === 0 && !result.error) {
-    const structured = readStructuredOutput({
-      schema: options.structuredOutput.schema,
-      schemaPath: options.structuredOutput.schemaPath,
-      outputPath: options.structuredOutput.outputPath
-    });
     result.structuredOutputSchemaPath = options.structuredOutput.schemaPath;
     result.structuredOutputPath = options.structuredOutput.outputPath;
-    if (structured.error) {
+    if (!structuredOutputToolInvoked) {
       result.exitCode = 1;
-      result.error = structured.error;
+      result.error = MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
+      result.structuredOutputFailed = true;
     } else {
-      result.structuredOutput = structured.value;
+      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) {
+    const messages = result.messages ?? [];
+    const finalText = getFinalOutput(messages);
+    const errorMessages = validatedStructuredOutput ? messages.slice(structuredOutputMessageStartIndex ?? messages.length) : messages;
+    const errInfo = detectSubagentError(errorMessages);
+    const missingOutput = !finalText?.trim() && !validatedStructuredOutput;
+    const terminalEmptyAfterUsefulWork = !validatedStructuredOutput && hasEmptyTerminalAssistantResponse(messages) && (progress.toolCount > 0 || Boolean(finalText?.trim()));
+    if ((missingOutput || terminalEmptyAfterUsefulWork) && (!errInfo.hasError || hasEmptyTerminalAssistantResponse(messages))) {
+      result.exitCode = 1;
+      result.error = formatEmptyTerminalAssistantResponseError(messages);
+    } else if (errInfo.hasError) {
+      result.exitCode = errInfo.exitCode ?? 1;
+      result.error = errInfo.details ? `${errInfo.errorType} failed (exit ${errInfo.exitCode}): ${errInfo.details}` : `${errInfo.errorType} failed with exit code ${errInfo.exitCode}`;
     }
   }
   progress.status = result.exitCode === 0 ? "completed" : "failed";
@@ -864,37 +1428,89 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
     }
   }
   result.progressSummary = {
+    ...childSessionName ? { sessionName: childSessionName } : {},
     toolCount: progress.toolCount,
     tokens: progress.tokens,
     durationMs: progress.durationMs
   };
-  const acceptanceOutput = getFinalOutput(result.messages);
+  const mutationEvidence = collectTrackedMutationEvidence(mutationSnapshot, options.cwd ?? runtimeCwd);
+  const acceptanceOutput = getFinalOutput(result.messages ?? []);
   let fullOutput = stripAcceptanceReport(acceptanceOutput);
+  if (!fullOutput.trim() && result.structuredOutput !== undefined)
+    fullOutput = JSON.stringify(result.structuredOutput, null, 2);
+  result.outputState = fullOutput.trim() || result.structuredOutput !== undefined ? "present" : "absent";
   if (result.timedOut) {
     const timeoutMessage = formatTimeoutMessage(options.timeoutMs ?? 0);
+    let requiredOutputMissing;
+    if (options.outputMode === "file-only" && options.outputPath) {
+      const outputChanged = hasSingleOutputChangedSinceSnapshot(options.outputPath, shared.outputSnapshot);
+      requiredOutputMissing = outputChanged === undefined ? undefined : !outputChanged;
+    } else if (options.structuredOutput) {
+      requiredOutputMissing = !existsSync(options.structuredOutput.outputPath);
+    }
+    result.timeoutRecovery = buildTimeoutRecoverySummary({
+      termination: "timed-out",
+      evidence: mutationEvidence,
+      requiredOutputMissing,
+      currentTool: progress.currentTool,
+      currentToolArgs: progress.currentToolArgs,
+      currentPath: progress.currentPath,
+      sessionFile: options.sessionFile,
+      transcriptPath: shared.transcriptWriter ? shared.artifactPaths?.transcriptPath : undefined,
+      artifactPaths: shared.artifactPaths
+    });
     fullOutput = fullOutput.trim() ? `${timeoutMessage}
 
+${result.timeoutRecovery.message}
+
 Partial output before timeout:
-${fullOutput}` : timeoutMessage;
-  } else if (result.turnBudgetExceeded && result.turnBudget) {
-    fullOutput = formatTurnBudgetOutput(turnBudgetExceededMessage(result.turnBudget, result.turnBudget.turnCount), fullOutput);
-  } else if (result.wrapUpRequested && result.turnBudget?.outcome === "wrap-up-requested") {
-    const note = turnBudgetSoftNote(result.turnBudget, result.turnBudget.wrapUpRequestedAtTurn ?? result.turnBudget.turnCount);
-    fullOutput = fullOutput.trim() ? `${note}
+${fullOutput}` : `${timeoutMessage}
 
-${fullOutput}` : note;
+${result.timeoutRecovery.message}`;
   }
-  const completionGuard = result.exitCode === 0 && !result.error && agent.completionGuard !== false ? evaluateCompletionMutationGuard({
+  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: agent.tools,
-    mcpDirectTools: agent.mcpDirectTools
+    messages: result.messages ?? [],
+    tools: contractTools,
+    mcpDirectTools: toolPlan.effectiveMcpTools,
+    mutationTools: agent.mutationTools,
+    toolAvailabilityError,
+    mutationEvidence
   }) : undefined;
-  if (completionGuard?.triggered && !observedMutationAttempt) {
+  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 = `Subagent completed without making edits for an implementation task.
-It appears to have returned planning or scratchpad output instead of applying changes.`;
+    result.error = completionEvidence.legacyFailureError;
     progress.status = "failed";
     progress.error = result.error;
     emitControlEvent(buildControlEvent({
@@ -909,12 +1525,19 @@ It appears to have returned planning or scratchpad output instead of applying ch
     }));
   }
   if (options.outputPath && result.exitCode === 0) {
-    const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
+    const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot, options.outputClaimPath);
     fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
     result.savedOutputPath = resolvedOutput.savedPath;
     result.outputSaveError = resolvedOutput.saveError;
+    if (resolvedOutput.fatalError) {
+      result.exitCode = 1;
+      result.error = result.error ? `${result.error}
+${resolvedOutput.saveError}` : resolvedOutput.saveError;
+    }
     if (resolvedOutput.savedPath) {
       result.outputReference = formatSavedOutputReference(resolvedOutput.savedPath, fullOutput);
+      if (result.outputState === "absent")
+        result.outputState = "unknown";
     }
   }
   artifactOutputByResult.set(result, fullOutput);
@@ -925,7 +1548,7 @@ It appears to have returned planning or scratchpad output instead of applying ch
   if (options.onUpdate) {
     const finalText = result.finalOutput || result.error || "(no output)";
     const progressSnapshot = snapshotProgress(progress);
-    const resultSnapshot = snapshotResult(result, progressSnapshot);
+    const resultSnapshot = snapshotStreamResult(result, progressSnapshot);
     options.onUpdate({
       content: [{ type: "text", text: finalText }],
       details: {
@@ -938,21 +1561,90 @@ It appears to have returned planning or scratchpad output instead of applying ch
   }
   return result;
 }
-export async function runSync(runtimeCwd, agents, agentName, task, options) {
+async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, options) {
+  const effectiveCwd = options.cwd ?? runtimeCwd;
+  const cwdError = preflightLaunchCwd(options.requestedCwd ?? effectiveCwd, effectiveCwd);
+  if (cwdError) {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agentName,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: cwdError
+    }, options.context));
+  }
+  options = {
+    ...options,
+    capabilityCeiling: intersectSubagentCapabilityCeilings(options.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(options.parentSessionId), decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]))
+  };
+  const childSessionName = deriveChildSessionName({ agent: agentName, task });
   const agent = agents.find((a) => a.name === agentName);
   if (!agent) {
-    return {
+    const diagnosticContext = options.unknownAgentDiagnosticContext ?? unknownAgentDiagnosticContext(discoverAgents(path.resolve(options.cwd ?? runtimeCwd), "both"));
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
       agent: agentName,
       task,
       exitCode: 1,
       messages: [],
       usage: emptyUsage(),
-      error: `Unknown agent: ${agentName}`
-    };
+      error: formatUnknownAgentError(agentName, diagnosticContext)
+    }, options.context));
   }
+  options = {
+    ...options,
+    thinkingCeiling: intersectThinkingCeilings(options.thinkingCeiling, agent.maxThinking, decodeThinkingCeiling(process.env[SUBAGENT_THINKING_CEILING_ENV]))
+  };
+  try {
+    assertAgentAllowedByCapabilityCeiling(agent.name, options.capabilityCeiling);
+  } catch (error) {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agent.name,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: error instanceof Error ? error.message : String(error),
+      ...options.capabilityCeiling ? { capabilityCeiling: options.capabilityCeiling } : {}
+    }, options.context));
+  }
+  const acceptanceErrors = validateAcceptanceInput(options.acceptance);
+  if (acceptanceErrors.length > 0) {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agentName,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: acceptanceErrors.join(" ")
+    }, options.context));
+  }
+  const toolTimeout = resolveToolTimeoutMs({
+    callValue: options.toolTimeoutMs,
+    agentValue: agent.defaultToolTimeoutMs,
+    configValue: options.configToolTimeoutMs,
+    envValue: toolTimeoutFromEnv()
+  });
+  if (toolTimeout.error) {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agentName,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: toolTimeout.error
+    }, options.context));
+  }
+  options = { ...options, toolTimeoutMs: toolTimeout.toolTimeoutMs };
   const outputModeValidationError = validateFileOnlyOutputMode(options.outputMode, options.outputPath, `Single run (${agentName})`);
   if (outputModeValidationError) {
-    return {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
       agent: agentName,
       task,
       exitCode: 1,
@@ -960,34 +1652,41 @@ export async function runSync(runtimeCwd, agents, agentName, task, options) {
       usage: emptyUsage(),
       outputMode: options.outputMode,
       error: outputModeValidationError
-    };
+    }, options.context));
   }
   const shareEnabled = options.share === true;
   const effectiveAcceptance = resolveEffectiveAcceptance({
     explicit: options.acceptance,
     agentName,
+    acceptanceRole: agent.acceptanceRole,
     task,
     mode: options.acceptanceContext?.mode ?? "single",
     async: options.acceptanceContext?.async,
     dynamic: options.acceptanceContext?.dynamic,
-    dynamicGroup: options.acceptanceContext?.dynamicGroup
+    dynamicGroup: options.acceptanceContext?.dynamicGroup,
+    agentContract: options.agentContract
   });
-  const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance);
+  const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance, { reportOptional: isAgentContractV1(options.agentContract), structuredOutput: Boolean(options.structuredOutput?.acceptanceReportPath) });
   const taskWithAcceptance = acceptancePrompt ? `${task}
 ${acceptancePrompt}` : task;
+  options.onEffectivePrompt?.(taskWithAcceptance);
   const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
+  if (options.context === "fork" && options.sessionFile && existsSync(options.sessionFile)) {
+    alignForkedSessionCwd(options.sessionFile, options.cwd ?? runtimeCwd);
+  }
   const skillNames = options.skills ?? agent.skills ?? [];
   const skillCwd = options.cwd ?? runtimeCwd;
-  const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, skillCwd, runtimeCwd);
+  const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, skillCwd, runtimeCwd, agent.skillPath, agent.filePath ? path.dirname(agent.filePath) : skillCwd);
   if (skillNames.some((skill) => skill.trim() === "dm-subagents") && missingSkills.includes("dm-subagents")) {
-    return {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
       agent: agentName,
       task,
       exitCode: 1,
       messages: [],
       usage: emptyUsage(),
       error: "Skills not found: dm-subagents"
-    };
+    }, options.context));
   }
   let systemPrompt = agent.systemPrompt?.trim() || "";
   if (resolvedSkills.length > 0) {
@@ -1002,12 +1701,42 @@ ${skillInjection}` : skillInjection;
 
 ${memoryInjection}` : memoryInjection;
   }
-  systemPrompt = injectOutputPathSystemPrompt(systemPrompt, options.outputPath);
-  const candidates = buildModelCandidates(options.modelOverride ?? agent.model, agent.fallbackModels, options.availableModels, options.preferredModelProvider, { scope: options.modelScope });
+  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));
+  }
+  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 });
+    }
+  } catch (error) {
+    return redactResultPrompt(withRunContext({
+      index: options.index ?? 0,
+      agent: agent.name,
+      task,
+      exitCode: 1,
+      messages: [],
+      usage: emptyUsage(),
+      error: error instanceof Error ? error.message : String(error)
+    }, options.context));
+  }
   const attemptedModels = [];
   const modelAttempts = [];
   const aggregateUsage = emptyUsage();
   const attemptNotes = [];
+  const launchWarnings = { emitted: false };
   let totalToolCount = 0;
   let totalDurationMs = 0;
   let artifactPathsResult;
@@ -1019,7 +1748,8 @@ ${memoryInjection}` : memoryInjection;
     if (options.artifactConfig?.includeInput !== false) {
       writeArtifact(artifactPathsResult.inputPath, `# Task for ${agentName}
 
-${taskWithAcceptance}`);
+${PROMPT_REDACTED}; live Prompt Audit only.
+`);
     }
     if (options.artifactConfig?.includeJsonl !== false) {
       jsonlPath = artifactPathsResult.jsonlPath;
@@ -1033,116 +1763,265 @@ ${taskWithAcceptance}`);
         childIndex: options.index,
         cwd: options.cwd ?? runtimeCwd
       });
-      transcriptWriter.writeInitialUserMessage(taskWithAcceptance);
+      transcriptWriter.writeInitialUserMessage(`${PROMPT_REDACTED}; live Prompt Audit only.`);
     }
   }
-  let lastResult;
-  const modelsToTry = candidates.length > 0 ? candidates : [undefined];
-  for (let i = 0;i < modelsToTry.length; i++) {
-    const candidate = modelsToTry[i];
-    const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
-    const result = await runSingleAttempt(runtimeCwd, agent, taskWithAcceptance, candidate, options, {
-      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,
-      outputSnapshot,
-      originalTask: task
+  const orcaProgressTab = createOrcaProgressTab({
+    cwd: options.cwd ?? runtimeCwd,
+    runId: options.runId,
+    agent: agentName,
+    index: options.index ?? 0
+  });
+  if (orcaProgressTab)
+    options.onOrcaProgressTabCreated?.(orcaProgressTab);
+  const persistResultMetadata = (target) => {
+    persistSingleResultMetadata({
+      metadataPath: artifactPathsResult?.metadataPath,
+      enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
+      runId: options.runId,
+      agent: agentName,
+      task,
+      result: target
     });
-    lastResult = result;
-    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 (result.timedOut || result.turnBudgetExceeded) {
-      break;
-    }
-    if (attemptSucceeded) {
-      break;
+  };
+  let intercomDetached = false;
+  let detachedReason;
+  const attemptOptions = {
+    ...options,
+    onDetachReceipt: (receipt) => {
+      receipt.acceptance = buildPendingAcceptanceLedger(effectiveAcceptance);
+      try {
+        persistResultMetadata(receipt);
+      } catch (error) {
+        receipt.metadataSaveError = error instanceof Error ? error.message : String(error);
+      }
+      const accepted = options.onDetachReceipt?.(receipt) === true;
+      if (accepted) {
+        detachedReason = receipt.detachedReason;
+        if (receipt.detachedReason === "intercom coordination")
+          intercomDetached = true;
+      }
+      return accepted;
     }
-    if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {
-      break;
+  };
+  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;
+      }
     }
-    attemptNotes.push(formatModelAttemptNote(attempt, modelsToTry[i + 1]));
-  }
-  const result = lastResult ?? {
+  const result = withRunContext(lastResult ?? {
+    index: options.index ?? 0,
     agent: agentName,
     task,
     exitCode: 1,
     messages: [],
     usage: emptyUsage(),
     error: "Subagent did not produce a result."
-  };
+  }, options.context);
+  result.task = task;
   result.usage = aggregateUsage;
   result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
   result.modelAttempts = modelAttempts.length > 0 ? modelAttempts : undefined;
   result.progressSummary = {
+    ...childSessionName ? { sessionName: childSessionName } : {},
     toolCount: totalToolCount,
     tokens: aggregateUsage.input + aggregateUsage.output,
     durationMs: totalDurationMs
   };
-  if (attemptNotes.length > 0 && result.progress) {
-    result.progress.recentOutput = [...attemptNotes, ...result.progress.recentOutput];
-    if (result.progress.recentOutput.length > 50) {
-      result.progress.recentOutput.splice(50);
-    }
-  }
   if (transcriptWriter)
     result.transcriptPath = artifactPathsResult?.transcriptPath;
   if (transcriptWriter?.getError())
     result.transcriptError = transcriptWriter.getError();
-  if (artifactPathsResult && options.artifactConfig?.enabled !== false) {
-    result.artifactPaths = artifactPathsResult;
-    if (options.artifactConfig?.includeOutput !== false) {
-      writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(result) ?? result.finalOutput ?? "");
-    }
-    if (options.artifactConfig?.includeMetadata !== false) {
-      writeMetadata(artifactPathsResult.metadataPath, {
-        runId: options.runId,
-        agent: agentName,
-        task,
-        exitCode: result.exitCode,
-        usage: result.usage,
-        model: result.model,
-        attemptedModels: result.attemptedModels,
-        modelAttempts: result.modelAttempts,
-        durationMs: result.progressSummary?.durationMs,
-        toolCount: result.progressSummary?.toolCount,
-        error: result.error,
-        ...transcriptWriter ? { transcriptPath: artifactPathsResult.transcriptPath } : {},
-        transcriptError: result.transcriptError,
-        skills: result.skills,
-        skillsWarning: result.skillsWarning,
-        timestamp: Date.now()
-      });
-    }
-    if (options.maxOutput) {
+  try {
+    if (artifactPathsResult && options.artifactConfig?.enabled !== false) {
+      result.artifactPaths = artifactPathsResult;
+      if (options.artifactConfig?.includeOutput !== false) {
+        writeArtifact(artifactPathsResult.outputPath, formatOutputArtifactContent({
+          output: artifactOutputByResult.get(result) ?? result.finalOutput ?? "",
+          error: result.error,
+          transcriptPath: result.transcriptPath,
+          metadataPath: options.artifactConfig?.includeMetadata === false ? undefined : artifactPathsResult.metadataPath
+        }));
+      }
+      if (options.maxOutput) {
+        const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
+        const truncationResult = truncateOutput(result.finalOutput ?? "", config, artifactPathsResult.outputPath);
+        if (truncationResult.truncated)
+          result.truncation = truncationResult;
+      }
+    } else if (options.maxOutput) {
       const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
-      const truncationResult = truncateOutput(result.finalOutput ?? "", config, artifactPathsResult.outputPath);
+      const truncationResult = truncateOutput(result.finalOutput ?? "", config);
       if (truncationResult.truncated)
         result.truncation = truncationResult;
     }
-  } else if (options.maxOutput) {
-    const config = { ...DEFAULT_MAX_OUTPUT, ...options.maxOutput };
-    const truncationResult = truncateOutput(result.finalOutput ?? "", config);
-    if (truncationResult.truncated)
-      result.truncation = truncationResult;
+  } catch (error) {
+    const message = `Artifact output post-processing failed: ${error instanceof Error ? error.message : String(error)}`;
+    result.outputSaveError = result.outputSaveError ? `${result.outputSaveError}
+${message}` : message;
   }
   if (options.sessionFile && (existsSync(options.sessionFile) || result.messages?.length)) {
     result.sessionFile = options.sessionFile;
@@ -1151,21 +2030,201 @@ ${taskWithAcceptance}`);
     if (sessionFile)
       result.sessionFile = sessionFile;
   }
-  result.acceptance = result.timedOut ? buildSkippedAcceptanceLedger(effectiveAcceptance, { id: "timeout", message: "Acceptance was not evaluated because the subagent timed out." }) : result.turnBudgetExceeded ? buildSkippedAcceptanceLedger(effectiveAcceptance, { id: "turn-budget", message: "Acceptance was not evaluated because the subagent exceeded its turn budget." }) : await evaluateAcceptance({
-    acceptance: effectiveAcceptance,
-    output: acceptanceOutputByResult.get(result) ?? result.finalOutput ?? "",
-    cwd: options.cwd ?? runtimeCwd
-  });
+  const childWrittenOutput = options.outputPath ? extractChildWrittenOutput(result.messages, options.outputPath, options.cwd ?? runtimeCwd) : undefined;
+  try {
+    if (result.interrupted && detachedReason === "user request") {
+      result.acceptance = buildInterruptedAcceptanceLedger(effectiveAcceptance);
+    } else if (result.stopped) {
+      result.acceptance = buildSkippedAcceptanceLedger(effectiveAcceptance, { id: "stopped", message: "Acceptance was not evaluated because the subagent was stopped." });
+    } else if (result.timedOut) {
+      result.acceptance = buildSkippedAcceptanceLedger(effectiveAcceptance, { id: "timeout", message: "Acceptance was not evaluated because the subagent timed out." });
+    } else {
+      result.acceptance = await evaluateAcceptance({
+        acceptance: effectiveAcceptance,
+        output: acceptanceOutputByResult.get(result) ?? result.finalOutput ?? "",
+        report: result.structuredAcceptanceReport,
+        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),
+        artifactsDir: options.artifactsDir,
+        runId: options.runId
+      });
+    }
+  } catch (error) {
+    const message = `Acceptance evaluation failed: ${error instanceof Error ? error.message : String(error)}`;
+    result.acceptance = buildSkippedAcceptanceLedger(effectiveAcceptance, { id: "acceptance-evaluation", message });
+  }
   const acceptanceFailure = acceptanceFailureMessage(result.acceptance);
   stripAcceptanceReportsFromMessages(result.messages);
-  if (acceptanceFailure && result.acceptance.explicit && result.exitCode === 0 && !result.detached && !result.interrupted && !result.timedOut) {
+  if (acceptanceFailure && result.acceptance.explicit && result.exitCode === 0 && !result.interrupted && !result.timedOut && !isAgentContractV1(options.agentContract)) {
     result.exitCode = 1;
+    if (result.savedOutputPath) {
+      result.finalOutput = finalizeSingleOutput({
+        fullOutput: result.finalOutput ?? "",
+        outputPath: options.outputPath,
+        outputMode: result.outputMode,
+        exitCode: result.exitCode,
+        preserveSavedOutput: true,
+        savedPath: result.savedOutputPath,
+        outputReference: result.outputReference
+      }).displayOutput;
+      artifactOutputByResult.set(result, result.finalOutput);
+    }
     result.error = result.error ? `${result.error}
 ${acceptanceFailure}` : acceptanceFailure;
+    if (artifactPathsResult && options.artifactConfig?.enabled !== false && options.artifactConfig?.includeOutput !== false) {
+      try {
+        writeArtifact(artifactPathsResult.outputPath, formatOutputArtifactContent({
+          output: artifactOutputByResult.get(result) ?? result.finalOutput ?? "",
+          error: result.error,
+          transcriptPath: result.transcriptPath,
+          metadataPath: options.artifactConfig?.includeMetadata === false ? undefined : artifactPathsResult.metadataPath
+        }));
+      } catch (error) {
+        const message = `Artifact output post-processing failed: ${error instanceof Error ? error.message : String(error)}`;
+        result.outputSaveError = result.outputSaveError ? `${result.outputSaveError}
+${message}` : message;
+      }
+    }
     if (result.progress) {
       result.progress.status = "failed";
       result.progress.error = result.error;
     }
   }
+  if (isAgentContractV1(options.agentContract))
+    attachContractProjections(result);
+  redactResultPrompt(result);
+  try {
+    persistResultMetadata(result);
+  } catch (error) {
+    result.metadataSaveError = error instanceof Error ? error.message : String(error);
+  }
   return result;
 }
+async function runSyncCompletion(runtimeCwd, agents, agentName, task, options) {
+  let orcaProgressTab;
+  try {
+    const result = await runSyncCompletionInner(runtimeCwd, agents, agentName, task, {
+      ...options,
+      onOrcaProgressTabCreated: (tab) => {
+        orcaProgressTab = tab;
+      }
+    });
+    orcaProgressTab?.finish(result.stopped ? "stopped" : result.exitCode === 0 && !result.error ? "completed" : "failed", result.sessionFile);
+    return result;
+  } catch (error) {
+    orcaProgressTab?.finish("failed");
+    throw error;
+  }
+}
+export async function runSync(runtimeCwd, agents, agentName, task, options) {
+  const strictContract = isAgentContractV1(options.agentContract);
+  let detachedReason;
+  let publishedReceipt;
+  let activeDetachAttempt;
+  let detachReadyPublished = false;
+  let resolveReceipt;
+  const receipt = new Promise((resolve) => {
+    resolveReceipt = resolve;
+  });
+  const originSignal = options.signal;
+  const originController = new AbortController;
+  const forwardOriginAbort = () => {
+    if (!detachedReason)
+      originController.abort(originSignal?.reason);
+  };
+  if (originSignal?.aborted)
+    forwardOriginAbort();
+  else
+    originSignal?.addEventListener("abort", forwardOriginAbort, { once: true });
+  const completion = runSyncCompletion(runtimeCwd, agents, agentName, task, {
+    ...options,
+    signal: originController.signal,
+    onDetachedExit: undefined,
+    onDetachReceipt: (detachedReceipt) => {
+      if (detachedReason || publishedReceipt)
+        return false;
+      publishedReceipt = structuredClone(detachedReceipt);
+      const callerReceipt = structuredClone(detachedReceipt);
+      publishedReceipt.agentContract = strictContract ? { version: 1 } : undefined;
+      callerReceipt.agentContract = strictContract ? { version: 1 } : undefined;
+      detachedReason = detachedReceipt.detachedReason ?? "user request";
+      resolveReceipt(callerReceipt);
+      return true;
+    },
+    onDetachReady: (detachAttempt) => {
+      activeDetachAttempt = detachAttempt;
+      if (detachReadyPublished)
+        return;
+      detachReadyPublished = true;
+      options.onDetachReady?.((reason = "user request") => {
+        if (detachedReason || originController.signal.aborted)
+          return false;
+        return activeDetachAttempt?.(reason) ?? false;
+      });
+    }
+  });
+  const authoritativeCompletion = completion.catch((error) => {
+    if (!publishedReceipt || !detachedReason)
+      throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    const failureMessage = `Detached completion pipeline failed after receipt: ${message}`;
+    const failedProgress = publishedReceipt.progress ? { ...publishedReceipt.progress, status: "failed", error: failureMessage } : {
+      index: options.index ?? 0,
+      agent: publishedReceipt.agent,
+      status: "failed",
+      task: publishedReceipt.task,
+      recentTools: [],
+      recentOutput: [],
+      toolCount: publishedReceipt.progressSummary?.toolCount ?? 0,
+      tokens: publishedReceipt.progressSummary?.tokens ?? 0,
+      durationMs: publishedReceipt.progressSummary?.durationMs ?? 0,
+      error: failureMessage
+    };
+    const failedResult = redactResultPrompt({
+      ...publishedReceipt,
+      detached: undefined,
+      detachedReason,
+      exitCode: 1,
+      error: failureMessage,
+      finalOutput: failureMessage,
+      progress: failedProgress,
+      progressSummary: {
+        toolCount: failedProgress.toolCount,
+        tokens: failedProgress.tokens,
+        durationMs: failedProgress.durationMs
+      },
+      acceptance: publishedReceipt.acceptance ? buildSkippedAcceptanceLedger(publishedReceipt.acceptance.effectiveAcceptance, { id: "completion-pipeline", message: failureMessage }) : undefined
+    });
+    if (strictContract)
+      attachContractProjections(failedResult);
+    try {
+      persistSingleResultMetadata({
+        metadataPath: failedResult.artifactPaths?.metadataPath,
+        enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
+        runId: options.runId,
+        agent: failedResult.agent,
+        task: failedResult.task,
+        result: failedResult
+      });
+    } catch (metadataError) {
+      failedResult.metadataSaveError = metadataError instanceof Error ? metadataError.message : String(metadataError);
+    }
+    return failedResult;
+  });
+  let terminalCallbackInvoked = false;
+  authoritativeCompletion.then((terminalResult) => {
+    if (!detachedReason || terminalCallbackInvoked)
+      return;
+    terminalCallbackInvoked = true;
+    terminalResult.detached = undefined;
+    terminalResult.detachedReason = detachedReason;
+    try {
+      options.onDetachedExit?.(terminalResult);
+    } catch {}
+  }).catch(() => {}).finally(() => {
+    originSignal?.removeEventListener("abort", forwardOriginAbort);
+  });
+  return Promise.race([authoritativeCompletion, receipt]);
+}