@sema-agent/core 5.61.0 → 5.63.0

package/dist/core/runner/prepare-task.js

@@ -95,7 +95,7 @@ import { BINDING_CHECKPOINT_VERSION, mintCheckpointId, mintCheckpointToken, ORG_
 import { boundInputHashOf } from "../canonical-json.js";
 import { countElicitOptIns, deriveWiringManifest, resolveAskSeamForm, resolveDeclaredDurability, resolveElicitSeam, resolveQuestionSeam, resolveSubagentTranscriptTier } from "../wiring-manifest.js";
 import { durableParkGapFor } from "../park-selfcheck.js";
-import { GLOBAL_USAGE_KEY, usageRetryAfterMs } from "../usage-window-store.js";
+import { GLOBAL_USAGE_KEY, usageRetryAfterMs, windowsGovernCost } from "../usage-window-store.js";
 import { deliverEngineNotice } from "../types.js";
 let announcedMaterializeEnvBySink = new WeakMap();
 const announcedMaterializeEnvConsole = new Set();
@@ -228,6 +228,61 @@ const ULTRA_REASONING_TIERS = new Set(["xhigh", "max"]);
 const DEFAULT_RESOURCE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 export const ENV_LIFETIME_SUSPEND_MARGIN_MS = 60_000;
 export const USAGE_WINDOW_REAP_MARGIN_MS = 60 * 60 * 1000;
+function buildUsageGovernance(windows, deps, principal, sessionId) {
+    if (windows === undefined || windows.length === 0)
+        return undefined;
+    const store = deps.usageWindowStore;
+    if (store === undefined) {
+        deps.onError?.(new Error("RunnerDeps.usageWindows is set but INACTIVE: no `usageWindowStore` is wired, so cross-task usage cannot be counted and no window can be enforced. Wire InMemoryUsageWindowStore (process-local) or FileUsageWindowStore (restart-surviving)."), { phase: "config", sessionId });
+        return undefined;
+    }
+    const key = principal || GLOBAL_USAGE_KEY;
+    const governsCost = windowsGovernCost(windows);
+    let chargedTokens = 0;
+    let chargedCostMicroUsd = 0;
+    let announcedCostGap = false;
+    let recordedUnpricedGap = false;
+    return {
+        key,
+        governsCost,
+        async check(now) {
+            const readings = await store.read(key, windows, now);
+            if (!announcedCostGap && readings.some((r) => r.costUnknown === true)) {
+                announcedCostGap = true;
+                deps.onError?.(new Error(`the usage window for ledger key ${JSON.stringify(key)} holds spend that nothing could price, so its maxCostUsd ceiling is being evaluated against a LOWER BOUND until that charge ages out of the window. Price every model this deployment can reach (including degrade targets and the compaction model).`), { phase: "config", sessionId });
+            }
+            return usageRetryAfterMs(readings, windows);
+        },
+        async commit(cumulativeTokens, cumulativeCostMicroUsd, now) {
+            if (!governsCost) {
+                const delta = cumulativeTokens - chargedTokens;
+                if (delta <= 0)
+                    return;
+                await store.charge(key, delta, now, windows);
+                chargedTokens = cumulativeTokens;
+                return;
+            }
+            if (cumulativeCostMicroUsd === undefined) {
+                const tokenDelta = cumulativeTokens - chargedTokens;
+                if (tokenDelta > 0 || !recordedUnpricedGap) {
+                    await store.charge(key, Math.max(0, tokenDelta), now, windows, null);
+                    chargedTokens = Math.max(chargedTokens, cumulativeTokens);
+                    recordedUnpricedGap = true;
+                }
+                const e = new Error("a deployment usage window declares maxCostUsd, but this run's spend has NO cost figure (RB-368 unpriced: a model served without a RunnerDeps.pricing entry or a Model.cost declaration). Refused rather than charged a fabricated 0 — the money ceiling would have silently stopped applying. Price every model this run can reach, or drop maxCostUsd from the window.");
+                e.code = "config.usage_window_unpriced";
+                throw e;
+            }
+            const tokenDelta = cumulativeTokens - chargedTokens;
+            const costDelta = cumulativeCostMicroUsd - chargedCostMicroUsd;
+            if (tokenDelta <= 0 && costDelta <= 0)
+                return;
+            await store.charge(key, Math.max(0, tokenDelta), now, windows, Math.max(0, costDelta));
+            chargedTokens = cumulativeTokens;
+            chargedCostMicroUsd = cumulativeCostMicroUsd;
+        },
+    };
+}
 export function resolveEnvLifetimeExpiry(env, observedAt) {
     const lifetimeMs = env.lifetimeMs;
     if (lifetimeMs === undefined)
@@ -267,7 +322,7 @@ class ParkRefusal extends Error {
     }
 }
 export { resolveCheckpointStore } from "../checkpoint-store.js";
-export { isFableFamilyModelId, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
+export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./prepare-workspace-restore.js";
 function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
     const triggerWindow = resolveTriggerWindow(model);
@@ -290,6 +345,7 @@ function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
         clearOnRejection: knob.clearOnRejection,
         ledger: createClearedProjectionLedger(),
         projectionRef: {},
+        inTurnCompactionRef: {},
         ...(offloadStore ? { offloadPersist: createOffloadPersist(offloadStore, sessionId, deps.onNotice) } : {}),
     };
 }
