@sema-agent/core 5.61.0 → 5.63.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";
@@ -395,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) {
@@ -606,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()
@@ -623,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,
@@ -636,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 } : {}),
@@ -1131,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() });
         }
@@ -1892,6 +1903,47 @@ export class Runner {
                             return;
                         }
                     }
+                    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") {
@@ -2236,7 +2288,7 @@ export class Runner {
             }
         }
         const loopLatch = { ended: false, userInterrupted: false };
-        onReady({ harness: prepared.harness, abortController: prepared.abortController, loop: loopLatch, reminderMark: prepared.reminderMark, sessionId: prepared.sessionId });
+        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 &&
@@ -2258,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);
@@ -2298,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;
@@ -2312,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;
@@ -2737,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;
@@ -2969,6 +3030,105 @@ export class Runner {
                 return messages;
             });
         }
+        const runForcedCompactionPass = async (lane, turnSignal) => {
+            if (!(spec.compaction?.enabled ?? true))
+                return false;
+            if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
+                return false;
+            const passSignal = turnSignal !== undefined ? AbortSignal.any([prepared.abortController.signal, turnSignal]) : prepared.abortController.signal;
+            try {
+                const comp = await maybeCompact({
+                    session: prepared.session,
+                    epochDeclaredSections: prepared.epochDeclaredSections,
+                    ...centerAdoptionOption(prepared),
+                    model: prepared.harness.getModel(),
+                    compactionModel: prepared.compModel,
+                    ...forkContextOption(prepared, true),
+                    brain: compactionBrain,
+                    getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
+                    thinking: prepared.thinking,
+                    settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
+                    customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
+                    signal: passSignal,
+                    minTokens: 0,
+                    force: true,
+                    overheadTokens: prepared.promptOverheadTokens,
+                    ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
+                    onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
+                    workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
+                    ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
+                    ...this.seamCCompactionOptions(prepared),
+                    ...gitRestateOption(prepared),
+                    ...windowSafetyOptions(prepared.harness.getModel()),
+                    ...this.compactionHookOptions(spec, prepared.sessionId, "forced", prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: passSignal }),
+                });
+                if (comp.compacted) {
+                    compactionBreaker.failures = 0;
+                    this.recordCompactionReuse(prepared, comp);
+                    if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
+                        const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
+                        rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
+                    }
+                    queue.push({
+                        type: "compacted",
+                        trigger: "forced",
+                        tokensBefore: comp.tokensBefore ?? 0,
+                        ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
+                        ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
+                        ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
+                        ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
+                        ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
+                        ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
+                        ...(comp.modelFallback ? { modelFallback: true } : {}),
+                        ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
+                        ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
+                        ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
+                        ...ident(),
+                    });
+                    if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
+                        const pd = comp.phaseDurations;
+                        const pdDur = comp.durationMs;
+                        emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
+                    }
+                    prepared.cacheBreakDetector?.notifyCompaction();
+                    if (rs.attach.attachState !== undefined) {
+                        rs.attach.attachState.postCompactPending = true;
+                        rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
+                    }
+                }
+                else {
+                    if (comp.noop) {
+                        compactionBreaker.failures = 0;
+                    }
+                    else {
+                        compactionBreaker.failures += 1;
+                    }
+                    const declineReason = lane === "rejection" ? "prompt-too-long recovery pass did not land" : "guard-chain forced compaction pass did not land";
+                    if (!comp.noop) {
+                        this.deps.onError?.(new Error(declineReason), { phase: "compaction", sessionId: prepared.sessionId });
+                    }
+                    queue.push({
+                        type: "compaction_outcome",
+                        outcome: comp.noop ? "noop" : "failed",
+                        trigger: "forced",
+                        reason: declineReason,
+                        ...ident(),
+                    });
+                }
+                return comp.compacted === true;
+            }
+            catch (err) {
+                if (turnSignal?.aborted === true && !prepared.abortController.signal.aborted) {
+                    queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: "guard-chain forced compaction cut short by a turn interrupt", ...ident() });
+                    return false;
+                }
+                compactionBreaker.failures += 1;
+                this.deps.onError?.(err instanceof Error ? err : new Error(String(err)), { phase: "compaction", sessionId: prepared.sessionId });
+                const msg = String(err instanceof Error ? err.message : err);
+                queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
+                return false;
+            }
+        };
         prepared.harness.setLoopRecovery({
             truncatedOutput: {},
             malformedToolUse: {},
@@ -3014,85 +3174,23 @@ export class Runner {
                             return true;
                         }
                     }
-                    if (!(spec.compaction?.enabled ?? true))
-                        return false;
-                    if (compactionBreaker.failures >= MAX_CONSECUTIVE_COMPACTION_FAILURES)
-                        return false;
-                    try {
-                        const comp = await maybeCompact({
-                            session: prepared.session,
-                            epochDeclaredSections: prepared.epochDeclaredSections,
-                            ...centerAdoptionOption(prepared),
-                            model: prepared.harness.getModel(),
-                            compactionModel: prepared.compModel,
-                            ...forkContextOption(prepared, true),
-                            brain: compactionBrain,
-                            getApiKeyAndHeaders: spec.getApiKeyAndHeaders,
-                            thinking: prepared.thinking,
-                            settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
-                            customInstructions: spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                            signal: prepared.abortController.signal,
-                            minTokens: 0,
-                            force: true,
-                            overheadTokens: prepared.promptOverheadTokens,
-                            ...(prepared.activeTools.size > 0 ? { activeTools: [...prepared.activeTools] } : {}),
-                            onInputTruncated: emitInputTruncated(rs.telemetry.tracer, rs.telemetry.taskId),
-                            workingFileAttachments: buildWorkingFileAttachments(spec, prepared),
-                            ...(prepared.onCompactionApplied ? { onApplied: prepared.onCompactionApplied } : {}),
-                            ...this.seamCCompactionOptions(prepared),
-                            ...gitRestateOption(prepared),
-                            ...windowSafetyOptions(prepared.harness.getModel()),
-                            ...this.compactionHookOptions(spec, prepared.sessionId, "forced", prepared.hookIdentity, { timeoutMs: prepared.hookTimeoutMs, signal: prepared.abortController.signal }),
-                        });
-                        if (comp.compacted) {
-                            compactionBreaker.failures = 0;
-                            this.recordCompactionReuse(prepared, comp);
-                            if ((comp.freedTokens ?? 0) >= COMPACTION_FREED_EPSILON) {
-                                const postSize = comp.postTriggerTokens ?? Math.max(0, (comp.triggerTokens ?? comp.tokensBefore ?? 0) - (comp.freedTokens ?? 0));
-                                rs.counters.compactionFloor = Math.ceil(postSize * COMPACTION_REGROWTH_FACTOR);
-                            }
-                            queue.push({
-                                type: "compacted",
-                                trigger: "forced",
-                                tokensBefore: comp.tokensBefore ?? 0,
-                                ...(comp.postTriggerTokens !== undefined ? { tokensAfter: comp.postTriggerTokens } : {}),
-                                ...(comp.triggerTokens !== undefined ? { triggerTokensBefore: comp.triggerTokens } : {}),
-                                ...(comp.durationMs !== undefined ? { durationMs: comp.durationMs } : {}),
-                                ...(comp.phaseDurations !== undefined ? { phaseDurations: comp.phaseDurations } : {}),
-                                ...(comp.firstKeptEntryId !== undefined ? { preserved_segment: { firstKeptEntryId: comp.firstKeptEntryId } } : {}),
-                                ...(comp.attachedFiles !== undefined ? { attachedFiles: comp.attachedFiles } : {}),
-                                ...(comp.modelFallback ? { modelFallback: true } : {}),
-                                ...(comp.fallbackReason !== undefined ? { fallbackReason: comp.fallbackReason } : {}),
-                                ...(comp.clampedRatio !== undefined ? { clampedRatio: comp.clampedRatio } : {}),
-                                ...(comp.clampReason !== undefined ? { clampReason: comp.clampReason } : {}),
-                                ...ident(),
-                            });
-                            if (comp.phaseDurations !== undefined && comp.durationMs !== undefined) {
-                                const pd = comp.phaseDurations;
-                                const pdDur = comp.durationMs;
-                                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.phase_timings", version: 1, taskId: rs.telemetry.taskId, ...pd, durationMs: pdDur, ts: Date.now() }));
-                            }
-                            prepared.cacheBreakDetector?.notifyCompaction();
-                            if (rs.attach.attachState !== undefined) {
-                                rs.attach.attachState.postCompactPending = true;
-                                rebaseCadenceWindows(rs.attach.attachState, rs.counters.cadenceTurns);
-                            }
-                        }
-                        else {
-                            compactionBreaker.failures += 1;
-                            queue.push({ type: "compaction_outcome", outcome: comp.noop ? "noop" : "failed", trigger: "forced", reason: "prompt-too-long recovery pass did not land", ...ident() });
-                        }
-                        return comp.compacted === true;
-                    }
-                    catch (err) {
-                        compactionBreaker.failures += 1;
-                        const msg = String(err instanceof Error ? err.message : err);
-                        queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: msg.length > 512 ? `${msg.slice(0, 512)}…` : msg, ...ident() });
-                        return false;
-                    }
+                    return runForcedCompactionPass("rejection");
                 },
             },
         });
