@sema-agent/core 5.62.0 → 5.63.0

package/dist/core/runner/runtask.js

@@ -3030,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: {},
@@ -3075,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;
@@ -4336,62 +4373,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 " +
@@ -4698,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;
@@ -4709,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()), 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 = 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 &&
@@ -4853,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 {

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

@@ -2658,9 +2658,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
@@ -6345,22 +6348,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 +6379,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;
     };
     /**

package/dist/engine/harness/agent-harness.js

@@ -547,7 +547,7 @@ export class AgentHarness {
         userInputParkRecords.delete(message);
         engineNotePayloads.delete(message);
     }
-    createLoopConfig(getTurnState, setTurnState) {
+    createLoopConfig(getTurnState, setTurnState, runPromptOverride) {
         const turnState = getTurnState();
         const self = this;
         return {
@@ -564,9 +564,24 @@ export class AgentHarness {
                 : {}),
             convertToLlm: (messages) => stripEngineMetadata(convertToLlm(messages)),
             shouldStopAfterTurn: () => this._stopAfterTurn,
-            transformContext: async (messages) => {
-                const result = await this.emitHook({ type: "context", messages: [...messages] });
-                return result?.messages ?? messages;
+            transformContext: async (messages, signal) => {
+                const result = await this.emitHook({ type: "context", messages: [...messages], ...(signal !== undefined ? { signal } : {}) });
+                if (result?.adoptSessionRebuild !== true) {
+                    return result?.messages ?? messages;
+                }
+                await this.flushPendingSessionWrites();
+                const nextTurnState = await this.createTurnState();
+                setTurnState(nextTurnState);
+                const rebuiltContext = this.createContext(nextTurnState, runPromptOverride);
+                const recheck = await this.emitHook({ type: "context", messages: [...rebuiltContext.messages], ...(signal !== undefined ? { signal } : {}), recheck: true });
+                return {
+                    messages: recheck?.messages ?? rebuiltContext.messages,
+                    adoptedContext: {
+                        messages: rebuiltContext.messages,
+                        systemPrompt: rebuiltContext.systemPrompt,
+                        ...(rebuiltContext.systemBlocks !== undefined ? { systemBlocks: rebuiltContext.systemBlocks } : {}),
+                    },
+                };
             },
             beforeToolCall: async ({ toolCall, args }) => {
                 const result = await this.emitHook({
@@ -780,7 +795,7 @@ export class AgentHarness {
         this.runAbortController = abortController;
         const runResultPromise = (async () => {
             try {
-                return await runAgentLoop(messages, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState), (event) => this.handleAgentEvent(event, abortController.signal), abortController.signal, this.createStreamFn(getTurnState), undefined, this.loopTrace);
+                return await runAgentLoop(messages, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState, beforeResult?.systemPrompt), (event) => this.handleAgentEvent(event, abortController.signal), abortController.signal, this.createStreamFn(getTurnState), undefined, this.loopTrace);
             }
             catch (error) {
                 try {

package/dist/engine/harness/types.d.ts

@@ -919,6 +919,25 @@ export interface BeforeAgentStartEvent<TSkill extends Skill = Skill, TPromptTemp
 export interface ContextEvent {
     type: "context";
     messages: AgentMessage[];
+    /**
+     * The TURN-scoped abort signal of the request build being transformed (present when the loop
+     * handed one — it always does in production; absent only for bare-harness callers). A handler
+     * that runs an EXPENSIVE reduction (the slice-3 arm-B in-turn compaction is the standing case)
+     * must honor it: a turn interrupt (design/373) fires this signal, and a reduction that only
+     * watches the RUN-level signal would make the interrupt wait out a long summary call and commit
+     * a session mutation the interrupted turn no longer needs (adversarial review r3).
+     */
+    signal?: AbortSignal;
+    /**
+     * design/374 slice 3 — set on the ONE bounded re-dispatch of the adopt seam
+     * ({@link ContextResult.adoptSessionRebuild}): `messages` are the just-adopted session rebuild,
+     * re-presented so the handler's request pipeline applies to what the provider will actually
+     * receive (the "recheck" step of build→reduce→adopt→recheck). A handler must not request a
+     * second adoption on this dispatch — the harness does not honor it (see the result member's
+     * doc) — so a reduction that is still over budget takes the handler's own next arm (the trim
+     * last resort) instead of looping. Absent on every ordinary dispatch.
+     */
+    recheck?: boolean;
 }
 export interface TurnBoundaryEvent {
     /** Fires between model-request boundaries, after session flush, before the context rebuild. */
@@ -997,6 +1016,25 @@ export interface BeforeAgentStartResult {
 /** Hook result for replacing the full context message list before provider conversion. */
 export interface ContextResult {
     messages: AgentMessage[];
+    /**
+     * design/374 slice 3 (arm B, the adopt seam) — the handler PERSISTED a session-level reduction
+     * during this dispatch (e.g. an in-turn forced compaction appended to the session) and asks the
+     * harness to adopt it MID-BUILD, the same three-step form as the two existing adoption flows
+     * (turn_boundary / prompt-too-long recovery): flush pending session writes, rebuild the turn
+     * context from the session (`createTurnState`), adopt it (`setTurnState` + the loop-context
+     * adoption via {@link import("../loop/types.js").TransformedContext}), then re-dispatch the
+     * context hook ONCE on the rebuilt view (`ContextEvent.recheck`) so the request pipeline applies
+     * to it. Result: the provider request, every subsequent hook dispatch, and the active turn state
+     * all see the SAME reduced transcript — the three-party co-view the seam exists for. `messages`
+     * on this arm are the handler's best unadopted view and are superseded by the rebuild.
+     *
+     * Honored AT MOST ONCE per request build: on the recheck dispatch this member is ignored (its
+     * `messages` are used verbatim) — the bound that keeps a reduction that cannot get under budget
+     * from re-entering forever. Typed on the hook RESULT deliberately (not a closure side channel):
+     * the adoption is part of the hook's answer, and the one prior closure-ref transport in this
+     * area (`requestLossyRef`) is a recorded bypass shape, not a precedent to grow.
+     */
+    adoptSessionRebuild?: boolean;
 }
 /** Hook result for patching provider request options before payload construction. */
 export interface BeforeProviderRequestResult {

package/dist/engine/loop/agent-loop.js

@@ -524,7 +524,26 @@ async function settleInterruptedTurn(state, message, executor, committedResults,
 async function streamAssistantResponse(context, config, signal, emit, streamFn, runtime, executor, staticReasoningCutDowngrade) {
     let messages = context.messages;
     if (config.transformContext) {
-        messages = await config.transformContext(messages, signal);
+        const transformed = await config.transformContext(messages, signal);
+        if (Array.isArray(transformed)) {
+            messages = transformed;
+        }
+        else {
+            const adopted = transformed.adoptedContext;
+            if (adopted !== undefined) {
+                context.messages = adopted.messages;
+                if (adopted.systemPrompt !== undefined) {
+                    context.systemPrompt = adopted.systemPrompt;
+                    if (adopted.systemBlocks !== undefined) {
+                        context.systemBlocks = adopted.systemBlocks;
+                    }
+                    else {
+                        delete context.systemBlocks;
+                    }
+                }
+            }
+            messages = transformed.messages;
+        }
     }
     const llmMessages = await config.convertToLlm(messages);
     const llmContext = {