@sema-agent/core 1.452.0 → 2.0.0

package/dist/core/runner/runtask.js

@@ -18,8 +18,6 @@ import { runWithBrainTelemetry, runWithStatusSink } from "../../brain/status-sin
 import { expandTiers, resolveModel, resolveTaskModel } from "../roles.js";
 import { runSideQuery } from "../side-query.js";
 import { generatePromptSuggestions } from "./prompt-suggestions.js";
-import { runMemoryConsolidation } from "./memory-consolidation.js";
-import { advanceCursorAfterInline } from "../consolidate-scope.js";
 import { PushQueue } from "../push-queue.js";
 import { TtlSessionStore } from "../session-store.js";
 import { toImageContent } from "./image.js";
@@ -41,16 +39,24 @@ import { toolPolicyNameSets } from "../tool-policy.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, PendingSessionNotifications, renderTaskNotificationXml, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
-import { createBrainMemorySelector } from "../memory-recall.js";
-import { buildRecallQuery, runDynamicRecall } from "../dynamic-recall.js";
-import { guardedMemoryStore } from "../memory.js";
-import { releaseSession } from "../../agents/session-util.js";
-export const DEFAULT_MAX_TURNS = 1000;
+import { DEFAULT_MAX_TURNS } from "../../config/defaults.js";
+import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
+export { DEFAULT_MAX_TURNS };
+function createRunState() {
+    return {
+        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, tracer: undefined, taskId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
+        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 },
+    };
+}
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
 const COMPACTION_FREED_EPSILON = 256;
-const MAX_TOOL_END_OUTPUT_CHARS = 16384;
 const BATCH_RESPONSE_MAX_CHARS = 500;
 function batchResponseDigest(result) {
     const content = result !== null && typeof result === "object" ? result.content : result;
@@ -220,9 +226,7 @@ export class Runner {
     parentConstraintRegistry = new Map();
     static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
     constructor(deps) {
-        this.deps = deps.memoryStore
-            ? { ...deps, memoryStore: guardedMemoryStore(deps.memoryStore, deps.utilityGate) }
-            : deps;
+        this.deps = deps;
         if (this.deps.tiers) {
             this.deps = { ...this.deps, models: expandTiers(this.deps.models, this.deps.tiers) };
         }
@@ -333,7 +337,6 @@ export class Runner {
         const queue = new PushQueue();
         const detachHub = new ToolDetachHub();
         let resultValue;
-        let consolidationDone = Promise.resolve();
         let suggestionsDone = Promise.resolve([]);
         let handle;
         let publishReady;
@@ -378,8 +381,6 @@ export class Runner {
                         }
                         this.parentConstraintRegistry.set(r.checkpointToken, pcs);
                     }
-                }, (p) => {
-                    consolidationDone = p;
                 }, (p) => {
                     suggestionsDone = p;
                 }, (h) => {
@@ -440,7 +441,7 @@ export class Runner {
                 result: "",
                 errorMessage: err instanceof Error ? err.message : String(err),
                 errorCode: code,
-                stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costUsd: 0 },
+                stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costMicroUsd: 0 },
             };
             emitTrace(spec.tracer ?? this.deps.tracer, () => ({
                 kind: "task.end",
@@ -499,10 +500,6 @@ export class Runner {
                 await settled;
                 return resultValue;
             },
-            consolidation: async () => {
-                await run.catch(() => { });
-                await consolidationDone.catch(() => { });
-            },
             suggestions: async () => {
                 await run.catch(() => { });
                 return suggestionsDone.catch(() => []);
@@ -626,7 +623,7 @@ export class Runner {
             })()),
         };
     }
-    async runLocked(spec, queue, setResult, onConsolidation, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef) {
+    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef) {
         const prepareResume = resume
             ? {
                 leafId: resume.cp.leafId,
@@ -641,9 +638,6 @@ export class Runner {
                     resume.outcome.decision === "allow",
             }
             : undefined;
-        const memorySelector = this.deps.memoryRecall?.enabled || this.deps.dynamicRecall?.enabled
-            ? (this.deps.memoryRecall?.select ?? createBrainMemorySelector(this, { model: this.deps.memoryRecall?.selectorModel, release: (id) => releaseSession(this, id) }))
-            : undefined;
         const taskNotificationQueue = new SystemInjectionQueue();
         const detachHub = internals?.detachHub ?? new ToolDetachHub();
         let notificationHarness;
@@ -691,7 +685,7 @@ export class Runner {
                     resolve("queued");
             });
         };
-        const prepared = await prepareTask(spec, this.deps, this.sessions, prepareResume, memorySelector, {
+        const prepared = await prepareTask(spec, this.deps, this.sessions, prepareResume, {
             ...(internals ?? {}),
             detachHub,
             onTaskNotification: (notification, opts) => {
@@ -731,8 +725,8 @@ export class Runner {
             }
         }
         onReady({ harness: prepared.harness, abortController: prepared.abortController });
-        const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costUsd: 0, costMicroUsd: 0 };
-        prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - taskStartMonotonic) });
+        const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
+        prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
         if (resume &&
             resume.cp.suspendedAt !== undefined &&
             (resume.cp.gate.kind === "human" ||
@@ -746,12 +740,12 @@ export class Runner {
             const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
             prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
         }
-        let cacheFamily = cacheFamilyOf(prepared.model);
-        let pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
-        let degradeToModel;
+        const rs = createRunState();
+        rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
+        rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
         if (spec.degrade) {
             try {
-                degradeToModel = resolveModel(spec.degrade.to, this.deps.models);
+                rs.degrade.degradeToModel = resolveModel(spec.degrade.to, this.deps.models);
             }
             catch (e) {
                 this.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId });
@@ -761,25 +755,23 @@ export class Runner {
         if (famOverride && !["input-includes-cached", "input-excludes-cached", "openai", "anthropic"].includes(famOverride)) {
             this.deps.onError?.(new Error(`prompt-cache: unrecognized model.params.promptCacheFamily "${famOverride}" — ignored (fell back to model.api inference). Use "input-includes-cached" | "input-excludes-cached" (aliases "openai" | "anthropic").`), { phase: "prompt-cache", sessionId: prepared.sessionId });
         }
-        let turnsExceeded = false;
-        let budgetHit;
-        let degraded;
-        let outputErrorStreak = 0;
-        let outputInvalid = false;
-        let cacheBreakReported = false;
-        const outputRetryCap = resolveOutputRetries(spec.outputRetries);
-        const effectiveMaxTurns = resolveMaxTurns(spec.limits);
-        const tracer = spec.tracer ?? this.deps.tracer;
-        const taskId = spec.taskId ?? prepared.sessionId;
+        rs.limits.turnsExceeded = false;
+        rs.degrade.outputErrorStreak = 0;
+        rs.degrade.outputInvalid = false;
+        rs.telemetry.cacheBreakReported = false;
+        rs.limits.outputRetryCap = resolveOutputRetries(spec.outputRetries);
+        rs.limits.effectiveMaxTurns = resolveMaxTurns(spec.limits);
+        rs.telemetry.tracer = spec.tracer ?? this.deps.tracer;
+        rs.telemetry.taskId = spec.taskId ?? prepared.sessionId;
         if (taskIdRef) {
-            taskIdRef.current = taskId;
+            taskIdRef.current = rs.telemetry.taskId;
             taskIdRef.sessionId = prepared.sessionId;
         }
-        const taskStart = Date.now();
-        const taskStartMonotonic = performance.now();
-        void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, taskId)).catch(() => { });
-        const recordDegraded = (info, toModel) => {
-            if (degraded !== undefined)
+        rs.telemetry.taskStart = Date.now();
+        rs.telemetry.taskStartMonotonic = performance.now();
+        void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, rs.telemetry.taskId)).catch(() => { });
+        rs.degrade.recordDegraded = (info, toModel) => {
+            if (rs.degrade.degraded !== undefined)
                 return;
             let m = toModel;
             if (!m) {
@@ -791,16 +783,16 @@ export class Runner {
                 }
             }
             if (m) {
-                pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-                cacheFamily = cacheFamilyOf(m);
+                rs.telemetry.pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+                rs.telemetry.cacheFamily = cacheFamilyOf(m);
             }
             else {
                 if (this.deps.pricing?.[info.to])
-                    pricing = this.deps.pricing[info.to];
-                cacheFamily = "input-excludes-cached";
+                    rs.telemetry.pricing = this.deps.pricing[info.to];
+                rs.telemetry.cacheFamily = "input-excludes-cached";
             }
-            degraded = info;
-            emitTrace(tracer, () => ({ kind: "task.degraded", version: 1, taskId, from: info.from, to: info.to, reason: info.reason, atTurn: info.atTurn, ts: Date.now() }));
+            rs.degrade.degraded = info;
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "task.degraded", version: 1, taskId: rs.telemetry.taskId, from: info.from, to: info.to, reason: info.reason, atTurn: info.atTurn, ts: Date.now() }));
             try {
                 this.deps.onError?.(new Error(`degraded to a cheaper model: ${info.from} → ${info.to} (${info.reason}) at turn ${info.atTurn}`), { phase: "degraded", sessionId: prepared.sessionId });
             }
@@ -808,63 +800,62 @@ export class Runner {
             }
         };
         const sliceWindowMicroUsd = spec.maxCostUsd !== undefined ? Math.round(spec.maxCostUsd * 1e6) : undefined;
-        const remainingMicroUsd = prepared.resourceLedger
+        rs.budget.remainingMicroUsd = prepared.resourceLedger
             ? remainingBudgetMicroUsd(prepared.resourceLedger)
             : spec.resourceSuspend?.totalBudgetUsd !== undefined
                 ? Math.round(spec.resourceSuspend.totalBudgetUsd * 1e6)
                 : undefined;
