@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/acp/processor/updates.js

@@ -0,0 +1,390 @@
+/** Session updates map in log order. Root chunks track streaming message boundaries; diverted and child updates retain their session address. Both feed the permission-origin graph and unfinished async-task state. Load history uses separate mapper scopes and emits unnumbered backfill events. */
+import { DRAFT_SESSION_UPDATE_NAMES } from '../draftSubagents.js';
+import { mapSessionUpdate, newMapperScopeData, SessionMapperState } from '../sessionUpdateMapper.js';
+import { validateWireEvent } from '../validate.js';
+import { emitEvent, isRecord } from './emit.js';
+import { observeSubagentSpawned } from './origins.js';
+import { reportActivity } from './runtime.js';
+import { INBOUND_NOTIFICATION_SCHEMAS } from './sdkSchemas.js';
+import { ASYNC_TASK_LIMIT, getOwn, putOwn } from './state.js';
+const DRAFT_NAMES = new Set(DRAFT_SESSION_UPDATE_NAMES);
+/**
+ * Updates that state what the session **is now** (its command table, mode, config, usage, info), not what happened in it (Task 21).
+ * One the loaded session sends after the load's response — the root is bound — but before the daemon's `historyEnd` is not history:
+ * it is folded live (numbered), or a reopened session would never show its command table (Claude sends `available_commands_update`
+ * from a timer right after answering `session/load`). Before the response such an update is part of the replay and stays history.
+ */
+const LEVEL_UPDATES = new Set([
+    'available_commands_update', 'current_mode_update', 'config_option_update', 'usage_update', 'session_info_update',
+]);
+const SESSION_NOTIFICATION = INBOUND_NOTIFICATION_SCHEMAS['session/update'];
+function stringField(payload, key) {
+    const value = payload[key];
+    return typeof value === 'string' ? value : null;
+}
+/** The mapper for `nativeSessionId`, over the checkpointed scope data (created on first use). */
+function liveMapper(state, out, nativeSessionId, t) {
+    let data = getOwn(state.mapperScopes, nativeSessionId);
+    if (!data)
+        putOwn(state.mapperScopes, nativeSessionId, data = newMapperScopeData());
+    // Codex's activity rides the root's own `session_info_update` (`AcpSession.scopes`' callback).
+    return new SessionMapperState((raw) => {
+        if (nativeSessionId === state.rootSessionId)
+            reportActivity(state, out, raw, t);
+    }, data);
+}
+/** An inbound `session/update` notification (params not yet validated). */
+export function onSessionUpdate(state, params, out, t) {
+    if (!isRecord(params) || typeof params.sessionId !== 'string' || params.sessionId.length === 0 || !isRecord(params.update)) {
+        state.diagnostics.droppedUpdates += 1;
+        return;
+    }
+    const { sessionId, update } = params;
+    if (state.history && !(LEVEL_UPDATES.has(String(update.sessionUpdate)) && state.rootSessionId !== null && sessionId === state.rootSessionId)) {
+        onHistoryUpdate(state, state.history, sessionId, update, out);
+        return;
+    }
+    const root = state.rootSessionId;
+    if (root === null) {
+        state.diagnostics.droppedUpdates += 1;
+        return;
+    }
+    const variant = update.sessionUpdate;
+    const draft = typeof variant === 'string' && DRAFT_NAMES.has(variant);
+    if (!draft && sessionId === root) {
+        const parsed = SESSION_NOTIFICATION.safeParse(params);
+        if (!parsed.success) {
+            state.diagnostics.droppedUpdates += 1;
+            return;
+        }
+        const stripped = parsed.data.update;
+        for (const event of mapSessionUpdate(stripped, liveMapper(state, out, root, t)))
+            routeOwnEvent(state, out, event);
+        return;
+    }
+    let events;
+    try {
+        events = mapSessionUpdate(update, liveMapper(state, out, sessionId, t));
+    }
+    catch {
+        // `applyDivertedUpdate`: an unmapped variant on a diverted update is dropped, the session lives on.
+        state.diagnostics.droppedUpdates += 1;
+        return;
+    }
+    for (const event of events)
+        emitSessionEvent(state, out, sessionId === root ? event : { ...event, acpSessionId: sessionId });
+}
+const CHUNK_CHURN = new WeakMap();
+const CHUNK_TICKS = new WeakMap();
+const canonical = (value) => { try {
+    return JSON.stringify(value) ?? 'undefined';
+}
+catch {
+    return 'unserializable';
+} };
+const isVolatileMetaKey = (key) => key === 'timestamp' || key.endsWith('.timestamp') || key.endsWith('_timestamp');
+/** Every event through the live/history entry points ticks once; a tracker whose last chunk is not the immediately
+ *  preceding event starts fresh. A tool call or any other update between two chunks therefore keeps their ids
+ *  meaningful — which also matches the server, where an unrelated event already flushes the pending text. */
+function tickEvent(state) {
+    const ticks = CHUNK_TICKS.get(state) ?? { tick: 0 };
+    ticks.tick += 1;
+    CHUNK_TICKS.set(state, ticks);
+    return ticks.tick;
+}
+function churnStateOf(state, key, tick) {
+    let perState = CHUNK_CHURN.get(state);
+    if (!perState)
+        CHUNK_CHURN.set(state, perState = new Map());
+    const fresh = state.turns.length;
+    let churn = perState.get(key);
+    if (!churn || churn.seenTurns !== fresh || churn.lastTick !== tick - 1)
+        perState.set(key, churn = { prevId: null, anchorId: null, trusted: false, prevMeta: null, anchorMeta: {}, churnyMetaKeys: new Set(), trustedMetaKeys: new Set(), seenTurns: fresh, lastTick: tick });
+    churn.lastTick = tick;
+    return churn;
+}
+/** Absorb per-delta id/meta churn on one assistant chunk (see the block comment above); other events pass through. */
+function absorbAssistantChunkChurn(state, tick, event) {
+    if (event.eventName !== 'agent_message_chunk' && event.eventName !== 'agent_thought_chunk')
+        return event;
+    const payload = event.payload;
+    const churn = churnStateOf(state, `${event.acpSessionId ?? 'root'}:${event.eventName}`, tick);
+    let changed = false;
+    const rawId = typeof payload.messageId === 'string' ? payload.messageId : null;
+    if (rawId !== null) {
+        if (churn.prevId !== null && rawId === churn.prevId)
+            churn.trusted = true;
+        if (churn.trusted) {
+            churn.anchorId = rawId;
+        }
+        else if (churn.prevId !== null) {
+            // A change with no stable pair ever seen: churn — keep the anchor.
+            if (churn.anchorId !== null && churn.anchorId !== rawId) {
+                payload.messageId = churn.anchorId;
+                changed = true;
+            }
+        }
+        else {
+            churn.anchorId = rawId;
+        }
+        churn.prevId = rawId;
+    }
+    const rawMeta = payload._meta;
+    if (rawMeta !== null && typeof rawMeta === 'object') {
+        const meta = rawMeta;
+        const emitted = {};
+        let anchored = false;
+        for (const [key, value] of Object.entries(meta)) {
+            if (!isVolatileMetaKey(key)) {
+                emitted[key] = value;
+                continue;
+            }
+            const previous = churn.prevMeta;
+            if (previous !== null && key in previous) {
+                if (canonical(value) === canonical(previous[key]))
+                    churn.trustedMetaKeys.add(key);
+                else if (!churn.trustedMetaKeys.has(key)) {
+                    // First sighting of a change on a never-stable key: anchor it to what the previous chunk
+                    // already emitted, so every chunk of this stream carries the identical map.
+                    if (!(key in churn.anchorMeta))
+                        churn.anchorMeta[key] = previous[key];
+                    churn.churnyMetaKeys.add(key);
+                }
+            }
+            emitted[key] = churn.churnyMetaKeys.has(key) && key in churn.anchorMeta ? churn.anchorMeta[key] : value;
+            if (emitted[key] !== value)
+                anchored = true;
+        }
+        churn.prevMeta = meta;
+        if (anchored) {
+            payload._meta = emitted;
+            changed = true;
+        }
+    }
+    return changed ? { ...event, payload } : event;
+}
+function routeOwnEvent(state, out, event) {
+    const tick = tickEvent(state);
+    event = absorbAssistantChunkChurn(state, tick, event);
+    observe(state, event);
+    observeBackgroundWriter(state, event);
+    if ((!event.acpSessionId || event.acpSessionId === state.rootSessionId) &&
+        (event.eventName === 'agent_message_chunk' || event.eventName === 'agent_thought_chunk'))
+        trackMessageBoundary(state, out, event);
+    emitEvent(state, out, event);
+}
+/** Normalize the root session address, observe the event, then emit. */
+export function emitSessionEvent(state, out, event) {
+    const tick = tickEvent(state);
+    event = absorbAssistantChunkChurn(state, tick, event);
+    // Inside a load's history window the session being loaded is the root (an attached `AcpSession` knows it).
+    const normalized = event.acpSessionId === (state.rootSessionId ?? state.history?.rootSessionId)
+        ? { eventName: event.eventName, payload: event.payload }
+        : event;
+    observe(state, normalized);
+    emitEvent(state, out, normalized);
+}
+/** What every live event feeds besides the outbox: the origin graph and the async-task set. */
+function observe(state, event) {
+    if (event.eventName === 'subagent_spawned') {
+        observeSubagentSpawned(state, event.acpSessionId ?? state.rootSessionId, event.payload.subagentSessionId);
+    }
+    trackAsyncTask(state, event);
+    trackDraftSubagent(state, event);
+}
+/** `AcpSession.observeBackgroundWriter`: an explicitly detached writer blocks `executionEnded` for good. */
+function observeBackgroundWriter(state, event) {
+    const input = event.payload.rawInput;
+    if (isRecord(input) && input.run_in_background === true)
+        state.backgroundWriterUnconfirmed = true;
+    const output = event.payload.rawOutput;
+    if (isRecord(output) && output.backgrounded === true && (typeof output.taskId === 'string' || typeof output.pid === 'number')) {
+        state.backgroundWriterUnconfirmed = true;
+    }
+}
+const DRAFT_CHILD_LIMIT = 4096;
+const DRAFT_TERMINALS = new Set(['completed', 'failed', 'cancelled']);
+/** Keep terminal tombstones: duplicated/reordered spawns cannot resurrect completed children.
+ * At capacity retain a conservative blocker rather than forget potentially running work. */
+function trackDraftSubagent(state, event) {
+    if (event.eventName !== 'subagent_spawned' && event.eventName !== 'subagent_state_update')
+        return;
+    const id = event.payload.subagentSessionId;
+    if (typeof id !== 'string' || !id.length)
+        return;
+    const data = state.draftSubagents;
+    if (id.length > 256) {
+        data.overflow = true;
+        return;
+    }
+    const terminal = event.eventName === 'subagent_state_update' && DRAFT_TERMINALS.has(String(event.payload.state));
+    if (getOwn(data.children, id) === false)
+        return;
+    if (!Object.hasOwn(data.children, id) && Object.keys(data.children).length >= DRAFT_CHILD_LIMIT) {
+        data.overflow = true;
+        return;
+    }
+    putOwn(data.children, id, !terminal);
+}
+export function unfinishedDraftSubagentCount(state) {
+    return Object.values(state.draftSubagents.children).filter(Boolean).length + Number(state.draftSubagents.overflow);
+}
+const TERMINAL_ASYNC_STATES = new Set(['completed', 'failed', 'stopped']);
+/**
+ * The unfinished async tasks (AIR `async_task_*`), per native session: spawned → running; a state
+ * update sets the last non-terminal state or removes the task on a terminal one. Settles on the
+ * **last** state — a finished shell sends `stopped` then `completed` (`draftSubagents.ts`), and the
+ * second finds nothing left to remove.
+ */
+function trackAsyncTask(state, event) {
+    if (event.eventName !== 'async_task_spawned' && event.eventName !== 'async_task_state_update')
+        return;
+    const taskId = event.payload.asyncTaskId;
+    if (typeof taskId !== 'string' || taskId.length === 0)
+        return;
+    const owner = event.acpSessionId ?? state.rootSessionId;
+    if (owner === null)
+        return;
+    const next = event.eventName === 'async_task_spawned' ? 'running' : event.payload.state;
+    let tasks = getOwn(state.asyncTasks, owner);
+    if (typeof next === 'string' && TERMINAL_ASYNC_STATES.has(next)) {
+        if (tasks && Object.hasOwn(tasks, taskId)) {
+            delete tasks[taskId];
+            if (Object.keys(tasks).length === 0)
+                delete state.asyncTasks[owner];
+        }
+        return;
+    }
+    if (next !== 'running' && next !== 'paused')
+        return;
+    if (!(tasks && Object.hasOwn(tasks, taskId)) && unfinishedAsyncTaskCount(state) >= ASYNC_TASK_LIMIT) {
+        state.diagnostics.untrackedAsyncTasks += 1;
+        return;
+    }
+    if (!tasks)
+        putOwn(state.asyncTasks, owner, tasks = {});
+    putOwn(tasks, taskId, next);
+}
+function unfinishedAsyncTaskCount(state) {
+    let count = 0;
+    for (const tasks of Object.values(state.asyncTasks))
+        count += Object.keys(tasks).length;
+    return count;
+}
+/** Every unfinished async task, as `{nativeSessionId, asyncTaskId, state}`, in insertion order. */
+export function unfinishedAsyncTasks(state) {
+    return Object.entries(state.asyncTasks).flatMap(([nativeSessionId, tasks]) => Object.entries(tasks).map(([asyncTaskId, status]) => ({ nativeSessionId, asyncTaskId, state: status })));
+}
+// ---- agent_message synthesis --------------------------------------------------------------------
+/** `AcpSession.trackMessageBoundary`, plus remembering whether the message began outside any turn. */
+function trackMessageBoundary(state, out, event) {
+    const message = state.message;
+    const messageId = stringField(event.payload, 'messageId');
+    if (message.open && messageId !== null && message.messageId !== null && messageId !== message.messageId)
+        flushMessage(state, out);
+    if (!message.open)
+        message.outOfTurn = state.turns.length === 0;
+    message.open = true;
+    if (messageId !== null)
+        message.messageId = messageId;
+}
+/** `AcpSession.flushMessageCompleted`: close the streaming message with `agent_message` (no-op if none). */
+export function flushMessage(state, out) {
+    const message = state.message;
+    if (!message.open)
+        return;
+    emitEvent(state, out, { eventName: 'agent_message', payload: { messageId: message.messageId ?? 'turn' } });
+    message.open = false;
+    message.messageId = null;
+    message.outOfTurn = false;
+}
+/** A turn is about to start: a message that began outside any turn is closed now, never merged into it. */
+export function flushOutOfTurnMessage(state, out) {
+    if (state.message.open && state.message.outOfTurn)
+        flushMessage(state, out);
+}
+// ---- load history -----------------------------------------------------------------------------
+/** `foldScopedReplayEvents`, one update at a time. */
+function onHistoryUpdate(state, history, sessionId, update, out) {
+    let data = getOwn(history.scopes, sessionId);
+    if (!data)
+        putOwn(history.scopes, sessionId, data = newMapperScopeData());
+    let events;
+    try {
+        events = mapSessionUpdate(update, new SessionMapperState(() => { }, data));
+    }
+    catch {
+        // Today an unmappable update throws out of the whole load (`replayNativeSession`); here one
+        // update is lost and the history goes on — counted, and reported on `processor.history_end`.
+        state.diagnostics.droppedUpdates += 1;
+        history.droppedCount += 1;
+        return;
+    }
+    for (const rawEvent of events) {
+        // Same churn absorption as the live path: a replayed CodeBuddy history fragments identically.
+        const event = absorbAssistantChunkChurn(state, tickEvent(state), rawEvent);
+        if (event.eventName === 'user_message_chunk')
+            flushHistoryMessage(state, history, sessionId, out);
+        if (event.eventName === 'agent_message_chunk' || event.eventName === 'agent_thought_chunk') {
+            const messageId = stringField(event.payload, 'messageId');
+            const index = history.messages.findIndex((entry) => entry.nativeSessionId === sessionId);
+            const previous = index >= 0 ? history.messages[index] : undefined;
+            if (previous && messageId !== null && previous.messageId !== null && messageId !== previous.messageId) {
+                flushHistoryMessage(state, history, sessionId, out);
+                history.messages.push({ nativeSessionId: sessionId, messageId });
+            }
+            else if (previous) {
+                previous.messageId = messageId ?? previous.messageId;
+            }
+            else {
+                history.messages.push({ nativeSessionId: sessionId, messageId });
+            }
+        }
+        emitHistory(state, history, out, event, sessionId);
+    }
+}
+function flushHistoryMessage(state, history, sessionId, out) {
+    const index = history.messages.findIndex((entry) => entry.nativeSessionId === sessionId);
+    if (index < 0)
+        return;
+    const [message] = history.messages.splice(index, 1);
+    emitHistory(state, history, out, { eventName: 'agent_message', payload: { messageId: message.messageId ?? 'replay' } }, sessionId);
+}
+function emitHistory(state, history, out, event, sessionId) {
+    const scoped = sessionId === history.rootSessionId ? event : { ...event, acpSessionId: sessionId };
+    if (validateWireEvent(scoped)) {
+        state.diagnostics.invalidEvents += 1;
+        return;
+    }
+    // `AcpSession.observeReplayEvent`: history restores the repair's calls, addresses and background-writer evidence.
+    if (scoped.eventName === 'subagent_spawned') {
+        observeSubagentSpawned(state, scoped.acpSessionId ?? history.rootSessionId, scoped.payload.subagentSessionId, history.rootSessionId);
+    }
+    trackDraftSubagent(state, scoped);
+    observeBackgroundWriter(state, scoped);
+    out.unjournaled({
+        t: 'processor.history_event',
+        eventName: scoped.eventName,
+        payload: scoped.payload,
+        ...(scoped.acpSessionId ? { acpSessionId: scoped.acpSessionId } : {}),
+    });
+}
+/**
+ * Close the history window: flush the open history messages (in first-chunk order, as
+ * `foldScopedReplayEvents` does at the end of its list) and report it. `ok: false` when the load
+ * failed or the connection closed — the daemon discards what it collected, as today's load does.
+ * `droppedCount` (history updates that could not be mapped) lets the daemon report a partial
+ * backfill. The `processor.history_event`s are unjournaled: a daemon that crashes inside the window
+ * restarts the load rather than resuming from a checkpoint cut inside it.
+ */
+export function endHistory(state, out, ok) {
+    const history = state.history;
+    if (!history)
+        return;
+    if (ok) {
+        while (history.messages.length > 0)
+            flushHistoryMessage(state, history, history.messages[0].nativeSessionId, out);
+    }
+    state.history = null;
+    out.unjournaled({ t: 'processor.history_end', ok, droppedCount: history.droppedCount });
+}