@sema-agent/client-core 0.83.3 → 0.83.4

package/dist/hitl/planReviewWire.js

@@ -1,5 +1,6 @@
 import { publishQuestionFrame, publishQuestionFrameFor, registerLocalQuestionResponder, unregisterLocalQuestionResponder, hasLocalQuestionResponder, hasQuestionOverlayFor, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
+import { abortableSleep } from '../abortableSleep.js';
 import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
@@ -7,9 +8,9 @@ import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTria
 import { decideFailureNote } from '../decideFailureNote.js';
 import { isPlanReviewModeAfter } from './hitlBridge.js';
 import { engineCapString } from '../engineCapsCache.js';
-import { planReviewQuestionId, REOPEN_ID_TAIL } from './gateIdentity.js';
+import { planReviewQuestionId, REOPEN_ID_TAIL, taskIdFromPlanReviewQuestionId } from './gateIdentity.js';
 import { notePlanReviewAnswered, notePlanReviewAnsweredFor, planReviewArmedKeyFor, registerArmedGateFor, waitForGateArmedFor, wasGateArmedFor, } from './armedGateRegistry.js';
-import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { PLAN_REVIEW_GATE_KIND } from '../adapter/activeRunSelfHeal.js';
 import { readRunTerminal, runTerminalGateKind } from '../runTerminal.js';
 const PLAN_REVIEW_RESUME_TIMEOUT_MS = 6 * 60 * 60_000;
@@ -84,6 +85,13 @@ function notePlanReviewAnsweredIfDecisiveFor(sessionKey, questionId, answer) {
     if (planReviewDecisionFromAnswer(answer ?? { answers: [] }, ALL_KNOWN_LABELS) === 'dismissed')
         return;
     notePlanReviewAnsweredFor(sessionKey, questionId);
+    const taskId = typeof questionId === 'string' ? taskIdFromPlanReviewQuestionId(questionId) : undefined;
+    if (taskId === undefined)
+        return;
+    const current = dismissalEntryFor(sessionKey, taskId);
+    if (current?.kind === 'dismissed' && current.questionId === questionId)
+        return;
+    notePlanReviewDecisiveAnswerFor(sessionKey, taskId);
 }
 export function isPlanReviewPark(result) {
     const read = readRunTerminal(result);
@@ -99,6 +107,93 @@ const offerModeAfterByTask = new Map();
 export function _resetArmedPlanReviewsForTest() {
     armedPlanReviewTaskIds.clear();
     offerModeAfterByTask.clear();
+    planReviewDismissalsByKey.clear();
+}
+const ON_SCREEN = Promise.resolve(true);
+const planReviewDismissalsByKey = createSessionSlot();
+const MAX_DISMISSAL_ENTRIES_PER_SESSION = 32;
+const GATE_INSTANCE_READ_WAIT_MS = 1_500;
+function dismissalEntryFor(sessionKey, taskId) {
+    return planReviewDismissalsByKey.get(sessionKey)?.get(taskId);
+}
+function putDismissalEntry(sessionKey, taskId, entry) {
+    let ledger = planReviewDismissalsByKey.get(sessionKey);
+    if (ledger === undefined) {
+        ledger = new Map();
+        planReviewDismissalsByKey.set(sessionKey, ledger);
+    }
+    ledger.delete(taskId);
+    ledger.set(taskId, entry);
+    while (ledger.size > MAX_DISMISSAL_ENTRIES_PER_SESSION) {
+        const oldest = ledger.keys().next();
+        if (oldest.done === true)
+            break;
+        ledger.delete(oldest.value);
+    }
+}
+function planReviewUserDismissalMarkFor(sessionKey, taskId) {
+    const entry = dismissalEntryFor(sessionKey, taskId);
+    return entry?.kind === 'dismissed' ? entry : undefined;
+}
+function startGateInstanceRead(reader, taskId) {
+    if (typeof reader !== 'function')
+        return null;
+    let raw;
+    try {
+        raw = reader(taskId);
+    }
+    catch {
+        return null;
+    }
+    return Promise.resolve(raw).then((v) => {
+        try {
+            return v instanceof Set ? new Set(v) : null;
+        }
+        catch {
+            return null;
+        }
+    }, () => null);
+}
+async function boundedGateInstanceRead(p) {
+    if (p === null)
+        return null;
+    const ac = new AbortController();
+    try {
+        return await Promise.race([
+            p.then((v) => v, () => null),
+            abortableSleep(GATE_INSTANCE_READ_WAIT_MS, ac.signal).then(() => null),
+        ]);
+    }
+    finally {
+        ac.abort();
+    }
+}
+function notePlanReviewUserDismissalFor(sessionKey, taskId, reader, questionId) {
+    try {
+        putDismissalEntry(sessionKey, taskId, { kind: 'dismissed', closedGates: startGateInstanceRead(reader, taskId), questionId });
+    }
+    catch (err) {
+        hostLog('debug', `planReviewWire: could not record that the user closed the plan card for task ${taskId}: ${String(err)}`);
+    }
+}
+function notePlanReviewDecisiveAnswerFor(sessionKey, taskId) {
+    if (dismissalEntryFor(sessionKey, taskId) === undefined)
+        return;
+    putDismissalEntry(sessionKey, taskId, { kind: 'decided', closedGates: null });
+}
+function revokePlanReviewUserDismissal(sessionKey, taskId, mark) {
+    if (mark === undefined || mark.kind !== 'dismissed')
+        return;
+    if (dismissalEntryFor(sessionKey, taskId) === mark)
+        putDismissalEntry(sessionKey, taskId, { kind: 'reopened', closedGates: null, onScreen: ON_SCREEN });
+}
+function dropDismissalEntry(sessionKey, taskId, entry) {
+    const ledger = planReviewDismissalsByKey.get(sessionKey);
+    if (ledger?.get(taskId) === entry)
+        ledger.delete(taskId);
+}
+export function clearPlanReviewUserDismissals(sessionKey = DEFAULT_SESSION_KEY) {
+    planReviewDismissalsByKey.set(sessionKey, undefined);
 }
 const ARM_QUESTION = 'The plan is ready for review. Approve it and start the implementation?';
 const REOPEN_QUESTION = 'This plan is still waiting for your review — it is what is holding this session. Approve it and start the implementation?';
@@ -158,9 +253,11 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             const shown = planReviewCardOptions(offerModeAfterByTask.get(taskId) === true).map(o => o.label);
             const choice = planReviewChoiceFromAnswer(answer, shown);
             if (choice === 'dismissed') {
+                notePlanReviewUserDismissalFor(DEFAULT_SESSION_KEY, taskId, opts?.readGateInstanceKeys, questionId);
                 return { ok: true };
             }
             const decided = choice.decision;
+            notePlanReviewDecisiveAnswerFor(DEFAULT_SESSION_KEY, taskId);
             const modeAfter = choice.decision === 'approve' ? choice.permissionModeAfter : undefined;
             offerModeAfterByTask.delete(taskId);
             notePlanReviewAnswered(questionId);
@@ -375,10 +472,245 @@ function retireActiveReopen(sessionKey, canonicalId) {
 }
 export function _resetActiveReopenRespondersForTest() {
     activeReopenResponders.clear();
+    reopenFlights.clear();
+}
+const reopenFlights = new Map();
+function joinReopenFlight(flight, taskId, receiptMs) {
+    hostLog('debug', `planReviewWire: reopen for task ${taskId} joined the card already on its way (no second card, its answer path kept)`);
+    if (receiptMs === undefined)
+        return { reopened: true, firstSight: false };
+    const ac = new AbortController();
+    return Promise.race([
+        flight.presented.then((v) => v === true, () => false),
+        abortableSleep(Math.max(0, receiptMs), ac.signal).then(() => false),
+    ]).then((presented) => {
+        ac.abort();
+        return presented ? { reopened: true, firstSight: false } : { reopened: false };
+    }, () => {
+        ac.abort();
+        return { reopened: false };
+    });
+}
+function mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs) {
+    const flightKey = `${sessionKey}\u0000${taskId}`;
+    const inFlight = reopenFlights.get(flightKey);
+    if (inFlight !== undefined)
+        return joinReopenFlight(inFlight, taskId, receiptMs);
+    let land = () => { };
+    const flight = {
+        presented: new Promise((resolve) => {
+            land = resolve;
+        }),
+    };
+    reopenFlights.set(flightKey, flight);
+    const settle = (presented) => {
+        land(presented);
+        if (reopenFlights.get(flightKey) === flight)
+            reopenFlights.delete(flightKey);
+    };
+    let verdict;
+    try {
+        verdict = mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs);
+    }
+    catch (e) {
+        settle(false);
+        throw e;
+    }
+    if (verdict instanceof Promise) {
+        return verdict.then((v) => {
+            settle(v.reopened === true);
+            return v;
+        }, (e) => {
+            settle(false);
+            throw e;
+        });
+    }
+    settle(verdict.reopened === true);
+    return verdict;
+}
+function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
+    const markBefore = dismissalEntryFor(sessionKey, taskId);
+    const settleOnReceipt = (receipt, firstSight) => receipt.then((presented) => {
+        if (!presented)
+            return { reopened: false };
+        revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
+        return { reopened: true, firstSight };
+    }, () => ({ reopened: false }));
+    const canonicalId = planReviewQuestionId(taskId);
+    const armedKey = planReviewArmedKeyFor(sessionKey, taskId);
+    const firstSight = !wasGateArmedFor(sessionKey, armedKey);
+    const mintFresh = opts?.mintFreshQuestionId !== false;
+    if (!mintFresh && hasLocalQuestionResponder(canonicalId)) {
+        hostLog('debug', `planReviewWire: reopen for task ${taskId} reusing the canonical responder (path=reopen-canonical)`);
+        if (opts?.deliverDecision !== undefined) {
+            hostLog('debug', `planReviewWire: reopen canonical-reuse branch for task ${taskId} ignores opts.deliverDecision (answers route through the existing arm responder — documented exception)`);
+        }
+        retireActiveReopen(sessionKey, canonicalId);
+        if (receiptMs !== undefined) {
+            const receipt = waitForGateArmedFor(sessionKey, [canonicalId], receiptMs);
+            publishQuestionFrameFor(sessionKey, {
+                type: 'question',
+                questionId: canonicalId,
+                questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
+            });
+            return settleOnReceipt(receipt, firstSight);
+        }
+        publishQuestionFrameFor(sessionKey, {
+            type: 'question',
+            questionId: canonicalId,
+            questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
+        });
+        registerArmedGateFor(sessionKey, armedKey);
+        revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
+        return { reopened: true, firstSight };
+    }
+    retireActiveReopen(sessionKey, canonicalId);
+    if (unregisterLocalQuestionResponder(canonicalId)) {
+        hostLog('debug', `planReviewWire: reopen retired the canonical responder for task ${taskId} (single-active discipline)`);
+    }
+    publishQuestionFrameFor(sessionKey, { type: 'question_complete', questionId: canonicalId });
+    const questionId = `${canonicalId}${REOPEN_ID_TAIL}${reopenIdSuffix()}`;
+    hostLog('debug', `planReviewWire: reopen for task ${taskId} minting a fresh card ${questionId} (path=reopen-fresh)`);
+    const deliver = opts?.deliverDecision ??
+        ((tid, decision) => {
+            hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
+            void decidePlanReview(tid, decision);
+        });
+    const activeKey = `${sessionKey}\u0000${canonicalId}`;
+    const unregister = registerLocalQuestionResponder(questionId, async (_id, answer) => {
+        unregister();
+        if (activeReopenResponders.get(activeKey)?.questionId === questionId) {
+            activeReopenResponders.delete(activeKey);
+        }
+        const decided = planReviewDecisionFromAnswer(answer, LEGACY_TWO_CHOICE_LABELS);
+        if (decided === 'dismissed') {
+            notePlanReviewUserDismissalFor(sessionKey, taskId, opts?.readGateInstanceKeys, questionId);
+            return { ok: true };
+        }
+        notePlanReviewDecisiveAnswerFor(sessionKey, taskId);
+        notePlanReviewAnsweredFor(sessionKey, questionId);
+        try {
+            await deliver(taskId, decided);
+        }
+        catch (e) {
+            hostLog('error', `planReviewWire: reopen decision delivery threw for task ${taskId}: ${String(e)}`);
+        }
+        return { ok: true };
+    });
+    activeReopenResponders.set(activeKey, { questionId, unregister });
+    if (receiptMs !== undefined) {
+        const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
+        publishQuestionFrameFor(sessionKey, {
+            type: 'question',
+            questionId,
+            questions: planReviewQuestions(REOPEN_QUESTION),
+        });
+        return settleOnReceipt(receipt, firstSight);
+    }
+    registerArmedGateFor(sessionKey, armedKey);
+    publishQuestionFrameFor(sessionKey, {
+        type: 'question',
+        questionId,
+        questions: planReviewQuestions(REOPEN_QUESTION),
+    });
+    revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
+    return { reopened: true, firstSight };
+}
+async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark) {
+    const refusedByUser = { reopened: false, dismissedByUser: true };
+    try {
+        let fresh = false;
+        const closed = await boundedGateInstanceRead(mark.closedGates);
+        if (closed !== null && closed.size > 0) {
+            const now = await boundedGateInstanceRead(startGateInstanceRead(opts.readGateInstanceKeys, taskId));
+            if (now !== null) {
+                for (const k of now) {
+                    if (!closed.has(k)) {
+                        fresh = true;
+                        break;
+                    }
+                }
+            }
+        }
+        let handedOver = false;
+        if (!decideInFlight.has(taskId)) {
+            try {
+                handedOver = opts.decisionHandedOver?.(taskId) === true;
+            }
+            catch (err) {
+                hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — the host's decision hand-over check threw: ${String(err)}`);
+                return { reopened: false };
+            }
+        }
+        if (decideInFlight.has(taskId) || handedOver) {
+            hostLog('debug', `planReviewWire: reopen for task ${taskId} refused after the dismissal check — a decision for this task went out while the check was reading`);
+            return { reopened: false, _sema_decisionInFlight: true };
+        }
+        const current = dismissalEntryFor(sessionKey, taskId);
+        if (current !== mark) {
+            hostLog('debug', `planReviewWire: reopen for task ${taskId} not minted — the dismissal record changed while it was being checked (stale evaluation)`);
+            return await staleDismissalVerdict(current, sessionKey, taskId, receiptMs);
+        }
+        if (!fresh) {
+            hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card (no newer gate instance proven)`);
+            return refusedByUser;
+        }
+        let settle = () => { };
+        const reopening = {
+            kind: 'reopened',
+            closedGates: null,
+            onScreen: new Promise((resolve) => {
+                settle = resolve;
+            }),
+        };
+        putDismissalEntry(sessionKey, taskId, reopening);
+        let verdict = { reopened: false };
+        try {
+            if (hasQuestionOverlayFor(sessionKey))
+                verdict = await mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
+        }
+        finally {
+            const presented = verdict.reopened === true;
+            settle(presented);
+            if (!presented)
+                dropDismissalEntry(sessionKey, taskId, reopening);
+        }
+        return verdict;
+    }
+    catch {
+        return refusedByUser;
+    }
+}
+async function staleDismissalVerdict(current, sessionKey, taskId, receiptMs) {
+    const ac = new AbortController();
+    const windowEnd = abortableSleep(Math.max(0, receiptMs), ac.signal).then(() => false);
+    try {
+        let entry = current;
+        for (let round = 0; round < 8; round++) {
+            if (entry?.kind === 'decided')
+                return { reopened: false, _sema_decisionInFlight: true };
+            if (entry?.kind === 'dismissed')
+                return { reopened: false, dismissedByUser: true };
+            if (entry?.kind !== 'reopened' || entry.onScreen === undefined)
+                return { reopened: false };
+            const onScreen = await Promise.race([
+                entry.onScreen.then((v) => v === true, () => false),
+                windowEnd,
+            ]);
+            const now = dismissalEntryFor(sessionKey, taskId);
+            if (now === entry) {
+                return onScreen ? { reopened: true, firstSight: !wasGateArmedFor(sessionKey, planReviewArmedKeyFor(sessionKey, taskId)) } : { reopened: false };
+            }
+            entry = now;
+        }
+        return { reopened: false };
+    }
+    finally {
+        ac.abort();
+    }
 }
 export function reopenPlanReviewCard(taskId, opts) {
     const receiptMs = opts?.presentationReceiptMs;
-    const settleOnReceipt = (receipt, firstSight) => receipt.then((presented) => (presented ? { reopened: true, firstSight } : { reopened: false }), () => ({ reopened: false }));
     try {
         if (typeof taskId !== 'string' || taskId.length === 0) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
@@ -399,81 +731,18 @@ export function reopenPlanReviewCard(taskId, opts) {
                 '此处拒绝而不是照发 —— 照发会把这条会话的决断发到另一个槽上。');
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
         }
-        const canonicalId = planReviewQuestionId(taskId);
-        const armedKey = planReviewArmedKeyFor(sessionKey, taskId);
-        const firstSight = !wasGateArmedFor(sessionKey, armedKey);
-        const mintFresh = opts?.mintFreshQuestionId !== false;
-        if (!mintFresh && hasLocalQuestionResponder(canonicalId)) {
-            hostLog('debug', `planReviewWire: reopen for task ${taskId} reusing the canonical responder (path=reopen-canonical)`);
-            if (opts?.deliverDecision !== undefined) {
-                hostLog('debug', `planReviewWire: reopen canonical-reuse branch for task ${taskId} ignores opts.deliverDecision (answers route through the existing arm responder — documented exception)`);
-            }
-            retireActiveReopen(sessionKey, canonicalId);
-            if (receiptMs !== undefined) {
-                const receipt = waitForGateArmedFor(sessionKey, [canonicalId], receiptMs);
-                publishQuestionFrameFor(sessionKey, {
-                    type: 'question',
-                    questionId: canonicalId,
-                    questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
-                });
-                return settleOnReceipt(receipt, firstSight);
-            }
-            publishQuestionFrameFor(sessionKey, {
-                type: 'question',
-                questionId: canonicalId,
-                questions: planReviewQuestions(ARM_QUESTION, offerModeAfterByTask.get(taskId) === true),
-            });
-            registerArmedGateFor(sessionKey, armedKey);
-            return { reopened: true, firstSight };
-        }
-        retireActiveReopen(sessionKey, canonicalId);
-        if (unregisterLocalQuestionResponder(canonicalId)) {
-            hostLog('debug', `planReviewWire: reopen retired the canonical responder for task ${taskId} (single-active discipline)`);
-        }
-        publishQuestionFrameFor(sessionKey, { type: 'question_complete', questionId: canonicalId });
-        const questionId = `${canonicalId}${REOPEN_ID_TAIL}${reopenIdSuffix()}`;
-        hostLog('debug', `planReviewWire: reopen for task ${taskId} minting a fresh card ${questionId} (path=reopen-fresh)`);
-        const deliver = opts?.deliverDecision ??
-            ((tid, decision) => {
-                hostLog('debug', `planReviewWire: reopen responder delivering ${decision} for task ${tid} (path=reopen-default)`);
-                void decidePlanReview(tid, decision);
-            });
-        const activeKey = `${sessionKey}\u0000${canonicalId}`;
-        const unregister = registerLocalQuestionResponder(questionId, async (_id, answer) => {
-            unregister();
-            if (activeReopenResponders.get(activeKey)?.questionId === questionId) {
-                activeReopenResponders.delete(activeKey);
-            }
-            const decided = planReviewDecisionFromAnswer(answer, LEGACY_TWO_CHOICE_LABELS);
-            if (decided === 'dismissed') {
-                return { ok: true };
-            }
-            notePlanReviewAnsweredFor(sessionKey, questionId);
-            try {
-                await deliver(taskId, decided);
-            }
-            catch (e) {
-                hostLog('error', `planReviewWire: reopen decision delivery threw for task ${taskId}: ${String(e)}`);
+        const trigger = opts?.trigger === undefined ? undefined : opts.trigger === 'user' ? 'user' : 'automatic';
+        if (trigger === 'automatic') {
+            const mark = planReviewUserDismissalMarkFor(sessionKey, taskId);
+            if (mark !== undefined) {
+                if (receiptMs === undefined || opts === undefined) {
+                    hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card`);
+                    return { reopened: false, dismissedByUser: true };
+                }
+                return reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark);
             }
