@sema-agent/core 5.60.1 → 5.62.0

package/dist/core/runner/runtask.js

@@ -15,7 +15,7 @@ import { eventDefaultOn } from "../../prompt-assembly/event-registry.js";
 import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill, sanitizeCompactionSettings } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME, canonicalizeCapturedPlainData, classifyQuestionOutcome, isLiveQuestionFace, markBoundOnlyQuestionFace } from "../ask-question.js";
 import { boundInputHashOf } from "../canonical-json.js";
-import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
+import { computeCostMicroUsd, isModelPriced, malformedPricingField, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
 import { ORG_ADJUDICATION_TIMEOUT_MS, settleOrgVerdictWithin } from "../permission-rule-org.js";
 import { emitTaskOutcome } from "../task-outcome.js";
@@ -36,13 +36,13 @@ 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 { gatedCallIdOf, prepareTask, resolveCheckpointStore } from "./prepare-task.js";
+import { effectiveDelegationFacts, gatedCallIdOf, prepareTask, resolveCheckpointStore } from "./prepare-task.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, resolveHookTimeoutMs, runHookSeat } from "../hooks.js";
+import { cloneObserverInput, formatHookFeedback, hookSeatExpiredError, 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";
@@ -50,7 +50,7 @@ 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 { defaultTaskRegistry } from "../task-registry.js";
-import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
+import { discloseDroppedPending, isDelegatedAgentTerminal, isSystemInjectionPriority, isTerminalTaskNotification, PendingSessionNotifications, renderTaskNotificationXml, SYSTEM_INJECTION_PRIORITIES, SystemInjectionQueue, taskNotificationDedupKey } from "../task-notification.js";
 import { ToolDetachHub } from "../tool-detach.js";
 import { createPeerInboundChainRef, createPeerSelfRef } from "../../agents/peer-admission.js";
 import { workflowSizeGuidelineChangeNotice } from "../../orchestration/workflow-size-guideline.js";
@@ -78,6 +78,7 @@ function nextHumanInputSeq(key) {
 function sameAcceptedSteerInput(a, b) {
     return (a.payload === b.payload &&
         a.trusted === b.trusted &&
+        a.priority === b.priority &&
         a.actor?.id === b.actor?.id &&
         a.actor?.hostAsserted === b.actor?.hostAsserted &&
         a.actor?.issuer === b.actor?.issuer);
@@ -394,7 +395,7 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                 const governance = prepared.usageGovernance;
                 try {
                     const at = Date.now();
-                    await awaitChargeWithSlowDisclosure(governance.commit(stats.tokens, at), () => runnerHooks.onError?.(new Error("the usage ledger CHARGE has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on the end-of-task flush). A wedged ledger store wedges this boundary, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
+                    await awaitChargeWithSlowDisclosure(governance.commit(stats.tokens, rs.telemetry.unpricedSpend ? undefined : stats.costMicroUsd, at), () => runnerHooks.onError?.(new Error("the usage ledger CHARGE has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on the end-of-task flush). A wedged ledger store wedges this boundary, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
                     const windowRead = governance.check(at);
                     let answer;
                     if (ledgerReadDeadline !== undefined) {
@@ -605,6 +606,7 @@ 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 toolSearchReminderOn = rs.attach.attachmentsCfg?.toolSearchReminder === true && prepared.deferredToolNames !== undefined;
                 const undiscoveredTools = toolSearchReminderOn
                     ? [...prepared.deferredToolNames].filter((n) => !prepared.activeTools.has(n)).sort()
@@ -622,6 +624,10 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                         changedFiles: changedFilesOn,
                         planModeReminder: rs.attach.attachmentsCfg?.planModeReminder === true,
                         budgetUsd: budgetUsdOn,
+                        totalTokensReminder: totalTokensOn,
+                        ...(rs.attach.attachmentsCfg?.totalTokensReminderMode !== undefined
+                            ? { totalTokensReminderMode: rs.attach.attachmentsCfg.totalTokensReminderMode }
+                            : {}),
                         backgroundTasks: backgroundTasksOn,
                         toolsDelta: toolsDeltaOn,
                         agentListing: rs.attach.agentListingOn,
@@ -635,6 +641,9 @@ function makeTurnBoundary(prepared, stats, rs, deps) {
                     ...(budgetUsdOn && rs.budget.maxCostMicroUsd !== undefined
                         ? { budgetUsd: { used: stats.costMicroUsd / 1e6, total: rs.budget.maxCostMicroUsd / 1e6 } }
                         : {}),
+                    ...(totalTokensOn && rs.budget.maxTokensWindow !== undefined
+                        ? { totalTokens: { used: stats.tokens, total: rs.budget.maxTokensWindow } }
+                        : {}),
                     ...(bgTasks !== undefined ? { backgroundTasks: bgTasks } : {}),
                     ...(pendingTools !== undefined ? { newTools: pendingTools } : {}),
                     ...(prepared.toolMaterializeStatic ? { newToolsStaticFace: true } : {}),
@@ -1130,6 +1139,9 @@ function makeHarnessHandlers(prepared, stats, rs, deps) {
                 rs.turn.firstTokenAt = Date.now();
             pushContent({ type: "text_delta", delta: ev.delta, ...ident() });
         }
+        else if (ev.type === "text_end" && typeof ev.content === "string" && ev.content.length !== 0) {
+            pushContent({ type: "text_end", content: ev.content, ...ident() });
+        }
         else if (ev.type === "thinking_delta" && ev.delta) {
             pushContent({ type: "reasoning_delta", delta: ev.delta, ...ident() });
         }
@@ -1829,6 +1841,11 @@ export class Runner {
                         throw steeringError(`inputId "${LEGACY_PENDING_STEER_INPUT_ID}" is reserved for a pre-queue parked steer and cannot be supplied by a caller`, "steering.invalid_content");
                     }
                 }
+                const priorityIn = options?.priority;
+                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
+                    throw steeringError(`priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when supplied`, "steering.invalid_content");
+                }
+                const priority = priorityIn ?? "next";
                 const actorIn = options?.actor;
                 const actor = actorIn === undefined ? undefined : snapshotActorAssertion(actorIn);
                 const projected = projectHumanInput({ text, actor, source: "steer" });
@@ -1837,6 +1854,7 @@ export class Runner {
                     text,
                     trusted,
                     inputId: effectiveInputId,
+                    ...(priorityIn !== undefined ? { priority } : {}),
                     ...(actor !== undefined ? { actor } : {}),
                 };
                 let payload;
@@ -1872,7 +1890,7 @@ export class Runner {
                         throw steeringError("the task is not running");
                     payload = trusted ? formatHookFeedback(projected, h.reminderMark) : frameMidTurnUserInput(projected);
                     mintsAFrame = payload.trim().length !== 0;
-                    replay = { payload, trusted, ...(actor !== undefined ? { actor } : {}) };
+                    replay = { payload, trusted, priority, ...(actor !== undefined ? { actor } : {}) };
                     if (typeof inputId === "string") {
                         const prior = acceptedSteerInputs.get(inputId);
                         if (prior !== undefined) {
@@ -1885,9 +1903,73 @@ export class Runner {
                             return;
                         }
                     }
-                    try {
-                        await h.harness.steer(payload, { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) });
+                    if (resultValue !== undefined || h.loop.ended)
+                        throw steeringError("the task is no longer running");
+                    if (mintsAFrame) {
+                        const screen = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
+                        if (screen !== undefined) {
+                            let decision;
+                            try {
+                                const seat = await runHookSeat("userPromptSubmit", { timeoutMs: h.hookTimeoutMs, signal: h.abortController.signal, abortEnds: true }, (sig) => screen(text, { identity: h.hookIdentity, signal: sig, source: "steer", inputId: effectiveInputId, ...(actor !== undefined ? { actor: snapshotActorAssertion(actor) } : {}) }));
+                                if (seat.expired) {
+                                    if (seat.cause === "timeout") {
+                                        try {
+                                            this.deps.onError?.(hookSeatExpiredError("userPromptSubmit", h.hookTimeoutMs, seat.cause, "the steering input was NOT accepted (fail-closed) and the caller was refused typed"), { phase: "hook", sessionId: h.sessionId });
+                                        }
+                                        catch {
+                                        }
+                                    }
+                                    throw steeringError(seat.cause === "timeout"
+                                        ? `the deployment's userPromptSubmit hook did not answer within its ${h.hookTimeoutMs}ms bound while screening this steering input; the input was NOT accepted (fail-closed)`
+                                        : `the task was cancelled while the deployment's userPromptSubmit hook was still screening this steering input; the input was NOT accepted (fail-closed)`, "steering.blocked_by_hook");
+                                }
+                                decision = seat.value;
+                            }
+                            catch (hookErr) {
+                                if (hookErr instanceof Error && hookErr.code === "steering.blocked_by_hook")
+                                    throw hookErr;
+                                const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                                try {
+                                    this.deps.onError?.(err, { phase: "hook", sessionId: h.sessionId });
+                                }
+                                catch {
+                                }
+                                throw steeringError(`the deployment's userPromptSubmit hook crashed while screening this steering input (${inlineUntrusted(err.message)}); the input was NOT accepted (fail-closed)`, "steering.blocked_by_hook");
+                            }
+                            if (decision?.block !== undefined && decision.block !== "") {
+                                throw steeringError(`the deployment's userPromptSubmit hook blocked this steering input: ${inlineUntrusted(decision.block)}`, "steering.blocked_by_hook");
+                            }
+                            if (decision?.additionalContext !== undefined && decision.additionalContext !== "") {
+                                payload = `${formatHookFeedback(decision.additionalContext, h.reminderMark)}\n\n${payload}`;
+                            }
+                        }
+                    }
+                    const injectFramed = async () => {
+                        const noteOptions = { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) };
+                        if (priority === "later") {
+                            await h.harness.followUp(payload, noteOptions);
+                            noteAccepted(h);
+                            return;
+                        }
+                        const frame = await h.harness.steer(payload, { ...noteOptions, ...(priority === "now" ? { immediate: true } : {}) });
                         noteAccepted(h);
+                        if (priority === "now" && frame !== undefined && h.harness.interruptTurn(frame)) {
+                            deliverEngineNotice(this.deps.onNotice, {
+                                code: "task.turn_interrupted",
+                                message: "a caller-provenance steer with priority \"now\" interrupted 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 continues with the steer at the queue head.",
+                                detail: {
+                                    inputId: effectiveInputId,
+                                    sessionId: h.sessionId,
+                                    ...(actor?.id !== undefined ? { actorId: actor.id } : {}),
+                                    ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                                },
+                            });
+                        }
+                    };
+                    try {
+                        await injectFramed();
                         return;
                     }
                     catch (e) {
@@ -1897,8 +1979,7 @@ export class Runner {
                     const birthDeadline = Date.now() + READY_TIMEOUT_MS;
                     while (resultValue === undefined && !h.loop.ended && Date.now() < birthDeadline) {
                         try {
-                            await h.harness.steer(payload, { provenance: "engine-note", callerAuthored: true, parkRecord, ...(actor !== undefined ? { actor } : {}) });
-                            noteAccepted(h);
+                            await injectFramed();
                             return;
                         }
                         catch (e2) {
@@ -1938,9 +2019,14 @@ export class Runner {
                 if (input.source !== undefined && typeof input.source !== "string") {
                     throw notifyError("input.source must be a string when present", "notify.invalid_payload");
                 }
-                if (opts?.priority !== undefined && !isSystemInjectionPriority(opts.priority)) {
+                const priorityIn = opts?.priority;
+                if (priorityIn !== undefined && !isSystemInjectionPriority(priorityIn)) {
                     throw notifyError(`opts.priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")} when present`, "notify.invalid_payload");
                 }
+                const priority = priorityIn;
+                if (priority === "now") {
+                    throw notifyError('priority "now" (turn interrupt) is not a notification-lane power — it belongs to the steer face; use "next" for earliest-boundary delivery', "notify.invalid_priority");
+                }
                 const payload = {
                     task_id: input.task_id,
                     task_type: "external",
@@ -1954,7 +2040,7 @@ export class Runner {
                 if (!h || notifyRef.inject === undefined) {
                     throw notifyError("the task is not running", "notify.not_running");
                 }
-                notifyRef.inject(payload, opts);
+                notifyRef.inject(payload, priority !== undefined ? { priority } : undefined);
             },
             compact: async (opts) => {
                 if (resultValue)
@@ -2050,7 +2136,7 @@ export class Runner {
         let descendantAnchorDisclosed = false;
         const parkTaskNotification = (payload, priority) => {
             if (notificationSessionId !== undefined)
-                this.pendingSessionNotifications.pend(notificationSessionId, payload);
+                this.pendingSessionNotifications.pend(notificationSessionId, payload, priority);
             if (!isDelegatedAgentTerminal(payload))
                 return;
             const uplink = internals?.parentNotify;
@@ -2065,7 +2151,7 @@ export class Runner {
             }
             const rootAnchor = internals?.rootSessionId;
             if (rootAnchor !== undefined && rootAnchor !== notificationSessionId) {
-                this.pendingSessionNotifications.pend(rootAnchor, payload);
+                this.pendingSessionNotifications.pend(rootAnchor, payload, priority);
                 return;
             }
             if (internals?.parentSessionId !== undefined && !descendantAnchorDisclosed) {
@@ -2074,10 +2160,17 @@ export class Runner {
             }
         };
         const unsubscribeTaskNotifications = taskNotificationQueue.subscribe((item) => {
-            queue.push({ type: "task_notification", notification: item.payload, ...notificationIdent() });
+            queue.push({ type: "task_notification", notification: item.payload, priority: item.priority, ...notificationIdent() });
             if (notificationHarness && prepared.batchHaltRef.current === undefined) {
                 const xml = renderTaskNotificationXml(item.payload);
-                const deliver = notificationHarness.steer(xml, { provenance: "engine-note", enginePayload: item.payload });
+                const noteOptions = {
+                    provenance: "engine-note",
+                    enginePayload: item.payload,
+                    ...(item.payload.task_type !== "external" && isTerminalTaskNotification(item.payload) ? { capPreferred: true } : {}),
+                };
+                const deliver = item.priority === "later"
+                    ? notificationHarness.followUp(xml, noteOptions)
+                    : notificationHarness.steer(xml, { ...noteOptions, ...(item.priority === "now" ? { immediate: true } : {}) });
                 void deliver.then(() => item.onDisposition?.("queued"), () => {
                     parkTaskNotification(item.payload, item.priority);
                     item.onDisposition?.("parked");
@@ -2090,18 +2183,7 @@ export class Runner {
         });
         const upstreamTaskNotification = internals?.onTaskNotification;
         const deliveredAtTurnOpen = new Set();
-        let priorityNowDisclosed = false;
         const injectTaskNotification = (notification, opts) => {
-            if (opts?.priority === "now" && !priorityNowDisclosed) {
-                priorityNowDisclosed = true;
-                deliverEngineNotice(this.deps.onNotice, {
-                    code: "task.injection_priority_unimplemented",
-                    message: `a notification was injected with priority "now", which this engine does not implement: all injection ` +
-                        `priorities deliver at the NEXT turn boundary and none aborts the running turn. The notification is ` +
-                        `delivered — only the interrupting semantics are absent.`,
-                    detail: { priority: "now", ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}), sessionId: prepared.sessionId },
-                });
-            }
             if (deliveredAtTurnOpen.has(taskNotificationDedupKey(notification)))
                 return Promise.resolve("dropped_duplicate");
             if (!notificationLaneLive) {
@@ -2196,16 +2278,17 @@ export class Runner {
             const pendingIdle = this.pendingSessionNotifications.drain(prepared.sessionId);
             if (pendingIdle !== undefined) {
                 for (const payload of discloseDroppedPending(pendingIdle)) {
+                    const parkedPriority = pendingIdle.priorities?.get(payload);
                     deliveredAtTurnOpen.add(taskNotificationDedupKey(payload));
-                    queue.push({ type: "task_notification", notification: payload, ...ident() });
+                    queue.push({ type: "task_notification", notification: payload, ...(parkedPriority !== undefined ? { priority: parkedPriority } : {}), ...ident() });
                     void prepared.harness.nextTurn(renderTaskNotificationXml(payload), { provenance: "engine-note", enginePayload: payload }).catch(() => {
-                        this.pendingSessionNotifications.pend(prepared.sessionId, payload);
+                        this.pendingSessionNotifications.pend(prepared.sessionId, payload, parkedPriority);
                     });
                 }
             }
         }
         const loopLatch = { ended: false, userInterrupted: false };
-        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark });
+        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId, 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 &&
@@ -2227,7 +2310,7 @@ export class Runner {
         const rs = createRunState();
         rs.telemetry.cacheFamily = cacheFamilyOf(prepared.model);
         rs.telemetry.pricing = this.deps.pricing?.[prepared.model.id] ?? modelCostToPricing(prepared.model.cost);
-        rs.telemetry.pricingConfigured = this.deps.pricing?.[prepared.model.id] !== undefined || prepared.model.cost !== undefined;
+        rs.telemetry.pricingConfigured = isModelPriced(prepared.model, this.deps.pricing);
         if (spec.limits?.degrade) {
             try {
                 rs.degrade.degradeToModel = resolveModel(spec.limits.degrade.to, modelCatalog);
@@ -2267,6 +2350,12 @@ export class Runner {
         catch (err) {
             discloseNoteTaskRunFailure(err);
         }
+        const noteUnevaluablePriceTable = (p) => {
+            if (prepared.usageGovernance?.governsCost !== true)
+                return;
+            if (malformedPricingField(p) !== undefined)
+                rs.telemetry.unpricedSpend = true;
+        };
         rs.degrade.recordDegraded = (info, toModel) => {
             if (rs.degrade.degraded !== undefined)
                 return;
@@ -2281,13 +2370,15 @@ export class Runner {
             }
             if (m) {
                 rs.telemetry.pricing = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-                rs.telemetry.pricingConfigured = this.deps.pricing?.[m.id] !== undefined || m.cost !== undefined;
+                rs.telemetry.pricingConfigured = isModelPriced(m, this.deps.pricing);
+                noteUnevaluablePriceTable(rs.telemetry.pricing);
                 rs.telemetry.cacheFamily = cacheFamilyOf(m);
             }
             else {
                 if (this.deps.pricing?.[info.to]) {
                     rs.telemetry.pricing = this.deps.pricing[info.to];
                     rs.telemetry.pricingConfigured = true;
+                    noteUnevaluablePriceTable(rs.telemetry.pricing);
                 }
                 else {
                     rs.telemetry.pricingConfigured = false;
@@ -2706,9 +2797,10 @@ export class Runner {
                 return;
             const fam = cacheFamilyOf(m);
             const price = this.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
-            const priced = this.deps.pricing?.[m.id] !== undefined || m.cost !== undefined;
+            const priced = isModelPriced(m, this.deps.pricing);
             if (!priced)
                 rs.telemetry.unpricedSpend = true;
+            noteUnevaluablePriceTable(price);
             const { totalInputTokens, uncachedInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
             stats.tokens += u.totalTokens || 0;
             stats.promptTokens += uncachedInputTokens;
@@ -3281,6 +3373,72 @@ export class Runner {
                         ...(resume.wakeMessage !== undefined ? [{ entry: resume.wakeMessage, source: "wake" }] : []),
                     ];
                     for (const { entry: steer, source } of resumeFrames) {
+                        if (source === "wake" && resume.wakeMessageHookContext !== undefined) {
+                            const hookStart = continuation.length;
+                            continuation += "\n\n" + formatHookFeedback(resume.wakeMessageHookContext, prepared.reminderMark);
+                            engineSegments.push({ start: hookStart, end: continuation.length });
+                        }
+                        if (source === "steer") {
+                            const parkedScreen = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
+                            if (parkedScreen !== undefined) {
+                                let outcome;
+                                try {
+                                    const seat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => parkedScreen(steer.text, {
+                                        identity: prepared.hookIdentity,
+                                        signal: sig,
+                                        source: "parked_redelivery",
+                                        ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                        ...(steer.actor !== undefined ? { actor: snapshotActorAssertion(steer.actor) } : {}),
+                                    }));
+                                    outcome = seat.expired
+                                        ? { blocked: seat.cause === "timeout" ? `the screen did not answer within its ${prepared.hookTimeoutMs}ms bound (fail-closed)` : "the run was cancelled while the screen was still deciding (fail-closed)" }
+                                        : seat.value?.block !== undefined && seat.value.block !== ""
+                                            ? { blocked: inlineUntrusted(seat.value.block) }
+                                            : { ...(seat.value?.additionalContext !== undefined && seat.value.additionalContext !== "" ? { context: seat.value.additionalContext } : {}) };
+                                }
+                                catch (hookErr) {
+                                    const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                                    try {
+                                        this.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
+                                    }
+                                    catch {
+                                    }
+                                    outcome = { blocked: `the screen crashed (${inlineUntrusted(err.message)}; fail-closed)` };
+                                }
+                                if ("blocked" in outcome) {
+                                    deliverEngineNotice(this.deps.onNotice, {
+                                        code: "steering.parked_input_blocked",
+                                        message: "a parked steering input was withheld by the deployment's userPromptSubmit screen when this resume redelivered it: " +
+                                            `${outcome.blocked}. The parked row was consumed with the checkpoint; the instruction never reached the model — ` +
+                                            "re-issue it if it still applies.",
+                                        detail: {
+                                            ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                            sessionId: prepared.sessionId,
+                                            ...(spec.taskId !== undefined ? { taskId: spec.taskId } : {}),
+                                        },
+                                    });
+                                    queue.push({
+                                        ...buildHumanInputEvent({
+                                            carrier: source,
+                                            source,
+                                            delivery: "blocked",
+                                            sessionSeq: nextHumanInputSeq(prepared.harness),
+                                            ...(steer.inputId !== undefined ? { inputId: steer.inputId } : {}),
+                                            ...(steer.actor !== undefined ? { actor: steer.actor } : {}),
+                                            ...(steer.actor?.issuer !== undefined ? { issuer: steer.actor.issuer } : {}),
+                                            ...(spec.principal !== undefined ? { principal: spec.principal } : {}),
+                                        }),
+                                        ...ident(),
+                                    });
+                                    continue;
+                                }
+                                if ("context" in outcome && outcome.context !== undefined) {
+                                    const hookStart = continuation.length;
+                                    continuation += "\n\n" + formatHookFeedback(outcome.context, prepared.reminderMark);
+                                    engineSegments.push({ start: hookStart, end: continuation.length });
+                                }
+                            }
+                        }
                         const start = continuation.length;
                         const projected = projectHumanInput({ text: steer.text, actor: steer.actor, source });
                         continuation +=
@@ -3331,7 +3489,7 @@ export class Runner {
                 const userPromptSubmit = (spec.hooks ?? this.deps.hooks)?.userPromptSubmit;
                 if (userPromptSubmit) {
                     try {
-                        const promptSeat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => userPromptSubmit(spec.objective, { identity: prepared.hookIdentity, signal: sig }));
+                        const promptSeat = await runHookSeat("userPromptSubmit", { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal, abortEnds: true }, (sig) => userPromptSubmit(spec.objective, { identity: prepared.hookIdentity, signal: sig, source: "objective", ...(objectiveActor !== undefined ? { actor: snapshotActorAssertion(objectiveActor) } : {}) }));
                         if (promptSeat.expired) {
                             if (promptSeat.cause === "timeout") {
                                 try {
@@ -3555,7 +3713,7 @@ export class Runner {
         }
         if (prepared.usageGovernance !== undefined) {
             try {
-                await awaitChargeWithSlowDisclosure(prepared.usageGovernance.commit(stats.tokens, Date.now()), () => this.deps.onError?.(new Error("the usage ledger's FINAL charge has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on a later flush). A wedged ledger store wedges this teardown, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
+                await awaitChargeWithSlowDisclosure(prepared.usageGovernance.commit(stats.tokens, rs.telemetry.unpricedSpend ? undefined : stats.costMicroUsd, Date.now()), () => this.deps.onError?.(new Error("the usage ledger's FINAL charge has not settled after 10s — still waiting (a charge is never abandoned: walking away would double-charge on a later flush). A wedged ledger store wedges this teardown, now visibly."), { phase: "config", sessionId: prepared.sessionId }));
             }
             catch (flushErr) {
                 this.deps.onError?.(flushErr, { phase: "config", sessionId: prepared.sessionId });
@@ -4138,7 +4296,9 @@ export class Runner {
             }
         }
         let wakeMessage;
+        let wakeHookContext;
         const outcomeGate = outcome.gate;
+        const resumeSignal = taskConfig.signal;
         let suppliedMessage;
         if (outcomeGate === "wake") {
             suppliedMessage = outcome.message;
@@ -4176,6 +4336,62 @@ export class Runner {
             }
             if (suppliedMessage !== undefined) {
                 wakeMessage = validatePendingSteer(suppliedMessage);
+                {
+                    const resumeScreenHooks = taskConfig.hooks ?? this.deps.hooks;
+                    const screen = resumeScreenHooks?.userPromptSubmit;
+                    if (screen !== undefined && resumeSignal?.aborted !== true) {
+                        const screenedMessage = wakeMessage;
+                        const identity = mintHookInvocationIdentity({
+                            sessionId: cp.sessionId,
+                            taskId: taskConfig.taskId ?? cp.sessionId,
+                            legKind: "resume",
+                            isDelegatedChild: effectiveDelegationFacts(internals, cp.state.isDelegatedChild).isDelegatedChild,
+                            ...(internals?.insideFork === true ? { insideFork: true } : {}),
+                            ...(internals?.agentName !== undefined ? { agentName: internals.agentName } : {}),
+                            ...(internals?.parentToolCallId !== undefined ? { parentToolCallId: internals.parentToolCallId } : {}),
+                        });
+                        const screenTimeoutMs = resolveHookTimeoutMs(resumeScreenHooks?.timeoutMs, (badErr) => {
+                            try {
+                                this.deps.onError?.(badErr instanceof Error ? badErr : new Error(String(badErr)), { phase: "hook", sessionId: cp.sessionId });
+                            }
+                            catch {
+                            }
+                        }, resumeScreenHooks);
+                        let decision;
+                        try {
+                            const seat = await runHookSeat("userPromptSubmit", { timeoutMs: screenTimeoutMs, ...(resumeSignal !== undefined ? { signal: resumeSignal } : {}), abortEnds: true }, (sig) => screen(screenedMessage.text, {
+                                identity,
+                                signal: sig,
+                                source: "resume_message",
+                                ...(screenedMessage.inputId !== undefined ? { inputId: screenedMessage.inputId } : {}),
+                                ...(screenedMessage.actor !== undefined ? { actor: snapshotActorAssertion(screenedMessage.actor) } : {}),
+                            }));
+                            if (seat.expired) {
+                                throw new CheckpointError("steering.blocked_by_hook", seat.cause === "timeout"
+                                    ? `the deployment's userPromptSubmit hook did not answer within its ${screenTimeoutMs}ms bound while screening this wake message; the resume was refused (fail-closed) and the checkpoint stays pending`
+                                    : `the resume was cancelled while the deployment's userPromptSubmit hook was still screening this wake message; the checkpoint stays pending`);
+                            }
+                            decision = seat.value;
+                        }
+                        catch (hookErr) {
+                            if (hookErr instanceof CheckpointError)
+                                throw hookErr;
+                            const err = hookErr instanceof Error ? hookErr : new Error(String(hookErr));
+                            try {
+                                this.deps.onError?.(err, { phase: "hook", sessionId: cp.sessionId });
+                            }
+                            catch {
+                            }
+                            throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook crashed while screening this wake message (${inlineUntrusted(err.message)}); the resume was refused (fail-closed) and the checkpoint stays pending`);
+                        }
+                        if (decision?.block !== undefined && decision.block !== "") {
+                            throw new CheckpointError("steering.blocked_by_hook", `the deployment's userPromptSubmit hook blocked this wake message: ${inlineUntrusted(decision.block)}`);
+                        }
+                        if (decision?.additionalContext !== undefined && decision.additionalContext !== "") {
+                            wakeHookContext = decision.additionalContext;
+                        }
+                    }
+                }
             }
             else if (readPendingSteerQueue(cp.state).length === 0) {
                 throw new CheckpointError("wake.nothing_to_deliver", "cannot wake: no message was supplied and the checkpoint holds no parked pendingSteer — an empty " +
@@ -4423,7 +4639,7 @@ export class Runner {
                 "resuming here would run the leg with that ceiling unenforced. Rejected pre-CAS (the checkpoint stays pending): finish it on a worker of the " +
                 "previous release, or start a fresh task bounded by resourceSuspend.totalTokens / totalBudgetUsd.");
         }
-        if (taskConfig.signal?.aborted === true && cp.status === "pending") {
+        if (resumeSignal?.aborted === true && cp.status === "pending") {
             throw new CheckpointError("checkpoint.resume_aborted", "the resume was handed an ALREADY-ABORTED signal — refusing to consume the approval on a leg that cannot run it (the checkpoint stays pending and is resumable with a live signal)");
         }
         if (cp.state.workspaceHandle !== undefined && this.deps.executionEnvFactory === undefined) {
@@ -4497,7 +4713,7 @@ export class Runner {
                 const preCasWindows = resolveUsageWindows(this.deps.usageWindows);
                 if (preCasWindows !== undefined && preCasWindows.length > 0) {
                     const ledgerKey = (suppliedPrincipal ?? rowPrincipal) || GLOBAL_USAGE_KEY;
-                    const wait = usageRetryAfterMs(await this.deps.usageWindowStore.read(ledgerKey, preCasWindows, Date.now()));
+                    const wait = usageRetryAfterMs(await this.deps.usageWindowStore.read(ledgerKey, preCasWindows, Date.now()), preCasWindows);
                     if (wait !== undefined) {
                         throw new CheckpointError("resume.usage_window_exhausted", `a deployment usage window for ledger key ${JSON.stringify(ledgerKey)} is exhausted, and this checkpoint still owes a delivery a re-mint cannot carry — ` +
                             `refused pre-CAS (nothing consumed, nothing unpinned): the same token and the same decision are redeemable once the window frees, in ${String(wait)}ms`, { retryAfterMs: wait });
@@ -4657,7 +4873,7 @@ export class Runner {
                     ? new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run AND the store refused to reopen the checkpoint — the approval is terminally consumed and the suspended work was not executed; a retry needs a fresh approval")
                     : new CheckpointError("checkpoint.reopen_failed", "the resume was aborted before the approved action could run and the reopen attempt FAILED IN FLIGHT — the checkpoint's state is unprovable from here: it may already be pending again. Re-read it before deciding; do NOT issue a fresh approval on the assumption the old one is dead (the approved action did NOT run either way)");
         }
-        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}) }, resumeInternals);
+        return this.runTaskStream(spec, { cp, outcome: outcomeForStore, onEnvRestoreFailed, ...(wakeMessage !== undefined ? { wakeMessage } : {}), ...(wakeHookContext !== undefined ? { wakeMessageHookContext: wakeHookContext } : {}) }, resumeInternals);
     }
     async applyResumeDecision(prepared, resume, emit, emitCommitted, onResolvedToolSuccess, onExecuteStart) {
         const { pendingAction } = resume.cp;