@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/hitl/approvalCompleteParked.js

@@ -0,0 +1,14 @@
+function ownData(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    return d !== undefined && 'value' in d ? d.value : undefined;
+}
+export function approvalCompleteParked(frame) {
+    try {
+        if (frame === null || typeof frame !== 'object')
+            return false;
+        return ownData(frame, 'outcome') === 'expired' && ownData(frame, 'parked') === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/approvalEndingCause.d.ts

@@ -0,0 +1,5 @@
+import type { ApprovalSettleCause, AskRowEndingCause } from '@sema-agent/sdk';
+export declare const ASK_ROW_ENDING_CAUSE_WORDS: readonly ["routing_failure_fail_closed", "run_cancelled", "run_exited", "batch_aborted", "batch_sibling_withdrawn", "batch_bound_elsewhere", "adhoc_leg_no_durable_domain", "orphan_ttl_exceeded", "crashed_before_park", "shutdown_before_park"];
+export declare function askRowEndingCauseFor(state: 'VOID' | 'DENIED' | undefined, word: unknown): AskRowEndingCause | undefined;
+export declare function approvalCompleteCauseOf(frame: unknown): ApprovalSettleCause | undefined;
+export declare function notPendingCauseSaysEnded(err: object): boolean;

package/dist/hitl/approvalEndingCause.js

@@ -0,0 +1,61 @@
+import { ASK_GONE_DENIED_WORD } from '../engineErrorCodes.js';
+import { SDK_ASK_ROW_ENDING_CAUSES } from '../generated/sdkFactTables.js';
+export const ASK_ROW_ENDING_CAUSE_WORDS = SDK_ASK_ROW_ENDING_CAUSES;
+const _askRowCausePin = true;
+void _askRowCausePin;
+const DENIED_GROUP_WORD = ASK_GONE_DENIED_WORD;
+const WAIT_CLASS_SETTLE_CAUSE_WORDS = Object.freeze({
+    ttl_expired: true,
+    broadcast_lost: true,
+    stream_disconnected: true,
+    undeliverable: true,
+});
+function isAskRowEndingCause(v) {
+    return typeof v === 'string' && ASK_ROW_ENDING_CAUSE_WORDS.includes(v);
+}
+function isApprovalSettleCause(v) {
+    return isAskRowEndingCause(v) || (typeof v === 'string' && Object.hasOwn(WAIT_CLASS_SETTLE_CAUSE_WORDS, v));
+}
+export function askRowEndingCauseFor(state, word) {
+    if (!isAskRowEndingCause(word))
+        return undefined;
+    if (state === 'DENIED')
+        return word === DENIED_GROUP_WORD ? word : undefined;
+    if (state === 'VOID')
+        return word !== DENIED_GROUP_WORD ? word : undefined;
+    return undefined;
+}
+export function approvalCompleteCauseOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return undefined;
+        const typeSlot = Object.getOwnPropertyDescriptor(frame, 'type');
+        if (typeSlot === undefined || !Object.hasOwn(typeSlot, 'value') || typeSlot.value !== 'tool_approval_complete')
+            return undefined;
+        const causeSlot = Object.getOwnPropertyDescriptor(frame, 'cause');
+        if (causeSlot === undefined || !Object.hasOwn(causeSlot, 'value'))
+            return undefined;
+        const word = causeSlot.value;
+        return isApprovalSettleCause(word) ? word : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const LEGACY_NOT_PENDING_ENDED_WORDS = new Set(['voided', 'denied']);
+export function notPendingCauseSaysEnded(err) {
+    try {
+        const extraSlot = Object.getOwnPropertyDescriptor(err, 'extra');
+        const extra = extraSlot !== undefined && Object.hasOwn(extraSlot, 'value') ? extraSlot.value : undefined;
+        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
+            return false;
+        const causeSlot = Object.getOwnPropertyDescriptor(extra, 'cause');
+        if (causeSlot === undefined || !Object.hasOwn(causeSlot, 'value'))
+            return false;
+        const word = causeSlot.value;
+        return isAskRowEndingCause(word) || (typeof word === 'string' && LEGACY_NOT_PENDING_ENDED_WORDS.has(word));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hitl/approvalHolds.d.ts

@@ -0,0 +1,46 @@
+import type { ApprovalHolderIdentity, FsApprovalOutcome, ToolApprovalFrameOutcome } from './toolApprovalWire.js';
+export interface DurableDecisionHold {
+    readonly lane: 'durable';
+    readonly outcome: Promise<FsApprovalOutcome>;
+    presented: boolean;
+    readonly interrupt: () => void;
+    readonly cardSignal: AbortSignal;
+    trailing?: Promise<unknown>;
+}
+export interface LiveCardHold {
+    readonly lane: 'live';
+    readonly identity: LiveCardIdentity;
+    readonly outcome: Promise<ToolApprovalFrameOutcome>;
+    phase: 'card' | 'respond';
+    superseded?: {
+        readonly parked: boolean;
+    };
+    readonly cardSignal: AbortSignal;
+    readonly interrupt: () => void;
+    trailing?: Promise<void>;
+}
+export type ApprovalHold = DurableDecisionHold | LiveCardHold;
+export interface LiveCardIdentity {
+    readonly approvalId: string;
+    readonly toolCallId?: string;
+    readonly taskId?: string;
+    readonly sessionId?: string;
+}
+export declare function liveCardHoldFor(who: ApprovalHolderIdentity): LiveCardHold | undefined;
+export declare function liveCardAnsweredHow(o: ToolApprovalFrameOutcome): 'answered' | 'interrupted' | undefined;
+export declare function awaitLiveCardHolder(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome | undefined>;
+export interface ApprovalDecisionHoldTable {
+    readonly inFlight: Map<string, ApprovalHold>;
+    readonly settled: Map<string, DurableSettledHold>;
+    readonly openReads: Set<number>;
+    clock: number;
+}
+export interface DurableSettledHold {
+    readonly at: number;
+    readonly hold: DurableDecisionHold;
+}
+export declare const approvalDecisionHolds: ApprovalDecisionHoldTable;
+export declare function liveCardHoldOf(key: string): LiveCardHold | undefined;
+export declare function holdLiveCard(identity: LiveCardIdentity, callerSignal: AbortSignal | undefined, present: (hold: LiveCardHold) => Promise<ToolApprovalFrameOutcome>): Promise<ToolApprovalFrameOutcome>;
+export declare function joinLiveCard(hold: LiveCardHold, signal: AbortSignal | undefined): Promise<ToolApprovalFrameOutcome>;
+export declare function supersedeLiveCard(key: string, parked: boolean): boolean;

package/dist/hitl/approvalHolds.js

@@ -0,0 +1,140 @@
+import { hostLog } from '../host.js';
+import { liveFrameCallKey } from './gateIdentity.js';
+import { approvalResolutionOf } from './approvalResolution.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+export function liveCardHoldFor(who) {
+    if (nonEmpty(who.approvalId))
+        return liveCardHoldOf(liveFrameCallKey(who.approvalId));
+    if (!nonEmpty(who.taskId) || !nonEmpty(who.toolCallId))
+        return undefined;
+    for (const h of approvalDecisionHolds.inFlight.values()) {
+        if (h.lane !== 'live' || h.phase !== 'card')
+            continue;
+        const id = h.identity;
+        if (id.taskId !== who.taskId || id.toolCallId !== who.toolCallId)
+            continue;
+        if (nonEmpty(who.sessionId) && nonEmpty(id.sessionId) && id.sessionId !== who.sessionId)
+            continue;
+        return h;
+    }
+    return undefined;
+}
+function liveCardSettledQuestion(hold, o) {
+    const r = approvalResolutionOf(o);
+    if (answeredHowOf(r) !== undefined)
+        return true;
+    if (r.kind === 'unsettled')
+        return false;
+    return hold.superseded !== undefined && !hold.superseded.parked;
+}
+export function liveCardAnsweredHow(o) {
+    return answeredHowOf(approvalResolutionOf(o));
+}
+function answeredHowOf(r) {
+    if (r.kind === 'decided')
+        return 'answered';
+    return r.kind === 'unsettled' && r.cause === 'interrupted' ? 'interrupted' : undefined;
+}
+export async function awaitLiveCardHolder(hold, signal) {
+    const unsubscribe = followCallerSignal(signal, hold.interrupt);
+    let o;
+    try {
+        o = await hold.outcome;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        unsubscribe();
+    }
+    return liveCardSettledQuestion(hold, o) ? { ...o, joinedInFlight: true } : undefined;
+}
+export const approvalDecisionHolds = { inFlight: new Map(), settled: new Map(), openReads: new Set(), clock: 0 };
+export function liveCardHoldOf(key) {
+    const h = approvalDecisionHolds.inFlight.get(key);
+    return h !== undefined && h.lane === 'live' ? h : undefined;
+}
+export function holdLiveCard(identity, callerSignal, present) {
+    const key = liveFrameCallKey(identity.approvalId);
+    const h = approvalDecisionHolds;
+    const cut = new AbortController();
+    let settled = false;
+    const interrupt = () => {
+        if (!settled && !cut.signal.aborted)
+            cut.abort();
+    };
+    const unsubscribe = followCallerSignal(callerSignal, interrupt);
+    let resolveOutcome = () => { };
+    let rejectOutcome = () => { };
+    const outcome = new Promise((resolve, reject) => {
+        resolveOutcome = resolve;
+        rejectOutcome = reject;
+    });
+    const hold = { lane: 'live', identity: Object.freeze({ ...identity }), outcome, phase: 'card', cardSignal: cut.signal, interrupt };
+    h.inFlight.set(key, hold);
+    const release = () => {
+        if (h.inFlight.get(key) === hold)
+            h.inFlight.delete(key);
+    };
+    const settle = (give) => {
+        settled = true;
+        unsubscribe();
+        const trailing = hold.trailing;
+        if (trailing === undefined) {
+            release();
+            give();
+            return;
+        }
+        give();
+        trailing.then(release, release);
+    };
+    let run;
+    try {
+        run = present(hold);
+    }
+    catch (e) {
+        run = Promise.reject(e);
+    }
+    run.then((o) => settle(() => resolveOutcome(o)), (e) => settle(() => rejectOutcome(e)));
+    return outcome;
+}
+export async function joinLiveCard(hold, signal) {
+    const unsubscribe = followCallerSignal(signal, hold.interrupt);
+    try {
+        const o = await hold.outcome;
+        return { ...o, joinedInFlight: true };
+    }
+    finally {
+        unsubscribe();
+    }
+}
+function followCallerSignal(signal, onAbort) {
+    if (signal === undefined || signal === null)
+        return () => { };
+    try {
+        if (signal.aborted === true) {
+            onAbort();
+            return () => { };
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    }
+    catch {
+        return () => { };
+    }
+    return () => {
+        try {
+            signal.removeEventListener('abort', onAbort);
+        }
+        catch (e) {
+            hostLog('debug', `approvalHolds: could not detach from the caller's abort signal (${String(e).slice(0, 120)}) — the listener is one-shot and inert after settle`);
+        }
+    };
+}
+export function supersedeLiveCard(key, parked) {
+    const hold = liveCardHoldOf(key);
+    if (hold === undefined || hold.phase !== 'card' || hold.superseded !== undefined)
+        return false;
+    hold.superseded = Object.freeze({ parked });
+    hold.interrupt();
+    return true;
+}

package/dist/hitl/approvalOutcomeNote.js

@@ -17,7 +17,8 @@ function detailOf(r) {
 }
 export function approvalOutcomeNoteOf(frame, outcome) {
     const r = approvalResolutionOf(outcome);
-    const retracted = approvalNotSentCause(r) === 'retracted';
+    const cause = approvalNotSentCause(r);
+    const retracted = cause === 'retracted';
     const detail = detailOf(r);
     return {
         approvalId: frame.approvalId,

package/dist/hitl/approvalResolution.js

@@ -106,13 +106,21 @@ function parkingViewOf(v) {
     const hint = pick(v, 'retryAfterMs');
     const retryAfterMs = typeof hint === 'number' && Number.isFinite(hint) && hint >= 0 ? hint : undefined;
     const decidePath = str(pick(v, 'decidePath'));
-    return { approvalId, ...(retryAfterMs !== undefined ? { retryAfterMs } : {}), ...(decidePath !== undefined ? { decidePath } : {}) };
+    const message = str(pick(v, 'message'));
+    return {
+        approvalId,
+        ...(retryAfterMs !== undefined ? { retryAfterMs } : {}),
+        ...(decidePath !== undefined ? { decidePath } : {}),
+        ...(message !== undefined ? { message } : {}),
+    };
 }
 function frameLegResolution(outcome) {
     if (pick(outcome, 'retracted') === true)
         return { kind: 'not_sent', cause: 'retracted' };
     if (pick(outcome, 'editRefused') === true)
         return { kind: 'not_sent', cause: 'edit_refused' };
+    if (pick(outcome, 'aborted') === true)
+        return { kind: 'unsettled', cause: 'interrupted' };
     const parking = parkingViewOf(pick(outcome, 'parking'));
     if (parking !== undefined)
         return { kind: 'unsettled', cause: 'parking_in_progress', parking };

package/dist/hitl/approvalsFeed.js

@@ -1,6 +1,7 @@
 import { hostLog } from '../host.js';
 import { unrefTimer } from '../unrefTimer.js';
 import { readLivePendingRows } from './livePendingAsk.js';
+import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
 const MAX_CONSECUTIVE_POLL_ESCAPES = 5;
 function readDurablePendingRows(raw) {
     if (!Array.isArray(raw))
@@ -364,7 +365,7 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 .then(() => scheduleReconcile());
         }, reconcileDelayMs));
     }
-    function scheduleStreamRetry() {
+    function scheduleStreamRetry(afterMs = streamRetryMs) {
         if (stopped || ac.signal.aborted || streamRetryMs <= 0)
             return;
         if (!client.approvals.stream)
@@ -377,9 +378,9 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 return;
             hostLog('debug', 'approvalsFeed: retrying push leg (降级是暂时的,服务端升级后不该还要重启客户端)');
             void runStream();
-        }, streamRetryMs));
+        }, afterMs));
     }
