@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/acp/processor/test/fixtureLog.js

@@ -1,18 +1,13 @@
 /**
  * A representative raw log that touches every piece of processor state Tasks 16–17b keep: initialize
- * facts and the Qoder profile, the open session bound from its response (new, then — after a respawn —
- * load with history and `historyEnd`), delegation and launch notes, config and steering round trips,
+ * facts and runtime diagnostics, the open session bound from its response (new, then — after a respawn —
+ * load with history and `historyEnd`), launch notes, config and steering round trips,
  * every kind of `session/update` route (root, draft, child), message synthesis including an
  * out-of-turn trailing chunk, async tasks, activity, both card kinds and the origin graph, turns
  * (completed, interrupted, cut by an exit), the 17a low-level notes, and the diagnostics.
  */
 import { createProcessor } from '../step.js';
 import { append, chunk, elicitationRequest, exitEntry, initializeResult, lastPromptId, lastRequestId, newSession, note, permissionRequest, prompt, respond, run, spawnEntry, subagentSpawned, up, update, } from './harness.js';
-export const QODER_PROFILE = {
-    cliVersion: '1.1.61', sdkVersion: '0.1.0', executable: '/usr/local/bin/qodercli', persistent: true, agentMessaging: false,
-    observerHealthy: true, completedContinuationEnabled: false, sendMessageExposed: false, mode: 'sdk-adapter', transport: 'process',
-    capabilities: ['background_tasks_v1'],
-};
 export const LAUNCH = { source: 'registry', executable: '/usr/local/bin/agent', platform: 'darwin', architecture: 'arm64', transport: 'stdio' };
 export function representativeLog() {
     const session = newSession();
@@ -27,15 +22,13 @@ export function representativeLog() {
         agentCapabilities: { loadSession: true, sessionCapabilities: { list: {} } },
         authMethods: [{ id: 'login', name: 'Login', type: 'terminal', args: ['login'] }, { type: 'terminal' }],
         agentInfo: { name: '@agentclientprotocol/claude-agent-acp', version: '1.0.0' },
-        _meta: { steering: { supported: true, timings: ['next'] }, qoderProfile: QODER_PROFILE },
+        _meta: { steering: { supported: true, timings: ['next'] } },
     })));
     step(
-    // Before the open response: a profile candidate (kept), an update (no root yet: dropped).
-    up({ jsonrpc: '2.0', method: '_axom/qoder/profile', params: { sessionId: 'S1', revision: 1,
-            profile: { ...QODER_PROFILE, rootSessionId: 'S1', runtimeGeneration: 'g1', rootConfirmed: true, initialized: true } } }), note('agent_session_open', {
-        mode: 'new', cwd: '/work', redact: ['secret:delegation'],
-        mcpServers: [{ type: 'http', name: 'axom-delegation', url: 'https://x.test/mcp/delegation', headers: [{ name: 'Authorization', value: 'secret:delegation' }] }],
-        delegation: { expiresAtEpochMs: 1_900_000_000_000, leaseId: 'lease-hash', bindingId: 'b-1', instanceId: 'i-1' },
+    // Before the open response: an update with no root yet is dropped.
+    note('agent_session_open', {
+        mode: 'new', cwd: '/work', redact: ['secret:mcp'],
+        mcpServers: [{ type: 'http', name: 'tools', url: 'https://x.test/mcp/tools', headers: [{ name: 'Authorization', value: 'secret:mcp' }] }],
     }), update('S1', { sessionUpdate: 'available_commands_update', availableCommands: [] }));
     step(respond(lastRequestId(session, 'session/new'), {
         sessionId: 'S1',
@@ -52,14 +45,14 @@ export function representativeLog() {
     step(note('agent_steer', { id: 'steer-1', blocksRef: 'steer-1', priority: 'next' }));
     step(respond(lastRequestId(session, '_session/steering'), { outcome: 'injected' }), respond(lastPromptId(session), { stopReason: 'end_turn' }), 
     // Trailing, after the response: out of turn, closed before the next turn starts.
-    chunk('S1', 'late words'), update('S1', { sessionUpdate: 'async_task_state_update', asyncTaskId: 'task-1', state: 'stopped' }), update('S1', { sessionUpdate: 'async_task_state_update', asyncTaskId: 'task-1', state: 'completed' }), note('agent_delegation_renewed', { expiresAtEpochMs: 1_900_000_100_000, renewalRevision: 1 }), prompt(session, 'two'), chunk('S1', 'thinking'), update('S1', { sessionUpdate: 'tool_call', toolCallId: 't2', title: 'Serve', kind: 'execute', rawInput: { command: 'serve', run_in_background: true } }), permissionRequest(10), note('agent_interrupt'));
+    chunk('S1', 'late words'), update('S1', { sessionUpdate: 'async_task_state_update', asyncTaskId: 'task-1', state: 'stopped' }), update('S1', { sessionUpdate: 'async_task_state_update', asyncTaskId: 'task-1', state: 'completed' }), prompt(session, 'two'), chunk('S1', 'thinking'), update('S1', { sessionUpdate: 'tool_call', toolCallId: 't2', title: 'Serve', kind: 'execute', rawInput: { command: 'serve', run_in_background: true } }), permissionRequest(10), note('agent_interrupt'));
     step(respond(lastPromptId(session), { stopReason: 'cancelled' }), prompt(session, 'three', { platformTurnId: 'turn-3' }), note('rpc.respond', { requestId: 5, result: { outcome: { outcome: 'cancelled' } } }));
     step(exitEntry(0), spawnEntry('spawn-b'));
     step(respond(lastRequestId(session, 'initialize'), initializeResult({ agentInfo: { name: 'other-agent', version: '2' } })));
     step(note('agent_launch', { launch: LAUNCH }), note('agent_session_open', { mode: 'load', cwd: '/work', sessionId: 'S1' }));
     step(update('S1', { sessionUpdate: 'user_message_chunk', content: { type: 'text', text: 'old question' } }), chunk('S1', 'old answer', 'h1'), subagentSpawned('S1', 'C9'), chunk('C9', 'old child'));
     step(respond(lastRequestId(session, 'session/load'), { configOptions: [] }));
-    step(chunk('S1', 'qoder replays one more old chunk after its response'), note('historyEnd'));
+    step(chunk('S1', 'agent replays one more old chunk after its response'), note('historyEnd'));
     step(prompt(session, 'four'), chunk('S1', 'new'), note('historyEnd'));
     return { session, records: session.log.read(0) };
 }

package/dist/workstation/acp/processor/transport/local.js

@@ -19,6 +19,7 @@ import { AcpSession } from '../../../keepers/acp/session.js';
 import { KeeperMethodError } from '../../../keepers/kit/protocol.js';
 import { StreamLog } from '../../../keepers/kit/streamLog.js';
 import { DAEMON_FRAME_INDEX } from '../../outbox.js';
+import { assertOwnedDirectory } from '../../../runtime/ownership.js';
 import { RawTruncatedError, checkpointBlob, rawRecordOf, } from './types.js';
 const DEFAULT_WINDOW = 32;
 /** Longest directory name used as is (file systems cap a name at 255 bytes); longer keys get a hashed name. */
@@ -43,12 +44,15 @@ export class LocalTransport {
     logLine;
     constructor(options) {
         this.options = options;
-        this.root = path.join(options.configDir, 'agents', 'local');
+        this.root = options.outboxDirectory ?? path.join(options.configDir, 'agents', 'local');
         this.now = options.now ?? Date.now;
         this.logLine = options.log ?? (() => { });
     }
     open(sessionKey, label, baseOffset, orphan) {
         const dir = localSessionDir(this.root, sessionKey);
+        assertOwnedDirectory(dir, this.options.ownership, 'local-outbox');
+        if (this.options.ownership)
+            label = { ...label, registrationId: this.options.ownership.registrationId };
         if (path.basename(dir).startsWith('~')) {
             mkdirSync(dir, { recursive: true, mode: 0o700 });
             writeFileSync(path.join(dir, KEY_FILE), sessionKey, { mode: 0o600 });
@@ -71,12 +75,15 @@ export class LocalTransport {
     async importOutbox(key, records) {
         const sessionKey = sessionKeyOf(key);
         const dir = localSessionDir(this.root, sessionKey);
-        if (this.entries.has(sessionKey) || existsSync(dir))
+        if (this.entries.has(sessionKey) || existsSync(dir)) {
+            assertOwnedDirectory(dir, this.options.ownership, 'local-outbox');
             return false;
+        }
         mkdirSync(this.root, { recursive: true, mode: 0o700 });
         const staging = path.join(this.root, `.staging-${randomUUID()}`);
         try {
             mkdirSync(staging, { mode: 0o700 });
+            assertOwnedDirectory(staging, this.options.ownership);
             if (path.basename(dir).startsWith('~'))
                 writeFileSync(path.join(staging, KEY_FILE), sessionKey, { mode: 0o600 });
             const log = StreamLog.open({ dir: staging, now: this.now, immediateKinds: [] });
@@ -127,6 +134,13 @@ export class LocalTransport {
             catch {
                 continue;
             }
+            try {
+                assertOwnedDirectory(path.join(this.root, name), this.options.ownership, 'local-outbox');
+            }
+            catch {
+                this.logLine('ACP local state skipped: registration owner is unknown or mismatched');
+                continue;
+            }
             if (!this.entries.has(key))
                 keys.push(key);
         }
@@ -135,8 +149,10 @@ export class LocalTransport {
     entry(key) {
         const sessionKey = sessionKeyOf(key);
         const existing = this.entries.get(sessionKey);
-        if (existing)
+        if (existing) {
+            assertOwnedDirectory(existing.dir, this.options.ownership, 'local-outbox');
             return existing;
+        }
         if (this.orphans().includes(sessionKey))
             return this.open(sessionKey, {}, undefined, true);
         throw new KeeperMethodError(AcpErrorCode.notFound, 'ACP session not found');

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

@@ -1,69 +1,6 @@
-/**
- * `session/update` → journaled `agent_event`s, one record at a time, in log order (Task 17b).
- *
- * ## One path, in log order (replaces `draftInterceptor` + the SDK's async chain)
- *
- * Today a draft variant or a child session's update is diverted by `interceptDraftUpdates` and
- * applied **synchronously** while the stream is read, and every other update travels the SDK's
- * **asynchronous** handler chain — so the two orders depend on pipe chunking (analysis B §0.1: the
- * same bytes, written at once or line by line, gave different event orders). Here both kinds are
- * handled on their own record, so the order of events is the order of the log, whatever the
- * chunking. What differs between them is only what `AcpSession` does with each, kept as it is:
- *
- * - **The root session's own ordinary update** is parsed with the SDK's `zSessionNotification` (as the
- *   SDK's router does — so unknown keys are stripped and an unknown variant is dropped), mapped with
- *   the root scope, and routed like `AcpSession.routeMappedEvent`: background-writer evidence and
- *   message-boundary tracking for `agent_message` synthesis.
- * - **A draft variant (any session) or any update on another session** is mapped raw, with that
- *   session's own scope, like `AcpSession.applyDivertedUpdate` → `emitEvent`: a child's events carry
- *   `acpSessionId`, and none of them touch the root's message boundaries.
- *
- * Both feed the permission-origin graph (`subagent_spawned`) and the unfinished async-task set.
- *
- * ## Binding, and what replaced the pre-bind buffer
- *
- * The root is bound by the open **response** (`control.ts`). An update that arrives before any root
- * is bound — outside a load's history window — has no session to belong to and is dropped
- * (`droppedUpdates`). Today's 32-entry, 5-second pre-bind buffer existed because the SDK processed
- * the `session/new` response *after* an update the agent had written *after* it; in log order that
- * update follows the response and is applied normally (analysis B A3/C1; the raw captures in `tmp/`
- * show Claude's first `available_commands_update` after the response line).
- *
- * ## Load history
- *
- * Between a `session/load` request and the `historyEnd` note, every update (any session) is history — except a level update
- * ({@link LEVEL_UPDATES}) the loaded session sends once its response is in, which is folded live (Task 21):
- * folded with its own scopes and message boundaries exactly as `adoption.ts` `foldScopedReplayEvents`
- * folds a finished list — incrementally here — then validated and emitted **unnumbered** as
- * `processor.history_event` frames for the daemon's backfill, and observed for origins and
- * background writers (`AcpSession.observeReplayEvent`).
- *
- * ## `agent_message` synthesis and out-of-turn chunks
- *
- * `AcpSession`'s rule: an `agent_message` closes the streaming assistant message when its `messageId`
- * changes and when a turn ends (before the turn's `agent_turn_done`). One addition, decided for 17b:
- * chunks that arrive with **no turn running** — after a prompt's response, or an agent working on its
- * own — are emitted as they are (an `agent_event` never carries a turn id; that is what today's path
- * does with them too), and the message they open is closed **before the next turn starts** instead
- * of being merged into that turn's message when neither carries a `messageId`.
- *
- * ## The Qoder adapter boundaries (Task 17c)
- *
- * `AcpSession` passes events through three adapter boundaries, and so does the processor, over its
- * checkpointed data (`state.boundaries`), at the same points:
- * - the root's own update ({@link routeOwnEvent} = `routeMappedEvent`): the foreground-output boundary
- *   may hold an unaddressed chunk back (certified qoder-cli), the terminal repair observes it, the
- *   subwork boundary maps it (`supportsSubworkMeta`) — and only an unscoped mapped chunk tracks the
- *   root's message boundary;
- * - everything `AcpSession.emitEvent` emits ({@link emitSessionEvent}): diverted updates, cards, and the
- *   terminal repair's own events (`sideChannel.ts`) — observed by the repair, then subwork-mapped;
- * - load history (`observeReplayEvent`): observed by the repair.
- */
+/** 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 { certifiedRuntime, ForegroundOutputBoundary } from '../../qoderAdapter/foregroundOutput.js';
-import { SubworkBoundary, supportsSubworkMeta } from '../../qoderAdapter/subwork.js';
-import { TerminalRepairFold } from '../../qoderAdapter/backgroundTerminalFold.js';
 import { validateWireEvent } from '../validate.js';
 import { emitEvent, isRecord } from './emit.js';
 import { observeSubagentSpawned } from './origins.js';
@@ -80,6 +17,10 @@ const DRAFT_NAMES = new Set(DRAFT_SESSION_UPDATE_NAMES);
 const LEVEL_UPDATES = new Set([
     'available_commands_update', 'current_mode_update', 'config_option_update', 'usage_update', 'session_info_update',
 ]);
+/** Only configuration snapshots: terminal usage, titles and actual output remain observable. */
+const CLOSED_REPLAY_LEVELS = new Set([
+    'available_commands_update', 'current_mode_update', 'config_option_update',
+]);
 const SESSION_NOTIFICATION = INBOUND_NOTIFICATION_SCHEMAS['session/update'];
 function stringField(payload, key) {
     const value = payload[key];
@@ -112,6 +53,15 @@ export function onSessionUpdate(state, params, out, t) {
         state.diagnostics.droppedUpdates += 1;
         return;
     }
+    // A load may replay and end a child that the host did not request as backfill.
+    // Its later configuration snapshot is still historical, not a live child event.
+    // Keep this narrow: unknown scopes and actual content/tool/lifecycle events retain
+    // their normal routing and ownership checks. A live spawn removes the tombstone.
+    if (sessionId !== root && getOwn(state.closedReplayScopes, sessionId) && CLOSED_REPLAY_LEVELS.has(String(update.sessionUpdate))) {
+        state.diagnostics.droppedUpdates += 1;
+        out.unjournaled({ t: 'processor.closed_replay_level', sessionId, sessionUpdate: update.sessionUpdate });
+        return;
+    }
     const variant = update.sessionUpdate;
     const draft = typeof variant === 'string' && DRAFT_NAMES.has(variant);
     if (!draft && sessionId === root) {
@@ -137,63 +87,128 @@ export function onSessionUpdate(state, params, out, t) {
     for (const event of events)
         emitSessionEvent(state, out, sessionId === root ? event : { ...event, acpSessionId: sessionId });
 }
-/** The agent `initialize` named (`AcpConnection.agentInfo`), if it is ready. */
-function agentInfo(state) {
-    return state.initialize.status === 'ready' ? state.initialize.facts.agentInfo : undefined;
+const CHUNK_CHURN = new WeakMap();
+const CHUNK_TICKS = new WeakMap();
+const canonical = (value) => { try {
+    return JSON.stringify(value) ?? 'undefined';
 }
-/** The terminal repair, once a `qoder_terminal_repair` note enabled it. */
-export function repairFold(state) {
-    return state.boundaries.repair ? new TerminalRepairFold(state.boundaries.repair) : 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;
 }
-/** `this.subworkBoundary?.map(event) ?? [event]`. */
-function throughSubwork(state, event) {
-    const root = state.rootSessionId;
-    if (root === null || !supportsSubworkMeta(agentInfo(state)))
-        return [event];
-    return new SubworkBoundary(root, state.boundaries.subwork).map(event);
+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;
 }
-/** `this.foregroundOutput?.endTurn()` — no turn remains. */
-export function endForegroundTurn(state) {
-    state.boundaries.foreground.pending = {};
+/** 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;
 }
-/** `AcpSession.routeMappedEvent`, Qoder boundaries included. */
 function routeOwnEvent(state, out, event) {
-    const root = state.rootSessionId;
-    if (certifiedRuntime(agentInfo(state)) && !new ForegroundOutputBoundary(root, state.boundaries.foreground).accept(event))
-        return;
-    repairFold(state)?.observe(event);
-    const subwork = supportsSubworkMeta(agentInfo(state));
-    for (const mapped of throughSubwork(state, event)) {
-        observe(state, mapped);
-        observeBackgroundWriter(state, mapped);
-        if ((!subwork || !mapped.acpSessionId || mapped.acpSessionId === root) &&
-            (mapped.eventName === 'agent_message_chunk' || mapped.eventName === 'agent_thought_chunk'))
-            trackMessageBoundary(state, out, mapped);
-        emitEvent(state, out, mapped);
-    }
+    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);
 }
-/**
- * `AcpSession.emitEvent` (minus a card's own checks, `session.ts`): a diverted update, a card, or a
- * repair event. The repair observes it as given; a root id on `acpSessionId` is dropped; the subwork
- * boundary maps it; each mapped event feeds the origin graph and is numbered.
- */
+/** Normalize the root session address, observe the event, then emit. */
 export function emitSessionEvent(state, out, event) {
-    repairFold(state)?.observe(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;
-    for (const mapped of throughSubwork(state, normalized)) {
-        observe(state, mapped);
-        emitEvent(state, out, mapped);
-    }
+    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);
+        const child = event.payload.subagentSessionId;
+        if (typeof child === 'string' && getOwn(state.permissionOrigins, child) &&
+            getOwn(state.permissionParents, child) === (event.acpSessionId ?? state.rootSessionId)) {
+            delete state.closedReplayScopes[child];
+        }
     }
     trackAsyncTask(state, event);
+    trackDraftSubagent(state, event);
 }
 /** `AcpSession.observeBackgroundWriter`: an explicitly detached writer blocks `executionEnded` for good. */
 function observeBackgroundWriter(state, event) {
@@ -205,6 +220,33 @@ function observeBackgroundWriter(state, event) {
         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
@@ -296,7 +338,9 @@ function onHistoryUpdate(state, history, sessionId, update, out) {
         history.droppedCount += 1;
         return;
     }
-    for (const event of events) {
+    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') {
@@ -331,10 +375,17 @@ function emitHistory(state, history, out, event, sessionId) {
         return;
     }
     // `AcpSession.observeReplayEvent`: history restores the repair's calls, addresses and background-writer evidence.
-    repairFold(state)?.observe(scoped);
     if (scoped.eventName === 'subagent_spawned') {
         observeSubagentSpawned(state, scoped.acpSessionId ?? history.rootSessionId, scoped.payload.subagentSessionId, history.rootSessionId);
     }
+    trackDraftSubagent(state, scoped);
+    if (scoped.eventName === 'subagent_state_update' && DRAFT_TERMINALS.has(String(scoped.payload.state))) {
+        const child = scoped.payload.subagentSessionId;
+        // Share the lifecycle tracker's bounded, validated identity set.
+        if (typeof child === 'string' && getOwn(state.draftSubagents.children, child) === false) {
+            putOwn(state.closedReplayScopes, child, true);
+        }
+    }
     observeBackgroundWriter(state, scoped);
     out.unjournaled({
         t: 'processor.history_event',