@sema-agent/core 7.5.1 → 7.5.2

package/dist/core/runner/prepare-task.js

@@ -1,55 +1,40 @@
-import { createHash, randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { resolve as resolveFsPath } from "node:path";
-import { AgentHarness, DEFAULT_CHARS_PER_TOKEN, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, estimateContextTokens, summaryOutputBudgetTokens } from "../../internal/harness.js";
-const PROMPT_HASH_SALT = randomBytes(16);
+import { AgentHarness, DEFAULT_CLAMP_TOLERANCE, DEFAULT_COMPACTION_SETTINGS, summaryOutputBudgetTokens } from "../../internal/harness.js";
 import { sanitizeCompactionSettings } from "../auto-compaction.js";
 import { projectStaleToolResults, resolveStaleToolResultOffload } from "./compaction-call-options.js";
-import { gateAskCarry, inheritedAskCarry, headlessDenyAtFold, headlessDenyAtRecheck, judgeInheritedClassifier, settleDenialLimitFallback } from "./denial-limit-arms.js";
-import { primaryActivityArg } from "../arg-summary.js";
-import { Value } from "typebox/value";
 import { uuidv7 } from "../../engine/session/uuid.js";
 import { brainToRuntime } from "../runtime.js";
 import { hasSessionFork } from "../session.js";
 import { SEND_MESSAGE_TOOL_NAME } from "../../agents/send-message-tool.js";
-import { askApproverIdentity, isLiveApproverSeat, carriesBidiControls, checkToolPolicyProjection, combinePolicies, constraintChainDigest, constraintChainEntryOfLayer, isApprovalSettledBy, isAskDenyResolution, screenApproverAttribution, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, describeThrown, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets, tryCloneArgs } from "../tool-policy.js";
-import { suggestRulesForCommand } from "../permission-rule-model.js";
-import { PERSISTED_RULE_TOOL, inheritedAskRuleEvidence, createPermissionRuleLanes } from "./prepare-permission-rules.js";
-import { createActiveSkillScopePolicy } from "./active-skill-scope.js";
-import { CHANGED_FILES_MTIME_EPS_MS } from "./turn-attachments.js";
-import { inlineUntrusted } from "../untrusted-text.js";
-import { loadAnnounceOnceLedger, serializeAnnouncedListings } from "./prepare-announce-once.js";
-import { isValidReminderMark, mintReminderMark, reminderMarkDeclaration } from "../reminder-mint.js";
-import { policyAskClassOf } from "../ask-class.js";
+import { loadAnnounceOnceLedger } from "./announce-once-ledger.js";
+import { isValidReminderMark, mintReminderMark } from "../reminder-mint.js";
 import { emitTrace } from "../trace.js";
-import { createSessionRulePolicy, PATH_CONFINABLE_WRITE_TOOLS } from "./session-rule-policy.js";
-import { askCarryRowMembers, cloneObserverInput, formatHookFeedback, persistedRuleMandateOf, resolveHookTimeoutMs, runHookSeat, hookSeatExpiredError, runToolGate } from "../hooks.js";
-import { createWriteProtectionCheck } from "../write-protect.js";
-import { CacheBreakDetector, toolsToFingerprintInputs } from "../cache-break-detector.js";
 import { reservedCollisions, reservedFor } from "../../brain/request-params.js";
 import { STALL_CONNECT_MS, STALL_FIRST_TOKEN_MS, STALL_IDLE_MS, withBrainCallGuardrail } from "../../brain/timeout.js";
-import { RETIRED_TOOL_NAMES } from "../tool-name-aliases.js";
-import { protocolOf } from "../protocol-table.js";
-import { isNamespacedCoveringRuleName, namespacedRuleNameCovers } from "../permission-rules.js";
-import { createOffloadPersist, InMemoryToolResultStore, ScopedToolResultStore, isVolatileOffloadStore, OFFLOAD_TOOL_NAME, } from "../tool-result-store.js";
+import { OFFLOAD_TOOL_NAME } from "../tool-result-store.js";
 import { OUTPUT_TOOL_NAME, createOutputTool } from "./synthetic-tools.js";
 import { compileOutputSchema } from "./strict-output-schema.js";
 import { MEMORY_ENGINE_TOOL_NAMES } from "../memory-engine/tools.js";
-import { classifyToolContentOrigin, contentOriginPollutes, delegationCallIsExternal } from "../memory-engine/content-origin.js";
-import { narrowContentSafety, readCardAttestation } from "../memory-engine/delegation-provenance.js";
-import { recordSyncUnattestable, sessionSettlements } from "../memory-engine/delegation-settlement.js";
-import { complianceCallDenial } from "../compliance.js";
 import { foldAdmissionFreeze } from "../memory-admission.js";
 import { prepareMemory } from "./prepare-memory.js";
+import { prepareMemoryEngineSession } from "./prepare-memory-engine-session.js";
 import { prepareDeferClassify } from "./prepare-defer-classify.js";
 import { prepareListings } from "./prepare-listings.js";
 import { preparePromptInputs } from "./prepare-prompt-inputs.js";
-import { hasConversationContent, prepareProjectContext } from "./prepare-project-context.js";
+import { prepareProjectContext } from "./prepare-project-context.js";
+import { preparePolicyChain } from "./prepare-policy-chain.js";
+import { prepareContextLane } from "./prepare-context-lane.js";
+import { prepareTurnWiring } from "./prepare-turn-wiring.js";
+export { runGuardChain } from "./prepare-context-lane.js";
+import { preparePromptAssembly } from "./prepare-prompt-assembly.js";
 import { limitConfigError, prepareConfigDoors } from "./prepare-config-doors.js";
-import { NAMESPACED_NAME_SHAPES, prepareSafetyScan } from "./prepare-safety-scan.js";
+import { prepareSafetyScan } from "./prepare-safety-scan.js";
 import { prepareAcquireReconcile } from "./prepare-acquire-reconcile.js";
 import { prepareHandsMount, resolveHandsLessReadFace } from "./prepare-hands-readface.js";
-import { prepareWorkspaceRestore, remoteEnvFailureNote, restoreWorkspaceWithRetry } from "./prepare-workspace-restore.js";
+import { prepareWorkspaceRestore } from "./prepare-workspace-restore.js";
+import { parkContaminationMarker } from "./park-commit.js";
+export { gatedCallIdOf, USAGE_WINDOW_REAP_MARGIN_MS } from "./park-commit.js";
 import { prepareOffloadWrappers } from "./prepare-offload-wrappers.js";
 import { prepareFileHistory } from "./prepare-file-history.js";
 import { prepareExecutionEnv } from "./prepare-execution-env.js";
@@ -59,42 +44,31 @@ import { prepareCapsAndWorkflow } from "./prepare-caps-and-workflow.js";
 import { prepareDelegationSurface } from "./prepare-delegation-surface.js";
 import { prepareToolDisclosureMount } from "./prepare-tool-disclosure-mount.js";
 import { prepareWiringManifest } from "./prepare-wiring-manifest.js";
-import { checkpointScopeOf } from "./checkpoint-scope.js";
-export { DEFAULT_IRREVERSIBLE_SCOPE, checkpointScopeOf } from "./checkpoint-scope.js";
+import { prepareAskLane } from "./prepare-ask-lane.js";
+import { prepareSuspendSaga } from "./prepare-suspend-saga.js";
+import { prepareBoundaryParks } from "./prepare-boundary-parks.js";
+import { prepareParkAsk } from "./prepare-park-ask.js";
+import { prepareGateStations } from "./prepare-gate-stations.js";
+export { batchContextAt } from "./prepare-park-ask.js";
+export { compensateUnparkedPause } from "./prepare-suspend-saga.js";
+import { placementValueOrAbsent } from "./checkpoint-scope.js";
+export { DEFAULT_IRREVERSIBLE_SCOPE, checkpointScopeOf, placementValueOrAbsent } from "./checkpoint-scope.js";
 export { mcpManifestEntries } from "./prepare-wiring-manifest.js";
 import { derivedRouteFallsBack } from "./derived-route-fallback.js";
 import { prepareProtocolTools } from "./prepare-protocol-tools.js";
-import { CONTENT_ASK_BINDING_CAP, prepareQuestionFace } from "./prepare-question-face.js";
+import { prepareQuestionFace } from "./prepare-question-face.js";
 import { prepareLsp } from "./prepare-lsp.js";
 import { createRollbackStack } from "./rollback-stack.js";
 export { __resetMaterializeEnvAnnouncements } from "./prepare-tool-disclosure-mount.js";
 export { fileHistoryFilesystemIdentity, resolveFileHistoryScope } from "./prepare-file-history.js";
-import { defaultPromptProvider, buildEnvironmentContext } from "../../prompts/default.js";
-import { applyGitFrameGuard } from "./git-status-frame.js";
-import { assemblePrompt } from "../../prompt-assembly/assemble.js";
-import { auditToolCollisions, projectToolManifest } from "../../prompt-assembly/tool-catalog.js";
-import { resolveEpochAgainstBundled } from "../../prompt-assembly/epoch.js";
-import { artifactDeclarations } from "../../prompt-assembly/artifact.js";
-import { buildTurnPromptSnapshot } from "../../prompt-assembly/turn-snapshot.js";
-import { SEMA_DEFAULT_PACK } from "../../prompt-assembly/packs/sema-default.js";
-import { clearStaleToolResults, createClearedProjectionLedger, dropEmptyFailureAssistants, editBudget, replayClearedProjection, resolveTriggerWindow, } from "../context-edit.js";
-import { capAggregateToolResults } from "../tool-result-budget.js";
-import { capAggregateMediaBytes, AGGREGATE_MEDIA_BUDGET_BYTES } from "../media-byte-cap.js";
-import { dropOrphanToolResults, guardBudget, insertTrimNotice, trimToBudget } from "../context-guard.js";
-import { isIsolated, isRemoteExecutionEnv, isSuspendable, RemoteExecutionError } from "../remote-env.js";
+import { resolveTriggerWindow, } from "../context-edit.js";
+import { isRemoteExecutionEnv } from "../remote-env.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
-import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { announcePeerLaneMount } from "../../agents/peer-session-drain.js";
-import { applyCompactionToReadFileState, isReadDedupStubResult } from "../../tools/fs/index.js";
-import { decodeTextBytes } from "../../tools/fs/encoding.js";
-import { ASK_USER_QUESTION_TOOL_NAME, classifyQuestionOutcome, validateAskQuestions, } from "../ask-question.js";
 import { createSchedulerTools } from "../../tools/scheduler-tools.js";
-import { PRESENT_PLAN_TOOL_NAME } from "../present-plan-tool.js";
 import { selfOrchestrationFailClosedReason } from "../../orchestration/workflow-script-runner.js";
-import { fileArgPath, resolveKey } from "../../tools/fs/safety.js";
-import { BINDING_CHECKPOINT_VERSION, mintCheckpointId, mintCheckpointToken, ORG_ADMISSION_CHECKPOINT_VERSION, F012_CHECKPOINT_VERSION, FACE_CHECKPOINT_VERSION, REAL_APPROVAL_CHECKPOINT_VERSION, RESOURCE_CHECKPOINT_VERSION, TOKEN_CHECKPOINT_VERSION, buildRiskDescriptor, debitLedger, encodeAtFidelity, remainingBudgetMicroUsd, resolveCheckpointStore, resolveDeclaredFidelity, samePlainValue, } from "../checkpoint-store.js";
-import { boundInputHashOf } from "../canonical-json.js";
+import { remainingBudgetMicroUsd } from "../checkpoint-store.js";
 import { durableParkGapFor } from "../park-selfcheck.js";
 import { deliverEngineNotice } from "../types.js";
 function warnCompactionWindowHazard(tracer, spec, model, compModel, hostTaskId) {
@@ -186,39 +160,9 @@ function toolModelGateManifest(gate) {
     }
     return firstClass === undefined ? undefined : { class: firstClass, removed, restore: TOOL_MODEL_GATE_RESTORE_SENTENCE };
 }
-function announceDeclaredMcpContentClasses(args) {
-    for (const entry of args.entries ?? []) {
-        const declaredClass = entry.contentOrigin;
-        if (declaredClass === undefined)
-            continue;
-        const server = inlineUntrusted(String(entry.name), 160);
-        const toolCount = args.statuses?.find((s) => s.name === entry.name)?.toolNames?.length ?? 0;
-        const resourceFaceCaveat = " (Not covered: the cross-server resource faces — ListMcpResourcesTool/ReadMcpResourceTool/ReadMcpResourceDirTool — stay externally classified and still mark.)";
-        const posture = declaredClass === "local"
-            ? `this server's mounted tools' invocations will not mark this session's memory as externally exposed.${resourceFaceCaveat}`
-            : declaredClass === "execution"
-                ? `this server's mounted tools' invocations will not mark this session's memory unless the execIsExternalContent strict upgrade is armed (currently: ${args.execIsExternalContent ? "armed" : "off"}).${resourceFaceCaveat}`
-                : "its tools stay externally classified and this declaration PINS that — the trustedTools allowlist no longer exempts them, and invocations mark this session's memory.";
-        deliverEngineNotice(args.onNotice, {
-            code: "memory.content_class_declared",
-            message: `MCP server "${server}" (${toolCount} tool(s) mounted) is declared ` +
-                `contentOrigin "${declaredClass}" by this deployment's configuration — ${posture}`,
-            detail: {
-                server,
-                contentOrigin: declaredClass,
-                toolCount,
-                ...(declaredClass === "execution" ? { execIsExternalContent: args.execIsExternalContent } : {}),
-                sessionId: args.sessionId,
-                runId: args.runId,
-            },
-        });
-    }
-}
 export { __resetReadFaceClampAnnouncement } from "./prepare-hands-readface.js";
 const DEFAULT_MAX_SUSPENDS = 5;
-const DEFAULT_RESOURCE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 export const ENV_LIFETIME_SUSPEND_MARGIN_MS = 60_000;
-export const USAGE_WINDOW_REAP_MARGIN_MS = 60 * 60 * 1000;
 export function resolveEnvLifetimeExpiry(env, observedAt) {
     const lifetimeMs = env.lifetimeMs;
     if (lifetimeMs === undefined)
@@ -235,343 +179,13 @@ export function resolveEnvLifetimeExpiry(env, observedAt) {
         return { unanchored: true };
     return { expiresAt: anchor + lifetimeMs };
 }
-const DEFAULT_UNATTENDED_APPROVAL_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-function sanitizedTtlMs(ttlMs) {
-    if (ttlMs === undefined)
-        return undefined;
-    return Number.isFinite(ttlMs) && ttlMs > 0 ? ttlMs : DEFAULT_RESOURCE_TTL_MS;
-}
-const advisedPolicyNames = new WeakMap();
-const ADVISED_KEYS_CAP = 64;
-class ParkRefusal extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ParkRefusal";
-    }
-}
 export { resolveCheckpointStore } from "../checkpoint-store.js";
 export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./workspace-path.js";
-function buildMicroCompactState(deps, model, sessionId, runId, offloadStore, knob) {
-    const triggerWindow = resolveTriggerWindow(model);
-    if (triggerWindow.clamped) {
-        deliverEngineNotice(deps.onNotice, {
-            code: "config.autocompact_window_clamped",
-            message: `model "${model.id}" declares autoCompactTokens=${triggerWindow.declaredAutoCompactTokens} ABOVE its physical window ` +
-                `${triggerWindow.physicalWindow}; the autocompact window only ever LOWERS the trigger-side geometry, so the value was ` +
-                `clamped to the physical window — fix the model config (declare a value at or below the physical window, or omit it)`,
-            detail: {
-                modelId: model.id,
-                declaredAutoCompactTokens: triggerWindow.declaredAutoCompactTokens,
-                physicalWindow: triggerWindow.physicalWindow,
-                sessionId,
-                runId,
-            },
-        });
-    }
-    return {
-        machine: knob.machine,
-        clearOnRejection: knob.clearOnRejection,
-        ledger: createClearedProjectionLedger(),
-        projectionRef: {},
-        inTurnCompactionRef: {},
-        ...(offloadStore ? { offloadPersist: createOffloadPersist(offloadStore, sessionId, deps.onNotice) } : {}),
-    };
-}
-function recordFrontierClears(args) {
-    for (const { index } of args.pass.clears) {
-        const at = args.index.keyAt(index);
-        const clearedMsg = args.edited[index];
-        const markerText = clearedMsg.content?.[0]?.text;
-        if (at !== undefined && typeof markerText === "string") {
-            args.ledger.entries.set(at.key, { marker: markerText, groupCount: at.groupCount, fp: at.fp });
-        }
-    }
-    emitTrace(args.tracer, () => ({
-        kind: "context.mc_clear",
-        version: 1,
-        taskId: args.taskId,
-        clearedCount: args.pass.clears.length,
-        tokensSavedEstimate: args.pass.tokensSavedEstimate,
-        trigger: args.trigger,
-        ts: Date.now(),
-    }));
-}
-function flushProjectionObservations(pending) {
-    for (const fire of pending.splice(0)) {
-        try {
-            fire();
-        }
-        catch {
-        }
-    }
-}
-export async function runGuardChain(args) {
-    const { edited, microCompact, guardAt, charsPerToken, deps, taskId } = args;
-    const applyGuardTrim = (view, anchoredTotal) => {
-        let trimmed = trimToBudget(view, guardAt, anchoredTotal, charsPerToken);
-        const dropped = trimmed.length < view.length;
-        if (dropped) {
-            args.trimPressureRef.droppedMessages = true;
-            const droppedCount = view.length - trimmed.length;
-            trimmed = insertTrimNotice(trimmed);
-            emitTrace(deps.tracer, () => ({
-                kind: "context.trim",
-                version: 1,
-                taskId,
-                dropped: droppedCount,
-                ts: Date.now(),
-            }));
-        }
-        return { trimmed, dropped };
-    };
-    let working = edited;
-    let anchoredWorking = estimateContextTokens(working, charsPerToken).tokens;
-    if (microCompact.machine === "legacy") {
-        const t = applyGuardTrim(working, anchoredWorking);
-        return { working, trimmed: t.trimmed, trimDroppedMessages: t.dropped };
-    }
-    if (microCompact.machine === "off" && anchoredWorking > guardAt) {
-        let blockingPass;
-        const blockingEdited = clearStaleToolResults(working, {
-            budgetTokens: guardAt,
-            machine: "cc",
-            clearSource: args.replayed,
-            onCleared: (pass) => { blockingPass = pass; },
-            anchoredTotalTokens: anchoredWorking,
-            charsPerToken,
-            ...(args.offloadStore ? { offload: { persist: createOffloadPersist(args.offloadStore, args.sessionId, deps.onNotice) } } : {}),
-        });
-        if (blockingPass !== undefined) {
-            recordFrontierClears({ pass: blockingPass, index: args.index, edited: blockingEdited, ledger: microCompact.ledger, tracer: deps.tracer, taskId, trigger: "blocking" });
-            working = blockingEdited;
-            anchoredWorking = estimateContextTokens(working, charsPerToken).tokens;
-        }
-    }
-    if (anchoredWorking > guardAt && args.recheck !== true) {
-        const compacted = (await microCompact.inTurnCompactionRef.current?.(args.signal, anchoredWorking)) === true;
-        if (compacted) {
-            args.pendingProjectionObservations.length = 0;
-            return { earlyReturn: { messages: working, adoptSessionRebuild: true } };
-        }
-        if (args.signal?.aborted === true) {
-            args.pendingProjectionObservations.length = 0;
-            return { working, trimmed: working, trimDroppedMessages: false };
-        }
-    }
-    const t = applyGuardTrim(working, anchoredWorking);
-    return { working, trimmed: t.trimmed, trimDroppedMessages: t.dropped };
-}
-export function gatedCallIdOf(p) {
-    if (p.suspendRef.token !== undefined)
-        return p.suspendRef.gatedCallId;
-    if (p.reviewRef.token !== undefined)
-        return p.reviewRef.gatedCallId;
-    return undefined;
-}
-function parkContaminationMarker(refs) {
-    if (refs.suspendRef.token === undefined && refs.reviewRef.token === undefined)
-        return undefined;
-    const gatedCallId = gatedCallIdOf(refs);
-    return { code: "gate.parked", ...(gatedCallId !== undefined ? { gatedCallId } : {}) };
-}
-function publishCommittedSuspend(refs, token, gate, scope, remoteHandle, checkpointId, pendingAction) {
-    const ref = gate.kind === "needs_review" || gate.kind === "plan_review" ? refs.reviewRef : refs.suspendRef;
-    ref.token = token;
-    if (checkpointId !== undefined)
-        ref.checkpointId = checkpointId;
-    ref.gate = gate;
-    ref.gatedCallId = pendingAction?.kind === "tool_approval" ? pendingAction.toolCallId : undefined;
-    if (remoteHandle !== undefined)
-        ref.restoreMode = remoteHandle.restoreMode === "park_only" ? "park_only" : "snapshot";
-    ref.scope = scope;
-}
 export function effectiveDelegationFacts(internals, seedIsDelegatedChild) {
     const isDelegatedChild = internals?.isDelegatedChild !== undefined ? internals.isDelegatedChild === true : seedIsDelegatedChild === true;
     return { isDelegatedChild, isNonForkChild: isDelegatedChild && internals?.insideFork !== true };
 }
