@sema-agent/core 7.11.2 → 7.12.0

package/dist/core/runner/runtask.js

@@ -1,63 +1,45 @@
-import { mintSystemReminder } from "../reminder-mint.js";
-import { deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
-import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
+import { deliverEngineNotice } from "../types.js";
+import { DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, remainingBudgetMicroUsd, readPendingSteerQueue, resolveCheckpointStore, realApprovalOrgFact } from "../checkpoint-store.js";
-import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
+import { CheckpointError, remainingBudgetMicroUsd, realApprovalOrgFact } from "../checkpoint-store.js";
 import { settleExecutionRecord } from "./execution-record.js";
-import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { computeCostMicroUsd, modelCostToPricing } from "../pricing.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 { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
-import { redactThenCut } from "../../agents/subagent-steps.js";
 import { adjudicateDerivedRoute, authCarrierFingerprint, fallbackToPrimaryNotice, normalizeBaseUrl, sameRouteIdentity } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
 import { expandTiers, resolveTaskModel } from "../roles.js";
 import { screenSwappableDeps } from "../swappable-deps.js";
-import { AutoModeBreakerLedger } from "../auto-mode.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 { toImageContent } from "./image.js";
-import { assembleResult, errorCodeOf } from "./assemble-result.js";
-import { amendTerminal, terminalProjection } from "./terminal-projection.js";
-import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.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 { drainForwardedFramesBeforeDone, forwardsSubagentEvents } from "./prepare-run-refs.js";
 import { callFaceSeat, judgeParkedToolIdentity, rosterEntryNamed, toolCallFaceOf } from "../tool-roster.js";
 import { normalizePersistedRuleHit } from "../gate-lanes.js";
 import { applyPersistedTightening, disclosedRuleSet } from "../persisted-rule-arms.js";
 import { SessionReadFileStates } from "./prepare-hands-readface.js";
-import { settleTeardownLeg } from "./teardown-bounded.js";
-import { hasDestroy, isIsolated } from "../remote-env.js";
-import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
+import { hasDestroy } from "../remote-env.js";
 import { formatHookFeedback, hookSeatExpiredError, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
-import { buildHumanInputEvent, projectHumanInput } from "../human-input-projection.js";
-import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText } from "../untrusted-text.js";
-import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.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 { defaultTaskRegistry } from "../task-registry.js";
-import { isDelegatedAgentTerminal, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { PendingSessionNotifications } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
-import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { createRunState } from "./initial-run-state.js";
-import { nextHumanInputSeq } from "./steer-admission.js";
 import { reconciledToolEndBody, toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
-import { answerFaceForRedeemedCall, deepJsonEqual, DEFERRED_REISSUE, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative } from "./decide-continuation.js";
-import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, platformLimitTerminal, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
-import { gitRestateOption, resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.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 { createTurnBoundary } from "./run-turn-boundary.js";
-import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { createHarnessHandlers } from "./run-harness-handlers.js";
 import { resumeAdmission } from "./resume-admission.js";
 import { resumeReviewOutcome } from "./resume-review-outcome.js";
@@ -72,6 +54,10 @@ import { streamReap } from "./stream-reap.js";
 import { streamSteerVerb } from "./stream-steer-verb.js";
 import { streamLifecycleVerbs } from "./stream-lifecycle-verbs.js";
 import { streamHaltVerbs } from "./stream-halt-verbs.js";
+import { runNotificationLane } from "./run-notification-lane.js";
+import { runLeg } from "./run-leg.js";
+import { runTerminalAdoption } from "./run-terminal-adoption.js";
+import { runSettleAndTeardown } from "./run-settle-and-teardown.js";
 import { runIdentityWiring } from "./run-identity-wiring.js";
 import { runTelemetryAndBudgetSeats } from "./run-telemetry-and-budget-seats.js";
 import { runAttachmentSeats } from "./run-attachment-seats.js";
@@ -93,7 +79,6 @@ export class Runner {
     sessions;
     sessionLocks = new Map();
     sessionReadStates = new SessionReadFileStates();
-    autoModeBreakerLedger = new AutoModeBreakerLedger();
     pendingSessionNotifications = new PendingSessionNotifications();
     parentConstraintRegistry = new Map();
     suspendedEnvReaps = new Map();
@@ -429,140 +414,35 @@ export class Runner {
             destroy,
         };
     }
-    async runLocked(input) {
-        const { spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer } = input;
-        const prepareResume = resume
-            ? {
-                leafId: resume.cp.leafId,
-                suspendedBatch: new Set(resume.cp.pendingAction.kind === "tool_approval" ? resume.cp.pendingAction.batchToolCallIds : []),
-                seed: resume.cp.state,
-                priorSuspendCount: resume.cp.suspendCount,
-                priorLedger: resume.cp.resourceLedger,
-                priorHumanReview: resume.cp.humanReview,
-                workspaceHandle: resume.cp.state.workspaceHandle,
-                executesApprovedAction: resume.cp.pendingAction.kind === "tool_approval" &&
-                    resume.outcome.gate !== "wake" &&
-                    resume.outcome.decision === "allow",
-                ...(resume.outcome.gate !== "wake" && resume.outcome.decision === "allow" && pendingContentAskCallId(resume.cp) !== undefined
-                    ? {
-                        redeemedContentAskCallId: pendingContentAskCallId(resume.cp),
-                        redeemedContentAskQuestionsHash: boundInputHashOf(resume.cp.pendingAction.args?.questions),
-                    }
-                    : {}),
-            }
-            : undefined;
-        const taskNotificationQueue = new SystemInjectionQueue();
-        const detachHub = internals?.detachHub ?? new ToolDetachHub();
-        let notificationHarness;
-        let notificationIdent = () => ({});
-        let notificationLaneLive = true;
-        let notificationSessionId;
-        let descendantAnchorDisclosed = false;
-        const parkTaskNotification = (payload, priority) => {
-            if (notificationSessionId !== undefined)
-                this.pendingSessionNotifications.pend(notificationSessionId, payload, priority);
-            if (!isDelegatedAgentTerminal(payload))
-                return;
-            const uplink = internals?.parentNotify;
-            if (uplink !== undefined) {
-                try {
-                    uplink(payload, { priority });
-                }
-                catch (e) {
-                    this.deps.onError?.(e, { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-uplink" });
-                }
-                return;
-            }
-            const rootAnchor = internals?.rootSessionId;
-            if (rootAnchor !== undefined && rootAnchor !== notificationSessionId) {
-                this.pendingSessionNotifications.pend(rootAnchor, payload, priority);
-                return;
-            }
-            if (internals?.parentSessionId !== undefined && !descendantAnchorDisclosed) {
-                descendantAnchorDisclosed = true;
-                this.deps.onError?.(new Error(`background-agent terminal ${payload.task_id} parked on this run's own session — the delegation tree's root session is not reachable from this run (no uplink, no root anchor)`), { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-unrouted" });
-            }
-        };
-        const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
-            queue.push({ type: "task_notification", notification: item.payload, priority: item.priority, ...notificationIdent() });
-            if (notificationHarness && prepared.batchHaltRef.current === undefined) {
-                const xml = renderTaskNotificationXml(item.payload);
-                const noteOptions = {
-                    provenance: "engine-note",
-                    enginePayload: item.payload,
-                    ...(item.payload.task_type !== "external" && isTerminalTaskNotification(item.payload) ? { capPreferred: true } : {}),
-                };
-                const deliver = item.priority === "later"
-                    ? notificationHarness.followUp(xml, noteOptions)
-                    : notificationHarness.steer(xml, { ...noteOptions, ...(item.priority === "now" ? { immediate: true } : {}) });
-                void deliver.then(() => item.onDisposition?.("queued"), () => {
-                    parkTaskNotification(item.payload, item.priority);
-                    item.onDisposition?.("parked");
-                });
-            }
-            else {
-                parkTaskNotification(item.payload, item.priority);
-                item.onDisposition?.("parked");
-            }
+    runLocked(input) {
+        const { spec, queue, resume, internals, taskIdRef } = 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),
         });
-        const upstreamTaskNotification = internals?.onTaskNotification;
-        const deliveredAtTurnOpen = new Set();
-        const injectTaskNotification = (notification, opts) => {
-            if (deliveredAtTurnOpen.has(taskNotificationDedupKey(notification)))
-                return Promise.resolve("dropped_duplicate");
-            if (!notificationLaneLive) {
-                parkTaskNotification(notification, opts?.priority ?? "later");
-                return Promise.resolve("parked");
-            }
-            return new Promise((resolve) => {
-                const accepted = taskNotificationQueue.enqueue({
-                    kind: "task_notification",
-                    priority: opts?.priority ?? "later",
-                    dedupKey: taskNotificationDedupKey(notification),
-                    payload: notification,
-                    onDisposition: resolve,
-                });
-                if (!accepted)
-                    resolve("queued");
-            });
-        };
-        const peerSelfRef = internals?.peerSelfRef ?? createPeerSelfRef(internals?.registryScope ?? spec.principal ?? "default");
-        const peerInboundChainRef = internals?.peerInboundChainRef ?? createPeerInboundChainRef();
-        const modelCatalog = this.deps.models;
-        const prepared = await prepareTask(spec, this.deps, this.sessions, prepareResume, {
-            ...(internals ?? {}),
-            peerSelfRef,
-            peerInboundChainRef,
-            detachHub,
-            sessionReadStates: this.sessionReadStates,
-            autoModeBreakerLedger: this.autoModeBreakerLedger,
-            onTaskNotification: (notification, opts) => {
-                try {
-                    upstreamTaskNotification?.(notification, opts);
-                }
-                catch {
-                }
-                injectTaskNotification(notification, opts);
-            },
-        }, this, taskIdRef);
-        let undrainedUserAtEnd;
-        const notificationLane = {
-            get harness() { return notificationHarness; }, set harness(h) { notificationHarness = h; },
-            get sessionId() { return notificationSessionId; }, set sessionId(s) { notificationSessionId = s; },
-            get ident() { return notificationIdent; }, set ident(f) { notificationIdent = f; },
-        };
-        const undrainedUserAtEndCell = { get current() { return undrainedUserAtEnd; }, set current(v) { undrainedUserAtEnd = v; } };
-        const { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats } = runIdentityWiring({
+    }
+    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, undrainedUserAtEnd: undrainedUserAtEndCell, pendingSessionNotifications: this.pendingSessionNotifications, runner: this.depsSeat,
+            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 });
-        await runAttachmentSeats({ spec, prepared, resume, rs, runner: this.depsSeat });
+        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 });
-        let reasoningResolution;
-        const reasoningResolutionCell = { get current() { return reasoningResolution; }, set current(v) { reasoningResolution = v; } };
-        const { observeReasoningWireFacts } = runReasoningSeat({ prepared, rs, taskIdRef, reasoningResolution: reasoningResolutionCell });
+        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]] : [])));
@@ -614,859 +494,24 @@ export class Runner {
             },
         });
         const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
