@sema-agent/core 5.55.0 → 5.56.0

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 5.56.0 — 2026-08-23
+
+### Fixed
+- **A2A covering rules join the mcp form** (#410, ruled): `a2a__peer` / `a2a__peer__*` deny, ask
+  and allow now fire in all five name-keyed lanes (rule DSL, allow/deny policy, approval policy,
+  frozen projection replay, persisted session rules) via the protocol-table-driven
+  `namespacedRuleNameCovers`. **Narrowings**: a frozen projection replayed under 5.56 honors
+  covering spellings it previously read as inert (heaviest); covering-name parenthesised rules
+  refuse (`unsupported.covering_paren`, additive union member); empty-peer spellings refuse at
+  construction. **Widening / false-refusal repair**: real minted names with separator-bearing tool
+  segments (`mcp__srv____foo` and twins) that previously THREW at construction now compile as
+  exact entries (the name-set screen judges the peer boundary only).
+- **Delegation entry caps cover every local spawn leg** (#385, anchor campaign): sync spawn,
+  sync fork and background fork now pass the same concurrency/cumulative gate as background
+  spawns (one pool, four admit sites; in-flight reservations returned on settle). Sync legs mint
+  `delegation.concurrency_cap` / `delegation.session_cap` under the `Sub-agent not started: `
+  prefix (new code+prefix combination); counted nouns drop the word "background";
+  `AgentDefinition.background: true` is honored (previously a dead field); no-principal mounts
+  fold to the engine default pool instead of skipping the gate.
+- **Every deployment hook seat is time-bounded** (#388, anchor campaign): the ten `Hooks` seats
+  ride one bounded family (default 600s; `Hooks.timeoutMs` knob, bad values refused loudly).
+  Decision seats fail closed on expiry (preToolUse → deny + permissionDenied(source "hook");
+  userPromptSubmit → block; stop → run ends); observation seats discard and shrink to a 1s grace
+  after task abort; hook contexts carry `signal` and live tracked `cwd`. Pre-ship rescan closures:
+  the runSpec hook mirror now carries `timeoutMs` (a deployment's bound was silently replaced by
+  the default on composed runs); stopFailure reads the deadline rather than a constant grace; the
+  post-abort grace caps remaining time instead of restarting the clock.
+- **interrupt() keeps accepted user input; an interrupt leaves CC's transcript marker** (#389,
+  anchor campaign): steer queues survive `interrupt()` (one-way abort latch + in-flight slot);
+  a durable park migrates queued steers onto the checkpoint (idempotent CAS verb) and the
+  undrained account announces only the remainder; an explicit interrupt that won the abort mints
+  CC's verbatim `[Request interrupted by user]` marker (double-gated); unknown
+  `SystemInjectionPriority` values refuse and the unimplemented `"now"` ladder is disclosed once
+  per run (`task.injection_priority_unimplemented`); the untrusted caller steer lane gains CC's
+  mid-turn delivery frame.
+- **A SendMessage name that changed hands refuses instead of silently redirecting** (CC's
+  `send_message_pin_guard` rebound arm): "Nothing was sent." plus both ways forward; a precise
+  task_id is never refused and re-pins; the tool description states the refusal.
+- **A legacy-decided parked row converges** (#400, test P0-KPI): the live reconcile's resolved
+  skip now means "a claim is in flight" (read from the store row) — a checkpoint decided by the
+  task-level legacy lane settles the row instead of leaving a process-lifetime zombie; the
+  decision is re-read immediately before the verdict so a reopen CAS is never judged dead.
+- **Compaction PTL retries disclose what they dropped** (#407, test P0-KPI):
+  `CompactionDetails.unsummarizedMessages` accumulates the true uncovered count across split
+  legs, with a shell-copy clause and an import-gate check. The summary prompt carries CC's
+  `<example>` skeleton and a compliant `<summary>` envelope is unwrapped in the persisted body
+  (pre-ship rescan closure: a fence-only EMPTY response is refused loudly, same class and wording
+  as the bare-empty arm — it could previously persist a footer-only summary).
+  `keepRecentToolResults` floors at 1 and refuses NaN/negative loudly.
+- **#384 (keepRecentTokens default) closed as REFUTED, with evidence**: the anchor-campaign claim
+  that the 0 default meant "no kept tail" was disproved on a real Runner — `findCutPoint` has a
+  structural floor, the kept tail is never empty, and the pinned behavior matches CC's posture
+  via the other knob. The default is unchanged; the floor is now pinned
+  (test/compaction-keep-tail-floor.test.ts) and four stale anchor comments were corrected.
+
+### Notes
+- Anchor-campaign satellite dispositions ride along (A3/A4/A8/A14 candidate tables in the
+  respective cars' receipts): truthfulness rewrites, registry entries, and the
+  PermissionDenied trigger-surface divergence registered.
+- Erratum owed to sibling repos (also stated in src/core/hooks.ts): "CC fails open on hook
+  faults except exit 2" is true only of the command(shell) hook channel; CC's in-process
+  callback channel is fail-closed with dedicated copy — cited as a fail-open precedent it is
+  the wrong channel.
+- Residuals filed, not shipped silently: #417-#423 (auth seats, Agent(<type>) governance,
+  lifecycle legs, postToolUse payload asymmetry, reopen fence, classic-arm Trust-but-verify).
+
 ## 5.55.0 — 2026-08-23
 
 ### BREAKING

package/dist/agents/send-message-tool.js

@@ -5,6 +5,7 @@ import { announceTranscriptIntegrityGapOnce, canAccessAgentRecord, clearRevivedR
 import { uuidv7 } from "../internal/harness.js";
 import { MAILBOX_TOMBSTONED_RECIPIENT_CODE } from "../core/mailbox-store.js";
 import { escapeAttributeValue, escapeEnvelopeTag, isObserverTaskId, OBSERVER_SENDMESSAGE_SENDER_REFUSAL, OBSERVER_SENDMESSAGE_TARGET_REFUSAL, } from "./observer.js";
+import { inlineUntrusted } from "../core/untrusted-text.js";
 import { SUBAGENT_RESUME_CAP, SubagentRetainLedger, getSessionRetainLedger } from "./retain-ledger.js";
 import { createSubagentResume } from "./subagent.js";
 import { appendHopToken, judgePeerAdmission, peerAxisToken, resolvePeerAdmissionConfig, PEER_MESSAGE_NOTICE, } from "./peer-admission.js";
@@ -45,6 +46,35 @@ function targetLaneKey(scope, targetId) {
 const OPERATOR_CONTINUATION_CTX = Symbol("sema.operator_continuation");
 export function createSendMessageTool(opts) {
     const tier3Capable = opts.agentStore !== undefined && opts.mailbox !== undefined && opts.reviveSpawn !== undefined;
+    const sendMessagePins = new Map();
+    const pinGuard = (targetId, targetName, rung, to) => {
+        if (rung === "other")
+            return undefined;
+        const pinKey = normalizeAgentName(targetName ?? "");
+        if (pinKey === "")
+            return undefined;
+        const pinned = sendMessagePins.get(pinKey);
+        if (pinned === undefined || pinned.id === targetId) {
+            sendMessagePins.set(pinKey, { id: targetId, name: targetName ?? to });
+            return undefined;
+        }
+        if (rung === "ref") {
+            sendMessagePins.set(pinKey, { id: targetId, name: targetName ?? to });
+            return undefined;
+        }
+        if (targetName !== undefined && normalizeAgentName(to) === pinKey && normalizeAgentName(pinned.name) !== pinKey) {
+            return undefined;
+        }
+        return {
+            content: `Message not sent: "${inlineUntrusted(to, 120)}" now resolves to a different agent than it did earlier in ` +
+                `this run — this name previously resolved to ${pinned.id.slice(0, 64)}, which it no longer reaches. Nothing was sent.\n` +
+                `It now resolves to ${targetId.slice(0, 64)}. To message that agent, re-send with its task_id: ` +
+                `{"to": "${targetId.slice(0, 64)}", …}. To reach the earlier agent, use its task_id ` +
+                `${pinned.id.slice(0, 64)} from its spawn result.`,
+            details: { error: "rebound", to, taskId: targetId, previousTaskId: pinned.id },
+            isError: true,
+        };
+    };
     return defineTool({
         name: SEND_MESSAGE_TOOL_NAME,
         contract: { contractId: "core.send_message@1", implementationRevision: "1" },
@@ -54,8 +84,9 @@ export function createSendMessageTool(opts) {
             `'to' is the agent's name (set at spawn via Agent({name})) or its task_id (a…). A RUNNING agent receives the ` +
             `message at its next turn (queued — never interrupts its current work); a FINISHED agent resumes as a new ` +
             `background run with its full prior conversation preserved, so don't re-explain what it already knows. Names ` +
-            `keep working after an agent completes; when a newer agent took the name, the newest wins — use the task_id to ` +
-            `address an older one. You will be notified automatically when it completes — prefer ending your turn; do not ` +
+            `keep working after an agent completes; but if a name you already messaged is later taken by a NEWER agent, the ` +
+            `send is refused rather than silently redirected — re-send with the task_id of whichever agent you meant. ` +
+            `You will be notified automatically when it completes — prefer ending your turn; do not ` +
             `poll. ` +
             (tier3Capable
                 ? `Continuing a finished agent works for agents with a durable record — by name or task_id, even across restarts — and for runs that retain sub-agent sessions; when neither covers it you get an honest error and should launch a new agent with the needed context instead.`
@@ -523,6 +554,11 @@ export function createSendMessageTool(opts) {
                         }
                     }
                     if (rosterHit !== undefined) {
+                        {
+                            const guard = pinGuard(rosterHit.agentId, to, "name", to);
+                            if (guard !== undefined)
+                                return guard;
+                        }
                         const revived = await tier3Revive(rosterHit.agentId);
                         if (revived !== undefined)
                             return revived;
@@ -563,6 +599,16 @@ export function createSendMessageTool(opts) {
             if (row.type !== "background_agent") {
                 return { content: `Message not sent: ${targetId} is a ${row.type} task, not a background agent.`, details: { error: "wrong_type", to }, isError: true };
             }
+            {
+                const rung = idRow !== undefined
+                    ? "ref"
+                    : row.name !== undefined && (row.name === to || normalizeAgentName(row.name) === normalizeAgentName(to))
+                        ? "name"
+                        : "other";
+                const guard = pinGuard(targetId, row.name, rung, to);
+                if (guard !== undefined)
+                    return guard;
+            }
             if (row.status === "running" || row.status === "pending") {
                 return await withTargetLane(targetLaneKey(access.scope, targetId), async () => {
                     const liveRecipientKey = peerAxisToken(resolvedAccess.scope, "h", targetId);

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/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;