@@ -308,10 +364,75 @@ function recordFrontierClears(args) {
         taskId: args.taskId,
         clearedCount: args.pass.clears.length,
         tokensSavedEstimate: args.pass.tokensSavedEstimate,
-        trigger: "frontier",
+        trigger: args.trigger,
         ts: Date.now(),
     }));
 }
+function flushProjectionObservations(pending) {
+    for (const fire of pending.splice(0)) {
+        try {
+            fire();
+        }
+        catch {
+        }
+    }
+}
+export async function runGuardChain(args) {
+    const { edited, microCompact, guardAt, charsPerToken, deps, taskId } = args;
+    const applyGuardTrim = (view, anchoredTotal) => {
+        let trimmed = trimToBudget(view, guardAt, anchoredTotal, charsPerToken);
+        const dropped = trimmed.length < view.length;
+        if (dropped) {
+            args.trimPressureRef.droppedMessages = true;
+            const droppedCount = view.length - trimmed.length;
+            trimmed = insertTrimNotice(trimmed);
+            emitTrace(deps.tracer, () => ({
+                kind: "context.trim",
+                version: 1,
+                taskId,
+                dropped: droppedCount,
+                ts: Date.now(),
+            }));
+        }
+        return { trimmed, dropped };
+    };
+    let working = edited;
+    let anchoredWorking = estimateContextTokens(working, charsPerToken).tokens;
+    if (microCompact.machine === "legacy") {
+        const t = applyGuardTrim(working, anchoredWorking);
+        return { working, trimmed: t.trimmed, trimDroppedMessages: t.dropped };
+    }
+    if (microCompact.machine === "off" && anchoredWorking > guardAt) {
+        let blockingPass;
+        const blockingEdited = clearStaleToolResults(working, {
+            budgetTokens: guardAt,
+            machine: "cc",
+            clearSource: args.replayed,
+            onCleared: (pass) => { blockingPass = pass; },
+            anchoredTotalTokens: anchoredWorking,
+            charsPerToken,
+            ...(args.offloadStore ? { offload: { persist: createOffloadPersist(args.offloadStore, args.sessionId, deps.onNotice) } } : {}),
+        });
+        if (blockingPass !== undefined) {
+            recordFrontierClears({ pass: blockingPass, index: args.index, edited: blockingEdited, ledger: microCompact.ledger, tracer: deps.tracer, taskId, trigger: "blocking" });
+            working = blockingEdited;
+            anchoredWorking = estimateContextTokens(working, charsPerToken).tokens;
+        }
+    }
+    if (anchoredWorking > guardAt && args.recheck !== true) {
+        const compacted = (await microCompact.inTurnCompactionRef.current?.(args.signal, anchoredWorking)) === true;
+        if (compacted) {
+            args.pendingProjectionObservations.length = 0;
+            return { earlyReturn: { messages: working, adoptSessionRebuild: true } };
+        }
+        if (args.signal?.aborted === true) {
+            args.pendingProjectionObservations.length = 0;
+            return { working, trimmed: working, trimDroppedMessages: false };
+        }
+    }
+    const t = applyGuardTrim(working, anchoredWorking);
+    return { working, trimmed: t.trimmed, trimDroppedMessages: t.dropped };
+}
 export function gatedCallIdOf(p) {
     if (p.suspendRef.token !== undefined)
         return p.suspendRef.gatedCallId;
@@ -339,7 +460,7 @@ function publishCommittedSuspend(refs, token, gate, scope, remoteHandle, checkpo
 function hasConversationContent(branch) {
     return branch.some((e) => e.type === "message" || e.type === "custom_message" || e.type === "compaction");
 }
-function effectiveDelegationFacts(internals, seedIsDelegatedChild) {
+export function effectiveDelegationFacts(internals, seedIsDelegatedChild) {
     const isDelegatedChild = internals?.isDelegatedChild !== undefined ? internals.isDelegatedChild === true : seedIsDelegatedChild === true;
     return { isDelegatedChild, isNonForkChild: isDelegatedChild && internals?.insideFork !== true };
 }
@@ -475,20 +596,21 @@ const sanitizePreview = (node, depth = 0) => {
 function resolveApprovalPreview(tools, toolName, args) {
     const t = tools.find((x) => x.name === toolName || (x.aliases?.includes(toolName) ?? false));
     if (t?.approvalPreview === undefined)
-        return undefined;
+        return {};
     try {
         const raw = t.approvalPreview(args);
         if (raw === undefined)
-            return undefined;
+            return {};
         const bytes = JSON.stringify(raw);
         if (bytes === undefined)
-            return undefined;
-        if (bytes.length > 16_384)
-            return { truncated: true, note: `approval preview exceeded 16KiB (${bytes.length} chars serialized)` };
-        return sanitizePreview(raw);
+            return { withheld: "unavailable" };
+        if (bytes.length > 16_384) {
+            return { preview: { truncated: true, note: `approval preview exceeded 16KiB (${bytes.length} chars serialized)` }, withheld: "oversize" };
+        }
+        return { preview: sanitizePreview(raw) };
     }
     catch {
-        return undefined;
+        return { withheld: "unavailable" };
     }
 }
 function inheritedAskRuleEvidence(deps) {
@@ -839,7 +961,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 if (e.type === "task_progress")
                     forwardSink(e);
                 else if (spec.forwardSubagentEvents === true &&
-                    (e.type === "text_delta" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_end")) {
+                    (e.type === "text_delta" || e.type === "text_end" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_end")) {
                     forwardSink(e);
                 }
             }
@@ -3140,6 +3262,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
             if (ask?.requiresRealApproval === true ||
                 ask?.persistedRuleShadowed !== undefined ||
                 ask?.decisionReason === "hook" ||
+                ask?.matchedAskRule !== undefined ||
                 ask?.inheritedUnresolved === true ||
                 ask?.ancestorResolved === true) {
                 return {};
@@ -3550,31 +3673,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 sessionId,
             });
         }
-        const usageGovernance = (() => {
-            if (usageWindows === undefined || usageWindows.length === 0)
-                return undefined;
-            const store = deps.usageWindowStore;
-            if (store === undefined) {
-                deps.onError?.(new Error("RunnerDeps.usageWindows is set but INACTIVE: no `usageWindowStore` is wired, so cross-task usage cannot be counted and no window can be enforced. Wire InMemoryUsageWindowStore (process-local) or FileUsageWindowStore (restart-surviving)."), { phase: "config", sessionId });
-                return undefined;
-            }
-            const key = spec.principal || GLOBAL_USAGE_KEY;
-            const windows = usageWindows;
-            let charged = 0;
-            return {
-                key,
-                async check(now) {
-                    return usageRetryAfterMs(await store.read(key, windows, now));
-                },
-                async commit(cumulativeTokens, now) {
-                    const delta = cumulativeTokens - charged;
-                    if (delta <= 0)
-                        return;
-                    await store.charge(key, delta, now, windows);
-                    charged = cumulativeTokens;
-                },
-            };
-        })();
+        const usageGovernance = buildUsageGovernance(usageWindows, deps, spec.principal, sessionId);
         const platformSuspendArmed = durableSuspendInfraReady && (envLifetimeSuspendAt !== undefined || usageGovernance !== undefined);
         const checkpointStore = resolveCheckpointStore(spec, deps);
         const durableApproval = spec.durableApproval ??
@@ -3667,8 +3766,8 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                     toolCallId: req.toolCallId,
                     args: req.args,
                     ...(() => {
-                        const preview = approvalPreviewOf(req.toolName, req.args);
-                        return preview !== undefined ? { preview } : {};
+                        const p = approvalPreviewOf(req.toolName, req.args);
+                        return { ...(p.preview !== undefined ? { preview: p.preview } : {}), ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}) };
                     })(),
                     ...ruleOffersOf(req.toolName, req.args, decision.action === "ask" ? decision : undefined),
                     message: decision.message ?? `approval required for "${req.toolName}"`,
@@ -4148,7 +4247,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                 }
             };
             const suspendAsk = parkLaneArmed && checkpointStore !== undefined