+        prepared.microCompact.inTurnCompactionRef.current = async (turnSignal, anchoredEstimate) => {
+            if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
+                return false;
+            if (turnSignal?.aborted === true)
+                return false;
+            if (anchoredEstimate !== undefined && rs.counters.compactionFloor > 0 && anchoredEstimate < rs.counters.compactionFloor) {
+                const floor = rs.counters.compactionFloor;
+                emitTrace(rs.telemetry.tracer, () => ({ kind: "compaction.suppressed", version: 1, taskId: rs.telemetry.taskId, estTokens: anchoredEstimate, floor, ts: Date.now() }));
+                queue.push({ type: "compaction_outcome", outcome: "suppressed", trigger: "forced", ...ident() });
+                return false;
+            }
+            return runForcedCompactionPass("guard", turnSignal);
+        };
         const rapidRefill = createRapidRefillState();
         const drainManualCompact = (outcome) => {
             manualCompactRef.requested = false;
@@ -3312,6 +3410,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 +=
@@ -3362,7 +3526,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 {
@@ -3586,7 +3750,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 });
@@ -4169,7 +4333,9 @@ export class Runner {
             }
         }
         let wakeMessage;
+        let wakeHookContext;
         const outcomeGate = outcome.gate;
+        const resumeSignal = taskConfig.signal;
         let suppliedMessage;
         if (outcomeGate === "wake") {
             suppliedMessage = outcome.message;
@@ -4454,7 +4620,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) {
@@ -4513,6 +4679,7 @@ export class Runner {
             throw new CheckpointError("checkpoint.invalid_outcome", "TaskSpec.basePolicyForResumeEdit is administratively locked by this deployment (locked key \"toolPolicy\") — a task-supplied " +
                 "resume-edit policy is refused pre-CAS (the checkpoint stays pending); remove the field or change the deployment's lock configuration");
         }
+        let recheckGovernanceWindow;
         {
             const rowPrincipal = cp.principal || undefined;
             const suppliedPrincipal = taskConfig.principal || undefined;
@@ -4524,16 +4691,79 @@ export class Runner {
             const owesDelivery = outcomeGate !== "resource_limit" ||
                 readPendingSteerQueue(cp.state).length > 0 ||
                 (cp.state.runningBackgroundTasks?.length ?? 0) > 0;
-            if (owesDelivery && this.deps.usageWindowStore !== undefined) {
+            const usageWindowStore = this.deps.usageWindowStore;
+            if (owesDelivery && usageWindowStore !== undefined) {
                 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()));
-                    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 });
+                    const assertWindowOpen = async () => {
+                        const wait = usageRetryAfterMs(await 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 });
+                        }
+                    };
+                    recheckGovernanceWindow = assertWindowOpen;
+                    await assertWindowOpen();
+                }
+            }
+        }
+        if (outcomeGate === "wake" && wakeMessage !== undefined) {
+            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;
                 }
+                if (recheckGovernanceWindow !== undefined)
+                    await recheckGovernanceWindow();
             }
         }
         if (plainPolicyOutcome !== undefined &&
@@ -4668,10 +4898,10 @@ export class Runner {
                 }
             }
             : undefined;
-        if (taskConfig.signal?.aborted === true && consumeFlipDone) {
+        if (resumeSignal?.aborted === true && consumeFlipDone) {
             throw new CheckpointError("checkpoint.resume_aborted", "the resume was aborted after its row was already claimed — the checkpoint stays consumed and the caller's rollback settles the outcome-unknown terminal (reopening here would strand a pending approval no redemption path can reach)");
         }
-        if (taskConfig.signal?.aborted === true) {
+        if (resumeSignal?.aborted === true) {
             let reopenOutcome = "refused";
             if (onEnvRestoreFailed !== undefined) {
                 try {
@@ -4688,7 +4918,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;