@sema-agent/core 2.0.1 → 2.2.0

package/dist/core/runner/runtask.js

@@ -26,6 +26,7 @@ import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
 import { assembleResult, errorCodeOf } from "./assemble-result.js";
 import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
 import { prepareTask } from "./prepare-task.js";
+import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
@@ -48,9 +49,9 @@ function createRunState() {
         degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
         limits: { turnsExceeded: false, budgetHit: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
         budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, overBudget: () => false, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => false },
-        turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false },
-        counters: { nudgesSent: 0, callCutoffs: 0, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
-        attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined },
+        turn: { callStartAt: undefined, firstTokenAt: undefined, turnUsage: undefined, turnUsageMissing: false, turnStopReason: undefined, lastTurnHadToolCalls: false, toolBatch: [] },
+        counters: { nudgesSent: 0, nudgeIdx: 0, finalizeInjected: false, walltimeSyncBackstopFired: false, compactionFloor: 0, trimForceBackoff: false, callCutoffs: 0, repetitionCuts: 0, repetitionSpared: 0, repetitionEvents: [], REPETITION_EVENTS_CAP: 0, preemptIgnoredReported: false, wroteThisRun: false, finalVerifyInjections: 0, groundingSignalPreR9: false, groundingSignalPostR9: false, cadenceTurns: 0 },
+        attach: { attachmentsCfg: undefined, agentListingOn: false, skillsListingOn: false, attachState: undefined, dateState: undefined, instrProbe: undefined, instrState: undefined, attachmentsInjected: 0 },
     };
 }
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
@@ -150,6 +151,8 @@ function writeFamilyOfCanonical(name) {
         return "task";
     if (name === "TodoWrite")
         return "todo";
+    if (name === TOOL_SEARCH_NAME)
+        return "tool_search";
     return undefined;
 }
 function toolResultMsg(toolCallId, toolName, text, isError) {
@@ -217,6 +220,888 @@ function resumeContinuation(resume) {
         `conversation above. Do NOT restart the task or re-run any tool you already ran; continue from this ` +
         `exact point, building on the existing results, and finish the remaining work.`);
 }