-                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage) => {
+                ? async (req, postHookArgs, safety, liveFaceUnavailable, realApproval, shadowedRule, askDecisionReason, probeReason, probeCause, segmentCoverage, matchedAskRule) => {
                     const syncFirstEligible = req.toolName === ASK_USER_QUESTION_TOOL_NAME ? contentAskRoutable(req.toolCallId) : isLiveApproverSeat(onAsk);
                     if (syncFirstEligible &&
                         runtimeCaps?.forceDurableGate !== true &&
@@ -4306,10 +4405,11 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                 toolName: req.toolName,
                                 args: parkedArgs,
                                 ...(() => {
-                                    const preview = approvalPreviewOf(req.toolName, parkedArgs);
-                                    const bidi = carriesBidiControls(parkedArgs) || carriesBidiControls(preview);
+                                    const p = approvalPreviewOf(req.toolName, parkedArgs);
+                                    const bidi = carriesBidiControls(parkedArgs) || carriesBidiControls(p.preview);
                                     return {
-                                        ...(preview !== undefined ? { preview } : {}),
+                                        ...(p.preview !== undefined ? { preview: p.preview } : {}),
+                                        ...(p.withheld !== undefined ? { previewWithheld: p.withheld } : {}),
                                         ...(bidi ? { hasBidiControls: true } : {}),
                                     };
                                 })(),
@@ -4317,6 +4417,7 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
                                     ...(realApproval !== undefined ? { requiresRealApproval: true } : {}),
                                     ...(shadowedRule !== undefined ? { persistedRuleShadowed: shadowedRule } : {}),
                                     ...(askDecisionReason !== undefined ? { decisionReason: askDecisionReason } : {}),
+                                    ...(matchedAskRule !== undefined ? { matchedAskRule } : {}),
                                     ...(inheritedUnavailableAsks.has(req.toolCallId) ? { inheritedUnresolved: true } : {}),
                                     ...(segmentCoverage !== undefined ? { segmentCoverage } : {}),
                                 }),
@@ -4586,101 +4687,108 @@ export async function prepareTask(spec, deps, sessions, resume, internals, runne
         const guardAt = guardBudget(model);
         const microCompact = buildMicroCompactState(deps, model, sessionId, offloadStore, microCompactKnob);
         const charsPerToken = model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
-        harness.on("context", async ({ messages }) => {
+        harness.on("context", async ({ messages, recheck, signal }) => {
             batchHaltRef.current = undefined;
-            const healed = dropEmptyFailureAssistants(messages);
-            const replay = replayClearedProjection(healed, microCompact.ledger);
-            const replayed = replay.messages;
-            const capped = await capAggregateToolResults(replayed, {
-                store: offloadStore,
-                sessionId,
-                onCapped: (info) => emitTrace(deps.tracer, () => ({
-                    kind: "tool_result.capped",
-                    version: 1,
-                    taskId: spec.taskId ?? sessionId,
-                    ...(info.tool !== undefined ? { tool: info.tool } : {}),
-                    sizeChars: info.sizeChars,
-                    storeFallback: info.storeFallback,
-                    ts: Date.now(),
-                })),
-            });
-            const mediaCapped = capAggregateMediaBytes(capped, {
-                limitBytes: deps.mediaByteCapBytes ?? AGGREGATE_MEDIA_BUDGET_BYTES,
-                onStripped: deps.onMediaStripped,
-            });
-            let ccPass;
-            const edited = clearStaleToolResults(mediaCapped, {
-                budgetTokens: editAt,
-                ...(microCompact.machine === "cc" || microCompact.clearOnRejection ? { recognizeCcMarkers: true } : {}),
-                ...(microCompact.machine === "cc"
-                    ? {
-                        machine: "cc",
-                        clearSource: replayed,
-                        onCleared: (pass) => { ccPass = pass; },
-                    }
-                    : {}),
-                anchoredTotalTokens: estimateContextTokens(mediaCapped, charsPerToken).tokens,
-                charsPerToken,
-                ...(offloadStore
-                    ? {
-                        offload: {
-                            persist: createOffloadPersist(offloadStore, sessionId, deps.onNotice),
-                        },
-                    }
-                    : {}),
-            });
-            if (ccPass !== undefined) {
-                recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: spec.taskId ?? sessionId });
-            }
-            let trimmed = trimToBudget(edited, guardAt, estimateContextTokens(edited, charsPerToken).tokens, charsPerToken);
-            const trimDroppedMessages = trimmed.length < edited.length;
-            if (trimDroppedMessages) {
-                trimPressureRef.droppedMessages = true;
-                const droppedCount = edited.length - trimmed.length;
-                trimmed = insertTrimNotice(trimmed);
-                emitTrace(deps.tracer, () => ({
-                    kind: "context.trim",
-                    version: 1,
-                    taskId: spec.taskId ?? sessionId,
-                    dropped: droppedCount,
-                    ts: Date.now(),
-                }));
-            }
-            trimmed = applyGitFrameGuard({
-                before: edited,
-                trimmed,
-                budgetTokens: guardAt,
-                ref: gitStatusRef,
-                charsPerToken,
-                onDegrade: (message) => {
+            const pendingProjectionObservations = [];
+            try {
+                const healed = dropEmptyFailureAssistants(messages);
+                const replay = replayClearedProjection(healed, microCompact.ledger);
+                const replayed = replay.messages;
+                const capped = await capAggregateToolResults(replayed, {
+                    store: offloadStore,
+                    sessionId,
+                    onCapped: (info) => pendingProjectionObservations.push(() => emitTrace(deps.tracer, () => ({
+                        kind: "tool_result.capped",
+                        version: 1,
+                        taskId: spec.taskId ?? sessionId,
+                        ...(info.tool !== undefined ? { tool: info.tool } : {}),
+                        sizeChars: info.sizeChars,
+                        storeFallback: info.storeFallback,
+                        ts: Date.now(),
+                    }))),
+                });
+                const mediaCapped = capAggregateMediaBytes(capped, {
+                    limitBytes: deps.mediaByteCapBytes ?? AGGREGATE_MEDIA_BUDGET_BYTES,
+                    onStripped: (info) => {
+                        const onMediaStripped = deps.onMediaStripped;
+                        if (onMediaStripped !== undefined)
+                            pendingProjectionObservations.push(() => onMediaStripped(info));
+                    },
+                });
+                let ccPass;
+                const edited = microCompact.machine === "off" ? mediaCapped : clearStaleToolResults(mediaCapped, {
+                    budgetTokens: editAt,
+                    machine: microCompact.machine,
+                    ...(microCompact.machine === "cc" || microCompact.clearOnRejection ? { recognizeCcMarkers: true } : {}),
+                    ...(microCompact.machine === "cc"
+                        ? {
+                            clearSource: replayed,
+                            onCleared: (pass) => { ccPass = pass; },
+                        }
+                        : {}),
+                    anchoredTotalTokens: estimateContextTokens(mediaCapped, charsPerToken).tokens,
+                    charsPerToken,
+                    ...(offloadStore
+                        ? {
+                            offload: {
+                                persist: createOffloadPersist(offloadStore, sessionId, deps.onNotice),
+                            },
+                        }
+                        : {}),
+                });
+                if (ccPass !== undefined) {
+                    recordFrontierClears({ pass: ccPass, index: replay.index, edited, ledger: microCompact.ledger, tracer: deps.tracer, taskId: spec.taskId ?? sessionId, trigger: "frontier" });
+                }
+                const chain = await runGuardChain({
+                    edited, replayed, index: replay.index, microCompact, guardAt, charsPerToken, offloadStore,
+                    sessionId, taskId: spec.taskId ?? sessionId, deps, trimPressureRef, recheck, signal,
+                    pendingProjectionObservations,
+                });
+                if ("earlyReturn" in chain) {
+                    return chain.earlyReturn;
+                }
+                const { working, trimDroppedMessages } = chain;
+                let trimmed = chain.trimmed;
+                trimmed = applyGitFrameGuard({
+                    before: working,
+                    trimmed,
+                    budgetTokens: guardAt,
+                    ref: gitStatusRef,
+                    charsPerToken,
+                    onDegrade: (message) => {
+                        try {
+                            deps.onError?.(new Error(message), { phase: "degraded", sessionId, classification: "env-git-snapshot" });
+                        }
+                        catch {
+                        }
+                    },
+                });
+                const swept = dropOrphanToolResults(trimmed);
+                if (swept.dropped.length > 0) {
                     try {
-                        deps.onError?.(new Error(message), { phase: "degraded", sessionId, classification: "env-git-snapshot" });
+                        deps.onError?.(new Error(`context belt: dropped ${swept.dropped.length} orphan toolResult(s) whose tool-call assistant was not in the request view — ` +
+                            swept.dropped
+                                .map((d) => `toolCallId=${d.toolCallId} at index ${d.index} (prev=${d.prevRole}, next=${d.nextRole})`)
+                                .join("; ")), { phase: "hook", sessionId });
                     }
                     catch {
                     }
-                },
-            });
-            const swept = dropOrphanToolResults(trimmed);
-            if (swept.dropped.length > 0) {
-                try {
-                    deps.onError?.(new Error(`context belt: dropped ${swept.dropped.length} orphan toolResult(s) whose tool-call assistant was not in the request view — ` +
-                        swept.dropped
-                            .map((d) => `toolCallId=${d.toolCallId} at index ${d.index} (prev=${d.prevRole}, next=${d.nextRole})`)
-                            .join("; ")), { phase: "hook", sessionId });
-                }
-                catch {
                 }
+                requestLossyRef.current =
+                    replayed !== healed ||
+                        capped !== replayed ||
+                        mediaCapped !== capped ||
+                        edited !== mediaCapped ||
+                        working !== edited ||
+                        trimDroppedMessages ||
+                        swept.dropped.length > 0 ||
+                        gitStatusRef.overBudgetShrunk === true;
+                microCompact.projectionRef.current = { messages: swept.messages, keyOf: replay.index.keyOf };
+                return { messages: swept.messages };
+            }
+            finally {
+                flushProjectionObservations(pendingProjectionObservations);
             }
-            requestLossyRef.current =
-                replayed !== healed ||
-                    capped !== replayed ||
-                    mediaCapped !== capped ||
-                    edited !== mediaCapped ||
-                    trimDroppedMessages ||
-                    swept.dropped.length > 0 ||
-                    gitStatusRef.overBudgetShrunk === true;
-            microCompact.projectionRef.current = { messages: swept.messages, keyOf: replay.index.keyOf };
-            return { messages: swept.messages };
         });
         const cacheBreakDetector = deps.cacheBreakDetection === false ? undefined : new CacheBreakDetector();
         const cacheFingerprint = cacheBreakDetector

package/dist/core/runner/runtask.d.ts

@@ -51,6 +51,13 @@ interface ResumeRun {
      *  wake message second), each under its own trusted framing — the old merge-into-the-slot shape
      *  silently DISPLACED the parked (undelivered) supervisor steer. Wake outcomes only. */
     wakeMessage?: Omit<PendingSteerEntry, "seq">;
+    /** design/373 §4.3 (D2) — the userPromptSubmit screen's `additionalContext` for {@link wakeMessage},
+     *  captured at the resume ENTRY (the message is screened once, pre-CAS, on the resuming process's
+     *  hook) and delivered by the drain as the engine's own reminder AHEAD of the wake frame — carrying
+     *  it forward is what keeps the hook single-run (re-screening at the drain would be the double-run
+     *  §4.3-3 reserves for the cross-process parked leg). Present only when a wake message passed a
+     *  screen that supplied context. */
+    wakeMessageHookContext?: string;
     /** Compensation hook (design/45/49): called iff the resumed run fails with `resume.env_failed` (post-CAS
      *  workspace `resumeVM` failed) OR `resume.tool_unavailable` (P-7: the approved tool vanished) — in both
      *  the CAS already consumed the checkpoint but the pending action never ran. `resumeStream` supplies a