@sema-agent/core 7.11.2 → 7.13.0

package/dist/core/runner/run-leg.js

@@ -0,0 +1,713 @@
+import { snapshotActorAssertion } from "../../internal/llm.js";
+import { redactThenCut } from "../../agents/subagent-steps.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
+import { CheckpointError, readPendingSteerQueue, realApprovalOrgFact, remainingBudgetMicroUsd } from "../checkpoint-store.js";
+import { normalizePersistedRuleHit } from "../gate-lanes.js";
+import { formatHookFeedback, hookSeatExpiredError, runHookSeat } from "../hooks.js";
+import { buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
+import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
+import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-arms.js";
+import { computeCostMicroUsd } from "../pricing.js";
+import { mintSystemReminder } from "../reminder-mint.js";
+import { hasDestroy } from "../remote-env.js";
+import { refuseOutOfContractDecision } from "../tool-policy.js";
+import { callFaceSeat, judgeParkedToolIdentity, rosterEntryNamed, toolCallFaceOf } from "../tool-roster.js";
+import { deliverEngineNotice } from "../types.js";
+import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
+import { errorCodeOf } from "./assemble-result.js";
+import { DEFAULT_PRECALL_OUTPUT_TOKENS, platformLimitTerminal } from "./clock-and-limits.js";
+import { deepJsonEqual, DEFERRED_REISSUE, resumeContinuation } from "./decide-continuation.js";
+import { settleExecutionRecord } from "./execution-record.js";
+import { mintGateOutcome } from "./gate-exit.js";
+import { resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
+import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
+import { toImageContent } from "./image.js";
+import { nextHumanInputSeq } from "./steer-admission.js";
+import { settleTeardownLeg } from "./teardown-bounded.js";
+import { toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
+import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.js";
+export async function runLeg(input) {
+    const { spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds, announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub, runner, next } = input;
+    let final;
+    let threw;
+    let abortedLive = false;
+    let userInterruptedLive = false;
+    let strandedHumanAnswers = [];
+    try {
+        if (prepared.abortController.signal.aborted) {
+            const e = new Error("run aborted");
+            e.name = "AbortError";
+            throw e;
+        }
+        if (resume) {
+            const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
+            const resumeWindowRetryAfterMs = !walltimeExhaustedResume && prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
+            if (resumeWindowRetryAfterMs !== undefined) {
+                const owesNothing = resume.outcome.gate === "resource_limit" &&
+                    readPendingSteerQueue(resume.cp.state).length === 0 &&
+                    (resume.cp.state.runningBackgroundTasks?.length ?? 0) === 0;
+                const committed = owesNothing &&
+                    prepared.suspendForPlatformLimit !== undefined &&
+                    (await prepared.suspendForPlatformLimit("usage_window", { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) }, { resumeAfterMs: resumeWindowRetryAfterMs }));
+                if (committed) {
+                    rs.limits.turnsExceeded = false;
+                    rs.limits.budgetHit = undefined;
+                }
+                else {
+                    const terminal = platformLimitTerminal("usage_window", resumeWindowRetryAfterMs, "resume");
+                    rs.limits.platformTerminal = terminal;
+                    try {
+                        runner.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+            if (resumeWindowRetryAfterMs === undefined && !walltimeExhaustedResume && resume.outcome.gate !== "wake") {
+                await applyResumeDecision(runner, prepared, resume, (e) => pushContent({ ...e, ...ident() }), emitCommitted, (toolName, details) => {
+                    if (rs.attach.attachState === undefined)
+                        return;
+                    const family = writeFamilyOf(toolName);
+                    if (family !== undefined)
+                        stampWriteAnchor(rs.attach.attachState, family, rs.counters.cadenceTurns);
+                    if (details !== undefined)
+                        reduceToolEnd(rs.attach.attachState, details);
+                }, (toolCallId) => {
+                    startedToolCallIds.add(toolCallId);
+                    if (resume !== undefined && resume.cp.pendingAction.kind === "tool_approval" && toolCallId === resume.cp.pendingAction.toolCallId) {
+                        resume.pendingActionStarted = true;
+                    }
+                });
+                if (resume.outcome.gate === "policy_ask")
+                    resume.decisionDelivered = true;
+                announceWorkspaceMove();
+            }
+            if (resumeWindowRetryAfterMs !== undefined) {
+            }
+            else if (walltimeExhaustedResume) {
+                timeout.fired = true;
+                timeout.clear();
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            else if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow <= 0) {
+                rs.limits.budgetHit = "exceeded";
+                rs.limits.budgetAxis = "tokens";
+            }
+            else if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd <= 0) {
+                rs.limits.budgetHit = "exceeded";
+                rs.limits.budgetAxis = "cost";
+            }
+            else {
+                let continuation = resumeContinuation(resume, prepared.reminderMark);
+                const bgSnapshot = resume.cp.state.runningBackgroundTasks;
+                if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
+                    const alive = new Set(prepared.listBackgroundTasks().map((t) => t.id));
+                    const orphans = bgSnapshot.filter((t) => !alive.has(t.id));
+                    if (orphans.length > 0) {
+                        continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphans), prepared.reminderMark);
+                    }
+                }
+                let gitResumeDelivered;
+                {
+                    const gitBody = await resolveGitLegDelivery(prepared, resume.cp.state.gitAnnouncement, (err) => {
+                        try {
+                            runner.deps.onError?.(new Error(`git announcement ladder unreadable (conservative re-announce): ${err.message}`), { phase: "degraded", sessionId: prepared.sessionId });
+                        }
+                        catch {
+                        }
+                    });
+                    const gitFrame = prepared.gitStatusRef.frame;
+                    if (gitBody !== undefined && gitFrame !== undefined) {
+                        const wrappedGit = wrapGitFrame(gitBody, prepared.reminderMark);
+                        continuation += "\n\n" + wrappedGit;
+                        gitResumeDelivered = { kind: gitFrame.kind, hash: gitFrame.hash, wrapped: wrappedGit };
+                        if (gitFrame.kind === "full" && gitFrame.shrunk !== undefined) {
+                            prepared.gitStatusRef.wrappedShrink = { find: wrappedGit, replace: wrapGitFrame(gitFrame.shrunk.body, prepared.reminderMark) };
+                        }
+                    }
+                }
+                const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
+                const resumeFrames = [
+                    ...readPendingSteerQueue(resume.cp.state).map((entry) => ({ entry, source: "steer" })),
+                    ...(resume.wakeMessage !== undefined ? [{ entry: resume.wakeMessage, source: "wake" }] : []),
+                ];
+                for (const { entry: steer, source } of resumeFrames) {
+                    if (source === "wake" && resume.wakeMessageHookContext !== undefined) {
+                        const hookStart = continuation.length;
+                        continuation += "\n\n" + formatHookFeedback(resume.wakeMessageHookContext, prepared.reminderMark);
+                        engineSegments.push({ start: hookStart, end: continuation.length });
+                    }
+                    if (source === "steer") {
+                        const parkedScreen = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
+                        if (parkedScreen !== undefined) {
+                            let outcome;
+                            try {
+                                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => parkedScreen(steer.text, {
+                                    identity: prepared.hookIdentity,
+                                    signal: sig,
+                                    source: "parked_redelivery",
+                                    ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                    ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
+                                }));
+                                outcome = seat.expired
+                                    ? { blocked: seat.cause === "timeout" ? `the screen did not answer within its ${prepared.hookTimeoutMs}ms bound (fail-closed)` : "the run was cancelled while the screen was still deciding (fail-closed)" }
+                                    : seat.value?.block !== undefined && seat.value.block !== ""
+                                        ? { blocked: inlineUntrusted(seat.value.block) }
+                                        : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
+                            }
+                            catch (hookErr) {
+                                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                                try {
+                                    runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                                }
+                                catch {
+                                }
+                                outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
+                            }
+                            if ("blocked" in outcome) {
+                                deliverEngineNotice(runner.deps.onNotice, {
+                                    code: "steering.parked_input_blocked",
+                                    message: "a parked steering input was withheld by the deployment's userPromptSubmit screen when this resume redelivered it: " +
+                                        `${outcome.blocked}. The parked row was consumed with the checkpoint; the instruction never reached the model — ` +
+                                        "re-issue it if it still applies.",
+                                    detail: {
+                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                        sessionId: prepared.sessionId,
+                                        runId: prepared.runId,
+                                        ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                                    },
+                                });
+                                queue.push({
+                                    ...buildHumanInputEvent({
+                                        carrier: source,
+                                        source,
+                                        delivery: "blocked",
+                                        sessionSeq: nextHumanInputSeq(prepared.harness),
+                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                        ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
+                                        ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
+                                        ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                                    }),
+                                    ...ident(),
+                                });
+                                continue;
+                            }
+                            if ("context" in outcome && outcome.context !== undefined) {
+                                const hookStart = continuation.length;
+                                continuation += "\n\n" + formatHookFeedback(outcome.context, prepared.reminderMark);
+                                engineSegments.push({ start: hookStart, end: continuation.length });
+                            }
+                        }
+                    }
+                    const start = continuation.length;
+                    const projected = projectHumanInput({ text: steer.text, actor: steer.actor, source });
+                    continuation +=
+                        "\n\n" +
+                            (steer.trusted ? formatHookFeedback(projected, prepared.reminderMark) : delimitUntrusted("supervisor steering message", projected));
+                    if (steer.trusted)
+                        engineSegments.push({ start, end: continuation.length });
+                    queue.push({
+                        ...buildHumanInputEvent({
+                            carrier: source,
+                            source,
+                            delivery: "applied",
+                            sessionSeq: nextHumanInputSeq(prepared.harness),
+                            inputId: steer.inputId,
+                            ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
+                            ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
+                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                        }),
+                        ...ident(),
+                    });
+                }
+                if (resume !== undefined)
+                    resume.decisionDelivered = true;
+                if (gitResumeDelivered !== undefined) {
+                    const delivered = gitResumeDelivered;
+                    prepared.gitStatusRef.protectedText = delivered.wrapped;
+                    prepared.gitStatusRef.pendingReceipt = {
+                        text: continuation,
+                        commit: (entryId) => {
+                            prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
+                            queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
+                            rs.attach.attachmentsInjected += 1;
+                            prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
+                        },
+                    };
+                }
+                final = await withBrainSinks(() => prepared.harness.prompt(continuation, { engineSegments }));
+                await flushGitMirror();
+                if (prepared.gitStatusRef.announced?.pending === true)
+                    await prepared.gitStatusRef.reassert?.();
+            }
+        }
+        else {
+            const objectiveActor = entryActor;
+            const projectedObjective = projectHumanInput({ text: spec.objective, actor: objectiveActor, source: "objective" });
+            let effectiveObjective = projectedObjective;
+            let promptBlocked = false;
+            const userPromptSubmit = (spec.hooks ?? runner.deps.hooks)?.userPromptSubmit;
+            if (userPromptSubmit) {
+                try {
+                    const promptSeat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => userPromptSubmit(spec.objective, { identity: prepared.hookIdentity, signal: sig, source: "objective", ...(objectiveActor !== undefined ? { actor: snapshotActorAssertion(objectiveActor) } : {}) }));
+                    if (promptSeat.expired) {
+                        if (promptSeat.cause === "timeout") {
+                            try {
+                                runner.deps.onError?.(hookSeatExpiredError("userPromptSubmit", prepared.hookTimeoutMs, promptSeat.cause, "the prompt was NOT submitted (fail-closed) and the task ends blocked"), { phase: "hook", sessionId: prepared.sessionId });
+                            }
+                            catch {
+                            }
+                        }
+                        prepared.blockedRef.reason = formatHookFeedback(promptSeat.cause === "timeout"
+                            ? `the deployment's userPromptSubmit hook did not answer within its ${prepared.hookTimeoutMs}ms bound while screening this prompt; ` +
+                                `the prompt was NOT submitted (fail-closed)`
+                            : `the task was cancelled while the deployment's userPromptSubmit hook was still screening this prompt; ` +
+                                `the prompt was NOT submitted (fail-closed)`, prepared.reminderMark);
+                        promptBlocked = true;
+                    }
+                    const decision = promptSeat.expired ? undefined : promptSeat.value;
+                    if (decision?.block) {
+                        prepared.blockedRef.reason = formatHookFeedback(decision.block, prepared.reminderMark);
+                        promptBlocked = true;
+                    }
+                    else if (decision?.additionalContext) {
+                        effectiveObjective = `${formatHookFeedback(decision.additionalContext, prepared.reminderMark)}\n\n${projectedObjective}`;
+                    }
+                }
+                catch (hookErr) {
+                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                    try {
+                        runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                    prepared.blockedRef.reason = formatHookFeedback(`the deployment's userPromptSubmit hook crashed while screening this prompt (${err.message}); ` +
+                        `the prompt was NOT submitted (fail-closed)`, prepared.reminderMark);
+                    promptBlocked = true;
+                }
+            }
+            let gitLegDelivered;
+            if (!promptBlocked) {
+                const gitBody = await resolveGitLegDelivery(prepared, undefined, (err) => {
+                    try {
+                        runner.deps.onError?.(new Error(`git announcement ladder unreadable (conservative re-announce): ${err.message}`), { phase: "degraded", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                });
+                const gitFrame = prepared.gitStatusRef.frame;
+                if (gitBody !== undefined && gitFrame !== undefined) {
+                    const wrappedGit = wrapGitFrame(gitBody, prepared.reminderMark);
+                    const standalone = spec.images !== undefined && spec.images.length > 0;
+                    if (!standalone)
+                        effectiveObjective = `${wrappedGit}\n${effectiveObjective}`;
+                    gitLegDelivered = { kind: gitFrame.kind, hash: gitFrame.hash, standalone, wrapped: wrappedGit };
+                    if (gitFrame.kind === "full" && gitFrame.shrunk !== undefined) {
+                        prepared.gitStatusRef.wrappedShrink = { find: wrappedGit, replace: wrapGitFrame(gitFrame.shrunk.body, prepared.reminderMark) };
+                    }
+                }
+            }
+            const firstFrames = [];
+            if (rs.attach.attachState !== undefined) {
+                const attach = rs.attach.attachState;
+                if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
+                    const listing = prepared.agentListing;
+                    const body = renderAgentListingDelta(attach, listing.entries, listing.toolName, listing.models);
+                    if (body !== undefined) {
+                        firstFrames.push({
+                            source: "agent_listing",
+                            body,
+                            commit: () => {
+                                commitAgentListing(attach, listing.entries, listing.models);
+                                prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
+                                if (listing.models !== undefined)
+                                    prepared.announcedListingsRef.models = [...listing.models];
+                            },
+                        });
+                    }
+                }
+                if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined) {
+                    const listing = prepared.skillsListing;
+                    const body = renderSkillsListingDelta(attach, listing.entries);
+                    if (body !== undefined) {
+                        firstFrames.push({
+                            source: "skills_listing",
+                            body,
+                            commit: () => {
+                                commitSkillsListing(attach, listing.entries);
+                                prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
+                            },
+                        });
+                    }
+                }
+                if (firstFrames.length > 0) {
+                    effectiveObjective = `${firstFrames.map((f) => mintSystemReminder(sanitizeUntrustedText(f.body, attachmentEnvelopeTags(f.source)), prepared.reminderMark)).join("\n")}\n${effectiveObjective}`;
+                }
+            }
+            const gitQueuedChars = gitLegDelivered !== undefined && gitLegDelivered.standalone ? gitLegDelivered.wrapped.length : 0;
+            const precallMicroUsd = rs.budget.maxCostMicroUsd === undefined
+                ? 0
+                : computeCostMicroUsd({
+                    totalInputTokens: Math.ceil((effectiveObjective.length + gitQueuedChars) / 4),
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                    cacheWriteTokensLong: 0,
+                    outputTokens: prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS,
+                }, rs.telemetry.pricing);
+            const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? rs.budget.remainingMicroUsd : rs.budget.maxCostMicroUsd;
+            const precallTokens = Math.ceil((effectiveObjective.length + gitQueuedChars) / 4) + (prepared.model.maxTokens ?? DEFAULT_PRECALL_OUTPUT_TOKENS);
+            const precallCeilingTokens = prepared.suspendForResource !== undefined ? rs.budget.remainingTokens : rs.budget.maxTokensWindow;
+            const entryUsageRetryAfterMs = prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
+            if (promptBlocked) {
+            }
+            else if (entryUsageRetryAfterMs !== undefined) {
+                const terminal = platformLimitTerminal("usage_window", entryUsageRetryAfterMs, "entry");
+                rs.limits.platformTerminal = terminal;
+                try {
+                    runner.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
+                }
+                catch {
+                }
+            }
+            else if (precallCeilingTokens !== undefined && precallTokens > precallCeilingTokens) {
+                rs.limits.budgetHit = "precall";
+                rs.limits.budgetAxis = "tokens";
+            }
+            else if (precallCeilingMicroUsd !== undefined && precallMicroUsd > precallCeilingMicroUsd) {
+                rs.limits.budgetHit = "precall";
+                rs.limits.budgetAxis = "cost";
+            }
+            else if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
+                timeout.fired = true;
+                timeout.clear();
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            else {
+                const images = spec.images
+                    ? await Promise.all(spec.images.map((img) => toImageContent(img, runner.deps.allowImageUrl)))
+                    : undefined;
+                if (gitLegDelivered !== undefined) {
+                    const delivered = gitLegDelivered;
+                    if (delivered.standalone)
+                        await prepared.harness.nextTurn(delivered.wrapped, { engineMinted: true });
+                    prepared.gitStatusRef.protectedText = delivered.wrapped;
+                    prepared.gitStatusRef.pendingReceipt = {
+                        text: delivered.standalone ? delivered.wrapped : effectiveObjective,
+                        commit: (entryId) => {
+                            prepared.gitStatusRef.announced = { kind: delivered.kind, hash: delivered.hash, entryId };
+                            queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[delivered.kind], ...ident() });
+                            rs.attach.attachmentsInjected += 1;
+                            prepared.gitStatusRef.mirrorOwed = { kind: delivered.kind, hash: delivered.hash, entryId };
+                        },
+                    };
+                }
+                for (const f of firstFrames) {
+                    f.commit();
+                    queue.push({ type: "steering_injected", source: f.source, preview: redactThenCut(f.body, 220), ...ident() });
+                }
+                rs.attach.attachmentsInjected += firstFrames.length;
+                if (firstFrames.length > 0 && prepared.announcedSnapshotRecovered)
+                    await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                const enginePrefixChars = effectiveObjective.length - projectedObjective.length;
+                queue.push({
+                    ...buildHumanInputEvent({
+                        carrier: "objective",
+                        source: "objective",
+                        delivery: "applied",
+                        sessionSeq: nextHumanInputSeq(prepared.harness),
+                        ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
+                        ...(objectiveActor?.issuer !== undefined ? { issuer: objectiveActor.issuer } : {}),
+                        ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                    }),
+                    ...ident(),
+                });
+                final = await withBrainSinks(() => prepared.harness.prompt(effectiveObjective, {
+                    ...(images && images.length > 0 ? { images } : {}),
+                    ...(enginePrefixChars > 0 ? { enginePrefixChars } : {}),
+                    ...(objectiveActor !== undefined ? { actor: objectiveActor } : {}),
+                }));
+                await flushGitMirror();
+                if (prepared.gitStatusRef.announced?.pending === true)
+                    await prepared.gitStatusRef.reassert?.();
+            }
+        }
+        loopLatch.ended = true;
+        abortedLive = prepared.abortController.signal.aborted;
+        userInterruptedLive = loopLatch.userInterrupted;
+    }
+    catch (err) {
+        loopLatch.ended = true;
+        if (errorCodeOf(err) === "resume.tool_unavailable" || errorCodeOf(err) === "resume.tool_contract_mismatch") {
+            await settleTeardownLeg(() => prepared.mcp.dispose(), "mcp.dispose (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            await settleTeardownLeg(() => prepared.a2a?.dispose(), "a2a.dispose (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            await settleTeardownLeg(() => (prepared.ownedEnv && hasDestroy(prepared.ownedEnv) ? prepared.ownedEnv.destroy() : undefined), "ownedEnv.destroy (tool_unavailable leg)", (e) => runner.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
+            throw err;
+        }
+        threw = err;
+        abortedLive = prepared.abortController.signal.aborted;
+        userInterruptedLive = loopLatch.userInterrupted;
+    }
+    finally {
+        timeout.clear();
+        prepared.lspDiagnostics?.registry.releaseRun(prepared.lspDiagnostics.runIdent);
+        prepared.abortController.abort();
+        prepared.releaseSignal();
+        strandedHumanAnswers = prepared.settleContentAskBindings();
+        try {
+            prepared.harness.recoverUndrainedEngineNotes();
+        }
+        catch {
+        }
+        notificationLane.live = false;
+        unsubscribeTaskNotifications();
+        prepared.toolRosterDeltas.unsubscribe();
+        unsubGitRetry();
+        unsubBoundary();
+        unsub();
+    }
+    return await next({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers });
+}
+const ORG_DISCLOSURE_MAX_CHARS = 600;
+async function applyResumeDecision(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
+    const { pendingAction } = resume.cp;
+    if (resume.outcome.gate === "dry_run_review")
+        return;
+    if (resume.outcome.gate === "plan_review")
+        return;
+    if (pendingAction.kind !== "tool_approval")
+        return;
+    if (resume.outcome.gate === "policy_ask" &&
+        resume.outcome.decision === "allow" &&
+        !prepared.tools.some((t) => t.name === pendingAction.toolName)) {
+        const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume — refusing to continue as if it ran; the checkpoint is reopened for a retry with the tool present`);
+        e.code = "resume.tool_unavailable";
+        throw e;
+    }
+    const liveRoster = prepared.toolRosterDeltas.current;
+    if (pendingAction.kind === "tool_approval" && liveRoster !== undefined && judgeParkedToolIdentity(pendingAction, rosterEntryNamed(liveRoster, pendingAction.toolName)) === "mismatch") {
+        const e = new Error(`the approved tool "${pendingAction.toolName}" on this leg is not the tool the approval was minted against (its contract / shape / revision differ) — refusing to execute a replacement wearing the name; the checkpoint is reopened for a retry with the original tool present`);
+        e.code = "resume.tool_contract_mismatch";
+        throw e;
+    }
+    const completed = new Set(pendingAction.completedCallIds);
+    const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
+    const names = new Map();
+    const deferredArgs = new Map();
+    if (deferredIds.length > 0) {
+        const { messages } = await prepared.session.buildContext();
+        for (const m of messages) {
+            if (m.role === "assistant") {
+                for (const c of m.content) {
+                    if (c.type === "toolCall") {
+                        names.set(c.id, c.name);
+                        deferredArgs.set(c.id, c.arguments);
+                    }
+                }
+            }
+        }
+    }
+    for (const id of pendingAction.batchToolCallIds) {
+        if (id === pendingAction.toolCallId) {
+            await resolvePendingCall(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart);
+        }
+        else if (!completed.has(id)) {
+            const name = names.get(id) ?? "unknown";
+            const displayLabel = (() => {
+                const l = prepared.tools.find((t) => t.name === name)?.label;
+                return l !== undefined && l !== name ? { label: l } : {};
+            })();
+            emit({ type: "tool_start", toolCallId: id, toolName: name, ...displayLabel, args: deferredArgs.get(id) ?? {} });
+            emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark) }, true, prepared.structuredProjector) });
+            const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark), true));
+            emitCommitted(eid, "toolResult", id);
+        }
+    }
+}
+async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
+    const { pendingAction } = resume.cp;
+    const { outcome } = resume;
+    if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
+        return;
+    const decidedGate = outcome.gateOutcome;
+    if (decidedGate === undefined) {
+        throw new CheckpointError("checkpoint.invalid_outcome", "pending action reached the resolver with no settlement record on its decision (gateOutcome) — refusing to execute or settle a decision that carries no record");
+    }
+    const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput !== undefined ? outcome.updatedInput : pendingAction.args);
+    const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
+    emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
+    const settleEnd = async (isError, result, gate = decidedGate) => {
+        emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, prepared.structuredProjector, gate) });
+        const word = await resume.recordExecutionOutcome(gate);
+        settleExecutionRecord(runner.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
+    };
+    const vetoed = (layer) => mintGateOutcome({
+        deniedBy: layer,
+        ...(outcome.gateOutcome?.settlement !== undefined && outcome.gateOutcome.origin !== undefined ? { settled: { settlement: outcome.gateOutcome.settlement, origin: outcome.gateOutcome.origin } } : {}),
+    });
+    if (outcome.decision === "deny") {
+        const defaultDenial = outcome.gateOutcome?.settlement?.kind === "park_sla_expired"
+            ? `No one answered the approval request for the pending tool call "${pendingAction.toolName}" — the approval window elapsed with no answer, so it was not executed.`
+            : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
+        const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY) : defaultDenial;
+        await settleEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
+        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason, prepared.reminderMark), true));
+        emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+        return;
+    }
+    if (outcome.decision !== "allow") {
+        throw new CheckpointError("checkpoint.invalid_outcome", `pending action reached the resolver with decision "${String(outcome.decision)}" — only "allow" executes and only "deny" injects a denial; refusing to execute`);
+    }
+    const beltBudget = {
+        resourceRemainingMicroUsd: remainingBudgetMicroUsd(prepared.resourceLedger),
+        resourceSpentMicroUsd: prepared.resourceLedger?.spentMicroUsd ?? 0,
+        suspendCount: resume.cp.suspendCount ?? 0,
+    };
+    if (outcome.decision === "allow" && outcome.updatedInput !== undefined && prepared.basePolicyForResumeEdit) {
+        const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check({
+            toolName: pendingAction.toolName,
+            args: resolvedArgs,
+            toolCallId: pendingAction.toolCallId,
+            budget: beltBudget,
+            ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+            ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
+        }, prepared.abortController.signal));
+        const beltUnsafe = rechecked.action === "deny" ||
+            (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, resolvedArgs));
+        if (beltUnsafe) {
+            const editedDenial = formatHookFeedback(`The approver EDITED this call's input; the edited call is refused by the deployment's tool policy and was not executed${rechecked.action === "deny" && rechecked.message ? `: ${rechecked.message}` : " (the policy rewrote the edit to a value that was not approved)"}.`, prepared.reminderMark);
+            await settleEnd(true, { content: editedDenial }, vetoed("policy"));
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            return;
+        }
+    }
+    const gateRealApproval = resume.cp.gate.kind === "irreversible_ask" ? resume.cp.gate.realApproval : undefined;
+    const gateOrgGoverned = realApprovalOrgFact(gateRealApproval) !== undefined;
+    if (gateOrgGoverned && prepared.permissionRuleOrg === undefined) {
+        const unwiredDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its approval was minted under organization governance (${gateRealApproval.origin}), and this worker has no org adjudication wiring — a governed approval may only be redeemed where governance can be enforced. This approval is spent; re-issue the call on an org-wired worker.`, prepared.reminderMark);
+        await settleEnd(true, { content: unwiredDenial }, vetoed("org"));
+        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
+        emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+        return;
+    }
+    if (prepared.permissionRuleOrg !== undefined) {
+        const orgVerdict = prepared.permissionRuleOrg
+            .adjudicate({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId })
+            .catch(() => ({ status: "unavailable", disclosures: ["the org adjudication face threw on resume"] }));
+        let orgWaitCancelled = false;
+        const org = await settleOrgVerdictWithin(orgVerdict, { status: "unavailable", disclosures: [`the org adjudication face did not answer within ${ORG_ADJUDICATION_TIMEOUT_MS}ms (or the task ended first)`] }, {
+            signal: prepared.abortController.signal,
+            timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS,
+            onFallback: (cause) => {
+                orgWaitCancelled = cause === "aborted";
+            },
+        });
+        const blocked = org.status === "unavailable"
+            ? realApprovalOrgFact(gateRealApproval) === "unavailable"
+                ? undefined
+                : orgWaitCancelled
+                    ? "this deployment is org-governed and the task was cancelled before the organization policy snapshot could be adjudicated"
+                    : "this deployment is org-governed and cannot currently adjudicate against an organization policy snapshot"
+            : org.verdict?.behavior === "deny"
+                ? `an organization policy rule (${org.verdict.rule}) denies it`
+                : undefined;
+        if (blocked !== undefined) {
+            const orgDisclosures = org.status === "unavailable" && org.disclosures.length > 0
+                ? ` Governance disclosures: ${inlineUntrusted(org.disclosures.join("; "), ORG_DISCLOSURE_MAX_CHARS)}.`
+                : "";
+            const orgDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${blocked}.${orgDisclosures} This approval is spent — the call has to be re-issued and approved again once organization policy permits it.`, prepared.reminderMark);
+            await settleEnd(true, { content: orgDenial }, vetoed("org"));
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            return;
+        }
+    }
+    if (prepared.denyNarrowingPolicy) {
+        const narrowed = refuseOutOfContractDecision(await prepared.denyNarrowingPolicy.check({
+            toolName: pendingAction.toolName,
+            args: resolvedArgs,
+            toolCallId: pendingAction.toolCallId,
+            ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
+            budget: beltBudget,
+            ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+        }, prepared.abortController.signal));
+        if (narrowed.action === "deny") {
+            const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
+            await settleEnd(true, { content: narrowedDenial }, vetoed("policy"));
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            return;
+        }
+    }
+    if (prepared.persistedRuleLane !== undefined) {
+        const unreadable = { unreadable: true };
+        const read = await settleOrgVerdictWithin(Promise.resolve()
+            .then(() => prepared.persistedRuleLane.adjudicate({
+            toolName: pendingAction.toolName,
+            args: resolvedArgs,
+            toolCallId: pendingAction.toolCallId,
+            ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
+            budget: beltBudget,
+            ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
+        }))
+            .then((answer) => normalizePersistedRuleHit(answer)), unreadable, { signal: prepared.abortController.signal, timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS });
+        const tightened = applyPersistedTightening({ action: "allow" }, read);
+        if (tightened.tightened === "deny" || tightened.tightened === "unreadable") {
+            const why = tightened.tightened === "deny"
+                ? `a standing deny rule of yours (${disclosedRuleSet(read.hit?.rules ?? [])}) now refuses it`
+                : "your persisted permission rules could not be read on this leg";
+            const ruleDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${why}. This approval is spent — the call has to be re-issued and approved again.`, prepared.reminderMark);
+            await settleEnd(true, { content: ruleDenial }, vetoed("persisted_rule"));
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, ruleDenial, true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            return;
+        }
+    }
+    const tool = prepared.tools.find((t) => t.name === pendingAction.toolName);
+    if (!tool) {
+        const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume`);
+        e.code = "resume.tool_unavailable";
+        throw e;
+    }
+    const args = resolvedArgs;
+    onExecuteStart?.(pendingAction.toolCallId);
+    prepared.suspendProgressRef.executedApproved = true;
+    let res;
+    try {
+        res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
+    }
+    catch (err) {
+        const execError = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        const marks = (() => {
+            if (err === null || typeof err !== "object")
+                return undefined;
+            const src = err;
+            let d;
+            if (src.details !== null && typeof src.details === "object" && !Array.isArray(src.details)) {
+                d = { ...src.details };
+            }
+            if (typeof src.errorKind === "string")
+                d = { ...(d ?? {}), errorKind: src.errorKind };
+            return d;
+        })();
+        await settleEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
+        const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, execError, true));
+        emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+        return;
+    }
+    const executedIsError = res.isError === true;
+    await settleEnd(executedIsError, res);
+    onResolvedToolSuccess?.(pendingAction.toolName, executedIsError ? undefined : res.details);
+    const eid = await prepared.session.appendMessage({
+        role: "toolResult",
+        toolCallId: pendingAction.toolCallId,
+        toolName: pendingAction.toolName,
+        content: res.content,
+        details: res.details,
+        isError: executedIsError,
+        timestamp: Date.now(),
+    });
+    emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+}