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

package/lib/types/session-mirror.js

@@ -10,7 +10,14 @@ import { join } from 'node:path';
 import { readdir, stat } from 'node:fs/promises';
 import { createAssistantMessage, createToolResultMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
 import { persistChildSession } from '@khorsheed/dsh-local-agent';
-import { readKimiTranscript, sumUsageRecords } from './session-view.js';
+import { addTokenUsage, readKimiTranscript, sumUsageRecords } from './session-view.js';
+/**
+ * The synthesized result for a call whose result the wire never recorded
+ * (a settle-pass fold, or a live reservation kimi never logged). The
+ * released-log contract resolves every advertised call before its step
+ * closes, so an interrupted call folds with this error result.
+ */
+export const KIMI_INTERRUPTED_TOOL_RESULT = '（工具调用被中断，未能记录返回结果）';
 /** One user-role message event. */
 function userEvent(text) {
     return createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } });
@@ -23,38 +30,46 @@ export function assistantEvent(blocks, model) {
     });
 }
 /**
- * The step the next fold pass would assign in one turn (the max existing
- * step + 1). The token-granularity live
- * driver reserves its stream merge key here LAZILY at the first delta, so
- * tool cards folded before the stream started keep their chronological
- * place below it instead of the stream squatting on step 1.
+ * The step the next fold pass would assign in one turn: the smallest step
+ * nothing holds (never written, never reserved at call time — callers skip
+ * their own reservations on top). Filling the smallest free step keeps the
+ * stored log dense: the released-log reader admits only dense, strictly
+ * sequential steps, and a reservation released mid-round (its content rode an
+ * earlier fold) leaves a gap only the next first-free write fills.
  * @param childSession - the run's child session.
  * @param turn - the round's turn number.
- * @returns the next free step in the turn.
+ * @returns the smallest free step in the turn.
  */
 export function nextKimiSessionStep(childSession, turn) {
-    let next = 1;
+    const taken = new Set();
     for (const event of childSession.snapshotEvents()) {
         const data = event.data;
         if (data.turn === turn && typeof data.step === 'number')
-            next = Math.max(next, data.step + 1);
+            taken.add(data.step);
     }
+    let next = 1;
+    while (taken.has(next))
+        next += 1;
     return next;
 }
 /**
- * Fold one non-tool transcript line into message blocks. Thinking maps to
- * the native `reasoning` block so the standard conversation renders it as
- * thinking rather than a `[思考]` text prefix; reply text stays text (content
- * is never filtered — kimi's own injections remain visible). Tool lines are
- * NOT folded here: they become native `tool/call`/`tool/result` event pairs
- * (see the mirror loop), so the standard conversation renders them as tool
- * cards instead of `[工具 X]` text.
+ * The step a durable write takes: one past the highest step this turn has
+ * opened in the log. The released-log reader admits steps only in order —
+ * one past the last, never below it — so the coordinate is decided when the
+ * step is written, never reserved ahead (a reservation filled later lands
+ * below a higher step already written: a gap, then a step out of order).
+ * Stream and tool reservations only key the live preview.
  */
