@sema-agent/core 5.64.0 → 6.0.0

package/dist/core/runner/runtask.js

@@ -34,21 +34,22 @@ import { toImageContent } from "./image.js";
 import { OUTPUT_TOOL_NAME, SKILLS_LISTING_PROBE_HEADER, 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, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
-import { buildWorkingFileAttachments, centerAdoptionOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
-import { effectiveDelegationFacts, gatedCallIdOf, prepareTask, resolveCheckpointStore } from "./prepare-task.js";
+import { ATTACHMENT_BYTE_CAP, CHANGED_FILES_MAX, TOTAL_TOKENS_REMINDER_DEFAULT_MODE, AGENT_LISTING_REMOVED_HEADER, SKILLS_LISTING_DELTA_HEADER, SKILLS_LISTING_REMOVED_HEADER, advanceCadenceClock, agentListingDeltaHeader, attachmentEnvelopeTags, agentListingInitialHeader, replayAnnouncedListing, replayAnnouncedModels, clipToBytes, collectDateChange, collectDueAttachments, collectInstructionsChange, commitAgentListing, commitInstructionsChange, commitSkillsListing, createAttachmentState, rebaseCadenceWindows, reduceToolEnd, renderAgentListingDelta, renderMcpDroppedTools, renderMcpInstructionsDelta, renderOrphanedBackgroundTasks, selectMcpDroppedBatch, renderSkillsListingDelta, renderToolsDelta, stampWriteAnchor } from "./turn-attachments.js";
+import { buildWorkingFileAttachments, centerAdoptionOption, contextInstructionFilesOption, emitInputTruncated, forkContextOption } from "./compaction-call-options.js";
+import { effectiveDelegationFacts, gatedCallIdOf, placementValueOrAbsent, prepareTask, resolveCheckpointStore } from "./prepare-task.js";
+import { SessionReadFileStates } from "./prepare-hands-readface.js";
 import { settleTeardownLeg } from "./teardown-bounded.js";
 import { TOOL_SEARCH_NAME } from "./tool-disclosure.js";
 import { hasVerifiableStructureSignal } from "./grounding-signal.js";
 import { hasDestroy, isIsolated } from "../remote-env.js";
 import { hasBackgroundShell, sweepBackgroundShells } from "../background-shell.js";
-import { cloneObserverInput, formatHookFeedback, hookSeatExpiredError, mintHookInvocationIdentity, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
+import { cloneObserverInput, formatHookFeedback, hookSeatExpiredError, MAX_HOOK_TIMEOUT_MS, mintHookInvocationIdentity, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
 import { buildHumanInputEvent, frameMidTurnUserInput, projectHumanInput } from "../human-input-projection.js";
 import { delimitUntrusted, inlineUntrusted, REVIEWER_NOTE_MAX_BODY, sanitizeUntrustedText, SHELLED_BODY_ENVELOPE_TAGS } from "../untrusted-text.js";
 import { appendInterruptionMarker, reconcileInterruptedSession } from "../session-reconcile.js";
 import { RunnerSharedToolResultStore } from "../tool-result-store.js";
 import { formatDiagnosticsBlock } from "../lsp-diagnostics.js";
-import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOf, isApprovalSettledBy, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
+import { checkToolPolicyProjection, constraintChainDigest, constraintChainEntryOfSuppliedLayer, isApprovalSettledBy, refuseOutOfContractDecision, screenApproverAttribution, toolPolicyNameSets } from "../tool-policy.js";
 import { defaultTaskRegistry } from "../task-registry.js";
 import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
@@ -57,7 +58,7 @@ import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-
 import { structuredFrom, toolOutputFrom } from "./tool-output-projection.js";
 function createRunState() {
     return {
-        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, pricingConfigured: true, unpricedSpend: false, tracer: undefined, taskId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
+        telemetry: { cacheFamily: "input-excludes-cached", pricing: { inputPer1M: 0, outputPer1M: 0 }, pricingConfigured: true, unpricedSpend: false, tracer: undefined, taskId: "", runId: "", taskStart: 0, taskStartMonotonic: 0, cacheBreakReported: false },
         degrade: { degradeToModel: undefined, degraded: undefined, outputErrorStreak: 0, outputInvalid: false, recordDegraded: () => { } },
         limits: { turnsExceeded: false, budgetHit: undefined, budgetAxis: undefined, platformTerminal: undefined, outputRetryCap: 0, effectiveMaxTurns: undefined },
         budget: { remainingMicroUsd: undefined, maxCostMicroUsd: undefined, remainingTokens: undefined, maxTokensWindow: undefined, overBudget: () => undefined, streamCancel: false, callOutputChars: 0, lastStreamBudgetCheck: 0, projectedOverBudget: () => undefined },
@@ -84,6 +85,7 @@ function sameAcceptedSteerInput(a, b) {
         a.actor?.issuer === b.actor?.issuer);
 }
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
+const RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS = 10_000;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
 const COMPACTION_FREED_EPSILON = 256;
@@ -123,8 +125,6 @@ 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;
 const LIMIT_APPROACH_DEFAULT_THRESHOLDS = [0.8, 0.95];
 const DEFAULT_PRECALL_OUTPUT_TOKENS = 4096;
 function limitApproachFrames(index, axis, percent, mark) {
@@ -606,7 +606,13 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                 const mcpRemovals = mcpInstructionsOn && mcpDelta.pendingRemovals.length > 0 ? [...mcpDelta.pendingRemovals] : undefined;
                 const mcpDropped = mcpInstructionsOn && prepared.mcp.droppedTools.length > 0 ? selectMcpDroppedBatch(prepared.mcp.droppedTools) : undefined;
                 const budgetUsdOn = rs.attach.attachmentsCfg?.budgetUsd === true && rs.budget.maxCostMicroUsd !== undefined && rs.turn.lastTurnHadToolCalls;
-                const totalTokensOn = rs.attach.attachmentsCfg?.totalTokensReminder === true && rs.turn.lastTurnHadToolCalls;
+                const totalTokensDeclared = rs.attach.attachmentsCfg?.totalTokensReminder;
+                const totalTokensMode = rs.attach.attachmentsCfg?.totalTokensReminderMode ?? TOTAL_TOKENS_REMINDER_DEFAULT_MODE;
+                const totalTokensArmedByDefault = totalTokensDeclared === undefined &&
+                    eventDefaultOn("total_tokens_reminder") &&
+                    totalTokensMode !== "fixed" &&
+                    totalTokensMode !== "infinite";
+                const totalTokensOn = (totalTokensDeclared === true || totalTokensArmedByDefault) && rs.turn.lastTurnHadToolCalls;
                 const toolSearchReminderOn = rs.attach.attachmentsCfg?.toolSearchReminder === true && prepared.deferredToolNames !== undefined;
                 const undiscoveredTools = toolSearchReminderOn
                     ? [...prepared.deferredToolNames].filter((n) => !prepared.activeTools.has(n)).sort()
@@ -896,6 +902,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                 overheadTokens: prepared.promptOverheadTokens,
                 ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
                 workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                ...contextInstructionFilesOption(prepared),
                 ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                 ...runnerHooks.seamCCompactionOptions(prepared),
                 ...gitRestateOption(prepared),
@@ -1164,6 +1171,8 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
         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 (event.entryId !== undefined && m.role === "user")
+            prepared.fileHistoryBoundary?.begin(event.entryId);
         if (event.entryId !== undefined && m.role === "user" && prepared.gitStatusRef.pendingReceipt !== undefined) {
             const pr = prepared.gitStatusRef.pendingReceipt;
             const c = m.content;
@@ -1452,9 +1461,11 @@ export class Runner {
     deps;
     sessions;
     sessionLocks = new Map();
-    snapshotTooLargeRoots = new Map();
+    sessionReadStates = new SessionReadFileStates();
     pendingSessionNotifications = new PendingSessionNotifications();
     parentConstraintRegistry = new Map();
+    suspendedEnvReaps = new Map();
+    locallyClaimedTokens = new Set();
     static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
     constructor(deps) {
         this.deps = deps;
@@ -1602,7 +1613,7 @@ export class Runner {
         deliverEngineNotice(this.deps.onNotice, {
             code: "config.models_swapped",
             message: `model catalog swapped: ${Object.keys(next.models).length} model(s), ${tiers ? Object.keys(tiers).length : 0} tier binding(s); in-flight tasks finish on their resolved models, new tasks resolve against the new catalog`,
-            detail: { models: Object.keys(next.models).length, tiers: tiers ? Object.keys(tiers).length : 0 },
+            detail: { models: Object.keys(next.models).length, tiers: tiers ? Object.keys(tiers).length : 0, occurrenceId: uuidv7() },
         });
         if (movedEntries.length > 0) {
             const RENDER_CAP = 8;
@@ -1613,7 +1624,7 @@ export class Runner {
                     rendered.map((e) => `"${e.modelId}" ${e.from || "(config root)"} → ${e.to || "(config root)"}`).join("; ") +
                     (movedEntries.length > rendered.length ? `; +${movedEntries.length - rendered.length} more` : "") +
                     " — if the provider changed (not just its domain), update the credential reference in the same step",
-                detail: { entries: rendered, total: movedEntries.length },
+                detail: { entries: rendered, total: movedEntries.length, occurrenceId: uuidv7() },
             });
         }
     }
@@ -1626,6 +1637,7 @@ export class Runner {
                 "(Note the parameter order: runTaskStream(spec, resume?, internals?) — internals is the THIRD parameter.)");
         }
         const entryActor = spec.actor === undefined ? undefined : snapshotActorAssertion(spec.actor);
+        const entryTracer = { tracer: spec.tracer ?? this.deps.tracer };
         const queue = new PushQueue();
         const detachHub = new ToolDetachHub();
         let resultValue;
@@ -1647,6 +1659,7 @@ export class Runner {
         let steerChain = Promise.resolve();
         const acceptedSteerInputs = new Map();
         const notifyRef = {};
+        const captureOptOutRef = {};
         const manualCompactRef = { requested: false, waiters: [] };
         const drainManualCompactWaiters = (outcome) => {
             manualCompactRef.requested = false;
@@ -1663,8 +1676,11 @@ export class Runner {
                 await this.runLocked(spec, queue, (r) => {
                     resultValue = r;
                     const pcs = internals?.inheritedGate?.parentConstraints;
+                    if (resume !== undefined)
+                        this.locallyClaimedTokens.delete(resume.cp.token);
                     if (resume !== undefined && r.checkpointToken !== resume.cp.token) {
                         this.parentConstraintRegistry.delete(resume.cp.token);
+                        this.suspendedEnvReaps.delete(resume.cp.token);
                     }
                     if (r.status === "suspended" && r.checkpointToken !== undefined && pcs !== undefined && pcs.length > 0) {
                         if (this.parentConstraintRegistry.size >= Runner.PARENT_CONSTRAINT_REGISTRY_CAP) {
@@ -1681,7 +1697,8 @@ export class Runner {
                     publishReady(h);
                 }, (s) => {
                     reapHandle = s;
-                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef, entryActor);
+                    this.suspendedEnvReaps.set(s.token, s);
+                }, manualCompactRef, taskIdRef, resume, { ...(internals ?? {}), detachHub }, notifyRef, captureOptOutRef, entryActor, entryTracer);
             }
             finally {
                 releaseLock?.();
@@ -1698,6 +1715,7 @@ export class Runner {
             const reopenReason = code === "resume.tool_unavailable" ? "tool_unavailable" : "env_failed";
             const reopenable = resume !== undefined && resume.pendingActionStarted !== true && reopenReason !== undefined && !(resumeDecisionWasNegative(resume) && resume.decisionDelivered === true);
             let reopenCommitted = false;
+            let reopenStateUnknown = false;
             if (reopenable && resume?.onEnvRestoreFailed) {
                 try {
                     await resume.onEnvRestoreFailed(reopenReason);
@@ -1708,15 +1726,26 @@ export class Runner {
                     const original = err instanceof Error ? err : new Error(String(err));
                     const reopenMsg = reopenErr instanceof Error ? reopenErr.message : String(reopenErr);
                     const definitive = errorCodeOf(reopenErr) === "checkpoint.reopen_failed";
+                    reopenStateUnknown = !definitive;
                     err = Object.assign(new Error(definitive
                         ? `${reopenMsg} (original resume failure: ${original.message})`
                         : `checkpoint reopen threw mid-flight — state UNKNOWN, confirm via the checkpoint store before retrying: ${reopenMsg} (original resume failure: ${original.message})`, { cause: original }), { code: "checkpoint.reopen_failed" });
                     code = "checkpoint.reopen_failed";
                 }
             }
+            if (resume)
+                this.locallyClaimedTokens.delete(resume.cp.token);
             if (resume && !reopenCommitted) {
                 this.parentConstraintRegistry.delete(resume.cp.token);
                 await settleTeardownLeg(() => this.sessions.unpin?.(resume.cp.sessionId), "sessions.unpin (resume-failure leg)", (e) => this.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
+                if (!reopenStateUnknown) {
+                    const failedReap = this.suspendedEnvReaps.get(resume.cp.token);
+                    this.suspendedEnvReaps.delete(resume.cp.token);
+                    if (failedReap?.env !== undefined && hasDestroy(failedReap.env)) {
+                        const failedEnv = failedReap.env;
+                        await settleTeardownLeg(() => failedEnv.destroy(), "terminal resume-failure env destroy", (e) => this.deps.onError?.(e, { phase: "config", sessionId: resume.cp.sessionId }));
+                    }
+                }
             }
             if (resultValue !== undefined) {
                 try {
@@ -1740,6 +1769,7 @@ export class Runner {
             resultValue = {
                 taskId: taskIdRef.current ?? "unknown",
                 sessionId: taskIdRef.sessionId ?? "unknown",
+                ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
                 status: "failed",
                 result: "",
                 errorMessage: err instanceof Error ? err.message : String(err),
@@ -1755,10 +1785,11 @@ export class Runner {
                 })(),
                 stats: { turns: 0, tokens: 0, toolCalls: 0, cachedTokens: 0, costMicroUsd: 0 },
             };
-            emitTrace(spec.tracer ?? this.deps.tracer, () => ({
+            emitTrace(entryTracer.tracer, () => ({
                 kind: "task.end",
                 version: 1,
                 taskId: taskIdRef.current ?? "unknown",
+                ...(taskIdRef.runId !== undefined ? { runId: taskIdRef.runId } : {}),
                 status: "failed",
                 errorCode: code,
                 turns: 0,
@@ -1802,9 +1833,13 @@ export class Runner {
                 reportErr(err);
                 return;
             }
-            if (!won)
+            if (!won) {
+                if (!this.locallyClaimedTokens.has(rh.token))
+                    this.suspendedEnvReaps.delete(rh.token);
                 return;
+            }
             this.parentConstraintRegistry.delete(rh.token);
+            this.suspendedEnvReaps.delete(rh.token);
             if (rh.env && hasDestroy(rh.env)) {
                 try {
                     await rh.env.destroy();
@@ -1962,6 +1997,7 @@ export class Runner {
                                 detail: {
                                     inputId: effectiveInputId,
                                     sessionId: h.sessionId,
+                                    runId: h.runId,
                                     ...(actor?.id !== undefined ? { actorId: actor.id } : {}),
                                     ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
                                 },
@@ -2042,6 +2078,26 @@ export class Runner {
                 }
                 notifyRef.inject(payload, priority !== undefined ? { priority } : undefined);
             },
+            optOutMemoryCapture: async (options) => {
+                const reasonIn = options?.reason;
+                if (reasonIn !== undefined && typeof reasonIn !== "string") {
+                    const e = new Error(`cannot opt out of memory capture: options.reason must be a string when present`);
+                    e.code = "steering.invalid_content";
+                    throw e;
+                }
+                const reason = reasonIn;
+                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 (captureOptOutRef.flip === undefined) {
+                    const e = new Error(`cannot opt out of memory capture: this run mounted no memory session (no memory spec / no backend / prepare degraded memory-less) — there is nothing to opt out of`);
+                    e.code = "memory.capture_optout_unavailable";
+                    throw e;
+                }
+                return captureOptOutRef.flip(reason);
+            },
             compact: async (opts) => {
                 if (resultValue)
                     throw steeringError("the task has already finished");
@@ -2095,6 +2151,60 @@ export class Runner {
                 h.abortController.abort();
                 void h.harness.abort();
             },
+            halt: async () => {
+                const haltRefused = (msg) => {
+                    const e = new Error(`cannot halt: ${msg}`);
+                    e.code = "steering.not_running";
+                    return e;
+                };
+                if (resultValue)
+                    throw haltRefused("the task has already finished");
+                const h = handle ?? (await orTimeout(ready));
+                if (!h)
+                    throw haltRefused("the task is not running");
+                const apply = () => {
+                    const abortOwnedBeforeHalt = h.abortController.signal.aborted;
+                    const receipt = h.harness.halt();
+                    if (receipt.accepted && !abortOwnedBeforeHalt)
+                        h.loop.userHalted = true;
+                    if (receipt.turnCut) {
+                        deliverEngineNotice(this.deps.onNotice, {
+                            code: "task.turn_interrupted",
+                            message: "a bare user halt cut the running turn: in-flight work was cut at a manufactured boundary " +
+                                "(finished tool calls keep their real results; never-started ones settle as interrupted) and " +
+                                "the run is collecting to a clean, resumable stop — no further model turn will start.",
+                            detail: {
+                                cause: "user_halt",
+                                sessionId: h.sessionId,
+                                runId: h.runId,
+                                ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                            },
+                        });
+                    }
+                    return { turnCut: receipt.turnCut };
+                };
+                try {
+                    if (resultValue !== undefined || h.loop.ended)
+                        throw haltRefused("the task is no longer running");
+                    return apply();
+                }
+                catch (e) {
+                    if (!(e instanceof Error && e.code === "invalid_state"))
+                        throw e;
+                }
+                const birthDeadline = Date.now() + READY_TIMEOUT_MS;
+                while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
+                    try {
+                        return apply();
+                    }
+                    catch (e2) {
+                        if (!(e2 instanceof Error && e2.code === "invalid_state"))
+                            throw e2;
+                    }
+                    await new Promise((r) => setTimeout(r, 10));
+                }
+                throw haltRefused("the task is no longer running");
+            },
             destroy: () => (destroyOnce ??= (async () => {
                 const h = handle ?? (await orTimeout(ready));
                 if (h) {
@@ -2106,7 +2216,7 @@ export class Runner {
             })()),
         };
     }
-    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, entryActor) {
+    async runLocked(spec, queue, setResult, onSuggestions, onReady, onSuspend, manualCompactRef, taskIdRef, resume, internals, notifyRef, captureOptOutRef, entryActor, entryTracer) {
         const prepareResume = resume
             ? {
                 leafId: resume.cp.leafId,
@@ -2210,6 +2320,7 @@ export class Runner {
             peerSelfRef,
             peerInboundChainRef,
             detachHub,
+            sessionReadStates: this.sessionReadStates,
             onTaskNotification: (notification, opts) => {
                 try {
                     upstreamTaskNotification?.(notification, opts);
@@ -2218,7 +2329,7 @@ export class Runner {
                 }
                 injectTaskNotification(notification, opts);
             },
-        }, this);
+        }, this, taskIdRef);
         notificationHarness = prepared.harness;
         notificationSessionId = prepared.sessionId;
         if (taskIdRef)
@@ -2258,7 +2369,7 @@ export class Runner {
                 undrainedUserAtEnd = counts;
                 return;
             }
-            for (const notice of undrainedUserInputNotices(counts, spec.taskId, prepared.sessionId)) {
+            for (const notice of undrainedUserInputNotices(counts, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
                 deliverEngineNotice(this.deps.onNotice, notice);
             }
         };
@@ -2269,6 +2380,9 @@ export class Runner {
         };
         if (notifyRef)
             notifyRef.inject = injectTaskNotification;
+        if (captureOptOutRef && prepared.memoryEngineSession?.captureOptOut !== undefined) {
+            captureOptOutRef.flip = prepared.memoryEngineSession.captureOptOut.flip;
+        }
         try {
             internals?.onNotifyInjectorReady?.(injectTaskNotification);
         }
@@ -2287,8 +2401,8 @@ export class Runner {
                 }
             }
         }
-        const loopLatch = { ended: false, userInterrupted: false };
-        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity });
+        const loopLatch = { ended: false, userInterrupted: false, userHalted: false };
+        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, runId: prepared.runId, hookTimeoutMs: prepared.hookTimeoutMs, hookIdentity: prepared.hookIdentity });
         const stats = { turns: 0, tokens: 0, toolCalls: 0, promptTokens: 0, totalInputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cacheWriteTokensLong: 0, outputTokens: 0, costMicroUsd: 0 };
         prepared.liveSpendRef.get = () => ({ costMicroUsd: stats.costMicroUsd, tokens: stats.tokens, turns: stats.turns, walltimeMs: Math.round(performance.now() - rs.telemetry.taskStartMonotonic) });
         if (resume &&
@@ -2329,8 +2443,9 @@ export class Runner {
         rs.telemetry.cacheBreakReported = false;
         rs.limits.outputRetryCap = resolveOutputRetries(spec.outputRetries);
         rs.limits.effectiveMaxTurns = resolveMaxTurns(spec.limits);
-        rs.telemetry.tracer = spec.tracer ?? this.deps.tracer;
+        rs.telemetry.tracer = entryTracer !== undefined ? entryTracer.tracer : (spec.tracer ?? this.deps.tracer);
         rs.telemetry.taskId = runSourceTaskId;
+        rs.telemetry.runId = prepared.runId;
         if (taskIdRef) {
             taskIdRef.current = rs.telemetry.taskId;
             taskIdRef.sessionId = prepared.sessionId;
@@ -2345,7 +2460,7 @@ export class Runner {
             }
         };
         try {
-            void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, rs.telemetry.taskId)).catch(discloseNoteTaskRunFailure);
+            void Promise.resolve(this.sessions.noteTaskRun?.(prepared.sessionId, rs.telemetry.taskId, rs.telemetry.runId)).catch(discloseNoteTaskRunFailure);
         }
         catch (err) {
             discloseNoteTaskRunFailure(err);
@@ -2631,7 +2746,7 @@ export class Runner {
         const writeFamilyOf = (name) => writeFamilyByName.get(name) ?? writeFamilyOfCanonical(name);
         const toolStartAt = new Map();
         const startedToolCallIds = new Set();
-        emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
+        emitTrace(rs.telemetry.tracer, () => ({ kind: "task.start", version: 1, taskId: rs.telemetry.taskId, runId: rs.telemetry.runId, model: prepared.model.id, engineVersion: engineVersion(), ts: rs.telemetry.taskStart }));
         emitTrace(rs.telemetry.tracer, () => ({
             kind: "prompt.assembled",
             version: 1,
@@ -2723,7 +2838,9 @@ export class Runner {
                 }
             }
         };
+        const ownCommittedTailRef = { current: undefined };
         const emitCommitted = (entryId, role, toolCallId) => {
+            ownCommittedTailRef.current = entryId;
             if (role === "toolResult" && toolCallId !== undefined)
                 startedToolCallIds.delete(toolCallId);
             queue.push({ type: "message_committed", entryId, role, ...(toolCallId !== undefined ? { toolCallId } : {}), ...ident() });
@@ -2739,6 +2856,7 @@ export class Runner {
                 ...(s.detail !== undefined ? { detail: s.detail } : {}),
                 ...(s.retryInSec !== undefined ? { retryInSec: s.retryInSec } : {}),
                 ...(s.retryInMs !== undefined ? { retryInMs: s.retryInMs } : {}),
+                ...(s.retryAtMs !== undefined ? { retryAtMs: s.retryAtMs } : {}),
                 ...(s.attempt !== undefined ? { attempt: s.attempt } : {}),
                 ...(s.maxRetries !== undefined ? { maxRetries: s.maxRetries } : {}),
                 ...(s.errClass !== undefined ? { errClass: s.errClass } : {}),
@@ -3056,6 +3174,7 @@ export class Runner {
                     ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
                     onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
                     workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                    ...contextInstructionFilesOption(prepared),
                     ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                     ...this.seamCCompactionOptions(prepared),
                     ...gitRestateOption(prepared),
@@ -3456,6 +3575,7 @@ export class Runner {
                                         detail: {
                                             ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
                                             sessionId: prepared.sessionId,
+                                            runId: prepared.runId,
                                             ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
                                         },
                                     });
@@ -3836,7 +3956,7 @@ export class Runner {
                 steer: Math.max(0, undrainedUserAtEnd.steer - migratedParked.steer),
                 followUp: Math.max(0, undrainedUserAtEnd.followUp - migratedParked.followUp),
             };
-            for (const notice of undrainedUserInputNotices(remaining, spec.taskId, prepared.sessionId)) {
+            for (const notice of undrainedUserInputNotices(remaining, spec.taskId ?? prepared.sessionId, prepared.sessionId, prepared.runId)) {
                 deliverEngineNotice(this.deps.onNotice, notice);
             }
         }
@@ -3844,6 +3964,7 @@ export class Runner {
             emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.announce_dropped", version: 1, taskId: rs.telemetry.taskId, ts: Date.now() }));
         }
         const comp = await this.finish(spec, prepared, {
+            telemetry: { tracer: rs.telemetry.tracer, taskId: rs.telemetry.taskId },
             skipCompaction: durablyPaused || compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES,
             minTokens: rs.counters.compactionFloor,
             brain: compactionBrain,
@@ -3928,10 +4049,12 @@ export class Runner {
             }
             const result = assembleResult(spec, prepared.sessionId, final, stats, {
                 threw,
+                runId: prepared.runId,
                 model: prepared.model.id,
                 unpricedSpend: rs.telemetry.unpricedSpend,
                 rewindNotes: prepared.rewindNotes,
                 haltedOnUserRejection: prepared.batchHaltRef.current !== undefined,
+                userHalted: loopLatch.userHalted,
                 strandedHumanAnswers,
                 remoteEnvFailures: prepared.remoteEnvFailures,
                 effectiveReadFace: prepared.effectiveReadFace,
@@ -3985,6 +4108,7 @@ export class Runner {
                     r.errorMessage = `${r.errorMessage ?? "the resume leg did not complete"} — the approved action never started, and reopening the checkpoint FAILED: its state is unprovable from here. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead`;
                 }
             }
+            prepared.sealReadStateSeat?.(ownCommittedTailRef.current);
             {
                 const wss = prepared.workspaceStateSettle;
                 if (wss !== undefined && result.status !== "suspended" && result.status !== "needs_review") {
@@ -4073,6 +4197,7 @@ export class Runner {
                 kind: "task.end",
                 version: 1,
                 taskId: rs.telemetry.taskId,
+                runId: rs.telemetry.runId,
                 status: result.status,
                 errorCode: result.errorCode,
                 turns: stats.turns,
@@ -4116,9 +4241,7 @@ export class Runner {
             manualCompactRef.emitMooted = undefined;
             queue.push({ type: "done", result });
             queue.close();
-            if (spec.rewindFiles && result.status === "completed") {
-                await this.snapshotTurn(prepared);
-            }
+            await prepared.fileHistoryBoundary?.settle();
             if (spec.suggestNextPrompts && result.status === "completed") {
                 onSuggestions(this.suggestNextPrompts(spec, prepared, result));
             }
@@ -4197,7 +4320,7 @@ export class Runner {
             if (!sameRouteIdentity(model, prepared.model)) {
                 const verdict = await adjudicateDerivedRoute({ brain: this.deps.brain, model, getApiKeyAndHeaders: spec.getApiKeyAndHeaders });
                 if (verdict !== undefined && !verdict.ok) {
-                    deliverEngineNotice(this.deps.onNotice, fallbackToPrimaryNotice({ seat: "prompt-suggestions", from: model.id, to: prepared.model.id, verdict, sessionId: prepared.sessionId }));
+                    deliverEngineNotice(this.deps.onNotice, fallbackToPrimaryNotice({ seat: "prompt-suggestions", from: model.id, to: prepared.model.id, verdict, sessionId: prepared.sessionId, runId: prepared.runId }));
                     model = prepared.model;
                     thinking = prepared.thinking;
                 }
@@ -4230,71 +4353,6 @@ export class Runner {
             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 refusal = this.snapshotTooLargeRoots.get(root);
-            if (refusal !== undefined) {
-                if (Date.now() - refusal.refusedAt < SNAPSHOT_TOO_LARGE_TTL_MS) {
-                    if (!refusal.skipAnnounced) {
-                        refusal.skipAnnounced = true;
-                        try {
-                            this.deps.onError?.(new Error(`rewind-files snapshot skipped for this working-tree root: a too_large refusal is still inside its ${SNAPSHOT_TOO_LARGE_TTL_MS / 60_000}-minute cooldown (re-probed at ${new Date(refusal.refusedAt + SNAPSHOT_TOO_LARGE_TTL_MS).toISOString()}) — turns completed during the cooldown capture no snapshot and cannot be rewound to. Announced once per cooldown window.`), { phase: "rewind", sessionId: prepared.sessionId, classification: "too_large" });
-                        }
-                        catch {
-                        }
-                    }
-                    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);
-            });
-            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";
-                const refusedAt = Date.now();
-                if (tooLarge && !this.snapshotTooLargeRoots.has(root))
-                    this.snapshotTooLargeRoots.set(root, { refusedAt, skipAnnounced: false });
-                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) during a ${SNAPSHOT_TOO_LARGE_TTL_MS / 60_000}-minute cooldown, until ${new Date(refusedAt + SNAPSHOT_TOO_LARGE_TTL_MS).toISOString()}, when the tree is re-probed automatically. Raise the store's snapshotBounds to accept a tree this size; shrinking the tree also re-enables rewind, but only at that re-probe — not immediately`
-                            : "")), { 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) {
@@ -4314,6 +4372,7 @@ export class Runner {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome must be an object naming its gate (got ${outcome === null ? "null" : typeof outcome})`);
         }
         const config = typeof taskConfig === "object" && taskConfig !== null ? { ...taskConfig } : taskConfig;
+        internals = internals !== undefined ? { ...internals } : undefined;
         const store = resolveCheckpointStore(config, this.deps);
         if (!store) {
             throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
@@ -4663,12 +4722,13 @@ export class Runner {
                         "(corrupt / inconsistently-minted row) — the frozen deny data the resume would execute is not the data the " +
                         "digest authenticates; rejected pre-CAS (the checkpoint stays pending)");
                 }
-                const suppliedDigest = constraintChainDigest((internals?.inheritedGate?.parentConstraints ?? []).map((pc) => constraintChainEntryOf(pc.policy, { ...(pc.autoMode !== undefined ? { autoModeArmed: true } : {}), ...(pc.durableMandate === true ? { durableMandate: true } : {}), ...(pc.contentMandate === true ? { contentMandate: true } : {}) })));
+                const suppliedDigest = constraintChainDigest((internals?.inheritedGate?.parentConstraints ?? []).map((pc, i) => constraintChainEntryOfSuppliedLayer(pc, persistedChain[i])));
                 if (suppliedDigest !== expectedDigest) {
                     throw new CheckpointError("resume.parent_constraint_mismatch", "the re-supplied parent-constraint chain's projection content does not match what the checkpoint recorded " +
                         `(recorded ${expectedDigest}, re-supplied ${suppliedDigest}) — a same-shape chain with different frozen ` +
                         "deny data would run the resumed leg under a different ancestor gate than it suspended with; " +
-                        "rejected pre-CAS (the checkpoint stays pending) — re-resume with the original chain's policies");
+                        "rejected pre-CAS (the checkpoint stays pending) — re-resume with the original chain's policies " +
+                        "(including, when the row recorded one, the ancestor's auto-mode arming recipe verbatim)");
                 }
             }
         }
@@ -4694,6 +4754,15 @@ export class Runner {
                     "running the resumed leg under a different identity would move its usage-ledger bucket, scope derivation and attribution; " +
                     "refused pre-CAS (the checkpoint stays pending): re-resume with the original principal, or omit the field to inherit the recorded one");
             }
+            {
+                const recordedPlacementRoot = placementValueOrAbsent(cp.state.placementRootSessionId);
+                const suppliedPlacementRoot = placementValueOrAbsent(internals?.placementRoot);
+                if (recordedPlacementRoot !== undefined && suppliedPlacementRoot !== undefined && suppliedPlacementRoot !== recordedPlacementRoot) {
+                    throw new CheckpointError("resume.placement_mismatch", `the resume supplied explicit placement root ${JSON.stringify(suppliedPlacementRoot)} but this checkpoint recorded placement root ${JSON.stringify(recordedPlacementRoot)} at suspend — ` +
+                        "resuming under a different placement fixed point would re-place the leg (and its descendants) on another target; " +
+                        "refused pre-CAS (the checkpoint stays pending): re-resume with the recorded root, or omit internals.placementRoot to inherit it");
+                }
+            }
             const owesDelivery = outcomeGate !== "resource_limit" ||
                 readPendingSteerQueue(cp.state).length > 0 ||
                 (cp.state.runningBackgroundTasks?.length ?? 0) > 0;
@@ -4869,7 +4938,121 @@ export class Runner {
         if (outcomeForStore === undefined) {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome (gate "${describeSuppliedValue(outcomeGate)}") matched the checkpoint gate but no lane captured it — refusing pre-CAS rather than passing the caller's live object to the store and the resumed run`);
         }
+        if (this.deps.resumePreflight !== undefined) {
+            const preflight = this.deps.resumePreflight;
+            const rawDeadline = this.deps.resumePreflightTimeoutMs;
+            let preflightTimeoutMs = RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS;
+            if (rawDeadline !== undefined) {
+                if (typeof rawDeadline === "number" && Number.isFinite(rawDeadline) && rawDeadline > 0 && rawDeadline <= MAX_HOOK_TIMEOUT_MS) {
+                    preflightTimeoutMs = rawDeadline;
+                }
+                else {
+                    try {
+                        this.deps.onError?.(new Error(`RunnerDeps.resumePreflightTimeoutMs is not a positive finite number within the seat ceiling of ${MAX_HOOK_TIMEOUT_MS}ms (got ${describeSuppliedValue(rawDeadline)}) — the resume preflight falls back to its own ${RESUME_PREFLIGHT_DEFAULT_TIMEOUT_MS}ms default`), { phase: "config", sessionId: cp.sessionId });
+                    }
+                    catch {
+                    }
+                }
+            }
+            const info = {
+                token,
+                sessionId: cp.sessionId,
+                ...(cp.state.placementRootSessionId !== undefined ? { placementRootSessionId: cp.state.placementRootSessionId } : {}),
+                ...(cp.principal ? { principal: cp.principal } : {}),
+                ...(cp.state.workspaceHandle !== undefined ? { workspaceHandle: structuredClone(cp.state.workspaceHandle) } : {}),
+                gateKind: cp.gate.kind,
+            };
+            const refusalTail = "; the checkpoint stays pending and the same token is redeemable once the obstacle clears";
+            let verdict;
+            try {
+                const seat = await runHookSeat("resumePreflight", {
+                    timeoutMs: preflightTimeoutMs,
+                    ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}),
+                    abortEnds: true,
+                    onBadTimeout: (badErr) => {
+                        try {
+                            this.deps.onError?.(badErr instanceof Error ? badErr : new Error(String(badErr)), { phase: "hook", sessionId: cp.sessionId });
+                        }
+                        catch {
+                        }
+                    },
+                    owner: this.deps,
+                }, (sig) => preflight(info, sig));
+                if (seat.expired) {
+                    throw new CheckpointError("resume.preflight_rejected", seat.cause === "timeout"
+                        ? `the deployment's resumePreflight did not answer within its ${preflightTimeoutMs}ms deadline while screening this resume — refused fail-closed (retry-later arm)${refusalTail}`
+                        : `the resume was cancelled while the deployment's resumePreflight was still screening it — refused (retry-later arm)${refusalTail}`);
+                }
+                verdict = seat.value;
+            }
+            catch (preflightErr) {
+                if (preflightErr instanceof CheckpointError)
+                    throw preflightErr;
+                const err = preflightErr instanceof Error ? preflightErr : new Error(String(preflightErr));
+                try {
+                    this.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
+                }
+                catch {
+                }
+                throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight crashed while screening this resume (${inlineUntrusted(err.message)}) — refused fail-closed (retry-later arm)${refusalTail}`);
+            }
+            const verdictOk = verdict !== null && typeof verdict === "object" ? verdict.ok : undefined;
+            if (verdictOk !== true) {
+                const bag = verdict !== null && typeof verdict === "object" ? verdict : undefined;
+                const disposition = bag?.disposition;
+                const suppliedMessage = bag?.message;
+                const retryAfterMs = bag?.retryAfterMs;
+                const readableMessage = typeof suppliedMessage === "string" && suppliedMessage !== "" ? suppliedMessage : undefined;
+                const said = readableMessage !== undefined ? `: ${inlineUntrusted(readableMessage)}` : " (no readable verdict — fail-closed)";
+                if (disposition === "terminal" && readableMessage !== undefined) {
+                    this.locallyClaimedTokens.add(token);
+                    let settled;
+                    try {
+                        settled = await store.expire(token, cp.scope);
+                    }
+                    catch (expireErr) {
+                        this.locallyClaimedTokens.delete(token);
+                        throw expireErr;
+                    }
+                    if (!settled) {
+                        this.locallyClaimedTokens.delete(token);
+                        const live = await store.get(token);
+                        if (live?.status === "pending") {
+                            throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said}, but the row moved under this refusal (a concurrent resolve/reopen cycle) — nothing was settled here; the row is pending again, re-resume against the current state (the preflight screens every attempt)`);
+                        }
+                        throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said} — a concurrent actor had already settled the row (${describeSuppliedValue(live?.status ?? "consumed")}); nothing was settled by this refusal`);
+                    }
+                    this.parentConstraintRegistry.delete(token);
+                    const terminalReap = this.suspendedEnvReaps.get(token);
+                    this.suspendedEnvReaps.delete(token);
+                    this.locallyClaimedTokens.delete(token);
+                    if (terminalReap?.env !== undefined && hasDestroy(terminalReap.env)) {
+                        const terminalEnv = terminalReap.env;
+                        await settleTeardownLeg(() => terminalEnv.destroy(), "terminal-preflight env destroy", (envErr) => {
+                            try {
+                                this.deps.onError?.(envErr, { phase: "config", sessionId: terminalReap.sessionId });
+                            }
+                            catch {
+                            }
+                        });
+                    }
+                    try {
+                        this.deps.onError?.(new Error(`resumePreflight ruled this row PERMANENTLY blocked${said} — the row was settled terminally (expired) by this refusal's single-shot CAS (token no longer redeemable)`), { phase: "hook", sessionId: cp.sessionId });
+                    }
+                    catch {
+                    }
+                    throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight ruled this resume PERMANENTLY blocked${said} — the row was settled terminally (expired by this refusal's single-shot CAS); the token is not redeemable`);
+                }
+                const waitHint = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? retryAfterMs : undefined;
+                throw new CheckpointError("resume.preflight_rejected", `the deployment's resumePreflight refused this resume${said}${refusalTail}${waitHint !== undefined ? ` (deployment wait hint: ${String(waitHint)}ms)` : ""}`, waitHint !== undefined ? { retryAfterMs: waitHint } : undefined);
+            }
+            if (recheckGovernanceWindow !== undefined)
+                await recheckGovernanceWindow();
+        }
+        this.locallyClaimedTokens.add(token);
         const won = await store.resolve(token, cp.scope, outcomeForStore, { rev: cp.rev ?? 0 });
+        if (!won)
+            this.locallyClaimedTokens.delete(token);
         if (!won) {
             const live = await store.get(token);
             if (live?.status === "pending") {
@@ -5223,9 +5406,10 @@ export class Runner {
                     minTokens: opts?.minTokens,
                     overheadTokens: prepared.promptOverheadTokens,
                     ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                    onInputTruncated: emitInputTruncated(spec.tracer ?? this.deps.tracer, spec.taskId ?? prepared.sessionId),
+                    onInputTruncated: emitInputTruncated(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId),
                     ...(opts?.windowSafety ?? {}),
                     workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                    ...contextInstructionFilesOption(prepared),
                     ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
                     ...this.seamCCompactionOptions(prepared),
                     ...gitRestateOption(prepared),
@@ -5236,17 +5420,17 @@ export class Runner {
                 });
                 this.recordCompactionReuse(prepared, finishComp);
                 if (finishComp.unevaluableWindow) {
-                    discloseUnevaluableWindow(finishComp.unevaluableWindow, prepared, spec.tracer ?? this.deps.tracer, spec.taskId ?? prepared.sessionId, this.deps.onError);
+                    discloseUnevaluableWindow(finishComp.unevaluableWindow, prepared, opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId, this.deps.onError);
                 }
                 comp = finishComp;
             }
             catch (err) {
                 const failMsg = String(err instanceof Error ? err.message : err);
                 const failReason = failMsg.length > 512 ? `${failMsg.slice(0, 512)}…` : failMsg;
-                emitTrace(spec.tracer ?? this.deps.tracer, () => ({
+                emitTrace(opts?.telemetry?.tracer ?? spec.tracer ?? this.deps.tracer, () => ({
                     kind: "compaction.failed",
                     version: 1,
-                    taskId: spec.taskId ?? prepared.sessionId,
+                    taskId: opts?.telemetry?.taskId ?? spec.taskId ?? prepared.sessionId,
                     trigger: "auto",
                     reason: failReason,
                     ts: Date.now(),