-export function batchContextAt(messages, currentId) {
-    let batch = [];
-    for (const m of messages) {
-        if (m.role === "assistant") {
-            const ids = [...new Set(m.content.filter((c) => c.type === "toolCall").map((c) => c.id))];
-            if (ids.includes(currentId))
-                batch = ids;
-        }
-    }
-    const resolved = new Set(messages.filter((m) => m.role === "toolResult").map((m) => m.toolCallId));
-    const completedCallIds = batch.filter((id) => id !== currentId && resolved.has(id));
-    return { batchToolCallIds: batch, completedCallIds };
-}
-function composeCallSignal(runSignal, callSignal) {
-    return callSignal !== undefined ? AbortSignal.any([runSignal, callSignal]) : runSignal;
-}
-function lateAskSettlementObserver(args) {
-    return (late) => {
-        if (late.kind === "approve") {
-            deliverEngineNotice(args.onNotice, {
-                code: "task.late_approval",
-                message: `an approval for "${args.toolName}" was not consumed: a run or turn interrupt released the ask wait, ` +
-                    `so the tool did NOT run and the approval was not honored (an unconsumed answer is the approver ` +
-                    `releasing its wait, never a verdict).`,
-                detail: {
-                    toolName: args.toolName,
-                    toolCallId: args.toolCallId,
-                    sessionId: args.sessionId,
-                    runId: args.runId,
-                    ...(args.taskId !== undefined ? { taskId: args.taskId } : {}),
-                },
-            });
-            return;
-        }
-        args.onError?.(late.error, { phase: "hook", sessionId: args.sessionId });
-    };
-}
-function askGrantShapeOf(args) {
-    try {
-        return JSON.stringify(args ?? null);
-    }
-    catch {
-        return undefined;
-    }
-}
-function consumeInheritedAskGrant(grants, onAsk, humanReviewRef, decision, req) {
-    if (decision.decisionReason !== undefined && decision.decisionReason !== "rule")
-        return undefined;
-    const grant = grants.get(req.toolCallId);
-    if (grant === undefined || askApproverIdentity(grant.approver) !== askApproverIdentity(onAsk) || grant.argsJson !== askGrantShapeOf(req.args))
-        return undefined;
-    grants.delete(req.toolCallId);
-    humanReviewRef.count += 1;
-    humanReviewRef.totalWaitMs += grant.waitMs;
-    const toolArg = primaryActivityArg(req.args);
-    humanReviewRef.gates.push({
-        kind: "human",
-        waitMs: grant.waitMs,
-        decision: "allow",
-        toolName: req.toolName,
-        ...(toolArg !== undefined ? { toolArg } : {}),
-    });
-    return { action: "allow", presentedInput: grant.presented };
-}
-function raceSettlementAgainstSignal(p, signal) {
-    const settled = p.then((value) => ({ tag: "value", value }), (error) => ({ tag: "threw", error }));
-    if (signal.aborted)
-        return Promise.resolve({ tag: "aborted" });
-    return new Promise((resolve) => {
-        let done = false;
-        const finish = (r) => {
-            if (done)
-                return;
-            done = true;
-            signal.removeEventListener("abort", onAbortEvent);
-            resolve(r);
-        };
-        const onAbortEvent = () => finish({ tag: "aborted" });
-        signal.addEventListener("abort", onAbortEvent, { once: true });
-        void settled.then(finish);
-    });
-}
-const PARK_COMPENSATION_TIMEOUT_MS = 30_000;
-export async function compensateUnparkedPause(remoteEnv, snapshotId, io) {
-    const boundCtl = new AbortController();
-    const boundTimer = setTimeout(() => boundCtl.abort(), io.boundMs);
-    const bound = boundCtl.signal;
-    let phase = "resumeVM";
-    let restoreAttempts = 1;
-    let vmRunning = false;
-    const work = (async () => {
-        const { outcome: back, attempts: backAttempts } = await restoreWorkspaceWithRetry(remoteEnv, snapshotId, { abortSignal: bound }, (attempt) => (restoreAttempts = attempt));
-        if (!back.ok) {
-            io.noteFailure(remoteEnvFailureNote("resumeVM", back.error, backAttempts));
-            io.disclose(back.error);
-            return { ok: false, reason: `resumeVM failed (${back.error.code}) while compensating an unparked pause` };
-        }
-        vmRunning = true;
-        if (bound.aborted) {
-            return { ok: false, reason: "resumeVM settled only after the decision bound" };
-        }
-        phase = "postResumeInit";
-        const init = await remoteEnv.postResumeInit({ abortSignal: bound });
-        if (!init.ok) {
-            io.noteFailure(remoteEnvFailureNote("postResumeInit", init.error, 1));
-            io.disclose(init.error);
-            return { ok: false, reason: `postResumeInit failed (${init.error.code}) while compensating an unparked pause` };
-        }
-        return { ok: true };
-    })();
-    const raced = await raceSettlementAgainstSignal(work, bound);
-    clearTimeout(boundTimer);
-    if (raced.tag === "value")
-        return raced.value;
-    if (raced.tag === "threw") {
-        io.noteFailure(remoteEnvFailureNote(phase, raced.error instanceof RemoteExecutionError
-            ? raced.error
-            : new RemoteExecutionError("unknown", `the pause compensation's ${phase} call threw: ${raced.error instanceof Error ? raced.error.message : String(raced.error)}`), phase === "resumeVM" ? restoreAttempts : 1));
-        io.disclose(raced.error);
-        return {
-            ok: false,
-            reason: "the pause compensation threw (adapter contract violation; the deployment's error face carries the exception)",
-        };
-    }
-    const timedOut = new RemoteExecutionError("timeout", `the pause compensation's ${phase} call did not settle within the ${io.boundMs}ms decision bound`);
-    io.noteFailure(remoteEnvFailureNote(phase, timedOut, phase === "resumeVM" ? restoreAttempts : 1));
-    io.disclose(timedOut);
-    const destroyOwnerlessLate = () => {
-        io.disclose(new Error(`park compensation settled after its ${io.boundMs}ms decision bound: the VM is running with no run ` +
-            `left to own it — destroying the env (an ownerless running VM must not linger; the run already took ` +
-            `the fail-closed arm when the bound fired)`));
-        void Promise.resolve()
-            .then(() => remoteEnv.destroy())
-            .catch((destroyErr) => io.disclose(destroyErr));
-    };
-    void work.then((late) => {
-        if (vmRunning) {
-            destroyOwnerlessLate();
-            return;
-        }
-        void late;
-    }, (lateErr) => {
-        io.disclose(lateErr);
-        if (vmRunning)
-            destroyOwnerlessLate();
-    });
-    return {
-        ok: false,
-        reason: `the pause compensation did not settle within ${io.boundMs}ms — treated as failed (a late-restored VM is destroyed; a late restore failure is disclosed)`,
-    };
-}
-function raceAbort(p, signal, onAbort) {
-    if (signal.aborted)
-        return Promise.resolve(onAbort());
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (v) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener("abort", onAbortEvent);
-            resolve(v);
-        };
-        const onAbortEvent = () => finish(onAbort());
-        signal.addEventListener("abort", onAbortEvent, { once: true });
-        p.then(finish, () => finish(onAbort()));
-    });
-}
-function createDenyObserverNotifier(hooks, hookTimeoutMs, signal, report) {
-    if (hooks?.permissionDenied === undefined)
-        return undefined;
-    return async (payload) => {
-        try {
-            const seat = await runHookSeat("permissionDenied", { timeoutMs: hookTimeoutMs, signal }, (sig) => hooks.permissionDenied({ ...payload, signal: sig }));
-            if (seat.expired)
-                report(hookSeatExpiredError("permissionDenied", hookTimeoutMs, seat.cause, "the deny observation was abandoned; the deny itself is unchanged"));
-        }
-        catch (err) {
-            report(err);
-        }
-    };
-}
 async function forgetQuietly(sessions, sessionId) {
     try {
         if (sessions.forget)
@@ -580,144 +194,6 @@ async function forgetQuietly(sessions, sessionId) {
     catch {
     }
 }
-function screenGateSettlement(result, settling) {
-    const defects = [];
-    const reportedBy = result.settledBy;
-    let settledBy;
-    if (reportedBy !== undefined) {
-        if (!isApprovalSettledBy(reportedBy) || (!settling && reportedBy !== "human")) {
-            defects.push(`a tool-gate settlement reported settledBy "${String(reportedBy)}" on ${settling ? "a blocked" : "an executing"} call — ` +
-                `it is one of "human" / "timeout" / "aborted", and only "human" can be the source of a call that runs; the frame carries no source`);
-        }
-        else
-            settledBy = reportedBy;
-    }
-    const attribution = screenApproverAttribution(result.approver);
-    if (attribution.defect !== undefined) {
-        defects.push(`a tool-gate settlement reported an attribution this engine refuses: ${attribution.defect}; the frame carries no approver`);
-    }
-    const reportedResolution = result.resolution;
-    let resolution;
-    if (reportedResolution !== undefined) {
-        if (!isAskDenyResolution(reportedResolution) || !settling) {
-            defects.push(`a tool-gate settlement reported a deny resolution "${String(reportedResolution)}" on ${settling ? "a blocked" : "an executing"} call — ` +
-                `it is one of the closed ask-deny vocabulary and only a BLOCKED call can carry one; the frame carries no resolution`);
-        }
-        else
-            resolution = reportedResolution;
-    }
-    const reportedAutoDenied = result.autoDenied;
-    let autoDenied;
-    if (reportedAutoDenied === true) {
-        if (!settling)
-            defects.push("a tool-gate settlement reported autoDenied on an executing call — only a BLOCKED call can carry the marker; the frame carries none");
-        else
-            autoDenied = true;
-    }
-    const record = {
-        ...(settledBy !== undefined ? { settledBy } : {}),
-        ...(attribution.approver !== undefined ? { approver: attribution.approver } : {}),
-        ...(resolution !== undefined ? { resolution } : {}),
-        ...(autoDenied !== undefined ? { autoDenied } : {}),
-    };
-    return { ...(settledBy !== undefined || attribution.approver !== undefined || resolution !== undefined || autoDenied !== undefined ? { record } : {}), defects };
-}
-function maybeHumanRejectionHalt(input) {
-    if (!input.bare || input.settledBy !== "human" || input.isDelegatedChild)
-        return undefined;
-    return {
-        reason: `This tool call was NOT executed: the user rejected the "${input.toolName}" tool call in the same ` +
-            `assistant message, which stops the rest of the batch. Nothing was run for this call — ` +
-            `re-issue it after the user's direction only if it is still needed.`,
-        details: {
-            error: "gate.batch_halted",
-            code: "gate.batch_halted",
-            rejectedToolCallId: input.toolCallId,
-            rejectedToolName: input.toolName,
-        },
-    };
-}
-const sanitizePreview = (node, depth = 0) => {
-    if (depth > 6)
-        return undefined;
-    if (typeof node === "string") {
-        return node.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "\u2400");
-    }
-    if (node === null || typeof node !== "object")
-        return node;
-    if (Array.isArray(node))
-        return node.map((v) => sanitizePreview(v, depth + 1));
-    const out = {};
-    for (const [k, v] of Object.entries(node)) {
-        out[sanitizePreview(k, depth + 1)] = sanitizePreview(v, depth + 1);
-    }
-    return out;
-};
-function resolveApprovalPreview(tools, toolName, args) {
-    const t = tools.find((x) => x.name === toolName || (x.aliases?.includes(toolName) ?? false));
-    if (t?.approvalPreview === undefined)
-        return {};
-    try {
-        const raw = t.approvalPreview(args);
-        if (raw === undefined)
-            return {};
-        const bytes = JSON.stringify(raw);
-        if (bytes === undefined)
-            return { withheld: "unavailable" };
-        if (bytes.length > 16_384) {
-            return { preview: { truncated: true, note: `approval preview exceeded 16KiB (${bytes.length} chars serialized)` }, withheld: "oversize" };
-        }
-        return { preview: sanitizePreview(raw) };
-    }
-    catch {
-        return { withheld: "unavailable" };
-    }
-}
-function makeRuleOffersOf(cfg) {
-    return (toolName, args, ask) => {
-        if (!cfg.laneArmed || toolName !== PERSISTED_RULE_TOOL)
-            return {};
-        if ((cfg.principal === undefined || cfg.principal === "") && !cfg.localOwnerDeclared)
-            return {};
-        const closedDoor = (() => {
-            if (ask?.requiresRealApproval === true)
-                return "mandated";
-            if (ask?.persistedRuleShadowed !== undefined)
-                return "shadowed";
-            if (ask?.decisionReason === "hook")
-                return "mandated";
-            if (ask?.matchedAskRule !== undefined)
-                return "shadowed";
-            if (ask?.inheritedUnresolved === true)
-                return "mandated";
-            if (ask?.ancestorResolved === true)
-                return "mandated";
-            return undefined;
-        })();
-        if (closedDoor !== undefined)
-            return { ruleOffersAbsence: closedDoor };
-        if (persistedRuleMandateOf({
-            egress: cfg.egressTools.has(toolName),
-            irreversibility: cfg.irreversibilityTier.get(toolName),
-            shellGated: cfg.shellGatedBash,
-            probeMandated: ask?.probeMandated === true,
-        }) !== undefined) {
-            return { ruleOffersAbsence: "mandated" };
-        }
-        const command = args?.command;
-        if (typeof command !== "string")
-            return { ruleOffersAbsence: "lane_cannot_speak" };
-        const offers = suggestRulesForCommand(command, {
-            ...(ask?.segmentCoverage !== undefined ? { coverage: ask.segmentCoverage } : {}),
-            ...(cfg.taskRoot !== undefined ? { scope: { kind: "project", root: cfg.taskRoot }, cwd: cfg.taskRoot } : {}),
-            ...(cfg.cwdRef?.current !== undefined ? { execCwd: cfg.cwdRef.current } : {}),
-            ...(cfg.deniesDirectoryRead !== undefined ? { deniesDirectoryRead: cfg.deniesDirectoryRead } : {}),
-        });
-        return offers.length > 0
-            ? { ruleOffers: offers, ...(cfg.cwdRef?.current !== undefined ? { execCwd: cfg.cwdRef.current } : {}) }
-            : { ruleOffersAbsence: "lane_cannot_speak" };
-    };
-}
 async function adoptReminderMark(session, sessionId, seedMark, spawnMark, onError) {
     const sessionReminderMark = await (async () => {
         try {
@@ -753,12 +229,6 @@ function restorePlacementRoot(internals, seedPlacementRoot) {
         return internals;
     return { ...(internals ?? {}), placementRoot: seed };
 }
-export function placementValueOrAbsent(value) {
-    return value || undefined;
-}
-function stampPlacementRootSessionId(placementRootResolved) {
-    return placementValueOrAbsent(placementRootResolved);
-}
 function refuseRequireExistingWithoutSession(spec) {
     if (spec.requireExistingSession && !spec.sessionId) {
         const e = new Error(`requireExistingSession requires a sessionId — cannot require an existing session without one (design/114 Phase3)`);
@@ -766,14 +236,6 @@ function refuseRequireExistingWithoutSession(spec) {
         throw e;
     }
 }
-function autoModeLatchHealthy(d) {
-    try {
-        return d.breakerOpen() !== true && typeof d.consecutiveFailures === "function" && d.consecutiveFailures() === 0;
-    }
-    catch {
-        return false;
-    }
-}
 function validateInputFaultNotice(onError, sessionId) {
     return ({ toolName, toolCallId, error }) => onError?.(new Error(`tool input pre-validation (validateInput) threw for ${toolName} (call ${toolCallId}) — read as no verdict; the call proceeded to the gate: ${error instanceof Error ? error.message : String(error)}`), { phase: "hook", sessionId });
 }
@@ -900,8 +362,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         let resolvedReadFace;
         let readDenyAdditionsNormalized = [];
         let handsLessResolvedFace;
-        const { liveInheritedGate, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, inheritedParentConstraints, autoModeIntent, inheritedAdmittedOrgScopes, priorOwnOrgVerdict, orgGovernedProvenance, effectiveShellGate, ownSessionRulesRef, memoryAdmittedOrgScopesRef, ownOrgVerdictRef, orgAdmissionCheckpointState, faceCheckpointSection, faceCheckpointState, f012CheckpointState, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, frozenOnQuestion, provenanceForChildrenRef, delegationSettlementRef, inheritedGateForChildren, carrierReadFace, fullShellReachable, gateStopRef, stopForDenialLimit, enrichSpecToolCtx } = prepareInheritedGate({ spec, deps, internals, resume, sessions, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, ownedEnv, lockedPreflight, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, autoModeSeat, handsEnabled, reportUsage, harnessRef, skillScope, forwardEvent, subagentRetain, worktreeIsolation, requestReview, requestStopAfterTurn, enterPlanMode, reminderMark, reminderDisclosureCounts, fileHistoryEnabled, historyScope, historyRoot, historyFs, abortRun: () => { abortController.abort(); void harness.abort(); }, runtimeCaps: () => runtimeCaps, hooks: () => hooks, preToolUseObservational: () => preToolUseObservational, hookTimeoutMs: () => hookTimeoutMs, hookEnvFace: () => hookEnvFace, autoModeDecider: () => autoModeDecider, autoModeDenialTracking: () => autoModeDenialTracking, autoModeArming: () => autoModeArming, agentForkDenial: () => agentForkDenial, observersActive: () => observersActive, resolvedReadFace: () => resolvedReadFace, readDenyAdditionsNormalized: () => readDenyAdditionsNormalized, handsLessResolvedFace: () => handsLessResolvedFace, centerAdoption: () => centerAdoption, memoryEngineSession: () => memoryEngineSession });
-        const { tools, blockedRef, runtimeCaps, runtimeCapsFaulted, complianceDenies, complianceDegraded, agentForkDenial, observersActive, autoModeArmReason, autoModeDecider, autoModeDenialTracking, autoModeArming, selfOrchestrationActive, workflowToolsActive, workflowSizeGuideline } = await prepareCapsAndWorkflow({ spec, deps, internals, session, sessionId, runId, hostTaskId, taskScope, taskRootFinal, model, thinking, lockedPreflight, toolEffects, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, harnessRef, frozenOnAsk, carrierReadFace, forwardEvent, inheritedGateForChildren, enrichSpecToolCtx, maybeOffload, requestReview, enterPlanMode, autoModeIntent, peerLaneActive, peerSendMessageBuiltIn, runnerSelf, memoryEngineSession: () => memoryEngineSession, centerAdoption: () => centerAdoption, readDenyAdditionsNormalized: () => readDenyAdditionsNormalized });
+        const { liveInheritedGate, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, inheritedParentConstraints, autoModeIntent, inheritedAdmittedOrgScopes, priorOwnOrgVerdict, orgGovernedProvenance, effectiveShellGate, ownSessionRulesRef, memoryAdmittedOrgScopesRef, ownOrgVerdictRef, orgAdmissionCheckpointState, faceCheckpointSection, faceCheckpointState, f012CheckpointState, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, frozenOnQuestion, provenanceForChildrenRef, delegationSettlementRef, inheritedGateForChildren, carrierReadFace, fullShellReachable, gateStopRef, stopForDenialLimit, enrichSpecToolCtx } = prepareInheritedGate({ spec, deps, internals, resume, sessions, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, ownedEnv, lockedPreflight, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, autoModeSeat, handsEnabled, reportUsage, harnessRef, skillScope, forwardEvent, subagentRetain, worktreeIsolation, requestReview, requestStopAfterTurn, enterPlanMode, reminderMark, reminderDisclosureCounts, fileHistoryEnabled, historyScope, historyRoot, historyFs, abortRun: () => { abortController.abort(); void harness.abort(); }, runtimeCaps: () => runtimeCaps, hooks: () => hooks, preToolUseObservational: () => preToolUseObservational, hookTimeoutMs: () => hookTimeoutMs, hookEnvFace: () => hookEnvFace, autoModeDecider: () => autoModeDecider, autoModeDenialTracking: () => autoModeDenialTracking, autoModeArming: () => autoModeArming, agentForkDenial: () => agentForkDenial, observersActive: () => observersActive, resolvedReadFace: () => resolvedReadFace, readDenyAdditionsNormalized: () => readDenyAdditionsNormalized, handsLessResolvedFace: () => handsLessResolvedFace, centerAdoption: () => centerAdoptionRef.current, memoryEngineSession: () => memoryEngineSession });
+        const { tools, blockedRef, runtimeCaps, runtimeCapsFaulted, complianceDenies, complianceDegraded, agentForkDenial, observersActive, autoModeArmReason, autoModeDecider, autoModeDenialTracking, autoModeArming, selfOrchestrationActive, workflowToolsActive, workflowSizeGuideline } = await prepareCapsAndWorkflow({ spec, deps, internals, session, sessionId, runId, hostTaskId, taskScope, taskRootFinal, model, thinking, lockedPreflight, toolEffects, toolFaceSnapshot, promptProfile, resolvedInteractionPosture, harnessRef, frozenOnAsk, carrierReadFace, forwardEvent, inheritedGateForChildren, enrichSpecToolCtx, maybeOffload, requestReview, enterPlanMode, autoModeIntent, peerLaneActive, peerSendMessageBuiltIn, runnerSelf, memoryEngineSession: () => memoryEngineSession, centerAdoption: () => centerAdoptionRef.current, readDenyAdditionsNormalized: () => readDenyAdditionsNormalized });
         const suspendRef = {};
         const reviewRef = {};
         const remoteEnvFailures = [];
@@ -934,9 +396,6 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             resourceSpentMicroUsd: priorLedger?.spentMicroUsd ?? 0,
             suspendCount: priorSuspendCount,
         };
-        let suspendForResource;
-        let suspendForPlatformLimit;
-        let suspendForReview;
         const outputRef = {};
         if (resume?.seed.outputRef) {
             outputRef.value = resume.seed.outputRef.value;
@@ -1097,323 +556,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const { memoryBlock: memoryBlockWithProject, instructionSources, projectInstructionContent, hasSkillManifest, skillsListing, sharedMemoryPairMounted, memoryEnginePairMounted } = projectContext;
         const { provider, featureFlags, userSystemPrompt, userAppendSystemPrompt, mcpInstructionsBlock, envFacts, tzValid, userTz, gitStatusRef } = await preparePromptInputs({ spec, deps, failClosedReason: selfOrchestrationFailClosedReason(spec, deps), lockedPreflight, selfOrchestrationActive, executionEnv, reminderMark, resolvedReadFace, toolFaceSnapshot, promptProfile, fableMitigations, internals, thinking, ownedEnv, delegation, resolvedRole, mcp, model, externalContentTargetActive, resume, handsEnabled, taskRootFinal, additionalRootsCanonical, additionalReadRootsCanonical, sessionId });
         const { deferred, memoryBlock } = prepareDeferClassify({ spec, deps, tools, toolFaceSnapshot, handsEnabled, fullShellReachable, promptProfile, model, mcp, a2a, sharedMemoryPairMounted, memoryEnginePairMounted, memoryBlock: memoryBlockWithProject, memoryRecallSegment, onceLedger, sessionId });
-        const delegationProvenanceChannel = internals?.delegationProvenance;
-        if (memoryEngineSession !== undefined || delegationProvenanceChannel !== undefined) {
-            const pollution = memoryEngineSession?.pollution;
-            const delegationEvidenceAttestedOnly = memoryDelegationEvidence === "attested-only";
-            let staticMarkWaiverAnnounced = false;
-            const effectiveSafety = narrowContentSafety(delegationProvenanceChannel?.contentSafety, memoryEngineSession?.contentSafety);
-            const trustedTools = effectiveSafety.trustedTools;
-            const execIsExternalContent = effectiveSafety.execIsExternalContent || externalContentTargetActive;
-            provenanceForChildrenRef.current = { trustedTools: [...trustedTools], execIsExternalContent };
-            announceDeclaredMcpContentClasses({
-                entries: lockedPreflight.mcp,
-                statuses: mcp?.statuses,
-                execIsExternalContent,
-                sessionId,
-                runId,
-                onNotice: deps.onNotice,
-            });
-            if (memoryEngineSession?.settlement !== undefined) {
-                delegationSettlementRef.current = { controlDir: memoryEngineSession.settlement.controlDir, sessionId: memoryEngineSession.settlement.sessionId };
-            }
-            const recordExternal = () => {
-                if (delegationProvenanceChannel !== undefined)
-                    delegationProvenanceChannel.ref.current.sawExternal = true;
-            };
-            const recordIncomplete = () => {
-                if (delegationProvenanceChannel !== undefined)
-                    delegationProvenanceChannel.ref.current.incomplete = true;
-            };
-            const callerToolNames = new Set((spec.tools ?? []).map((t) => t.name));
-            const contentOriginWrapped = new WeakSet();
-            const classOf = (t) => externalContentTargetActive && envHandToolNames.has(t.name)
-                ? "external"
-                : classifyToolContentOrigin({
-                    declared: t.contentOrigin,
-                    isProtocolTool: protocolOf(t.name) !== undefined,
-                    isCallerTool: callerToolNames.has(t.name),
-                    trusted: trustedTools.has(t.name),
-                });
-            const delegationByName = new Map();
-            for (const t of spec.tools ?? []) {
-                const withFaces = t;
-                if (withFaces.agentToolFaces === undefined && t.agentListing === undefined)
-                    continue;
-                delegationByName.set(t.name, { faces: withFaces.agentToolFaces, pool: withFaces.agentToolPool });
-            }
-            const poolToolPollutes = (t) => contentOriginPollutes(classifyToolContentOrigin({
-                declared: t.contentOrigin,
-                isProtocolTool: protocolOf(t.name) !== undefined,
-                isCallerTool: true,
-                trusted: trustedTools.has(t.name),
-            }), execIsExternalContent);
-            const recallTaintJudge = memoryEngineSession?.recallTaint?.judgeDeliveredPath;
-            contentOriginWrapRef.current = () => {
-                for (let i = 0; i < tools.length; i++) {
-                    const t = tools[i];
-                    if (contentOriginWrapped.has(t))
-                        continue;
-                    const origin = classOf(t);
-                    const delegation = delegationByName.get(t.name);
-                    const isDelegation = delegation !== undefined;
-                    const pollutes = contentOriginPollutes(origin, execIsExternalContent);
-                    const readsMemoryPlane = recallTaintJudge !== undefined && t.name === "Read";
-                    if (!pollutes && !isDelegation && !readsMemoryPlane) {
-                        contentOriginWrapped.add(t);
-                        continue;
-                    }
-                    const inner = t.execute.bind(t);
-                    const mark = (reason, cause) => {
-                        try {
-                            pollution?.markPolluted(reason, cause);
-                        }
-                        catch {
-                        }
-                    };
-                    const wrapped = {
-                        ...t,
-                        execute: async (toolCallId, params, signal, onUpdate) => {
-                            if (pollutes) {
-                                mark(`tool "${t.name}" (${origin} content class) was invoked in this session`, "observed");
-                                recordExternal();
-                            }
-                            if (!isDelegation) {
-                                if (!readsMemoryPlane)
-                                    return inner(toolCallId, params, signal, onUpdate);
-                                const result = await inner(toolCallId, params, signal, onUpdate);
-                                const raw = result;
-                                const contentField = typeof raw === "object" && raw !== null ? raw.content : undefined;
-                                const headText = typeof raw === "string"
-                                    ? raw
-                                    : typeof contentField === "string"
-                                        ? contentField
-                                        : Array.isArray(contentField) && typeof contentField[0]?.text === "string"
-                                            ? contentField[0].text
-                                            : "";
-                                const delivered = result?.isError !== true &&
-                                    result?.details?.type !== "file_unchanged" &&
-                                    !headText.startsWith("<system-reminder");
-                                const fp = fileArgPath(params);
-                                if (delivered && fp !== undefined && recallTaintJudge(fp)) {
-                                    mark(`the "${t.name}" tool delivered the content of an external-origin memory entry file`, "derived");
-                                }
-                                return result;
-                            }
-                            let preCallLaunchRows;
-                            if (delegationEvidenceAttestedOnly && memoryEngineSession?.settlement !== undefined) {
-                                try {
-                                    preCallLaunchRows = new Set(sessionSettlements(memoryEngineSession.settlement.controlDir, memoryEngineSession.settlement.sessionId)
-                                        .filter((r) => r.row.lane === "background" && r.row.toolUseId === toolCallId)
-                                        .map((r) => r.row.settleId));
-                                }
-                                catch {
-                                    preCallLaunchRows = undefined;
-                                }
-                            }
-                            const requested = params?.subagent_type;
-                            const external = delegationCallIsExternal({
-                                requestedType: typeof requested === "string" ? requested : undefined,
-                                faces: delegation.faces,
-                                pool: delegation.pool,
-                                isPolluting: poolToolPollutes,
-                            });
-                            const result = await inner(toolCallId, params, signal, onUpdate);
-                            const att = readCardAttestation(result?.details);
-                            if (att === "external") {
-                                mark(`tool "${t.name}" returned the output of a delegated agent that invoked an external-content-class tool at runtime` +
-                                    (typeof requested === "string" ? ` (subagent_type "${requested}")` : ""), "observed");
-                                recordExternal();
-                            }
-                            else if (att !== "clean") {
-                                if (external) {
-                                    const staticFaceReason = `tool "${t.name}" returned the output of a delegated agent whose tool face can reach external content` +
-                                        (typeof requested === "string" ? ` (subagent_type "${requested}")` : " (no subagent_type named — classified fail-closed)");
-                                    if (!delegationEvidenceAttestedOnly) {
-                                        mark(staticFaceReason, "static");
-                                    }
-                                    else {
-                                        const receiptDetails = result?.details;
-                                        const claimsLaunchReceipt = receiptDetails !== undefined && receiptDetails !== null && receiptDetails.status === "async_launched";
-                                        const claimedSettleId = claimsLaunchReceipt && typeof receiptDetails.settle_id === "string" ? receiptDetails.settle_id : undefined;
-                                        const settlementSeat = memoryEngineSession?.settlement;
-                                        let isLaunchReceipt = false;
-                                        if (claimsLaunchReceipt && settlementSeat !== undefined) {
-                                            try {
-                                                isLaunchReceipt =
-                                                    preCallLaunchRows !== undefined &&
-                                                        claimedSettleId !== undefined &&
-                                                        !preCallLaunchRows.has(claimedSettleId) &&
-                                                        sessionSettlements(settlementSeat.controlDir, settlementSeat.sessionId).some((r) => r.row.lane === "background" && r.row.settleId === claimedSettleId && r.row.toolUseId === toolCallId);
-                                            }
-                                            catch {
-                                                isLaunchReceipt = false;
-                                            }
-                                        }
-                                        if (!isLaunchReceipt && settlementSeat !== undefined) {
-                                            try {
-                                                recordSyncUnattestable(settlementSeat.controlDir, { sessionId: settlementSeat.sessionId, toolCallId, now: Date.now });
-                                            }
-                                            catch (err) {
-                                                const e = new Error(`delegated output withheld (fail-closed): the delegation delivered without a provable attestation and the settlement account could not record the fact (${err instanceof Error ? err.message : String(err)}) — repair the memory control plane or retry`);
-                                                e.code = "memory.settlement_record_failed";
-                                                throw e;
-                                            }
-                                        }
-                                    }
-                                    if (delegationEvidenceAttestedOnly && pollution !== undefined && !staticMarkWaiverAnnounced) {
-                                        staticMarkWaiverAnnounced = true;
-                                        const waivedReason = inlineUntrusted(staticFaceReason, 200);
-                                        deliverEngineNotice(deps.onNotice, {
-                                            code: "memory.delegation_static_mark_waived",
-                                            message: `Delegation static-face pollution mark waived: ${waivedReason}. The deployment configured ` +
-                                                `memoryDelegationEvidence="attested-only", so a static tool-face verdict alone does not mark this ` +
-                                                `session's memory polluted; a delivered "external" attestation and a direct polluting-class ` +
-                                                `invocation still mark, and on a provenance-armed chain this delegation still records as ` +
-                                                `incomplete. At most one notice per prepared task leg.`,
-                                            detail: {
-                                                reason: waivedReason,
-                                                ...(typeof requested === "string" ? { subagentType: inlineUntrusted(requested, 120) } : {}),
-                                                sessionId,
-                                                runId,
-                                            },
-                                        });
-                                    }
-                                }
-                                recordIncomplete();
-                            }
-                            return result;
-                        },
-                    };
-                    contentOriginWrapped.add(wrapped);
-                    tools[i] = wrapped;
-                }
-            };
-            contentOriginWrapRef.current();
-        }
-        let centerAdoption;
-        let centerAdoptionFresh = false;
-        {
-            const failUnavailable = (digest, via) => {
-                const e = new Error(`prompt snapshot unavailable: ${via} center prompt artifact ${digest.slice(0, 23)}… has no verified resolvable copy (artifact store miss/corrupt${deps.promptSource === undefined ? "; RunnerDeps.promptSource is not configured" : ""}) — refusing to recompose a hybrid prompt (protocol §9.2)`);
-                e.code = "prompt.snapshot_unavailable";
-                throw e;
-            };
-            const pinnedEarly = await session.getPromptEpoch();
-            if (pinnedEarly?.centerArtifactDigest !== undefined) {
-                const art = await deps.promptSource?.get(pinnedEarly.centerArtifactDigest);
-                if (art === undefined)
-                    failUnavailable(pinnedEarly.centerArtifactDigest, "this session is pinned to");
-                centerAdoption = { artifact: art, ...(pinnedEarly.sourceRevision !== undefined ? { sourceRevision: pinnedEarly.sourceRevision } : {}) };
-            }
-            else if (pinnedEarly === undefined) {
-                if (internals?.parentCenterArtifactDigest !== undefined) {
-                    const art = await deps.promptSource?.get(internals.parentCenterArtifactDigest);
-                    if (art === undefined)
-                        failUnavailable(internals.parentCenterArtifactDigest, "the spawning parent adopted");
-                    centerAdoption = {
-                        artifact: art,
-                        ...(internals.parentCenterSourceRevision !== undefined ? { sourceRevision: internals.parentCenterSourceRevision } : {}),
-                    };
-                }
-                else if (resume === undefined && internals?.parentTaskId === undefined && internals?.parentSessionId === undefined) {
-                    const candidate = deps.promptSource?.current();
-                    if (candidate !== undefined && !hasConversationContent(await session.getBranch())) {
-                        centerAdoption = { artifact: candidate.artifact, sourceRevision: candidate.sourceRevision };
-                        centerAdoptionFresh = true;
-                    }
-                }
-            }
-        }
-        const buildAssembleInputs = (centerDecls) => ({
-            provider,
-            isDefaultProvider: provider === defaultPromptProvider,
-            userSystemPrompt,
-            userAppendSystemPrompt,
-            tools: tools.map((t) => (t.aliases === undefined ? { ...t } : { ...t, aliases: [...t.aliases] })),
-            facts: {
-                supervisorEnabled: false,
-                teammateEnabled: internals?.explicitAgentName !== undefined && tools.some((t) => t.name === SEND_MESSAGE_TOOL_NAME),
-                ...featureFlags,
-                orchestrationEnabled: featureFlags.orchestrationEnabled && tools.some((t) => t.name === "Workflow"),
-                orchestrationDeferred: featureFlags.orchestrationDeferred && tools.some((t) => t.name === "Workflow"),
-                promptProfile,
-                fableMitigations,
-            },
-            mcpInstructionsBlock,
-            memoryBlock,
-            buildEnvBlock: (date) => buildEnvironmentContext({ ...envFacts, date }) || undefined,
-            date: envFacts.date,
-            ...(model.promptGuidance && model.promptGuidance.length > 0 ? { modelGuidance: model.promptGuidance.join("\n\n") } : {}),
-            onWarn: (message, phase) => deps.onError?.(new Error(message), { phase, sessionId }),
-            ...(centerDecls !== undefined ? { centerDeclarations: centerDecls } : {}),
-        });
-        const assembled = assemblePrompt(buildAssembleInputs(centerAdoption !== undefined ? artifactDeclarations(centerAdoption.artifact) : undefined));
-        if (centerAdoption !== undefined && assembled.centerMounted !== true) {
-            const ownsWholePrompt = assembled.constitution === "provider-assembled";
-            const digest = centerAdoption.artifact.artifactDigest.slice(0, 23);
-            if (ownsWholePrompt) {
-                const e = new Error(`center prompt artifact ${digest}… cannot mount: this PromptProvider owns the whole prompt (assembled-identity pass-through) — upgrade the provider to stableBlocks/stableSystem or remove RunnerDeps.promptSource for this deployment`);
-                e.code = "prompt.center_unmountable";
-                throw e;
-            }
-            deps.onError?.(new Error(centerAdoptionFresh
-                ? `prompt-constitution: center prompt artifact ${digest}… contributed NO section to this prompt — every section it declares collides with a PromptProvider stableBlocks declaration of the same id, and the deployment-local declaration wins. This session runs on the bundled prompt and is deliberately NOT pinned to the artifact (a pin claiming content the model never received would be durable and wrong). Rename the colliding section ids on either side to adopt it; the per-section collisions are reported individually on this channel.`
-                : `prompt-constitution: this session is pinned to center prompt artifact ${digest}…, but under the CURRENT PromptProvider every section that artifact declares collides with a stableBlocks declaration of the same id, so none of them compiled into this prompt. The session keeps its pin and continues on the bundled prompt — its epoch's declaredSections record what actually compiled. Rename the colliding section ids on either side to restore the artifact's content.`), { phase: "prompt-constitution", sessionId });
-            if (centerAdoptionFresh)
-                centerAdoption = undefined;
-        }
-        let systemPrompt = assembled.systemPrompt;
-        if (!systemPrompt.includes(reminderMarkDeclaration(reminderMark))) {
-            deps.onError?.(new Error("reminder-mark declaration missing from the assembled system prompt: this run's PromptProvider owns the prompt and did not render the mark declaration, so engine <system-reminder> tags carry a mark the model is never told about (the impersonation defense is inactive for this deployment). Render `reminderMarkDeclaration(ctx.reminderMark)` (exported; the value rides StablePromptContext.reminderMark) in the provider, or accept the disclosure."), { phase: "config", sessionId });
-        }
-        const renderWithDate = assembled.renderWithDate
-            ? (date) => {
-                systemPrompt = assembled.renderWithDate(date);
-                return systemPrompt;
-            }
-            : undefined;
-        const promptConstitution = assembled.constitution;
-        const promptBlocks = assembled.legacyBlocks;
-        const collisionAudit = auditToolCollisions(tools);
-        for (const y of collisionAudit.yields) {
-            onceLedger.onError(new Error(`tool mount: caller tool "${y.name}" shadows another tool with the same canonical name (deliberate last-write-wins yield — the later mount serves)`), { phase: "config", sessionId });
-        }
-        for (const c of collisionAudit.aliasCollisions) {
-            onceLedger.onError(new Error(`tool mount: alias "${c.alias}" is claimed by both "${c.owners[0]}" and "${c.owners[1]}" (design/141 warn face — name resolution serves the later mount)`), { phase: "config", sessionId });
-        }
-        const saltedHash = (text) => createHash("sha256").update(PROMPT_HASH_SALT).update(text).digest("hex").slice(0, 12);
-        const promptManifest = {
-            constitution: promptConstitution,
-            blocks: promptBlocks.map((b) => ({ id: b.id, chars: b.text.length, hash: saltedHash(b.text) })),
-            ...(assembled.sections
-                ? { sections: assembled.sections.map((s) => ({ id: s.id, slot: s.slot, carrier: s.carrier, cadence: s.cadence, cacheClass: s.cacheClass, chars: s.text.length, hash: saltedHash(s.text), ...(s.declaredContentHash !== undefined ? { contentHash: s.declaredContentHash } : {}) })) }
-                : {}),
-            tools: projectToolManifest(tools, (t) => protocolOf(t.name)?.id ?? "caller"),
-        };
-        const epochDeclaredSections = (assembled.sections ?? [])
-            .filter((s) => s.origin === "provider")
-            .map((s) => ({ id: s.id, slot: s.slot, chars: s.text.length, ...(s.declaredContentHash !== undefined ? { contentHash: s.declaredContentHash } : {}) }));
-        let epochArtifactDigestForSnapshot = "";
-        {
-            const pinned = await session.getPromptEpoch();
-            const resolved = resolveEpochAgainstBundled(pinned, SEMA_DEFAULT_PACK, epochDeclaredSections);
-            epochArtifactDigestForSnapshot = resolved.descriptor.artifactDigest;
-            if (resolved.migrated) {
-                const priorConversation = pinned === undefined ? hasConversationContent(await session.getBranch()) : true;
-                const activatedBy = pinned === undefined && !priorConversation ? "session_start" : "legacy_migration";
-                await session.appendPromptEpoch({
-                    ...resolved.descriptor,
-                    activatedBy,
-                    ...(centerAdoption !== undefined
-                        ? {
-                            centerArtifactDigest: centerAdoption.artifact.artifactDigest,
-                            ...(centerAdoption.sourceRevision !== undefined ? { sourceRevision: centerAdoption.sourceRevision } : {}),
-                        }
-                        : {}),
-                });
-            }
-        }
+        prepareMemoryEngineSession({ memoryEngineSession, internals, memoryDelegationEvidence, externalContentTargetActive, lockedPreflight, mcp, sessionId, runId, deps, provenanceForChildrenRef, delegationSettlementRef, spec, envHandToolNames, tools, contentOriginWrapRef });
+        const { systemPromptSeat, renderWithDate, systemBlocks, promptManifest, epochDeclaredSections, epochArtifactDigestForSnapshot, buildAssembleInputs, centerAdoptionRef } = await preparePromptAssembly({ session, deps, internals, resume, provider, userSystemPrompt, userAppendSystemPrompt, featureFlags, mcpInstructionsBlock, memoryBlock, envFacts, promptProfile, fableMitigations, tools, model, sessionId, reminderMark, onceLedger });
         const { activeTools, fpRef, turnSnapshotRef, harnessTools, toolsDeltaRef, toolMaterializeStatic, deferDirectCall, staticFaceForRef, listingRideRef } = await prepareToolDisclosureMount({ spec, deps, session, resume, deferred, tools, onceLedger, mcp, promptManifest, offloadReachableToolsRef, contentOriginWrapRef, rebuildHarnessToolsRef, harnessRef });
         const { agentListing, announcedListingsRef, dateChange } = prepareListings({ spec, tools, onceLedger, sessionId, toolFaceSnapshot, activeTools, resume, skillsListing, listingRideRef, renderWithDate, envFacts, tzValid, userTz });
         const lastBrainContextRef = {};
@@ -1474,8 +618,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             tools: harnessTools,
             model,
             thinkingLevel: thinking ?? "off",
-            systemPrompt,
-            ...(assembled.systemBlocks ? { systemBlocks: assembled.systemBlocks } : {}),
+            systemPrompt: systemPromptSeat.current,
+            ...(systemBlocks ? { systemBlocks } : {}),
             getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
             runtime: brainToRuntime({
                 ...guardedBrain,
@@ -1508,1864 +652,23 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 releaseSignal = () => sig.removeEventListener("abort", onExternalAbort);
             }
         }
-        const policy = lockedPreflight.toolPolicy;
-        const auditPolicyNames = (auditee) => {
-            const nameGroups = toolPolicyNameSets(auditee);
-            if (nameGroups.length > 0) {
-                const known = new Set(tools.flatMap((t) => [t.name, ...(t.aliases ?? [])]));
-                for (const t of harnessTools)
-                    known.add(t.name);
-                const unmatched = new Set();
-                for (const g of nameGroups) {
-                    for (const [kind, list] of [["deny", g.deny], ["ask", g.ask], ["allow", g.allow]]) {
-                        for (const n of list ?? []) {
-                            if (known.has(n))
-                                continue;
-                            if (isNamespacedCoveringRuleName(n) && [...known].some((k) => namespacedRuleNameCovers(n, k)))
-                                continue;
-                            const retired = RETIRED_TOOL_NAMES.get(n);
-                            if (retired !== undefined) {
-                                const err = new Error(`tool policy ${kind}-list entry "${n}" is a RETIRED tool name (${retired}) and matches nothing in this run's roster — legacy-name normalization was removed (RB-476-A), so this entry would silently guard nothing. Update the deployment's rule to the current name.`);
-                                err.code = "config.legacy_tool_name";
-                                throw err;
-                            }
-                            if (n.includes("__") && protocolOf(n) === undefined) {
-                                const err = new Error(`tool policy ${kind}-list entry "${n}" carries the "__" namespace separator but no protocol prefix, and matches nothing in this run's roster — protocol tools are named ${NAMESPACED_NAME_SHAPES}, and legacy-name normalization was removed (RB-476-A), so this entry would silently guard nothing. Prefix the entry with the owning protocol's marker.`);
-                                err.code = "config.legacy_tool_name";
-                                throw err;
-                            }
-                            unmatched.add(`"${n}" (${kind})`);
-                        }
-                    }
-                }
-                const dedupeKey = [...unmatched].sort().join("|");
-                const advised = advisedPolicyNames.get(deps) ?? new Set();
-                if (unmatched.size > 0 && !advised.has(dedupeKey)) {
-                    advised.add(dedupeKey);
-                    if (advised.size > ADVISED_KEYS_CAP) {
-                        const oldest = advised.values().next().value;
-                        if (oldest !== undefined)
-                            advised.delete(oldest);
-                    }
-                    advisedPolicyNames.set(deps, advised);
-                    try {
-                        const e = new Error(`toolPolicy name audit: ${[...unmatched].join(", ")} match(es) no tool mounted this run (primary or alias) — the rule cannot fire here. Often a typo or a self-report/wire name skew (e.g. TodoWrite vs the mounted TaskCreate family; "*" has no wildcard meaning in a name-keyed policy). Advisory only: enforcement is unchanged, and a name can be legitimate for another scenario or a per-spawn tool.`);
-                        e.code = "config.toolpolicy.unmatched_names";
-                        deps.onError?.(e, { phase: "config", sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-        };
-        auditPolicyNames(policy);
-        let sessionRulePolicy;
-        if (deps.sessionPolicyStore && spec.sessionId) {
-            const rules = await deps.sessionPolicyStore.getRules(spec.sessionId, spec.principal);
-            if (rules) {
-                sessionRulePolicy = createSessionRulePolicy(rules, { env: executionEnv, rootPath: taskRootFinal, toolEffects });
-                ownSessionRulesRef.current = {
-                    sessionId: spec.sessionId,
-                    ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
-                    rev: rules.rev,
-                    rules,
-                };
-            }
-        }
-        const ancestorRulePolicies = [];
-        for (const snap of inheritedAncestorRules ?? []) {
-            let ancestorRules = snap.rules;
-            if (deps.sessionPolicyStore) {
-                try {
-                    const live = await deps.sessionPolicyStore.getRules(snap.sessionId, snap.principal);
-                    if (live !== null && live.rev >= snap.rev)
-                        ancestorRules = live;
-                }
-                catch {
-                }
-            }
-            ancestorRulePolicies.push(createSessionRulePolicy(ancestorRules, { env: executionEnv, rootPath: taskRootFinal, toolEffects }));
-        }
-        const skillScopePolicy = hasSkillManifest
-            ? createActiveSkillScopePolicy({
-                scope: skillScope,
-                env: executionEnv,
-                rootPath: taskRootFinal,
-                toolEffects,
-            })
-            : undefined;
-        const frozenConstraintLayers = (seedInheritedGate?.constraintChain ?? [])
-            .filter((e) => !("opaque" in e))
-            .map((entry) => ({
-            check: (creq) => checkToolPolicyProjection(entry, creq) ?? { action: "allow" },
-        }));
-        const narrowingLayers = [sessionRulePolicy, ...ancestorRulePolicies, ...frozenConstraintLayers, skillScopePolicy].filter((p) => p !== undefined);
-        for (const layer of narrowingLayers)
-            auditPolicyNames(layer);
-        const denyNarrowingPolicy = narrowingLayers.length === 0 ? undefined : narrowingLayers.length === 1 ? narrowingLayers[0] : combinePolicies(...narrowingLayers);
-        const basePolicyForResumeEdit = lockedPreflight.basePolicyForResumeEdit ?? lockedPreflight.toolPolicy;
-        const hooks = spec.hooks ?? deps.hooks;
-        const hookTimeoutMs = resolveHookTimeoutMs(hooks?.timeoutMs, notifyOwnHookCrash, hooks);
-        const preToolUseObservational = hooks?.preToolUse !== undefined && hooks.preToolUseObservational === true;
-        const ownGatePreToolUse = !preToolUseObservational
-            ? hooks?.preToolUse
-            : async (toolName, input, ctx) => {
-                const r = await hooks.preToolUse(toolName, cloneObserverInput(input), ctx);
-                if (r === undefined)
-                    return undefined;
-                try {
-                    const action = typeof r.action === "string" ? r.action : "(non-string action)";
-                    deps.onError?.(new Error(`a PreToolUse hook declared observational (Hooks.preToolUseObservational) returned a decision ("${action}") while screening ` +
-                        `"${toolName}" — the decision was NOT adopted and the call proceeded as if the hook had no opinion. ` +
-                        `A declared-observational face must return undefined; drop the declaration if its verdicts are meant to count ` +
-                        `(they then also travel to delegated children as an inherited screening constraint).`), { phase: "hook", sessionId, classification: "observational-hook-verdict-ignored" });
-                }
-                catch {
-                }
-                return undefined;
-            };
-        const sameInstanceAncestorCount = policy === undefined ? 0 : (inheritedParentConstraints ?? []).reduce((n, pc) => (pc.policy === policy ? n + 1 : n), 0);
-        const sharedFirstDecision = new Map();
-        const SHARED_FIRST_DECISION_CAP = 256;
-        const inheritedUnavailableAsks = new Set();
-        const INHERITED_UNAVAILABLE_CAP = 256;
-        const markInheritedUnavailable = (toolCallId) => {
-            if (inheritedUnavailableAsks.size >= INHERITED_UNAVAILABLE_CAP && !inheritedUnavailableAsks.has(toolCallId))
-                return false;
-            inheritedUnavailableAsks.add(toolCallId);
-            return true;
-        };
-        const inheritedAskGrants = new Map();
-        const recordInheritedAskGrant = (toolCallId, approver, presented, waitMs) => {
-            if (typeof approver !== "function")
-                return;
-            if (presented === undefined)
-                return;
-            if (inheritedAskGrants.size >= INHERITED_UNAVAILABLE_CAP && !inheritedAskGrants.has(toolCallId))
-                return;
-            const argsJson = askGrantShapeOf(presented);
-            if (argsJson === undefined)
-                return;
-            inheritedAskGrants.set(toolCallId, { approver, argsJson, presented, waitMs });
-        };
-        const sandboxDeclared = isIsolated(executionEnv);
-        const sandboxAdmissionArmed = (() => {
-            if (!sandboxDeclared)
-                return false;
-            const store = resolveCheckpointStore(spec, deps);
-            const missing = [];
-            if (store === undefined)
-                missing.push("a wired CheckpointStore");
-            else if (store.redecision?.reopen !== true)
-                missing.push("a CheckpointStore that DECLARES redecision.reopen (declaration, never duck-typing)");
-            if (spec.durableApproval === undefined && runtimeCaps?.forceDurableGate !== true)
-                missing.push("a durable park (spec.durableApproval, or the forceDurableGate entitlement)");
-            if (missing.length === 0)
-                return true;
-            try {
-                const e = new Error(`sandbox admission mode NOT armed: the execution env declares an isolated sandbox (capabilities.isolation), but the mode's ` +
-                    `park prerequisites are missing — ${missing.join("; ")}. Asks keep the conservative default chain (no auto-admission, no boundary park).`);
-                e.code = "config.sandbox_admission_unavailable";
-                deps.onError?.(e, { phase: "config", sessionId, classification: "sandbox-admission-unavailable" });
-            }
-            catch {
-            }
-            return false;
-        })();
-        const foldAskClasses = new Map();
-        const FOLD_ASK_CLASSES_CAP = 256;
-        const recordFoldAskClass = (toolCallId, cls, layer) => {
-            if (!foldAskClasses.has(toolCallId) && foldAskClasses.size >= FOLD_ASK_CLASSES_CAP)
-                return;
-            const list = foldAskClasses.get(toolCallId) ?? [];
-            list.push({ cls, layer });
-            foldAskClasses.set(toolCallId, list);
-        };
-        const sandboxBoundaryCapable = (toolName) => egressTools.has(toolName) || toolName.includes("__") || ownToolNames.has(toolName) || toolName === SEND_MESSAGE_TOOL_NAME;
-        const emitSandboxAdmitted = (info) => {
-            emitTrace(deps.tracer, () => ({
-                kind: "permission.sandbox_admitted",
-                version: 1,
-                taskId: hostTaskId,
-                toolCallId: info.toolCallId,
-                toolName: info.toolName,
-                askClasses: info.askClasses.map((a) => a.cls),
-                sourceLayers: info.askClasses.map((a) => a.layer),
-                boundary: info.boundary,
-                ts: Date.now(),
-            }));
-        };
-        const ancestorSandboxAdmissions = new Map();
-        const recordAncestorSandboxAdmission = (toolCallId, toolName) => {
-            const list = ancestorSandboxAdmissions.get(toolCallId);
-            if (list !== undefined)
-                list.push({ cls: "sandbox_local", layer: "ancestor_constraint" });
-            else
-                ancestorSandboxAdmissions.set(toolCallId, [{ cls: "sandbox_local", layer: "ancestor_constraint" }]);
-            void toolName;
-        };
-        const callerPolicyLayer = policy !== undefined && sameInstanceAncestorCount > 0
-            ? {
-                check: async (creq, csignal) => {
-                    const decision = await policy.check(creq, csignal ?? abortController.signal);
-                    sharedFirstDecision.set(creq.toolCallId, decision);
-                    if (sharedFirstDecision.size > SHARED_FIRST_DECISION_CAP) {
-                        const oldest = sharedFirstDecision.keys().next().value;
-                        if (oldest !== undefined)
-                            sharedFirstDecision.delete(oldest);
-                    }
-                    return decision;
-                },
-            }
-            : policy;
-        const askSourceIdentity = () => ({
-            principal: spec.principal,
-            sourceTaskId: sessionId,
-            ...(internals?.parentTaskId !== undefined ? { fromSubagent: true } : {}),
-            ...((internals?.explicitAgentName ?? internals?.agentName) !== undefined
-                ? { sourceAgentName: internals?.explicitAgentName ?? internals?.agentName }
-                : {}),
-            ...(delegation.isDelegatedChild ? { isDelegatedChild: true } : {}),
-        });
-        const riskAxesOf = (toolName) => {
-            const tier = irreversibilityTier.get(toolName);
-            const negatives = axisExplicitNegatives.get(toolName);
-            const irreversible = tier === "always" || tier === "maybe" ? true : tier === "never" ? false : negatives?.irreversible;
-            const egress = egressTools.has(toolName) ? true : negatives?.egress;
-            if (irreversible === undefined && egress === undefined)
-                return {};
-            return { riskAxes: { ...(irreversible !== undefined ? { irreversible } : {}), ...(egress !== undefined ? { egress } : {}) } };
-        };
-        const inheritedAskEvidence = inheritedAskRuleEvidence(deps.permissionRuleStore);
-        const { personal: permissionRuleLane, org: permissionRuleOrgLane } = createPermissionRuleLanes({
-            provider: deps.permissionRuleStore,
-            localOwnerDeclared: deps.localOwnerRules === true,
-            principal: spec.principal,
-            sessionId,
-            root: taskRootFinal,
-            liveCwd: () => handsCwdRef?.current,
-            questionToolMounted,
-            questionToolName: ASK_USER_QUESTION_TOOL_NAME,
-            onRevisionDefect: (message) => deps.onError?.(new Error(message), { phase: "config", sessionId }),
-            onDisclosure: (message) => emitTrace(deps.tracer, () => ({ kind: "permission.rule_store_unreadable", version: 1, taskId: hostTaskId, message, ts: Date.now() })),
-        });
-        const ruleOffersOf = makeRuleOffersOf({
-            laneArmed: permissionRuleLane !== undefined,
-            principal: spec.principal,
-            localOwnerDeclared: deps.localOwnerRules === true,
-            egressTools,
-            irreversibilityTier,
-            shellGatedBash,
-            taskRoot: taskRootFinal,
-            cwdRef: handsCwdRef,
-            deniesDirectoryRead: readDenyMatcher !== undefined ? (d) => readDenyMatcher.matchPath(d) !== null : undefined,
-        });
-        const recheckApprovedEdit = async (pol, onAskOf, creq, edit, csignal, ancestorDecider, ancestorTracker) => {
-            let editArgs = edit;
-            for (let round = 0;; round++) {
-                if (round >= 3) {
-                    return {
-                        action: "deny",
-                        message: `the approval-edit chain for "${creq.toolName}" exceeded the re-approval cap (inherited parent policy) — denied fail-closed; re-submit the edited action directly`,
-                    };
-                }
-                let re;
-                try {
-                    re = await pol.check({ ...creq, args: editArgs }, csignal ?? abortController.signal);
-                }
-                catch (err) {
-                    return {
-                        action: "deny",
-                        message: `inherited parent policy re-check of the approved edit errored for "${creq.toolName}": ${err instanceof Error ? err.message : String(err)}`,
-                    };
-                }
-                if (re.action === "deny")
-                    return re;
-                if (re.action === "allow") {
-                    return { action: "allow", updatedInput: re.updatedInput !== undefined ? re.updatedInput : editArgs };
-                }
-                if (re.updatedInput !== undefined)
-                    editArgs = re.updatedInput;
-                const judged = await judgeInheritedClassifier({ autoMode: ancestorDecider !== undefined ? { decider: ancestorDecider, denialTracking: ancestorTracker } : undefined, ask: re, req: { ...creq, args: editArgs }, signal: csignal ?? abortController.signal, subject: "the approved edit" });
-                if (judged.kind === "allow")
-                    return { action: "allow", updatedInput: editArgs };
-                if (judged.kind === "deny")
-                    return judged.result;
-                const { ask: editAsk, fallback: editFallback, mintedHere: editMintedHere, origin: editOrigin } = judged;
-                re = editAsk;
-                const rr = await resolveAsk({
-                    toolName: creq.toolName,
-                    toolCallId: creq.toolCallId,
-                    args: editArgs,
-                    ...ruleOffersOf(creq.toolName, editArgs, { ...(re ?? {}), ancestorResolved: true }),
-                    message: re.message ?? `approval required for "${creq.toolName}" (inherited parent policy)`,
-                    ...askSourceIdentity(),
-                    ...riskAxesOf(creq.toolName),
-                    ...(re.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-                    ...(re.persistedRuleShadowed !== undefined ? { persistedRuleShadowed: re.persistedRuleShadowed } : {}),
-                    ...inheritedAskCarry(editOrigin, editFallback, isLiveApproverSeat(onAskOf), ancestorTracker),
-                    ruleEvidence: inheritedAskEvidence,
-                }, onAskOf, csignal ?? abortController.signal, lateAskSettlementObserver({ toolName: creq.toolName, toolCallId: creq.toolCallId, sessionId, runId, ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), onNotice: deps.onNotice, onError: deps.onError }));
-                settleDenialLimitFallback({ fallback: editFallback, mintedHere: editMintedHere, tracker: ancestorTracker, resolved: rr, headless: headlessDenyAtRecheck, stop: stopForDenialLimit, toolName: creq.toolName, toolCallId: creq.toolCallId });
-                if (rr.action !== "allow")
-                    return rr;
-                if (rr.updatedInput === undefined)
-                    return { action: "allow", updatedInput: editArgs };
-                editArgs = rr.updatedInput;
-            }
-        };
-        const parentConstraintWrappers = (inheritedParentConstraints ?? []).map((pc) => pc.preToolUse !== undefined &&
-            pc.preToolUse === hooks?.preToolUse &&
-            !preToolUseObservational &&
-            pc.durableMandate !== true &&
-            pc.contentMandate !== true &&
-            askApproverIdentity(pc.onAsk) === askApproverIdentity(frozenOnAsk) &&
-            pc.hookEnv === hookEnvSource &&
-            pc.autoMode?.decider === autoModeDecider
-            ? { check: () => ({ action: "allow" }) }
-            : policy !== undefined && pc.policy === policy
-                ? {
-                    check: async (creq, csignal) => {
-                        const first = sharedFirstDecision.get(creq.toolCallId);
-                        if (first === undefined) {
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy could not be arbitrated for "${creq.toolName}" ` +
-                                    `(shared-instance first decision unavailable); denied fail-closed`,
-                            };
-                        }
-                        if (first.action === "deny")
-                            return first;
-                        if (first.action === "allow")
-                            return { action: "allow" };
-                        if (creq.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-                            if (pc.contentMandate !== true || markInheritedUnavailable(creq.toolCallId))
-                                return first;
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy requires durable handling of the question raised for "${creq.toolName}" and the marker channel is at capacity — ` +
-                                    `denied fail-closed (tighten-only)`,
-                            };
-                        }
-                        if (pc.durableMandate === true) {
-                            if (resolveCheckpointStore(spec, deps) !== undefined &&
-                                (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true) &&
-                                markInheritedUnavailable(creq.toolCallId)) {
-                                return first;
-                            }
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy requires durable approval for "${creq.toolName}" — the parent's durable ` +
-                                    `ask cannot be reconstructed in a delegated child; denied fail-closed (tighten-only)`,
-                            };
-                        }
-                        const judged = await judgeInheritedClassifier({ autoMode: pc.autoMode, ask: first, req: creq, signal: csignal ?? abortController.signal, subject: "this call" });
-                        if (judged.kind === "allow")
-                            return { action: "allow" };
-                        if (judged.kind === "deny")
-                            return judged.result;
-                        const { ask: inheritedAsk, fallback, mintedHere, origin: inheritedOrigin } = judged;
-                        if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName)) {
-                            recordAncestorSandboxAdmission(creq.toolCallId, creq.toolName);
-                            return { action: "allow" };
-                        }
-                        const presentedArgs = creq.args;
-                        const askT0 = now();
-                        const resolved = await resolveAsk({
-                            toolName: creq.toolName,
-                            toolCallId: creq.toolCallId,
-                            args: presentedArgs,
-                            ...ruleOffersOf(creq.toolName, presentedArgs, { ...(inheritedAsk.action === "ask" ? inheritedAsk : {}), ancestorResolved: true }),
-                            message: inheritedAsk.message ?? `approval required for "${creq.toolName}" (inherited parent policy)`,
-                            ...askSourceIdentity(),
-                            ...riskAxesOf(creq.toolName),
-                            ...(inheritedAsk.action === "ask" && inheritedAsk.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-                            ...(inheritedAsk.action === "ask" && inheritedAsk.persistedRuleShadowed !== undefined ? { persistedRuleShadowed: inheritedAsk.persistedRuleShadowed } : {}),
-                            ...inheritedAskCarry(inheritedOrigin, fallback, isLiveApproverSeat(pc.onAsk), pc.autoMode?.denialTracking),
-                            ruleEvidence: inheritedAskEvidence,
-                        }, pc.onAsk, csignal ?? abortController.signal, lateAskSettlementObserver({ toolName: creq.toolName, toolCallId: creq.toolCallId, sessionId, runId, ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), onNotice: deps.onNotice, onError: deps.onError }));
-                        const askWaitMs = Math.max(0, now() - askT0);
-                        if (resolved.action === "deny" && resolved.approverUnavailable === true) {
-                            if (markInheritedUnavailable(creq.toolCallId))
-                                return inheritedAsk;
-                            return {
-                                action: "deny",
-                                message: `no approver is reachable for the inherited approval of "${creq.toolName}" and the marker channel is at capacity — denied fail-closed`,
-                            };
-                        }
-                        settleDenialLimitFallback({ fallback, mintedHere, tracker: pc.autoMode?.denialTracking, resolved, headless: headlessDenyAtFold, stop: stopForDenialLimit, toolName: creq.toolName, toolCallId: creq.toolCallId });
-                        if (resolved.action !== "allow")
-                            return resolved;
-                        if (resolved.updatedInput !== undefined) {
-                            return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
-                        }
-                        recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs);
-                        return { action: "allow" };
-                    },
-                }
-                : {
-                    check: async (creq, csignal) => {
-                        let decision;
-                        try {
-                            decision = await pc.policy.check(creq, csignal ?? abortController.signal);
-                        }
-                        catch (err) {
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy errored for "${creq.toolName}": ${err instanceof Error ? err.message : String(err)}`,
-                            };
-                        }
-                        if (decision.action !== "ask")
-                            return decision;
-                        if (creq.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-                            if (pc.contentMandate !== true || markInheritedUnavailable(creq.toolCallId))
-                                return decision;
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy requires durable handling of the question raised for "${creq.toolName}" and the marker channel is at capacity — ` +
-                                    `denied fail-closed (tighten-only)`,
-                            };
-                        }
-                        if (pc.durableMandate === true) {
-                            if (resolveCheckpointStore(spec, deps) !== undefined &&
-                                (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true) &&
-                                markInheritedUnavailable(creq.toolCallId)) {
-                                return decision;
-                            }
-                            return {
-                                action: "deny",
-                                message: `inherited parent policy requires durable approval for "${creq.toolName}" — the parent's durable ` +
-                                    `ask cannot be reconstructed in a delegated child; denied fail-closed (tighten-only)`,
-                            };
-                        }
-                        const presentedArgs = decision.updatedInput !== undefined ? decision.updatedInput : creq.args;
-                        const judged = await judgeInheritedClassifier({ autoMode: pc.autoMode, ask: decision, req: { ...creq, args: presentedArgs }, signal: csignal ?? abortController.signal, subject: "this call" });
-                        if (judged.kind === "allow")
-                            return decision.updatedInput !== undefined ? { action: "allow", updatedInput: decision.updatedInput } : { action: "allow" };
-                        if (judged.kind === "deny")
-                            return judged.result;
-                        const { ask: inheritedAsk, fallback, mintedHere, origin: inheritedOrigin } = judged;
-                        if (fallback === undefined && sandboxAdmissionArmed && policyAskClassOf(pc.policy) === "sandbox_local" && !sandboxBoundaryCapable(creq.toolName)) {
-                            recordAncestorSandboxAdmission(creq.toolCallId, creq.toolName);
-                            return decision.updatedInput !== undefined ? { action: "allow", updatedInput: decision.updatedInput } : { action: "allow" };
-                        }
-                        const askT0 = now();
-                        const resolved = await resolveAsk({
-                            toolName: creq.toolName,
-                            toolCallId: creq.toolCallId,
-                            args: presentedArgs,
-                            ...ruleOffersOf(creq.toolName, presentedArgs, { ...(inheritedAsk.action === "ask" ? inheritedAsk : {}), ancestorResolved: true }),
-                            message: inheritedAsk.message ?? `approval required for "${creq.toolName}" (inherited parent policy)`,
-                            ...askSourceIdentity(),
-                            ...riskAxesOf(creq.toolName),
-                            ...(inheritedAsk.action === "ask" && inheritedAsk.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-                            ...(inheritedAsk.action === "ask" && inheritedAsk.persistedRuleShadowed !== undefined ? { persistedRuleShadowed: inheritedAsk.persistedRuleShadowed } : {}),
-                            ...inheritedAskCarry(inheritedOrigin, fallback, isLiveApproverSeat(pc.onAsk), pc.autoMode?.denialTracking),
-                            ruleEvidence: inheritedAskEvidence,
-                        }, pc.onAsk, csignal ?? abortController.signal, lateAskSettlementObserver({ toolName: creq.toolName, toolCallId: creq.toolCallId, sessionId, runId, ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), onNotice: deps.onNotice, onError: deps.onError }));
-                        const askWaitMs = Math.max(0, now() - askT0);
-                        if (resolved.action === "deny" && resolved.approverUnavailable === true) {
-                            if (markInheritedUnavailable(creq.toolCallId))
-                                return inheritedAsk;
-                            return {
-                                action: "deny",
-                                message: `no approver is reachable for the inherited approval of "${creq.toolName}" and the marker channel is at capacity — denied fail-closed`,
-                            };
-                        }
-                        settleDenialLimitFallback({ fallback, mintedHere, tracker: pc.autoMode?.denialTracking, resolved, headless: headlessDenyAtFold, stop: stopForDenialLimit, toolName: creq.toolName, toolCallId: creq.toolCallId });
-                        if (resolved.action !== "allow")
-                            return resolved;
-                        if (resolved.updatedInput !== undefined) {
-                            return recheckApprovedEdit(pc.policy, pc.onAsk, creq, resolved.updatedInput, csignal, pc.autoMode?.decider, pc.autoMode?.denialTracking);
-                        }
-                        if (pc.preToolUse === undefined) {
-                            recordInheritedAskGrant(creq.toolCallId, pc.onAsk, resolved.presentedInput, askWaitMs);
-                        }
-                        return decision.updatedInput !== undefined ? { ...resolved, updatedInput: decision.updatedInput } : resolved;
-                    },
-                });
-        const rewriteCapableLayers = policy !== undefined || parentConstraintWrappers.length > 0;
-        const rewriteEmitterIndex = new Map();
-        const rewriteCapableChain = [
-            ...(callerPolicyLayer !== undefined ? [callerPolicyLayer] : []),
-            ...parentConstraintWrappers,
-        ];
-        const callerSlotOffset = callerPolicyLayer !== undefined ? 1 : 0;
-        const sameInstanceAdapterIndices = new Set();
-        (inheritedParentConstraints ?? []).forEach((pc, j) => {
-            if (policy !== undefined && pc.policy === policy)
-                sameInstanceAdapterIndices.add(j + callerSlotOffset);
-        });
-        const instrumentedChain = rewriteCapableChain.map((layer, idx) => ({
-            check: async (creq, csignal) => {
-                const d = await layer.check(creq, csignal);
-                if (d.updatedInput !== undefined)
-                    rewriteEmitterIndex.set(creq.toolCallId, idx);
-                if (d.action === "ask") {
-                    recordFoldAskClass(creq.toolCallId, idx < callerSlotOffset ? policyAskClassOf(policy) : "mandate", idx < callerSlotOffset ? "caller_policy" : "ancestor_constraint");
-                }
-                return d;
-            },
-        }));
-        const policyLayers = [
-            ...narrowingLayers,
-            ...instrumentedChain,
-            ...(rewriteCapableLayers ? narrowingLayers : []),
-        ];
-        const integrityGuardLayers = [createTranscriptIntegrityPolicy(), createUnverifiableDeletePolicy()];
-        const guardedPolicyLayers = rewriteCapableLayers
-            ? [...integrityGuardLayers, ...policyLayers, ...integrityGuardLayers]
-            : [...integrityGuardLayers, ...policyLayers];
-        const foldedPolicy = guardedPolicyLayers.length === 1 ? guardedPolicyLayers[0] : combinePolicies(...guardedPolicyLayers);
-        const effectivePolicy = foldedPolicy !== undefined && rewriteCapableLayers
-            ? {
-                check: async (req, signal) => {
-                    let decision;
-                    try {
-                        decision = await foldedPolicy.check(req, signal);
-                    }
-                    catch (err) {
-                        rewriteEmitterIndex.delete(req.toolCallId);
-                        throw err;
-                    }
-                    const emitterIdx = rewriteEmitterIndex.get(req.toolCallId);
-                    rewriteEmitterIndex.delete(req.toolCallId);
-                    if (decision.action === "deny" || decision.updatedInput === undefined)
-                        return decision;
-                    const recheckPrefix = rewriteCapableChain.slice(0, emitterIdx ?? rewriteCapableChain.length);
-                    const postEmitterSameInstanceAdapters = [];
-                    if (emitterIdx !== undefined && emitterIdx > 0) {
-                        for (let i = emitterIdx + 1; i < rewriteCapableChain.length; i++) {
-                            if (sameInstanceAdapterIndices.has(i))
-                                postEmitterSameInstanceAdapters.push(rewriteCapableChain[i]);
-                        }
-                    }
-                    const recheckLayers = [...recheckPrefix, ...postEmitterSameInstanceAdapters];
-                    const finalReq = { ...req, args: decision.updatedInput };
-                    let asked;
-                    try {
-                        for (const layer of recheckLayers) {
-                            const d = await layer.check(finalReq, signal);
-                            if (d.action === "deny") {
-                                return { ...d, updatedInput: decision.updatedInput };
-                            }
-                            if (d.updatedInput !== undefined) {
-                                return {
-                                    action: "deny",
-                                    message: "policy required a rewrite during final-form re-check — the arguments that would execute were not accepted as-is (fail-closed; rewrite chains are not iterated to a fixpoint)",
-                                    updatedInput: decision.updatedInput,
-                                };
-                            }
-                            if (d.action === "ask" && asked === undefined)
-                                asked = d;
-                        }
-                    }
-                    finally {
-                        rewriteEmitterIndex.delete(req.toolCallId);
-                    }
-                    if (asked !== undefined && decision.action === "allow") {
-                        return { ...asked, updatedInput: decision.updatedInput };
-                    }
-                    return decision;
-                },
-            }
-            : foldedPolicy;
-        const { onAsk, preToolContexts, blockedToolCalls, approvalSettlement, humanBareRejections, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, platformSuspendArmed, durableApproval, wiringManifest, parkLaneArmed, hookIdentity, hookEnvFace } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, handsEnabled, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, suspendRef, reviewRef, frozenOnAsk, liveInheritedGate, delegation });
+        const { hooks, hookTimeoutMs, preToolUseObservational, ownGatePreToolUse, basePolicyForResumeEdit, denyNarrowingPolicy, policyLayers, effectivePolicy, inheritedUnavailableAsks, inheritedAskGrants, askSourceIdentity, riskAxesOf, ruleOffersOf, permissionRuleLane, permissionRuleOrgLane, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, foldAskClasses, ancestorSandboxAdmissions } = await preparePolicyChain({ spec, deps, internals, sessionId, runId, hostTaskId, taskRootFinal, executionEnv, lockedPreflight, tools, harnessTools, toolEffects, egressTools, irreversibilityTier, axisExplicitNegatives, ownToolNames, shellGatedBash, handsCwdRef, readDenyMatcher, questionToolMounted, runtimeCaps, inheritedAncestorRules, inheritedParentConstraints, seedInheritedGate, hasSkillManifest, skillScope, frozenOnAsk, hookEnvSource, notifyOwnHookCrash, autoModeDecider, stopForDenialLimit, delegation, abortController, now, ownSessionRulesRef });
+        const { onAsk, preToolContexts, blockedToolCalls, approvalSettlement, humanBareRejections, batchHaltRef, blockedTracked, incompleteSuspendAdapter, durableSuspendInfraReady, resourceSuspendEligible, usageGovernance, durableApproval, wiringManifest, parkLaneArmed, gateMachineryActive, hookIdentity, hookEnvFace } = prepareWiringManifest({ spec, deps, internals, resume, sessionId, runId, hostTaskId, taskScope, hooks, preToolUseObservational, policyLayers, effectivePolicy, handsEnabled, mcp, irreversibleTools, egressTools, toolEffects, ownedEnv, executionEnv, offloadStore, onceLedger, usageWindows, envLifetimeSuspendAt, runtimeCaps, resolvedInteractionPosture, durableQuestionFace, liveQuestionFace, checkpointStore, sessions, modelGateManifest, autoModeArmReason, lockedPreflight, peerLaneRefs, peerLaneActive, harness, suspendRef, reviewRef, frozenOnAsk, liveInheritedGate, delegation });
         if (fileHistoryBoundary !== undefined) {
             harness.on("tool_call", async () => {
                 await fileHistoryBoundary.settle();
                 return undefined;
             });
         }
-        if (effectivePolicy || hooks?.preToolUse || egressTools.size > 0 || irreversibleTools.size > 0 || resourceSuspendEligible || platformSuspendArmed || spec.enablePlanMode === true) {
-            const composedCallSignal = (callSignal) => composeCallSignal(abortController.signal, callSignal);
-            const adjudicate = effectivePolicy
-                ? (req, callSignal) => {
-                    const signal = composedCallSignal(callSignal);
-                    return raceAbort(Promise.resolve(effectivePolicy.check({ ...req, budget: budgetSnapshot, ...(handsCwdRef !== undefined ? { cwd: handsCwdRef.current } : {}) }, signal)), signal, () => ({
-                        action: "deny",
-                        message: "policy check aborted (task timed out or cancelled)",
-                    }));
-                }
-                : undefined;
-            const approvalPreviewOf = (toolName, args) => resolveApprovalPreview(tools, toolName, args);
-            const resolveAskBound = async (decision, req, callSignal) => {
-                if (inheritedUnavailableAsks.delete(req.toolCallId)) {
-                    return {
-                        action: "deny",
-                        message: `approval for "${req.toolName}" requires an ancestor task's approval that cannot be resolved here ` +
-                            `(no live approver reachable, or a durable-park mandate applies), and no durable approval park is ` +
-                            `available — denied fail-closed (the inherited constraint stands).`,
-                        decisionReason: "mode",
-                        approverUnavailable: true,
-                    };
-                }
-                const grantReuse = consumeInheritedAskGrant(inheritedAskGrants, onAsk, humanReviewRef, decision, req);
-                if (grantReuse !== undefined)
-                    return grantReuse;
-                const t0 = now();
-                const resolved = await resolveAsk({
-                    toolName: req.toolName,
-                    toolCallId: req.toolCallId,
-                    args: req.args,
-                    ...(() => {
-                        const p = approvalPreviewOf(req.toolName, req.args);
-                        return { ...(p.preview !== undefined ? { preview: p.preview } : {}), ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}) };
-                    })(),
-                    ...ruleOffersOf(req.toolName, req.args, decision.action === "ask" ? decision : undefined),
-                    message: decision.message ?? `approval required for "${req.toolName}"`,
-                    ...askSourceIdentity(),
-                    ...riskAxesOf(req.toolName),
-                    ...(decision.action === "ask" && decision.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-                    ...(decision.action === "ask" && decision.persistedRuleShadowed !== undefined ? { persistedRuleShadowed: decision.persistedRuleShadowed } : {}),
-                    ...(decision.action === "ask" ? gateAskCarry(decision, isLiveApproverSeat(onAsk), autoModeDenialTracking) : {}),
-                    ...(decision.action === "ask" && decision.probeReason !== undefined ? { probeReason: decision.probeReason } : {}),
-                    ...(decision.action === "ask" && decision.probeCause !== undefined ? { probeCause: decision.probeCause } : {}),
-                    ...(decision.action === "ask" && decision.ruleEvidence !== undefined ? { ruleEvidence: decision.ruleEvidence } : {}),
-                }, onAsk, composedCallSignal(callSignal), lateAskSettlementObserver({ toolName: req.toolName, toolCallId: req.toolCallId, sessionId, runId, ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), onNotice: deps.onNotice, onError: deps.onError }));
-                const waitMs = Math.max(0, now() - t0);
-                if (resolved.approverUnavailable !== true && resolved.resolution !== "task_aborted") {
-                    humanReviewRef.count += 1;
-                    humanReviewRef.totalWaitMs += waitMs;
-                    const toolArg = primaryActivityArg(req.args);
-                    humanReviewRef.gates.push({
-                        kind: "human",
-                        waitMs,
-                        decision: resolved.action === "allow" ? "allow" : "deny",
-                        toolName: req.toolName,
-                        ...(toolArg !== undefined ? { toolArg } : {}),
-                    });
-                }
-                if (resolved.action === "deny" && resolved.settledBy === "human" && resolved.humanRefusalNote !== true) {
-                    humanBareRejections.add(req.toolCallId);
-                }
-                return resolved;
-            };
-            const notifyPermissionDenied = createDenyObserverNotifier(hooks, hookTimeoutMs, abortController.signal, notifyOwnHookCrash);
-            const notifyHookError = (err) => {
-                try {
-                    deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
-                }
-                catch {
-                }
-            };
-            const inFlightSpendMicroUsd = () => {
-                const own = liveSpendRef.get?.().costMicroUsd ?? 0;
-                const seededNested = resume?.seed.nestedStats.costMicroUsd;
-                const nestedDelta = nestedStats.costMicroUsd - (typeof seededNested === "number" && Number.isFinite(seededNested) ? seededNested : 0);
-                return (Number.isFinite(own) ? own : 0) + Math.max(0, Number.isFinite(nestedDelta) ? nestedDelta : 0);
-            };
-            const repairBundleForCheckpoint = (parkedSpendMicroUsd) => {
-                const carried = internals?.repairBundle !== undefined
-                    ? structuredClone(internals.repairBundle)
-                    : resume?.seed.repairBundle !== undefined
-                        ? structuredClone(resume.seed.repairBundle)
-                        : undefined;
-                if (carried === undefined)
-                    return undefined;
-                if (parkedSpendMicroUsd === undefined || !Number.isFinite(parkedSpendMicroUsd) || parkedSpendMicroUsd <= 0)
-                    return carried;
-                const prior = typeof carried.spentMicroUsd === "number" && Number.isFinite(carried.spentMicroUsd) ? Math.max(0, carried.spentMicroUsd) : 0;
-                carried.spentMicroUsd = prior + parkedSpendMicroUsd;
-                return carried;
-            };
-            const screeningParkDisclosedRef = { done: false };
-            const serializeCheckpointState = (workspaceHandle, parkedSpendMicroUsd) => ({
-                activeTools: [...activeTools],
-                outputRef: { value: outputRef.value, set: outputRef.set },
-                nestedStats: { ...nestedStats },
-                consolidationNotes: undefined,
-                readFileState: readFileStateForCheckpoint ? [...readFileStateForCheckpoint.entries()] : undefined,
-                readFace: faceCheckpointSection(),
-                reminderMark,
-                repairBundle: repairBundleForCheckpoint(parkedSpendMicroUsd),
-                workspaceHandle,
-                handsCwd: handsCwdRef?.current,
-                activeWorktree: worktreeSessionRef?.current ? { ...worktreeSessionRef.current } : undefined,
-                runningBackgroundTasks: (() => {
-                    const live = defaultTaskRegistry
-                        .list({ owner: hostTaskId, scope: taskScope, sessionId })
-                        .filter((t) => t.status === "pending" || t.status === "running")
-                        .map((t) => ({ id: t.task_id, ...(t.description !== undefined ? { description: t.description } : {}) }));
-                    return live.length > 0 ? live : undefined;
-                })(),
-                pendingSteer: undefined,
-                pendingSteerQueue: undefined,
-                inheritedGate: (() => {
-                    const requiresParentConstraint = (inheritedParentConstraints?.length ?? 0) > 0 || seedInheritedGate?.requiresParentConstraint === true;
-                    const parentConstraintCount = (inheritedParentConstraints?.length ?? 0) > 0 ? inheritedParentConstraints.length : seedInheritedGate?.parentConstraintCount;
-                    const constraintChain = (inheritedParentConstraints?.length ?? 0) > 0
-                        ? inheritedParentConstraints.map((pc) => constraintChainEntryOfLayer(pc))
-                        : seedInheritedGate?.constraintChain;
-                    const constraintDigest = (inheritedParentConstraints?.length ?? 0) > 0
-                        ? constraintChainDigest(constraintChain)
-                        : seedInheritedGate?.constraintDigest;
-                    const autoModeIntentCarried = autoModeIntent && (autoModeDecider === undefined || autoModeLatchHealthy(autoModeDecider));
-                    return inheritedAncestorRules !== undefined ||
-                        inheritedShellGate !== undefined ||
-                        autoModeIntentCarried ||
-                        inheritedAdmittedOrgScopes !== undefined ||
-                        ownOrgVerdictRef.current !== undefined ||
-                        orgGovernedProvenance ||
-                        requiresParentConstraint
-                        ? {
-                            ...(inheritedAncestorRules !== undefined ? { ancestorRules: structuredClone(inheritedAncestorRules) } : {}),
-                            ...(inheritedShellGate !== undefined ? { shellGate: inheritedShellGate } : {}),
-                            ...(autoModeIntentCarried ? { autoModeRequested: true } : {}),
-                            ...(inheritedAdmittedOrgScopes !== undefined ? { admittedOrgScopes: [...inheritedAdmittedOrgScopes] } : {}),
-                            ...(ownOrgVerdictRef.current !== undefined
-                                ? { ownAdmittedOrgScopes: [...ownOrgVerdictRef.current.scopes], ownAdmittedOrgWriteScope: ownOrgVerdictRef.current.writeScope }
-                                : {}),
-                            ...(orgGovernedProvenance ? { orgAdmissionGoverned: true } : {}),
-                            requiresParentConstraint,
-                            ...(requiresParentConstraint && parentConstraintCount !== undefined ? { parentConstraintCount } : {}),
-                            ...(requiresParentConstraint && constraintChain !== undefined
-                                ? { constraintChain: structuredClone(constraintChain), ...(constraintDigest !== undefined ? { constraintDigest } : {}) }
-                                : {}),
-                        }
-                        : undefined;
-                })(),
-                announcedListings: serializeAnnouncedListings(announcedListingsRef),
-                gitAnnouncement: gitStatusRef.announced !== undefined ? { ...gitStatusRef.announced } : undefined,
-                delegationProvenance: internals?.delegationProvenance !== undefined ? { ...internals.delegationProvenance.ref.current } : undefined,
-                isDelegatedChild: hookIdentity.isDelegatedChild ? true : undefined,
-                placementRootSessionId: stampPlacementRootSessionId(placementRootResolved),
-                externalContentTarget: externalContentTargetActive ? true : undefined,
-            });
-            const compensatePausedVM = (remoteEnv, snapshotId) => compensateUnparkedPause(remoteEnv, snapshotId, {
-                boundMs: PARK_COMPENSATION_TIMEOUT_MS,
-                noteFailure: (note) => remoteEnvFailures.push(note),
-                disclose: (err) => {
-                    try {
-                        deps.onError?.(err, { phase: "config", sessionId });
-                    }
-                    catch {
-                    }
-                },
-            });
-            const commitSuspendSaga = async (token, cp, remoteEnv, remoteHandle, cutSignal) => {
-                if (!checkpointStore)
-                    return { tag: "absent" };
-                if (memoryEngineSession)
-                    await memoryEngineSession.harvest("checkpoint");
-                if (cutSignal?.aborted) {
-                    if (remoteEnv !== undefined && remoteHandle?.snapshotId !== undefined) {
-                        const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);
-                        if (!back.ok) {
-                            abortController.abort();
-                            void harness.abort();
-                            return { tag: "compensation_failed", reason: back.reason };
-                        }
-                    }
-                    return { tag: "cut" };
-                }
-                const announceCommittedScreeningPark = () => {
-                    const committedCount = cp.state.inheritedGate?.parentConstraintCount;
-                    if (cp.state.inheritedGate?.requiresParentConstraint === true &&
-                        !screeningParkDisclosedRef.done &&
-                        (inheritedParentConstraints ?? []).some((pc) => pc.preToolUse !== undefined)) {
-                        screeningParkDisclosedRef.done = true;
-                        try {
-                            deps.onError?.(new Error(`durable park under an inherited PreToolUse SCREENING constraint: this checkpoint records ` +
-                                `requiresParentConstraint with parentConstraintCount=${committedCount ?? "(unrecorded)"}, and the live ` +
-                                `closures cannot be persisted. A resume on THIS Runner re-supplies them automatically; a resume on a fresh ` +
-                                `Runner (restart / another replica) must hand back the whole chain via resumeStream(..., internals), ` +
-                                `rebuilding the screening entry with createPreToolUseConstraintPolicy(hook, env) — otherwise the row stays ` +
-                                `pending. If the face only observes, declare Hooks.preToolUseObservational and it stops entering the chain.`), { phase: "degraded", sessionId, classification: "screening-constraint-in-durable-chain" });
-                        }
-                        catch {
-                        }
-                    }
-                };
-                const confirmPutOutcome = async (putErr) => {
-                    if (putErr?.code === "checkpoint.already_exists")
-                        return "absent";
-                    try {
-                        const row = await checkpointStore.get(token);
-                        if (row == null)
-                            return "absent";
-                        const sameCall = (a, b) => a.kind === b.kind && (a.kind !== "tool_approval" || b.kind !== "tool_approval" || a.toolCallId === b.toolCallId);
-                        const isOurs = row.scope === cp.scope && row.sessionId === cp.sessionId && row.leafId === cp.leafId && sameCall(row.pendingAction, cp.pendingAction);
-                        return isOurs ? "committed" : "absent";
-                    }
-                    catch (readErr) {
-                        deps.onError?.(readErr, { phase: "config", sessionId });
-                        return "unknown";
-                    }
-                };
-                try {
-                    await checkpointStore.put(token, cp);
-                    announceCommittedScreeningPark();
-                    return { tag: "committed" };
-                }
-                catch (putErr) {
-                    deps.onError?.(putErr, { phase: "config", sessionId });
-                    const confirmed = await confirmPutOutcome(putErr);
-                    if (confirmed === "committed") {
-                        try {
-                            deps.onError?.(new Error(`durable approval checkpoint: the store's write reported a failure but the row EXISTS — the commit ` +
-                                `landed and its acknowledgement was lost (a network backend can complete the INSERT and drop the ` +
-                                `connection before replying). The run suspends on that row rather than continuing, which would leave ` +
-                                `a redeemable pending checkpoint behind. This backend's acknowledgement path is lossy — the operator ` +
-                                `face carries the store's own message.`), { phase: "degraded", sessionId, classification: "checkpoint-put-confirmation-lost" });
-                        }
-                        catch {
-                        }
-                        announceCommittedScreeningPark();
-                        return { tag: "committed" };
-                    }
-                    if (confirmed === "unknown") {
-                        const unknownReason = "the approval checkpoint's state cannot be established (the store rejected the write and then could not be read back; a committed-but-unacknowledged row may exist) — the run is stopped rather than continued past an approval whose durable record is unknown";
-                        try {
-                            deps.onError?.(new Error(`durable approval checkpoint: ${unknownReason}`), {
-                                phase: "degraded",
-                                sessionId,
-                                classification: "checkpoint-put-outcome-unknown",
-                            });
-                        }
-                        catch {
-                        }
-                        abortController.abort();
-                        void harness.abort();
-                        return { tag: "unknown", reason: unknownReason };
-                    }
-                    const reason = "the approval checkpoint could not be persisted (the store rejected the write; the deployment's error face carries the store's own message)";
-                    if (remoteEnv !== undefined && remoteHandle?.snapshotId !== undefined) {
-                        const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);
-                        if (back.ok)
-                            return { tag: "absent", reason };
-                        abortController.abort();
-                        void harness.abort();
-                        return { tag: "compensation_failed", reason };
-                    }
-                    return { tag: "absent", reason };
-                }
-            };
-            const suspendLoopCapHit = (count, cap, detail) => {
-                if (cap === undefined)
-                    return false;
-                if (count + 1 <= cap)
-                    return false;
-                suspendLoopRef.hit = true;
-                abortController.abort();
-                void harness.abort();
-                try {
-                    deps.onError?.(new Error(`suspend loop: task already suspended ${count} time(s) (max ${cap}); refusing to suspend again${detail}`), { phase: "config", sessionId });
-                }
-                catch {
-                }
-                return true;
-            };
-            const suspendableEnv = ownedEnv !== undefined && isSuspendable(ownedEnv) ? ownedEnv : undefined;
-            const parkOnlyRemoteEnv = suspendableEnv === undefined && ownedEnv !== undefined && isRemoteExecutionEnv(ownedEnv) && incompleteSuspendAdapter === undefined
-                ? ownedEnv
-                : undefined;
-            const parkOnlyHandle = (env) => {
-                const { snapshotId: _lineage, ...identity } = env.workspaceHandle();
-                return { ...identity, restoreMode: "park_only" };
-            };
-            const mintResourceSuspend = async (reason, sliceSpend, hint) => {
-                const rs = spec.resourceSuspend;
-                if (!checkpointStore)
-                    return false;
-                const scope = rs?.scope ?? checkpointScopeOf(spec);
-                if (abortController.signal.aborted)
-                    return false;
-                if (suspendLoopCapHit(priorLedger?.sliceCount ?? 0, maxSlices, " (resource slice limit)"))
-                    return false;
-                const leafId = await session.getLeafId();
-                if (!leafId)
-                    return false;
-                if (abortController.signal.aborted)
-                    return false;
-                let remoteHandle;
-                if (suspendableEnv !== undefined) {
-                    if (hasBackgroundShell(suspendableEnv))
-                        await sweepBackgroundShells(suspendableEnv, defaultTaskRegistry);
-                    const snap = await suspendableEnv.suspendVM({ abortSignal: abortController.signal });
-                    if (!snap.ok) {
-                        remoteEnvFailures.push(remoteEnvFailureNote("suspendVM", snap.error, 1));
-                        deps.onError?.(new Error(`resource suspendVM failed (${snap.error.code}): ${snap.error.message}`, { cause: snap.error }), { phase: "config", sessionId });
-                        return false;
-                    }
-                    remoteHandle = { ...suspendableEnv.workspaceHandle(), snapshotId: snap.value };
-                }
-                else if (parkOnlyRemoteEnv !== undefined) {
-                    if (hasBackgroundShell(parkOnlyRemoteEnv) && spec.retainBackgroundProcesses !== true)
-                        await sweepBackgroundShells(parkOnlyRemoteEnv, defaultTaskRegistry);
-                    remoteHandle = parkOnlyHandle(parkOnlyRemoteEnv);
-                }
-                const token = mintCheckpointToken();
-                const gate = { kind: "resource_limit", reason, ...(hint !== undefined ? { resumeAfterMs: hint.resumeAfterMs } : {}) };
-                const resourceLedgerOut = debitLedger(priorLedger, sliceSpend, resourceTotal);
-                const mintedAt = Date.now();
-                const cp = {
-                    token,
-                    checkpointId: mintCheckpointId(),
-                    version: faceCheckpointState() ? FACE_CHECKPOINT_VERSION : f012CheckpointState() ? F012_CHECKPOINT_VERSION : orgAdmissionCheckpointState() ? ORG_ADMISSION_CHECKPOINT_VERSION : resourceLedgerOut.totalTokens !== undefined ? TOKEN_CHECKPOINT_VERSION : RESOURCE_CHECKPOINT_VERSION,
-                    scope,
-                    sessionId,
-                    leafId,
-                    gate,
-                    pendingAction: { kind: "resource_limit", reason },
-                    state: serializeCheckpointState(remoteHandle),
-                    status: "pending",
-                    createdAt: mintedAt,
-                    deadline: mintedAt + Math.max(sanitizedTtlMs(rs?.ttlMs) ?? DEFAULT_RESOURCE_TTL_MS, hint !== undefined ? hint.resumeAfterMs + USAGE_WINDOW_REAP_MARGIN_MS : 0),
-                    suspendCount: priorSuspendCount,
-                    humanReview: humanReviewRef.count > 0
-                        ? { count: humanReviewRef.count, totalWaitMs: humanReviewRef.totalWaitMs, gates: [...humanReviewRef.gates] }
-                        : undefined,
-                    resourceLedger: resourceLedgerOut,
-                    ...(spec.durableApproval !== undefined ? { durableApproval: { ...spec.durableApproval } } : {}),
-                    ...(spec.principal ? { principal: spec.principal } : {}),
-                };
-                if ((await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).tag !== "committed")
-                    return false;
-                publishCommittedSuspend({ suspendRef, reviewRef }, token, gate, scope, remoteHandle, cp.checkpointId, cp.pendingAction);
-                try {
-                    await sessions.pin?.(sessionId);
-                }
-                catch (pinErr) {
-                    deps.onError?.(pinErr, { phase: "config", sessionId });
-                }
-                harness.requestStopAfterTurn();
-                return true;
-            };
-            suspendForResource = resourceSuspendEligible ? mintResourceSuspend : undefined;
-            suspendForPlatformLimit = durableSuspendInfraReady ? mintResourceSuspend : undefined;
-            suspendForReview = checkpointStore
-                ? async (reason) => {
-                    if (!checkpointStore)
-                        return false;
-                    if (abortController.signal.aborted)
-                        return false;
-                    if (incompleteSuspendAdapter !== undefined) {
-                        try {
-                            deps.onError?.(new Error(`plan_review park skipped: the per-task execution env declares capabilities.suspendable but its adapter does not implement ${incompleteSuspendAdapter.join(" or ")}, so its workspace could not be restored on resume (the plan-review request was dropped; the run continues without pausing)`), { phase: "config", sessionId });
-                        }
-                        catch {
-                        }
-                        return false;
-                    }
-                    if (suspendLoopCapHit(suspendChainBase(), maxSuspends, " for a plan_review (likely a resume/restart loop)."))
-                        return false;
-                    const leafId = await session.getLeafId();
-                    if (!leafId) {
-                        try {
-                            deps.onError?.(new Error("plan_review park skipped: no committed session leaf (the plan-review request was dropped; the run continues without pausing)"), { phase: "config", sessionId });
-                        }
-                        catch {
-                        }
-                        return false;
-                    }
-                    if (abortController.signal.aborted)
-                        return false;
-                    let remoteHandle;
-                    if (suspendableEnv !== undefined) {
-                        if (hasBackgroundShell(suspendableEnv))
-                            await sweepBackgroundShells(suspendableEnv, defaultTaskRegistry);
-                        const snap = await suspendableEnv.suspendVM({ abortSignal: abortController.signal });
-                        if (!snap.ok) {
-                            remoteEnvFailures.push(remoteEnvFailureNote("suspendVM", snap.error, 1));
-                            deps.onError?.(new Error(`plan_review suspendVM failed (${snap.error.code}): ${snap.error.message}`, { cause: snap.error }), { phase: "config", sessionId });
-                            return false;
-                        }
-                        remoteHandle = { ...suspendableEnv.workspaceHandle(), snapshotId: snap.value };
-                    }
-                    else if (parkOnlyRemoteEnv !== undefined) {
-                        if (hasBackgroundShell(parkOnlyRemoteEnv) && spec.retainBackgroundProcesses !== true)
-                            await sweepBackgroundShells(parkOnlyRemoteEnv, defaultTaskRegistry);
-                        remoteHandle = parkOnlyHandle(parkOnlyRemoteEnv);
-                    }
-                    const token = mintCheckpointToken();
-                    const scope = checkpointScopeOf(spec);
-                    const gate = { kind: "plan_review", reason: reason ?? `plan review requested` };
-                    const reviewLedger = debitLedger(priorLedger, liveSpendRef.get?.() ?? { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: 0 }, resourceTotal, { countSlice: false });
-                    const mintedAt = Date.now();
-                    const cp = {
-                        token,
-                        checkpointId: mintCheckpointId(),
-                        version: faceCheckpointState() ? FACE_CHECKPOINT_VERSION : f012CheckpointState() ? F012_CHECKPOINT_VERSION : orgAdmissionCheckpointState() ? ORG_ADMISSION_CHECKPOINT_VERSION : reviewLedger.totalTokens !== undefined ? TOKEN_CHECKPOINT_VERSION : BINDING_CHECKPOINT_VERSION,
-                        scope,
-                        sessionId,
-                        leafId,
-                        gate,
-                        pendingAction: { kind: "plan_review" },
-                        state: serializeCheckpointState(remoteHandle, inFlightSpendMicroUsd()),
-                        status: "pending",
-                        createdAt: mintedAt,
-                        suspendedAt: now(),
-                        deadline: mintedAt + (sanitizedTtlMs(spec.durableApproval?.ttlMs) ?? DEFAULT_RESOURCE_TTL_MS),
-                        suspendCount: suspendChainBase() + 1,
-                        humanReview: humanReviewRef.count > 0
-                            ? { count: humanReviewRef.count, totalWaitMs: humanReviewRef.totalWaitMs, gates: [...humanReviewRef.gates] }
-                            : undefined,
-                        resourceLedger: reviewLedger,
-                        sourceTaskId: sessionId,
-                        ...(spec.principal ? { principal: spec.principal } : {}),
-                        ...(spec.durableApproval !== undefined ? { durableApproval: { ...spec.durableApproval } } : {}),
-                    };
-                    if ((await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).tag !== "committed")
-                        return false;
-                    publishCommittedSuspend({ suspendRef, reviewRef }, token, gate, scope, remoteHandle, cp.checkpointId, cp.pendingAction);
-                    try {
-                        await sessions.pin?.(sessionId);
-                    }
-                    catch (pinErr) {
-                        deps.onError?.(pinErr, { phase: "config", sessionId });
-                    }
-                    abortController.abort();
-                    void harness.abort();
-                    return true;
-                }
-                : undefined;
-            const resolveContentAsk = async (req, callSignal) => {
-                const contentAskSignal = composedCallSignal(callSignal);
-                if (!contentAskRoutable(req.toolCallId) || liveQuestionFace === undefined || mountedQuestionTool === undefined) {
-                    return { kind: "unavailable", parkDeclined: false };
-                }
-                const deliveryId = uuidv7();
-                const bindOutcome = (entry, questionsHash) => {
-                    if (contentAskBindings.size >= CONTENT_ASK_BINDING_CAP && !contentAskBindings.has(req.toolCallId))
-                        return;
-                    contentAskBindings.set(req.toolCallId, { ...entry, questionsHash, deliveryId });
-                };
-                const refuseBeforeDelivery = (code, presentedInput) => ({
-                    kind: "delivery_failure",
-                    code,
-                    ...(presentedInput !== undefined ? { presentedInput } : {}),
-                });
-                let retained;
-                let presented;
-                try {
-                    retained = structuredClone(req.args);
-                    presented = structuredClone(retained.questions);
-                }
-                catch {
-                    return refuseBeforeDelivery("question.malformed_request");
-                }
-                const retainedQuestionsHash = boundInputHashOf(retained.questions);
-                if (!Value.Check(mountedQuestionTool.parameters, retained) || validateAskQuestions(presented) !== undefined) {
-                    return refuseBeforeDelivery("question.malformed_request", retained);
-                }
-                if (contentAskBindings.size >= CONTENT_ASK_BINDING_CAP && !contentAskBindings.has(req.toolCallId)) {
-                    return { kind: "unavailable", parkDeclined: true };
-                }
-                if (contentAskSignal.aborted) {
-                    return { kind: "delivery_failure", code: "question.aborted", presentedInput: retained };
-                }
-                try {
-                    const facePromise = (async () => liveQuestionFace({
-                        toolCallId: req.toolCallId,
-                        questions: presented,
-                        ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
-                        sourceTaskId: sessionId,
-                        boundInputHash: boundInputHashOf(retained),
-                        deliveryId,
-                    }, contentAskSignal))();
-                    const settlement = await raceAbort(facePromise.then((outcome) => ({ tag: "outcome", outcome }), (error) => ({ tag: "threw", error })), contentAskSignal, () => ({ tag: "aborted" }));
-                    if (settlement.tag === "aborted") {
-                        void facePromise.then((late) => {
-                            if (classifyQuestionOutcome(late).shape !== "answered")
-                                return;
-                            lateStrandedAnswers.push({ deliveryId, toolCallId: req.toolCallId });
-                            discloseStrandedAnswers([{ deliveryId, toolCallId: req.toolCallId }], "the task had already ended when the answer arrived");
-                        }, () => undefined).catch(() => undefined);
-                    }
-                    if (settlement.tag === "outcome") {
-                        const outcome = settlement.outcome;
-                        const reading = classifyQuestionOutcome(outcome);
-                        if (reading.shape === "contradictory") {
-                            bindOutcome({ kind: "failed", error: new Error("the question channel returned a contradictory outcome (an unavailable answer)") }, retainedQuestionsHash);
-                            return { kind: "delivery_failure", code: "question.human_channel_failed", presentedInput: retained };
-                        }
-                        if (reading.shape === "unavailable")
-                            return { kind: "unavailable", parkDeclined: true, presentedInput: retained };
-                        const answerSnapshot = reading.answer;
-                        bindOutcome({ kind: "answered", answer: answerSnapshot }, retainedQuestionsHash);
-                        return { kind: "answered", presentedInput: retained };
-                    }
-                    const error = settlement.tag === "threw"
-                        ? settlement.error
-                        : Object.assign(new Error("the task ended while this question was still out"), { name: "AbortError" });
-                    bindOutcome({ kind: "failed", error }, retainedQuestionsHash);
-                    return {
-                        kind: "delivery_failure",
-                        code: settlement.tag === "aborted" || contentAskSignal.aborted ? "question.aborted" : "question.human_channel_failed",
-                        presentedInput: retained,
-                    };
-                }
-                catch (err) {
-                    bindOutcome({ kind: "failed", error: err }, retainedQuestionsHash);
-                    return { kind: "delivery_failure", code: "question.human_channel_failed", presentedInput: retained };
-                }
-            };
-            const suspendAsk = parkLaneArmed && checkpointStore !== undefined
-                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule, probeMandated, carry) => {
-                    const syncFirstEligible = req.toolName === ASK_USER_QUESTION_TOOL_NAME ? contentAskRoutable(req.toolCallId) : isLiveApproverSeat(onAsk);
-                    if (syncFirstEligible &&
-                        runtimeCaps?.forceDurableGate !== true &&
-                        liveFaceUnavailable !== true &&
-                        !inheritedUnavailableAsks.has(req.toolCallId)) {
-                        return undefined;
-                    }
-                    const cutSignal = composedCallSignal(carry?.signal);
-                    let token;
-                    let gate;
-                    let cp;
-                    let remoteHandle;
-                    const remoteEnv = suspendableEnv;
-                    try {
-                        const parked = tryCloneArgs(postHookArgs);
-                        if (!parked.ok) {
-                            throw new ParkRefusal(`the arguments of "${req.toolName}" cannot be captured onto an approval checkpoint (unclonable value: ${parked.reason}) — ` +
-                                `a durable approval row must hold an inert snapshot of exactly what a human approves and a resume executes`, { cause: parked.cause });
-                        }
-                        let backendFidelity;
-                        try {
-                            backendFidelity = resolveDeclaredFidelity(checkpointStore, "checkpointStore");
-                        }
-                        catch (err) {
-                            throw new ParkRefusal(`the checkpoint backend declares an unrecognized encoding fidelity, so the width of the snapshot this row may hold is unknown (${describeThrown(err)}) — ` +
-                                `refusing to park rather than guess which values would survive it`, { cause: err });
-                        }
-                        const captured = encodeAtFidelity(backendFidelity, parked.value);
-                        if (!captured.ok) {
-                            throw new ParkRefusal(`the arguments of "${req.toolName}" cannot be encoded by this checkpoint backend (${describeThrown(captured.cause)}) — ` +
-                                `a durable approval row must hold an inert snapshot of exactly what a human approves and a resume executes`, { cause: captured.cause });
-                        }
-                        const parkedArgs = captured.value;
-                        const projectionMovedArgs = backendFidelity !== "structured-clone" && !samePlainValue(parked.value, parkedArgs);
-                        if (projectionMovedArgs && basePolicyForResumeEdit === undefined) {
-                            throw new ParkRefusal(`the arguments of "${req.toolName}" change shape when stored by this checkpoint backend, and no policy is wired to re-adjudicate the stored shape ` +
-                                `(no basePolicyForResumeEdit override and no caller toolPolicy) — refusing to file a row whose executable form nothing adjudicated`);
-                        }
-                        if (projectionMovedArgs && basePolicyForResumeEdit !== undefined) {
-                            const presented = encodeAtFidelity(backendFidelity, parkedArgs);
-                            if (!presented.ok) {
-                                throw new ParkRefusal(`the stored form of "${req.toolName}"'s arguments could not be presented for re-adjudication (${describeThrown(presented.cause)})`, { cause: presented.cause });
-                            }
-                            const reprojectedRaced = await raceSettlementAgainstSignal(Promise.resolve(basePolicyForResumeEdit.check({
-                                toolName: req.toolName,
-                                args: presented.value,
-                                toolCallId: req.toolCallId,
-                                budget: budgetSnapshot,
-                                ...(handsCwdRef !== undefined ? { cwd: handsCwdRef.current } : {}),
-                            }, cutSignal)), cutSignal);
-                            if (reprojectedRaced.tag === "aborted")
-                                return undefined;
-                            if (reprojectedRaced.tag === "threw")
-                                throw reprojectedRaced.error;
-                            const reprojected = refuseOutOfContractDecision(reprojectedRaced.value);
-                            const demanded = reprojected.updatedInput !== undefined ? tryCloneArgs(reprojected.updatedInput) : undefined;
-                            const rewroteTheFiledValue = reprojected.updatedInput !== undefined &&
-                                !(demanded?.ok === true &&
-                                    samePlainValue(demanded.value, parkedArgs) &&
-                                    samePlainValue(reprojected.updatedInput, parkedArgs));
-                            if (reprojected.action === "deny" || rewroteTheFiledValue) {
-                                throw new ParkRefusal(`the arguments of "${req.toolName}" change shape when stored by this checkpoint backend, and the deployment's tool policy does not accept the stored shape` +
-                                    `${reprojected.action === "deny" && reprojected.message ? `: ${reprojected.message}` : ""} — ` +
-                                    `refusing to file a row whose executable form nothing adjudicated`);
-                            }
-                        }
-                        if (offloadStore && isVolatileOffloadStore(offloadStore) && !offloadStore.isEmpty()) {
-                            throw new ParkRefusal("durable suspend requires a durable toolResultStore (the default InMemoryToolResultStore " +
-                                "holds offloaded results that are lost across a cross-replica resume); inject " +
-                                "RunnerDeps.toolResultStore or disable offload.");
-                        }
-                        if (ownedEnv !== undefined && remoteEnv === undefined && parkOnlyRemoteEnv === undefined) {
-                            throw new ParkRefusal(incompleteSuspendAdapter !== undefined
-                                ? `durable suspend is not supported with this per-task executionEnvFactory env: it declares capabilities.suspendable but its adapter does not implement ${incompleteSuspendAdapter.join(" or ")}, so a snapshot taken now could never be restored. Implement the full RemoteExecutionEnv restore surface, or declare capabilities.suspendable:false if the workspace is externally durable (the park-only lane).`
-                                : "durable suspend is not supported with a non-remote per-task executionEnvFactory env: the " +
-                                    "minted env is destroyed on suspend, so a resumed file/shell tool would act on a fresh " +
-                                    "(empty) env. Use a RemoteExecutionEnv factory (it is paused, not destroyed) or a static, " +
-                                    "caller-owned RunnerDeps.executionEnv.");
-                        }
-                        const leafId = await session.getLeafId();
-                        if (!leafId) {
-                            throw new ParkRefusal("cannot suspend: session has no committed leaf to resume from");
-                        }
-                        const { messages } = await session.buildContext();
-                        const { batchToolCallIds, completedCallIds } = batchContextAt(messages, req.toolCallId);
-                        if (cutSignal.aborted) {
-                            return undefined;
-                        }
-                        if (suspendLoopCapHit(suspendChainBase(), maxSuspends, ` for tool "${req.toolName}" — likely a resume/restart loop.`))
-                            return undefined;
-                        if (remoteEnv !== undefined) {
-                            if (hasBackgroundShell(remoteEnv))
-                                await sweepBackgroundShells(remoteEnv, defaultTaskRegistry);
-                            const snap = await remoteEnv.suspendVM({ abortSignal: cutSignal });
-                            if (!snap.ok) {
-                                remoteEnvFailures.push(remoteEnvFailureNote("suspendVM", snap.error, 1));
-                                throw new Error(`suspendVM failed (${snap.error.code}): ${snap.error.message}`, { cause: snap.error });
-                            }
-                            remoteHandle = { ...remoteEnv.workspaceHandle(), snapshotId: snap.value };
-                            if (cutSignal.aborted) {
-                                const back = await compensatePausedVM(remoteEnv, snap.value);
-                                if (!back.ok) {
-                                    abortController.abort();
-                                    void harness.abort();
-                                }
-                                return undefined;
-                            }
-                        }
-                        else if (parkOnlyRemoteEnv !== undefined) {
-                            if (hasBackgroundShell(parkOnlyRemoteEnv) && spec.retainBackgroundProcesses !== true)
-                                await sweepBackgroundShells(parkOnlyRemoteEnv, defaultTaskRegistry);
-                            remoteHandle = parkOnlyHandle(parkOnlyRemoteEnv);
-                        }
-                        token = mintCheckpointToken();
-                        const riskDescriptor = buildRiskDescriptor({
-                            toolName: req.toolName,
-                            args: parkedArgs,
-                            safety,
-                            ...(shadowedRule !== undefined ? { shadowedRule } : {}),
-                            ...(probeReason !== undefined ? { probeReason } : {}),
-                            ...(probeCause !== undefined ? { probeCause } : {}),
-                            shellGated: (req.toolName === "Bash" && shellGatedBash) || (req.toolName === "Monitor" && shellGatedMonitor),
-                            ...(effectiveShellGate !== "off" ? { shellGateDoctrine: effectiveShellGate } : {}),
-                        });
-                        gate =
-                            safety !== undefined || realApproval !== undefined
-                                ? {
-                                    kind: "irreversible_ask",
-                                    reason: safety !== undefined
-                                        ? `human approval required before safety-tightened tool "${req.toolName}"`
-                                        : `real human approval required for tool "${req.toolName}" (non-budgetable: ${realApproval.origin})`,
-                                    toolName: req.toolName,
-                                    ...(safety !== undefined ? { safetyAxis: safety } : {}),
-                                    ...(realApproval !== undefined ? { realApproval } : {}),
-                                    riskDescriptor,
-                                }
-                                : durableApproval
-                                    ? {
-                                        kind: "human",
-                                        reason: `human approval required for tool "${req.toolName}"`,
-                                        toolName: req.toolName,
-                                        riskDescriptor,
-                                    }
-                                    : {
-                                        kind: "irreversible_ask",
-                                        reason: `human approval required before irreversible tool "${req.toolName}"`,
-                                        toolName: req.toolName,
-                                        riskDescriptor,
-                                    };
-                        const scope = durableApproval?.scope || checkpointScopeOf({ principal: spec.principal });
-                        const ttlMs = sanitizedTtlMs(durableApproval?.ttlMs);
-                        const checkpointState = serializeCheckpointState(remoteHandle, inFlightSpendMicroUsd());
-                        if (realApproval !== undefined && checkpointState.readFace !== undefined) {
-                            checkpointState.readFace = { ...checkpointState.readFace, realApproval: true };
-                        }
-                        const approvalLedger = debitLedger(priorLedger, liveSpendRef.get?.() ?? { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: 0 }, resourceTotal, { countSlice: false });
-                        const mintedAt = Date.now();
-                        cp = {
-                            token,
-                            checkpointId: mintCheckpointId(),
-                            version: faceCheckpointState() ? FACE_CHECKPOINT_VERSION : realApproval !== undefined ? REAL_APPROVAL_CHECKPOINT_VERSION : f012CheckpointState() ? F012_CHECKPOINT_VERSION : orgAdmissionCheckpointState() ? ORG_ADMISSION_CHECKPOINT_VERSION : approvalLedger.totalTokens !== undefined ? TOKEN_CHECKPOINT_VERSION : BINDING_CHECKPOINT_VERSION,
-                            scope,
-                            sessionId,
-                            leafId,
-                            gate,
-                            pendingAction: {
-                                kind: "tool_approval",
-                                toolCallId: req.toolCallId,
-                                toolName: req.toolName,
-                                args: parkedArgs,
-                                ...(() => {
-                                    const p = approvalPreviewOf(req.toolName, parkedArgs);
-                                    const bidi = carriesBidiControls(parkedArgs) || carriesBidiControls(p.preview);
-                                    return {
-                                        ...(p.preview !== undefined ? { preview: p.preview } : {}),
-                                        ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}),
-                                        ...(bidi ? { hasBidiControls: true } : {}),
-                                    };
-                                })(),
-                                ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
-                                ...askCarryRowMembers(carry),
-                                ...ruleOffersOf(req.toolName, parkedArgs, {
-                                    ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
-                                    ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
-                                    ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
-                                    ...(matchedAskRule !== undefined ? { matchedAskRule } : {}),
-                                    ...(probeMandated === true ? { probeMandated: true } : {}),
-                                    ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
-                                    ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
-                                }),
-                                boundInputHash: boundInputHashOf(parkedArgs),
-                                batchToolCallIds,
-                                completedCallIds,
-                            },
-                            state: checkpointState,
-                            deadline: ttlMs !== undefined
-                                ? mintedAt + ttlMs
-                                : durableApproval !== undefined
-                                    ? undefined
-                                    : mintedAt + DEFAULT_UNATTENDED_APPROVAL_TTL_MS,
-                            status: "pending",
-                            createdAt: mintedAt,
-                            suspendedAt: now(),
-                            humanReview: humanReviewRef.count > 0
-                                ? { count: humanReviewRef.count, totalWaitMs: humanReviewRef.totalWaitMs, gates: [...humanReviewRef.gates] }
-                                : undefined,
-                            suspendCount: suspendChainBase() + 1,
-                            resourceLedger: approvalLedger,
-                            sourceTaskId: sessionId,
-                            ...(spec.principal ? { principal: spec.principal } : {}),
-                            ...(durableApproval !== undefined ? { durableApproval: { ...durableApproval } } : {}),
-                        };
-                    }
-                    catch (err) {
-                        const cutWon = cutSignal.aborted;
-                        const preselected = cutWon
-                            ? undefined
-                            : {
-                                parkFailed: err instanceof ParkRefusal
-                                    ? err.message
-                                    : "the durable approval park could not be prepared (the deployment's error face carries the exception)",
-                            };
-                        try {
-                            deps.onError?.(err, { phase: "config", sessionId });
-                        }
-                        catch {
-                        }
-                        return preselected;
-                    }
-                    const committed = await commitSuspendSaga(token, cp, remoteEnv, remoteHandle, cutSignal);
-                    if (committed.tag !== "committed") {
-                        if (committed.tag === "cut")
-                            return undefined;
-                        if (committed.tag === "absent") {
-                            if (cutSignal.aborted)
-                                return undefined;
-                            return committed.reason !== undefined ? { parkFailed: committed.reason } : undefined;
-                        }
-                        return { parkFailed: committed.reason };
-                    }
-                    publishCommittedSuspend({ suspendRef, reviewRef }, token, gate, cp.scope, remoteHandle, cp.checkpointId, cp.pendingAction);
-                    try {
-                        await sessions.pin?.(sessionId);
-                    }
-                    catch (pinErr) {
-                        deps.onError?.(pinErr, { phase: "config", sessionId });
-                    }
-                    abortController.abort();
-                    void harness.abort();
-                    return { token, gate };
-                }
-                : undefined;
-            for (const t of tools) {
-                const eff = t.effect;
-                if (eff !== undefined && !toolEffects.has(t.name))
-                    toolEffects.set(t.name, eff);
-            }
-            const writeProtectionCheck = createWriteProtectionCheck(deps.writeProtectedPaths, deps.memoryEngineDir !== undefined ? { dataRoot: deps.memoryEngineDir } : undefined);
-            const writeProtectionArmed = writeProtectionCheck !== undefined && tools.some((t) => PATH_CONFINABLE_WRITE_TOOLS.has(t.name));
-            toolCallGateArmedRef.armed =
-                effectivePolicy !== undefined ||
-                    hooks?.preToolUse !== undefined ||
-                    egressTools.size > 0 ||
-                    irreversibleTools.size > 0 ||
-                    spec.enablePlanMode === true ||
-                    complianceDenies.has("web_fetch") ||
-                    writeProtectionArmed;
-            if (toolCallGateArmedRef.armed) {
-                harness.on("tool_call", async (e) => {
-                    blockedToolCalls.delete(e.toolCallId);
-                    inheritedAskGrants.delete(e.toolCallId);
-                    humanBareRejections.delete(e.toolCallId);
-                    {
-                        const complianceDeny = complianceCallDenial(complianceDenies, e.toolName);
-                        if (complianceDeny !== undefined) {
-                            if (blockedTracked)
-                                blockedToolCalls.add(e.toolCallId);
-                            if (notifyPermissionDenied) {
-                                await notifyPermissionDenied({ toolName: e.toolName, input: cloneObserverInput(e.input), toolCallId: e.toolCallId, reason: complianceDeny, source: "safety", identity: hookIdentity });
-                            }
-                            return { block: true, reason: formatHookFeedback(complianceDeny, reminderMark), preToolContext: [] };
-                        }
-                    }
-                    if (planModeRef.active && (toolEffects.get(e.toolName) ?? "write") !== "read") {
-                        if (blockedTracked)
-                            blockedToolCalls.add(e.toolCallId);
-                        const planDenyReason = `Plan mode is active — "${e.toolName}" is a write/mutating tool and is read-only-blocked. ` +
-                            `Research with read-only tools, then call ${PRESENT_PLAN_TOOL_NAME} with your plan to get it approved before acting.`;
-                        if (notifyPermissionDenied) {
-                            await notifyPermissionDenied({ toolName: e.toolName, input: cloneObserverInput(e.input), toolCallId: e.toolCallId, reason: planDenyReason, source: "planMode", identity: hookIdentity });
-                        }
-                        return {
-                            block: true,
-                            reason: formatHookFeedback(planDenyReason, reminderMark),
-                            preToolContext: [],
-                        };
-                    }
-                    let result;
-                    let humanBareRejection = false;
-                    try {
-                        result = await runToolGate({
-                            onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: hostTaskId, site: f.site, message: f.error.message, ts: Date.now() })),
-                            event: e,
-                            ...(e.signal !== undefined ? { callSignal: e.signal } : {}),
-                            identity: hookIdentity,
-                            reminderMark,
-                            preToolUse: ownGatePreToolUse,
-                            hookTimeoutMs,
-                            ...(handsCwdRef !== undefined ? { trackedCwd: () => handsCwdRef.current } : {}),
-                            ...(hookEnvFace !== undefined ? { hookEnv: hookEnvFace } : {}),
-                            adjudicate,
-                            resolveAsk: resolveAskBound,
-                            suspendAsk,
-                            resolveContentAsk,
-                            egress: egressTools.has(e.toolName),
-                            peerMessage: e.toolName === SEND_MESSAGE_TOOL_NAME,
-                            ...(writeProtectionCheck !== undefined ? { writeProtectionCheck } : {}),
-                            irreversibility: irreversibilityTier.get(e.toolName),
-                            reversibilityProbe: reversibilityProbes.get(e.toolName),
-                            abortSignal: abortController.signal,
-                            ...(notifyPermissionDenied ? { permissionDenied: notifyPermissionDenied } : {}),
-                            onHookError: notifyHookError,
-                            shellGated: (e.toolName === "Bash" && shellGatedBash) || (e.toolName === "Monitor" && shellGatedMonitor),
-                            ...(autoModeDecider ? { autoMode: { decider: autoModeDecider, ...(autoModeDenialTracking !== undefined ? { denialTracking: autoModeDenialTracking } : {}) } } : {}),
-                            onHeadlessDenialLimit: stopForDenialLimit,
-                            ...(permissionRuleLane
-                                ? {
-                                    persistedRules: {
-                                        admits: permissionRuleLane.admits,
-                                        onResolved: (info) => emitTrace(deps.tracer, () => ({
-                                            kind: "permission.persisted_rule_allowed",
-                                            version: 2,
-                                            taskId: hostTaskId,
-                                            toolName: info.toolName,
-                                            toolCallId: info.toolCallId,
-                                            rules: [...info.rules],
-                                            ts: Date.now(),
-                                        })),
-                                    },
-                                }
-                                : {}),
-                            ...(permissionRuleOrgLane
-                                ? {
-                                    orgRules: {
-                                        adjudicate: permissionRuleOrgLane.adjudicate,
-                                        contentAskToolMounted: questionToolMounted,
-                                        onUnavailable: (info) => emitTrace(deps.tracer, () => ({
-                                            kind: "permission.org_snapshot_unavailable",
-                                            version: 1,
-                                            taskId: hostTaskId,
-                                            toolName: info.toolName,
-                                            toolCallId: info.toolCallId,
-                                            message: info.message,
-                                            ts: Date.now(),
-                                        })),
-                                    },
-                                }
-                                : {}),
-                            isMarkedUnresolvable: (toolCallId) => inheritedUnavailableAsks.has(toolCallId),
-                            ...(sandboxAdmissionArmed
-                                ? {
-                                    sandboxAdmission: {
-                                        askClassesOf: (toolCallId) => foldAskClasses.get(toolCallId),
-                                        boundaryCapable: sandboxBoundaryCapable(e.toolName),
-                                        onAdmitted: emitSandboxAdmitted,
-                                    },
-                                }
-                                : {}),
-                        });
-                    }
-                    finally {
-                        inheritedUnavailableAsks.delete(e.toolCallId);
-                        inheritedAskGrants.delete(e.toolCallId);
-                        foldAskClasses.delete(e.toolCallId);
-                        humanBareRejection = humanBareRejections.delete(e.toolCallId);
-                    }
-                    const ancestorAdmitted = ancestorSandboxAdmissions.get(e.toolCallId);
-                    ancestorSandboxAdmissions.delete(e.toolCallId);
-                    if (ancestorAdmitted !== undefined && !result.block && !result.suspend) {
-                        emitSandboxAdmitted({ toolCallId: e.toolCallId, toolName: e.toolName, askClasses: ancestorAdmitted, boundary: "sandbox_internal" });
-                        result.preToolContext.push(`permission.sandbox_admitted: this call's inherited pending approval was auto-admitted because the deployment declares an isolated sandbox execution env and the request stays inside it. Recorded for audit.`);
-                    }
-                    if (!result.block && !result.suspend && result.preToolContext.length > 0) {
-                        preToolContexts.set(e.toolCallId, result.preToolContext);
-                    }
-                    if (blockedTracked && (result.block || result.suspend)) {
-                        blockedToolCalls.add(e.toolCallId);
-                    }
-                    const settlement = screenGateSettlement(result, result.block === true);
-                    for (const defect of settlement.defects)
-                        deps.onError?.(new Error(defect), { phase: "config", sessionId });
-                    if (settlement.record !== undefined)
-                        approvalSettlement.set(e.toolCallId, settlement.record);
-                    if (result.block) {
-                        const haltRemaining = maybeHumanRejectionHalt({
-                            bare: humanBareRejection,
-                            settledBy: result.settledBy,
-                            isDelegatedChild: delegation.isDelegatedChild === true,
-                            toolName: e.toolName,
-                            toolCallId: e.toolCallId,
-                        });
-                        if (haltRemaining !== undefined) {
-                            batchHaltRef.current = { rejectedToolCallId: e.toolCallId };
-                            return { block: true, reason: result.reason, haltRemaining };
-                        }
-                        return { block: true, reason: result.reason };
-                    }
-                    return result.updatedInput !== undefined ? { updatedInput: result.updatedInput } : undefined;
-                });
-            }
-        }
-        if (hooks?.postToolUse || hooks?.preToolUse || hooks?.postToolUseFailure) {
-            harness.on("tool_result", async (e) => {
-                if (blockedToolCalls.delete(e.toolCallId)) {
-                    return undefined;
-                }
-                let content = e.content;
-                let changed = false;
-                if (e.isError) {
-                    if (hooks?.postToolUseFailure) {
-                        let clonedDetails = e.details;
-                        try {
-                            clonedDetails = structuredClone(e.details);
-                        }
-                        catch {
-                        }
-                        const failureSeat = await runHookSeat("postToolUseFailure", { timeoutMs: hookTimeoutMs, signal: abortController.signal }, (sig) => hooks.postToolUseFailure(e.toolName, e.input, {
-                            error: e.content
-                                .filter((c) => c.type === "text")
-                                .map((c) => c.text)
-                                .join("\n"),
-                            isInterrupt: abortController.signal.aborted || spec.signal?.aborted === true,
-                            content: e.content.map((c) => ({ ...c })),
-                            details: clonedDetails,
-                        }, { toolCallId: e.toolCallId, toolName: e.toolName, signal: sig, ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}), ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}), identity: hookIdentity }));
-                        if (failureSeat.expired) {
-                            notifyOwnHookCrash(hookSeatExpiredError("postToolUseFailure", hookTimeoutMs, failureSeat.cause, "the observation was abandoned and its additionalContext dropped; the failure result itself is unchanged"));
-                        }
-                        const patch = failureSeat.expired ? undefined : failureSeat.value;
-                        if (patch?.additionalContext) {
-                            content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
-                            changed = true;
-                        }
-                    }
-                }
-                else if (hooks?.postToolUse) {
-                    const successSeat = await runHookSeat("postToolUse", { timeoutMs: hookTimeoutMs, signal: abortController.signal }, (sig) => hooks.postToolUse(e.toolName, e.input, { content: e.content, details: e.details, isError: e.isError }, { toolCallId: e.toolCallId, toolName: e.toolName, signal: sig, ...(handsCwdRef?.current !== undefined ? { cwd: handsCwdRef.current } : {}), ...(hookEnvFace !== undefined ? { env: hookEnvFace } : {}), identity: hookIdentity }));
-                    if (successSeat.expired) {
-                        notifyOwnHookCrash(hookSeatExpiredError("postToolUse", hookTimeoutMs, successSeat.cause, "the seat was abandoned; the tool result is delivered to the model UNMODIFIED (no updatedOutput, no additionalContext)"));
-                    }
-                    const patch = successSeat.expired ? undefined : successSeat.value;
-                    if (patch?.updatedOutput) {
-                        content = patch.updatedOutput;
-                        changed = true;
-                    }
-                    if (patch?.additionalContext) {
-                        content = [...content, { type: "text", text: formatHookFeedback(patch.additionalContext, reminderMark) }];
-                        changed = true;
-                    }
-                }
-                const pre = preToolContexts.get(e.toolCallId);
-                if (pre) {
-                    preToolContexts.delete(e.toolCallId);
-                    content = [...content, ...pre.map((t) => ({ type: "text", text: formatHookFeedback(t, reminderMark) }))];
-                    changed = true;
-                }
-                return changed ? { content } : undefined;
-            });
-        }
-        const editAt = editBudget(model);
-        const guardAt = guardBudget(model);
-        const microCompact = buildMicroCompactState(deps, model, sessionId, runId, offloadStore, microCompactKnob);
-        const charsPerToken = model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
-        harness.on("context", async ({ messages, recheck, signal }) => {
-            batchHaltRef.current = undefined;
-            const pendingProjectionObservations = [];
-            try {
-                const healed = dropEmptyFailureAssistants(messages);
-                const replay = replayClearedProjection(healed, microCompact.ledger);
-                const replayed = replay.messages;
-                const capped = await capAggregateToolResults(replayed, {
-                    store: offloadStore,
-                    sessionId,
-                    onCapped: (info) => pendingProjectionObservations.push(() => emitTrace(deps.tracer, () => ({
-                        kind: "tool_result.capped",
-                        version: 1,
-                        taskId: hostTaskId,
-                        ...(info.tool !== undefined ? { tool: info.tool } : {}),
-                        sizeChars: info.sizeChars,
-                        storeFallback: info.storeFallback,
-                        ts: Date.now(),
-                    }))),
-                });
-                const mediaCapped = capAggregateMediaBytes(capped, {
-                    limitBytes: deps.mediaByteCapBytes ?? AGGREGATE_MEDIA_BUDGET_BYTES,
-                    onStripped: (info) => {
-                        const onMediaStripped = deps.onMediaStripped;
-                        if (onMediaStripped !== undefined)
-                            pendingProjectionObservations.push(() => onMediaStripped(info));
-                    },
-                });
-                let ccPass;
-                const edited = microCompact.machine === "off" ? mediaCapped : clearStaleToolResults(mediaCapped, {
-                    budgetTokens: editAt,
-                    machine: microCompact.machine,
-                    ...(microCompact.machine === "cc" || microCompact.clearOnRejection ? { recognizeCcMarkers: true } : {}),
-                    ...(microCompact.machine === "cc"
-                        ? {
-                            clearSource: replayed,
-                            onCleared: (pass) => { ccPass = pass; },
-                        }
-                        : {}),
-                    anchoredTotalTokens: estimateContextTokens(mediaCapped, charsPerToken).tokens,
-                    charsPerToken,
-                    ...(offloadStore
-                        ? {
-                            offload: {
-                                persist: createOffloadPersist(offloadStore, sessionId, deps.onNotice),
-                            },
-                        }
-                        : {}),
-                });
-                if (ccPass !== undefined) {
-                    recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: hostTaskId, trigger: "frontier" });
-                }
-                const chain = await runGuardChain({
-                    edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken, offloadStore,
-                    sessionId, taskId: hostTaskId, deps, trimPressureRef, recheck, signal,
-                    pendingProjectionObservations,
-                });
-                if ("earlyReturn" in chain) {
-                    return chain.earlyReturn;
-                }
-                const { working, trimDroppedMessages } = chain;
-                let trimmed = chain.trimmed;
-                trimmed = applyGitFrameGuard({
-                    before: working,
-                    trimmed,
-                    budgetTokens: guardAt,
-                    ref: gitStatusRef,
-                    charsPerToken,
-                    onDegrade: (message) => {
-                        try {
-                            deps.onError?.(new Error(message), { phase: "degraded", sessionId, classification: "env-git-snapshot" });
-                        }
-                        catch {
-                        }
-                    },
-                });
-                const swept = dropOrphanToolResults(trimmed);
-                if (swept.dropped.length > 0) {
-                    try {
-                        deps.onError?.(new Error(`context belt: dropped ${swept.dropped.length} orphan toolResult(s) whose tool-call assistant was not in the request view — ` +
-                            swept.dropped
-                                .map((d) => `toolCallId=${d.toolCallId} at index ${d.index} (prev=${d.prevRole}, next=${d.nextRole})`)
-                                .join("; ")), { phase: "hook", sessionId });
-                    }
-                    catch {
-                    }
-                }
-                requestLossyRef.current =
-                    replayed !== healed ||
-                        capped !== replayed ||
-                        mediaCapped !== capped ||
-                        edited !== mediaCapped ||
-                        working !== edited ||
-                        trimDroppedMessages ||
-                        swept.dropped.length > 0 ||
-                        gitStatusRef.overBudgetShrunk === true;
-                microCompact.projectionRef.current = { messages: swept.messages, keyOf: replay.index.keyOf };
-                return { messages: swept.messages };
-            }
-            finally {
-                flushProjectionObservations(pendingProjectionObservations);
-            }
-        });
-        const cacheBreakDetector = deps.cacheBreakDetection === false ? undefined : new CacheBreakDetector();
-        const cacheFingerprint = cacheBreakDetector
-            ? { systemPrompt, tools: toolsToFingerprintInputs(harnessTools) }
-            : undefined;
-        fpRef.current = cacheFingerprint;
-        const turnSnapshot = buildTurnPromptSnapshot({
-            provider: model.provider,
-            modelId: model.id,
-            artifactDigest: epochArtifactDigestForSnapshot,
-            promptProfile,
-            fableMitigations,
-            layoutGroups: (assembled.systemBlocks ?? [{ groupId: "body", cacheControlBoundary: true }]).map((b) => ({ groupId: b.groupId, cacheControlBoundary: b.cacheControlBoundary })),
-            stableSystemText: systemPrompt,
-            toolWire: toolsToFingerprintInputs(harnessTools),
-            thinkingLevel: (thinking ?? "off"),
-            maxTokens: model.maxTokens,
-            hasOutputSchema: spec.outputSchema !== undefined,
-            sessionId,
-            taskId: spec.taskId,
-        }, model.api, (text) => `salted:${createHash("sha256").update(PROMPT_HASH_SALT).update(text).digest("hex")}`);
-        turnSnapshotRef.current = turnSnapshot;
-        promptManifest.snapshot = { cacheIdentity: turnSnapshot.cacheIdentity, elements: { ...turnSnapshot.elements } };
-        promptManifest.lowering = turnSnapshot.lowering;
-        const promptOverheadTokens = Math.ceil((systemPrompt.length +
-            harnessTools.reduce((a, t) => a + t.name.length + (t.description?.length ?? 0) + JSON.stringify(t.parameters ?? {}).length, 0)) / charsPerToken);
-        const announceAttachmentSkip = (path, reason) => {
-            deps.onError?.(new Error(`working-file attachment skipped — ${path}: ${reason}`), {
-                phase: "degraded",
-                sessionId,
-                classification: "attachment-read",
-            });
-        };
-        const readTaskFile = handsEnabled
-            ? async (path) => {
-                try {
-                    let key = path;
-                    if (attachmentRootCanonical !== undefined) {
-                        const rk = await resolveKey(executionEnv, attachmentRootCanonical, path, undefined, undefined, [...additionalRootsCanonical, ...additionalReadRootsCanonical], undefined, readDenyMatcher, resolvedReadFace);
-                        if (!rk.ok) {
-                            announceAttachmentSkip(path, rk.violation.message);
-                            if (rk.violation.code === "read_path_denied" && rk.violation.pattern !== undefined) {
-                                return { withheld: { pattern: rk.violation.pattern } };
-                            }
-                            return null;
-                        }
-                        key = rk.key;
-                    }
-                    const r = await executionEnv.readBinaryFile(key);
-                    if (!r.ok) {
-                        announceAttachmentSkip(path, r.error.message);
-                        return null;
-                    }
-                    const d = decodeTextBytes(r.value);
-                    if (d.malformed) {
-                        announceAttachmentSkip(path, "malformed text encoding (truncated UTF-16 body)");
-                        return null;
-                    }
-                    return d.text;
-                }
-                catch (err) {
-                    announceAttachmentSkip(path, err instanceof Error ? err.message : String(err));
-                    return null;
-                }
-            }
-            : undefined;
-        const normalizeAttachmentPath = handsEnabled
-            ? async (path) => {
-                if (attachmentRootCanonical === undefined)
-                    return path;
-                try {
-                    const rk = await resolveKey(executionEnv, attachmentRootCanonical, path, undefined, handsCwdRef?.current, [...additionalRootsCanonical, ...additionalReadRootsCanonical], undefined, undefined, resolvedReadFace);
-                    return rk.ok ? rk.key : path;
-                }
-                catch {
-                    return path;
-                }
-            }
-            : undefined;
-        const isDedupStubResult = handsEnabled ? isReadDedupStubResult : undefined;
-        const recentlyReadFiles = handsEnabled && readFileStateForCheckpoint
-            ? () => [...readFileStateForCheckpoint.entries()]
-                .filter(([, v]) => v.seededFromContext !== true)
-                .sort((a, b) => (b[1].lastReadAt ?? 0) - (a[1].lastReadAt ?? 0))
-                .map(([path]) => path)
-            : undefined;
-        const onCompactionApplied = handsEnabled && readFileStateForCheckpoint
-            ? (attachedComplete, preserveReadState) => applyCompactionToReadFileState(readFileStateForCheckpoint, attachedComplete, preserveReadState)
-            : undefined;
-        const changedFilesReadDenied = denyNarrowingPolicy === undefined
-            ? undefined
-            : async (path) => {
-                try {
-                    const d = refuseOutOfContractDecision(await denyNarrowingPolicy.check({ toolName: "Read", args: { file_path: path }, toolCallId: "changed-files-visibility-probe" }, abortController.signal));
-                    return d.action === "deny";
-                }
-                catch {
-                    return false;
-                }
-            };
-        const detectExternalChanges = handsEnabled && readFileStateForCheckpoint
-            ? async (maxFiles) => {
-                const candidates = [...readFileStateForCheckpoint.entries()]
-                    .filter(([, e]) => e.lastReadAt !== undefined)
-                    .filter(([, e]) => e.truncated !== true)
-                    .sort((a, b) => (b[1].lastReadAt ?? 0) - (a[1].lastReadAt ?? 0))
-                    .slice(0, Math.max(0, maxFiles));
-                const changed = [];
-                const evicted = [];
-                for (const [path, entry] of candidates) {
-                    if (changedFilesReadDenied !== undefined && (await changedFilesReadDenied(path)))
-                        continue;
-                    try {
-                        const info = await executionEnv.fileInfo(path, abortController.signal);
-                        if (!info.ok) {
-                            if (info.error.code === "not_found") {
-                                readFileStateForCheckpoint.delete(path);
-                                evicted.push(path);
-                            }
-                            continue;
-                        }
-                        if (info.value.mtimeMs > (entry.lastReadAt ?? 0) + CHANGED_FILES_MTIME_EPS_MS) {
-                            changed.push({ path, mtimeMs: info.value.mtimeMs });
-                        }
-                    }
-                    catch {
-                    }
-                }
-                return { changed, evicted };
-            }
-            : undefined;
-        const listBackgroundTasks = () => defaultTaskRegistry
-            .list({ owner: hostTaskId, scope: taskScope, sessionId })
-            .filter((t) => t.status === "pending" || t.status === "running" || t.status === "parked")
-            .map((t) => ({ id: t.task_id, ...(t.description !== undefined ? { description: t.description } : {}), status: t.status }));
-        const overheadState = { promptChars: 0 };
-        const centerCompactionCandidate = deps.promptSource !== undefined && centerAdoption !== undefined
-            ? () => {
-                const state = deps.promptSource.sourceState?.() ?? "unavailable";
-                const cand = deps.promptSource.current();
-                const toBundled = state === "disabled";
-                if (!toBundled && (cand === undefined || cand.artifact.artifactDigest === centerAdoption.artifact.artifactDigest))
-                    return undefined;
-                let a2;
-                try {
-                    a2 = assemblePrompt(buildAssembleInputs(toBundled ? undefined : artifactDeclarations(cand.artifact)));
-                }
-                catch {
-                    return undefined;
-                }
-                if (!toBundled && a2.centerMounted !== true)
-                    return undefined;
-                const declared2 = (a2.sections ?? [])
-                    .filter((sec) => sec.origin === "provider")
-                    .map((sec) => ({ id: sec.id, slot: sec.slot, chars: sec.text.length, ...(sec.declaredContentHash !== undefined ? { contentHash: sec.declaredContentHash } : {}) }));
-                const overheadTokensAfter = preparedHolder.current.promptOverheadTokens -
-                    Math.ceil(overheadState.promptChars / charsPerToken) +
-                    Math.ceil(a2.systemPrompt.length / charsPerToken);
-                return {
-                    ...(toBundled
-                        ? { clear: true }
-                        : {
-                            centerArtifactDigest: cand.artifact.artifactDigest,
-                            ...(cand.sourceRevision !== undefined ? { sourceRevision: cand.sourceRevision } : {}),
-                        }),
-                    declaredSections: declared2,
-                    overheadTokensAfter,
-                    apply: (committedArtifactDigest) => {
-                        systemPrompt = a2.systemPrompt;
-                        harnessRef.current?.setSystemPrompt(a2.systemPrompt, a2.systemBlocks);
-                        if (fpRef.current)
-                            fpRef.current.systemPrompt = a2.systemPrompt;
-                        turnSnapshotRef.current?.refreshStableSystem(a2.systemPrompt, committedArtifactDigest);
-                        preparedHolder.current.epochDeclaredSections = declared2;
-                        preparedHolder.current.promptOverheadTokens = overheadTokensAfter;
-                        overheadState.promptChars = a2.systemPrompt.length;
-                        centerAdoption = toBundled
-                            ? undefined
-                            : { artifact: cand.artifact, ...(cand.sourceRevision !== undefined ? { sourceRevision: cand.sourceRevision } : {}) };
-                    },
-                };
-            }
-            : undefined;
-        overheadState.promptChars = systemPrompt.length;
-        const effectiveReadFaceObserved = carrierReadFace();
-        const effectiveReadDenyObserved = readDenyAdditionsNormalized.length > 0 ? readDenyAdditionsNormalized.map((e) => ({ ...e })) : undefined;
-        await onceLedger.settle(session, announcedListingsRef);
+        const { askLane } = prepareAskLane({ gateMachineryActive, abortController, effectivePolicy, budgetSnapshot, handsCwdRef, tools, inheritedUnavailableAsks, inheritedAskGrants, onAsk, humanReviewRef, humanBareRejections, now, ruleOffersOf, askSourceIdentity, riskAxesOf, autoModeDenialTracking, spec, deps, sessionId, runId, hooks, hookTimeoutMs, notifyOwnHookCrash });
+        const { saga } = prepareSuspendSaga({ gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, autoModeDecider, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter });
+        const { suspendForResource, suspendForPlatformLimit, suspendForReview } = prepareBoundaryParks({ saga, spec, checkpointStore, abortController, harness, session, sessions, sessionId, deps, priorLedger, maxSlices, maxSuspends, resourceTotal, priorSuspendCount, suspendChainBase, humanReviewRef, liveSpendRef, now, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, suspendRef, reviewRef, remoteEnvFailures, resourceSuspendEligible, durableSuspendInfraReady, incompleteSuspendAdapter });
+        const { parkAsk } = prepareParkAsk({ askLane, saga, spec, deps, sessionId, checkpointStore, parkLaneArmed, contentAskRoutable, liveQuestionFace, mountedQuestionTool, contentAskBindings, lateStrandedAnswers, discloseStrandedAnswers, onAsk, runtimeCaps, inheritedUnavailableAsks, basePolicyForResumeEdit, budgetSnapshot, handsCwdRef, offloadStore, ownedEnv, incompleteSuspendAdapter, session, sessions, suspendChainBase, maxSuspends, remoteEnvFailures, shellGatedBash, shellGatedMonitor, effectiveShellGate, durableApproval, priorLedger, liveSpendRef, resourceTotal, faceCheckpointState, f012CheckpointState, orgAdmissionCheckpointState, ruleOffersOf, now, humanReviewRef, abortController, harness, suspendRef, reviewRef });
+        prepareGateStations({ askLane, parkAsk, tools, toolEffects, deps, toolCallGateArmedRef, effectivePolicy, hooks, egressTools, irreversibleTools, spec, complianceDenies, harness, blockedToolCalls, inheritedAskGrants, humanBareRejections, inheritedUnavailableAsks, foldAskClasses, ancestorSandboxAdmissions, preToolContexts, approvalSettlement, batchHaltRef, blockedTracked, hookIdentity, reminderMark, planModeRef, hostTaskId, sessionId, ownGatePreToolUse, hookTimeoutMs, handsCwdRef, hookEnvFace, irreversibilityTier, reversibilityProbes, abortController, shellGatedBash, shellGatedMonitor, autoModeDecider, autoModeDenialTracking, stopForDenialLimit, permissionRuleLane, permissionRuleOrgLane, questionToolMounted, sandboxAdmissionArmed, sandboxBoundaryCapable, emitSandboxAdmitted, delegation, notifyOwnHookCrash });
+        const { microCompact, charsPerToken } = prepareContextLane({ model, deps, sessionId, runId, hostTaskId, offloadStore, microCompactKnob, harness, batchHaltRef, gitStatusRef, requestLossyRef, trimPressureRef });
         const preparedHolder = {};
