@khorsheed/dsh-local-agent-kimi 0.2.0-rc.3 → 0.2.0

package/lib/types/live-driver.js

@@ -16,11 +16,14 @@
  * throttled `mirrorKimiDelta` passes and the settle pass stays authoritative
  * (one fold, one offset, zero divergence between the two drivers). Every
  * transcript item folds 1:1 into the child session log.
- * Live output also mirrors the in-flight item: chunk
- * deltas accumulate per streaming item and append throttled snapshot
- * assistant/messages at the item's reserved (turn, step) — the host folds
- * repeated settles at one coordinate into one live-updating chat node — and
- * the wire line completing the item folds at the same step, finalizing it.
+ * Live output rides the `local-agent/stream` channel: chunk deltas
+ * accumulate per streaming item and publish throttled updates at the item's
+ * reserved (turn, step) — the member live node renders them as-is — while
+ * the item's durable content lands as ONE atomic step/start→…→step/end
+ * triple at that step, written by the completing wire line's fold or at
+ * settle. Durable steps stay dense and strictly sequential (the released-log
+ * reader validates exactly that on every cold open); snapshots never hold a
+ * step open across appends.
  *
  * Lifecycle mirrors the dsh/codex live drivers' discipline: lazy spawn with an
  * initialize handshake (loadSession capability required — crash recovery is
@@ -37,7 +40,7 @@ import { configureKimiSession } from './session-configuration.js';
 import { kimiNativeConfiguration } from './model-catalog.js';
 import { StringDecoder } from 'node:string_decoder';
 import { randomUUID } from 'node:crypto';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createToolResultMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionId } from '@deepseek-ai/dsh-session';
 import { settleRunResult, subprocessRunHandle, } from '@deepseek-ai/dsh-subagent';
 import { delegationEnv, persistChildSession, LiveStreamPublisher, LiveFlush, LIVE_FLUSH_INTERVAL_MS } from '@khorsheed/dsh-local-agent';
@@ -45,7 +48,7 @@ import { endpointAuthEnv, hasEndpointCredential } from './endpoint-auth.js';
 import { ensureKimiEndpointProvider, KIMI_MANAGED_BASE_URL } from './provision.js';
 import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV } from '@khorsheed/dsh-local-agent/types';
 import { DEFAULT_DISPOSE_GRACE_MS, mirrorKimiDelta, textTask, } from './kimi-cli-provider.js';
-import { assistantEvent, nextKimiSessionStep } from './session-mirror.js';
+import { assistantEvent, KIMI_INTERRUPTED_TOOL_RESULT, nextKimiSessionStep, nextWrittenKimiStep } from './session-mirror.js';
 import { addTokenUsage } from './session-view.js';
 import { writeKimiDefaultModel } from './provision.js';
 /** Default idle lifetime of an unused resident runtime before reclaim. */
