@sema-agent/core 7.11.1 → 7.12.0

package/dist/core/runner/runtask.js

@@ -1,69 +1,45 @@
-import { createSafeNotifier, observeThenableRejection } from "../safe-notify.js";
-import { mintSystemReminder, openSystemReminder } from "../reminder-mint.js";
-import { deliverDelegationLifecycle, deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
-import { planRejectionClears, resolveTriggerWindow } from "../context-edit.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, remainingTokens, resolveCheckpointStore, realApprovalOrgFact } from "../checkpoint-store.js";
-import { GIT_STATUS_ECHO_PREVIEW, stripGitStatusUnits } from "./git-status-frame.js";
+import { CheckpointError, remainingBudgetMicroUsd, realApprovalOrgFact } from "../checkpoint-store.js";
 import { settleExecutionRecord } from "./execution-record.js";
-import { engineVersion } from "../version.js";
-import { CONFIG_CATALOG_VERSION, declarationReasons, resolveEffectiveConfig } from "../../config/catalog.js";
-import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact, sanitizeCompactionSettings } from "../auto-compaction.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, isModelPriced, malformedPricingField, 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 { resolveReasoning } from "../../brain/reasoning.js";
 import { adjudicateDerivedRoute, authCarrierFingerprint, fallbackToPrimaryNotice, normalizeBaseUrl, sameRouteIdentity } from "../../brain/route-adjudicator.js";
