@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/engineAgentAbsence.d.ts

@@ -1,5 +1,5 @@
 import { type EngineAgentPanelAbsence, type EngineAgentPanelCycleIdentity, type EngineAgentPanelEvent } from './engineAgentPanelStore.js';
-import type { RunTerminalStatus } from './runTerminal.js';
+import type { CcTaskTerminalStatus } from './terminalStatuses.js';
 export declare const ENGINE_AGENT_ABSENT_ROW_TEXT = "engine no longer reports this agent \u00B7 it may still be running";
 export declare const ENGINE_AGENT_ABSENCE_TTL_MS: number;
 export type EngineAgentAbsenceMark = Readonly<Pick<EngineAgentPanelAbsence, 'lastSeenAtMs' | 'absentForMs'>>;
@@ -48,7 +48,7 @@ export interface EngineAgentAbsenceReapOptions {
 }
 export declare function reapEngineAgentAbsentRows(rows: Readonly<Record<string, EngineAgentAbsenceReapRow | null | undefined>>, opts: EngineAgentAbsenceReapOptions): EngineAgentAbsenceReap;
 export declare function engineAgentAbsenceDroppedLine(label: string, ttlMs?: number, removeReason?: string | null): string;
-export declare function engineAgentTerminalAfterDropLine(label: string, status: RunTerminalStatus, hasReport: boolean): string;
+export declare function engineAgentTerminalAfterDropLine(label: string, status: CcTaskTerminalStatus, hasReport: boolean): string;
 export interface EngineAgentRegistryRowView {
     readonly id: string;
     readonly type: string;

package/dist/engineAgentPanelStore.d.ts

@@ -1,3 +1,7 @@
+import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS, type EnginePanelTaskIdentity, type PanelDelta } from './panelReduce.js';
+import type { EngineAgentPanelCycleIdentity } from './cycleOrder.js';
+export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
+export type { EngineAgentPanelCycleIdentity, EnginePanelTaskIdentity };
 export type EngineAgentPanelEvent = {
     kind: 'tick';
     taskId: string;
@@ -45,33 +49,19 @@ export declare const PANEL_TOOLUSES_LANE_POLICY: Readonly<Record<'tick' | 'fleet
 export declare function markEnginePanelTaskResident(taskId: string): void;
 export declare function clearEnginePanelTaskResident(taskId: string): void;
 export declare function isEnginePanelTaskResident(taskId: string): boolean;
-type Listener = (ev: EngineAgentPanelEvent) => void;
-export declare function isNewEngineAgentPanelCycle(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
-export interface EngineAgentPanelCycleIdentity {
-    readonly cycleSeq?: number;
-    readonly startedAt?: number;
-}
-export declare function isStaleEngineAgentPanelEnd(end: EngineAgentPanelCycleIdentity | null | undefined, current: EngineAgentPanelCycleIdentity | null | undefined): boolean;
-export declare const MAX_HELD_WIRE_TICK_BEATS = 16;
-export interface EnginePanelTaskIdentity {
-    readonly taskId: string;
-    readonly origin: 'fleet-row' | 'wire';
-    readonly cycleSeq?: number;
-    readonly startedAt?: number;
-}
 export declare function resolveEnginePanelTaskId(wireTaskId: string, parentToolCallId?: string): EnginePanelTaskIdentity;
 export declare function clearEnginePanelTaskResidentByWire(wireTaskId: string, cycle?: EngineAgentPanelCycleIdentity): void;
 export declare function __resetEngineAgentPanelIdentityForTests(): void;
+export declare function __resetEnginePanelStateForTests(): void;
 export declare function publishEngineAgentPanelEvent(ev: EngineAgentPanelEvent): void;
-export declare function subscribeEngineAgentPanel(fn: Listener): () => void;
+export declare function subscribeEngineAgentPanel(fn: (ev: EngineAgentPanelEvent) => void): () => void;
+export declare function subscribeEnginePanelRows(fn: (delta: PanelDelta) => void): () => void;
 export interface EngineAgentPanelAbsence {
     taskId: string;
     lastSeenAtMs: number;
     absentForMs: number;
     wireTaskId?: string;
 }
-type AbsenceListener = (ev: EngineAgentPanelAbsence) => void;
 export declare function publishEngineAgentPanelAbsence(ev: EngineAgentPanelAbsence): void;
-export declare function subscribeEngineAgentPanelAbsence(fn: AbsenceListener): () => void;
+export declare function subscribeEngineAgentPanelAbsence(fn: (ev: EngineAgentPanelAbsence) => void): () => void;
 export declare function __resetEngineAgentPanelAbsenceForTests(): void;
-export {};

package/dist/engineAgentPanelStore.js

@@ -1,566 +1,48 @@
-import { retirePanelRowRunning, notePanelRowEnded, panelRowEndedIdentity, peekHeldNewbornTerminalRow, takeHeldNewbornTerminalRow, dropHeldNewbornTerminalRow, heldNewbornTerminalRefs } from './panelRunningHistory.js';
+import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, panelIsResident, panelResolveTaskId, MAX_HELD_WIRE_TICK_BEATS, } from './panelReduce.js';
+import { clearEnginePanelIdentity, panelStateNow, resetAbsenceChannel, stepEnginePanel, subscribeAbsence, subscribeLegacyEvents, subscribeRows, resetEnginePanelHolder, } from './panelStateHolder.js';
+export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 const _panelToolUsesLanePins = [true, true];
 void _panelToolUsesLanePins;
 export const PANEL_TOOLUSES_LANE_POLICY = {
     tick: 'required-engine-always-emits',
     'fleet-row': 'optional-tolerate-absent',
 };
-const residentTaskIds = new Set();
 export function markEnginePanelTaskResident(taskId) {
-    residentTaskIds.add(taskId);
+    stepEnginePanel({ kind: 'resident', taskId, resident: true });
 }
 export function clearEnginePanelTaskResident(taskId) {
-    residentTaskIds.delete(taskId);
+    stepEnginePanel({ kind: 'resident', taskId, resident: false });
 }
 export function isEnginePanelTaskResident(taskId) {
-    return residentTaskIds.has(taskId);
-}
-const MAX_BUFFER = 200;
-let listener = null;
-const buffer = [];
-function launchAnchorChanged(prev, next) {
-    if (prev.kind !== 'fleet-row' || next.kind !== 'fleet-row')
-        return false;
-    return isNewEngineAgentPanelCycle(prev, next);
-}
-export function isNewEngineAgentPanelCycle(prev, next) {
-    const pc = cycleSeqOf(prev);
-    const nc = cycleSeqOf(next);
-    if (pc !== undefined && nc !== undefined)
-        return pc !== nc;
-    const ps = startedAtOf(prev);
-    const ns = startedAtOf(next);
-    return ps !== undefined && ns !== undefined && ps !== ns;
-}
-function cycleSeqOf(v) {
-    const n = v?.cycleSeq;
-    return typeof n === 'number' && Number.isInteger(n) && n >= 1 ? n : undefined;
-}
-function startedAtOf(v) {
-    const n = v?.startedAt;
-    return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
-}
-export function isStaleEngineAgentPanelEnd(end, current) {
-    const ec = cycleSeqOf(end);
-    const cc = cycleSeqOf(current);
-    if (ec !== undefined && cc !== undefined)
-        return ec < cc;
-    const es = startedAtOf(end);
-    const cs = startedAtOf(current);
-    if (es !== undefined && cs !== undefined)
-        return es < cs;
-    return false;
-}
-const MAX_IDENTITY_KEYS = 2048;
-const MAX_HELD_WIRE_TICKS = 64;
-export const MAX_HELD_WIRE_TICK_BEATS = 16;
-const fleetIdByTranscriptId = new Map();
-const fleetIdByParentToolCallId = new Map();
-const heldWireTicks = new Map();
-const latestCycleByFleetId = new Map();
-const MAX_OWNERSHIP_KEYS = 8192;
-const publishedWireIds = new Map();
-const publishedWireByParent = new Map();
-const wireIdByFleetId = new Map();
-function bounded(map, key, value) {
-    map.delete(key);
-    map.set(key, value);
-    if (map.size > MAX_IDENTITY_KEYS) {
-        const oldest = map.keys().next().value;
-        if (oldest !== undefined)
-            map.delete(oldest);
-    }
-}
-function boundedOwnership(map, key, value) {
-    map.delete(key);
-    map.set(key, value);
-    if (map.size <= MAX_OWNERSHIP_KEYS)
-        return;
-    for (const [k, v] of map) {
-        if (v.retired) {
-            map.delete(k);
-            return;
-        }
-    }
-    const oldest = map.keys().next().value;
-    if (oldest !== undefined)
-        map.delete(oldest);
-}
-function notePublishedWire(ev) {
-    boundedOwnership(publishedWireIds, ev.taskId, { retired: publishedWireIds.get(ev.taskId)?.retired ?? false });
-    if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
-        bounded(publishedWireByParent, ev.parentToolCallId, ev.taskId);
-}
-function retireWire(wireId) {
-    const w = publishedWireIds.get(wireId);
-    if (w !== undefined)
-        w.retired = true;
-    for (const o of wireIdByFleetId.values())
-        if (o.wireId === wireId)
-            o.retired = true;
-}
-function publishedWireFor(ev) {
-    if (ev.transcriptId !== undefined && publishedWireIds.has(ev.transcriptId))
-        return ev.transcriptId;
-    if (ev.parentToolCallId !== undefined) {
-        const u = publishedWireByParent.get(ev.parentToolCallId);
-        if (u !== undefined && publishedWireIds.get(u)?.retired === false)
-            return u;
-    }
-    return undefined;
-}
-function wireOwnerOf(fleetId, current, transcriptId) {
-    const o = wireIdByFleetId.get(fleetId);
-    if (o === undefined)
-        return undefined;
-    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId);
-    if (newTranscript || (current !== undefined && isStaleEngineAgentPanelEnd(o, current))) {
-        wireIdByFleetId.delete(fleetId);
-        retireWire(o.wireId);
-        return undefined;
-    }
-    return o.wireId;
-}
-function remember(map, key, alias) {
-    map.delete(key);
-    map.set(key, alias);
-    if (map.size > MAX_IDENTITY_KEYS) {
-        const oldest = map.keys().next().value;
-        if (oldest !== undefined)
-            map.delete(oldest);
-    }
+    return panelIsResident(panelStateNow(), taskId);
 }
 export function resolveEnginePanelTaskId(wireTaskId, parentToolCallId) {
-    const byTranscript = fleetIdByTranscriptId.get(wireTaskId);
-    if (byTranscript !== undefined) {
-        remember(fleetIdByTranscriptId, wireTaskId, byTranscript);
-        return identityOf(byTranscript);
-    }
-    const byParent = parentToolCallId !== undefined ? fleetIdByParentToolCallId.get(parentToolCallId) : undefined;
-    if (byParent !== undefined) {
-        remember(fleetIdByParentToolCallId, parentToolCallId, byParent);
-        return identityOf(byParent);
-    }
-    return { taskId: wireTaskId, origin: 'wire' };
-}
-function identityOf(alias) {
-    return {
-        taskId: alias.fleetId,
-        origin: 'fleet-row',
-        ...(alias.cycleSeq !== undefined ? { cycleSeq: alias.cycleSeq } : {}),
-        ...(alias.startedAt !== undefined ? { startedAt: alias.startedAt } : {}),
-    };
-}
-function rememberResolvedWire(wireTaskId, id) {
-    if (fleetIdByTranscriptId.has(wireTaskId))
-        return;
-    remember(fleetIdByTranscriptId, wireTaskId, {
-        fleetId: id.taskId,
-        ...(id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
-        ...(id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
-    });
-}
-function ageHeld(except) {
-    for (const [wireId, held] of [...heldWireTicks]) {
-        if (wireId === except)
-            continue;
-        held.beats += 1;
-        if (held.beats >= MAX_HELD_WIRE_TICK_BEATS) {
-            heldWireTicks.delete(wireId);
-            deliverEngineAgentPanelEvent(asIsTick(held.ev));
-        }
-    }
-}
-function migrateResidency(wireTaskId, fleetId) {
-    if (wireTaskId !== fleetId && residentTaskIds.has(wireTaskId)) {
-        residentTaskIds.delete(wireTaskId);
-        residentTaskIds.add(fleetId);
-    }
-}
-function normalizedTick(ev, fleetId) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    migrateResidency(ev.taskId, fleetId);
-    return { ...rest, taskId: fleetId, wireTaskId: ev.taskId, taskIdOrigin: 'fleet-row' };
-}
-function asIsTick(ev) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    notePublishedWire(ev);
-    return { ...rest, taskIdOrigin: 'wire' };
-}
-function staleWireTick(id) {
-    return isStaleEngineAgentPanelEnd(id, latestCycleByFleetId.get(id.taskId));
-}
-function flushHeld(wireTaskId) {
-    const held = heldWireTicks.get(wireTaskId);
-    if (held === undefined)
-        return;
-    heldWireTicks.delete(wireTaskId);
-    if (publishedWireIds.has(held.ev.taskId)) {
-        deliverEngineAgentPanelEvent(asIsTick(held.ev));
-        return;
-    }
-    const id = resolveEnginePanelTaskId(held.ev.taskId, held.ev.parentToolCallId);
-    if (id.origin === 'fleet-row') {
-        if (staleWireTick(id))
-            return;
-        rememberResolvedWire(held.ev.taskId, id);
-        deliverEngineAgentPanelEvent(normalizedTick(held.ev, id.taskId));
-        return;
-    }
-    deliverEngineAgentPanelEvent(asIsTick(held.ev));
+    return panelResolveTaskId(panelStateNow(), wireTaskId, parentToolCallId);
 }
 export function clearEnginePanelTaskResidentByWire(wireTaskId, cycle) {
-    residentTaskIds.delete(wireTaskId);
-    const owner = wireIdByFleetId.get(wireTaskId);
-    if (owner !== undefined && !(cycle !== undefined && isStaleEngineAgentPanelEnd(cycle, owner)))
-        residentTaskIds.delete(owner.wireId);
-    const id = resolveEnginePanelTaskId(wireTaskId);
-    if (id.taskId === wireTaskId)
-        return;
-    if (isStaleEngineAgentPanelEnd(id, latestCycleByFleetId.get(id.taskId)))
-        return;
-    residentTaskIds.delete(id.taskId);
+    stepEnginePanel({ kind: 'resident-clear-wire', taskId: wireTaskId, ...(cycle !== undefined ? { cycle } : {}) });
 }
 export function __resetEngineAgentPanelIdentityForTests() {
-    fleetIdByTranscriptId.clear();
-    fleetIdByParentToolCallId.clear();
-    heldWireTicks.clear();
-    latestCycleByFleetId.clear();
-    publishedWireIds.clear();
-    publishedWireByParent.clear();
-    wireIdByFleetId.clear();
-}
-function heldRowConsumerKey(tail, held) {
-    const owner = wireIdByFleetId.get(tail);
-    if (owner !== undefined)
-        return owner.wireId;
-    return publishedWireFor(held) ?? tail;
+    clearEnginePanelIdentity();
 }
