@sema-agent/client-core 0.105.0 → 0.106.0

package/dist/hitl/planReviewWire.js

@@ -2,22 +2,21 @@ import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionRes
 import { hostLog } from '../host.js';
 import { abortableSleep, settleWithinDeadline } from '../abortableSleep.js';
 import { clientHasVerbs, engineWireFor, noAnswerKindOf, sendOnce } from '../engineWireFor.js';
-import { engineCapTrue } from '../engineCapsCache.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
 import { decideFailureNote } from '../decideFailureNote.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { readThrownExtra, wireFailureTextsOf } from '../wireFailureShape.js';
 import { appendOwnElement, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, resumeContextUnavailableContent, resumeContextUnavailableFromError } from '../resumeRefusalCopy.js';
-import { REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
+import { APPROVAL_STALE, REQUEST_FIELD_CONFLICT } from '../engineErrorCodes.js';
 import { refusalDeliveryOf } from './decisionRefusal.js';
 import { directFailureVerdictOf, directSafetyStopOf } from './approvalResolution.js';
 import { __resetDecisionLedgerForTests, decisionInFlightOf, decisionKeyInFlight, decisionLedgerKeysOf, decisionOpsWithKey, decisionReadMark, dropDecisionOp, latestDecisionHandedMark, markLatestDecisionNotApplied, openDecisionOp, planDecisionKey, readMarkOf, settleDecisionOp, settleDecisionOpsOnGateLeft, } from './decisionLedger.js';
 import { denyReasonForWire, isPlanReviewModeAfter } from './hitlBridge.js';
 import { freshPlanReviewQuestionId, planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
 import { isPlanReviewPark, mintPlanReviewCardFacts, notePlanReviewCardIssued, pausedCheckpointIdOf, planReviewCardFactsFrom, planReviewFactsCurrent, registeredPlanReviewCardFacts, samePlanReviewCardFacts, unknownBody, _resetPlanReviewRunsForTest, } from '../planReviewCardFacts.js';
-import { planReviewAskAgainKey, planReviewCardNoteRef, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.js';
+import { planReviewAskAgainKey, planReviewCardNoteRef, planReviewDecisionReasonRef, planReviewUnreadableNoteRef, takePlanReviewFacts, _resetPlanReviewFactsFlightsForTest, } from './planReviewCard.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage, DATA_FACE_LANGUAGE } from '../i18n/translate.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
@@ -183,6 +182,7 @@ const armedPlanReviews = new Map();
 const offeredModeByQuestionId = new Map();
 const OFFERED_MODE_LEDGER_MAX = 64;
 export function _resetArmedPlanReviewsForTest() {
+    engineRefusedGateIds.clear();
     armedPlanReviews.clear();
     offeredModeByQuestionId.clear();
     planReviewDismissalsByKey.clear();
@@ -519,7 +519,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             const cardDelivery = cardReason !== undefined ? { ...delivery, reason: cardReason } : delivery;
             notePlanReviewAnswered(questionId);
             hostLog('debug', `planReviewWire: arm responder delivering ${decided} for task ${taskId} (path=arm)`);
-            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, gateBefore, facts);
+            void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts);
             return { ok: true };
         };
         unregister = registerLocalQuestionResponder(questionId, responder);
@@ -534,7 +534,7 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
     switch (effect) {
         case 'took_effect':
             return decision === 'approve'
-                ? `Use TaskOutput("${taskId}") if you need the resumed task's full output, then give the user a brief report of what was done.`
+                ? `The result of the resumed task ${JSON.stringify(taskId)} arrives in its completion notification; when it arrives, give the user a brief report of what was done.`
                 : 'Briefly acknowledge to the user that the plan was rejected and continue planning.';
         case 'advanced':
             return `Tell the user the ${decision} went through and that another approval is now waiting for them; do not report the task as finished.`;
@@ -543,9 +543,9 @@ export function planReviewOutcomeTail(taskId, decision, effect, cause) {
         case 'not_sent':
             return `Nothing was sent to the engine. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; the plan is still waiting for a decision.`;
         case 'not_applied':
-            return `The ${decision} did not take effect. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; check the task's current state with TaskOutput("${taskId}") before saying anything about the plan.`;
+            return `The ${decision} did not take effect. Do not tell the user the plan was ${decision === 'approve' ? 'approved' : 'rejected'}; find out where task ${JSON.stringify(taskId)} stands (the background task list or its next notification shows it) before saying anything about the plan.`;
         case 'unconfirmed':
-            return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; TaskOutput("${taskId}") shows where the task stands.`;
+            return `Do not state the result as fact: tell the user the ${decision} was submitted but its effect could not be confirmed; the background task list or the next notification of task ${JSON.stringify(taskId)} shows where it stands.`;
     }
 }
 function planReviewDecisionTimedOutOutcome(decision) {
@@ -632,12 +632,39 @@ export function latestPlanReviewDecisionMark(taskId) {
 export function __resetPlanReviewDecisionLatchForTests() {
     __resetDecisionLedgerForTests('plan_review');
 }
+const engineRefusedGateIds = new Set();
+const ENGINE_REFUSED_GATE_IDS_MAX = 64;
+function noteEngineRefusedGate(id) {
+    if (engineRefusedGateIds.has(id))
+        return;
+    engineRefusedGateIds.add(id);
+    while (engineRefusedGateIds.size > ENGINE_REFUSED_GATE_IDS_MAX) {
+        const oldest = engineRefusedGateIds.values().next();
+        if (oldest.done === true)
+            break;
+        engineRefusedGateIds.delete(oldest.value);
+    }
+}
+function planReviewDecisionReasonSegment(reason, card) {
+    if (reason === undefined)
+        return '';
+    try {
+        return ` ${renderMessage(planReviewDecisionReasonRef(reason, card), DATA_FACE_LANGUAGE)}`;
+    }
+    catch {
+        return '';
+    }
+}
 export async function decidePlanReview(taskId, decision, permissionModeAfter, opts) {
-    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, parkedGateIdentityOf(opts));
+    return decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, decisionCardOf(taskId, opts));
 }
-function parkedGateIdentityOf(opts) {
+function decisionCardOf(taskId, opts) {
     try {
-        return opts !== null && typeof opts === 'object' ? pausedCheckpointIdOf(opts.parkedResult) : undefined;
+        if (opts === null || typeof opts !== 'object')
+            return undefined;
+        const raw = readOwnDataValue(opts, 'card');
+        const facts = raw !== null && typeof raw === 'object' ? planReviewCardFactsFrom(raw) : undefined;
+        return facts !== undefined && facts.taskId === taskId ? facts : undefined;
     }
     catch {
         return undefined;
@@ -691,7 +718,7 @@ function askAgainReasonOf(card, opts) {
         return renderMessage(msg('approval.planReview.askAgain.unknown'), DATA_FACE_LANGUAGE);
     }
 }
-async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, gateBefore, card) {
+async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts, card) {
     if (typeof taskId === 'string' && planReviewOpsOf(taskId).some((op) => op.phase === 'posting')) {
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
@@ -724,7 +751,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     try {
         const wireDecision = decision === 'ask_again' ? 'reject' : decision;
         const wireOpts = decision === 'ask_again' ? { ...opts, reason: askAgainReasonOf(card, opts) } : opts;
-        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, gateBefore, decision);
+        await decidePlanReviewInner(taskId, wireDecision, permissionModeAfter, dispatchNo, releaseLatch, settle, wireOpts, card, decision);
     }
     finally {
         releaseLatch();
@@ -745,8 +772,11 @@ function planReviewClientsFor(resolved) {
         repull: () => resolved.make({ timeoutMs: 15_000 }),
     };
 }
-async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, gateBefore, semanticDecision) {
+async function decidePlanReviewInner(taskId, decision, permissionModeAfter, dispatchNo, releaseLatch, settle, opts, card, semanticDecision) {
     let outcome;
+    let decisionReason;
+    const gateBefore = card?.checkpointId;
+    const approvalWithheld = decision !== 'approve' ? undefined : card === undefined ? 'card_missing' : card.body.kind !== 'shown' || card.checkpointId === undefined ? 'card_withholds' : undefined;
     let effect = 'unconfirmed';
     let stillParkedCause;
     let statusSeen;
@@ -758,6 +788,12 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         effect = 'not_sent';
         outcome = `The plan_review ${decision} could NOT be sent: the post-approval permission mode given with it is not valid (it must be "default" or "acceptEdits"). Tell the user plainly that the decision did not go through; the plan is still waiting.`;
     }
+    else if (approvalWithheld !== undefined) {
+        hostLog('debug', `planReviewWire: not-sent decision=${decision} reason=${approvalWithheld}`);
+        effect = 'not_sent';
+        decisionReason = approvalWithheld;
+        outcome = renderMessage(msg('approval.planReview.decision.notSent', { decision }), DATA_FACE_LANGUAGE);
+    }
     else if (resolved.kind === 'no-target') {
         hostLog('error', `planReviewWire: ${decision} NOT sent — engineWireTarget() unavailable`);
         effect = 'not_sent';
@@ -777,11 +813,24 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
         }
         else {
             const client = clients.decide;
+            const checkpointId = gateBefore !== undefined && !engineRefusedGateIds.has(gateBefore) ? gateBefore : undefined;
+            const repullRow = async () => {
+                const probe = clients.repull();
+                if (!probe)
+                    return undefined;
+                if (wire !== undefined) {
+                    const got = await settleWithinDeadline(PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS, (signal) => probe.runs.get(taskId, { signal }));
+                    if (got.kind === 'error')
+                        throw new Error(got.detail);
+                    if (got.kind === 'deadline')
+                        throw new Error(`post-decide status re-pull passed its ${PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS} ms deadline`);
+                    return got.value;
+                }
+                return (await probe.runs.get(taskId));
+            };
             try {
                 const mode = isPlanReviewModeAfter(permissionModeAfter) ? permissionModeAfter : undefined;
                 const reason = denyReasonForWire(opts?.reason, `plan-review ${taskId}`);
-                const capsBase = resolved.kind === 'target' ? resolved.target.baseUrl : resolved.capsBaseUrl;
-                const checkpointId = gateBefore !== undefined && engineCapTrue(capsBase, 'planReviewCheckpointId') ? gateBefore : undefined;
                 const reqBody = { decision };
                 if (reason !== undefined)
                     reqBody.reason = reason;
@@ -812,20 +861,8 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                 let gateAfter;
                 let gateKindAfter;
                 try {
-                    const probe = clients.repull();
-                    if (probe) {
-                        let post;
-                        if (wire !== undefined) {
-                            const got = await settleWithinDeadline(PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS, (signal) => probe.runs.get(taskId, { signal }));
-                            if (got.kind === 'error')
-                                throw new Error(got.detail);
-                            if (got.kind === 'deadline')
-                                throw new Error(`post-decide status re-pull passed its ${PLAN_REVIEW_INJECTED_REPULL_TIMEOUT_MS} ms deadline`);
-                            post = got.value;
-                        }
-                        else {
-                            post = (await probe.runs.get(taskId));
-                        }
+                    const post = await repullRow();
+                    if (post !== undefined) {
                         postStatus = bodyWordOf(post, 'status');
                         gateAfter = pausedCheckpointIdOf(post?.result);
                         gateKindAfter = pausedGateKindOf(post?.result);
@@ -898,6 +935,36 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                         `This ${decision} was not applied: the engine no longer has a pending plan review for this task — an earlier decision most likely already went through (or the review expired). ` +
                             'This is NOT a rejection of the plan and NOT a failure of the task; the answer just given simply had nothing left to act on.';
                 }
+                else if (status === 409 && refusedCode === APPROVAL_STALE) {
+                    let untrusted = false;
+                    if (checkpointId !== undefined) {
+                        const bag = readThrownExtra(e);
+                        const noCurrentPending = bag.state === 'object' &&
+                            (() => {
+                                try {
+                                    return Object.getOwnPropertyDescriptor(bag.value, 'currentPending') === undefined;
+                                }
+                                catch {
+                                    return false;
+                                }
+                            })();
+                        if (noCurrentPending) {
+                            try {
+                                const row = await repullRow();
+                                untrusted = row !== undefined && pausedCheckpointIdOf(row?.result) === checkpointId;
+                            }
+                            catch {
+                                untrusted = false;
+                            }
+                        }
+                    }
+                    if (untrusted && checkpointId !== undefined)
+                        noteEngineRefusedGate(checkpointId);
+                    hostLog('debug', `planReviewWire: approval-stale decision=${decision} reason=${untrusted ? 'gate_untrusted' : 'gate_moved'}`);
+                    effect = 'not_applied';
+                    decisionReason = untrusted ? 'gate_untrusted' : 'gate_moved';
+                    outcome = renderMessage(msg('approval.planReview.decision.refused', { decision }), DATA_FACE_LANGUAGE);
+                }
                 else if (checkpointUnsupportedVersionFromError(e) !== null) {
                     const cu = checkpointUnsupportedVersionFromError(e);
                     hostLog('debug', `planReviewWire: ${decision} → 409 checkpoint.unsupported_version (the server cannot continue this parked review in its stored form; still pending)`);
@@ -939,6 +1006,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
             }
         }
     }
+    outcome = `${outcome}${planReviewDecisionReasonSegment(decisionReason, card)}`;
     const tail = planReviewOutcomeTail(taskId, decision, effect, stillParkedCause);
     const prompt = `<plan-review-outcome>\n${outcome}\n${tail}\n</plan-review-outcome>`;
     const onOutcome = opts?.onOutcome;
@@ -1087,10 +1155,10 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         ? { ...(opts.wire !== undefined ? { wire: opts.wire } : {}), ...(opts.onOutcome !== undefined ? { onOutcome: opts.onOutcome } : {}) }
         : undefined;
     const deliver = opts?.deliverDecision ??
-        ((tid, decision, reason) => {
+        ((tid, decision, reason, card) => {
             hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
             const withReason = reason === undefined ? delivery : { ...delivery, reason };
-            void decidePlanReviewFor(tid, decision, undefined, withReason, parkedGateIdentityOf(withReason), facts);
+            void decidePlanReviewFor(tid, decision, undefined, withReason, card);
         });
     const activeKey = `${sessionKey}\u0000${canonicalId}`;
     let unregister = () => { };
@@ -1116,10 +1184,7 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         notePlanReviewDecisiveAnswerFor(sessionKey, taskId);
         notePlanReviewAnsweredFor(sessionKey, questionId);
         try {
-            if (cardReason === undefined)
-                await deliver(taskId, decided);
-            else
-                await deliver(taskId, decided, cardReason);
+            await deliver(taskId, decided, cardReason, facts);
         }
         catch (e) {
             hostLog('error', `planReviewWire: reopen decision delivery threw for task ${taskId}: ${String(e)}`);

package/dist/hitl/sessionAllowRoute.d.ts

@@ -0,0 +1,2 @@
+export type SessionAllowLeg = 'frame' | 'v1' | 'generic';
+export declare function sessionAllowCarried(leg: SessionAllowLeg, approvalId: unknown): boolean;

package/dist/hitl/sessionAllowRoute.js

@@ -0,0 +1,7 @@
+export function sessionAllowCarried(leg, approvalId) {
+    if (leg === 'frame')
+        return true;
+    if (leg === 'v1')
+        return typeof approvalId === 'string' && approvalId !== '';
+    return false;
+}

package/dist/hitl/sessionPolicyWire.d.ts

@@ -128,17 +128,11 @@ export interface SessionPolicyInertEntryRefusal {
 export declare function tightenSessionPolicy(facade: SessionPolicyFacade, req: SessionPolicyTightenRequest, opts?: {
     signal?: AbortSignal;
 }): Promise<SessionPolicyTightenOutcome>;
-export interface SessionPolicyTightenFacts {
-    readonly agentsStartedBeforeFirstRule?: number | undefined;
-    readonly workflowsRunning?: number | undefined;
-    readonly untrackedBackgroundItems?: number | undefined;
-    readonly inFlightUnreadable?: true | undefined;
-}
 export interface SessionPolicyDeploymentFacts {
     readonly operator?: 'present' | 'absent';
     readonly identityAttach?: 'available' | 'unavailable';
 }
-export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome, lang?: UiLanguage, facts?: SessionPolicyTightenFacts, deployment?: SessionPolicyDeploymentFacts): string;
+export declare function sessionPolicyTightenNotice(outcome: SessionPolicyTightenOutcome, lang?: UiLanguage, deployment?: SessionPolicyDeploymentFacts): string;
 export declare function sessionPolicyReadNotice(outcome: Exclude<SessionPolicyReadOutcome, {
     kind: 'present';
 }> | {

package/dist/hitl/sessionPolicyWire.js

@@ -414,29 +414,6 @@ export async function tightenSessionPolicy(facade, req, opts) {
     return { kind: 'conflict', rev: second.retryAtRev };
 }
 const earlierGrammarNote = (lang) => renderMessage(msg('rules.sessionPolicy.tighten.earlierGrammar'), lang);
-function factSlot(facts, key) {
-    try {
-        return ownRead(facts, key);
-    }
-    catch {
-        return undefined;
-    }
-}
-function factCount(facts, key) {
-    const n = factSlot(facts, key);
-    return typeof n === 'number' && Number.isSafeInteger(n) && n >= 1 ? n : undefined;
-}
-function firstRuleWorkFactsOf(facts) {
-    const none = { agents: undefined, workflows: undefined, untracked: undefined, unreadable: false };
-    if (typeof facts !== 'object' || facts === null)
-        return none;
-    return {
-        agents: factCount(facts, 'agentsStartedBeforeFirstRule'),
-        workflows: factCount(facts, 'workflowsRunning'),
-        untracked: factCount(facts, 'untrackedBackgroundItems'),
-        unreadable: factSlot(facts, 'inFlightUnreadable') === true,
-    };
-}
 function deploymentHasNoOperator(d) {
     try {
         return typeof d === 'object' && d !== null && ownRead(d, 'operator') === 'absent';
@@ -453,28 +430,11 @@ function deploymentHasNoIdentity(d) {
         return false;
     }
 }
-export function sessionPolicyTightenNotice(outcome, lang, facts, deployment) {
+export function sessionPolicyTightenNotice(outcome, lang, deployment) {
     const say = (key, params) => renderMessage(msg(key, params), lang);
     switch (outcome.kind) {
-        case 'written': {
-            const head = say('rules.sessionPolicy.tighten.written', { rev: outcome.rev });
-            const w = firstRuleWorkFactsOf(facts);
-            const unseen = msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.unseen');
-            if (w.unreadable)
-                return `${head} ${renderMessage(msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.unreadable'), lang)} ${renderMessage(unseen, lang)}`;
-            const parts = [];
-            if (w.agents !== undefined)
-                appendOwnElement(parts, msg(w.agents === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.agents.many', { n: w.agents }));
-            if (w.workflows !== undefined)
-                appendOwnElement(parts, msg(w.workflows === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.workflows.many', { n: w.workflows }));
-            if (w.untracked !== undefined)
-                appendOwnElement(parts, msg(w.untracked === 1 ? 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.one' : 'rules.sessionPolicy.tighten.writtenBeforeFirstRule.untracked.many', { n: w.untracked }));
-            const [p0, p1, p2] = parts;
-            if (p0 === undefined)
-                return head;
-            const list = p1 === undefined ? p0 : p2 === undefined ? msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.two', { a: p0, b: p1 }) : msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.list.three', { a: p0, b: p1, c: p2 });
-            return `${head} ${renderMessage(msg('rules.sessionPolicy.tighten.writtenBeforeFirstRule.counts', { list }), lang)} ${renderMessage(unseen, lang)}`;
-        }
+        case 'written':
+            return say('rules.sessionPolicy.tighten.written', { rev: outcome.rev });
         case 'conflict':
             return say('rules.sessionPolicy.tighten.conflict');
         case 'loosen_forbidden':

package/dist/hitl/subagentSource.d.ts

@@ -0,0 +1 @@
+export declare function subagentSourceSessionOf(carrier: object | null | undefined): string | undefined;

package/dist/hitl/subagentSource.js

@@ -0,0 +1,13 @@
+import { slotReadOf } from '../wireFailureShape.js';
+const nonEmpty = (v) => (typeof v === 'string' && v !== '' ? v : undefined);
+export function subagentSourceSessionOf(carrier) {
+    if (typeof carrier !== 'object' || carrier === null)
+        return undefined;
+    const current = slotReadOf(carrier, 'sourceSessionId');
+    if (current.presence === 'present')
+        return nonEmpty(current.value);
+    if (current.presence !== 'absent')
+        return undefined;
+    const retired = slotReadOf(carrier, 'sourceTaskId');
+    return retired.presence === 'present' ? nonEmpty(retired.value) : undefined;
+}

package/dist/hitl/toolApprovalWire.d.ts

@@ -163,7 +163,7 @@ export declare function approvalCardPortFor(sessionKey: string): ApprovalCardPor
 export declare function __resetSettledApprovalsForTests(): void;
 export declare function _resetApprovalCardPortForTest(): void;
 export declare function surfaceApprovalCard(req: ApprovalCardRequest): Promise<ApprovalCardDecision>;
-declare const REMEMBER_REFUSAL_CODES: readonly ["remember_not_in_proof", "remember_requires_binding", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported"];
+declare const REMEMBER_REFUSAL_CODES: readonly ["remember_not_in_proof", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported"];
 export type RememberRefusalCode = (typeof REMEMBER_REFUSAL_CODES)[number];
 export declare function rememberRefusalOf(error: unknown): RememberRefusalCode | undefined;
 export declare function surfaceFsApprovalAndDecide(deps: FsApprovalWireDeps, taskId: string, argsByCall: Map<string, unknown>, signal?: AbortSignal, parkGatedCallId?: string, parkToolName?: string): Promise<ApprovalResolution>;
@@ -179,7 +179,7 @@ export interface ReadRootCandidateView {
     covers?: 'exact';
 }
 export type ToolApprovalDelegation = ApprovalCardDelegation;
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "approvalCard", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrantAbsence", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause", "requestedBy"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "sourceSessionId", "agentId", "askReasons", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "approvalCard", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrantAbsence", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause", "requestedBy"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;
@@ -283,6 +283,7 @@ export interface ApprovalCardFrameFactsOptions {
     readonly argsUnavailable?: true;
 }
 export declare function approvalCardFactsOfV1(card: object | null | undefined): Readonly<ApprovalCardV1Facts> | undefined;
+export declare function approvalCardFactsOfV1Frame(frame: object | null | undefined): Readonly<ApprovalCardFacts> | undefined;
 export declare function approvalCardFactsOfFrame(frame: object | null | undefined, opts?: ApprovalCardFrameFactsOptions | null): Readonly<ApprovalCardFacts> | undefined;
 export declare function approvalCardFactsOfGeneric(card: object | null | undefined): Readonly<ApprovalCardFacts> | undefined;
 export interface ToolApprovalFrameLaneOpts {