-        const maxCostMicroUsd = sliceWindowMicroUsd !== undefined && remainingMicroUsd !== undefined
-            ? Math.min(sliceWindowMicroUsd, remainingMicroUsd)
-            : (sliceWindowMicroUsd ?? remainingMicroUsd);
-        const overBudget = () => (maxCostMicroUsd !== undefined && stats.costMicroUsd > maxCostMicroUsd) ||
+        rs.budget.maxCostMicroUsd =
+            sliceWindowMicroUsd !== undefined && rs.budget.remainingMicroUsd !== undefined
+                ? Math.min(sliceWindowMicroUsd, rs.budget.remainingMicroUsd)
+                : (sliceWindowMicroUsd ?? rs.budget.remainingMicroUsd);
+        rs.budget.overBudget = () => (rs.budget.maxCostMicroUsd !== undefined && stats.costMicroUsd > rs.budget.maxCostMicroUsd) ||
             (spec.maxTokens !== undefined && stats.tokens > spec.maxTokens);
-        const streamCancel = (spec.budgetStreamCancel ?? maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
-        let callOutputChars = 0;
-        let lastStreamBudgetCheck = 0;
-        const projectedOverBudget = () => {
-            const estOut = Math.ceil(callOutputChars / 4);
-            if (maxCostMicroUsd !== undefined) {
-                const estOutMicro = computeCostMicroUsd({ totalInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: estOut }, pricing);
-                if (stats.costMicroUsd + estOutMicro > maxCostMicroUsd)
+        rs.budget.streamCancel =
+            (spec.budgetStreamCancel ?? rs.budget.maxCostMicroUsd !== undefined) && prepared.suspendForResource === undefined;
+        rs.budget.callOutputChars = 0;
+        rs.budget.lastStreamBudgetCheck = 0;
+        rs.budget.projectedOverBudget = () => {
+            const estOut = Math.ceil(rs.budget.callOutputChars / 4);
+            if (rs.budget.maxCostMicroUsd !== undefined) {
+                const estOutMicro = computeCostMicroUsd({ totalInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: estOut }, rs.telemetry.pricing);
+                if (stats.costMicroUsd + estOutMicro > rs.budget.maxCostMicroUsd)
                     return true;
             }
             return spec.maxTokens !== undefined && stats.tokens + estOut > spec.maxTokens;
         };
-        let callStartAt;
-        let firstTokenAt;
-        let turnUsage;
-        let turnUsageMissing = false;
-        let turnStopReason;
-        let nudgesSent = 0;
-        let callCutoffs = 0;
-        let repetitionCuts = 0;
-        let repetitionSpared = 0;
-        const repetitionEvents = [];
-        const REPETITION_EVENTS_CAP = 20;
-        let preemptIgnoredReported = false;
-        let wroteThisRun = false;
-        let finalVerifyInjections = 0;
-        let groundingSignalPreR9 = false;
-        let groundingSignalPostR9 = false;
-        const attachmentsCfg = spec.attachments;
-        const agentListingOn = attachmentsCfg?.agentListing !== false && eventDefaultOn("agent_listing");
-        const skillsListingOn = attachmentsCfg?.skillsListing !== false && eventDefaultOn("skills_listing");
-        const listingsLive = (agentListingOn && prepared.agentListing !== undefined) || (skillsListingOn && prepared.skillsListing !== undefined);
-        const attachState = attachmentsCfg !== undefined || listingsLive ? createAttachmentState() : undefined;
-        const dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.legDate } : undefined;
-        const instrProbe = this.deps.probeInstructionSources;
-        const instrState = instrProbe !== undefined && prepared.instructionSources !== undefined && prepared.instructionSources.length > 0
-            ? { lastAnnouncedHash: new Map(prepared.instructionSources.map((s) => [s.path, s.contentHash])) }
-            : undefined;
-        let cadenceTurns = 0;
-        let lastTurnHadToolCalls = false;
-        if (attachState !== undefined && attachmentsCfg?.backgroundTasks === true) {
+        rs.turn.turnUsageMissing = false;
+        rs.counters.nudgesSent = 0;
+        rs.counters.callCutoffs = 0;
+        rs.counters.repetitionCuts = 0;
+        rs.counters.repetitionSpared = 0;
+        rs.counters.repetitionEvents = [];
+        rs.counters.REPETITION_EVENTS_CAP = 20;
+        rs.counters.preemptIgnoredReported = false;
+        rs.counters.wroteThisRun = false;
+        rs.counters.finalVerifyInjections = 0;
+        rs.counters.groundingSignalPreR9 = false;
+        rs.counters.groundingSignalPostR9 = false;
+        rs.attach.attachmentsCfg = spec.attachments;
+        rs.attach.agentListingOn = rs.attach.attachmentsCfg?.agentListing !== false && eventDefaultOn("agent_listing");
+        rs.attach.skillsListingOn = rs.attach.attachmentsCfg?.skillsListing !== false && eventDefaultOn("skills_listing");
+        const listingsLive = (rs.attach.agentListingOn && prepared.agentListing !== undefined) || (rs.attach.skillsListingOn && prepared.skillsListing !== undefined);
+        rs.attach.attachState = rs.attach.attachmentsCfg !== undefined || listingsLive ? createAttachmentState() : undefined;
+        rs.attach.dateState = prepared.dateChange !== undefined ? { announcedDate: prepared.dateChange.legDate } : undefined;
+        rs.attach.instrProbe = this.deps.probeInstructionSources;
+        rs.attach.instrState =
+            rs.attach.instrProbe !== undefined && prepared.instructionSources !== undefined && prepared.instructionSources.length > 0
+                ? { lastAnnouncedHash: new Map(prepared.instructionSources.map((s) => [s.path, s.contentHash])) }
+                : undefined;
+        rs.counters.cadenceTurns = 0;
+        rs.turn.lastTurnHadToolCalls = false;
+        if (rs.attach.attachState !== undefined && rs.attach.attachmentsCfg?.backgroundTasks === true) {
             try {
                 const branch = await prepared.session.getBranch();
                 for (let i = branch.length - 1; i >= 0; i--) {
                     const e = branch[i];
                     if (e.type === "compaction") {
-                        attachState.postCompactPending = true;
+                        rs.attach.attachState.postCompactPending = true;
                         break;
                     }
                     if (e.type === "message" && e.message.role === "assistant")
@@ -874,9 +865,9 @@ export class Runner {
             catch {
             }
         }
-        if (attachState !== undefined &&
-            ((agentListingOn && prepared.agentListing?.seedAnnounced === true) ||
-                (skillsListingOn && prepared.skillsListing?.seedAnnounced === true))) {
+        if (rs.attach.attachState !== undefined &&
+            ((rs.attach.agentListingOn && prepared.agentListing?.seedAnnounced === true) ||
+                (rs.attach.skillsListingOn && prepared.skillsListing?.seedAnnounced === true))) {
             const cpListings = resume?.cp.state.announcedListings;
             let entryListings;
             try {
@@ -927,23 +918,23 @@ export class Runner {
                     return undefined;
                 }
             };
-            if (agentListingOn && prepared.agentListing?.seedAnnounced === true) {
+            if (rs.attach.agentListingOn && prepared.agentListing?.seedAnnounced === true) {
                 const listing = prepared.agentListing;
                 if (cpListings?.agents === undefined && entryListings?.agents !== undefined) {
                     const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    attachState.announcedAgentTypes = new Map(entryListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
+                    rs.attach.attachState.announcedAgentTypes = new Map(entryListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
                     prepared.announcedListingsRef.agents = [...entryListings.agents];
                     if (entryListings.models !== undefined) {
-                        attachState.announcedModels = [...entryListings.models];
+                        rs.attach.attachState.announcedModels = [...entryListings.models];
                         prepared.announcedListingsRef.models = [...entryListings.models];
                     }
                 }
                 else if (cpListings?.agents !== undefined) {
                     const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    attachState.announcedAgentTypes = new Map(cpListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
+                    rs.attach.attachState.announcedAgentTypes = new Map(cpListings.agents.map((n) => [n, descOf.get(n) ?? ""]));
                     prepared.announcedListingsRef.agents = [...cpListings.agents];
                     if (cpListings.models !== undefined) {
-                        attachState.announcedModels = [...cpListings.models];
+                        rs.attach.attachState.announcedModels = [...cpListings.models];
                         prepared.announcedListingsRef.models = [...cpListings.models];
                     }
                 }
@@ -955,26 +946,26 @@ export class Runner {
                     });
                     if (replayed !== undefined) {
                         const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                        attachState.announcedAgentTypes = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
+                        rs.attach.attachState.announcedAgentTypes = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
                         prepared.announcedListingsRef.agents = [...replayed];
                         const replayedModels = replayAnnouncedModels(await branchLoad());
                         if (replayedModels !== undefined) {
-                            attachState.announcedModels = [...replayedModels];
+                            rs.attach.attachState.announcedModels = [...replayedModels];
                             prepared.announcedListingsRef.models = [...replayedModels];
                         }
                     }
                 }
             }
-            if (skillsListingOn && prepared.skillsListing?.seedAnnounced === true) {
+            if (rs.attach.skillsListingOn && prepared.skillsListing?.seedAnnounced === true) {
                 const listing = prepared.skillsListing;
                 if (cpListings?.skills === undefined && entryListings?.skills !== undefined) {
                     const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    attachState.announcedSkills = new Map(entryListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
+                    rs.attach.attachState.announcedSkills = new Map(entryListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
                     prepared.announcedListingsRef.skills = [...entryListings.skills];
                 }
                 else if (cpListings?.skills !== undefined) {
                     const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                    attachState.announcedSkills = new Map(cpListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
+                    rs.attach.attachState.announcedSkills = new Map(cpListings.skills.map((n) => [n, descOf.get(n) ?? ""]));
                     prepared.announcedListingsRef.skills = [...cpListings.skills];
                 }
                 else {
@@ -985,7 +976,7 @@ export class Runner {
                     });
                     if (replayed !== undefined) {
                         const descOf = new Map(listing.entries.map((e) => [e.name, e.description]));
-                        attachState.announcedSkills = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
+                        rs.attach.attachState.announcedSkills = new Map([...replayed].map((n) => [n, descOf.get(n) ?? ""]));
                         prepared.announcedListingsRef.skills = [...replayed];
                     }
                 }
@@ -1002,11 +993,11 @@ export class Runner {
                         const text = typeof m.content === "string"
                             ? m.content
                             : m.content.map((b) => (b !== null && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : "")).join("\n");
-                        if (text.includes("<system-reminder>[final verification]") && finalVerifyInjections < 2)
-                            finalVerifyInjections += 1;
+                        if (text.includes("<system-reminder>[final verification]") && rs.counters.finalVerifyInjections < 2)
+                            rs.counters.finalVerifyInjections += 1;
                     }
-                    else if (m.role === "toolResult" && !wroteThisRun && (prepared.toolEffects.get(m.toolName) ?? "write") !== "read") {
-                        wroteThisRun = true;
+                    else if (m.role === "toolResult" && !rs.counters.wroteThisRun && (prepared.toolEffects.get(m.toolName) ?? "write") !== "read") {
+                        rs.counters.wroteThisRun = true;
                     }
                 }
             }
@@ -1014,10 +1005,10 @@ export class Runner {
             }
         }
         let attachmentsInjected = 0;
-        const todoToolMounted = attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TodoWrite");
-        const taskToolsMounted = attachState !== undefined && prepared.tools.some((t) => canonicalToolName(t.name) === "TaskCreate");
+        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();
-        if (attachState !== undefined) {
+        if (rs.attach.attachState !== undefined) {
             for (const t of prepared.tools) {
                 const family = writeFamilyOfCanonical(canonicalToolName(t.name));
                 if (family !== undefined)
@@ -1029,11 +1020,11 @@ export class Runner {
         const toolStartAt = new Map();
         const turnToolSpan = {};
         const startedToolCallIds = new Set();
-        emitTrace(tracer, () => ({ kind: "task.start", version: 1, taskId, model: prepared.model.id, engineVersion: engineVersion(), ts: taskStart }));
-        emitTrace(tracer, () => ({
+        emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
+        emitTrace(rs.telemetry.tracer, () => ({
             kind: "prompt.assembled",
             version: 1,
-            taskId,
+            taskId: rs.telemetry.taskId,
             constitution: prepared.promptManifest.constitution,
             blocks: prepared.promptManifest.blocks,
             ...(prepared.promptManifest.sections ? { sections: prepared.promptManifest.sections } : {}),
@@ -1041,36 +1032,36 @@ export class Runner {
             ...(prepared.promptManifest.snapshot ? { snapshot: prepared.promptManifest.snapshot } : {}),
             ...(prepared.promptManifest.lowering ? { lowering: prepared.promptManifest.lowering } : {}),
             totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
-            ts: taskStart,
+            ts: rs.telemetry.taskStart,
         }));
-        emitTrace(tracer, () => {
+        emitTrace(rs.telemetry.tracer, () => {
             const reasons = declarationReasons(spec.configOverrides);
             return {
                 kind: "config.assembled",
                 version: 1,
-                taskId,
+                taskId: rs.telemetry.taskId,
                 catalogVersion: CONFIG_CATALOG_VERSION,
                 fields: resolveEffectiveConfig(spec, { modelMaxTokens: prepared.model.maxTokens }),
                 ...(Object.keys(reasons).length > 0 ? { overrideReasons: reasons } : {}),
-                ts: taskStart,
+                ts: rs.telemetry.taskStart,
             };
         });
         if (prepared.turnSnapshot !== undefined) {
-            prepared.turnSnapshot.onChange = (snap) => emitTrace(tracer, () => ({
+            prepared.turnSnapshot.onChange = (snap) => emitTrace(rs.telemetry.tracer, () => ({
                 kind: "prompt.snapshot_changed",
                 version: 1,
-                taskId,
+                taskId: rs.telemetry.taskId,
                 snapshot: { cacheIdentity: snap.cacheIdentity, elements: { ...snap.elements } },
                 ts: Date.now(),
             }));
         }
         if (prepared.thinking && prepared.thinking !== "off" && prepared.model.reasoning === true) {
-            emitTrace(tracer, () => {
+            emitTrace(rs.telemetry.tracer, () => {
                 const r = resolveReasoning(prepared.thinking, prepared.model);
                 return {
                     kind: "reasoning.resolved",
                     version: 1,
-                    taskId,
+                    taskId: rs.telemetry.taskId,
                     model: prepared.model.id,
                     requested: r.requested,
                     effective: r.effective,
@@ -1091,8 +1082,8 @@ export class Runner {
         const effectiveTimeoutMs = sliceWindowWalltimeMs !== undefined && remainingWalltimeBudgetMs !== undefined
             ? Math.min(sliceWindowWalltimeMs, remainingWalltimeBudgetMs)
             : (sliceWindowWalltimeMs ?? remainingWalltimeBudgetMs);
-        const walltimeDeadlineMs = effectiveTimeoutMs !== undefined ? taskStart + effectiveTimeoutMs : undefined;
-        const walltimeMonotonicDeadline = effectiveTimeoutMs !== undefined ? taskStartMonotonic + effectiveTimeoutMs : undefined;
+        const walltimeDeadlineMs = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStart + effectiveTimeoutMs : undefined;
+        const walltimeMonotonicDeadline = effectiveTimeoutMs !== undefined ? rs.telemetry.taskStartMonotonic + effectiveTimeoutMs : undefined;
         if (prepared.callCapRef && prepared.suspendForResource === undefined && walltimeDeadlineMs !== undefined) {
             prepared.callCapRef.deadlineMs = walltimeDeadlineMs;
             if (spec.limits?.gracefulFinalize !== false) {
@@ -1109,7 +1100,7 @@ export class Runner {
             if (conf !== false && budgetSec && budgetSec > 0) {
                 const [a, b] = conf?.at ?? [0.8, 0.95];
                 if (a > 0 && a < 1) {
-                    const t1 = taskStart + a * budgetSec * 1000;
+                    const t1 = rs.telemetry.taskStart + a * budgetSec * 1000;
                     const remainMin = Math.max(1, Math.round((budgetSec * 1000 * (1 - a)) / 60_000));
                     const budgetMin = Math.max(1, Math.round(budgetSec / 60));
                     nudgeSchedule.push({
@@ -1117,7 +1108,7 @@ export class Runner {
                         text: `<system-reminder>[deadline] ~${remainMin} min of the ~${budgetMin}-min wall-clock budget remain. ` +
                             `Start converging: persist finished work (write files / commit), prefer completing in-flight items over opening new ones.</system-reminder>`,
                     });
-                    const t2 = taskStart + Math.max(Math.min(b * budgetSec * 1000, budgetSec * 1000 - 120_000), a * budgetSec * 1000 + 1);
+                    const t2 = rs.telemetry.taskStart + Math.max(Math.min(b * budgetSec * 1000, budgetSec * 1000 - 120_000), a * budgetSec * 1000 + 1);
                     if (b > a && b < 1) {
                         nudgeSchedule.push({
                             atMs: t2,
@@ -1139,7 +1130,7 @@ export class Runner {
             `</system-reminder>`;
         const timeout = startTimeout(prepared.harness, prepared.abortController, walltimeMonotonicDeadline !== undefined ? walltimeMonotonicDeadline - performance.now() : undefined, prepared.suspendForResource !== undefined);
         const parentToolCallId = internals?.parentToolCallId;
-        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: taskId } : { eventId: uuidv7() };
+        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: rs.telemetry.taskId } : { eventId: uuidv7() };
         notificationIdent = ident;
         const pushContent = (e) => {
             queue.push(e);
@@ -1168,121 +1159,41 @@ export class Runner {
             });
         };
         const telemetryEmit = (t) => {
-            emitTrace(tracer, () => t.kind === "failover"
+            emitTrace(rs.telemetry.tracer, () => t.kind === "failover"
                 ? {
                     kind: "brain.failover",
                     version: 1,
-                    taskId,
+                    taskId: rs.telemetry.taskId,
                     servedIndex: t.servedIndex,
                     total: t.total,
                     ...(t.errorCode !== undefined ? { errorCode: t.errorCode } : {}),
                     ts: Date.now(),
                 }
                 : t.kind === "breaker"
-                    ? { kind: "breaker.transition", version: 1, taskId, key: t.key, phase: t.phase, failures: t.failures, ts: Date.now() }
+                    ? { kind: "breaker.transition", version: 1, taskId: rs.telemetry.taskId, key: t.key, phase: t.phase, failures: t.failures, ts: Date.now() }
                     : t.kind === "retry"
-                        ? { kind: "brain.retry", version: 1, taskId, attempt: t.attempt, phase: t.phase, ts: Date.now() }
-                        : { kind: "vision.placeholder", version: 1, taskId, count: t.count, ts: Date.now() });
+                        ? { kind: "brain.retry", version: 1, taskId: rs.telemetry.taskId, attempt: t.attempt, phase: t.phase, ts: Date.now() }
+                        : { kind: "vision.placeholder", version: 1, taskId: rs.telemetry.taskId, count: t.count, ts: Date.now() });
         };
         const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, fn));
-        const safeJsonLength = (v) => {
-            try {
-                return JSON.stringify(v)?.length;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const trunc = (s) => ({
-            text: s.slice(0, MAX_TOOL_END_OUTPUT_CHARS) + `…[+${s.length - MAX_TOOL_END_OUTPUT_CHARS} chars truncated]`,
-            totalChars: s.length,
-        });
-        const toolOutputFrom = (result) => {
-            const content = result !== null && typeof result === "object" ? result.content : result;
-            if (content === undefined)
-                return undefined;
-            if (typeof content === "string") {
-                if (content.length <= MAX_TOOL_END_OUTPUT_CHARS)
-                    return { output: content, truncated: false };
-                const t = trunc(content);
-                return { output: t.text, truncated: true, totalChars: t.totalChars };
-            }
-            let serialized;
-            try {
-                serialized = JSON.stringify(content) ?? "";
-            }
-            catch {
-                return { output: "[unserializable tool output]", truncated: false };
-            }
-            if (serialized.length <= MAX_TOOL_END_OUTPUT_CHARS)
-                return { output: content, truncated: false };
-            let anyNonText = false;
-            let trueChars = 0;
-            const raw = Array.isArray(content)
-                ? content
-                    .map((b) => {
-                    const block = b;
-                    if (block?.type === "text" && typeof block.text === "string") {
-                        trueChars += block.text.length;
-                        return block.text;
-                    }
-                    anyNonText = true;
-                    trueChars += typeof block?.data === "string" ? block.data.length : (safeJsonLength(block) ?? 0);
-                    return `[${typeof block?.type === "string" ? block.type : "block"}${typeof block?.mimeType === "string" ? `: ${block.mimeType}` : ""}]`;
-                })
-                    .join("\n")
-                : serialized;
-            const totalChars = Array.isArray(content) ? trueChars : serialized.length;
-            if (raw.length > MAX_TOOL_END_OUTPUT_CHARS) {
-                const t = trunc(raw);
-                return { output: t.text, truncated: true, totalChars };
-            }
-            if (!anyNonText) {
-                return { output: raw, truncated: false };
-            }
-            return { output: raw, truncated: true, totalChars };
-        };
-        const CC_DETAIL_TYPES = new Set([
-            "edit", "multiedit", "create", "update", "bash", "notebook-edit", "notebook", "text", "grep", "glob", "mcp",
-            "agent", "task", "task-list", "task-output", "memory-saved", "workflow-run",
-            "web-fetch", "web-search", "todo", "cron-create", "cron-delete", "cron-list", "image",
-            "task-stop", "tool-search", "memory-recall", "repo-map", "fork", "enter-plan-mode", "exit-plan-mode",
-        ]);
-        const structuredFrom = (result) => {
-            const details = result !== null && typeof result === "object" ? result.details : undefined;
-            if (details === null || typeof details !== "object")
-                return undefined;
-            const t = details.type;
-            if (typeof t !== "string" || !CC_DETAIL_TYPES.has(t))
-                return undefined;
-            try {
-                const serialized = JSON.stringify(details) ?? "";
-                if (serialized.length > MAX_TOOL_END_OUTPUT_CHARS * 4)
-                    return undefined;
-            }
-            catch {
-                return undefined;
-            }
-            return details;
-        };
         const onMessageUpdate = (event) => {
             const ev = event.assistantMessageEvent;
-            if (callStartAt === undefined)
-                callStartAt = Date.now();
+            if (rs.turn.callStartAt === undefined)
+                rs.turn.callStartAt = Date.now();
             if (ev.type === "text_delta" && ev.delta) {
-                if (firstTokenAt === undefined)
-                    firstTokenAt = Date.now();
+                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 (streamCancel && !budgetHit && (ev.type === "text_delta" || ev.type === "thinking_delta") && ev.delta) {
-                callOutputChars += ev.delta.length;
-                if (callOutputChars - lastStreamBudgetCheck >= 256) {
-                    lastStreamBudgetCheck = callOutputChars;
-                    if (projectedOverBudget()) {
-                        budgetHit = "exceeded";
+            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();
                     }
@@ -1294,55 +1205,54 @@ export class Runner {
             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 (degraded === undefined && m.role === "assistant") {
+            if (rs.degrade.degraded === undefined && m.role === "assistant") {
                 const deg = readDegradation(m);
                 if (deg)
-                    recordDegraded({ from: deg.from, to: deg.to, reason: deg.reason, atTurn: stats.turns + 1, ...(deg.chain && { chain: deg.chain }) });
+                    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)
-                    turnUsageMissing = true;
+                    rs.turn.turnUsageMissing = true;
                 const u = m.usage;
                 stats.tokens += u.totalTokens || 0;
-                const { totalInputTokens: turnInput, costMicroUsd: turnCostMicroUsd } = usageCostMicroUsd(cacheFamily, u, pricing);
+                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.costUsd += u.cost?.total || 0;
                 stats.costMicroUsd += turnCostMicroUsd;
-                turnUsage ??= { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costMicroUsd: 0 };
-                turnUsage.inputTokens += turnInput;
-                turnUsage.outputTokens += u.output || 0;
-                turnUsage.cacheReadTokens += u.cacheRead || 0;
-                turnUsage.cacheWriteTokens += u.cacheWrite || 0;
-                turnUsage.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, callStartAt !== undefined ? callEndAt - callStartAt : 0, {
+                    recordCallSample(prepared.callCapRef.state, u.output || 0, rs.turn.callStartAt !== undefined ? callEndAt - rs.turn.callStartAt : 0, {
                         contentValid: m.usageMissing === true && hasRealContent(m.content),
                     });
-                    if (callStartAt !== undefined && firstTokenAt !== undefined) {
-                        recordTtftSample(prepared.callCapRef.state, firstTokenAt - callStartAt);
+                    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(tracer, () => ({
+                emitTrace(rs.telemetry.tracer, () => ({
                     kind: "brain.call",
                     version: 1,
-                    taskId,
+                    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: callStartAt !== undefined ? callEndAt - callStartAt : 0,
-                    firstTokenMs: callStartAt !== undefined && firstTokenAt !== undefined ? firstTokenAt - callStartAt : undefined,
+                    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 } : {}),
@@ -1373,16 +1283,16 @@ export class Runner {
                         cacheRead: u.cacheRead || 0,
                     });
                     if (finding) {
-                        cacheBreakReported = true;
+                        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") {
-                turnStopReason = m.stopReason;
+                rs.turn.turnStopReason = m.stopReason;
             }
             if (m.role === "assistant" && m.errorMessage === WALLTIME_CUTOFF_MESSAGE) {
-                callCutoffs += 1;
+                rs.counters.callCutoffs += 1;
                 if (prepared.callCapRef)
                     prepared.callCapRef.finalizeMode = true;
                 if (!finalizeInjected) {
@@ -1404,16 +1314,16 @@ export class Runner {
                     ];
                     for (const { action, e } of observed) {
                         if (action === "cut")
-                            repetitionCuts += 1;
+                            rs.counters.repetitionCuts += 1;
                         else
-                            repetitionSpared += 1;
-                        if (repetitionEvents.length < REPETITION_EVENTS_CAP) {
-                            repetitionEvents.push({ turn: stats.turns + 1, action, rule: e.rule, period: e.period, reps: e.reps, segment: e.segment });
+                            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(tracer, () => ({
+                        emitTrace(rs.telemetry.tracer, () => ({
                             kind: "repetition.detected",
                             version: 1,
-                            taskId,
+                            taskId: rs.telemetry.taskId,
                             turn: stats.turns + 1,
                             action,
                             rule: e.rule,
@@ -1434,14 +1344,14 @@ export class Runner {
             }
             if (m.role === "assistant") {
                 const content = m.content;
-                if (attachState !== undefined)
-                    cadenceTurns = advanceCadenceClock(attachState, cadenceTurns, content, writeFamilyOf);
-                lastTurnHadToolCalls = Array.isArray(content) && content.some((c) => c?.type === "toolCall");
-            }
-            callStartAt = undefined;
-            firstTokenAt = undefined;
-            callOutputChars = 0;
-            lastStreamBudgetCheck = 0;
+                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;
@@ -1453,11 +1363,11 @@ export class Runner {
             startedToolCallIds.add(event.toolCallId);
             batchArgs?.set(event.toolCallId, event.args);
             stats.toolCalls += 1;
-            if (spec.finalVerification === true && !(finalVerifyInjections === 0 ? groundingSignalPreR9 : groundingSignalPostR9) && hasVerifiableStructureSignal(event.args)) {
-                if (finalVerifyInjections === 0)
-                    groundingSignalPreR9 = true;
+            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
-                    groundingSignalPostR9 = true;
+                    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 } : {}) });
@@ -1479,13 +1389,13 @@ export class Runner {
                 turnToolSpan.startMin = turnToolSpan.startMin === undefined ? toolStarted : Math.min(turnToolSpan.startMin, toolStarted);
                 turnToolSpan.endMax = turnToolSpan.endMax === undefined ? toolNow : Math.max(turnToolSpan.endMax, toolNow);
             }
-            if (!wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
-                wroteThisRun = true;
+            if (!rs.counters.wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
+                rs.counters.wroteThisRun = true;
             }
-            if (attachState !== undefined && !event.isError) {
+            if (rs.attach.attachState !== undefined && !event.isError) {
                 const det = event.result?.details;
                 if (det !== undefined)
-                    reduceToolEnd(attachState, det);
+                    reduceToolEnd(rs.attach.attachState, det);
             }
             if (postToolBatchHook !== undefined) {
                 if (prepared.blockedToolCalls.delete(event.toolCallId)) {
@@ -1503,10 +1413,10 @@ export class Runner {
                     batchArgs?.delete(event.toolCallId);
                 }
             }
-            emitTrace(tracer, () => ({
+            emitTrace(rs.telemetry.tracer, () => ({
                 kind: "tool.call",
                 version: 1,
-                taskId,
+                taskId: rs.telemetry.taskId,
                 name: event.toolName,
                 durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
                 ok: !event.isError,
@@ -1547,33 +1457,33 @@ export class Runner {
             }
             if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
                 if (event.isError) {
-                    outputErrorStreak += 1;
-                    if (outputErrorStreak > outputRetryCap) {
-                        outputInvalid = true;
+                    rs.degrade.outputErrorStreak += 1;
+                    if (rs.degrade.outputErrorStreak > rs.limits.outputRetryCap) {
+                        rs.degrade.outputInvalid = true;
                         void prepared.harness.abort();
                         prepared.abortController.abort();
                     }
                 }
                 else {
-                    outputErrorStreak = 0;
+                    rs.degrade.outputErrorStreak = 0;
                 }
             }
         };
         const onTurnEnd = () => {
             stats.turns += 1;
-            const stopExtra = turnStopReason !== undefined ? { stopReason: turnStopReason } : {};
-            queue.push(turnUsage
-                ? { type: "turn_end", usage: turnUsage, ...(turnUsageMissing ? { usageMissing: true } : {}), ...stopExtra, ...ident() }
+            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() });
-            turnUsageMissing = false;
-            turnStopReason = undefined;
+            rs.turn.turnUsageMissing = false;
+            rs.turn.turnStopReason = undefined;
             if (parentToolCallId !== undefined) {
                 const progress = {
                     type: "task_progress",
-                    taskId,
+                    taskId: rs.telemetry.taskId,
                     ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                     ...(subagentName ? { name: subagentName } : {}),
-                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - taskStart },
+                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                     status: "running",
                     ...ident(),
                 };
@@ -1584,37 +1494,37 @@ export class Runner {
                 catch {
                 }
             }
-            emitTrace(tracer, () => ({ kind: "turn.end", version: 1, taskId, turn: stats.turns, ts: Date.now() }));
-            turnUsage = undefined;
-            callStartAt = undefined;
-            firstTokenAt = undefined;
-            callOutputChars = 0;
-            lastStreamBudgetCheck = 0;
+            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 (effectiveMaxTurns !== undefined && effectiveMaxTurns > 0 && stats.turns >= effectiveMaxTurns) {
-                turnsExceeded = true;
+            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 (degraded === undefined &&
+                if (rs.degrade.degraded === undefined &&
                     spec.degrade &&
-                    degradeToModel &&
-                    maxCostMicroUsd !== undefined &&
-                    stats.costMicroUsd >= spec.degrade.atCostFraction * maxCostMicroUsd) {
-                    void prepared.harness.setModel(degradeToModel);
-                    recordDegraded({ from: prepared.model.id, to: degradeToModel.id, reason: "budget", atTurn: stats.turns }, degradeToModel);
+                    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 &&
-                        degradeToModel.maxTokens !== undefined &&
-                        (prepared.callCapRef.staticCapTokens === undefined || degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
-                        prepared.callCapRef.staticCapTokens = degradeToModel.maxTokens;
+                        rs.degrade.degradeToModel.maxTokens !== undefined &&
+                        (prepared.callCapRef.staticCapTokens === undefined || rs.degrade.degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
+                        prepared.callCapRef.staticCapTokens = rs.degrade.degradeToModel.maxTokens;
                     }
                 }
-                if (!budgetHit && overBudget()) {
-                    budgetHit = "exceeded";
+                if (!rs.limits.budgetHit && rs.budget.overBudget()) {
+                    rs.limits.budgetHit = "exceeded";
                     if (prepared.suspendForResource === undefined) {
                         void prepared.harness.abort();
                         prepared.abortController.abort();
@@ -1634,11 +1544,10 @@ export class Runner {
             stats.cachedTokens += u.cacheRead || 0;
             stats.cacheWriteTokens += u.cacheWrite || 0;
             stats.outputTokens += u.output || 0;
-            stats.costUsd += u.cost?.total || 0;
             stats.costMicroUsd += costMicroUsd;
             stats.compactionMicroUsd = (stats.compactionMicroUsd ?? 0) + costMicroUsd;
-            emitTrace(tracer, () => ({
-                kind: "brain.call", version: 1, taskId, model: m.id, provider: m.provider,
+            emitTrace(rs.telemetry.tracer, () => ({
+                kind: "brain.call", version: 1, taskId: rs.telemetry.taskId, model: m.id, provider: m.provider,
                 promptTokens: totalInputTokens, completionTokens: u.output || 0,
                 cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0,
                 latencyMs: 0, costMicroUsd, ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
@@ -1658,11 +1567,11 @@ export class Runner {
         const compactionBreaker = { failures: 0 };
         const compactionThroughputRef = {};
         const windowSafetyOptions = (mainModel) => ({
-            ...(maxCostMicroUsd !== undefined
+            ...(rs.budget.maxCostMicroUsd !== undefined
                 ? {
                     fallbackBudget: {
                         spentMicroUsd: () => stats.costMicroUsd,
-                        capMicroUsd: maxCostMicroUsd,
+                        capMicroUsd: rs.budget.maxCostMicroUsd,
                         mainInputPer1M: (this.deps.pricing?.[mainModel.id] ?? modelCostToPricing(mainModel.cost)).inputPer1M,
                     },
                 }
@@ -1678,10 +1587,10 @@ export class Runner {
                 : {}),
             onWindowSafety: (info) => {
                 if (info.kind === "fallback") {
-                    emitTrace(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.model_fallback",
                         version: 1,
-                        taskId,
+                        taskId: rs.telemetry.taskId,
                         contentTokens: info.contentTokens,
                         headroomTokens: info.headroomTokens ?? 0,
                         truncationRatio: info.truncationRatio,
@@ -1690,10 +1599,10 @@ export class Runner {
                     }));
                 }
                 else {
-                    emitTrace(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.clamp_disclosure",
                         version: 1,
-                        taskId,
+                        taskId: rs.telemetry.taskId,
                         truncationRatio: info.truncationRatio,
                         reason: info.reason ?? "tolerance",
                         ...(info.estCostMicroUsd !== undefined ? { estCostMicroUsd: info.estCostMicroUsd } : {}),
@@ -1710,13 +1619,13 @@ export class Runner {
                 if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
                     return [];
                 if (finalVerificationOn &&
-                    (finalVerifyInjections === 0 || (finalVerifyInjections === 1 && groundingSignalPreR9 && !groundingSignalPostR9)) &&
-                    wroteThisRun &&
+                    (rs.counters.finalVerifyInjections === 0 || (rs.counters.finalVerifyInjections === 1 && rs.counters.groundingSignalPreR9 && !rs.counters.groundingSignalPostR9)) &&
+                    rs.counters.wroteThisRun &&
                     prepared.outputRef.set !== true &&
                     !finalizeInjected &&
-                    !(effectiveMaxTurns !== undefined && effectiveMaxTurns > 0 && stats.turns >= effectiveMaxTurns - 1)) {
-                    finalVerifyInjections += 1;
-                    if (finalVerifyInjections === 2) {
+                    !(rs.limits.effectiveMaxTurns !== undefined && rs.limits.effectiveMaxTurns > 0 && stats.turns >= rs.limits.effectiveMaxTurns - 1)) {
+                    rs.counters.finalVerifyInjections += 1;
+                    if (rs.counters.finalVerifyInjections === 2) {
                         return [
                             {
                                 role: "user",
@@ -1860,7 +1769,7 @@ export class Runner {
                             minTokens: 0,
                             force: true,
                             overheadTokens: prepared.promptOverheadTokens,
-                            onInputTruncated: (info) => emitTrace(tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
+                            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() })),
                             workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
                                 ? {
                                     readFile: prepared.readTaskFile,
@@ -1903,12 +1812,12 @@ export class Runner {
                             if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                                 const pd = comp.phaseDurations;
                                 const pdDur = comp.durationMs;
-                                emitTrace(tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
+                                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
                             }
                             prepared.cacheBreakDetector?.notifyCompaction();
-                            if (attachState !== undefined) {
-                                attachState.postCompactPending = true;
-                                rebaseCadenceWindows(attachState, cadenceTurns);
+                            if (rs.attach.attachState !== undefined) {
+                                rs.attach.attachState.postCompactPending = true;
+                                rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
                             }
                         }
                         else {
@@ -1964,31 +1873,31 @@ export class Runner {
                 }
                 if (due) {
                     void prepared.harness.steer(due.text, { engineMinted: true }).catch(() => { });
-                    nudgesSent += 1;
+                    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 && !preemptIgnoredReported) {
-                preemptIgnoredReported = true;
-                emitTrace(tracer, () => ({ kind: "preempt.ignored", version: 1, taskId, ts: Date.now() }));
+            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 &&
-                (turnsExceeded || budgetHit !== undefined || walltimeHit || preemptHit) &&
+                (rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || walltimeHit || preemptHit) &&
                 prepared.suspendRef.token === undefined) {
                 const reason = preemptHit
                     ? "preempt"
-                    : budgetHit !== undefined
+                    : rs.limits.budgetHit !== undefined
                         ? "budget"
                         : walltimeHit
                             ? "walltime"
                             : "turns";
-                const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - taskStartMonotonic) };
+                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)) {
-                    turnsExceeded = false;
-                    budgetHit = undefined;
+                    rs.limits.turnsExceeded = false;
+                    rs.limits.budgetHit = undefined;
                 }
                 else {
                     void prepared.harness.abort();
@@ -2020,7 +1929,7 @@ export class Runner {
                     await prepared.suspendForReview(reason);
                     return undefined;
                 }
-                emitTrace(tracer, () => ({ kind: "review.dropped", version: 1, taskId, ts: Date.now() }));
+                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();
@@ -2033,18 +1942,18 @@ export class Runner {
             }
             let boundaryAttachmentBytes = 0;
             let attachmentsPayload;
-            if ((dateState !== undefined || instrState !== undefined || attachState !== undefined) &&
+            if ((rs.attach.dateState !== undefined || rs.attach.instrState !== undefined || rs.attach.attachState !== undefined) &&
                 !boundarySteered &&
                 !finalizeInjected &&
-                finalVerifyInjections === 0 &&
+                rs.counters.finalVerifyInjections === 0 &&
                 !prepared.abortController.signal.aborted) {
                 const due = [];
-                if (attachState !== undefined) {
-                    const changedFilesOn = Boolean(attachmentsCfg?.changedFiles);
+                if (rs.attach.attachState !== undefined) {
+                    const changedFilesOn = Boolean(rs.attach.attachmentsCfg?.changedFiles);
                     let changed;
                     if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
-                        const maxFiles = typeof attachmentsCfg?.changedFiles === "object"
-                            ? (attachmentsCfg.changedFiles.maxFiles ?? CHANGED_FILES_MAX)
+                        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([
@@ -2055,53 +1964,53 @@ export class Runner {
                             }),
                         ]);
                         for (const p of scan.evicted)
-                            attachState.surfacedMtime.delete(p);
+                            rs.attach.attachState.surfacedMtime.delete(p);
                         changed = scan.changed;
                     }
-                    const backgroundTasksOn = attachmentsCfg?.backgroundTasks === true;
-                    const bgTasks = backgroundTasksOn && attachState.postCompactPending ? prepared.listBackgroundTasks() : undefined;
-                    const toolsDeltaOn = attachmentsCfg?.toolsDelta === true;
+                    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 = attachmentsCfg?.mcpInstructions === true;
+                    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 = attachmentsCfg?.budgetUsd === true && maxCostMicroUsd !== undefined && lastTurnHadToolCalls;
-                    due.push(...collectDueAttachments(attachState, {
+                    const budgetUsdOn = rs.attach.attachmentsCfg?.budgetUsd === true && rs.budget.maxCostMicroUsd !== undefined && rs.turn.lastTurnHadToolCalls;
+                    due.push(...collectDueAttachments(rs.attach.attachState, {
                         turn: stats.turns,
-                        cadenceTurn: cadenceTurns,
+                        cadenceTurn: rs.counters.cadenceTurns,
                         todoMounted: todoToolMounted,
                         taskListMounted: taskToolsMounted,
                         planActive: prepared.planModeRef.active,
                         config: {
-                            todoReminder: attachmentsCfg?.todoReminder === true,
-                            ...(attachmentsCfg?.todoReminderMode !== undefined ? { todoReminderMode: attachmentsCfg.todoReminderMode } : {}),
+                            todoReminder: rs.attach.attachmentsCfg?.todoReminder === true,
+                            ...(rs.attach.attachmentsCfg?.todoReminderMode !== undefined ? { todoReminderMode: rs.attach.attachmentsCfg.todoReminderMode } : {}),
                             changedFiles: changedFilesOn,
-                            planModeReminder: attachmentsCfg?.planModeReminder === true,
+                            planModeReminder: rs.attach.attachmentsCfg?.planModeReminder === true,
                             budgetUsd: budgetUsdOn,
                             backgroundTasks: backgroundTasksOn,
                             toolsDelta: toolsDeltaOn,
-                            agentListing: agentListingOn,
-                            skillsListing: skillsListingOn,
+                            agentListing: rs.attach.agentListingOn,
+                            skillsListing: rs.attach.skillsListingOn,
                             mcpInstructions: mcpInstructionsOn,
                         },
                         ...(changed !== undefined ? { changedFiles: changed } : {}),
-                        ...(budgetUsdOn && maxCostMicroUsd !== undefined
-                            ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: maxCostMicroUsd / 1e6 } }
+                        ...(budgetUsdOn && rs.budget.maxCostMicroUsd !== undefined
+                            ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: rs.budget.maxCostMicroUsd / 1e6 } }
                             : {}),
                         ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
                         ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
-                        ...(agentListingOn && prepared.agentListing !== undefined
+                        ...(rs.attach.agentListingOn && prepared.agentListing !== undefined
                             ? {
                                 agentListing: prepared.agentListing.entries,
                                 agentToolName: prepared.agentListing.toolName,
                                 ...(prepared.agentListing.models !== undefined ? { agentModels: prepared.agentListing.models } : {}),
                             }
                             : {}),
-                        ...(skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
+                        ...(rs.attach.skillsListingOn && prepared.skillsListing !== undefined ? { skillsListing: prepared.skillsListing.entries } : {}),
                         ...(mcpAdds !== undefined || mcpRemovals !== undefined
                             ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
                             : {}),
@@ -2121,41 +2030,41 @@ export class Runner {
                         due.some((a) => a.source === "mcp_dropped_tools" && a.body === renderMcpDroppedTools(mcpDropped))) {
                         prepared.mcp.droppedTools.splice(0, mcpDropped.length);
                     }
-                    if (agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
+                    if (rs.attach.agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
                         const listing = prepared.agentListing;
-                        const intactBody = renderAgentListingDelta(attachState, listing.entries, listing.toolName, listing.models);
+                        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(attachState, listing.entries, listing.models);
+                            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 (skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
+                    if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined && due.some((a) => a.source === "skills_listing")) {
                         const listing = prepared.skillsListing;
-                        const intactBody = renderSkillsListingDelta(attachState, listing.entries);
+                        const intactBody = renderSkillsListingDelta(rs.attach.attachState, listing.entries);
                         if (intactBody !== undefined && due.some((a) => a.source === "skills_listing" && a.body === intactBody)) {
-                            commitSkillsListing(attachState, listing.entries);
+                            commitSkillsListing(rs.attach.attachState, listing.entries);
                             prepared.announcedListingsRef.skills = listing.entries.map((e) => e.name);
                             await prepared.session.appendAnnouncedListing(prepared.announcedListingsRef).catch(() => undefined);
                         }
                     }
                 }
-                if (dateState !== undefined && lastTurnHadToolCalls) {
+                if (rs.attach.dateState !== undefined && rs.turn.lastTurnHadToolCalls) {
                     const today = prepared.dateChange.today();
-                    const cand = collectDateChange(dateState, today);
+                    const cand = collectDateChange(rs.attach.dateState, today);
                     if (cand !== undefined) {
                         due.unshift(cand);
-                        dateState.announcedDate = today;
+                        rs.attach.dateState.announcedDate = today;
                     }
                 }
-                if (instrState !== undefined && instrProbe !== undefined && lastTurnHadToolCalls) {
+                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([
-                            instrProbe(prepared.instructionSources),
+                            rs.attach.instrProbe(prepared.instructionSources),
                             new Promise((resolve) => {
                                 const t = setTimeout(() => resolve(null), PROBE_CEILING_MS);
                                 t.unref?.();
@@ -2165,10 +2074,10 @@ export class Runner {
                     catch {
                         probed = null;
                     }
-                    const cand = collectInstructionsChange(instrState, probed);
+                    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(instrState, cand.announced);
+                        commitInstructionsChange(rs.attach.instrState, cand.announced);
                     }
                 }
                 if (due.length > 0) {
@@ -2186,7 +2095,7 @@ export class Runner {
                 const batch = toolBatch;
                 toolBatch = [];
                 batchArgs?.clear();
-                if (!boundarySteered && !finalizeInjected && finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
+                if (!boundarySteered && !finalizeInjected && rs.counters.finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
                     try {
                         const r = await postToolBatchHook(batch);
                         if (r?.additionalContext) {
@@ -2220,17 +2129,17 @@ export class Runner {
                 prepared.suspendRef.token !== undefined ||
                 prepared.reviewRef.token !== undefined) {
                 if (forceManual) {
-                    emitTrace(tracer, () => ({ kind: "compaction.mooted", version: 1, taskId, reason: "task_ending", ts: Date.now() }));
+                    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(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.failed",
                         version: 1,
-                        taskId,
+                        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(),
@@ -2275,7 +2184,7 @@ export class Runner {
             const trimPressure = trimPressureArmed && !trimForceBackoff;
             let manualOutcome = "failed";
             if (finalizeInjected && forceManual) {
-                emitTrace(tracer, () => ({ kind: "compaction.manual_in_finalize", version: 1, taskId, ts: Date.now() }));
+                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.manual_in_finalize", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
             }
             const manualInstructions = claimedManual?.instructions;
             try {
@@ -2297,7 +2206,7 @@ export class Runner {
                     ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
                     minTokens: forceManual ? 0 : compactionFloor,
                     force: forceManual,
-                    onInputTruncated: (info) => emitTrace(tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
+                    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
@@ -2318,10 +2227,10 @@ export class Runner {
                     ...this.compactionHookOptions(spec, prepared.sessionId, trimPressure ? "forced" : forceManual ? "manual" : "auto"),
                 });
                 if (comp.blocked) {
-                    emitTrace(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.blocked",
                         version: 1,
-                        taskId,
+                        taskId: rs.telemetry.taskId,
                         trigger: forceManual ? "manual" : "auto",
                         ts: Date.now(),
                     }));
@@ -2335,10 +2244,10 @@ export class Runner {
                 }
                 if (comp.suppressedByFloor) {
                     const s = comp.suppressedByFloor;
-                    emitTrace(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.suppressed",
                         version: 1,
-                        taskId,
+                        taskId: rs.telemetry.taskId,
                         estTokens: s.estTokens,
                         floor: s.floor,
                         ts: Date.now(),
@@ -2347,10 +2256,10 @@ export class Runner {
                 manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
                 if (forceManual && !comp.compacted && !comp.blocked) {
                     if (comp.disabled) {
-                        emitTrace(tracer, () => ({ kind: "compaction.disabled", version: 1, taskId, ts: Date.now() }));
+                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.disabled", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
                     }
                     else {
-                        emitTrace(tracer, () => ({ kind: "compaction.noop", version: 1, taskId, ts: Date.now() }));
+                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.noop", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
                     }
                 }
                 if (comp.compacted && !forceManual) {
@@ -2379,24 +2288,23 @@ export class Runner {
                     if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                         const pd = comp.phaseDurations;
                         const pdDur = comp.durationMs;
-                        emitTrace(tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
+                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
                     }
                     prepared.cacheBreakDetector?.notifyCompaction();
-                    if (attachState !== undefined) {
-                        attachState.postCompactPending = true;
-                        rebaseCadenceWindows(attachState, cadenceTurns);
+                    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);
                     }
-                    await this.maybeDynamicRecall(prepared);
                 }
             }
             catch (err) {
                 const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
                 if (manualCancelAbort) {
-                    emitTrace(tracer, () => ({ kind: "compaction.mooted", version: 1, taskId, reason: "cancelled", ts: Date.now() }));
+                    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) {
@@ -2405,10 +2313,10 @@ export class Runner {
                         compactionBreaker.failures += 1;
                     this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
                     const msg = String(err instanceof Error ? err.message : err);
-                    emitTrace(tracer, () => ({
+                    emitTrace(rs.telemetry.tracer, () => ({
                         kind: "compaction.failed",
                         version: 1,
-                        taskId,
+                        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)"
@@ -2462,13 +2370,13 @@ export class Runner {
                 const walltimeExhaustedResume = effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0;
                 if (!walltimeExhaustedResume && resume.outcome.gate !== "wake") {
                     await this.applyResumeDecision(prepared, resume, (e) => queue.push(e), emitCommitted, (toolName, details) => {
-                        if (attachState === undefined)
+                        if (rs.attach.attachState === undefined)
                             return;
                         const family = writeFamilyOf(toolName);
                         if (family !== undefined)
-                            stampWriteAnchor(attachState, family, cadenceTurns);
+                            stampWriteAnchor(rs.attach.attachState, family, rs.counters.cadenceTurns);
                         if (details !== undefined)
-                            reduceToolEnd(attachState, details);
+                            reduceToolEnd(rs.attach.attachState, details);
                     }, (toolCallId) => {
                         startedToolCallIds.add(toolCallId);
                         if (resume !== undefined && resume.cp.pendingAction.kind === "tool_approval" && toolCallId === resume.cp.pendingAction.toolCallId) {
@@ -2482,8 +2390,8 @@ export class Runner {
                     void prepared.harness.abort();
                     prepared.abortController.abort();
                 }
-                else if (maxCostMicroUsd !== undefined && maxCostMicroUsd <= 0) {
-                    budgetHit = "exceeded";
+                else if (rs.budget.maxCostMicroUsd !== undefined && rs.budget.maxCostMicroUsd <= 0) {
+                    rs.limits.budgetHit = "exceeded";
                 }
                 else {
                     let continuation = resumeContinuation(resume);
@@ -2524,9 +2432,9 @@ export class Runner {
                     }
                 }
                 const firstFrames = [];
-                if (attachState !== undefined) {
-                    const attach = attachState;
-                    if (agentListingOn && prepared.agentListing !== undefined) {
+                if (rs.attach.attachState !== undefined) {
+                    const attach = rs.attach.attachState;
+                    if (rs.attach.agentListingOn && prepared.agentListing !== undefined) {
                         const listing = prepared.agentListing;
                         const body = renderAgentListingDelta(attach, listing.entries, listing.toolName, listing.models);
                         if (body !== undefined) {
@@ -2542,7 +2450,7 @@ export class Runner {
                             });
                         }
                     }
-                    if (skillsListingOn && prepared.skillsListing !== undefined) {
+                    if (rs.attach.skillsListingOn && prepared.skillsListing !== undefined) {
                         const listing = prepared.skillsListing;
                         const body = renderSkillsListingDelta(attach, listing.entries);
                         if (body !== undefined) {
@@ -2560,7 +2468,7 @@ export class Runner {
                         effectiveObjective = `${firstFrames.map((f) => `<system-reminder>\n${sanitizeUntrustedText(f.body)}\n</system-reminder>`).join("\n")}\n${effectiveObjective}`;
                     }
                 }
-                const precallMicroUsd = maxCostMicroUsd === undefined
+                const precallMicroUsd = rs.budget.maxCostMicroUsd === undefined
                     ? 0
                     : computeCostMicroUsd({
                         totalInputTokens: Math.ceil(effectiveObjective.length / 4),
@@ -2568,12 +2476,12 @@ export class Runner {
                         cacheWriteTokens: 0,
                         cacheWriteTokensLong: 0,
                         outputTokens: prepared.model.maxTokens ?? 4096,
-                    }, pricing);
-                const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? remainingMicroUsd : maxCostMicroUsd;
+                    }, rs.telemetry.pricing);
+                const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? rs.budget.remainingMicroUsd : rs.budget.maxCostMicroUsd;
                 if (promptBlocked) {
                 }
                 else if (precallCeilingMicroUsd !== undefined && precallMicroUsd > precallCeilingMicroUsd) {
-                    budgetHit = "precall";
+                    rs.limits.budgetHit = "precall";
                 }
                 else if (effectiveTimeoutMs !== undefined && effectiveTimeoutMs <= 0) {
                     timeout.fired = true;
@@ -2637,7 +2545,7 @@ export class Runner {
         const reviewPaused = prepared.reviewRef.token !== undefined && prepared.reviewRef.gate !== undefined;
         const durablyPaused = suspended || reviewPaused;
         const interrupted = !durablyPaused &&
-            (threw !== undefined || timeout.fired || turnsExceeded || budgetHit !== undefined || abortedLive || final?.stopReason === "aborted");
+            (threw !== undefined || timeout.fired || rs.limits.turnsExceeded || rs.limits.budgetHit !== undefined || abortedLive || final?.stopReason === "aborted");
         if (interrupted) {
             try {
                 const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects, undefined, startedToolCallIds);
@@ -2662,8 +2570,8 @@ export class Runner {
                 });
             }
         }
-        if (attachState?.postCompactPending === true && attachmentsCfg?.backgroundTasks === true) {
-            emitTrace(tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId, ts: Date.now() }));
+        if (rs.attach.attachState?.postCompactPending === true && rs.attach.attachmentsCfg?.backgroundTasks === true) {
+            emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
         }
         const comp = await this.finish(spec, prepared, {
             skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
@@ -2691,7 +2599,7 @@ export class Runner {
                 if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
                     const pd = comp.phaseDurations;
                     const pdDur = comp.durationMs;
-                    emitTrace(tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
+                    emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
                 }
                 prepared.cacheBreakDetector?.notifyCompaction();
             }
@@ -2700,7 +2608,6 @@ export class Runner {
                     tokens: prepared.nestedStats.tokens,
                     turns: prepared.nestedStats.turns,
                     tasks: prepared.nestedStats.tasks,
-                    costUsd: prepared.nestedStats.costUsd || undefined,
                     costMicroUsd: prepared.nestedStats.costMicroUsd || undefined,
                 };
             }
@@ -2710,9 +2617,9 @@ export class Runner {
                     this.deps.onError?.(new Error(`prompt-cache: usage/api mismatch — cachedTokens (${stats.cachedTokens}) > promptTokens (${stats.promptTokens}); the cache family is likely wrong. Does model.api match the brain serving it? Override with model.params.promptCacheFamily = "input-includes-cached" | "input-excludes-cached".`), { phase: "prompt-cache", sessionId: prepared.sessionId });
                 }
                 stats.cacheHitRate = Math.min(1, rawHit);
-                if (!cacheBreakReported && stats.turns >= 2 && stats.promptTokens >= 8000 && stats.cacheHitRate < 0.15) {
-                    const cause = degraded
-                        ? `a mid-task model switch (${degraded.from} → ${degraded.to}, degradation) reset the prefix cache — this is the likely cause`
+                if (!rs.telemetry.cacheBreakReported && stats.turns >= 2 && stats.promptTokens >= 8000 && stats.cacheHitRate < 0.15) {
+                    const cause = rs.degrade.degraded
+                        ? `a mid-task model switch (${rs.degrade.degraded.from} → ${rs.degrade.degraded.to}, degradation) reset the prefix cache — this is the likely cause`
                         : `the cacheable prefix looks unstable. Keep volatile content (memory/timestamps/ids) out of the prompt prefix and tool order stable, or it's a server-side/TTL miss`;
                     this.deps.onError?.(new Error(`prompt-cache: low prefix-cache hit rate ${(stats.cacheHitRate * 100).toFixed(0)}% over ${stats.turns} turns (${stats.promptTokens} prompt tokens) — ${cause}. See design/09.`), { phase: "prompt-cache", sessionId: prepared.sessionId });
                 }
@@ -2720,7 +2627,6 @@ export class Runner {
             if (prepared.resourceLedger &&
                 (resume?.cp.gate.kind === "resource_limit" || prepared.suspendRef.gate?.kind === "resource_limit")) {
                 stats.costMicroUsd += prepared.resourceLedger.spentMicroUsd;
-                stats.costUsd += prepared.resourceLedger.spentMicroUsd / 1e6;
                 stats.tokens += prepared.resourceLedger.spentTokens;
                 stats.turns += prepared.resourceLedger.spentTurns;
             }
@@ -2736,34 +2642,34 @@ export class Runner {
             const toolCuts = prepared.callCapRef?.toolCuts ?? 0;
             const pendingCutTools = prepared.callCapRef?.pendingCutTools ?? 0;
             const toolCutKills = prepared.cutKills?.kills ?? 0;
-            if (finalizeInjected || nudgesSent > 0 || capShrinks > 0 || callCutoffs > 0 || toolClamps > 0 || toolCuts > 0 || toolCutKills > 0 || pendingCutTools > 0 || finalVerifyInjections > 0 || attachmentsInjected > 0 || repetitionCuts > 0 || repetitionSpared > 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) {
                 stats.mechanisms = {
                     ...(finalizeInjected ? { finalizeInjected: true } : {}),
-                    ...(nudgesSent > 0 ? { nudgesSent } : {}),
+                    ...(rs.counters.nudgesSent > 0 ? { nudgesSent: rs.counters.nudgesSent } : {}),
                     ...(capShrinks > 0 ? { capShrinks } : {}),
-                    ...(callCutoffs > 0 ? { callCutoffs } : {}),
+                    ...(rs.counters.callCutoffs > 0 ? { callCutoffs: rs.counters.callCutoffs } : {}),
                     ...(toolClamps > 0 ? { toolClamps } : {}),
                     ...(toolCuts > 0 ? { toolCuts } : {}),
                     ...(toolCutKills > 0 ? { toolCutKills } : {}),
                     ...(pendingCutTools > 0 ? { pendingCutTools } : {}),
-                    ...(finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
-                    ...(finalVerifyInjections > 0 ? { finalVerifyInjections } : {}),
+                    ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
+                    ...(rs.counters.finalVerifyInjections > 0 ? { finalVerifyInjections: rs.counters.finalVerifyInjections } : {}),
                     ...(attachmentsInjected > 0 ? { attachmentsInjected } : {}),
-                    ...(repetitionCuts > 0 ? { repetitionCuts } : {}),
-                    ...(repetitionSpared > 0 ? { repetitionSpared } : {}),
-                    ...(repetitionEvents.length > 0 ? { repetitionEvents } : {}),
+                    ...(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 } : {}),
                 };
             }
             const result = assembleResult(spec, prepared.sessionId, final, stats, {
                 threw,
                 model: prepared.model.id,
                 abortedForTimeout: timeout.fired,
-                abortedForTurns: turnsExceeded,
+                abortedForTurns: rs.limits.turnsExceeded,
                 abortedLive,
-                budgetHit,
+                budgetHit: rs.limits.budgetHit,
                 blockedReason: prepared.blockedRef.reason,
                 conflict: prepared.conflictRef.hit,
-                outputInvalid,
+                outputInvalid: rs.degrade.outputInvalid,
                 suspendLoop: prepared.suspendLoopRef.hit,
                 suspendRef: prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined
                     ? { token: prepared.suspendRef.token, gate: prepared.suspendRef.gate }
@@ -2815,8 +2721,8 @@ export class Runner {
                 final.errorMessage !== DEGENERATE_MESSAGE &&
                 final.errorMessage !== WALLTIME_CUTOFF_MESSAGE &&
                 threw === undefined &&
-                budgetHit === undefined &&
-                !outputInvalid &&
+                rs.limits.budgetHit === undefined &&
+                !rs.degrade.outputInvalid &&
                 !prepared.suspendLoopRef.hit &&
                 !abortedLive &&
                 result.errorCode !== "conflict") {
@@ -2835,8 +2741,8 @@ export class Runner {
                     }
                 }
             }
-            if (degraded)
-                result.degraded = degraded;
+            if (rs.degrade.degraded)
+                result.degraded = rs.degrade.degraded;
             if (prepared.outputRef.set)
                 result.structuredOutput = prepared.outputRef.value;
             const committedToken = prepared.suspendRef.token ?? prepared.reviewRef.token;
@@ -2867,16 +2773,16 @@ export class Runner {
             }
             if (prepared.memoryEngineSession)
                 await prepared.memoryEngineSession.harvest();
-            emitTrace(tracer, () => ({
+            emitTrace(rs.telemetry.tracer, () => ({
                 kind: "task.end",
                 version: 1,
-                taskId,
+                taskId: rs.telemetry.taskId,
                 status: result.status,
                 errorCode: result.errorCode,
                 turns: stats.turns,
                 tokens: stats.tokens,
                 costMicroUsd: stats.costMicroUsd,
-                durationMs: Date.now() - taskStart,
+                durationMs: Date.now() - rs.telemetry.taskStart,
                 ...(prepared.outputRef.set ? { hasStructuredOutput: true } : {}),
                 ...(stats.mechanisms !== undefined
                     ? { mechanisms: (({ repetitionEvents: _events, ...scalars }) => scalars)(stats.mechanisms) }
@@ -2891,10 +2797,10 @@ export class Runner {
             if (parentToolCallId !== undefined && (result.status === "completed" || result.status === "failed" || result.status === "timeout" || result.status === "blocked")) {
                 const terminalTick = {
                     type: "task_progress",
-                    taskId,
+                    taskId: rs.telemetry.taskId,
                     ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
                     ...(subagentName ? { name: subagentName } : {}),
-                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - taskStart },
+                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - rs.telemetry.taskStart },
                     status: result.status === "completed" ? "completed" : "failed",
                     ...ident(),
                 };
@@ -2910,9 +2816,6 @@ export class Runner {
             if (spec.rewindFiles && result.status === "completed") {
                 await this.snapshotTurn(prepared);
             }
-            if (prepared.consolidation && prepared.consolidation.notes.length > 0) {
-                onConsolidation(this.consolidateMemory(spec, prepared, result));
-            }
             if (spec.suggestNextPrompts && result.status === "completed") {
                 onSuggestions(this.suggestNextPrompts(spec, prepared, result));
             }
@@ -2927,8 +2830,8 @@ export class Runner {
                 await defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default", sessionId: prepared.sessionId }, {
                     source: abortedLive &&
                         !timeout.fired &&
-                        !turnsExceeded &&
-                        budgetHit === undefined &&
+                        !rs.limits.turnsExceeded &&
+                        rs.limits.budgetHit === undefined &&
                         prepared.suspendRef.token === undefined &&
                         prepared.reviewRef.token === undefined
                         ? "user"
@@ -2981,67 +2884,6 @@ export class Runner {
             await this.teardownOwnedEnv(prepared);
         }
     }
-    async consolidateMemory(spec, prepared, result) {
-        const consolidation = prepared.consolidation;
-        if (!consolidation || !this.deps.memoryStore) {
-            return;
-        }
-        const { scope, notes, settings } = consolidation;
-        const onWarn = (err) => {
-            try {
-                this.deps.onError?.(err, { phase: "memory", sessionId: prepared.sessionId });
-            }
-            catch {
-            }
-        };
-        const ac = new AbortController();
-        const timer = settings.timeoutSec > 0 ? setTimeout(() => ac.abort(), settings.timeoutSec * 1000) : undefined;
-        timer?.unref?.();
-        try {
-            let model = prepared.model;
-            let thinking = prepared.thinking;
-            try {
-                const resolved = resolveTaskModel({ modelRole: settings.role, roles: spec.roles }, this.deps);
-                model = resolved.model;
-                thinking = resolved.thinking;
-            }
-            catch {
-            }
-            const pricing = this.deps.pricing?.[model.id] ?? modelCostToPricing(model.cost);
-            const stats = await runMemoryConsolidation({
-                store: this.deps.memoryStore,
-                scope,
-                notes,
-                band: settings.band,
-                searchLimit: settings.searchLimit,
-                maxNotes: settings.maxNotes,
-                onWarn,
-                llm: {
-                    brain: this.deps.brain,
-                    model,
-                    pricing,
-                    thinking,
-                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                    signal: ac.signal,
-                },
-            });
-            await advanceCursorAfterInline(this.deps.memoryStore, scope, stats?.consolidatedIds ?? [], stats?.addedIds ?? [], stats?.failedIds ?? [], onWarn);
-            if (stats) {
-                result.stats.memory = { tokens: stats.tokens, costMicroUsd: stats.costMicroUsd, applied: stats.applied };
-                if (result.stats.costBreakdown) {
-                    result.stats.costBreakdown.memoryConsolidationMicroUsd = stats.costMicroUsd;
-                }
-            }
-        }
-        catch (err) {
-            onWarn(err);
-        }
-        finally {
-            if (timer) {
-                clearTimeout(timer);
-            }
-        }
-    }
     async suggestNextPrompts(spec, prepared, result) {
         const cfg = typeof spec.suggestNextPrompts === "object" ? spec.suggestNextPrompts : {};
         const count = cfg.count && cfg.count > 0 ? Math.min(cfg.count, SUGGESTIONS_MAX_COUNT) : SUGGESTIONS_DEFAULT_COUNT;
@@ -3471,40 +3313,6 @@ export class Runner {
             consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
         };
     }
-    async maybeDynamicRecall(prepared) {
-        const dr = prepared.dynamicRecall;
-        if (!dr)
-            return;
-        try {
-            const cfg = this.deps.dynamicRecall;
-            const { messages } = await prepared.session.buildContext();
-            const query = buildRecallQuery(messages, cfg?.recentMessageWindow, cfg?.maxQueryChars);
-            if (query.length === 0)
-                return;
-            const outcome = await runDynamicRecall({
-                store: this.deps.memoryStore,
-                scopes: dr.scopes,
-                selector: dr.selector,
-                query,
-                recentTools: dr.recentTools,
-                maxSelected: this.deps.memoryRecall?.maxSelected,
-                maxLinked: this.deps.memoryRecall?.maxLinked,
-                timeoutMs: this.deps.memoryRecall?.timeoutMs,
-                signal: prepared.abortController.signal,
-                priorSurfacedIds: dr.surfacedIds,
-                priorSurfacedKeys: dr.surfacedKeys,
-            });
-            if (!outcome.block)
-                return;
-            for (const id of outcome.surfacedIds)
-                dr.surfacedIds.add(id);
-            for (const k of outcome.surfacedKeys)
-                dr.surfacedKeys.add(k);
-            await prepared.harness.steer(outcome.block, { provenance: "engine-note" });
-        }
-        catch {
-        }
-    }
     compactionHookOptions(spec, sessionId, trigger) {
         const hooks = spec.hooks ?? this.deps.hooks;
         const pre = hooks?.preCompact;