@sema-agent/core 7.11.2 → 7.13.0

package/dist/core/runner/runtask.js

@@ -1,63 +1,30 @@
-import { mintSystemReminder } from "../reminder-mint.js";
-import { deliverEngineNotice, undrainedUserInputNotices } from "../types.js";
-import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, isSyntheticApiErrorMessage, uuidv7 } from "../../internal/harness.js";
+import { deliverEngineNotice } from "../types.js";
+import { uuidv7 } from "../../internal/harness.js";
 import { snapshotActorAssertion } from "../../internal/llm.js";
-import { CheckpointError, remainingBudgetMicroUsd, readPendingSteerQueue, resolveCheckpointStore, realApprovalOrgFact } from "../checkpoint-store.js";
-import { GIT_STATUS_ECHO_PREVIEW } from "./git-status-frame.js";
-import { settleExecutionRecord } from "./execution-record.js";
-import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact } from "../auto-compaction.js";
-import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
+import { CheckpointError } from "../checkpoint-store.js";
+import { createRapidRefillState } from "../auto-compaction.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
-import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
 import { emitTaskOutcome } from "../task-outcome.js";
-import { isDegenerateCutMessage } from "../../brain/terminal-cause.js";
-import { redactThenCut } from "../../agents/subagent-steps.js";
-import { adjudicateDerivedRoute, authCarrierFingerprint, fallbackToPrimaryNotice, normalizeBaseUrl, sameRouteIdentity } from "../../brain/route-adjudicator.js";
+import { authCarrierFingerprint, normalizeBaseUrl } from "../../brain/route-adjudicator.js";
 import { runWithReasoningWireFacts } from "../../brain/status-sink.js";
-import { expandTiers, resolveTaskModel } from "../roles.js";
+import { expandTiers } from "../roles.js";
 import { screenSwappableDeps } from "../swappable-deps.js";
-import { AutoModeBreakerLedger } from "../auto-mode.js";
 import { runSideQuery } from "../side-query.js";
-import { generatePromptSuggestions } from "./prompt-suggestions.js";
 import { PushQueue } from "../push-queue.js";
 import { TtlSessionStore } from "../session-store.js";
