@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/hitl/decisionRefusalCarrier.js

@@ -0,0 +1,348 @@
+import { isSecretKeyName } from '../seatContract.js';
+import { placeThrownExtraOnCopy, wireFailureCoreOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { decideFailureNote } from '../decideFailureNote.js';
+import { REFUSAL_ROUTES, classifyDecisionRefusal, decisionRefusalAskReading, decisionRefusalSaysAskGone, mintDecisionRefusalReading, readDecisionRefusalReading, } from './decisionRefusal.js';
+import { decisionConflictOf } from './decisionConflict.js';
+import { resumeReopenFromError } from './suspendedReopen.js';
+import { askGoneFromError, decideParkMovedFromError, decideRefusalFromError, decideRequiresBindingFromError } from '../decideReceipt.js';
+import { corruptStoredRowWhere, resumeRetryLaterFromError, scenarioDenyFromError } from '../wireErrorTriage.js';
+import { checkpointUnsupportedVersionFromError, parkedResumeStartupFromError, refusedParkFromError, requireExistingSessionRefusalFromError, resumeContextUnavailableFromError, resumePolicyBlockFromError, resumeRefusalFromError, } from '../resumeRefusalCopy.js';
+import { admissionWallRefusalFromError, autonomyLaneRefusalFromError, bodyShapeRefusalFromError, cancelConflictFromError, denyAttributionRefusalFromError, envCredentialRefusalFromError, fieldLimitRefusalFromError, fleetLeaseUnavailableFromError, hostPostureRefusalFromError, quotaExhaustedFromError, runConcurrencyCapFromError, sessionArchiveStampedFromError, sessionDeleteConflictFromError, sessionIdRetiredFromError, settingsHooksRefusalFromError, toolDeclarationRefusalFromError, unreadRequestMembersFromError, unsupportedRuleRefusalFromError, usageWindowExhaustedFromError, userAttachmentRefusalFromError, userInvokedSkillRefusalFromError, } from '../wireRefusalCopy.js';
+import { scenarioRefusalFromError } from '../scenarioRefusal.js';
+import { inheritEnvRefusalFromError } from '../inheritEnvWire.js';
+const DECISION_WORDS = { approve: true, deny: true };
+const DECISIONS = Object.freeze([undefined, ...Object.keys(DECISION_WORDS)]);
+const CONTEXTS = Object.freeze([undefined, ...REFUSAL_ROUTES.map((route) => Object.freeze({ route }))]);
+const READERS = Object.freeze({
+    classifyDecisionRefusal: (e) => CONTEXTS.map((c) => classifyDecisionRefusal(e, c)),
+    readDecisionRefusalReading: (e) => CONTEXTS.map((c) => readDecisionRefusalReading(e, c)),
+    mintDecisionRefusalReading: (e) => [mintDecisionRefusalReading(e, undefined, true), mintDecisionRefusalReading(e, undefined, false)],
+    decisionRefusalAskReading: (e) => decisionRefusalAskReading(e),
+    decisionRefusalSaysAskGone: (e) => decisionRefusalSaysAskGone(e),
+    decideFailureNote: (e) => DECISIONS.map((d) => decideFailureNote(e, d)),
+    decisionConflictOf: (e) => decisionConflictOf(e),
+    corruptStoredRowWhere: (e) => corruptStoredRowWhere(e),
+    wireFailureCoreOf: (e) => wireFailureCoreOf(e),
+    wireFailureTextsOf: (e) => wireFailureTextsOf(e).reason,
+    admissionWallRefusalFromError: (e) => admissionWallRefusalFromError(e),
+    askGoneFromError: (e) => askGoneFromError(e),
+    autonomyLaneRefusalFromError: (e) => autonomyLaneRefusalFromError(e),
+    bodyShapeRefusalFromError: (e) => bodyShapeRefusalFromError(e),
+    cancelConflictFromError: (e) => cancelConflictFromError(e),
+    checkpointUnsupportedVersionFromError: (e) => checkpointUnsupportedVersionFromError(e),
+    decideParkMovedFromError: (e) => decideParkMovedFromError(e),
+    decideRefusalFromError: (e) => decideRefusalFromError(e),
+    decideRequiresBindingFromError: (e) => decideRequiresBindingFromError(e),
+    denyAttributionRefusalFromError: (e) => [denyAttributionRefusalFromError(e, true), denyAttributionRefusalFromError(e, false)],
+    envCredentialRefusalFromError: (e) => envCredentialRefusalFromError(e),
+    fieldLimitRefusalFromError: (e) => fieldLimitRefusalFromError(e),
+    fleetLeaseUnavailableFromError: (e) => fleetLeaseUnavailableFromError(e),
+    hostPostureRefusalFromError: (e) => hostPostureRefusalFromError(e, undefined),
+    inheritEnvRefusalFromError: (e) => inheritEnvRefusalFromError(e, undefined),
+    parkedResumeStartupFromError: (e) => DECISIONS.map((d) => parkedResumeStartupFromError(e, d)),
+    quotaExhaustedFromError: (e) => quotaExhaustedFromError(e),
+    refusedParkFromError: (e) => refusedParkFromError(e),
+    requireExistingSessionRefusalFromError: (e) => requireExistingSessionRefusalFromError(e),
+    resumeContextUnavailableFromError: (e) => resumeContextUnavailableFromError(e),
+    resumePolicyBlockFromError: (e) => resumePolicyBlockFromError(e),
+    resumeRefusalFromError: (e) => resumeRefusalFromError(e),
+    resumeReopenFromError: (e) => resumeReopenFromError(e),
+    resumeRetryLaterFromError: (e) => resumeRetryLaterFromError(e),
+    runConcurrencyCapFromError: (e) => runConcurrencyCapFromError(e),
+    scenarioDenyFromError: (e) => scenarioDenyFromError(e),
+    scenarioRefusalFromError: (e) => scenarioRefusalFromError(e),
+    sessionArchiveStampedFromError: (e) => sessionArchiveStampedFromError(e),
+    sessionDeleteConflictFromError: (e) => sessionDeleteConflictFromError(e),
+    sessionIdRetiredFromError: (e) => sessionIdRetiredFromError(e),
+    settingsHooksRefusalFromError: (e) => settingsHooksRefusalFromError(e),
+    toolDeclarationRefusalFromError: (e) => toolDeclarationRefusalFromError(e),
+    unreadRequestMembersFromError: (e) => unreadRequestMembersFromError(e),
+    unsupportedRuleRefusalFromError: (e) => unsupportedRuleRefusalFromError(e),
+    usageWindowExhaustedFromError: (e) => usageWindowExhaustedFromError(e),
+    userAttachmentRefusalFromError: (e) => userAttachmentRefusalFromError(e),
+    userInvokedSkillRefusalFromError: (e) => userInvokedSkillRefusalFromError(e),
+});
+export function decisionRefusalCarrierReaderNames() {
+    return Object.freeze(Object.keys(READERS));
+}
+const COPY_DEPTH_MAX = 16;
+const COPY_NODES_MAX = 4096;
+const COPY_KEYS_MAX = 1024;
+const SKIP = Symbol('carrier-skip');
+function ownDataDescriptor(o, k) {
+    try {
+        const d = Reflect.getOwnPropertyDescriptor(o, k);
+        return d !== undefined && Object.hasOwn(d, 'value') ? { value: d.value } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function copyOf(v, depth, run) {
+    if (v === null || v === undefined || typeof v === 'string' || typeof v === 'boolean' || typeof v === 'number')
+        return v;
+    if (typeof v !== 'object' && typeof v !== 'function')
+        return SKIP;
+    const o = v;
+    if (depth > COPY_DEPTH_MAX || run.nodes >= COPY_NODES_MAX || run.path.has(o))
+        return SKIP;
+    run.nodes += 1;
+    run.path.add(o);
+    try {
+        let isArray;
+        try {
+            isArray = Array.isArray(o);
+        }
+        catch {
+            return SKIP;
+        }
+        if (isArray) {
+            const len = ownDataDescriptor(o, 'length')?.value;
+            if (typeof len !== 'number' || !Number.isInteger(len) || len < 0 || len > COPY_KEYS_MAX)
+                return SKIP;
+            const out = new Array(len);
+            for (let i = 0; i < len; i += 1) {
+                const d = ownDataDescriptor(o, String(i));
+                if (d === undefined)
+                    continue;
+                const c = copyOf(d.value, depth + 1, run);
+                if (c !== SKIP)
+                    out[i] = c;
+            }
+            return out;
+        }
+        let keys;
+        try {
+            keys = Reflect.ownKeys(o);
+        }
+        catch {
+            return SKIP;
+        }
+        const out = {};
+        let taken = 0;
+        for (let i = 0; i < keys.length; i += 1) {
+            const k = keys[i];
+            if (typeof k !== 'string')
+                continue;
+            if (taken >= COPY_KEYS_MAX)
+                break;
+            const d = ownDataDescriptor(o, k);
+            if (d === undefined)
+                continue;
+            const c = copyOf(d.value, depth + 1, run);
+            if (c === SKIP)
+                continue;
+            Object.defineProperty(out, k, { value: c, writable: true, enumerable: true, configurable: true });
+            taken += 1;
+        }
+        placeThrownExtraOnCopy(o, out, (bag) => {
+            const c = copyOf(bag, depth + 1, run);
+            return c === SKIP ? undefined : c;
+        });
+        return out;
+    }
+    finally {
+        run.path.delete(o);
+    }
+}
+const newWatch = (node) => ({ node, touched: new Set(), kids: new Map(), enumerated: false, whole: false });
+function viewOf(w, watches) {
+    if (w.view !== undefined)
+        return w.view;
+    const kid = (k, v) => {
+        if (typeof v !== 'object' || v === null)
+            return v;
+        let c = w.kids.get(k);
+        if (c === undefined || c.node !== v) {
+            c = newWatch(v);
+            w.kids.set(k, c);
+        }
+        return viewOf(c, watches);
+    };
+    const view = new Proxy(w.node, {
+        getOwnPropertyDescriptor(t, k) {
+            const d = Reflect.getOwnPropertyDescriptor(t, k);
+            if (typeof k !== 'string')
+                return d;
+            w.touched.add(k);
+            return d !== undefined && Object.hasOwn(d, 'value') ? { ...d, value: kid(k, d.value) } : d;
+        },
+        get(t, k, receiver) {
+            if (typeof k !== 'string')
+                return Reflect.get(t, k, receiver);
+            w.touched.add(k);
+            return Object.hasOwn(t, k) ? kid(k, t[k]) : Reflect.get(t, k, receiver);
+        },
+        has(t, k) {
+            if (typeof k === 'string')
+                w.touched.add(k);
+            return Reflect.has(t, k);
+        },
+        ownKeys(t) {
+            w.enumerated = true;
+            return Reflect.ownKeys(t);
+        },
+    });
+    w.view = view;
+    watches.set(view, w);
+    return view;
+}
+function ownKeysReading(o) {
+    try {
+        return { kind: 'listed', keys: Reflect.ownKeys(o) };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+function consumeOutput(out, watches, seen, depth) {
+    if ((typeof out !== 'object' && typeof out !== 'function') || out === null || depth > COPY_DEPTH_MAX || seen.has(out))
+        return;
+    const w = watches.get(out);
+    if (w !== undefined) {
+        w.whole = true;
+        return;
+    }
+    seen.add(out);
+    const listed = ownKeysReading(out);
+    if (listed.kind === 'unreadable')
+        return;
+    for (let i = 0; i < listed.keys.length; i += 1) {
+        const k = listed.keys[i];
+        if (typeof k !== 'string')
+            continue;
+        const d = ownDataDescriptor(out, k);
+        if (d !== undefined)
+            consumeOutput(d.value, watches, seen, depth + 1);
+    }
+}
+function wholeOf(v) {
+    if (typeof v !== 'object' || v === null)
+        return v;
+    if (Array.isArray(v)) {
+        const out = new Array(v.length);
+        for (let i = 0; i < v.length; i += 1)
+            if (Object.hasOwn(v, i))
+                out[i] = wholeOf(v[i]);
+        return out;
+    }
+    const out = {};
+    const names = Object.keys(v);
+    for (let i = 0; i < names.length; i += 1) {
+        const k = names[i];
+        if (isSecretKeyName(k))
+            continue;
+        Object.defineProperty(out, k, { value: wholeOf(v[k]), writable: true, enumerable: true, configurable: true });
+    }
+    return out;
+}
+function carried(w, k, v) {
+    if (typeof v !== 'object' || v === null)
+        return v;
+    if (w.whole)
+        return wholeOf(v);
+    const c = w.kids.get(k);
+    if (c !== undefined && c.node === v)
+        return pruned(c);
+    return Array.isArray(v) ? [] : {};
+}
+function pruned(w) {
+    if (w.whole)
+        return wholeOf(w.node);
+    const src = w.node;
+    if (Array.isArray(src)) {
+        const out = new Array(src.length);
+        for (let i = 0; i < src.length; i += 1) {
+            const k = String(i);
+            if (!Object.hasOwn(src, k))
+                continue;
+            if (w.touched.has(k))
+                out[i] = carried(w, k, src[k]);
+            else if (w.enumerated)
+                out[i] = null;
+        }
+        return out;
+    }
+    const out = {};
+    const names = Object.keys(src);
+    for (let i = 0; i < names.length; i += 1) {
+        const k = names[i];
+        if (isSecretKeyName(k))
+            continue;
+        const value = w.touched.has(k) ? carried(w, k, src[k]) : w.enumerated ? null : SKIP;
+        if (value !== SKIP)
+            Object.defineProperty(out, k, { value, writable: true, enumerable: true, configurable: true });
+    }
+    return out;
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null && !Object.isFrozen(v)) {
+        Object.freeze(v);
+        const names = Object.keys(v);
+        for (let i = 0; i < names.length; i += 1)
+            deepFreeze(v[names[i]]);
+    }
+    return v;
+}
+function sameReading(a, b, depth) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null || depth > COPY_DEPTH_MAX * 2)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    for (let i = 0; i < ka.length; i += 1) {
+        const k = ka[i];
+        if (k !== kb[i] || !sameReading(a[k], b[k], depth + 1))
+            return false;
+    }
+    return true;
+}
+function readAll(e) {
+    return Object.values(READERS).map((read) => {
+        try {
+            return read(e);
+        }
+        catch {
+            return Symbol('reader-threw');
+        }
+    });
+}
+export function decisionRefusalCarrierOf(err) {
+    try {
+        if ((typeof err !== 'object' && typeof err !== 'function') || err === null)
+            return undefined;
+        const copy = copyOf(err, 0, { nodes: 0, path: new Set() });
+        if (typeof copy !== 'object' || copy === null || Array.isArray(copy))
+            return undefined;
+        const root = newWatch(copy);
+        const watches = new WeakMap();
+        const view = viewOf(root, watches);
+        const readers = Object.values(READERS);
+        for (let i = 0; i < readers.length; i += 1) {
+            const read = readers[i];
+            let out;
+            try {
+                out = read(view);
+            }
+            catch {
+                return undefined;
+            }
+            consumeOutput(out, watches, new Set(), 0);
+        }
+        const carrier = deepFreeze(pruned(root));
+        const original = readAll(err);
+        const fromCarrier = readAll(carrier);
+        for (let i = 0; i < original.length; i += 1)
+            if (!sameReading(original[i], fromCarrier[i], 0))
+                return undefined;
+        return carrier;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/decisionSend.d.ts

@@ -1,5 +1,7 @@
 import type { AgentClient, ElicitResponse } from '@sema-agent/sdk';
 import type { UiLanguage } from '../env/uiLanguage.js';
+import type { ToolPermissionSettledElsewhere } from './approvalResolution.js';
+import { type ToolPermissionAck } from '../seatContract.js';
 import { type AskGoneDetail } from '../decideReceipt.js';
 import type { ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecisionNoteAudit } from './approvalDecisionNoteAudit.js';
@@ -12,6 +14,10 @@ export declare const HITL_DECISION_NOT_APPLIED_CAUSES: readonly ["gone", "parked
 export type HitlDecisionNotAppliedCause = (typeof HITL_DECISION_NOT_APPLIED_CAUSES)[number];
 export declare const HITL_DECISION_UNCONFIRMED_CAUSES: readonly ["transport", "server_error", "local_error", "aborted", "gone_after_retry"];
 export type HitlDecisionUnconfirmedCause = (typeof HITL_DECISION_UNCONFIRMED_CAUSES)[number];
+export type ToolPermissionUnconfirmedCause = HitlDecisionUnconfirmedCause | 'registry_unreadable';
+export interface ToolPermissionUnconfirmed {
+    readonly cause: ToolPermissionUnconfirmedCause;
+}
 export declare const HITL_DECISION_NOT_SENT_CAUSES: readonly ["aborted", "duplicate_in_flight", "invalid_request", "no_verb", "not_an_answer"];
 export type HitlDecisionNotSentCause = (typeof HITL_DECISION_NOT_SENT_CAUSES)[number];
 export interface HitlApprovalDecisionRequest {
@@ -64,6 +70,7 @@ interface HitlDecisionOutcomeBase {
     readonly attempts: number;
     readonly fallback?: 'approval';
     readonly noteDropped?: true;
+    readonly allowNoteDropped?: true;
     readonly rememberDropped?: true;
     readonly allowSessionCarried?: true;
     readonly attributionDropped?: true;
@@ -115,5 +122,8 @@ export interface HitlDecisionSendTiming {
 export declare function __setHitlDecisionSendTimingForTests(t?: HitlDecisionSendTiming): void;
 export declare function hitlAskIdempotencyKey(askId: string, verdict: 'approve' | 'deny'): string;
 export declare function sendHitlDecision(request: HitlDecisionSendRequest, deps: HitlDecisionSendDeps): Promise<HitlDecisionSendOutcome>;
+export declare function toolPermissionSettledLine(fact: ToolPermissionSettledElsewhere | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function toolPermissionUnconfirmedLine(ack: ToolPermissionAck | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function toolPermissionUnconfirmedOf(thrown: {} | null | undefined, signal?: AbortSignal): ToolPermissionUnconfirmed | undefined;
 export declare function hitlDecisionOutcomeContent(outcome: HitlDecisionSendOutcome, lang?: UiLanguage): string | undefined;
 export {};

package/dist/hitl/decisionSend.js

@@ -1,6 +1,7 @@
 import { settleWithinDeadline } from '../abortableSleep.js';
 import { hostLog } from '../host.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
+import { readToolPermissionAckState } from '../seatContract.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { askGoneFromError } from '../decideReceipt.js';
 import { appendOwnElement, guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
@@ -14,7 +15,7 @@ import { ASK_DECIDED_CODE, classifyDeliveredDecisionRefusal, decisionRefusalClos
 import { sessionAllowEligible } from './sessionAllowRoute.js';
 import { addDecisionOpKeys, closeDecisionOp, decisionLedgerKeysOf, decisionOpsWithKey, openDecisionOp } from './decisionLedger.js';
 import { hostHoldIsActive, takeHostHoldLedgerOp, tryHoldApprovalNow } from './approvalHolds.js';
-import { answerPayloadFor, decisionAttributionKeyOf, isToolApprovalRespondReplayed, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, } from './toolApprovalWire.js';
+import { allowNoteReadingOf, answerPayloadFor, decisionAttributionKeyOf, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, replayVerdictFrom, settlementAckOf, } from './toolApprovalWire.js';
 export const HITL_DECISION_FAMILIES = Object.freeze(['approval', 'ask', 'elicitation']);
 export const HITL_DECISION_NOT_APPLIED_CAUSES = Object.freeze(['gone', 'parked', 'parking', 'lane_disabled', 'refused', 'idempotency_crossed']);
 export const HITL_DECISION_UNCONFIRMED_CAUSES = Object.freeze(['transport', 'server_error', 'local_error', 'aborted', 'gone_after_retry']);
@@ -163,9 +164,10 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
         const hint = view !== undefined ? ownReadingSlot(view, 'retryAfterMs') : undefined;
         return { ...base, kind: 'not_applied', cause: 'parking', ...(view !== undefined ? { parking: view, ...(hint !== undefined ? { retryAfterMs: hint } : {}) } : {}) };
     }
-    const parsed = readToolApprovalRespondAck(raw);
-    if (parsed !== undefined && isToolApprovalRespondReplayed(parsed)) {
-        const first = parsed.approvalId === approvalId ? verdictOf(parsed.decision) : undefined;
+    const parsed = settlementAckOf(readToolApprovalRespondAck(raw));
+    const replay = replayVerdictFrom(raw, parsed, approvalId);
+    if (replay.kind === 'replayed') {
+        const first = verdictOf(replay.firstDecision);
         return {
             ...base,
             kind: 'settled_elsewhere',
@@ -173,8 +175,8 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
             ...(first !== undefined && ours !== undefined && first !== ours ? { contrary: true } : {}),
         };
     }
-    if (ownTrue(raw, 'idempotent'))
-        return { ...base, kind: 'settled_elsewhere' };
+    if (replay.kind === 'unreadable')
+        return { ...base, kind: 'unconfirmed', cause: 'local_error' };
     const ack = parsed !== undefined && parsed.approvalId === approvalId ? parsed : undefined;
     return { ...base, kind: 'applied', ...(ack !== undefined ? { ack } : {}), ...(ctx.noteCapable ? { noteAudit: readDecisionNoteAudit(raw) } : {}) };
 }
@@ -183,14 +185,12 @@ function bodyFacts(answer, payload, rememberUnsupported) {
     return {
         ...(reason !== undefined && reason.trim() !== '' && payload.note === undefined ? { noteDropped: true } : {}),
         ...(rememberUnsupported && answer.kind === 'allow' && answer.allowSession === true ? { rememberDropped: true } : {}),
+        ...(answer.kind === 'allow' && allowNoteReadingOf(answer).kind === 'text' ? { allowNoteDropped: true } : {}),
     };
 }
 function answerGateCannotTake(out) {
     return out.kind === 'not_applied' && (out.cause === 'gone' || out.cause === 'parking' || out.cause === 'lane_disabled');
 }
-function ownTrue(raw, key) {
-    return typeof raw === 'object' && raw !== null && guardedRead(() => readOwnDataValue(raw, key)) === true;
-}
 async function sendAskFamily(respondForFallback, decideAsk, req, ctx) {
     const payload = answerPayloadFor(req.answer, 'respond', { approvalDecisionNoteCapable: ctx.noteCapable });
     if (payload === undefined)
@@ -361,8 +361,10 @@ function snapshotAnswer(raw) {
     if (kind === 'allow') {
         const allowSession = guardedRead(() => readOwnDataValue(raw, 'allowSession')) === true;
         const edited = guardedRead(() => readOwnDataValue(raw, 'updatedInput'));
+        const noteReading = guardedRead(() => allowNoteReadingOf(raw));
+        const note = noteReading?.kind === 'text' ? noteReading.text : undefined;
         if (edited === undefined)
-            return Object.freeze({ kind: 'allow', allowSession });
+            return Object.freeze({ kind: 'allow', allowSession, ...(note !== undefined ? { note } : {}) });
         let copy;
         try {
             const text = JSON.stringify(edited);
@@ -373,7 +375,7 @@ function snapshotAnswer(raw) {
         catch {
             return undefined;
         }
-        return Object.freeze({ kind: 'allow', allowSession, updatedInput: copy });
+        return Object.freeze({ kind: 'allow', allowSession, ...(note !== undefined ? { note } : {}), updatedInput: copy });
     }
     if (kind === 'deny') {
         const reason = guardedRead(() => readOwnDataValue(raw, 'reason'));
@@ -560,6 +562,48 @@ export async function sendHitlDecision(request, deps) {
         ownHold.release(out.kind === 'applied' || out.kind === 'settled_elsewhere' ? 'answered' : undefined);
     return Object.freeze(out);
 }
+function settledElsewhereContraryContent(first, lang) {
+    return first === 'deny'
+        ? renderMessage(msg('approval.decision.settledElsewhereContrary.deniedFirst'), lang)
+        : renderMessage(msg('approval.decision.settledElsewhereContrary.approvedFirst'), lang);
+}
+export function toolPermissionSettledLine(fact, lang) {
+    try {
+        if (typeof fact !== 'object' || fact === null)
+            return undefined;
+        if (readOwnDataValue(fact, 'contrary') !== true)
+            return undefined;
+        const first = readOwnDataValue(fact, 'firstDecision');
+        return first === 'allow' || first === 'deny' ? settledElsewhereContraryContent(first, lang) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function unconfirmedDecisionContent(cause, lang) {
+    return cause === 'gone_after_retry' ? renderMessage(msg('approval.decision.unconfirmedAfterRetry'), lang) : renderMessage(msg('approval.decideAck.unconfirmed'), lang);
+}
+export function toolPermissionUnconfirmedLine(ack, lang) {
+    try {
+        const state = readToolPermissionAckState(ack);
+        return state !== undefined && state.kind === 'unconfirmed' ? unconfirmedDecisionContent(state.cause, lang) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function toolPermissionUnconfirmedOf(thrown, signal) {
+    try {
+        const out = outcomeOfThrown(thrown, 'approval', undefined, signal, newSendTally(), false);
+        if (out.kind !== 'unconfirmed')
+            return undefined;
+        const cause = HITL_DECISION_UNCONFIRMED_CAUSES.find((w) => w === out.cause);
+        return cause === undefined ? undefined : Object.freeze({ cause });
+    }
+    catch {
+        return Object.freeze({ cause: 'local_error' });
+    }
+}
 export function hitlDecisionOutcomeContent(outcome, lang) {
     try {
         if (typeof outcome !== 'object' || outcome === null)
@@ -569,14 +613,10 @@ export function hitlDecisionOutcomeContent(outcome, lang) {
             if (readOwnDataValue(outcome, 'contrary') !== true)
                 return undefined;
             const first = readOwnDataValue(outcome, 'firstDecision');
-            if (first === 'deny')
-                return renderMessage(msg('approval.decision.settledElsewhereContrary.deniedFirst'), lang);
-            if (first === 'approve')
-                return renderMessage(msg('approval.decision.settledElsewhereContrary.approvedFirst'), lang);
-            return undefined;
+            return first === 'deny' || first === 'approve' ? settledElsewhereContraryContent(first, lang) : undefined;
         }
         if (kind === 'unconfirmed' && readOwnDataValue(outcome, 'cause') === 'gone_after_retry')
-            return renderMessage(msg('approval.decision.unconfirmedAfterRetry'), lang);
+            return unconfirmedDecisionContent('gone_after_retry', lang);
         return undefined;
     }
     catch {

package/dist/hitl/editedApprovalAcceptance.d.ts

@@ -0,0 +1,25 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare const EDITED_APPROVAL_STATES: readonly ["accepts", "refuses", "unknown"];
+export type EditedApprovalState = (typeof EDITED_APPROVAL_STATES)[number];
+export declare const EDITED_APPROVAL_BASES: Readonly<{
+    accepts: readonly ["args_available"];
+    refuses: readonly ["args_unavailable"];
+    unknown: readonly ["card_unreadable", "slot_unreadable", "slot_malformed"];
+}>;
+interface EditedApprovalAccepts {
+    readonly state: 'accepts';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.accepts)[number];
+}
+interface EditedApprovalRefuses {
+    readonly state: 'refuses';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.refuses)[number];
+    readonly askStaysPending: true;
+}
+interface EditedApprovalUnknown {
+    readonly state: 'unknown';
+    readonly basis: (typeof EDITED_APPROVAL_BASES.unknown)[number];
+}
+export type EditedApprovalAcceptance = EditedApprovalAccepts | EditedApprovalRefuses | EditedApprovalUnknown;
+export declare function editedApprovalAcceptanceOf(card: {} | null | undefined): EditedApprovalAcceptance;
+export declare function editedApprovalRefusedLine(lang?: UiLanguage): string;
+export {};

package/dist/hitl/editedApprovalAcceptance.js

@@ -0,0 +1,26 @@
+import { msg, renderMessage } from '../i18n/translate.js';
+import { slotReadOf } from '../wireFailureShape.js';
+export const EDITED_APPROVAL_STATES = Object.freeze(['accepts', 'refuses', 'unknown']);
+export const EDITED_APPROVAL_BASES = Object.freeze({
+    accepts: Object.freeze(['args_available']),
+    refuses: Object.freeze(['args_unavailable']),
+    unknown: Object.freeze(['card_unreadable', 'slot_unreadable', 'slot_malformed']),
+});
+const ACCEPTS = Object.freeze({ state: 'accepts', basis: 'args_available' });
+const REFUSES = Object.freeze({ state: 'refuses', basis: 'args_unavailable', askStaysPending: true });
+const UNKNOWN_CARD = Object.freeze({ state: 'unknown', basis: 'card_unreadable' });
+const UNKNOWN_SLOT = Object.freeze({ state: 'unknown', basis: 'slot_unreadable' });
+const UNKNOWN_MALFORMED = Object.freeze({ state: 'unknown', basis: 'slot_malformed' });
+export function editedApprovalAcceptanceOf(card) {
+    if (typeof card !== 'object' || card === null)
+        return UNKNOWN_CARD;
+    const read = slotReadOf(card, 'argsUnavailable');
+    if (read.presence === 'unreadable')
+        return UNKNOWN_SLOT;
+    if (read.presence === 'absent' || read.value === undefined)
+        return ACCEPTS;
+    return read.value === true ? REFUSES : UNKNOWN_MALFORMED;
+}
+export function editedApprovalRefusedLine(lang) {
+    return renderMessage(msg('approval.editRefusal.line', { stem: msg('approval.editRefusal.stem') }), lang);
+}

package/dist/hitl/elicitationRefusal.d.ts

@@ -0,0 +1,4 @@
+import type { EventLegElicitationFrame } from '../eventLeg.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+import type { HitlDecisionSendOutcome } from './decisionSend.js';
+export declare function elicitationRefusedLine(frame: EventLegElicitationFrame, outcome: HitlDecisionSendOutcome, lang?: UiLanguage): string | undefined;

package/dist/hitl/elicitationRefusal.js

@@ -0,0 +1,23 @@
+import { capForDisplay } from '../fleetTaskDesc.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
+const SERVER_NAME_SHOWN_MAX = 40;
+export function elicitationRefusedLine(frame, outcome, lang) {
+    try {
+        if (typeof frame !== 'object' || frame === null || typeof outcome !== 'object' || outcome === null)
+            return undefined;
+        if (guardedRead(() => readOwnDataValue(frame, 'type')) !== 'elicitation')
+            return undefined;
+        if (guardedRead(() => readOwnDataValue(outcome, 'family')) !== 'elicitation')
+            return undefined;
+        if (guardedRead(() => readOwnDataValue(outcome, 'kind')) !== 'applied')
+            return undefined;
+        const name = guardedRead(() => readOwnDataNonEmptyString(frame, 'mcpServerName'));
+        return name === undefined
+            ? renderMessage(msg('mcp.elicitation.refused.unnamed'), lang)
+            : renderMessage(msg('mcp.elicitation.refused.named', { server: capForDisplay(name, SERVER_NAME_SHOWN_MAX) }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/hitl/frameRouter.d.ts

@@ -38,9 +38,8 @@ export interface AskGateWireDeps {
     onToolApprovalOutcome?: (frame: ToolApprovalFrame, resolution: ApprovalResolution) => void | Promise<void>;
     onDecideOperation?: DecideOperationObserver;
     onReplayedApproval?: (frame: ToolApprovalFrame, disposition: ReplayedApprovalDisposition) => void | Promise<void>;
+    engineGeneration?: () => number;
 }
-export declare function setBridgeRunHandleFallback(deps: object, read: () => string | undefined): void;
-export declare function bridgeRunHandleFallbackOf(deps: object): string | undefined;
 type GateKind = 'ask' | 'fs';
 export interface GatePark {
     gate: GateKind;
@@ -73,6 +72,7 @@ export interface FrameRouterCtx {
     deps: AskGateWireDeps;
     taskId: TaskIdRef;
     signal?: AbortSignal | undefined;
+    streamGeneration?: number | undefined;
 }
 export declare function isAskTool(toolName: string | undefined): boolean;
 export declare function questionCardVerdict(carrier: object | null | undefined): boolean | undefined;