@sema-agent/core 7.1.0 → 7.3.0

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

@@ -23,7 +23,8 @@ import { createSendMessageTool, SEND_MESSAGE_TOOL_NAME } from "../../agents/send
 import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
 import { askApproverIdentity, carriesBidiControls, checkToolPolicyProjection, combinePolicies, constraintChainDigest, constraintChainEntryOfLayer, isApprovalSettledBy, isAskDenyResolution, screenApproverAttribution, createTranscriptIntegrityPolicy, createUnverifiableDeletePolicy, describeThrown, refuseOutOfContractDecision, resolveAsk, toolPolicyNameSets, tryCloneArgs } from "../tool-policy.js";
 const PERSISTED_RULE_TOOL = "Bash";
-import { findAdmittingRule, segmentCoverageOf, suggestRulesForCommand } from "../permission-rule-model.js";
+const DIRECTORY_RULE_TOOL = "Read";
+import { directoryRuleAdmits, eligiblePersisted, findAdmittingRule, lexicalNormalAbsolutePathOf, segmentCoverageOf, suggestRulesForCommand } from "../permission-rule-model.js";
 import { normalizePersistedRule } from "../permission-rule-store.js";
 import { ActiveSkillScope, createActiveSkillScopePolicy } from "./active-skill-scope.js";
 import { CHANGED_FILES_MTIME_EPS_MS, fenceMcpServerInstructions, renderAgentListingDelta } from "./turn-attachments.js";
@@ -76,12 +77,14 @@ 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 { StubExecutionEnv } from "../stub-env.js";
-import { hasDestroy, isIsolated, isRemoteExecutionEnv, isSuspendable, missingRestoreSurface } from "../remote-env.js";
+import { hasDestroy, isIsolated, isRemoteExecutionEnv, isSuspendable, missingRestoreSurface, RemoteExecutionError } from "../remote-env.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
 import { createTaskOutputTool, createTaskStopTool, defaultTaskRegistry } from "../task-registry.js";
 import { createMonitorTool } from "../../tools/monitor.js";
 import { createWorktreeTools } from "../../tools/worktree.js";
+import { announcePeerLaneMount, bindPeerLaneDrain, listAgentsMountable, mountListAgents, peerLaneSendMessageSeats } from "../../agents/peer-session-drain.js";
+import { CROSS_SESSION_CLASSIFIER_RULE } from "../../agents/cross-session-envelope.js";
 import { applyCompactionToReadFileState, isReadDedupStubResult, FULL_SHELL_CONTRACT_ID, HAND_TOOL_EFFECTS } from "../../tools/fs/index.js";
 import { decodeTextBytes } from "../../tools/fs/encoding.js";
 import { ASK_USER_QUESTION_TOOL_NAME, createAskUserQuestionTool, classifyQuestionOutcome, isLiveQuestionFace, validateAskQuestions, } from "../ask-question.js";
@@ -197,6 +200,20 @@ function announceToolModelGate(onNotice, modelId, gate) {
         }
     }
 }
+export const TOOL_MODEL_GATE_RESTORE_SENTENCE = "restore via TaskSpec.restoreGatedTools, SEMA_TOOL_MODEL_GATE=off, or RunnerDeps.toolModelGate: false";
+function toolModelGateManifest(gate) {
+    let firstClass;
+    const removed = [];
+    for (const [gateClass, names] of gate.removedByClass) {
+        if (names.length === 0)
+            continue;
+        firstClass ??= gateClass;
+        for (const n of names)
+            if (!removed.includes(n))
+                removed.push(n);
+    }
+    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;
@@ -713,6 +730,93 @@ function consumeInheritedAskGrant(grants, onAsk, humanReviewRef, decision, req)
     });
     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());
@@ -869,6 +973,87 @@ function persistedRuleHitOf(admitting) {
         ? undefined
         : { rules: admitting.map((r) => ({ rule: r.rule, dots: r.adds.map((a) => ({ actor: a.dot.actor, counter: a.dot.counter })) })) };
 }
