@sema-agent/core 7.7.0 → 7.9.0

package/dist/core/runner/runtask.js

@@ -1,30 +1,26 @@
-import { persistedReadDenyEntryProblem } from "../../tools/fs/read-deny.js";
 import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
 import { mintSystemReminder, openSystemReminder } from "../reminder-mint.js";
-import { GLOBAL_USAGE_KEY, resolveUsageWindows, usageRetryAfterMs } from "../usage-window-store.js";
 import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
 import { planRejectionClears, resolveTriggerWindow } from "../context-edit.js";
 import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, F012_CHECKPOINT_VERSION, MAX_SUPPORTED_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, FACE_CHECKPOINT_VERSION, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, resolveCheckpointStore, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, validatePendingSteer, winnerFromOutcome, realApprovalOrgFact } from "../checkpoint-store.js";
+import { CheckpointError, remainingBudgetMicroUsd, readPendingSteerQueue, remainingTokens, resolveCheckpointStore, LEGACY_PENDING_STEER_INPUT_ID, MAX_STEER_INPUT_ID_CHARS, realApprovalOrgFact } from "../checkpoint-store.js";
 import { GIT_STATUS_ECHO_PREVIEW, stripGitStatusUnits } from "./git-status-frame.js";
 import { settleExecutionRecord } from "./execution-record.js";
 import { engineVersion } from "../version.js";
 import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
 import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill, sanitizeCompactionSettings } from "../auto-compaction.js";
