@sema-agent/client-core 0.110.0 → 0.112.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,6 +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';
@@ -13,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 {
@@ -118,5 +123,7 @@ export declare function __setHitlDecisionSendTimingForTests(t?: HitlDecisionSend
 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 { allowNoteReadingOf, answerPayloadFor, decisionAttributionKeyOf, readApprovalDenySettledBy, readToolApprovalRespondAck, readToolApprovalRespondParking, replayedFirstDecisionOf, settlementAckOf, } 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']);
@@ -164,9 +165,9 @@ async function sendApprovalFamily(respond, approvalId, answer, ctx) {
         return { ...base, kind: 'not_applied', cause: 'parking', ...(view !== undefined ? { parking: view, ...(hint !== undefined ? { retryAfterMs: hint } : {}) } : {}) };
     }
     const parsed = settlementAckOf(readToolApprovalRespondAck(raw));
-    const replayWord = replayedFirstDecisionOf(parsed);
-    if (parsed !== undefined && replayWord !== undefined) {
-        const first = parsed.approvalId === approvalId ? verdictOf(replayWord) : undefined;
+    const replay = replayVerdictFrom(raw, parsed, approvalId);
+    if (replay.kind === 'replayed') {
+        const first = verdictOf(replay.firstDecision);
         return {
             ...base,
             kind: 'settled_elsewhere',
@@ -174,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) } : {}) };
 }
@@ -190,9 +191,6 @@ function bodyFacts(answer, payload, rememberUnsupported) {
 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)