@@ -793,25 +796,17 @@ export class KimiAcpLiveDriver {
         /** The round's accumulated assistant text (the run output — chunks are the only source). */
         let roundText = '';
         /**
-         * The step ledger: every step a stream reservation consumed this round
-         * (in increasing order — permanently, whether the stream later completes
-         * or stays an orphan snapshot). The file fold skips these steps for its
-         * sequential folds, so a tool card folded mid-stream lands ABOVE the
-         * stream's step and the projection renders the round's chronological
-         * order.
+         * The step ledger: the steps in-flight reservations currently hold this
+         * round. A reservation's durable content lands at the fold that consumes
+         * it (possibly carrying several reservations' kinds in one message — the
+         * wire step's fold), which RELEASES the other consumed coordinates for
+         * later folds; only a reservation kimi never completes (a plan stream, an
+         * unwired tool notification) stays held until its settle-time finalize.
+         * The file fold skips held steps for its sequential folds, so a tool card
+         * folded mid-stream lands ABOVE the stream's step and the projection
+         * renders the round's chronological order.
          */
         const reservedSteps = [];
-        /**
-         * The streaming items seen this round . kimi's ACP
-         * chunks carry no item id, so the stream key is synthetic per kind per
-         * round (the codex live driver's fallback shape): thought chunks share
-         * one stream, message chunks another. Deltas accumulate into throttled
-         * snapshot assistant/messages appended at the stream's reserved
-         * (turn, step) — the host folds repeated settles at one coordinate into
-         * one live-updating chat node. The wire line that completes the stream's
-         * kind folds at the same step and finalizes it; an entry whose completion
-         * never folds is force-finalized at settle.
-         */
         const streams = new Map();
         /** The stream the latest delta accumulated into (a kind switch force-snapshots it). */
         let activeStream;
@@ -839,7 +834,23 @@ export class KimiAcpLiveDriver {
         };
         /** A stream's synthetic key: kimi's ACP deltas carry no item id, so kind + turn pairs them. */
         let generation = 0;
+        /**
+         * One step reservation per generation, shared by the think and text
+         * streams of the same response segment: the host's own live shape is
+         * reasoning + text on ONE step, and a per-kind step would leave the
+         * consumed reservation's stream frames pointing at a step that never
+         * materializes (an empty trailing step breaks the host's answer
+         * detection, folding the reply into the collapsed process block).
+         */
+        const generationSteps = new Map();
         const seenToolCalls = new Set();
+        /**
+         * ACP tool_call notifications' chronological reservations (call id →
+         * step, plus the notification's display title). No durable event lands at
+         * notification time: the native lifecycle (advertisement, call, result in
+         * one closed step) is written by the wire line's fold, or at settle with
+         * an interrupted placeholder when kimi never logged the call.
+         */
         const toolSteps = new Map();
         const streamKey = (kind) => `kimi-stream-${kind}-${turn}-${generation}`;
         /** The plan stream's key: a snapshot stream beside the think/text delta streams. */
@@ -857,7 +868,7 @@ export class KimiAcpLiveDriver {
             const stream = streams.get(key);
             if (stream !== undefined) {
                 stream.text += text;
-                appendStreamSnapshot(stream, false, false);
+                publishStreamSnapshot(stream, false);
             }
             localAgent?.reportRunProgress(childSession.id, { kind: 'delta', text });
         };
@@ -881,133 +892,304 @@ export class KimiAcpLiveDriver {
             if (plan === '')
                 return;
             // The plan's own snapshot stream (think-styled): every update replaces
-            // the text and lands a snapshot at the reserved (turn, step); the
-            // stream force-finalizes at settle (the wire carries no plan line
-            // that could complete it).
+            // the text and publishes at the reserved (turn, step); the stream
+            // finalizes at settle (the wire carries no plan line that could
+            // complete it) — or early, when a fold needs its step closed.
             reserveStream(planKey, 'think');
             const stream = streams.get(planKey);
             if (stream !== undefined && stream.text !== plan) {
                 stream.text = plan;
-                appendStreamSnapshot(stream, true, false);
+                publishStreamSnapshot(stream, true);
             }
         };
         /**
-         * Append one snapshot of a streaming item at its reserved (turn, step).
-         * Batched per stream on a bounded deadline unless `force`; the forced
-         * final snapshot carries `interrupted` (a cancelled turn reads 已停止
-         * legitimately) and, when `withUsage`, the round's uncarried usage. An
-         * empty stream leaves no boundary at all.
+         * The live-output channel. Snapshots are browser-only previews (never
+         * `local-agent/stream` log events) — durable step content lands once per
+         * stream, at finalization, as the fold's atomic triple.
          */
         const streamPublisher = localAgent?.liveStreams === undefined ? undefined
             : new LiveStreamPublisher(localAgent.liveStreams, childSession, turn, persist, error => this.ctx.logger.warn(`live checkpoint failed: ${String(error)}`));
         const liveFlush = new LiveFlush(error => this.ctx.logger.warn(`live mirror flush failed: ${String(error)}`), this.config.snapshotMinIntervalMs ?? DEFAULT_SNAPSHOT_MIN_INTERVAL_MS);
         const pendingStreamArrival = new Map();
-        const appendStreamSnapshot = (stream, force, interrupted, withUsage = false, final = false) => {
-            if (stream.text.trim() === '')
+        /**
+         * Publish one snapshot of a streaming item at its reserved (turn, step)
+         * through the live channel. Batched per stream on a bounded deadline
+         * unless `force`. Never writes durable content.
+         */
+        const publishStreamSnapshot = (stream, force) => {
+            if (stream.text.trim() === '' || stream.sealed === true)
                 return;
             const now = Date.now();
             if (!force) {
                 if (!pendingStreamArrival.has(stream.step))
                     pendingStreamArrival.set(stream.step, now);
-                liveFlush.schedule(stream.step, () => appendStreamSnapshot(stream, true, interrupted, withUsage));
+                liveFlush.schedule(stream.step, () => publishStreamSnapshot(stream, true));
                 return;
             }
             liveFlush.cancel(stream.step);
             const receivedAt = pendingStreamArrival.get(stream.step) ?? now;
             pendingStreamArrival.delete(stream.step);
-            if (streamPublisher !== undefined && !final) {
-                if (!stream.opened) {
-                    childSession.append('step/start', { turn, step: stream.step });
-                    stream.opened = true;
+            // The kind rides the item id so two kinds sharing one step never collide.
+            // Browser-only (preview): the step is reserved, not yet open in the log,
+            // and a durable checkpoint there would land before its step/start — a
+            // replayed log then orders that step first and loses the turn's final
+            // answer under the fold. The durable content is the fold's atomic triple.
+            streamPublisher?.preview(stream.step, stream.kind, stream.text, { receivedAt, itemId: stream.kind });
+            stream.lastSnapshotLen = stream.text.length;
+        };
+        /**
+         * Write the stream's durable content as ONE atomic
+         * step/start→assistant/message→step/end triple at its reserved step and
+         * seal the reservation (its completing wire line, when one exists, pairs
+         * and drops). `interrupted` marks a non-completed round's partial (a
+         * cancelled turn reads 已停止 legitimately); `withUsage` attaches the
+         * round's uncarried usage.
+         */
+        /**
+         * Write the durable content of every stream sharing one step as ONE atomic
+         * step/start→assistant/message→step/end triple (a generation's think and
+         * text merge into a single message — the host's own shape) and seal the
+         * reservations. `interrupted` marks a non-completed round's partial (a
+         * cancelled turn reads 已停止 legitimately); `withUsage` attaches the
+         * round's uncarried usage.
+         */
+        const finalizeStep = (step, entries, interrupted, withUsage) => {
+            liveFlush.cancel(step);
+            pendingStreamArrival.delete(step);
+            const reasoning = entries.filter(([, stream]) => stream.kind === 'think').map(([, stream]) => stream.text).join('');
+            const text = entries.filter(([, stream]) => stream.kind === 'text').map(([, stream]) => stream.text).join('');
+            const blocks = [];
+            if (reasoning.trim() !== '')
+                blocks.push({ type: 'reasoning', text: reasoning });
+            if (text.trim() !== '')
+                blocks.push({ type: 'text', text });
+            if (blocks.length === 0) {
+                // Nothing durable to write: release the coordinate instead of pinning
+                // it forever — a later fold landing above would otherwise strand a
+                // permanent step gap the released-log reader rejects as corruption.
+                streamPublisher?.finish(step);
+                const keys = new Set(entries.map(([key]) => key));
+                const held = new Set([...streams.entries()]
+                    .filter(([key, stream]) => !keys.has(key) && stream.sealed !== true)
+                    .map(([, stream]) => stream.step));
+                if (!held.has(step)) {
+                    const index = reservedSteps.indexOf(step);
+                    if (index >= 0)
+                        reservedSteps.splice(index, 1);
+                }
+                for (const [key, stream] of entries) {
+                    stream.sealed = true;
+                    generationSteps.delete(stream.generation);
+                    if (activeStream === key)
+                        activeStream = undefined;
                 }
-                streamPublisher.update(stream.step, stream.kind, stream.text, { receivedAt });
-                stream.lastSnapshotAt = now;
-                stream.lastSnapshotLen = stream.text.length;
                 return;
             }
-            if (!stream.opened) {
-                childSession.append('step/start', { turn, step: stream.step });
-                stream.opened = true;
-            }
+            // The reservation keyed the preview; the log takes the next step in write order.
+            const durable = nextWrittenKimiStep(childSession, turn);
+            childSession.append('step/start', { turn, step: durable });
             childSession.append('assistant/message', {
                 turn,
-                step: stream.step,
-                message: assistantEvent([
-                    stream.kind === 'think'
-                        ? { type: 'reasoning', text: stream.text }
-                        : { type: 'text', text: stream.text },
-                ], runtime?.modelConfiguration?.currentModel ?? roundModel),
+                step: durable,
+                message: assistantEvent(blocks, runtime?.modelConfiguration?.currentModel ?? roundModel),
                 stream: [],
                 ...withUsage && roundUsage !== undefined ? { usage: roundUsage } : {},
                 ...interrupted ? { interrupted: true } : {},
             }, { surfaceOp: 'append' });
             if (withUsage)
                 roundUsage = undefined;
-            stream.lastSnapshotAt = now;
-            stream.lastSnapshotLen = stream.text.length;
+            streamPublisher?.finish(step);
+            childSession.append('step/end', { turn, step: durable });
+            for (const [key, stream] of entries) {
+                stream.sealed = true;
+                generationSteps.delete(stream.generation);
+                if (activeStream === key)
+                    activeStream = undefined;
+            }
             persist();
         };
+        /**
+         * Write the durable step for an ACP tool call kimi never logged to the
+         * wire (a crash between the notification and the wire flush): the
+         * notification's title stands in for the name and the result is the
+         * shared interrupted placeholder — the native lifecycle in one step.
+         */
+        /** Whether this turn's log already carries the tool call (folded from the wire). */
+        const toolLogged = (id) => childSession.snapshotEvents().some(event => event.type === 'tool/call' && event.data.turn === turn
+            && event.data.callId === id);
+        const finalizeOrphanTool = (id, entry) => {
+            const name = entry.title ?? 'tool';
+            // The reservation keyed the preview; the log takes the next step in write order.
+            const step = nextWrittenKimiStep(childSession, turn);
+            childSession.append('step/start', { turn, step });
+            childSession.append('assistant/message', {
+                turn,
+                step,
+                message: assistantEvent([{ type: 'tool-call', id: id, name, arguments: '' }], runtime?.modelConfiguration?.currentModel ?? roundModel),
+                stream: [],
+            }, { surfaceOp: 'append' });
+            const call = childSession.append('tool/call', {
+                turn,
+                step,
+                callId: id,
+                name,
+                arguments: '',
+            });
+            childSession.append('tool/result', {
+                turn,
+                step,
+                message: createToolResultMessage({
+                    callId: id,
+                    content: [{ type: 'text', text: KIMI_INTERRUPTED_TOOL_RESULT }],
+                    isError: true,
+                }),
+            }, { surfaceOp: 'append', sourceEventSeqs: [call.seq] });
+            childSession.append('step/end', { turn, step });
+        };
+        /**
+         * The fold's gap fill: a fold about to write at `step` first finalizes
+         * every live stream reserved below it (ascending), so the stored log's
+         * steps land dense and strictly sequential. Only streams can sit in the
+         * gap: an unresulted tool line holds its fold instead (session-mirror).
+         */
+        const finalizeBefore = (targetTurn, step) => {
+            if (targetTurn !== turn)
+                return;
+            const pending = [...streams.entries()]
+                .filter(([, stream]) => stream.sealed !== true && stream.step < step)
+                .sort((a, b) => a[1].step - b[1].step);
+            const byStep = new Map();
+            for (const entry of pending) {
+                const group = byStep.get(entry[1].step) ?? [];
+                group.push(entry);
+                byStep.set(entry[1].step, group);
+            }
+            for (const [at, entries] of byStep)
+                finalizeStep(at, entries, false, false);
+        };
         /**
          * Reserve the step one streaming item will occupy — past every folded
          * line (the session's own event ledger: the file fold writes events
-         * synchronously) and every earlier reservation. A kind switch forces one
-         * freshness snapshot of the current stream (skipped when its text has not
-         * grown since the last one); its completion still folds at its own
-         * reserved step when the wire line lands.
+         * synchronously) and every earlier reservation. A kind switch publishes
+         * one freshness snapshot of the current stream (skipped when its text has
+         * not grown since the last one); its durable triple still lands at its
+         * own reserved step when the wire line folds or the round settles.
          */
         const reserveStream = (key, kind) => {
             if (activeStream !== undefined && activeStream !== key) {
                 const previous = streams.get(activeStream);
                 if (previous !== undefined && previous.text.length !== previous.lastSnapshotLen) {
-                    appendStreamSnapshot(previous, true, false);
+                    publishStreamSnapshot(previous, true);
                 }
                 activeStream = undefined;
             }
             let stream = streams.get(key);
+            // A sealed entry's durable triple already landed: later deltas (a plan
+            // rewriting itself after a gap fill, a same-generation think resuming)
+            // open a FRESH reservation instead of growing a closed step.
+            if (stream?.sealed === true) {
+                streams.delete(key);
+                stream = undefined;
+            }
             if (stream === undefined) {
-                let step = nextKimiSessionStep(childSession, turn);
-                for (const reserved of reservedSteps)
-                    step = Math.max(step, reserved + 1);
-                reservedSteps.push(step);
-                stream = { kind, step, text: '', lastSnapshotAt: 0, lastSnapshotLen: 0, opened: false };
+                // The think and text streams of one generation share ONE reserved
+                // step; the plan stream keeps its own.
+                let step = key === planKey ? undefined : generationSteps.get(generation);
+                if (step === undefined) {
+                    step = nextKimiSessionStep(childSession, turn);
+                    while (reservedSteps.includes(step))
+                        step += 1;
+                    reservedSteps.push(step);
+                    if (key !== planKey)
+                        generationSteps.set(generation, step);
+                }
+                stream = { kind, step, generation: key === planKey ? -1 : generation, text: '', lastSnapshotLen: 0 };
                 streams.set(key, stream);
             }
             activeStream = key;
         };
         /**
-         * The fold-pass coordination surface : the file
-         * fold skips reserved steps for sequential folds and pairs a completed
-         * think/assistant line with its stream — scoped to THIS round's turn, so
-         * an earlier round's leftover lines never consume this round's stream.
+         * The fold-pass coordination surface: the file
+         * fold skips reserved steps for sequential folds, pairs one fold with the
+         * round's in-flight streams of the fold's kinds (consuming both — a wire
+         * step's think and text ride ONE durable step), and closes every
+         * reservation below each fold step first (finalizeBefore) — scoped to
+         * THIS round's turn, so an earlier round's leftover lines never consume
+         * this round's stream.
          */
         const mirrorStreams = {
             reservedSteps: t => t === turn ? reservedSteps : [],
-            completeTool: (line) => {
+            finalizeBefore,
+            releaseTool: (line) => {
                 if (line.turn !== turn)
-                    return undefined;
-                const step = toolSteps.get(line.id);
-                if (step === undefined)
-                    return undefined;
+                    return;
+                const entry = toolSteps.get(line.id);
+                if (entry === undefined)
+                    return;
                 toolSteps.delete(line.id);
-                return { step, opened: true };
+                // The fold's step carries the whole lifecycle; the coordinate frees.
+                const index = reservedSteps.indexOf(entry.step);
+                if (index >= 0)
+                    reservedSteps.splice(index, 1);
             },
-            completeStream: (line) => {
-                if (line.turn !== turn)
+            completeStreams: (t, kinds) => {
+                if (t !== turn)
                     return undefined;
-                const kind = line.kind === 'think' ? 'think' : 'text';
-                const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
-                if (entry === undefined)
+                const picked = [];
+                for (const kind of kinds) {
+                    const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
+                    if (entry !== undefined)
+                        picked.push(entry);
+                }
+                if (picked.length === 0)
                     return undefined;
-                const [key, stream] = entry;
-                liveFlush.cancel(stream.step);
-                streamPublisher?.finish(stream.step);
-                streams.delete(key);
-                if (activeStream === key)
-                    activeStream = undefined;
-                return { step: stream.step, opened: stream.opened };
+                const sealed = [];
+                for (const [key, stream] of picked) {
+                    streams.delete(key);
+                    generationSteps.delete(stream.generation);
+                    if (activeStream === key)
+                        activeStream = undefined;
+                    // A sealed entry's durable triple already landed: its content stays
+                    // out of the fold, and its coordinate keeps its (durable) place.
+                    if (stream.sealed === true) {
+                        sealed.push(stream.kind);
+                        continue;
+                    }
+                    liveFlush.cancel(stream.step);
+                }
+                const open = picked.filter(([, stream]) => stream.sealed !== true);
+                if (open.length === 0)
+                    return { sealed };
+                // The reservations whose content rides this fold free their own —
+                // unless another open stream still holds the same (shared) step.
+                const held = new Set([...streams.values()].filter(stream => stream.sealed !== true).map(stream => stream.step));
+                for (const [, stream] of open) {
+                    if (held.has(stream.step))
+                        continue;
+                    const index = reservedSteps.indexOf(stream.step);
+                    if (index >= 0)
+                        reservedSteps.splice(index, 1);
+                }
+                for (const step of new Set(open.map(([, stream]) => stream.step)))
+                    streamPublisher?.finish(step);
+                // The fold's coordinate: the earliest consumed reservation — or a
+                // lower step an earlier release freed, so the stored log stays dense.
+                // A step whose triple an earlier fold already wrote takes nothing.
+                const written = new Set();
+                for (const event of childSession.snapshotEvents()) {
+                    const data = event.data;
+                    if (event.type === 'step/start' && data.turn === turn && typeof data.step === 'number')
+                        written.add(data.step);
+                }
+                let free = nextKimiSessionStep(childSession, turn);
+                while (reservedSteps.includes(free))
+                    free += 1;
+                const candidates = [...new Set(open.map(([, stream]) => stream.step))].filter(step => !written.has(step));
+                const step = Math.min(free, ...candidates);
+                return { step, sealed };
             },
         };
-        const mirrorOptions = () => ({ streams: mirrorStreams });
+        const mirrorOptions = (settle = false) => ({ streams: mirrorStreams, ...settle ? { settle: true } : {} });
         /**
          * Observation accounting across mirror passes: a pass whose window
          * attached its usage to a folded message is already carried; anything else
@@ -1016,8 +1198,8 @@ export class KimiAcpLiveDriver {
          * the latest.
          */
         const noteMirrorUsage = (delta) => {
-            if (delta.usage !== undefined && delta.usageAttached !== true) {
-                roundUsage = addTokenUsage(roundUsage, delta.usage);
+            if (delta.usageUnattached !== undefined) {
+                roundUsage = addTokenUsage(roundUsage, delta.usageUnattached);
             }
             if (delta.model !== undefined)
                 roundModel = delta.model;
@@ -1078,22 +1260,32 @@ export class KimiAcpLiveDriver {
                     const stream = streams.get(key);
                     if (stream !== undefined) {
                         stream.text += text;
-                        appendStreamSnapshot(stream, false, false);
+                        publishStreamSnapshot(stream, false);
                     }
                 }
             }
             else if (kind === 'tool_call') {
                 const id = typeof update['toolCallId'] === 'string' ? update['toolCallId'] : undefined;
                 if (id === undefined || !seenToolCalls.has(id)) {
-                    if (id !== undefined) {
+                    // The wire flush can win the race: a call already folded into the
+                    // log (its notification arriving late) needs no reservation — one
+                    // would never be released and settle would write the call twice.
+                    if (id !== undefined && toolLogged(id))
+                        seenToolCalls.add(id);
+                    else if (id !== undefined) {
                         seenToolCalls.add(id);
+                        // Reserve the chronological step only — nothing durable lands at
+                        // notification time. The wire line's fold writes the whole native
+                        // lifecycle in one step; a call kimi never logs finalizes as an
+                        // interrupted placeholder at settle.
                         let step = nextKimiSessionStep(childSession, turn);
-                        for (const reserved of reservedSteps)
-                            step = Math.max(step, reserved + 1);
+                        while (reservedSteps.includes(step))
+                            step += 1;
                         reservedSteps.push(step);
-                        toolSteps.set(id, step);
-                        childSession.append('step/start', { turn, step });
-                        persist();
+                        toolSteps.set(id, {
+                            step,
+                            ...typeof update['title'] === 'string' ? { title: update['title'] } : {},
+                        });
                     }
                     // ACP has no text-item ids. A new tool call separates generation
                     // segments; late file folds consume same-kind segments in order.
@@ -1191,7 +1383,7 @@ export class KimiAcpLiveDriver {
             let stableReads = 0;
             const deadline = Date.now() + SETTLE_MIRROR_QUIESCE_MS;
             for (;;) {
-                const delta = await mirrorKimiDelta(this.ctx, childSession, spec.homeDir, sessionId, mirrorOptions());
+                const delta = await mirrorKimiDelta(this.ctx, childSession, spec.homeDir, sessionId, mirrorOptions(true));
                 noteMirrorUsage(delta);
                 localAgent?.reportRunProgress(childSession.id, { kind: 'mirror', mirroredLines: delta.total });
                 stableReads = delta.total === lastTotal ? stableReads + 1 : 0;
@@ -1222,33 +1414,46 @@ export class KimiAcpLiveDriver {
             if (turnOpened) {
                 // Reconcile the file fold INSIDE the turn window
                 // (bounded quiescence — the price of the wire flush race; a mirror
-                // failure never fails the round), so every streamed item's completion
-                // fold lands at its reserved step before turn/end. Streams whose
-                // completing wire line never folded (abort, or a flush outlasting the
-                // quiescence window) then finalize in place: one forced snapshot each
-                // — interrupted on a non-completed round, the LAST one carrying the
-                // round's uncarried usage — then step/end.
+                // failure never fails the round), then finalize every reservation
+                // the fold left behind in ASCENDING step order, so the stored log's
+                // steps stay dense and strictly sequential — the contract the
+                // released-log reader validates on every cold open:
+                //   - a stream whose completing wire line never folded (abort, or a
+                //     flush outlasting the quiescence window) finalizes from its
+                //     accumulated text — interrupted on a non-completed round, the
+                //     LAST stream carrying the round's uncarried usage;
+                //   - a tool reservation kimi never logged to the wire finalizes as
+                //     an interrupted placeholder step.
                 try {
                     await settleMirror();
                 }
                 catch (error) {
                     this.ctx.logger.warn(`subagent-kimi: live settle mirror failed: ${thrown(error).message}`);
                 }
-                if (streams.size > 0) {
-                    const remaining = [...streams.values()];
-                    for (const [position, stream] of remaining.entries()) {
-                        appendStreamSnapshot(stream, true, settled.stopReason !== 'completed', position === remaining.length - 1, true);
-                        streamPublisher?.finish(stream.step);
-                        if (stream.opened)
-                            childSession.append('step/end', { turn, step: stream.step });
-                    }
-                    streams.clear();
-                    activeStream = undefined;
-                    persist();
-                }
-                for (const step of toolSteps.values())
-                    childSession.append('step/end', { turn, step });
+                const pending = [
+                    ...[...[...streams.entries()]
+                            .filter(([, stream]) => stream.sealed !== true)
+                            .reduce((byStep, entry) => {
+                            const group = byStep.get(entry[1].step) ?? [];
+                            group.push(entry);
+                            byStep.set(entry[1].step, group);
+                            return byStep;
+                        }, new Map())
+                            .entries()].map(([step, entries]) => ({ step, entries })),
+                    ...[...toolSteps.entries()].map(([toolId, tool]) => ({ step: tool.step, toolId, tool })),
+                ].sort((a, b) => a.step - b.step);
+                const lastStream = pending.map((entry, index) => 'entries' in entry ? index : -1).filter(index => index >= 0).at(-1);
+                pending.forEach((entry, index) => {
+                    if ('entries' in entry)
+                        finalizeStep(entry.step, entry.entries, settled.stopReason !== 'completed', index === lastStream);
+                    else if (!toolLogged(entry.toolId))
+                        finalizeOrphanTool(entry.toolId, entry.tool);
+                });
+                streams.clear();
                 toolSteps.clear();
+                activeStream = undefined;
+                if (pending.length > 0)
+                    persist();
                 if (settled.stopReason === 'completed') {
                     childSession.append('turn/end', { turn, reason: { kind: 'completed' } });
                 }