-            return { ok: true };
-        });
-        activeReopenResponders.set(activeKey, { questionId, unregister });
-        if (receiptMs !== undefined) {
-            const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
-            publishQuestionFrameFor(sessionKey, {
-                type: 'question',
-                questionId,
-                questions: planReviewQuestions(REOPEN_QUESTION),
-            });
-            return settleOnReceipt(receipt, firstSight);
         }
-        registerArmedGateFor(sessionKey, armedKey);
-        publishQuestionFrameFor(sessionKey, {
-            type: 'question',
-            questionId,
-            questions: planReviewQuestions(REOPEN_QUESTION),
-        });
-        return { reopened: true, firstSight };
+        return mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
     }
     catch {
         return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,6 +1,7 @@
 import { type GateCurrentPending, type HitlFailureStage, type HitlSafetyCode, type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
 import { type RuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
+import type { ToolPermissionRequest } from '../seatContract.js';
 import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
 import { type DecideReceiptView } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS } from '@sema-agent/sdk';
@@ -207,6 +208,7 @@ export declare function approvalIsMandated(v: ApprovalMandatedFacts | undefined
 export declare function readApprovalMandate(v: {
     readonly mandate?: string;
 } | undefined | null): ApprovalMandateWord | undefined;
+export declare function toolPermissionRequestAskBits(card: object | null | undefined): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence'>;
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 export type ToolApprovalRespondDecision = 'allow' | 'allow_session' | 'deny';
 export interface RespondToolApprovalOpts {

package/dist/hitl/toolApprovalWire.js

@@ -206,7 +206,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
             : {}),
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(pending.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-        ...(pending.mandated === true ? { mandated: true } : {}),
+        ...(hasOwnStrictTrue(pending, 'mandated') ? { mandated: true } : {}),
         ...((w) => (w !== undefined ? { mandate: w } : {}))(readApprovalMandate(pending)),
         ...((o) => (o !== undefined ? { origin: o } : {}))(readOwnNonEmptyString(pending, 'origin')),
         ...(pending.gateKind === 'irreversible_ask' ? { irreversibleParkGate: true } : {}),
@@ -403,9 +403,11 @@ const MANDATED_ABSENCE_WORD = 'mandated';
 export function approvalIsMandated(v) {
     if (v === null || v === undefined)
         return false;
-    if (v.mandated === true)
+    if (typeof v !== 'object')
+        return false;
+    if (hasOwnStrictTrue(v, 'mandated'))
         return true;
-    if (v.ruleOffersAbsence === MANDATED_ABSENCE_WORD)
+    if (readOwnNonEmptyString(v, 'ruleOffersAbsence') === MANDATED_ABSENCE_WORD)
         return true;
     return readApprovalMandate(v) !== undefined;
 }
@@ -415,6 +417,23 @@ export function readApprovalMandate(v) {
     const raw = v.mandate;
     return isApprovalMandateWord(raw) ? raw : undefined;
 }
+export function toolPermissionRequestAskBits(card) {
+    if (typeof card !== 'object' || card === null)
+        return {};
+    const mandated = hasOwnStrictTrue(card, 'mandated');
+    const mandate = readApprovalMandate(card);
+    const origin = readOwnNonEmptyString(card, 'origin');
+    const ruleOffersAbsence = readOwnNonEmptyString(card, 'ruleOffersAbsence');
+    return {
+        ...(mandated ? { mandated: true } : {}),
+        ...(mandate !== undefined ? { mandate } : {}),
+        ...(origin !== undefined ? { origin } : {}),
+        ...(ruleOffersAbsence !== undefined ? { ruleOffersAbsence } : {}),
+    };
+}
+function hasOwnStrictTrue(v, key) {
+    return Object.hasOwn(v, key) && v[key] === true;
+}
 function isToolApprovalDelegation(v) {
     if (v === null || typeof v !== 'object')
         return false;
@@ -840,7 +859,7 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         ...(isWireRecordCarrier(frame.probeCause) ? { probeCause: frame.probeCause } : {}),
         ...(isWireRecordCarrier(frame.ruleEvidence) ? { ruleEvidence: frame.ruleEvidence } : {}),
         ...(frame.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
-        ...(frame.mandated === true ? { mandated: true } : {}),
+        ...(hasOwnStrictTrue(frame, 'mandated') ? { mandated: true } : {}),
         ...((w) => (w !== undefined ? { mandate: w } : {}))(readApprovalMandate(frame)),
         ...(() => { const rc = readReadRootCandidate(frame.readRootCandidate); return rc !== undefined ? { readRootCandidate: rc } : {}; })(),
         ...(frame.inputHasBidi === true ? { inputHasBidi: true } : {}),

package/dist/index.d.ts

@@ -66,6 +66,7 @@ export * from './controlRouter.js';
 export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
+export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export * from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -154,7 +155,7 @@ export * from './hitl/editedRuleTextPrecheck.js';
 export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
-export * from './hitl/gateIdentity.js';
+export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
 export * from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';

package/dist/index.js

@@ -64,6 +64,7 @@ export * from './controlRouter.js';
 export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
+export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
 export * from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
@@ -151,7 +152,7 @@ export * from './hitl/editedRuleTextPrecheck.js';
 export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
-export * from './hitl/gateIdentity.js';
+export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
 export * from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';

package/dist/seatContract.d.ts

@@ -2,6 +2,7 @@ import type { ReasoningEffort } from "./effortWire.js";
 import type { LaneProof } from "./seam.js";
 import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
+import type { ApprovalMandateWord } from "./gateVocabulary.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -55,6 +56,10 @@ export interface ToolPermissionRequest {
     createdAtMs?: number;
     governanceForced?: true;
     delegation?: ToolApprovalDelegation;
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+    ruleOffersAbsence?: string;
 }
 declare const SEAT_EVENT_TYPE_TUPLE: readonly ["start", "close", "session_updated", "message", "stream_event", "chrome_event", "error", "tool_permission_resolved"];
 export type SeatEventType = (typeof SEAT_EVENT_TYPE_TUPLE)[number];
@@ -255,7 +260,7 @@ export declare const SEAT_METHOD_NAMES: readonly ["start", "sendMessage", "inter
 export declare const SEAT_STORE_PROPS: readonly ["sessionsStateStore", "focusedSessionStateStore", "settingsStateStore"];
 export declare const SEAT_EVENT_METHOD_NAMES: readonly ["onEvent", "onToolPermissionRequest"];
 export declare const LOCAL_SESSION_EVENT_KEYS: readonly ["type", "sessionId", "message", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "chrome"];
-export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation"];
+export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation", "mandated", "mandate", "origin", "ruleOffersAbsence"];
 export declare const LOCAL_SESSION_RECORD_KEYS: readonly ["sessionId", "engineSessionId", "model", "title", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked"];
 export declare const SEND_MESSAGE_REQUEST_KEYS: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario"];
 export declare const SEAT_SEND_MESSAGE_KEY_ORIGINS: {
@@ -318,6 +323,18 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
         }, {
             readonly key: "delegation";
             readonly why: "展示增强位,权威结构门在 hitl wire 卡口(结构读+仅子代 ask 在场,坏形降缺席);座位门同款理由不设第二判官。消费端坏形降缺席,绝不拒行。";
+        }, {
+            readonly key: "mandated";
+            readonly why: "展示增强位(CC-203),权威窄读在卡口与过境口 toolPermissionRequestAskBits(严格 true 才上座);座位门再裁一次会为一个徽标键拒掉整条 request、把安全 ask 丢给引擎 TTL deny。消费端经 approvalIsMandated 读,其余一律当缺席。";
+        }, {
+            readonly key: "mandate";
+            readonly why: "展示增强位(CC-203),权威窄读在卡口与过境口(闭集六词精确字节,表外不上座);座位门不设第二判官,理由同 mandated。消费端经 readApprovalMandate 读,表外值读成缺席。";
+        }, {
+            readonly key: "origin";
+            readonly why: "喂姿态谓词 askSurvivesPosture 的安全位(CC-203),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口 toolPermissionRequestAskBits,座位门不设第二判官(为一个位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形的两种失效方向:非串 / 空串读成缺席 ⇒ 宿主报了没命中时姿态谓词可答可以放(放宽方向:真出身若是必问词就丢了);表外串读成不认识的词 ⇒ 答 unknown,宿主退回自己的规则(不放宽)。不经过境口自铸座位请求的宿主要自己按同一把窄读。";
+        }, {
+            readonly key: "ruleOffersAbsence";
+            readonly why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。";
         }];
     };
     readonly LocalSessionEvent: {