-function heldNewbornTerminalVerdict(taskId, endCycle) {
-    const held = peekHeldNewbornTerminalRow(taskId);
-    if (held === undefined || held.kind !== 'fleet-row')
-        return 'none';
-    const heldCycle = { ...(held.cycleSeq !== undefined ? { cycleSeq: held.cycleSeq } : {}), ...(held.startedAt !== undefined ? { startedAt: held.startedAt } : {}) };
-    if (isStaleEngineAgentPanelEnd(endCycle, heldCycle))
-        return 'keep';
-    if (isStaleEngineAgentPanelEnd(heldCycle, endCycle))
-        return 'drop';
-    return 'release';
-}
-function heldRowReleasesOntoSameKey(tail, end) {
-    const held = peekHeldNewbornTerminalRow(tail);
-    if (held === undefined || held.kind !== 'fleet-row')
-        return false;
-    const rowKey = heldRowConsumerKey(tail, held);
-    if (rowKey === end.taskId)
-        return true;
-    return rowKey === tail && held.transcriptId === end.taskId && !publishedWireIds.has(end.taskId);
-}
-function releaseHeldNewbornTerminal(taskId, endCycle) {
-    const verdict = heldNewbornTerminalVerdict(taskId, endCycle);
-    if (verdict === 'drop') {
-        dropHeldNewbornTerminalRow(taskId);
-        return;
-    }
-    if (verdict !== 'release')
-        return;
-    const held = takeHeldNewbornTerminalRow(taskId);
-    if (held !== undefined)
-        publishEngineAgentPanelEvent(held);
-}
-function settleRowHistory(taskId, cycle) {
-    retirePanelRowRunning(taskId);
-    notePanelRowEnded(taskId, cycle, isStaleEngineAgentPanelEnd(cycle, panelRowEndedIdentity(taskId)));
-}
-function endOlderThanKnown(end, taskId, rowCycle) {
-    return isStaleEngineAgentPanelEnd(end, rowCycle) || isStaleEngineAgentPanelEnd(end, panelRowEndedIdentity(taskId));
+export function __resetEnginePanelStateForTests() {
+    resetEnginePanelHolder();
 }
 export function publishEngineAgentPanelEvent(ev) {
-    if (ev.kind === 'end' || ev.kind === 'sweep')
-        ageHeld(ev.kind === 'sweep' ? undefined : ev.taskId);
-    switch (ev.kind) {
-        case 'fleet-row': {
-            const rowCycle = { ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}), ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}) };
-            const published = wireOwnerOf(ev.taskId, rowCycle, ev.transcriptId) ?? publishedWireFor(ev);
-            if (published !== undefined && published !== ev.taskId) {
-                const prev = wireIdByFleetId.get(ev.taskId);
-                boundedOwnership(wireIdByFleetId, ev.taskId, { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...(ev.transcriptId !== undefined ? { transcriptId: ev.transcriptId } : prev?.transcriptId !== undefined ? { transcriptId: prev.transcriptId } : {}), ...rowCycle });
-                deliverEngineAgentPanelEvent({ ...ev, taskId: published, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
-                ageHeld(undefined);
-                return;
-            }
-            const alias = {
-                fleetId: ev.taskId,
-                ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}),
-                ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}),
-            };
-            if (alias.cycleSeq !== undefined || alias.startedAt !== undefined) {
-                latestCycleByFleetId.delete(ev.taskId);
-                latestCycleByFleetId.set(ev.taskId, { ...(alias.cycleSeq !== undefined ? { cycleSeq: alias.cycleSeq } : {}), ...(alias.startedAt !== undefined ? { startedAt: alias.startedAt } : {}) });
-                if (latestCycleByFleetId.size > MAX_IDENTITY_KEYS) {
-                    const oldest = latestCycleByFleetId.keys().next().value;
-                    if (oldest !== undefined)
-                        latestCycleByFleetId.delete(oldest);
-                }
-            }
-            if (ev.transcriptId !== undefined && ev.transcriptId.length > 0)
-                remember(fleetIdByTranscriptId, ev.transcriptId, alias);
-            if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
-                remember(fleetIdByParentToolCallId, ev.parentToolCallId, alias);
-            deliverEngineAgentPanelEvent(ev);
-            for (const [wireId, held] of [...heldWireTicks]) {
-                if (wireId === ev.transcriptId || (held.ev.parentToolCallId !== undefined && held.ev.parentToolCallId === ev.parentToolCallId))
-                    flushHeld(wireId);
-            }
-            ageHeld(undefined);
-            return;
-        }
-        case 'tick': {
-            if (publishedWireIds.has(ev.taskId)) {
-                heldWireTicks.delete(ev.taskId);
-                deliverEngineAgentPanelEvent(asIsTick(ev));
-                return;
-            }
-            const id = resolveEnginePanelTaskId(ev.taskId, ev.parentToolCallId);
-            if (id.origin === 'fleet-row') {
-                heldWireTicks.delete(ev.taskId);
-                if (staleWireTick(id))
-                    return;
-                rememberResolvedWire(ev.taskId, id);
-                deliverEngineAgentPanelEvent(normalizedTick(ev, id.taskId));
-                return;
-            }
-            if (ev.cardBound === true) {
-                deliverEngineAgentPanelEvent(asIsTick(ev));
-                return;
-            }
-            if (heldWireTicks.has(ev.taskId)) {
-                heldWireTicks.delete(ev.taskId);
-                deliverEngineAgentPanelEvent(asIsTick(ev));
-                return;
-            }
-            if (heldWireTicks.size >= MAX_HELD_WIRE_TICKS) {
-                const oldest = heldWireTicks.keys().next().value;
-                if (oldest !== undefined)
-                    flushHeld(oldest);
-            }
-            heldWireTicks.set(ev.taskId, { ev, beats: 0 });
-            return;
-        }
-        case 'end': {
-            releaseHeldNewbornTerminal(ev.taskId, ev);
-            {
-                const pre = resolveEnginePanelTaskId(ev.taskId);
-                if (pre.origin === 'fleet-row' && pre.taskId !== ev.taskId) {
-                    releaseHeldNewbornTerminal(pre.taskId, {
-                        ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : pre.cycleSeq !== undefined ? { cycleSeq: pre.cycleSeq } : {}),
-                        ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : pre.startedAt !== undefined ? { startedAt: pre.startedAt } : {}),
-                    });
-                }
-                for (const [fleetId, o] of wireIdByFleetId)
-                    if (o.wireId === ev.taskId && !o.retired)
-                        releaseHeldNewbornTerminal(fleetId, ev);
-                const heldMatches = [];
-                for (const ref of heldNewbornTerminalRefs()) {
-                    if (ref.taskId === ev.taskId)
-                        continue;
-                    const byTranscript = ref.transcriptId !== undefined && ref.transcriptId === ev.taskId;
-                    const byParent = ref.parentToolCallId !== undefined &&
-                        publishedWireByParent.get(ref.parentToolCallId) === ev.taskId &&
-                        publishedWireIds.get(ev.taskId)?.retired === false;
-                    if (byTranscript || byParent)
-                        heldMatches.push(ref.taskId);
-                }
-                const releasable = [];
-                for (const tail of heldMatches) {
-                    const verdict = heldNewbornTerminalVerdict(tail, ev);
-                    if (verdict === 'drop')
-                        dropHeldNewbornTerminalRow(tail);
-                    else if (verdict === 'release' && heldRowReleasesOntoSameKey(tail, ev))
-                        releasable.push(tail);
-                }
-                if (releasable.length === 1)
-                    releaseHeldNewbornTerminal(releasable[0], ev);
-            }
-            const wireOwner = wireOwnerOf(ev.taskId, ev);
-            if (wireOwner !== undefined) {
-                const ownerRec = wireIdByFleetId.get(ev.taskId);
-                const staleA = endOlderThanKnown(ev, ev.taskId, ownerRec) || isStaleEngineAgentPanelEnd(ev, panelRowEndedIdentity(wireOwner));
-                deliverEngineAgentPanelEvent({ ...ev, taskId: wireOwner, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
-                if (!staleA) {
-                    retireWire(wireOwner);
-                    settleRowHistory(ev.taskId, ev);
-                    settleRowHistory(wireOwner, ev);
-                }
-                return;
-            }
-            if (publishedWireIds.has(ev.taskId)) {
-                flushHeld(ev.taskId);
-                const ownedFleetIds = [];
-                for (const [fleetId, o] of wireIdByFleetId) {
-                    if (o.wireId === ev.taskId && !endOlderThanKnown(ev, fleetId, o))
-                        ownedFleetIds.push(fleetId);
-                }
-                const alias = fleetIdByTranscriptId.get(ev.taskId);
-                if (alias !== undefined && !endOlderThanKnown(ev, alias.fleetId, alias) && !ownedFleetIds.includes(alias.fleetId))
-                    ownedFleetIds.push(alias.fleetId);
-                deliverEngineAgentPanelEvent(ev);
-                retireWire(ev.taskId);
-                if (!isStaleEngineAgentPanelEnd(ev, panelRowEndedIdentity(ev.taskId)))
-                    settleRowHistory(ev.taskId, ev);
-                for (const fleetId of ownedFleetIds)
-                    settleRowHistory(fleetId, ev);
-                return;
-            }
-            const id = resolveEnginePanelTaskId(ev.taskId);
-            if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
-                flushHeld(ev.taskId);
-                migrateResidency(ev.taskId, id.taskId);
-                const effectiveEnd = {
-                    ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
-                    ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
-                };
-                const staleC = endOlderThanKnown(effectiveEnd, id.taskId, latestCycleByFleetId.get(id.taskId));
-                deliverEngineAgentPanelEvent({
-                    ...ev,
-                    taskId: id.taskId,
-                    wireTaskId: ev.taskId,
-                    taskIdOrigin: 'fleet-row',
-                    ...(ev.cycleSeq === undefined && id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
-                    ...(ev.startedAt === undefined && id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
-                });
-                if (!staleC)
-                    settleRowHistory(id.taskId, effectiveEnd);
-                return;
-            }
-            flushHeld(ev.taskId);
-            const staleD = endOlderThanKnown(ev, ev.taskId, latestCycleByFleetId.get(ev.taskId));
-            deliverEngineAgentPanelEvent(ev);
-            retireWire(ev.taskId);
-            if (!staleD)
-                settleRowHistory(ev.taskId, ev);
-            return;
-        }
-        default:
-            deliverEngineAgentPanelEvent(ev);
-    }
-}
-function deliverEngineAgentPanelEvent(ev) {
-    if (ev.kind !== 'sweep')
-        absenceBuffer.delete(ev.taskId);
-    if (listener) {
-        try {
-            listener(ev);
-        }
-        catch {
-        }
-        return;
-    }
-    if (ev.kind === 'sweep' && buffer.length > 0 && buffer[buffer.length - 1]?.kind === 'sweep')
-        return;
-    const progress = ev.kind === 'tick' || ev.kind === 'fleet-row';
-    if (progress) {
-        const kind = ev.kind;
-        const taskId = ev.taskId;
-        let i = -1;
-        for (let at = buffer.length - 1; at >= 0; at--) {
-            const b = buffer[at];
-            if (b === undefined)
-                continue;
-            if (b.kind === 'sweep')
-                break;
-            if (b.kind === 'end') {
-                if (b.taskId === taskId)
-                    break;
-                continue;
-            }
-            if (b.taskId !== taskId)
-                continue;
-            if (b.kind === kind && !launchAnchorChanged(b, ev))
-                i = at;
-            break;
-        }
-        if (i >= 0) {
-            const merged = { ...buffer[i], ...ev };
-            buffer.splice(i, 1);
-            buffer.push(merged);
-            return;
-        }
-    }
-    if (buffer.length < MAX_BUFFER) {
-        buffer.push(ev);
-        return;
-    }
-    const evictAt = buffer.findIndex(b => b.kind === 'tick' || b.kind === 'fleet-row');
-    if (evictAt >= 0) {
-        buffer.splice(evictAt, 1);
-        buffer.push(ev);
-        return;
-    }
-    buffer.shift();
-    buffer.push(ev);
+    stepEnginePanel(ev);
 }
 export function subscribeEngineAgentPanel(fn) {
-    listener = fn;
-    if (buffer.length > 0) {
-        const pending = buffer.splice(0, buffer.length);
-        for (const ev of pending) {
-            try {
-                fn(ev);
-            }
-            catch {
-            }
-        }
-    }
-    return () => {
-        if (listener === fn)
-            listener = null;
-    };
+    return subscribeLegacyEvents(fn);
+}
+export function subscribeEnginePanelRows(fn) {
+    return subscribeRows(fn);
 }
