@sema-agent/core 7.11.1 → 7.11.2

package/dist/core/runner/runtask.js

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