@sema-agent/server 7.53.0 → 7.55.0

package/dist/tool-approval.js

@@ -8,6 +8,7 @@ import { createLogger } from "./observability/logger.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { deriveAskId, deriveBatchId, MAX_DECISION_NOTE_CHARS } from "./approval-ask-machine.js";
 import { ApprovalCardEnvelopeSchema, MAX_RULE_OFFERS, buildApprovalCard, buildApprovalCardEnvelope, buildApprovalRequestFrame, buildRevokeFrame, readProbeCause, readRuleEvidence, readRuleOffersAbsence, } from "./approval-card.js";
+import { projectAskTerminalClaimTruth } from "./plugins/approval-ask-store-sql.js";
 import { governanceAskMarksFor, runWithGovernanceAskScope } from "./governance-ask-marks.js";
 const defaultLogger = createLogger();
 export const APPROVAL_GATE_KINDS = ["human", "irreversible_ask"];
@@ -43,9 +44,26 @@ function durableRuleMaterial(material) {
     return { ruleCommand: material.command, ruleScopeRoot: material.scopeRoot ?? null };
 }
 export const ASK_DECISION_CONSUMER_ABSENT = "absent";
+const MAX_INFLIGHT_TERMINAL_CLAIMS = 2;
 const DURABLE_CONVERGE_BACKOFF_MS = [50, 100, 200, 400, 800, 1600];
 const DURABLE_CONVERGE_READ_TIMEOUT_MS = 2_000;
 const DURABLE_CALL_TIMEOUT_MS = 5_000;