-    function degradeToPoll(why, real = true) {
+    function degradeToPoll(why, real = true, retryAfterMs) {
         if (stopped)
             return;
         if (real)
@@ -389,8 +390,9 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
         }
         mode = 'poll';
         schedulePoll();
-        scheduleStreamRetry();
+        scheduleStreamRetry(retryAfterMs);
     }
+    const drains = createStreamDrainingLegs();
     async function runStream() {
         const stream = client.approvals.stream;
         if (!stream) {
@@ -401,6 +403,10 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
             for await (const ev of stream.call(client.approvals, { signal: ac.signal })) {
                 if (stopped || ac.signal.aborted)
                     return;
+                if (drains.see(ev)) {
+                    hostLog('debug', 'approvalsFeed: push leg received the drain end frame — the engine is going down; this leg ends with it and reopens on the draining ladder');
+                    continue;
+                }
                 if (mode !== 'push') {
                     mode = 'push';
                     if (pollTimer !== undefined) {
@@ -418,10 +424,21 @@ export function startApprovalsFeed(client, onSnapshot, opts) {
                 stats.pushEvents++;
                 await take('push');
             }
-            if (!stopped && !ac.signal.aborted)
-                degradeToPoll('stream ended without progress');
+            if (stopped || ac.signal.aborted)
+                return;
+            const drained = drains.legEnded('returned');
+            if (drained !== undefined) {
+                const decision = drained;
+                if ('reconnectAfterMs' in decision)
+                    degradeToPoll(`engine draining — push leg closed; reopening in ${decision.reconnectAfterMs}ms`, false, decision.reconnectAfterMs);
+                else
+                    degradeToPoll(`engine draining — reconnect attempts exhausted (${decision.giveUp})`);
+                return;
+            }
+            degradeToPoll('stream ended without progress');
         }
         catch (e) {
+            drains.legEnded('threw');
             if (stopped || ac.signal.aborted)
                 return;
             degradeToPoll(String(e));

package/dist/hitl/askGateWire.d.ts

@@ -8,9 +8,10 @@ export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export type { GateDenyAttribution } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';
+export { GATE_FAILURE_CODES } from './hitlBridge.js';
 export declare function bridgeAskUserQuestionGates(source: AsyncGenerator<AgentEvent>, deps: AskGateWireDeps, opts?: {
     signal?: AbortSignal;
     taskId?: string;

package/dist/hitl/askGateWire.js

@@ -1,12 +1,16 @@
 import { createGateLedger } from './gateLedger.js';
 import { flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.js';
 import { resolvePark, nextHopBudget, stalledTerminal, MAX_GATE_HOPS } from './parkResolver.js';
+import { createStreamDrainingLegs } from '../streamDrainingLegs.js';
+import { abortableSleep } from '../abortableSleep.js';
+import { hostLog } from '../host.js';
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
 export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
 export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
 export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
-export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { toAnsweredOutput, isAlreadyResolvedFailure, isAlreadyResolvedGateReason, isGateStandingErrorCode, isCodeClassifiedGateFailure, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
+export { GATE_FAILURE_CODES } from './hitlBridge.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();
     const taskId = { current: opts?.taskId };
@@ -24,9 +28,15 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     let lastResolvedGatedCallId;
     let lastRoundDecided = false;
     let unverifiableParks = 0;
+    const drains = createStreamDrainingLegs();
     while (true) {
         let park = null;
         for await (const ev of stream) {
+            if (drains.see(ev))
+                continue;
+            const answering = led.answeringLiveCards();
+            if (answering.length > 0)
+                await Promise.all(answering);
             led.noteSeq(ev);
             if (isHostProgressFrame(ev))
                 progressedSinceReattach = true;
@@ -54,6 +64,24 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             break;
         }
         if (!park) {
+            const drained = drains.legEnded('returned');
+            if (drained !== undefined) {
+                const reopenAfterMs = 'reconnectAfterMs' in drained ? drained.reconnectAfterMs : undefined;
+                if (reopenAfterMs !== undefined && taskId.current !== undefined && !opts?.signal?.aborted) {
+                    hostLog('debug', `liveHitlAskWire: runs.events(${taskId.current}) ended on the drain end frame — the engine is going down; reopening in ${reopenAfterMs}ms`);
+                    await abortableSleep(reopenAfterMs, opts?.signal ?? new AbortController().signal);
+                    if (!opts?.signal?.aborted) {
+                        const seq = led.lastSeq();
+                        led.beginStreamSegment();
+                        stream = deps.runsEvents(taskId.current, {
+                            ...(seq !== undefined ? { lastEventId: seq } : {}),
+                            ...(opts?.signal ? { signal: opts.signal } : {}),
+                        });
+                        continue;
+                    }
+                }
+                hostLog('debug', `liveHitlAskWire: runs.events ended on the drain end frame and is not reopened (${'giveUp' in drained ? drained.giveUp : taskId.current === undefined ? 'no run handle' : 'aborted'}) — ending this leg like a dropped stream`);
+            }
             yield* flushHeldWithInterruptRewrite(led, { signal: opts?.signal });
             return;
         }

package/dist/hitl/automaticAnswerVerdict.d.ts

@@ -1,5 +1,7 @@
 import { type CoreModeArbitrationRow } from '../generated/engineFactTables.js';
-export type AutomaticAnswerLane = 'mode_posture' | 'standing_rule';
+import { CORE_ASK_FACES } from '../generated/engineAskFaceTables.js';
+export type AutomaticAnswerLane = 'mode_posture' | 'standing_rule' | 'permission_request_hook';
+export type AutomaticAnswerAskFace = (typeof CORE_ASK_FACES)[number];
 export interface AutomaticAnswerFacts {
     readonly settingsAskRuleMatched?: boolean;
 }
@@ -17,5 +19,9 @@ export type AutomaticAnswerVerdict = {
     readonly kind: 'unknown';
     readonly why: AutomaticAnswerUnknownWhy;
 };
-export declare function foldModeArbitrationRow(classes: Iterable<string>): CoreModeArbitrationRow;
+export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "rule_unreadable" | "write_protection_unresolved" | "content_question" | "ancestor" | "dangerous_delete" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "ask_rule" | "denial_limit_fallback" | "classifier_no_ruling" | "requires_user_interaction" | "operator_forced" | "shell_floor" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", CoreModeArbitrationRow>>;
+export declare function foldModeArbitrationRow(classes: Iterable<string>, askFace?: AutomaticAnswerAskFace): CoreModeArbitrationRow;
 export declare function automaticAnswerVerdict(card: object | null | undefined, lane: AutomaticAnswerLane, facts?: AutomaticAnswerFacts | null): AutomaticAnswerVerdict;
+export declare function mandatedApprovalDetailOf(card: object | null | undefined): string;
+export type PermissionRequestHookScope = 'allow_or_deny' | 'deny_only' | 'skip';
+export declare function permissionRequestHookScope(verdict: AutomaticAnswerVerdict | null | undefined): PermissionRequestHookScope;

package/dist/hitl/automaticAnswerVerdict.js

@@ -1,8 +1,11 @@
 import { CORE_MODE_ARBITRATION, CORE_MODE_RELEASE_REASONS } from '../generated/engineFactTables.js';
-import { readOwnNonEmptyString } from '../ownKey.js';
+import { CORE_RELEASABLE_ASK_CLASSES_BY_FACE, CORE_SHELL_FACE_TOOL_NAMES } from '../generated/engineAskFaceTables.js';
+import { mandatedApprovalDetail } from '../gateVocabulary.js';
+import { readAskOrigin, readOwnNonEmptyString } from '../ownKey.js';
 import { readAskClassPairState } from './askClassPair.js';
 import { approvalAllowRuleShadowed } from './allowRuleShadow.js';
 import { approvalIsMandated, readApprovalMandate } from './toolApprovalWire.js';
+export const MODE_ARBITRATION = CORE_MODE_ARBITRATION;
 const TABLE = CORE_MODE_ARBITRATION;
 const ORIGIN_IMPLIES_CLASS = Object.freeze({
     content_question: 'content_question',
@@ -12,12 +15,26 @@ const ORIGIN_IMPLIES_CLASS = Object.freeze({
     ask_rule: 'ask_rule',
     denial_limit_fallback: 'denial_limit_fallback',
 });
-const MANDATE_WORD_IMPLIES_CLASS = Object.freeze({
-    operator_always: 'shell_floor',
-    write_protection_unresolved: 'write_protection_unresolved',
-});
+function mandateWordClass(word) {
+    if (word === 'operator_always')
+        return 'shell_floor';
+    return Object.hasOwn(TABLE, word) ? word : undefined;
+}
 const ORDINARY_ROW = CORE_MODE_ARBITRATION.ordinary;
-export function foldModeArbitrationRow(classes) {
+function bypassImmuneOn(c, face) {
+    const on = face !== undefined && Object.hasOwn(CORE_RELEASABLE_ASK_CLASSES_BY_FACE, face) ? face : 'other';
+    return !CORE_RELEASABLE_ASK_CLASSES_BY_FACE[on].includes(c);
+}
+function askFaceOfCard(card) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(card, 'toolName');
+        return d !== undefined && 'value' in d && typeof d.value === 'string' && CORE_SHELL_FACE_TOOL_NAMES.includes(d.value) ? 'shell' : 'other';
+    }
+    catch {
+        return 'other';
+    }
+}
+export function foldModeArbitrationRow(classes, askFace) {
     let any = false;
     let bypassImmune = false;
     let classifierEligible = true;
@@ -29,7 +46,7 @@ export function foldModeArbitrationRow(classes) {
             continue;
         const row = TABLE[c];
         any = true;
-        bypassImmune ||= row.bypassImmune;
+        bypassImmune ||= bypassImmuneOn(c, askFace);
         classifierEligible &&= row.classifierEligible;
         sandboxAdmission &&= row.sandboxAdmission;
         ruleMayClear &&= row.ruleMayClear;
@@ -39,8 +56,12 @@ export function foldModeArbitrationRow(classes) {
         return ORDINARY_ROW;
     return Object.freeze({ bypassImmune, classifierEligible, sandboxAdmission, ruleMayClear, hookAskFloor });
 }
-function laneBlocks(lane, row) {
-    return lane === 'mode_posture' ? row.bypassImmune : !row.ruleMayClear;
+function rowBlocks(lane, row) {
+    return lane === 'mode_posture' ? row.bypassImmune : lane === 'standing_rule' ? !row.ruleMayClear : row.hookAskFloor;
+}
+function classBlocks(lane, c, face) {
+    const row = TABLE[c];
+    return lane === 'mode_posture' ? bypassImmuneOn(c, face) : lane === 'standing_rule' ? !row.ruleMayClear : row.hookAskFloor;
 }
 function mustAsk(road, extra) {
     return Object.freeze({ kind: 'must_ask', road, ...(extra?.askClass !== undefined ? { askClass: extra.askClass } : {}), ...(extra?.origin !== undefined ? { origin: extra.origin } : {}) });
@@ -75,34 +96,33 @@ function readHostAskRuleMatched(facts) {
     }
 }
 export function automaticAnswerVerdict(card, lane, facts) {
-    if (lane !== 'mode_posture' && lane !== 'standing_rule')
+    if (lane !== 'mode_posture' && lane !== 'standing_rule' && lane !== 'permission_request_hook')
         return UNKNOWN.lane_not_recognised;
     try {
         if (typeof card !== 'object' || card === null)
             return UNKNOWN.card_unreadable;
-        const origin = readOwnNonEmptyString(evidenceView(card, 'origin'), 'origin');
+        const face = lane === 'mode_posture' ? askFaceOfCard(card) : undefined;
+        const origin = readAskOrigin(evidenceView(card, 'origin'));
         if (origin !== undefined && Object.hasOwn(ORIGIN_IMPLIES_CLASS, origin)) {
             const cls = ORIGIN_IMPLIES_CLASS[origin];
-            if (laneBlocks(lane, TABLE[cls]))
+            if (classBlocks(lane, cls, face))
                 return mustAsk('origin', { origin, askClass: cls });
         }
-        if (lane === 'standing_rule' && evidenceView(card, 'requiresRealApproval').requiresRealApproval === true)
+        if (lane !== 'mode_posture' && evidenceView(card, 'requiresRealApproval').requiresRealApproval === true)
             return mustAsk('requires_real_approval');
         if (evidenceView(card, 'governanceForced').governanceForced === true)
             return mustAsk('governance');
         if (lane === 'mode_posture') {
             const word = readApprovalMandate(evidenceView(card, 'mandate'));
-            if (word !== undefined && Object.hasOwn(MANDATE_WORD_IMPLIES_CLASS, word)) {
-                const cls = MANDATE_WORD_IMPLIES_CLASS[word];
-                if (laneBlocks(lane, TABLE[cls]))
-                    return mustAsk('mandate_word', { askClass: cls });
-            }
+            const cls = word !== undefined ? mandateWordClass(word) : undefined;
+            if (cls !== undefined && classBlocks(lane, cls, face))
+                return mustAsk('mandate_word', { askClass: cls });
         }
         else {
             const mandateView = evidenceView(card, 'mandated', 'ruleOffersAbsence', 'mandate');
             if (approvalIsMandated(mandateView))
                 return mustAsk('mandated');
-            if (approvalAllowRuleShadowed(card) || readOwnNonEmptyString(mandateView, 'ruleOffersAbsence') === 'shadowed')
+            if (lane === 'standing_rule' && (approvalAllowRuleShadowed(card) || readOwnNonEmptyString(mandateView, 'ruleOffersAbsence') === 'shadowed'))
                 return mustAsk('allow_rule_shadow');
         }
         const pair = readAskClassPairState(card);
@@ -110,7 +130,7 @@ export function automaticAnswerVerdict(card, lane, facts) {
             return UNKNOWN.classes_malformed;
         if (pair.state === 'absent')
             return UNKNOWN.classes_absent;
-        const folded = foldModeArbitrationRow(pair.classes);
+        const folded = foldModeArbitrationRow(pair.classes, face);
         let anyKnown = false;
         let firstBlocking;
         let anyUnknown = false;
@@ -120,14 +140,14 @@ export function automaticAnswerVerdict(card, lane, facts) {
                 continue;
             }
             anyKnown = true;
-            if (firstBlocking === undefined && laneBlocks(lane, TABLE[c]))
+            if (firstBlocking === undefined && classBlocks(lane, c, face))
                 firstBlocking = c;
         }
-        if (anyKnown && laneBlocks(lane, folded))
+        if (anyKnown && rowBlocks(lane, folded))
             return mustAsk('ask_class', firstBlocking !== undefined ? { askClass: firstBlocking } : undefined);
         if (anyUnknown)
             return UNKNOWN.class_not_in_table;
-        if (lane === 'standing_rule')
+        if (lane !== 'mode_posture')
             return MAY_ANSWER;
         const matched = readHostAskRuleMatched(facts);
         if (matched === true)
@@ -141,3 +161,31 @@ export function automaticAnswerVerdict(card, lane, facts) {
         return UNKNOWN.card_unreadable;
     }
 }
+export function mandatedApprovalDetailOf(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return mandatedApprovalDetail();
+        const pair = readAskClassPairState(card);
+        if (pair.state !== 'pair')
+            return mandatedApprovalDetail();
+        if (pair.classes.some((c) => !Object.hasOwn(TABLE, c)))
+            return mandatedApprovalDetail();
+        const row = foldModeArbitrationRow(pair.classes);
+        if (row.classifierEligible || row.sandboxAdmission)
+            return mandatedApprovalDetail();
+        return MANDATED_NO_AUTOMATIC_CHECK_DETAIL;
+    }
+    catch {
+        return mandatedApprovalDetail();
+    }
+}
+const MANDATED_NO_AUTOMATIC_CHECK_DETAIL = 'no saved allow rule and no remembered answer can retire this question, and no automatic check answers it; each call is settled on its own, by you here, and an answer covers only that call';
+export function permissionRequestHookScope(verdict) {
+    try {
+        const kind = typeof verdict === 'object' && verdict !== null ? verdict.kind : undefined;
+        return kind === 'may_answer' ? 'allow_or_deny' : kind === 'must_ask' ? 'skip' : 'deny_only';
+    }
+    catch {
+        return 'deny_only';
+    }
+}

package/dist/hitl/crashConverged.js

@@ -3,6 +3,8 @@ const CRASH_CONVERGED_CAUSE_WORDS = Object.freeze({
     shutdown_before_park: true,
 });
 export const isCrashConvergedCause = (v) => typeof v === 'string' && Object.hasOwn(CRASH_CONVERGED_CAUSE_WORDS, v);
+const _crashConvergedCausePin = true;
+void _crashConvergedCausePin;
 const isString = (v) => typeof v === 'string';
 const isNumber = (v) => typeof v === 'number';
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;

package/dist/hitl/decisionConflict.d.ts

@@ -0,0 +1,3 @@
+export type DecisionRefusalConflict = 'binding_mismatch' | 'row_integrity' | 'format_version' | 'answer_invalid';
+export declare function decisionConflictOf(err: unknown): DecisionRefusalConflict | undefined;
+export declare const DECISION_ANSWER_INVALID_CONTENT = "The engine rejected the answer itself because it does not fit the question that was asked \u00B7 Nothing was decided and the question is still waiting \u00B7 Correct the answer and send it again";