@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/eventLeg.js

@@ -0,0 +1,305 @@
+import { approvalFrameContextOfFrame, frameBindingOf, registerApprovalFrameContext, registerFrameBinding } from './frameBinding.js';
+import { bridgeAskUserQuestionGates } from './hitl/askGateWire.js';
+import { diagnoseSseIdleTear } from './sseIdleTriage.js';
+import { recordSubagentOwnerFromProgress } from './subagentContentStore.js';
+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 }),
+    durable: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames', 'askBridge']), windowIsCurrent: false }),
+    continuation: Object.freeze({ stages: Object.freeze(['bindRun', 'stampOwner', 'hitlFrames']), windowIsCurrent: false }),
+});
+function makeFrameStageDomains(domains) {
+    return Object.freeze(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', 'approval_request', 'approval_revoke']),
+});
+const HITL_PORT_OF = Object.freeze({
+    question: 'question',
+    question_complete: 'question',
+    elicitation: 'elicitation',
+    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;
+    if (!EVENT_LEG_KINDS.includes(kind))
+        throw new TypeError(`composeEventLeg: unknown leg kind ${JSON.stringify(kind)}`);
+    const legRunId = kind === 'live' ? undefined : leg.runId;
+    if (kind !== 'live' && (typeof legRunId !== 'string' || legRunId === ''))
+        throw new TypeError(`composeEventLeg: a ${kind} leg needs a non-empty runId`);
+    const row = EVENT_LEG_TABLE[kind];
+    const stageOn = (s) => row.stages.includes(s);
+    const hostBridge = stageOn('askBridge') && typeof ports.askBridge === 'object' && ports.askBridge !== null ? ports.askBridge : undefined;
+    const hitl = ports.hitl;
+    const required = [];
+    if (typeof hitl?.question !== 'function')
+        required.push('hitl.question');
+    if (typeof hitl?.elicitation !== 'function')
+        required.push('hitl.elicitation');
+    if (hostBridge === undefined && typeof hitl?.toolApproval !== 'function')
+        required.push('hitl.toolApproval');
+    if (hostBridge !== undefined && typeof hostBridge.respondToolApproval !== 'function')
+        required.push('askBridge.respondToolApproval');
+    if (required.length > 0) {
+        throw Object.assign(new Error(`composeEventLeg: host port missing — ${required.join(', ')}`), { code: HOST_PORT_MISSING, ports: Object.freeze([...required]) });
+    }
+    const runPorts = ports.run;
+    const missingPorts = [];
+    if (typeof runPorts?.onBound !== 'function')
+        missingPorts.push('run.onBound');
+    if (typeof runPorts?.onTerminal !== 'function')
+        missingPorts.push('run.onTerminal');
+    const portFaults = {};
+    let hitlUndelivered = 0;
+    const fault = (name, why) => {
+        portFaults[name] = (portFaults[name] ?? 0) + 1;
+        hostLog('debug', `eventLeg: host port ${name} faulted — ${why.slice(0, 160)}`);
+    };
+    const callPort = (name, call) => {
+        let threw = false;
+        invokeHostCallbackIsolated(`eventLeg: ${name}`, () => {
+            try {
+                return call();
+            }
+            catch (e) {
+                threw = true;
+                portFaults[name] = (portFaults[name] ?? 0) + 1;
+                throw e;
+            }
+        });
+        return threw;
+    };
+    const isCurrentNow = () => {
+        if (runPorts === undefined)
+            return true;
+        try {
+            const port = runPorts.isCurrent;
+            if (port === undefined)
+                return true;
+            if (typeof port !== 'function') {
+                fault('run.isCurrent', `not a function (${typeof port})`);
+                return false;
+            }
+            return port.call(runPorts) === true;
+        }
+        catch (e) {
+            fault('run.isCurrent', String(e));
+            return false;
+        }
+    };
+    const readHeaderRunId = () => {
+        if (runPorts === undefined)
+            return undefined;
+        try {
+            const port = runPorts.headerRunId;
+            if (port === undefined)
+                return undefined;
+            if (typeof port !== 'function') {
+                fault('run.headerRunId', `not a function (${typeof port})`);
+                return undefined;
+            }
+            const v = port.call(runPorts);
+            if (typeof v === 'string' && v !== '')
+                return v;
+            if (v !== undefined && v !== '')
+                fault('run.headerRunId', `returned ${typeof v}`);
+            return undefined;
+        }
+        catch (e) {
+            fault('run.headerRunId', String(e));
+            return undefined;
+        }
+    };
+    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;
+    const noteBound = (binding) => {
+        if (lastBound !== undefined && lastBound.taskId === binding.taskId && lastBound.sessionId === binding.sessionId)
+            return;
+        const cause = lastBound === undefined ? 'open' : lastBound.taskId !== binding.taskId ? 'handoff' : 'frame';
+        lastBound = binding;
+        if (runPorts === undefined || typeof runPorts.onBound !== 'function' || !isCurrentNow())
+            return;
+        const boundInfo = Object.freeze({ cause, leg: kind });
+        callPort('run.onBound', () => runPorts.onBound?.(binding, boundInfo));
+    };
+    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++;
+        return true;
+    };
+    async function* frameLevel(stream, streamKind, streamRunId) {
+        let taskId = streamRunId;
+        let sessionId = streamRunId !== undefined ? runSessions.get(streamRunId) : undefined;
+        let binding;
+        let runEvidence = false;
+        const env = Object.freeze({ windowIsCurrent: EVENT_LEG_TABLE[streamKind].windowIsCurrent, leg: streamKind });
+        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;
+                        }
+                    }
+                    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;
+            }
+        }
+        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);
+    };
+    let inner = streamOf(source, kind, legRunId);
+    if (hostBridge !== undefined) {
+        let windowOpen = row.windowIsCurrent;
+        const runsEvents = (taskId, opts) => {
+            windowOpen = false;
+            return streamOf(hostBridge.runsEvents(taskId, opts), 'continuation', taskId);
+        };
+        const deps = hostView(hostBridge, {
+            runsEvents: () => runsEvents,
+            approvalLane: () => {
+                const lane = hostBridge.approvalLane;
+                return typeof lane === 'object' && lane !== null ? hostView(lane, { windowIsCurrent: () => windowOpen }) : Object.freeze({ windowIsCurrent: windowOpen });
+            },
+        });
+        inner = bridgeAskUserQuestionGates(inner, deps, { ...(ports.signal !== undefined ? { signal: ports.signal } : {}), ...(legRunId !== undefined ? { taskId: legRunId } : {}) });
+    }
+    const baseUrl = ports.idleTriage?.baseUrl;
+    if (stageOn('idleTriage') && typeof baseUrl === 'string' && baseUrl !== '')
+        inner = diagnoseSseIdleTear(inner, baseUrl, ports.signal);
+    async function* exit(stream) {
+        for await (const ev of stream) {
+            if ((ev.type === 'done' || ev.type === 'failed') && runPorts !== undefined && typeof runPorts.onTerminal === 'function' && isCurrentNow()) {
+                const binding = frameBindingOf(ev);
+                callPort('run.onTerminal', () => runPorts.onTerminal?.(ev, binding, info));
+            }
+            yield ev;
+        }
+    }
+    return Object.freeze({
+        events: exit(inner),
+        report: () => Object.freeze({ missingPorts: Object.freeze([...missingPorts]), portFaults: Object.freeze({ ...portFaults }), hitlUndelivered }),
+    });
+}
+function refusalOf(ev, candidateRunId) {
+    if (ev.type !== 'done' && ev.type !== 'failed')
+        return undefined;
+    const candidate = candidateRunId !== undefined ? { candidateRunId } : {};
+    const busy = activeRunBusySignal(ev);
+    if (busy !== null)
+        return Object.freeze({ kind: 'busy', ...candidate, busy });
+    if (ev.type !== 'done')
+        return undefined;
+    const r = guardedRead(() => readOwnDataValue(ev, 'result'));
+    if (typeof r !== 'object' || r === null || Array.isArray(r))
+        return undefined;
+    if (guardedRead(() => readOwnDataNonEmptyString(r, 'status')) !== 'failed')
+        return undefined;
+    for (const k of ['taskId', 'stats', 'terminal', 'activeTaskId'])
+        if (guardedRead(() => Object.hasOwn(r, k)) !== false)
+            return undefined;
+    const errorCode = guardedRead(() => readOwnDataNonEmptyString(r, 'errorCode'));
+    if (errorCode === undefined || guardedRead(() => readOwnDataNonEmptyString(r, 'errorMessage')) === undefined)
+        return undefined;
+    return Object.freeze({ kind: 'not_created', ...candidate, errorCode });
+}
+function hostView(host, overrides) {
+    const replaced = (k) => typeof k === 'string' && Object.hasOwn(overrides, k);
+    const valueOf = (k) => overrides[k]?.();
+    return new Proxy(Object.create(null), {
+        get(_t, k) {
+            if (replaced(k))
+                return valueOf(k);
+            const v = Reflect.get(host, k, host);
+            return typeof v === 'function' ? v.bind(host) : v;
+        },
+        has: (_t, k) => replaced(k) || Reflect.has(host, k),
+        getOwnPropertyDescriptor(_t, k) {
+            if (replaced(k))
+                return { value: valueOf(k), writable: false, enumerable: true, configurable: true };
+            const d = Reflect.getOwnPropertyDescriptor(host, k);
+            return d === undefined ? undefined : { ...d, configurable: true };
+        },
+        ownKeys: () => [...new Set([...Reflect.ownKeys(host), ...Object.keys(overrides)])],
+    });
+}
+async function* generatorOf(raw) {
+    yield* raw;
+}