+function makeTurnBoundary(prepared, stats, rs, deps) {
+    const { spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, turnToolSpan, walltimeDeadlineMs, walltimeMonotonicDeadline, nudgeSchedule, buildFinalizeText, timeout, ident, postToolBatchHook, batchArgs, compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions, rapidRefill, drainManualCompact, runnerHooks } = deps;
+    const onTurnBoundary = async (event) => {
+        if (prepared.callCapRef && turnToolSpan.startMin !== undefined && turnToolSpan.endMax !== undefined) {
+            recordToolCycleSample(prepared.callCapRef.state, turnToolSpan.endMax - turnToolSpan.startMin);
+        }
+        turnToolSpan.startMin = undefined;
+        turnToolSpan.endMax = undefined;
+        let boundarySteered = false;
+        if (prepared.suspendForResource === undefined) {
+            const nowMs = Date.now();
+            if (!rs.counters.finalizeInjected &&
+                spec.limits?.gracefulFinalize !== false &&
+                walltimeDeadlineMs !== undefined &&
+                prepared.callCapRef !== undefined) {
+                const remainingMs = walltimeDeadlineMs - nowMs;
+                if (remainingMs > 0 && remainingMs < estimateCycleMs(prepared.callCapRef.state) + (effectiveCushionMs(prepared.callCapRef) ?? 0)) {
+                    rs.counters.finalizeInjected = true;
+                    prepared.callCapRef.finalizeMode = true;
+                    void prepared.harness.setThinkingLevel("off").catch(() => { });
+                    prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
+                    rs.counters.nudgeIdx = nudgeSchedule.length;
+                    const finalizeText = buildFinalizeText();
+                    void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
+                    boundarySteered = true;
+                    queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
+                }
+            }
+            let due;
+            while (rs.counters.nudgeIdx < nudgeSchedule.length && nowMs >= nudgeSchedule[rs.counters.nudgeIdx].atMs) {
+                due = nudgeSchedule[rs.counters.nudgeIdx++];
+            }
+            if (due) {
+                void prepared.harness.steer(due.text, { engineMinted: true }).catch(() => { });
+                rs.counters.nudgesSent += 1;
+                boundarySteered = true;
+                queue.push({ type: "steering_injected", source: "deadline_nudge", preview: due.text.slice(0, 220), ...ident() });
+            }
+        }
+        const walltimeHit = walltimeMonotonicDeadline !== undefined && performance.now() >= walltimeMonotonicDeadline;
+        const preemptHit = spec.preemptSignal?.aborted === true;
+        if (preemptHit && !prepared.suspendForResource && !rs.counters.preemptIgnoredReported) {
+            rs.counters.preemptIgnoredReported = true;
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "preempt.ignored", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+        }
+        if (prepared.suspendForResource &&
+            (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
+            prepared.suspendRef.token === undefined) {
+            const reason = preemptHit
+                ? "preempt"
+                : rs.limits.budgetHit !== undefined
+                    ? "budget"
+                    : walltimeHit
+                        ? "walltime"
+                        : "turns";
+            const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
+            if (await prepared.suspendForResource(reason, sliceSpend)) {
+                rs.limits.turnsExceeded = false;
+                rs.limits.budgetHit = undefined;
+            }
+            else {
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            return undefined;
+        }
+        if (walltimeMonotonicDeadline !== undefined &&
+            prepared.suspendForResource === undefined &&
+            performance.now() >= walltimeMonotonicDeadline) {
+            if (!timeout.fired) {
+                timeout.fired = true;
+                timeout.clear();
+                timeout.latenessMs = Math.max(timeout.latenessMs ?? 0, performance.now() - walltimeMonotonicDeadline);
+                rs.counters.walltimeSyncBackstopFired = true;
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+            return undefined;
+        }
+        if (prepared.reviewRequestRef.pending !== undefined) {
+            const { reason } = prepared.reviewRequestRef.pending;
+            prepared.reviewRequestRef.pending = undefined;
+            const honorable = prepared.suspendForReview !== undefined &&
+                !prepared.abortController.signal.aborted &&
+                prepared.suspendRef.token === undefined &&
+                prepared.reviewRef.token === undefined;
+            if (honorable && prepared.suspendForReview) {
+                await prepared.suspendForReview(reason);
+                return undefined;
+            }
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "review.dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+        }
+        if (prepared.lspDiagnostics && !prepared.lspDiagnostics.registry.isEmpty() && !prepared.abortController.signal.aborted) {
+            const files = prepared.lspDiagnostics.registry.drain();
+            if (files.length > 0) {
+                queue.push({ type: "diagnostics", files, isNew: true, ...ident() });
+                const block = formatDiagnosticsBlock(files);
+                void prepared.harness.steer(block, { provenance: "engine-note" }).catch(() => undefined);
+                boundarySteered = true;
+            }
+        }
+        let boundaryAttachmentBytes = 0;
+        let attachmentsPayload;
+        if ((rs.attach.dateState !== undefined || rs.attach.instrState !== undefined || rs.attach.attachState !== undefined) &&
+            !boundarySteered &&
+            !rs.counters.finalizeInjected &&
+            rs.counters.finalVerifyInjections === 0 &&
+            !prepared.abortController.signal.aborted) {
+            const due = [];
+            if (rs.attach.attachState !== undefined) {
+                const changedFilesOn = Boolean(rs.attach.attachmentsCfg?.changedFiles);
+                let changed;
+                if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
+                    const maxFiles = typeof rs.attach.attachmentsCfg?.changedFiles === "object"
+                        ? (rs.attach.attachmentsCfg.changedFiles.maxFiles ?? CHANGED_FILES_MAX)
+                        : CHANGED_FILES_MAX;
+                    const SCAN_CEILING_MS = 2_000;
+                    const scan = await Promise.race([
+                        prepared.detectExternalChanges(maxFiles),
+                        new Promise((resolve) => {
+                            const t = setTimeout(() => resolve({ changed: [], evicted: [] }), SCAN_CEILING_MS);
+                            t.unref?.();
+                        }),
+                    ]);
+                    for (const p of scan.evicted)
+                        rs.attach.attachState.surfacedMtime.delete(p);
+                    changed = scan.changed;
+                }
+                const backgroundTasksOn = rs.attach.attachmentsCfg?.backgroundTasks === true;
+                const bgTasks = backgroundTasksOn && rs.attach.attachState.postCompactPending ? prepared.listBackgroundTasks() : undefined;
+                const toolsDeltaOn = rs.attach.attachmentsCfg?.toolsDelta === true;
+                const tdRef = toolsDeltaOn ? prepared.toolsDeltaRef : undefined;
+                const pendingTools = tdRef !== undefined && tdRef.pending.length > 0 ? [...tdRef.pending] : undefined;
+                const pendingRemovedTools = tdRef !== undefined && tdRef.pendingRemoved.length > 0 ? [...tdRef.pendingRemoved] : undefined;
+                const pendingReaddedTools = tdRef !== undefined && tdRef.pendingReadded.length > 0 ? [...tdRef.pendingReadded] : undefined;
+                const pendingFailedMcp = tdRef !== undefined && tdRef.pendingFailed.length > 0 ? tdRef.pendingFailed.map((f) => ({ ...f })) : undefined;
+                const mcpToolsDelta = pendingRemovedTools !== undefined || pendingReaddedTools !== undefined || pendingFailedMcp !== undefined
+                    ? {
+                        ...(pendingRemovedTools !== undefined ? { removed: pendingRemovedTools } : {}),
+                        ...(pendingReaddedTools !== undefined ? { readded: pendingReaddedTools } : {}),
+                        ...(pendingFailedMcp !== undefined ? { failedServers: pendingFailedMcp } : {}),
+                    }
+                    : undefined;
+                const mcpInstructionsOn = rs.attach.attachmentsCfg?.mcpInstructions === true;
+                const mcpDelta = prepared.mcp.instructionsDelta;
+                const mcpAdds = mcpInstructionsOn && mcpDelta.pendingAdds.length > 0 ? [...mcpDelta.pendingAdds] : undefined;
+                const mcpRemovals = mcpInstructionsOn && mcpDelta.pendingRemovals.length > 0 ? [...mcpDelta.pendingRemovals] : undefined;
+                const mcpDropped = mcpInstructionsOn && prepared.mcp.droppedTools.length > 0 ? selectMcpDroppedBatch(prepared.mcp.droppedTools) : undefined;
+                const budgetUsdOn = rs.attach.attachmentsCfg?.budgetUsd === true && rs.budget.maxCostMicroUsd !== undefined && rs.turn.lastTurnHadToolCalls;
+                const toolSearchReminderOn = rs.attach.attachmentsCfg?.toolSearchReminder === true && prepared.deferredToolNames !== undefined;
+                const undiscoveredTools = toolSearchReminderOn
+                    ? [...prepared.deferredToolNames].filter((n) => !prepared.activeTools.has(n)).sort()
+                    : undefined;
+                due.push(...collectDueAttachments(rs.attach.attachState, {
+                    turn: stats.turns,
+                    cadenceTurn: rs.counters.cadenceTurns,
+                    todoMounted: todoToolMounted,
+                    taskListMounted: taskToolsMounted,
+                    planActive: prepared.planModeRef.active,
+                    config: {
+                        todoReminder: rs.attach.attachmentsCfg?.todoReminder === true,
+                        ...(rs.attach.attachmentsCfg?.todoReminderMode !== undefined ? { todoReminderMode: rs.attach.attachmentsCfg.todoReminderMode } : {}),
+                        toolSearchReminder: toolSearchReminderOn,
+                        changedFiles: changedFilesOn,
+                        planModeReminder: rs.attach.attachmentsCfg?.planModeReminder === true,
+                        budgetUsd: budgetUsdOn,
+                        backgroundTasks: backgroundTasksOn,
+                        toolsDelta: toolsDeltaOn,
+                        agentListing: rs.attach.agentListingOn,
+                        skillsListing: rs.attach.skillsListingOn,
+                        mcpInstructions: mcpInstructionsOn,
+                    },
+                    ...(undiscoveredTools !== undefined && undiscoveredTools.length > 0 ? { undiscoveredTools } : {}),
+                    ...(changed !== undefined ? { changedFiles: changed } : {}),
+                    ...(budgetUsdOn && rs.budget.maxCostMicroUsd !== undefined
+                        ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: rs.budget.maxCostMicroUsd / 1e6 } }
+                        : {}),
+                    ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
+                    ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
+                    ...(mcpToolsDelta !== undefined ? { mcpToolsDelta } : {}),
+                    ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
+                        ? {
+                            agentListing: prepared.agentListing.entries,
+                            agentToolName: prepared.agentListing.toolName,
+                            ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
+                        }
+                        : {}),
+                    ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
+                    ...(mcpAdds !== undefined || mcpRemovals !== undefined
+                        ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
+                        : {}),
+                    ...(mcpDropped !== undefined ? { mcpDroppedTools: mcpDropped } : {}),
+                }));
+                if (pendingTools !== undefined || mcpToolsDelta !== undefined) {
+                    const exact = renderToolsDelta({ ...(pendingTools !== undefined ? { added: pendingTools } : {}), ...(mcpToolsDelta ?? {}) });
+                    if (exact !== undefined && due.some((a) => a.source === "tools_delta" && a.body === exact)) {
+                        const ref = prepared.toolsDeltaRef;
+                        if (pendingTools !== undefined)
+                            ref.pending.splice(0, pendingTools.length);
+                        if (pendingRemovedTools !== undefined)
+                            ref.pendingRemoved.splice(0, pendingRemovedTools.length);
+                        if (pendingReaddedTools !== undefined)
+                            ref.pendingReadded.splice(0, pendingReaddedTools.length);
+                        if (pendingFailedMcp !== undefined)
+                            ref.pendingFailed.splice(0, pendingFailedMcp.length);
+                    }
+                }
+                if ((mcpAdds !== undefined || mcpRemovals !== undefined) &&
+                    due.some((a) => a.source === "mcp_instructions" && a.body === renderMcpInstructionsDelta(mcpAdds ?? [], mcpRemovals ?? []))) {
+                    if (mcpAdds !== undefined)
+                        mcpDelta.pendingAdds.splice(0, mcpAdds.length);
+                    if (mcpRemovals !== undefined)
+                        mcpDelta.pendingRemovals.splice(0, mcpRemovals.length);
+                }
+                if (mcpDropped !== undefined &&
+                    due.some((a) => a.source === "mcp_dropped_tools" && a.body === renderMcpDroppedTools(mcpDropped))) {
+                    prepared.mcp.droppedTools.splice(0, mcpDropped.length);
+                }
+                if (rs.attach.agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
+                    const listing = prepared.agentListing;
+                    const intactBody = renderAgentListingDelta(rs.attach.attachState, listing.entries, listing.toolName, listing.models);
+                    if (intactBody !== undefined && due.some((a) => a.source === "agent_listing" && a.body === intactBody)) {
+                        commitAgentListing(rs.attach.attachState, listing.entries, listing.models);
+                        prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
+                        if (listing.models !== undefined)
+                            prepared.announcedListingsRef.models = [...listing.models];
+                        await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                    }
+                }
+                if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
+                    const listing = prepared.skillsListing;
+                    const intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
+                    if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
+                        commitSkillsListing(rs.attach.attachState, listing.entries);
+                        prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
+                        await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
+                    }
+                }
+            }
+            if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
+                const today = prepared.dateChange.today();
+                const cand = collectDateChange(rs.attach.dateState, today);
+                if (cand !== undefined) {
+                    due.unshift(cand);
+                    rs.attach.dateState.announcedDate = today;
+                }
+            }
+            if (rs.attach.instrState !== undefined && rs.attach.instrProbe !== undefined && rs.turn.lastTurnHadToolCalls) {
+                let probed = null;
+                try {
+                    const PROBE_CEILING_MS = 2_000;
+                    probed = await Promise.race([
+                        rs.attach.instrProbe(prepared.instructionSources),
+                        new Promise((resolve) => {
+                            const t = setTimeout(() => resolve(null), PROBE_CEILING_MS);
+                            t.unref?.();
+                        }),
+                    ]);
+                }
+                catch {
+                    probed = null;
+                }
+                const cand = collectInstructionsChange(rs.attach.instrState, probed);
+                if (cand !== undefined) {
+                    due.splice(due.length > 0 && due[0].source === "date_change" ? 1 : 0, 0, cand.attachment);
+                    commitInstructionsChange(rs.attach.instrState, cand.announced);
+                }
+            }
+            if (due.length > 0) {
+                attachmentsPayload = due.map((a) => `<system-reminder>\n${sanitizeUntrustedText(a.body)}\n</system-reminder>`).join("\n");
+                for (const a of due)
+                    boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
+                rs.attach.attachmentsInjected += due.length;
+                for (const a of due) {
+                    queue.push({ type: "steering_injected", source: a.source, preview: a.body.slice(0, 220), ...ident() });
+                }
+            }
+        }
+        let batchContextBlock;
+        if (postToolBatchHook !== undefined && rs.turn.toolBatch.length > 0) {
+            const batch = rs.turn.toolBatch;
+            rs.turn.toolBatch = [];
+            batchArgs?.clear();
+            if (!boundarySteered && !rs.counters.finalizeInjected && rs.counters.finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
+                try {
+                    const r = await postToolBatchHook(batch);
+                    if (r?.additionalContext) {
+                        const body = sanitizeUntrustedText(r.additionalContext);
+                        const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
+                        if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
+                            const clipped = clipToByteBudget(body, budget) === body
+                                ? body
+                                : `${clipToByteBudget(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
+                            batchContextBlock = `<system-reminder>\n${clipped}\n</system-reminder>`;
+                        }
+                    }
+                }
+                catch (err) {
+                    try {
+                        runnerHooks.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        if (attachmentsPayload !== undefined || batchContextBlock !== undefined) {
+            const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
+            void prepared.harness.steer(payload, { engineMinted: true }).catch(() => { });
+        }
+        const forceManual = manualCompactRef.requested;
+        if ((!withinTaskCompaction && !forceManual) ||
+            (rs.counters.finalizeInjected && !forceManual) ||
+            prepared.abortController.signal.aborted ||
+            prepared.suspendRef.token !== undefined ||
+            prepared.reviewRef.token !== undefined) {
+            if (forceManual) {
+                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
+                drainManualCompact("mooted");
+            }
+            return undefined;
+        }
+        if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES) {
+            if (forceManual) {
+                emitTrace(rs.telemetry.tracer, () => ({
+                    kind: "compaction.failed",
+                    version: 1,
+                    taskId: rs.telemetry.taskId,
+                    trigger: "manual",
+                    reason: "compaction circuit breaker open (3 consecutive failures this task) — manual request drained without an attempt",
+                    ts: Date.now(),
+                }));
+                drainManualCompact("failed");
+            }
+            return undefined;
+        }
+        const claimedManual = forceManual
+            ? (() => {
+                const waiters = manualCompactRef.waiters.splice(0);
+                let instructions;
+                for (let i = waiters.length - 1; i >= 0; i--) {
+                    if (waiters[i].instructions !== undefined) {
+                        instructions = waiters[i].instructions;
+                        break;
+                    }
+                }
+                return { instructions, waiters };
+            })()
+            : undefined;
+        if (forceManual) {
+            manualCompactRef.requested = false;
+        }
+        const resolveClaimedWaiters = (outcome) => {
+            if (claimedManual !== undefined)
+                for (const w of claimedManual.waiters.splice(0))
+                    w.resolve(outcome);
+        };
+        const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
+        const manualCancelSignal = claimedCancelSignals.length === 0
+            ? undefined
+            : claimedCancelSignals.length === 1
+                ? claimedCancelSignals[0]
+                : AbortSignal.any(claimedCancelSignals);
+        const compactionPassSignal = claimedCancelSignals.length > 0
+            ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
+            : prepared.abortController.signal;
+        const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
+        if (trimPressureArmed)
+            prepared.trimPressureRef.droppedMessages = false;
+        const trimPressure = trimPressureArmed && !rs.counters.trimForceBackoff;
+        let manualOutcome = "failed";
+        if (rs.counters.finalizeInjected && forceManual) {
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.manual_in_finalize", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+        }
+        const manualInstructions = claimedManual?.instructions;
+        try {
+            const comp = await maybeCompact({
+                session: prepared.session,
+                epochDeclaredSections: prepared.epochDeclaredSections,
+                ...(() => {
+                    const ca = prepared.centerCompactionCandidate?.();
+                    return ca !== undefined ? { centerAdoption: ca } : {};
+                })(),
+                model: event.model,
+                compactionModel: prepared.compModel,
+                brain: compactionBrain,
+                getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                thinking: prepared.thinking,
+                settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                signal: compactionPassSignal,
+                ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
+                minTokens: forceManual ? 0 : rs.counters.compactionFloor,
+                force: forceManual,
+                onInputTruncated: (info) => emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId: rs.telemetry.taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
+                forceUnderThreshold: trimPressure,
+                overheadTokens: prepared.promptOverheadTokens,
+                workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
+                    ? {
+                        readFile: prepared.readTaskFile,
+                        ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                        ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
+                        ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
+                        ...(prepared.instructionSources
+                            ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
+                            : {}),
+                        ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+                    }
+                    : undefined,
+                ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
+                ...runnerHooks.seamCCompactionOptions(prepared),
+                ...windowSafetyOptions(event.model),
+                ...runnerHooks.compactionHookOptions(spec, prepared.sessionId, trimPressure ? "forced" : forceManual ? "manual" : "auto"),
+            });
+            if (comp.blocked) {
+                emitTrace(rs.telemetry.tracer, () => ({
+                    kind: "compaction.blocked",
+                    version: 1,
+                    taskId: rs.telemetry.taskId,
+                    trigger: forceManual ? "manual" : "auto",
+                    ts: Date.now(),
+                }));
+            }
+            else {
+                compactionBreaker.failures = 0;
+            }
+            rs.counters.trimForceBackoff = nextTrimForceBackoff(rs.counters.trimForceBackoff, comp, trimPressure);
+            if (comp.contextUsage) {
+                queue.push({ type: "context_usage", ...comp.contextUsage, ...ident() });
+            }
+            if (comp.suppressedByFloor) {
+                const s = comp.suppressedByFloor;
+                emitTrace(rs.telemetry.tracer, () => ({
+                    kind: "compaction.suppressed",
+                    version: 1,
+                    taskId: rs.telemetry.taskId,
+                    estTokens: s.estTokens,
+                    floor: s.floor,
+                    ts: Date.now(),
+                }));
+            }
+            manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
+            if (forceManual && !comp.compacted && !comp.blocked) {
+                if (comp.disabled) {
+                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.disabled", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+                }
+                else {
+                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.noop", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
+                }
+            }
+            if (comp.compacted && !forceManual) {
+                if (recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
+                    compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
+                    runnerHooks.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
+                }
+            }
+            runnerHooks.recordCompactionReuse(prepared, comp);
+            if (comp.compacted) {
+                queue.push({
+                    type: "compacted",
+                    trigger: forceManual ? "manual" : "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 } : {}),
+                });
+                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);
+                }
+                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);
+                }
+            }
+        }
+        catch (err) {
+            const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
+            if (manualCancelAbort) {
+                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "cancelled", ts: Date.now() }));
+                manualOutcome = "mooted";
+            }
+            else if (!prepared.abortController.signal.aborted) {
+                const walltimeAbort = isCompactionWalltimeAbort(err);
+                if (!walltimeAbort)
+                    compactionBreaker.failures += 1;
+                runnerHooks.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+                const msg = String(err instanceof Error ? err.message : err);
+                emitTrace(rs.telemetry.tracer, () => ({
+                    kind: "compaction.failed",
+                    version: 1,
+                    taskId: rs.telemetry.taskId,
+                    trigger: trimPressure ? "forced" : forceManual ? "manual" : "auto",
+                    reason: walltimeAbort
+                        ? "walltime soft-deadline abort (engine-initiated write-out protection; not counted toward the breaker)"
+                        : msg.length > 512
+                            ? `${msg.slice(0, 512)}…`
+                            : msg,
+                    ts: Date.now(),
+                }));
+                manualOutcome = "failed";
+            }
+            else {
+                manualOutcome = "mooted";
+            }
+        }
+        if (forceManual)
+            resolveClaimedWaiters(manualOutcome);
+        return undefined;
+    };
+    return onTurnBoundary;
+}
+function makeHarnessHandlers(prepared, stats, rs, deps) {
+    const { spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName, pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf, toolLabels, postToolBatchHook, batchArgs } = deps;
+    let lastWorkspaceCwd = prepared.cwdRef?.current;
+    const onMessageUpdate = (event) => {
+        const ev = event.assistantMessageEvent;
+        if (rs.turn.callStartAt === undefined)
+            rs.turn.callStartAt = Date.now();
+        if (ev.type === "text_delta" && ev.delta) {
+            if (rs.turn.firstTokenAt === undefined)
+                rs.turn.firstTokenAt = Date.now();
+            pushContent({ type: "text_delta", delta: ev.delta, ...ident() });
+        }
+        else if (ev.type === "thinking_delta" && ev.delta) {
+            pushContent({ type: "reasoning_delta", delta: ev.delta, ...ident() });
+        }
+        if (rs.budget.streamCancel && !rs.limits.budgetHit && (ev.type === "text_delta" || ev.type === "thinking_delta") && ev.delta) {
+            rs.budget.callOutputChars += ev.delta.length;
+            if (rs.budget.callOutputChars - rs.budget.lastStreamBudgetCheck >= 256) {
+                rs.budget.lastStreamBudgetCheck = rs.budget.callOutputChars;
+                if (rs.budget.projectedOverBudget()) {
+                    rs.limits.budgetHit = "exceeded";
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                }
+            }
+        }
+    };
+    const onMessageEnd = (event) => {
+        const m = event.message;
+        if (event.entryId !== undefined && (m.role === "user" || m.role === "assistant" || m.role === "toolResult")) {
+            emitCommitted(event.entryId, m.role, m.role === "toolResult" ? m.toolCallId : undefined);
+        }
+        if (rs.degrade.degraded === undefined && m.role === "assistant") {
+            const deg = readDegradation(m);
+            if (deg)
+                rs.degrade.recordDegraded({ from: deg.from, to: deg.to, reason: deg.reason, atTurn: stats.turns + 1, ...(deg.chain && { chain: deg.chain }) });
+        }
+        if (m.role === "assistant" && "usage" in m && m.usage) {
+            if (m.usageMissing)
+                rs.turn.turnUsageMissing = true;
+            const u = m.usage;
+            stats.tokens += u.totalTokens || 0;
+            const { totalInputTokens: turnInput, costMicroUsd: turnCostMicroUsd } = usageCostMicroUsd(rs.telemetry.cacheFamily, u, rs.telemetry.pricing);
+            stats.promptTokens += turnInput;
+            stats.cachedTokens += u.cacheRead || 0;
+            stats.cacheWriteTokens += u.cacheWrite || 0;
+            stats.outputTokens += u.output || 0;
+            stats.costMicroUsd += turnCostMicroUsd;
+            rs.turn.turnUsage ??= { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costMicroUsd: 0 };
+            rs.turn.turnUsage.inputTokens += turnInput;
+            rs.turn.turnUsage.outputTokens += u.output || 0;
+            rs.turn.turnUsage.cacheReadTokens += u.cacheRead || 0;
+            rs.turn.turnUsage.cacheWriteTokens += u.cacheWrite || 0;
+            rs.turn.turnUsage.costMicroUsd += turnCostMicroUsd;
+            const callEndAt = Date.now();
+            const callIssuedAt = prepared.callIssuedAtRef?.current;
+            if (prepared.callIssuedAtRef)
+                prepared.callIssuedAtRef.current = undefined;
+            const capLast = prepared.callCapRef?.state.last;
+            if (prepared.callCapRef) {
+                recordCallSample(prepared.callCapRef.state, u.output || 0, rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0, {
+                    contentValid: m.usageMissing === true && hasRealContent(m.content),
+                });
+                if (rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined) {
+                    recordTtftSample(prepared.callCapRef.state, rs.turn.firstTokenAt - rs.turn.callStartAt);
+                }
+                prepared.callCapRef.state.last = undefined;
+            }
+            emitTrace(rs.telemetry.tracer, () => ({
+                kind: "brain.call",
+                version: 1,
+                taskId: rs.telemetry.taskId,
+                model: m.model,
+                provider: m.provider,
+                promptTokens: turnInput,
+                completionTokens: u.output || 0,
+                cacheRead: u.cacheRead || 0,
+                cacheWrite: u.cacheWrite || 0,
+                latencyMs: rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0,
+                firstTokenMs: rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined ? rs.turn.firstTokenAt - rs.turn.callStartAt : undefined,
+                ...(callIssuedAt !== undefined ? { callStartedAt: callIssuedAt } : {}),
+                costMicroUsd: turnCostMicroUsd,
+                ...(capLast !== undefined ? { callCap: capLast.cap, capThinkingSkipped: capLast.thinkingSkipped } : {}),
+                ...(m.role === "assistant" && typeof m.stopReason === "string"
+                    ? { stopReason: m.stopReason }
+                    : {}),
+                ts: callEndAt,
+            }));
+            if (prepared.callCapRef &&
+                prepared.callCapRef.reasoningObserved !== true &&
+                capLast !== undefined &&
+                m.role === "assistant" &&
+                m.stopReason === "length") {
+                const blocks = Array.isArray(m.content)
+                    ? (m.content)
+                    : [];
+                const productive = blocks.some((c) => c?.type === "toolCall") ||
+                    blocks.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim() !== "");
+                if (!productive)
+                    prepared.callCapRef.reasoningObserved = true;
+            }
+            if (prepared.cacheBreakDetector && prepared.cacheFingerprint) {
+                const finding = prepared.cacheBreakDetector.observe({
+                    turn: stats.turns + 1,
+                    systemPrompt: prepared.cacheFingerprint.systemPrompt,
+                    tools: prepared.cacheFingerprint.tools,
+                    modelKey: `${m.provider}:${m.model}`,
+                    cacheRead: u.cacheRead || 0,
+                });
+                if (finding) {
+                    rs.telemetry.cacheBreakReported = true;
+                    deps.runnerHooks.onError?.(new Error(`prompt-cache: break at turn ${finding.turn} — cache_read ${finding.cacheReadBefore}→${finding.cacheReadAfter}; ${finding.detail}. See design/31.`), { phase: "prompt-cache", sessionId: prepared.sessionId, classification: finding.cause });
+                }
+            }
+        }
+        if (m.role === "assistant" && typeof m.stopReason === "string") {
+            rs.turn.turnStopReason = m.stopReason;
+        }
+        if (m.role === "assistant" && m.errorMessage === WALLTIME_CUTOFF_MESSAGE) {
+            rs.counters.callCutoffs += 1;
+            if (prepared.callCapRef)
+                prepared.callCapRef.finalizeMode = true;
+            if (!rs.counters.finalizeInjected) {
+                const finalizeText = buildFinalizeText();
+                void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
+                void prepared.harness.setThinkingLevel("off").catch(() => { });
+                prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
+                rs.counters.finalizeInjected = true;
+                rs.counters.nudgeIdx = nudgeSchedule.length;
+                queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
+            }
+        }
+        if (m.role === "assistant") {
+            const rep = m.repetition;
+            if (rep !== undefined) {
+                const observed = [
+                    ...(rep.cut !== undefined ? [{ action: "cut", e: rep.cut }] : []),
+                    ...(rep.spared ?? []).map((e) => ({ action: "spared", e })),
+                ];
+                for (const { action, e } of observed) {
+                    if (action === "cut")
+                        rs.counters.repetitionCuts += 1;
+                    else
+                        rs.counters.repetitionSpared += 1;
+                    if (rs.counters.repetitionEvents.length < rs.counters.REPETITION_EVENTS_CAP) {
+                        rs.counters.repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment: e.segment });
+                    }
+                    emitTrace(rs.telemetry.tracer, () => ({
+                        kind: "repetition.detected",
+                        version: 1,
+                        taskId: rs.telemetry.taskId,
+                        turn: stats.turns + 1,
+                        action,
+                        rule: e.rule,
+                        period: e.period,
+                        reps: e.reps,
+                        segment: e.segment,
+                        ts: Date.now(),
+                    }));
+                }
+            }
+        }
+        if (prepared.callCapRef &&
+            prepared.callCapRef.reasoningObserved !== true &&
+            m.role === "assistant" &&
+            Array.isArray(m.content) &&
+            m.content.some((c) => c?.type === "thinking")) {
+            prepared.callCapRef.reasoningObserved = true;
+        }
+        if (m.role === "assistant") {
+            const content = m.content;
+            if (rs.attach.attachState !== undefined)
+                rs.counters.cadenceTurns = advanceCadenceClock(rs.attach.attachState, rs.counters.cadenceTurns, content, writeFamilyOf);
+            rs.turn.lastTurnHadToolCalls = Array.isArray(content) && content.some((c) => c?.type === "toolCall");
+        }
+        rs.turn.callStartAt = undefined;
+        rs.turn.firstTokenAt = undefined;
+        rs.budget.callOutputChars = 0;
+        rs.budget.lastStreamBudgetCheck = 0;
+    };
+    const onToolStart = (event) => {
+        const startAt = Date.now();
+        toolStartAt.set(event.toolCallId, startAt);
+        startedToolCallIds.add(event.toolCallId);
+        batchArgs?.set(event.toolCallId, event.args);
+        stats.toolCalls += 1;
+        if (spec.finalVerification === true && !(rs.counters.finalVerifyInjections === 0 ? rs.counters.groundingSignalPreR9 : rs.counters.groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
+            if (rs.counters.finalVerifyInjections === 0)
+                rs.counters.groundingSignalPreR9 = true;
+            else
+                rs.counters.groundingSignalPostR9 = true;
+        }
+        const activityArg = primaryActivityArg(event.args);
+        internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, at: startAt, ...(activityArg !== undefined ? { arg: activityArg } : {}) });
+        pushContent({
+            type: "tool_start",
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
+            args: event.args,
+            ...ident(),
+        });
+    };
+    const onToolEnd = (event) => {
+        const toolStarted = toolStartAt.get(event.toolCallId);
+        toolStartAt.delete(event.toolCallId);
+        const toolNow = Date.now();
+        if (prepared.callCapRef && toolStarted !== undefined) {
+            recordToolSample(prepared.callCapRef.state, toolNow - toolStarted);
+            turnToolSpan.startMin = turnToolSpan.startMin === undefined ? toolStarted : Math.min(turnToolSpan.startMin, toolStarted);
+            turnToolSpan.endMax = turnToolSpan.endMax === undefined ? toolNow : Math.max(turnToolSpan.endMax, toolNow);
+        }
+        if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
+            rs.counters.wroteThisRun = true;
+        }
+        if (rs.attach.attachState !== undefined && !event.isError) {
+            const det = event.result?.details;
+            if (det !== undefined)
+                reduceToolEnd(rs.attach.attachState, det);
+        }
+        if (postToolBatchHook !== undefined) {
+            if (prepared.blockedToolCalls.delete(event.toolCallId)) {
+                batchArgs?.delete(event.toolCallId);
+            }
+            else {
+                const digest = batchResponseDigest(event.result);
+                rs.turn.toolBatch.push({
+                    toolName: event.toolName,
+                    input: batchArgs?.get(event.toolCallId),
+                    toolCallId: event.toolCallId,
+                    ...(digest !== undefined ? { response: digest } : {}),
+                    isError: event.isError,
+                });
+                batchArgs?.delete(event.toolCallId);
+            }
+        }
+        emitTrace(rs.telemetry.tracer, () => ({
+            kind: "tool.call",
+            version: 1,
+            taskId: rs.telemetry.taskId,
+            name: event.toolName,
+            durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
+            ok: !event.isError,
+            ts: toolNow,
+        }));
+        internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow });
+        if (prepared.lspDiagnostics && !event.isError) {
+            const name = canonicalToolName(event.toolName);
+            if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
+                const d = event.result?.details;
+                const p = typeof d?.filePath === "string" ? d.filePath : typeof d?.notebookPath === "string" ? d.notebookPath : undefined;
+                if (p)
+                    prepared.lspDiagnostics.nudge(p);
+            }
+        }
+        pushContent({
+            type: "tool_end",
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
+            isError: event.isError,
+            ...(() => {
+                const o = toolOutputFrom(event.result);
+                return o !== undefined
+                    ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) }
+                    : {};
+            })(),
+            ...(() => {
+                const st = structuredFrom(event.result);
+                return st !== undefined ? { structured: st } : {};
+            })(),
+            ...ident(),
+        });
+        const cwdNow = prepared.cwdRef?.current;
+        if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
+            lastWorkspaceCwd = cwdNow;
+            queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
+        }
+        if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
+            if (event.isError) {
+                rs.degrade.outputErrorStreak += 1;
+                if (rs.degrade.outputErrorStreak > rs.limits.outputRetryCap) {
+                    rs.degrade.outputInvalid = true;
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                }
+            }
+            else {
+                rs.degrade.outputErrorStreak = 0;
+            }
+        }
+    };
+    const onTurnEnd = () => {
+        stats.turns += 1;
+        const stopExtra = rs.turn.turnStopReason !== undefined ? { stopReason: rs.turn.turnStopReason } : {};
+        queue.push(rs.turn.turnUsage
+            ? { type: "turn_end", usage: rs.turn.turnUsage, ...(rs.turn.turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() }
+            : { type: "turn_end", usageMissing: true, ...stopExtra, ...ident() });
+        rs.turn.turnUsageMissing = false;
+        rs.turn.turnStopReason = undefined;
+        if (parentToolCallId !== undefined) {
+            const progress = {
+                type: "task_progress",
+                taskId: rs.telemetry.taskId,
+                ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
+                ...(subagentName ? { name: subagentName } : {}),
+                usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
+                status: "running",
+                ...ident(),
+            };
+            queue.push(progress);
+            try {
+                internals?.onForwardEvent?.(progress);
+            }
+            catch {
+            }
+        }
+        emitTrace(rs.telemetry.tracer, () => ({ kind: "turn.end", version: 1, taskId: rs.telemetry.taskId, turn: stats.turns, ts: Date.now() }));
+        rs.turn.turnUsage = undefined;
+        rs.turn.callStartAt = undefined;
+        rs.turn.firstTokenAt = undefined;
+        rs.budget.callOutputChars = 0;
+        rs.budget.lastStreamBudgetCheck = 0;
+        toolStartAt.clear();
+        if (rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns) {
+            rs.limits.turnsExceeded = true;
+            if (prepared.suspendForResource === undefined) {
+                void prepared.harness.abort();
+                prepared.abortController.abort();
+            }
+        }
+        else {
+            if (rs.degrade.degraded === undefined &&
+                spec.degrade &&
+                rs.degrade.degradeToModel &&
+                rs.budget.maxCostMicroUsd !== undefined &&
+                stats.costMicroUsd >= spec.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
+                void prepared.harness.setModel(rs.degrade.degradeToModel);
+                rs.degrade.recordDegraded({ from: prepared.model.id, to: rs.degrade.degradeToModel.id, reason: "budget", atTurn: stats.turns }, rs.degrade.degradeToModel);
+                if (prepared.callCapRef &&
+                    spec.limits?.maxOutputTokens === undefined &&
+                    rs.degrade.degradeToModel.maxTokens !== undefined &&
+                    (prepared.callCapRef.staticCapTokens === undefined || rs.degrade.degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
+                    prepared.callCapRef.staticCapTokens = rs.degrade.degradeToModel.maxTokens;
+                }
+            }
+            if (!rs.limits.budgetHit && rs.budget.overBudget()) {
+                rs.limits.budgetHit = "exceeded";
+                if (prepared.suspendForResource === undefined) {
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                }
+            }
+        }
+    };
+    return { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd };
+}
 export class Runner {
     deps;
     sessions;
@@ -1004,7 +1889,7 @@ export class Runner {
             catch {
             }
         }
-        let attachmentsInjected = 0;
+        rs.attach.attachmentsInjected = 0;
         const todoToolMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TodoWrite");
         const taskToolsMounted = rs.attach.attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TaskCreate");
         const writeFamilyByName = new Map();
@@ -1091,8 +1976,8 @@ export class Runner {
                 prepared.callCapRef.budgetMs = effectiveTimeoutMs;
             }
         }
-        let finalizeInjected = false;
-        let walltimeSyncBackstopFired = false;
+        rs.counters.finalizeInjected = false;
+        rs.counters.walltimeSyncBackstopFired = false;
         const nudgeSchedule = [];
         {
             const conf = spec.limits?.deadlineNudge;
@@ -1119,7 +2004,7 @@ export class Runner {
                 }
             }
         }
-        let nudgeIdx = 0;
+        rs.counters.nudgeIdx = 0;
         const buildFinalizeText = () => `<system-reminder>[deadline] the wall-clock budget is exhausted — this is the FINAL turn. ` +
             `Write your best current work to the deliverable path NOW, even if incomplete — persist to disk FIRST; everything else comes after. ` +
             `If a better version exists anywhere else (a draft, scratch or temp file), copy it to the deliverable path now. ` +
@@ -1148,7 +2033,6 @@ export class Runner {
             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;
-        let lastWorkspaceCwd = prepared.cwdRef?.current;
         const statusEmit = (s) => {
             queue.push({
                 type: "status",
@@ -1176,362 +2060,16 @@ export class Runner {
                         : { kind: "vision.placeholder", version: 1, taskId: rs.telemetry.taskId, count: t.count, ts: Date.now() });
         };
         const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, fn));
-        const onMessageUpdate = (event) => {
-            const ev = event.assistantMessageEvent;
-            if (rs.turn.callStartAt === undefined)
-                rs.turn.callStartAt = Date.now();
-            if (ev.type === "text_delta" && ev.delta) {
-                if (rs.turn.firstTokenAt === undefined)
-                    rs.turn.firstTokenAt = Date.now();
-                pushContent({ type: "text_delta", delta: ev.delta, ...ident() });
-            }
-            else if (ev.type === "thinking_delta" && ev.delta) {
-                pushContent({ type: "reasoning_delta", delta: ev.delta, ...ident() });
-            }
-            if (rs.budget.streamCancel && !rs.limits.budgetHit && (ev.type === "text_delta" || ev.type === "thinking_delta") && ev.delta) {
-                rs.budget.callOutputChars += ev.delta.length;
-                if (rs.budget.callOutputChars - rs.budget.lastStreamBudgetCheck >= 256) {
-                    rs.budget.lastStreamBudgetCheck = rs.budget.callOutputChars;
-                    if (rs.budget.projectedOverBudget()) {
-                        rs.limits.budgetHit = "exceeded";
-                        void prepared.harness.abort();
-                        prepared.abortController.abort();
-                    }
-                }
-            }
-        };
-        const onMessageEnd = (event) => {
-            const m = event.message;
-            if (event.entryId !== undefined && (m.role === "user" || m.role === "assistant" || m.role === "toolResult")) {
-                emitCommitted(event.entryId, m.role, m.role === "toolResult" ? m.toolCallId : undefined);
-            }
-            if (rs.degrade.degraded === undefined && m.role === "assistant") {
-                const deg = readDegradation(m);
-                if (deg)
-                    rs.degrade.recordDegraded({ from: deg.from, to: deg.to, reason: deg.reason, atTurn: stats.turns + 1, ...(deg.chain && { chain: deg.chain }) });
-            }
-            if (m.role === "assistant" && "usage" in m && m.usage) {
-                if (m.usageMissing)
-                    rs.turn.turnUsageMissing = true;
-                const u = m.usage;
-                stats.tokens += u.totalTokens || 0;
-                const { totalInputTokens: turnInput, costMicroUsd: turnCostMicroUsd } = usageCostMicroUsd(rs.telemetry.cacheFamily, u, rs.telemetry.pricing);
-                stats.promptTokens += turnInput;
-                stats.cachedTokens += u.cacheRead || 0;
-                stats.cacheWriteTokens += u.cacheWrite || 0;
-                stats.outputTokens += u.output || 0;
-                stats.costMicroUsd += turnCostMicroUsd;
-                rs.turn.turnUsage ??= { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costMicroUsd: 0 };
-                rs.turn.turnUsage.inputTokens += turnInput;
-                rs.turn.turnUsage.outputTokens += u.output || 0;
-                rs.turn.turnUsage.cacheReadTokens += u.cacheRead || 0;
-                rs.turn.turnUsage.cacheWriteTokens += u.cacheWrite || 0;
-                rs.turn.turnUsage.costMicroUsd += turnCostMicroUsd;
-                const callEndAt = Date.now();
-                const callIssuedAt = prepared.callIssuedAtRef?.current;
-                if (prepared.callIssuedAtRef)
-                    prepared.callIssuedAtRef.current = undefined;
-                const capLast = prepared.callCapRef?.state.last;
-                if (prepared.callCapRef) {
-                    recordCallSample(prepared.callCapRef.state, u.output || 0, rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0, {
-                        contentValid: m.usageMissing === true && hasRealContent(m.content),
-                    });
-                    if (rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined) {
-                        recordTtftSample(prepared.callCapRef.state, rs.turn.firstTokenAt - rs.turn.callStartAt);
-                    }
-                    prepared.callCapRef.state.last = undefined;
-                }
-                emitTrace(rs.telemetry.tracer, () => ({
-                    kind: "brain.call",
-                    version: 1,
-                    taskId: rs.telemetry.taskId,
-                    model: m.model,
-                    provider: m.provider,
-                    promptTokens: turnInput,
-                    completionTokens: u.output || 0,
-                    cacheRead: u.cacheRead || 0,
-                    cacheWrite: u.cacheWrite || 0,
-                    latencyMs: rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0,
-                    firstTokenMs: rs.turn.callStartAt !== undefined && rs.turn.firstTokenAt !== undefined ? rs.turn.firstTokenAt - rs.turn.callStartAt : undefined,
-                    ...(callIssuedAt !== undefined ? { callStartedAt: callIssuedAt } : {}),
-                    costMicroUsd: turnCostMicroUsd,
-                    ...(capLast !== undefined ? { callCap: capLast.cap, capThinkingSkipped: capLast.thinkingSkipped } : {}),
-                    ...(m.role === "assistant" && typeof m.stopReason === "string"
-                        ? { stopReason: m.stopReason }
-                        : {}),
-                    ts: callEndAt,
-                }));
-                if (prepared.callCapRef &&
-                    prepared.callCapRef.reasoningObserved !== true &&
-                    capLast !== undefined &&
-                    m.role === "assistant" &&
-                    m.stopReason === "length") {
-                    const blocks = Array.isArray(m.content)
-                        ? (m.content)
-                        : [];
-                    const productive = blocks.some((c) => c?.type === "toolCall") ||
-                        blocks.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim() !== "");
-                    if (!productive)
-                        prepared.callCapRef.reasoningObserved = true;
-                }
-                if (prepared.cacheBreakDetector && prepared.cacheFingerprint) {
-                    const finding = prepared.cacheBreakDetector.observe({
-                        turn: stats.turns + 1,
-                        systemPrompt: prepared.cacheFingerprint.systemPrompt,
-                        tools: prepared.cacheFingerprint.tools,
-                        modelKey: `${m.provider}:${m.model}`,
-                        cacheRead: u.cacheRead || 0,
-                    });
-                    if (finding) {
-                        rs.telemetry.cacheBreakReported = true;
-                        this.deps.onError?.(new Error(`prompt-cache: break at turn ${finding.turn} — cache_read ${finding.cacheReadBefore}→${finding.cacheReadAfter}; ${finding.detail}. See design/31.`), { phase: "prompt-cache", sessionId: prepared.sessionId, classification: finding.cause });
-                    }
-                }
-            }
-            if (m.role === "assistant" && typeof m.stopReason === "string") {
-                rs.turn.turnStopReason = m.stopReason;
-            }
-            if (m.role === "assistant" && m.errorMessage === WALLTIME_CUTOFF_MESSAGE) {
-                rs.counters.callCutoffs += 1;
-                if (prepared.callCapRef)
-                    prepared.callCapRef.finalizeMode = true;
-                if (!finalizeInjected) {
-                    const finalizeText = buildFinalizeText();
-                    void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
-                    void prepared.harness.setThinkingLevel("off").catch(() => { });
-                    prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
-                    finalizeInjected = true;
-                    nudgeIdx = nudgeSchedule.length;
-                    queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
-                }
-            }
-            if (m.role === "assistant") {
-                const rep = m.repetition;
-                if (rep !== undefined) {
-                    const observed = [
-                        ...(rep.cut !== undefined ? [{ action: "cut", e: rep.cut }] : []),
-                        ...(rep.spared ?? []).map((e) => ({ action: "spared", e })),
-                    ];
-                    for (const { action, e } of observed) {
-                        if (action === "cut")
-                            rs.counters.repetitionCuts += 1;
-                        else
-                            rs.counters.repetitionSpared += 1;
-                        if (rs.counters.repetitionEvents.length < rs.counters.REPETITION_EVENTS_CAP) {
-                            rs.counters.repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment: e.segment });
-                        }
-                        emitTrace(rs.telemetry.tracer, () => ({
-                            kind: "repetition.detected",
-                            version: 1,
-                            taskId: rs.telemetry.taskId,
-                            turn: stats.turns + 1,
-                            action,
-                            rule: e.rule,
-                            period: e.period,
-                            reps: e.reps,
-                            segment: e.segment,
-                            ts: Date.now(),
-                        }));
-                    }
-                }
-            }
-            if (prepared.callCapRef &&
-                prepared.callCapRef.reasoningObserved !== true &&
-                m.role === "assistant" &&
-                Array.isArray(m.content) &&
-                m.content.some((c) => c?.type === "thinking")) {
-                prepared.callCapRef.reasoningObserved = true;
-            }
-            if (m.role === "assistant") {
-                const content = m.content;
-                if (rs.attach.attachState !== undefined)
-                    rs.counters.cadenceTurns = advanceCadenceClock(rs.attach.attachState, rs.counters.cadenceTurns, content, writeFamilyOf);
-                rs.turn.lastTurnHadToolCalls = Array.isArray(content) && content.some((c) => c?.type === "toolCall");
-            }
-            rs.turn.callStartAt = undefined;
-            rs.turn.firstTokenAt = undefined;
-            rs.budget.callOutputChars = 0;
-            rs.budget.lastStreamBudgetCheck = 0;
-        };
         const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
         const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
         const batchArgs = postToolBatchHook ? new Map() : undefined;
-        let toolBatch = [];
-        const onToolStart = (event) => {
-            const startAt = Date.now();
-            toolStartAt.set(event.toolCallId, startAt);
-            startedToolCallIds.add(event.toolCallId);
-            batchArgs?.set(event.toolCallId, event.args);
-            stats.toolCalls += 1;
-            if (spec.finalVerification === true && !(rs.counters.finalVerifyInjections === 0 ? rs.counters.groundingSignalPreR9 : rs.counters.groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
-                if (rs.counters.finalVerifyInjections === 0)
-                    rs.counters.groundingSignalPreR9 = true;
-                else
-                    rs.counters.groundingSignalPostR9 = true;
-            }
-            const activityArg = primaryActivityArg(event.args);
-            internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, at: startAt, ...(activityArg !== undefined ? { arg: activityArg } : {}) });
-            pushContent({
-                type: "tool_start",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
-                args: event.args,
-                ...ident(),
-            });
-        };
-        const onToolEnd = (event) => {
-            const toolStarted = toolStartAt.get(event.toolCallId);
-            toolStartAt.delete(event.toolCallId);
-            const toolNow = Date.now();
-            if (prepared.callCapRef && toolStarted !== undefined) {
-                recordToolSample(prepared.callCapRef.state, toolNow - toolStarted);
-                turnToolSpan.startMin = turnToolSpan.startMin === undefined ? toolStarted : Math.min(turnToolSpan.startMin, toolStarted);
-                turnToolSpan.endMax = turnToolSpan.endMax === undefined ? toolNow : Math.max(turnToolSpan.endMax, toolNow);
-            }
-            if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
-                rs.counters.wroteThisRun = true;
-            }
-            if (rs.attach.attachState !== undefined && !event.isError) {
-                const det = event.result?.details;
-                if (det !== undefined)
-                    reduceToolEnd(rs.attach.attachState, det);
-            }
-            if (postToolBatchHook !== undefined) {
-                if (prepared.blockedToolCalls.delete(event.toolCallId)) {
-                    batchArgs?.delete(event.toolCallId);
-                }
-                else {
-                    const digest = batchResponseDigest(event.result);
-                    toolBatch.push({
-                        toolName: event.toolName,
-                        input: batchArgs?.get(event.toolCallId),
-                        toolCallId: event.toolCallId,
-                        ...(digest !== undefined ? { response: digest } : {}),
-                        isError: event.isError,
-                    });
-                    batchArgs?.delete(event.toolCallId);
-                }
-            }
-            emitTrace(rs.telemetry.tracer, () => ({
-                kind: "tool.call",
-                version: 1,
-                taskId: rs.telemetry.taskId,
-                name: event.toolName,
-                durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
-                ok: !event.isError,
-                ts: toolNow,
-            }));
-            internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError, at: toolNow });
-            if (prepared.lspDiagnostics && !event.isError) {
-                const name = canonicalToolName(event.toolName);
-                if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
-                    const d = event.result?.details;
-                    const p = typeof d?.filePath === "string" ? d.filePath : typeof d?.notebookPath === "string" ? d.notebookPath : undefined;
-                    if (p)
-                        prepared.lspDiagnostics.nudge(p);
-                }
-            }
-            pushContent({
-                type: "tool_end",
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
-                isError: event.isError,
-                ...(() => {
-                    const o = toolOutputFrom(event.result);
-                    return o !== undefined
-                        ? { output: o.output, ...(o.truncated ? { truncated: true } : {}), ...(o.totalChars !== undefined ? { totalChars: o.totalChars } : {}) }
-                        : {};
-                })(),
-                ...(() => {
-                    const st = structuredFrom(event.result);
-                    return st !== undefined ? { structured: st } : {};
-                })(),
-                ...ident(),
-            });
-            const cwdNow = prepared.cwdRef?.current;
-            if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
-                lastWorkspaceCwd = cwdNow;
-                queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
-            }
-            if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
-                if (event.isError) {
-                    rs.degrade.outputErrorStreak += 1;
-                    if (rs.degrade.outputErrorStreak > rs.limits.outputRetryCap) {
-                        rs.degrade.outputInvalid = true;
-                        void prepared.harness.abort();
-                        prepared.abortController.abort();
-                    }
-                }
-                else {
-                    rs.degrade.outputErrorStreak = 0;
-                }
-            }
-        };
-        const onTurnEnd = () => {
-            stats.turns += 1;
-            const stopExtra = rs.turn.turnStopReason !== undefined ? { stopReason: rs.turn.turnStopReason } : {};
-            queue.push(rs.turn.turnUsage
-                ? { type: "turn_end", usage: rs.turn.turnUsage, ...(rs.turn.turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() }
-                : { type: "turn_end", usageMissing: true, ...stopExtra, ...ident() });
-            rs.turn.turnUsageMissing = false;
-            rs.turn.turnStopReason = undefined;
-            if (parentToolCallId !== undefined) {
-                const progress = {
-                    type: "task_progress",
-                    taskId: rs.telemetry.taskId,
-                    ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
-                    ...(subagentName ? { name: subagentName } : {}),
-                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
-                    status: "running",
-                    ...ident(),
-                };
-                queue.push(progress);
-                try {
-                    internals?.onForwardEvent?.(progress);
-                }
-                catch {
-                }
-            }
-            emitTrace(rs.telemetry.tracer, () => ({ kind: "turn.end", version: 1, taskId: rs.telemetry.taskId, turn: stats.turns, ts: Date.now() }));
-            rs.turn.turnUsage = undefined;
-            rs.turn.callStartAt = undefined;
-            rs.turn.firstTokenAt = undefined;
-            rs.budget.callOutputChars = 0;
-            rs.budget.lastStreamBudgetCheck = 0;
-            toolStartAt.clear();
-            if (rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns) {
-                rs.limits.turnsExceeded = true;
-                if (prepared.suspendForResource === undefined) {
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-            }
-            else {
-                if (rs.degrade.degraded === undefined &&
-                    spec.degrade &&
-                    rs.degrade.degradeToModel &&
-                    rs.budget.maxCostMicroUsd !== undefined &&
-                    stats.costMicroUsd >= spec.degrade.atCostFraction * rs.budget.maxCostMicroUsd) {
-                    void prepared.harness.setModel(rs.degrade.degradeToModel);
-                    rs.degrade.recordDegraded({ from: prepared.model.id, to: rs.degrade.degradeToModel.id, reason: "budget", atTurn: stats.turns }, rs.degrade.degradeToModel);
-                    if (prepared.callCapRef &&
-                        spec.limits?.maxOutputTokens === undefined &&
-                        rs.degrade.degradeToModel.maxTokens !== undefined &&
-                        (prepared.callCapRef.staticCapTokens === undefined || rs.degrade.degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
-                        prepared.callCapRef.staticCapTokens = rs.degrade.degradeToModel.maxTokens;
-                    }
-                }
-                if (!rs.limits.budgetHit && rs.budget.overBudget()) {
-                    rs.limits.budgetHit = "exceeded";
-                    if (prepared.suspendForResource === undefined) {
-                        void prepared.harness.abort();
-                        prepared.abortController.abort();
-                    }
-                }
-            }
-        };
+        rs.turn.toolBatch = [];
+        const { onMessageUpdate, onMessageEnd, onToolStart, onToolEnd, onTurnEnd } = makeHarnessHandlers(prepared, stats, rs, {
+            spec, queue, internals, buildFinalizeText, ident, nudgeSchedule, parentToolCallId, subagentName,
+            pushContent, emitCommitted, startedToolCallIds, toolStartAt, turnToolSpan, writeFamilyOf,
+            toolLabels, postToolBatchHook, batchArgs,
+            runnerHooks: { onError: (e, info) => this.deps.onError?.(e, info) },
+        });
         const recordCompactionUsage = (m, msg) => {
             const u = msg?.usage;
             if (!u)
@@ -1622,7 +2160,7 @@ export class Runner {
                     (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
                     rs.counters.wroteThisRun &&
                     prepared.outputRef.set !== true &&
-                    !finalizeInjected &&
+                    !rs.counters.finalizeInjected &&
                     !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1)) {
                     rs.counters.finalVerifyInjections += 1;
                     if (rs.counters.finalVerifyInjections === 2) {
@@ -1792,7 +2330,7 @@ export class Runner {
                             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));
-                                compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                                rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
                             }
                             queue.push({
                                 type: "compacted",
@@ -1834,507 +2372,23 @@ export class Runner {
             },
         });
         const rapidRefill = createRapidRefillState();
-        let compactionFloor = 0;
-        let trimForceBackoff = false;
         const drainManualCompact = (outcome) => {
             manualCompactRef.requested = false;
             for (const w of manualCompactRef.waiters.splice(0))
                 w.resolve(outcome);
         };
-        const onTurnBoundary = async (event) => {
-            if (prepared.callCapRef && turnToolSpan.startMin !== undefined && turnToolSpan.endMax !== undefined) {
-                recordToolCycleSample(prepared.callCapRef.state, turnToolSpan.endMax - turnToolSpan.startMin);
-            }
-            turnToolSpan.startMin = undefined;
-            turnToolSpan.endMax = undefined;
-            let boundarySteered = false;
-            if (prepared.suspendForResource === undefined) {
-                const nowMs = Date.now();
-                if (!finalizeInjected &&
-                    spec.limits?.gracefulFinalize !== false &&
-                    walltimeDeadlineMs !== undefined &&
-                    prepared.callCapRef !== undefined) {
-                    const remainingMs = walltimeDeadlineMs - nowMs;
-                    if (remainingMs > 0 && remainingMs < estimateCycleMs(prepared.callCapRef.state) + (effectiveCushionMs(prepared.callCapRef) ?? 0)) {
-                        finalizeInjected = true;
-                        prepared.callCapRef.finalizeMode = true;
-                        void prepared.harness.setThinkingLevel("off").catch(() => { });
-                        prepared.turnSnapshot?.refreshRequestPolicy({ thinkingLevel: "off" });
-                        nudgeIdx = nudgeSchedule.length;
-                        const finalizeText = buildFinalizeText();
-                        void prepared.harness.steer(finalizeText, { engineMinted: true }).catch(() => { });
-                        boundarySteered = true;
-                        queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
-                    }
-                }
-                let due;
-                while (nudgeIdx < nudgeSchedule.length && nowMs >= nudgeSchedule[nudgeIdx].atMs) {
-                    due = nudgeSchedule[nudgeIdx++];
-                }
-                if (due) {
-                    void prepared.harness.steer(due.text, { engineMinted: true }).catch(() => { });
-                    rs.counters.nudgesSent += 1;
-                    boundarySteered = true;
-                    queue.push({ type: "steering_injected", source: "deadline_nudge", preview: due.text.slice(0, 220), ...ident() });
-                }
-            }
-            const walltimeHit = walltimeMonotonicDeadline !== undefined && performance.now() >= walltimeMonotonicDeadline;
-            const preemptHit = spec.preemptSignal?.aborted === true;
-            if (preemptHit && !prepared.suspendForResource && !rs.counters.preemptIgnoredReported) {
-                rs.counters.preemptIgnoredReported = true;
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "preempt.ignored", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-            }
-            if (prepared.suspendForResource &&
-                (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
-                prepared.suspendRef.token === undefined) {
-                const reason = preemptHit
-                    ? "preempt"
-                    : rs.limits.budgetHit !== undefined
-                        ? "budget"
-                        : walltimeHit
-                            ? "walltime"
-                            : "turns";
-                const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) };
-                if (await prepared.suspendForResource(reason, sliceSpend)) {
-                    rs.limits.turnsExceeded = false;
-                    rs.limits.budgetHit = undefined;
-                }
-                else {
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-                return undefined;
-            }
-            if (walltimeMonotonicDeadline !== undefined &&
-                prepared.suspendForResource === undefined &&
-                performance.now() >= walltimeMonotonicDeadline) {
-                if (!timeout.fired) {
-                    timeout.fired = true;
-                    timeout.clear();
-                    timeout.latenessMs = Math.max(timeout.latenessMs ?? 0, performance.now() - walltimeMonotonicDeadline);
-                    walltimeSyncBackstopFired = true;
-                    void prepared.harness.abort();
-                    prepared.abortController.abort();
-                }
-                return undefined;
-            }
-            if (prepared.reviewRequestRef.pending !== undefined) {
-                const { reason } = prepared.reviewRequestRef.pending;
-                prepared.reviewRequestRef.pending = undefined;
-                const honorable = prepared.suspendForReview !== undefined &&
-                    !prepared.abortController.signal.aborted &&
-                    prepared.suspendRef.token === undefined &&
-                    prepared.reviewRef.token === undefined;
-                if (honorable && prepared.suspendForReview) {
-                    await prepared.suspendForReview(reason);
-                    return undefined;
-                }
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "review.dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-            }
-            if (prepared.lspDiagnostics && !prepared.lspDiagnostics.registry.isEmpty() && !prepared.abortController.signal.aborted) {
-                const files = prepared.lspDiagnostics.registry.drain();
-                if (files.length > 0) {
-                    queue.push({ type: "diagnostics", files, isNew: true, ...ident() });
-                    const block = formatDiagnosticsBlock(files);
-                    void prepared.harness.steer(block, { provenance: "engine-note" }).catch(() => undefined);
-                    boundarySteered = true;
-                }
-            }
-            let boundaryAttachmentBytes = 0;
-            let attachmentsPayload;
-            if ((rs.attach.dateState !== undefined || rs.attach.instrState !== undefined || rs.attach.attachState !== undefined) &&
-                !boundarySteered &&
-                !finalizeInjected &&
-                rs.counters.finalVerifyInjections === 0 &&
-                !prepared.abortController.signal.aborted) {
-                const due = [];
-                if (rs.attach.attachState !== undefined) {
-                    const changedFilesOn = Boolean(rs.attach.attachmentsCfg?.changedFiles);
-                    let changed;
-                    if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
-                        const maxFiles = typeof rs.attach.attachmentsCfg?.changedFiles === "object"
-                            ? (rs.attach.attachmentsCfg.changedFiles.maxFiles ?? CHANGED_FILES_MAX)
-                            : CHANGED_FILES_MAX;
-                        const SCAN_CEILING_MS = 2_000;
-                        const scan = await Promise.race([
-                            prepared.detectExternalChanges(maxFiles),
-                            new Promise((resolve) => {
-                                const t = setTimeout(() => resolve({ changed: [], evicted: [] }), SCAN_CEILING_MS);
-                                t.unref?.();
-                            }),
-                        ]);
-                        for (const p of scan.evicted)
-                            rs.attach.attachState.surfacedMtime.delete(p);
-                        changed = scan.changed;
-                    }
-                    const backgroundTasksOn = rs.attach.attachmentsCfg?.backgroundTasks === true;
-                    const bgTasks = backgroundTasksOn && rs.attach.attachState.postCompactPending ? prepared.listBackgroundTasks() : undefined;
-                    const toolsDeltaOn = rs.attach.attachmentsCfg?.toolsDelta === true;
-                    const pendingTools = toolsDeltaOn && prepared.toolsDeltaRef !== undefined && prepared.toolsDeltaRef.pending.length > 0
-                        ? [...prepared.toolsDeltaRef.pending]
-                        : undefined;
-                    const mcpInstructionsOn = rs.attach.attachmentsCfg?.mcpInstructions === true;
-                    const mcpDelta = prepared.mcp.instructionsDelta;
-                    const mcpAdds = mcpInstructionsOn && mcpDelta.pendingAdds.length > 0 ? [...mcpDelta.pendingAdds] : undefined;
-                    const mcpRemovals = mcpInstructionsOn && mcpDelta.pendingRemovals.length > 0 ? [...mcpDelta.pendingRemovals] : undefined;
-                    const mcpDropped = mcpInstructionsOn && prepared.mcp.droppedTools.length > 0 ? selectMcpDroppedBatch(prepared.mcp.droppedTools) : undefined;
-                    const budgetUsdOn = rs.attach.attachmentsCfg?.budgetUsd === true && rs.budget.maxCostMicroUsd !== undefined && rs.turn.lastTurnHadToolCalls;
-                    due.push(...collectDueAttachments(rs.attach.attachState, {
-                        turn: stats.turns,
-                        cadenceTurn: rs.counters.cadenceTurns,
-                        todoMounted: todoToolMounted,
-                        taskListMounted: taskToolsMounted,
-                        planActive: prepared.planModeRef.active,
-                        config: {
-                            todoReminder: rs.attach.attachmentsCfg?.todoReminder === true,
-                            ...(rs.attach.attachmentsCfg?.todoReminderMode !== undefined ? { todoReminderMode: rs.attach.attachmentsCfg.todoReminderMode } : {}),
-                            changedFiles: changedFilesOn,
-                            planModeReminder: rs.attach.attachmentsCfg?.planModeReminder === true,
-                            budgetUsd: budgetUsdOn,
-                            backgroundTasks: backgroundTasksOn,
-                            toolsDelta: toolsDeltaOn,
-                            agentListing: rs.attach.agentListingOn,
-                            skillsListing: rs.attach.skillsListingOn,
-                            mcpInstructions: mcpInstructionsOn,
-                        },
-                        ...(changed !== undefined ? { changedFiles: changed } : {}),
-                        ...(budgetUsdOn && rs.budget.maxCostMicroUsd !== undefined
-                            ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: rs.budget.maxCostMicroUsd / 1e6 } }
-                            : {}),
-                        ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
-                        ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
-                        ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
-                            ? {
-                                agentListing: prepared.agentListing.entries,
-                                agentToolName: prepared.agentListing.toolName,
-                                ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
-                            }
-                            : {}),
-                        ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
-                        ...(mcpAdds !== undefined || mcpRemovals !== undefined
-                            ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
-                            : {}),
-                        ...(mcpDropped !== undefined ? { mcpDroppedTools: mcpDropped } : {}),
-                    }));
-                    if (pendingTools !== undefined && due.some((a) => a.source === "tools_delta" && a.body === renderToolsDelta(pendingTools))) {
-                        prepared.toolsDeltaRef.pending.splice(0, pendingTools.length);
-                    }
-                    if ((mcpAdds !== undefined || mcpRemovals !== undefined) &&
-                        due.some((a) => a.source === "mcp_instructions" && a.body === renderMcpInstructionsDelta(mcpAdds ?? [], mcpRemovals ?? []))) {
-                        if (mcpAdds !== undefined)
-                            mcpDelta.pendingAdds.splice(0, mcpAdds.length);
-                        if (mcpRemovals !== undefined)
-                            mcpDelta.pendingRemovals.splice(0, mcpRemovals.length);
-                    }
-                    if (mcpDropped !== undefined &&
-                        due.some((a) => a.source === "mcp_dropped_tools" && a.body === renderMcpDroppedTools(mcpDropped))) {
-                        prepared.mcp.droppedTools.splice(0, mcpDropped.length);
-                    }
-                    if (rs.attach.agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
-                        const listing = prepared.agentListing;
-                        const intactBody = renderAgentListingDelta(rs.attach.attachState, listing.entries, listing.toolName, listing.models);
-                        if (intactBody !== undefined && due.some((a) => a.source === "agent_listing" && a.body === intactBody)) {
-                            commitAgentListing(rs.attach.attachState, listing.entries, listing.models);
-                            prepared.announcedListingsRef.agents = listing.entries.map((e) => e.name);
-                            if (listing.models !== undefined)
-                                prepared.announcedListingsRef.models = [...listing.models];
-                            await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                        }
-                    }
-                    if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
-                        const listing = prepared.skillsListing;
-                        const intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
-                        if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
-                            commitSkillsListing(rs.attach.attachState, listing.entries);
-                            prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
-                            await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
-                        }
-                    }
-                }
-                if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
-                    const today = prepared.dateChange.today();
-                    const cand = collectDateChange(rs.attach.dateState, today);
-                    if (cand !== undefined) {
-                        due.unshift(cand);
-                        rs.attach.dateState.announcedDate = today;
-                    }
-                }
-                if (rs.attach.instrState !== undefined && rs.attach.instrProbe !== undefined && rs.turn.lastTurnHadToolCalls) {
-                    let probed = null;
-                    try {
-                        const PROBE_CEILING_MS = 2_000;
-                        probed = await Promise.race([
-                            rs.attach.instrProbe(prepared.instructionSources),
-                            new Promise((resolve) => {
-                                const t = setTimeout(() => resolve(null), PROBE_CEILING_MS);
-                                t.unref?.();
-                            }),
-                        ]);
-                    }
-                    catch {
-                        probed = null;
-                    }
-                    const cand = collectInstructionsChange(rs.attach.instrState, probed);
-                    if (cand !== undefined) {
-                        due.splice(due.length > 0 && due[0].source === "date_change" ? 1 : 0, 0, cand.attachment);
-                        commitInstructionsChange(rs.attach.instrState, cand.announced);
-                    }
-                }
-                if (due.length > 0) {
-                    attachmentsPayload = due.map((a) => `<system-reminder>\n${sanitizeUntrustedText(a.body)}\n</system-reminder>`).join("\n");
-                    for (const a of due)
-                        boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
-                    attachmentsInjected += due.length;
-                    for (const a of due) {
-                        queue.push({ type: "steering_injected", source: a.source, preview: a.body.slice(0, 220), ...ident() });
-                    }
-                }
-            }
-            let batchContextBlock;
-            if (postToolBatchHook !== undefined && toolBatch.length > 0) {
-                const batch = toolBatch;
-                toolBatch = [];
-                batchArgs?.clear();
-                if (!boundarySteered && !finalizeInjected && rs.counters.finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
-                    try {
-                        const r = await postToolBatchHook(batch);
-                        if (r?.additionalContext) {
-                            const body = sanitizeUntrustedText(r.additionalContext);
-                            const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
-                            if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
-                                const clipped = clipToByteBudget(body, budget) === body
-                                    ? body
-                                    : `${clipToByteBudget(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
-                                batchContextBlock = `<system-reminder>\n${clipped}\n</system-reminder>`;
-                            }
-                        }
-                    }
-                    catch (err) {
-                        try {
-                            this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
-                        }
-                        catch {
-                        }
-                    }
-                }
-            }
-            if (attachmentsPayload !== undefined || batchContextBlock !== undefined) {
-                const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
-                void prepared.harness.steer(payload, { engineMinted: true }).catch(() => { });
-            }
-            const forceManual = manualCompactRef.requested;
-            if ((!withinTaskCompaction && !forceManual) ||
-                (finalizeInjected && !forceManual) ||
-                prepared.abortController.signal.aborted ||
-                prepared.suspendRef.token !== undefined ||
-                prepared.reviewRef.token !== undefined) {
-                if (forceManual) {
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "task_ending", ts: Date.now() }));
-                    drainManualCompact("mooted");
-                }
-                return undefined;
-            }
-            if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES) {
-                if (forceManual) {
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.failed",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        trigger: "manual",
-                        reason: "compaction circuit breaker open (3 consecutive failures this task) — manual request drained without an attempt",
-                        ts: Date.now(),
-                    }));
-                    drainManualCompact("failed");
-                }
-                return undefined;
-            }
-            const claimedManual = forceManual
-                ? (() => {
-                    const waiters = manualCompactRef.waiters.splice(0);
-                    let instructions;
-                    for (let i = waiters.length - 1; i >= 0; i--) {
-                        if (waiters[i].instructions !== undefined) {
-                            instructions = waiters[i].instructions;
-                            break;
-                        }
-                    }
-                    return { instructions, waiters };
-                })()
-                : undefined;
-            if (forceManual) {
-                manualCompactRef.requested = false;
-            }
-            const resolveClaimedWaiters = (outcome) => {
-                if (claimedManual !== undefined)
-                    for (const w of claimedManual.waiters.splice(0))
-                        w.resolve(outcome);
-            };
-            const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
-            const manualCancelSignal = claimedCancelSignals.length === 0
-                ? undefined
-                : claimedCancelSignals.length === 1
-                    ? claimedCancelSignals[0]
-                    : AbortSignal.any(claimedCancelSignals);
-            const compactionPassSignal = claimedCancelSignals.length > 0
-                ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
-                : prepared.abortController.signal;
-            const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
-            if (trimPressureArmed)
-                prepared.trimPressureRef.droppedMessages = false;
-            const trimPressure = trimPressureArmed && !trimForceBackoff;
-            let manualOutcome = "failed";
-            if (finalizeInjected && forceManual) {
-                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.manual_in_finalize", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-            }
-            const manualInstructions = claimedManual?.instructions;
-            try {
-                const comp = await maybeCompact({
-                    session: prepared.session,
-                    epochDeclaredSections: prepared.epochDeclaredSections,
-                    ...(() => {
-                        const ca = prepared.centerCompactionCandidate?.();
-                        return ca !== undefined ? { centerAdoption: ca } : {};
-                    })(),
-                    model: event.model,
-                    compactionModel: prepared.compModel,
-                    brain: compactionBrain,
-                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                    thinking: prepared.thinking,
-                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                    customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    signal: compactionPassSignal,
-                    ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
-                    minTokens: forceManual ? 0 : compactionFloor,
-                    force: forceManual,
-                    onInputTruncated: (info) => emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId: rs.telemetry.taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
-                    forceUnderThreshold: trimPressure,
-                    overheadTokens: prepared.promptOverheadTokens,
-                    workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
-                        ? {
-                            readFile: prepared.readTaskFile,
-                            ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
-                            ...(prepared.normalizeAttachmentPath ? { normalizePath: prepared.normalizeAttachmentPath } : {}),
-                            ...(prepared.isDedupStubResult ? { isDedupStubResult: prepared.isDedupStubResult } : {}),
-                            ...(prepared.instructionSources
-                                ? { instructionSourcePaths: prepared.instructionSources.filter((s) => s.contentHash !== null).map((s) => s.path) }
-                                : {}),
-                            ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
-                        }
-                        : undefined,
-                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                    ...this.seamCCompactionOptions(prepared),
-                    ...windowSafetyOptions(event.model),
-                    ...this.compactionHookOptions(spec, prepared.sessionId, trimPressure ? "forced" : forceManual ? "manual" : "auto"),
-                });
-                if (comp.blocked) {
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.blocked",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        trigger: forceManual ? "manual" : "auto",
-                        ts: Date.now(),
-                    }));
-                }
-                else {
-                    compactionBreaker.failures = 0;
-                }
-                trimForceBackoff = nextTrimForceBackoff(trimForceBackoff, comp, trimPressure);
-                if (comp.contextUsage) {
-                    queue.push({ type: "context_usage", ...comp.contextUsage, ...ident() });
-                }
-                if (comp.suppressedByFloor) {
-                    const s = comp.suppressedByFloor;
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.suppressed",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        estTokens: s.estTokens,
-                        floor: s.floor,
-                        ts: Date.now(),
-                    }));
-                }
-                manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
-                if (forceManual && !comp.compacted && !comp.blocked) {
-                    if (comp.disabled) {
-                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.disabled", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-                    }
-                    else {
-                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.noop", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
-                    }
-                }
-                if (comp.compacted && !forceManual) {
-                    if (recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
-                        compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
-                        this.deps.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
-                    }
-                }
-                this.recordCompactionReuse(prepared, comp);
-                if (comp.compacted) {
-                    queue.push({
-                        type: "compacted",
-                        trigger: forceManual ? "manual" : "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 } : {}),
-                    });
-                    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);
-                    }
-                    if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                        const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                        compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
-                    }
-                }
-            }
-            catch (err) {
-                const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
-                if (manualCancelAbort) {
-                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.mooted", version: 1, taskId: rs.telemetry.taskId, reason: "cancelled", ts: Date.now() }));
-                    manualOutcome = "mooted";
-                }
-                else if (!prepared.abortController.signal.aborted) {
-                    const walltimeAbort = isCompactionWalltimeAbort(err);
-                    if (!walltimeAbort)
-                        compactionBreaker.failures += 1;
-                    this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
-                    const msg = String(err instanceof Error ? err.message : err);
-                    emitTrace(rs.telemetry.tracer, () => ({
-                        kind: "compaction.failed",
-                        version: 1,
-                        taskId: rs.telemetry.taskId,
-                        trigger: trimPressure ? "forced" : forceManual ? "manual" : "auto",
-                        reason: walltimeAbort
-                            ? "walltime soft-deadline abort (engine-initiated write-out protection; not counted toward the breaker)"
-                            : msg.length > 512
-                                ? `${msg.slice(0, 512)}…`
-                                : msg,
-                        ts: Date.now(),
-                    }));
-                    manualOutcome = "failed";
-                }
-                else {
-                    manualOutcome = "mooted";
-                }
-            }
-            if (forceManual)
-                resolveClaimedWaiters(manualOutcome);
-            return undefined;
-        };
+        const onTurnBoundary = makeTurnBoundary(prepared, stats, rs, {
+            spec, queue, manualCompactRef, todoToolMounted, taskToolsMounted, turnToolSpan,
+            walltimeDeadlineMs, walltimeMonotonicDeadline, nudgeSchedule, buildFinalizeText,
+            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),
+                recordCompactionReuse: (p, c) => this.recordCompactionReuse(p, c),
+            },
+        });
         const unsubBoundary = prepared.harness.on("turn_boundary", onTurnBoundary);
         const unsub = prepared.harness.subscribe((event) => {
             switch (event.type) {
@@ -2497,7 +2551,7 @@ export class Runner {
                         f.commit();
                         queue.push({ type: "steering_injected", source: f.source, preview: f.body.slice(0, 220), ...ident() });
                     }
-                    attachmentsInjected += firstFrames.length;
+                    rs.attach.attachmentsInjected += firstFrames.length;
                     if (firstFrames.length > 0)
                         await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
                     const enginePrefixChars = effectiveObjective.length - spec.objective.length;
@@ -2575,7 +2629,7 @@ export class Runner {
         }
         const comp = await this.finish(spec, prepared, {
             skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
-            minTokens: compactionFloor,
+            minTokens: rs.counters.compactionFloor,
             brain: compactionBrain,
             windowSafety: windowSafetyOptions(prepared.model),
         });
@@ -2642,9 +2696,9 @@ export class Runner {
             const toolCuts = prepared.callCapRef?.toolCuts ?? 0;
             const pendingCutTools = prepared.callCapRef?.pendingCutTools ?? 0;
             const toolCutKills = prepared.cutKills?.kills ?? 0;
-            if (finalizeInjected || rs.counters.nudgesSent > 0 || capShrinks > 0 || rs.counters.callCutoffs > 0 || toolClamps > 0 || toolCuts > 0 || toolCutKills > 0 || pendingCutTools > 0 || rs.counters.finalVerifyInjections > 0 || attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0) {
+            if (rs.counters.finalizeInjected || rs.counters.nudgesSent > 0 || capShrinks > 0 || rs.counters.callCutoffs > 0 || toolClamps > 0 || toolCuts > 0 || toolCutKills > 0 || pendingCutTools > 0 || rs.counters.finalVerifyInjections > 0 || rs.attach.attachmentsInjected > 0 || rs.counters.repetitionCuts > 0 || rs.counters.repetitionSpared > 0) {
                 stats.mechanisms = {
-                    ...(finalizeInjected ? { finalizeInjected: true } : {}),
+                    ...(rs.counters.finalizeInjected ? { finalizeInjected: true } : {}),
                     ...(rs.counters.nudgesSent > 0 ? { nudgesSent: rs.counters.nudgesSent } : {}),
                     ...(capShrinks > 0 ? { capShrinks } : {}),
                     ...(rs.counters.callCutoffs > 0 ? { callCutoffs: rs.counters.callCutoffs } : {}),
@@ -2654,7 +2708,7 @@ export class Runner {
                     ...(pendingCutTools > 0 ? { pendingCutTools } : {}),
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
                     ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjections: rs.counters.finalVerifyInjections } : {}),
-                    ...(attachmentsInjected > 0 ? { attachmentsInjected } : {}),
+                    ...(rs.attach.attachmentsInjected > 0 ? { attachmentsInjected: rs.attach.attachmentsInjected } : {}),
                     ...(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 } : {}),
@@ -2790,7 +2844,7 @@ export class Runner {
                 ...(timeout.latenessMs !== undefined && timeout.latenessMs > TIMER_LATENESS_REPORT_MS
                     ? { timerLatenessMs: timeout.latenessMs }
                     : {}),
-                ...(walltimeSyncBackstopFired ? { walltimeSyncBackstop: true } : {}),
+                ...(rs.counters.walltimeSyncBackstopFired ? { walltimeSyncBackstop: true } : {}),
                 ts: Date.now(),
             }));
             setResult(result);