-function lineBlocks(line) {
-    if (line.kind === 'think') {
-        return [{ type: 'reasoning', text: line.text }];
+export function nextWrittenKimiStep(childSession, turn) {
+    let last = 0;
+    for (const event of childSession.snapshotEvents()) {
+        if (event.type !== 'step/start')
+            continue;
+        const data = event.data;
+        if (data.turn === turn && typeof data.step === 'number' && data.step > last)
+            last = data.step;
     }
-    return [{ type: 'text', text: line.text }];
+    return last + 1;
 }
 /** The run-progress delta text for one transcript line (any kind). */
 export function kimiLineProgressText(line) {
@@ -64,10 +79,14 @@ export function kimiLineProgressText(line) {
     return `${call}${line.result !== undefined ? ` → ${line.result}` : ''}`;
 }
 /**
- * Mirror one kimi session's transcript into the dsh subagent session: each
- * user prompt becomes a `user/message`, each assistant reply (including
- * folded thinking and tool activity) an `assistant/message`, then the events
- * are appended to persistence so the child session is viewable.
+ * Mirror one kimi session's transcript into a dsh subagent session: each
+ * user prompt becomes a `user/message`, and each WIRE STEP (one LLM request:
+ * its thinking, reply text and tool calls share the wire's own step number)
+ * folds into one dsh step whose `assistant/message` carries the reasoning,
+ * text and tool-call blocks together — the host session's own shape, so the
+ * standard surfaces (conversation, Context Lens) read one request per LLM
+ * call. Then the events are appended to persistence so the child session is
+ * viewable.
  *
  * A resumed round (or a live poll) passes the already-mirrored
  * transcript-line count so only the delta is appended — re-mirroring earlier
@@ -77,22 +96,29 @@ export function kimiLineProgressText(line) {
  * already in the child session, so a round mirrored across several live polls
  * does not restart step 1 per poll.
  *
- * Every folded step is wrapped in the `step/start`–`step/end` boundary pair
- * the live conversation assembler requires: without a boundary the step never
- * enters the location index, the assistant message resolves to a turn-level
- * location, and the real-time view renders nothing (only a full rebuild,
- * which mints step drafts from the explicit coordinates, recovers it). A
- * think/assistant line that completes an in-flight stream folds at the
- * stream's reserved step instead (see {@link KimiMirrorStreams}), and a
- * sequential fold never takes a step a stream reserved.
+ * Every folded step is one ATOMIC `step/start`–`step/end` triple, written
+ * only when its content lands: the released-log reader admits only dense,
+ * strictly sequential steps (one open at a time — a second `step/start`
+ * while another step is open fails the session's reload validation), and the
+ * live conversation assembler needs the boundary to materialize the step at
+ * all. A fold paired with in-flight streams lands at the earliest consumed
+ * reservation (see {@link KimiMirrorStreams}), after `finalizeBefore` has
+ * closed every stream reservation below it; a sequential fold never takes a
+ * step a stream reserved. Mid-round, a wire step the wire has not CLOSED yet
+ * (no `step.end`) holds the pass — its parts may still arrive — and so does
+ * an unresulted tool call (the reader resolves every advertised call before
+ * the step closes; the result merges into the call's line in place, so the
+ * next pass sees it). The settle pass folds the remainder with a synthesized
+ * interrupted result. Lines the wire never step-tagged (older kimi) fold one
+ * by one, immediately, as before.
  *
  * Usage accounting is exactly-once ACROSS passes: each `usage.record` is
- * tagged with the transcript position it occurred at, and a pass attaches the
- * records in the half-open range `(fromLines, newTotal]` — the records that
- * trail THIS pass's lines — summed onto the delta's final assistant message.
- * (A record flushed only after its line was already mirrored belongs to no
- * later pass and is dropped; kimi flushes content and usage together per
- * request, so this window is a flush race, not the norm.)
+ * tagged with the transcript position it occurred at, a pass owns the records
+ * between the old offset and its own consumed end, and inside the window each
+ * record rides the unit whose line span encloses it — one record per wire
+ * step, landing on its own step's message. (A record raced PAST its content
+ * encloses into the next unit instead: attribution off by one in a flush
+ * race, totals still exact.)
  * @param ctx - host context carrying the session persistence service.
  * @param childSession - the dsh subagent session created for this delegation.
  * @param homeDir - the `kimi` harness's scoped home.
@@ -100,7 +126,9 @@ export function kimiLineProgressText(line) {
  *   recent session (a one-shot `kimi -p` run always creates a fresh one).
  * @param fromLines - transcript lines already mirrored into the child session
  *   (0 for the first round); only lines after this offset are appended.
- * @returns the new total and the newly mirrored lines' texts.
+ * @returns the new mirror offset and the newly mirrored lines' texts. A held
+ *   unit (open wire step or unresulted tool) stops the offset before itself;
+ *   the next pass retries from there.
  */
 export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, fromLines = 0, options) {
     let workspaces;
@@ -164,7 +192,6 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
     }
     if (transcript === undefined || transcript.lines.length === 0)
         return { total: 0, texts: [] };
-    const newTotal = transcript.lines.length;
     const delta = transcript.lines.slice(fromLines);
     const observedModel = options?.turn === undefined || transcript.modelTurn === options.turn ? transcript.model : undefined;
     // The ROUND's tool calls, counted over the transcript lines carrying this
@@ -172,146 +199,212 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
     // whose delta a live poll already drained still owes the round its real
     // count, and a resume round must not inherit the earlier rounds' calls.
     const toolCalls = roundToolCalls(transcript.lines, options?.turn);
-    // No early return on an empty delta: a result that merged into an
-    // already-mirrored tool line does not change the line count, and the
-    // backfill below still owes that call its `tool/result` event.
-    // The pass attaches the usage records whose content ITS lines carry. kimi
-    // writes a request's `usage.record` BEFORE the content parts it accounts
-    // for, so a record sitting exactly on the delta boundary (its content is
-    // entirely inside this pass) must attach here — otherwise incremental
-    // folds (live mid-run + settle) lose the round's accounting entirely.
-    const deltaUsage = sumUsageRecords(transcript.usageRecords.filter(record => record.line >= fromLines && record.line <= newTotal));
-    // Attach the summed usage to the delta's LAST assistant message (text or
-    // think both carry the round's accounting; tool lines do not).
-    let lastAssistant = -1;
-    for (let index = 0; index < delta.length; index += 1) {
-        const line = delta[index];
-        if (line !== undefined && line.kind !== 'user' && line.kind !== 'tool')
-            lastAssistant = index;
+    const units = [];
+    for (const line of delta) {
+        if (line === undefined)
+            continue;
+        const last = units.at(-1);
+        const head = last?.[0];
+        if (last !== undefined && head !== undefined
+            && line.kind !== 'user' && head.kind !== 'user'
+            && line.wireStep !== undefined && line.wireStep === head.wireStep
+            && line.turn === head.turn) {
+            last.push(line);
+            continue;
+        }
+        units.push([line]);
     }
-    // Continue step numbering from the steps already mirrored (assistant
-    // messages AND tool events both consume steps), so a round mirrored across
-    // several live polls keeps 1, 2, 3… instead of restarting per poll.
-    const steps = new Map();
-    // The child session's own events are the ledger of mirrored tool calls:
-    // callId → its event (for pairing late results) and the already-settled
-    // call ids (so a backfill never duplicates a result).
-    const openCalls = new Map();
-    const settledCalls = new Set();
+    // Mid-round, a unit that may still grow HOLDS the pass: a wire-step group
+    // whose step the wire has not closed yet, or a unit whose tool call lacks
+    // its result (the released-log contract resolves every advertised call
+    // before its step closes; the result merges into the call's line in place,
+    // so the next pass sees it). The offset stops before the first such unit
+    // and the fold retries once the wire completes it. The settle pass never
+    // holds — a result that will never arrive folds as a synthesized
+    // interrupted one.
+    let holdAt = -1;
+    if (options?.settle !== true) {
+        for (let index = 0; index < units.length; index += 1) {
+            const unit = units[index];
+            const head = unit[0];
+            const openGroup = head.kind !== 'user'
+                && head.wireStep !== undefined
+                && !transcript.closedSteps.has(`${head.turn}:${head.wireStep}`);
+            if (openGroup || unit.some(line => line.kind === 'tool' && line.result === undefined)) {
+                holdAt = index;
+                break;
+            }
+        }
+    }
+    const foldedUnits = holdAt < 0 ? units : units.slice(0, holdAt);
+    const consumedTotal = fromLines + foldedUnits.reduce((n, unit) => n + unit.length, 0);
+    // Usage is exactly-once across passes: a pass owns the records at positions
+    // [fromLines, consumedTotal] (the boundary included — a record flushed right
+    // after its content otherwise falls out of every span). kimi's norm is one
+    // usage.record per wire step, right BEFORE the step's content, so a
+    // step-tagged unit claims its own line span's records; records no tagged
+    // unit claims (untagged spans on older wires, or the boundary) sum onto the
+    // pass's last folded content unit — the pre-tagging shape.
+    const unitUsage = [];
+    const claimed = [];
+    let unitStart = fromLines;
+    for (const unit of foldedUnits) {
+        const start = unitStart;
+        unitStart += unit.length;
+        const head = unit[0];
+        if (head.kind !== 'user' && head.wireStep !== undefined) {
+            claimed.push({ from: start, to: unitStart });
+            unitUsage.push(sumUsageRecords(transcript.usageRecords.filter(record => record.line >= start && record.line < unitStart)));
+        }
+        else {
+            unitUsage.push(undefined);
+        }
+    }
+    const unclaimedUsage = sumUsageRecords(transcript.usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal
+        && !claimed.some(span => record.line >= span.from && record.line < span.to)));
+    const deltaUsage = sumUsageRecords(transcript.usageRecords.filter(record => record.line >= fromLines && record.line <= consumedTotal));
+    // The steps a fold may NOT take: every step already written (the session's
+    // own event ledger), consulted per turn. A round mirrored across several
+    // live polls keeps its earlier writes, so later polls never reuse them.
+    const takenSteps = new Map();
     for (const event of childSession.snapshotEvents()) {
         const data = event.data;
         if (typeof data.turn === 'number' && typeof data.step === 'number') {
-            steps.set(data.turn, Math.max(steps.get(data.turn) ?? 0, data.step + 1));
-        }
-        if (event.type === 'tool/call') {
-            const call = event.data;
-            openCalls.set(call.callId, { turn: call.turn, step: call.step, seq: event.seq });
-        }
-        else if (event.type === 'tool/result') {
-            // The call id moved with the V4 message shape: rc.1's native tool-role
-            // message carries it at the top level, the pre-V4 user-role shape
-            // wrapped it in the single content block. Read both — a session
-            // mirrored before the upgrade still owes its old-shape results pairing.
-            const message = event.data.message;
-            const id = message?.toolCallId ?? message?.content?.[0]?.toolCallId;
-            if (id !== undefined) {
-                openCalls.delete(id);
-                settledCalls.add(id);
-            }
+            const taken = takenSteps.get(data.turn) ?? new Set();
+            taken.add(data.step);
+            takenSteps.set(data.turn, taken);
         }
     }
     /**
-     * The next sequential fold step in one turn: the running counter, shifted
-     * past every step an in-flight stream reserved (a stream's snapshots and
-     * its completion fold live at the reserved coordinate — a sequential fold
-     * landing there would write a second step/start, which the assembler
-     * rejects).
+     * The fold's coordinate: the smallest step of the turn that nothing holds
+     * — neither written nor currently reserved. Filling the smallest free step
+     * keeps the stored log dense even when a stream reservation below was
+     * released mid-round (its content rode an earlier fold's step).
      */
     const nextFoldStep = (turn) => {
-        let step = steps.get(turn) ?? 1;
-        const reserved = options?.streams?.reservedSteps(turn);
-        if (reserved !== undefined && reserved.length > 0) {
-            const skip = new Set(reserved);
-            while (skip.has(step))
-                step += 1;
-        }
-        steps.set(turn, step + 1);
+        const taken = new Set(takenSteps.get(turn));
+        for (const reserved of options?.streams?.reservedSteps(turn) ?? [])
+            taken.add(reserved);
+        let step = 1;
+        while (taken.has(step))
+            step += 1;
         return step;
     };
-    /** Whether this pass attached its window's usage to a folded message. */
-    let usageAttached = false;
-    const texts = [];
-    // Backfill results that landed after their call was mirrored in an earlier
-    // pass: the delta window never revisits those lines, so a result that
-    // arrives late (parallel calls settle out of order) pairs here. The result
-    // reuses its call's turn/step — no new step is consumed.
-    for (let index = 0; index < fromLines && index < transcript.lines.length; index += 1) {
-        const line = transcript.lines[index];
-        if (line === undefined || line.kind !== 'tool' || line.result === undefined)
-            continue;
-        const call = openCalls.get(line.id);
-        if (call === undefined)
-            continue;
-        openCalls.delete(line.id);
-        settledCalls.add(line.id);
-        // No second boundary pair here: the call's fold already opened AND closed
-        // this (turn, step), and the live assembler throws on a duplicate start
-        // match for the same context. The step stays registered in the location
-        // index, so the bare result still resolves to the step location — and the
-        // tool definition never consults it anyway.
-        childSession.append('tool/result', {
-            turn: call.turn,
-            step: call.step,
-            message: createToolResultMessage({
-                callId: line.id,
-                content: [{ type: 'text', text: line.result }],
-                isError: false,
-            }),
-        }, { surfaceOp: 'append', sourceEventSeqs: [call.seq] });
-        texts.push(kimiLineProgressText(line));
-    }
-    if (delta.length === 0) {
-        // No new lines this pass: only the late-result backfill above could have
-        // produced events. Persist those and skip the empty delta loop.
-        if (texts.length > 0) {
-            await persistChildSession(ctx, childSession);
+    /** Record a fold's coordinate chosen by a stream pairing. */
+    const markTaken = (turn, step) => {
+        const written = takenSteps.get(turn) ?? new Set();
+        written.add(step);
+        takenSteps.set(turn, written);
+    };
+    /** The window's accounting that no fold carried (dropped units' sums). */
+    let carryUsage;
+    // The pass's last content unit carries the records no tagged unit claimed.
+    let lastContentUnit = -1;
+    for (let index = foldedUnits.length - 1; index >= 0; index -= 1) {
+        if (foldedUnits[index][0]?.kind !== 'user') {
+            lastContentUnit = index;
+            break;
         }
-        return {
-            total: newTotal,
-            texts,
-            ...deltaUsage !== undefined ? { usage: deltaUsage } : {},
-            ...usageAttached ? { usageAttached: true } : {},
-            ...observedModel !== undefined ? { model: observedModel } : {},
-            ...toolCalls !== undefined ? { toolCalls } : {},
-        };
     }
-    for (let index = 0; index < delta.length; index += 1) {
-        const line = delta[index];
-        if (line === undefined)
-            continue;
+    const texts = [];
+    for (let unitIndex = 0; unitIndex < foldedUnits.length; unitIndex += 1) {
+        const unit = foldedUnits[unitIndex];
+        const head = unit[0];
+        // The unit's own records plus whatever a dropped unit handed forward.
+        let usage = addTokenUsage(carryUsage, unitUsage[unitIndex]);
+        carryUsage = undefined;
+        if (unitIndex === lastContentUnit)
+            usage = addTokenUsage(usage, unclaimedUsage);
         // The wire's turn number (1-based, matching the provider's turn/start
         // numbering) is the dsh round; no offset is needed because both count the
         // same rounds.
-        const turn = line.turn;
-        if (line.kind === 'user') {
+        const turn = head.turn;
+        if (head.kind === 'user') {
             // The live driver appends the round's user/message at turn start (so the
             // question renders before the streamed think/text instead of after it).
             // Skip the wire's copy of the same prompt — scoped to THIS turn so two
             // rounds with identical prompts still fold independently.
-            if (userAlreadyAppended(childSession, turn, line.text))
+            if (userAlreadyAppended(childSession, turn, head.text))
                 continue;
-            steps.set(turn, 1);
-            childSession.append('user/message', userEvent(line.text), { surfaceOp: 'append' });
-            texts.push(line.text);
+            childSession.append('user/message', userEvent(head.text), { surfaceOp: 'append' });
+            texts.push(head.text);
+            carryUsage = usage;
+            continue;
+        }
+        const toolLines = unit.filter((line) => line.kind === 'tool');
+        const reasoning = unit.filter(line => line.kind === 'think').map(line => line.text).join('');
+        const text = unit.filter(line => line.kind === 'assistant').map(line => line.text).join('');
+        const kinds = [
+            ...reasoning.trim() === '' ? [] : ['think'],
+            ...text.trim() === '' ? [] : ['text'],
+        ];
+        // Pair the fold with the round's in-flight streams, consuming the kinds
+        // present: the fold lands at the earliest consumed reservation, and a
+        // kind already gap-sealed keeps its durable triple — its content stays
+        // out of this message.
+        const pairing = kinds.length === 0 ? undefined : options?.streams?.completeStreams(turn, kinds);
+        const sealed = new Set(pairing?.sealed ?? []);
+        const blocks = [];
+        if (reasoning.trim() !== '' && !sealed.has('think'))
+            blocks.push({ type: 'reasoning', text: reasoning });
+        if (text.trim() !== '' && !sealed.has('text'))
+            blocks.push({ type: 'text', text });
+        for (const line of toolLines) {
+            blocks.push({ type: 'tool-call', id: line.id, name: line.name, arguments: line.args ?? '' });
         }
-        else if (line.kind === 'tool') {
-            // Native tool card: the call event now, the result event when the wire
-            // already carries it (else the backfill above pairs it in a later pass).
-            const reserved = options?.streams?.completeTool?.(line);
-            const step = reserved?.step ?? nextFoldStep(turn);
-            steps.set(turn, Math.max(steps.get(turn) ?? 1, step + 1));
-            if (reserved?.opened !== true)
-                childSession.append('step/start', { turn, step });
+        for (const line of unit)
+            texts.push(kimiLineProgressText(line));
+        if (blocks.length === 0) {
+            // Every content kind already durable via a gap fill and no tool
+            // lifecycle to fold: the unit drops; its usage rides the next fold.
+            carryUsage = usage;
+            continue;
+        }
+        // A tool reservation only pins chronological order — the fold's step
+        // carries the whole lifecycle, so the reserved coordinate frees.
+        for (const line of toolLines)
+            options?.streams?.releaseTool?.(line);
+        let step = pairing?.step ?? nextFoldStep(turn);
+        // Close every stream reservation below the fold step first: stored steps
+        // must land dense and strictly sequential.
+        options?.streams?.finalizeBefore?.(turn, step);
+        // Finalization may have WRITTEN a reservation below the provisional
+        // coordinate — or RELEASED an empty one without a write. Either way the
+        // fold must take the smallest step still free afterwards: writing above
+        // a released-but-never-written reservation strands a permanent gap the
+        // released-log reader rejects as corruption.
+        let sequential = nextKimiSessionStep(childSession, turn);
+        const reservedAfter = options?.streams?.reservedSteps(turn) ?? [];
+        while (reservedAfter.includes(sequential))
+            sequential += 1;
+        step = Math.min(step, sequential);
+        markTaken(turn, step);
+        // The durable coordinate is decided now, in write order (see nextWrittenKimiStep).
+        step = nextWrittenKimiStep(childSession, turn);
+        // The wire's own request config rides a request/header ahead of the fold
+        // (the host session's own shape) — Context Lens reads the child log's
+        // config from it instead of showing 未记录. Only a change is logged.
+        const requestConfig = unit.map(line => line.kind !== 'user' ? line.requestConfig : undefined).find(config => config !== undefined);
+        if (requestConfig?.model !== undefined) {
+            appendRequestHeaderIfChanged(childSession, {
+                provider: 'kimi-cli',
+                model: requestConfig.model,
+                ...requestConfig.reasoningEffort === undefined ? {} : { reasoningEffort: requestConfig.reasoningEffort },
+                ...requestConfig.maxTokens === undefined ? {} : { maxTokens: requestConfig.maxTokens },
+            });
+        }
+        const model = [...unit].reverse().find(line => line.model !== undefined)?.model;
+        childSession.append('step/start', { turn, step });
+        childSession.append('assistant/message', {
+            turn,
+            step,
+            message: assistantEvent(blocks, model),
+            stream: [],
+            ...usage === undefined ? {} : { usage },
+        }, { surfaceOp: 'append' });
+        // The native tool lifecycle inside the same step: the message advertises
+        // every call, then each call resolves before the step closes.
+        for (const line of toolLines) {
             const call = childSession.append('tool/call', {
                 turn,
                 step,
@@ -319,66 +412,28 @@ export async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSes
                 name: line.name,
                 arguments: line.args ?? '',
             });
-            texts.push(kimiLineProgressText(line));
-            if (line.result !== undefined) {
-                childSession.append('tool/result', {
-                    turn,
-                    step,
-                    message: createToolResultMessage({
-                        callId: line.id,
-                        content: [{ type: 'text', text: line.result }],
-                        isError: false,
-                    }),
-                }, { surfaceOp: 'append', sourceEventSeqs: [call.seq] });
-            }
-            childSession.append('step/end', { turn, step });
-        }
-        else {
-            // A completed think/assistant line pairs with its in-flight stream when
-            // one is live (the token granularity's per-kind stream): the fold lands
-            // at the stream's reserved step, finalizing the snapshots — the step
-            // opens only when no snapshot ever landed (a fast item that stayed
-            // under the throttle), and closes here. A (turn, step) never takes a
-            // second step/start.
-            const completion = options?.streams?.completeStream(line);
-            if (completion !== undefined) {
-                steps.set(turn, Math.max(steps.get(turn) ?? 1, completion.step + 1));
-                if (!completion.opened)
-                    childSession.append('step/start', { turn, step: completion.step });
-                if (index === lastAssistant && deltaUsage !== undefined)
-                    usageAttached = true;
-                childSession.append('assistant/message', {
-                    turn,
-                    step: completion.step,
-                    message: assistantEvent(lineBlocks(line), line.model),
-                    stream: [],
-                    ...index === lastAssistant && deltaUsage !== undefined ? { usage: deltaUsage } : {},
-                }, { surfaceOp: 'append' });
-                childSession.append('step/end', { turn, step: completion.step });
-                texts.push(kimiLineProgressText(line));
-                continue;
-            }
-            const step = nextFoldStep(turn);
-            childSession.append('step/start', { turn, step });
-            if (index === lastAssistant && deltaUsage !== undefined)
-                usageAttached = true;
-            childSession.append('assistant/message', {
+            childSession.append('tool/result', {
                 turn,
                 step,
-                message: assistantEvent(lineBlocks(line), line.model),
-                stream: [],
-                ...index === lastAssistant && deltaUsage !== undefined ? { usage: deltaUsage } : {},
-            }, { surfaceOp: 'append' });
-            childSession.append('step/end', { turn, step });
-            texts.push(kimiLineProgressText(line));
+                message: createToolResultMessage({
+                    callId: line.id,
+                    content: [{ type: 'text', text: line.result ?? KIMI_INTERRUPTED_TOOL_RESULT }],
+                    isError: line.result === undefined,
+                }),
+            }, { surfaceOp: 'append', sourceEventSeqs: [call.seq] });
         }
+        childSession.append('step/end', { turn, step });
     }
     await persistChildSession(ctx, childSession);
+    // The window's accounting that folded nowhere: dropped units' carry plus the
+    // unclaimed sum when no content unit folded at all.
+    const remainder = addTokenUsage(carryUsage, lastContentUnit === -1 ? unclaimedUsage : undefined);
     return {
-        total: newTotal,
+        total: consumedTotal,
         texts,
         ...deltaUsage !== undefined ? { usage: deltaUsage } : {},
-        ...usageAttached ? { usageAttached: true } : {},
+        ...deltaUsage !== undefined && remainder === undefined ? { usageAttached: true } : {},
+        ...remainder !== undefined ? { usageUnattached: remainder } : {},
         ...observedModel !== undefined ? { model: observedModel } : {},
         ...toolCalls !== undefined ? { toolCalls } : {},
     };
@@ -405,6 +460,27 @@ export function roundToolCalls(lines, turn) {
     }
     return count === 0 ? undefined : { count, byName };
 }
+/**
+ * Write the fold's request/header when the wire's declared config differs from
+ * the child log's last one (the host logs changed snapshots, not per-call
+ * duplicates): first write is `initial`, a differing one `change`, an
+ * identical one skipped.
+ */
+function appendRequestHeaderIfChanged(childSession, config) {
+    const serialized = JSON.stringify(config);
+    let last;
+    for (const event of childSession.snapshotEvents()) {
+        if (event.type === 'request/header') {
+            last = JSON.stringify(event.data.header?.config);
+        }
+    }
+    if (last === serialized)
+        return;
+    childSession.append('request/header', {
+        header: { config },
+        reason: last === undefined ? 'initial' : 'change',
+    });
+}
 /**
  * Whether the turn already carries a user/message with this exact text (the
  * live driver's round-start append). Scoped to the events at or after this