-        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 {
-                            this.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
-                        }
-                        catch {
-                        }
-                    }
-                }
-                if (resumeWindowRetryAfterMs === undefined && !walltimeExhaustedResume && resume.outcome.gate !== "wake") {
-                    await this.applyResumeDecision(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 {
-                                this.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 ?? this.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 {
-                                        this.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
-                                    }
-                                    catch {
-                                    }
-                                    outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
-                                }
-                                if ("blocked" in outcome) {
-                                    deliverEngineNotice(this.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 ?? this.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 {
-                                    this.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 {
-                            this.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 {
-                            this.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 {
-                        this.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, this.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) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-                await settleTeardownLeg(() => prepared.a2a?.dispose(), "a2a.dispose (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-                await settleTeardownLeg(() => (prepared.ownedEnv && hasDestroy(prepared.ownedEnv) ? prepared.ownedEnv.destroy() : undefined), "ownedEnv.destroy (tool_unavailable leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-                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 {
-            }
-            notificationLaneLive = false;
-            unsubscribeTaskNotifications();
-            prepared.toolRosterDeltas.unsubscribe();
-            unsubGitRetry();
-            unsubBoundary();
-            unsub();
-        }
-        if (threw === undefined && prepared.brainCallGuardrailRef.timedOut !== undefined) {
-            threw = prepared.brainCallGuardrailRef.timedOut;
-        }
-        if (threw === undefined && prepared.gateStopRef.terminal !== undefined) {
-            threw = prepared.gateStopRef.terminal;
-        }
-        if (rs.limits.platformTerminal !== undefined) {
-            threw = rs.limits.platformTerminal;
-        }
-        if (prepared.usageGovernance !== undefined) {
-            try {
-                await awaitChargeWithSlowDisclosure(prepared.usageGovernance.commit(stats.tokens, rs.telemetry.unpricedSpend ? undefined : stats.costMicroUsd, Date.now()), () => this.deps.onError?.(new Error("the usage ledger's FINAL charge has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on a later flush). A wedged ledger store wedges this teardown, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
-            }
-            catch (flushErr) {
-                this.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
-            }
-        }
-        const committedPause = prepared.pausedRef.current;
-        const durablyPaused = committedPause !== undefined;
-        const interrupted = !durablyPaused &&
-            (threw !== undefined || timeout.fired || rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || abortedLive || final?.stopReason === "aborted");
-        let orphansClosed = 0;
-        let reconcileComplete = false;
-        if (interrupted) {
-            try {
-                const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
-                orphansClosed = report.recovered.length;
-                for (const orphan of report.recovered) {
-                    queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
-                    emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
-                }
-                reconcileComplete = true;
-            }
-            catch (reconcileErr) {
-                this.deps.onError?.(reconcileErr instanceof Error ? reconcileErr : new Error(String(reconcileErr)), {
-                    phase: "interrupt-reconcile",
-                    sessionId: prepared.sessionId,
-                });
-            }
-            try {
-                await prepared.harness.flushQueuedSessionWrites();
-            }
-            catch (flushErr) {
-                this.deps.onError?.(flushErr instanceof Error ? flushErr : new Error(String(flushErr)), {
-                    phase: "interrupt-reconcile",
-                    sessionId: prepared.sessionId,
-                });
-            }
-        }
-        if (interrupted && userInterruptedLive && reconcileComplete) {
-            try {
-                const entryId = await appendInterruptionMarker(prepared.session, { toolUseInFlight: orphansClosed > 0 });
-                emitCommitted(entryId, "user");
-            }
-            catch (markerErr) {
-                this.deps.onError?.(markerErr instanceof Error ? markerErr : new Error(String(markerErr)), {
-                    phase: "interrupt-reconcile",
-                    sessionId: prepared.sessionId,
-                });
-            }
-        }
-        let migratedParked = { steer: 0, followUp: 0 };
-        if (committedPause !== undefined && this.deps.checkpointStore !== undefined) {
-            const parkToken = committedPause.cause.token;
-            const parkScope = committedPause.scope;
-            const store = this.deps.checkpointStore;
-            const carried = [];
-            for (const record of prepared.harness.readParkableUserInputs()) {
-                try {
-                    if (!(await store.setPendingSteer(parkToken, parkScope, record)))
-                        break;
-                    carried.push(record);
-                }
-                catch (parkErr) {
-                    this.deps.onError?.(parkErr instanceof Error ? parkErr : new Error(String(parkErr)), {
-                        phase: "config",
-                        sessionId: prepared.sessionId,
-                    });
-                    const parkCode = errorCodeOf(parkErr);
-                    if (parkCode === "steering.invalid_content" || parkCode === "steering.queue_full")
-                        continue;
-                    break;
-                }
-            }
-            migratedParked = prepared.harness.dropParkedUserInputs(carried);
-        }
-        if (undrainedUserAtEnd !== undefined) {
-            const remaining = {
-                steer: Math.max(0, undrainedUserAtEnd.steer - migratedParked.steer),
-                followUp: Math.max(0, undrainedUserAtEnd.followUp - migratedParked.followUp),
-            };
-            for (const notice of undrainedUserInputNotices(remaining, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
-                deliverEngineNotice(this.deps.onNotice, notice);
-            }
-        }
-        if (rs.attach.attachState?.postCompactPending === true && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-        }
-        const comp = await this.finish(spec, prepared, {
-            telemetry: { tracer: rs.telemetry.tracer, taskId: rs.telemetry.taskId },
-            skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
-            minTokens: rs.counters.compactionFloor,
-            brain: compactionBrain,
-            windowSafety: windowSafetyOptions(prepared.model),
-            onCompactionFailed: (reason) => queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "auto", reason, ...ident() }),
-            cancelled: abortedLive,
+        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),
+                }),
+            }),
         });
-        try {
-            if (comp?.compacted) {
-                queue.push({
-                    type: "compacted",
-                    trigger: "auto",
-                    tokensBefore: comp.tokensBefore ?? 0,
-                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                    ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                    ...(comp.modelFallback ? { modelFallback: true } : {}),
-                    ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                    ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                    ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                    ...ident(),
-                });
-                if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
-                    const pd = comp.phaseDurations;
-                    const pdDur = comp.durationMs;
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
-                }
-                prepared.cacheBreakDetector?.notifyCompaction();
-            }
-            if (prepared.nestedStats.tasks > 0) {
-                stats.nested = {
-                    tokens: prepared.nestedStats.tokens,
-                    turns: prepared.nestedStats.turns,
-                    tasks: prepared.nestedStats.tasks,
-                    ...(prepared.nestedStats.anyUnpriced ? {} : { costMicroUsd: prepared.nestedStats.costMicroUsd }),
-                };
-            }
-            if (stats.totalInputTokens > 0) {
-                const rawHit = stats.cachedTokens / stats.totalInputTokens;
-                if (stats.cachedTokens > stats.totalInputTokens) {
-                    this.deps.onError?.(new Error(`prompt-cache: usage/api mismatch — cachedTokens (${stats.cachedTokens}) > totalInputTokens (${stats.totalInputTokens}); the cache family is likely wrong. Does model.api match the brain serving it? Override with model.params.promptCacheFamily = "input-includes-cached" | "input-excludes-cached".`), { phase: "prompt-cache", sessionId: prepared.sessionId });
-                }
-                stats.cacheHitRate = Math.min(1, rawHit);
-                if (!rs.telemetry.cacheBreakReported && stats.turns >= 2 && stats.totalInputTokens >= 8000 && stats.cacheHitRate < 0.15) {
-                    const cacheWritten = stats.cacheWriteTokens + stats.cacheWriteTokensLong;
-                    const cause = rs.degrade.degraded
-                        ? `a mid-task model switch (${rs.degrade.degraded.from} → ${rs.degrade.degraded.to}, degradation) reset the prefix cache — this is the likely cause`
-                        : cacheWritten > 0
-                            ? `this task reported ${cacheWritten} cache-write tokens across its calls (compaction included) but served almost none back as reads — consistent with a prompt prefix that CHANGES between turns (client-side: volatile content up front, or per-turn tool churn/reorder) and, less often, with server-side eviction. Keep volatile content (memory/timestamps/ids) out of the prefix and the tool list stable in membership AND order`
-                            : `no call in this task reported any cache-write tokens — and this API family may not report them at all (an openai-shaped usage row carries cached READS only), so the write side is no evidence here; check that the prompt prefix (system prompt + tool list, membership AND order) is byte-stable across turns and that this route caches this model`;
-                    this.deps.onError?.(new Error(`prompt-cache: low prefix-cache hit rate ${(stats.cacheHitRate * 100).toFixed(0)}% over ${stats.turns} turns (${stats.totalInputTokens} prompt tokens) — ${cause}. See design/09.`), { phase: "prompt-cache", sessionId: prepared.sessionId });
-                }
-            }
-            if (prepared.resourceLedger &&
-                (resume?.cp.gate.kind === "resource_limit" || prepared.pausedRef.current?.cause.gate.kind === "resource_limit")) {
-                stats.costMicroUsd += prepared.resourceLedger.spentMicroUsd;
-                stats.tokens += prepared.resourceLedger.spentTokens;
-                stats.turns += prepared.resourceLedger.spentTurns;
-            }
-            if (prepared.humanReviewRef.count > 0) {
-                stats.humanReview = {
-                    count: prepared.humanReviewRef.count,
-                    totalWaitMs: prepared.humanReviewRef.totalWaitMs,
-                    gates: [...prepared.humanReviewRef.gates],
-                };
-            }
-            const reminderDisclosuresActive = Object.keys(prepared.reminderDisclosureCounts).length > 0;
-            if (rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0 || rs.counters.approachNoticesSent > 0 || reminderDisclosuresActive) {
-                stats.mechanisms = {
-                    ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
-                    ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjections: rs.counters.finalVerifyInjections } : {}),
-                    ...(rs.attach.attachmentsInjected > 0 ? { attachmentsInjected: rs.attach.attachmentsInjected } : {}),
-                    ...(rs.counters.approachNoticesSent > 0 ? { approachNoticesSent: rs.counters.approachNoticesSent } : {}),
-                    ...(rs.counters.repetitionCuts > 0 ? { repetitionCuts: rs.counters.repetitionCuts } : {}),
-                    ...(rs.counters.repetitionSpared > 0 ? { repetitionSpared: rs.counters.repetitionSpared } : {}),
-                    ...(rs.counters.repetitionEvents.length > 0 ? { repetitionEvents: rs.counters.repetitionEvents } : {}),
-                    ...(reminderDisclosuresActive ? { reminderDisclosures: { ...prepared.reminderDisclosureCounts } } : {}),
-                };
-            }
-            const result = assembleResult(spec, prepared.sessionId, final, stats, {
-                threw,
-                runId: prepared.runId,
-                model: prepared.model.id,
-                unpricedSpend: rs.telemetry.unpricedSpend,
-                rewindNotes: prepared.rewindNotes,
-                editedFiles: prepared.editedFilesSnapshot(),
-                haltedOnUserRejection: prepared.batchHaltRef.current !== undefined,
-                userHalted: loopLatch.userHalted,
-                strandedHumanAnswers,
-                remoteEnvFailures: prepared.remoteEnvFailures,
-                effectiveReadFace: prepared.effectiveReadFace,
-                effectiveReadDenyPatterns: prepared.effectiveReadDenyPatterns,
-                effectiveMemoryScopes: prepared.effectiveMemoryScopes,
-                effectiveReasoning: reasoningResolution,
-                retryAfterMs: rs.limits.platformTerminal?.retryAfterMs,
-                abortedForTimeout: timeout.fired,
-                abortedForTurns: rs.limits.turnsExceeded,
-                abortedLive,
-                budgetHit: rs.limits.budgetHit,
-                budgetAxis: rs.limits.budgetAxis,
-                blockedReason: prepared.blockedRef.reason,
-                conflict: prepared.conflictRef.hit,
-                gitCoreOverBudget: prepared.gitStatusRef.terminalCode === "irreducible_core_over_budget",
-                outputInvalid: rs.degrade.outputInvalid,
-                suspendLoop: prepared.suspendLoopRef.hit,
-                ...(prepared.pausedRef.current !== undefined ? { paused: prepared.pausedRef.current.cause } : {}),
-            });
-            if (resume !== undefined &&
-                resume.pendingActionStarted !== true &&
-                result.terminal.kind !== "completed" &&
-                result.terminal.kind !== "paused" &&
-                !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true) &&
-                resume.onEnvRestoreFailed !== undefined) {
-                try {
-                    await resume.onEnvRestoreFailed("env_failed");
-                    amendTerminal(result, "resume.reopened_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, so the checkpoint was REOPENED (pending): the same approval can be resumed again, do not ask for a fresh one`);
-                }
-                catch {
-                    amendTerminal(result, "resume.reopen_failed_unstarted", (m) => `${m ?? "the resume leg did not complete"} — the approved action never started, and reopening the checkpoint FAILED: its state is unprovable from here. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead`);
-                }
-            }
-            prepared.sealReadStateSeat?.(ownCommittedTailRef.current);
-            {
-                const wss = prepared.workspaceStateSettle;
-                if (wss !== undefined && result.terminal.kind !== "paused") {
-                    const curCwd = prepared.cwdRef?.current !== undefined && prepared.cwdRef.current !== wss.rootCanonical ? prepared.cwdRef.current : undefined;
-                    const curWt = prepared.worktreeSessionRef?.current;
-                    const changed = curCwd !== wss.restoredHandsCwd || curWt?.worktreeDir !== wss.restoredWorktreeDir;
-                    if (curCwd !== undefined || curWt !== undefined || changed || wss.baselineUnknown === true) {
-                        await settleTeardownLeg(() => prepared.session.appendWorkspaceState({
-                            taskRoot: wss.rootCanonical,
-                            ...(curCwd !== undefined ? { handsCwd: curCwd } : {}),
-                            ...(curWt !== undefined ? { activeWorktree: { ...curWt } } : {}),
-                        }), "session.appendWorkspaceState (settle leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-                    }
-                }
-            }
-            const stopFailureHook = (spec.hooks ?? this.deps.hooks)?.stopFailure;
-            if (stopFailureHook !== undefined &&
-                result.terminal.kind === "failed" &&
-                final?.stopReason === "error" &&
-                !isDegenerateCutMessage(final) &&
-                threw === undefined &&
-                rs.limits.budgetHit === undefined &&
-                !rs.degrade.outputInvalid &&
-                !prepared.suspendLoopRef.hit &&
-                !abortedLive &&
-                result.terminal.code !== "conflict") {
-                const failedCause = result.terminal;
-                try {
-                    const failureSeat = await runHookSeat("stopFailure", { timeoutMs: prepared.hookTimeoutMs }, (sig) => stopFailureHook({
-                        identity: prepared.hookIdentity,
-                        error: failedCause.message ?? "model error",
-                        ...(failedCause.code !== undefined ? { errorKind: failedCause.code } : {}),
-                        turns: stats.turns,
-                        signal: sig,
-                    }));
-                    if (failureSeat.expired) {
-                        try {
-                            this.deps.onError?.(hookSeatExpiredError("stopFailure", prepared.hookTimeoutMs, failureSeat.cause, "the terminal observation was abandoned; the assembled TaskResult is unchanged"), { phase: "hook", sessionId: prepared.sessionId });
-                        }
-                        catch {
-                        }
-                    }
-                }
-                catch (err) {
-                    try {
-                        this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            const terminalFace = terminalProjection(result.terminal);
-            emitDelegationLifecycle({
-                phase: "terminal",
-                identity: prepared.hookIdentity,
-                status: terminalFace.status,
-                turns: stats.turns,
-                ...(terminalFace.errorCode !== undefined ? { errorCode: terminalFace.errorCode } : {}),
-            });
-            if (taskIdRef !== undefined)
-                taskIdRef.delegationTerminalOwed = undefined;
-            if (rs.degrade.degraded)
-                result.degraded = rs.degrade.degraded;
-            if (prepared.outputRef.set)
-                result.structuredOutput = prepared.outputRef.value;
-            const committedToken = prepared.pausedRef.current?.cause.token;
-            const committedScope = prepared.pausedRef.current?.scope;
-            if (committedToken !== undefined) {
-                const store = resolveCheckpointStore(spec, this.deps);
-                if (store && committedScope !== undefined) {
-                    onSuspend({
-                        env: prepared.ownedEnv,
-                        token: committedToken,
-                        scope: committedScope,
-                        store,
-                        sessionId: prepared.sessionId,
-                    });
-                }
-            }
-            if (resume && committedToken === undefined) {
-                await settleTeardownLeg(() => this.sessions.unpin?.(resume.cp.sessionId), "sessions.unpin (resumed-terminal leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-            }
-            if (prepared.memoryEngineSession) {
-                const mes = prepared.memoryEngineSession;
-                await settleTeardownLeg(() => mes.harvest(), "memoryEngineSession.harvest (settle leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-            }
-            emitTrace(rs.telemetry.tracer, () => ({
-                kind: "task.end",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                runId: rs.telemetry.runId,
-                status: terminalFace.status,
-                errorCode: terminalFace.errorCode,
-                turns: stats.turns,
-                tokens: stats.tokens,
-                ...(rs.telemetry.unpricedSpend ? {} : { costMicroUsd: stats.costMicroUsd }),
-                durationMs: Date.now() - rs.telemetry.taskStart,
-                ...(prepared.outputRef.set ? { hasStructuredOutput: true } : {}),
-                ...(stats.mechanisms !== undefined
-                    ? { mechanisms: (({ repetitionEvents: _events, ...scalars }) => scalars)(stats.mechanisms) }
-                    : {}),
-                ...(timeout.latenessMs !== undefined && timeout.latenessMs > TIMER_LATENESS_REPORT_MS
-                    ? { timerLatenessMs: timeout.latenessMs }
-                    : {}),
-                ...(rs.counters.walltimeSyncBackstopFired ? { walltimeSyncBackstop: true } : {}),
-                ts: Date.now(),
-            }));
-            setResult(result);
-            if (parentToolCallId !== undefined && result.terminal.kind !== "paused") {
-                const terminalTick = {
-                    type: "task_progress",
-                    taskId: rs.telemetry.taskId,
-                    ...(internals?.delegationTaskType !== undefined ? { taskType: internals.delegationTaskType } : {}),
-                    ...(internals?.cycleSeq !== undefined ? { seq: internals.cycleSeq } : {}),
-                    ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
-                    ...(subagentName ? { name: subagentName } : {}),
-                    model: prepared.model.id,
-                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
-                    status: result.terminal.kind === "completed" ? "completed" : "failed",
-                    ...ident(),
-                };
-                queue.push(terminalTick);
-                try {
-                    internals?.onForwardEvent?.(terminalTick);
-                }
-                catch {
-                }
-            }
-            if (manualCompactRef.waiters.length > 0) {
-                queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason: "task_ending", ...ident() });
-                drainManualCompact("mooted");
-            }
-            manualCompactRef.emitMooted = undefined;
-            if (forwardsSubagentEvents(spec))
-                await drainForwardedFramesBeforeDone();
-            queue.push({ type: "done", result });
-            queue.close();
-            await prepared.fileHistoryBoundary?.settle();
-            if (spec.suggestNextPrompts && result.terminal.kind === "completed") {
-                onSuggestions(this.suggestNextPrompts(spec, prepared, result));
-            }
-        }
-        finally {
-            const ownedEnvDying = prepared.ownedEnv !== undefined &&
-                hasDestroy(prepared.ownedEnv) &&
-                isIsolated(prepared.ownedEnv) &&
-                prepared.pausedRef.current === undefined;
-            await settleTeardownLeg(() => defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default", sessionId: prepared.sessionId }, {
-                source: abortedLive &&
-                    !timeout.fired &&
-                    !rs.limits.turnsExceeded &&
-                    rs.limits.budgetHit === undefined &&
-                    prepared.pausedRef.current === undefined
-                    ? "user"
-                    : "parent",
-                skipSessionScoped: true,
-                envDying: ownedEnvDying,
-                retainProcesses: spec.retainBackgroundProcesses === true,
-            }), "taskRegistry.settleKilledForOwner", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-            const bgEnv = prepared.ownedEnv ?? this.deps.executionEnv;
-            const retainBgBySpec = spec.retainBackgroundProcesses === true && !ownedEnvDying;
-            if (bgEnv && hasBackgroundShell(bgEnv) && !retainBgBySpec) {
-                try {
-                    const keepAlive = ownedEnvDying && bgEnv === prepared.ownedEnv
-                        ? []
-                        : [
-                            ...defaultTaskRegistry.sessionResidentShellIds(prepared.sessionId, bgEnv),
-                            ...defaultTaskRegistry.timeoutResidentShellIds(bgEnv),
-                            ...defaultTaskRegistry.retainedShellIds(bgEnv),
-                        ];
-                    await settleTeardownLeg(() => sweepBackgroundShells(bgEnv, defaultTaskRegistry, keepAlive.length > 0 ? { except: keepAlive } : undefined), "sweepBackgroundShells", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-                }
-                catch (e) {
-                    this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId });
-                }
-            }
-            defaultTaskRegistry.clearBackgroundForOwner({
-                owner: spec.taskId ?? prepared.sessionId,
-                scope: spec.principal ?? "default",
-            });
-            defaultTaskRegistry.abortBackgroundAgentsForOwner({
-                owner: spec.taskId ?? prepared.sessionId,
-                scope: spec.principal ?? "default",
-            }, { skipSessionScoped: true });
-            if (prepared.subagentRetain) {
-                await settleTeardownLeg(() => prepared.subagentRetain.disposeAll(), "subagentRetain.disposeAll", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-            }
-            await settleTeardownLeg(() => this.teardownOwnedEnv(prepared), "teardownOwnedEnv", (e) => this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId }));
-        }
     }
     async suggestNextPrompts(spec, prepared, result) {
         const cfg = typeof spec.suggestNextPrompts === "object" ? spec.suggestNextPrompts : {};