-import { runWithBrainTelemetry, runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
-import { expandTiers, resolveModel, resolveTaskModel } from "../roles.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 { SKILLS_LISTING_PROBE_HEADER, resolveOutputRetries } from "./synthetic-tools.js";
-import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
-import { assembleResult, errorCodeOf } from "./assemble-result.js";
-import { amendTerminal, terminalProjection } from "./terminal-projection.js";
-import { AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, commitAgentListing, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, 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 { discloseDroppedPending, 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, writeFamilyOfCanonical } 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, resolveMaxTurns, startTimeout, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
-import { gitRestateOption, resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
-import { COMPACTION_FREED_EPSILON, COMPACTION_REGROWTH_FACTOR, MAX_CONSECUTIVE_COMPACTION_FAILURES, createTurnBoundary } from "./run-turn-boundary.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 { createTurnBoundary } from "./run-turn-boundary.js";
 import { createHarnessHandlers } from "./run-harness-handlers.js";
 import { resumeAdmission } from "./resume-admission.js";
 import { resumeReviewOutcome } from "./resume-review-outcome.js";
@@ -78,7 +54,21 @@ 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";
-const STOP_HOOK_BLOCK_CAP = 8;
+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";
+import { runToolMountFacts } from "./run-tool-mount-facts.js";
+import { runReasoningSeat } from "./run-reasoning-seat.js";
+import { runClockAndContent } from "./run-clock-and-content.js";
+import { runBrainSinks } from "./run-brain-sinks.js";
+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;
@@ -89,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();
@@ -329,33 +318,48 @@ export class Runner {
                 ? await this.acquireSessionLock(spec.sessionId)
                 : undefined;
             try {
-                await this.runLocked(spec, queue, (r) => {
-                    resultValue = r;
-                    const pcs = internals?.inheritedGate?.parentConstraints;
-                    if (resume !== undefined)
-                        this.locallyClaimedTokens.delete(resume.cp.token);
-                    const rToken = r.terminal.kind === "paused" ? r.terminal.token : undefined;
-                    if (resume !== undefined && rToken !== resume.cp.token) {
-                        this.parentConstraintRegistry.delete(resume.cp.token);
-                        this.suspendedEnvReaps.delete(resume.cp.token);
-                    }
-                    if (r.terminal.kind === "paused" && PAUSE_REGISTRY[r.terminal.gate.kind].taskStatus === "suspended" && pcs !== undefined && pcs.length > 0) {
-                        if (this.parentConstraintRegistry.size >= Runner.PARENT_CONSTRAINT_REGISTRY_CAP) {
-                            const oldest = this.parentConstraintRegistry.keys().next().value;
-                            if (oldest !== undefined)
-                                this.parentConstraintRegistry.delete(oldest);
+                await this.runLocked({
+                    spec,
+                    queue,
+                    setResult: (r) => {
+                        resultValue = r;
+                        const pcs = internals?.inheritedGate?.parentConstraints;
+                        if (resume !== undefined)
+                            this.locallyClaimedTokens.delete(resume.cp.token);
+                        const rToken = r.terminal.kind === "paused" ? r.terminal.token : undefined;
+                        if (resume !== undefined && rToken !== resume.cp.token) {
+                            this.parentConstraintRegistry.delete(resume.cp.token);
+                            this.suspendedEnvReaps.delete(resume.cp.token);
                         }
-                        this.parentConstraintRegistry.set(r.terminal.token, pcs);
-                    }
-                }, (p) => {
-                    suggestionsDone = p;
-                }, (h) => {
-                    handle = h;
-                    publishReady(h);
-                }, (s) => {
-                    reapHandle = s;
-                    this.suspendedEnvReaps.set(s.token, s);
-                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef, captureOptOutRef, entryActor, entryTracer);
+                        if (r.terminal.kind === "paused" && PAUSE_REGISTRY[r.terminal.gate.kind].taskStatus === "suspended" && pcs !== undefined && pcs.length > 0) {
+                            if (this.parentConstraintRegistry.size >= Runner.PARENT_CONSTRAINT_REGISTRY_CAP) {
+                                const oldest = this.parentConstraintRegistry.keys().next().value;
+                                if (oldest !== undefined)
+                                    this.parentConstraintRegistry.delete(oldest);
+                            }
+                            this.parentConstraintRegistry.set(r.terminal.token, pcs);
+                        }
+                    },
+                    onSuggestions: (p) => {
+                        suggestionsDone = p;
+                    },
+                    onReady: (h) => {
+                        handle = h;
+                        publishReady(h);
+                    },
+                    onSuspend: (s) => {
+                        reapHandle = s;
+                        this.suspendedEnvReaps.set(s.token, s);
+                    },
+                    manualCompactRef,
+                    taskIdRef,
+                    resume,
+                    internals: { ...(internals ?? {}), detachHub },
+                    notifyRef,
+                    captureOptOutRef,
+                    entryActor,
+                    entryTracer,
+                });
             }
             finally {
                 releaseLock?.();
@@ -410,692 +414,37 @@ export class Runner {
             destroy,
         };
     }
-    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer) {
-        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);
-        notificationHarness = prepared.harness;
-        notificationSessionId = prepared.sessionId;
-        if (taskIdRef)
-            taskIdRef.effectiveMemoryScopes = prepared.effectiveMemoryScopes;
-        if (taskIdRef)
-            taskIdRef.editedFiles = prepared.editedFilesSnapshot;
-        const runSourceTaskId = spec.taskId ?? prepared.sessionId;
-        const parentToolCallId = internals?.parentToolCallId;
-        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: runSourceTaskId } : { eventId: uuidv7() };
-        notificationIdent = ident;
-        queue.push({ type: "wiring_manifest", manifest: prepared.wiringManifest, ...ident() });
-        prepared.toolRosterDeltas.subscribe((delta) => queue.push({ type: "tool_roster_delta", delta, ...ident() }));
-        const delegationLifecycleNotifier = createSafeNotifier({
-            onError: (f) => console.warn(`[sema-core] ${f.site}: delegation-lifecycle observer threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
+    }
+    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 emitDelegationLifecycle = (event) => {
-            if (!prepared.hookIdentity.isDelegatedChild)
-                return;
-            if (this.deps.onDelegationLifecycle === undefined)
-                return;
-            deliverDelegationLifecycle(this.deps.onDelegationLifecycle, event, delegationLifecycleNotifier, "runtask.onDelegationLifecycle");
-        };
-        emitDelegationLifecycle({ phase: "spawn", identity: prepared.hookIdentity });
-        if (taskIdRef !== undefined && prepared.hookIdentity.isDelegatedChild && this.deps.onDelegationLifecycle !== undefined) {
-            taskIdRef.delegationTerminalOwed = prepared.hookIdentity;
-        }
-        manualCompactRef.emitMooted = (reason) => {
-            queue.push({ type: "compaction_outcome", outcome: "mooted", trigger: "manual", reason, ...ident() });
-        };
-        prepared.harness.onUndrainedEngineNotes = (payloads) => {
-            if (notificationSessionId === undefined)
-                return;
-            for (const p of payloads)
-                this.pendingSessionNotifications.pend(notificationSessionId, p);
-        };
-        prepared.harness.engineInjectionsHeld = () => prepared.batchHaltRef.current !== undefined;
-        let undrainedUserAtEnd;
-        prepared.harness.onUndrainedUserInputs = (counts) => {
-            if (prepared.pausedRef.current !== undefined) {
-                undrainedUserAtEnd = counts;
-                return;
-            }
-            for (const notice of undrainedUserInputNotices(counts, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
-                deliverEngineNotice(this.deps.onNotice, notice);
-            }
-        };
-        prepared.harness.onEngineNoteConsumed = (p) => {
-            const peer = p?.peer;
-            if (peer !== undefined && Array.isArray(peer.hopChain))
-                peerInboundChainRef.current = [...peer.hopChain];
-        };
-        if (notifyRef)
-            notifyRef.inject = injectTaskNotification;
-        if (captureOptOutRef && prepared.memoryEngineSession?.captureOptOut !== undefined) {
-            captureOptOutRef.flip = prepared.memoryEngineSession.captureOptOut.flip;
-        }
-        try {
-            internals?.onNotifyInjectorReady?.(injectTaskNotification);
-        }
-        catch {
-        }
-        {
-            const pendingIdle = this.pendingSessionNotifications.drain(prepared.sessionId);
-            if (pendingIdle !== undefined) {
-                for (const payload of discloseDroppedPending(pendingIdle)) {
-                    const parkedPriority = pendingIdle.priorities?.get(payload);
-                    deliveredAtTurnOpen.add(taskNotificationDedupKey(payload));
-                    queue.push({ type: "task_notification", notification: payload, ...(parkedPriority !== undefined ? { priority: parkedPriority } : {}), ...ident() });
-                    void prepared.harness.nextTurn(renderTaskNotificationXml(payload), { provenance: "engine-note", enginePayload: payload }).catch(() => {
-                        this.pendingSessionNotifications.pend(prepared.sessionId, payload, parkedPriority);
-                    });
-                }
-            }
-        }
-        const loopLatch = { ended: false, userInterrupted: false, userHalted: false };
-        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity });
-        const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
-        prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
-        if (resume &&
-            resume.cp.suspendedAt !== undefined &&
-            (resume.cp.gate.kind === "human" ||
-                resume.cp.gate.kind === "irreversible_ask" ||
-                resume.cp.gate.kind === "needs_review" ||
-                resume.cp.gate.kind === "plan_review")) {
-            const waitMs = Math.max(0, prepared.now() - resume.cp.suspendedAt);
-            const decision = resume.outcome.gate === "wake" ? undefined : resume.outcome.decision;
-            prepared.humanReviewRef.count += 1;
-            prepared.humanReviewRef.totalWaitMs += waitMs;
-            const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
-            prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
-        }
-        if (resume !== undefined && resume.outcome.gate === "plan_review" && resume.outcome.decision === "reject") {
-            prepared.planModeRef.active = true;
-        }
         const rs = createRunState();
-        rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
-        rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
-        rs.telemetry.pricingConfigured = isModelPriced(prepared.model, this.deps.pricing);
-        if (spec.limits?.degrade) {
-            try {
-                rs.degrade.degradeToModel = resolveModel(spec.limits.degrade.to, modelCatalog);
-            }
-            catch (e) {
-                this.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId });
-            }
-        }
-        const famOverride = prepared.model.params?.promptCacheFamily;
-        if (famOverride && !["input-includes-cached", "input-excludes-cached", "openai", "anthropic"].includes(famOverride)) {
-            this.deps.onError?.(new Error(`prompt-cache: unrecognized model.params.promptCacheFamily "${famOverride}" — ignored (fell back to model.api inference). Use "input-includes-cached" | "input-excludes-cached" (aliases "openai" | "anthropic").`), { phase: "prompt-cache", sessionId: prepared.sessionId });
-        }
-        rs.limits.turnsExceeded = false;
-        rs.degrade.outputErrorStreak = 0;
-        rs.degrade.outputInvalid = false;
-        rs.telemetry.cacheBreakReported = false;
-        rs.limits.outputRetryCap = resolveOutputRetries(spec.outputRetries);
-        rs.limits.effectiveMaxTurns = resolveMaxTurns(spec.limits);
-        rs.telemetry.tracer = entryTracer !== undefined ? entryTracer.tracer : (spec.tracer ?? this.deps.tracer);
-        rs.telemetry.taskId = runSourceTaskId;
-        rs.telemetry.runId = prepared.runId;
-        if (taskIdRef) {
-            taskIdRef.current = rs.telemetry.taskId;
-            taskIdRef.sessionId = prepared.sessionId;
-        }
-        rs.telemetry.taskStart = Date.now();
-        rs.telemetry.taskStartMonotonic = performance.now();
-        const discloseNoteTaskRunFailure = (err) => {
-            try {
-                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "config", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-        };
-        try {
-            void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, rs.telemetry.taskId, rs.telemetry.runId)).catch(discloseNoteTaskRunFailure);
-        }
-        catch (err) {
-            discloseNoteTaskRunFailure(err);
-        }
-        const noteUnevaluablePriceTable = (p) => {
-            if (prepared.usageGovernance?.governsCost !== true)
-                return;
-            if (malformedPricingField(p) !== undefined)
-                rs.telemetry.unpricedSpend = true;
-        };
-        rs.degrade.recordDegraded = (info, toModel) => {
-            if (rs.degrade.degraded !== undefined)
-                return;
-            let m = toModel;
-            if (!m) {
-                try {
-                    m = resolveModel(info.to, modelCatalog);
-                }
-                catch {
-                    m = undefined;
-                }
-            }
-            if (m) {
-                rs.telemetry.pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-                rs.telemetry.pricingConfigured = isModelPriced(m, this.deps.pricing);
-                noteUnevaluablePriceTable(rs.telemetry.pricing);
-                rs.telemetry.cacheFamily = cacheFamilyOf(m);
-            }
-            else {
-                if (this.deps.pricing?.[info.to]) {
-                    rs.telemetry.pricing = this.deps.pricing[info.to];
-                    rs.telemetry.pricingConfigured = true;
-                    noteUnevaluablePriceTable(rs.telemetry.pricing);
-                }
-                else {
-                    rs.telemetry.pricingConfigured = false;
-                }
-                rs.telemetry.cacheFamily = "input-excludes-cached";
-            }
-            rs.degrade.degraded = info;
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "task.degraded", version: 1, taskId: rs.telemetry.taskId, from: info.from, to: info.to, reason: info.reason, atTurn: info.atTurn, ts: Date.now() }));
-            try {
-                this.deps.onError?.(new Error(`degraded to a cheaper model: ${info.from} → ${info.to} (${info.reason}) at turn ${info.atTurn}`), { phase: "degraded", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-        };
-        const sliceWindowMicroUsd = spec.limits?.maxCostUsd !== undefined ? Math.round(spec.limits.maxCostUsd * 1e6) : undefined;
-        rs.budget.remainingMicroUsd = prepared.resourceLedger
-            ? remainingBudgetMicroUsd(prepared.resourceLedger)
-            : spec.resourceSuspend?.totalBudgetUsd !== undefined
-                ? Math.round(spec.resourceSuspend.totalBudgetUsd * 1e6)
-                : undefined;
-        rs.budget.maxCostMicroUsd =
-            sliceWindowMicroUsd !== undefined && rs.budget.remainingMicroUsd !== undefined
-                ? Math.min(sliceWindowMicroUsd, rs.budget.remainingMicroUsd)
-                : (sliceWindowMicroUsd ?? rs.budget.remainingMicroUsd);
-        rs.budget.remainingTokens = prepared.resourceLedger
-            ? remainingTokens(prepared.resourceLedger)
-            : spec.resourceSuspend?.totalTokens;
-        rs.budget.maxTokensWindow =
-            spec.limits?.maxTokens !== undefined && rs.budget.remainingTokens !== undefined
-                ? Math.min(spec.limits.maxTokens, rs.budget.remainingTokens)
-                : (spec.limits?.maxTokens ?? rs.budget.remainingTokens);
-        rs.budget.overBudget = () => {
-            if (rs.budget.maxTokensWindow !== undefined && stats.tokens > rs.budget.maxTokensWindow)
-                return "tokens";
-            if (rs.budget.maxCostMicroUsd !== undefined && stats.costMicroUsd > rs.budget.maxCostMicroUsd)
-                return "cost";
-            return undefined;
-        };
-        rs.budget.streamCancel =
-            (spec.limits?.budgetStreamCancel ?? rs.budget.maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
-        rs.budget.callOutputChars = 0;
-        rs.budget.lastStreamBudgetCheck = 0;
-        rs.budget.projectedOverBudget = () => {
-            const estOut = Math.ceil(rs.budget.callOutputChars / 4);
-            if (rs.budget.maxTokensWindow !== undefined && stats.tokens + estOut > rs.budget.maxTokensWindow)
-                return "tokens";
-            if (rs.budget.maxCostMicroUsd !== undefined) {
-                const estOutMicro = computeCostMicroUsd({ totalInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: estOut }, rs.telemetry.pricing);
-                if (stats.costMicroUsd + estOutMicro > rs.budget.maxCostMicroUsd)
-                    return "cost";
-            }
-            return undefined;
-        };
-        rs.turn.turnUsageMissing = false;
-        rs.counters.repetitionCuts = 0;
-        rs.counters.repetitionSpared = 0;
-        rs.counters.repetitionEvents = [];
-        rs.counters.REPETITION_EVENTS_CAP = 20;
-        rs.counters.preemptIgnoredReported = false;
-        rs.counters.wroteThisRun = false;
-        rs.counters.finalVerifyInjections = 0;
-        rs.counters.groundingSignalPreR9 = false;
-        rs.counters.groundingSignalPostR9 = false;
-        rs.attach.attachmentsCfg = spec.attachments;
-        rs.attach.agentListingOn = rs.attach.attachmentsCfg?.agentListing !== false && eventDefaultOn("agent_listing");
-        rs.attach.skillsListingOn = rs.attach.attachmentsCfg?.skillsListing !== false && eventDefaultOn("skills_listing");
-        const listingsLive = (rs.attach.agentListingOn && prepared.agentListing !== undefined) || (rs.attach.skillsListingOn && prepared.skillsListing !== undefined);
-        const backgroundTasksLive = (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true;
-        rs.attach.attachState = rs.attach.attachmentsCfg !== undefined || listingsLive || backgroundTasksLive ? createAttachmentState() : undefined;
-        rs.attach.dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.legDate } : undefined;
-        rs.attach.instrProbe = this.deps.probeInstructionSources;
-        rs.attach.instrState =
-            rs.attach.instrProbe !== undefined && prepared.instructionSources !== undefined && prepared.instructionSources.length > 0
-                ? { lastAnnouncedHash: new Map(prepared.instructionSources.map((s) => [s.path, s.contentHash])) }
-                : undefined;
-        rs.attach.sizeGuidelineState =
-            prepared.workflowSizeGuideline !== undefined
-                ? { announcedGuideline: prepared.workflowSizeGuideline.legGuideline, current: prepared.workflowSizeGuideline.current }
-                : undefined;
-        rs.counters.cadenceTurns = 0;
-        rs.turn.lastTurnHadToolCalls = false;
-        if (rs.attach.attachState !== undefined && (rs.attach.attachmentsCfg?.backgroundTasks ?? eventDefaultOn("background_tasks")) === true) {
-            try {
-                const branch = await prepared.session.getBranch();
-                for (let i = branch.length - 1; i >= 0; i--) {
-                    const e = branch[i];
-                    if (e.type === "compaction") {
-                        rs.attach.attachState.postCompactPending = true;
-                        break;
-                    }
-                    if (e.type === "message" && e.message.role === "assistant")
-                        break;
-                }
-            }
-            catch {
-            }
-        }
-        if (rs.attach.attachState !== undefined &&
-            ((rs.attach.agentListingOn && prepared.agentListing?.seedAnnounced === true) ||
-                (rs.attach.skillsListingOn && prepared.skillsListing?.seedAnnounced === true))) {
-            const cpListings = resume?.cp.state.announcedListings;
-            let entryListings;
-            try {
-                entryListings = await prepared.session.getAnnouncedListing();
-            }
-            catch {
-                entryListings = undefined;
-            }
-            const textOf = (m) => {
-                const c = m.content;
-                if (typeof c === "string")
-                    return c;
-                if (Array.isArray(c)) {
-                    return c
-                        .map((b) => (b !== null && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : ""))
-                        .join("\n");
-                }
-                return "";
-            };
-            let branchTexts = null;
-            const branchLoad = async () => {
-                if (branchTexts === null) {
-                    const branch = await prepared.session.getBranch();
-                    branchTexts = branch.flatMap((e) => {
-                        if (e.type !== "message")
-                            return [];
-                        const m = e.message;
-                        if (m.role !== "user")
-                            return [];
-                        const full = textOf(e.message);
-                        if (m.engineMinted === true)
-                            return [stripGitStatusUnits(full, prepared.reminderMark)];
-                        if (Array.isArray(m.engineSegments) && m.engineSegments.length > 0) {
-                            return m.engineSegments.map((s) => stripGitStatusUnits(full.slice(Math.max(0, s.start), Math.max(0, s.end)), prepared.reminderMark));
-                        }
-                        if (typeof m.enginePrefixChars === "number" && m.enginePrefixChars > 0)
-                            return [stripGitStatusUnits(full.slice(0, m.enginePrefixChars), prepared.reminderMark)];
-                        return [];
-                    });
-                }
-                return branchTexts;
-            };
-            const branchReplay = async (headers) => {
-                try {
-                    return replayAnnouncedListing(await branchLoad(), headers);
-                }
-                catch {
-                    return undefined;
-                }
-            };
-            if (rs.attach.agentListingOn && prepared.agentListing?.seedAnnounced === true) {
-                const listing = prepared.agentListing;
-                if (cpListings?.agents === undefined && entryListings?.agents !== undefined) {
-                    const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    rs.attach.attachState.announcedAgentTypes = new Map(entryListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
-                    prepared.announcedListingsRef.agents = [...entryListings.agents];
-                    if (entryListings.models !== undefined) {
-                        rs.attach.attachState.announcedModels = [...entryListings.models];
-                        prepared.announcedListingsRef.models = [...entryListings.models];
-                    }
-                }
-                else if (cpListings?.agents !== undefined) {
-                    const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    rs.attach.attachState.announcedAgentTypes = new Map(cpListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
-                    prepared.announcedListingsRef.agents = [...cpListings.agents];
-                    if (cpListings.models !== undefined) {
-                        rs.attach.attachState.announcedModels = [...cpListings.models];
-                        prepared.announcedListingsRef.models = [...cpListings.models];
-                    }
-                }
-                else {
-                    const replayed = await branchReplay({
-                        initial: agentListingInitialHeader(listing.toolName),
-                        delta: agentListingDeltaHeader(listing.toolName),
-                        removed: AGENT_LISTING_REMOVED_HEADER,
-                    });
-                    if (replayed !== undefined) {
-                        const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                        rs.attach.attachState.announcedAgentTypes = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
-                        prepared.announcedListingsRef.agents = [...replayed];
-                        const replayedModels = replayAnnouncedModels(await branchLoad());
-                        if (replayedModels !== undefined) {
-                            rs.attach.attachState.announcedModels = [...replayedModels];
-                            prepared.announcedListingsRef.models = [...replayedModels];
-                        }
-                    }
-                }
-            }
-            if (rs.attach.skillsListingOn && prepared.skillsListing?.seedAnnounced === true) {
-                const listing = prepared.skillsListing;
-                if (cpListings?.skills === undefined && entryListings?.skills !== undefined) {
-                    const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    rs.attach.attachState.announcedSkills = new Map(entryListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
-                    prepared.announcedListingsRef.skills = [...entryListings.skills];
-                }
-                else if (cpListings?.skills !== undefined) {
-                    const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    rs.attach.attachState.announcedSkills = new Map(cpListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
-                    prepared.announcedListingsRef.skills = [...cpListings.skills];
-                }
-                else {
-                    const replayed = await branchReplay({
-                        initial: SKILLS_LISTING_PROBE_HEADER,
-                        delta: SKILLS_LISTING_DELTA_HEADER,
-                        removed: SKILLS_LISTING_REMOVED_HEADER,
-                    });
-                    if (replayed !== undefined) {
-                        const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                        rs.attach.attachState.announcedSkills = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
-                        prepared.announcedListingsRef.skills = [...replayed];
-                    }
-                }
-            }
-        }
-        if (spec.finalVerification === true && resume !== undefined) {
-            try {
-                const branch = await prepared.session.getBranch();
-                for (const e of branch) {
-                    if (e.type !== "message")
-                        continue;
-                    const m = e.message;
-                    if (m.role === "user") {
-                        const text = typeof m.content === "string"
-                            ? m.content
-                            : m.content.map((b) => (b !== null && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : "")).join("\n");
-                        const fvMarked = m.engineMinted === true && text.includes(`<system-reminder mark="${prepared.reminderMark}">[final verification]`);
-                        if ((fvMarked || text.includes("<system-reminder>[final verification]")) && rs.counters.finalVerifyInjections < 2)
-                            rs.counters.finalVerifyInjections += 1;
-                    }
-                    else if (m.role === "toolResult" && !rs.counters.wroteThisRun && (prepared.toolEffects.get(m.toolName) ?? "write") !== "read") {
-                        rs.counters.wroteThisRun = true;
-                    }
-                }
-            }
-            catch {
-            }
-        }
-        rs.attach.attachmentsInjected = 0;
-        const todoToolMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TodoWrite");
-        const taskToolsMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => t.name === "TaskCreate");
-        const writeFamilyByName = new Map();
-        if (rs.attach.attachState !== undefined) {
-            for (const t of prepared.tools) {
-                const family = writeFamilyOfCanonical(t.name);
-                if (family !== undefined)
-                    for (const n of [t.name, ...(t.aliases ?? [])])
-                        writeFamilyByName.set(n, family);
-            }
-        }
-        const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(name);
-        const toolStartAt = new Map();
-        const startedToolCallIds = new Set();
-        emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, runId: rs.telemetry.runId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
-        emitTrace(rs.telemetry.tracer, () => ({
-            kind: "prompt.assembled",
-            version: 1,
-            taskId: rs.telemetry.taskId,
-            constitution: prepared.promptManifest.constitution,
-            blocks: prepared.promptManifest.blocks,
-            ...(prepared.promptManifest.sections ? { sections: prepared.promptManifest.sections } : {}),
-            ...(prepared.promptManifest.tools ? { tools: prepared.promptManifest.tools } : {}),
-            ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
-            ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),
-            ...(prepared.promptManifest.toolDisclosure ? { toolDisclosure: prepared.promptManifest.toolDisclosure } : {}),
-            totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
-            ts: rs.telemetry.taskStart,
-        }));
-        emitTrace(rs.telemetry.tracer, () => {
-            const reasons = declarationReasons(spec.configOverrides);
-            return {
-                kind: "config.assembled",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                catalogVersion: CONFIG_CATALOG_VERSION,
-                fields: resolveEffectiveConfig(spec, { modelMaxTokens: prepared.model.maxTokens }),
-                ...(Object.keys(reasons).length > 0 ? { overrideReasons: reasons } : {}),
-                ts: rs.telemetry.taskStart,
-            };
+        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 }),
         });
-        if (prepared.turnSnapshot !== undefined) {
-            prepared.turnSnapshot.onChange = (snap) => emitTrace(rs.telemetry.tracer, () => ({
-                kind: "prompt.snapshot_changed",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                snapshot: { cacheIdentity: snap.cacheIdentity, elements: { ...snap.elements } },
-                ts: Date.now(),
-            }));
-        }
-        let reasoningResolution = prepared.thinking && prepared.thinking !== "off" ? resolveReasoning(prepared.thinking, prepared.model) : undefined;
-        const publishReasoningResolution = (r) => {
-            reasoningResolution = r;
-            if (taskIdRef)
-                taskIdRef.effectiveReasoning = r;
-            emitTrace(rs.telemetry.tracer, () => ({
-                kind: "reasoning.resolved",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                model: prepared.model.id,
-                requested: r.requested,
-                effective: r.effective,
-                graded: r.graded,
-                clamped: r.clamped,
-                format: r.format,
-                endpoint: r.endpoint,
-                ...(r.dropped === true ? { dropped: true } : {}),
-                ts: Date.now(),
-            }));
-        };
-        if (reasoningResolution !== undefined)
-            publishReasoningResolution(reasoningResolution);
-        let reasoningFactsConsumed = false;
-        const observeReasoningWireFacts = (facts) => {
-            if (reasoningFactsConsumed)
-                return;
-            reasoningFactsConsumed = true;
-            if (prepared.thinking === undefined || prepared.thinking === "off")
-                return;
-            const next = resolveReasoning(prepared.thinking, prepared.model, facts);
-            const current = reasoningResolution;
-            if (current !== undefined &&
-                current.effective === next.effective &&
-                current.graded === next.graded &&
-                current.clamped === next.clamped &&
-                current.format === next.format &&
-                current.endpoint === next.endpoint &&
-                current.dropped === next.dropped) {
-                return;
-            }
-            publishReasoningResolution(next);
-        };
-        const effectiveTimeoutMs = spec.limits?.maxWalltimeMs;
-        const walltimeMonotonicDeadline = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStartMonotonic + effectiveTimeoutMs : undefined;
-        rs.counters.walltimeSyncBackstopFired = false;
-        const timeout = startTimeout(prepared.harness, prepared.abortController, walltimeMonotonicDeadline !== undefined ? walltimeMonotonicDeadline - performance.now() : undefined, prepared.suspendForResource !== undefined);
-        const pushContent = (e) => {
-            queue.push(e);
-            if (parentToolCallId !== undefined && internals?.onForwardEvent) {
-                try {
-                    internals.onForwardEvent(e);
-                }
-                catch {
-                }
-            }
-        };
-        const ownCommittedTailRef = { current: undefined };
-        const emitCommitted = (entryId, role, toolCallId) => {
-            ownCommittedTailRef.current = entryId;
-            if (role === "toolResult" && toolCallId !== undefined)
-                startedToolCallIds.delete(toolCallId);
-            queue.push({ type: "message_committed", entryId, role, ...(toolCallId !== undefined ? { toolCallId } : {}), ...ident() });
-        };
-        const subagentName = parentToolCallId !== undefined && internals?.agentName !== undefined ? inlineUntrusted(internals.agentName.slice(0, 320), 80) : undefined;
-        const statusSinkNotifier = createSafeNotifier({
-            onError: (f) => console.warn(`[sema-core] ${f.site}: run-internals status sink threw (contained; further failures counted, not re-disclosed): ${f.error.message}`),
-        });
-        const statusEmit = (s) => {
-            const frame = {
-                type: "status",
-                phase: s.phase,
-                ...(s.detail !== undefined ? { detail: s.detail } : {}),
-                ...(s.retryInSec !== undefined ? { retryInSec: s.retryInSec } : {}),
-                ...(s.retryInMs !== undefined ? { retryInMs: s.retryInMs } : {}),
-                ...(s.retryAtMs !== undefined ? { retryAtMs: s.retryAtMs } : {}),
-                ...(s.elapsedMs !== undefined ? { elapsedMs: s.elapsedMs } : {}),
-                ...(s.timeoutMs !== undefined ? { timeoutMs: s.timeoutMs } : {}),
-                ...(s.attempt !== undefined ? { attempt: s.attempt } : {}),
-                ...(s.maxRetries !== undefined ? { maxRetries: s.maxRetries } : {}),
-                ...(s.errClass !== undefined ? { errClass: s.errClass } : {}),
-                ...(s.errorStatus !== undefined ? { errorStatus: s.errorStatus } : {}),
-                ...ident(),
-            };
-            Object.freeze(frame);
-            const accepted = queue.push(frame);
-            if (accepted && internals?.onStatusEvent !== undefined) {
-                statusSinkNotifier.notify(() => observeThenableRejection(internals.onStatusEvent?.(frame), statusSinkNotifier, "runtask.onStatusEvent"), "runtask.onStatusEvent");
-            }
-        };
-        const telemetryEmit = (t) => {
-            emitTrace(rs.telemetry.tracer, () => t.kind === "failover"
-                ? {
-                    kind: "brain.failover",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    servedIndex: t.servedIndex,
-                    total: t.total,
-                    ...(t.errorCode !== undefined ? { errorCode: t.errorCode } : {}),
-                    ts: Date.now(),
-                }
-                : t.kind === "breaker"
-                    ? { kind: "breaker.transition", version: 1, taskId: rs.telemetry.taskId, key: t.key, phase: t.phase, failures: t.failures, ts: Date.now() }
-                    : t.kind === "retry"
-                        ? {
-                            kind: "brain.retry",
-                            version: 1,
-                            taskId: rs.telemetry.taskId,
-                            attempt: t.attempt,
-                            phase: t.phase,
-                            ...(t.errClass !== undefined ? { errClass: t.errClass } : {}),
-                            ...(t.nextDelayMs !== undefined ? { nextDelayMs: t.nextDelayMs } : {}),
-                            ts: Date.now(),
-                        }
-                        : { kind: "vision.placeholder", version: 1, taskId: rs.telemetry.taskId, count: t.count, ts: Date.now() });
-        };
-        const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, () => runWithReasoningWireFacts(observeReasoningWireFacts, fn)));
+    }
+    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() });
@@ -1113,412 +462,16 @@ export class Runner {
                 runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
             },
         });
-        const recordCompactionUsage = (m, msg) => {
-            const u = msg?.usage;
-            if (!u)
-                return;
-            const fam = cacheFamilyOf(m);
-            const price = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-            const priced = isModelPriced(m, this.deps.pricing);
-            if (!priced)
-                rs.telemetry.unpricedSpend = true;
-            noteUnevaluablePriceTable(price);
-            const { totalInputTokens, uncachedInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
-            stats.tokens += u.totalTokens || 0;
-            stats.promptTokens += uncachedInputTokens;
-            stats.totalInputTokens += totalInputTokens;
-            stats.cachedTokens += u.cacheRead || 0;
-            stats.cacheWriteTokens += u.cacheWrite || 0;
-            stats.outputTokens += u.output || 0;
-            stats.costMicroUsd += costMicroUsd;
-            stats.compactionMicroUsd = (stats.compactionMicroUsd ?? 0) + costMicroUsd;
-            emitTrace(rs.telemetry.tracer, () => ({
-                kind: "brain.call", version: 1, taskId: rs.telemetry.taskId, model: m.id, provider: m.provider,
-                promptTokens: uncachedInputTokens, totalInputTokens, completionTokens: u.output || 0,
-                cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0,
-                latencyMs: 0, ...(priced ? { costMicroUsd } : {}), ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
-            }));
-        };
-        const compactionBrain = {
-            stream: this.deps.brain.stream,
-            complete: async (m, c, o) => {
-                const msg = await runWithStatusSink(() => { }, async () => await runWithReasoningWireFacts(() => { }, async () => this.deps.brain.complete
-                    ? await this.deps.brain.complete(m, c, o)
-                    : await (await Promise.resolve(this.deps.brain.stream(m, c, o))).result()));
-                recordCompactionUsage(m, msg);
-                return msg;
-            },
-        };
-        const withinTaskCompaction = (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true);
-        const compactionBreaker = { failures: 0 };
-        if (spec.compaction?.enabled ?? true) {
-            const prefixWindow = resolveTriggerWindow(prepared.model).window;
-            if (Number.isFinite(prefixWindow) && prefixWindow > 0) {
-                const prefixSettings = sanitizeCompactionSettings({ ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction }, prefixWindow);
-                const prefixCompactAt = prefixWindow - prefixSettings.reserveTokens;
-                if (prepared.promptOverheadTokens >= prefixCompactAt) {
-                    this.deps.onError?.(new Error(`compaction cannot help: the fixed request prefix (system prompt + tool schemas, ≈${prepared.promptOverheadTokens} tokens) ` +
-                        `already meets or exceeds the compaction threshold (${prefixCompactAt} of a ${prefixWindow}-token window). ` +
-                        `Compaction only shrinks conversation history, so this run will re-trigger or overflow regardless — ` +
-                        `shrink the system prompt/tool surface or use a larger-window model.`), { phase: "config", sessionId: prepared.sessionId });
-                }
-            }
-        }
-        const windowSafetyOptions = (mainModel) => ({
-            ...(rs.budget.maxCostMicroUsd !== undefined
-                ? {
-                    fallbackBudget: {
-                        spentMicroUsd: () => stats.costMicroUsd,
-                        capMicroUsd: rs.budget.maxCostMicroUsd,
-                        mainInputPer1M: (this.deps.pricing?.[mainModel.id] ?? modelCostToPricing(mainModel.cost)).inputPer1M,
-                    },
-                }
-                : {}),
-            onWindowSafety: (info) => {
-                if (info.kind === "fallback") {
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.model_fallback",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        contentTokens: info.contentTokens,
-                        headroomTokens: info.headroomTokens ?? 0,
-                        truncationRatio: info.truncationRatio,
-                        ...(info.estCostMicroUsd !== undefined ? { estCostMicroUsd: info.estCostMicroUsd } : {}),
-                        ts: Date.now(),
-                    }));
-                }
-                else {
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.clamp_disclosure",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        truncationRatio: info.truncationRatio,
-                        reason: info.reason ?? "tolerance",
-                        ...(info.estCostMicroUsd !== undefined ? { estCostMicroUsd: info.estCostMicroUsd } : {}),
-                        ts: Date.now(),
-                    }));
-                }
+        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 stopHook = (spec.hooks ?? this.deps.hooks)?.stop;
-        const finalVerificationOn = spec.finalVerification === true;
-        const finalVerifyBudgetFill = () => {
-            let worst = 0;
-            if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow > 0)
-                worst = Math.max(worst, stats.tokens / rs.budget.maxTokensWindow);
-            if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd > 0)
-                worst = Math.max(worst, stats.costMicroUsd / rs.budget.maxCostMicroUsd);
-            if (walltimeMonotonicDeadline !== undefined && prepared.suspendForResource === undefined) {
-                const windowMs = walltimeMonotonicDeadline - rs.telemetry.taskStartMonotonic;
-                if (windowMs > 0)
-                    worst = Math.max(worst, (performance.now() - rs.telemetry.taskStartMonotonic) / windowMs);
-            }
-            return worst;
-        };
-        const emitFinalVerifyEcho = (body) => {
-            queue.push({ type: "steering_injected", source: "final_verification", preview: body.slice(0, 220), ...ident() });
-        };
-        if (stopHook || finalVerificationOn) {
-            let consecutiveBlocks = 0;
-            prepared.harness.setStopGate(async () => {
-                if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined || prepared.batchHaltRef.current !== undefined)
-                    return [];
-                if (finalVerificationOn &&
-                    (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
-                    rs.counters.wroteThisRun &&
-                    prepared.outputRef.set !== true &&
-                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1) &&
-                    finalVerifyBudgetFill() < 0.9) {
-                    rs.counters.finalVerifyInjections += 1;
-                    if (rs.counters.finalVerifyInjections === 2) {
-                        const reentryBody = openSystemReminder(prepared.reminderMark) +
-                            "[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
-                            "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
-                            "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
-                            "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
-                            "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
-                            "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
-                            "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
-                            "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
-                            "this verification gate — it will not intervene again.</system-reminder>";
-                        emitFinalVerifyEcho(reentryBody);
-                        return [
-                            {
-                                role: "user",
-                                engineMinted: true,
-                                content: reentryBody,
-                                timestamp: Date.now(),
-                            },
-                        ];
-                    }
-                    const nudgeBody = openSystemReminder(prepared.reminderMark) +
-                        "[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
-                        "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
-                        "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
-                        "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
-                        "finishing. " +
-                        "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
-                        "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
-                        "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
-                        "license to skip the real acceptance path or to check a substitute of your own making: expected " +
-                        "values must come from the task's requirements, never from content you generated. If the real " +
-                        "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
-                        "required final state, and verify that final state before finishing. " +
-                        "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
-                        "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
-                        "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
-                        "produced it matches the task's requirements. " +
-                        "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
-                        "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
-                        "correctness — and cross-check through an independent second path where the task or environment offers one " +
-                        "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
-                        "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
-                        "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
-                        "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
-                        "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
-                        "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
-                        "no reported check result means the work is not finished. " +
-                        "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
-                        "oracle to check against, briefly confirm completion and stop. " +
-                        "Residue YOUR OWN testing created (scratch files, running processes, generated outputs the task does not ask for) " +
-                        "is not protected state — if the task's required final state is a clean target, removing your own residue is part " +
-                        "of delivering it. " +
-                        "Verification must never LAUNDER uncertainty: if part of your conclusion was uncertain before this check, keep " +
-                        "reporting it as uncertain unless the check you actually ran resolved it — a re-stated conclusion is not new " +
-                        "evidence.</system-reminder>";
-                    emitFinalVerifyEcho(nudgeBody);
-                    return [
-                        {
-                            role: "user",
-                            engineMinted: true,
-                            content: nudgeBody,
-                            timestamp: Date.now(),
-                        },
-                    ];
-                }
-                if (!stopHook)
-                    return [];
-                let result;
-                try {
-                    const stopSeat = await runHookSeat("stop", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => stopHook({
-                        stopHookActive: consecutiveBlocks > 0,
-                        consecutiveBlocks,
-                        getBranch: () => prepared.session.getBranch(),
-                        identity: prepared.hookIdentity,
-                        signal: sig,
-                    }));
-                    if (stopSeat.expired) {
-                        if (stopSeat.cause === "timeout") {
-                            this.deps.onError?.(hookSeatExpiredError("stop", prepared.hookTimeoutMs, stopSeat.cause, "the run was allowed to END (the seat's own no-opinion answer); no pushback and no additional context were injected"), { phase: "hook", sessionId: prepared.sessionId });
-                        }
-                        consecutiveBlocks = 0;
-                        return [];
-                    }
-                    result = stopSeat.value;
-                }
-                catch (err) {
-                    this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
-                    return [];
-                }
-                const messages = [];
-                if (result?.additionalContext) {
-                    messages.push({
-                        role: "user",
-                        engineMinted: true,
-                        content: formatHookFeedback(`Stop hook additional context: ${result.additionalContext}`, prepared.reminderMark),
-                        timestamp: Date.now(),
-                    });
-                }
-                if (messages.length === 0 && !result?.block) {
-                    consecutiveBlocks = 0;
-                    return messages;
-                }
-                consecutiveBlocks++;
-                const cap = STOP_HOOK_BLOCK_CAP;
-                if (consecutiveBlocks > cap) {
-                    this.deps.onError?.(new Error(`a Stop hook kept the turn from ending ${consecutiveBlocks} consecutive times — overriding and ending the run. ` +
-                        `Both a block and an additionalContext-only push-back count (CC 2.1.220). ` +
-                        `Check ctx.stopHookActive in the hook and return success while it's true.`), { phase: "hook", sessionId: prepared.sessionId });
-                    return [];
-                }
-                if (result?.block) {
-                    messages.push({
-                        role: "user",
-                        engineMinted: true,
-                        content: formatHookFeedback(`Stop hook stopped continuation: ${result.block}`, prepared.reminderMark),
-                        timestamp: Date.now(),
-                    });
-                }
-                return messages;
-            });
-        }
-        const runForcedCompactionPass = async (lane, turnSignal) => {
-            if (!(spec.compaction?.enabled ?? true))
-                return false;
-            if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
-                return false;
-            const passSignal = turnSignal !== undefined ? AbortSignal.any([prepared.abortController.signal, turnSignal]) : prepared.abortController.signal;
-            try {
-                const comp = await maybeCompact({
-                    session: prepared.session,
-                    epochDeclaredSections: prepared.epochDeclaredSections,
-                    ...centerAdoptionOption(prepared),
-                    model: prepared.harness.getModel(),
-                    compactionModel: prepared.compModel,
-                    ...forkContextOption(prepared, true),
-                    brain: compactionBrain,
-                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                    thinking: prepared.thinking,
-                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    signal: passSignal,
-                    minTokens: 0,
-                    force: true,
-                    overheadTokens: prepared.promptOverheadTokens,
-                    ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                    onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
-                    workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
-                    ...contextInstructionFilesOption(prepared),
-                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                    ...this.seamCCompactionOptions(prepared),
-                    ...gitRestateOption(prepared),
-                    ...windowSafetyOptions(prepared.harness.getModel()),
-                    ...this.compactionHookOptions(spec, prepared.sessionId, "forced", prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: passSignal }),
-                });
-                if (comp.compacted) {
-                    compactionBreaker.failures = 0;
-                    this.recordCompactionReuse(prepared, comp);
-                    if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                        const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                        rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
-                    }
-                    queue.push({
-                        type: "compacted",
-                        trigger: "forced",
-                        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 (rs.attach.attachState !== undefined) {
-                        rs.attach.attachState.postCompactPending = true;
-                        rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
-                    }
-                }
-                else {
-                    if (comp.noop) {
-                        compactionBreaker.failures = 0;
-                    }
-                    else {
-                        compactionBreaker.failures += 1;
-                    }
-                    const declineReason = lane === "rejection" ? "prompt-too-long recovery pass did not land" : "guard-chain forced compaction pass did not land";
-                    if (!comp.noop) {
-                        this.deps.onError?.(new Error(declineReason), { phase: "compaction", sessionId: prepared.sessionId });
-                    }
-                    queue.push({
-                        type: "compaction_outcome",
-                        outcome: comp.noop ? "noop" : "failed",
-                        trigger: "forced",
-                        reason: declineReason,
-                        ...ident(),
-                    });
-                }
-                return comp.compacted === true;
-            }
-            catch (err) {
-                if (turnSignal?.aborted === true && !prepared.abortController.signal.aborted) {
-                    const interruptReason = lane === "rejection"
-                        ? "prompt-too-long recovery pass cut short by a turn interrupt"
-                        : "guard-chain forced compaction cut short by a turn interrupt";
-                    queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: interruptReason, ...ident() });
-                    return false;
-                }
-                compactionBreaker.failures += 1;
-                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "compaction", sessionId: prepared.sessionId });
-                const msg = String(err instanceof Error ? err.message : err);
-                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
-                return false;
-            }
-        };
-        prepared.harness.setLoopRecovery({
-            truncatedOutput: {},
-            malformedToolUse: {},
-            thinkingOnly: {},
-            degenerateOutput: { detect: (m) => isDegenerateCutMessage(m) },
-            promptTooLong: {
-                recover: async (attempt, turnSignal) => {
-                    if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
-                        return false;
-                    if (turnSignal?.aborted === true)
-                        return false;
-                    if (prepared.microCompact.clearOnRejection && attempt === 1) {
-                        const proj = prepared.microCompact.projectionRef.current;
-                        const compactionAvailable = (spec.compaction?.enabled ?? true) && compactionBreaker.failures < MAX_CONSECUTIVE_COMPACTION_FAILURES;
-                        const declineArm = compactionAvailable ? "forced_compaction" : "none";
-                        const plan = proj === undefined
-                            ? { declined: "no_candidates" }
-                            : planRejectionClears(proj.messages, {
-                                keyOf: proj.keyOf,
-                                ...(prepared.microCompact.offloadPersist ? { offload: { persist: prepared.microCompact.offloadPersist } } : {}),
-                            });
-                        if ("declined" in plan) {
-                            emitTrace(rs.telemetry.tracer, () => ({
-                                kind: "context.mc_null",
-                                version: 1,
-                                taskId: rs.telemetry.taskId,
-                                reason: plan.declined,
-                                nextArm: declineArm,
-                                ts: Date.now(),
-                            }));
-                        }
-                        else {
-                            for (const e of plan.cleared) {
-                                prepared.microCompact.ledger.entries.set(e.key, { marker: e.marker, groupCount: e.groupCount, fp: e.fp });
-                            }
-                            emitTrace(rs.telemetry.tracer, () => ({
-                                kind: "context.mc_clear",
-                                version: 1,
-                                taskId: rs.telemetry.taskId,
-                                clearedCount: plan.cleared.length,
-                                tokensSavedEstimate: plan.tokensSavedEstimate,
-                                trigger: "refusal",
-                                ts: Date.now(),
-                            }));
-                            return true;
-                        }
-                    }
-                    return runForcedCompactionPass("rejection", turnSignal);
-                },
-            },
-        });
-        prepared.microCompact.inTurnCompactionRef.current = async (turnSignal, anchoredEstimate) => {
-            if (prepared.abortController.signal.aborted || prepared.pausedRef.current !== undefined)
-                return false;
-            if (turnSignal?.aborted === true)
-                return false;
-            if (anchoredEstimate !== undefined && rs.counters.compactionFloor > 0 && anchoredEstimate < rs.counters.compactionFloor) {
-                const floor = rs.counters.compactionFloor;
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.suppressed", version: 1, taskId: rs.telemetry.taskId, estTokens: anchoredEstimate, floor, ts: Date.now() }));
-                queue.push({ type: "compaction_outcome", outcome: "suppressed", trigger: "forced", ...ident() });
-                return false;
-            }
-            return runForcedCompactionPass("guard", turnSignal);
-        };
         const rapidRefill = createRapidRefillState();
         const drainManualCompact = (outcome) => {
             manualCompactRef.requested = false;
@@ -1540,955 +493,25 @@ export class Runner {
                 },
             },
         });
