@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/eventLeg.d.ts

@@ -0,0 +1,92 @@
+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';
+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';
+export interface EventLegRow {
+    readonly stages: readonly EventLegStage[];
+    readonly windowIsCurrent: boolean;
+}
+export declare const EVENT_LEG_TABLE: Readonly<Record<EventLegKind, EventLegRow>>;
+export interface EventLegLiveSpec {
+    readonly kind: 'live';
+}
+export interface EventLegRunSpec {
+    readonly kind: 'durable' | 'continuation';
+    readonly runId: string;
+}
+export type EventLegSpec = EventLegLiveSpec | EventLegRunSpec;
+export type EventLegBindCause = 'open' | 'frame' | 'handoff';
+export interface EventLegBoundInfo {
+    readonly cause: EventLegBindCause;
+    readonly leg: EventLegKind;
+}
+export interface EventLegFrameInfo {
+    readonly leg: EventLegKind;
+}
+export interface EventLegHitlEnvelope {
+    readonly windowIsCurrent: boolean;
+    readonly leg: EventLegKind;
+}
+export type EventLegQuestionFrame = Extract<AgentEvent, {
+    type: 'question' | 'question_complete';
+}>;
+export type EventLegElicitationFrame = Extract<AgentEvent, {
+    type: 'elicitation' | 'elicitation_complete';
+}>;
+export type EventLegToolApprovalFrame = Extract<AgentEvent, {
+    type: 'tool_approval' | 'tool_approval_complete';
+}>;
+export interface EventLegRunPorts {
+    headerRunId?(): string | undefined;
+    onBound?(binding: EngineBoundRun, info: EventLegBoundInfo): void;
+    onRefused?(refusal: EventLegRefusal, info: EventLegFrameInfo): void;
+    onTerminal?(frame: AgentEvent, binding: EngineBoundRun | undefined, info: EventLegFrameInfo): void;
+    isCurrent?(): boolean;
+}
+export interface EventLegRefusal {
+    readonly kind: 'busy' | 'not_created';
+    readonly candidateRunId?: string;
+    readonly busy?: ActiveRunBusySignal;
+    readonly errorCode?: string;
+}
+export interface EventLegOwnerPorts {
+    readonly sessionKey?: string;
+}
+export interface EventLegHitlPorts {
+    question?(frame: EventLegQuestionFrame, env: EventLegHitlEnvelope): void;
+    elicitation?(frame: EventLegElicitationFrame, env: EventLegHitlEnvelope): void;
+    toolApproval?(frame: EventLegToolApprovalFrame, env: EventLegHitlEnvelope): void;
+}
+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 {
+    readonly leg: EventLegKind;
+    readonly runId: string | undefined;
+}
+export interface EventLegPorts {
+    readonly run?: EventLegRunPorts;
+    readonly owner?: EventLegOwnerPorts;
+    readonly hitl?: EventLegHitlPorts;
+    readonly askBridge?: AskGateWireDeps;
+    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 interface EventLegReport {
+    readonly missingPorts: readonly EventLegPortName[];
+    readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;
+    readonly hitlUndelivered: number;
+}
+export interface EventLeg {
+    readonly events: AsyncGenerator<AgentEvent>;
+    report(): EventLegReport;
+}
+export declare function composeEventLeg(source: AsyncIterable<AgentEvent>, leg: EventLegSpec, ports: EventLegPorts): EventLeg;

package/dist/eventLeg.js

@@ -0,0 +1,285 @@
+import { frameBindingOf, 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';
+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']),
+});
+const HITL_PORT_OF = Object.freeze({
+    question: 'question',
+    question_complete: 'question',
+    elicitation: 'elicitation',
+    elicitation_complete: 'elicitation',
+    tool_approval: 'toolApproval',
+    tool_approval_complete: 'toolApproval',
+});
+const inDomain = (stage, frameType) => FRAME_STAGE_DOMAINS[stage].includes(frameType);
+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) => {
+        if (!inDomain('hitlFrames', ev.type))
+            return false;
+        const port = HITL_PORT_OF[ev.type];
+        if (port === 'toolApproval' && hostBridge !== undefined)
+            return false;
+        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 });
+        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))
+                continue;
+            for (const tap of taps)
+                callPort('taps', () => tap(ev));
+            yield ev;
+        }
+    }
+    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

@@ -10,9 +10,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): {
@@ -33,4 +30,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

@@ -23,9 +23,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);
 }
@@ -69,6 +66,10 @@ const FILE_HISTORY_REFUSAL_NOT_YET = "Nothing was sent: file checkpointing is tu
 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, ' +
@@ -88,7 +89,7 @@ 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) {
@@ -179,6 +180,3 @@ export function fileHistoryCaptureDoctorDetail(reading) {
             return unobserved;
     }
 }
-export function __resetFileHistoryCaptureReadingsForTests() {
-    reader.__resetForTests();
-}

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;
     }): {