@sema-agent/server 7.147.0 → 7.149.0

package/dist/tool-approval.js

@@ -3,18 +3,20 @@ import { heldAskOf, liveHostSource, readDecider, retiredDecisionKeyFacts, POLICY
 import { AsyncLocalStorage } from "node:async_hooks";
 import { uuidv7, classifyAsk, foldArbitrationRow, policyCannotAnswer, screenAskClassMembers, MAX_RULE_TEXT_CHARS, READ_ROOT_CANDIDATE_DIR_MAX, parseRuleText, pathConfinableWriteToolNames } from "@sema-agent/core";
 import { precheckCardRuleText } from "./rules-consent.js";
-import { cardTakesWholeToolConsent } from "./permission-rule-vocab.js";
+import { CARD_RULE_FORM_OF_MATCH, cardRuleFormOf } from "./permission-rule-vocab.js";
 import { redactDeep, redactSecrets, redactSecretsWithArms } from "./trace/redact.js";
 import { seatText } from "./trace/exit-seat.js";
 import { hasBidiControls } from "./text-bidi.js";
 import { approvalPayloadFingerprint } from "./plugins/approval-payload-fingerprint.js";
 import { createLogger } from "./observability/logger.js";
 import { errorKindOf } from "./observability/err-text.js";
+import { createHitlOpenRace, deliverHitlNotice } from "./hitl-delivery.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { ownerOfCheckpointScope } from "./security.js";
+import { keyAdmits, ownerCellOf, recoveredSubject } from "./owner-faces.js";
 import { deriveAskId, deriveAskScopedBatchId, deriveBatchId, MAX_DECISION_NOTE_CHARS, noteLandedOnRow, noteRecordedReceipt, readBoundInputHash } from "./approval-ask-machine.js";
 import { askDemandsAPerson, storedPersonDemandRecord, currentParkArm, MAX_RULE_OFFERS, buildApprovalCard, buildApprovalCardEnvelope, adoptStoredLiveFacts, buildApprovalRequestFrame, buildReplayFrame, buildRevokeFrame, readDenialLimitFallback, readProbeCause, readProbeReason, readReadRootCandidate, readStoredCardEnvelope, readRuleEvidence, readAllowRuleShadowed, readRuleOffersAbsence, readRuleOffersAbsenceSeat, readParkRowTrueSeat, readAskClassPair, readAskReasons, readClosedWordSeat, buildApprovalCompleteFrame, readRuleOfferList, } from "./approval-card.js";
-import { askOwnerAdmits, askRowCarriesOwner, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth } from "./plugins/approval-ask-store-sql.js";
+import { askRowCarriesOwner, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth } from "./plugins/approval-ask-store-sql.js";
 import { APPROVAL_ENDING_CAUSES, SETTLE_OUTCOME, askRowEndingCause, askRowParkTrigger } from "./approval-deny-reasons.js";
 import { settleByPolicy } from "./approval-policy-settlement.js";
 import { governanceAskMarksFor, runWithGovernanceAskScope } from "./governance-ask-marks.js";
@@ -35,7 +37,7 @@ const ADOPT_OPEN_ASKS_MAX = 1_000;
 const EDITED_DECISION_MARK_CAP_MS = 10_000;
 const DEFAULT_WINDOW_MARGIN_MS = 10_000;
 const SHUTDOWN_DRAIN_POLL_MS = 50;
-const MAX_ALLOW_SESSIONS = 4096;
+export const MAX_ALLOW_SESSIONS = 4096;
 const DEFAULT_ADMIT_MAX_PER_TASK = 32;
 const DEFAULT_ADMIT_MAX_PER_OWNER = 256;
 const DEFAULT_PARK_REDEMPTION_MAX = 2000;
@@ -46,8 +48,10 @@ const PARKING_RETRY_AFTER_MS = 250;
 export function approvalDecidePath(sessionId) {
     return `/v1/approvals/${encodeURIComponent(sessionId)}/decide`;
 }
-function parkSessionOf(row) {
-    return row.sourceSessionId === row.sessionId && row.sessionId !== row.taskId ? row.sessionId : undefined;
+export function parkSessionOf(row) {
+    if (row.state === "PARKED")
+        return row.sourceSessionId;
+    return row.sourceSessionId !== row.taskId ? row.sourceSessionId : undefined;
 }
 function ruleMaterialCarriesCredentialShape(command) {
     return redactSecretsWithArms(command, { observe: false }).arms.has("full");
@@ -111,8 +115,10 @@ const FS_WRITE_TOOLS = pathConfinableWriteToolNames();
 function sessionAllowCategory(toolName) {
     return FS_WRITE_TOOLS.has(toolName) ? "fs-write" : `tool:${toolName}`;
 }
-function sessionAllowKey(owner, sessionId, category, binding) {
-    return JSON.stringify([owner, sessionId, category, binding.kind === "bound" ? binding.digest : null]);
+function sessionAllowKey(owner, sessionId, incarnation, category, binding) {
+    if (!sessionId || !incarnation)
+        return undefined;
+    return JSON.stringify([owner, sessionId, incarnation, category, binding.kind === "bound" ? binding.digest : null]);
 }
 function askStandingAnswerFacts(req, governanceForced, deploymentListAsks) {
     const classes = screenAskClassMembers(req.askClass, req.classes)?.classes;
@@ -223,11 +229,14 @@ function mandatedFromSeat(seat) {
             return false;
     }
 }
-function rowOrUnknown(read) {
-    return read.kind === "row" ? read.row : null;
-}
 function askRowVisibleTo(row, principal) {
-    return row !== null && askOwnerAdmits(row.owner, principal);
+    return row !== null && askOwnerAdmitsAnswer(row.owner, principal);
+}
+function askOwnerAdmitsAnswer(owner, principal) {
+    return keyAdmits("ask.answer", { subject: recoveredSubject(principal), operator: false }, ownerCellOf(owner));
+}
+function receiptAnswersNow(redeemedGeneration, openGenerationNow) {
+    return redeemedGeneration === undefined || openGenerationNow === undefined || openGenerationNow <= redeemedGeneration;
 }
 function waitingLegsReached(entry, othersReached) {
     return (entry.adopted === true ? 0 : 1) + othersReached;
@@ -257,8 +266,10 @@ function livePendingRowOf(e) {
         ...(e.adopted === true ? { consumerState: ASK_DECISION_CONSUMER_ABSENT } : {}),
     };
 }
+const _legFamiliesAreFrameFamilies = true;
+void _legFamiliesAreFrameFamilies;
 function canPresentWithoutDurableRow(c) {
-    return c.emitCard === undefined;
+    return c.family === "tool_approval";
 }
 export const PERSIST_RULE_TEXT_ERROR = `persistRule.rule must be a non-empty string of at most ${MAX_RULE_TEXT_CHARS} characters`;
 export const PERSIST_RULE_EDITED_FLAG_ERROR = "persistRule.edited must be a boolean when present";
@@ -435,49 +446,6 @@ export function declaredApprovalFrameFamilies(settings) {
     const raw = Reflect.get(settings, "approvalFrameFamilies");
     return new Set(Array.isArray(raw) ? raw.filter((w) => APPROVAL_FRAME_FAMILIES.includes(w)) : []);
 }
-export function createApprovalCardEmitter(sinks) {
-    const present = [sinks.appendDurable, sinks.writeLive].filter((w) => w !== undefined);
-    const attempt = (write, frame) => (async () => {
-        try {
-            await write(frame);
-            return true;
-        }
-        catch (err) {
-            defaultLogger.warn("approval_card_sink_write_failed", { frame: frame.type, approvalId: frame.approvalId, errKind: errorKindOf(err) });
-            return false;
-        }
-    })();
-    const opened = new Map();
-    return async (frame, registration) => {
-        if (frame.type === "approval_request") {
-            const results = present.map((write) => attempt(write, frame));
-            opened.set(registration, results);
-            const accepted = await new Promise((resolve) => {
-                let pending = results.length;
-                if (pending === 0)
-                    resolve(false);
-                for (const r of results) {
-                    void r.then((ok) => {
-                        if (ok)
-                            resolve(true);
-                        else if (--pending === 0)
-                            resolve(false);
-                    });
-                }
-            });
-            if (!accepted) {
-                opened.delete(registration);
-                throw new Error("approval card undeliverable — no sink accepted the frame (live stream closed and/or the durable append failed)");
-            }
-            return;
-        }
-        const results = opened.get(registration);
-        opened.delete(registration);
-        if (results === undefined)
-            return;
-        await Promise.all(present.map((write, i) => results[i].then((ok) => (ok ? attempt(write, frame) : false))));
-    };
-}
 export function resolveApprovalLeg(input) {
     const active = input.streamApprovalOn;
     const tightDeadline = active && input.legWalltimeMs !== undefined && input.legWalltimeMs - input.windowMarginMs <= 0;
@@ -767,14 +735,14 @@ export class ToolApprovalCoordinator {
             }
         });
     }
-    static ruleOfferDerivedFactsAgree(offer) {
+    static ruleOfferDerivedFactsAgree(offer, cardTool) {
         const derive = (rule) => {
             const p = parseRuleText(rule, "allow");
             return "rule" in p ? p.rule : undefined;
         };
         if (offer.kind === "single") {
             const d = derive(offer.rule);
-            return d !== undefined && d.rule === offer.rule && d.match === offer.match && d.command === offer.command && ToolApprovalCoordinator.singleOfferToolAgrees(d.match, d.tool);
+            return d !== undefined && d.rule === offer.rule && d.match === offer.match && d.command === offer.command && ToolApprovalCoordinator.singleOfferBelongsOnCard(d.match, d.tool, cardTool);
         }
         return offer.rules.every((m) => {
             const d = derive(m.rule);
@@ -790,40 +758,21 @@ export class ToolApprovalCoordinator {
             }
         });
     }
-    static singleOfferToolAgrees(match, tool) {
-        switch (match) {
-            case "exact":
-            case "prefix":
-            case "wildcard":
-            case "pattern":
-                return tool === "Bash";
-            case "tool":
-                return cardTakesWholeToolConsent(tool);
-            case "subpath":
-            case "path":
-            case "name":
-            case "name_prefix":
-            case "host":
-            case "subdomain":
-                return false;
-            default: {
-                const unknown = match;
-                void unknown;
-                return false;
-            }
-        }
+    static singleOfferBelongsOnCard(match, ruleTool, cardTool) {
+        const form = CARD_RULE_FORM_OF_MATCH[match];
+        return ruleTool === cardTool && form !== undefined && form === cardRuleFormOf(cardTool);
     }
-    static boundRuleOfferTexts(offers) {
+    static boundRuleOfferTexts(offers, cardTool) {
         const over = (s) => s.length > MAX_RULE_TEXT_CHARS;
         const clipSegment = (s) => (over(s) ? s.slice(0, MAX_RULE_TEXT_CHARS) : s);
         const out = [];
         for (const { offer } of readRuleOfferList(offers)) {
             if (ToolApprovalCoordinator.ruleOfferTextsOverSize(offer))
                 return undefined;
-            if (!ToolApprovalCoordinator.ruleOfferDerivedFactsAgree(offer)) {
+            if (!ToolApprovalCoordinator.ruleOfferDerivedFactsAgree(offer, cardTool)) {
                 defaultLogger.warn("rule_offer_dropped_derived_facts_disagree", {
                     kind: offer.kind,
-                    note: "an offer's kind/match/command/directory seats do not agree with what the shared validator derives from its rule text — dropped whole so the card never shows one grant while redeeming another (core/dist skew or forged material?)",
+                    note: "an offer's kind/match/command/directory seats do not agree with what the shared validator derives from its rule text, or it is not this card's tool / card form — dropped whole so the card never shows one grant while redeeming another (core/dist skew or forged material?)",
                 });
                 continue;
             }
@@ -860,11 +809,9 @@ export class ToolApprovalCoordinator {
         return out;
     }
     static cardBindingOf(args, offers) {
-        const isWholeTool = (o) => o.kind === "single" && o.match === "tool";
-        if (offers.length > 0 && offers.every(isWholeTool))
-            return "";
-        if (offers.some(isWholeTool))
-            return undefined;
+        const valueOffers = offers.filter((o) => o.kind === "single" && CARD_RULE_FORM_OF_MATCH[o.match] !== "command");
+        if (valueOffers.length > 0)
+            return valueOffers.length === 1 && offers.length === 1 ? valueOffers[0].command : undefined;
         if (args === null || typeof args !== "object" || Array.isArray(args))
             return undefined;
         const command = args.command;
@@ -881,7 +828,7 @@ export class ToolApprovalCoordinator {
         if (!Array.isArray(rawOffers) || rawOffers.length === 0)
             return undefined;
         const capped = rawOffers.length > MAX_RULE_OFFERS ? rawOffers.slice(0, MAX_RULE_OFFERS) : rawOffers;
-        const offers = ToolApprovalCoordinator.boundRuleOfferTexts(capped);
+        const offers = ToolApprovalCoordinator.boundRuleOfferTexts(capped, req.toolName);
         if (offers === undefined)
             return undefined;
         const command = ToolApprovalCoordinator.cardBindingOf(req.args, offers);
@@ -1012,7 +959,8 @@ export class ToolApprovalCoordinator {
         const sessionId = origin.sessionId;
         if (!sessionId)
             return false;
-        const live = this.allowAllSessions.has(sessionAllowKey(origin.owner, sessionId, sessionAllowCategory(req.toolName), facts.grantBinding));
+        const liveKey = sessionAllowKey(origin.owner, sessionId, origin.incarnation, sessionAllowCategory(req.toolName), facts.grantBinding);
+        const live = liveKey !== undefined && this.allowAllSessions.has(liveKey);
         const durable = !live && facts.grantBinding.kind === "none" && (await this.durableGrantHas(sessionId, req.toolName));
         if (!live && !durable)
             return false;
@@ -1036,7 +984,14 @@ export class ToolApprovalCoordinator {
     }
     boundUnattendedAsk = (identity, why) => {
         return async (req) => {
-            const origin = { owner: identity.owner, taskId: identity.taskId, ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}), legKey: "", executionLane: identity.executionLane };
+            const origin = {
+                owner: identity.owner,
+                taskId: identity.taskId,
+                ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}),
+                legKey: "",
+                executionLane: identity.executionLane,
+                ...(identity.incarnation !== undefined ? { incarnation: identity.incarnation } : {}),
+            };
             if (await this.standingGrantSettles(origin, req, this.governanceForcedOf(origin, req)))
                 return true;
             return this.unattendedAskOutcome({ ...why, taskId: identity.taskId, owner: identity.owner, toolName: req.toolName });
@@ -1224,15 +1179,9 @@ export class ToolApprovalCoordinator {
     emitRevokeTo(ctxs, frame) {
         if (frame.askIds.length === 0)
             return;
-        for (const c of ctxs) {
-            if (!c.emitRevoke)
-                continue;
-            try {
-                void Promise.resolve(c.emitRevoke(frame)).catch(() => undefined);
-            }
-            catch {
-            }
-        }
+        for (const c of ctxs)
+            if (c.family === "approval_request")
+                void deliverHitlNotice(c.transport, frame);
     }
     emitRevoke(frame, target) {
         const targets = new Set();
@@ -1288,6 +1237,7 @@ export class ToolApprovalCoordinator {
             ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
             legKey: ctx.legKey ?? "",
             executionLane: ctx.executionLane,
+            ...(ctx.incarnation !== undefined ? { incarnation: ctx.incarnation } : {}),
             ...(ctx.legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic: ctx.legDeadlineMonotonic } : {}),
         }, [ctx], req, signal);
     };
@@ -1301,6 +1251,7 @@ export class ToolApprovalCoordinator {
                 ...(identity.sessionId !== undefined ? { sessionId: identity.sessionId } : {}),
                 legKey: identity.legKey ?? "",
                 executionLane: identity.executionLane,
+                ...(identity.incarnation !== undefined ? { incarnation: identity.incarnation } : {}),
                 ...(identity.legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic: identity.legDeadlineMonotonic } : {}),
             }, live, req, signal);
         };
@@ -1583,6 +1534,7 @@ export class ToolApprovalCoordinator {
         const allowedP = new Promise((resolve) => { resolveAllowed = resolve; });
         let lastOutcome = SETTLE_OUTCOME.EXPIRED;
         let lastCause;
+        let completeFrame;
         const abortListeners = [];
         let selfEntry;
         let hostSettled;
@@ -1646,8 +1598,10 @@ export class ToolApprovalCoordinator {
             }
             lastOutcome = outcome;
             lastCause = verdict.by === "system" ? verdict.cause : undefined;
-            if (lastLiveRegistration && askId !== undefined) {
-                this.notifyPresentedCardWatchers(askId, buildApprovalCompleteFrame({ askId, taskId: origin.taskId, approvalId: wireApprovalId, outcome, ...(lastCause !== undefined ? { cause: lastCause } : {}), parked: parkRouted, nowMs: Date.now() }));
+            if (askId !== undefined) {
+                completeFrame = buildApprovalCompleteFrame({ askId, taskId: origin.taskId, approvalId: wireApprovalId, outcome, ...(lastCause !== undefined ? { cause: lastCause } : {}), parked: parkRouted, nowMs: Date.now() });
+                if (lastLiveRegistration)
+                    this.notifyPresentedCardWatchers(askId, completeFrame);
             }
             releaseAdmission();
             if (selfEntry)
@@ -1952,10 +1906,12 @@ export class ToolApprovalCoordinator {
             forceParkNow,
             settleParkRoute: (cause) => settleParkRouteIfUnsettled(undefined, cause),
             owner: origin.owner,
+            ownerReadSeq: this.rowReadSeq,
             ...(primary ? { ctxTaskId: primary.taskId, originCtx: primary } : {}),
             ...(reachability === "unreached" ? { suspended: true } : {}),
             ...(child ? { originTaskId: req.sourceSessionId } : primary ? { targetCtxs: new Set(aliveCtxs), onTargetGone } : {}),
             ...(origin.sessionId ? { sessionId: origin.sessionId } : {}),
+            ...(origin.incarnation !== undefined ? { incarnation: origin.incarnation } : {}),
             frame,
             ...(cardFrame !== undefined ? { cardFrame } : {}),
             approvalId: wireApprovalId,
@@ -2014,38 +1970,24 @@ export class ToolApprovalCoordinator {
             frame.serverNowMs = serverNowMs;
             frame.expiresInMs = Math.max(0, persistedExpiresAtMs - serverNowMs);
         }
-        const emitOne = async (c) => {
-            let family;
-            let send;
-            if (c.emitCard !== undefined) {
-                if (cardFrame === undefined) {
-                    defaultLogger.warn("approval card leg cannot present this ask: it has no confirmed durable identity (no approval_request frame is minted without one)", {
-                        taskId: origin.taskId,
-                        approvalId: wireApprovalId,
-                        toolName: req.toolName,
-                    });
-                    return { delivered: false };
-                }
-                family = "approval_request";
-                send = () => c.emitCard(cardFrame, id);
-            }
-            else {
-                family = "tool_approval";
-                send = () => c.emit(frame);
-            }
-            try {
-                await send();
-                return { delivered: true };
-            }
-            catch (err) {
-                defaultLogger.warn("approval_card_delivery_failed", { taskId: origin.taskId, approvalId: wireApprovalId, family, errKind: errorKindOf(err) });
-                return { delivered: false };
-            }
-        };
-        const openByCtx = new Map(aliveCtxs.map((c) => [c, emitOne(c)]));
+        const cardCtxs = aliveCtxs.filter((c) => c.family === "approval_request");
+        const legacyCtxs = aliveCtxs.filter((c) => c.family === "tool_approval");
+        if (cardFrame === undefined && cardCtxs.length > 0) {
+            defaultLogger.warn("approval card leg cannot present this ask: it has no confirmed durable identity (no approval_request frame is minted without one)", {
+                taskId: origin.taskId,
+                approvalId: wireApprovalId,
+                toolName: req.toolName,
+            });
+        }
+        const cardRace = cardFrame !== undefined && cardCtxs.length > 0
+            ? createHitlOpenRace({ targets: cardCtxs.map((c) => ({ transport: c.transport, frame: cardFrame })), settled: allowedP })
+            : undefined;
+        const legacyRace = legacyCtxs.length > 0 ? createHitlOpenRace({ targets: legacyCtxs.map((c) => ({ transport: c.transport, frame })), settled: allowedP }) : undefined;
+        if (cardRace !== undefined && cardFrame !== undefined)
+            cardCtxs.forEach((c, i) => this.notePresentedCardRegistration(cardFrame.askId, c.transport, cardRace.acceptedLive(i)));
         const emitAllP = (async () => {
-            const results = await Promise.all(openByCtx.values());
-            const anySucceeded = reachability === "unreached" || this.hasOtherSuspendedOwner(askId, selfEntry) || results.some((r) => r.delivered);
+            const landings = await Promise.all([cardRace?.landing, legacyRace?.landing]);
+            const anySucceeded = reachability === "unreached" || this.hasOtherSuspendedOwner(askId, selfEntry) || landings.includes("delivered");
             emitSettled = true;
             if (!anySucceeded && !done) {
                 if (this.askStore && askId !== undefined && batchId !== undefined) {
@@ -2086,35 +2028,15 @@ export class ToolApprovalCoordinator {
         })();
         await Promise.race([emitAllP, allowedP]);
         const settled = await allowedP;
-        for (const c of aliveCtxs) {
-            void openByCtx
-                .get(c)
-                .then(({ delivered }) => {
-                if (!delivered)
-                    return undefined;
-                if (c.emitCard !== undefined) {
-                    if (cardFrame === undefined)
-                        return undefined;
-                    return c.emitCard(buildApprovalCompleteFrame({
-                        askId: cardFrame.askId,
-                        taskId: cardFrame.taskId,
-                        approvalId: wireApprovalId,
-                        outcome: lastOutcome,
-                        ...(lastCause !== undefined ? { cause: lastCause } : {}),
-                        parked: parkRouted,
-                        nowMs: Date.now(),
-                    }), id);
-                }
-                return c.emit({
-                    type: "tool_approval_complete",
-                    approvalId: wireApprovalId,
-                    outcome: lastOutcome,
-                    ...(lastCause !== undefined ? { cause: lastCause } : {}),
-                    ...(parkRouted ? { parked: true } : {}),
-                });
-            })
-                .catch(() => undefined);
-        }
+        if (cardRace !== undefined && completeFrame !== undefined)
+            cardRace.close(completeFrame);
+        legacyRace?.close({
+            type: "tool_approval_complete",
+            approvalId: wireApprovalId,
+            outcome: lastOutcome,
+            ...(lastCause !== undefined ? { cause: lastCause } : {}),
+            ...(parkRouted ? { parked: true } : {}),
+        });
         if (emitFailed)
             return this.unattendedOutcome({ arm: "emit_failed", taskId: origin.taskId, ...(origin.owner !== null ? { owner: origin.owner } : {}), toolName: req.toolName, reachability });
         if (windowRouteUnavailable)
@@ -2133,7 +2055,7 @@ export class ToolApprovalCoordinator {
         const entry = this.liveEntryFor(id);
         if (entry?.adopted === true)
             return this.respondByRow(entry, id, principal, parsed, httpReq);
-        if (entry !== undefined && askOwnerAdmits(entry.owner, principal))
+        if (entry !== undefined && askOwnerAdmitsAnswer(entry.owner, principal))
             return this.answerRegistration(entry, entry.owner, id, principal, parsed, httpReq);
         if (entry !== undefined && this.registrationHasRow(entry))
             return this.respondByRow(entry, id, principal, parsed, httpReq);
@@ -2145,10 +2067,10 @@ export class ToolApprovalCoordinator {
     async respondByRow(entry, id, principal, parsed, httpReq) {
         const store = this.askStore;
         if (!store)
-            return this.notPending();
-        const row = rowOrUnknown(await this.askRowFor(store, id, "getAsk(respond-by-row)"));
+            return this.askNotVisible();
+        const row = await this.askRowFollowingOwner(store, id, "getAsk(respond-by-row)");
         if (!askRowVisibleTo(row, principal))
-            return this.notPending(NOT_PENDING_UNKNOWN_CAUSE);
+            return this.askNotVisible();
         if (row.state !== "STREAM_PENDING")
             return this.dispatchRowTruth(row, id, parsed, httpReq, principal);
         return this.answerRegistration(entry, row.owner, id, principal, parsed, httpReq);
@@ -2240,31 +2162,27 @@ export class ToolApprovalCoordinator {
             }),
         };
     }
+    askNotVisible() {
+        return { status: 404, body: refusalBody({ errorCode: "not_found.ask", message: "no such approval ask (never existed, no longer kept, or not yours)" }) };
+    }
     readApproval(id, principal) {
         const entry = this.liveEntryFor(id);
         if (entry !== undefined && this.registrationHasRow(entry))
             return this.readByRow(entry, id, principal);
-        if (entry !== undefined && askOwnerAdmits(entry.owner, principal)) {
+        if (entry !== undefined && askOwnerAdmitsAnswer(entry.owner, principal)) {
             const body = { state: "pending", ...livePendingRowOf(entry) };
             return { status: 200, body };
         }
         const store = this.askStore;
         if (!store)
-            return this.notPending();
+            return this.askNotVisible();
         return this.readAskRowState(store, id, principal);
     }
     async readByRow(entry, id, principal) {
         const store = this.askStore;
         if (!store)
-            return this.notPending();
-        const read = await this.askRowFor(store, id, "getAsk(read-by-row)");
-        if (read.kind === "unreadable") {
-            if (entry.adopted === true || !askOwnerAdmits(entry.owner, principal))
-                return this.notPending(NOT_PENDING_UNKNOWN_CAUSE);
-            const body = { state: "pending", ...livePendingRowOf(entry) };
-            return { status: 200, body };
-        }
-        const row = rowOrUnknown(read);
+            return this.askNotVisible();
+        const row = await this.askRowFollowingOwner(store, id, "getAsk(read-by-row)");
         if (askRowVisibleTo(row, principal) && row.state === "STREAM_PENDING") {
             const body = { state: "pending", ...livePendingRowOf(entry) };
             return { status: 200, body };
@@ -2272,23 +2190,27 @@ export class ToolApprovalCoordinator {
         return this.readStateOfRow(row, principal);
     }
     async readAskRowState(store, id, principal) {
-        return this.readStateOfRow(rowOrUnknown(await this.askRowFor(store, id, "getAsk(read)")), principal);
+        return this.readStateOfRow(await this.askRowFor(store, id, "getAsk(read)"), principal);
     }
     async readParkedGate(row) {
         const gate = this.parkedGate;
         if (gate === undefined || row.gateToken === null)
-            return { kind: "open" };
+            return undefined;
         try {
             return await this.withStoreDeadline(gate({ gateToken: row.gateToken, gateBoundCallId: row.gateBoundCallId }), "readParkedGate", DURABLE_CONVERGE_READ_TIMEOUT_MS);
         }
         catch (err) {
             this.noteStoreError(err, "readParkedGate");
-            return { kind: "open" };
+            return undefined;
         }
     }
+    async openGateGeneration(row) {
+        const gate = await this.readParkedGate(row);
+        return gate?.kind === "open" ? gate.generation : undefined;
+    }
     async readStateOfRow(row, principal) {
         if (!askRowVisibleTo(row, principal))
-            return this.notPending(NOT_PENDING_UNKNOWN_CAUSE);
+            return this.askNotVisible();
         const projection = buildAskRowReadProjection(row, Date.now());
         let body;
         switch (row.state) {
@@ -2301,13 +2223,13 @@ export class ToolApprovalCoordinator {
             }
             case "PARKING":
             case "PARKED": {
-                const gate = row.state === "PARKED" ? await this.readParkedGate(row) : { kind: "open" };
+                const gate = row.state === "PARKED" ? await this.readParkedGate(row) : undefined;
+                if (gate === undefined || gate.kind === "open") {
+                    const parkSession = parkSessionOf(row);
+                    body = { state: "parked", ...projection, ...(parkSession !== undefined ? { decidePath: approvalDecidePath(parkSession) } : {}), ...(gate?.reopened !== undefined ? { reopened: gate.reopened } : {}) };
+                    break;
+                }
                 switch (gate.kind) {
-                    case "open": {
-                        const parkSession = parkSessionOf(row);
-                        body = { state: "parked", ...projection, ...(parkSession !== undefined ? { decidePath: approvalDecidePath(parkSession) } : {}), ...(gate.reopened !== undefined ? { reopened: gate.reopened } : {}) };
-                        break;
-                    }
                     case "decided":
                         body = { state: "decided", ...projection, decision: gate.decision, decidedAtMs: gate.decidedAtMs, ...(gate.decisionNote !== undefined ? { decisionNote: gate.decisionNote } : {}) };
                         break;
@@ -2350,11 +2272,11 @@ export class ToolApprovalCoordinator {
     respondLate(id, principal, parsed, httpReq) {
         const store = this.askStore;
         if (!store)
-            return this.notPending();
+            return this.askNotVisible();
         return this.dispatchLateByRow(store, id, parsed, httpReq, principal);
     }
-    watchPresentedCards(askIds, deliver) {
-        const watcher = { deliver, askIds: new Set() };
+    watchPresentedCards(askIds, deliver, connection) {
+        const watcher = { deliver, connection, askIds: new Set(), registrationsOnConnection: new Map() };
         for (const askId of askIds) {
             if (!this.pendingByAskId.has(askId))
                 continue;
@@ -2370,13 +2292,26 @@ export class ToolApprovalCoordinator {
             for (const askId of watcher.askIds)
                 this.dropPresentedCardWatcher(askId, watcher);
             watcher.askIds.clear();
+            watcher.registrationsOnConnection.clear();
         };
     }
+    notePresentedCardRegistration(askId, transport, acceptedLive) {
+        for (const watcher of this.presentedCardWatchers.get(askId) ?? []) {
+            if (watcher.connection() !== transport)
+                continue;
+            const opens = watcher.registrationsOnConnection.get(askId);
+            if (opens === undefined)
+                watcher.registrationsOnConnection.set(askId, [acceptedLive]);
+            else
+                opens.push(acceptedLive);
+        }
+    }
     dropPresentedCardWatcher(askId, watcher) {
         const set = this.presentedCardWatchers.get(askId);
         if (set === undefined)
             return;
         set.delete(watcher);
+        watcher.registrationsOnConnection.delete(askId);
         if (set.size === 0)
             this.presentedCardWatchers.delete(askId);
     }
@@ -2387,12 +2322,20 @@ export class ToolApprovalCoordinator {
         this.presentedCardWatchers.delete(askId);
         for (const watcher of set) {
             watcher.askIds.delete(askId);
-            try {
-                watcher.deliver(frame);
-            }
-            catch (err) {
-                defaultLogger.warn("presented-card completion notice could not be written to its connection", { askId, error: err instanceof Error ? err.message : String(err) });
-            }
+            const opens = watcher.registrationsOnConnection.get(askId) ?? [];
+            watcher.registrationsOnConnection.delete(askId);
+            const write = () => {
+                try {
+                    watcher.deliver(frame);
+                }
+                catch (err) {
+                    defaultLogger.warn("presented-card completion notice could not be written to its connection", { askId, error: err instanceof Error ? err.message : String(err) });
+                }
+            };
+            if (opens.length === 0)
+                write();
+            else
+                void Promise.all(opens).then((accepted) => (accepted.includes(true) ? undefined : write()));
         }
     }
     liveEntryFor(id) {
@@ -2404,24 +2347,27 @@ export class ToolApprovalCoordinator {
         return undefined;
     }
     async dispatchLateByRow(store, id, parsed, httpReq, principal) {
-        return this.dispatchRowTruth(rowOrUnknown(await this.askRowFor(store, id, "getAsk(respond-late)")), id, parsed, httpReq, principal);
+        return this.dispatchRowTruth(await this.askRowFor(store, id, "getAsk(respond-late)"), id, parsed, httpReq, principal);
     }
     async askRowFor(store, id, label) {
         try {
-            const row = await this.withStoreDeadline(store.getAsk(id), label, DURABLE_CONVERGE_READ_TIMEOUT_MS);
-            return row === null ? { kind: "absent" } : { kind: "row", row };
+            return await this.withStoreDeadline(store.getAsk(id), label, DURABLE_CONVERGE_READ_TIMEOUT_MS);
         }
         catch (err) {
             this.noteStoreError(err, label);
-            return { kind: "unreadable" };
+            return null;
         }
     }
+    async askRowFollowingOwner(store, id, label) {
+        const readSeq = this.nextRowReadSeq();
+        const row = await this.askRowFor(store, id, label);
+        if (row?.state === "STREAM_PENDING")
+            this.followRowOwner(row.askId, row.owner, readSeq);
+        return row;
+    }
     async dispatchRowTruth(row, id, parsed, httpReq, principal) {
         if (!askRowVisibleTo(row, principal))
-            return this.notPending(NOT_PENDING_UNKNOWN_CAUSE);
-        const receipt = this.lookupParkRedemption(row.askId);
-        if (receipt?.redeemed !== undefined)
-            return this.replayRedeemReceipt(id, receipt, row, receipt.redeemed, parsed);
+            return this.askNotVisible();
         switch (row.state) {
             case "DECIDED":
                 return this.replayDecidedAsk(id, row, parsed);
@@ -2494,14 +2440,17 @@ export class ToolApprovalCoordinator {
             defaultLogger.error("tool approval parked row carries no gate token — nothing to redeem", { askId: row.askId });
             return this.notPending();
         }
+        const openGenerationNow = this.lookupParkRedemption(row.askId) !== undefined ? await this.openGateGeneration(row) : undefined;
         const prior = this.lookupParkRedemption(row.askId);
-        if (prior?.redeemed !== undefined)
+        if (prior?.redeemed !== undefined && receiptAnswersNow(prior.redeemed.gateGeneration, openGenerationNow))
             return this.replayRedeemReceipt(id, prior, row, prior.redeemed, parsed);
         if (prior?.inflight !== undefined) {
             const shared = await prior.inflight;
             if (shared.status < 200 || shared.status >= 300)
                 return shared;
-            return this.replayRedeemReceipt(id, prior, row, { decision: shared.decision, body: shared.body, ...(shared.rule?.terminal === true ? { rule: shared.rule.body } : {}) }, parsed);
+            if (!receiptAnswersNow(shared.gateGeneration, openGenerationNow))
+                return this.redeemParkedAsk(id, row, parsed, httpReq, principal);
+            return this.replayRedeemReceipt(id, prior, row, { decision: shared.decision, body: shared.body, gateGeneration: shared.gateGeneration, ...(shared.rule?.terminal === true ? { rule: shared.rule.body } : {}) }, parsed);
         }
         const admission = this.parkRedemptionAdmission(row.owner);
         if (admission !== undefined)
@@ -2550,7 +2499,7 @@ export class ToolApprovalCoordinator {
         }
         const rule = out.rule;
         if (this.retainParkRedemption(row.askId, memo))
-            memo.redeemed = { decision, body: out.body, ...(rule?.terminal === true ? { rule: rule.body } : {}) };
+            memo.redeemed = { decision, body: out.body, gateGeneration: out.gateGeneration, ...(rule?.terminal === true ? { rule: rule.body } : {}) };
         return {
             status: out.status,
             body: {
@@ -2779,17 +2728,33 @@ export class ToolApprovalCoordinator {
             this.noteStoreError(err, "decideAsk");
             ruleEligibility.eligible = false;
             try {
+                const confirmSeq = this.nextRowReadSeq();
                 const row = await this.withStoreDeadline(askStore.getAsk(askId), "getAsk(decideAsk-confirm)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
-                if (row !== null && !askRowCarriesOwner(row, owner))
+                if (row?.state === "STREAM_PENDING")
+                    this.followRowOwner(askId, row.owner, confirmSeq);
+                if (row === null || !askRowCarriesOwner(row, owner))
                     return { lost: true, row: null };
-                if (row?.state === "DECIDED" && row.decision === (parsed.value === "deny" ? "deny" : "approve")) {
+                if (row.state === "DECIDED" && row.decision === (parsed.value === "deny" ? "deny" : "approve")) {
                     winnerRow = row;
                     ambiguousConfirmedRow = row;
                     noteLanded = noteLandedOnRow(parsed.note, row.decisionNote);
                 }
+                else if (row.state !== "STREAM_PENDING") {
+                    return { lost: true, row };
+                }
             }
             catch (confirmErr) {
                 this.noteStoreError(confirmErr, "getAsk(decideAsk-confirm)");
+                return {
+                    lost: false,
+                    result: {
+                        status: 500,
+                        body: refusalBody({
+                            errorCode: "internal.error",
+                            message: "the approval store failed while recording this answer and could not be read back, so whether the answer was recorded is unknown — retry: a retry returns the recorded answer if it was recorded, or records it if it was not",
+                        }),
+                    },
+                };
             }
         }
         const wantAllowed = parsed.value !== "deny";
@@ -2831,15 +2796,20 @@ export class ToolApprovalCoordinator {
                 throw new Error(`unhandled standing-answer home: ${String(unhandled)}`);
             }
         }
-        if (parsed.value === "allow_session")
-            rememberApplied = Boolean(entry.sessionId) && grantable;
-        if (parsed.value === "allow_session" && entry.sessionId && grantable) {
-            if (this.allowAllSessions.size >= MAX_ALLOW_SESSIONS) {
-                const oldest = this.allowAllSessions.values().next().value;
-                if (oldest !== undefined)
-                    this.allowAllSessions.delete(oldest);
+        if (parsed.value === "allow_session") {
+            const grantKey = grantable ? sessionAllowKey(judgedOwner, entry.sessionId, entry.incarnation, sessionAllowCategory(entry.toolName), entry.grantBinding) : undefined;
+            rememberApplied = grantKey !== undefined;
+            if (grantKey !== undefined) {
+                if (this.allowAllSessions.size >= MAX_ALLOW_SESSIONS) {
+                    const oldest = this.allowAllSessions.values().next().value;
+                    if (oldest !== undefined)
+                        this.allowAllSessions.delete(oldest);
+                }
+                this.allowAllSessions.add(grantKey);
+            }
+            else if (grantable && entry.sessionId) {
+                defaultLogger.warn("session_grant_refused_occupant_unreadable", { sessionId: entry.sessionId, toolName: entry.toolName });
             }
-            this.allowAllSessions.add(sessionAllowKey(judgedOwner, entry.sessionId, sessionAllowCategory(entry.toolName), entry.grantBinding));
         }
         const allowed = parsed.value !== "deny";
         const settleArgs = opts?.settleOutcome !== undefined
@@ -2939,6 +2909,7 @@ export class ToolApprovalCoordinator {
             forceParkNow: release,
             settleParkRoute: (cause) => leave({ outcome: SETTLE_OUTCOME.EXPIRED, cause, parked: this.unattendedRoutesToPark }),
             owner: row.owner,
+            ownerReadSeq: this.rowReadSeq,
             executionLane: row.executionLane,
             ...(row.sessionId !== row.taskId ? { sessionId: row.sessionId } : {}),
             ...(card.fromSubagent === true ? { originTaskId: row.sourceSessionId } : {}),
@@ -2972,10 +2943,42 @@ export class ToolApprovalCoordinator {
         for (const watcher of watchers)
             watcher.askIds.delete(askId);
     }
-    followAdoptedOwner(askId, owner) {
-        for (const e of this.pendingByAskId.get(askId) ?? [])
-            if (e.adopted === true)
-                e.owner = owner;
+    followRowOwner(askId, owner, readSeq) {
+        for (const e of this.pendingByAskId.get(askId) ?? []) {
+            if (e.ownerReadSeq >= readSeq)
+                continue;
+            e.owner = owner;
+            e.ownerReadSeq = readSeq;
+        }
+    }
+    rowReadSeq = 0;
+    nextRowReadSeq() {
+        this.rowReadSeq += 1;
+        return this.rowReadSeq;
+    }
+    async followRowOwners() {
+        const store = this.askStore;
+        const out = { read: 0, followed: 0, unreadable: 0 };
+        if (!store)
+            return out;
+        for (const askId of [...this.pendingByAskId.keys()]) {
+            out.read += 1;
+            const readSeq = this.nextRowReadSeq();
+            let row;
+            try {
+                row = await this.withStoreDeadline(store.getAsk(askId), "getAsk(follow-row-owners)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
+            }
+            catch (err) {
+                this.noteStoreError(err, "getAsk(follow-row-owners)");
+                out.unreadable += 1;
+                continue;
+            }
+            if (row?.state !== "STREAM_PENDING")
+                continue;
+            this.followRowOwner(askId, row.owner, readSeq);
+            out.followed += 1;
+        }
+        return out;
     }
     waitingRegistrationCount(askId) {
         let n = 0;
@@ -2984,18 +2987,29 @@ export class ToolApprovalCoordinator {
                 n += 1;
         return n;
     }
-    listLivePending(scope) {
-        const rows = [];
+    async listLivePending(scope) {
         const owner = scope === undefined ? undefined : ownerOfCheckpointScope(scope);
-        const seen = new Set();
-        for (const e of this.pending.values()) {
-            if (owner !== undefined && e.owner !== owner)
-                continue;
-            if (seen.has(e.approvalId))
-                continue;
-            seen.add(e.approvalId);
-            rows.push(livePendingRowOf(e));
-        }
+        const inScope = (rowOwner) => owner === undefined || rowOwner === owner;
+        const candidates = new Map();
+        for (const e of this.pending.values())
+            if (!candidates.has(e.approvalId))
+                candidates.set(e.approvalId, e);
+        const store = this.askStore;
+        const ids = [...candidates.keys()];
+        const listed = await Promise.all([...candidates.values()].map(async (entry) => {
+            if (store === undefined || !this.registrationHasRow(entry))
+                return inScope(entry.owner);
+            const ask = await this.askRowFollowingOwner(store, entry.askId, "getAsk(list-live)");
+            return ask?.state === "STREAM_PENDING" && inScope(ask.owner);
+        }));
+        const rows = [];
+        ids.forEach((id, i) => {
+            if (!listed[i])
+                return;
+            const current = this.liveEntryFor(id);
+            if (current !== undefined)
+                rows.push(livePendingRowOf(current));
+        });
         return rows;
     }
     hasLivePendingFromLeg(names) {
@@ -3051,6 +3065,7 @@ export class ToolApprovalCoordinator {
             else
                 this.adoptedPollOffset = adoptedStart + ++polledAdopted;
             let row;
+            const readSeq = this.nextRowReadSeq();
             try {
                 row = await this.withStoreDeadline(store.getAsk(askId), "getAsk(poll-suspended)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
             }
@@ -3063,7 +3078,7 @@ export class ToolApprovalCoordinator {
                 continue;
             }
             if (row.state === "STREAM_PENDING") {
-                this.followAdoptedOwner(askId, row.owner);
+                this.followRowOwner(askId, row.owner, readSeq);
                 continue;
             }
             if (this.editedDecisionInFlight(askId))