-import { toImageContent } from "./image.js";
-import { assembleResult, errorCodeOf } from "./assemble-result.js";
-import { amendTerminal, terminalProjection } from "./terminal-projection.js";
-import { attachmentEnvelopeTags, commitAgentListing, commitSkillsListing, reduceToolEnd, renderAgentListingDelta, renderOrphanedBackgroundTasks, renderSkillsListingDelta, stampWriteAnchor } from "./turn-attachments.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { errorCodeOf } from "./assemble-result.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 { 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 { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { PAUSE_REGISTRY } from "../pause-registry.js";
-import { refuseOutOfContractDecision, toolPolicyNameSets } from "../tool-policy.js";
-import { mintGateOutcome } from "./gate-exit.js";
-import { defaultTaskRegistry } from "../task-registry.js";
-import { isDelegatedAgentTerminal, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { toolPolicyNameSets } from "../tool-policy.js";
+import { PendingSessionNotifications } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
-import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { createRunState } from "./initial-run-state.js";
-import { nextHumanInputSeq } from "./steer-admission.js";
-import { reconciledToolEndBody, toolEndBodyFrom, toolResultMsg } from "./tool-end-body.js";
-import { answerFaceForRedeemedCall, deepJsonEqual, DEFERRED_REISSUE, pendingContentAskCallId, resumeContinuation, resumeDecisionWasNegative } from "./decide-continuation.js";
-import { awaitChargeWithSlowDisclosure, DEFAULT_PRECALL_OUTPUT_TOKENS, discloseUnevaluableWindow, platformLimitTerminal, TIMER_LATENESS_REPORT_MS } from "./clock-and-limits.js";
-import { gitRestateOption, resolveGitLegDelivery, wrapGitFrame } from "./git-leg-delivery.js";
+import { reconciledToolEndBody } from "./tool-end-body.js";
+import { answerFaceForRedeemedCall } from "./decide-continuation.js";
 import { createTurnBoundary } from "./run-turn-boundary.js";
-import { MAX_CONSECUTIVE_COMPACTION_FAILURES } from "./compaction-knobs.js";
 import { createHarnessHandlers } from "./run-harness-handlers.js";
 import { resumeAdmission } from "./resume-admission.js";
 import { resumeReviewOutcome } from "./resume-review-outcome.js";
@@ -72,6 +39,10 @@ import { streamReap } from "./stream-reap.js";
 import { streamSteerVerb } from "./stream-steer-verb.js";
 import { streamLifecycleVerbs } from "./stream-lifecycle-verbs.js";
 import { streamHaltVerbs } from "./stream-halt-verbs.js";
+import { runNotificationLane } from "./run-notification-lane.js";
+import { runLeg } from "./run-leg.js";
+import { runTerminalAdoption } from "./run-terminal-adoption.js";
+import { runSettleAndTeardown } from "./run-settle-and-teardown.js";
 import { runIdentityWiring } from "./run-identity-wiring.js";
 import { runTelemetryAndBudgetSeats } from "./run-telemetry-and-budget-seats.js";
 import { runAttachmentSeats } from "./run-attachment-seats.js";
@@ -83,17 +54,11 @@ import { runCompactionMachinery } from "./run-compaction-machinery.js";
 import { runStopAndFinalVerify } from "./run-stop-and-final-verify.js";
 import { runRecoveryLanes } from "./run-recovery-lanes.js";
 import { runGitLane } from "./run-git-lane.js";
-const ORG_DISCLOSURE_MAX_CHARS = 600;
-const SUGGESTIONS_DEFAULT_COUNT = 3;
-const SUGGESTIONS_MAX_COUNT = 8;
-const SUGGESTIONS_TIMEOUT_MS = 30_000;
-const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
 export class Runner {
     deps;
     sessions;
     sessionLocks = new Map();
     sessionReadStates = new SessionReadFileStates();
-    autoModeBreakerLedger = new AutoModeBreakerLedger();
     pendingSessionNotifications = new PendingSessionNotifications();
     parentConstraintRegistry = new Map();
     suspendedEnvReaps = new Map();
@@ -429,1115 +394,82 @@ export class Runner {
             destroy,
         };
     }
-    async runLocked(input) {
+    runLocked(input) {
         const { spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer } = input;
-        const prepareResume = resume
-            ? {
-                leafId: resume.cp.leafId,
-                suspendedBatch: new Set(resume.cp.pendingAction.kind === "tool_approval" ? resume.cp.pendingAction.batchToolCallIds : []),
-                seed: resume.cp.state,
-                priorSuspendCount: resume.cp.suspendCount,
-                priorLedger: resume.cp.resourceLedger,
-                priorHumanReview: resume.cp.humanReview,
-                workspaceHandle: resume.cp.state.workspaceHandle,
-                executesApprovedAction: resume.cp.pendingAction.kind === "tool_approval" &&
-                    resume.outcome.gate !== "wake" &&
-                    resume.outcome.decision === "allow",
-                ...(resume.outcome.gate !== "wake" && resume.outcome.decision === "allow" && pendingContentAskCallId(resume.cp) !== undefined
-                    ? {
-                        redeemedContentAskCallId: pendingContentAskCallId(resume.cp),
-                        redeemedContentAskQuestionsHash: boundInputHashOf(resume.cp.pendingAction.args?.questions),
-                    }
-                    : {}),
-            }
-            : undefined;
-        const taskNotificationQueue = new SystemInjectionQueue();
-        const detachHub = internals?.detachHub ?? new ToolDetachHub();
-        let notificationHarness;
-        let notificationIdent = () => ({});
-        let notificationLaneLive = true;
-        let notificationSessionId;
-        let descendantAnchorDisclosed = false;
-        const parkTaskNotification = (payload, priority) => {
-            if (notificationSessionId !== undefined)
-                this.pendingSessionNotifications.pend(notificationSessionId, payload, priority);
-            if (!isDelegatedAgentTerminal(payload))
-                return;
-            const uplink = internals?.parentNotify;
-            if (uplink !== undefined) {
-                try {
-                    uplink(payload, { priority });
-                }
-                catch (e) {
-                    this.deps.onError?.(e, { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-uplink" });
-                }
-                return;
-            }
-            const rootAnchor = internals?.rootSessionId;
-            if (rootAnchor !== undefined && rootAnchor !== notificationSessionId) {
-                this.pendingSessionNotifications.pend(rootAnchor, payload, priority);
-                return;
-            }
-            if (internals?.parentSessionId !== undefined && !descendantAnchorDisclosed) {
-                descendantAnchorDisclosed = true;
-                this.deps.onError?.(new Error(`background-agent terminal ${payload.task_id} parked on this run's own session — the delegation tree's root session is not reachable from this run (no uplink, no root anchor)`), { phase: "degraded", sessionId: notificationSessionId ?? "", classification: "descendant-terminal-unrouted" });
-            }
-        };
-        const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
-            queue.push({ type: "task_notification", notification: item.payload, priority: item.priority, ...notificationIdent() });
-            if (notificationHarness && prepared.batchHaltRef.current === undefined) {
-                const xml = renderTaskNotificationXml(item.payload);
-                const noteOptions = {
-                    provenance: "engine-note",
-                    enginePayload: item.payload,
-                    ...(item.payload.task_type !== "external" && isTerminalTaskNotification(item.payload) ? { capPreferred: true } : {}),
-                };
-                const deliver = item.priority === "later"
-                    ? notificationHarness.followUp(xml, noteOptions)
-                    : notificationHarness.steer(xml, { ...noteOptions, ...(item.priority === "now" ? { immediate: true } : {}) });
-                void deliver.then(() => item.onDisposition?.("queued"), () => {
-                    parkTaskNotification(item.payload, item.priority);
-                    item.onDisposition?.("parked");
+        return runNotificationLane({
+            spec, queue, resume, internals, taskIdRef,
+            runner: this.depsSeat, self: this, sessions: this.sessions, sessionReadStates: this.sessionReadStates, pendingSessionNotifications: this.pendingSessionNotifications,
+            prepareTask,
+            next: ({ prepared, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef, modelCatalog, notificationLane, unsubscribeTaskNotifications }) => {
+                const { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats, undrainedUserAtEnd, userInputLostAtEnd } = runIdentityWiring({
+                    spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef,
+                    notificationLane, pendingSessionNotifications: this.pendingSessionNotifications, runner: this.depsSeat,
                 });
-            }
-            else {
-                parkTaskNotification(item.payload, item.priority);
-                item.onDisposition?.("parked");
-            }
-        });
-        const upstreamTaskNotification = internals?.onTaskNotification;
-        const deliveredAtTurnOpen = new Set();
-        const injectTaskNotification = (notification, opts) => {
-            if (deliveredAtTurnOpen.has(taskNotificationDedupKey(notification)))
-                return Promise.resolve("dropped_duplicate");
-            if (!notificationLaneLive) {
-                parkTaskNotification(notification, opts?.priority ?? "later");
-                return Promise.resolve("parked");
-            }
-            return new Promise((resolve) => {
-                const accepted = taskNotificationQueue.enqueue({
-                    kind: "task_notification",
-                    priority: opts?.priority ?? "later",
-                    dedupKey: taskNotificationDedupKey(notification),
-                    payload: notification,
-                    onDisposition: resolve,
-                });
-                if (!accepted)
-                    resolve("queued");
-            });
-        };
-        const peerSelfRef = internals?.peerSelfRef ?? createPeerSelfRef(internals?.registryScope ?? spec.principal ?? "default");
-        const peerInboundChainRef = internals?.peerInboundChainRef ?? createPeerInboundChainRef();
-        const modelCatalog = this.deps.models;
-        const prepared = await prepareTask(spec, this.deps, this.sessions, prepareResume, {
-            ...(internals ?? {}),
-            peerSelfRef,
-            peerInboundChainRef,
-            detachHub,
-            sessionReadStates: this.sessionReadStates,
-            autoModeBreakerLedger: this.autoModeBreakerLedger,
-            onTaskNotification: (notification, opts) => {
-                try {
-                    upstreamTaskNotification?.(notification, opts);
-                }
-                catch {
-                }
-                injectTaskNotification(notification, opts);
-            },
-        }, this, taskIdRef);
-        let undrainedUserAtEnd;
-        const notificationLane = {
-            get harness() { return notificationHarness; }, set harness(h) { notificationHarness = h; },
-            get sessionId() { return notificationSessionId; }, set sessionId(s) { notificationSessionId = s; },
-            get ident() { return notificationIdent; }, set ident(f) { notificationIdent = f; },
-        };
-        const undrainedUserAtEndCell = { get current() { return undrainedUserAtEnd; }, set current(v) { undrainedUserAtEnd = v; } };
-        const { runSourceTaskId, parentToolCallId, ident, emitDelegationLifecycle, loopLatch, stats } = runIdentityWiring({
-            spec, queue, prepared, internals, taskIdRef, onReady, manualCompactRef, notifyRef, captureOptOutRef, injectTaskNotification, deliveredAtTurnOpen, peerInboundChainRef,
-            notificationLane, undrainedUserAtEnd: undrainedUserAtEndCell, pendingSessionNotifications: this.pendingSessionNotifications, runner: this.depsSeat,
-        });
-        const rs = createRunState();
-        const { noteUnevaluablePriceTable } = runTelemetryAndBudgetSeats({ spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner: this.depsSeat, sessions: this.sessions });
-        await runAttachmentSeats({ spec, prepared, resume, rs, runner: this.depsSeat });
-        const { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds } = runToolMountFacts({ spec, prepared, rs });
-        let reasoningResolution;
-        const reasoningResolutionCell = { get current() { return reasoningResolution; }, set current(v) { reasoningResolution = v; } };
-        const { observeReasoningWireFacts } = runReasoningSeat({ prepared, rs, taskIdRef, reasoningResolution: reasoningResolutionCell });
-        const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
-        const { subagentName, withBrainSinks } = runBrainSinks({ queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts });
-        const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
-        for (const orphan of prepared.wakeRecovered) {
-            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
-            emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
-        }
-        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
-        const batchArgs = postToolBatchHook ? new Map() : undefined;
-        rs.turn.toolBatch = [];
-        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
-            prepared, stats, rs,
-            deps: {
-                spec, queue, internals, ident, parentToolCallId, subagentName,
-                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
-                toolLabels, postToolBatchHook, batchArgs,
-                runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
-            },
-        });
-        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, runner: this.depsSeat });
-        runStopAndFinalVerify({ spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner: this.depsSeat });
-        runRecoveryLanes({
-            spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner: this.depsSeat,
-            compactionSeats: {
-                seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
-                compactionHookOptions: (s, sid, trig, identity, seatBound) => this.compactionHookOptions(s, sid, trig, identity, seatBound),
-                recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
-            },
-        });
-        const rapidRefill = createRapidRefillState();
-        const drainManualCompact = (outcome) => {
-            manualCompactRef.requested = false;
-            for (const w of manualCompactRef.waiters.splice(0))
-                w.resolve(outcome);
-        };
-        const onTurnBoundary = createTurnBoundary({
-            prepared, stats, rs,
-            deps: {
-                spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
-                walltimeMonotonicDeadline,
-                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
-                compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
-                runnerHooks: {
-                    onError: this.deps.onError,
-                    seamCCompactionOptions: (p) => this.seamCCompactionOptions(p),
-                    compactionHookOptions: (s, sid, trig) => this.compactionHookOptions(s, sid, trig, prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
-                    recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
-                },
-            },
-        });
-        const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
-        let final;
-        let threw;
-        let abortedLive = false;
-        let userInterruptedLive = false;
-        let strandedHumanAnswers = [];
-        try {
-            if (prepared.abortController.signal.aborted) {
-                const e = new Error("run aborted");
-                e.name = "AbortError";
-                throw e;
-            }
-            if (resume) {
-                const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
-                const resumeWindowRetryAfterMs = !walltimeExhaustedResume && prepared.usageGovernance !== undefined ? await prepared.usageGovernance.check(Date.now()) : undefined;
-                if (resumeWindowRetryAfterMs !== undefined) {
-                    const owesNothing = resume.outcome.gate === "resource_limit" &&
-                        readPendingSteerQueue(resume.cp.state).length === 0 &&
-                        (resume.cp.state.runningBackgroundTasks?.length ?? 0) === 0;
-                    const committed = owesNothing &&
-                        prepared.suspendForPlatformLimit !== undefined &&
-                        (await prepared.suspendForPlatformLimit("usage_window", { costMicroUsd: 0, tokens: 0, turns: 0, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) }, { resumeAfterMs: resumeWindowRetryAfterMs }));
-                    if (committed) {
-                        rs.limits.turnsExceeded = false;
-                        rs.limits.budgetHit = undefined;
-                    }
-                    else {
-                        const terminal = platformLimitTerminal("usage_window", resumeWindowRetryAfterMs, "resume");
-                        rs.limits.platformTerminal = terminal;
-                        try {
-                            this.deps.onError?.(terminal, { phase: "config", sessionId: prepared.sessionId });
-                        }
-                        catch {
-                        }
-                    }
-                }
-                if (resumeWindowRetryAfterMs === undefined && !walltimeExhaustedResume && resume.outcome.gate !== "wake") {
-                    await this.applyResumeDecision(prepared, resume, (e) => pushContent({ ...e, ...ident() }), emitCommitted, (toolName, details) => {
-                        if (rs.attach.attachState === undefined)
-                            return;
-                        const family = writeFamilyOf(toolName);
-                        if (family !== undefined)
-                            stampWriteAnchor(rs.attach.attachState, family, rs.counters.cadenceTurns);
-                        if (details !== undefined)
-                            reduceToolEnd(rs.attach.attachState, details);
-                    }, (toolCallId) => {
-                        startedToolCallIds.add(toolCallId);
-                        if (resume !== undefined && resume.cp.pendingAction.kind === "tool_approval" && toolCallId === resume.cp.pendingAction.toolCallId) {
-                            resume.pendingActionStarted = true;
-                        }
-                    });
-                    if (resume.outcome.gate === "policy_ask")
-                        resume.decisionDelivered = true;
-                    announceWorkspaceMove();
-                }
-                if (resumeWindowRetryAfterMs !== undefined) {
-                }
-                else if (walltimeExhaustedResume) {
-                    timeout.fired = true;
-                    timeout.clear();
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-                else if (rs.budget.maxTokensWindow !== undefined && rs.budget.maxTokensWindow <= 0) {
-                    rs.limits.budgetHit = "exceeded";
-                    rs.limits.budgetAxis = "tokens";
-                }
-                else if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd <= 0) {
-                    rs.limits.budgetHit = "exceeded";
-                    rs.limits.budgetAxis = "cost";
-                }
-                else {
-                    let continuation = resumeContinuation(resume, prepared.reminderMark);
-                    const bgSnapshot = resume.cp.state.runningBackgroundTasks;
-                    if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
-                        const alive = new Set(prepared.listBackgroundTasks().map((t) => t.id));
-                        const orphans = bgSnapshot.filter((t) => !alive.has(t.id));
-                        if (orphans.length > 0) {
-                            continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphans), prepared.reminderMark);
-                        }
-                    }
-                    let gitResumeDelivered;
-                    {
-                        const gitBody = await resolveGitLegDelivery(prepared, resume.cp.state.gitAnnouncement, (err) => {
-                            try {
-                                this.deps.onError?.(new Error(`git announcement ladder unreadable (conservative re-announce): ${err.message}`), { phase: "degraded", sessionId: prepared.sessionId });
-                            }
-                            catch {
-                            }
-                        });
-                        const gitFrame = prepared.gitStatusRef.frame;
-                        if (gitBody !== undefined && gitFrame !== undefined) {
-                            const wrappedGit = wrapGitFrame(gitBody, prepared.reminderMark);
-                            continuation += "\n\n" + wrappedGit;
-                            gitResumeDelivered = { kind: gitFrame.kind, hash: gitFrame.hash, wrapped: wrappedGit };
-                            if (gitFrame.kind === "full" && gitFrame.shrunk !== undefined) {
-                                prepared.gitStatusRef.wrappedShrink = { find: wrappedGit, replace: wrapGitFrame(gitFrame.shrunk.body, prepared.reminderMark) };
-                            }
-                        }
-                    }
-                    const engineSegments = continuation.length > 0 ? [{ start: 0, end: continuation.length }] : [];
-                    const resumeFrames = [
-                        ...readPendingSteerQueue(resume.cp.state).map((entry) => ({ entry, source: "steer" })),
-                        ...(resume.wakeMessage !== undefined ? [{ entry: resume.wakeMessage, source: "wake" }] : []),
-                    ];
-                    for (const { entry: steer, source } of resumeFrames) {
-                        if (source === "wake" && resume.wakeMessageHookContext !== undefined) {
-                            const hookStart = continuation.length;
-                            continuation += "\n\n" + formatHookFeedback(resume.wakeMessageHookContext, prepared.reminderMark);
-                            engineSegments.push({ start: hookStart, end: continuation.length });
-                        }
-                        if (source === "steer") {
-                            const parkedScreen = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
-                            if (parkedScreen !== undefined) {
-                                let outcome;
-                                try {
-                                    const seat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => parkedScreen(steer.text, {
-                                        identity: prepared.hookIdentity,
-                                        signal: sig,
-                                        source: "parked_redelivery",
-                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
-                                        ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
-                                    }));
-                                    outcome = seat.expired
-                                        ? { blocked: seat.cause === "timeout" ? `the screen did not answer within its ${prepared.hookTimeoutMs}ms bound (fail-closed)` : "the run was cancelled while the screen was still deciding (fail-closed)" }
-                                        : seat.value?.block !== undefined && seat.value.block !== ""
-                                            ? { blocked: inlineUntrusted(seat.value.block) }
-                                            : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
-                                }
-                                catch (hookErr) {
-                                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
-                                    try {
-                                        this.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
-                                    }
-                                    catch {
-                                    }
-                                    outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
-                                }
-                                if ("blocked" in outcome) {
-                                    deliverEngineNotice(this.deps.onNotice, {
-                                        code: "steering.parked_input_blocked",
-                                        message: "a parked steering input was withheld by the deployment's userPromptSubmit screen when this resume redelivered it: " +
-                                            `${outcome.blocked}. The parked row was consumed with the checkpoint; the instruction never reached the model — ` +
-                                            "re-issue it if it still applies.",
-                                        detail: {
-                                            ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
-                                            sessionId: prepared.sessionId,
-                                            runId: prepared.runId,
-                                            ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
-                                        },
-                                    });
-                                    queue.push({
-                                        ...buildHumanInputEvent({
-                                            carrier: source,
-                                            source,
-                                            delivery: "blocked",
-                                            sessionSeq: nextHumanInputSeq(prepared.harness),
-                                            ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
-                                            ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
-                                            ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
-                                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
-                                        }),
-                                        ...ident(),
-                                    });
-                                    continue;
-                                }
-                                if ("context" in outcome && outcome.context !== undefined) {
-                                    const hookStart = continuation.length;
-                                    continuation += "\n\n" + formatHookFeedback(outcome.context, prepared.reminderMark);
-                                    engineSegments.push({ start: hookStart, end: continuation.length });
-                                }
-                            }
+                const rs = createRunState();
+                const { noteUnevaluablePriceTable } = runTelemetryAndBudgetSeats({ spec, prepared, resume, stats, taskIdRef, entryTracer, modelCatalog, runSourceTaskId, rs, runner: this.depsSeat, sessions: this.sessions });
+                return runAttachmentSeats({
+                    spec, prepared, resume, rs, runner: this.depsSeat,
+                    next: () => {
+                        const { todoToolMounted, taskToolsMounted, writeFamilyOf, toolStartAt, startedToolCallIds } = runToolMountFacts({ spec, prepared, rs });
+                        const { observeReasoningWireFacts, reasoningResolution } = runReasoningSeat({ prepared, rs, taskIdRef });
+                        const { effectiveTimeoutMs, walltimeMonotonicDeadline, timeout, pushContent, ownCommittedTailRef, emitCommitted } = runClockAndContent({ spec, prepared, queue, internals, rs, ident, parentToolCallId, startedToolCallIds });
+                        const { subagentName, withBrainSinks } = runBrainSinks({ queue, internals, rs, ident, parentToolCallId, observeReasoningWireFacts });
+                        const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
+                        for (const orphan of prepared.wakeRecovered) {
+                            queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, ...(toolLabels.has(orphan.toolName) ? { label: toolLabels.get(orphan.toolName) } : {}), isError: true, ...reconciledToolEndBody(orphan, prepared.structuredProjector), ...ident() });
+                            emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
                         }
-                        const 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 };
+                        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
+                        const batchArgs = postToolBatchHook ? new Map() : undefined;
+                        rs.turn.toolBatch = [];
+                        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, announceWorkspaceMove } = createHarnessHandlers({
+                            prepared, stats, rs,
+                            deps: {
+                                spec, queue, internals, ident, parentToolCallId, subagentName,
+                                pushContent, emitCommitted, startedToolCallIds, toolStartAt, writeFamilyOf,
+                                toolLabels, postToolBatchHook, batchArgs,
+                                runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
                             },
+                        });
+                        const { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions } = runCompactionMachinery({ spec, prepared, rs, stats, noteUnevaluablePriceTable, runner: this.depsSeat });
+                        runStopAndFinalVerify({ spec, prepared, queue, rs, stats, ident, walltimeMonotonicDeadline, runner: this.depsSeat });
+                        runRecoveryLanes({ spec, prepared, queue, rs, ident, compactionBrain, compactionBreaker, windowSafetyOptions, runner: this.depsSeat });
+                        const rapidRefill = createRapidRefillState();
+                        const drainManualCompact = (outcome) => {
+                            manualCompactRef.requested = false;
+                            for (const w of manualCompactRef.waiters.splice(0))
+                                w.resolve(outcome);
                         };
-                    }
-                    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 };
+                        const onTurnBoundary = createTurnBoundary({
+                            prepared, stats, rs,
+                            deps: {
+                                spec, queue, loopLatch, manualCompactRef, todoToolMounted, taskToolsMounted,
+                                walltimeMonotonicDeadline,
+                                timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction,
+                                compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact,
+                                runnerHooks: { onError: this.deps.onError },
+                                runner: this.depsSeat,
                             },
-                        };
-                    }
-                    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,
-        });
-        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(),
+                        });
+                        const { flushGitMirror, unsubGitRetry, unsubBoundary, unsub } = runGitLane({ prepared, queue, rs, ident, onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd, onTurnBoundary, runner: this.depsSeat });
+                        return runLeg({
+                            spec, queue, prepared, resume, rs, entryActor, effectiveTimeoutMs, timeout, pushContent, ident, emitCommitted, writeFamilyOf, startedToolCallIds,
+                            announceWorkspaceMove, withBrainSinks, flushGitMirror, loopLatch, notificationLane, unsubscribeTaskNotifications, unsubGitRetry, unsubBoundary, unsub,
+                            runner: this.depsSeat,
+                            next: ({ final, threw, abortedLive, userInterruptedLive, strandedHumanAnswers }) => runTerminalAdoption({
+                                spec, queue, prepared, rs, stats, ident, emitCommitted, startedToolCallIds, toolLabels, timeout, compactionBrain, compactionBreaker, windowSafetyOptions,
+                                undrainedUserAtEnd, userInputLostAtEnd, final, threw, abortedLive, userInterruptedLive, runner: this.depsSeat, sessions: this.sessions,
+                                next: ({ threw, comp, answerSettled }) => runSettleAndTeardown({
+                                    spec, queue, prepared, resume, internals, rs, stats, ident, parentToolCallId, subagentName, loopLatch, timeout, ownCommittedTailRef,
+                                    emitDelegationLifecycle, taskIdRef, manualCompactRef, drainManualCompact, final, threw, abortedLive, userInterruptedLive, answerSettled, strandedHumanAnswers, reasoningResolution, comp,
+                                    setResult, onSuggestions, onSuspend, runner: this.depsSeat, sessions: this.sessions,
+                                }),
+                            }),
+                        });
+                    },
                 });