-        prepared.gitStatusRef.reassert = async () => {
-            const ref = prepared.gitStatusRef;
-            const frame = ref.frame;
-            if (frame === undefined)
-                return;
-            delete ref.mirrorOwed;
-            const use = ref.overBudgetShrunk && frame.shrunk !== undefined
-                ? { kind: "degraded", body: frame.shrunk.body, hash: frame.shrunk.hash }
-                : { kind: frame.kind, body: frame.body, hash: frame.hash };
-            const wrapped = wrapGitFrame(use.body, prepared.reminderMark);
-            try {
-                const entryId = await prepared.session.appendMessage({
-                    role: "user",
-                    content: [{ type: "text", text: wrapped }],
-                    timestamp: Date.now(),
-                    engineMinted: true,
-                });
-                ref.announced = { kind: use.kind, hash: use.hash, entryId };
-                ref.protectedText = wrapped;
-                if (use.kind === "full" && frame.shrunk !== undefined) {
-                    ref.wrappedShrink = { find: wrapped, replace: wrapGitFrame(frame.shrunk.body, prepared.reminderMark) };
-                }
-                else {
-                    delete ref.wrappedShrink;
-                }
-                queue.push({ type: "steering_injected", source: "git_status", preview: GIT_STATUS_ECHO_PREVIEW[use.kind], ...ident() });
-                rs.attach.attachmentsInjected += 1;
-                try {
-                    await prepared.session.appendGitAnnouncement?.({ kind: use.kind, hash: use.hash, entryId });
-                }
-                catch (mirrorErr) {
-                    try {
-                        this.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; next leg re-announces): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            catch (err) {
-                ref.announced = { kind: use.kind, hash: use.hash, pending: true };
-                try {
-                    this.deps.onError?.(new Error(`git status frame re-assert append failed (pending; retried at the next boundary): ${err instanceof Error ? err.message : String(err)}`), { phase: "degraded", sessionId: prepared.sessionId });
-                }
-                catch {
-                }
-            }
-        };
-        const flushGitMirror = async () => {
-            const owed = prepared.gitStatusRef.mirrorOwed;
-            if (owed === undefined)
-                return;
-            if (prepared.gitStatusRef.overBudgetShrunk && owed.kind === "full") {
-                delete prepared.gitStatusRef.mirrorOwed;
-                return;
-            }
-            delete prepared.gitStatusRef.mirrorOwed;
-            try {
-                await prepared.session.appendGitAnnouncement?.(owed);
-            }
-            catch (mirrorErr) {
-                prepared.gitStatusRef.mirrorOwed = owed;
-                try {
-                    this.deps.onError?.(new Error(`git announcement mirror write failed (frame delivered; retried at the next serialization point): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`), { phase: "degraded", sessionId: prepared.sessionId });
-                }
-                catch {
-                }
-            }
-        };
-        const unsubGitRetry = prepared.harness.on("turn_boundary", async () => {
-            await flushGitMirror();
-            if (prepared.gitStatusRef.announced?.pending === true)
-                await prepared.gitStatusRef.reassert?.();
-            return undefined;
-        });
-        const unsubBoundary = prepared.harness.on("turn_boundary", onTurnBoundary);
-        const unsub = prepared.harness.subscribe((event) => {
-            switch (event.type) {
-                case "message_update":
-                    onMessageUpdate(event);
-                    break;
-                case "message_end":
-                    onMessageEnd(event);
-                    break;
-                case "tool_execution_start":
-                    onToolStart(event);
-                    break;
-                case "tool_execution_end":
-                    onToolEnd(event);
-                    break;
-                case "turn_end":
-                    onTurnEnd();
-                    break;
-                default:
-                    break;
-            }
-        });
-        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,
+        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),
+                }),
+            }),
         });
-        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 : {};