@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/engineToolDirectory.js

@@ -35,18 +35,20 @@ export function engineToolDirectoryOf(source) {
         const deployment = readHalf(ownDataField(source, 'deploymentMcpServers'));
         if (request === 'unreadable' || deployment === 'unreadable')
             return unreadable();
-        if (request === 'absent' || deployment === 'absent')
+        if (request === 'absent')
             return notLanded();
         const ns = namingPorts();
         if (ns === undefined)
             return unreadable();
         const prefixes = [];
-        for (const name of [...request, ...deployment]) {
+        for (const name of deployment === 'absent' ? request : [...request, ...deployment]) {
             const prefix = mintNamespacePrefix(ns, name);
             if (typeof prefix !== 'string' || prefix.length === 0)
                 return unreadable();
             prefixes.push(prefix);
         }
+        if (deployment === 'absent')
+            return Object.freeze({ state: 'request_only', requestMcpServerPrefixes: frozenSet(prefixes) });
         return Object.freeze({ state: 'directory', mcpServerPrefixes: frozenSet(prefixes) });
     }
     catch {

package/dist/engineWireFor.js

@@ -1,6 +1,7 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireTargetFor } from './engineWireTarget.js';
+import { readThrownSlot } from './wireFailureShape.js';
 export const INJECTED_WIRE_SETTLE_MS = 60_000;
 export function engineWireFor(wire, sessionKey, usable) {
     if (wire !== undefined) {
@@ -285,15 +286,9 @@ function abortedBeforeSendError() {
     return e;
 }
 function answeredByEngine(e) {
-    try {
-        if (e === null || typeof e !== 'object')
-            return false;
-        const o = e;
-        return typeof o.status === 'number' || typeof o.errorCode === 'string';
-    }
-    catch {
+    if (e === null || typeof e !== 'object')
         return false;
-    }
+    return typeof readThrownSlot(e, 'status', 'data') === 'number' || typeof readThrownSlot(e, 'errorCode', 'data') === 'string';
 }
 const SETTLED_BY_PACKAGE_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-settled');
 function settledByPackage(value) {

package/dist/env/uiLanguage.d.ts

@@ -1,4 +1,5 @@
-export type UiLanguage = 'en' | 'zh';
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export type UiLanguage = (typeof SETTINGS_UI_LANGUAGE_VALUES)[number];
 export declare const UI_LANGUAGES: readonly UiLanguage[];
 export declare const UI_LANGUAGE_ENDONYMS: Record<UiLanguage, string>;
 export declare function isUiLanguage(v: unknown): v is UiLanguage;

package/dist/env/uiLanguage.js

@@ -1,11 +1,12 @@
 import { parseLocaleTag } from './localeTag.js';
-export const UI_LANGUAGES = ['en', 'zh'];
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export const UI_LANGUAGES = SETTINGS_UI_LANGUAGE_VALUES;
 export const UI_LANGUAGE_ENDONYMS = {
     en: 'English',
     zh: '中文',
 };
 export function isUiLanguage(v) {
-    return v === 'en' || v === 'zh';
+    return typeof v === 'string' && UI_LANGUAGES.includes(v);
 }
 export function pickUiLanguage(localeTag) {
     return parseLocaleTag(localeTag).language === 'zh' ? 'zh' : 'en';

package/dist/eventLeg.d.ts

@@ -2,6 +2,7 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
 import { type AskGateWireDeps } from './hitl/askGateWire.js';
 import { type ActiveRunBusySignal } from './adapter/runStream.js';
+import type { ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
 export declare const EVENT_LEG_KINDS: readonly ["live", "durable", "continuation"];
 export type EventLegKind = (typeof EVENT_LEG_KINDS)[number];
 export type EventLegStage = 'bindRun' | 'stampOwner' | 'hitlFrames' | 'askBridge' | 'idleTriage';
@@ -64,11 +65,13 @@ export interface EventLegIdleTriagePorts {
     readonly baseUrl: string;
 }
 export type EventLegTap = (frame: AgentEvent) => void;
-export type EventLegStreamDecorator = (stream: AsyncGenerator<AgentEvent>, ctx: EventLegStreamContext) => AsyncGenerator<AgentEvent>;
-export interface EventLegStreamContext {
+export interface ApprovalFrameContext {
     readonly leg: EventLegKind;
-    readonly runId: string | undefined;
+    readonly windowIsCurrent: boolean;
+    readonly receivedAtMs: number;
+    readonly streamEnded: AbortSignal;
 }
+export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
 export interface EventLegPorts {
     readonly run?: EventLegRunPorts;
     readonly owner?: EventLegOwnerPorts;
@@ -77,9 +80,8 @@ export interface EventLegPorts {
     readonly idleTriage?: EventLegIdleTriagePorts;
     readonly signal?: AbortSignal;
     readonly taps?: readonly EventLegTap[];
-    readonly perStream?: readonly EventLegStreamDecorator[];
 }
-export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps' | 'perStream';
+export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps';
 export interface EventLegReport {
     readonly missingPorts: readonly EventLegPortName[];
     readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;

package/dist/eventLeg.js

@@ -1,4 +1,4 @@
-import { frameBindingOf, registerFrameBinding } from './frameBinding.js';
+import { approvalFrameContextOfFrame, frameBindingOf, registerApprovalFrameContext, registerFrameBinding } from './frameBinding.js';
 import { bridgeAskUserQuestionGates } from './hitl/askGateWire.js';
 import { diagnoseSseIdleTear } from './sseIdleTriage.js';
 import { recordSubagentOwnerFromProgress } from './subagentContentStore.js';
@@ -6,6 +6,8 @@ import { activeRunBusySignal } from './adapter/runStream.js';
 import { invokeHostCallbackIsolated } from './hostCallbackGuard.js';
 import { hostLog } from './host.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { settleEngineClosedApproval } from './hitl/approvalHolds.js';
+import { approvalCompleteParked } from './hitl/approvalCompleteParked.js';
 export const EVENT_LEG_KINDS = Object.freeze(['live', 'durable', 'continuation']);
 export const EVENT_LEG_TABLE = Object.freeze({
     live: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames', 'askBridge', 'idleTriage']), windowIsCurrent: true }),
@@ -18,8 +20,14 @@ function makeFrameStageDomains(domains) {
 const FRAME_STAGE_DOMAINS = makeFrameStageDomains({
     bindRun: Object.freeze(['meta', 'done', 'failed']),
     stampOwner: Object.freeze(['task_progress']),
-    hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete']),
+    hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete', 'approval_request', 'approval_revoke']),
 });
+const HITL_FRAMES_PROJECTED = Object.freeze(['human_input']);
+const _hitlFrameTypesPin = [true, true];
+const _hitlProjectedDisjointPin = true;
+void _hitlFrameTypesPin;
+void _hitlProjectedDisjointPin;
+void HITL_FRAMES_PROJECTED;
 const HITL_PORT_OF = Object.freeze({
     question: 'question',
     question_complete: 'question',
@@ -27,8 +35,14 @@ const HITL_PORT_OF = Object.freeze({
     elicitation_complete: 'elicitation',
     tool_approval: 'toolApproval',
     tool_approval_complete: 'toolApproval',
+    approval_request: 'register',
+    approval_revoke: 'register',
 });
 const inDomain = (stage, frameType) => FRAME_STAGE_DOMAINS[stage].includes(frameType);
+export function approvalFrameContextOf(arm) {
+    const frame = guardedRead(() => readOwnDataValue(arm, 'frame'));
+    return typeof frame === 'object' && frame !== null ? approvalFrameContextOfFrame(frame) : undefined;
+}
 const HOST_PORT_MISSING = 'host_port_missing';
 export function composeEventLeg(source, leg, ports) {
     const kind = leg.kind;
@@ -122,7 +136,6 @@ export function composeEventLeg(source, leg, ports) {
     };
     const sessionKey = typeof ports.owner?.sessionKey === 'string' && ports.owner.sessionKey !== '' ? ports.owner.sessionKey : undefined;
     const taps = (ports.taps ?? []).filter((t) => typeof t === 'function');
-    const decorators = (ports.perStream ?? []).filter((d) => typeof d === 'function');
     const info = Object.freeze({ leg: kind });
     const runSessions = new Map();
     let lastBound;
@@ -136,12 +149,18 @@ export function composeEventLeg(source, leg, ports) {
         const boundInfo = Object.freeze({ cause, leg: kind });
         callPort('run.onBound', () => runPorts.onBound?.(binding, boundInfo));
     };
-    const deliverHitl = (ev, env) => {
+    const deliverHitl = (ev, env, streamEnded) => {
         if (!inDomain('hitlFrames', ev.type))
             return false;
         const port = HITL_PORT_OF[ev.type];
+        if (port === 'register') {
+            registerApprovalFrameContext(ev, Object.freeze({ leg: env.leg, windowIsCurrent: env.windowIsCurrent, receivedAtMs: Date.now(), streamEnded }));
+            return false;
+        }
         if (port === 'toolApproval' && hostBridge !== undefined)
             return false;
+        if (ev.type === 'tool_approval_complete')
+            settleEngineClosedApproval(ev, approvalCompleteParked(ev));
         const threw = callPort(`hitl.${port}`, () => hitl?.[port]?.call(hitl, ev, env));
         if (threw)
             hitlUndelivered++;
@@ -153,58 +172,58 @@ export function composeEventLeg(source, leg, ports) {
         let binding;
         let runEvidence = false;
         const env = Object.freeze({ windowIsCurrent: EVENT_LEG_TABLE[streamKind].windowIsCurrent, leg: streamKind });
-        for await (const ev of stream) {
-            if (taskId === undefined && streamKind === 'live')
-                taskId = readHeaderRunId();
-            const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
-            if (!inDomain('bindRun', ev.type))
-                runEvidence = true;
-            if (refusal !== undefined) {
-                if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())
-                    callPort('run.onRefused', () => runPorts.onRefused?.(refusal, info));
-            }
-            else {
-                if (ev.type === 'meta' || ev.type === 'done') {
-                    const carrier = ev.type === 'meta' ? ev : ev.result;
-                    const tid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'taskId')) : undefined;
-                    const sid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId')) : undefined;
-                    const runId = ev.type === 'done' && tid !== undefined && tid === sid ? undefined : tid;
-                    if (streamKind === 'live' && runId !== undefined && runId !== taskId) {
-                        taskId = runId;
-                        sessionId = sid;
+        const ended = new AbortController();
+        try {
+            for await (const ev of stream) {
+                if (taskId === undefined && streamKind === 'live')
+                    taskId = readHeaderRunId();
+                const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
+                if (!inDomain('bindRun', ev.type))
+                    runEvidence = true;
+                if (refusal !== undefined) {
+                    if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())
+                        callPort('run.onRefused', () => runPorts.onRefused?.(refusal, info));
+                }
+                else {
+                    if (ev.type === 'meta' || ev.type === 'done') {
+                        const carrier = ev.type === 'meta' ? ev : ev.result;
+                        const tid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'taskId')) : undefined;
+                        const sid = typeof carrier === 'object' && carrier !== null ? guardedRead(() => readOwnDataNonEmptyString(carrier, 'sessionId')) : undefined;
+                        const runId = ev.type === 'done' && tid !== undefined && tid === sid ? undefined : tid;
+                        if (streamKind === 'live' && runId !== undefined && runId !== taskId) {
+                            taskId = runId;
+                            sessionId = sid;
+                        }
+                        else if (sid !== undefined && taskId !== undefined && (runId === undefined || runId === taskId)) {
+                            sessionId = sid;
+                        }
                     }
-                    else if (sid !== undefined && taskId !== undefined && (runId === undefined || runId === taskId)) {
-                        sessionId = sid;
+                    if (taskId !== undefined) {
+                        if (binding === undefined || binding.taskId !== taskId || binding.sessionId !== sessionId) {
+                            binding = Object.freeze({ taskId, ...(sessionId !== undefined ? { sessionId } : {}) });
+                        }
+                        if (sessionId !== undefined)
+                            runSessions.set(taskId, sessionId);
+                        registerFrameBinding(ev, binding);
+                        noteBound(binding);
                     }
                 }
-                if (taskId !== undefined) {
-                    if (binding === undefined || binding.taskId !== taskId || binding.sessionId !== sessionId) {
-                        binding = Object.freeze({ taskId, ...(sessionId !== undefined ? { sessionId } : {}) });
-                    }
-                    if (sessionId !== undefined)
-                        runSessions.set(taskId, sessionId);
-                    registerFrameBinding(ev, binding);
-                    noteBound(binding);
+                if (inDomain('stampOwner', ev.type)) {
+                    const b = frameBindingOf(ev);
+                    recordSubagentOwnerFromProgress(ev, b?.taskId, b?.sessionId, sessionKey);
                 }
+                if (deliverHitl(ev, env, ended.signal))
+                    continue;
+                for (const tap of taps)
+                    callPort('taps', () => tap(ev));
+                yield ev;
             }
-            if (inDomain('stampOwner', ev.type)) {
-                const b = frameBindingOf(ev);
-                recordSubagentOwnerFromProgress(ev, b?.taskId, b?.sessionId, sessionKey);
-            }
-            if (deliverHitl(ev, env))
-                continue;
-            for (const tap of taps)
-                callPort('taps', () => tap(ev));
-            yield ev;
+        }
+        finally {
+            ended.abort();
         }
     }
-    const streamOf = (raw, streamKind, streamRunId) => {
-        let s = generatorOf(raw);
-        const ctx = Object.freeze({ leg: streamKind, runId: streamRunId });
-        for (const d of decorators)
-            s = d(s, ctx);
-        return frameLevel(s, streamKind, streamRunId);
-    };
+    const streamOf = (raw, streamKind, streamRunId) => frameLevel(generatorOf(raw), streamKind, streamRunId);
     let inner = streamOf(source, kind, legRunId);
     if (hostBridge !== undefined) {
         let windowOpen = row.windowIsCurrent;

package/dist/fileHistoryCaptureCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type FileHistoryCaptureReading = {
     kind: 'unobserved';
 } | {
@@ -12,13 +13,10 @@ export type FileHistoryCaptureMode = 'off' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
-export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
-    fileHistory: 'disabled';
-} | Record<string, never>;
 export declare const FILE_HISTORY_TIGHTEN_VERDICTS: readonly ["not_requested", "declare", "already_off", "unjudged"];
 export type FileHistoryTightenVerdict = (typeof FILE_HISTORY_TIGHTEN_VERDICTS)[number];
 export declare function fileHistoryTightenVerdict(reading: FileHistoryCaptureReading, captureOffByUser: boolean): FileHistoryTightenVerdict;
-export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean): string | undefined;
+export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean, lang?: UiLanguage): string | undefined;
 export interface FileHistoryTightenJudgement {
     readonly verdict: FileHistoryTightenVerdict;
     readonly reading: FileHistoryCaptureReading;

package/dist/fileHistoryCaptureCapability.js

@@ -1,9 +1,9 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
-import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -46,9 +46,6 @@ export function fileHistoryCaptureMode(reading) {
         return 'on-optional';
     return 'unknown';
 }
-export function fileHistoryDeclarationField(reading, captureOff) {
-    return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
-}
 export const FILE_HISTORY_TIGHTEN_VERDICTS = Object.freeze(['not_requested', 'declare', 'already_off', 'unjudged']);
 export function fileHistoryTightenVerdict(reading, captureOffByUser) {
     if (captureOffByUser !== true)
@@ -60,21 +57,11 @@ export function fileHistoryTightenVerdict(reading, captureOffByUser) {
         return 'already_off';
     return 'unjudged';
 }
-const FILE_HISTORY_REFUSAL_NOT_YET = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's capabilities have not been read " +
-    'yet, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. ' +
-    'Try again in a moment; to send regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_NOT_SAID = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
-    'stop recording file history for a session, so sending now could record it anyway. Trying again will not change that ' +
-    'while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_UNRECOGNIZED = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine reported a file-history capture mode ' +
-    'this client does not recognize, so whether it can stop recording file history for a session is unknown and sending now could ' +
-    'record it anyway. Trying again will not change that while this engine reports the same; to send and let file history be ' +
-    'recorded this time, turn file checkpointing back on in your settings.';
-const FILE_HISTORY_REFUSAL_UNREADABLE = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's report on whether it can stop " +
-    'recording file history for a session could not be read by this client, so sending now could record it anyway. Trying ' +
-    'again will not change that while this engine reports the same; to send and let file history be recorded this time, ' +
-    'turn file checkpointing back on in your settings.';
-function unjudgedRefusalOf(reading) {
+const FILE_HISTORY_REFUSAL_NOT_YET = 'session.fileHistoryRefusal.notYet';
+const FILE_HISTORY_REFUSAL_NOT_SAID = 'session.fileHistoryRefusal.notSaid';
+const FILE_HISTORY_REFUSAL_UNRECOGNIZED = 'session.fileHistoryRefusal.unrecognized';
+const FILE_HISTORY_REFUSAL_UNREADABLE = 'session.fileHistoryRefusal.unreadable';
+function unjudgedRefusalKeyOf(reading) {
     let kind;
     let word;
     try {
@@ -92,8 +79,11 @@ function unjudgedRefusalOf(reading) {
         return FILE_HISTORY_REFUSAL_UNRECOGNIZED;
     return FILE_HISTORY_REFUSAL_NOT_YET;
 }
-export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
-    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading) : undefined;
+function unjudgedRefusalOf(reading, lang) {
+    return renderMessage(msg(unjudgedRefusalKeyOf(reading)), lang);
+}
+export function fileHistoryUnjudgedRefusal(reading, captureOffByUser, lang) {
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading, lang) : undefined;
 }
 const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
 export async function judgeFileHistoryTighten(captureOffByUser, opts) {
@@ -101,7 +91,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
     const failClosed = () => {
         const reading = { kind: 'unobserved' };
         return closed
-            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_REFUSAL_NOT_YET }
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: renderMessage(msg(FILE_HISTORY_REFUSAL_NOT_YET)) }
             : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
     };
     try {

package/dist/fileHistoryLegNotice.d.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
 import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
 export type FileHistoryDeclarationFact = 'sent' | 'not_sent' | 'unknown';
 export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "honored", "not_declared", "unknown"];
@@ -10,7 +11,7 @@ export interface FileHistoryLegNoticeInput {
     readonly legWord: string | undefined;
 }
 export declare function fileHistoryLegNoticeVerdict(input: FileHistoryLegNoticeInput): FileHistoryLegNoticeVerdict;
-export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict): string | null;
+export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict, lang?: UiLanguage): string | null;
 export declare function fileHistoryDeclarationOfBody(body: object | null | undefined): FileHistoryDeclarationFact;
 export type OutboundBodyField = {
     kind: 'absent';

package/dist/fileHistoryLegNotice.js

@@ -1,4 +1,5 @@
 import { fileHistoryCaptureMode } from './fileHistoryCaptureCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { frameProvesDelivery } from './promptDelivery.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export const FILE_HISTORY_LEG_VERDICTS = Object.freeze(['not_honored', 'honored', 'not_declared', 'unknown']);
@@ -35,10 +36,9 @@ export function fileHistoryLegNoticeVerdict(input) {
         return 'not_declared';
     return 'unknown';
 }
-const NOT_HONORED_SENTENCE = 'The engine is still capturing file history for this session, though your settings asked it not to.';
-export function fileHistoryLegNoticeSentence(verdict) {
+export function fileHistoryLegNoticeSentence(verdict, lang) {
     if (verdict === 'not_honored')
-        return NOT_HONORED_SENTENCE;
+        return renderMessage(msg('session.fileHistoryLeg.notHonored'), lang);
     return null;
 }
 export function fileHistoryDeclarationOfBody(body) {

package/dist/frameBinding.d.ts

@@ -1,5 +1,8 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
+import type { ApprovalFrameContext } from './eventLeg.js';
+export declare function registerApprovalFrameContext(frame: AgentEvent, ctx: ApprovalFrameContext): void;
+export declare function approvalFrameContextOfFrame(frame: object | null | undefined): ApprovalFrameContext | undefined;
 export declare function registerFrameBinding(frame: AgentEvent, binding: EngineBoundRun): void;
 export declare function frameBindingOf(frame: AgentEvent): EngineBoundRun | undefined;
 export declare function inheritFrameBinding<T extends AgentEvent>(from: AgentEvent, to: T): T;

package/dist/frameBinding.js

@@ -1,4 +1,13 @@
 const frameBindings = new WeakMap();
+const approvalFrameContexts = new WeakMap();
+export function registerApprovalFrameContext(frame, ctx) {
+    if (typeof frame !== 'object' || frame === null || approvalFrameContexts.has(frame))
+        return;
+    approvalFrameContexts.set(frame, ctx);
+}
+export function approvalFrameContextOfFrame(frame) {
+    return typeof frame === 'object' && frame !== null ? approvalFrameContexts.get(frame) : undefined;
+}
 export function registerFrameBinding(frame, binding) {
     if (typeof frame !== 'object' || frame === null)
         return;
@@ -19,5 +28,8 @@ export function inheritFrameBinding(from, to) {
     const binding = frameBindings.get(from);
     if (binding !== undefined && !frameBindings.has(to))
         frameBindings.set(to, binding);
+    const ctx = approvalFrameContexts.get(from);
+    if (ctx !== undefined && !approvalFrameContexts.has(to))
+        approvalFrameContexts.set(to, ctx);
     return to;
 }

package/dist/gateOutcome.js

@@ -237,9 +237,23 @@ export function gateOutcomeOf(frame) {
     return readGateRecord(frame)?.view;
 }
 export function isGateParkedToolEnd(frame) {
-    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+    if (typeof frame !== 'object' || frame === null)
+        return false;
+    try {
+        if (Array.isArray(frame))
+            return false;
+        if (readOwnDataValue(frame, 'errorCode') === GATE_PARKED_ERROR_CODE)
+            return true;
+        if (readOwnDataValue(frame, 'role') !== 'toolResult')
+            return false;
+        const details = readOwnDataValue(frame, 'details');
+        if (typeof details !== 'object' || details === null || Array.isArray(details))
+            return false;
+        return readOwnDataValue(details, 'code') === GATE_PARKED_ERROR_CODE;
+    }
+    catch {
         return false;
-    return frame.errorCode === GATE_PARKED_ERROR_CODE;
+    }
 }
 export function gateModeRelease(g) {
     return g?.disposition.kind === 'allowed' ? g.disposition.released : undefined;

package/dist/gateVocabulary.d.ts

@@ -1,4 +1,5 @@
 import { CORE_DENIED_BY_VALUES, CORE_PERSISTED_RULE_MANDATES } from './generated/engineFactTables.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const CC_TOOL_DENIAL_KINDS: readonly ["user-rejected", "permission-rule", "automode-blocked", "automode-unavailable", "automode-parsing-error", "interrupted", "cancelled"];
 export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
 export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
@@ -7,15 +8,15 @@ export declare function ccToolDenialKindForSettledBy(settledBy: unknown): CcTool
 export type GateDeniedByWord = (typeof CORE_DENIED_BY_VALUES)[number];
 export declare const GATE_DENIED_BY_WORDS: readonly GateDeniedByWord[];
 export declare function isGateDeniedByWord(v: unknown): v is GateDeniedByWord;
-export declare function gateDeniedByDetail(deniedBy: unknown): string;
-export declare function askOriginDetail(origin: unknown): string;
-export declare function askOriginNoteOf(origin: string | undefined): string | undefined;
+export declare function gateDeniedByDetail(deniedBy: unknown, lang?: UiLanguage): string;
+export declare function askOriginDetail(origin: unknown, lang?: UiLanguage): string;
+export declare function askOriginNoteOf(origin: string | undefined, lang?: UiLanguage): string | undefined;
 export declare function ruleOffersAbsenceDetail(reason: string | undefined, opts?: {
     readonly deploymentListSessionRow?: boolean;
-}): string | undefined;
-export declare function ruleOfferUncoveredDetail(reason: string | undefined): string;
-export declare function mandatedApprovalDetail(): string;
+}, lang?: UiLanguage): string | undefined;
+export declare function ruleOfferUncoveredDetail(reason: string | undefined, lang?: UiLanguage): string;
+export declare function mandatedApprovalDetail(lang?: UiLanguage): string;
 export declare const APPROVAL_MANDATE_WORDS: readonly (typeof CORE_PERSISTED_RULE_MANDATES)[number][];
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
-export declare function approvalMandateDetail(word: ApprovalMandateWord): string;
+export declare function approvalMandateDetail(word: ApprovalMandateWord, lang?: UiLanguage): string;