@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/hitl/askGateWire.js

@@ -1,9 +1,10 @@
 import { createGateLedger } from './gateLedger.js';
-import { bridgeRunHandleFallbackOf, flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from './frameRouter.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';
+import { sourceGenerationNow } from './screenCardCarriers.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { decideAcceptedNotResolved, readDecideReceipt } from '../decideReceipt.js';
 import { APPROVAL_EXPIRED } from '../engineErrorCodes.js';
@@ -28,6 +29,7 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
         deps,
         taskId,
         ...(opts?.signal ? { signal: opts.signal } : {}),
+        streamGeneration: sourceGenerationNow(deps),
     };
     let stream = source;
     let budget;
@@ -81,16 +83,12 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             const drained = drains.legEnded('returned');
             if (drained !== undefined) {
                 const reopenAfterMs = 'reconnectAfterMs' in drained ? drained.reconnectAfterMs : undefined;
-                if (taskId.current === undefined) {
-                    const bound = bridgeRunHandleFallbackOf(deps);
-                    if (bound !== undefined && reopenAfterMs !== undefined)
-                        taskId.current = bound;
-                }
                 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();
+                        ctx.streamGeneration = sourceGenerationNow(deps);
                         stream = deps.runsEvents(taskId.current, {
                             ...(seq !== undefined ? { lastEventId: seq } : {}),
                             ...(opts?.signal ? { signal: opts.signal } : {}),
@@ -169,6 +167,7 @@ export async function* bridgeAskUserQuestionGates(source, deps, opts) {
             led.forgetRunScopedState();
         }
         const seq = handoff !== undefined ? undefined : led.lastSeq();
+        ctx.streamGeneration = sourceGenerationNow(deps);
         stream = deps.runsEvents(taskId.current, {
             ...(seq !== undefined ? { lastEventId: seq } : {}),
             ...(opts?.signal ? { signal: opts.signal } : {}),

package/dist/hitl/decisionRefusal.d.ts

@@ -19,6 +19,8 @@ export interface RefusalRouteContext {
     readonly afterRetry?: true;
 }
 export declare function notPendingAfterRetry(status: number | undefined, retried: boolean): boolean;
+type RefusalRoute = NonNullable<RefusalRouteContext['route']>;
+export declare const REFUSAL_ROUTES: readonly RefusalRoute[];
 export interface RefusalDelivery {
     readonly delivery: 'refused' | 'ambiguous' | 'no_answer';
     readonly status?: number;

package/dist/hitl/decisionRefusal.js

@@ -7,7 +7,7 @@ import { isAlreadyResolvedGateReason, isCodeClassifiedGateFailure } from './park
 import { decisionConflictOf } from './decisionConflict.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorRecord, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, isDisplayableWireCode, isSlotCarrier, ownFoldedCodeBitsOf, protocolErrorNameReading, readErrorPresent, readErrorString, readRefusalField, readThrownSlot } from '../wireFailureShape.js';
 import { attributionRefusalOf, carrierReadOf } from './attributionLadder.js';
 import { CODE_UNREADABLE, ownReadingSlot } from '../engineWireFor.js';
 export const ASK_DECIDED_CODE = 'conflict.ask_decided';
@@ -29,7 +29,7 @@ export function notPendingAfterRetry(status, retried) {
     return retried && (status === 404 || status === 410);
 }
 const ROUTE_WORDS = { approval_decide: true, live_respond: true, ask_decide: true, plan_review: true, compact: true };
-const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
+export const REFUSAL_ROUTES = Object.freeze(Object.keys(ROUTE_WORDS));
 const PRIOR_REFUSAL_EVIDENCE = Object.freeze([
     Object.freeze({
         errorCode: 'corrupt',
@@ -74,12 +74,11 @@ const codeUnreadable = () => {
     throw new TypeError('status or errorCode was unreadable when this failure was first read');
 };
 function preflightSettledBitsPresent(carrier) {
-    const detail = guardedRead(() => readErrorRecord(carrier, 'detail'));
-    if (detail === undefined)
-        return false;
-    const bit = (k) => guardedRead(() => readOwnDataValue(detail, k));
-    const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
-    return nonEmpty(bit('settledBy')) || nonEmpty(bit('rowStatus'));
+    const nonEmpty = (k) => {
+        const v = guardedRead(() => readErrorString(carrier, k));
+        return typeof v === 'string' && v.length > 0;
+    };
+    return nonEmpty('settledBy') || nonEmpty('rowStatus');
 }
 const RESOLUTION_KINDS = Object.freeze(['decided', 'not_sent', 'unsettled']);
 const ASK_READINGS = Object.freeze(['settled', 'not_settled', 'unreadable']);

package/dist/hitl/decisionRefusalCarrier.d.ts

@@ -0,0 +1,3 @@
+import { type DecisionRefusalCarrier } from '../seatContract.js';
+export declare function decisionRefusalCarrierReaderNames(): readonly string[];
+export declare function decisionRefusalCarrierOf(err: {} | null | undefined): DecisionRefusalCarrier | undefined;

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;