@@ -363,8 +361,8 @@ function snapshotAnswer(raw) {
     if (kind === 'allow') {
         const allowSession = guardedRead(() => readOwnDataValue(raw, 'allowSession')) === true;
         const edited = guardedRead(() => readOwnDataValue(raw, 'updatedInput'));
-        const noteRaw = guardedRead(() => readOwnDataValue(raw, 'note'));
-        const note = typeof noteRaw === 'string' && noteRaw.trim() !== '' ? noteRaw : undefined;
+        const noteReading = guardedRead(() => allowNoteReadingOf(raw));
+        const note = noteReading?.kind === 'text' ? noteReading.text : undefined;
         if (edited === undefined)
             return Object.freeze({ kind: 'allow', allowSession, ...(note !== undefined ? { note } : {}) });
         let copy;
@@ -582,6 +580,30 @@ export function toolPermissionSettledLine(fact, lang) {
         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)
@@ -594,7 +616,7 @@ export function hitlDecisionOutcomeContent(outcome, lang) {
             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.js

@@ -22,5 +22,5 @@ export function editedApprovalAcceptanceOf(card) {
     return read.value === true ? REFUSES : UNKNOWN_MALFORMED;
 }
 export function editedApprovalRefusedLine(lang) {
-    return renderMessage(msg('approval.editRefusal.line'), 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;

package/dist/hitl/frameRouter.js

@@ -89,6 +89,8 @@ function policyDenyHeadFor(cause) {
             return renderMessage(msg('approval.policyDeny.denyRule', { tail }));
         case 'engine_floor':
             return renderMessage(msg('approval.policyDeny.engineFloor', { tail }));
+        case 'hook':
+            return renderMessage(msg('approval.policyDeny.hook'));
         case 'no_approval_ui':
         case undefined:
             return HITL_POLICY_DENY_MESSAGE;
@@ -117,20 +119,6 @@ function denyStampedEnd(ev, attribution) {
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
-const bridgeRunHandleFallbacks = new WeakMap();
-export function setBridgeRunHandleFallback(deps, read) {
-    bridgeRunHandleFallbacks.set(deps, read);
-}
-export function bridgeRunHandleFallbackOf(deps) {
-    try {
-        const read = bridgeRunHandleFallbacks.get(deps);
-        const v = read?.();
-        return typeof v === 'string' && v !== '' ? v : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function isAskToolLoose(name) {
     return typeof name === 'string' && name.replace(/[\s_-]+/g, '').toLowerCase() === 'askuserquestion';
 }
@@ -371,7 +359,12 @@ async function routeToolApprovalFrame(ev, ctx) {
     const gatedCallId = fromSubagent ? undefined : frameCallId ?? led.lastPendingFsCall();
     const argsCallId = frameCallId === undefined ? gatedCallId : typeof ev.toolName === 'string' && toolNameIsFsWrite(ev.toolName) ? frameCallId : undefined;
     const runTaskId = ctx.taskId.current;
-    const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane, typeof runTaskId === 'string' && runTaskId !== '' ? { taskId: runTaskId } : undefined);
+    const streamGeneration = ctx.streamGeneration;
+    const runFacts = {
+        ...(typeof runTaskId === 'string' && runTaskId !== '' ? { taskId: runTaskId } : {}),
+        ...(streamGeneration !== undefined ? { sourceGeneration: streamGeneration } : {}),
+    };
+    const launched = surfaceToolApprovalFrameAndRespond(ev, deps.respondToolApproval, argsOfGatedStart(led, argsCallId), ctx.signal, deps.approvalLane, Object.keys(runFacts).length > 0 ? runFacts : undefined);
     const hold = liveCardHoldOf(liveFrameCallKey(ev.approvalId));
     const handled = launched.then((outcome) => settleLiveCardOutcome(ev, outcome, ctx, fromSubagent, gatedCallId), (e) => {
         hostLog('debug', `liveHitlAskWire: tool_approval card for ${ev.approvalId} failed: ${String(e).slice(0, 160)}`);

package/dist/hitl/gateIdentity.d.ts

@@ -1,9 +1,14 @@
 export declare const PLAN_REVIEW_QUESTION_ID_PREFIX = "plan-review:";
 export declare const REOPEN_ID_TAIL = "#reopen-";
+export declare const SCREEN_CARD_ORIGINS: readonly ["live-approval", "park-approval", "park-question", "plan-review", "host-reopen-question", "host-choice", "local-permission"];
+export type ScreenCardOrigin = (typeof SCREEN_CARD_ORIGINS)[number];
 export declare function approvalCallKey(gatedCallId: string | undefined, taskId: string): string;
 export declare function askGateQuestionId(callKey: string): string;
 export declare function planReviewQuestionId(taskId: string): string;
 export declare function freshPlanReviewQuestionId(taskId: string, suffix: string): string;
+export declare function hostReopenQuestionId(rowTaskId: string, suffix: string): string;
+export declare function hostRunChoiceQuestionId(taskId: string, suffix: string): string;
+export declare function questionCardOriginOf(questionId: {} | null | undefined): Extract<ScreenCardOrigin, 'park-question' | 'plan-review' | 'host-reopen-question' | 'host-choice'> | undefined;
 export declare function liveFrameCallKey(approvalId: string): string;
 export declare function taskIdFromPlanReviewQuestionId(questionId: string): string | undefined;
 export declare function armedKeyFromQuestionId(questionId: string): string;

package/dist/hitl/gateIdentity.js

@@ -2,6 +2,9 @@ const HITL_ASK_QUESTION_ID_PREFIX = 'hitl-ask:';
 export const PLAN_REVIEW_QUESTION_ID_PREFIX = 'plan-review:';
 const HITL_FRAME_CALL_KEY_PREFIX = 'hitl-frame:';
 export const REOPEN_ID_TAIL = '#reopen-';
+const HOST_REOPEN_QUESTION_ID_PREFIX = 'ask-park:';
+const HOST_RUN_CHOICE_QUESTION_ID_PREFIX = 'active-run:';
+export const SCREEN_CARD_ORIGINS = Object.freeze(['live-approval', 'park-approval', 'park-question', 'plan-review', 'host-reopen-question', 'host-choice', 'local-permission']);
 export function approvalCallKey(gatedCallId, taskId) {
     return gatedCallId ?? taskId;
 }
@@ -14,6 +17,26 @@ export function planReviewQuestionId(taskId) {
 export function freshPlanReviewQuestionId(taskId, suffix) {
     return `${planReviewQuestionId(taskId)}${REOPEN_ID_TAIL}${suffix}`;
 }
+export function hostReopenQuestionId(rowTaskId, suffix) {
+    return `${HOST_REOPEN_QUESTION_ID_PREFIX}${rowTaskId}${REOPEN_ID_TAIL}${suffix}`;
+}
+export function hostRunChoiceQuestionId(taskId, suffix) {
+    return `${HOST_RUN_CHOICE_QUESTION_ID_PREFIX}${taskId}${REOPEN_ID_TAIL}${suffix}`;
+}
+export function questionCardOriginOf(questionId) {
+    if (typeof questionId !== 'string')
+        return undefined;
+    const has = (prefix) => questionId.startsWith(prefix) && questionId.length > prefix.length;
+    if (has(HITL_ASK_QUESTION_ID_PREFIX))
+        return 'park-question';
+    if (has(PLAN_REVIEW_QUESTION_ID_PREFIX))
+        return 'plan-review';
+    if (has(HOST_REOPEN_QUESTION_ID_PREFIX))
+        return 'host-reopen-question';
+    if (has(HOST_RUN_CHOICE_QUESTION_ID_PREFIX))
+        return 'host-choice';
+    return undefined;
+}
 export function liveFrameCallKey(approvalId) {
     return `${HITL_FRAME_CALL_KEY_PREFIX}${approvalId}`;
 }

package/dist/hitl/hitlBridge.d.ts

@@ -138,6 +138,12 @@ export type FindPendingOutcome = {
         readonly kind: 'ok';
     }>;
 };
+export interface PendingRowCallIdentity {
+    readonly taskId?: string | null;
+    readonly toolCallId?: string | null;
+    readonly boundCallId?: string | null;
+}
+export declare function pendingRowAnswersCall(row: PendingRowCallIdentity, taskId: string, callId: string): boolean;
 export declare function findPendingForTask(client: HitlClientLike, taskId: string, matches: (toolName: string | undefined) => boolean, opts?: {
     signal?: AbortSignal;
 }, callId?: string, identityAccepts?: (row: PendingCheckpoint) => boolean): Promise<FindPendingOutcome>;