-                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 : {};
-        const count = cfg.count && cfg.count > 0 ? Math.min(cfg.count, SUGGESTIONS_MAX_COUNT) : SUGGESTIONS_DEFAULT_COUNT;
-        const ac = new AbortController();
-        let timer;
-        const timeout = new Promise((resolve) => {
-            timer = setTimeout(() => {
-                ac.abort();
-                resolve([]);
-            }, SUGGESTIONS_TIMEOUT_MS);
+            },
         });
-        const work = (async () => {
-            let model = prepared.model;
-            let thinking = prepared.thinking;
-            try {
-                const resolved = resolveTaskModel({ modelRole: cfg.role ?? "summarize", roles: spec.roles }, this.deps);
-                model = resolved.model;
-                thinking = resolved.thinking;
-            }
-            catch (roleErr) {
-                if (cfg.role !== undefined) {
-                    let asked;
-                    try {
-                        asked = String(cfg.role);
-                    }
-                    catch {
-                        asked = `<unrenderable ${typeof cfg.role}>`;
-                    }
-                    try {
-                        this.deps.onError?.(new Error(`suggestNextPrompts.role ${JSON.stringify(asked.length > 80 ? `${asked.slice(0, 80)}…` : asked)} did not resolve to a model — the prompt-suggestion pass ran on the task's own model (${prepared.model.id}) instead. Configure that role in RunnerDeps.roles / TaskSpec.roles, or omit the field to use the "summarize" role.`, { cause: roleErr }), { phase: "suggestions", sessionId: prepared.sessionId });
-                    }
-                    catch {
-                    }
-                }
-            }
-            if (!sameRouteIdentity(model, prepared.model)) {
-                const verdict = await adjudicateDerivedRoute({ brain: this.deps.brain, model, getApiKeyAndHeaders: spec.getApiKeyAndHeaders });
-                if (verdict !== undefined && !verdict.ok) {
-                    deliverEngineNotice(this.deps.onNotice, fallbackToPrimaryNotice({ seat: "prompt-suggestions", from: model.id, to: prepared.model.id, verdict, sessionId: prepared.sessionId, runId: prepared.runId }));
-                    model = prepared.model;
-                    thinking = prepared.thinking;
-                }
-            }
-            const pricing = this.deps.pricing?.[model.id] ?? modelCostToPricing(model.cost);
-            const ctx = await prepared.session.buildContext();
-            const transcript = ctx.messages.filter((m) => !isSyntheticApiErrorMessage(m)).slice(-SUGGESTIONS_TRANSCRIPT_MESSAGES);
-            const out = await generatePromptSuggestions({ brain: this.deps.brain, model, pricing, thinking, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, signal: ac.signal }, transcript, count);
-            if (out.tokens > 0 || out.costMicroUsd > 0) {
-                result.stats.suggestions = { tokens: out.tokens, costMicroUsd: out.costMicroUsd };
-                if (result.stats.costBreakdown) {
-                    result.stats.costBreakdown.suggestionsMicroUsd = out.costMicroUsd;
-                }
-            }
-            return out.suggestions;
-        })();
-        work.catch(() => { });
-        try {
-            return await Promise.race([work, timeout]);
-        }
-        catch (err) {
-            try {
-                this.deps.onError?.(err, { phase: "suggestions", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-            return [];
-        }
-        finally {
-            clearTimeout(timer);
-        }
     }
     async runTask(spec, internals) {
         const stream = this.runTaskStream(spec, undefined, internals);
@@ -1638,412 +570,6 @@ export class Runner {
         }
         return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, recordExecutionOutcome, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
     }
-    async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
-        const { pendingAction } = resume.cp;
-        if (resume.outcome.gate === "dry_run_review")
-            return;
-        if (resume.outcome.gate === "plan_review")
-            return;
-        if (pendingAction.kind !== "tool_approval")
-            return;
-        if (resume.outcome.gate === "policy_ask" &&
-            resume.outcome.decision === "allow" &&
-            !prepared.tools.some((t) => t.name === pendingAction.toolName)) {
-            const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume — refusing to continue as if it ran; the checkpoint is reopened for a retry with the tool present`);
-            e.code = "resume.tool_unavailable";
-            throw e;
-        }
-        const liveRoster = prepared.toolRosterDeltas.current;
-        if (pendingAction.kind === "tool_approval" && liveRoster !== undefined && judgeParkedToolIdentity(pendingAction, rosterEntryNamed(liveRoster, pendingAction.toolName)) === "mismatch") {
-            const e = new Error(`the approved tool "${pendingAction.toolName}" on this leg is not the tool the approval was minted against (its contract / shape / revision differ) — refusing to execute a replacement wearing the name; the checkpoint is reopened for a retry with the original tool present`);
-            e.code = "resume.tool_contract_mismatch";
-            throw e;
-        }
-        const completed = new Set(pendingAction.completedCallIds);
-        const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
-        const names = new Map();
-        const deferredArgs = new Map();
-        if (deferredIds.length > 0) {
-            const { messages } = await prepared.session.buildContext();
-            for (const m of messages) {
-                if (m.role === "assistant") {
-                    for (const c of m.content) {
-                        if (c.type === "toolCall") {
-                            names.set(c.id, c.name);
-                            deferredArgs.set(c.id, c.arguments);
-                        }
-                    }
-                }
-            }
-        }
-        for (const id of pendingAction.batchToolCallIds) {
-            if (id === pendingAction.toolCallId) {
-                await this.resolvePendingCall(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart);
-            }
-            else if (!completed.has(id)) {
-                const name = names.get(id) ?? "unknown";
-                const displayLabel = (() => {
-                    const l = prepared.tools.find((t) => t.name === name)?.label;
-                    return l !== undefined && l !== name ? { label: l } : {};
-                })();
-                emit({ type: "tool_start", toolCallId: id, toolName: name, ...displayLabel, args: deferredArgs.get(id) ?? {} });
-                emit({ type: "tool_end", toolCallId: id, toolName: name, ...displayLabel, isError: true, ...toolEndBodyFrom({ content: formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark) }, true, prepared.structuredProjector) });
-                const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE, prepared.reminderMark), true));
-                emitCommitted(eid, "toolResult", id);
-            }
-        }
-    }
-    async resolvePendingCall(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
-        const { pendingAction } = resume.cp;
-        const { outcome } = resume;
-        if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
-            return;
-        const decidedGate = outcome.gateOutcome;
-        if (decidedGate === undefined) {
-            throw new CheckpointError("checkpoint.invalid_outcome", "pending action reached the resolver with no settlement record on its decision (gateOutcome) — refusing to execute or settle a decision that carries no record");
-        }
-        const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput !== undefined ? outcome.updatedInput : pendingAction.args);
-        const pendingLabel = (() => { const l = prepared.tools.find((t) => t.name === pendingAction.toolName)?.label; return l !== undefined && l !== pendingAction.toolName ? { label: l } : {}; })();
-        emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, args: resolvedArgs });
-        const settleEnd = async (isError, result, gate = decidedGate) => {
-            emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, ...pendingLabel, isError, ...toolEndBodyFrom(result, isError, prepared.structuredProjector, gate) });
-            const word = await resume.recordExecutionOutcome(gate);
-            settleExecutionRecord(this.deps.onNotice, word, { toolName: pendingAction.toolName, gate, sessionId: prepared.sessionId, runId: prepared.runId, scope: resume.cp.scope, ...(resume.cp.checkpointId !== undefined ? { checkpointId: resume.cp.checkpointId } : {}) });
-        };
-        const vetoed = (layer) => mintGateOutcome({
-            deniedBy: layer,
-            ...(outcome.gateOutcome?.settlement !== undefined && outcome.gateOutcome.origin !== undefined ? { settled: { settlement: outcome.gateOutcome.settlement, origin: outcome.gateOutcome.origin } } : {}),
-        });
-        if (outcome.decision === "deny") {
-            const defaultDenial = outcome.gateOutcome?.settlement?.kind === "park_sla_expired"
-                ? `No one answered the approval request for the pending tool call "${pendingAction.toolName}" — the approval window elapsed with no answer, so it was not executed.`
-                : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
-            const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason, REVIEWER_NOTE_MAX_BODY) : defaultDenial;
-            await settleEnd(true, { content: formatHookFeedback(reason, prepared.reminderMark) });
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason, prepared.reminderMark), true));
-            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-            return;
-        }
-        if (outcome.decision !== "allow") {
-            throw new CheckpointError("checkpoint.invalid_outcome", `pending action reached the resolver with decision "${String(outcome.decision)}" — only "allow" executes and only "deny" injects a denial; refusing to execute`);
-        }
-        const beltBudget = {
-            resourceRemainingMicroUsd: remainingBudgetMicroUsd(prepared.resourceLedger),
-            resourceSpentMicroUsd: prepared.resourceLedger?.spentMicroUsd ?? 0,
-            suspendCount: resume.cp.suspendCount ?? 0,
-        };
-        if (outcome.decision === "allow" && outcome.updatedInput !== undefined && prepared.basePolicyForResumeEdit) {
-            const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check({
-                toolName: pendingAction.toolName,
-                args: resolvedArgs,
-                toolCallId: pendingAction.toolCallId,
-                budget: beltBudget,
-                ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
-                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
-            }, prepared.abortController.signal));
-            const beltUnsafe = rechecked.action === "deny" ||
-                (rechecked.updatedInput !== undefined && !deepJsonEqual(rechecked.updatedInput, resolvedArgs));
-            if (beltUnsafe) {
-                const editedDenial = formatHookFeedback(`The approver EDITED this call's input; the edited call is refused by the deployment's tool policy and was not executed${rechecked.action === "deny" && rechecked.message ? `: ${rechecked.message}` : " (the policy rewrote the edit to a value that was not approved)"}.`, prepared.reminderMark);
-                await settleEnd(true, { content: editedDenial }, vetoed("policy"));
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, editedDenial, true));
-                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-                return;
-            }
-        }
-        const gateRealApproval = resume.cp.gate.kind === "irreversible_ask" ? resume.cp.gate.realApproval : undefined;
-        const gateOrgGoverned = realApprovalOrgFact(gateRealApproval) !== undefined;
-        if (gateOrgGoverned && prepared.permissionRuleOrg === undefined) {
-            const unwiredDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its approval was minted under organization governance (${gateRealApproval.origin}), and this worker has no org adjudication wiring — a governed approval may only be redeemed where governance can be enforced. This approval is spent; re-issue the call on an org-wired worker.`, prepared.reminderMark);
-            await settleEnd(true, { content: unwiredDenial }, vetoed("org"));
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, unwiredDenial, true));
-            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-            return;
-        }
-        if (prepared.permissionRuleOrg !== undefined) {
-            const orgVerdict = prepared.permissionRuleOrg
-                .adjudicate({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId })
-                .catch(() => ({ status: "unavailable", disclosures: ["the org adjudication face threw on resume"] }));
-            let orgWaitCancelled = false;
-            const org = await settleOrgVerdictWithin(orgVerdict, { status: "unavailable", disclosures: [`the org adjudication face did not answer within ${ORG_ADJUDICATION_TIMEOUT_MS}ms (or the task ended first)`] }, {
-                signal: prepared.abortController.signal,
-                timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS,
-                onFallback: (cause) => {
-                    orgWaitCancelled = cause === "aborted";
-                },
-            });
-            const blocked = org.status === "unavailable"
-                ? realApprovalOrgFact(gateRealApproval) === "unavailable"
-                    ? undefined
-                    : orgWaitCancelled
-                        ? "this deployment is org-governed and the task was cancelled before the organization policy snapshot could be adjudicated"
-                        : "this deployment is org-governed and cannot currently adjudicate against an organization policy snapshot"
-                : org.verdict?.behavior === "deny"
-                    ? `an organization policy rule (${org.verdict.rule}) denies it`
-                    : undefined;
-            if (blocked !== undefined) {
-                const orgDisclosures = org.status === "unavailable" && org.disclosures.length > 0
-                    ? ` Governance disclosures: ${inlineUntrusted(org.disclosures.join("; "), ORG_DISCLOSURE_MAX_CHARS)}.`
-                    : "";
-                const orgDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${blocked}.${orgDisclosures} This approval is spent — the call has to be re-issued and approved again once organization policy permits it.`, prepared.reminderMark);
-                await settleEnd(true, { content: orgDenial }, vetoed("org"));
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, orgDenial, true));
-                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-                return;
-            }
-        }
-        if (prepared.denyNarrowingPolicy) {
-            const narrowed = refuseOutOfContractDecision(await prepared.denyNarrowingPolicy.check({
-                toolName: pendingAction.toolName,
-                args: resolvedArgs,
-                toolCallId: pendingAction.toolCallId,
-                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
-                budget: beltBudget,
-                ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
-            }, prepared.abortController.signal));
-            if (narrowed.action === "deny") {
-                const narrowedDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.message ? `: ${narrowed.message}` : ""}.`, prepared.reminderMark);
-                await settleEnd(true, { content: narrowedDenial }, vetoed("policy"));
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, narrowedDenial, true));
-                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-                return;
-            }
-        }
-        if (prepared.persistedRuleLane !== undefined) {
-            const unreadable = { unreadable: true };
-            const read = await settleOrgVerdictWithin(Promise.resolve()
-                .then(() => prepared.persistedRuleLane.adjudicate({
-                toolName: pendingAction.toolName,
-                args: resolvedArgs,
-                toolCallId: pendingAction.toolCallId,
-                ...callFaceSeat(toolCallFaceOf(prepared.toolRosterDeltas.current, pendingAction.toolName)),
-                budget: beltBudget,
-                ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}),
-            }))
-                .then((answer) => normalizePersistedRuleHit(answer)), unreadable, { signal: prepared.abortController.signal, timeoutMs: ORG_ADJUDICATION_TIMEOUT_MS });
-            const tightened = applyPersistedTightening({ action: "allow" }, read);
-            if (tightened.tightened === "deny" || tightened.tightened === "unreadable") {
-                const why = tightened.tightened === "deny"
-                    ? `a standing deny rule of yours (${disclosedRuleSet(read.hit?.rules ?? [])}) now refuses it`
-                    : "your persisted permission rules could not be read on this leg";
-                const ruleDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: ${why}. This approval is spent — the call has to be re-issued and approved again.`, prepared.reminderMark);
-                await settleEnd(true, { content: ruleDenial }, vetoed("persisted_rule"));
-                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, ruleDenial, true));
-                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-                return;
-            }
-        }
-        const tool = prepared.tools.find((t) => t.name === pendingAction.toolName);
-        if (!tool) {
-            const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume`);
-            e.code = "resume.tool_unavailable";
-            throw e;
-        }
-        const args = resolvedArgs;
-        onExecuteStart?.(pendingAction.toolCallId);
-        prepared.suspendProgressRef.executedApproved = true;
-        let res;
-        try {
-            res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
-        }
-        catch (err) {
-            const execError = `Error: ${err instanceof Error ? err.message : String(err)}`;
-            const marks = (() => {
-                if (err === null || typeof err !== "object")
-                    return undefined;
-                const src = err;
-                let d;
-                if (src.details !== null && typeof src.details === "object" && !Array.isArray(src.details)) {
-                    d = { ...src.details };
-                }
-                if (typeof src.errorKind === "string")
-                    d = { ...(d ?? {}), errorKind: src.errorKind };
-                return d;
-            })();
-            await settleEnd(true, { content: execError, ...(marks !== undefined ? { details: marks } : {}) });
-            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, execError, true));
-            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-            return;
-        }
-        const executedIsError = res.isError === true;
-        await settleEnd(executedIsError, res);
-        onResolvedToolSuccess?.(pendingAction.toolName, executedIsError ? undefined : res.details);
-        const eid = await prepared.session.appendMessage({
-            role: "toolResult",
-            toolCallId: pendingAction.toolCallId,
-            toolName: pendingAction.toolName,
-            content: res.content,
-            details: res.details,
-            isError: executedIsError,
-            timestamp: Date.now(),
-        });
-        emitCommitted(eid, "toolResult", pendingAction.toolCallId);
-    }
-    seamCCompactionOptions(prepared) {
-        if (!this.deps.summaryProvider)
-            return undefined;
-        return {
-            summaryProvider: this.deps.summaryProvider,
-            onCompaction: this.deps.onCompaction,
-            maxConsecutiveProviderReuse: this.deps.maxConsecutiveProviderReuse,
-            consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
-        };
-    }
-    compactionHookOptions(spec, sessionId, trigger, identity, seatBound) {
-        const hooks = spec.hooks ?? this.deps.hooks;
-        const pre = hooks?.preCompact;
-        const post = hooks?.postCompact;
-        const seatMs = seatBound?.timeoutMs ?? resolveHookTimeoutMs(hooks?.timeoutMs);
-        const seatSignal = seatBound?.signal;
-        const withIdentity = (ctx) => identity !== undefined ? { ...ctx, identity } : ctx;
-        return {
-            trigger,
-            ...(pre
-                ? {
-                    preCompact: async (rawCtx) => {
-                        const ctx = withIdentity(rawCtx);
-                        const report = (err) => {
-                            try {
-                                this.deps.onError?.(err, { phase: "hook", sessionId });
-                            }
-                            catch {
-                            }
-                        };
-                        try {
-                            const seat = await runHookSeat("preCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => pre.call(hooks, { ...ctx, signal: sig }));
-                            if (seat.expired) {
-                                report(hookSeatExpiredError("preCompact", seatMs, seat.cause, `the "${ctx.trigger}" compaction PROCEEDED unblocked and with no additional instructions`));
-                                return undefined;
-                            }
-                            const r = seat.value;
-                            if (r?.block && ctx.trigger === "forced") {
-                                report(new Error(`a preCompact callback blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
-                            }
-                            return r;
-                        }
-                        catch (err) {
-                            report(err instanceof Error ? err : new Error(String(err)));
-                            return undefined;
-                        }
-                    },
-                }
-                : {}),
-            ...(post
-                ? {
-                    postCompact: async (rawCtx) => {
-                        try {
-                            const seat = await runHookSeat("postCompact", { timeoutMs: seatMs, ...(seatSignal !== undefined ? { signal: seatSignal } : {}) }, (sig) => post.call(hooks, { ...withIdentity(rawCtx), signal: sig }));
-                            if (seat.expired) {
-                                try {
-                                    this.deps.onError?.(hookSeatExpiredError("postCompact", seatMs, seat.cause, "the observation was abandoned; the compaction that already landed is unchanged"), { phase: "hook", sessionId });
-                                }
-                                catch {
-                                }
-                            }
-                        }
-                        catch (err) {
-                            try {
-                                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
-                            }
-                            catch {
-                            }
-                        }
-                    },
-                }
-                : {}),
-        };
-    }
-    recordCompactionReuse(prepared, comp) {
-        if (!this.deps.summaryProvider || !comp.compacted)
-            return;
-        prepared.compactionReuseRef.consecutive = comp.reused ? prepared.compactionReuseRef.consecutive + 1 : 0;
-    }
-    async finish(spec, prepared, opts) {
-        let comp;
-        if (!opts?.skipCompaction) {
-            try {
-                const finishComp = await maybeCompact({
-                    session: prepared.session,
-                    epochDeclaredSections: prepared.epochDeclaredSections,
-                    ...centerAdoptionOption(prepared),
-                    model: prepared.model,
-                    compactionModel: prepared.compModel,
-                    ...forkContextOption(prepared, false),
-                    brain: opts?.brain ?? this.deps.brain,
-                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                    thinking: prepared.thinking,
-                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    minTokens: opts?.minTokens,
-                    overheadTokens: prepared.promptOverheadTokens,
-                    ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                    onInputTruncated: emitInputTruncated(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId),
-                    ...(opts?.windowSafety ?? {}),
-                    workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
-                    ...contextInstructionFilesOption(prepared),
-                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                    ...this.seamCCompactionOptions(prepared),
-                    ...gitRestateOption(prepared),
-                    ...this.compactionHookOptions(spec, prepared.sessionId, "auto", prepared.hookIdentity, {
-                        timeoutMs: prepared.hookTimeoutMs,
-                        ...(opts?.cancelled === true ? { signal: prepared.abortController.signal } : {}),
-                    }),
-                });
-                this.recordCompactionReuse(prepared, finishComp);
-                if (finishComp.unevaluableWindow) {
-                    discloseUnevaluableWindow(finishComp.unevaluableWindow, prepared, opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId, this.deps.onError);
-                }
-                comp = finishComp;
-            }
-            catch (err) {
-                const failMsg = String(err instanceof Error ? err.message : err);
-                const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
-                emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, () => ({
-                    kind: "compaction.failed",
-                    version: 1,
-                    taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
-                    trigger: "auto",
-                    reason: failReason,
-                    ts: Date.now(),
-                }));
-                opts?.onCompactionFailed?.(failReason);
-                this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-            }
-        }
-        try {
-            await this.sessions.touch(prepared.sessionId);
-        }
-        catch (err) {
-            this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
-        }
-        try {
-            await prepared.mcp.dispose();
-        }
-        catch (err) {
-            this.deps.onError?.(err, { phase: "mcp", sessionId: prepared.sessionId });
-        }
-        if (prepared.a2a !== undefined) {
-            try {
-                await prepared.a2a.dispose();
-            }
-            catch (err) {
-                this.deps.onError?.(err, { phase: "a2a", sessionId: prepared.sessionId });
-            }
-        }
-        return comp;
-    }
-    async teardownOwnedEnv(prepared) {
-        if (prepared.ownedEnv &&
-            hasDestroy(prepared.ownedEnv) &&
-            prepared.pausedRef.current === undefined) {
-            try {
-                await prepared.ownedEnv.destroy();
-            }
-            catch (err) {
-                this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
-            }
-        }
-    }
 }
 export function runTask(spec, deps) {
     return new Runner(deps).runTask(spec);