@platless/axom-cli 0.5.9 → 0.6.36

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';
@@ -137,56 +74,115 @@ 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) {
@@ -194,6 +190,7 @@ function observe(state, event) {
         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) {
@@ -205,6 +202,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 +320,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 +357,10 @@ 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);
     observeBackgroundWriter(state, scoped);
     out.unjournaled({
         t: 'processor.history_event',

package/dist/workstation/acp/processorSession.js

@@ -1,96 +1,6 @@
-/**
- * One live agent session driven by the deterministic ACP processor over a transport (Task 19, spec 2026-10-11 §5.3/§5.4/§5.7):
- * the daemon side of keeper-acp — or of the local fallback, which is the same session mechanism in this process.
- *
- * ## The record loop
- *
- * The transport's raw stream (`subscribeRaw`) is the only input. For each record, in order:
- * `step(record)` → every command it produced is executed through the transport (`executeDownCommandsVia`: idempotent by cause,
- * refused unless its spawn runs now, prompt blocks filled from this daemon's memory, `secretRef`s substituted from this daemon's
- * memory) → a prompt whose blocks are gone is failed with an `agent_prompt_failed` note → the record's frames go out.
- * Everything the server or this daemon decides reaches the processor as a note or a write first (`agent_prompt`, `agent_answer`,
- * `agent_interrupt`, …); nothing here changes processor state directly, and nothing here numbers a frame — the processor does —
- * with the one exception the poison contract names (below).
- *
- * ## What leaves
- *
- * Frames the manager sends (`onFrames`), unchanged, with `src`. The ones meant for the daemon itself stay here:
- * `processor.open_result` settles {@link openSession}; `processor.history_event`/`history_end` become the load's backfill
- * (never journaled: a daemon that dies inside the window loads again); an `agent_steered` / `agent_config_option_set` whose
- * request this object made settles that call (one with nobody waiting goes out as a frame).
- *
- * ## Secrets and blocks
- *
- * Prompt and steer blocks are held in memory under a `blocksRef` until their `down` is written; secrets (a delegation bearer)
- * under a `secretRef`, for the life of the session. Notes carry only the refs (spec §13).
- *
- * ## Poison (interface-contracts, "中毒恢复契约")
- *
- * A step that throws poisons the processor. The session is degraded: every turn still open ends with a failed `agent_turn_done`
- * this object numbers itself, after the processor's last seq; the adapter is terminated; `onDegraded` tells the manager, which
- * retires the session so the next `agent_open` starts a new spawn (`session/load`). Never retried from a checkpoint: replay is
- * deterministic and would poison again on the same record. A transport that fails under the loop (keeper gone, raw truncated) is
- * handled the same way: Task 19 has no re-attach (Task 21).
- *
- * ## Qoder side files (17c)
- *
- * When the repair is on, a 1 s timer asks the processor's **current** `sideDemand` — only once the processor has folded every
- * record this object appended — runs `BackgroundSideNotes.poll(demand)` and appends the notes it returns, in order. The reader
- * stops when the demand is `undefined` (no repair any more).
- *
- * ## Outbox, backpressure, checkpoints (Task 20, spec §5.5/§5.6)
- *
- * The manager records every journaled frame in {@link outbox} (the transport's outbox stream) before it sends it; the listener
- * {@link onFrames} registers returns that append, and the loop awaits it before folding the next record — so the outbox holding a
- * frame with `src.o = o` proves record `o`'s commands are in raw, and a checkpoint at `o` never precedes `o`'s frames. Before each
- * record the loop waits for {@link SessionOutbox.room}: a server that does not acknowledge stops the processor, and the backlog
- * stays in the raw log.
- *
- * Checkpoints (`acp.commit{checkpoint, rawThrough}`, raw truncated to the checkpoint): at the end of every turn; within a turn
- * every {@link CHECKPOINT_RAW_BYTES} of folded raw or {@link CHECKPOINT_INTERVAL_MS}; and on a `close('keep')` (graceful exit,
- * detach). Never while `boundaries.sideChunk` holds a half-read Qoder fact or a load's history window is open — deferred to the
- * next record where both are clear. Each carries `processorVersion` (`checkpointOf`).
- *
- * ## A session left under the same key
- *
- * An earlier life of this ref (a swept or degraded session, a previous daemon's, a local outbox) is reused, not released: the new
- * spawn continues the same raw log and outbox. Its unacknowledged frames are read back into {@link outbox} (resent when the server
- * reopens the ref) and the processor numbers after the highest seq the outbox ever held — `max(outbox.maxSeq, committedTail.seq,
- * resumeFromSeq)` (§5.5). An earlier life whose adapter still runs is never stopped here: the daemon adopts it at start
- * ({@link ProcessorSession.adopt}), and keeper-acp refuses a second spawn into a running session.
- *
- * ## Adoption (Task 21, spec §5.5)
- *
- * A keeper-acp session whose adapter outlived the daemon (restart, upgrade, crash) is adopted, not stopped:
- * `acp.attach` → the head checkpoint is restored → raw `(checkpoint.offset, replayEnd]` is replayed **updating state only** —
- * `replayEnd = max(outbox last.src.o, committedTail.src.o)`, everything whose frames were recorded — and the frames the replay
- * produces are compared byte for byte with the outbox entries that survive (daemon-numbered ones, `src.i ≥ DAEMON_FRAME_INDEX`,
- * skipped; differences are only counted when the checkpoint came from this very processor version) → the seq continues after
- * `max(replayed seq, outbox.maxSeq, committedTail.seq)` → the unacknowledged outbox entries are resent on the server's reopen →
- * the records after `replayEnd` are folded live (their commands are idempotent by cause). A session whose open never completed, or
- * that cannot be rebuilt (no readable checkpoint and no spawn record left), is refused ({@link AdoptionRefusedError}); the caller
- * stops its adapter and keeps its outbox. A checkpoint is cut right after the spawn and when the open completes, so every session
- * has one that says whether it is open.
- *
- * ## Detach (Task 21, spec §5.5.5)
- *
- * {@link detach} ends this daemon's hold on a keeper-hosted session without touching the adapter: the loop stops after the
- * record in hand, a head checkpoint is cut when the state is safe (never mid Qoder chunk or load history — then the next daemon
- * replays), the subscription is dropped. No `session/cancel`, no answer to a pending card, no `turn_done(failed)`: a detaching
- * session never degrades. The next daemon adopts it.
- *
- * ## Keeper connection loss (Task 21)
- *
- * keeper-acp unreachable under the loop (a request lost on a dropped connection, a stream that ended) is not a degradation: the
- * session re-attaches — `acp.attach` (which relaunches the current generation's keeper-acp if it died; an older generation is
- * only reconnected) and the same rebuild as an adoption, in place — with bounded retries. A note whose append failed is looked
- * for in raw before it is appended again. Only a keeper that is gone with the session (not found, or unreachable after the
- * retries) degrades it. When keeper-acp itself restarted, the session it recovered ends with `proc exit{reason:'keeper_lost'}`:
- * that tail is folded (a real `turn_done` in it is delivered) and the session reports its adapter dead.
- */
+/** Daemon-side keeper session: records notes before commands, awaits outbox persistence before advancing, and checkpoints only complete history boundaries. A poisoned processor degrades the session and ends pending turns; it never retries half-updated state. */
 import { PROTOCOL_VERSION, RequestError } from '@agentclientprotocol/sdk';
 import { ACCOUNT_LIMITS_READ_TIMEOUT_MS } from '../protocol/accountLimits.js';
-import { BackgroundSideNotes, nativeTerminalHistoryPath } from '../qoderAdapter/backgroundTerminal.js';
 import { AgentInitializeTimeoutError, AgentSpawnError, UnsupportedProtocolVersionError } from './acpClient.js';
 import { executeDownCommandsVia } from './processor/transport/types.js';
 import { createProcessor, ProcessorPoisonedError, restoreProcessor } from './processor/step.js';
@@ -98,12 +8,10 @@ import { checkpointOf, decodeCheckpoint, encodeCheckpoint, PROCESSOR_VERSION } f
 import { DAEMON_FRAME_INDEX, isOutboxTail, SessionOutbox, transportOutboxStore } from './outbox.js';
 import { initialState } from './processor/state.js';
 import { activityRaw, runtimeDiagnostics } from './processor/runtime.js';
-import { sideDemand } from './processor/sideChannel.js';
-import { unfinishedAsyncTasks } from './processor/updates.js';
+import { unfinishedAsyncTasks, unfinishedDraftSubagentCount } from './processor/updates.js';
 import { pendingRequestIds } from './processor/session.js';
 import { steeredIds } from './processor/control.js';
 import { RawTruncatedError } from './processor/transport/types.js';
-import { REPAIR_NOTE } from '../qoderAdapter/backgroundTerminalFold.js';
 import { AcpKeeperUnavailableError } from '../keepers/acp/client.js';
 import { AcpErrorCode } from '../keepers/acp/protocol.js';
 import { KeeperClosedError, KeeperConnectionLostError, KeeperNotConnectedError, KeeperRequestError, KeeperRequestTimeoutError, } from '../keepers/kit/client.js';
@@ -111,8 +19,6 @@ import { KeeperClosedError, KeeperConnectionLostError, KeeperNotConnectedError,
 export const PROMPT_LOST = 'The prompt was lost before it reached the agent';
 /** The error a turn ends with when the session degrades under it (poison, or a transport that failed under the loop). */
 export const SESSION_DEGRADED = 'The agent session failed and was stopped; reopen it to continue';
-/** How often the Qoder side-file reader polls (the live repair's timer). */
-const SIDE_POLL_MS = 1_000;
 /** stderr kept for a startup failure's message (the `err` records the processor ignores). */
 const STDERR_TAIL_BYTES = 8_192;
 /** Within a turn, a checkpoint every this many bytes of folded raw (spec §5.5, §14). */
@@ -210,7 +116,6 @@ export class ProcessorSession {
     openResult;
     historyEnd;
     history = [];
-    side;
     /** The record loop's tail: notes it appends are serialised behind it. */
     chain = Promise.resolve();
     /** The loop is held at a record boundary for a switch ({@link suspend}); `release` lets it go on. */
@@ -262,11 +167,12 @@ export class ProcessorSession {
             // resent when the server reopens the ref, and numbering continues after the highest seq the outbox ever held.
             const attached = await transport.attach(sessionKey);
             let leftovers = await readOutboxTail(transport, sessionKey, attached.outbox);
-            if (seed && seed.imports.length > 0) {
+            const imports = (seed?.imports ?? options.imports ?? []).filter((entry) => entry.seq > (attached.outbox?.lastSeq ?? 0));
+            if (imports.length > 0) {
                 // A switch's successor (Task 24): the predecessor's unacknowledged frames land here before anything this session numbers —
                 // the predecessor is released only after this append returned (never the other way round: the frames would be nowhere).
                 const at = Math.max(spawned.o - 1, 0);
-                const entries = seed.imports.map((entry, k) => ({ seq: entry.seq, src: { o: at, i: DAEMON_FRAME_INDEX + k }, frame: { ...entry.frame } }));
+                const entries = imports.map((entry, index) => ({ seq: entry.seq, src: { o: at, i: DAEMON_FRAME_INDEX + index }, frame: { ...entry.frame } }));
                 const { first } = await transport.appendOutbox(sessionKey, entries);
                 leftovers = [...leftovers, ...entries.map((entry, k) => ({ o: first + k, t: Date.now(), ...entry }))];
             }
@@ -552,14 +458,9 @@ export class ProcessorSession {
         if (this.checkpointDue && this.checkpointSafe())
             this.cutCheckpoint();
     }
-    /**
-     * A checkpoint must let a replay continue from it alone: not while a chunked Qoder fact is half-read (`sideChunk`, its first
-     * chunks would be truncated away) nor inside a load's history window (history is never journaled: a daemon that dies in the
-     * window loads again — interface-contracts, T19).
-     */
     checkpointSafe() {
         const state = this.processor.state;
-        return state.offset >= 0 && state.offset <= this.recordedThrough && state.boundaries.sideChunk === null && state.history === null &&
+        return state.offset >= 0 && state.offset <= this.recordedThrough && state.history === null &&
             this.processor.poisoned === undefined;
     }
     /** Snapshot now (a record boundary: the loop is between records) and commit it with raw truncated through it (not a marker's). */
@@ -644,7 +545,7 @@ export class ProcessorSession {
     /** Async tasks / background work the adapter still runs for this session (processor state): a switch would kill them. */
     get liveBackgroundWork() {
         const state = this.processor.state;
-        return unfinishedAsyncTasks(state).length + (sideDemand(state)?.active() ? 1 : 0);
+        return unfinishedAsyncTasks(state).length + unfinishedDraftSubagentCount(state);
     }
     /** The adapter's exit, once it has one: the spawn it ended and why (keeper-acp's `reason`, absent for an exit of its own). */
     get adapterExit() {
@@ -945,7 +846,6 @@ export class ProcessorSession {
         for (const [, reply] of this.pendingReplies)
             reply({ ok: false, error: reason });
         this.pendingReplies.clear();
-        this.stopSide();
         void this.transport.terminate(this.key).catch(() => null);
         try {
             this.options.onDegrade?.(this.headSeq);
@@ -1010,20 +910,8 @@ export class ProcessorSession {
             ...(request.sessionId !== undefined ? { sessionId: request.sessionId } : {}),
             mcpServers: request.mcpServers,
             ...(request.redact && request.redact.length > 0 ? { redact: [...request.redact] } : {}),
-            ...(request.delegation ? { delegation: request.delegation } : {}),
         };
-        const repair = request.mode === 'load' ? request.repair : undefined;
-        if (repair) {
-            // The repair note must follow the open note before the loop folds the open note (and so writes the `session/load` line
-            // the history answers): the loop is held while both are appended.
-            await this.holdingLoop(async () => {
-                await this.send(note);
-                await this.enableRepair(request.sessionId, request.cwd, repair.historyHome);
-            });
-        }
-        else {
-            await this.send(note);
-        }
+        await this.send(note);
         return this.waitFor(() => this.openResult);
     }
     /** Runs `work` (appends only — never a wait on the loop) with the record loop held, so no record is folded meanwhile. */
@@ -1044,55 +932,6 @@ export class ProcessorSession {
             await this.send({ type: 'historyEnd' });
         return this.waitFor(() => this.historyEnd);
     }
-    /**
-     * Turn the Qoder background terminal repair on (17c): the `qoder_terminal_repair` note, then the side-file reader. Nothing for a
-     * runtime the repair does not certify (no history path).
-     */
-    async enableRepair(nativeSessionId, cwd, historyHome, restoreCalls = false) {
-        const path = nativeTerminalHistoryPath(this.agentInfo, nativeSessionId, cwd, historyHome);
-        if (!path || this.side?.nativeSessionId === nativeSessionId)
-            return;
-        // A load that failed and fell back to `session/new`: the processor closed the load's repair (`settleOpen`); its reader goes
-        // too, and the new session gets its own (the old path closed the attached session and opened a fresh one).
-        this.stopSide();
-        const from = await this.appendNote({ type: REPAIR_NOTE, nativeSessionId, ...(restoreCalls ? { restoreCalls: true } : {}) });
-        const reader = new BackgroundSideNotes({ path, nativeSessionId, cwd, restoreCalls });
-        const timer = setInterval(() => { void this.pollSide(); }, SIDE_POLL_MS);
-        timer.unref();
-        this.side = { reader, timer, from, polling: false, nativeSessionId };
-    }
-    async pollSide() {
-        const side = this.side;
-        if (!side || side.polling || this.degraded !== undefined || this.closing)
-            return;
-        // The demand is the processor's *current* state, so only once it has folded everything this object appended.
-        if (this.processor.state.offset < Math.max(side.from, this.appended))
-            return;
-        const demand = sideDemand(this.processor.state);
-        if (!demand) {
-            this.stopSide();
-            return;
-        }
-        side.polling = true;
-        try {
-            const notes = await side.reader.poll(demand);
-            for (const note of notes)
-                await this.appendNote(note);
-        }
-        catch (error) {
-            this.log(`[acp] session ${this.key}: background terminal read failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        finally {
-            side.polling = false;
-        }
-    }
-    stopSide() {
-        if (!this.side)
-            return;
-        clearInterval(this.side.timer);
-        this.side.reader.close();
-        this.side = undefined;
-    }
     // ---- AcpAgentSession ----------------------------------------------------------------------------------------------------
     get facts() {
         const initialize = this.processor.state.initialize;
@@ -1108,7 +947,6 @@ export class ProcessorSession {
     get configOptions() { return this.processor.state.configOptions ?? []; }
     get runtimeDiagnostics() { return runtimeDiagnostics(this.processor.state); }
     get activityRaw() { return activityRaw(this.processor.state); }
-    get delegation() { return this.processor.state.delegation ?? null; }
     get nativeSessionId() {
         const root = this.processor.state.rootSessionId;
         return root !== null && root.length > 0 ? root : null;
@@ -1283,7 +1121,6 @@ export class ProcessorSession {
             this.resume();
             this.detached = true;
             this.unlisten();
-            this.stopSide();
             for (const waiter of [...this.waiters])
                 waiter.reject(new Error('The agent session was handed to the next daemon'));
             // A loop waiting for room stops (it sees `closing`); the head checkpoint is cut at the record boundary after it.
@@ -1307,7 +1144,6 @@ export class ProcessorSession {
         this.closing ??= (async () => {
             this.resume(); // a held loop drains (every fold sees `closing`)
             this.unlisten();
-            this.stopSide();
             for (const waiter of [...this.waiters])
                 waiter.reject(new Error('The agent session is closed'));
             for (const [, reply] of this.pendingReplies)