@sema-agent/core 5.54.0 → 5.56.0

package/dist/agents/subagent.js

@@ -1032,6 +1032,134 @@ export function delegationEntryLedgerFootprint(registry) {
         handles += s.size;
     return { keys: byKey.size, handles };
 }
+const localDelegationInFlight = new WeakMap();
+function localDelegationInFlightCount(anchor, key) {
+    return localDelegationInFlight.get(anchor)?.get(key) ?? 0;
+}
+function chargeLocalDelegationInFlight(anchor, key) {
+    let byKey = localDelegationInFlight.get(anchor);
+    if (byKey === undefined) {
+        byKey = new Map();
+        localDelegationInFlight.set(anchor, byKey);
+    }
+    byKey.set(key, (byKey.get(key) ?? 0) + 1);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const live = localDelegationInFlight.get(anchor);
+        if (live === undefined)
+            return;
+        const n = (live.get(key) ?? 0) - 1;
+        if (n > 0)
+            live.set(key, n);
+        else
+            live.delete(key);
+    };
+}
+const spawnAbortedResult = (wt) => ({
+    isError: true,
+    content: `Sub-agent not started: the delegating call was aborted.${wt ? `\n${wt}` : ""}`,
+    details: { error: "aborted" },
+});
+const noopRelease = () => undefined;
+const DELEGATION_POOL_DEFAULT_SCOPE = "default";
+async function untilAbort(p, signal) {
+    if (signal === undefined)
+        return await p;
+    if (signal.aborted)
+        throw new Error("delegation entry gate: aborted before the durable floor was read");
+    let onAbort;
+    try {
+        return await Promise.race([
+            p,
+            new Promise((_resolve, reject) => {
+                onAbort = () => reject(new Error("delegation entry gate: aborted while reading the durable floor"));
+                signal.addEventListener("abort", onAbort, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        if (onAbort !== undefined)
+            signal.removeEventListener("abort", onAbort);
+    }
+}
+async function openDelegationEntryGate(input) {
+    const { poolAnchor, registry, store, root, caps, revival, signal } = input;
+    if (root === undefined)
+        return { key: undefined, admit: () => ({ admitted: true, release: noopRelease }) };
+    const scope = input.scope ?? DELEGATION_POOL_DEFAULT_SCOPE;
+    const key = JSON.stringify([scope, root]);
+    let storedHandles = [];
+    let storedEnumerationOk = false;
+    if (store !== undefined && !revival) {
+        try {
+            storedHandles = (await untilAbort(store.listBySession(scope, root), signal)).map((r) => r.handle);
+            storedEnumerationOk = true;
+        }
+        catch {
+            storedHandles = [];
+        }
+    }
+    const admit = (kind) => {
+        const activeFace = registry === undefined ? undefined : registry.activeDelegationHandles;
+        const active = typeof activeFace === "function" ? activeFace.call(registry, scope, root) : [];
+        const local = localDelegationInFlightCount(poolAnchor, key);
+        const running = active.length + local;
+        if (running >= caps.maxConcurrent) {
+            return {
+                admitted: false,
+                refusal: {
+                    code: "delegation.concurrency_cap",
+                    text: `this session tree already has ${running} agents running — the concurrency cap (${caps.maxConcurrent}; RunnerDeps.delegationEntryCaps.maxConcurrent) refuses another. ${kind === "registered" ? "Wait for one to complete (you will be notified) or stop one, then relaunch." : "Wait for one of them to finish or stop one, then try again."}`,
+                },
+            };
+        }
+        if (!revival) {
+            const ledger = delegationEntryLedger(poolAnchor, key);
+            let retained;
+            if (store !== undefined && storedEnumerationOk) {
+                const keep = new Set([...storedHandles, ...active]);
+                if (kind === "registered") {
+                    for (const h of [...ledger])
+                        if (!keep.has(h))
+                            ledger.delete(h);
+                    retained = new Set([...storedHandles, ...ledger]).size;
+                }
+                else {
+                    const survivors = new Set(storedHandles);
+                    for (const h of ledger)
+                        if (keep.has(h))
+                            survivors.add(h);
+                    retained = survivors.size;
+                }
+            }
+            else {
+                retained = ledger.size;
+            }
+            const cumulative = retained + local;
+            if (cumulative >= caps.maxCumulativePerSession) {
+                return {
+                    admitted: false,
+                    refusal: {
+                        code: "delegation.session_cap",
+                        text: `this session tree has already launched ${cumulative} agents in its retained window — the cumulative cap (${caps.maxCumulativePerSession}; RunnerDeps.delegationEntryCaps.maxCumulativePerSession) refuses more. Continue an existing agent (SendMessage) instead of launching new ones.`,
+                    },
+                };
+            }
+        }
+        return { admitted: true, release: kind === "local" ? chargeLocalDelegationInFlight(poolAnchor, key) : noopRelease };
+    };
+    return { key, admit };
+}
+function chargeDelegationEntryHandle(registry, key, store, handle) {
+    if (handle !== undefined)
+        delegationEntryLedger(registry, key).add(handle);
+    bindDelegationLedgerKeyStore(registry, key, store);
+    armDelegationLedgerLifecycle(registry);
+    sweepDelegationLedgerRound(registry, 3);
+}
 export function normalizeSubagentType(value) {
     return value.normalize("NFKC").toLowerCase().replace(/[\p{White_Space}\p{Pd}_]+/gu, "");
 }
@@ -1314,7 +1442,6 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
         prepareArguments: (args) => foldGeneralPurposeAlias(args, generalPurposeShadowed),
         execute: async (args, ctx) => {
             const a = foldGeneralPurposeAlias(args, generalPurposeShadowed);
-            const wantsBackground = opts.background !== undefined && a.run_in_background !== false;
             const reviveClaim = ctx.reviveClaim;
             if (reviveClaim !== undefined && opts.background === undefined) {
                 return {
@@ -1358,6 +1485,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
             }
             const omitted = rawType === "" || (!generalPurposeShadowed && rawType === GENERAL_PURPOSE_SUBAGENT_TYPE);
             const def = hasAgents && !wantsFork && !omitted ? agentMap.get(rawType) : undefined;
+            const wantsBackground = opts.background !== undefined && (a.run_in_background !== false || def?.background === true);
             const spawnAgentType = wantsFork ? FORK_SUBAGENT_TYPE : omitted ? GENERAL_PURPOSE_SUBAGENT_TYPE : rawType;
             if (!def && !wantsFork && !omitted) {
                 return {
@@ -1789,6 +1917,21 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 return { ...(recentSteps ? { recentSteps } : {}), ...(editedFiles ? { editedFiles } : {}) };
             };
             const treeScope = reviveClaim?.row.scope ?? ctx.principal ?? opts.background?.scope;
+            const entryCapPoolAnchor = opts.background?.registry ?? opts;
+            const entryCaps = ctx.delegationEntryCaps ?? { maxConcurrent: DELEGATION_MAX_CONCURRENT_DEFAULT, maxCumulativePerSession: DELEGATION_MAX_PER_SESSION_DEFAULT };
+            const entryCapRoot = reviveClaim !== undefined
+                ? (reviveClaim.row.rootSessionId ?? reviveClaim.row.parentSessionId ?? (reviveClaim.row.sessionScoped ? reviveClaim.row.owner : undefined))
+                : (ctx.rootSessionId ?? ctx.sessionId);
+            const openEntryGate = () => openDelegationEntryGate({
+                poolAnchor: entryCapPoolAnchor,
+                registry: opts.background?.registry,
+                store: opts.background?.agentStore,
+                scope: treeScope,
+                root: entryCapRoot,
+                caps: entryCaps,
+                revival: reviveClaim !== undefined,
+                signal: ctx.signal,
+            });
             const provenanceRequest = ctx.delegationProvenanceForChildren?.();
             const childProvenanceRef = provenanceRequest !== undefined ? { current: newDelegationProvenanceAggregate() } : undefined;
             const childAttestation = (status) => childProvenanceRef !== undefined ? reduceDelegationAttestation(childProvenanceRef.current, { completed: status === "completed" }) : undefined;
@@ -2053,7 +2196,7 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 if (ctx.signal?.aborted) {
                     await cancelObserver();
                     const wt = await finishWorktree();
-                    return { isError: true, content: `Sub-agent not started: the delegating call was aborted.${wt ? `\n${wt}` : ""}`, details: { error: "aborted" } };
+                    return spawnAbortedResult(wt);
                 }
                 if (spawnVerdict.kind === "block") {
                     await cancelObserver();
@@ -2106,6 +2249,21 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     const shortDesc = `fork: ${(typeof a.description === "string" && a.description.trim() ? a.description.trim() : prompt).slice(0, 180)}`;
                     const bgOwner = sessionScopedBg ? ctx.sessionId : ctx.taskId ?? bg.owner;
                     const bgScope = treeScope;
+                    const forkEntryGate = await openEntryGate();
+                    {
+                        const admission = forkEntryGate.admit("registered");
+                        if (!admission.admitted) {
+                            dropHostAbortListener();
+                            try {
+                                await (releaseForked ? releaseForked() : opts.runner.sessions.release?.(forkedId));
+                            }
+                            catch {
+                            }
+                            await cancelObserver();
+                            const wt = await finishWorktree();
+                            return errorResult(`Sub-agent not started in background: ${admission.refusal.text}${wt ? `\n${wt}` : ""}`, { error: admission.refusal.code, code: admission.refusal.code });
+                        }
+                    }
                     const forkSettlementSeat = ctx.delegationSettlement?.();
                     const forkSettleId = forkSettlementSeat !== undefined ? `bg-${uuidv7()}` : undefined;
                     if (forkSettlementSeat !== undefined && forkSettleId !== undefined) {
@@ -2195,6 +2353,8 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                         }
                         return { isError: true, content: `Sub-agent not started in background: ${e instanceof Error ? e.message : String(e)}${wt ? `\n${wt}` : ""}`, details: { error: "register_failed" } };
                     }
+                    if (forkEntryGate.key !== undefined)
+                        chargeDelegationEntryHandle(bg.registry, forkEntryGate.key, bg.agentStore, taskId);
                     childInternals.peerSelfRef?.addAxis("h", taskId);
                     bg.registry.bindBackgroundAgentSession(taskId, forkedId);
                     const forkBgHangAt = Date.now();
@@ -2507,6 +2667,28 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 const bgIgnoredNote = a.run_in_background === true
                     ? `note: run_in_background was ignored for subagent_type "${FORK_SUBAGENT_TYPE}" — the fork ran synchronously (this delegation tool has no background surface configured).`
                     : undefined;
+                const syncForkEntryGate = await openEntryGate();
+                if (ctx.signal?.aborted) {
+                    try {
+                        await (releaseForked ? releaseForked() : opts.runner.sessions.release?.(forkedId));
+                    }
+                    catch {
+                    }
+                    await cancelObserver();
+                    const wt = await finishWorktree();
+                    return spawnAbortedResult(wt);
+                }
+                const syncForkAdmission = syncForkEntryGate.admit("local");
+                if (!syncForkAdmission.admitted) {
+                    try {
+                        await (releaseForked ? releaseForked() : opts.runner.sessions.release?.(forkedId));
+                    }
+                    catch {
+                    }
+                    await cancelObserver();
+                    const wt = await finishWorktree();
+                    return errorResult(`Sub-agent not started: ${syncForkAdmission.refusal.text}${wt ? `\n${wt}` : ""}`, { error: syncForkAdmission.refusal.code, code: syncForkAdmission.refusal.code });
+                }
                 let forkChild;
                 try {
                     forkChild = await opts.runner.runTask({ ...buildChildSpec(ctx.signal), sessionId: forkedId, requireExistingSession: true, objective: forkObjective }, forkInternals);
@@ -2527,6 +2709,9 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     const wt = await finishWorktree();
                     return { isError: true, content: `Fork failed: the forked run threw (${e instanceof Error ? e.message : String(e)}).${wt ? `\n${wt}` : ""}`, details: { error: "fork run failed" } };
                 }
+                finally {
+                    syncForkAdmission.release();
+                }
                 const forkHandbackWarning = await reviewHandback({
                     review: ctx.autoModeReview,
                     toolCallId: ctx.toolCallId,
@@ -2601,51 +2786,15 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 const shortDesc = reviveRow?.description ?? String(a.description ?? "sub-agent").slice(0, 200);
                 const bgOwner = reviveRow !== undefined ? reviveRow.owner : sessionScopedBg ? ctx.sessionId : ctx.taskId ?? bg.owner;
                 const bgScope = treeScope;
-                const capScope = bgScope;
-                const capRoot = reviveRow !== undefined
-                    ? (reviveRow.rootSessionId ?? reviveRow.parentSessionId ?? (reviveRow.sessionScoped ? reviveRow.owner : undefined))
-                    : (ctx.rootSessionId ?? ctx.sessionId);
-                const entryCaps = ctx.delegationEntryCaps ?? { maxConcurrent: DELEGATION_MAX_CONCURRENT_DEFAULT, maxCumulativePerSession: DELEGATION_MAX_PER_SESSION_DEFAULT };
-                const capLedgerKey = capScope !== undefined && capRoot !== undefined ? JSON.stringify([capScope, capRoot]) : undefined;
-                if (capScope !== undefined && capRoot !== undefined) {
-                    let storedHandles = [];
-                    let storedEnumerationOk = false;
-                    if (bg.agentStore !== undefined && reviveRow === undefined) {
-                        try {
-                            storedHandles = (await bg.agentStore.listBySession(capScope, capRoot)).map((r) => r.handle);
-                            storedEnumerationOk = true;
-                        }
-                        catch {
-                            storedHandles = [];
-                        }
-                    }
-                    const capRefusal = async (code, text) => {
+                const bgEntryGate = await openEntryGate();
+                const capLedgerKey = bgEntryGate.key;
+                {
+                    const admission = bgEntryGate.admit("registered");
+                    if (!admission.admitted) {
                         dropHostAbortListener();
                         await cancelObserver();
                         const wt = await finishWorktree();
-                        return errorResult(`Sub-agent not started in background: ${text}${wt ? `\n${wt}` : ""}`, { error: code, code });
-                    };
-                    const activeFace = bg.registry.activeDelegationHandles;
-                    const active = typeof activeFace === "function" ? activeFace.call(bg.registry, capScope, capRoot) : [];
-                    if (typeof activeFace === "function" && active.length >= entryCaps.maxConcurrent) {
-                        return await capRefusal("delegation.concurrency_cap", `this session tree already has ${active.length} background agents running — the concurrency cap (${entryCaps.maxConcurrent}; RunnerDeps.delegationEntryCaps.maxConcurrent) refuses another. Wait for one to complete (you will be notified) or stop one, then relaunch.`);
-                    }
-                    if (reviveRow === undefined) {
-                        const ledger = delegationEntryLedger(bg.registry, capLedgerKey);
-                        let cumulative;
-                        if (bg.agentStore !== undefined && storedEnumerationOk) {
-                            const keep = new Set([...storedHandles, ...active]);
-                            for (const h of [...ledger])
-                                if (!keep.has(h))
-                                    ledger.delete(h);
-                            cumulative = new Set([...storedHandles, ...ledger]).size;
-                        }
-                        else {
-                            cumulative = ledger.size;
-                        }
-                        if (cumulative >= entryCaps.maxCumulativePerSession) {
-                            return await capRefusal("delegation.session_cap", `this session tree has already launched ${cumulative} background agents in its retained window — the cumulative cap (${entryCaps.maxCumulativePerSession}; RunnerDeps.delegationEntryCaps.maxCumulativePerSession) refuses more. Continue an existing agent (SendMessage) instead of launching new ones.`);
-                        }
+                        return errorResult(`Sub-agent not started in background: ${admission.refusal.text}${wt ? `\n${wt}` : ""}`, { error: admission.refusal.code, code: admission.refusal.code });
                     }
                 }
                 const settlementSeat = ctx.delegationSettlement?.();
@@ -2770,13 +2919,8 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                     }
                     return { isError: true, content: `Sub-agent not started in background: ${e instanceof Error ? e.message : String(e)}${wt ? `\n${wt}` : ""}`, details: { error: "register_failed" } };
                 }
-                if (capLedgerKey !== undefined && reviveRow === undefined)
-                    delegationEntryLedger(bg.registry, capLedgerKey).add(taskId);
-                if (capLedgerKey !== undefined) {
-                    bindDelegationLedgerKeyStore(bg.registry, capLedgerKey, bg.agentStore);
-                    armDelegationLedgerLifecycle(bg.registry);
-                    sweepDelegationLedgerRound(bg.registry, 3);
-                }
+                if (capLedgerKey !== undefined)
+                    chargeDelegationEntryHandle(bg.registry, capLedgerKey, bg.agentStore, reviveRow === undefined ? taskId : undefined);
                 childInternals.peerSelfRef?.addAxis("h", taskId);
                 if (agentName !== undefined) {
                     recordRosterSpawn(ctx.roster, { name: agentName, agentId: taskId, toolUseId: ctx.toolCallId, owner: bgOwner, scope: bgScope, ...((typeof childModel === "string" ? resolveModelDisplayLabel(childModel) : childModel?.id) !== undefined ? { model: typeof childModel === "string" ? childModel : childModel?.id } : {}), ...(reviveRow !== undefined ? ((reviveRow.rootSessionId ?? reviveRow.parentSessionId) !== undefined ? { rootSessionId: reviveRow.rootSessionId ?? reviveRow.parentSessionId } : {}) : (ctx.rootSessionId ?? ctx.sessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? ctx.sessionId } : {}), ...(sessionScopedBg ? { sessionScoped: true } : {}), createdAt: reviveRow?.spawnedAt ?? Date.now() }, (err) => opts.onObserverError?.(err, { site: "roster.recordSpawn" }));
@@ -3411,49 +3555,66 @@ function createSubagentToolNode(opts, depth, excluded, extraToolsBudget) {
                 };
             }
             let child;
+            const syncEntryGate = await openEntryGate();
+            if (ctx.signal?.aborted) {
+                await cancelObserver();
+                const wt = await finishWorktree();
+                return spawnAbortedResult(wt);
+            }
+            const syncAdmission = syncEntryGate.admit("local");
+            if (!syncAdmission.admitted) {
+                await cancelObserver();
+                const wt = await finishWorktree();
+                return errorResult(`Sub-agent not started: ${syncAdmission.refusal.text}${wt ? `\n${wt}` : ""}`, { error: syncAdmission.refusal.code, code: syncAdmission.refusal.code });
+            }
             const syncStartedAt = Date.now();
             let retainEntry;
-            if (ctx.onSubagentSpawn || observerPairing) {
-                retainEntry = ctx.onSubagentSpawn ? await tryRetainChild(ctx.subagentRetain) : undefined;
-                if (retainEntry)
-                    stepRecorder.lockTo(retainEntry.childSessionId);
-                const stream = opts.runner.runTaskStream({ ...buildChildSpec(ctx.signal), ...(retainEntry ? { sessionId: retainEntry.childSessionId } : {}) }, undefined, childInternals);
-                observedSteerRef.steer = (text, o) => stream.steer(text, o);
-                let settleResolve;
-                const settled = new Promise((r) => { settleResolve = r; });
-                if (ctx.onSubagentSpawn) {
-                    const resume = createSubagentResume({
-                        ledger: ctx.subagentRetain,
-                        parentToolCallId: ctx.toolCallId,
-                        runner: opts.runner,
-                        ...(opts.background?.notify ? { notify: opts.background.notify } : {}),
-                        sink: ctx.onSubagentSpawn,
-                        ...(opts.background ? { registry: opts.background.registry } : {}),
-                        ...(opts.onObserverError !== undefined ? { onNotifyError: (f) => opts.onObserverError?.(f.error, { site: f.site }) } : {}),
-                        ...(ctx.onQuestion !== undefined ? { currentOnQuestion: ctx.onQuestion } : {}),
-                        ...(ctx.autoModeReview !== undefined ? { currentAutoModeReview: ctx.autoModeReview } : {}),
-                    });
-                    notifier.notify(() => ctx.onSubagentSpawn?.(createSteerHandle(stream, ctx.toolCallId, childAgentName, settled, {
-                        resume,
-                        ...(retainEntry ? { childSessionId: retainEntry.childSessionId } : {}),
-                    })), "subagent.onSubagentSpawn");
-                }
-                try {
-                    for await (const ev of stream)
-                        observerTap?.record(ev);
-                    child = await stream.result();
-                }
-                catch (e) {
-                    await settleObserver("failed");
-                    throw e;
+            try {
+                if (ctx.onSubagentSpawn || observerPairing) {
+                    retainEntry = ctx.onSubagentSpawn ? await tryRetainChild(ctx.subagentRetain) : undefined;
+                    if (retainEntry)
+                        stepRecorder.lockTo(retainEntry.childSessionId);
+                    const stream = opts.runner.runTaskStream({ ...buildChildSpec(ctx.signal), ...(retainEntry ? { sessionId: retainEntry.childSessionId } : {}) }, undefined, childInternals);
+                    observedSteerRef.steer = (text, o) => stream.steer(text, o);
+                    let settleResolve;
+                    const settled = new Promise((r) => { settleResolve = r; });
+                    if (ctx.onSubagentSpawn) {
+                        const resume = createSubagentResume({
+                            ledger: ctx.subagentRetain,
+                            parentToolCallId: ctx.toolCallId,
+                            runner: opts.runner,
+                            ...(opts.background?.notify ? { notify: opts.background.notify } : {}),
+                            sink: ctx.onSubagentSpawn,
+                            ...(opts.background ? { registry: opts.background.registry } : {}),
+                            ...(opts.onObserverError !== undefined ? { onNotifyError: (f) => opts.onObserverError?.(f.error, { site: f.site }) } : {}),
+                            ...(ctx.onQuestion !== undefined ? { currentOnQuestion: ctx.onQuestion } : {}),
+                            ...(ctx.autoModeReview !== undefined ? { currentAutoModeReview: ctx.autoModeReview } : {}),
+                        });
+                        notifier.notify(() => ctx.onSubagentSpawn?.(createSteerHandle(stream, ctx.toolCallId, childAgentName, settled, {
+                            resume,
+                            ...(retainEntry ? { childSessionId: retainEntry.childSessionId } : {}),
+                        })), "subagent.onSubagentSpawn");
+                    }
+                    try {
+                        for await (const ev of stream)
+                            observerTap?.record(ev);
+                        child = await stream.result();
+                    }
+                    catch (e) {
+                        await settleObserver("failed");
+                        throw e;
+                    }
+                    finally {
+                        settleResolve();
+                        ctx.subagentRetain?.markSettled(ctx.toolCallId);
+                    }
                 }
-                finally {
-                    settleResolve();
-                    ctx.subagentRetain?.markSettled(ctx.toolCallId);
+                else {
+                    child = await opts.runner.runTask(buildChildSpec(ctx.signal), childInternals);
                 }
             }
-            else {
-                child = await opts.runner.runTask(buildChildSpec(ctx.signal), childInternals);
+            finally {
+                syncAdmission.release();
             }
             await settleObserver(child.status);
             const handbackWarning = await reviewHandback({

package/dist/agents/verify.d.ts

@@ -172,9 +172,20 @@ export interface VerificationOutcome {
      * Total cost (micro-USD) of the VERIFIER run(s) across all rounds — the verification OVERHEAD, separate from
      * the implementation's own cost (which is the returned `TaskResult.stats`, as the verifier runs in its own
      * session). Mirrors `runWithTeacher`'s `teacherStats` work-vs-overhead split. Σ of each verifier run's
-     * cost+nested. `result.stats.costMicroUsd + verification.verifierCost` is the EXACT operation total for the
-     * common single-pass case; in the rarer multi-round fix case `result.stats` is the FINAL impl attempt's cost
-     * (the returned `...current`) so an earlier failed attempt's impl cost is not separately surfaced. Omitted
+     * cost+nested.
+     *
+     * THE OPERATION TOTAL, exactly (note the middle term — it is easy to miss and this doc used to omit it):
+     * `stats.costMicroUsd + (stats.nested?.costMicroUsd ?? 0) + verification.verifierCost`. The axes are
+     * DISJOINT, so nothing is counted twice — but they are not symmetric, which is why the nested term is
+     * spelled out: THIS field already folds the verifier's own delegated spend into itself, while the
+     * implementation side keeps own and nested apart (the family convention — a consumer adds `stats.X +
+     * stats.nested.X` for the true total, and nested cost is never folded into `costMicroUsd`).
+     *
+     * That total is now exact **in the multi-round fix case too**, since the returned `stats` accumulates
+     * every impl-side leg (see {@link VerificationResult}). It held only for the single-pass case before: the
+     * returned stats were the FINAL impl attempt's alone, so once a fix round ran, the ORIGINAL attempt's
+     * cost was absent from the entire return value and any such sum silently undercounted the operation by
+     * exactly that much. Omitted
      * (undefined) when no verifier ran (e.g. an impl that suspended/was opted out before verification).
      */
     verifierCost?: number;
@@ -201,6 +212,19 @@ export interface VerificationOutcome {
 export interface VerificationResult extends TaskResult {
     /** The verification outcome. The task `result`/`status` is the implementation's; consult `verdict` for quality. */
     verification: VerificationOutcome;
+    /**
+     * ACCOUNTING NOTE for the inherited `stats` (it is the ONE inherited field the gate does not simply pass
+     * through). The gate can run the implementation session SEVERAL times — the impl leg, then a continuation
+     * per fix round — and each leg's own `stats` cover only that leg. So `stats` here is the CUMULATIVE
+     * impl-side account (every impl + fix leg summed, own and nested kept disjoint as everywhere else), not
+     * the final leg's; the non-accumulated fields such as `model` come from the final leg. When exactly one
+     * leg contributed (the common no-fix path, and every early hand-back before a fix round), it is that
+     * leg's own object, untouched.
+     *
+     * The VERIFIER's spend is NOT in here — it is the separate overhead axis on
+     * {@link VerificationOutcome.verifierCost}, which documents the sum that gives the operation total.
+     */
+    stats: TaskResult["stats"];
 }
 /**
  * Verify an already-**completed** implementation `result` behind the independent falsification-style verifier,

package/dist/agents/verify.js

@@ -4,6 +4,7 @@ import { releaseSession } from "./session-util.js";
 import { mapNestedSuspend, isDurablePause } from "./suspend-guard.js";
 import { delimitUntrusted, sanitizeUntrustedText } from "../core/untrusted-text.js";
 import { createSafeNotifier } from "../core/safe-notify.js";
+import { createCumulativeStatsTracker } from "./cumulative-stats.js";
 export const VERIFICATION_PROMPT = `You are a verification specialist. Your job is NOT to confirm the implementation works — it is to try to BREAK it.
 
 You have two documented failure patterns. First, verification avoidance: faced with a check, you find reasons not to run it — you read code, narrate what you would test, declare "PASS," and move on. Second, being seduced by the first 80%: a polished result or a passing test suite makes you inclined to pass it, not noticing the edge that crashes, the state that vanishes, the bad input that is unhandled. The first 80% is the easy part. Your entire value is in finding the last 20%.
@@ -172,6 +173,9 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
         }
     };
     let current = result;
+    const implAccount = createCumulativeStatsTracker();
+    implAccount.add(result.stats);
+    const withImplAccount = (r) => implAccount.legs > 1 ? { ...r, stats: implAccount.build(r.stats) } : r;
     let outcome = { verdict: "unverified", rounds: 0, findings: [] };
     const startedAt = Date.now();
     let spend = 0;
@@ -240,13 +244,14 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
             ...(foldedReadDeny.length > 0 ? { readDenyPatterns: [...foldedReadDeny] } : {}),
         }, internals);
         spend += (current.stats.costMicroUsd ?? 0) + (current.stats.nested?.costMicroUsd ?? 0);
+        implAccount.add(current.stats);
         if (isDurablePause(current.status)) {
-            return { ...mapNestedSuspend(carryFrozenPosture(current)), verification: outcome };
+            return { ...mapNestedSuspend(carryFrozenPosture(withImplAccount(current))), verification: outcome };
         }
         if (current.status !== "completed")
             break;
     }
-    return { ...carryFrozenPosture(current), verification: outcome };
+    return { ...carryFrozenPosture(withImplAccount(current)), verification: outcome };
 }
 export async function runWithVerification(runner, implSpec, config = {}, internals) {
     refuseUnhonorableInternals(internals, "door");

package/dist/core/auto-compaction.d.ts

@@ -383,7 +383,12 @@ export interface MaybeCompactOptions {
      * compaction is FORCED through the real `generateSummary` LLM path even if the provider would hit — this
      * bounds summary drift from indefinite reuse. The caller owns the counter via {@link onCompaction}
      * (`reused`) and feeds it back via this option; core treats `summaryProvider` as if absent for that one
-     * boundary when `consecutiveProviderReuse >= maxConsecutiveProviderReuse`. Default `3` (CC parity).
+     * boundary when `consecutiveProviderReuse >= maxConsecutiveProviderReuse`. Default `3`, a
+     * SEMA choice — the earlier "(CC parity)" label was unsupported and is withdrawn (anchoring
+     * re-check 2026-08-23: CC 2.1.223 has no external summary provider and no reuse concept at all;
+     * its three 3s are the PTL retry cap `b$d`, the consecutive-compaction-failure breaker `C$d` and
+     * the rapid-refill trip `Q3u`, none of them this). 3 is picked for the same reason those are: a
+     * small bound on how long a degraded path may keep answering before the real one is forced.
      * `0`/undefined with no `consecutiveProviderReuse` = provider always consulted (no forced refresh).
      */
     maxConsecutiveProviderReuse?: number;
@@ -618,9 +623,17 @@ export declare function maybeCompact(opts: MaybeCompactOptions): Promise<{
  *      (clamped ≥0, so ≤0 means "freed nothing") — orthogonal to rule 2/3's threshold test, which
  *      misses this shape because the bloated post (44609) can still sit UNDER the threshold (44800),
  *      so rule 3 alone would re-enable the force and repeat the negative-yield pass every boundary.
- *      SEMA-ONLY DEFENSE, not a CC port: CC's full compact keeps tail 0 and monotonically shrinks
- *      (capture §A4), and CC has no request-layer trim, so this regime cannot exist there — it is a
- *      derived interaction of our trim seam × keep-tail × attachment mass. Scoped to trim-forced
+ *      SEMA-ONLY DEFENSE, not a CC port — but the ORIGINAL justification for that label was wrong
+ *      on both of its premises, and the corrected pair still supports it. (a) "CC's full compact
+ *      keeps tail 0 and monotonically shrinks" describes the `GNo` branch, which a LOCAL threshold
+ *      compaction never reaches (CC 2.1.223 `y9s` :432704 routes local passes to the reactive
+ *      pipeline, which preserves the last group verbatim — `YMo` :399971, `s = 1` :399982); CC's
+ *      default posture therefore has a keep-tail, exactly as ours does. (b) "CC has no
+ *      request-layer trim" holds only for the MAIN conversation request: CC does own a
+ *      keep-the-newest-groups-that-fit primitive (`UPb` :645223), whose only caller is the
+ *      prompt-hook evaluator's own transcript window, not a main-lane request. What actually makes
+ *      this regime ours is the third factor — the trim seam feeding a deceived usage anchor, and
+ *      attachment mass re-entering after the fold — not the absence of a keep-tail. Scoped to trim-forced
  *      passes only (`trimForced`), so Seam C reused-summary landings (freed≈0 by design) on the
  *      natural/manual paths never trip it. Release path unchanged: backoff gates only the FORCE, a
  *      later natural landing that posts under threshold (rule 3, non-trim-forced) turns it back off.

package/dist/core/auto-compaction.js

@@ -196,6 +196,9 @@ export async function maybeCompact(opts) {
         if (prep.value.elidedMessages !== undefined && prep.value.elidedMessages > 0) {
             details.elidedMessages = prep.value.elidedMessages;
         }
+        if (prep.value.carriedUnsummarizedMessages !== undefined && prep.value.carriedUnsummarizedMessages > 0) {
+            details.unsummarizedMessages = prep.value.carriedUnsummarizedMessages;
+        }
     }
     else {
         let summaryModel = opts.compactionModel ?? opts.model;

package/dist/core/context-edit.d.ts

@@ -14,11 +14,18 @@ export declare const EDIT_FRACTION = 0.7;
  *   effectiveWindow = autocompactWindow − min(maxOutputTokens, 20000)   (CC `Nye`, cap `uMd`)
  *   trigger         = effectiveWindow − 13000                           (CC `dSo`, buffer `rMd`)
  * i.e. trigger = W − 33000 for every model whose max output is ≥ 20k: a 200k window triggers at
- * 167000 (83.5% of nominal), a 1M window at 967000. (CC additionally ships a sonnet-5-only 1M
- * autocompact-window special of 967000 via dynamic config, making ITS 1M trigger 934000; that is a
- * per-model config delivery, not geometry — an embedder reproduces it EXACTLY via
- * `model.autoCompactTokens = 967000`, which lowers only this trigger-side window while the guard
- * and physical request budgeting stay on the 1M window — CC's dual-window shape.) We take the
+ * 167000 (83.5% of nominal), a 1M window at 967000.
+ *
+ * 1M DIVERGENCE, stated as fact rather than as an equivalence (anchoring re-check 2026-08-23): CC
+ * carries a MODEL-DEFAULT autocompact-window table (2.1.223 `j3u` :242918 — `claude-sonnet-5`
+ * default 967000, and since 223 a surface dimension: `remote_cowork` / `local-agent` 500000), so a
+ * 1M sonnet-5 gets 967000 as its window and 934000 as its trigger WITHOUT anyone configuring
+ * anything. We ship no such table: a model declaring only `contextWindow: 1e6` triggers at 967000
+ * here, 33000 LATER than CC. `model.autoCompactTokens = 967000` reproduces CC's number — but that
+ * is an EMBEDDER action against CC's product default, not the same posture, and the choice not to
+ * follow 934000 is deliberate (design/146 §1.3 argues against living on that thin a cushion). The
+ * knob itself is real and unchanged: `autoCompactTokens` lowers only this trigger-side window while
+ * the guard and physical request budgeting stay on the 1M window — CC's dual-window shape. We take the
  * 20000 cap branch unconditionally (flat 33000), i.e. the `min(maxOutputTokens, 20000)` branch is
  * deliberately NOT ported: the deduction is exact parity only for models with max output ≥ 20k. A
  * model with a smaller max output would deduct less in CC (trigger LATER); we deduct the full
@@ -51,11 +58,53 @@ export declare function contextEditFrontier(window: number): number;
  * PowerShell is kept for CC fidelity even though sema does not mount it. Overridable per call via
  * {@link ContextEditOptions.compactableTools} for custom-tool-heavy embedders.
  */
+/**
+ * How many most-recent CANDIDATE tool results keep their content when the stale-result pass runs.
+ *
+ * 3, UNCHANGED — and the fact that CC's corresponding number is 5 (2.1.223 `uAp`, and the same value
+ * on CC 88's `timeBasedMCConfig`, so it is stable across both corpus generations) is deliberately NOT
+ * adopted here. Two reasons, in order of weight:
+ *
+ *  1. MEASURED: widening the window removes this pass's only lever in the shape where a terminal
+ *     parallel batch holds exactly as many large results as the window keeps. Probed on a 200k model
+ *     with a 140k usage anchor and five 36k-char Bash results: at 3 the pass clears two and the
+ *     request lands at ~167k, UNDER the 177k request guard; at 5 nothing is clearable, the request
+ *     stays at 185k, and the guard cannot recover it either — `trimToBudget` must turn-align back to
+ *     the emitting assistant, so the whole batch is retained. The window is count-based on both
+ *     sides (CC's `slice(-keepRecent)` too), so this ceiling exists at every value; 5 simply widens
+ *     the band that reaches it.
+ *  2. SEAT: the two numbers do not govern the same machine. CC's keep-recent clear runs ONLY on the
+ *     `context_hint` rejection leg — gated off by default — and behind a hard "saves ≥ 20000 tokens
+ *     or don't bother" test, with request REFUSAL as the real backstop. Ours is on by default, is
+ *     the only reduction between the frontier and the guard, and its backstop drops messages instead
+ *     of refusing. Copying a constant across that difference is the "same name, different question"
+ *     mistake, not parity.
+ *
+ * So the VALUE is an open adjudication (recorded with the probe above), while the two things CC
+ * unambiguously answers — the floor and the candidate-scoped window — are followed exactly.
+ */
+export declare const DEFAULT_KEEP_RECENT_TOOL_RESULTS = 3;
+/** Minimum kept results — CC `EUs` :397710 `Math.max(1, keepRecent)`. See
+ *  {@link ContextEditOptions.keepRecentToolResults} for why both degenerate ends are unusable. */
+export declare const MIN_KEEP_RECENT_TOOL_RESULTS = 1;
 export declare const COMPACTABLE_TOOLS: ReadonlySet<string>;
 export interface ContextEditOptions {
     /** Start clearing once estimated context tokens exceed this. */
     budgetTokens: number;
-    /** Always keep the content of this many most-recent tool results. Default 3. */
+    /**
+     * Always keep the content of this many most-recent CANDIDATE tool results (candidates = results
+     * from {@link compactableTools}). Default {@link DEFAULT_KEEP_RECENT_TOOL_RESULTS} = 3 — see that
+     * constant for why CC's 5 is not adopted here.
+     *
+     * Floored at 1, which IS CC's rule (`EUs` `Math.max(1, keepRecent)`), whose own source note gives
+     * the reason: 0 leaves the model with zero working tool context, and in CC's `slice(-0)` spelling
+     * it degenerates the other way into keeping everything — two unusable extremes for one value.
+     * Ours degenerated identically (a 0 or negative `keep` cleared EVERY candidate). Values that are
+     * not a non-negative safe integer are REFUSED rather than floored: a NaN used to make this whole
+     * defense silently inert (`slice(0, NaN)` = clear nothing), which is the one outcome a context
+     * defense must never reach quietly, and there is no config door upstream to announce at — this
+     * option only ever arrives as a direct argument from an embedder.
+     */
     keepRecentToolResults?: number;
     /**
      * roadmap #6② (CC contentReplacementState parity): when set, a result's FULL TEXT is offloaded to