+function directoryRuleLaneAnswer(table, args, ctx) {
+    const filePath = args?.file_path;
+    if (typeof filePath !== "string" || filePath === "")
+        return undefined;
+    const spelled = filePath.startsWith("/") ? filePath : `${(ctx.liveCwd ?? ctx.root ?? "").replace(/\/+$/, "")}/${filePath}`;
+    const target = lexicalNormalAbsolutePathOf(spelled);
+    if (target === undefined)
+        return undefined;
+    const hit = table.find((r) => eligiblePersisted(r, { tool: DIRECTORY_RULE_TOOL, cwd: ctx.root, sessionId: ctx.sessionId }) && directoryRuleAdmits(r, target));
+    return hit !== undefined ? persistedRuleHitOf([hit]) : undefined;
+}
+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" };
+    };
+}
+function makeOrgAdjudicationLane(overlay, questionToolMounted, onRevisionDefect) {
+    if (overlay === undefined)
+        return undefined;
+    return {
+        adjudicate: async (req) => {
+            if (req.toolName === ASK_USER_QUESTION_TOOL_NAME && questionToolMounted)
+                return { status: "available" };
+            let resolution;
+            try {
+                resolution = await overlay.resolve();
+            }
+            catch (err) {
+                return { status: "unavailable", disclosures: [`the org rule overlay threw: ${err instanceof Error ? err.message : String(err)}`] };
+            }
+            if (resolution.status === "unavailable")
+                return { status: "unavailable", disclosures: resolution.disclosures };
+            const revisionCell = orgRevisionEvidenceOf(resolution, onRevisionDefect);
+            const command = req.args?.command;
+            if (req.toolName !== PERSISTED_RULE_TOOL || typeof command !== "string")
+                return { status: "available", ...revisionCell };
+            const verdict = orgRuleVerdictFor(resolution.rules, { tool: req.toolName, command });
+            return verdict === undefined ? { status: "available", ...revisionCell } : { status: "available", verdict, ...revisionCell };
+        },
+    };
+}
 function cwdConflictsRestoreError(requestedCwd) {
     const e = new Error(`RunInternals.requestedCwd ("${requestedCwd}") cannot be combined with a checkpoint workspace restore — ` +
         `the restored workspace's own mount path is authoritative for the task root, so a requested cwd on this leg ` +
@@ -992,14 +1177,101 @@ function refuseRequireExistingWithoutSession(spec) {
         throw e;
     }
 }
+function screenAutoModeCap(caps, onError, sessionId) {
+    if (caps === undefined)
+        return { caps, faulted: false };
+    if (typeof caps !== "object" || caps === null || Array.isArray(caps)) {
+        onError?.(new Error(`runtimeCapsResolver returned a non-record value (${JSON.stringify(caps)}) — read as a resolver fault: every per-principal capability is DENIED for this run (auto mode is not armed; asks flow the original chain). Return a RuntimeCaps object or undefined.`), { phase: "config", sessionId });
+        return { caps: { allowWorkflows: false, allowFork: false, autoMode: false }, faulted: true };
+    }
+    const record = caps;
+    if (record.autoMode === undefined || typeof record.autoMode === "boolean")
+        return { caps: record, faulted: false };
+    onError?.(new Error(`runtimeCapsResolver returned a non-boolean autoMode (${JSON.stringify(record.autoMode)}) — read as a resolver fault: auto mode is DENIED for this run (the classifier is not armed; asks flow the original chain). Return true, false, or omit the key.`), { phase: "config", sessionId });
+    return { caps: { ...record, autoMode: false }, faulted: true };
+}
+function mintPersistedArming(am, laneRule, classifierSystemPrompt, onError, sessionId) {
+    const arming = autoModeArmingRecipeOf(laneRule ? { ...am, crossSessionMessagesRule: true } : am, {
+        promptDigest: `apv1:${createHash("sha256").update(classifierSystemPrompt).digest("hex")}`,
+    });
+    if (arming === undefined) {
+        onError?.(new Error("RunnerDeps.autoMode.persistArming is set but the auto-mode face did not canonicalize into an arming recipe " +
+            "(a rule list carrying a non-string, or a non-finite/out-of-range timeoutMs / failureThreshold / window bound) — " +
+            "NO arming recipe is recorded on this run's parked constraint chain, and a cross-process redemption keeps the " +
+            "conservative behavior (the ancestor classifier answers unavailable and the inherited ask flows to a human)"), { phase: "config", sessionId });
+    }
+    return arming;
+}
+function autoModeLatchHealthy(d) {
+    try {
+        return d.breakerOpen() !== true && typeof d.consecutiveFailures === "function" && d.consecutiveFailures() === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function refuseInvalidAutoModeSeat(spec) {
+    if (spec.autoModeRequested !== undefined && spec.autoModeRequested !== true) {
+        const e = new Error(`autoModeRequested must be the literal true when present (got ${JSON.stringify(spec.autoModeRequested)}) — omit it for a non-auto task; a non-boolean or false value is refused rather than read as either polarity.`);
+        e.code = "config.auto_mode_requested_invalid";
+        throw e;
+    }
+    return spec.autoModeRequested === true;
+}
+function announceDurableGateUnavailable(args) {
+    if (!args.forceDurableGate || args.storeWired)
+        return;
+    const cause = args.taskStoreNull ? "task_store_null" : "no_deployment_store";
+    const inheritedContentMandate = (args.parentConstraints ?? []).some((pc) => pc.contentMandate === true);
+    const liveQuestionFace = args.liveQuestionFace && !inheritedContentMandate;
+    deliverEngineNotice(args.onNotice, {
+        code: "config.durable_gate_unavailable",
+        message: `Durable approval gate mandated but unavailable: the runtime entitlement forceDurableGate is in force for this ` +
+            `principal, but ${cause === "task_store_null" ? "this task disabled the checkpoint store (checkpointStore: null)" : "this deployment wired no checkpoint store"}, ` +
+            `so no interactive ask of this task can be parked for a durable answer. Asks resolve on the live chain instead ` +
+            `(${args.liveApprover ? "a live approver answers permission asks in-stream" : "permission asks are denied fail-closed — no live approver is wired"}; ` +
+            `${liveQuestionFace ? "a live question face answers AskUserQuestion in-stream" : args.liveQuestionFace ? "AskUserQuestion is withheld from the live face by an inherited durable mandate and refused" : "AskUserQuestion has no live face and is refused"}) ` +
+            `and NO durable approval record is written. ${cause === "task_store_null" ? "Run this task with its store, or withdraw the entitlement for principals whose runs are machine-started." : "Wire a checkpoint store on this deployment, or withdraw the entitlement for principals served here."}`,
+        detail: {
+            sessionId: args.sessionId,
+            runId: args.runId,
+            ...(args.principal ? { principal: args.principal } : {}),
+            cause,
+            liveApprover: args.liveApprover,
+            liveQuestionFace,
+        },
+    });
+}
+function buildTier3ReviveSpawn(delegationForRevive, enrichSpecToolCtx) {
+    if (delegationForRevive === undefined)
+        return undefined;
+    return async (req) => {
+        const out = await delegationForRevive.execute({
+            description: req.row.description ?? "revived teammate",
+            prompt: req.prompt,
+            run_in_background: true,
+            ...(req.row.agentType !== undefined ? { subagent_type: req.row.agentType } : {}),
+            ...(req.row.name !== undefined ? { name: req.row.name } : {}),
+            ...(req.row.model !== undefined ? { model: req.row.model } : {}),
+        }, enrichSpecToolCtx({ toolCallId: `rv-${randomBytes(8).toString("hex")}`, reviveClaim: { row: req.row, rev: req.rev, ...(req.peerSeed !== undefined ? { peerSeed: req.peerSeed } : {}) } }));
+        const o = (typeof out === "string" ? { content: out } : out);
+        return {
+            content: typeof o.content === "string" ? o.content : JSON.stringify(o.content),
+            ...(o.isError === true ? { isError: true } : {}),
+            ...(o.details !== undefined ? { details: o.details } : {}),
+        };
+    };
+}
 export async function prepareTask(spec, deps, sessions, resume, internals, runnerSelf, runIdSink) {
     const runId = uuidv7();
     if (runIdSink !== undefined)
         runIdSink.runId = runId;
     const doors = prepareConfigDoors({ spec, deps, sessions, resume, internals });
     spec = doors.spec;
+    const autoModeSeat = refuseInvalidAutoModeSeat(spec);
     const { toolFaceSnapshot, promptProfile, lockedPreflight, resolvedInteractionPosture, microCompactKnob, resolvedRole, model, thinking, compModel, fableMitigations, memoryDelegationEvidence, memoryProvenance, memoryCapturePolicy, usageWindows, brainCallGuardrailRef, brainCallGuardrailMs } = doors;
     announceToolModelGate(deps.onNotice, model.id, doors.modelGate);
+    const modelGateManifest = toolModelGateManifest(doors.modelGate);
     const { toolEffects, egressTools, irreversibleTools, irreversibilityTier, axisExplicitNegatives, reversibilityProbes, ownToolNames } = prepareSafetyScan({ spec, deps });
     let shellGatedBash = false;
     let shellGatedMonitor = false;
@@ -1019,6 +1291,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
     const taskScope = internals?.registryScope ?? spec.principal ?? "default";
     internals?.peerSelfRef?.addAxis("s", sessionId);
     internals?.peerSelfRef?.addAxis("t", hostTaskId);
+    const peerLaneActive = announcePeerLaneMount(deps, { sessionId, runId });
+    const peerLaneRefs = {};
+    const peerSendMessageBuiltIn = runnerSelf !== undefined && !(toolFaceSnapshot.exclude ?? []).includes(SEND_MESSAGE_TOOL_NAME) && !(spec.tools ?? []).some((t) => t.name === SEND_MESSAGE_TOOL_NAME);
     const { reminderMark, reminderDisclosureCounts } = await adoptReminderMark(session, sessionId, resume?.seed.reminderMark, internals?.reminderMark, deps.onError);
     const offloadScope = spec.principal ?? "default";
     if (internals?.registryScope !== undefined && internals.registryScope !== offloadScope) {
@@ -1406,6 +1681,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     ? liveShellGate
                     : seedShellGate;
         const inheritedParentConstraints = liveInheritedGate?.parentConstraints;
+        const autoModeIntent = autoModeSeat || liveInheritedGate?.autoModeRequested === true || seedInheritedGate?.autoModeRequested === true;
         const liveAdmittedOrg = liveInheritedGate?.admittedOrgScopes;
         const seedAdmittedOrg = seedInheritedGate?.admittedOrgScopes;
         const inheritedAdmittedOrgScopes = liveAdmittedOrg === undefined ? seedAdmittedOrg : seedAdmittedOrg === undefined ? liveAdmittedOrg : liveAdmittedOrg.filter((s) => seedAdmittedOrg.includes(s));
@@ -1518,6 +1794,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             return {
                 ...(ancestorRules.length > 0 ? { ancestorRules } : {}),
                 ...(effectiveShellGate !== "off" ? { shellGate: effectiveShellGate } : {}),
+                ...(autoModeIntent ? { autoModeRequested: true } : {}),
                 ...(parentConstraints.length > 0 ? { parentConstraints } : {}),
                 admittedOrgScopes: memoryAdmittedOrgScopesRef.current,
                 ...(orgGovernedProvenance ? { orgAdmissionGoverned: true } : {}),
@@ -1658,9 +1935,12 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             }
             catch (err) {
                 deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId });
-                runtimeCaps = { allowWorkflows: false, allowFork: false };
+                runtimeCaps = { allowWorkflows: false, allowFork: false, autoMode: false };
                 runtimeCapsFaulted = true;
             }
+            const screened = screenAutoModeCap(runtimeCaps, deps.onError, sessionId);
+            runtimeCaps = screened.caps;
+            runtimeCapsFaulted ||= screened.faulted;
         }
         let complianceDenies = new Set();
         let complianceDegraded = false;
@@ -1697,7 +1977,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         agentForkDenial = forkGovernanceDenial(spec.enableFork, runtimeCaps?.allowFork);
         observersActive = runtimeCaps?.allowObservers === true;
-        if (runtimeCaps?.autoMode === true && deps.autoMode !== undefined) {
+        if (autoModeIntent && deps.autoMode !== undefined && runtimeCaps?.autoMode !== false) {
             const am = deps.autoMode;
             let classifierModel;
             try {
@@ -1709,7 +1989,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             if (await derivedRouteFallsBack({ seat: "auto-mode-classifier", derived: classifierModel, primary: model, brain: deps.brain, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, onNotice: deps.onNotice, sessionId, runId })) {
                 classifierModel = model;
             }
-            const classifierSystemPrompt = buildAutoModePrompt(am);
+            const classifierLaneRule = peerLaneActive && peerSendMessageBuiltIn;
+            const classifierSystemPrompt = buildAutoModePrompt(classifierLaneRule ? { ...am, crossSessionMessagesRule: CROSS_SESSION_CLASSIFIER_RULE } : am);
             const classifierRuntime = brainToRuntime(deps.brain);
             autoModeDecider = createAutoModeDecider({
                 ...(am.timeoutMs !== undefined ? { timeoutMs: am.timeoutMs } : {}),
@@ -1732,17 +2013,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         .join("");
                 },
             });
-            if (am.persistArming === true) {
-                autoModeArming = autoModeArmingRecipeOf(am, {
-                    promptDigest: `apv1:${createHash("sha256").update(classifierSystemPrompt).digest("hex")}`,
-                });
-                if (autoModeArming === undefined) {
-                    deps.onError?.(new Error("RunnerDeps.autoMode.persistArming is set but the auto-mode face did not canonicalize into an arming recipe " +
-                        "(a rule list carrying a non-string, or a non-finite/out-of-range timeoutMs / failureThreshold / window bound) — " +
-                        "NO arming recipe is recorded on this run's parked constraint chain, and a cross-process redemption keeps the " +
-                        "conservative behavior (the ancestor classifier answers unavailable and the inherited ask flows to a human)"), { phase: "config", sessionId });
-                }
-            }
+            if (am.persistArming === true)
+                autoModeArming = mintPersistedArming(am, classifierLaneRule, classifierSystemPrompt, deps.onError, sessionId);
         }
         const deploymentWorkflowReady = runnerSelf !== undefined && isSelfOrchestrationActive(spec, deps);
         const selfOrchestrationActive = deploymentWorkflowReady && runtimeCaps?.allowWorkflows !== false;
@@ -2037,32 +2309,18 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         handsLessResolvedFace = handsReadFace.handsLessResolvedFace;
         shellGatedBash = handsReadFace.shellGatedBash;
         shellGatedMonitor = handsReadFace.shellGatedMonitor;
-        if (backgroundTaskToolsActive || workflowToolsActive) {
-            toolEffects.set("TaskOutput", "read");
-            toolEffects.set("TaskStop", "write");
-            tools.push(firstPartyOffload(createTaskOutputTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore, notificationWired: internals?.onTaskNotification !== undefined, oneShot: spec.oneShot, toolResultStore: offloadStore })), firstPartyOffload(createTaskStopTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore })));
+        const delegationSurfaceActive = backgroundTaskToolsActive || workflowToolsActive;
+        if (delegationSurfaceActive || internals?.parentNotify !== undefined || peerLaneActive) {
+            if (delegationSurfaceActive) {
+                toolEffects.set("TaskOutput", "read");
+                toolEffects.set("TaskStop", "write");
+                tools.push(firstPartyOffload(createTaskOutputTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore, notificationWired: internals?.onTaskNotification !== undefined, oneShot: spec.oneShot, toolResultStore: offloadStore })), firstPartyOffload(createTaskStopTool({ registry: defaultTaskRegistry, owner: hostTaskId, scope: taskScope, sessionId, workflowStore: deps.workflowRunStore, agentStore: deps.backgroundAgentStore })));
+            }
             if (runnerSelf && !(spec.tools ?? []).some((t) => t.name === SEND_MESSAGE_TOOL_NAME)) {
                 toolEffects.set(SEND_MESSAGE_TOOL_NAME, "write");
                 axisExplicitNegatives.set(SEND_MESSAGE_TOOL_NAME, { ...axisExplicitNegatives.get(SEND_MESSAGE_TOOL_NAME), egress: false });
                 const delegationForRevive = (spec.tools ?? []).find((t) => t.agentListing !== undefined);
-                const reviveSpawn = delegationForRevive !== undefined && deps.backgroundAgentStore !== undefined && deps.mailboxStore !== undefined
-                    ? async (req) => {
-                        const out = await delegationForRevive.execute({
-                            description: req.row.description ?? "revived teammate",
-                            prompt: req.prompt,
-                            run_in_background: true,
-                            ...(req.row.agentType !== undefined ? { subagent_type: req.row.agentType } : {}),
-                            ...(req.row.name !== undefined ? { name: req.row.name } : {}),
-                            ...(req.row.model !== undefined ? { model: req.row.model } : {}),
-                        }, enrichSpecToolCtx({ toolCallId: `rv-${randomBytes(8).toString("hex")}`, reviveClaim: { row: req.row, rev: req.rev, ...(req.peerSeed !== undefined ? { peerSeed: req.peerSeed } : {}) } }));
-                        const o = (typeof out === "string" ? { content: out } : out);
-                        return {
-                            content: typeof o.content === "string" ? o.content : JSON.stringify(o.content),
-                            ...(o.isError === true ? { isError: true } : {}),
-                            ...(o.details !== undefined ? { details: o.details } : {}),
-                        };
-                    }
-                    : undefined;
+                const reviveSpawn = deps.backgroundAgentStore !== undefined && deps.mailboxStore !== undefined ? buildTier3ReviveSpawn(delegationForRevive, enrichSpecToolCtx) : undefined;
                 tools.push(firstPartyOffload(createSendMessageTool({
                     runner: runnerSelf,
                     registry: defaultTaskRegistry,
@@ -2070,7 +2328,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     owner: hostTaskId,
                     scope: taskScope,
                     ...(sessionId !== undefined ? { sessionId } : {}),
-                    ...(internals?.onTaskNotification !== undefined ? { notify: internals.onTaskNotification } : {}), ...(spec.oneShot !== undefined ? { oneShot: spec.oneShot } : {}),
+                    ...(internals?.onTaskNotification !== undefined ? { notify: internals.onTaskNotification } : {}), ...(spec.oneShot !== undefined ? { oneShot: spec.oneShot } : {}), retrievalToolMounted: delegationSurfaceActive,
                     ...(internals?.onSubagentSpawn !== undefined ? { sink: internals.onSubagentSpawn } : {}),
                     ...(internals?.parentNotify !== undefined
                         ? { uplink: internals.parentNotify, ...(internals.parentPeerRef !== undefined ? { uplinkRecipient: internals.parentPeerRef } : {}) }
@@ -2088,6 +2346,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     ...(deps.backgroundAgentStore !== undefined ? { agentStore: deps.backgroundAgentStore } : {}),
                     ...(deps.mailboxStore !== undefined ? { mailbox: deps.mailboxStore } : {}),
                     ...(reviveSpawn !== undefined ? { reviveSpawn } : {}),
+                    ...(peerLaneActive ? peerLaneSendMessageSeats({ peerDirectory: deps.peerDirectory, sessionId, scope: taskScope, ...(internals?.explicitAgentName !== undefined ? { name: internals.explicitAgentName } : {}), refs: peerLaneRefs, listingMounted: listAgentsMountable({ exclude: toolFaceSnapshot.exclude, specTools: spec.tools ?? [] }) }) : {}),
                     onNotifyError: (f) => emitTrace(deps.tracer, () => ({ kind: "observer.notify_failed", version: 1, taskId: hostTaskId, site: f.site, message: f.error.message, ts: Date.now() })),
                     onTranscriptIntegrityGap: (handle, scope) => deliverEngineNotice(deps.onNotice, {
                         code: "delegation.transcript_integrity",
@@ -2095,7 +2354,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         detail: { handle, ...(scope !== undefined ? { scope } : {}) },
                     }),
                 })));
-                if (!(spec.tools ?? []).some((t) => t.name === AGENT_TRANSCRIPT_TOOL_NAME)) {
+                if (delegationSurfaceActive && !(spec.tools ?? []).some((t) => t.name === AGENT_TRANSCRIPT_TOOL_NAME)) {
                     tools.push(firstPartyOffload(createAgentTranscriptTool({
                         runner: runnerSelf,
                         registry: defaultTaskRegistry,
@@ -2113,6 +2372,9 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             }
         }
+        const listAgents = peerLaneActive && peerSendMessageBuiltIn && listAgentsMountable({ exclude: toolFaceSnapshot.exclude, specTools: spec.tools ?? [] }) ? mountListAgents({ peerDirectory: deps.peerDirectory, sessionId, scope: taskScope, hostTaskId, ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}), ...(internals?.parentSessionId !== undefined ? { parentSessionId: internals.parentSessionId } : {}), registry: defaultTaskRegistry, ...(deps.rosterStore !== undefined ? { roster: deps.rosterStore } : {}), specTools: spec.tools ?? [], toolEffects }) : undefined;
+        if (listAgents !== undefined)
+            tools.push(firstPartyOffload(listAgents));
         if (backgroundTaskToolsActive) {
             toolEffects.set("Monitor", "write");
             envHandToolNames.add("Monitor");
@@ -2159,10 +2421,13 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const liveQuestionFace = isLiveQuestionFace(onQuestion) ? onQuestion : undefined;
         const contentAskBindings = new Map();
         const CONTENT_ASK_BINDING_CAP = 32;
+        const checkpointStore = resolveCheckpointStore(spec, deps);
+        const questionParkStoreWired = checkpointStore !== undefined;
+        const questionDurableMandateBinding = runtimeCaps?.forceDurableGate === true && questionParkStoreWired;
         const contentAskRoutable = (toolCallId) => liveQuestionFace !== undefined &&
             mountedQuestionTool !== undefined &&
             tools.includes(mountedQuestionTool) &&
-            runtimeCaps?.forceDurableGate !== true &&
+            !questionDurableMandateBinding &&
             !inheritedUnavailableAsks.has(toolCallId);
         const lateStrandedAnswers = [];
         const discloseStrandedAnswers = (records, why) => {
@@ -2189,8 +2454,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 byDelivery.set(r.deliveryId, r);
             return [...byDelivery.values()];
         };
-        const durableQuestionFace = resolveCheckpointStore(spec, deps) !== undefined &&
-            (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true);
+        const durableQuestionFace = questionParkStoreWired && (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true);
         const mountedQuestionFace = liveQuestionFace !== undefined
             ? async (req, signal) => {
                 const bound = contentAskBindings.get(req.toolCallId);
@@ -3659,10 +3923,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     const anonymous = spec.principal === undefined || spec.principal === "";
                     if (anonymous && !localOwnerDeclared)
                         return undefined;
-                    if (req.toolName !== PERSISTED_RULE_TOOL)
-                        return undefined;
-                    const command = req.args?.command;
-                    if (typeof command !== "string")
+                    if (req.toolName !== PERSISTED_RULE_TOOL && req.toolName !== DIRECTORY_RULE_TOOL)
                         return undefined;
                     let listed;
                     try {
@@ -3682,76 +3943,32 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         return { unreadable: true };
                     }
                     const table = await spliceSessionOverlayRows(deps.sessionPermissionRules, sessionId, listed.rules, deps.tracer, hostTaskId);
-                    const admitting = findAdmittingRule(table, { tool: req.toolName, command, cwd: root, sessionId });
+                    if (req.toolName === DIRECTORY_RULE_TOOL) {
+                        return directoryRuleLaneAnswer(table, req.args, { root, sessionId, liveCwd: handsCwdRef?.current });
+                    }
+                    const command = req.args?.command;
+                    if (typeof command !== "string")
+                        return undefined;
+                    const admitting = findAdmittingRule(table, { tool: req.toolName, command, cwd: root, sessionId, ...(handsCwdRef?.current !== undefined ? { execCwd: handsCwdRef.current } : {}) });
                     if (admitting !== undefined)
                         return persistedRuleHitOf(admitting);
-                    const coverage = segmentCoverageOf(command, { persisted: table }, { tool: req.toolName, cwd: root, sessionId });
+                    const coverage = segmentCoverageOf(command, { persisted: table }, { tool: req.toolName, cwd: root, sessionId, ...(handsCwdRef?.current !== undefined ? { execCwd: handsCwdRef.current } : {}) });
                     return coverage !== undefined ? { segmentCoverage: coverage } : undefined;
                 },
             };
         })();
-        const permissionRuleOrgLane = (() => {
-            const overlay = deps.permissionRuleOrg;
-            if (overlay === undefined)
-                return undefined;
-            return {
-                adjudicate: async (req) => {
-                    if (req.toolName === ASK_USER_QUESTION_TOOL_NAME && questionToolMounted)
-                        return { status: "available" };
-                    let resolution;
-                    try {
-                        resolution = await overlay.resolve();
-                    }
-                    catch (err) {
-                        return { status: "unavailable", disclosures: [`the org rule overlay threw: ${err instanceof Error ? err.message : String(err)}`] };
-                    }
-                    if (resolution.status === "unavailable")
-                        return { status: "unavailable", disclosures: resolution.disclosures };
-                    const revisionCell = orgRevisionEvidenceOf(resolution, (message) => deps.onError?.(new Error(message), { phase: "config", sessionId }));
-                    const command = req.args?.command;
-                    if (req.toolName !== PERSISTED_RULE_TOOL || typeof command !== "string")
-                        return { status: "available", ...revisionCell };
-                    const verdict = orgRuleVerdictFor(resolution.rules, { tool: req.toolName, command });
-                    return verdict === undefined ? { status: "available", ...revisionCell } : { status: "available", verdict, ...revisionCell };
-                },
-            };
-        })();
-        const ruleOffersOf = (toolName, args, ask) => {
-            if (permissionRuleLane === undefined || toolName !== PERSISTED_RULE_TOOL)
-                return {};
-            if ((spec.principal === undefined || spec.principal === "") && deps.localOwnerRules !== true)
-                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: egressTools.has(toolName),
-                irreversibility: irreversibilityTier.get(toolName),
-                shellGated: 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 } : undefined);
-            return offers.length > 0 ? { ruleOffers: offers } : { ruleOffersAbsence: "lane_cannot_speak" };
-        };
+        const permissionRuleOrgLane = makeOrgAdjudicationLane(deps.permissionRuleOrg, questionToolMounted, (message) => deps.onError?.(new Error(message), { phase: "config", sessionId }));
+        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 frozenClassifierExcluded = (d) => d.decisionReason === "hook" || d.matchedAskRule !== undefined;
         const recheckApprovedEdit = async (pol, onAskOf, creq, edit, csignal, ancestorDecider) => {
             let editArgs = edit;
@@ -4147,7 +4364,6 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         }
         const usageGovernance = buildUsageGovernance(usageWindows, deps, spec.principal, sessionId);
         const platformSuspendArmed = durableSuspendInfraReady && (envLifetimeSuspendAt !== undefined || usageGovernance !== undefined);
