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

package/lib/index.js

@@ -2080,13 +2080,16 @@ async function readKimiTranscript(sessionDir) {
 	const sessionId = sessionDir.split("session_").pop() ?? sessionDir;
 	const lines = [];
 	const usageRecords = [];
+	const closedSteps = /* @__PURE__ */ new Set();
 	let model;
 	let modelTurn;
 	let lineModel;
+	let lineConfig;
 	const push = (line) => {
 		lines.push({
 			...line,
-			...lineModel === void 0 ? {} : { model: lineModel }
+			...lineModel === void 0 ? {} : { model: lineModel },
+			...line.kind !== "user" && lineConfig !== void 0 ? { requestConfig: { ...lineConfig } } : {}
 		});
 	};
 	let turn = 0;
@@ -2100,7 +2103,8 @@ async function readKimiTranscript(sessionDir) {
 		if (error.code === "ENOENT") return {
 			sessionId,
 			lines,
-			usageRecords
+			usageRecords,
+			closedSteps
 		};
 		throw error;
 	}
@@ -2117,6 +2121,10 @@ async function readKimiTranscript(sessionDir) {
 			if (typeof event.model === "string" && event.model !== "") {
 				model = lineModel = event.model;
 				modelTurn = turn || 1;
+				if (lineConfig !== void 0) lineConfig = {
+					...lineConfig,
+					model: event.model
+				};
 			}
 			const usage = usageFromWire(event.usage);
 			if (usage !== void 0) usageRecords.push({
@@ -2131,6 +2139,11 @@ async function readKimiTranscript(sessionDir) {
 				model = event.model;
 				modelTurn = turn || 1;
 			}
+			lineConfig = lineModel === void 0 ? void 0 : {
+				model: lineModel,
+				...typeof event.thinkingEffort === "string" && event.thinkingEffort !== "" ? { reasoningEffort: event.thinkingEffort } : {},
+				...typeof event.maxTokens === "number" && Number.isFinite(event.maxTokens) ? { maxTokens: event.maxTokens } : {}
+			};
 			continue;
 		}
 		if (event.type === "turn.prompt") {
@@ -2175,17 +2188,21 @@ async function readKimiTranscript(sessionDir) {
 				turn = Math.max(turn, loopTurn);
 				turnSeen = true;
 			}
+			const wireStep = typeof loop.step === "number" ? loop.step : void 0;
 			const part = loop.part;
 			const lineTurn = turn === 0 ? 1 : turn;
+			if (loop.type === "step.end" && wireStep !== void 0) closedSteps.add(`${lineTurn}:${wireStep}`);
 			if (part?.type === "text" && part.text !== void 0 && part.text.trim() !== "") push({
 				kind: "assistant",
 				text: part.text,
-				turn: lineTurn
+				turn: lineTurn,
+				...wireStep === void 0 ? {} : { wireStep }
 			});
 			else if (part?.type === "think" && part.think !== void 0 && part.think.trim() !== "") push({
 				kind: "think",
 				text: part.think,
-				turn: lineTurn
+				turn: lineTurn,
+				...wireStep === void 0 ? {} : { wireStep }
 			});
 			else if (loop.type === "tool.call") {
 				const call = loop;
@@ -2197,7 +2214,8 @@ async function readKimiTranscript(sessionDir) {
 					id: typeof call.toolCallId === "string" ? call.toolCallId : typeof call.uuid === "string" ? call.uuid : `kimi-tool-${lineIndex}`,
 					name,
 					...args === void 0 ? {} : { args },
-					turn: lineTurn
+					turn: lineTurn,
+					...wireStep === void 0 ? {} : { wireStep }
 				});
 				if (typeof call.uuid === "string") callsByUuid.set(call.uuid, lineIndex);
 				if (typeof call.toolCallId === "string") callsByToolCallId.set(call.toolCallId, lineIndex);
@@ -2230,6 +2248,7 @@ async function readKimiTranscript(sessionDir) {
 		sessionId,
 		lines,
 		usageRecords,
+		closedSteps,
 		...model === void 0 ? {} : { model },
 		...modelTurn === void 0 ? {} : { modelTurn }
 	};
@@ -2238,7 +2257,9 @@ async function readKimiTranscript(sessionDir) {
 * Map a wire `usage.record` payload onto the shared usage contract. kimi
 * reports input (uncached), cache read, cache creation, and output; the
 * creation counter is its cache-write analog. Non-numeric or missing
-* counters are dropped so the record stays usable when kimi omits a field.
+* counters are dropped so the record stays usable when kimi omits a field;
+* a reported cache-read counter is always written (zero included), so a
+* reader can tell "no hits" from "not reported".
 * @param raw - the event's `usage` value.
 * @returns the shared usage record, or undefined when nothing was reported.
 */
@@ -2258,7 +2279,7 @@ function usageFromWire(raw) {
 		inputTokens: input ?? 0,
 		outputTokens: output ?? 0
 	};
-	if (cacheRead !== void 0 && cacheRead > 0) usage.cacheReadTokens = cacheRead;
+	if (cacheRead !== void 0) usage.cacheReadTokens = cacheRead;
 	if (cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
 	return usage;
 }
@@ -2333,6 +2354,13 @@ function renderTranscript(transcript) {
 * call.
 * @module @khorsheed/dsh-local-agent-kimi/session-mirror
 */
+/**
+* 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.
+*/
+const KIMI_INTERRUPTED_TOOL_RESULT = "（工具调用被中断，未能记录返回结果）";
 /** One user-role message event. */
 function userEvent(text) {
 	return createUserMessage({
@@ -2354,41 +2382,42 @@ 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.
 */
 function nextKimiSessionStep(childSession, turn) {
-	let next = 1;
+	const taken = /* @__PURE__ */ 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);
+		if (data.turn === turn && typeof data.step === "number") 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
-	}];
-	return [{
-		type: "text",
-		text: line.text
-	}];
+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 last + 1;
 }
 /** The run-progress delta text for one transcript line (any kind). */
 function kimiLineProgressText(line) {
@@ -2396,10 +2425,14 @@ function kimiLineProgressText(line) {
 	return `${`[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}`}${line.result !== void 0 ? ` → ${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
@@ -2409,22 +2442,29 @@ 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.
@@ -2432,7 +2472,9 @@ 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.
 */
 async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, fromLines = 0, options) {
 	let workspaces;
@@ -2485,110 +2527,153 @@ async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId,
 		total: 0,
 		texts: []
 	};
-	const newTotal = transcript.lines.length;
 	const delta = transcript.lines.slice(fromLines);
 	const observedModel = options?.turn === void 0 || transcript.modelTurn === options.turn ? transcript.model : void 0;
 	const toolCalls = roundToolCalls(transcript.lines, options?.turn);
-	const deltaUsage = sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= fromLines && record.line <= newTotal));
-	let lastAssistant = -1;
-	for (let index = 0; index < delta.length; index += 1) {
-		const line = delta[index];
-		if (line !== void 0 && line.kind !== "user" && line.kind !== "tool") lastAssistant = index;
-	}
-	const steps = /* @__PURE__ */ new Map();
-	const openCalls = /* @__PURE__ */ new Map();
-	const settledCalls = /* @__PURE__ */ new Set();
+	const units = [];
+	for (const line of delta) {
+		if (line === void 0) continue;
+		const last = units.at(-1);
+		const head = last?.[0];
+		if (last !== void 0 && head !== void 0 && line.kind !== "user" && head.kind !== "user" && line.wireStep !== void 0 && line.wireStep === head.wireStep && line.turn === head.turn) {
+			last.push(line);
+			continue;
+		}
+		units.push([line]);
+	}
+	let holdAt = -1;
+	if (options?.settle !== true) for (let index = 0; index < units.length; index += 1) {
+		const unit = units[index];
+		const head = unit[0];
+		if (head.kind !== "user" && head.wireStep !== void 0 && !transcript.closedSteps.has(`${head.turn}:${head.wireStep}`) || unit.some((line) => line.kind === "tool" && line.result === void 0)) {
+			holdAt = index;
+			break;
+		}
+	}
+	const foldedUnits = holdAt < 0 ? units : units.slice(0, holdAt);
+	const consumedTotal = fromLines + foldedUnits.reduce((n, unit) => n + unit.length, 0);
+	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 !== void 0) {
+			claimed.push({
+				from: start,
+				to: unitStart
+			});
+			unitUsage.push(sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= start && record.line < unitStart)));
+		} else unitUsage.push(void 0);
+	}
+	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));
+	const takenSteps = /* @__PURE__ */ 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") {
-			const message = event.data.message;
-			const id = message?.toolCallId ?? message?.content?.[0]?.toolCallId;
-			if (id !== void 0) {
-				openCalls.delete(id);
-				settledCalls.add(id);
-			}
+		if (typeof data.turn === "number" && typeof data.step === "number") {
+			const taken = takenSteps.get(data.turn) ?? /* @__PURE__ */ 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 !== void 0 && 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;
+	/** Record a fold's coordinate chosen by a stream pairing. */
+	const markTaken = (turn, step) => {
+		const written = takenSteps.get(turn) ?? /* @__PURE__ */ new Set();
+		written.add(step);
+		takenSteps.set(turn, written);
+	};
+	/** The window's accounting that no fold carried (dropped units' sums). */
+	let carryUsage;
+	let lastContentUnit = -1;
+	for (let index = foldedUnits.length - 1; index >= 0; index -= 1) if (foldedUnits[index][0]?.kind !== "user") {
+		lastContentUnit = index;
+		break;
+	}
 	const texts = [];
-	for (let index = 0; index < fromLines && index < transcript.lines.length; index += 1) {
-		const line = transcript.lines[index];
-		if (line === void 0 || line.kind !== "tool" || line.result === void 0) continue;
-		const call = openCalls.get(line.id);
-		if (call === void 0) continue;
-		openCalls.delete(line.id);
-		settledCalls.add(line.id);
-		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]
+	for (let unitIndex = 0; unitIndex < foldedUnits.length; unitIndex += 1) {
+		const unit = foldedUnits[unitIndex];
+		const head = unit[0];
+		let usage = addTokenUsage(carryUsage, unitUsage[unitIndex]);
+		carryUsage = void 0;
+		if (unitIndex === lastContentUnit) usage = addTokenUsage(usage, unclaimedUsage);
+		const turn = head.turn;
+		if (head.kind === "user") {
+			if (userAlreadyAppended(childSession, turn, head.text)) continue;
+			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"]];
+		const pairing = kinds.length === 0 ? void 0 : 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
 		});
-		texts.push(kimiLineProgressText(line));
-	}
-	if (delta.length === 0) {
-		if (texts.length > 0) await persistChildSession(ctx, childSession);
-		return {
-			total: newTotal,
-			texts,
-			...deltaUsage !== void 0 ? { usage: deltaUsage } : {},
-			...usageAttached ? { usageAttached: true } : {},
-			...observedModel !== void 0 ? { model: observedModel } : {},
-			...toolCalls !== void 0 ? { toolCalls } : {}
-		};
-	}
-	for (let index = 0; index < delta.length; index += 1) {
-		const line = delta[index];
-		if (line === void 0) continue;
-		const turn = line.turn;
-		if (line.kind === "user") {
-			if (userAlreadyAppended(childSession, turn, line.text)) continue;
-			steps.set(turn, 1);
-			childSession.append("user/message", userEvent(line.text), { surfaceOp: "append" });
-			texts.push(line.text);
-		} else if (line.kind === "tool") {
-			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
-			});
+		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 ?? ""
+		});
+		for (const line of unit) texts.push(kimiLineProgressText(line));
+		if (blocks.length === 0) {
+			carryUsage = usage;
+			continue;
+		}
+		for (const line of toolLines) options?.streams?.releaseTool?.(line);
+		let step = pairing?.step ?? nextFoldStep(turn);
+		options?.streams?.finalizeBefore?.(turn, step);
+		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);
+		step = nextWrittenKimiStep(childSession, turn);
+		const requestConfig = unit.map((line) => line.kind !== "user" ? line.requestConfig : void 0).find((config) => config !== void 0);
+		if (requestConfig?.model !== void 0) appendRequestHeaderIfChanged(childSession, {
+			provider: "kimi-cli",
+			model: requestConfig.model,
+			...requestConfig.reasoningEffort === void 0 ? {} : { reasoningEffort: requestConfig.reasoningEffort },
+			...requestConfig.maxTokens === void 0 ? {} : { maxTokens: requestConfig.maxTokens }
+		});
+		const model = [...unit].reverse().find((line) => line.model !== void 0)?.model;
+		childSession.append("step/start", {
+			turn,
+			step
+		});
+		childSession.append("assistant/message", {
+			turn,
+			step,
+			message: assistantEvent(blocks, model),
+			stream: [],
+			...usage === void 0 ? {} : { usage }
+		}, { surfaceOp: "append" });
+		for (const line of toolLines) {
 			const call = childSession.append("tool/call", {
 				turn,
 				step,
@@ -2596,75 +2681,35 @@ async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId,
 				name: line.name,
 				arguments: line.args ?? ""
 			});
-			texts.push(kimiLineProgressText(line));
-			if (line.result !== void 0) childSession.append("tool/result", {
+			childSession.append("tool/result", {
 				turn,
 				step,
 				message: createToolResultMessage({
 					callId: line.id,
 					content: [{
 						type: "text",
-						text: line.result
+						text: line.result ?? "（工具调用被中断，未能记录返回结果）"
 					}],
-					isError: false
+					isError: line.result === void 0
 				})
 			}, {
 				surfaceOp: "append",
 				sourceEventSeqs: [call.seq]
 			});
-			childSession.append("step/end", {
-				turn,
-				step
-			});
-		} else {
-			const completion = options?.streams?.completeStream(line);
-			if (completion !== void 0) {
-				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 !== void 0) usageAttached = true;
-				childSession.append("assistant/message", {
-					turn,
-					step: completion.step,
-					message: assistantEvent(lineBlocks(line), line.model),
-					stream: [],
-					...index === lastAssistant && deltaUsage !== void 0 ? { 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 !== void 0) usageAttached = true;
-			childSession.append("assistant/message", {
-				turn,
-				step,
-				message: assistantEvent(lineBlocks(line), line.model),
-				stream: [],
-				...index === lastAssistant && deltaUsage !== void 0 ? { usage: deltaUsage } : {}
-			}, { surfaceOp: "append" });
-			childSession.append("step/end", {
-				turn,
-				step
-			});
-			texts.push(kimiLineProgressText(line));
 		}
+		childSession.append("step/end", {
+			turn,
+			step
+		});
 	}
 	await persistChildSession(ctx, childSession);
+	const remainder = addTokenUsage(carryUsage, lastContentUnit === -1 ? unclaimedUsage : void 0);
 	return {
-		total: newTotal,
+		total: consumedTotal,
 		texts,
 		...deltaUsage !== void 0 ? { usage: deltaUsage } : {},
-		...usageAttached ? { usageAttached: true } : {},
+		...deltaUsage !== void 0 && remainder === void 0 ? { usageAttached: true } : {},
+		...remainder !== void 0 ? { usageUnattached: remainder } : {},
 		...observedModel !== void 0 ? { model: observedModel } : {},
 		...toolCalls !== void 0 ? { toolCalls } : {}
 	};
@@ -2693,6 +2738,22 @@ function roundToolCalls(lines, turn) {
 	};
 }
 /**
+* 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 === void 0 ? "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
 * turn's turn/start so identical prompts across rounds stay independent.
@@ -2727,11 +2788,14 @@ function userAlreadyAppended(childSession, turn, text) {
 * 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
@@ -3416,25 +3480,17 @@ var KimiAcpLiveDriver = class {
 		/** 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 = /* @__PURE__ */ new Map();
 		/** The stream the latest delta accumulated into (a kind switch force-snapshots it). */
 		let activeStream;
@@ -3462,7 +3518,23 @@ var KimiAcpLiveDriver = class {
 		};
 		/** 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 = /* @__PURE__ */ new Map();
 		const seenToolCalls = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
 		const streamKey = (kind) => `kimi-stream-${kind}-${turn}-${generation}`;
 		/** The plan stream's key: a snapshot stream beside the think/text delta streams. */
@@ -3480,7 +3552,7 @@ var KimiAcpLiveDriver = class {
 			const stream = streams.get(key);
 			if (stream !== void 0) {
 				stream.text += text;
-				appendStreamSnapshot(stream, false, false);
+				publishStreamSnapshot(stream, false);
 			}
 			localAgent?.reportRunProgress(childSession.id, {
 				kind: "delta",
@@ -3506,135 +3578,283 @@ var KimiAcpLiveDriver = class {
 			const stream = streams.get(planKey);
 			if (stream !== void 0 && 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 === void 0 ? void 0 : 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 = /* @__PURE__ */ new Map();
-		const appendStreamSnapshot = (stream, force, interrupted, withUsage = false, final = false) => {
-			if (stream.text.trim() === "") return;
+		/**
+		* 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 !== void 0 && !final) {
-				if (!stream.opened) {
-					childSession.append("step/start", {
-						turn,
-						step: stream.step
-					});
-					stream.opened = true;
+			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) {
+				streamPublisher?.finish(step);
+				const keys = new Set(entries.map(([key]) => key));
+				if (!new Set([...streams.entries()].filter(([key, stream]) => !keys.has(key) && stream.sealed !== true).map(([, stream]) => stream.step)).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 = void 0;
 				}
-				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;
-			}
+			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 !== void 0 ? { usage: roundUsage } : {},
 				...interrupted ? { interrupted: true } : {}
 			}, { surfaceOp: "append" });
 			if (withUsage) roundUsage = void 0;
-			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 = void 0;
+			}
 			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";
+			const step = nextWrittenKimiStep(childSession, turn);
+			childSession.append("step/start", {
+				turn,
+				step
+			});
+			childSession.append("assistant/message", {
+				turn,
+				step,
+				message: assistantEvent([{
+					type: "tool-call",
+					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 = /* @__PURE__ */ 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 !== void 0 && activeStream !== key) {
 				const previous = streams.get(activeStream);
-				if (previous !== void 0 && previous.text.length !== previous.lastSnapshotLen) appendStreamSnapshot(previous, true, false);
+				if (previous !== void 0 && previous.text.length !== previous.lastSnapshotLen) publishStreamSnapshot(previous, true);
 				activeStream = void 0;
 			}
 			let stream = streams.get(key);
+			if (stream?.sealed === true) {
+				streams.delete(key);
+				stream = void 0;
+			}
 			if (stream === void 0) {
-				let step = nextKimiSessionStep(childSession, turn);
-				for (const reserved of reservedSteps) step = Math.max(step, reserved + 1);
-				reservedSteps.push(step);
+				let step = key === planKey ? void 0 : generationSteps.get(generation);
+				if (step === void 0) {
+					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: "",
-					lastSnapshotAt: 0,
-					lastSnapshotLen: 0,
-					opened: false
+					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) => {
-				if (line.turn !== turn) return void 0;
-				const step = toolSteps.get(line.id);
-				if (step === void 0) return void 0;
+			finalizeBefore,
+			releaseTool: (line) => {
+				if (line.turn !== turn) return;
+				const entry = toolSteps.get(line.id);
+				if (entry === void 0) return;
 				toolSteps.delete(line.id);
-				return {
-					step,
-					opened: true
-				};
+				const index = reservedSteps.indexOf(entry.step);
+				if (index >= 0) reservedSteps.splice(index, 1);
 			},
-			completeStream: (line) => {
-				if (line.turn !== turn) return void 0;
-				const kind = line.kind === "think" ? "think" : "text";
-				const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
-				if (entry === void 0) return void 0;
-				const [key, stream] = entry;
-				liveFlush.cancel(stream.step);
-				streamPublisher?.finish(stream.step);
-				streams.delete(key);
-				if (activeStream === key) activeStream = void 0;
+			completeStreams: (t, kinds) => {
+				if (t !== turn) return void 0;
+				const picked = [];
+				for (const kind of kinds) {
+					const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
+					if (entry !== void 0) picked.push(entry);
+				}
+				if (picked.length === 0) return void 0;
+				const sealed = [];
+				for (const [key, stream] of picked) {
+					streams.delete(key);
+					generationSteps.delete(stream.generation);
+					if (activeStream === key) activeStream = void 0;
+					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 };
+				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);
+				const written = /* @__PURE__ */ 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));
 				return {
-					step: stream.step,
-					opened: stream.opened
+					step: Math.min(free, ...candidates),
+					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
@@ -3643,7 +3863,7 @@ var KimiAcpLiveDriver = class {
 		* the latest.
 		*/
 		const noteMirrorUsage = (delta) => {
-			if (delta.usage !== void 0 && delta.usageAttached !== true) roundUsage = addTokenUsage(roundUsage, delta.usage);
+			if (delta.usageUnattached !== void 0) roundUsage = addTokenUsage(roundUsage, delta.usageUnattached);
 			if (delta.model !== void 0) roundModel = delta.model;
 		};
 		/** Throttled push-triggered mirror pass; the file fold stays the only transcript source. */
@@ -3695,23 +3915,22 @@ var KimiAcpLiveDriver = class {
 					const stream = streams.get(key);
 					if (stream !== void 0) {
 						stream.text += text;
-						appendStreamSnapshot(stream, false, false);
+						publishStreamSnapshot(stream, false);
 					}
 				}
 			} else if (kind === "tool_call") {
 				const id = typeof update["toolCallId"] === "string" ? update["toolCallId"] : void 0;
 				if (id === void 0 || !seenToolCalls.has(id)) {
-					if (id !== void 0) {
+					if (id !== void 0 && toolLogged(id)) seenToolCalls.add(id);
+					else if (id !== void 0) {
 						seenToolCalls.add(id);
 						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
+						toolSteps.set(id, {
+							step,
+							...typeof update["title"] === "string" ? { title: update["title"] } : {}
 						});
-						persist();
 					}
 					generation++;
 				}
@@ -3781,7 +4000,7 @@ var KimiAcpLiveDriver = class {
 			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",
@@ -3816,25 +4035,28 @@ var KimiAcpLiveDriver = class {
 				} catch (error) {
 					this.ctx.logger.warn(`subagent-kimi: live settle mirror failed: ${thrown$1(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 = void 0;
-					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;
+				}, /* @__PURE__ */ 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 = void 0;
+				if (pending.length > 0) persist();
 				if (settled.stopReason === "completed") childSession.append("turn/end", {
 					turn,
 					reason: { kind: "completed" }
@@ -4433,7 +4655,10 @@ async function mirrorKimiAfterExit(spec, stderr) {
 	try {
 		const kimiSessionId = spec.resume?.cliSessionId ?? kimiSessionIdFromOutput(stderr);
 		if (spec.resume === void 0) spec.onCliSessionId?.(kimiSessionId);
-		const delta = await mirrorKimiDelta(spec.ctx, spec.childSession, spec.homeDir, kimiSessionId, { turn: spec.resume?.turn ?? 1 });
+		const delta = await mirrorKimiDelta(spec.ctx, spec.childSession, spec.homeDir, kimiSessionId, {
+			turn: spec.resume?.turn ?? 1,
+			settle: true
+		});
 		spec.ctx.get("localAgent")?.reportRunProgress(spec.childSession.id, {
 			kind: "mirror",
 			mirroredLines: delta.total
@@ -4599,29 +4824,6 @@ async function startKimiCliRun(request, spec) {
 		onAbort
 	}).then((settled) => {
 		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
-		if (spec.childSession !== void 0) {
-			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
-				turn,
-				reason: { kind: "completed" }
-			});
-			else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
-				turn,
-				reason: {
-					kind: "aborted",
-					reason: { kind: "parent" }
-				}
-			});
-			else spec.childSession.append("turn/end", {
-				turn,
-				reason: {
-					kind: "error",
-					error: {
-						message: "kimi -p exited before the run completed",
-						code: "UNKNOWN"
-					}
-				}
-			});
-		}
 		return settled;
 	});
 	result.then(() => child.done).then(() => {
@@ -4630,14 +4832,41 @@ async function startKimiCliRun(request, spec) {
 			if (KIMI_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
 		}
 		enqueueMirror(async () => {
-			const settled = await mirrorKimiAfterExit(spec, stderr);
-			addRoundUsage(settled?.usage);
+			const settled = await result;
+			const mirrored = await mirrorKimiAfterExit(spec, stderr);
+			addRoundUsage(mirrored?.usage);
+			if (spec.childSession !== void 0) {
+				if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
+					turn,
+					reason: { kind: "completed" }
+				});
+				else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "aborted",
+						reason: { kind: "parent" }
+					}
+				});
+				else spec.childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "error",
+						error: {
+							message: "kimi -p exited before the run completed",
+							code: "UNKNOWN"
+						}
+					}
+				});
+				if (spec.ctx !== void 0) await persistChildSession(spec.ctx, spec.childSession).catch((error) => {
+					spec.ctx?.logger.warn(`subagent-kimi: turn/end persistence failed: ${thrown(error).message}`);
+				});
+			}
 			const cliVersion = await spec.cliVersion?.();
 			spec.onRoundSettled?.({
-				...settled?.model === void 0 ? {} : { observedModel: settled.model },
+				...mirrored?.model === void 0 ? {} : { observedModel: mirrored.model },
 				...cliVersion === void 0 ? {} : { cliVersion },
 				...roundUsage === void 0 ? {} : { usage: roundUsage },
-				...settled?.toolCalls === void 0 ? {} : { toolCalls: settled.toolCalls }
+				...mirrored?.toolCalls === void 0 ? {} : { toolCalls: mirrored.toolCalls }
 			});
 		});
 	}, () => {});
@@ -4790,6 +5019,47 @@ function dedupe(candidates) {
 	return out;
 }
 /**
+* Scope the served directory to the surface asking for it (the same helper
+* lives in each provider's broker — fold into the family core when the
+* directory faces next evolve):
+*
+* - memberless (the card's add-model dialog, the invite picker): the
+*   endpoint's served catalog only — the configuration/history extras the
+*   broker's info extension adds for STATUS display (a config-defined model
+*   the endpoint does not serve) must never become add candidates;
+* - a member whose harness has a curated list: the list IS the vocabulary,
+*   in the list's own order (the same rule `choices` already follows) — a
+*   curated value the endpoint no longer serves stays as a bare row (the
+*   card shows it the same way), and the member's current effective model is
+*   kept visible as a bare entry when it sits outside the list, so a pre-list
+*   binding never renders blank;
+* - a member without a curated list: the legacy extended vocabulary.
+*/
+function scopeServedDirectory(directory, opts) {
+	if (opts.member && opts.curated.length === 0) return directory;
+	const served = directory.entries.filter((entry) => entry.source === "native");
+	if (!opts.member) return {
+		...directory,
+		entries: served
+	};
+	const byValue = new Map(served.flatMap((entry) => entry.resolvedModel === void 0 ? [[entry.value, entry]] : [[entry.value, entry], [entry.resolvedModel, entry]]));
+	const entries = opts.curated.map((value) => byValue.get(value) ?? {
+		value,
+		label: value,
+		source: "configuration"
+	});
+	const current = opts.current?.trim();
+	if (current !== void 0 && current !== "" && !entries.some((entry) => entry.value === current || entry.resolvedModel === current)) entries.push({
+		value: current,
+		label: current,
+		source: "configuration"
+	});
+	return {
+		...directory,
+		entries
+	};
+}
+/**
 * The kimi harness's {@link LocalAgentModelBroker}. Also the provider-facing
 * member-model ledger: the provider records each delegation's start model
 * here and reads the session-level override for its exec-path resolution, so
@@ -4854,14 +5124,19 @@ var KimiModelBroker = class {
 	}
 	async modelDirectory(childSessionId, refresh = false) {
 		if (refresh) await this.deps.catalog?.refresh(childSessionId);
-		return (await this.modelInfo(childSessionId)).directory ?? {
+		const info = await this.modelInfo(childSessionId);
+		return scopeServedDirectory(info.directory ?? {
 			entries: [],
 			complete: false,
 			customInput: true,
 			status: "unsupported",
 			refreshing: false,
 			revision: 0
-		};
+		}, {
+			member: childSessionId !== void 0,
+			curated: this.deps.modelList?.(this.deps.homeDir(childSessionId)) ?? [],
+			current: info.effective
+		});
 	}
 	async *followModelDirectory(childSessionId, signal) {
 		if (this.deps.catalog === void 0) {