+const TERMINAL_LADDER_WALL_MS = DURABLE_CALL_TIMEOUT_MS + DURABLE_CONVERGE_READ_TIMEOUT_MS + DURABLE_CONVERGE_BACKOFF_MS.reduce((a, b) => a + b, 0);
+const TERMINAL_CLAIM_CAP_POLL_MS = 50;
+function ambiguousCasFailOpenTag(intent) {
+    switch (intent) {
+        case "expire":
+            return "server.approval.ambiguous-cas.expire";
+        case "cancel":
+            return "server.approval.ambiguous-cas.cancel";
+        case "unreachable":
+            return "server.approval.ambiguous-cas.unreachable";
+        default: {
+            const unreachable = intent;
+            throw new Error(`ambiguousCasFailOpenTag: unknown intent ${String(unreachable)}`);
+        }
+    }
+}
 class ApprovalStoreDeadlineError extends Error {
     constructor(label, timeoutMs) {
         super(`approval store call ${label} timed out after ${timeoutMs}ms`);
@@ -214,6 +232,30 @@ function settleArgsOf(outcome) {
 export class ToolApprovalCoordinator {
     als = new AsyncLocalStorage();
     pending = new Map();
+    terminalClaimsInFlight = new Map();
+    admitTerminalClaim(askId) {
+        const n = this.terminalClaimsInFlight.get(askId) ?? 0;
+        if (n >= MAX_INFLIGHT_TERMINAL_CLAIMS)
+            return undefined;
+        this.terminalClaimsInFlight.set(askId, n + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const cur = this.terminalClaimsInFlight.get(askId) ?? 0;
+            if (cur <= 1)
+                this.terminalClaimsInFlight.delete(askId);
+            else
+                this.terminalClaimsInFlight.set(askId, cur - 1);
+        };
+    }
+    terminalClaimsInFlightCount(askId) {
+        return this.terminalClaimsInFlight.get(askId) ?? 0;
+    }
+    terminalClaimsInFlightForTest(askId) {
+        return this.terminalClaimsInFlightCount(askId);
+    }
     pendingByAskId = new Map();
     allowAllSessions = new Set();
     streams = new Map();
@@ -239,6 +281,7 @@ export class ToolApprovalCoordinator {
     parkTombstoneTtlMs;
     parkTombstonePerPrincipalMax;
     parkedRedeem;
+    askAudit;
     constructor(opts) {
         this.ruleConsent = opts?.ruleConsent;
         this.ruleScopeRootFor = opts?.ruleScopeRootFor;
@@ -254,6 +297,7 @@ export class ToolApprovalCoordinator {
         this.parkTombstoneMax = opts?.parkTombstoneMax ?? DEFAULT_PARK_TOMBSTONE_MAX;
         this.parkTombstoneTtlMs = opts?.parkTombstoneTtlMs ?? DEFAULT_PARK_TOMBSTONE_TTL_MS;
         this.parkTombstonePerPrincipalMax = opts?.parkTombstonePerPrincipalMax ?? DEFAULT_PARK_TOMBSTONE_PER_PRINCIPAL_MAX;
+        this.askAudit = opts?.askAudit;
     }
     unattendedOutcome() {
         return this.unattendedPolicy === "deny" ? false : "unavailable";
@@ -440,26 +484,39 @@ export class ToolApprovalCoordinator {
             return false;
         }
     }
-    async readDecidedForRecovery(askId) {
-        if (!this.askStore)
-            return undefined;
+    async probeRowWhileYielding(askId, budgetMs) {
+        if (!this.askStore || budgetMs <= 0)
+            return { kind: "none" };
+        const release = this.admitTerminalClaim(askId);
+        if (release === undefined)
+            return { kind: "denied" };
+        const raw = this.askStore.getAsk(askId);
+        void raw.then(release, release);
+        let row;
         try {
-            const row = await this.withStoreDeadline(this.askStore.getAsk(askId), "getAsk(expire-error-recovery)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
-            if (row === null || row.state !== "DECIDED")
-                return undefined;
-            if (replayTerminalAskRow(row) === true && this.abandonedEditedDecisionPending(askId)) {
-                this.guardRowDerivedApprove(askId, true, "expire-error-recovery");
-                return undefined;
-            }
-            if (this.editedDecisionInFlight(askId))
-                return undefined;
-            const replayed = settleArgsOf(replayTerminalAskRow(row));
-            return replayed === "unavailable" ? undefined : replayed;
+            row = await this.withStoreDeadline(raw, "getAsk(yield-probe)", Math.min(DURABLE_CONVERGE_READ_TIMEOUT_MS, budgetMs));
         }
         catch (err) {
-            this.noteStoreError(err, "getAsk(expire-error-recovery)");
-            return undefined;
+            this.noteStoreError(err, "getAsk(yield-probe)");
+            return { kind: "none" };
         }
+        if (row === null || row.state === "STREAM_PENDING")
+            return { kind: "none" };
+        return { kind: "row", current: projectAskTerminalClaimTruth(row) };
+    }
+    classifyClaimLoss(askId, current, where) {
+        if (current.state === "absent")
+            return { kind: "absent" };
+        const replayed = settleArgsOf(this.guardRowDerivedApprove(askId, replayTerminalAskRow(current), where));
+        if (replayed === "unavailable")
+            return { kind: "parked" };
+        if (!replayed.allowed)
+            return { kind: "denied" };
+        if (replayed.updatedInput !== undefined)
+            return { kind: "approved", updatedInput: replayed.updatedInput };
+        if (this.editedDecisionInFlight(askId))
+            return { kind: "edit-in-flight" };
+        return { kind: "approved" };
     }
     hasOtherSuspendedOwner(askId, self) {
         if (askId === undefined)
@@ -490,13 +547,17 @@ export class ToolApprovalCoordinator {
         const now = Date.now();
         let ownCount = 0;
         let ownExpiredVictim;
+        let ownBridgeVictim;
         let ownPlainVictim;
         let ownEvictable;
         let globalExpiredVictim;
+        let globalBridgeVictim;
         for (const [k, t] of this.parkTombstones) {
             const expired = now - t.parkedAtMs > this.parkTombstoneTtlMs;
             if (globalExpiredVictim === undefined && expired && t.inflight === undefined)
                 globalExpiredVictim = k;
+            if (globalBridgeVictim === undefined && t.kind === "voidBridge" && t.inflight === undefined)
+                globalBridgeVictim = k;
             if (t.owner !== tomb.owner)
                 continue;
             ownCount++;
@@ -506,13 +567,16 @@ export class ToolApprovalCoordinator {
                 ownEvictable = k;
             if (ownExpiredVictim === undefined && expired)
                 ownExpiredVictim = k;
-            if (ownPlainVictim === undefined && t.redeemed === undefined)
+            if (ownBridgeVictim === undefined && t.kind === "voidBridge")
+                ownBridgeVictim = k;
+            if (ownPlainVictim === undefined && t.kind === "park" && t.redeemed === undefined)
                 ownPlainVictim = k;
         }
+        const insertingBridge = tomb.kind === "voidBridge";
         if (ownCount >= effectivePerPrincipalMax) {
-            const victim = ownExpiredVictim ?? ownPlainVictim ?? ownEvictable;
+            const victim = insertingBridge ? (ownExpiredVictim ?? ownBridgeVictim) : (ownExpiredVictim ?? ownBridgeVictim ?? ownPlainVictim ?? ownEvictable);
             if (victim === undefined) {
-                recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"} reason=all-inflight`);
+                recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"} reason=${insertingBridge ? "bridge-would-evict-redeemable" : "all-inflight"}`);
                 return;
             }
             this.parkTombstones.delete(victim);
@@ -520,8 +584,11 @@ export class ToolApprovalCoordinator {
         else if (this.parkTombstones.size >= this.parkTombstoneMax && globalExpiredVictim !== undefined) {
             this.parkTombstones.delete(globalExpiredVictim);
         }
+        else if (this.parkTombstones.size >= this.parkTombstoneMax && !insertingBridge && globalBridgeVictim !== undefined) {
+            this.parkTombstones.delete(globalBridgeVictim);
+        }
         else if (this.parkTombstones.size >= this.parkTombstoneMax) {
-            recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"}`);
+            recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"}${insertingBridge ? " reason=bridge-refused-at-global-cap" : ""}`);
             return;
         }
         this.parkTombstones.set(approvalId, tomb);
@@ -601,6 +668,7 @@ export class ToolApprovalCoordinator {
                     if (p.targetCtxs?.has(ctx))
                         p.onTargetGone?.(ctx);
                 }
+                this.askAudit?.noteLegClosed(ctx.taskId);
             }
         }));
     }
@@ -878,7 +946,7 @@ export class ToolApprovalCoordinator {
                 sig.removeEventListener("abort", fn);
             this.pending.delete(id);
             if (windowRouteUnavailable && askId !== undefined && batchId !== undefined && this.unattendedOutcome() !== false) {
-                this.recordParkTombstone(wireApprovalId, { askId, batchId, owner: origin.owner, parkedAtMs: Date.now() });
+                this.recordParkTombstone(wireApprovalId, { kind: "park", askId, batchId, owner: origin.owner, parkedAtMs: Date.now() });
                 parkRouted = true;
             }
             if (askId !== undefined) {
@@ -893,55 +961,171 @@ export class ToolApprovalCoordinator {
             releaseAdmission();
             if (selfEntry)
                 selfEntry.settledOutcome = outcome;
+            this.askAudit?.recordSettle({
+                approvalId: wireApprovalId,
+                outcome,
+                ...(windowRouteUnavailable ? { parkRouted: true } : {}),
+                ...(hostSettledBy !== undefined ? { settledBy: hostSettledBy } : {}),
+                settledAtMs: Date.now(),
+            });
             resolveAllowed({ allowed, ...(allowed && updatedInput !== undefined ? { updatedInput } : {}) });
         };
-        const convergeFromDurableState = async (where) => {
-            if (!this.askStore || askId === undefined)
+        const broadcastClaimTruth = (read) => {
+            if (askId === undefined)
                 return;
-            const store = this.askStore;
+            switch (read.kind) {
+                case "approved":
+                    this.notifyExternalDecision(askId, true, read.updatedInput);
+                    return;
+                case "denied":
+                    this.notifyExternalDecision(askId, false);
+                    return;
+                case "parked":
+                    this.settleSameAskIdParkRoute(askId);
+                    return;
+                case "absent":
+                case "edit-in-flight":
+                    return;
+                default: {
+                    const unreachable = read;
+                    throw new Error(`broadcastClaimTruth: unknown recovery read ${String(unreachable)}`);
+                }
+            }
+        };
+        const settleFromClaimLoss = (read) => {
+            switch (read.kind) {
+                case "approved":
+                    settle(true, "allowed", read.updatedInput);
+                    broadcastClaimTruth(read);
+                    return true;
+                case "denied":
+                    settle(false, "denied");
+                    broadcastClaimTruth(read);
+                    return true;
+                case "parked":
+                    windowRouteUnavailable = true;
+                    settle(false, "expired");
+                    broadcastClaimTruth(read);
+                    return true;
+                case "absent":
+                case "edit-in-flight":
+                    return false;
+                default: {
+                    const unreachable = read;
+                    throw new Error(`settleFromClaimLoss: unknown recovery read ${String(unreachable)}`);
+                }
+            }
+        };
+        const lateClaimLossSettle = (current, intent) => {
+            if (askId === undefined)
+                return;
+            const read = this.classifyClaimLoss(askId, current, `late:${intent}`);
+            if (done) {
+                broadcastClaimTruth(read);
+                return;
+            }
+            settleFromClaimLoss(read);
+        };
+        const boundedClaim = (mk, label, timeoutMs, late) => {
+            const release = this.admitTerminalClaim(askId ?? wireApprovalId);
+            if (release === undefined)
+                return undefined;
+            const raw = mk();
+            void raw.then(release, release);
+            return this.withStoreDeadline(raw, label, timeoutMs, late);
+        };
+        const resolveLocalOutcome = async (arm) => {
+            if (askId === undefined) {
+                arm.settleByIntent();
+                return;
+            }
             const pinnedAskId = askId;
-            for (let attempt = 0; attempt < DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
+            let lastLoss;
+            const ladderStartedAt = Date.now();
+            const remainingMs = () => ladderStartedAt + TERMINAL_LADDER_WALL_MS - Date.now();
+            const nap = async (ms) => {
+                const slice = Math.min(ms, remainingMs());
+                if (slice > 0)
+                    await new Promise((r) => setTimeout(r, slice).unref?.());
+            };
+            let attempt = 0;
+            let claimsIssued = 0;
+            let rejects = 0;
+            while (attempt <= DURABLE_CONVERGE_BACKOFF_MS.length && remainingMs() > 0) {
                 if (done)
                     return;
-                try {
-                    const row = await this.withStoreDeadline(store.getAsk(pinnedAskId), `getAsk(${where})`, DURABLE_CONVERGE_READ_TIMEOUT_MS);
+                const backoffAfter = attempt < DURABLE_CONVERGE_BACKOFF_MS.length ? DURABLE_CONVERGE_BACKOFF_MS[attempt] : 0;
+                if (attempt > 0 && this.editedDecisionInFlight(pinnedAskId)) {
+                    const probed = await this.probeRowWhileYielding(pinnedAskId, remainingMs());
                     if (done)
                         return;
-                    if (row === null) {
-                        settle(false, "expired");
-                        return;
-                    }
-                    if (row.state === "STREAM_PENDING" || this.editedDecisionInFlight(pinnedAskId)) {
-                        await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
+                    if (probed.kind === "denied") {
+                        await nap(TERMINAL_CLAIM_CAP_POLL_MS);
                         continue;
                     }
-                    const outcome = settleArgsOf(this.guardRowDerivedApprove(pinnedAskId, replayTerminalAskRow(row), `converge:${where}`));
-                    if (outcome === "unavailable") {
-                        windowRouteUnavailable = true;
-                        settle(false, "expired");
-                    }
-                    else if (outcome.allowed) {
-                        settle(true, "allowed", outcome.updatedInput);
+                    if (probed.kind === "row") {
+                        const read = this.classifyClaimLoss(pinnedAskId, probed.current, `yield-probe:${arm.intent}`);
+                        if (settleFromClaimLoss(read))
+                            return;
+                        if (read.kind === "edit-in-flight")
+                            lastLoss = probed.current;
                     }
-                    else {
-                        settle(false, "denied");
+                    else if (this.terminalClaimsInFlightCount(pinnedAskId) > 0) {
+                        await nap(TERMINAL_CLAIM_CAP_POLL_MS);
+                        continue;
                     }
-                    return;
+                    await nap(backoffAfter);
+                    attempt++;
+                    continue;
+                }
+                const inFlight = arm.claim(Math.min(attempt === 0 ? DURABLE_CALL_TIMEOUT_MS : DURABLE_CONVERGE_READ_TIMEOUT_MS, remainingMs()));
+                if (inFlight === undefined) {
+                    await nap(TERMINAL_CLAIM_CAP_POLL_MS);
+                    continue;
+                }
+                claimsIssued++;
+                let outcome;
+                try {
+                    outcome = await inFlight;
                 }
                 catch (err) {
-                    this.noteStoreError(err, `getAsk(${where})`);
-                    await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
+                    this.noteStoreError(err, arm.storeLabel);
+                    rejects++;
+                    await nap(backoffAfter);
+                    attempt++;
+                    continue;
                 }
-            }
-            if (!done) {
-                if (this.editedDecisionInFlight(pinnedAskId)) {
-                    windowRouteUnavailable = true;
-                    settle(false, "expired");
+                if (outcome.claimed) {
+                    arm.onWon(outcome);
+                    return;
                 }
-                else {
-                    settle(false, "expired");
+                arm.onLostTruth?.(outcome.current);
+                const read = this.classifyClaimLoss(pinnedAskId, outcome.current, `claim:${arm.intent}`);
+                if (done) {
+                    broadcastClaimTruth(read);
+                    return;
+                }
+                if (settleFromClaimLoss(read))
+                    return;
+                if (read.kind === "absent") {
+                    arm.settleByIntent();
+                    return;
                 }
+                lastLoss = outcome.current;
+                await nap(backoffAfter);
+                attempt++;
             }
+            if (done)
+                return;
+            if (this.editedDecisionInFlight(pinnedAskId)) {
+                windowRouteUnavailable = true;
+                settle(false, "expired");
+                return;
+            }
+            if (lastLoss !== undefined && settleFromClaimLoss(this.classifyClaimLoss(pinnedAskId, lastLoss, `claim-tail:${arm.intent}`)))
+                return;
+            recordFailOpen(ambiguousCasFailOpenTag(arm.intent), `askId=${pinnedAskId} attempts=${attempt} claims=${claimsIssued} rejects=${rejects} elapsedMs=${Date.now() - ladderStartedAt}`);
+            arm.settleByIntent();
         };
         const settleParkRouteIfUnsettled = (hostSettledBy) => {
             if (done)
@@ -955,34 +1139,30 @@ export class ToolApprovalCoordinator {
                     settleParkRouteIfUnsettled(hostSelfReport);
                     return;
                 }
-                try {
-                    const res = await this.withStoreDeadline(this.askStore.expireAsk(askId, batchId), "expireAsk(window)", DURABLE_CALL_TIMEOUT_MS, (late) => {
-                        if (!late.won)
+                const store = this.askStore;
+                const pinnedAskId = askId;
+                const pinnedBatchId = batchId;
+                await resolveLocalOutcome({
+                    intent: "expire",
+                    storeLabel: "claimTerminal(window)",
+                    claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "expire"), "claimTerminal(window)", timeoutMs, (late) => {
+                        if (!late.claimed) {
+                            lateClaimLossSettle(late.current, "expire");
                             return;
-                        this.settleSameAskIdParkRoute(askId);
+                        }
+                        this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(late.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, late.voidedSiblings, "superseded_by_park", Date.now()));
-                    });
-                    if (res.won) {
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, late.voidedSiblings, "superseded_by_park", Date.now(), origin.taskId));
+                    }),
+                    onWon: (res) => {
                         windowRouteUnavailable = true;
                         settle(false, "expired");
-                        this.settleSameAskIdParkRoute(askId);
+                        this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(res.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, res.voidedSiblings, "superseded_by_park", Date.now()));
-                    }
-                    else {
-                        await convergeFromDurableState("windowExpired");
-                    }
-                }
-                catch (err) {
-                    this.noteStoreError(err, "expireAsk");
-                    const decided = await this.readDecidedForRecovery(askId);
-                    if (decided !== undefined && !done) {
-                        settle(decided.allowed, decided.allowed ? "allowed" : "denied", decided.updatedInput);
-                        return;
-                    }
-                    settleParkRouteIfUnsettled(hostSelfReport);
-                }
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, res.voidedSiblings, "superseded_by_park", Date.now(), origin.taskId));
+                    },
+                    settleByIntent: () => settleParkRouteIfUnsettled(hostSelfReport),
+                });
             })();
         };
         const forceParkNow = () => {
@@ -1005,26 +1185,36 @@ export class ToolApprovalCoordinator {
                 settle(false, "expired");
                 return;
             }
-            try {
-                const won = await this.withStoreDeadline(this.askStore.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: Date.now() }), "transitionAsk(cancel)", DURABLE_CALL_TIMEOUT_MS, (lateWon) => {
-                    if (!lateWon)
+            const store = this.askStore;
+            const pinnedAskId = askId;
+            const pinnedBatchId = batchId;
+            const cancelLostTruth = (current) => {
+                if (current.state !== "VOID")
+                    return;
+                this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+            };
+            await resolveLocalOutcome({
+                intent: "cancel",
+                storeLabel: "claimTerminal(cancel)",
+                claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "cancel"), "claimTerminal(cancel)", timeoutMs, (late) => {
+                    if (!late.claimed) {
+                        cancelLostTruth(late.current);
+                        lateClaimLossSettle(late.current, "cancel");
                         return;
-                    this.settleVoidedSiblings([askId]);
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, [askId], "aborted", Date.now()));
-                });
-                if (won) {
+                    }
+                    this.settleVoidedSiblings([pinnedAskId]);
+                    this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now(), origin.taskId));
+                }),
+                onWon: () => {
                     settle(false, "expired");
-                    this.settleVoidedSiblings([askId]);
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, [askId], "aborted", Date.now()));
-                }
-                else {
-                    await convergeFromDurableState("runCancel");
-                }
-            }
-            catch (err) {
-                this.noteStoreError(err, "transitionAsk(cancel)");
-                settle(false, "expired");
-            }
+                    this.settleVoidedSiblings([pinnedAskId]);
+                    this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now(), origin.taskId));
+                },
+                onLostTruth: cancelLostTruth,
+                settleByIntent: () => settle(false, "expired"),
+            });
         };
         if (signal) {
             const onTaskAbort = () => void runCancel();
@@ -1082,6 +1272,18 @@ export class ToolApprovalCoordinator {
             }
             siblings.add(pendingEntry);
         }
