@sema-agent/core 7.12.0 → 7.13.0

package/dist/core/runner/runtask.js

@@ -1,44 +1,29 @@
 import { deliverEngineNotice } from "../types.js";
-import { DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
+import { uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, remainingBudgetMicroUsd, realApprovalOrgFact } from "../checkpoint-store.js";
-import { settleExecutionRecord } from "./execution-record.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact } from "../auto-compaction.js";
-import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
+import { CheckpointError } from "../checkpoint-store.js";
+import { createRapidRefillState } from "../auto-compaction.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
-import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { adjudicateDerivedRoute, authCarrierFingerprint, fallbackToPrimaryNotice, normalizeBaseUrl, sameRouteIdentity } from "../../brain/route-adjudicator.js";
+import { authCarrierFingerprint, normalizeBaseUrl } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
-import { expandTiers, resolveTaskModel } from "../roles.js";
+import { expandTiers } from "../roles.js";
 import { screenSwappableDeps } from "../swappable-deps.js";
 import { runSideQuery } from "../side-query.js";
-import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { PushQueue } from "../push-queue.js";
 import { TtlSessionStore } from "../session-store.js";
 import { errorCodeOf } from "./assemble-result.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
 import { effectiveDelegationFacts, prepareTask } from "./prepare-task.js";
-import { callFaceSeat, judgeParkedToolIdentity, rosterEntryNamed, toolCallFaceOf } from "../tool-roster.js";
-import { normalizePersistedRuleHit } from "../gate-lanes.js";
-import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-arms.js";
 import { SessionReadFileStates } from "./prepare-hands-readface.js";
-import { hasDestroy } from "../remote-env.js";
-import { formatHookFeedback, hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
-import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY } from "../untrusted-text.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { PAUSE_REGISTRY } from "../pause-registry.js";
-import { refuseOutOfContractDecision, toolPolicyNameSets } from "../tool-policy.js";
-import { mintGateOutcome } from "./gate-exit.js";
+import { toolPolicyNameSets } from "../tool-policy.js";
 import { PendingSessionNotifications } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createRunState } from "./initial-run-state.js";
