@sema-agent/core 1.279.0

package/dist/core/runner/runtask.js

@@ -0,0 +1,2703 @@
+import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, uuidv7 } from "../../internal/harness.js";
+import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, winnerFromOutcome, } from "../checkpoint-store.js";
+import { estimateCycleMs, recordCallSample, recordToolSample, writeoutCushionMs } from "./call-cap.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
+import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
+import { emitTrace } from "../trace.js";
+import { emitTaskOutcome } from "../task-outcome.js";
+import { DEGENERATE_MESSAGE } from "../../brain/repetition.js";
+import { WALLTIME_CUTOFF_MESSAGE } from "../../brain/walltime.js";
+import { primaryActivityArg } from "../arg-summary.js";
+import { resolveReasoning } from "../../brain/reasoning.js";
+import { readDegradation } from "../../brain/degrading.js";
+import { runWithBrainTelemetry, runWithStatusSink } from "../../brain/status-sink.js";
+import { expandTiers, resolveModel, resolveTaskModel } from "../roles.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";
+import { OUTPUT_TOOL_NAME, resolveOutputRetries } from "./synthetic-tools.js";
+import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
+import { assembleResult, errorCodeOf } from "./assemble-result.js";
+import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, advanceCadenceClock, agentListingDeltaHeader, agentListingInitialHeader, collectDueAttachments, commitAgentListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
+import { prepareTask } from "./prepare-task.js";
+import { hasVerifiableStructureSignal } from "./grounding-signal.js";
+import { hasDestroy, isIsolated } from "../remote-env.js";
+import { hasBackgroundShell } from "../background-shell.js";
+import { formatHookFeedback } from "../hooks.js";
+import { delimitUntrusted, inlineUntrusted, sanitizeUntrustedText } from "../untrusted-text.js";
+import { reconcileInterruptedSession } from "../session-reconcile.js";
+import { RunnerSharedToolResultStore } from "../tool-result-store.js";
+import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
+import { canonicalToolName } from "../tool-name-aliases.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 = 500;
+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;
+    if (content === undefined || content === null)
+        return undefined;
+    let text;
+    if (typeof content === "string") {
+        text = content;
+    }
+    else if (Array.isArray(content)) {
+        text = content
+            .map((c) => (c !== null && typeof c === "object" && typeof c.text === "string" ? c.text : ""))
+            .filter((t) => t.length > 0)
+            .join("\n");
+    }
+    else {
+        try {
+            text = JSON.stringify(content) ?? "";
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (text.length === 0)
+        return undefined;
+    return text.length > BATCH_RESPONSE_MAX_CHARS
+        ? `${text.slice(0, BATCH_RESPONSE_MAX_CHARS)}…[+${text.length - BATCH_RESPONSE_MAX_CHARS} chars truncated]`
+        : text;
+}
+function clipToByteBudget(s, maxBytes) {
+    if (Buffer.byteLength(s, "utf8") <= maxBytes)
+        return s;
+    let lo = 0;
+    let hi = s.length;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (Buffer.byteLength(s.slice(0, mid), "utf8") <= maxBytes)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return s.slice(0, lo);
+}
+const BATCH_CONTEXT_MIN_KEEP_BYTES = 160;
+const BATCH_TRUNCATION_MARKER = "\n…[truncated]";
+const SUGGESTIONS_DEFAULT_COUNT = 3;
+const SUGGESTIONS_MAX_COUNT = 8;
+const SUGGESTIONS_TIMEOUT_MS = 30_000;
+const SUGGESTIONS_TRANSCRIPT_MESSAGES = 12;
+const SNAPSHOT_TIMEOUT_MS = 30_000;
+const SNAPSHOT_TOO_LARGE_TTL_MS = 30 * 60_000;
+function resolveMaxTurns(limits) {
+    if (limits?.maxTurns !== undefined) {
+        return limits.maxTurns;
+    }
+    if (limits?.timeoutSec !== undefined && limits.timeoutSec > 0) {
+        return undefined;
+    }
+    return DEFAULT_MAX_TURNS;
+}
+const DEFERRED_REISSUE = "[DEFERRED] This tool call shared a batch with a call that suspended for durable approval, so it was " +
+    "NOT executed on resume. If you still need it, issue it again now.";
+function deepJsonEqual(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b || a === null || b === null || typeof a !== "object") {
+        return false;
+    }
+    const aArr = Array.isArray(a);
+    const bArr = Array.isArray(b);
+    if (aArr !== bArr)
+        return false;
+    if (aArr && bArr) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => deepJsonEqual(v, b[i]));
+    }
+    const ao = a;
+    const bo = b;
+    const aKeys = Object.keys(ao);
+    const bKeys = Object.keys(bo);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepJsonEqual(ao[k], bo[k]));
+}
+function sameWinner(a, b) {
+    return a.boundCallId === b.boundCallId && a.decision === b.decision && deepJsonEqual(a.updatedInput, b.updatedInput);
+}
+function writeFamilyOfCanonical(name) {
+    if (name === "TaskCreate" || name === "TaskUpdate")
+        return "task";
+    if (name === "TodoWrite")
+        return "todo";
+    return undefined;
+}
+function toolResultMsg(toolCallId, toolName, text, isError) {
+    return {
+        role: "toolResult",
+        toolCallId,
+        toolName,
+        content: [{ type: "text", text }],
+        isError,
+        timestamp: Date.now(),
+    };
+}
+function resumeContinuation(resume) {
+    if (resume.outcome.gate === "resource_limit") {
+        return formatHookFeedback("You were resumed after a pause. Before continuing, re-orient from the workspace: run `git status` and " +
+            "review your recent changes / last commits to confirm what is already done, then continue the " +
+            "remaining work. Do NOT restart the task or re-run work that is already committed.");
+    }
+    if (resume.outcome.gate === "dry_run_review") {
+        const verdict = resume.outcome.decision === "approve"
+            ? "Your predicted change was REVIEWED and APPROVED; it has been applied"
+            : `Your predicted change was REVIEWED and REJECTED${resume.outcome.reason ? `: ${delimitUntrusted("reviewer note", resume.outcome.reason)}` : ""}; it was NOT applied`;
+        return formatHookFeedback(`You were resumed after a dry-run review. ${verdict}. Before continuing, re-orient from the workspace ` +
+            "(run `git status` and review your recent changes) to confirm the current state, then continue the " +
+            "remaining work. Do NOT restart the task or re-run work that is already done.");
+    }
+    if (resume.outcome.gate === "plan_review") {
+        if (resume.outcome.decision === "approve") {
+            return formatHookFeedback("Your proposed PLAN was REVIEWED and APPROVED. Proceed with that plan now — begin executing it. " +
+                "This is a RESUMED task; do NOT re-plan or restart from scratch, just carry out the approved plan.");
+        }
+        if (resume.outcome.decision === "edit") {
+            if (!resume.outcome.editedPlan) {
+                return formatHookFeedback("Your proposed PLAN was REVIEWED and EDITED, but no revised plan text was supplied — proceed with your " +
+                    "ORIGINAL plan as-is, begin executing it now. This is a RESUMED task; do NOT re-plan or restart from scratch.");
+            }
+            return formatHookFeedback("Your proposed PLAN was REVIEWED and EDITED by a human reviewer. Proceed with the REVISED plan below " +
+                "(it supersedes your earlier plan); begin executing it now. This is a RESUMED task; do NOT re-plan " +
+                "or restart from scratch, just carry out the revised plan.\n\nThe REVISED plan to follow is:\n" +
+                delimitUntrusted("revised plan", resume.outcome.editedPlan));
+        }
+        const why = resume.outcome.reason ? ` Reviewer note: ${delimitUntrusted("reviewer note", resume.outcome.reason)}` : "";
+        return formatHookFeedback(`Your proposed PLAN was REVIEWED and REJECTED; it was NOT executed.${why} Produce a NEW plan that ` +
+            "addresses the concern, then continue. This is a RESUMED task — re-plan from the current state; do " +
+            "NOT execute the rejected plan.");
+    }
+    const { pendingAction } = resume.cp;
+    if (pendingAction.kind !== "tool_approval") {
+        return formatHookFeedback("This is a RESUMED task — continue from where you left off without restarting or re-running prior work.");
+    }
+    const decided = resume.outcome.decision === "allow"
+        ? "was APPROVED and has now been executed — its result is in the tool results above"
+        : `was DENIED${resume.outcome.reason ? `: ${delimitUntrusted("reviewer note", resume.outcome.reason)}` : ""}`;
+    const remaining = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !pendingAction.completedCallIds.includes(id)).length;
+    const batchNote = remaining > 0
+        ? ` ${remaining} other tool call(s) from that batch were returned as deferred and not run — re-issue any you still need.`
+        : "";
+    return formatHookFeedback(`The pending tool call "${pendingAction.toolName}" ${decided}.${batchNote} ` +
+        `This is a RESUMED task — every step before this point is already done and its results are in the ` +
+        `conversation above. Do NOT restart the task or re-run any tool you already ran; continue from this ` +
+        `exact point, building on the existing results, and finish the remaining work.`);
+}
+export class Runner {
+    deps;
+    sessions;
+    sessionLocks = new Map();
+    snapshotTooLargeRoots = new Map();
+    pendingSessionNotifications = new PendingSessionNotifications();
+    constructor(deps) {
+        this.deps = deps.memoryStore
+            ? { ...deps, memoryStore: guardedMemoryStore(deps.memoryStore, deps.utilityGate) }
+            : deps;
+        if (this.deps.tiers) {
+            this.deps = { ...this.deps, models: expandTiers(this.deps.models, this.deps.tiers) };
+        }
+        if (!this.deps.toolResultStore) {
+            this.deps = { ...this.deps, toolResultStore: new RunnerSharedToolResultStore({ maxTotalChars: 64_000_000 }) };
+        }
+        this.sessions = deps.sessionStore ?? new TtlSessionStore();
+    }
+    emitTaskOutcome(outcome) {
+        emitTaskOutcome(this.deps, outcome);
+    }
+    get agentCatalog() {
+        return {
+            ...(this.deps.agents ? { agents: [...this.deps.agents] } : {}),
+            ...(this.deps.builtinAgents !== undefined ? { builtinAgents: this.deps.builtinAgents } : {}),
+            ...(this.deps.models ? { models: { ...this.deps.models } } : {}),
+        };
+    }
+    get gateBaseline() {
+        const deps = this.deps;
+        const h = deps.hooks;
+        const hooks = h
+            ? {
+                ...(typeof h.preToolUse === "function" ? { preToolUse: (t, i, c) => h.preToolUse(t, i, c) } : {}),
+                ...(typeof h.postToolUse === "function" ? { postToolUse: (t, i, o, c) => h.postToolUse(t, i, o, c) } : {}),
+                ...(typeof h.userPromptSubmit === "function" ? { userPromptSubmit: (p) => h.userPromptSubmit(p) } : {}),
+                ...(typeof h.stop === "function" ? { stop: (c) => h.stop(c) } : {}),
+                ...(typeof h.postToolUseFailure === "function"
+                    ? { postToolUseFailure: (t, i, f, c) => h.postToolUseFailure(t, i, f, c) }
+                    : {}),
+                ...(typeof h.postToolBatch === "function" ? { postToolBatch: (b) => h.postToolBatch(b) } : {}),
+                ...(typeof h.preCompact === "function" ? { preCompact: (c) => h.preCompact(c) } : {}),
+                ...(typeof h.postCompact === "function" ? { postCompact: (c) => h.postCompact(c) } : {}),
+                ...(typeof h.stopFailure === "function" ? { stopFailure: (c) => h.stopFailure(c) } : {}),
+                ...(typeof h.permissionDenied === "function" ? { permissionDenied: (p) => h.permissionDenied(p) } : {}),
+            }
+            : undefined;
+        return {
+            ...(deps.toolPolicy !== undefined
+                ? { toolPolicy: { check: (req, signal) => deps.toolPolicy.check(req, signal) } }
+                : {}),
+            ...(hooks !== undefined ? { hooks } : {}),
+        };
+    }
+    async acquireSessionLock(sessionId) {
+        const prev = this.sessionLocks.get(sessionId) ?? Promise.resolve();
+        let release;
+        const mine = new Promise((r) => {
+            release = r;
+        });
+        const chain = prev.then(() => mine);
+        this.sessionLocks.set(sessionId, chain);
+        await prev.catch(() => { });
+        return () => {
+            release();
+            void chain.then(() => {
+                if (this.sessionLocks.get(sessionId) === chain) {
+                    this.sessionLocks.delete(sessionId);
+                }
+            });
+        };
+    }
+    runTaskStream(spec, resume, internals) {
+        const queue = new PushQueue();
+        const detachHub = new ToolDetachHub();
+        let resultValue;
+        let consolidationDone = Promise.resolve();
+        let suggestionsDone = Promise.resolve([]);
+        let handle;
+        let publishReady;
+        const ready = new Promise((res) => {
+            publishReady = res;
+        });
+        const READY_TIMEOUT_MS = 30_000;
+        const orTimeout = (p) => {
+            let t;
+            const timeout = new Promise((res2) => {
+                t = setTimeout(() => res2(undefined), READY_TIMEOUT_MS);
+                t.unref?.();
+            });
+            return Promise.race([p, timeout]).finally(() => clearTimeout(t));
+        };
+        let reapHandle;
+        const manualCompactRef = { requested: false, waiters: [] };
+        const drainManualCompactWaiters = (outcome) => {
+            manualCompactRef.requested = false;
+            for (const w of manualCompactRef.waiters.splice(0))
+                w(outcome);
+        };
+        const run = (async () => {
+            const releaseLock = spec.sessionId
+                ? await this.acquireSessionLock(spec.sessionId)
+                : undefined;
+            try {
+                await this.runLocked(spec, queue, (r) => {
+                    resultValue = r;
+                }, (p) => {
+                    consolidationDone = p;
+                }, (p) => {
+                    suggestionsDone = p;
+                }, (h) => {
+                    handle = h;
+                    publishReady(h);
+                }, (s) => {
+                    reapHandle = s;
+                }, manualCompactRef, resume, { ...(internals ?? {}), detachHub });
+            }
+            finally {
+                releaseLock?.();
+                publishReady(handle);
+                drainManualCompactWaiters("mooted");
+            }
+        })();
+        const settled = run.catch(async (err) => {
+            const code = errorCodeOf(err);
+            const reopenReason = code === "resume.env_failed"
+                ? "env_failed"
+                : code === "resume.tool_unavailable"
+                    ? "tool_unavailable"
+                    : undefined;
+            const reopenable = reopenReason !== undefined;
+            if (reopenable && resume?.onEnvRestoreFailed) {
+                try {
+                    await resume.onEnvRestoreFailed(reopenReason);
+                }
+                catch {
+                }
+            }
+            else if (resume && !reopenable) {
+                try {
+                    await this.sessions.unpin?.(resume.cp.sessionId);
+                }
+                catch {
+                }
+            }
+            resultValue = {
+                taskId: spec.taskId ?? "unknown",
+                sessionId: spec.sessionId ?? "unknown",
+                status: "failed",
+                result: "",
+                errorMessage: err instanceof Error ? err.message : String(err),
+                errorCode: code,
+                stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costUsd: 0 },
+            };
+            queue.push({ type: "done", result: resultValue });
+            queue.close();
+        });
+        const steeringError = (msg, code = "steering.not_running") => {
+            const e = new Error(`cannot steer: ${msg}`);
+            e.code = code;
+            return e;
+        };
+        let destroyOnce;
+        const reapSuspended = async () => {
+            const rh = reapHandle;
+            if (!rh)
+                return;
+            const reportErr = (err) => {
+                try {
+                    this.deps.onError?.(err, { phase: "config", sessionId: rh.sessionId });
+                }
+                catch {
+                }
+            };
+            let won;
+            try {
+                won = await rh.store.expire(rh.token, rh.scope);
+            }
+            catch (err) {
+                reportErr(err);
+                return;
+            }
+            if (!won)
+                return;
+            if (rh.env && hasDestroy(rh.env)) {
+                try {
+                    await rh.env.destroy();
+                }
+                catch (err) {
+                    reportErr(err);
+                }
+            }
+        };
+        return {
+            [Symbol.asyncIterator]: () => queue[Symbol.asyncIterator](),
+            result: async () => {
+                await settled;
+                return resultValue;
+            },
+            consolidation: async () => {
+                await run.catch(() => { });
+                await consolidationDone.catch(() => { });
+            },
+            suggestions: async () => {
+                await run.catch(() => { });
+                return suggestionsDone.catch(() => []);
+            },
+            steer: async (text, options) => {
+                if (resultValue)
+                    throw steeringError("the task has already finished");
+                const h = handle ?? (await orTimeout(ready));
+                if (!h)
+                    throw steeringError("the task is not running");
+                if (options?.trusted && sanitizeUntrustedText(text) !== text) {
+                    throw steeringError("trusted steering text must not contain a </system-reminder> tag", "steering.invalid_content");
+                }
+                const payload = options?.trusted ? formatHookFeedback(text) : text;
+                try {
+                    await h.harness.steer(payload);
+                }
+                catch (e) {
+                    if (e instanceof Error && e.code === "invalid_state") {
+                        throw steeringError("the task is no longer running");
+                    }
+                    throw e;
+                }
+            },
+            compact: async () => {
+                if (resultValue)
+                    throw steeringError("the task has already finished");
+                const h = handle ?? (await orTimeout(ready));
+                if (!h)
+                    throw steeringError("the task is not running");
+                return new Promise((resolve) => {
+                    manualCompactRef.requested = true;
+                    manualCompactRef.waiters.push(resolve);
+                });
+            },
+            detach: (toolCallId) => {
+                detachHub.request(toolCallId);
+            },
+            interrupt: async () => {
+                const h = handle ?? (await orTimeout(ready));
+                if (!h)
+                    return;
+                h.abortController.abort();
+                void h.harness.abort();
+            },
+            destroy: () => (destroyOnce ??= (async () => {
+                const h = handle ?? (await orTimeout(ready));
+                if (h) {
+                    h.abortController.abort();
+                    void h.harness.abort();
+                }
+                await orTimeout(run.catch(() => { }));
+                await reapSuspended();
+            })()),
+        };
+    }
+    async runLocked(spec, queue, setResult, onConsolidation, onSuggestions, onReady, onSuspend, manualCompactRef, resume, internals) {
+        const prepareResume = resume
+            ? {
+                leafId: resume.cp.leafId,
+                suspendedBatch: new Set(resume.cp.pendingAction.kind === "tool_approval" ? resume.cp.pendingAction.batchToolCallIds : []),
+                seed: resume.cp.state,
+                priorSuspendCount: resume.cp.suspendCount,
+                priorLedger: resume.cp.resourceLedger,
+                priorHumanReview: resume.cp.humanReview,
+                workspaceHandle: resume.cp.state.workspaceHandle,
+            }
+            : 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;
+        let notificationIdent = () => ({});
+        let notificationLaneLive = true;
+        let notificationSessionId;
+        const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
+            queue.push({ type: "task_notification", notification: item.payload, ...notificationIdent() });
+            if (notificationHarness) {
+                const xml = renderTaskNotificationXml(item.payload);
+                const deliver = item.priority === "later" ? notificationHarness.followUp(xml) : notificationHarness.steer(xml);
+                void deliver.catch(() => {
+                    if (notificationSessionId !== undefined)
+                        this.pendingSessionNotifications.pend(notificationSessionId, item.payload);
+                });
+            }
+        });
+        const upstreamTaskNotification = internals?.onTaskNotification;
+        const prepared = await prepareTask(spec, this.deps, this.sessions, prepareResume, memorySelector, {
+            ...(internals ?? {}),
+            detachHub,
+            onTaskNotification: (notification, opts) => {
+                try {
+                    upstreamTaskNotification?.(notification, opts);
+                }
+                catch {
+                }
+                if (!notificationLaneLive) {
+                    if (notificationSessionId !== undefined)
+                        this.pendingSessionNotifications.pend(notificationSessionId, notification);
+                    return;
+                }
+                taskNotificationQueue.enqueue({
+                    kind: "task_notification",
+                    priority: opts?.priority ?? "later",
+                    dedupKey: taskNotificationDedupKey(notification),
+                    payload: notification,
+                });
+            },
+        }, this);
+        notificationHarness = prepared.harness;
+        notificationSessionId = prepared.sessionId;
+        {
+            const pendingIdle = this.pendingSessionNotifications.drain(prepared.sessionId);
+            if (pendingIdle !== undefined) {
+                for (const payload of discloseDroppedPending(pendingIdle)) {
+                    queue.push({ type: "task_notification", notification: payload });
+                    void prepared.harness.nextTurn(renderTaskNotificationXml(payload)).catch(() => {
+                        this.pendingSessionNotifications.pend(prepared.sessionId, payload);
+                    });
+                }
+            }
+        }
+        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 });
+        if (resume &&
+            resume.cp.suspendedAt !== undefined &&
+            (resume.cp.gate.kind === "human" ||
+                resume.cp.gate.kind === "irreversible_ask" ||
+                resume.cp.gate.kind === "needs_review" ||
+                resume.cp.gate.kind === "plan_review")) {
+            const waitMs = Math.max(0, prepared.now() - resume.cp.suspendedAt);
+            const decision = resume.outcome.decision;
+            prepared.humanReviewRef.count += 1;
+            prepared.humanReviewRef.totalWaitMs += waitMs;
+            const gateToolName = "toolName" in resume.cp.gate ? resume.cp.gate.toolName : undefined;
+            prepared.humanReviewRef.gates.push({ kind: resume.cp.gate.kind, waitMs, ...(decision !== undefined ? { decision } : {}), ...(gateToolName !== undefined ? { toolName: gateToolName } : {}) });
+        }
+        let cacheFamily = cacheFamilyOf(prepared.model);
+        let pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
+        let degradeToModel;
+        if (spec.degrade) {
+            try {
+                degradeToModel = resolveModel(spec.degrade.to, this.deps.models);
+            }
+            catch (e) {
+                this.deps.onError?.(e, { phase: "degraded", sessionId: prepared.sessionId });
+            }
+        }
+        const famOverride = prepared.model.params?.promptCacheFamily;
+        if (famOverride && !["input-includes-cached", "input-excludes-cached", "openai", "anthropic"].includes(famOverride)) {
+            this.deps.onError?.(new Error(`prompt-cache: unrecognized model.params.promptCacheFamily "${famOverride}" — ignored (fell back to model.api inference). Use "input-includes-cached" | "input-excludes-cached" (aliases "openai" | "anthropic").`), { phase: "prompt-cache", sessionId: prepared.sessionId });
+        }
+        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;
+        const taskStart = Date.now();
+        void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, taskId)).catch(() => { });
+        const recordDegraded = (info, toModel) => {
+            if (degraded !== undefined)
+                return;
+            let m = toModel;
+            if (!m) {
+                try {
+                    m = resolveModel(info.to, this.deps.models);
+                }
+                catch {
+                    m = undefined;
+                }
+            }
+            if (m) {
+                pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+                cacheFamily = cacheFamilyOf(m);
+            }
+            else if (this.deps.pricing?.[info.to]) {
+                pricing = this.deps.pricing[info.to];
+            }
+            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() }));
+            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 });
+        };
+        const sliceWindowMicroUsd = spec.maxCostUsd !== undefined ? Math.round(spec.maxCostUsd * 1e6) : undefined;
+        const 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) ||
+            (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)
+                    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 attachState = attachmentsCfg !== undefined ? createAttachmentState() : undefined;
+        let cadenceTurns = 0;
+        let lastTurnHadToolCalls = false;
+        if (attachState !== undefined && 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;
+                        break;
+                    }
+                    if (e.type === "message" && e.message.role === "assistant")
+                        break;
+                }
+            }
+            catch {
+            }
+        }
+        if (attachState !== undefined && attachmentsCfg?.agentListing === true && prepared.agentListing?.seedAnnounced === true) {
+            const listing = prepared.agentListing;
+            try {
+                const headers = [agentListingInitialHeader(listing.toolName), agentListingDeltaHeader(listing.toolName)];
+                const textOf = (m) => {
+                    const c = m.content;
+                    if (typeof c === "string")
+                        return c;
+                    if (Array.isArray(c)) {
+                        return c
+                            .map((b) => (b !== null && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : ""))
+                            .join("\n");
+                    }
+                    return "";
+                };
+                const branch = await prepared.session.getBranch();
+                const delivered = branch.some((e) => {
+                    if (e.type !== "message")
+                        return false;
+                    const text = textOf(e.message);
+                    return headers.some((h) => text.includes(h));
+                });
+                if (delivered) {
+                    attachState.announcedAgentTypes = new Map(listing.entries.map((e) => [e.name, e.description]));
+                }
+            }
+            catch {
+            }
+        }
+        if (spec.finalVerification === true && resume !== undefined) {
+            try {
+                const branch = await prepared.session.getBranch();
+                for (const e of branch) {
+                    if (e.type !== "message")
+                        continue;
+                    const m = e.message;
+                    if (m.role === "user") {
+                        const text = typeof m.content === "string"
+                            ? m.content
+                            : m.content.map((b) => (b !== null && typeof b === "object" && b.type === "text" ? String(b.text ?? "") : "")).join("\n");
+                        if (text.includes("<system-reminder>[final verification]") && finalVerifyInjections < 2)
+                            finalVerifyInjections += 1;
+                    }
+                    else if (m.role === "toolResult" && !wroteThisRun && (prepared.toolEffects.get(m.toolName) ?? "write") !== "read") {
+                        wroteThisRun = true;
+                    }
+                }
+            }
+            catch {
+            }
+        }
+        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 writeFamilyByName = new Map();
+        if (attachState !== undefined) {
+            for (const t of prepared.tools) {
+                const family = writeFamilyOfCanonical(canonicalToolName(t.name));
+                if (family !== undefined)
+                    for (const n of [t.name, ...(t.aliases ?? [])])
+                        writeFamilyByName.set(n, family);
+            }
+        }
+        const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(canonicalToolName(name));
+        const toolStartAt = new Map();
+        emitTrace(tracer, () => ({ kind: "task.start", version: 1, taskId, model: prepared.model.id, ts: taskStart }));
+        emitTrace(tracer, () => ({
+            kind: "prompt.assembled",
+            version: 1,
+            taskId,
+            constitution: prepared.promptManifest.constitution,
+            blocks: prepared.promptManifest.blocks,
+            totalChars: prepared.promptManifest.blocks.reduce((n, b) => n + b.chars, 0),
+            ts: taskStart,
+        }));
+        if (prepared.thinking && prepared.thinking !== "off" && prepared.model.reasoning === true) {
+            emitTrace(tracer, () => {
+                const r = resolveReasoning(prepared.thinking, prepared.model);
+                return {
+                    kind: "reasoning.resolved",
+                    version: 1,
+                    taskId,
+                    model: prepared.model.id,
+                    requested: r.requested,
+                    effective: r.effective,
+                    graded: r.graded,
+                    clamped: r.clamped,
+                    format: r.format,
+                    endpoint: r.endpoint,
+                    ts: Date.now(),
+                };
+            });
+        }
+        const walltimeDeadlineMs = spec.limits?.timeoutSec ? taskStart + spec.limits.timeoutSec * 1000 : undefined;
+        if (prepared.callCapRef && prepared.suspendForResource === undefined && walltimeDeadlineMs !== undefined) {
+            prepared.callCapRef.deadlineMs = walltimeDeadlineMs;
+            if (spec.limits?.gracefulFinalize !== false) {
+                prepared.callCapRef.cushionMs = writeoutCushionMs(spec.limits.timeoutSec * 1000);
+            }
+        }
+        let finalizeInjected = false;
+        const nudgeSchedule = [];
+        {
+            const conf = spec.limits?.deadlineNudge;
+            const budgetSec = spec.limits?.timeoutSec;
+            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 remainMin = Math.max(1, Math.round((budgetSec * 1000 * (1 - a)) / 60_000));
+                    const budgetMin = Math.max(1, Math.round(budgetSec / 60));
+                    nudgeSchedule.push({
+                        atMs: t1,
+                        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);
+                    if (b > a && b < 1) {
+                        nudgeSchedule.push({
+                            atMs: t2,
+                            text: `<system-reminder>[deadline] the wall-clock budget is nearly exhausted. STOP new work — ` +
+                                `write out deliverables and give your final answer NOW; an unfinished answer beats a hard timeout.</system-reminder>`,
+                        });
+                    }
+                }
+            }
+        }
+        let nudgeIdx = 0;
+        const timeout = startTimeout(prepared.harness, prepared.abortController, spec.limits?.timeoutSec, prepared.suspendForResource !== undefined);
+        const parentToolCallId = internals?.parentToolCallId;
+        const ident = () => parentToolCallId !== undefined ? { eventId: uuidv7(), parentToolCallId, sourceTaskId: taskId } : { eventId: uuidv7() };
+        notificationIdent = ident;
+        const pushContent = (e) => {
+            queue.push(e);
+            if (parentToolCallId !== undefined && internals?.onForwardEvent) {
+                try {
+                    internals.onForwardEvent(e);
+                }
+                catch {
+                }
+            }
+        };
+        const emitCommitted = (entryId, role, toolCallId) => {
+            queue.push({ type: "message_committed", entryId, role, ...(toolCallId !== undefined ? { toolCallId } : {}), ...ident() });
+        };
+        const subagentName = parentToolCallId !== undefined && internals?.agentName !== undefined ? inlineUntrusted(internals.agentName.slice(0, 320), 80) : undefined;
+        let lastWorkspaceCwd = prepared.cwdRef?.current;
+        const statusEmit = (s) => {
+            queue.push({
+                type: "status",
+                phase: s.phase,
+                ...(s.detail !== undefined ? { detail: s.detail } : {}),
+                ...(s.retryInSec !== undefined ? { retryInSec: s.retryInSec } : {}),
+                ...ident(),
+            });
+        };
+        const telemetryEmit = (t) => {
+            emitTrace(tracer, () => t.kind === "failover"
+                ? {
+                    kind: "brain.failover",
+                    version: 1,
+                    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() }
+                    : 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() });
+        };
+        const withBrainSinks = (fn) => runWithStatusSink(statusEmit, () => runWithBrainTelemetry(telemetryEmit, fn));
+        const trunc = (s) => s.slice(0, MAX_TOOL_END_OUTPUT_CHARS) + `…[+${s.length - MAX_TOOL_END_OUTPUT_CHARS} chars truncated]`;
+        const toolOutputFrom = (result) => {
+            const content = result !== null && typeof result === "object" ? result.content : result;
+            if (content === undefined)
+                return undefined;
+            if (typeof content === "string") {
+                return content.length > MAX_TOOL_END_OUTPUT_CHARS ? { output: trunc(content), truncated: true } : { output: content, truncated: false };
+            }
+            let serialized;
+            try {
+                serialized = JSON.stringify(content) ?? "";
+            }
+            catch {
+                return { output: "[unserializable tool output]", truncated: false };
+            }
+            return serialized.length > MAX_TOOL_END_OUTPUT_CHARS ? { output: trunc(serialized), truncated: true } : { output: content, truncated: false };
+        };
+        const CC_DETAIL_TYPES = new Set([
+            "edit", "multiedit", "create", "update", "bash", "notebook-edit", "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 (ev.type === "text_delta" && ev.delta) {
+                if (firstTokenAt === undefined)
+                    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";
+                        void prepared.harness.abort();
+                        prepared.abortController.abort();
+                    }
+                }
+            }
+        };
+        const onMessageEnd = (event) => {
+            const m = event.message;
+            if (event.entryId !== undefined && (m.role === "user" || m.role === "assistant" || m.role === "toolResult")) {
+                emitCommitted(event.entryId, m.role, m.role === "toolResult" ? m.toolCallId : undefined);
+            }
+            if (m.role === "assistant" && "usage" in m && m.usage) {
+                if (m.usageMissing)
+                    turnUsageMissing = true;
+                const u = m.usage;
+                stats.tokens += u.totalTokens || 0;
+                const { totalInputTokens: turnInput, costMicroUsd: turnCostMicroUsd } = usageCostMicroUsd(cacheFamily, u, 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;
+                const callEndAt = Date.now();
+                const capLast = prepared.callCapRef?.state.last;
+                if (prepared.callCapRef) {
+                    recordCallSample(prepared.callCapRef.state, u.output || 0, callStartAt !== undefined ? callEndAt - callStartAt : 0);
+                    prepared.callCapRef.state.last = undefined;
+                }
+                emitTrace(tracer, () => ({
+                    kind: "brain.call",
+                    version: 1,
+                    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,
+                    costMicroUsd: turnCostMicroUsd,
+                    ...(capLast !== undefined ? { callCap: capLast.cap, capThinkingSkipped: capLast.thinkingSkipped } : {}),
+                    ...(m.role === "assistant" && typeof m.stopReason === "string"
+                        ? { stopReason: m.stopReason }
+                        : {}),
+                    ts: callEndAt,
+                }));
+                if (prepared.callCapRef &&
+                    prepared.callCapRef.reasoningObserved !== true &&
+                    capLast !== undefined &&
+                    m.role === "assistant" &&
+                    m.stopReason === "length") {
+                    const blocks = Array.isArray(m.content)
+                        ? (m.content)
+                        : [];
+                    const productive = blocks.some((c) => c?.type === "toolCall") ||
+                        blocks.some((c) => c?.type === "text" && typeof c.text === "string" && c.text.trim() !== "");
+                    if (!productive)
+                        prepared.callCapRef.reasoningObserved = true;
+                }
+                if (prepared.cacheBreakDetector && prepared.cacheFingerprint) {
+                    const finding = prepared.cacheBreakDetector.observe({
+                        turn: stats.turns + 1,
+                        systemPrompt: prepared.cacheFingerprint.systemPrompt,
+                        tools: prepared.cacheFingerprint.tools,
+                        modelKey: `${m.provider}:${m.model}`,
+                        cacheRead: u.cacheRead || 0,
+                    });
+                    if (finding) {
+                        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;
+            }
+            if (m.role === "assistant" && m.errorMessage === WALLTIME_CUTOFF_MESSAGE) {
+                callCutoffs += 1;
+            }
+            if (m.role === "assistant") {
+                const rep = m.repetition;
+                if (rep !== undefined) {
+                    const observed = [
+                        ...(rep.cut !== undefined ? [{ action: "cut", e: rep.cut }] : []),
+                        ...(rep.spared ?? []).map((e) => ({ action: "spared", e })),
+                    ];
+                    for (const { action, e } of observed) {
+                        if (action === "cut")
+                            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 });
+                        }
+                        emitTrace(tracer, () => ({
+                            kind: "repetition.detected",
+                            version: 1,
+                            taskId,
+                            turn: stats.turns + 1,
+                            action,
+                            rule: e.rule,
+                            period: e.period,
+                            reps: e.reps,
+                            segment: e.segment,
+                            ts: Date.now(),
+                        }));
+                    }
+                }
+            }
+            if (prepared.callCapRef &&
+                prepared.callCapRef.reasoningObserved !== true &&
+                m.role === "assistant" &&
+                Array.isArray(m.content) &&
+                m.content.some((c) => c?.type === "thinking")) {
+                prepared.callCapRef.reasoningObserved = true;
+            }
+            if (attachState !== undefined && m.role === "assistant") {
+                const content = m.content;
+                cadenceTurns = advanceCadenceClock(attachState, cadenceTurns, content, writeFamilyOf);
+                lastTurnHadToolCalls = Array.isArray(content) && content.some((c) => c?.type === "toolCall");
+            }
+            if (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 }) });
+            }
+            callStartAt = undefined;
+            firstTokenAt = undefined;
+            callOutputChars = 0;
+            lastStreamBudgetCheck = 0;
+        };
+        const toolLabels = new Map(prepared.tools.flatMap((t) => (t.label !== undefined && t.label !== t.name ? [[t.name, t.label]] : [])));
+        const postToolBatchHook = (spec.hooks ?? this.deps.hooks)?.postToolBatch;
+        const batchArgs = postToolBatchHook ? new Map() : undefined;
+        let toolBatch = [];
+        const onToolStart = (event) => {
+            toolStartAt.set(event.toolCallId, Date.now());
+            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;
+                else
+                    groundingSignalPostR9 = true;
+            }
+            const activityArg = primaryActivityArg(event.args);
+            internals?.onActivity?.({ phase: "start", toolCallId: event.toolCallId, toolName: event.toolName, ...(activityArg !== undefined ? { arg: activityArg } : {}) });
+            pushContent({
+                type: "tool_start",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
+                args: event.args,
+                ...ident(),
+            });
+        };
+        const onToolEnd = (event) => {
+            const toolStarted = toolStartAt.get(event.toolCallId);
+            toolStartAt.delete(event.toolCallId);
+            const toolNow = Date.now();
+            if (prepared.callCapRef && toolStarted !== undefined) {
+                recordToolSample(prepared.callCapRef.state, toolNow - toolStarted);
+            }
+            if (!wroteThisRun && (prepared.toolEffects.get(event.toolName) ?? "write") !== "read") {
+                wroteThisRun = true;
+            }
+            if (attachState !== undefined && !event.isError) {
+                const det = event.result?.details;
+                if (det !== undefined)
+                    reduceToolEnd(attachState, det);
+            }
+            if (postToolBatchHook !== undefined) {
+                if (prepared.blockedToolCalls.delete(event.toolCallId)) {
+                    batchArgs?.delete(event.toolCallId);
+                }
+                else {
+                    const digest = batchResponseDigest(event.result);
+                    toolBatch.push({
+                        toolName: event.toolName,
+                        input: batchArgs?.get(event.toolCallId),
+                        toolCallId: event.toolCallId,
+                        ...(digest !== undefined ? { response: digest } : {}),
+                        isError: event.isError,
+                    });
+                    batchArgs?.delete(event.toolCallId);
+                }
+            }
+            emitTrace(tracer, () => ({
+                kind: "tool.call",
+                version: 1,
+                taskId,
+                name: event.toolName,
+                durationMs: toolStarted !== undefined ? toolNow - toolStarted : 0,
+                ok: !event.isError,
+                ts: toolNow,
+            }));
+            internals?.onActivity?.({ phase: "end", toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError });
+            if (prepared.lspDiagnostics && !event.isError) {
+                const name = canonicalToolName(event.toolName);
+                if (name === "Edit" || name === "Write" || name === "NotebookEdit") {
+                    const d = event.result?.details;
+                    const p = typeof d?.filePath === "string" ? d.filePath : typeof d?.notebookPath === "string" ? d.notebookPath : undefined;
+                    if (p)
+                        prepared.lspDiagnostics.nudge(p);
+                }
+            }
+            pushContent({
+                type: "tool_end",
+                toolCallId: event.toolCallId,
+                toolName: event.toolName,
+                ...(toolLabels.get(event.toolName) !== undefined ? { label: toolLabels.get(event.toolName) } : {}),
+                isError: event.isError,
+                ...(() => {
+                    const o = toolOutputFrom(event.result);
+                    return o !== undefined ? { output: o.output, ...(o.truncated ? { truncated: true } : {}) } : {};
+                })(),
+                ...(() => {
+                    const st = structuredFrom(event.result);
+                    return st !== undefined ? { structured: st } : {};
+                })(),
+                ...ident(),
+            });
+            const cwdNow = prepared.cwdRef?.current;
+            if (cwdNow !== undefined && cwdNow !== lastWorkspaceCwd) {
+                lastWorkspaceCwd = cwdNow;
+                queue.push({ type: "workspace_changed", cwd: cwdNow, ...ident() });
+            }
+            if (spec.outputSchema && event.toolName === OUTPUT_TOOL_NAME) {
+                if (event.isError) {
+                    outputErrorStreak += 1;
+                    if (outputErrorStreak > outputRetryCap) {
+                        outputInvalid = true;
+                        void prepared.harness.abort();
+                        prepared.abortController.abort();
+                    }
+                }
+                else {
+                    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() }
+                : { type: "turn_end", usageMissing: true, ...stopExtra, ...ident() });
+            turnUsageMissing = false;
+            turnStopReason = undefined;
+            if (parentToolCallId !== undefined) {
+                const progress = {
+                    type: "task_progress",
+                    taskId,
+                    ...(internals?.parentTaskId !== undefined ? { parentTaskId: internals.parentTaskId } : {}),
+                    ...(subagentName ? { name: subagentName } : {}),
+                    usage: { totalTokens: stats.tokens, toolUses: stats.toolCalls, durationMs: Date.now() - taskStart },
+                    status: "running",
+                    ...ident(),
+                };
+                queue.push(progress);
+                try {
+                    internals?.onForwardEvent?.(progress);
+                }
+                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;
+            toolStartAt.clear();
+            if (effectiveMaxTurns !== undefined && effectiveMaxTurns > 0 && stats.turns >= effectiveMaxTurns) {
+                turnsExceeded = true;
+                if (prepared.suspendForResource === undefined) {
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                }
+            }
+            else {
+                if (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);
+                    if (prepared.callCapRef &&
+                        spec.limits?.maxOutputTokens === undefined &&
+                        degradeToModel.maxTokens !== undefined &&
+                        (prepared.callCapRef.staticCapTokens === undefined || degradeToModel.maxTokens < prepared.callCapRef.staticCapTokens)) {
+                        prepared.callCapRef.staticCapTokens = degradeToModel.maxTokens;
+                    }
+                }
+                if (!budgetHit && overBudget()) {
+                    budgetHit = "exceeded";
+                    if (prepared.suspendForResource === undefined) {
+                        void prepared.harness.abort();
+                        prepared.abortController.abort();
+                    }
+                }
+            }
+        };
+        const recordCompactionUsage = (m, msg) => {
+            const u = msg?.usage;
+            if (!u)
+                return;
+            const fam = cacheFamilyOf(m);
+            const price = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
+            const { totalInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
+            stats.tokens += u.totalTokens || 0;
+            stats.promptTokens += totalInputTokens;
+            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,
+                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(),
+            }));
+        };
+        const compactionBrain = {
+            stream: this.deps.brain.stream,
+            complete: async (m, c, o) => {
+                const msg = await runWithStatusSink(() => { }, async () => this.deps.brain.complete
+                    ? await this.deps.brain.complete(m, c, o)
+                    : await (await Promise.resolve(this.deps.brain.stream(m, c, o))).result());
+                recordCompactionUsage(m, msg);
+                return msg;
+            },
+        };
+        const withinTaskCompaction = (spec.compaction?.enabled ?? true) && (spec.compaction?.withinTask ?? true);
+        const compactionBreaker = { failures: 0 };
+        const stopHook = (spec.hooks ?? this.deps.hooks)?.stop;
+        const finalVerificationOn = spec.finalVerification === true;
+        if (stopHook || finalVerificationOn) {
+            let consecutiveBlocks = 0;
+            prepared.harness.setStopGate(async () => {
+                if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
+                    return [];
+                if (finalVerificationOn &&
+                    (finalVerifyInjections === 0 || (finalVerifyInjections === 1 && groundingSignalPreR9 && !groundingSignalPostR9)) &&
+                    wroteThisRun &&
+                    prepared.outputRef.set !== true &&
+                    !finalizeInjected &&
+                    !(effectiveMaxTurns !== undefined && effectiveMaxTurns > 0 && stats.turns >= effectiveMaxTurns - 1)) {
+                    finalVerifyInjections += 1;
+                    if (finalVerifyInjections === 2) {
+                        return [
+                            {
+                                role: "user",
+                                content: "<system-reminder>[final verification] Your tool calls in this run worked with raw bytes, structural parsing, " +
+                                    "or checksum/digest computation — the deliverable very likely embeds verifiable structure (structural fields, an " +
+                                    "embedded checksum-family value, reference data it must match, or a replayable deterministic path). You MUST " +
+                                    "execute the grounding check that structure supports — recompute the embedded value and compare it against the " +
+                                    "declared one, re-parse the structure from the raw bytes and reconcile it with your output, compare against the " +
+                                    "reference data, or replay the deterministic path — and REPORT the check's concrete result before finishing. " +
+                                    "A closing statement without a reported check result is not verification. If you already ran such a check, state " +
+                                    "its concrete result now; if the check mismatches, fix the deliverable first. This is the final reminder from " +
+                                    "this verification gate — it will not intervene again.</system-reminder>",
+                                timestamp: Date.now(),
+                            },
+                        ];
+                    }
+                    return [
+                        {
+                            role: "user",
+                            content: "<system-reminder>[final verification] Before finishing: re-verify the FINAL deliverable through its REAL entry point, " +
+                                "exactly as the acceptance criteria would exercise it — execute the binary/function/endpoint directly and read the ACTUAL " +
+                                "output and exit code. Do NOT rely on earlier self-tests, shell redirections, or assumptions (a program that prints to " +
+                                "stdout is not a program that writes the required file). If anything mismatches the task's requirements, fix it before " +
+                                "finishing. " +
+                                "Treat verification writes as state-harmless: when the deliverable itself is a persisted final " +
+                                "state (for example a committed or pushed file, a deployed artifact, or a required output file), " +
+                                "do not change that state merely to test it. This constrains HOW you verify — it is never a " +
+                                "license to skip the real acceptance path or to check a substitute of your own making: expected " +
+                                "values must come from the task's requirements, never from content you generated. If the real " +
+                                "acceptance path requires a write, use disposable inputs or an isolated target, end in the exact " +
+                                "required final state, and verify that final state before finishing. " +
+                                "If the work relied on a third-party API, library, or model, check the usage contract the object itself declares " +
+                                "(docstrings, metadata, configuration — e.g. prompt conventions shipped with a model) and confirm your calls follow " +
+                                "it rather than a default symmetric usage. Verify not only that the deliverable EXISTS but that the METHOD that " +
+                                "produced it matches the task's requirements. " +
+                                "Choose the verification SURFACE deliberately: check against the reference data, oracle, or evaluation tooling the " +
+                                "task itself provides — re-running your own implementation and getting the same answer is self-consistency, not " +
+                                "correctness — and cross-check through an independent second path where the task or environment offers one " +
+                                "(checksums, runtime artifacts). Verify the PERSISTED artifact — re-read what is actually on disk or committed, " +
+                                "not in-memory state — against every hard constraint from the original task text (numeric bounds, allowed-value " +
+                                "lists, naming semantics, required files), reconciling whole-set completeness: nothing missing, nothing duplicated. " +
+                                "If the deliverable embeds verifiable structure — structural fields, an embedded checksum-family value, " +
+                                "reference data it must match, or a replayable deterministic path — you MUST execute the grounding check " +
+                                "that structure supports and REPORT its concrete result in your closing summary: for such a deliverable, " +
+                                "no reported check result means the work is not finished. " +
+                                "If the task produced neither an executable deliverable nor any verifiable structure or acceptance " +
+                                "oracle to check against, briefly confirm completion and stop.</system-reminder>",
+                            timestamp: Date.now(),
+                        },
+                    ];
+                }
+                if (!stopHook)
+                    return [];
+                let result;
+                try {
+                    result = await stopHook({ stopHookActive: consecutiveBlocks > 0, consecutiveBlocks });
+                }
+                catch (err) {
+                    this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                    return [];
+                }
+                const messages = [];
+                if (result?.additionalContext) {
+                    messages.push({
+                        role: "user",
+                        content: formatHookFeedback(`Stop hook additional context: ${result.additionalContext}`),
+                        timestamp: Date.now(),
+                    });
+                }
+                if (!result?.block) {
+                    consecutiveBlocks = 0;
+                    return messages;
+                }
+                consecutiveBlocks++;
+                const cap = STOP_HOOK_BLOCK_CAP;
+                if (consecutiveBlocks > cap) {
+                    this.deps.onError?.(new Error(`a Stop hook blocked the turn from ending ${consecutiveBlocks} consecutive times — overriding and ending the run. ` +
+                        `Check ctx.stopHookActive in the hook and return success while it's true.`), { phase: "hook", sessionId: prepared.sessionId });
+                    return [];
+                }
+                messages.push({ role: "user", content: formatHookFeedback(`Stop hook stopped continuation: ${result.block}`), timestamp: Date.now() });
+                return messages;
+            });
+        }
+        prepared.harness.setLoopRecovery({
+            truncatedOutput: {},
+            malformedToolUse: {},
+            thinkingOnly: {},
+            degenerateOutput: { detect: (m) => m.errorMessage === DEGENERATE_MESSAGE },
+            walltimeCutoff: { detect: (m) => m.errorMessage === WALLTIME_CUTOFF_MESSAGE },
+            promptTooLong: {
+                recover: async () => {
+                    if (!(spec.compaction?.enabled ?? true))
+                        return false;
+                    if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
+                        return false;
+                    if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
+                        return false;
+                    try {
+                        const comp = await maybeCompact({
+                            session: prepared.session,
+                            model: prepared.harness.getModel(),
+                            compactionModel: prepared.compModel,
+                            brain: compactionBrain,
+                            getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                            thinking: prepared.thinking,
+                            settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                            customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                            signal: prepared.abortController.signal,
+                            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() })),
+                            workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
+                                ? {
+                                    readFile: prepared.readTaskFile,
+                                    ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                                    ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+                                }
+                                : undefined,
+                            ...this.seamCCompactionOptions(prepared),
+                            ...this.compactionHookOptions(spec, prepared.sessionId, "forced"),
+                        });
+                        if (comp.compacted) {
+                            compactionBreaker.failures = 0;
+                            this.recordCompactionReuse(prepared, comp);
+                            if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
+                                const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
+                                compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                            }
+                            queue.push({
+                                type: "compacted",
+                                trigger: "auto",
+                                tokensBefore: comp.tokensBefore ?? 0,
+                                ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+                                ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+                                ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+                                ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+                                ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+                            });
+                            prepared.cacheBreakDetector?.notifyCompaction();
+                            if (attachState !== undefined) {
+                                attachState.postCompactPending = true;
+                                rebaseCadenceWindows(attachState, cadenceTurns);
+                            }
+                        }
+                        else {
+                            compactionBreaker.failures += 1;
+                        }
+                        return comp.compacted === true;
+                    }
+                    catch {
+                        compactionBreaker.failures += 1;
+                        return false;
+                    }
+                },
+            },
+        });
+        const rapidRefill = createRapidRefillState();
+        let compactionFloor = 0;
+        let trimForceBackoff = false;
+        const drainManualCompact = (outcome) => {
+            manualCompactRef.requested = false;
+            for (const w of manualCompactRef.waiters.splice(0))
+                w(outcome);
+        };
+        const onTurnBoundary = async (event) => {
+            let boundarySteered = false;
+            if (prepared.suspendForResource === undefined) {
+                const nowMs = Date.now();
+                if (!finalizeInjected &&
+                    spec.limits?.gracefulFinalize !== false &&
+                    walltimeDeadlineMs !== undefined &&
+                    prepared.callCapRef !== undefined) {
+                    const remainingMs = walltimeDeadlineMs - nowMs;
+                    if (remainingMs > 0 && remainingMs < estimateCycleMs(prepared.callCapRef.state) + (prepared.callCapRef.cushionMs ?? 0)) {
+                        finalizeInjected = true;
+                        prepared.callCapRef.finalizeMode = true;
+                        nudgeIdx = nudgeSchedule.length;
+                        const finalizeText = `<system-reminder>[deadline] the wall-clock budget is exhausted — this is the FINAL turn. ` +
+                            `Write your best current work to the deliverable path NOW, even if incomplete — persist to disk FIRST; everything else comes after. ` +
+                            `If a better version exists anywhere else (a draft, scratch or temp file), copy it to the deliverable path now. ` +
+                            `Do NOT open new work, new investigations, or long commands; write out and stop.` +
+                            (finalVerificationOn
+                                ? ` After writing, if seconds permit, confirm the deliverable file actually EXISTS at the required path with your latest content.`
+                                : "") +
+                            `</system-reminder>`;
+                        void prepared.harness.steer(finalizeText).catch(() => { });
+                        boundarySteered = true;
+                        queue.push({ type: "steering_injected", source: "finalize", preview: finalizeText.slice(0, 220), ...ident() });
+                    }
+                }
+                let due;
+                while (nudgeIdx < nudgeSchedule.length && nowMs >= nudgeSchedule[nudgeIdx].atMs) {
+                    due = nudgeSchedule[nudgeIdx++];
+                }
+                if (due) {
+                    void prepared.harness.steer(due.text).catch(() => { });
+                    nudgesSent += 1;
+                    boundarySteered = true;
+                    queue.push({ type: "steering_injected", source: "deadline_nudge", preview: due.text.slice(0, 220), ...ident() });
+                }
+            }
+            const walltimeHit = walltimeDeadlineMs !== undefined && Date.now() >= walltimeDeadlineMs;
+            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 (prepared.suspendForResource &&
+                (turnsExceeded || budgetHit !== undefined || walltimeHit || preemptHit) &&
+                prepared.suspendRef.token === undefined) {
+                const reason = preemptHit
+                    ? "preempt"
+                    : budgetHit !== undefined
+                        ? "budget"
+                        : walltimeHit
+                            ? "walltime"
+                            : "turns";
+                const sliceSpend = { costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns };
+                if (await prepared.suspendForResource(reason, sliceSpend)) {
+                    turnsExceeded = false;
+                    budgetHit = undefined;
+                }
+                else {
+                    void prepared.harness.abort();
+                    prepared.abortController.abort();
+                }
+                return undefined;
+            }
+            if (prepared.reviewRequestRef.pending !== undefined) {
+                const { reason } = prepared.reviewRequestRef.pending;
+                prepared.reviewRequestRef.pending = undefined;
+                const honorable = prepared.suspendForReview !== undefined &&
+                    !prepared.abortController.signal.aborted &&
+                    prepared.suspendRef.token === undefined &&
+                    prepared.reviewRef.token === undefined;
+                if (honorable && prepared.suspendForReview) {
+                    await prepared.suspendForReview(reason);
+                    return undefined;
+                }
+                emitTrace(tracer, () => ({ kind: "review.dropped", version: 1, taskId, ts: Date.now() }));
+            }
+            if (prepared.lspDiagnostics && !prepared.lspDiagnostics.registry.isEmpty() && !prepared.abortController.signal.aborted) {
+                const files = prepared.lspDiagnostics.registry.drain();
+                if (files.length > 0) {
+                    queue.push({ type: "diagnostics", files, isNew: true, ...ident() });
+                    const block = formatDiagnosticsBlock(files);
+                    void prepared.harness.steer(block).catch(() => undefined);
+                    boundarySteered = true;
+                }
+            }
+            let boundaryAttachmentBytes = 0;
+            let attachmentsPayload;
+            if (attachState !== undefined &&
+                attachmentsCfg !== undefined &&
+                !boundarySteered &&
+                !finalizeInjected &&
+                finalVerifyInjections === 0 &&
+                !prepared.abortController.signal.aborted) {
+                const changedFilesOn = Boolean(attachmentsCfg.changedFiles);
+                let changed;
+                if (changedFilesOn && prepared.detectExternalChanges !== undefined) {
+                    const maxFiles = typeof attachmentsCfg.changedFiles === "object"
+                        ? (attachmentsCfg.changedFiles.maxFiles ?? CHANGED_FILES_MAX)
+                        : CHANGED_FILES_MAX;
+                    const SCAN_CEILING_MS = 2_000;
+                    const scan = await Promise.race([
+                        prepared.detectExternalChanges(maxFiles),
+                        new Promise((resolve) => {
+                            const t = setTimeout(() => resolve({ changed: [], evicted: [] }), SCAN_CEILING_MS);
+                            t.unref?.();
+                        }),
+                    ]);
+                    for (const p of scan.evicted)
+                        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 pendingTools = toolsDeltaOn && prepared.toolsDeltaRef !== undefined && prepared.toolsDeltaRef.pending.length > 0
+                    ? [...prepared.toolsDeltaRef.pending]
+                    : undefined;
+                const agentListingOn = attachmentsCfg.agentListing === true;
+                const mcpInstructionsOn = 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 budgetUsdOn = attachmentsCfg.budgetUsd === true && maxCostMicroUsd !== undefined && lastTurnHadToolCalls;
+                const due = collectDueAttachments(attachState, {
+                    turn: stats.turns,
+                    cadenceTurn: cadenceTurns,
+                    todoMounted: todoToolMounted,
+                    taskListMounted: taskToolsMounted,
+                    planActive: prepared.planModeRef.active,
+                    config: {
+                        todoReminder: attachmentsCfg.todoReminder === true,
+                        ...(attachmentsCfg.todoReminderMode !== undefined ? { todoReminderMode: attachmentsCfg.todoReminderMode } : {}),
+                        changedFiles: changedFilesOn,
+                        planModeReminder: attachmentsCfg.planModeReminder === true,
+                        budgetUsd: budgetUsdOn,
+                        backgroundTasks: backgroundTasksOn,
+                        toolsDelta: toolsDeltaOn,
+                        agentListing: agentListingOn,
+                        mcpInstructions: mcpInstructionsOn,
+                    },
+                    ...(changed !== undefined ? { changedFiles: changed } : {}),
+                    ...(budgetUsdOn && maxCostMicroUsd !== undefined
+                        ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: maxCostMicroUsd / 1e6 } }
+                        : {}),
+                    ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
+                    ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
+                    ...(agentListingOn && prepared.agentListing !== undefined
+                        ? { agentListing: prepared.agentListing.entries, agentToolName: prepared.agentListing.toolName }
+                        : {}),
+                    ...(mcpAdds !== undefined || mcpRemovals !== undefined
+                        ? { mcpInstructions: { added: mcpAdds ?? [], removed: mcpRemovals ?? [] } }
+                        : {}),
+                });
+                if (pendingTools !== undefined && due.some((a) => a.source === "tools_delta" && a.body === renderToolsDelta(pendingTools))) {
+                    prepared.toolsDeltaRef.pending.splice(0, pendingTools.length);
+                }
+                if ((mcpAdds !== undefined || mcpRemovals !== undefined) &&
+                    due.some((a) => a.source === "mcp_instructions" && a.body === renderMcpInstructionsDelta(mcpAdds ?? [], mcpRemovals ?? []))) {
+                    if (mcpAdds !== undefined)
+                        mcpDelta.pendingAdds.splice(0, mcpAdds.length);
+                    if (mcpRemovals !== undefined)
+                        mcpDelta.pendingRemovals.splice(0, mcpRemovals.length);
+                }
+                if (agentListingOn && prepared.agentListing !== undefined && due.some((a) => a.source === "agent_listing")) {
+                    const listing = prepared.agentListing;
+                    const intactBody = renderAgentListingDelta(attachState, listing.entries, listing.toolName);
+                    if (intactBody !== undefined && due.some((a) => a.source === "agent_listing" && a.body === intactBody)) {
+                        commitAgentListing(attachState, listing.entries);
+                    }
+                }
+                if (due.length > 0) {
+                    attachmentsPayload = due.map((a) => `<system-reminder>\n${sanitizeUntrustedText(a.body)}\n</system-reminder>`).join("\n");
+                    for (const a of due)
+                        boundaryAttachmentBytes += Buffer.byteLength(a.body, "utf8");
+                    attachmentsInjected += due.length;
+                    for (const a of due) {
+                        queue.push({ type: "steering_injected", source: a.source, preview: a.body.slice(0, 220), ...ident() });
+                    }
+                }
+            }
+            let batchContextBlock;
+            if (postToolBatchHook !== undefined && toolBatch.length > 0) {
+                const batch = toolBatch;
+                toolBatch = [];
+                batchArgs?.clear();
+                if (!boundarySteered && !finalizeInjected && finalVerifyInjections === 0 && !prepared.abortController.signal.aborted) {
+                    try {
+                        const r = await postToolBatchHook(batch);
+                        if (r?.additionalContext) {
+                            const body = sanitizeUntrustedText(r.additionalContext);
+                            const budget = ATTACHMENT_BYTE_CAP - boundaryAttachmentBytes;
+                            if (budget >= BATCH_CONTEXT_MIN_KEEP_BYTES) {
+                                const clipped = clipToByteBudget(body, budget) === body
+                                    ? body
+                                    : `${clipToByteBudget(body, budget - Buffer.byteLength(BATCH_TRUNCATION_MARKER, "utf8"))}${BATCH_TRUNCATION_MARKER}`;
+                                batchContextBlock = `<system-reminder>\n${clipped}\n</system-reminder>`;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        try {
+                            this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                        }
+                        catch {
+                        }
+                    }
+                }
+            }
+            if (attachmentsPayload !== undefined || batchContextBlock !== undefined) {
+                const payload = attachmentsPayload !== undefined && batchContextBlock !== undefined ? `${attachmentsPayload}\n${batchContextBlock}` : (attachmentsPayload ?? batchContextBlock);
+                void prepared.harness.steer(payload).catch(() => { });
+            }
+            const forceManual = manualCompactRef.requested;
+            if ((!withinTaskCompaction && !forceManual) ||
+                (finalizeInjected && !forceManual) ||
+                prepared.abortController.signal.aborted ||
+                prepared.suspendRef.token !== undefined ||
+                prepared.reviewRef.token !== undefined) {
+                if (forceManual) {
+                    emitTrace(tracer, () => ({ kind: "compaction.mooted", version: 1, taskId, reason: "task_ending", ts: Date.now() }));
+                    drainManualCompact("mooted");
+                }
+                return undefined;
+            }
+            if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES) {
+                if (forceManual) {
+                    emitTrace(tracer, () => ({
+                        kind: "compaction.failed",
+                        version: 1,
+                        taskId,
+                        trigger: "manual",
+                        reason: "compaction circuit breaker open (3 consecutive failures this task) — manual request drained without an attempt",
+                        ts: Date.now(),
+                    }));
+                    drainManualCompact("failed");
+                }
+                return undefined;
+            }
+            const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
+            if (trimPressureArmed)
+                prepared.trimPressureRef.droppedMessages = false;
+            const trimPressure = trimPressureArmed && !trimForceBackoff;
+            let manualOutcome = "failed";
+            try {
+                const comp = await maybeCompact({
+                    session: prepared.session,
+                    model: event.model,
+                    compactionModel: prepared.compModel,
+                    brain: compactionBrain,
+                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                    thinking: prepared.thinking,
+                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                    signal: prepared.abortController.signal,
+                    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() })),
+                    forceUnderThreshold: trimPressure,
+                    overheadTokens: prepared.promptOverheadTokens,
+                    workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
+                        ? {
+                            readFile: prepared.readTaskFile,
+                            ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                            ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+                        }
+                        : undefined,
+                    ...this.seamCCompactionOptions(prepared),
+                    ...this.compactionHookOptions(spec, prepared.sessionId, trimPressure ? "forced" : forceManual ? "manual" : "auto"),
+                });
+                if (comp.blocked) {
+                    emitTrace(tracer, () => ({
+                        kind: "compaction.blocked",
+                        version: 1,
+                        taskId,
+                        trigger: forceManual ? "manual" : "auto",
+                        ts: Date.now(),
+                    }));
+                }
+                else {
+                    compactionBreaker.failures = 0;
+                }
+                trimForceBackoff = nextTrimForceBackoff(trimForceBackoff, comp, trimPressure);
+                if (comp.suppressedByFloor) {
+                    const s = comp.suppressedByFloor;
+                    emitTrace(tracer, () => ({
+                        kind: "compaction.suppressed",
+                        version: 1,
+                        taskId,
+                        estTokens: s.estTokens,
+                        floor: s.floor,
+                        ts: Date.now(),
+                    }));
+                }
+                manualOutcome = comp.compacted ? "compacted" : comp.blocked ? "blocked" : comp.disabled ? "disabled" : "noop";
+                if (forceManual && !comp.compacted && !comp.blocked) {
+                    if (comp.disabled) {
+                        emitTrace(tracer, () => ({ kind: "compaction.disabled", version: 1, taskId, ts: Date.now() }));
+                    }
+                    else {
+                        emitTrace(tracer, () => ({ kind: "compaction.noop", version: 1, taskId, ts: Date.now() }));
+                    }
+                }
+                if (comp.compacted && !forceManual) {
+                    if (recordCompactionAndCheckRapidRefill(rapidRefill, stats.turns)) {
+                        compactionBreaker.failures = MAX_CONSECUTIVE_COMPACTION_FAILURES;
+                        this.deps.onError?.(new Error("compaction.rapid_refill: the context refilled within <3 turns of compaction 3 times in a row — compaction disabled for the rest of this task (thrash spiral; the transcript is dominated by incompressible content)"), { phase: "compaction", sessionId: prepared.sessionId });
+                    }
+                }
+                this.recordCompactionReuse(prepared, comp);
+                if (comp.compacted) {
+                    queue.push({
+                        type: "compacted",
+                        trigger: forceManual ? "manual" : "auto",
+                        tokensBefore: comp.tokensBefore ?? 0,
+                        ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+                        ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+                        ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+                        ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+                        ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+                    });
+                    prepared.cacheBreakDetector?.notifyCompaction();
+                    if (attachState !== undefined) {
+                        attachState.postCompactPending = true;
+                        rebaseCadenceWindows(attachState, 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) {
+                if (!prepared.abortController.signal.aborted) {
+                    compactionBreaker.failures += 1;
+                    this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+                    const msg = String(err instanceof Error ? err.message : err);
+                    emitTrace(tracer, () => ({
+                        kind: "compaction.failed",
+                        version: 1,
+                        taskId,
+                        trigger: trimPressure ? "forced" : forceManual ? "manual" : "auto",
+                        reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg,
+                        ts: Date.now(),
+                    }));
+                    manualOutcome = "failed";
+                }
+                else {
+                    manualOutcome = "mooted";
+                }
+            }
+            if (forceManual)
+                drainManualCompact(manualOutcome);
+            return undefined;
+        };
+        const unsubBoundary = prepared.harness.on("turn_boundary", onTurnBoundary);
+        const unsub = prepared.harness.subscribe((event) => {
+            switch (event.type) {
+                case "message_update":
+                    onMessageUpdate(event);
+                    break;
+                case "message_end":
+                    onMessageEnd(event);
+                    break;
+                case "tool_execution_start":
+                    onToolStart(event);
+                    break;
+                case "tool_execution_end":
+                    onToolEnd(event);
+                    break;
+                case "turn_end":
+                    onTurnEnd();
+                    break;
+                default:
+                    break;
+            }
+        });
+        let final;
+        let threw;
+        let abortedLive = false;
+        try {
+            if (prepared.abortController.signal.aborted) {
+                const e = new Error("run aborted");
+                e.name = "AbortError";
+                throw e;
+            }
+            if (resume) {
+                await this.applyResumeDecision(prepared, resume, (e) => queue.push(e), emitCommitted, (toolName, details) => {
+                    if (attachState === undefined)
+                        return;
+                    const family = writeFamilyOf(toolName);
+                    if (family !== undefined)
+                        stampWriteAnchor(attachState, family, cadenceTurns);
+                    if (details !== undefined)
+                        reduceToolEnd(attachState, details);
+                });
+                if (maxCostMicroUsd !== undefined && maxCostMicroUsd <= 0) {
+                    budgetHit = "exceeded";
+                }
+                else {
+                    let continuation = resumeContinuation(resume);
+                    const bgSnapshot = resume.cp.state.runningBackgroundTasks;
+                    if (bgSnapshot !== undefined && bgSnapshot.length > 0) {
+                        const alive = new Set(prepared.listBackgroundTasks().map((t) => t.id));
+                        const orphans = bgSnapshot.filter((t) => !alive.has(t.id));
+                        if (orphans.length > 0) {
+                            continuation += "\n\n" + formatHookFeedback(renderOrphanedBackgroundTasks(orphans));
+                        }
+                    }
+                    const steer = resume.cp.state.pendingSteer;
+                    if (steer) {
+                        continuation +=
+                            "\n\n" +
+                                (steer.trusted ? formatHookFeedback(steer.text) : delimitUntrusted("supervisor steering message", steer.text));
+                    }
+                    final = await withBrainSinks(() => prepared.harness.prompt(continuation));
+                }
+            }
+            else {
+                let effectiveObjective = spec.objective;
+                let promptBlocked = false;
+                const userPromptSubmit = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
+                if (userPromptSubmit) {
+                    const decision = await userPromptSubmit(spec.objective);
+                    if (decision?.block) {
+                        prepared.blockedRef.reason = formatHookFeedback(decision.block);
+                        promptBlocked = true;
+                    }
+                    else if (decision?.additionalContext) {
+                        effectiveObjective = `${formatHookFeedback(decision.additionalContext)}\n\n${spec.objective}`;
+                    }
+                }
+                const precallMicroUsd = maxCostMicroUsd === undefined
+                    ? 0
+                    : computeCostMicroUsd({
+                        totalInputTokens: Math.ceil(effectiveObjective.length / 4),
+                        cacheReadTokens: 0,
+                        cacheWriteTokens: 0,
+                        cacheWriteTokensLong: 0,
+                        outputTokens: prepared.model.maxTokens ?? 4096,
+                    }, pricing);
+                const precallCeilingMicroUsd = prepared.suspendForResource !== undefined ? remainingMicroUsd : maxCostMicroUsd;
+                if (promptBlocked) {
+                }
+                else if (precallCeilingMicroUsd !== undefined && precallMicroUsd > precallCeilingMicroUsd) {
+                    budgetHit = "precall";
+                }
+                else {
+                    const images = spec.images
+                        ? await Promise.all(spec.images.map((img) => toImageContent(img, this.deps.allowImageUrl)))
+                        : undefined;
+                    final = await withBrainSinks(() => prepared.harness.prompt(effectiveObjective, images && images.length > 0 ? { images } : undefined));
+                }
+            }
+            abortedLive = prepared.abortController.signal.aborted;
+        }
+        catch (err) {
+            if (errorCodeOf(err) === "resume.tool_unavailable") {
+                try {
+                    await prepared.mcp.dispose();
+                }
+                catch {
+                }
+                try {
+                    if (prepared.ownedEnv && hasDestroy(prepared.ownedEnv))
+                        await prepared.ownedEnv.destroy();
+                }
+                catch {
+                }
+                throw err;
+            }
+            threw = err;
+            abortedLive = prepared.abortController.signal.aborted;
+        }
+        finally {
+            timeout.clear();
+            prepared.abortController.abort();
+            prepared.releaseSignal();
+            notificationLaneLive = false;
+            unsubscribeTaskNotifications();
+            unsubBoundary();
+            unsub();
+        }
+        const suspended = prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined;
+        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");
+        if (interrupted) {
+            try {
+                const report = await reconcileInterruptedSession(prepared.session, prepared.toolEffects);
+                for (const orphan of report.recovered) {
+                    queue.push({ type: "tool_end", toolCallId: orphan.toolCallId, toolName: orphan.toolName, isError: true, ...ident() });
+                    emitCommitted(orphan.entryId, "toolResult", orphan.toolCallId);
+                }
+            }
+            catch (reconcileErr) {
+                this.deps.onError?.(reconcileErr instanceof Error ? reconcileErr : new Error(String(reconcileErr)), {
+                    phase: "interrupt-reconcile",
+                    sessionId: prepared.sessionId,
+                });
+            }
+            try {
+                await prepared.harness.flushQueuedSessionWrites();
+            }
+            catch (flushErr) {
+                this.deps.onError?.(flushErr instanceof Error ? flushErr : new Error(String(flushErr)), {
+                    phase: "interrupt-reconcile",
+                    sessionId: prepared.sessionId,
+                });
+            }
+        }
+        if (attachState?.postCompactPending === true && attachmentsCfg?.backgroundTasks === true) {
+            emitTrace(tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId, ts: Date.now() }));
+        }
+        const comp = await this.finish(spec, prepared, {
+            skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
+            minTokens: compactionFloor,
+            brain: compactionBrain,
+        });
+        try {
+            if (comp?.compacted) {
+                queue.push({
+                    type: "compacted",
+                    trigger: "auto",
+                    tokensBefore: comp.tokensBefore ?? 0,
+                    ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+                    ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+                    ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+                    ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+                    ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+                });
+                prepared.cacheBreakDetector?.notifyCompaction();
+            }
+            if (prepared.nestedStats.tasks > 0) {
+                stats.nested = {
+                    tokens: prepared.nestedStats.tokens,
+                    turns: prepared.nestedStats.turns,
+                    tasks: prepared.nestedStats.tasks,
+                    costUsd: prepared.nestedStats.costUsd || undefined,
+                    costMicroUsd: prepared.nestedStats.costMicroUsd || undefined,
+                };
+            }
+            if (stats.promptTokens > 0) {
+                const rawHit = stats.cachedTokens / stats.promptTokens;
+                if (stats.cachedTokens > stats.promptTokens) {
+                    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`
+                        : `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 });
+                }
+            }
+            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;
+            }
+            if (prepared.humanReviewRef.count > 0) {
+                stats.humanReview = {
+                    count: prepared.humanReviewRef.count,
+                    totalWaitMs: prepared.humanReviewRef.totalWaitMs,
+                    gates: [...prepared.humanReviewRef.gates],
+                };
+            }
+            const capShrinks = prepared.callCapRef?.shrinks ?? 0;
+            const toolClamps = prepared.callCapRef?.toolClamps ?? 0;
+            if (finalizeInjected || nudgesSent > 0 || capShrinks > 0 || callCutoffs > 0 || toolClamps > 0 || finalVerifyInjections > 0 || attachmentsInjected > 0 || repetitionCuts > 0 || repetitionSpared > 0) {
+                stats.mechanisms = {
+                    ...(finalizeInjected ? { finalizeInjected: true } : {}),
+                    ...(nudgesSent > 0 ? { nudgesSent } : {}),
+                    ...(capShrinks > 0 ? { capShrinks } : {}),
+                    ...(callCutoffs > 0 ? { callCutoffs } : {}),
+                    ...(toolClamps > 0 ? { toolClamps } : {}),
+                    ...(finalVerifyInjections > 0 ? { finalVerifyInjected: true } : {}),
+                    ...(finalVerifyInjections > 0 ? { finalVerifyInjections } : {}),
+                    ...(attachmentsInjected > 0 ? { attachmentsInjected } : {}),
+                    ...(repetitionCuts > 0 ? { repetitionCuts } : {}),
+                    ...(repetitionSpared > 0 ? { repetitionSpared } : {}),
+                    ...(repetitionEvents.length > 0 ? { repetitionEvents } : {}),
+                };
+            }
+            const result = assembleResult(spec, prepared.sessionId, final, stats, {
+                threw,
+                model: prepared.model.id,
+                abortedForTimeout: timeout.fired,
+                abortedForTurns: turnsExceeded,
+                abortedLive,
+                budgetHit,
+                blockedReason: prepared.blockedRef.reason,
+                conflict: prepared.conflictRef.hit,
+                outputInvalid,
+                suspendLoop: prepared.suspendLoopRef.hit,
+                suspendRef: prepared.suspendRef.token !== undefined && prepared.suspendRef.gate !== undefined
+                    ? { token: prepared.suspendRef.token, gate: prepared.suspendRef.gate }
+                    : undefined,
+                reviewRef: prepared.reviewRef.token !== undefined && prepared.reviewRef.gate !== undefined
+                    ? { token: prepared.reviewRef.token, gate: prepared.reviewRef.gate }
+                    : undefined,
+            });
+            const stopFailureHook = (spec.hooks ?? this.deps.hooks)?.stopFailure;
+            if (stopFailureHook !== undefined &&
+                result.status === "failed" &&
+                final?.stopReason === "error" &&
+                final.errorMessage !== DEGENERATE_MESSAGE &&
+                final.errorMessage !== WALLTIME_CUTOFF_MESSAGE &&
+                threw === undefined &&
+                budgetHit === undefined &&
+                !outputInvalid &&
+                !prepared.suspendLoopRef.hit &&
+                !abortedLive &&
+                result.errorCode !== "conflict") {
+                try {
+                    await stopFailureHook({
+                        error: result.errorMessage ?? "model error",
+                        ...(result.errorCode !== undefined ? { errorKind: result.errorCode } : {}),
+                        turns: stats.turns,
+                    });
+                }
+                catch (err) {
+                    try {
+                        this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+            if (degraded)
+                result.degraded = degraded;
+            if (prepared.outputRef.set)
+                result.structuredOutput = prepared.outputRef.value;
+            const committedToken = prepared.suspendRef.token ?? prepared.reviewRef.token;
+            const committedScope = prepared.suspendRef.scope ?? prepared.reviewRef.scope;
+            if (committedToken !== undefined) {
+                const store = spec.checkpointStore ?? this.deps.checkpointStore;
+                if (store && committedScope !== undefined) {
+                    onSuspend({
+                        env: prepared.ownedEnv,
+                        token: committedToken,
+                        scope: committedScope,
+                        store,
+                        sessionId: prepared.sessionId,
+                    });
+                }
+            }
+            if (resume && committedToken === undefined) {
+                try {
+                    await this.sessions.unpin?.(resume.cp.sessionId);
+                }
+                catch (err) {
+                    try {
+                        this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+            if (prepared.memoryEngineSession)
+                await prepared.memoryEngineSession.harvest();
+            emitTrace(tracer, () => ({
+                kind: "task.end",
+                version: 1,
+                taskId,
+                status: result.status,
+                errorCode: result.errorCode,
+                turns: stats.turns,
+                tokens: stats.tokens,
+                costMicroUsd: stats.costMicroUsd,
+                durationMs: Date.now() - taskStart,
+                ...(prepared.outputRef.set ? { hasStructuredOutput: true } : {}),
+                ts: Date.now(),
+            }));
+            setResult(result);
+            queue.push({ type: "done", result });
+            queue.close();
+            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));
+            }
+        }
+        finally {
+            const ownedEnvDying = prepared.ownedEnv !== undefined &&
+                hasDestroy(prepared.ownedEnv) &&
+                isIsolated(prepared.ownedEnv) &&
+                prepared.suspendRef.token === undefined &&
+                prepared.reviewRef.token === undefined;
+            try {
+                await defaultTaskRegistry.settleKilledForOwner({ owner: spec.taskId ?? prepared.sessionId, scope: spec.principal ?? "default" }, {
+                    source: abortedLive &&
+                        !timeout.fired &&
+                        !turnsExceeded &&
+                        budgetHit === undefined &&
+                        prepared.suspendRef.token === undefined &&
+                        prepared.reviewRef.token === undefined
+                        ? "user"
+                        : "parent",
+                    skipSessionScoped: true,
+                    envDying: ownedEnvDying,
+                });
+            }
+            catch (e) {
+                try {
+                    this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId });
+                }
+                catch {
+                }
+            }
+            const bgEnv = prepared.ownedEnv ?? this.deps.executionEnv;
+            if (bgEnv && hasBackgroundShell(bgEnv)) {
+                try {
+                    const keepAlive = ownedEnvDying && bgEnv === prepared.ownedEnv
+                        ? []
+                        : [
+                            ...defaultTaskRegistry.sessionResidentShellIds(prepared.sessionId, bgEnv),
+                            ...defaultTaskRegistry.timeoutResidentShellIds(bgEnv),
+                        ];
+                    await bgEnv.disposeBackgroundShells(keepAlive.length > 0 ? { except: keepAlive } : undefined);
+                }
+                catch (e) {
+                    this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId });
+                }
+            }
+            defaultTaskRegistry.clearBackgroundForOwner({
+                owner: spec.taskId ?? prepared.sessionId,
+                scope: spec.principal ?? "default",
+            });
+            defaultTaskRegistry.abortBackgroundAgentsForOwner({
+                owner: spec.taskId ?? prepared.sessionId,
+                scope: spec.principal ?? "default",
+            }, { skipSessionScoped: true });
+            if (prepared.subagentRetain) {
+                try {
+                    await prepared.subagentRetain.disposeAll();
+                }
+                catch (e) {
+                    this.deps.onError?.(e, { phase: "config", sessionId: prepared.sessionId });
+                }
+            }
+            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;
+        const ac = new AbortController();
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                ac.abort();
+                resolve([]);
+            }, SUGGESTIONS_TIMEOUT_MS);
+            timer.unref?.();
+        });
+        const work = (async () => {
+            let model = prepared.model;
+            let thinking = prepared.thinking;
+            try {
+                const resolved = resolveTaskModel({ modelRole: cfg.role ?? "summarize", roles: spec.roles }, this.deps);
+                model = resolved.model;
+                thinking = resolved.thinking;
+            }
+            catch {
+            }
+            const pricing = this.deps.pricing?.[model.id] ?? modelCostToPricing(model.cost);
+            const ctx = await prepared.session.buildContext();
+            const transcript = ctx.messages.slice(-SUGGESTIONS_TRANSCRIPT_MESSAGES);
+            const out = await generatePromptSuggestions({ brain: this.deps.brain, model, pricing, thinking, getApiKeyAndHeaders: spec.getApiKeyAndHeaders, signal: ac.signal }, transcript, count);
+            if (out.tokens > 0 || out.costMicroUsd > 0) {
+                result.stats.suggestions = { tokens: out.tokens, costMicroUsd: out.costMicroUsd };
+                if (result.stats.costBreakdown) {
+                    result.stats.costBreakdown.suggestionsMicroUsd = out.costMicroUsd;
+                }
+            }
+            return out.suggestions;
+        })();
+        work.catch(() => { });
+        try {
+            return await Promise.race([work, timeout]);
+        }
+        catch (err) {
+            try {
+                this.deps.onError?.(err, { phase: "suggestions", sessionId: prepared.sessionId });
+            }
+            catch {
+            }
+            return [];
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async snapshotTurn(prepared) {
+        const store = this.deps.fileSnapshotStore;
+        const env = prepared.ownedEnv ?? this.deps.executionEnv;
+        if (!store || !env)
+            return;
+        try {
+            const leafId = await prepared.session.getLeafId();
+            if (!leafId)
+                return;
+            const root = prepared.taskRootPath;
+            const refusedAt = this.snapshotTooLargeRoots.get(root);
+            if (refusedAt !== undefined) {
+                if (Date.now() - refusedAt < SNAPSHOT_TOO_LARGE_TTL_MS)
+                    return;
+                this.snapshotTooLargeRoots.delete(root);
+            }
+            const ac = new AbortController();
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => {
+                    ac.abort();
+                    resolve({ ok: false, error: { code: "aborted", message: "snapshot timed out" } });
+                }, SNAPSHOT_TIMEOUT_MS);
+                timer.unref?.();
+            });
+            const work = store.snapshot(prepared.sessionId, leafId, env, root, ac.signal);
+            work.catch(() => { });
+            let r;
+            try {
+                r = await Promise.race([work, timeout]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (!r.ok) {
+                const tooLarge = r.error.code === "too_large";
+                if (tooLarge)
+                    this.snapshotTooLargeRoots.set(root, Date.now());
+                try {
+                    this.deps.onError?.(new Error(`rewind-files snapshot failed (${r.error.code}): ${r.error.message}` +
+                        (tooLarge ? " — skipping further snapshots for this root (this process); raise the store's snapshotBounds or shrink the tree to re-enable rewind" : "")), { phase: "rewind", sessionId: prepared.sessionId, ...(tooLarge ? { classification: "too_large" } : {}) });
+                }
+                catch {
+                }
+            }
+        }
+        catch (err) {
+            try {
+                this.deps.onError?.(err, { phase: "rewind", sessionId: prepared.sessionId });
+            }
+            catch {
+            }
+        }
+    }
+    async runTask(spec, internals) {
+        const stream = this.runTaskStream(spec, undefined, internals);
+        for await (const _ of stream) {
+            void _;
+        }
+        return stream.result();
+    }
+    async resume(token, outcome, taskConfig) {
+        const stream = await this.resumeStream(token, outcome, taskConfig);
+        for await (const _ of stream) {
+            void _;
+        }
+        return stream.result();
+    }
+    async resumeStream(token, outcome, taskConfig, internals) {
+        const store = taskConfig.checkpointStore ?? this.deps.checkpointStore;
+        if (!store) {
+            throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
+        }
+        const cp = await store.get(token);
+        if (!cp) {
+            throw new CheckpointError("checkpoint.not_found", "no checkpoint found for the supplied token");
+        }
+        const gateMatch = (cp.gate.kind === "human" && outcome.gate === "policy_ask") ||
+            (cp.gate.kind === "irreversible_ask" && outcome.gate === "policy_ask") ||
+            (cp.gate.kind === "resource_limit" && outcome.gate === "resource_limit") ||
+            (cp.gate.kind === "needs_review" && outcome.gate === "dry_run_review") ||
+            (cp.gate.kind === "plan_review" && outcome.gate === "plan_review");
+        if (!gateMatch) {
+            throw new CheckpointError("checkpoint.gate_mismatch", `resume outcome (gate "${outcome.gate}") does not match checkpoint gate "${cp.gate.kind}" — resume serves human/policy_ask, irreversible_ask/policy_ask, resource_limit/resource_limit, needs_review/dry_run_review, and plan_review/plan_review`);
+        }
+        const reasonBearing = (outcome.gate === "policy_ask" && outcome.decision === "deny") ||
+            (outcome.gate === "dry_run_review" && outcome.decision === "reject") ||
+            (outcome.gate === "plan_review" && outcome.decision === "reject");
+        if (reasonBearing && outcome.reason && sanitizeUntrustedText(outcome.reason) !== outcome.reason) {
+            throw new CheckpointError("checkpoint.invalid_outcome", "resume deny/reject reason must not contain a </system-reminder> tag");
+        }
+        if (outcome.gate === "plan_review" &&
+            outcome.decision === "edit" &&
+            outcome.editedPlan &&
+            sanitizeUntrustedText(outcome.editedPlan) !== outcome.editedPlan) {
+            throw new CheckpointError("checkpoint.invalid_outcome", "resume editedPlan must not contain a </system-reminder> tag");
+        }
+        if (outcome.gate === "policy_ask") {
+            const boundTo = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.toolCallId : undefined;
+            if (outcome.boundCallId !== boundTo) {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume boundCallId "${outcome.boundCallId}" does not match the checkpoint's pending tool call "${boundTo ?? "(none)"}" — the decision-action binding (design/80 D-1) failed; refusing to apply a decision bound to a different action`);
+            }
+            const boundHash = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction.boundInputHash : undefined;
+            if (boundHash !== undefined) {
+                if (outcome.boundInputHash !== boundHash) {
+                    throw new CheckpointError("checkpoint.invalid_outcome", "resume boundInputHash does not match the checkpoint's pending tool call input — the decision-action input binding (design/80 D-1 §2) failed; refusing to apply an approval bound to a different input (TOCTOU re-mint guard)");
+                }
+            }
+            else if (checkpointVersionOf(cp) >= BINDING_CHECKPOINT_VERSION) {
+                throw new CheckpointError("checkpoint.invalid_outcome", `resume of a binding-version (v${checkpointVersionOf(cp)}) checkpoint whose pending tool call has no persisted boundInputHash — refusing to resume an unbound binding-version checkpoint (corruption / downgrade guard)`);
+            }
+            if (cp.reopenReason === "env_failed") {
+                if (cp.resolvedOutcome === undefined) {
+                    throw new CheckpointError("checkpoint.reopen_revote", "checkpoint was reopened after an env-restore failure (env_failed) but carries no persisted winner to replay — refusing to resume (inconsistent row, fail-closed)");
+                }
+                const incoming = winnerFromOutcome(outcome);
+                if (incoming === undefined || !sameWinner(incoming, cp.resolvedOutcome)) {
+                    throw new CheckpointError("checkpoint.reopen_revote", `this checkpoint was reopened after an env-restore failure (env_failed) — a re-resume is a system retry of the already-approved action, not a re-vote; the supplied decision must replay the persisted winner (boundCallId "${cp.resolvedOutcome.boundCallId}", decision "${cp.resolvedOutcome.decision}"), refusing a different decision`);
+                }
+            }
+        }
+        if (checkpointVersionOf(cp) > MAX_SUPPORTED_CHECKPOINT_VERSION) {
+            throw new CheckpointError("checkpoint.unsupported_version", `checkpoint version ${checkpointVersionOf(cp)} is newer than this worker supports (max ${MAX_SUPPORTED_CHECKPOINT_VERSION})`);
+        }
+        if (cp.state.workspaceHandle !== undefined && this.deps.executionEnvFactory === undefined) {
+            throw new CheckpointError("checkpoint.unsupported_version", "checkpoint has a remote workspaceHandle but no RunnerDeps.executionEnvFactory is wired to rebuild the env");
+        }
+        const won = await store.resolve(token, cp.scope, outcome, { rev: cp.rev ?? 0 });
+        if (!won) {
+            const live = await store.get(token);
+            if (live?.status === "pending") {
+                throw new CheckpointError("checkpoint.reopened_concurrently", "checkpoint changed concurrently (its revision advanced via a resolve/reopen cycle since this resume validated) — not executed; re-resume against the current state");
+            }
+            throw new CheckpointError("checkpoint.already_resolved", "checkpoint already resolved or expired — not re-executed (idempotent)");
+        }
+        const spec = {
+            ...taskConfig,
+            objective: "",
+            sessionId: cp.sessionId,
+            preemptSignal: taskConfig.preemptSignal?.aborted ? undefined : taskConfig.preemptSignal,
+        };
+        const onEnvRestoreFailed = store.reopen
+            ? async (reason) => {
+                await store.reopen?.(token, cp.scope, reason);
+            }
+            : undefined;
+        return this.runTaskStream(spec, { cp, outcome, onEnvRestoreFailed }, internals);
+    }
+    async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess) {
+        const { pendingAction } = resume.cp;
+        if (resume.outcome.gate === "dry_run_review")
+            return;
+        if (resume.outcome.gate === "plan_review")
+            return;
+        if (pendingAction.kind !== "tool_approval")
+            return;
+        if (resume.outcome.gate === "policy_ask" &&
+            resume.outcome.decision === "allow" &&
+            !prepared.tools.some((t) => t.name === canonicalToolName(pendingAction.toolName))) {
+            const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume — refusing to continue as if it ran; the checkpoint is reopened for a retry with the tool present`);
+            e.code = "resume.tool_unavailable";
+            throw e;
+        }
+        const completed = new Set(pendingAction.completedCallIds);
+        const deferredIds = pendingAction.batchToolCallIds.filter((id) => id !== pendingAction.toolCallId && !completed.has(id));
+        const names = new Map();
+        if (deferredIds.length > 0) {
+            const { messages } = await prepared.session.buildContext();
+            for (const m of messages) {
+                if (m.role === "assistant") {
+                    for (const c of m.content) {
+                        if (c.type === "toolCall")
+                            names.set(c.id, c.name);
+                    }
+                }
+            }
+        }
+        for (const id of pendingAction.batchToolCallIds) {
+            if (id === pendingAction.toolCallId) {
+                await this.resolvePendingCall(prepared, resume, emit, emitCommitted, onResolvedToolSuccess);
+            }
+            else if (!completed.has(id)) {
+                const name = names.get(id) ?? "unknown";
+                emit({ type: "tool_end", toolCallId: id, toolName: name, isError: true });
+                const eid = await prepared.session.appendMessage(toolResultMsg(id, name, formatHookFeedback(DEFERRED_REISSUE), true));
+                emitCommitted(eid, "toolResult", id);
+            }
+        }
+    }
+    async resolvePendingCall(prepared, resume, emit, emitCommitted, onResolvedToolSuccess) {
+        const { pendingAction } = resume.cp;
+        const { outcome } = resume;
+        if (pendingAction.kind !== "tool_approval" || outcome.gate !== "policy_ask")
+            return;
+        const resolvedArgs = pendingAction.toolName === ASK_USER_QUESTION_TOOL_NAME ? pendingAction.args : (outcome.updatedInput ?? pendingAction.args);
+        emit({ type: "tool_start", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, args: resolvedArgs });
+        const emitEnd = (isError) => emit({ type: "tool_end", toolCallId: pendingAction.toolCallId, toolName: pendingAction.toolName, isError });
+        if (outcome.decision === "deny") {
+            emitEnd(true);
+            const reason = outcome.reason ? delimitUntrusted("reviewer note", outcome.reason) : `The pending tool call "${pendingAction.toolName}" was denied by an approver.`;
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(reason), true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+            return;
+        }
+        if (prepared.denyNarrowingPolicy) {
+            const narrowed = await prepared.denyNarrowingPolicy.check({ toolName: pendingAction.toolName, args: resolvedArgs, toolCallId: pendingAction.toolCallId }, prepared.abortController.signal);
+            if (narrowed.action === "deny") {
+                emitEnd(true);
+                const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, formatHookFeedback(`The approved tool call "${pendingAction.toolName}" is now denied by a session rule and was not executed${narrowed.reason ? `: ${narrowed.reason}` : ""}.`), true));
+                emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+                return;
+            }
+        }
+        const tool = prepared.tools.find((t) => t.name === canonicalToolName(pendingAction.toolName));
+        if (!tool) {
+            const e = new Error(`the approved tool "${pendingAction.toolName}" is no longer available on resume`);
+            e.code = "resume.tool_unavailable";
+            throw e;
+        }
+        const args = resolvedArgs;
+        try {
+            const res = await tool.execute(pendingAction.toolCallId, args, prepared.abortController.signal);
+            emitEnd(false);
+            onResolvedToolSuccess?.(canonicalToolName(pendingAction.toolName), res.details);
+            const eid = await prepared.session.appendMessage({
+                role: "toolResult",
+                toolCallId: pendingAction.toolCallId,
+                toolName: pendingAction.toolName,
+                content: res.content,
+                details: res.details,
+                isError: false,
+                timestamp: Date.now(),
+            });
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+        }
+        catch (err) {
+            emitEnd(true);
+            const eid = await prepared.session.appendMessage(toolResultMsg(pendingAction.toolCallId, pendingAction.toolName, `Error: ${err instanceof Error ? err.message : String(err)}`, true));
+            emitCommitted(eid, "toolResult", pendingAction.toolCallId);
+        }
+    }
+    seamCCompactionOptions(prepared) {
+        if (!this.deps.summaryProvider)
+            return undefined;
+        return {
+            summaryProvider: this.deps.summaryProvider,
+            onCompaction: this.deps.onCompaction,
+            maxConsecutiveProviderReuse: this.deps.maxConsecutiveProviderReuse,
+            consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
+        };
+    }
+    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);
+        }
+        catch {
+        }
+    }
+    compactionHookOptions(spec, sessionId, trigger) {
+        const hooks = spec.hooks ?? this.deps.hooks;
+        const pre = hooks?.preCompact;
+        const post = hooks?.postCompact;
+        return {
+            trigger,
+            ...(pre
+                ? {
+                    preCompact: async (ctx) => {
+                        const report = (err) => {
+                            try {
+                                this.deps.onError?.(err, { phase: "hook", sessionId });
+                            }
+                            catch {
+                            }
+                        };
+                        try {
+                            const r = await pre.call(hooks, ctx);
+                            if (r?.block && ctx.trigger === "forced") {
+                                report(new Error(`a preCompact callback blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
+                            }
+                            return r;
+                        }
+                        catch (err) {
+                            report(err instanceof Error ? err : new Error(String(err)));
+                            return undefined;
+                        }
+                    },
+                }
+                : {}),
+            ...(post
+                ? {
+                    postCompact: async (ctx) => {
+                        try {
+                            await post.call(hooks, ctx);
+                        }
+                        catch (err) {
+                            try {
+                                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "hook", sessionId });
+                            }
+                            catch {
+                            }
+                        }
+                    },
+                }
+                : {}),
+        };
+    }
+    recordCompactionReuse(prepared, comp) {
+        if (!this.deps.summaryProvider || !comp.compacted)
+            return;
+        prepared.compactionReuseRef.consecutive = comp.reused ? prepared.compactionReuseRef.consecutive + 1 : 0;
+    }
+    async finish(spec, prepared, opts) {
+        let comp;
+        if (!opts?.skipCompaction) {
+            try {
+                const finishComp = await maybeCompact({
+                    session: prepared.session,
+                    model: prepared.model,
+                    compactionModel: prepared.compModel,
+                    brain: opts?.brain ?? this.deps.brain,
+                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                    thinking: prepared.thinking,
+                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                    minTokens: opts?.minTokens,
+                    overheadTokens: prepared.promptOverheadTokens,
+                    onInputTruncated: (info) => emitTrace(spec.tracer ?? this.deps.tracer, () => ({
+                        kind: "compaction.input_truncated",
+                        version: 1,
+                        taskId: spec.taskId ?? prepared.sessionId,
+                        label: info.label,
+                        droppedChars: info.droppedChars,
+                        keptChars: info.keptChars,
+                        ts: Date.now(),
+                    })),
+                    workingFileAttachments: spec.compaction?.attachWorkingFiles !== false && prepared.readTaskFile
+                        ? {
+                            readFile: prepared.readTaskFile,
+                            ...(prepared.recentlyReadFiles ? { recentlyReadFiles: prepared.recentlyReadFiles } : {}),
+                            ...(typeof spec.compaction?.attachWorkingFiles === "object" ? spec.compaction.attachWorkingFiles : undefined),
+                        }
+                        : undefined,
+                    ...this.seamCCompactionOptions(prepared),
+                    ...this.compactionHookOptions(spec, prepared.sessionId, "auto"),
+                });
+                this.recordCompactionReuse(prepared, finishComp);
+                comp = finishComp;
+            }
+            catch (err) {
+                this.deps.onError?.(err, { phase: "compaction", sessionId: prepared.sessionId });
+            }
+        }
+        try {
+            await this.sessions.touch(prepared.sessionId);
+        }
+        catch (err) {
+            this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
+        }
+        try {
+            await prepared.mcp.dispose();
+        }
+        catch (err) {
+            this.deps.onError?.(err, { phase: "mcp", sessionId: prepared.sessionId });
+        }
+        return comp;
+    }
+    async teardownOwnedEnv(prepared) {
+        if (prepared.ownedEnv &&
+            hasDestroy(prepared.ownedEnv) &&
+            prepared.suspendRef.token === undefined &&
+            prepared.reviewRef.token === undefined) {
+            try {
+                await prepared.ownedEnv.destroy();
+            }
+            catch (err) {
+                this.deps.onError?.(err, { phase: "config", sessionId: prepared.sessionId });
+            }
+        }
+    }
+}
+export function runTask(spec, deps) {
+    return new Runner(deps).runTask(spec);
+}
+const WALLTIME_SUSPEND_GRACE_SEC = 120;
+function startTimeout(harness, abortController, timeoutSec, softSuspendable = false) {
+    const state = { fired: false, clear: () => { } };
+    if (timeoutSec && timeoutSec > 0) {
+        const hardSec = softSuspendable ? timeoutSec + WALLTIME_SUSPEND_GRACE_SEC : timeoutSec;
+        const timer = setTimeout(() => {
+            state.fired = true;
+            abortController.abort();
+            void harness.abort();
+        }, hardSec * 1000);
+        timer.unref?.();
+        state.clear = () => clearTimeout(timer);
+    }
+    return state;
+}
+//# sourceMappingURL=runtask.js.map