-import { ASK_USER_QUESTION_TOOL_NAME, canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace } from "../ask-question.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact, sanitizeCompactionSettings } from "../auto-compaction.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { boundInputHashOf } from "../canonical-json.js";
 import { computeCostMicroUsd, isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
 import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
 import { emitTaskOutcome } from "../task-outcome.js";
 import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
-import { primaryActivityArg } from "../arg-summary.js";
 import { redactThenCut } from "../../agents/subagent-steps.js";
 import { resolveReasoning } from "../../brain/reasoning.js";
 import { adjudicateDerivedRoute, authCarrierFingerprint, fallbackToPrimaryNotice, normalizeBaseUrl, sameRouteIdentity } from "../../brain/route-adjudicator.js";
-import { readDegradation } from "../../brain/degrading.js";
 import { runWithBrainTelemetry, runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
 import { expandTiers, resolveModel, resolveTaskModel } from "../roles.js";
 import { runSideQuery } from "../side-query.js";
@@ -32,1066 +28,55 @@ import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { PushQueue } from "../push-queue.js";
 import { TtlSessionStore } from "../session-store.js";
 import { toImageContent } from "./image.js";
-import { OUTPUT_TOOL_NAME, SKILLS_LISTING_PROBE_HEADER, resolveOutputRetries } from "./synthetic-tools.js";
+import { SKILLS_LISTING_PROBE_HEADER, resolveOutputRetries } from "./synthetic-tools.js";
 import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
 import { assembleResult, errorCodeOf } from "./assemble-result.js";
 import { amendTerminal, terminalProjection } from "./terminal-projection.js";
-import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
+import { AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, commitAgentListing, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.js";
 import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { effectiveDelegationFacts, prepareTask } from "./prepare-task.js";
-import { gatedCallIdOf } from "./park-commit.js";
-import { placementValueOrAbsent } from "./checkpoint-scope.js";
+import { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
+import { callFaceSeat, judgeParkedToolIdentity, rosterEntryNamed, toolCallFaceOf } from "../tool-roster.js";
+import { normalizePersistedRuleHit } from "../gate-lanes.js";
+import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-arms.js";
 import { SessionReadFileStates } from "./prepare-hands-readface.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
-import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
-import { cloneObserverInput, formatHookFeedback, hookSeatExpiredError, MAX_HOOK_TIMEOUT_MS, mintHookInvocationIdentity, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
+import { formatHookFeedback, hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
 import { buildHumanInputEvent, frameMidTurnUserInput, projectHumanInput } from "../human-input-projection.js";
-import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
-import { droppedToolDigest, withAnnounceDigests } from "./announce-once-ledger.js";
+import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
-import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
-import { isAskOrigin } from "../ask-origin.js";
-import { isGateKind, PAUSE_REGISTRY, resumeGateMatches } from "../pause-registry.js";
-import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOfSuppliedLayer, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
+import { PAUSE_REGISTRY } from "../pause-registry.js";
+import { refuseOutOfContractDecision, toolPolicyNameSets } from "../tool-policy.js";
 import { mintGateOutcome } from "./gate-exit.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
-import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
 import { createRunState } from "./initial-run-state.js";
 import { nextHumanInputSeq, sameAcceptedSteerInput } from "./steer-admission.js";
-import { batchResponseDigest, reconciledToolEndBody, toolEndBodyFrom, toolResultMsg, writeFamilyOfCanonical } from "./tool-end-body.js";
-import { answerFaceForRedeemedCall, assertOutcomeText, deepJsonEqual, DEFERRED_REISSUE, describeSuppliedValue, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative, sameWinner } from "./decide-continuation.js";
-import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, ENV_DUE_GOVERNANCE_READ_BUDGET_MS, GOVERNANCE_READ_STALLED, LIMIT_APPROACH_DEFAULT_THRESHOLDS, limitApproachFrames, platformLimitTerminal, raceUntilDeadline, resolveMaxTurns, startTimeout, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
+import { reconciledToolEndBody, toolEndBodyFrom, toolResultMsg, writeFamilyOfCanonical } from "./tool-end-body.js";
+import { answerFaceForRedeemedCall, deepJsonEqual, DEFERRED_REISSUE, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative } from "./decide-continuation.js";
+import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, platformLimitTerminal, resolveMaxTurns, startTimeout, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
 import { gitRestateOption, resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
-const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
-const RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS = 10_000;
+import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES, createTurnBoundary } from "./run-turn-boundary.js";
+import { createHarnessHandlers } from "./run-harness-handlers.js";
+import { resumeAdmission } from "./resume-admission.js";
+import { resumeReviewOutcome } from "./resume-review-outcome.js";
+import { resumePolicyOutcome } from "./resume-policy-outcome.js";
+import { resumeCheckpointScreen } from "./resume-checkpoint-screen.js";
+import { resumeInternalsAndConfig } from "./resume-internals-and-config.js";
+import { resumeApply } from "./resume-apply.js";
+import { resumePreflight } from "./resume-preflight.js";
+import { resumeClaim } from "./resume-claim.js";
 const STOP_HOOK_BLOCK_CAP = 8;
-const COMPACTION_REGROWTH_FACTOR = 1.5;
-const COMPACTION_FREED_EPSILON = 256;
 const ORG_DISCLOSURE_MAX_CHARS = 600;
-const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
-const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
 const SUGGESTIONS_DEFAULT_COUNT = 3;
 const SUGGESTIONS_MAX_COUNT = 8;
 const SUGGESTIONS_TIMEOUT_MS = 30_000;
 const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
-function makeTurnBoundary(prepared, stats, rs, deps) {
-    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, walltimeMonotonicDeadline, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
-    let finalVerifySeenAtLastBoundary = 0;
-    const onTurnBoundary = async (event) => {
-        let boundarySteered = false;
-        const noNextRequest = () => prepared.stopRequestedRef.current || deps.loopLatch.userHalted;
-        const walltimeHit = walltimeMonotonicDeadline !== undefined && performance.now() >= walltimeMonotonicDeadline;
-        const preemptHit = spec.preemptSignal?.aborted === true;
-        if (preemptHit && !prepared.suspendForResource && !rs.counters.preemptIgnoredReported) {
-            rs.counters.preemptIgnoredReported = true;
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "preempt.ignored", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-        }
-        let platformCause;
-        let platformRetryAfterMs;
-        const preemptWillSuspend = preemptHit && prepared.suspendForResource !== undefined;
-        if (!preemptWillSuspend && prepared.pausedRef.current === undefined && !prepared.abortController.signal.aborted) {
-            const ledgerReadDeadline = prepared.envLifetimeSuspendAt !== undefined ? prepared.envLifetimeSuspendAt + ENV_DUE_GOVERNANCE_READ_BUDGET_MS : undefined;
-            if (prepared.usageGovernance !== undefined) {
-                const governance = prepared.usageGovernance;
-                try {
-                    const at = Date.now();
-                    await awaitChargeWithSlowDisclosure(governance.commit(stats.tokens, rs.telemetry.unpricedSpend ? undefined : stats.costMicroUsd, at), () => runnerHooks.onError?.(new Error("the usage ledger CHARGE has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on the end-of-task flush). A wedged ledger store wedges this boundary, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
-                    const windowRead = governance.check(at);
-                    let answer;
-                    if (ledgerReadDeadline !== undefined) {
-                        answer = await raceUntilDeadline(windowRead, ledgerReadDeadline);
-                        if (answer === GOVERNANCE_READ_STALLED) {
-                            void windowRead.catch((lateErr) => {
-                                try {
-                                    runnerHooks.onError?.(lateErr instanceof Error ? lateErr : new Error(String(lateErr)), { phase: "config", sessionId: prepared.sessionId });
-                                }
-                                catch {
-                                }
-                            });
-                            try {
-                                runnerHooks.onError?.(new Error("the usage ledger did not answer before the execution environment's suspend deadline — stopping for the environment, the cause this run can still prove. The window state for this boundary is UNKNOWN and was not enforced."), { phase: "config", sessionId: prepared.sessionId });
-                            }
-                            catch {
-                            }
-                        }
-                    }
-                    else {
-                        answer = await windowRead;
-                    }
-                    if (answer !== GOVERNANCE_READ_STALLED) {
-                        platformRetryAfterMs = answer;
-                        if (platformRetryAfterMs !== undefined)
-                            platformCause = "usage_window";
-                    }
-                }
-                catch (govErr) {
-                    rs.limits.platformTerminal = govErr instanceof Error ? govErr : new Error(String(govErr));
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                    return undefined;
-                }
-            }
-            if (platformCause === undefined && prepared.envLifetimeSuspendAt !== undefined && Date.now() >= prepared.envLifetimeSuspendAt) {
-                platformCause = "env_lifetime";
-            }
-        }
-        if (platformCause !== undefined) {
-            const platformSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
-            const committed = prepared.suspendForPlatformLimit !== undefined &&
-                (await prepared.suspendForPlatformLimit(platformCause, platformSpend, platformRetryAfterMs !== undefined ? { resumeAfterMs: platformRetryAfterMs } : undefined));
-            if (committed) {
-                rs.limits.turnsExceeded = false;
-                rs.limits.budgetHit = undefined;
-                return undefined;
-            }
-            const terminal = platformLimitTerminal(platformCause, platformRetryAfterMs);
-            rs.limits.platformTerminal = terminal;
-            try {
-                runnerHooks.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-            void prepared.harness.abort();
-            prepared.abortController.abort();
-            return undefined;
-        }
-        if (prepared.suspendForResource &&
-            (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
-            prepared.pausedRef.current === undefined) {
-            const reason = preemptHit
-                ? "preempt"
-                : rs.limits.budgetHit !== undefined
-                    ? rs.limits.budgetAxis === "tokens"
-                        ? "budget_tokens"
-                        : "budget_cost"
-                    : rs.limits.turnsExceeded
-                        ? "turns"
-                        : "walltime";
-            const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
-            if (await prepared.suspendForResource(reason, sliceSpend)) {
-                rs.limits.turnsExceeded = false;
-                rs.limits.budgetHit = undefined;
-            }
-            else {
-                void prepared.harness.abort();
-                prepared.abortController.abort();
-            }
-            return undefined;
-        }
-        if (walltimeMonotonicDeadline !== undefined &&
-            prepared.suspendForResource === undefined &&
-            performance.now() >= walltimeMonotonicDeadline) {
-            if (!timeout.fired) {
-                timeout.fired = true;
-                timeout.clear();
-                timeout.latenessMs = Math.max(timeout.latenessMs ?? 0, performance.now() - walltimeMonotonicDeadline);
-                rs.counters.walltimeSyncBackstopFired = true;
-                void prepared.harness.abort();
-                prepared.abortController.abort();
-            }
-            return undefined;
-        }
-        const approachCfg = spec.limits?.approachNotice;
-        if (approachCfg !== false &&
-            rs.counters.approachNoticesSent < LIMIT_APPROACH_DEFAULT_THRESHOLDS.length &&
-            prepared.suspendForResource === undefined &&
-            rs.turn.lastTurnHadToolCalls &&
-            prepared.batchHaltRef.current === undefined &&
-            !boundarySteered &&
-            !prepared.abortController.signal.aborted) {
-            const thresholds = approachCfg?.at ?? LIMIT_APPROACH_DEFAULT_THRESHOLDS;
-            const ratios = [];
-            if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow > 0) {
-                ratios.push({ axis: "token budget", ratio: stats.tokens / rs.budget.maxTokensWindow });
-            }
-            if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd > 0) {
-                ratios.push({ axis: "cost budget", ratio: stats.costMicroUsd / rs.budget.maxCostMicroUsd });
-            }
-            const declaredMaxTurns = spec.limits?.maxTurns;
-            if (declaredMaxTurns !== undefined && declaredMaxTurns > 0) {
-                ratios.push({ axis: "turn budget", ratio: (stats.turns + 1) / declaredMaxTurns });
-            }
-            if (walltimeMonotonicDeadline !== undefined) {
-                const walltimeWindowMs = walltimeMonotonicDeadline - rs.telemetry.taskStartMonotonic;
-                if (walltimeWindowMs > 0) {
-                    ratios.push({ axis: "walltime budget", ratio: (performance.now() - rs.telemetry.taskStartMonotonic) / walltimeWindowMs });
-                }
-            }
-            let tightest;
-            for (const r of ratios)
-                if (tightest === undefined || r.ratio > tightest.ratio)
-                    tightest = r;
-            const index = rs.counters.approachNoticesSent;
-            if (tightest !== undefined && tightest.ratio >= thresholds[index]) {
-                rs.counters.approachNoticesSent += 1;
-                const percent = Math.min(100, Math.round(tightest.ratio * 100));
-                const body = limitApproachFrames(index === 0 ? 0 : 1, tightest.axis, percent, prepared.reminderMark);
-                void prepared.harness.steer(body, { engineMinted: true }).catch(() => undefined);
-                queue.push({ type: "steering_injected", source: "limit_approach", preview: body.slice(0, 220), ...ident() });
-                boundarySteered = true;
-            }
-        }
-        if (prepared.reviewRequestRef.pending !== undefined) {
-            const { reason } = prepared.reviewRequestRef.pending;
-            prepared.reviewRequestRef.pending = undefined;
-            const honorable = prepared.suspendForReview !== undefined &&
-                !prepared.abortController.signal.aborted &&
-                prepared.pausedRef.current === undefined;
-            if (honorable && prepared.suspendForReview) {
-                await prepared.suspendForReview(reason);
-                return undefined;
-            }
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "review.dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-        }
-        if (prepared.lspDiagnostics &&
-            !prepared.lspDiagnostics.registry.isEmpty() &&
-            !prepared.abortController.signal.aborted &&
-            prepared.batchHaltRef.current === undefined) {
-            const files = prepared.lspDiagnostics.registry.drain(prepared.lspDiagnostics.runIdent);
-            if (files.length > 0) {
-                queue.push({ type: "diagnostics", files, isNew: true, ...ident() });
-                const block = mintSystemReminder(formatDiagnosticsBlock(files), prepared.reminderMark);
-                void prepared.harness.steer(block, { provenance: "engine-note" }).catch(() => undefined);
-                boundarySteered = true;
-            }
-        }
-        let boundaryAttachmentBytes = 0;
-        let attachmentsPayload;
-        if ((rs.attach.dateState !== undefined ||
-            rs.attach.instrState !== undefined ||
-            rs.attach.sizeGuidelineState !== undefined ||
-            rs.attach.attachState !== undefined) &&
-            !boundarySteered &&
-            prepared.batchHaltRef.current === undefined &&
-            !noNextRequest() &&
-            rs.counters.finalVerifyInjections === 0 &&
-            !prepared.abortController.signal.aborted) {
-            const due = [];
-            if (rs.attach.attachState !== undefined) {
-                const changedFilesOn = Boolean(rs.attach.attachmentsCfg?.changedFiles);
-                let changed;
-                if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
-                    const maxFiles = typeof rs.attach.attachmentsCfg?.changedFiles === "object"
-                        ? (rs.attach.attachmentsCfg.changedFiles.maxFiles ?? CHANGED_FILES_MAX)
-                        : CHANGED_FILES_MAX;
-                    const SCAN_CEILING_MS = 2_000;
-                    const scan = await Promise.race([
-                        prepared.detectExternalChanges(maxFiles),
-                        new Promise((resolve) => {
-                            setTimeout(() => resolve({ changed: [], evicted: [] }), SCAN_CEILING_MS);
-                        }),
-                    ]);
-                    for (const p of scan.evicted)
-                        rs.attach.attachState.surfacedMtime.delete(p);
-                    changed = scan.changed;
-                }
-                const backgroundTasksOn = (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true;
-                const bgTasks = backgroundTasksOn && rs.attach.attachState.postCompactPending ? prepared.listBackgroundTasks() : undefined;
-                const toolsDeltaOn = rs.attach.attachmentsCfg?.toolsDelta === true;
-                let announcedOnceDirty = false;
-                const tdRef = toolsDeltaOn ? prepared.toolsDeltaRef : undefined;
-                const pendingTools = tdRef !== undefined && tdRef.pending.length > 0 ? [...tdRef.pending] : undefined;
-                const pendingRemovedTools = tdRef !== undefined && tdRef.pendingRemoved.length > 0 ? [...tdRef.pendingRemoved] : undefined;
-                const pendingReaddedTools = tdRef !== undefined && tdRef.pendingReadded.length > 0 ? [...tdRef.pendingReadded] : undefined;
-                const pendingFailedMcp = tdRef !== undefined && tdRef.pendingFailed.length > 0 ? tdRef.pendingFailed.map((f) => ({ ...f })) : undefined;
-                const mcpToolsDelta = pendingRemovedTools !== undefined || pendingReaddedTools !== undefined || pendingFailedMcp !== undefined
-                    ? {
-                        ...(pendingRemovedTools !== undefined ? { removed: pendingRemovedTools } : {}),
-                        ...(pendingReaddedTools !== undefined ? { readded: pendingReaddedTools } : {}),
-                        ...(pendingFailedMcp !== undefined ? { failedServers: pendingFailedMcp } : {}),
-                    }
-                    : undefined;
-                const mcpInstructionsOn = rs.attach.attachmentsCfg?.mcpInstructions === true;
-                const mcpDelta = prepared.mcp.instructionsDelta;
-                const mcpAdds = mcpInstructionsOn && mcpDelta.pendingAdds.length > 0 ? [...mcpDelta.pendingAdds] : undefined;
-                const mcpRemovals = mcpInstructionsOn && mcpDelta.pendingRemovals.length > 0 ? [...mcpDelta.pendingRemovals] : undefined;
-                const mcpDropped = mcpInstructionsOn && prepared.mcp.droppedTools.length > 0 ? selectMcpDroppedBatch(prepared.mcp.droppedTools) : undefined;
-                const budgetUsdOn = rs.attach.attachmentsCfg?.budgetUsd === true && rs.budget.maxCostMicroUsd !== undefined && rs.turn.lastTurnHadToolCalls;
-                const totalTokensDeclared = rs.attach.attachmentsCfg?.totalTokensReminder;
-                const totalTokensMode = rs.attach.attachmentsCfg?.totalTokensReminderMode ?? TOTAL_TOKENS_REMINDER_DEFAULT_MODE;
-                const totalTokensArmedByDefault = totalTokensDeclared === undefined &&
-                    eventDefaultOn("total_tokens_reminder") &&
-                    totalTokensMode !== "fixed" &&
-                    totalTokensMode !== "infinite";
-                const totalTokensOn = (totalTokensDeclared === true || totalTokensArmedByDefault) && rs.turn.lastTurnHadToolCalls;
-                const toolSearchReminderOn = rs.attach.attachmentsCfg?.toolSearchReminder === true && prepared.deferredToolNames !== undefined;
-                const undiscoveredTools = toolSearchReminderOn
-                    ? [...prepared.deferredToolNames].filter((n) => !prepared.activeTools.has(n)).sort()
-                    : undefined;
-                due.push(...collectDueAttachments(rs.attach.attachState, {
-                    turn: stats.turns,
-                    cadenceTurn: rs.counters.cadenceTurns,
-                    todoMounted: todoToolMounted,
-                    taskListMounted: taskToolsMounted,
-                    planActive: prepared.planModeRef.active,
-                    config: {
-                        todoReminder: rs.attach.attachmentsCfg?.todoReminder === true,
-                        ...(rs.attach.attachmentsCfg?.todoReminderMode !== undefined ? { todoReminderMode: rs.attach.attachmentsCfg.todoReminderMode } : {}),
-                        toolSearchReminder: toolSearchReminderOn,
-                        changedFiles: changedFilesOn,
-                        planModeReminder: rs.attach.attachmentsCfg?.planModeReminder === true,
-                        budgetUsd: budgetUsdOn,
-                        totalTokensReminder: totalTokensOn,
-                        ...(rs.attach.attachmentsCfg?.totalTokensReminderMode !== undefined
-                            ? { totalTokensReminderMode: rs.attach.attachmentsCfg.totalTokensReminderMode }
-                            : {}),
-                        backgroundTasks: backgroundTasksOn,
-                        toolsDelta: toolsDeltaOn,
-                        agentListing: rs.attach.agentListingOn,
-                        skillsListing: rs.attach.skillsListingOn,
-                        mcpInstructions: mcpInstructionsOn,
-                    },
-                    ...(undiscoveredTools !== undefined && undiscoveredTools.length > 0
-                        ? { undiscoveredTools, deferDirectCall: prepared.deferDirectCall }
-                        : {}),
-                    ...(changed !== undefined ? { changedFiles: changed } : {}),
-                    ...(budgetUsdOn && rs.budget.maxCostMicroUsd !== undefined
-                        ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: rs.budget.maxCostMicroUsd / 1e6 } }
-                        : {}),
-                    ...(totalTokensOn && rs.budget.maxTokensWindow !== undefined
-                        ? { totalTokens: { used: stats.tokens, total: rs.budget.maxTokensWindow } }
-                        : {}),
-                    ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
-                    ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
-                    ...(prepared.toolMaterializeStatic ? { newToolsStaticFace: true } : {}),
-                    ...(prepared.toolMaterializeStatic && pendingTools !== undefined
-                        ? { newToolsSwappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
-                        : {}),
-                    ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
-                        ? { readdedToolsSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
-                        : {}),
-                    ...(mcpToolsDelta !== undefined ? { mcpToolsDelta } : {}),
-                    ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
-                        ? {
-                            agentListing: prepared.agentListing.entries,
-                            agentToolName: prepared.agentListing.toolName,
-                            ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
-                        }
-                        : {}),
-                    ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
-                    ...(mcpAdds !== undefined || mcpRemovals !== undefined
-                        ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
-                        : {}),
-                    ...(mcpDropped !== undefined ? { mcpDroppedTools: mcpDropped } : {}),
-                }));
-                if (pendingTools !== undefined || mcpToolsDelta !== undefined) {
-                    const exact = renderToolsDelta({
-                        ...(pendingTools !== undefined ? { added: pendingTools } : {}),
-                        ...(prepared.toolMaterializeStatic ? { staticFace: true } : {}),
-                        ...(prepared.toolMaterializeStatic && pendingTools !== undefined
-                            ? { swappedUnderStatic: pendingTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
-                            : {}),
-                        ...(prepared.toolMaterializeStatic && pendingReaddedTools !== undefined
-                            ? { readdedSwappedUnderStatic: pendingReaddedTools.filter((n) => prepared.staticFaceFor?.(n) !== true) }
-                            : {}),
-                        ...(mcpToolsDelta ?? {}),
-                    });
-                    if (exact !== undefined && due.some((a) => a.source === "tools_delta" && a.body === exact)) {
-                        const ref = prepared.toolsDeltaRef;
-                        if (pendingTools !== undefined)
-                            ref.pending.splice(0, pendingTools.length);
-                        if (pendingRemovedTools !== undefined)
-                            ref.pendingRemoved.splice(0, pendingRemovedTools.length);
-                        if (pendingReaddedTools !== undefined)
-                            ref.pendingReadded.splice(0, pendingReaddedTools.length);
-                        if (pendingFailedMcp !== undefined) {
-                            ref.pendingFailed.splice(0, pendingFailedMcp.length);
-                            if (!noNextRequest()) {
-                                prepared.announcedListingsRef.mcpFailed = [...(prepared.announcedListingsRef.mcpFailed ?? []), ...pendingFailedMcp];
-                                announcedOnceDirty = true;
-                            }
-                        }
-                    }
-                }
-                if ((mcpAdds !== undefined || mcpRemovals !== undefined) &&
-                    due.some((a) => a.source === "mcp_instructions" && a.body === renderMcpInstructionsDelta(mcpAdds ?? [], mcpRemovals ?? []))) {
-                    if (mcpAdds !== undefined)
-                        mcpDelta.pendingAdds.splice(0, mcpAdds.length);
-                    if (mcpRemovals !== undefined)
-                        mcpDelta.pendingRemovals.splice(0, mcpRemovals.length);
-                }
-                if (mcpDropped !== undefined &&
-                    due.some((a) => a.source === "mcp_dropped_tools" && a.body === renderMcpDroppedTools(mcpDropped))) {
-                    prepared.mcp.droppedTools.splice(0, mcpDropped.length);
-                    if (!noNextRequest()) {
-                        prepared.announcedListingsRef.advisories = withAnnounceDigests(prepared.announcedListingsRef.advisories, mcpDropped.map(droppedToolDigest));
-                        announcedOnceDirty = true;
-                    }
-                }
-                if (rs.attach.agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
-                    const listing = prepared.agentListing;
-                    const intactBody = renderAgentListingDelta(rs.attach.attachState, listing.entries, listing.toolName, listing.models);
-                    if (intactBody !== undefined && due.some((a) => a.source === "agent_listing" && a.body === intactBody)) {
-                        commitAgentListing(rs.attach.attachState, listing.entries, listing.models);
-                        prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
-                        if (listing.models !== undefined)
-                            prepared.announcedListingsRef.models = [...listing.models];
-                        if (prepared.announcedSnapshotRecovered)
-                            await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                    }
-                }
-                if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
-                    const listing = prepared.skillsListing;
-                    const intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
-                    if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
-                        commitSkillsListing(rs.attach.attachState, listing.entries);
-                        prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
-                        if (prepared.announcedSnapshotRecovered)
-                            await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                    }
-                }
-                if (announcedOnceDirty && prepared.announcedSnapshotRecovered)
-                    await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-            }
-            if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
-                const today = prepared.dateChange.today();
-                const cand = collectDateChange(rs.attach.dateState, today);
-                if (cand !== undefined) {
-                    due.unshift(cand);
-                    rs.attach.dateState.announcedDate = today;
-                }
-            }
-            if (rs.attach.sizeGuidelineState !== undefined && rs.turn.lastTurnHadToolCalls) {
-                const guideline = rs.attach.sizeGuidelineState.current();
-                if (guideline !== rs.attach.sizeGuidelineState.announcedGuideline) {
-                    due.splice(due.length > 0 && due[0].source === "date_change" ? 1 : 0, 0, {
-                        source: "workflow_size_guideline_change",
-                        body: workflowSizeGuidelineChangeNotice(guideline),
-                    });
-                    rs.attach.sizeGuidelineState.announcedGuideline = guideline;
-                }
-            }
-            if (rs.attach.instrState !== undefined && rs.attach.instrProbe !== undefined && rs.turn.lastTurnHadToolCalls) {
-                let probed = null;
-                try {
-                    const PROBE_CEILING_MS = 2_000;
-                    probed = await Promise.race([
-                        rs.attach.instrProbe(prepared.instructionSources),
-                        new Promise((resolve) => {
-                            setTimeout(() => resolve(null), PROBE_CEILING_MS);
-                        }),
-                    ]);
-                }
-                catch {
-                    probed = null;
-                }
-                const cand = collectInstructionsChange(rs.attach.instrState, probed);
-                if (cand !== undefined) {
-                    due.splice(due.length > 0 && due[0].source === "date_change" ? 1 : 0, 0, cand.attachment);
-                    commitInstructionsChange(rs.attach.instrState, cand.announced);
-                }
-            }
-            if (due.length > 0) {
-                attachmentsPayload = due.map((a) => mintSystemReminder(sanitizeUntrustedText(a.body, attachmentEnvelopeTags(a.source)), prepared.reminderMark)).join("\n");
-                for (const a of due)
-                    boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
-                rs.attach.attachmentsInjected += due.length;
-                for (const a of due) {
-                    queue.push({ type: "steering_injected", source: a.source, preview: redactThenCut(a.body, 220), ...ident() });
-                }
-            }
-        }
-        let batchContextBlock;
-        const finalVerifyInjectedThisTurn = rs.counters.finalVerifyInjections !== finalVerifySeenAtLastBoundary;
-        finalVerifySeenAtLastBoundary = rs.counters.finalVerifyInjections;
-        if (postToolBatchHook !== undefined && rs.turn.toolBatch.length > 0) {
-            const batch = rs.turn.toolBatch;
-            rs.turn.toolBatch = [];
-            batchArgs?.clear();
-            const injectedThisTurn = finalVerifyInjectedThisTurn ? "final_verification" : undefined;
-            if (!boundarySteered && !prepared.abortController.signal.aborted) {
-                try {
-                    const batchSeat = await runHookSeat("postToolBatch", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }, (sig) => postToolBatchHook(batch, injectedThisTurn !== undefined ? { injectedThisTurn } : undefined, { identity: prepared.hookIdentity, signal: sig }));
-                    if (batchSeat.expired) {
-                        runnerHooks.onError?.(hookSeatExpiredError("postToolBatch", prepared.hookTimeoutMs, batchSeat.cause, "the boundary observation was abandoned and its additionalContext dropped; the turn boundary itself is unchanged"), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    const r = batchSeat.expired ? undefined : batchSeat.value;
-                    if (r?.additionalContext && injectedThisTurn === undefined) {
-                        const body = sanitizeUntrustedText(r.additionalContext, SHELLED_BODY_ENVELOPE_TAGS);
-                        const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
-                        if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
-                            const clipped = clipToBytes(body, budget) === body
-                                ? body
-                                : `${clipToBytes(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
-                            batchContextBlock = mintSystemReminder(clipped, prepared.reminderMark);
-                        }
-                    }
-                }
-                catch (err) {
-                    try {
-                        runnerHooks.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-        }
-        if ((attachmentsPayload !== undefined || batchContextBlock !== undefined) && prepared.batchHaltRef.current === undefined) {
-            const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
-            void prepared.harness.steer(payload, { engineMinted: true }).catch(() => { });
-        }
-        const forceManual = manualCompactRef.requested;
-        if ((!withinTaskCompaction && !forceManual) ||
-            prepared.abortController.signal.aborted ||
-            prepared.pausedRef.current !== undefined) {
-            if (forceManual) {
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
-                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });
-                drainManualCompact("mooted");
-            }
-            return undefined;
-        }
-        if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES) {
-            if (forceManual) {
-                emitTrace(rs.telemetry.tracer, () => ({
-                    kind: "compaction.failed",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    trigger: "manual",
-                    reason: "compaction circuit breaker open (3 consecutive failures this task) — manual request drained without an attempt",
-                    ts: Date.now(),
-                }));
-                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "manual", reason: "compaction circuit breaker open (3 consecutive failures this task) — manual request drained without an attempt", ...ident() });
-                drainManualCompact("failed");
-            }
-            return undefined;
-        }
-        const claimedManual = forceManual
-            ? (() => {
-                const waiters = manualCompactRef.waiters.splice(0);
-                let instructions;
-                for (let i = waiters.length - 1; i >= 0; i--) {
-                    if (waiters[i].instructions !== undefined) {
-                        instructions = waiters[i].instructions;
-                        break;
-                    }
-                }
-                return { instructions, waiters };
-            })()
-            : undefined;
-        if (forceManual) {
-            manualCompactRef.requested = false;
-        }
-        const resolveClaimedWaiters = (outcome) => {
-            if (claimedManual !== undefined)
-                for (const w of claimedManual.waiters.splice(0))
-                    w.resolve(outcome);
-        };
-        const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
-        const manualCancelSignal = claimedCancelSignals.length === 0
-            ? undefined
-            : claimedCancelSignals.length === 1
-                ? claimedCancelSignals[0]
-                : AbortSignal.any(claimedCancelSignals);
-        const compactionPassSignal = claimedCancelSignals.length > 0
-            ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
-            : prepared.abortController.signal;
-        const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
-        if (trimPressureArmed)
-            prepared.trimPressureRef.droppedMessages = false;
-        const trimPressure = trimPressureArmed && !rs.counters.trimForceBackoff;
-        const passTrigger = trimPressure ? "forced" : forceManual ? "manual" : "auto";
-        let manualOutcome = "failed";
-        const manualInstructions = claimedManual?.instructions;
-        try {
-            const comp = await maybeCompact({
-                session: prepared.session,
-                epochDeclaredSections: prepared.epochDeclaredSections,
-                ...centerAdoptionOption(prepared),
-                model: event.model,
-                compactionModel: prepared.compModel,
-                ...forkContextOption(prepared, false),
-                brain: compactionBrain,
-                getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                thinking: prepared.thinking,
-                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                signal: compactionPassSignal,
-                ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
-                minTokens: forceManual ? 0 : rs.counters.compactionFloor,
-                force: forceManual,
-                onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
-                forceUnderThreshold: trimPressure,
-                overheadTokens: prepared.promptOverheadTokens,
-                ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
-                ...contextInstructionFilesOption(prepared),
-                ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                ...runnerHooks.seamCCompactionOptions(prepared),
-                ...gitRestateOption(prepared),
-                ...windowSafetyOptions(event.model),
-                ...runnerHooks.compactionHookOptions(spec, prepared.sessionId, passTrigger),
-            });
-            if (comp.blocked) {
-                emitTrace(rs.telemetry.tracer, () => ({
-                    kind: "compaction.blocked",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    trigger: forceManual ? "manual" : "auto",
-                    ts: Date.now(),
-                }));
-            }
-            else {
-                compactionBreaker.failures = 0;
-            }
-            rs.counters.trimForceBackoff = nextTrimForceBackoff(rs.counters.trimForceBackoff, comp, trimPressure);
-            if (comp.contextUsage) {
-                queue.push({ type: "context_usage", ...comp.contextUsage, ...ident() });
-            }
-            if (comp.unevaluableWindow) {
-                discloseUnevaluableWindow(comp.unevaluableWindow, prepared, rs.telemetry.tracer, rs.telemetry.taskId, runnerHooks.onError);
-            }
-            if (comp.suppressedByFloor) {
-                const s = comp.suppressedByFloor;
-                emitTrace(rs.telemetry.tracer, () => ({
-                    kind: "compaction.suppressed",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    estTokens: s.estTokens,
-                    floor: s.floor,
-                    ts: Date.now(),
-                }));
-            }
-            manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
-            if (forceManual && !comp.compacted && !comp.blocked) {
-                if (comp.disabled) {
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.disabled", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-                }
-                else {
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.noop", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-                }
-            }
-            if (!comp.compacted) {
-                const outcome = comp.blocked
-                    ? "blocked"
-                    : comp.disabled
-                        ? (forceManual || trimPressure ? "disabled" : undefined)
-                        : comp.suppressedByFloor
-                            ? "suppressed"
-                            : comp.noop || forceManual
-                                ? "noop"
-                                : undefined;
-                if (outcome !== undefined) {
-                    queue.push({ type: "compaction_outcome", outcome, trigger: passTrigger, ...ident() });
-                }
-            }
-            runnerHooks.recordCompactionReuse(prepared, comp);
-            if (comp.compacted) {
-                queue.push({
-                    type: "compacted",
-                    trigger: passTrigger,
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
-                if (!forceManual && recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
-                    compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
-                    queue.push({ type: "compaction_outcome", outcome: "disabled", trigger: passTrigger, reason: "rapid_refill: compaction disabled for the rest of this task", ...ident() });
-                    runnerHooks.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
-                }
-                if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
-                    const pd = comp.phaseDurations;
-                    const pdDur = comp.durationMs;
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
-                }
-                prepared.cacheBreakDetector?.notifyCompaction();
-                if (rs.attach.attachState !== undefined) {
-                    rs.attach.attachState.postCompactPending = true;
-                    rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
-                }
-                if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                    const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                    rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
-                }
-            }
-        }
-        catch (err) {
-            const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
-            if (manualCancelAbort) {
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "cancelled", ts: Date.now() }));
-                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: passTrigger, reason: "cancelled", ...ident() });
-                manualOutcome = "mooted";
-            }
-            else if (!prepared.abortController.signal.aborted) {
-                compactionBreaker.failures += 1;
-                runnerHooks.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-                const msg = String(err instanceof Error ? err.message : err);
-                const failReason = msg.length > 512 ? `${msg.slice(0, 512)}…` : msg;
-                emitTrace(rs.telemetry.tracer, () => ({
-                    kind: "compaction.failed",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    trigger: passTrigger,
-                    reason: failReason,
-                    ts: Date.now(),
-                }));
-                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: passTrigger, reason: failReason, ...ident() });
-                manualOutcome = "failed";
-            }
-            else {
-                manualOutcome = "mooted";
-            }
-        }
-        if (forceManual)
-            resolveClaimedWaiters(manualOutcome);
-        return undefined;
-    };
-    return onTurnBoundary;
-}
-function makeHarnessHandlers(prepared, stats, rs, deps) {
-    const { spec, queue, internals, ident, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
-    const internalsNotifier = createSafeNotifier({
-        onError: (f) => console.warn(`[sema-core] ${f.site}: run-internals activity sink threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
-    });
-    let lastWorkspaceCwd = prepared.cwdRef?.current;
-    const announceWorkspaceMove = () => {
-        const cwdNow = prepared.cwdRef?.current;
-        if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
-            lastWorkspaceCwd = cwdNow;
-            queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
-        }
-    };
-    const onMessageUpdate = (event) => {
-        const ev = event.assistantMessageEvent;
-        if (rs.turn.callStartAt === undefined)
-            rs.turn.callStartAt = Date.now();
-        if (ev.type === "text_delta" && ev.delta) {
-            if (rs.turn.firstTokenAt === undefined)
-                rs.turn.firstTokenAt = Date.now();
-            pushContent({ type: "text_delta", delta: ev.delta, ...ident() });
-        }
-        else if (ev.type === "text_end" && typeof ev.content === "string" && ev.content.length !== 0) {
-            pushContent({ type: "text_end", content: ev.content, ...ident() });
-        }
-        else if (ev.type === "thinking_delta" && ev.delta) {
-            pushContent({ type: "reasoning_delta", delta: ev.delta, ...ident() });
-        }
-        if (rs.budget.streamCancel && !rs.limits.budgetHit && (ev.type === "text_delta" || ev.type === "thinking_delta") && ev.delta) {
-            rs.budget.callOutputChars += ev.delta.length;
-            if (rs.budget.callOutputChars - rs.budget.lastStreamBudgetCheck >= 256) {
-                rs.budget.lastStreamBudgetCheck = rs.budget.callOutputChars;
-                const projectedAxis = rs.budget.projectedOverBudget();
-                if (projectedAxis !== undefined) {
-                    rs.limits.budgetHit = "exceeded";
-                    rs.limits.budgetAxis = projectedAxis;
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-            }
-        }
-    };
-    const onMessageEnd = (event) => {
-        const m = event.message;
-        if (event.entryId !== undefined && (m.role === "user" || m.role === "assistant" || m.role === "toolResult")) {
-            emitCommitted(event.entryId, m.role, m.role === "toolResult" ? m.toolCallId : undefined);
-        }
-        if (event.entryId !== undefined && m.role === "user")
-            prepared.fileHistoryBoundary?.begin(event.entryId);
-        if (event.entryId !== undefined && m.role === "user" && prepared.gitStatusRef.pendingReceipt !== undefined) {
-            const pr = prepared.gitStatusRef.pendingReceipt;
-            const c = m.content;
-            const text = typeof c === "string"
-                ? c
-                : Array.isArray(c) && c.length >= 1 && c[0].type === "text"
-                    ? c[0].text
-                    : undefined;
-            if (text === pr.text) {
-                delete prepared.gitStatusRef.pendingReceipt;
-                pr.commit(event.entryId);
-            }
-        }
-        if (rs.degrade.degraded === undefined && m.role === "assistant") {
-            const deg = readDegradation(m);
-            if (deg)
-                rs.degrade.recordDegraded({ from: deg.from, to: deg.to, reason: deg.reason, atTurn: stats.turns + 1, ...(deg.chain && { chain: deg.chain }) });
-        }
-        if (m.role === "assistant" && "usage" in m && m.usage) {
-            if (m.usageMissing)
-                rs.turn.turnUsageMissing = true;
-            const u = m.usage;
-            stats.tokens += u.totalTokens || 0;
-            const { totalInputTokens: turnTotal, uncachedInputTokens: turnUncached, costMicroUsd: turnCostMicroUsd, } = usageCostMicroUsd(rs.telemetry.cacheFamily, u, rs.telemetry.pricing);
-            if (!rs.telemetry.pricingConfigured)
-                rs.telemetry.unpricedSpend = true;
-            stats.promptTokens += turnUncached;
-            stats.totalInputTokens += turnTotal;
-            stats.cachedTokens += u.cacheRead || 0;
-            stats.cacheWriteTokens += u.cacheWrite || 0;
-            stats.outputTokens += u.output || 0;
-            stats.costMicroUsd += turnCostMicroUsd;
-            rs.turn.turnUsage ??= { inputTokens: 0, totalInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costMicroUsd: 0 };
-            rs.turn.turnUsage.inputTokens += turnUncached;
-            rs.turn.turnUsage.totalInputTokens += turnTotal;
-            rs.turn.turnUsage.outputTokens += u.output || 0;
-            rs.turn.turnUsage.cacheReadTokens += u.cacheRead || 0;
-            rs.turn.turnUsage.cacheWriteTokens += u.cacheWrite || 0;
-            rs.turn.turnUsage.costMicroUsd += turnCostMicroUsd;
-            const callEndAt = Date.now();
-            const callIssuedAt = prepared.callIssuedAtRef.current;
-            prepared.callIssuedAtRef.current = undefined;
-            emitTrace(rs.telemetry.tracer, () => ({
-                kind: "brain.call",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                model: m.model,
-                provider: m.provider,
-                turn: stats.turns + 1,
-                promptTokens: turnUncached,
-                totalInputTokens: turnTotal,
-                completionTokens: u.output || 0,
-                cacheRead: u.cacheRead || 0,
-                cacheWrite: u.cacheWrite || 0,
-                latencyMs: rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0,
-                firstTokenMs: rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined ? rs.turn.firstTokenAt - rs.turn.callStartAt : undefined,
-                ...(callIssuedAt !== undefined ? { callStartedAt: callIssuedAt } : {}),
-                ...(rs.telemetry.pricingConfigured ? { costMicroUsd: turnCostMicroUsd } : {}),
-                ...(m.role === "assistant" && typeof m.stopReason === "string"
-                    ? { stopReason: m.stopReason }
-                    : {}),
-                ts: callEndAt,
-            }));
-            const cacheRowUnknown = m.usageMissing === true || m.stopReason === "aborted";
-            if (prepared.cacheBreakDetector && prepared.cacheFingerprint && !cacheRowUnknown) {
-                const finding = prepared.cacheBreakDetector.observe({
-                    turn: stats.turns + 1,
-                    systemPrompt: prepared.cacheFingerprint.systemPrompt,
-                    tools: prepared.cacheFingerprint.tools,
-                    modelKey: `${m.provider}:${m.model}`,
-                    cacheRead: u.cacheRead || 0,
-                });
-                if (finding) {
-                    rs.telemetry.cacheBreakReported = true;
-                    deps.runnerHooks.onError?.(new Error(`prompt-cache: break at turn ${finding.turn} — cache_read ${finding.cacheReadBefore}→${finding.cacheReadAfter}; ${finding.detail}. See design/31.`), { phase: "prompt-cache", sessionId: prepared.sessionId, classification: finding.cause });
-                }
-            }
-        }
-        if (m.role === "assistant" && typeof m.stopReason === "string") {
-            rs.turn.turnStopReason = m.stopReason;
-        }
-        if (m.role === "assistant") {
-            const rep = m.repetition;
-            if (rep !== undefined) {
-                const observed = [
-                    ...(rep.cut !== undefined ? [{ action: "cut", e: rep.cut }] : []),
-                    ...(rep.spared ?? []).map((e) => ({ action: "spared", e })),
-                ];
-                for (const { action, e } of observed) {
-                    if (action === "cut")
-                        rs.counters.repetitionCuts += 1;
-                    else
-                        rs.counters.repetitionSpared += 1;
-                    if (rs.counters.repetitionEvents.length < rs.counters.REPETITION_EVENTS_CAP) {
-                        rs.counters.repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment: e.segment });
-                    }
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "repetition.detected",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        turn: stats.turns + 1,
-                        action,
-                        rule: e.rule,
-                        period: e.period,
-                        reps: e.reps,
-                        segment: e.segment,
-                        ts: Date.now(),
-                    }));
-                }
-            }
-        }
-        if (m.role === "assistant") {
-            const content = m.content;
-            if (rs.attach.attachState !== undefined)
-                rs.counters.cadenceTurns = advanceCadenceClock(rs.attach.attachState, rs.counters.cadenceTurns, content, writeFamilyOf);
-            rs.turn.lastTurnHadToolCalls = Array.isArray(content) && content.some((c) => c?.type === "toolCall");
-        }
-        rs.turn.callStartAt = undefined;
-        rs.turn.firstTokenAt = undefined;
-        rs.budget.callOutputChars = 0;
-        rs.budget.lastStreamBudgetCheck = 0;
-    };
-    const onToolStart = (event) => {
-        const startAt = Date.now();
-        toolStartAt.set(event.toolCallId, startAt);
-        startedToolCallIds.add(event.toolCallId);
-        batchArgs?.set(event.toolCallId, event.args);
-        stats.toolCalls += 1;
-        if (spec.finalVerification === true && !(rs.counters.finalVerifyInjections === 0 ? rs.counters.groundingSignalPreR9 : rs.counters.groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
-            if (rs.counters.finalVerifyInjections === 0)
-                rs.counters.groundingSignalPreR9 = true;
-            else
-                rs.counters.groundingSignalPostR9 = true;
-        }
-        const activityArg = primaryActivityArg(event.args);
-        internalsNotifier.notify(() => observeThenableRejection(internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, at: startAt, ...(activityArg !== undefined ? { arg: activityArg } : {}) }), internalsNotifier, "runtask.onActivity.start"), "runtask.onActivity.start");
-        pushContent({
-            type: "tool_start",
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
-            args: event.args,
-            ...ident(),
-        });
-    };
-    const onToolEnd = (event) => {
-        const toolStarted = toolStartAt.get(event.toolCallId);
-        toolStartAt.delete(event.toolCallId);
-        const toolNow = Date.now();
-        if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
-            rs.counters.wroteThisRun = true;
-        }
-        if (rs.attach.attachState !== undefined && !event.isError) {
-            const det = event.result?.details;
-            if (det !== undefined)
-                reduceToolEnd(rs.attach.attachState, det);
-        }
-        if (postToolBatchHook !== undefined) {
-            if (prepared.blockedToolCalls.delete(event.toolCallId) || event.notExecuted === true) {
-                batchArgs?.delete(event.toolCallId);
-            }
-            else {
-                const digest = batchResponseDigest(event.result);
-                rs.turn.toolBatch.push({
-                    toolName: event.toolName,
-                    input: batchArgs?.get(event.toolCallId),
-                    toolCallId: event.toolCallId,
-                    ...(digest !== undefined ? { response: digest } : {}),
-                    isError: event.isError,
-                });
-                batchArgs?.delete(event.toolCallId);
-            }
-        }
-        emitTrace(rs.telemetry.tracer, () => ({
-            kind: "tool.call",
-            version: 1,
-            taskId: rs.telemetry.taskId,
-            name: event.toolName,
-            toolCallId: event.toolCallId,
-            turn: stats.turns + 1,
-            durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
-            ok: !event.isError,
-            ts: toolNow,
-        }));
-        internalsNotifier.notify(() => observeThenableRejection(internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow }), internalsNotifier, "runtask.onActivity.end"), "runtask.onActivity.end");
-        if (prepared.lspDiagnostics && !event.isError) {
-            const name = event.toolName;
-            if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
-                const d = event.result?.details;
-                const p = typeof d?.filePath === "string" ? d.filePath : typeof d?.notebookPath === "string" ? d.notebookPath : undefined;
-                if (p)
-                    prepared.lspDiagnostics.nudge(p);
-            }
-        }
-        const gate = prepared.gateOutcomes.get(event.toolCallId);
-        if (gate !== undefined)
-            prepared.gateOutcomes.delete(event.toolCallId);
-        pushContent({
-            type: "tool_end",
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
-            isError: event.isError,
-            ...toolEndBodyFrom(event.result, event.isError, gate, prepared.abortController.signal.aborted ? gatedCallIdOf(prepared) : undefined),
-            ...ident(),
-        });
-        announceWorkspaceMove();
-        if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
-            if (event.isError) {
-                rs.degrade.outputErrorStreak += 1;
-                if (rs.degrade.outputErrorStreak > rs.limits.outputRetryCap) {
-                    rs.degrade.outputInvalid = true;
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-            }
-            else {
-                rs.degrade.outputErrorStreak = 0;
-            }
-        }
-    };
-    const onTurnEnd = () => {
-        stats.turns += 1;
-        const stopExtra = rs.turn.turnStopReason !== undefined ? { stopReason: rs.turn.turnStopReason } : {};
-        queue.push(rs.turn.turnUsage
-            ? { type: "turn_end", usage: rs.turn.turnUsage, ...(rs.turn.turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() }
-            : { type: "turn_end", usageMissing: true, ...stopExtra, ...ident() });
-        rs.turn.turnUsageMissing = false;
-        rs.turn.turnStopReason = undefined;
-        if (parentToolCallId !== undefined) {
-            const progress = {
-                type: "task_progress",
-                taskId: rs.telemetry.taskId,
-                ...(internals?.delegationTaskType !== undefined ? { taskType: internals.delegationTaskType } : {}),
-                ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
-                ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
-                ...(subagentName ? { name: subagentName } : {}),
-                model: prepared.model.id,
-                usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
-                status: "running",
-                ...ident(),
-            };
-            queue.push(progress);
-            try {
-                internals?.onForwardEvent?.(progress);
-            }
-            catch {
-            }
-        }
-        emitTrace(rs.telemetry.tracer, () => ({ kind: "turn.end", version: 1, taskId: rs.telemetry.taskId, turn: stats.turns, ts: Date.now() }));
-        rs.turn.turnUsage = undefined;
-        rs.turn.callStartAt = undefined;
-        rs.turn.firstTokenAt = undefined;
-        rs.budget.callOutputChars = 0;
-        rs.budget.lastStreamBudgetCheck = 0;
-        toolStartAt.clear();
-        if (rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns) {
-            rs.limits.turnsExceeded = true;
-            if (prepared.suspendForResource === undefined) {
-                void prepared.harness.abort();
-                prepared.abortController.abort();
-            }
-        }
-        else {
-            if (rs.degrade.degraded === undefined &&
-                spec.limits?.degrade &&
-                rs.degrade.degradeToModel &&
-                rs.budget.maxCostMicroUsd !== undefined &&
-                stats.costMicroUsd >= spec.limits.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
-                void prepared.harness.setModel(rs.degrade.degradeToModel);
-                rs.degrade.recordDegraded({ from: prepared.model.id, to: rs.degrade.degradeToModel.id, reason: "budget", atTurn: stats.turns }, rs.degrade.degradeToModel);
-            }
-            const overAxis = rs.limits.budgetHit ? undefined : rs.budget.overBudget();
-            if (overAxis !== undefined) {
-                rs.limits.budgetHit = "exceeded";
-                rs.limits.budgetAxis = overAxis;
-                if (prepared.suspendForResource === undefined) {
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-            }
-        }
-    };
-    return { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove };
-}
-const REFUSED_DECIDE_KEYS = [
-    ["gateOutcome", "the settlement record is minted by core from the host's decision facts and the row's origin, never supplied"],
-    ["settledBy", 'a retired key — the host supplies decision FACTS as hostDecision{decidedBy: "person" | "sla_timeout", approver?} and core mints the settlement word from them'],
-    ["approver", "a retired key — the attribution rides the facts it belongs to, as hostDecision.approver"],
-];
 export class Runner {
     deps;
     sessions;
@@ -1102,7 +87,10 @@ export class Runner {
     suspendedEnvReaps = new Map();
     locallyClaimedTokens = new Set();
     static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
+    depsSeat;
     constructor(deps) {
+        const runner = this;
+        this.depsSeat = { get deps() { return runner.deps; } };
         this.deps = deps;
         if (this.deps.tiers) {
             this.deps = { ...this.deps, models: expandTiers(this.deps.models, this.deps.tiers) };
@@ -1348,7 +336,7 @@ export class Runner {
         })();
         const settled = run.catch(async (err) => {
             let code = errorCodeOf(err);
-            const reopenReason = code === "resume.tool_unavailable" ? "tool_unavailable" : "env_failed";
+            const reopenReason = code === "resume.tool_unavailable" || code === "resume.tool_contract_mismatch" ? "tool_unavailable" : "env_failed";
             const reopenable = resume !== undefined && resume.pendingActionStarted !== true && reopenReason !== undefined && !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true);
             let reopenCommitted = false;
             let reopenStateUnknown = false;
@@ -1442,6 +430,8 @@ export class Runner {
                     onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
                 }), "runtask.onDelegationLifecycle");
             }
+            if (forwardsSubagentEvents(spec))
+                await drainForwardedFramesBeforeDone();
             queue.push({ type: "done", result: resultValue });
             queue.close();
         });
@@ -1992,6 +982,7 @@ export class Runner {
         const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: runSourceTaskId } : { eventId: uuidv7() };
         notificationIdent = ident;
         queue.push({ type: "wiring_manifest", manifest: prepared.wiringManifest, ...ident() });
+        prepared.toolRosterDeltas.subscribe((delta) => queue.push({ type: "tool_roster_delta", delta, ...ident() }));
         const delegationLifecycleNotifier = createSafeNotifier({
             onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
         });
@@ -2553,17 +1544,20 @@ export class Runner {
         const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, () => runWithReasoningWireFacts(observeReasoningWireFacts, fn)));
         const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
         for (const orphan of prepared.wakeRecovered) {
-            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan), ...ident() });
+            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
             emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
         }
         const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
         const batchArgs = postToolBatchHook ? new Map() : undefined;
         rs.turn.toolBatch = [];