package/dist/executionLaneCapability.d.ts

@@ -17,12 +17,8 @@ export type ExecutionLaneReading = {
 };
 export declare function projectExecutionLaneCapability(caps: unknown): ExecutionLaneReading | undefined;
 export declare function projectExecutionLaneWiring(wiring: unknown): ExecutionLaneReading | undefined;
-export declare function noteEngineCapsForExecutionLane(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedExecutionLane(baseUrl?: string | undefined): ExecutionLaneReading;
 export declare function toolsRunHereFromExecutionLane(reading: ExecutionLaneReading): boolean;
 export declare function noOsSandboxOnThisHost(reading: ExecutionLaneReading): 'yes' | 'no' | 'unknown';
 export declare function noOsSandboxContent(): string;
 export declare function executionLaneDoctorDetail(reading: ExecutionLaneReading): string;
-export declare function __resetExecutionLaneReadingsForTests(): void;

package/dist/executionLaneCapability.js

@@ -26,17 +26,10 @@ function projectExecutionLaneObject(lane) {
         return undefined;
     if (typeof toolsOnThisHost !== 'boolean')
         return undefined;
-    let isolated;
-    let isolatedThrew = false;
-    try {
-        isolated = ownDataField(lane, 'isolated');
-    }
-    catch {
-        isolatedThrew = true;
-    }
-    if (!isolatedThrew && typeof isolated === 'boolean')
+    const isolated = ownDataField(lane, 'isolated');
+    if (typeof isolated === 'boolean')
         return { kind: 'present', view: { provider, toolsOnThisHost, isolated } };
-    const isolatedAbsent = isolatedThrew || isolated !== undefined ? 'unreadable' : toolsOnThisHost ? 'unreadable' : 'no_hands';
+    const isolatedAbsent = isolated !== undefined ? 'unreadable' : toolsOnThisHost ? 'unreadable' : 'no_hands';
     return { kind: 'present', view: { provider, toolsOnThisHost, isolatedAbsent } };
 }
 export function projectExecutionLaneWiring(wiring) {
@@ -56,9 +49,6 @@ const reader = createEngineCapReader({
     name: 'executionLane',
     project: projectExecutionLaneCapability,
 });
-export function noteEngineCapsForExecutionLane(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -117,6 +107,3 @@ export function executionLaneDoctorDetail(reading) {
         }
     }
 }
-export function __resetExecutionLaneReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/fileHistoryCaptureCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type FileHistoryCaptureReading = {
     kind: 'unobserved';
 } | {
@@ -10,9 +11,6 @@ export type FileHistoryCaptureReading = {
 };
 export type FileHistoryCaptureMode = 'off' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
-export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
 export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
@@ -21,7 +19,7 @@ export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureR
 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;
@@ -33,4 +31,3 @@ export declare function judgeFileHistoryTighten(captureOffByUser: boolean, opts?
     withinMs?: number;
 }): Promise<FileHistoryTightenJudgement>;
 export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
-export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -1,3 +1,4 @@
+import { msg, renderMessage } from './i18n/translate.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
@@ -23,9 +24,6 @@ const reader = createEngineCapReader({
     name: 'fileHistoryCapture',
     project: projectFileHistoryCaptureCapability,
 });
-export function noteEngineCapsForFileHistoryCapture(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -63,17 +61,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_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 {
@@ -88,11 +80,14 @@ function unjudgedRefusalOf(reading) {
     if (kind === 'not_reported')
         return FILE_HISTORY_REFUSAL_NOT_SAID;
     if (kind === 'present' && typeof word === 'string' && word.length > 0)
-        return FILE_HISTORY_REFUSAL_NOT_SAID;
+        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) {
@@ -100,7 +95,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 {
@@ -179,6 +174,3 @@ export function fileHistoryCaptureDoctorDetail(reading) {
             return unobserved;
     }
 }
-export function __resetFileHistoryCaptureReadingsForTests() {
-    reader.__resetForTests();
-}

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/fleet/fleetLedger.d.ts

@@ -74,7 +74,6 @@ export interface CreateFleetLedgerOptions {
     nowFn?: () => number;
 }
 export interface FleetLedgerStatus {
-    connected: boolean;
     version: number | null;
     scoped: boolean | null;
     sessionScoped: boolean | undefined;
@@ -89,12 +88,10 @@ export interface FleetLedgerStatus {
     droppedStaleIngress: number;
 }
 export interface FleetLedger {
-    applyFrame(frame: FleetFrame): void;
     issueStream(): FleetIngress;
     issueSnapshot(opts?: {
         timeoutMs?: number;
     }): FleetSnapshotIngress;
-    setConnected(v: boolean): void;
     project(nowMs: number, opts: ProjectTasksOptions & {
         viewingTaskId?: string | undefined;
     }): {