+        this.askAudit?.recordAsk({
+            approvalId: wireApprovalId,
+            taskId: origin.taskId,
+            ...(req.sourceTaskId !== undefined ? { sourceTaskId: req.sourceTaskId } : {}),
+            ...(origin.sessionId !== undefined ? { sessionId: origin.sessionId } : {}),
+            owner: origin.owner,
+            toolName: req.toolName,
+            toolCallId: req.toolCallId,
+            legTracked: !child && aliveCtxs.some((c) => c.taskId === origin.taskId),
+            expiresAtMs: persistedExpiresAtMs,
+            mintedAtMs: Date.now(),
+        });
         const cardFrame = askId !== undefined && cardForFrame !== undefined
             ? buildApprovalRequestFrame({ askId, taskId: origin.taskId, approvalId: wireApprovalId, card: cardForFrame, expiresAtMs: persistedExpiresAtMs, nowMs: Date.now() })
             : undefined;
@@ -1114,31 +1316,42 @@ export class ToolApprovalCoordinator {
         const emitAllP = (async () => {
             const results = await Promise.all(openByCtx.values());
             const anySucceeded = reachability === "unreached" || this.hasOtherSuspendedOwner(askId, selfEntry) || results.some((r) => r.legacy || r.card);
+            emitSettled = true;
             if (!anySucceeded && !done) {
                 if (this.askStore && askId !== undefined && batchId !== undefined) {
-                    try {
-                        const res = await this.withStoreDeadline(this.askStore.expireAsk(askId, batchId), "expireAsk(emit-failed)");
-                        if (res.won && !done) {
-                            emitFailed = true;
-                            settle(false, "expired");
-                            this.settleSameAskIdParkRoute(askId);
+                    const store = this.askStore;
+                    const pinnedAskId = askId;
+                    const pinnedBatchId = batchId;
+                    const settleUnreachable = () => {
+                        if (done)
+                            return;
+                        emitFailed = true;
+                        settle(false, "expired");
+                    };
+                    await resolveLocalOutcome({
+                        intent: "unreachable",
+                        storeLabel: "claimTerminal(emit-failed)",
+                        claim: (timeoutMs) => boundedClaim(() => store.claimTerminal(pinnedAskId, pinnedBatchId, "expire"), "claimTerminal(emit-failed)", timeoutMs, (late) => {
+                            if (!late.claimed) {
+                                lateClaimLossSettle(late.current, "unreachable");
+                                return;
+                            }
+                            this.settleSameAskIdParkRoute(pinnedAskId);
+                            this.settleVoidedSiblings(late.voidedSiblings);
+                        }),
+                        onWon: (res) => {
+                            settleUnreachable();
+                            this.settleSameAskIdParkRoute(pinnedAskId);
                             this.settleVoidedSiblings(res.voidedSiblings);
-                        }
-                    }
-                    catch (err) {
-                        this.noteStoreError(err, "expireAsk(emit-failed)");
-                        if (!done) {
-                            emitFailed = true;
-                            settle(false, "expired");
-                        }
-                    }
+                        },
+                        settleByIntent: settleUnreachable,
+                    });
                 }
                 else if (!done) {
                     emitFailed = true;
                     settle(false, "expired");
                 }
             }
-            emitSettled = true;
         })();
         await Promise.race([emitAllP, allowedP]);
         const settled = await allowedP;

package/dist/trace/engine-notice-wire.d.ts

@@ -16,7 +16,7 @@
  * 同文件 G1 e2e 的全码扇出夹具、以及契约文档附录 D.3 那张表(含**小节标题里的码数** —— 那道门本批
  * 刚立,立完就在下一次加码时自己咬住了)。
  */
-export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted"];
+export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "task.halt_unconsumed", "task.late_approval"];
 export type EngineNoticeWireCode = (typeof ENGINE_NOTICE_WIRE_CODES)[number];
 /** 白名单谓词(单点):路由与门都读这一个,不许第二处手抄码串。 */
 export declare function isEngineNoticeWireCode(code: string): code is EngineNoticeWireCode;