-        const checkpointStore = resolveCheckpointStore(spec, deps);
         const durableApproval = spec.durableApproval ??
             (runtimeCaps?.forceDurableGate ? { scope: spec.principal || DEFAULT_IRREVERSIBLE_SCOPE } : undefined);
         const wiringQuestionSeam = resolveQuestionSeam(spec, deps);
@@ -4183,8 +4399,14 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             complianceWired: deps.compliancePostureResolver !== undefined,
             memoryAdmissionWired: deps.memoryScopeAdmission !== undefined,
             retentionPolicyWired: deps.retentionPolicy !== undefined,
+            ...(modelGateManifest !== undefined ? { modelGate: modelGateManifest } : {}),
         });
+        peerLaneRefs.askEffective = wiringManifest.ask.effective;
+        if (peerLaneActive && internals?.onTaskNotification !== undefined) {
+            bindPeerLaneDrain(harness, { deps, sessionId, runId, scope: taskScope, inject: internals.onTaskNotification, ownTokens: () => internals?.peerSelfRef?.current.ownTokens ?? [], refs: peerLaneRefs });
+        }
         const parkLaneArmed = wiringManifest.parkLane.effective === true;
+        announceDurableGateUnavailable({ onNotice: deps.onNotice, forceDurableGate: runtimeCaps?.forceDurableGate === true, storeWired: checkpointStore !== undefined, taskStoreNull: spec.checkpointStore === null, liveApprover: isLiveApproverSeat(frozenOnAsk), liveQuestionFace: liveQuestionFace !== undefined, parentConstraints: liveInheritedGate?.parentConstraints, sessionId, runId, principal: spec.principal });
         const hookIdentity = mintHookInvocationIdentity({
             sessionId,
             taskId: hostTaskId,
@@ -4324,8 +4546,10 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     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 ||
@@ -4333,6 +4557,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         ? {
                             ...(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 }
@@ -4359,11 +4584,33 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 placementRootSessionId: stampPlacementRootSessionId(placementRootResolved),
                 externalContentTarget: externalContentTargetActive ? true : undefined,
             });
-            const commitSuspendSaga = async (token, cp, remoteEnv, remoteHandle) => {
+            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 { ok: false };
+                    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 &&
@@ -4401,7 +4648,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 try {
                     await checkpointStore.put(token, cp);
                     announceCommittedScreeningPark();
-                    return { ok: true };
+                    return { tag: "committed" };
                 }
                 catch (putErr) {
                     deps.onError?.(putErr, { phase: "config", sessionId });
@@ -4417,7 +4664,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         catch {
                         }
                         announceCommittedScreeningPark();
-                        return { ok: true };
+                        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";
@@ -4432,29 +4679,18 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         }
                         abortController.abort();
                         void harness.abort();
-                        return { ok: false, reason: unknownReason };
+                        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 { outcome: back, attempts: backAttempts } = await restoreWorkspaceWithRetry(remoteEnv, remoteHandle.snapshotId, {
-                            abortSignal: abortController.signal,
-                        });
-                        if (back.ok) {
-                            const init = await remoteEnv.postResumeInit();
-                            if (init.ok)
-                                return { ok: false, reason };
-                            remoteEnvFailures.push(remoteEnvFailureNote("postResumeInit", init.error, 1));
-                            deps.onError?.(init.error, { phase: "config", sessionId });
-                        }
-                        else {
-                            remoteEnvFailures.push(remoteEnvFailureNote("resumeVM", back.error, backAttempts));
-                            deps.onError?.(back.error, { phase: "config", sessionId });
-                        }
+                        const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);
+                        if (back.ok)
+                            return { tag: "absent", reason };
                         abortController.abort();
                         void harness.abort();
-                        return { ok: false, reason };
+                        return { tag: "compensation_failed", reason };
                     }