-import { reconciledToolEndBody, toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
-import { answerFaceForRedeemedCall, deepJsonEqual, DEFERRED_REISSUE } from "./decide-continuation.js";
-import { discloseUnevaluableWindow } from "./clock-and-limits.js";
-import { gitRestateOption } from "./git-leg-delivery.js";
+import { reconciledToolEndBody } from "./tool-end-body.js";
+import { answerFaceForRedeemedCall } from "./decide-continuation.js";
 import { createTurnBoundary } from "./run-turn-boundary.js";
 import { createHarnessHandlers } from "./run-harness-handlers.js";
 import { resumeAdmission } from "./resume-admission.js";
@@ -69,11 +54,6 @@ import { runCompactionMachinery } from "./run-compaction-machinery.js";
 import { runStopAndFinalVerify } from "./run-stop-and-final-verify.js";
 import { runRecoveryLanes } from "./run-recovery-lanes.js";
 import { runGitLane } from "./run-git-lane.js";
-const ORG_DISCLOSURE_MAX_CHARS = 600;
-const SUGGESTIONS_DEFAULT_COUNT = 3;
-const SUGGESTIONS_MAX_COUNT = 8;
-const SUGGESTIONS_TIMEOUT_MS = 30_000;
-const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
 export class Runner {
     deps;
     sessions;
@@ -415,174 +395,81 @@ export class Runner {
         };
     }
     runLocked(input) {
-        const { spec, queue, resume, internals, taskIdRef } = input;
+        const { spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer } = input;
         return runNotificationLane({
             spec, queue, resume, internals, taskIdRef,
             runner: this.depsSeat, self: this, sessions: this.sessions, sessionReadStates: this.sessionReadStates, pendingSessionNotifications: this.pendingSessionNotifications,
             prepareTask,
-            next: (lane) => this.runSeatLanes(input, lane),
-        });
-    }
-    runSeatLanes(input, lane) {
-        const { spec, queue, onReady, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryTracer } = input;
-        const { prepared, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, modelCatalog, notificationLane } = lane;
-        const { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, undrainedUserAtEnd } = runIdentityWiring({
-            spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef,
-            notificationLane, pendingSessionNotifications: this.pendingSessionNotifications, runner: this.depsSeat,
-        });
-        const rs = createRunState();
-        const { noteUnevaluablePriceTable } = runTelemetryAndBudgetSeats({ spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner: this.depsSeat, sessions: this.sessions });
-        return runAttachmentSeats({
-            spec, prepared, resume, rs, runner: this.depsSeat,
-            next: () => this.runAssembliesAndLegs(input, lane, { rs, stats, ident, parentToolCallId, emitDelegationLifecycle, loopLatch, undrainedUserAtEnd, noteUnevaluablePriceTable }),
-        });
-    }
-    runAssembliesAndLegs(input, lane, seats) {
-        const { spec, queue, setResult, onSuggestions, onSuspend, manualCompactRef, taskIdRef, resume, internals, entryActor } = input;
-        const { prepared, notificationLane, unsubscribeTaskNotifications } = lane;
-        const { rs, stats, ident, parentToolCallId, emitDelegationLifecycle, loopLatch, undrainedUserAtEnd, noteUnevaluablePriceTable } = seats;
-        const { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds } = runToolMountFacts({ spec, prepared, rs });
-        const { observeReasoningWireFacts, reasoningResolution } = runReasoningSeat({ prepared, rs, taskIdRef });
-        const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
-        const { subagentName, withBrainSinks } = runBrainSinks({ queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts });
-        const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
-        for (const orphan of prepared.wakeRecovered) {
-            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
-            emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
-        }
-        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
-        const batchArgs = postToolBatchHook ? new Map() : undefined;
-        rs.turn.toolBatch = [];
-        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
-            prepared, stats, rs,
-            deps: {
-                spec, queue, internals, ident, parentToolCallId, subagentName,
-                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
-                toolLabels, postToolBatchHook, batchArgs,
-                runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
-            },
-        });
-        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, runner: this.depsSeat });
-        runStopAndFinalVerify({ spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner: this.depsSeat });
-        runRecoveryLanes({
-            spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner: this.depsSeat,
-            compactionSeats: {
-                seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
-                compactionHookOptions: (s, sid, trig, identity, seatBound) => this.compactionHookOptions(s, sid, trig, identity, seatBound),
-                recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
-            },
-        });
-        const rapidRefill = createRapidRefillState();
-        const drainManualCompact = (outcome) => {
-            manualCompactRef.requested = false;
-            for (const w of manualCompactRef.waiters.splice(0))
-                w.resolve(outcome);
-        };
-        const onTurnBoundary = createTurnBoundary({
-            prepared, stats, rs,
-            deps: {
-                spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
-                walltimeMonotonicDeadline,
-                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
-                compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
-                runnerHooks: {
-                    onError: this.deps.onError,
-                    seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
-                    compactionHookOptions: (s, sid, trig) => this.compactionHookOptions(s, sid, trig, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
-                    recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
-                },
+            next: ({ prepared, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, modelCatalog, notificationLane, unsubscribeTaskNotifications }) => {
+                const { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, undrainedUserAtEnd, userInputLostAtEnd } = runIdentityWiring({
+                    spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef,
+                    notificationLane, pendingSessionNotifications: this.pendingSessionNotifications, runner: this.depsSeat,
+                });
+                const rs = createRunState();
+                const { noteUnevaluablePriceTable } = runTelemetryAndBudgetSeats({ spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner: this.depsSeat, sessions: this.sessions });
+                return runAttachmentSeats({
+                    spec, prepared, resume, rs, runner: this.depsSeat,
+                    next: () => {
+                        const { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds } = runToolMountFacts({ spec, prepared, rs });
+                        const { observeReasoningWireFacts, reasoningResolution } = runReasoningSeat({ prepared, rs, taskIdRef });
+                        const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
+                        const { subagentName, withBrainSinks } = runBrainSinks({ queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts });
+                        const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
+                        for (const orphan of prepared.wakeRecovered) {
+                            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
+                            emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
+                        }
+                        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
+                        const batchArgs = postToolBatchHook ? new Map() : undefined;
+                        rs.turn.toolBatch = [];
+                        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
+                            prepared, stats, rs,
+                            deps: {
+                                spec, queue, internals, ident, parentToolCallId, subagentName,
+                                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
+                                toolLabels, postToolBatchHook, batchArgs,
+                                runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
+                            },
+                        });
+                        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, runner: this.depsSeat });
+                        runStopAndFinalVerify({ spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner: this.depsSeat });
+                        runRecoveryLanes({ spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner: this.depsSeat });
+                        const rapidRefill = createRapidRefillState();
+                        const drainManualCompact = (outcome) => {
+                            manualCompactRef.requested = false;
+                            for (const w of manualCompactRef.waiters.splice(0))
+                                w.resolve(outcome);
+                        };
+                        const onTurnBoundary = createTurnBoundary({
+                            prepared, stats, rs,
+                            deps: {
+                                spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
+                                walltimeMonotonicDeadline,
+                                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
+                                compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
+                                runnerHooks: { onError: this.deps.onError },
+                                runner: this.depsSeat,
+                            },
+                        });
+                        const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
+                        return runLeg({
+                            spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
+                            announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub,
+                            runner: this.depsSeat,
+                            next: ({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers }) => runTerminalAdoption({
+                                spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions,
+                                undrainedUserAtEnd, userInputLostAtEnd, final, threw, abortedLive, userInterruptedLive, runner: this.depsSeat, sessions: this.sessions,
+                                next: ({ threw, comp, answerSettled }) => runSettleAndTeardown({
+                                    spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef,
+                                    emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp,
+                                    setResult, onSuggestions, onSuspend, runner: this.depsSeat, sessions: this.sessions,
+                                }),
+                            }),
+                        });
+                    },
+                });
             },
         });
