@sema-agent/core 5.62.0 → 5.63.0

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

@@ -345,6 +345,7 @@ function buildMicroCompactState(deps, model, sessionId, offloadStore, knob) {
         clearOnRejection: knob.clearOnRejection,
         ledger: createClearedProjectionLedger(),
         projectionRef: {},
+        inTurnCompactionRef: {},
         ...(offloadStore ? { offloadPersist: createOffloadPersist(offloadStore, sessionId, deps.onNotice) } : {}),
     };
 }
@@ -363,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;
@@ -4621,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