@sema-agent/client-core 0.97.0 → 0.98.0

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

package/dist/fleet/fleetLedger.js

@@ -44,7 +44,7 @@ export function readEngineActiveBgTasksFor(sessionKey) {
     for (const view of viewsFor(sessionKey)) {
         try {
             const r = view.read();
-            if (r.connected)
+            if (r.fresh)
                 fresh = true;
             for (const row of r.rows)
                 byId.set(row.id, row);
@@ -146,7 +146,6 @@ export function createFleetLedger(hooks = {}, opts = {}) {
     let droppedUnknownFrame = 0;
     let droppedForeignBgNotification = 0;
     let droppedStaleIngress = 0;
-    let connected = false;
     let version = null;
     let scoped = null;
     let sessionScopedMeta;
@@ -154,12 +153,12 @@ export function createFleetLedger(hooks = {}, opts = {}) {
     let disposed = false;
     let epochSeq = 0;
     let liveStreamEpoch = 0;
+    let deliveredStreamEpoch = 0;
     let liveSnapshotEpoch = 0;
     let streamAnchor;
-    let everIssuedStream = false;
     let contentAnchor;
     let contentAnchorSet = false;
-    let ledgerWrites = 0;
+    const streamDelivering = () => !disposed && liveStreamEpoch !== 0 && deliveredStreamEpoch === liveStreamEpoch;
     const debug = (line) => {
         if (engineWireDebugEnabled())
             hostLog('debug', line);
@@ -242,7 +241,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                     continue;
                 rows.push(toBgTask(r.row, true));
             }
-            return { connected, rows };
+            return { fresh: streamDelivering(), rows };
         },
         sessionScoped: () => sessionScopedMeta,
         clearRetained: () => {
@@ -259,7 +258,6 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         views.add(bgView);
     }
     function applyFrame(frame, ing) {
-        ledgerWrites++;
         switch (frame.type) {
             case 'meta': {
                 version = frame.version;
@@ -324,7 +322,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                     if (parentOwned)
                         recordOwnEngineRun(childTid);
                     if (parentOwned || sessionScopedMeta === true) {
-                        recordBgParentRun(childTid, parentTid, ing?.session, ing?.sessionKey);
+                        recordBgParentRun(childTid, parentTid, ing.session, ing.sessionKey);
                     }
                     else {
                         debug(`[fleet-frame] task row parent-map SKIPPED foreign/unowned(row=${row.id} parent=${parentTid})`);
@@ -409,7 +407,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             return;
         }
         const serverFailClosed = bgNotifyFailClosedMeta && sessionScopedMeta === true;
-        const anchor = ing !== null ? ing.session : engineSessionParamFor(sessionKey);
+        const anchor = ing.session;
         const ownByRoot = typeof n.rootSessionId === 'string' &&
             n.rootSessionId.length > 0 &&
             n.rootSessionId === anchor;
@@ -423,16 +421,14 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             return;
         }
         const defaultSlot = sessionKey === DEFAULT_SESSION_KEY;
-        const viaIngress = ing !== null;
-        const ownRootTrusted = defaultSlot || viaIngress;
         const serverFailClosedTrusted = defaultSlot;
         const trustedSessionArm = serverFailClosed && serverFailClosedTrusted
             ? 'server_fail_closed'
-            : ownByRoot && ownRootTrusted
+            : ownByRoot
                 ? 'own_root'
                 : undefined;
         const evidence = trustedSessionArm ??
-            (serverFailClosed || ownByRoot
+            (serverFailClosed
                 ? 'session_anchor_untrusted'
                 : typeof n.parentTaskId === 'string' && n.parentTaskId.length > 0
                     ? 'own_parent'
@@ -446,7 +442,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         }
         if (isSdkFleetTaskTerminal(n.status)) {
             if (typeof n.parentTaskId === 'string' && n.parentTaskId) {
-                recordBgParentRun(n.taskId, n.parentTaskId, ing?.session, ing?.sessionKey);
+                recordBgParentRun(n.taskId, n.parentTaskId, ing.session, ing.sessionKey);
             }
             if (typeof n.transcriptId === 'string' && n.transcriptId.length > 0) {
                 recordEngineTranscriptId(n.taskId, n.transcriptId);
@@ -629,9 +625,13 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                         ` type=${String(frame.type)})`);
                     return;
                 }
-                applyFrame(frame, { session, sessionKey });
+                if (kind === 'stream')
+                    deliveredStreamEpoch = epoch;
+                else
+                    closed = true;
                 contentAnchor = session;
                 contentAnchorSet = true;
+                applyFrame(frame, { session, sessionKey });
             },
             close() {
                 closed = true;
@@ -649,8 +649,7 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         bgNotifyFailClosedMeta = false;
         debug(`[fleet-frame] 连接级 meta 复位(${why})—— 新连接自报之前不许沿用上一条连接的让位/信任位`);
     };
-    const hasLedgerContent = () => taskMap.size > 0 || wfMap.size > 0 || retained.size > 0;
-    const shouldResetContentFor = (session) => contentAnchorSet ? contentAnchor !== session : hasLedgerContent();
+    const shouldResetContentFor = (session) => contentAnchorSet && contentAnchor !== session;
     const resetLedgerContentOnSessionChange = (from, to) => {
         taskMap.clear();
         wfMap.clear();
@@ -664,21 +663,14 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             '(换会话不是重连:再渲上一会话的行就是跨会话残影)');
     };
     return {
-        applyFrame(frame) {
-            if (disposed)
-                return;
-            applyFrame(frame, null);
-        },
         issueStream() {
             const session = engineSessionParamFor(sessionKey);
-            if (shouldResetContentFor(session)) {
-                resetLedgerContentOnSessionChange(contentAnchorSet ? contentAnchor : '<兼容入口,归属不可知>', session);
-            }
+            if (shouldResetContentFor(session))
+                resetLedgerContentOnSessionChange(contentAnchor, session);
             resetConnectionMeta('新 stream ingress');
             const epoch = ++epochSeq;
             liveStreamEpoch = epoch;
             streamAnchor = session;
-            everIssuedStream = true;
             liveSnapshotEpoch = 0;
             debug(`[fleet-frame] ingress issued(kind=stream key=${sessionKey} epoch=${epoch} session=${session ?? '-'})`);
             return {
@@ -688,13 +680,11 @@ export function createFleetLedger(hooks = {}, opts = {}) {
         },
         issueSnapshot(snapOpts) {
             const inStreamMode = liveStreamEpoch !== 0;
-            const compatStreamLive = !inStreamMode && connected && !everIssuedStream;
-            const duringLiveStream = inStreamMode || compatStreamLive;
+            const duringLiveStream = inStreamMode;
             const session = inStreamMode ? streamAnchor : engineSessionParamFor(sessionKey);
             if (!duringLiveStream) {
-                if (shouldResetContentFor(session)) {
-                    resetLedgerContentOnSessionChange(contentAnchorSet ? contentAnchor : '<兼容入口,归属不可知>', session);
-                }
+                if (shouldResetContentFor(session))
+                    resetLedgerContentOnSessionChange(contentAnchor, session);
                 resetConnectionMeta('快照连接:SDK 封装吞掉了它自己的 meta,不许沿用别条连接的信任位');
             }
             if (inStreamMode) {
@@ -704,9 +694,8 @@ export function createFleetLedger(hooks = {}, opts = {}) {
             const epoch = ++epochSeq;
             liveSnapshotEpoch = epoch;
             debug(`[fleet-frame] ingress issued(kind=snapshot key=${sessionKey} epoch=${epoch} session=${session ?? '-'})`);
-            const writesAtIssue = ledgerWrites;
             const issuedDuringStream = duringLiveStream;
-            const base = makeIngress('snapshot', epoch, session, () => liveSnapshotEpoch === epoch && !issuedDuringStream && ledgerWrites === writesAtIssue);
+            const base = makeIngress('snapshot', epoch, session, () => liveSnapshotEpoch === epoch && !issuedDuringStream);
             return {
                 ...base,
                 applySnapshot(snapshot) {
@@ -723,12 +712,8 @@ export function createFleetLedger(hooks = {}, opts = {}) {
                 },
             };
         },
-        setConnected(v) {
-            connected = v;
-        },
         project,
         status: () => ({
-            connected,
             version,
             scoped,
             sessionScoped: sessionScopedMeta,

package/dist/fleet/fleetProjection.d.ts

@@ -1,5 +1,5 @@
-import type { FleetTaskRow, FleetWorkflowRow } from '@sema-agent/sdk';
-export type FleetTaskStatus = 'queued' | 'running' | 'waiting' | 'stopping' | 'awaiting approval' | 'idle' | 'completed' | 'failed' | 'killed';
+import type { FleetTaskRow, FleetWorkflowRow, FleetTaskStatus } from '@sema-agent/sdk';
+export type { FleetTaskStatus };
 export interface FleetTaskView {
     id: string;
     name: string;

package/dist/fleet/fleetProjection.js

@@ -4,7 +4,10 @@ import { cycleSeqValue } from '../cycleOrder.js';
 import { frozenSet } from '../frozenSet.js';
 import { CORE_RESERVED_AGENT_NAMES } from '../generated/engineFactTables.js';
 export function coerceTaskStatus(s) {
-    switch (s) {
+    if (s === 'parked')
+        return 'awaiting approval';
+    const word = s;
+    switch (word) {
         case 'queued':
         case 'running':
         case 'waiting':
@@ -14,11 +17,12 @@ export function coerceTaskStatus(s) {
         case 'completed':
         case 'failed':
         case 'killed':
-            return s;
-        case 'parked':
-            return 'awaiting approval';
-        default:
+            return word;
+        default: {
+            const unhandled = word;
+            void unhandled;
             return 'idle';
+        }
     }
 }
 export function coerceWorkflowStatus(s) {
@@ -49,11 +53,9 @@ function deriveAgentLabel(agentType, agentName, name, id) {
     const tail = rowIdTail(id).slice(-8);
     return tail ? `agent ${tail}` : 'agent';
 }
-const CONTROL_VERB_LEGACY_NAMES = ['Task', 'Fork'];
 const CONTROL_VERB_GOAL_NAMES = ['DeclareDone'];
 export const CONTROL_TOOL_VERBS = frozenSet([
     ...CORE_RESERVED_AGENT_NAMES,
-    ...CONTROL_VERB_LEGACY_NAMES,
     ...CONTROL_VERB_GOAL_NAMES,
 ]);
 export function projectDescription(description) {
@@ -350,5 +352,5 @@ export const FLEET_TASK_ROW_KEYS_NOT_PROJECTED = {
     },
 };
 export const FLEET_WORKFLOW_ROW_KEYS_NOT_PROJECTED = {};
-const _fleetViewKeyPins = [true, true, true, true, true, true, true, true, true, true];
+const _fleetViewKeyPins = [true, true, true, true, true, true, true, true];
 void _fleetViewKeyPins;

package/dist/frameBinding.d.ts

@@ -0,0 +1,5 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import type { EngineBoundRun } from './engineRowRef.js';
+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;