-const MAX_ABSENCE_BUFFER = 200;
-let absenceListener = null;
-const absenceBuffer = new Map();
 export function publishEngineAgentPanelAbsence(ev) {
-    const owner = wireOwnerOf(ev.taskId);
-    if (owner !== undefined)
-        ev = { ...ev, taskId: owner, wireTaskId: ev.taskId };
-    if (absenceListener) {
-        try {
-            absenceListener(ev);
-        }
-        catch {
-        }
-        return;
-    }
-    absenceBuffer.delete(ev.taskId);
-    absenceBuffer.set(ev.taskId, ev);
-    if (absenceBuffer.size > MAX_ABSENCE_BUFFER) {
-        const oldest = absenceBuffer.keys().next().value;
-        if (oldest !== undefined)
-            absenceBuffer.delete(oldest);
-    }
+    stepEnginePanel({ kind: 'absence', absence: ev });
 }
 export function subscribeEngineAgentPanelAbsence(fn) {
-    absenceListener = fn;
-    if (absenceBuffer.size > 0) {
-        const pending = [...absenceBuffer.values()];
-        absenceBuffer.clear();
-        for (const ev of pending) {
-            try {
-                fn(ev);
-            }
-            catch {
-            }
-        }
-    }
-    return () => {
-        if (absenceListener === fn)
-            absenceListener = null;
-    };
+    return subscribeAbsence(fn);
 }
 export function __resetEngineAgentPanelAbsenceForTests() {
-    absenceListener = null;
-    absenceBuffer.clear();
+    resetAbsenceChannel();
 }

package/dist/engineCapReader.d.ts

@@ -8,16 +8,16 @@ interface EngineCapReader<R> {
         generation?: number;
     }): void;
     observed(baseUrl: string | undefined): R;
-    forget(baseUrl: string | undefined): void;
     __resetForTests(): void;
 }
 export declare function createEngineCapReader<R>(spec: EngineCapReaderSpec<R>): EngineCapReader<R>;
-export type CapsGeneration = {
-    generation: 'new';
+export type StoreSeat = {
+    kind: 'object';
     store: object;
 } | {
-    generation: 'old';
-    store: 'absent' | 'malformed';
+    kind: 'absent';
+} | {
+    kind: 'malformed';
 };
-export declare function capsGenerationOf(caps: object): CapsGeneration;
+export declare function storeSeatOf(caps: object): StoreSeat;
 export {};