@sema-agent/core 5.62.0 → 5.64.0

package/dist/core/runner/runtask.js

@@ -3030,15 +3030,119 @@ 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) {
+                    const interruptReason = lane === "rejection"
+                        ? "prompt-too-long recovery pass cut short by a turn interrupt"
+                        : "guard-chain forced compaction cut short by a turn interrupt";
+                    queue.push({ type: "compaction_outcome", outcome: "failed", trigger: "forced", reason: interruptReason, ...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: {},
             thinkingOnly: {},
             degenerateOutput: { detect: (m) => isDegenerateCutMessage(m) },
             promptTooLong: {
-                recover: async (attempt) => {
+                recover: async (attempt, turnSignal) => {
                     if (prepared.abortController.signal.aborted || prepared.suspendRef.token !== undefined)
                         return false;
+                    if (turnSignal?.aborted === true)
+                        return false;
                     if (prepared.microCompact.clearOnRejection && attempt === 1) {
                         const proj = prepared.microCompact.projectionRef.current;
                         const compactionAvailable = (spec.compaction?.enabled ?? true) && compactionBreaker.failures < MAX_CONSECUTIVE_COMPACTION_FAILURES;
@@ -3075,85 +3179,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", turnSignal);
                 },
             },
         });
+        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;
@@ -4271,7 +4313,8 @@ export class Runner {
         if (outcome === null || typeof outcome !== "object") {
             throw new CheckpointError("checkpoint.invalid_outcome", `resume outcome must be an object naming its gate (got ${outcome === null ? "null" : typeof outcome})`);
         }
-        const store = resolveCheckpointStore(taskConfig, this.deps);
+        const config = typeof taskConfig === "object" && taskConfig !== null ? { ...taskConfig } : taskConfig;
+        const store = resolveCheckpointStore(config, this.deps);
         if (!store) {
             throw new CheckpointError("checkpoint.not_found", "no CheckpointStore wired — cannot resume (set RunnerDeps.checkpointStore or taskConfig.checkpointStore)");
         }
@@ -4298,7 +4341,7 @@ export class Runner {
         let wakeMessage;
         let wakeHookContext;
         const outcomeGate = outcome.gate;
-        const resumeSignal = taskConfig.signal;
+        const resumeSignal = config.signal;
         let suppliedMessage;
         if (outcomeGate === "wake") {
             suppliedMessage = outcome.message;
@@ -4336,62 +4379,6 @@ 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 " +
@@ -4583,7 +4570,7 @@ export class Runner {
                     : "resume carried a content-ask `answer` on a `deny` — a denial injects a refusal, never an answer; refusing rather than dropping it silently", { field: "answer" });
             }
             if (contentAskCallId !== undefined && plainPolicyOutcome.decision === "allow" && suppliedAnswer === undefined) {
-                if (!isLiveQuestionFace(taskConfig.onQuestion ?? this.deps.onQuestion)) {
+                if (!isLiveQuestionFace(config.onQuestion ?? this.deps.onQuestion)) {
                     throw new CheckpointError("checkpoint.invalid_outcome", "resume approved a content-ask (the reserved question tool) without an `answer`, and this resume has no live answering face — " +
                         'executing the question against nothing would hand the model a fabricated "no human is available" default while consuming the approval; ' +
                         "re-resume with the operator's answer on the outcome (or deny it), the checkpoint stays pending", { field: "answer" });
@@ -4694,13 +4681,14 @@ export class Runner {
                 },
             }
             : internals;
-        if (this.deps.lockedConfig?.keys?.includes("toolPolicy") === true && taskConfig.basePolicyForResumeEdit !== undefined) {
+        if (this.deps.lockedConfig?.keys?.includes("toolPolicy") === true && config.basePolicyForResumeEdit !== undefined) {
             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;
+            const suppliedPrincipal = config.principal || undefined;
             if (rowPrincipal !== undefined && suppliedPrincipal !== undefined && suppliedPrincipal !== rowPrincipal) {
                 throw new CheckpointError("resume.principal_mismatch", `the resume config carries principal ${JSON.stringify(suppliedPrincipal)} but this checkpoint was suspended under principal ${JSON.stringify(rowPrincipal)} — ` +
                     "running the resumed leg under a different identity would move its usage-ledger bucket, scope derivation and attribution; " +
@@ -4709,16 +4697,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()), 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 });
+                    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 = config.hooks ?? this.deps.hooks;
+            const screen = resumeScreenHooks?.userPromptSubmit;
+            if (screen !== undefined && resumeSignal?.aborted !== true) {
+                const screenedMessage = wakeMessage;
+                const identity = mintHookInvocationIdentity({
+                    sessionId: cp.sessionId,
+                    taskId: config.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 &&
@@ -4739,7 +4790,7 @@ export class Runner {
                 budget: editBudget,
                 ...(cp.state.handsCwd !== undefined ? { cwd: cp.state.handsCwd } : {}),
             };
-            const editSignal = taskConfig.signal;
+            const editSignal = config.signal;
             const raceEditAbort = async (p) => {
                 if (editSignal === undefined)
                     return p;
@@ -4778,7 +4829,7 @@ export class Runner {
             const toolPolicyLocked = this.deps.lockedConfig?.keys?.includes("toolPolicy") === true;
             const editBasePolicy = toolPolicyLocked
                 ? (this.deps.basePolicyForResumeEdit ?? this.deps.toolPolicy)
-                : (taskConfig.basePolicyForResumeEdit ?? this.deps.basePolicyForResumeEdit ?? taskConfig.toolPolicy ?? this.deps.toolPolicy);
+                : (config.basePolicyForResumeEdit ?? this.deps.basePolicyForResumeEdit ?? config.toolPolicy ?? this.deps.toolPolicy);
             if (editBasePolicy !== undefined) {
                 let rechecked;
                 try {
@@ -4798,7 +4849,7 @@ export class Runner {
                         `refused pre-CAS (the checkpoint stays pending); re-submit the edited action so the rewrite is adjudicated and approved synchronously`);
                 }
             }
-            const resumeHooks = taskConfig.hooks ?? this.deps.hooks;
+            const resumeHooks = config.hooks ?? this.deps.hooks;
             if (resumeHooks?.preToolUse !== undefined && resumeHooks.preToolUseObservational === true) {
                 try {
                     await raceEditAbort(Promise.resolve(resumeHooks.preToolUse(cp.pendingAction.toolName, cloneObserverInput(editedArgs), {
@@ -4833,15 +4884,15 @@ export class Runner {
             consumeFlipDone = true;
         }
         const answerFace = plainPolicyOutcome !== undefined && redeemedAnswer !== undefined
-            ? answerFaceForRedeemedCall(redeemedAnswer, plainPolicyOutcome.boundCallId, taskConfig.onQuestion ?? this.deps.onQuestion, boundInputHashOf(cp.pendingAction.args?.questions))
+            ? answerFaceForRedeemedCall(redeemedAnswer, plainPolicyOutcome.boundCallId, config.onQuestion ?? this.deps.onQuestion, boundInputHashOf(cp.pendingAction.args?.questions))
             : undefined;
         const spec = {
-            ...taskConfig,
-            ...((taskConfig.principal || undefined) === undefined && (cp.principal || undefined) !== undefined ? { principal: cp.principal } : {}),
+            ...config,
+            ...((config.principal || undefined) === undefined && (cp.principal || undefined) !== undefined ? { principal: cp.principal } : {}),
             objective: "",
             sessionId: cp.sessionId,
             requireExistingSession: true,
-            preemptSignal: taskConfig.preemptSignal?.aborted ? undefined : taskConfig.preemptSignal,
+            preemptSignal: config.preemptSignal?.aborted ? undefined : config.preemptSignal,
             ...(answerFace !== undefined ? { onQuestion: answerFace } : {}),
         };
         const reopenFn = store.reopen?.bind(store);
@@ -4853,10 +4904,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 {

package/dist/core/trace.d.ts

@@ -734,10 +734,11 @@ export type TraceEvent = {
      *  occurrences were replaced with markers in one pass. `trigger` names the arm: `"frontier"`
      *  = the proactive request-build pass (anchored estimate crossed the edit budget),
      *  `"refusal"` = the MC-R rejection-recovery arm (provider said input-too-long), `"blocking"`
-     *  = the slice-3 pre-guard arm (reserved; not emitted before slice 3). SCOPE (X1): emitted
-     *  only when the design/374 machinery is enabled — the `"frontier"` arm requires
-     *  `microCompact.machine: "cc"`, the `"refusal"` arm requires `microCompact.clearOnRejection`;
-     *  the legacy DEFAULT machine clears silently exactly as pre-374 (its clears are ledger-less
+     *  = the slice-3 guard-chain arm A (the machine's one pre-guard shot when the frontier pass
+     *  is off, `microCompact.machine: "off"`). SCOPE (X1): emitted only by the cc machine — the
+     *  `"frontier"` arm requires `microCompact.machine: "cc"` (the default since the slice-3
+     *  flip), the `"refusal"` arm requires `microCompact.clearOnRejection` (also default-on);
+     *  the legacy OPT-OUT machine clears silently exactly as pre-374 (its clears are ledger-less
      *  and re-fire per request, so a frame there would re-count the same occurrences and break
      *  this frame's cardinality clause). Cardinality: exactly ONE frame per firing pass — a retry
      *  chain re-sending an already-cleared view emits none. A `"refusal"` frame also marks one

package/dist/core/types.d.ts

@@ -552,6 +552,13 @@ export interface ToolExecuteContext {
      *  fixed point `ctx.rootSessionId ?? ctx.sessionId` at every spawn). Absent for a top-level run
      *  (its OWN sessionId is the root). */
     rootSessionId?: string;
+    /** design/380 O1② (C12) — the spawning run's EXPLICIT placement fixed point
+     *  (`RunInternals.placementRoot`), present only when its internals carried one (cascade rungs /
+     *  verification legs after the first, or a caller-declared root). A delegation tool threads it
+     *  VERBATIM into child RunInternals so every descendant keeps the ladder/gate placement; absent ⇒
+     *  the `rootSessionId` chain above IS the placement root through prepare's mint middle segment
+     *  (`placementRoot ?? rootSessionId ?? sessionId`) and nothing extra is threaded. */
+    placementRoot?: string;
     /**
      * design/151 §7 S3c — TRUSTED tier-3 revival claim (same trusted-internals seat as
      * {@link parentTaskId}; never a model argument). Filled ONLY by the auto-mounted SendMessage's
@@ -2658,9 +2665,12 @@ export interface TaskSpec {
      * Scope caveat (design/141 examples 批实测): `instructions` rides the WHOLE-TURN summarization
      * request only; a split-turn cut point (mid-turn prefix summarization) uses the engine-owned
      * turn-prefix prompt and does not carry it (same A2 boundary as `RunnerDeps.summaryProvider`).
-     * `withinTask: false` keeps end-of-task compaction but disables the within-task (turn-boundary)
-     * trigger — the escape hatch for the §25 (A) control-flow change; the system prompt then stops
-     * claiming mid-task summarization (§6.3 honesty).
+     * `withinTask: false` keeps end-of-task compaction but disables the ROUTINE within-task
+     * (turn-boundary) trigger — the escape hatch for the §25 (A) control-flow change; the system
+     * prompt then stops claiming ROUTINE mid-task summarization (§6.3 honesty). It does NOT silence
+     * the recovery-class forced lanes (design/374 slice 3): a prompt-too-long recovery or the guard
+     * chain's arm B may still legitimately compact WITHIN the task — error/pressure recovery is not
+     * a routine boundary pass, so a within-task compaction under this flag is contract-conforming.
      * `attachWorkingFiles` (LONGRUN-2; **default ON since 2026-07-03** — CC 198 hard-codes its
      * post-compact file restore, and LONGRUN-2 measured ≈2.3 extra read round-trips per compaction
      * without it): after each compaction, re-read the task's most recently READ files (CC
@@ -5929,9 +5939,12 @@ export interface RunnerDeps {
      * `TaskSpec.limits`, which is the allowance ONE task asked for — an operator granting "N tokens per 5
      * hours" cannot express it as a task limit, because nothing stops the next task from asking again.
      *
-     * A window carries a TOKEN ceiling and, optionally, a MONEY ceiling (`UsageWindow.maxCostUsd`, absolute
-     * USD — the `TaskLimits.maxCostUsd` quantity one governance level up). The two are independent and
-     * either one binds. A $ ceiling requires a PRICED run: a task whose model has neither a {@link pricing}
+     * A window carries a TOKEN ceiling (`UsageWindow.maxTokens`), a MONEY ceiling (`UsageWindow.maxCostUsd`,
+     * absolute USD — the `TaskLimits.maxCostUsd` quantity one governance level up), or both: each is
+     * optional on its own and at least one is required, so a deployment governed by spend alone declares
+     * only `maxCostUsd` (a window with neither ceiling is refused, `config.usage_window_invalid`). The two
+     * are independent and every declared one binds. A $ ceiling requires a PRICED run: a task whose model
+     * has neither a {@link pricing}
      * entry nor a `Model.cost` declaration is refused at the door (`config.usage_window_unpriced`) rather
      * than charged the fabricated 0 an unpriced run would otherwise file into an operator's ceiling.
      *
@@ -6345,22 +6358,26 @@ export interface RunnerDeps {
      */
     toolResultThresholdChars?: number;
     /**
-     * design/374 — microCompact machine-alignment knobs (EXPERIMENTAL until the slice-3 default
-     * flip; both default OFF so a deployment that never touches this bag runs the pre-374 machine
-     * byte for byte).
+     * design/374 — microCompact machine-alignment knobs. Since the slice-3 default flip BOTH knobs
+     * default ON (`machine: "cc"`, `clearOnRejection: true`); the pre-374 behavior is the explicit
+     * opt-out `{ machine: "legacy", clearOnRejection: false }`.
      *
      *  - `machine`: which stale-tool-result clearing machine the request pipeline runs —
-     *    `"legacy"` (default; the historical keep-3 / clear-to-budget machine) or `"cc"` (the CC
-     *    2.1.223 rejection-leg form: keep 5, ≥20k minimum-savings gate, one deep clear beyond the
-     *    keep window, CC marker bytes). ⚠️ Read the P-form warning on
-     *    {@link import("./context-edit.js").ContextEditMachine} before selecting `"cc"`: until the
-     *    slice-3 fallback re-ordering ships, the 20k gate sits in front of the only reduction while
-     *    the message-dropping guard trim still backstops — opting in is accepting that trade.
+     *    `"cc"` (default: the CC 2.1.223 rejection-leg form — keep 5, ≥20k minimum-savings gate, one
+     *    deep clear beyond the keep window, CC marker bytes), `"legacy"` (the historical keep-3 /
+     *    clear-to-budget machine, kept as the compatibility opt-out; it also keeps the pre-374
+     *    backstop order — guard trim as the ordinary second line), or `"off"` (no proactive frontier
+     *    clearing at all — the D-2 off switch; the unified machine then gets its ONE shot at the
+     *    blocking point instead, the slice-3 arm A, trace trigger `"blocking"`). The pre-flip P-form
+     *    warning on {@link import("./context-edit.js").ContextEditMachine} is resolved: the slice-3
+     *    fallback re-ordering shipped with this default (blocking-point re-run → in-turn forced
+     *    compaction behind the adopt seam → trim demoted to the disaster-only last resort), so an
+     *    under-20k refusal no longer falls straight into a message-dropping trim.
      *  - `clearOnRejection` (MC-R, slice 2): on a provider input-too-long rejection, run ONE cheap
      *    deterministic clear over the rejected projection (same cc machine, savings ≥20k or nothing)
-     *    and retry inside the turn BEFORE the forced-compaction recovery. Default false (X2: the
-     *    machinery lands dark; the default flips together with the machine in slice 3). Independent
-     *    of `machine` — an enabled MC-R always clears in the cc form (the rejection arm has no
+     *    and retry inside the turn BEFORE the forced-compaction recovery. Default true (flipped with
+     *    the machine default in slice 3; X2's dark-landing clause is spent). Independent of
+     *    `machine` — an enabled MC-R always clears in the cc form (the rejection arm has no
      *    budget coordinate for the legacy incremental form to stop at). BUDGET ACCOUNTING (design/374
      *    §3.2.1, stated here because it is otherwise invisible to a deployment): a successful MC-R
      *    clear-and-retry SPENDS one attempt of the shared prompt-too-long recovery budget (default 2
@@ -6372,10 +6389,11 @@ export interface RunnerDeps {
      *  A declaration outside the closed vocabulary (a `machine` string not in the union, a
      *  non-boolean `clearOnRejection` — JSON/env-derived config the type cannot guard) refuses the
      *  whole prepare loudly (`code: "config.microcompact_invalid"`, no silent re-default): folding it
-     *  would run the pre-374 machine while the deployment believes it opted in.
+     *  would silently run the DEFAULT machine while the deployment believes its declaration took
+     *  effect.
      */
     microCompact?: {
-        machine?: "legacy" | "cc";
+        machine?: "off" | "legacy" | "cc";
         clearOnRejection?: boolean;
     };
     /**