-        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = makeHarnessHandlers(prepared, stats, rs, {
-            spec, queue, internals, ident, parentToolCallId, subagentName,
-            pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
-            toolLabels, postToolBatchHook, batchArgs,
-            runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
+        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
+            prepared, stats, rs,
+            deps: {
+                spec, queue, internals, ident, parentToolCallId, subagentName,
+                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
+                toolLabels, postToolBatchHook, batchArgs,
+                runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
+            },
         });
         const recordCompactionUsage = (m, msg) => {
             const u = msg?.usage;
@@ -2977,16 +1971,19 @@ export class Runner {
             for (const w of manualCompactRef.waiters.splice(0))
                 w.resolve(outcome);
         };
-        const onTurnBoundary = makeTurnBoundary(prepared, stats, rs, {
-            spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
-            walltimeMonotonicDeadline,
-            timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
-            compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
-            runnerHooks: {
-                onError: this.deps.onError,
-                seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
-                compactionHookOptions: (s, sid, trig) => this.compactionHookOptions(s, sid, trig, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
-                recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
+        const onTurnBoundary = createTurnBoundary({
+            prepared, stats, rs,
+            deps: {
+                spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
+                walltimeMonotonicDeadline,
+                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
+                compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
+                runnerHooks: {
+                    onError: this.deps.onError,
+                    seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
+                    compactionHookOptions: (s, sid, trig) => this.compactionHookOptions(s, sid, trig, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
+                    recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
+                },
             },
         });
         prepared.gitStatusRef.reassert = async () => {
@@ -3496,7 +2493,7 @@ export class Runner {
         }
         catch (err) {
             loopLatch.ended = true;
-            if (errorCodeOf(err) === "resume.tool_unavailable") {
+            if (errorCodeOf(err) === "resume.tool_unavailable" || errorCodeOf(err) === "resume.tool_contract_mismatch") {
                 await settleTeardownLeg(() => prepared.mcp.dispose(), "mcp.dispose (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
                 await settleTeardownLeg(() => prepared.a2a?.dispose(), "a2a.dispose (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
                 await settleTeardownLeg(() => (prepared.ownedEnv && hasDestroy(prepared.ownedEnv) ? prepared.ownedEnv.destroy() : undefined), "ownedEnv.destroy (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
@@ -3519,6 +2516,7 @@ export class Runner {
             }
             notificationLaneLive = false;
             unsubscribeTaskNotifications();
+            prepared.toolRosterDeltas.unsubscribe();
             unsubGitRetry();
             unsubBoundary();
             unsub();
@@ -3551,7 +2549,7 @@ export class Runner {
                 const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
                 orphansClosed = report.recovered.length;
                 for (const orphan of report.recovered) {
-                    queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan), ...ident() });
+                    queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
                     emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
                 }
                 reconcileComplete = true;
@@ -3881,6 +2879,8 @@ export class Runner {
                 drainManualCompact("mooted");
             }
             manualCompactRef.emitMooted = undefined;
+            if (forwardsSubagentEvents(spec))
+                await drainForwardedFramesBeforeDone();
             queue.push({ type: "done", result });
             queue.close();
             await prepared.fileHistoryBoundary?.settle();
@@ -4022,718 +3022,41 @@ export class Runner {
         return stream.result();
     }
     async resumeStream(token, outcome, taskConfig, internals) {
-        if (outcome === null || typeof outcome !== "object") {
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome must be an object naming its gate (got ${outcome === null ? "null" : typeof outcome})`);
-        }
-        const config = typeof taskConfig === "object" && taskConfig !== null ? { ...taskConfig } : taskConfig;
-        internals = internals !== undefined ? { ...internals } : undefined;
-        const store = resolveCheckpointStore(config, this.deps);
-        if (!store) {
-            throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
-        }
-        let cp = await store.get(token);
-        if (!cp) {
-            throw new CheckpointError("checkpoint.not_found", "no checkpoint found for the supplied token");
-        }
-        if (cp.status !== "pending") {
-            const live = await store.get(token);
-            if (live?.status === "pending") {
-                throw new CheckpointError("checkpoint.reopened_concurrently", "checkpoint changed concurrently (a resolve/reopen cycle landed between this resume's read of the row and its state check) — nothing was validated or executed; re-resume against the current state");
-            }
-            throw new CheckpointError("checkpoint.already_resolved", `checkpoint is ${describeSuppliedValue(live?.status ?? cp.status)} — the token is consumed, so this resume was neither validated nor executed (idempotent); a different outcome cannot redeem it`);
-        }
-        if ((internals?.inheritedGate?.parentConstraints?.length ?? 0) === 0) {
-            const parked = this.parentConstraintRegistry.get(token);
-            if (parked !== undefined) {
-                internals = {
-                    ...(internals ?? {}),
-                    inheritedGate: { ...(internals?.inheritedGate ?? {}), parentConstraints: parked },
-                };
-            }
-        }
-        let wakeMessage;
-        let wakeHookContext;
-        const outcomeGate = outcome.gate;
-        const resumeSignal = config.signal;
-        let suppliedMessage;
-        if (outcomeGate === "wake") {
-            suppliedMessage = outcome.message;
-            const gk = cp.gate.kind;
-            const decideEntry = gk === "human" || gk === "irreversible_ask"
-                ? 'a `policy_ask` outcome (decision allow/deny bound to the pending tool call)'
-                : gk === "needs_review"
-                    ? 'a `dry_run_review` outcome (decision approve/reject)'
-                    : gk === "plan_review"
-                        ? 'a `plan_review` outcome (decision approve/edit/reject)'
-                        : gk === "resource_limit"
-                            ? 'a `resource_limit` outcome (decision "continue")'
-                            : undefined;
-            if (gk !== "task_done") {
-                throw new CheckpointError("wake.gate_pending", `cannot wake: this checkpoint awaits a pending gate decision (gate "${gk}") — wake is not a decision ` +
-                    `channel; resume it with ${decideEntry ?? "its own gate outcome"} instead`);
-            }
-            const pa = cp.pendingAction;
-            switch (pa.kind) {
-                case "task_done":
-                    break;
-                case "tool_approval":
-                case "resource_limit":
-                case "review":
-                case "plan_review": {
-                    throw new CheckpointError("wake.gate_pending", `cannot wake: this checkpoint still carries a pending gate-typed action (pendingAction "${pa.kind}" ` +
-                        `on a "${gk}" gate — inconsistent row) — wake is not a decision channel; resolve it through its ` +
-                        `own decide entry instead`);
-                }
-                default: {
-                    const _exhaustive = pa;
-                    void _exhaustive;
-                    throw new CheckpointError("wake.gate_pending", `cannot wake: this checkpoint carries an unrecognized pendingAction kind "${pa.kind}" ` +
-                        `(newer-version row?) — fail-closed: wake only serves a pure park (pendingAction "task_done")`);
-                }
-            }
-            if (suppliedMessage !== undefined) {
-                wakeMessage = validatePendingSteer(suppliedMessage);
-            }
-            else if (readPendingSteerQueue(cp.state).length === 0) {
-                throw new CheckpointError("wake.nothing_to_deliver", "cannot wake: no message was supplied and the checkpoint holds no parked pendingSteer — an empty " +
-                    "wake would burn the checkpoint on a blank continuation; supply `message` or park a steer first");
-            }
-        }
-        const gateMatch = isGateKind(cp.gate.kind) && resumeGateMatches(cp.gate.kind, outcomeGate);
-        if (!gateMatch) {
-            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") does not match checkpoint gate "${cp.gate.kind}" — resume serves ${Object.entries(PAUSE_REGISTRY)
-                .filter(([, row]) => !row.terminal)
-                .map(([k, row]) => `${k}/${row.resume}`)
-                .join(", ")}`);
-        }
-        let plainReviewOutcome;
-        if (cp.gate.kind === "plan_review") {
-            const decide = outcome;
-            const decision = decide.decision;
-            const editedPlan = decide.editedPlan;
-            const reason = decide.reason;
-            if (decision !== "approve" && decision !== "edit" && decision !== "reject") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the plan_review domain — a plan review is exactly "approve", "edit" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
-            }
-            assertOutcomeText(editedPlan, "editedPlan");
-            assertOutcomeText(reason, "reason");
-            plainReviewOutcome = {
-                gate: "plan_review",
-                decision,
-                ...(editedPlan !== undefined ? { editedPlan } : {}),
-                ...(reason !== undefined ? { reason } : {}),
-            };
-        }
-        else if (cp.gate.kind === "needs_review") {
-            const decide = outcome;
-            const decision = decide.decision;
-            const reason = decide.reason;
-            if (decision !== "approve" && decision !== "reject") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the dry_run_review domain — a dry-run review is exactly "approve" or "reject"; refusing pre-CAS, the checkpoint stays pending`);
-            }
-            assertOutcomeText(reason, "reason");
-            plainReviewOutcome = {
-                gate: "dry_run_review",
-                decision,
-                ...(reason !== undefined ? { reason } : {}),
-            };
-        }
-        if (plainReviewOutcome !== undefined) {
-            const reason = plainReviewOutcome.reason;
-            if (plainReviewOutcome.decision === "reject" && reason && sanitizeUntrustedText(reason) !== reason) {
-                throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
-            }
-            const capturedPlan = plainReviewOutcome.gate === "plan_review" ? plainReviewOutcome.editedPlan : undefined;
-            if (plainReviewOutcome.decision === "edit" &&
-                capturedPlan &&
-                sanitizeUntrustedText(capturedPlan) !== capturedPlan) {
-                throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
-            }
-            if (cp.reopenReason === "env_failed") {
-                const winner = cp.resolvedOutcome;
-                if (winner === undefined) {
-                    throw new CheckpointError("checkpoint.reopen_revote", "review checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
-                }
-                if (winner.decision !== plainReviewOutcome.decision) {
-                    throw new CheckpointError("checkpoint.reopen_revote", `an env_failed reopen replays the ALREADY-RECORDED review decision ("${winner.decision}") — refusing a re-vote with a different decision ("${plainReviewOutcome.decision}")`);
-                }
-                if (winner.updatedInput !== capturedPlan) {
-                    throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose edited plan differs from the recorded one");
-                }
-                if (winner.reason !== undefined && winner.reason !== plainReviewOutcome.reason) {
-                    throw new CheckpointError("checkpoint.reopen_revote", "an env_failed reopen replays the ALREADY-RECORDED review decision — refusing a re-vote whose reviewer note differs from the recorded one");
-                }
-            }
-        }
-        let plainParkOutcome;
-        if (outcomeGate === "wake") {
-            plainParkOutcome = {
-                gate: "wake",
-                ...(wakeMessage !== undefined ? { message: wakeMessage } : {}),
-            };
-        }
-        else if (outcomeGate === "resource_limit") {
-            const decision = outcome.decision;
-            if (decision !== "continue") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the resource_limit domain — a slice resume is exactly "continue"; refusing pre-CAS, the checkpoint stays pending`);
-            }
-            plainParkOutcome = { gate: "resource_limit", decision };
-        }
-        let suppliedAnswer;
-        let redeemedAnswer;
-        let plainPolicyOutcome;
-        if (cp.gate.kind === "human" || cp.gate.kind === "irreversible_ask") {
-            const decide = outcome;
-            suppliedAnswer = decide.answer;
-            if (suppliedAnswer !== undefined) {
-                const reading = classifyQuestionOutcome(suppliedAnswer);
-                if (reading.shape !== "answered") {
-                    throw new CheckpointError("checkpoint.invalid_outcome", "resume carried a content-ask `answer` that does not read as an answer (malformed, sparse, or not capturable as plain data) — " +
-                        "refusing pre-CAS rather than fabricating an empty human response; the checkpoint stays pending", { field: "answer" });
-                }
-                redeemedAnswer = reading.answer;
-            }
-            const updatedInputRaw = decide.updatedInput;
-            let updatedInput;
-            try {
-                updatedInput = updatedInputRaw === undefined ? undefined : structuredClone(updatedInputRaw);
-            }
-            catch {
-                throw new CheckpointError("checkpoint.invalid_outcome", "resume carried an `updatedInput` that could not be captured as plain data — refusing pre-CAS; the checkpoint stays pending");
-            }
-            if (Object.is(updatedInput, -0))
-                updatedInput = 0;
-            if (updatedInput !== undefined && !canonicalizeCapturedPlainData(updatedInput)) {
-                throw new CheckpointError("checkpoint.invalid_outcome", "resume carried an `updatedInput` outside the plain-JSON value domain (a Map/Set/Date/buffer, a sparse or expando-carrying array, a non-finite number, or a cycle) — " +
-                    "such a value reads differently on the two sides of the durable store; refusing pre-CAS, the checkpoint stays pending");
-            }
-            const decision = decide.decision;
-            if (decision !== "allow" && decision !== "deny") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume decision "${describeSuppliedValue(decision)}" is outside the policy_ask domain — a decide is exactly "allow" or "deny"; refusing pre-CAS, the checkpoint stays pending`);
-            }
-            for (const [key, why] of REFUSED_DECIDE_KEYS) {
-                if (Reflect.get(decide, key) !== undefined) {
-                    throw new CheckpointError("checkpoint.invalid_outcome", `resume carries \`${key}\` — ${why}; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-                }
-            }
-            const hostDecisionRaw = decide.hostDecision;
-            if (typeof hostDecisionRaw !== "object" || hostDecisionRaw === null) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries no hostDecision — a policy_ask decide names who decided it ({ decidedBy: "person" | "sla_timeout", approver? }); refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-            }
-            const decidedBy = hostDecisionRaw.decidedBy;
-            if (decidedBy !== "person" && decidedBy !== "sla_timeout") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume hostDecision.decidedBy "${describeSuppliedValue(decidedBy)}" is outside the closed set — it is exactly "person" or "sla_timeout"; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-            }
-            if (decidedBy === "sla_timeout" && decision === "allow") {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries decision "allow" decided by "sla_timeout" — an elapsed SLA window cannot be what approved an action that EXECUTES; refusing pre-CAS, the checkpoint stays pending`, { field: "hostDecision" });
-            }
-            const attribution = screenApproverAttribution(hostDecisionRaw.approver);
-            if (attribution.defect !== undefined) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume carries an approver attribution this engine refuses: ${attribution.defect}; refusing pre-CAS, the checkpoint stays pending`, { field: "approver" });
-            }
-            const reason = decide.reason;
-            assertOutcomeText(reason, "reason");
-            const approverCell = attribution.approver !== undefined ? { approver: attribution.approver } : {};
-            plainPolicyOutcome = {
-                gate: "policy_ask",
-                boundCallId: decide.boundCallId,
-                boundInputHash: decide.boundInputHash,
-                decision,
-                ...(updatedInput !== undefined ? { updatedInput } : {}),
-                ...(reason !== undefined ? { reason } : {}),
-                ...(redeemedAnswer !== undefined ? { answer: redeemedAnswer } : {}),
-                hostDecision: { decidedBy, ...approverCell },
-            };
-            if (plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason && sanitizeUntrustedText(plainPolicyOutcome.reason) !== plainPolicyOutcome.reason) {
-                throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
-            }
-        }
-        if (plainPolicyOutcome !== undefined) {
-            const boundTo = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolCallId : undefined;
-            if (plainPolicyOutcome.boundCallId !== boundTo) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${plainPolicyOutcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`, { field: "boundCallId" });
-            }
-            const boundHash = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.boundInputHash : undefined;
-            if (boundHash !== undefined) {
-                if (plainPolicyOutcome.boundInputHash !== boundHash) {
-                    throw new CheckpointError("checkpoint.invalid_outcome", "resume boundInputHash does not match the checkpoint's pending tool call input — the decision-action input binding (design/80 D-1 §2) failed; refusing to apply an approval bound to a different input (TOCTOU re-mint guard)", { field: "boundInputHash" });
-                }
-            }
-            else if (checkpointVersionOf(cp) >= BINDING_CHECKPOINT_VERSION) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `resume of a binding-version (v${checkpointVersionOf(cp)}) checkpoint whose pending tool call has no persisted boundInputHash — refusing to resume an unbound binding-version checkpoint (corruption / downgrade guard)`);
-            }
-            if (cp.reopenReason === "env_failed") {
-                if (cp.resolvedOutcome === undefined) {
-                    throw new CheckpointError("checkpoint.reopen_revote", "checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
-                }
-                const incoming = winnerFromOutcome(plainPolicyOutcome);
-                const persistedWinner = (() => {
-                    const w = cp.resolvedOutcome;
-                    if (w?.answer === undefined)
-                        return w;
-                    const reading = classifyQuestionOutcome(w.answer);
-                    return reading.shape === "answered" ? { ...w, answer: reading.answer } : w;
-                })();
-                if (incoming === undefined || !sameWinner(incoming, persistedWinner)) {
-                    throw new CheckpointError("checkpoint.reopen_revote", `this checkpoint was reopened after an env-restore failure (env_failed) — a re-resume is a system retry of the already-approved action, not a re-vote; the supplied decision must replay the persisted winner (boundCallId "${cp.resolvedOutcome.boundCallId}", decision "${cp.resolvedOutcome.decision}"), refusing a different decision`);
-                }
-            }
-            const contentAskCallId = pendingContentAskCallId(cp);
-            if (suppliedAnswer !== undefined && (contentAskCallId === undefined || plainPolicyOutcome.decision !== "allow")) {
-                throw new CheckpointError("checkpoint.invalid_outcome", contentAskCallId === undefined
-                    ? "resume carried a content-ask `answer` but the checkpoint's pending call is not the reserved question tool — an answer has no consumer on a side-effecting tool's approval; refusing rather than dropping it silently"
-                    : "resume carried a content-ask `answer` on a `deny` — a denial injects a refusal, never an answer; refusing rather than dropping it silently", { field: "answer" });
-            }
-            if (contentAskCallId !== undefined && plainPolicyOutcome.decision === "allow" && suppliedAnswer === undefined) {
-                if (!isLiveQuestionFace(config.onQuestion ?? this.deps.onQuestion)) {
-                    throw new CheckpointError("checkpoint.invalid_outcome", "resume approved a content-ask (the reserved question tool) without an `answer`, and this resume has no live answering face — " +
-                        'executing the question against nothing would hand the model a fabricated "no human is available" default while consuming the approval; ' +
-                        "re-resume with the operator's answer on the outcome (or deny it), the checkpoint stays pending", { field: "answer" });
-                }
-            }
-        }
-        if (checkpointVersionOf(cp) > MAX_SUPPORTED_CHECKPOINT_VERSION) {
-            throw new CheckpointError("checkpoint.unsupported_version", `checkpoint version ${checkpointVersionOf(cp)} is newer than this worker supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION})`, { reason: "version_newer" });
-        }
-        const preCasGateBit = cp.gate.kind === "irreversible_ask" ? cp.gate.realApproval : undefined;
-        const preCasBitWellFormed = preCasGateBit !== undefined && typeof preCasGateBit === "object" && isAskOrigin(preCasGateBit.origin);
-        const faceSaysGoverned = (cp.state.readFace?.realApproval) === true;
-        const preCasBitViolation = checkpointVersionOf(cp) === REAL_APPROVAL_CHECKPOINT_VERSION
-            ? !preCasBitWellFormed
-            : checkpointVersionOf(cp) < REAL_APPROVAL_CHECKPOINT_VERSION
-                ? preCasGateBit !== undefined
-                : faceSaysGoverned
-                    ? !preCasBitWellFormed
-                    : preCasGateBit !== undefined && !preCasBitWellFormed;
-        if (preCasBitViolation) {
-            throw new CheckpointError("checkpoint.invalid_outcome", checkpointVersionOf(cp) >= REAL_APPROVAL_CHECKPOINT_VERSION
-                ? `a v${checkpointVersionOf(cp)} checkpoint's realApproval gate bit must be well-formed (origin a member of the closed ask-origin set)${checkpointVersionOf(cp) === REAL_APPROVAL_CHECKPOINT_VERSION ? " and present on an irreversible_ask gate" : ""} — this row's is not; refusing to resume a damaged real-approval row (corruption / downgrade guard), the checkpoint stays pending`
-                : `a v${checkpointVersionOf(cp)} checkpoint carries a realApproval gate bit no release of that version ever minted — refusing to honor a fabricated origin (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= REAL_APPROVAL_CHECKPOINT_VERSION ? "real_approval_damaged" : "real_approval_forged" });
-        }
-        {
-            const faceSectionRaw = cp.state.readFace;
-            const faceCandidate = faceSectionRaw !== undefined && typeof faceSectionRaw === "object" && faceSectionRaw !== null
-                ? faceSectionRaw
-                : undefined;
-            const faceWellFormed = faceCandidate !== undefined &&
-                (faceCandidate.face === "open" || faceCandidate.face === "roots") &&
-                (faceCandidate.realApproval === undefined || faceCandidate.realApproval === true) &&
-                (faceCandidate.denyEntries === undefined ||
-                    (Array.isArray(faceCandidate.denyEntries) &&
-                        faceCandidate.denyEntries.every((e) => persistedReadDenyEntryProblem(e) === null)));
-            if (checkpointVersionOf(cp) >= FACE_CHECKPOINT_VERSION ? !faceWellFormed : faceSectionRaw !== undefined) {
-                throw new CheckpointError("checkpoint.invalid_outcome", checkpointVersionOf(cp) >= FACE_CHECKPOINT_VERSION
-                    ? `a v${checkpointVersionOf(cp)} checkpoint must carry a well-formed read-face section (state.readFace) — this row's is missing or malformed; refusing to resume a damaged read-face row (corruption / downgrade guard), the checkpoint stays pending`
-                    : `a v${checkpointVersionOf(cp)} checkpoint carries a read-face section no release of that version ever minted — refusing to honor a fabricated read-face state (corruption / forgery guard), the checkpoint stays pending`, { reason: checkpointVersionOf(cp) >= FACE_CHECKPOINT_VERSION ? "read_face_damaged" : "read_face_forged" });
-            }
-        }
-        if (realApprovalOrgFact(preCasGateBit) !== undefined && this.deps.permissionRuleStore?.partitions.org !== true) {
-            throw new CheckpointError("checkpoint.unsupported_version", `this checkpoint's approval was minted under organization governance (org ${String(realApprovalOrgFact(preCasGateBit))}, routed as ${String(preCasGateBit?.origin)}) and this worker has no org adjudication wiring (its permission-rule store carries no org partition) — a governed approval may only be redeemed where governance can be enforced; the checkpoint stays pending, resume it on an org-wired worker`, { reason: "governed_unwired" });
-        }
-        const retiredWalltimeTotal = cp.resourceLedger?.totalWalltimeSec;
-        if (retiredWalltimeTotal !== undefined) {
-            throw new CheckpointError("checkpoint.walltime_axis_retired", "this checkpoint's ledger carries a cross-slice WALL-CLOCK allocation (resourceLedger.totalWalltimeSec), an axis this engine version retired — " +
-                "resuming here would run the leg with that ceiling unenforced. Rejected pre-CAS (the checkpoint stays pending): finish it on a worker of the " +
-                "previous release, or start a fresh task bounded by resourceSuspend.totalTokens / totalBudgetUsd.");
-        }
-        if (resumeSignal?.aborted === true && cp.status === "pending") {
-            throw new CheckpointError("checkpoint.resume_aborted", "the resume was handed an ALREADY-ABORTED signal — refusing to consume the approval on a leg that cannot run it (the checkpoint stays pending and is resumable with a live signal)");
-        }
-        if (cp.state.workspaceHandle !== undefined && this.deps.executionEnvFactory === undefined) {
-            throw new CheckpointError("checkpoint.unsupported_version", "checkpoint has a remote workspaceHandle but no RunnerDeps.executionEnvFactory is wired to rebuild the env", { reason: "env_factory_missing" });
-        }
-        if (cp.state.workspaceHandle !== undefined && internals?.requestedCwd !== undefined) {
-            throw new CheckpointError("checkpoint.cwd_conflicts_restore", `internals.requestedCwd ("${internals.requestedCwd}") cannot be combined with a checkpoint workspace restore — ` +
-                "the restored workspace's own mount path is authoritative for the task root. Drop requestedCwd on resume legs " +
-                "(the checkpoint stays pending and is resumable without it).");
-        }
-        if (cp.state.inheritedGate?.requiresParentConstraint === true) {
-            const supplied = internals?.inheritedGate?.parentConstraints?.length ?? 0;
-            if (supplied === 0) {
-                throw new CheckpointError("resume.parent_constraint_missing", "this checkpoint's task ran under inherited parent-policy constraints (state.inheritedGate.requiresParentConstraint) " +
-                    "— the live policy/onAsk closures cannot be persisted, so the resume must re-supply them via " +
-                    "resumeStream(token, outcome, taskConfig, internals) with internals.inheritedGate.parentConstraints; " +
-                    "rejected pre-CAS (the checkpoint stays pending) rather than silently dropping the ancestors' gate");
-            }
-            const expected = cp.state.inheritedGate.parentConstraintCount;
-            if (expected !== undefined && supplied !== expected) {
-                throw new CheckpointError("resume.parent_constraint_mismatch", `re-supplied ${supplied} parent constraint(s) but the checkpoint recorded ${expected} — a partial/mismatched ` +
-                    "re-supply would run the resumed leg under a different ancestor chain than it suspended with; " +
-                    "rejected pre-CAS (the checkpoint stays pending) — re-resume with the full original chain");
-            }
-            if (checkpointVersionOf(cp) >= F012_CHECKPOINT_VERSION &&
-                (cp.state.inheritedGate.constraintChain === undefined || cp.state.inheritedGate.constraintDigest === undefined)) {
-                throw new CheckpointError("checkpoint.invalid_outcome", `a v${checkpointVersionOf(cp)} checkpoint that requires parent constraints must carry BOTH the frozen constraintChain and its constraintDigest (they are minted in one write with the version stamp) — this row carries neither or only one; refusing to fall back to the count-only contract on a damaged row (corruption / downgrade guard), the checkpoint stays pending`, { reason: "constraint_chain_missing" });
-            }
-            const expectedDigest = cp.state.inheritedGate.constraintDigest;
-            if (expectedDigest !== undefined) {
-                const persistedChain = cp.state.inheritedGate.constraintChain;
-                if (persistedChain === undefined || constraintChainDigest(persistedChain) !== expectedDigest) {
-                    throw new CheckpointError("resume.parent_constraint_mismatch", "the checkpoint's OWN recorded constraint chain does not match its recorded digest " +
-                        "(corrupt / inconsistently-minted row) — the frozen deny data the resume would execute is not the data the " +
-                        "digest authenticates; rejected pre-CAS (the checkpoint stays pending)");
-                }
-                const suppliedDigest = constraintChainDigest((internals?.inheritedGate?.parentConstraints ?? []).map((pc, i) => constraintChainEntryOfSuppliedLayer(pc, persistedChain[i])));
-                if (suppliedDigest !== expectedDigest) {
-                    throw new CheckpointError("resume.parent_constraint_mismatch", "the re-supplied parent-constraint chain's projection content does not match what the checkpoint recorded " +
-                        `(recorded ${expectedDigest}, re-supplied ${suppliedDigest}) — a same-shape chain with different frozen ` +
-                        "deny data would run the resumed leg under a different ancestor gate than it suspended with; " +
-                        "rejected pre-CAS (the checkpoint stays pending) — re-resume with the original chain's policies " +
-                        "(including, when the row recorded one, the ancestor's auto-mode arming recipe verbatim)");
-                }
-            }
-        }
-        const resumeInternals = internals?.inheritedGate?.parentConstraints !== undefined
-            ? {
-                ...internals,
-                inheritedGate: {
-                    ...internals.inheritedGate,
-                    parentConstraints: Object.freeze(internals.inheritedGate.parentConstraints.map((e) => ({ ...e }))),
-                },
-            }
-            : internals;
-        if (this.deps.lockedConfig?.keys?.includes("toolPolicy") === true && config.basePolicyForResumeEdit !== undefined) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "TaskSpec.basePolicyForResumeEdit is administratively locked by this deployment (locked key \"toolPolicy\") — a task-supplied " +
-                "resume-edit policy is refused pre-CAS (the checkpoint stays pending); remove the field or change the deployment's lock configuration");
-        }
-        let recheckGovernanceWindow;
-        {
-            const rowPrincipal = cp.principal || undefined;
-            const suppliedPrincipal = config.principal || undefined;
-            if (rowPrincipal !== undefined && suppliedPrincipal !== undefined && suppliedPrincipal !== rowPrincipal) {
-                throw new CheckpointError("resume.principal_mismatch", `the resume config carries principal ${JSON.stringify(suppliedPrincipal)} but this checkpoint was suspended under principal ${JSON.stringify(rowPrincipal)} — ` +
-                    "running the resumed leg under a different identity would move its usage-ledger bucket, scope derivation and attribution; " +
-                    "refused pre-CAS (the checkpoint stays pending): re-resume with the original principal, or omit the field to inherit the recorded one");
-            }
-            {
-                const recordedPlacementRoot = placementValueOrAbsent(cp.state.placementRootSessionId);
-                const suppliedPlacementRoot = placementValueOrAbsent(internals?.placementRoot);
-                if (recordedPlacementRoot !== undefined && suppliedPlacementRoot !== undefined && suppliedPlacementRoot !== recordedPlacementRoot) {
-                    throw new CheckpointError("resume.placement_mismatch", `the resume supplied explicit placement root ${JSON.stringify(suppliedPlacementRoot)} but this checkpoint recorded placement root ${JSON.stringify(recordedPlacementRoot)} at suspend — ` +
-                        "resuming under a different placement fixed point would re-place the leg (and its descendants) on another target; " +
-                        "refused pre-CAS (the checkpoint stays pending): re-resume with the recorded root, or omit internals.placementRoot to inherit it");
-                }
-            }
-            const owesDelivery = outcomeGate !== "resource_limit" ||
-                readPendingSteerQueue(cp.state).length > 0 ||
-                (cp.state.runningBackgroundTasks?.length ?? 0) > 0;
-            const usageWindowStore = this.deps.usageWindowStore;
-            if (owesDelivery && usageWindowStore !== undefined) {
-                const preCasWindows = resolveUsageWindows(this.deps.usageWindows);
-                if (preCasWindows !== undefined && preCasWindows.length > 0) {
-                    const ledgerKey = (suppliedPrincipal ?? rowPrincipal) || GLOBAL_USAGE_KEY;
-                    const assertWindowOpen = async () => {
-                        const wait = usageRetryAfterMs(await usageWindowStore.read(ledgerKey, preCasWindows, Date.now()), preCasWindows);
-                        if (wait !== undefined) {
-                            throw new CheckpointError("resume.usage_window_exhausted", `a deployment usage window for ledger key ${JSON.stringify(ledgerKey)} is exhausted, and this checkpoint still owes a delivery a re-mint cannot carry — ` +
-                                `refused pre-CAS (nothing consumed, nothing unpinned): the same token and the same decision are redeemable once the window frees, in ${String(wait)}ms`, { retryAfterMs: wait });
-                        }
-                    };
-                    recheckGovernanceWindow = assertWindowOpen;
-                    await assertWindowOpen();
-                }
-            }
-        }
-        if (outcomeGate === "wake" && wakeMessage !== undefined) {
-            const resumeScreenHooks = config.hooks ?? this.deps.hooks;
-            const screen = resumeScreenHooks?.userPromptSubmit;
-            if (screen !== undefined && resumeSignal?.aborted !== true) {
-                const screenedMessage = wakeMessage;
-                const identity = mintHookInvocationIdentity({
-                    sessionId: cp.sessionId,
-                    taskId: config.taskId ?? cp.sessionId,
-                    legKind: "resume",
-                    isDelegatedChild: effectiveDelegationFacts(internals, cp.state.isDelegatedChild).isDelegatedChild,
-                    ...(internals?.insideFork === true ? { insideFork: true } : {}),
-                    ...(internals?.agentName !== undefined ? { agentName: internals.agentName } : {}),
-                    ...(internals?.parentToolCallId !== undefined ? { parentToolCallId: internals.parentToolCallId } : {}),
-                });
-                const screenTimeoutMs = resolveHookTimeoutMs(resumeScreenHooks?.timeoutMs, (badErr) => {
-                    try {
-                        this.deps.onError?.(badErr instanceof Error ? badErr : new Error(String(badErr)), { phase: "hook", sessionId: cp.sessionId });
-                    }
-                    catch {
-                    }
-                }, resumeScreenHooks);
-                let decision;
-                try {
-                    const seat = await runHookSeat("userPromptSubmit", { timeoutMs: screenTimeoutMs, ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}), abortEnds: true }, (sig) => screen(screenedMessage.text, {
-                        identity,
-                        signal: sig,
-                        source: "resume_message",
-                        ...(screenedMessage.inputId !== undefined ? { inputId: screenedMessage.inputId } : {}),
-                        ...(screenedMessage.actor !== undefined ? { actor: snapshotActorAssertion(screenedMessage.actor) } : {}),
-                    }));
-                    if (seat.expired) {
-                        throw new CheckpointError("steering.blocked_by_hook", seat.cause === "timeout"
-                            ? `the deployment's userPromptSubmit hook did not answer within its ${screenTimeoutMs}ms bound while screening this wake message; the resume was refused (fail-closed) and the checkpoint stays pending`
-                            : `the resume was cancelled while the deployment's userPromptSubmit hook was still screening this wake message; the checkpoint stays pending`);
-                    }
-                    decision = seat.value;
-                }
-                catch (hookErr) {
-                    if (hookErr instanceof CheckpointError)
-                        throw hookErr;
-                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
-                    try {
-                        this.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
-                    }
-                    catch {
-                    }
-                    throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook crashed while screening this wake message (${inlineUntrusted(err.message)}); the resume was refused (fail-closed) and the checkpoint stays pending`);
-                }
-                if (decision?.block !== undefined && decision.block !== "") {
-                    throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook blocked this wake message: ${inlineUntrusted(decision.block)}`);
-                }
-                if (decision?.additionalContext !== undefined && decision.additionalContext !== "") {
-                    wakeHookContext = decision.additionalContext;
-                }
-                if (recheckGovernanceWindow !== undefined)
-                    await recheckGovernanceWindow();
-            }
-        }
-        if (plainPolicyOutcome !== undefined &&
-            plainPolicyOutcome.decision === "allow" &&
-            plainPolicyOutcome.updatedInput !== undefined &&
-            cp.pendingAction.kind === "tool_approval" &&
-            cp.pendingAction.toolName !== ASK_USER_QUESTION_TOOL_NAME) {
-            const editedArgs = plainPolicyOutcome.updatedInput;
-            const editBudget = {
-                resourceRemainingMicroUsd: remainingBudgetMicroUsd(cp.resourceLedger),
-                resourceSpentMicroUsd: cp.resourceLedger?.spentMicroUsd ?? 0,
-                suspendCount: cp.suspendCount ?? 0,
-            };
-            const editedReq = {
-                toolName: cp.pendingAction.toolName,
-                args: editedArgs,
-                toolCallId: cp.pendingAction.toolCallId,
-                budget: editBudget,
-                ...(cp.state.handsCwd !== undefined ? { cwd: cp.state.handsCwd } : {}),
-            };
-            const editSignal = config.signal;
-            const raceEditAbort = async (p) => {
-                if (editSignal === undefined)
-                    return p;
-                if (editSignal.aborted) {
-                    throw new CheckpointError("checkpoint.resume_aborted", "the resume was aborted while re-adjudicating the approver's edit — the checkpoint stays pending and is resumable with a live signal");
-                }
-                return new Promise((resolve, reject) => {
-                    const onAbort = () => reject(new CheckpointError("checkpoint.resume_aborted", "the resume was aborted while re-adjudicating the approver's edit — the checkpoint stays pending and is resumable with a live signal"));
-                    editSignal.addEventListener("abort", onAbort, { once: true });
-                    p.then((v) => { editSignal.removeEventListener("abort", onAbort); resolve(v); }, (e) => { editSignal.removeEventListener("abort", onAbort); reject(e); });
-                });
-            };
-            const ig = cp.state.inheritedGate;
-            if (ig?.requiresParentConstraint === true) {
-                const chain = ig.constraintChain;
-                const unprojectable = chain === undefined
-                    ? "the checkpoint predates the frozen projection chain (no constraintChain recorded)"
-                    : chain.some((e) => "opaque" in e)
-                        ? "the inherited chain carries an OPAQUE layer (no projection exported)"
-                        : chain.some((e) => !("opaque" in e) && e.requiresLiveRemainder)
-                            ? "an inherited chain layer declares a live remainder beyond its projection"
-                            : undefined;
-                if (unprojectable !== undefined) {
-                    throw new CheckpointError("resume.constraint_unprojectable", `the approver EDITED this call's input, but the inherited ancestor chain cannot re-adjudicate the edit statically: ${unprojectable}. ` +
-                        "Refusing the edited resume pre-CAS (the checkpoint stays pending and remains decidable) — approve the shown input as-is, deny it, " +
-                        "or re-issue the edited action as a fresh call so the full live chain adjudicates it");
-                }
-                for (const entry of chain) {
-                    const denied = checkToolPolicyProjection(entry, editedReq);
-                    if (denied !== undefined) {
-                        throw new CheckpointError("resume.constraint_rejected", `the approver EDITED this call's input and a FROZEN inherited ancestor constraint denies the edited args${denied.message ? `: ${denied.message}` : ""}. ` +
-                            "Refused pre-CAS (fresh-redecision semantics: the checkpoint stays pending and the same token remains decidable — approve as shown, deny, or edit differently)");
-                    }
-                }
-            }
-            const toolPolicyLocked = this.deps.lockedConfig?.keys?.includes("toolPolicy") === true;
-            const editBasePolicy = toolPolicyLocked
-                ? (this.deps.basePolicyForResumeEdit ?? this.deps.toolPolicy)
-                : (config.basePolicyForResumeEdit ?? this.deps.basePolicyForResumeEdit ?? config.toolPolicy ?? this.deps.toolPolicy);
-            if (editBasePolicy !== undefined) {
-                let rechecked;
-                try {
-                    rechecked = refuseOutOfContractDecision(await raceEditAbort(Promise.resolve(editBasePolicy.check(editedReq, editSignal))));
-                }
-                catch (err) {
-                    if (err instanceof CheckpointError)
-                        throw err;
-                    rechecked = { action: "deny", message: `the resume-edit policy re-check errored: ${err instanceof Error ? err.message : String(err)}` };
-                }
-                if (rechecked.action === "deny") {
-                    throw new CheckpointError("resume.constraint_rejected", `the approver EDITED this call's input and the deployment's resume-edit policy denies the edited args${rechecked.message ? `: ${rechecked.message}` : ""}. ` +
-                        "Refused pre-CAS (the checkpoint stays pending and remains decidable)");
-                }
-                if (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, editedArgs)) {
-                    throw new CheckpointError("resume.constraint_rejected", `the deployment's resume-edit policy REWROTE the approver's edited args to a different value than was approved — the durable resume cannot execute either the un-adjudicated edit or an unapproved rewrite; ` +
-                        `refused pre-CAS (the checkpoint stays pending); re-submit the edited action so the rewrite is adjudicated and approved synchronously`);
-                }
-            }
-            const resumeHooks = config.hooks ?? this.deps.hooks;
-            if (resumeHooks?.preToolUse !== undefined && resumeHooks.preToolUseObservational === true) {
-                try {
-                    await raceEditAbort(Promise.resolve(resumeHooks.preToolUse(cp.pendingAction.toolName, cloneObserverInput(editedArgs), {
-                        toolCallId: cp.pendingAction.toolCallId,
-                        toolName: cp.pendingAction.toolName,
-                    })));
-                }
-                catch (err) {
-                    if (err instanceof CheckpointError)
-                        throw err;
-                    throw new CheckpointError("resume.constraint_rejected", `the declared-observational PreToolUse face threw while observing the approver's edited args (${err instanceof Error ? err.message : String(err)}) — ` +
-                        "refused fail-closed pre-CAS (the checkpoint stays pending and remains decidable)");
-                }
-            }
-        }
-        if (plainPolicyOutcome !== undefined) {
-            const parkedOrigin = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.origin : undefined;
-            if (!isAskOrigin(parkedOrigin)) {
-                throw new CheckpointError("checkpoint.unsupported_version", "this checkpoint's pending approval carries no origin word (a row minted before the ask's origin was persisted on the park) — its settlement cannot be recorded; the checkpoint stays pending");
-            }
-            const facts = plainPolicyOutcome.hostDecision;
-            const approverCell = facts.approver !== undefined ? { approver: facts.approver } : {};
-            const settlement = facts.decidedBy === "sla_timeout"
-                ? { kind: "park_sla_expired", who: { party: "host", ...approverCell }, when: Date.now() }
-                : { kind: plainPolicyOutcome.decision === "allow" ? "human_allowed" : "human_refused", who: { party: "person", ...approverCell }, when: Date.now(), ...(plainPolicyOutcome.decision === "deny" && plainPolicyOutcome.reason !== undefined ? { note: plainPolicyOutcome.reason } : {}) };
-            plainPolicyOutcome = { ...plainPolicyOutcome, gateOutcome: mintGateOutcome({ ...(plainPolicyOutcome.decision === "deny" ? { deniedBy: "ask_resolution" } : {}), settled: { settlement, origin: parkedOrigin } }) };
-        }
-        const outcomeForStore = plainPolicyOutcome ?? plainReviewOutcome ?? plainParkOutcome;
-        if (outcomeForStore === undefined) {
-            throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") matched the checkpoint gate but no lane captured it — refusing pre-CAS rather than passing the caller's live object to the store and the resumed run`);
-        }
-        if (this.deps.resumePreflight !== undefined) {
-            const preflight = this.deps.resumePreflight;
-            const rawDeadline = this.deps.resumePreflightTimeoutMs;
-            let preflightTimeoutMs = RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS;
-            if (rawDeadline !== undefined) {
-                if (typeof rawDeadline === "number" && Number.isFinite(rawDeadline) && rawDeadline > 0 && rawDeadline <= MAX_HOOK_TIMEOUT_MS) {
-                    preflightTimeoutMs = rawDeadline;
-                }
-                else {
-                    try {
-                        this.deps.onError?.(new Error(`RunnerDeps.resumePreflightTimeoutMs is not a positive finite number within the seat ceiling of ${MAX_HOOK_TIMEOUT_MS}ms (got ${describeSuppliedValue(rawDeadline)}) — the resume preflight falls back to its own ${RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS}ms default`), { phase: "config", sessionId: cp.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            const info = {
-                token,
-                sessionId: cp.sessionId,
-                ...(cp.state.placementRootSessionId !== undefined ? { placementRootSessionId: cp.state.placementRootSessionId } : {}),
-                ...(cp.principal ? { principal: cp.principal } : {}),
-                ...(cp.state.workspaceHandle !== undefined ? { workspaceHandle: structuredClone(cp.state.workspaceHandle) } : {}),
-                gateKind: cp.gate.kind,
-            };
-            const refusalTail = "; the checkpoint stays pending and the same token is redeemable once the obstacle clears";
-            let verdict;
-            try {
-                const seat = await runHookSeat("resumePreflight", {
-                    timeoutMs: preflightTimeoutMs,
-                    ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}),
-                    abortEnds: true,
-                    onBadTimeout: (badErr) => {
-                        try {
-                            this.deps.onError?.(badErr instanceof Error ? badErr : new Error(String(badErr)), { phase: "hook", sessionId: cp.sessionId });
-                        }
-                        catch {
-                        }
-                    },
-                    owner: this.deps,
-                }, (sig) => preflight(info, sig));
-                if (seat.expired) {
-                    throw new CheckpointError("resume.preflight_rejected", seat.cause === "timeout"
-                        ? `the deployment's resumePreflight did not answer within its ${preflightTimeoutMs}ms deadline while screening this resume — refused fail-closed (retry-later arm)${refusalTail}`
-                        : `the resume was cancelled while the deployment's resumePreflight was still screening it — refused (retry-later arm)${refusalTail}`);
-                }
-                verdict = seat.value;
-            }
-            catch (preflightErr) {
-                if (preflightErr instanceof CheckpointError)
-                    throw preflightErr;
-                const err = preflightErr instanceof Error ? preflightErr : new Error(String(preflightErr));
-                try {
-                    this.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
-                }
-                catch {
-                }
-                throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight crashed while screening this resume (${inlineUntrusted(err.message)}) — refused fail-closed (retry-later arm)${refusalTail}`);
-            }
-            const verdictOk = verdict !== null && typeof verdict === "object" ? verdict.ok : undefined;
-            if (verdictOk !== true) {
-                const bag = verdict !== null && typeof verdict === "object" ? verdict : undefined;
-                const disposition = bag?.disposition;
-                const suppliedMessage = bag?.message;
-                const retryAfterMs = bag?.retryAfterMs;
-                const readableMessage = typeof suppliedMessage === "string" && suppliedMessage !== "" ? suppliedMessage : undefined;
-                const said = readableMessage !== undefined ? `: ${inlineUntrusted(readableMessage)}` : " (no readable verdict — fail-closed)";
-                if (disposition === "terminal" && readableMessage !== undefined) {
-                    this.locallyClaimedTokens.add(token);
-                    let settled;
-                    try {
-                        settled = await store.expire(token, cp.scope);
-                    }
-                    catch (expireErr) {
-                        this.locallyClaimedTokens.delete(token);
-                        throw expireErr;
-                    }
-                    if (!settled) {
-                        this.locallyClaimedTokens.delete(token);
-                        const live = await store.get(token);
-                        if (live?.status === "pending") {
-                            throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said}, but the row moved under this refusal (a concurrent resolve/reopen cycle) — nothing was settled here; the row is pending again, re-resume against the current state (the preflight screens every attempt)`);
-                        }
-                        throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said} — a concurrent actor had already settled the row (${describeSuppliedValue(live?.status ?? "consumed")}); nothing was settled by this refusal`);
-                    }
-                    this.parentConstraintRegistry.delete(token);
-                    const terminalReap = this.suspendedEnvReaps.get(token);
-                    this.suspendedEnvReaps.delete(token);
-                    this.locallyClaimedTokens.delete(token);
-                    if (terminalReap?.env !== undefined && hasDestroy(terminalReap.env)) {
-                        const terminalEnv = terminalReap.env;
-                        await settleTeardownLeg(() => terminalEnv.destroy(), "terminal-preflight env destroy", (envErr) => {
-                            try {
-                                this.deps.onError?.(envErr, { phase: "config", sessionId: terminalReap.sessionId });
-                            }
-                            catch {
-                            }
-                        });
-                    }
-                    try {
-                        this.deps.onError?.(new Error(`resumePreflight ruled this row PERMANENTLY blocked${said} — the row was settled terminally (expired) by this refusal's single-shot CAS (token no longer redeemable)`), { phase: "hook", sessionId: cp.sessionId });
-                    }
-                    catch {
-                    }
-                    throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said} — the row was settled terminally (expired by this refusal's single-shot CAS); the token is not redeemable`);
-                }
-                const waitHint = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? retryAfterMs : undefined;
-                throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight refused this resume${said}${refusalTail}${waitHint !== undefined ? ` (deployment wait hint: ${String(waitHint)}ms)` : ""}`, waitHint !== undefined ? { retryAfterMs: waitHint } : undefined);
-            }
-            if (recheckGovernanceWindow !== undefined)
-                await recheckGovernanceWindow();
-        }
-        this.locallyClaimedTokens.add(token);
-        let won;
-        let claimLossStatus;
-        if (store.claimTerminal !== undefined) {
-            const claim = await store.claimTerminal(token, cp.scope, { kind: "resolve", outcome: outcomeForStore, expect: { rev: cp.rev ?? 0 } });
-            won = claim.claimed;
-            if (!claim.claimed)
-                claimLossStatus = claim.current.status;
-        }
-        else {
-            won = await store.resolve(token, cp.scope, outcomeForStore, { rev: cp.rev ?? 0 });
-        }
-        if (!won)
-            this.locallyClaimedTokens.delete(token);
-        if (!won) {
-            const stillPending = claimLossStatus !== undefined ? claimLossStatus === "pending" : (await store.get(token))?.status === "pending";
-            if (stillPending) {
-                throw new CheckpointError("checkpoint.reopened_concurrently", "checkpoint changed concurrently (its revision advanced via a resolve/reopen cycle since this resume validated) — not executed; re-resume against the current state");
-            }
-            this.parentConstraintRegistry.delete(token);
-            throw new CheckpointError("checkpoint.already_resolved", "checkpoint already resolved or expired — not re-executed (idempotent)");
-        }
+        return await resumeAdmission({
+            token,
+            outcome,
+            taskConfig,
+            internals,
+            runner: this.depsSeat,
+            parentConstraintRegistry: this.parentConstraintRegistry,
+            next: (admitted) => this.resumeLadder(token, outcome, admitted),
+        });
+    }
+    async resumeLadder(token, outcome, admitted) {
+        const { config, internals, store, cp, outcomeGate, resumeSignal, wakeMessage } = admitted;
+        const { plainReviewOutcome, plainParkOutcome } = resumeReviewOutcome({ cp, outcome, outcomeGate, wakeMessage });
+        const { plainPolicyOutcome: capturedPolicyOutcome, redeemedAnswer } = resumePolicyOutcome({ cp, outcome, config, runner: this.depsSeat });
+        const { resumeInternals } = resumeCheckpointScreen({ cp, resumeSignal, internals, runner: this.depsSeat });
+        const { recheckGovernanceWindow, windowEntrance } = resumeInternalsAndConfig({ cp, config, internals, outcomeGate, runner: this.depsSeat });
+        if (windowEntrance !== undefined)
+            await windowEntrance;
+        return await resumeApply({
+            cp, config, internals, outcomeGate, wakeMessage, resumeSignal, recheckGovernanceWindow,
+            plainPolicyOutcome: capturedPolicyOutcome, plainReviewOutcome, plainParkOutcome,
+            runner: this.depsSeat, effectiveDelegationFacts,
+            next: ({ wakeHookContext, plainPolicyOutcome, outcomeForStore }) => resumePreflight({
+                token, cp, resumeSignal, recheckGovernanceWindow, store, runner: this.depsSeat,
+                locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry, suspendedEnvReaps: this.suspendedEnvReaps,
+                next: () => resumeClaim({
+                    token, cp, store, outcomeForStore,
+                    locallyClaimedTokens: this.locallyClaimedTokens, parentConstraintRegistry: this.parentConstraintRegistry,
+                    next: () => this.resumeHandoff({ token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, resumeSignal }),
+                }),
+            }),
+        });
+    }
+    async resumeHandoff(claimed) {
+        const { token, cp, store, config, internals, resumeInternals, plainPolicyOutcome, redeemedAnswer, outcomeForStore, wakeMessage, wakeHookContext, resumeSignal } = claimed;
         let consumeFlipDone = false;
         if (internals?.afterCheckpointResolve !== undefined) {
             await internals.afterCheckpointResolve();
@@ -4798,6 +3121,12 @@ export class Runner {
             e.code = "resume.tool_unavailable";
             throw e;
         }
+        const liveRoster = prepared.toolRosterDeltas.current;
+        if (pendingAction.kind === "tool_approval" && liveRoster !== undefined && judgeParkedToolIdentity(pendingAction, rosterEntryNamed(liveRoster, pendingAction.toolName)) === "mismatch") {
+            const e = new Error(`the approved tool "${pendingAction.toolName}" on this leg is not the tool the approval was minted against (its contract / shape / revision differ) — refusing to execute a replacement wearing the name; the checkpoint is reopened for a retry with the original tool present`);
+            e.code = "resume.tool_contract_mismatch";
+            throw e;
+        }
         const completed = new Set(pendingAction.completedCallIds);
         const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
         const names = new Map();
@@ -4826,7 +3155,7 @@ export class Runner {
                     return l !== undefined && l !== name ? { label: l } : {};
                 })();
                 emit({ type: "tool_start", toolCallId: id, toolName: name, ...displayLabel, args: deferredArgs.get(id) ?? {} });
-                emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark) }, true) });
+                emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark) }, true, prepared.structuredProjector) });
                 const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark), true));
                 emitCommitted(eid, "toolResult", id);
             }
@@ -4845,7 +3174,7 @@ export class Runner {
         const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
         emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
         const settleEnd = async (isError, result, gate = decidedGate) => {
-            emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, gate) });
+            emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, prepared.structuredProjector, gate) });
             const word = await resume.recordExecutionOutcome(gate);
             settleExecutionRecord(this.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
         };
@@ -4878,6 +3207,7 @@ export class Runner {
                 toolCallId: pendingAction.toolCallId,
                 budget: beltBudget,
                 ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
             }, prepared.abortController.signal));
             const beltUnsafe = rechecked.action === "deny" ||
                 (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, resolvedArgs));
@@ -4935,6 +3265,7 @@ export class Runner {
                 toolName: pendingAction.toolName,
                 args: resolvedArgs,
                 toolCallId: pendingAction.toolCallId,
+                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
                 budget: beltBudget,
                 ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
             }, prepared.abortController.signal));
@@ -4946,6 +3277,30 @@ export class Runner {
                 return;
             }
         }
+        if (prepared.persistedRuleLane !== undefined) {
+            const unreadable = { unreadable: true };
+            const read = await settleOrgVerdictWithin(Promise.resolve()
+                .then(() => prepared.persistedRuleLane.adjudicate({
+                toolName: pendingAction.toolName,
+                args: resolvedArgs,
+                toolCallId: pendingAction.toolCallId,
+                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
+                budget: beltBudget,
+                ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+            }))
+                .then((answer) => normalizePersistedRuleHit(answer)), unreadable, { signal: prepared.abortController.signal, timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS });
+            const tightened = applyPersistedTightening({ action: "allow" }, read);
+            if (tightened.tightened === "deny" || tightened.tightened === "unreadable") {
+                const why = tightened.tightened === "deny"
+                    ? `a standing deny rule of yours (${disclosedRuleSet(read.hit?.rules ?? [])}) now refuses it`
+                    : "your persisted permission rules could not be read on this leg";
+                const ruleDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${why}. This approval is spent — the call has to be re-issued and approved again.`, prepared.reminderMark);
+                await settleEnd(true, { content: ruleDenial }, vetoed("persisted_rule"));
+                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, ruleDenial, true));
+                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+                return;
+            }
+        }
         const tool = prepared.tools.find((t) => t.name === pendingAction.toolName);
         if (!tool) {
             const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume`);