-        const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
-        return runLeg({
-            spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
-            announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub,
-            runner: this.depsSeat,
-            applyResumeDecision: (p, r, emit, committed, onResolved, onStart) => this.applyResumeDecision(p, r, emit, committed, onResolved, onStart),
-            next: ({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers }) => runTerminalAdoption({
-                spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions,
-                undrainedUserAtEnd, final, threw, abortedLive, userInterruptedLive, runner: this.depsSeat,
-                finish: (s, p, o) => this.finish(s, p, o),
-                next: ({ threw, comp }) => runSettleAndTeardown({
-                    spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef,
-                    emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, strandedHumanAnswers, reasoningResolution, comp,
-                    setResult, onSuggestions, onSuspend, runner: this.depsSeat, sessions: this.sessions,
-                    suggestNextPrompts: (s, p, r) => this.suggestNextPrompts(s, p, r),
-                    teardownOwnedEnv: (p) => this.teardownOwnedEnv(p),
-                }),
-            }),
-        });
-    }
-    async suggestNextPrompts(spec, prepared, result) {
-        const cfg = typeof spec.suggestNextPrompts === "object" ? spec.suggestNextPrompts : {};
-        const count = cfg.count && cfg.count > 0 ? Math.min(cfg.count, SUGGESTIONS_MAX_COUNT) : SUGGESTIONS_DEFAULT_COUNT;
-        const ac = new AbortController();
-        let timer;
-        const timeout = new Promise((resolve) => {
-            timer = setTimeout(() => {
-                ac.abort();
-                resolve([]);
-            }, SUGGESTIONS_TIMEOUT_MS);
-        });
-        const work = (async () => {
-            let model = prepared.model;
-            let thinking = prepared.thinking;
-            try {
-                const resolved = resolveTaskModel({ modelRole: cfg.role ?? "summarize", roles: spec.roles }, this.deps);
-                model = resolved.model;
-                thinking = resolved.thinking;
-            }
-            catch (roleErr) {
-                if (cfg.role !== undefined) {
-                    let asked;
-                    try {
-                        asked = String(cfg.role);
-                    }
-                    catch {
-                        asked = `<unrenderable ${typeof cfg.role}>`;
-                    }
-                    try {
-                        this.deps.onError?.(new Error(`suggestNextPrompts.role ${JSON.stringify(asked.length > 80 ? `${asked.slice(0, 80)}…` : asked)} did not resolve to a model — the prompt-suggestion pass ran on the task's own model (${prepared.model.id}) instead. Configure that role in RunnerDeps.roles / TaskSpec.roles, or omit the field to use the "summarize" role.`, { cause: roleErr }), { phase: "suggestions", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            if (!sameRouteIdentity(model, prepared.model)) {
-                const verdict = await adjudicateDerivedRoute({ brain: this.deps.brain, model, getApiKeyAndHeaders: spec.getApiKeyAndHeaders });
-                if (verdict !== undefined && !verdict.ok) {
-                    deliverEngineNotice(this.deps.onNotice, fallbackToPrimaryNotice({ seat: "prompt-suggestions", from: model.id, to: prepared.model.id, verdict, sessionId: prepared.sessionId, runId: prepared.runId }));
-                    model = prepared.model;
-                    thinking = prepared.thinking;
-                }
-            }
-            const pricing = this.deps.pricing?.[model.id] ?? modelCostToPricing(model.cost);
-            const ctx = await prepared.session.buildContext();
-            const transcript = ctx.messages.filter((m) => !isSyntheticApiErrorMessage(m)).slice(-SUGGESTIONS_TRANSCRIPT_MESSAGES);
-            const out = await generatePromptSuggestions({ brain: this.deps.brain, model, pricing, thinking, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, signal: ac.signal }, transcript, count);
-            if (out.tokens > 0 || out.costMicroUsd > 0) {
-                result.stats.suggestions = { tokens: out.tokens, costMicroUsd: out.costMicroUsd };
-                if (result.stats.costBreakdown) {
-                    result.stats.costBreakdown.suggestionsMicroUsd = out.costMicroUsd;
-                }
-            }
-            return out.suggestions;
-        })();
-        work.catch(() => { });
-        try {
-            return await Promise.race([work, timeout]);
-        }
-        catch (err) {
-            try {
-                this.deps.onError?.(err, { phase: "suggestions", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-            return [];
-        }
-        finally {
-            clearTimeout(timer);
-        }
     }
     async runTask(spec, internals) {
         const stream = this.runTaskStream(spec, undefined, internals);
@@ -683,412 +570,6 @@ export class Runner {
         }
         return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, recordExecutionOutcome, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
     }
-    async applyResumeDecision(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 this.resolvePendingCall(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 resolvePendingCall(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(this.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
-        };
-        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);
-    }
-    seamCCompactionOptions(prepared) {
-        if (!this.deps.summaryProvider)
-            return undefined;
-        return {
-            summaryProvider: this.deps.summaryProvider,
-            onCompaction: this.deps.onCompaction,
-            maxConsecutiveProviderReuse: this.deps.maxConsecutiveProviderReuse,
-            consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
-        };
-    }
-    compactionHookOptions(spec, sessionId, trigger, identity, seatBound) {
-        const hooks = spec.hooks ?? this.deps.hooks;
-        const pre = hooks?.preCompact;
-        const post = hooks?.postCompact;
-        const seatMs = seatBound?.timeoutMs ?? resolveHookTimeoutMs(hooks?.timeoutMs);
-        const seatSignal = seatBound?.signal;
-        const withIdentity = (ctx) => identity !== undefined ? { ...ctx, identity } : ctx;
-        return {
-            trigger,
-            ...(pre
-                ? {
-                    preCompact: async (rawCtx) => {
-                        const ctx = withIdentity(rawCtx);
-                        const report = (err) => {
-                            try {
-                                this.deps.onError?.(err, { phase: "hook", sessionId });
-                            }
-                            catch {
-                            }
-                        };
-                        try {
-                            const seat = await runHookSeat("preCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => pre.call(hooks, { ...ctx, signal: sig }));
-                            if (seat.expired) {
-                                report(hookSeatExpiredError("preCompact", seatMs, seat.cause, `the "${ctx.trigger}" compaction PROCEEDED unblocked and with no additional instructions`));
-                                return undefined;
-                            }
-                            const r = seat.value;
-                            if (r?.block && ctx.trigger === "forced") {
-                                report(new Error(`a preCompact callback blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
-                            }
-                            return r;
-                        }
-                        catch (err) {
-                            report(err instanceof Error ? err : new Error(String(err)));
-                            return undefined;
-                        }
-                    },
-                }
-                : {}),
-            ...(post
-                ? {
-                    postCompact: async (rawCtx) => {
-                        try {
-                            const seat = await runHookSeat("postCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => post.call(hooks, { ...withIdentity(rawCtx), signal: sig }));
-                            if (seat.expired) {
-                                try {
-                                    this.deps.onError?.(hookSeatExpiredError("postCompact", seatMs, seat.cause, "the observation was abandoned; the compaction that already landed is unchanged"), { phase: "hook", sessionId });
-                                }
-                                catch {
-                                }
-                            }
-                        }
-                        catch (err) {
-                            try {
-                                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
-                            }
-                            catch {
-                            }
-                        }
-                    },
-                }
-                : {}),
-        };
-    }
-    recordCompactionReuse(prepared, comp) {
-        if (!this.deps.summaryProvider || !comp.compacted)
-            return;
-        prepared.compactionReuseRef.consecutive = comp.reused ? prepared.compactionReuseRef.consecutive + 1 : 0;
-    }
-    async finish(spec, prepared, opts) {
-        let comp;
-        if (!opts?.skipCompaction) {
-            try {
-                const finishComp = await maybeCompact({
-                    session: prepared.session,
-                    epochDeclaredSections: prepared.epochDeclaredSections,
-                    ...centerAdoptionOption(prepared),
-                    model: prepared.model,
-                    compactionModel: prepared.compModel,
-                    ...forkContextOption(prepared, false),
-                    brain: opts?.brain ?? this.deps.brain,
-                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                    thinking: prepared.thinking,
-                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    minTokens: opts?.minTokens,
-                    overheadTokens: prepared.promptOverheadTokens,
-                    ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                    onInputTruncated: emitInputTruncated(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId),
-                    ...(opts?.windowSafety ?? {}),
-                    workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
-                    ...contextInstructionFilesOption(prepared),
-                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                    ...this.seamCCompactionOptions(prepared),
-                    ...gitRestateOption(prepared),
-                    ...this.compactionHookOptions(spec, prepared.sessionId, "auto", prepared.hookIdentity, {
-                        timeoutMs: prepared.hookTimeoutMs,
-                        ...(opts?.cancelled === true ? { signal: prepared.abortController.signal } : {}),
-                    }),
-                });
-                this.recordCompactionReuse(prepared, finishComp);
-                if (finishComp.unevaluableWindow) {
-                    discloseUnevaluableWindow(finishComp.unevaluableWindow, prepared, opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId, this.deps.onError);
-                }
-                comp = finishComp;
-            }
-            catch (err) {
-                const failMsg = String(err instanceof Error ? err.message : err);
-                const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
-                emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, () => ({
-                    kind: "compaction.failed",
-                    version: 1,
-                    taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
-                    trigger: "auto",
-                    reason: failReason,
-                    ts: Date.now(),
-                }));
-                opts?.onCompactionFailed?.(failReason);
-                this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-            }
-        }
-        try {
-            await this.sessions.touch(prepared.sessionId);
-        }
-        catch (err) {
-            this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
-        }
-        try {
-            await prepared.mcp.dispose();
-        }
-        catch (err) {
-            this.deps.onError?.(err, { phase: "mcp", sessionId: prepared.sessionId });
-        }
-        if (prepared.a2a !== undefined) {
-            try {
-                await prepared.a2a.dispose();
-            }
-            catch (err) {
-                this.deps.onError?.(err, { phase: "a2a", sessionId: prepared.sessionId });
-            }
-        }
-        return comp;
-    }
-    async teardownOwnedEnv(prepared) {
-        if (prepared.ownedEnv &&
-            hasDestroy(prepared.ownedEnv) &&
-            prepared.pausedRef.current === undefined) {
-            try {
-                await prepared.ownedEnv.destroy();
-            }
-            catch (err) {
-                this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
-            }
-        }
-    }
 }
 export function runTask(spec, deps) {
     return new Runner(deps).runTask(spec);