-                    return { ok: false, reason };
+                    return { tag: "absent", reason };
                 }
             };
             const suspendLoopCapHit = (count, cap, detail) => {
@@ -4536,7 +4772,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     ...(spec.durableApproval !== undefined ? { durableApproval: { ...spec.durableApproval } } : {}),
                     ...(spec.principal ? { principal: spec.principal } : {}),
                 };
-                if (!(await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).ok)
+                if ((await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).tag !== "committed")
                     return false;
                 publishCommittedSuspend({ suspendRef, reviewRef }, token, gate, scope, remoteHandle, cp.checkpointId, cp.pendingAction);
                 try {
@@ -4622,7 +4858,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         ...(spec.principal ? { principal: spec.principal } : {}),
                         ...(spec.durableApproval !== undefined ? { durableApproval: { ...spec.durableApproval } } : {}),
                     };
-                    if (!(await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).ok)
+                    if ((await commitSuspendSaga(token, cp, suspendableEnv, remoteHandle)).tag !== "committed")
                         return false;
                     publishCommittedSuspend({ suspendRef, reviewRef }, token, gate, scope, remoteHandle, cp.checkpointId, cp.pendingAction);
                     try {
@@ -4718,7 +4954,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             };
             const suspendAsk = parkLaneArmed && checkpointStore !== undefined