package/dist/trace/engine-notice-wire.js

@@ -13,6 +13,8 @@ export const ENGINE_NOTICE_WIRE_CODES = [
     "task.user_followup_undrained",
     "memory.capture_opted_out",
     "memory.capture_optout_unpersisted",
+    "task.halt_unconsumed",
+    "task.late_approval",
 ];
 const WIRE_CODES = new Set(ENGINE_NOTICE_WIRE_CODES);
 export function isEngineNoticeWireCode(code) {

package/dist/trace/injection-tier.d.ts

@@ -1,27 +1,17 @@
 /**
- * [ref] 注入档位(core 5.61.0)的**闭集单点**([ref])。
+ * [ref] 注入档位(core 5.61.0)的**闭集单点**([ref])——2026-08-31 起改为 **core 根导出直调**。
  *
- * ## 为什么本仓要自己留一份词表
- * 理想写法是复用 core 的谓词 `isSystemInjectionPriority` / 数据表 `SYSTEM_INJECTION_PRIORITIES`。
- * 但 core 5.61.0 **没有把它们放进根 barrel**(`dist/index.d.ts` 只导出了 `SystemInjectionPriority`
- * 这个**类型**),而 `@sema-agent/core` 的 `package.json#exports` 只开了 `.` / `./bench` / `./fixtures`
- * 三口 ⇒ 深导入被 exports map 关死,结构上够不着运行期的那份。
- *
- * 于是用本仓既有的**双向锚**姿势(`http/routes/notify-wake.ts` 的 `NOTIFY_STATUSES` 先例):
- *  · `satisfies` 管「表内不许有词表外的词」—— core 删/改档位 ⇒ 编译红;
- *  · 穷举断言管「词表不许有表外的词」—— core 加档位 ⇒ 编译红。
- * 两条合起来 = 上游任何一侧的增删都在编译期被逼着处置,而不是运行时静默漂。
- *
- * ## 为什么单独一个叶子模块
- * 消费点有两个且分属两条依赖链:`trace/project.ts`(wire 投影)与
- * `orchestration/workflow-completion-inbox.ts`(durable park 载荷)。手抄两份就是值拷贝漂移源
- * (本仓 [ref] 起的老病族);把它挂在任一方又会在两条链之间拉一条没必要的边。零依赖叶子最干净。
- *
- * 🔴 上游哪天补了根导出:删掉本文件,两处改成一行谓词调用。
+ * ## 收口条款兑现([ref] PM 审计④「core 前提句过期族」)
+ * 本文件 5.61 时代的顶注写着「core 没有把 `SYSTEM_INJECTION_PRIORITIES` / `isSystemInjectionPriority`
+ * 放进根 barrel ⇒ 本仓自留双向锚词表;上游哪天补了根导出:删掉本文件,两处改成一行谓词调用」。
+ * core 7.0.2 已把**表和谓词都放进根导出**(运行期亲证:`SYSTEM_INJECTION_PRIORITIES` 数组 +
+ * `isSystemInjectionPriority` 函数均可 require 到)——按条款执行:自留词表退役,改直调;本文件保留为
+ * 两个消费点(`trace/project.ts` / `orchestration/workflow-completion-inbox.ts`)的公共缝(语义注 +
+ * `injectionTierOrAbsent` 的丢键方向条款仍是本仓资产,不随词表走)。
  */
-import type { SystemInjectionPriority } from "@sema-agent/core";
-/** 三档闭集,与 core `SystemInjectionPriority` 双向锚(见顶注)。 */
-export declare const INJECTION_TIERS: readonly ["now", "next", "later"];
+import { type SystemInjectionPriority } from "@sema-agent/core";
+/** 三档闭集 —— 现在就是 core 的那份表(单源;保留导出名,两个消费点与既有测试不动)。 */
+export declare const INJECTION_TIERS: readonly SystemInjectionPriority[];
 /**
  * 边界守卫 —— 闭集内的值原样返回,**其余一律 `undefined`**(= 缺席)。
  *