+        const { cacheBreakDetector, cacheFingerprint, promptOverheadTokens, readTaskFile, normalizeAttachmentPath, isDedupStubResult, recentlyReadFiles, onCompactionApplied, detectExternalChanges, listBackgroundTasks, centerCompactionCandidate, effectiveReadFaceObserved, effectiveReadDenyObserved } = prepareTurnWiring({ deps, systemPromptSeat, harnessTools, fpRef, model, epochArtifactDigestForSnapshot, promptProfile, fableMitigations, systemBlocks, thinking, spec, sessionId, turnSnapshotRef, promptManifest, charsPerToken, handsEnabled, executionEnv, attachmentRootCanonical, additionalRootsCanonical, additionalReadRootsCanonical, readDenyMatcher, resolvedReadFace, handsCwdRef, readFileStateForCheckpoint, denyNarrowingPolicy, abortController, hostTaskId, taskScope, buildAssembleInputs, centerAdoptionRef, harnessRef, epochDeclaredSections, carrierReadFace, readDenyAdditionsNormalized, preparedHolder });
+        await onceLedger.settle(session, announcedListingsRef);
         const buildPrepared = () => ({ harness, session, sessionId, runId, reminderMark, reminderDisclosureCounts, editedFilesSnapshot, taskRootPath: taskRootFinal, model, thinking, compModel: effectiveCompModel, mcp, ...(a2a.tools.length > 0 ? { a2a } : {}), blockedRef, outputRef, abortController, conflictRef, blockedToolCalls, approvalSettlement, batchHaltRef, nestedStats, ...(rewindNotes.length > 0 ? { rewindNotes } : {}), ...(fileHistoryBoundary !== undefined ? { fileHistoryBoundary } : {}), ...(effectiveReadFaceObserved !== undefined ? { effectiveReadFace: effectiveReadFaceObserved } : {}), ...(effectiveReadDenyObserved !== undefined ? { effectiveReadDenyPatterns: effectiveReadDenyObserved } : {}), effectiveMemoryScopes: memoryEffectiveScopes, cwdRef: handsCwdRef, ...(worktreeSessionRef !== undefined ? { worktreeSessionRef } : {}), ...(workspaceStateSettle !== undefined ? { workspaceStateSettle } : {}), ...(sealReadStateSeat !== undefined ? { sealReadStateSeat } : {}), denyNarrowingPolicy, ...(basePolicyForResumeEdit !== undefined ? { basePolicyForResumeEdit } : {}), ...(permissionRuleOrgLane !== undefined ? { permissionRuleOrg: permissionRuleOrgLane } : {}), releaseSignal, settleContentAskBindings, cacheBreakDetector, cacheFingerprint, wiringManifest, promptManifest, epochDeclaredSections, activeTools, ...(deferred.size > 0 ? { deferredToolNames: deferred } : {}), toolMaterializeStatic, deferDirectCall, ...(staticFaceForRef.current !== undefined ? { staticFaceFor: staticFaceForRef.current } : {}), ownedEnv, suspendRef, suspendProgressRef, reviewRef, remoteEnvFailures, reviewRequestRef, suspendLoopRef, suspendForResource, ...(suspendForPlatformLimit !== undefined ? { suspendForPlatformLimit } : {}), ...(envLifetimeSuspendAt !== undefined ? { envLifetimeSuspendAt } : {}), ...(usageGovernance !== undefined ? { usageGovernance } : {}), callIssuedAtRef, brainCallGuardrailRef, gateStopRef, suspendForReview, resourceLedger: priorLedger, liveSpendRef, humanReviewRef, now, tools, toolEffects, wakeRecovered, promptOverheadTokens, lastBrainContext, readTaskFile, recentlyReadFiles, normalizeAttachmentPath, isDedupStubResult, ...(onCompactionApplied ? { onCompactionApplied } : {}), compactionReuseRef, trimPressureRef, microCompact, ...(memoryEngineSession ? { memoryEngineSession } : {}), ...(subagentRetain ? { subagentRetain } : {}), ...(lspDiagnostics && nudgeLspOnEdit ? { lspDiagnostics: { registry: lspDiagnostics, nudge: nudgeLspOnEdit, runIdent: lspRunIdent } } : {}), planModeRef, stopRequestedRef, announcedSnapshotRecovered: onceLedger.recovered, ...(dateChange ? { dateChange } : {}), ...(instructionSources ? { instructionSources } : {}), ...(projectInstructionContent !== undefined ? { projectInstructionContent } : {}), ...(workflowSizeGuideline ? { workflowSizeGuideline } : {}), ...(detectExternalChanges ? { detectExternalChanges } : {}), ...(toolsDeltaRef ? { toolsDeltaRef } : {}), ...(agentListing ? { agentListing } : {}), ...(skillsListing ? { skillsListing } : {}), announcedListingsRef, gitStatusRef, listBackgroundTasks, hookIdentity, hookTimeoutMs, ...(turnSnapshotRef.current !== undefined ? { turnSnapshot: turnSnapshotRef.current } : {}), ...(centerCompactionCandidate !== undefined ? { centerCompactionCandidate } : {}) });
         rollback.commit();
         const prepared = buildPrepared();