-                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule, probeMandated) => {
+                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule, probeMandated, callSignal) => {
                     const syncFirstEligible = req.toolName === ASK_USER_QUESTION_TOOL_NAME ? contentAskRoutable(req.toolCallId) : isLiveApproverSeat(onAsk);
                     if (syncFirstEligible &&
                         runtimeCaps?.forceDurableGate !== true &&
@@ -4726,6 +4962,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         !inheritedUnavailableAsks.has(req.toolCallId)) {
                         return undefined;
                     }
+                    const cutSignal = composedCallSignal(callSignal);
                     let token;
                     let gate;
                     let cp;
@@ -4761,13 +4998,18 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                             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 reprojected = refuseOutOfContractDecision(await basePolicyForResumeEdit.check({
+                            const reprojectedRaced = await raceSettlementAgainstSignal(Promise.resolve(basePolicyForResumeEdit.check({
                                 toolName: req.toolName,
                                 args: presented.value,
                                 toolCallId: req.toolCallId,
                                 budget: budgetSnapshot,
                                 ...(handsCwdRef !== undefined ? { cwd: handsCwdRef.current } : {}),
-                            }, abortController.signal));
+                            }, 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 &&
@@ -4798,7 +5040,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         }
                         const { messages } = await session.buildContext();
                         const { batchToolCallIds, completedCallIds } = batchContextAt(messages, req.toolCallId);
-                        if (abortController.signal.aborted) {
+                        if (cutSignal.aborted) {
                             return undefined;
                         }
                         if (suspendLoopCapHit(suspendChainBase(), maxSuspends, ` for tool "${req.toolName}" — likely a resume/restart loop.`))
@@ -4806,12 +5048,20 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         if (remoteEnv !== undefined) {
                             if (hasBackgroundShell(remoteEnv))
                                 await sweepBackgroundShells(remoteEnv, defaultTaskRegistry);
-                            const snap = await remoteEnv.suspendVM({ abortSignal: abortController.signal });
+                            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)
@@ -4917,16 +5167,31 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                         };
                     }
                     catch (err) {
-                        deps.onError?.(err, { phase: "config", sessionId });
-                        return {
-                            parkFailed: err instanceof ParkRefusal
-                                ? err.message
-                                : "the durable approval park could not be prepared (the deployment's error face carries the exception)",
-                        };
+                        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);
-                    if (!committed.ok) {
-                        return committed.reason !== undefined ? { parkFailed: committed.reason } : undefined;
+                    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 {