kfc-code-cli 0.0.1-alpha.14 → 0.0.1-alpha.16

package/dist/main.mjs

@@ -2312,6 +2312,9 @@ function createChatStreamingCallbacks(deps) {
 			});
 		},
 		onPrefetchedResult: (toolCallId, result) => {
+			prefetchedResults.set(toolCallId, Promise.resolve(result));
+		},
+		onPrefetchedResultPromise: (toolCallId, result) => {
 			prefetchedResults.set(toolCallId, result);
 		},
 		onAtomicPart: async (atomic) => {
@@ -2355,25 +2358,29 @@ function createChatStreamingCallbacks(deps) {
 * Pass 1 runs inside the step envelope and classifies every LLM-emitted
 * tool call. Fallback branches write a durable tool_call + synthetic
 * tool_result before step_end. Pass 2 runs after step_end and executes
-* allowed tools. SoulEvents for tool.result are deferred and flushed in
-* provider order so UI consumers always see a balanced tool.call →
-* tool.result stream even though WAL writes are split across the step
-* boundary.
+* allowed tools. Consecutive `isConcurrencySafe` tools execute as a
+* parallel batch; live tool.result events fire as soon as each sanitized
+* result is available, while durable context writes remain in provider
+* tool-call order for the next LLM request.
 */
 const GRACE_TIMEOUT_MS = 2e3;
-function flushDeferredToolResults(response, deferred, emit) {
-	for (const toolCall of response.toolCalls) {
-		const result = deferred.get(toolCall.id);
-		if (result !== void 0) {
-			emitToolResultEvent(emit, toolCall.id, result.output, result.isError);
-			deferred.delete(toolCall.id);
-		}
-	}
+function streamingPreparationKeepsPrefixOpen(preparation) {
+	if (preparation.kind === "handled") return true;
+	return preparation.kind === "pending" && preparation.pending.preparedResult !== void 0;
 }
-async function classifyToolCalls(step, response, deferred) {
+async function classifyToolCalls(step, response) {
 	const { config, context, emit, signal, turnId, currentStep, stepUuid, toolCallByProviderId } = step;
 	const pending = [];
 	for (const toolCall of response.toolCalls) {
+		const streamed = step.streamingPreparations.get(toolCall.id);
+		if (streamed !== void 0) {
+			const prepared = await streamed;
+			if (prepared.kind === "pending") {
+				pending.push(prepared.pending);
+				continue;
+			}
+			if (prepared.kind === "handled") continue;
+		}
 		emit({
 			type: "tool.call",
 			toolCallId: toolCall.id,
@@ -2384,29 +2391,20 @@ async function classifyToolCalls(step, response, deferred) {
 		if (tool === void 0) {
 			const output = `Tool "${toolCall.name}" not found`;
 			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
+			emitToolResultEvent(emit, toolCall.id, output, true);
 			continue;
 		}
 		if (toolCall.error !== void 0) {
 			const output = `Invalid input for tool "${toolCall.name}": ${toolCall.error}`;
 			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
+			emitToolResultEvent(emit, toolCall.id, output, true);
 			continue;
 		}
 		const parsed = tool.inputSchema.safeParse(toolCall.args);
 		if (!parsed.success) {
 			const output = `Invalid input for tool "${toolCall.name}": ${parsed.error.message}`;
 			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
+			emitToolResultEvent(emit, toolCall.id, output, true);
 			continue;
 		}
 		let hookResult;
@@ -2414,7 +2412,6 @@ async function classifyToolCalls(step, response, deferred) {
 			hookResult = await config.beforeToolCall({
 				toolCall,
 				args: parsed.data,
-				assistantMessage: response.message,
 				context,
 				turnId,
 				stepNumber: currentStep,
@@ -2424,19 +2421,13 @@ async function classifyToolCalls(step, response, deferred) {
 		} catch (error) {
 			const output = `beforeToolCall hook failed for "${toolCall.name}": ${errorMessage$1(error)}`;
 			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
+			emitToolResultEvent(emit, toolCall.id, output, true);
 			continue;
 		}
 		if (hookResult?.block === true) {
 			const output = hookResult.reason ?? `Tool call "${toolCall.name}" was blocked`;
 			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
+			emitToolResultEvent(emit, toolCall.id, output, true);
 			continue;
 		}
 		pending.push({
@@ -2448,112 +2439,241 @@ async function classifyToolCalls(step, response, deferred) {
 	}
 	return pending;
 }
-async function executePendingCalls(step, pending, deferred) {
+async function prepareStreamingToolCall(step, toolCall) {
 	const { config, context, emit, signal, turnId, currentStep, stepUuid, toolCallByProviderId } = step;
+	const tool = findTool(config.tools, toolCall.name);
+	if (tool === void 0 || toolCall.error !== void 0) return { kind: "declined" };
+	const parsed = tool.inputSchema.safeParse(toolCall.args);
+	if (!parsed.success || !isStreamingPrefetchSafe(tool, parsed.data)) return { kind: "declined" };
+	emit({
+		type: "tool.call",
+		toolCallId: toolCall.id,
+		name: toolCall.name,
+		args: toToolCallArgs(toolCall.args)
+	});
+	let hookResult;
+	if (config.beforeToolCall !== void 0) try {
+		hookResult = await config.beforeToolCall({
+			toolCall,
+			args: parsed.data,
+			context,
+			turnId,
+			stepNumber: currentStep,
+			stepUuid,
+			toolCallByProviderId
+		}, signal);
+	} catch (error) {
+		const output = `beforeToolCall hook failed for "${toolCall.name}": ${errorMessage$1(error)}`;
+		await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
+		emitToolResultEvent(emit, toolCall.id, output, true);
+		return { kind: "handled" };
+	}
+	if (hookResult?.block === true) {
+		const output = hookResult.reason ?? `Tool call "${toolCall.name}" was blocked`;
+		await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
+		emitToolResultEvent(emit, toolCall.id, output, true);
+		return { kind: "handled" };
+	}
+	const base = {
+		toolCall,
+		tool,
+		parsedArgs: parsed.data,
+		hookResult
+	};
+	if (!isStreamingPrefetchSafe(tool, getEffectiveInput(base))) return {
+		kind: "pending",
+		pending: base
+	};
+	const preparedResult = preparePendingToolResultCore(step, base).then((prepared) => {
+		emitToolResultEvent(emit, prepared.toolCallId, prepared.output, prepared.isError);
+		return prepared;
+	});
+	return {
+		kind: "pending",
+		pending: {
+			...base,
+			preparedResult,
+			resultEventEmitted: true
+		}
+	};
+}
+async function executePendingCalls(step, pending) {
+	const { emit, signal } = step;
 	const postContentCallbacks = [];
-	for (const [index, item] of pending.entries()) {
+	for (let index = 0; index < pending.length;) {
 		if (index > 0) signal.throwIfAborted();
-		const { toolCall, tool, parsedArgs, hookResult } = item;
-		let effectiveInput = parsedArgs;
-		if (hookResult?.block === true) {
-			const output = hookResult.reason ?? `Tool call "${toolCall.name}" was blocked`;
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
-			await writeFallbackToolCallAndResult(context, stepUuid, turnId, currentStep, toolCall, output);
-			continue;
-		}
-		if (hookResult?.updatedInput !== void 0) effectiveInput = hookResult.updatedInput;
-		let toolResult;
-		try {
-			const prefetched = step.prefetchedResults.get(toolCall.id);
-			if (prefetched !== void 0) toolResult = prefetched;
-			else toolResult = await raceExecuteWithGraceTimeout(tool.execute({
-				turnId,
-				toolCallId: toolCall.id,
-				args: effectiveInput,
-				signal,
-				onUpdate: (update) => {
-					emit({
-						type: "tool.progress",
-						toolCallId: toolCall.id,
-						update
-					});
-				},
-				wireUuid: toolCallByProviderId.get(toolCall.id)
-			}), signal, toolCall.name);
-		} catch (error) {
-			const output = isAbortError$3(error) || signal.aborted ? `Tool "${toolCall.name}" was aborted` : `Tool "${toolCall.name}" failed: ${errorMessage$1(error)}`;
-			const syntheticResult = {
-				content: output,
-				isError: true
-			};
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
-			await context.appendToolResult(toolCallByProviderId.get(toolCall.id), toolCall.id, {
-				output,
-				isError: true
-			});
-			if (config.afterToolCall !== void 0) try {
-				await config.afterToolCall({
-					toolCall,
-					args: effectiveInput,
-					result: syntheticResult,
-					context
-				}, signal);
-			} catch {}
+		const item = pending[index];
+		if (item === void 0) break;
+		if (isConcurrencySafe(item) && !signal.aborted) {
+			const batch = [];
+			while (index < pending.length) {
+				const next = pending[index];
+				if (next === void 0 || !isConcurrencySafe(next)) break;
+				batch.push(next);
+				index += 1;
+			}
+			let batchStopped = false;
+			const shouldEmit = () => !batchStopped;
+			const tasks = batch.map((batchItem) => prepareAndEmitToolResult(step, batchItem, shouldEmit));
+			for (const task of tasks) {
+				const outcome = await task;
+				if (!outcome.ok) {
+					batchStopped = true;
+					throw outcome.error instanceof Error ? outcome.error : new Error(errorMessage$1(outcome.error));
+				}
+				const prepared = outcome.prepared;
+				await appendPreparedToolResult(step, prepared, postContentCallbacks);
+				if (prepared.throwAfterCommit !== void 0) {
+					batchStopped = true;
+					throw prepared.throwAfterCommit;
+				}
+				if (signal.aborted) {
+					batchStopped = true;
+					signal.throwIfAborted();
+				}
+			}
 			continue;
 		}
-		let finalResult = toolResult;
-		let afterError;
+		const prepared = await preparePendingToolResult(step, item);
+		if (item.resultEventEmitted !== true) emitToolResultEvent(emit, prepared.toolCallId, prepared.output, prepared.isError);
+		await appendPreparedToolResult(step, prepared, postContentCallbacks);
+		if (prepared.throwAfterCommit !== void 0) throw prepared.throwAfterCommit;
+		index += 1;
+	}
+	for (const callback of postContentCallbacks) await callback();
+}
+async function preparePendingToolResult(step, item) {
+	if (item.preparedResult !== void 0) return item.preparedResult;
+	return preparePendingToolResultCore(step, item);
+}
+async function preparePendingToolResultCore(step, item) {
+	const { config, context, signal } = step;
+	const { toolCall, hookResult } = item;
+	const effectiveInput = getEffectiveInput(item);
+	if (hookResult?.block === true) return makeSyntheticPrepared(step, toolCall, hookResult.reason ?? `Tool call "${toolCall.name}" was blocked`);
+	let toolResult;
+	try {
+		toolResult = await executeOrAwaitPrefetch(step, item, effectiveInput);
+	} catch (error) {
+		const output = isAbortError$3(error) || signal.aborted ? `Tool "${toolCall.name}" was aborted` : `Tool "${toolCall.name}" failed: ${errorMessage$1(error)}`;
+		const syntheticResult = {
+			content: output,
+			isError: true
+		};
 		if (config.afterToolCall !== void 0) try {
-			const afterResult = await config.afterToolCall({
+			await config.afterToolCall({
 				toolCall,
 				args: effectiveInput,
-				result: toolResult,
+				result: syntheticResult,
 				context
 			}, signal);
-			if (afterResult?.resultOverride !== void 0) finalResult = afterResult.resultOverride;
-		} catch (error) {
-			afterError = error;
-		}
-		if (afterError !== void 0) {
-			if (isAbortError$3(afterError) || signal.aborted) {
-				const output = `Tool "${toolCall.name}" aborted during afterToolCall hook.`;
-				deferred.set(toolCall.id, {
-					output,
-					isError: true
-				});
-				await context.appendToolResult(toolCallByProviderId.get(toolCall.id), toolCall.id, {
-					output,
-					isError: true
-				});
-				throw afterError instanceof Error ? afterError : new Error(errorMessage$1(afterError));
-			}
-			const output = `afterToolCall hook failed for "${toolCall.name}": ${errorMessage$1(afterError)}`;
-			deferred.set(toolCall.id, {
-				output,
-				isError: true
-			});
-			await context.appendToolResult(toolCallByProviderId.get(toolCall.id), toolCall.id, {
-				output,
-				isError: true
+		} catch {}
+		return makeSyntheticPrepared(step, toolCall, output);
+	}
+	let finalResult = toolResult;
+	let afterError;
+	if (config.afterToolCall !== void 0) try {
+		const afterResult = await config.afterToolCall({
+			toolCall,
+			args: effectiveInput,
+			result: toolResult,
+			context
+		}, signal);
+		if (afterResult?.resultOverride !== void 0) finalResult = afterResult.resultOverride;
+	} catch (error) {
+		afterError = error;
+	}
+	if (afterError !== void 0) {
+		if (isAbortError$3(afterError) || signal.aborted) return makeSyntheticPrepared(step, toolCall, `Tool "${toolCall.name}" aborted during afterToolCall hook.`, afterError instanceof Error ? afterError : new Error(errorMessage$1(afterError)));
+		return makeSyntheticPrepared(step, toolCall, `afterToolCall hook failed for "${toolCall.name}": ${errorMessage$1(afterError)}`);
+	}
+	const adapted = adaptToolResult(finalResult);
+	const output = typeof adapted.output === "string" ? adapted.output : JSON.stringify(adapted.output);
+	return {
+		toolCallId: toolCall.id,
+		adapted,
+		output,
+		isError: finalResult.isError === true,
+		postContent: !finalResult.isError ? finalResult.postContent : void 0,
+		throwAfterCommit: void 0
+	};
+}
+async function prepareAndEmitToolResult(step, item, shouldEmit) {
+	try {
+		const prepared = await preparePendingToolResult(step, item);
+		if (item.resultEventEmitted !== true && shouldEmit()) emitToolResultEvent(step.emit, prepared.toolCallId, prepared.output, prepared.isError);
+		return {
+			ok: true,
+			prepared
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+async function executeOrAwaitPrefetch(step, item, effectiveInput) {
+	const { emit, signal, turnId, toolCallByProviderId } = step;
+	const { toolCall, tool } = item;
+	const prefetched = step.prefetchedResults.get(toolCall.id);
+	if (prefetched !== void 0) try {
+		return await raceExecuteWithGraceTimeout(prefetched, signal, tool.name);
+	} catch (error) {
+		if (signal.aborted) throw error;
+	}
+	return raceExecuteWithGraceTimeout(tool.execute({
+		turnId,
+		toolCallId: toolCall.id,
+		args: effectiveInput,
+		signal,
+		onUpdate: (update) => {
+			emit({
+				type: "tool.progress",
+				toolCallId: toolCall.id,
+				update
 			});
-			continue;
-		}
-		const adapted = adaptToolResult(finalResult);
-		const adaptedText = typeof adapted.output === "string" ? adapted.output : JSON.stringify(adapted.output);
-		deferred.set(toolCall.id, {
-			output: adaptedText,
-			isError: finalResult.isError === true
-		});
-		await context.appendToolResult(toolCallByProviderId.get(toolCall.id), toolCall.id, adapted);
-		if (!finalResult.isError && finalResult.postContent) postContentCallbacks.push(finalResult.postContent);
+		},
+		wireUuid: toolCallByProviderId.get(toolCall.id)
+	}), signal, tool.name);
+}
+function makeSyntheticPrepared(step, toolCall, output, throwAfterCommit) {
+	return {
+		toolCallId: toolCall.id,
+		adapted: {
+			output,
+			isError: true
+		},
+		output,
+		isError: true,
+		postContent: void 0,
+		throwAfterCommit
+	};
+}
+async function appendPreparedToolResult(step, prepared, postContentCallbacks) {
+	const parentUuid = step.toolCallByProviderId.get(prepared.toolCallId);
+	await step.context.appendToolResult(parentUuid, prepared.toolCallId, prepared.adapted);
+	if (prepared.postContent !== void 0) postContentCallbacks.push(prepared.postContent);
+}
+function getEffectiveInput(item) {
+	return item.hookResult?.updatedInput ?? item.parsedArgs;
+}
+function isConcurrencySafe(item) {
+	if (item.hookResult?.block === true) return false;
+	if (item.tool.isConcurrencySafe === void 0) return false;
+	try {
+		return item.tool.isConcurrencySafe(getEffectiveInput(item));
+	} catch {
+		return false;
+	}
+}
+function isStreamingPrefetchSafe(tool, input) {
+	if (tool.isStreamingPrefetchSafe === void 0) return false;
+	try {
+		return tool.isStreamingPrefetchSafe(input);
+	} catch {
+		return false;
 	}
-	for (const callback of postContentCallbacks) await callback();
 }
 function findTool(tools, name) {
 	return tools?.find((tool) => tool.name === name);
@@ -2643,33 +2763,7 @@ async function executeSoulStep(deps) {
 	const stepUuid = randomUUID();
 	const toolCallByProviderId = /* @__PURE__ */ new Map();
 	const prefetchedResults = /* @__PURE__ */ new Map();
-	await context.appendStepBegin({
-		uuid: stepUuid,
-		turnId,
-		step: currentStep
-	});
-	const response = await runtime.kosong.chat({
-		messages,
-		tools: visibleTools,
-		model,
-		systemPrompt: context.systemPrompt,
-		effort: overrides?.effort,
-		signal,
-		...createChatStreamingCallbacks({
-			emit,
-			context,
-			turnId,
-			currentStep,
-			stepUuid,
-			prefetchedResults
-		}),
-		contextWindow: config.contextWindow
-	});
-	recordUsage(response.usage);
-	const deferredResults = /* @__PURE__ */ new Map();
-	const flushDeferredResults = () => {
-		flushDeferredToolResults(response, deferredResults, emit);
-	};
+	const streamingPreparations = /* @__PURE__ */ new Map();
 	const step = {
 		config,
 		context,
@@ -2679,22 +2773,51 @@ async function executeSoulStep(deps) {
 		currentStep,
 		stepUuid,
 		toolCallByProviderId,
-		prefetchedResults
+		prefetchedResults,
+		streamingPreparations
 	};
+	const streamingScheduler = createStreamingToolCallScheduler(step, streamingPreparations);
+	await context.appendStepBegin({
+		uuid: stepUuid,
+		turnId,
+		step: currentStep
+	});
+	let response;
 	try {
-		const pending = await classifyToolCalls(step, response, deferredResults);
-		await context.appendStepEnd({
-			uuid: stepUuid,
-			turnId,
-			step: currentStep,
-			usage: toStepEndUsage(response.usage),
-			finishReason: response.stopReason
+		response = await runtime.kosong.chat({
+			messages,
+			tools: visibleTools,
+			model,
+			systemPrompt: context.systemPrompt,
+			effort: overrides?.effort,
+			signal,
+			...createChatStreamingCallbacks({
+				emit,
+				context,
+				turnId,
+				currentStep,
+				stepUuid,
+				prefetchedResults
+			}),
+			onToolCallReady: (toolCall, info) => {
+				streamingScheduler.markReady(toolCall, info);
+			},
+			contextWindow: config.contextWindow
 		});
-		await executePendingCalls(step, pending, deferredResults);
-		signal.throwIfAborted();
 	} finally {
-		flushDeferredResults();
+		streamingScheduler.finish();
 	}
+	recordUsage(response.usage);
+	const pending = await classifyToolCalls(step, response);
+	await context.appendStepEnd({
+		uuid: stepUuid,
+		turnId,
+		step: currentStep,
+		usage: toStepEndUsage(response.usage),
+		finishReason: response.stopReason
+	});
+	await executePendingCalls(step, pending);
+	signal.throwIfAborted();
 	emit({
 		type: "step.end",
 		step: currentStep
@@ -2710,6 +2833,86 @@ async function executeSoulStep(deps) {
 	} catch {}
 	return { stopReason };
 }
+function createStreamingToolCallScheduler(step, streamingPreparations) {
+	let nextOrdinal = 0;
+	let nextSyntheticOrdinal = 0;
+	let prefixOpen = true;
+	let finished = false;
+	let pumping = false;
+	const queue = /* @__PURE__ */ new Map();
+	const declined = () => ({ kind: "declined" });
+	const drainDeclined = () => {
+		for (const slot of queue.values()) slot.resolve(declined());
+		queue.clear();
+	};
+	const assignOrdinal = (info) => {
+		const ordinal = info?.ordinal;
+		if (ordinal !== void 0 && Number.isSafeInteger(ordinal) && ordinal >= 0) {
+			nextSyntheticOrdinal = Math.max(nextSyntheticOrdinal, ordinal + 1);
+			return ordinal;
+		}
+		while (nextSyntheticOrdinal < nextOrdinal || queue.has(nextSyntheticOrdinal)) nextSyntheticOrdinal += 1;
+		const synthetic = nextSyntheticOrdinal;
+		nextSyntheticOrdinal += 1;
+		return synthetic;
+	};
+	const pump = async () => {
+		if (pumping) return;
+		pumping = true;
+		try {
+			while (true) {
+				if (finished || !prefixOpen) break;
+				const slot = queue.get(nextOrdinal);
+				if (slot === void 0) break;
+				queue.delete(nextOrdinal);
+				nextOrdinal += 1;
+				let preparation;
+				try {
+					preparation = await prepareStreamingToolCall(step, slot.toolCall);
+				} catch {
+					preparation = declined();
+				}
+				slot.resolve(preparation);
+				if (!streamingPreparationKeepsPrefixOpen(preparation)) {
+					prefixOpen = false;
+					drainDeclined();
+					break;
+				}
+			}
+		} finally {
+			pumping = false;
+			if (!finished && prefixOpen && queue.has(nextOrdinal)) pump();
+		}
+	};
+	return {
+		markReady(toolCall, info) {
+			if (streamingPreparations.has(toolCall.id)) return;
+			const preparation = new Promise((resolve) => {
+				if (finished || !prefixOpen) {
+					resolve(declined());
+					return;
+				}
+				const ordinal = assignOrdinal(info);
+				if (ordinal < nextOrdinal || queue.has(ordinal)) {
+					prefixOpen = false;
+					resolve(declined());
+					drainDeclined();
+					return;
+				}
+				queue.set(ordinal, {
+					toolCall,
+					resolve
+				});
+				pump();
+			});
+			streamingPreparations.set(toolCall.id, preparation);
+		},
+		finish() {
+			finished = true;
+			drainDeclined();
+		}
+	};
+}
 function toStepEndUsage(usage) {
 	return {
 		input_tokens: usage.input,
@@ -3885,10 +4088,10 @@ var ToolStreamingPrefetchScope = class {
 	}
 	executeStreaming(toolCall, signal) {
 		const tool = this.currentTools.get(toolCall.name);
-		if (tool === void 0 || tool.isConcurrencySafe === void 0) return void 0;
+		if (tool === void 0 || tool.isStreamingPrefetchSafe === void 0) return void 0;
 		let safe;
 		try {
-			safe = tool.isConcurrencySafe(toolCall.args);
+			safe = tool.isStreamingPrefetchSafe(toolCall.args);
 		} catch {
 			return;
 		}
@@ -4600,7 +4803,9 @@ var StreamingKosongWrapper = class {
 		const sub = new AbortController();
 		const inFlight = /* @__PURE__ */ new Map();
 		const completed = /* @__PURE__ */ new Map();
+		const upstreamOnToolCallReady = params.onToolCallReady;
 		const onPrefetchedResult = params.onPrefetchedResult;
+		const onPrefetchedResultPromise = params.onPrefetchedResultPromise;
 		const onCallerAbort = () => {
 			try {
 				this.streaming.discardStreaming("aborted");
@@ -4609,19 +4814,28 @@ var StreamingKosongWrapper = class {
 		};
 		if (params.signal.aborted) sub.abort();
 		else params.signal.addEventListener("abort", onCallerAbort);
-		const onToolCallReady = (toolCall) => {
+		const onToolCallReady = (toolCall, info) => {
+			if (upstreamOnToolCallReady !== void 0) {
+				upstreamOnToolCallReady(toolCall, info);
+				return;
+			}
 			if (inFlight.has(toolCall.id) || completed.has(toolCall.id)) return;
 			const pending = this.streaming.executeStreaming(toolCall, sub.signal);
 			if (pending === void 0) return;
 			inFlight.set(toolCall.id, pending);
+			try {
+				onPrefetchedResultPromise?.(toolCall.id, pending);
+			} catch {}
 			pending.then((result) => {
 				inFlight.delete(toolCall.id);
 				completed.set(toolCall.id, result);
 				try {
 					onPrefetchedResult?.(toolCall.id, result);
 				} catch {}
+				return null;
 			}).catch(() => {
 				inFlight.delete(toolCall.id);
+				return null;
 			});
 		};
 		const unbind = typeof this.streaming.bindStreaming === "function" ? this.streaming.bindStreaming({
@@ -4634,18 +4848,31 @@ var StreamingKosongWrapper = class {
 				if (!sub.signal.aborted) sub.abort();
 			}
 		}) : () => {};
+		let deferredCleanup = false;
+		const cleanup = (clearCompleted) => {
+			if (clearCompleted) completed.clear();
+			unbind();
+			params.signal.removeEventListener("abort", onCallerAbort);
+		};
 		try {
 			const wrappedParams = {
 				...params,
 				onToolCallReady
 			};
 			const response = await this.raw.chat(wrappedParams);
-			if (inFlight.size > 0) await Promise.allSettled(inFlight.values());
+			if (inFlight.size > 0 && onPrefetchedResultPromise === void 0) await Promise.allSettled(inFlight.values());
+			if (inFlight.size > 0 && onPrefetchedResultPromise !== void 0) {
+				deferredCleanup = true;
+				const pendingAtReturn = [...inFlight.values()];
+				Promise.allSettled(pendingAtReturn).finally(() => {
+					cleanup(true);
+				});
+				return response;
+			}
 			completed.clear();
 			return response;
 		} finally {
-			unbind();
-			params.signal.removeEventListener("abort", onCallerAbort);
+			if (!deferredCleanup) cleanup(false);
 		}
 	}
 };
@@ -4703,6 +4930,7 @@ var DefaultToolExecutionScopeFactory = class {
 			if (inner.maxResultSizeChars !== void 0) wrapped.maxResultSizeChars = inner.maxResultSizeChars;
 			if (inner.display !== void 0) wrapped.display = inner.display;
 			if (inner.isConcurrencySafe !== void 0) wrapped.isConcurrencySafe = inner.isConcurrencySafe.bind(inner);
+			if (inner.isStreamingPrefetchSafe !== void 0) wrapped.isStreamingPrefetchSafe = inner.isStreamingPrefetchSafe.bind(inner);
 			return wrapped;
 		};
 		return {
@@ -4817,6 +5045,7 @@ function copyToolMetadata(inner, wrapped) {
 	if (inner.maxResultSizeChars !== void 0) wrapped.maxResultSizeChars = inner.maxResultSizeChars;
 	if (inner.display !== void 0) wrapped.display = inner.display;
 	if (inner.isConcurrencySafe !== void 0) wrapped.isConcurrencySafe = inner.isConcurrencySafe.bind(inner);
+	if (inner.isStreamingPrefetchSafe !== void 0) wrapped.isStreamingPrefetchSafe = inner.isStreamingPrefetchSafe.bind(inner);
 }
 async function maybeExecutePlanFileTool(toolName, args, planMode) {
 	if (!isRecord$10(args) || typeof args["path"] !== "string") return void 0;
@@ -5722,7 +5951,7 @@ function createSoulPlusToolRegistry(options) {
 	};
 }
 function registerSubagentTool(options) {
-	if (options.hasSubagentInfra && options.isToolEnabled("Agent")) options.toolRegistry.push(new AgentTool(options.soulRegistry, "agent_main"));
+	if (options.hasSubagentInfra && options.isToolEnabled("Agent")) options.toolRegistry.push(new AgentTool(options.soulRegistry, "agent_main", void 0, options.agentTypeRegistry));
 }
 function registerSkillTool(options) {
 	if (options.skillManager === void 0) return;
@@ -7443,6 +7672,10 @@ function isToolCall(part) {
 function isToolCallPart(part) {
 	return part.type === "tool_call_part";
 }
+/** Check if a streamed part marks a tool call as complete. */
+function isToolCallDone(part) {
+	return part.type === "tool_call_done";
+}
 /**
 * Merge `source` into `target` in-place for streaming accumulation.
 *
@@ -7568,13 +7801,13 @@ var APIEmptyResponseError = class extends ChatProviderError {
 * (e.g. TextPart + TextPart, ToolCall + ToolCallPart) are merged in-place so
 * the returned message always contains fully-assembled parts.
 *
-* **onToolCall firing**: The {@link GenerateCallbacks.onToolCall} callback is
-* fired once per fully-assembled tool call **after** the stream completes, in
-* the order they appear in `message.toolCalls`. Tool calls are never dispatched
-* mid-stream because parallel tool call streams may interleave arguments
-* (e.g. `tc0-header → tc1-header → tc0-args → tc1-args`), so the arguments of
-* any individual tool call are only guaranteed to be complete once the entire
-* stream has drained.
+* **tool-call callback firing**: {@link GenerateCallbacks.onToolCallReady}
+* may fire before stream end when a provider emits an explicit
+* `tool_call_done`, or when a linear provider opts into Python-style
+* merge-boundary readiness. Indexed streams without those signals can still
+* receive later routed argument deltas, so they are only marked ready after the
+* stream drains. {@link GenerateCallbacks.onToolCall} remains deferred until
+* after the stream completes, in final message order.
 *
 * @param provider - The chat provider to generate from.
 * @param systemPrompt - System-level instruction prepended to the request.
@@ -7595,16 +7828,23 @@ async function generate$1(provider, systemPrompt, tools, history, callbacks, opt
 		toolCalls: []
 	};
 	let pendingPart = null;
+	const readyToolCallIds = /* @__PURE__ */ new Set();
+	const readyStreamIndexes = /* @__PURE__ */ new Set();
 	const toolCallIndexMap = /* @__PURE__ */ new Map();
 	if (options?.signal?.aborted) throwAbortError();
 	const stream = await provider.generate(systemPrompt, tools, history, options);
 	await throwIfAborted(options?.signal, stream);
 	for await (const part of stream) {
 		await throwIfAborted(options?.signal, stream);
+		if (isLateArgumentDelta(part, readyStreamIndexes)) throw new Error(`Received tool-call arguments for stream index ${String(part.index)} after it was marked ready`);
 		if (callbacks?.onMessagePart !== void 0) {
 			await callbacks.onMessagePart(deepCopyPart(part));
 			await throwIfAborted(options?.signal, stream);
 		}
+		if (isToolCallDone(part)) {
+			pendingPart = await handleToolCallDone(message, pendingPart, part, toolCallIndexMap, callbacks, readyToolCallIds, readyStreamIndexes, options?.signal, stream);
+			continue;
+		}
 		if (isToolCallPart(part) && part.index !== void 0 && !isPendingToolCallAtIndex(pendingPart, part.index)) {
 			const arrayIdx = toolCallIndexMap.get(part.index);
 			if (arrayIdx !== void 0) {
@@ -7615,7 +7855,10 @@ async function generate$1(provider, systemPrompt, tools, history, callbacks, opt
 		}
 		if (pendingPart === null) pendingPart = part;
 		else if (!mergeInPlace(pendingPart, part)) {
-			flushPart(message, pendingPart, toolCallIndexMap);
+			const flushed = flushPart(message, pendingPart, toolCallIndexMap);
+			if (flushed !== void 0 && canReadyFromMergeBoundary(provider, flushed) && hasCompleteJsonArguments(flushed.toolCall)) {
+				if (await emitToolCallReady(callbacks, readyToolCallIds, flushed.toolCall, { ordinal: flushed.ordinal }, options?.signal, stream) && flushed.streamIndex !== void 0) readyStreamIndexes.add(flushed.streamIndex);
+			}
 			pendingPart = part;
 		}
 	}
@@ -7626,6 +7869,7 @@ async function generate$1(provider, systemPrompt, tools, history, callbacks, opt
 	const hasText = message.content.some((p) => p.type === "text" && p.text.trim().length > 0);
 	const hasToolCalls = message.toolCalls.length > 0;
 	if (hasThink && !hasText && !hasToolCalls) throw new APIEmptyResponseError(`The API returned a response containing only thinking content without any text or tool calls. This usually indicates the stream was interrupted or the output token budget was exhausted during reasoning. Provider: ${provider.name}, model: ${provider.modelName}`);
+	if (callbacks?.onToolCallReady !== void 0) for (const [ordinal, toolCall] of message.toolCalls.entries()) await emitToolCallReady(callbacks, readyToolCallIds, toolCall, { ordinal }, options?.signal, stream);
 	if (callbacks?.onToolCall !== void 0) for (const toolCall of message.toolCalls) {
 		await throwIfAborted(options?.signal, stream);
 		await callbacks.onToolCall(toolCall);
@@ -7659,13 +7903,29 @@ async function throwIfAborted(signal, stream) {
 function isPendingToolCallAtIndex(pending, index) {
 	return pending !== null && isToolCall(pending) && pending._streamIndex === index;
 }
+function isLateArgumentDelta(part, readyStreamIndexes) {
+	return isToolCallPart(part) && part.index !== void 0 && readyStreamIndexes.has(part.index);
+}
+function hasCompleteJsonArguments(toolCall) {
+	const raw = toolCall.function.arguments;
+	if (raw === null || raw.length === 0) return false;
+	try {
+		JSON.parse(raw);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function canReadyFromMergeBoundary(provider, flushed) {
+	return flushed.streamIndex === void 0 || provider.toolCallReadyStrategy === "merge-boundary";
+}
 /**
 * Append a fully-merged part to the message.
 *
 * - ContentPart -> message.content
 * - ToolCall    -> message.toolCalls (the `_streamIndex` routing key is
 *                  registered in the map and stripped before storage).
-* - ToolCallPart -> ignored (orphaned delta)
+* - ToolCallPart / ToolCallDone -> ignored (control or orphaned delta)
 */
 function flushPart(message, part, toolCallIndexMap) {
 	if (isContentPart$1(part)) {
@@ -7680,10 +7940,48 @@ function flushPart(message, part, toolCallIndexMap) {
 			function: part.function,
 			extras: part.extras
 		};
-		const arrayIdx = message.toolCalls.length;
+		const ordinal = message.toolCalls.length;
 		message.toolCalls.push(storedCall);
-		if (streamIndex !== void 0) toolCallIndexMap.set(streamIndex, arrayIdx);
-	}
+		if (streamIndex !== void 0) toolCallIndexMap.set(streamIndex, ordinal);
+		return {
+			toolCall: storedCall,
+			streamIndex,
+			ordinal
+		};
+	}
+}
+async function handleToolCallDone(message, pendingPart, part, toolCallIndexMap, callbacks, readyToolCallIds, readyStreamIndexes, signal, stream) {
+	let target = getToolCallEntryByStreamIndex(message, toolCallIndexMap, part.index);
+	let nextPending = pendingPart;
+	if (target === void 0 && isPendingToolCallAtIndex(pendingPart, part.index)) {
+		const flushed = flushPart(message, pendingPart, toolCallIndexMap);
+		target = flushed !== void 0 ? {
+			toolCall: flushed.toolCall,
+			ordinal: flushed.ordinal
+		} : void 0;
+		nextPending = null;
+	}
+	if (target === void 0) return nextPending;
+	if ("arguments" in part) target.toolCall.function.arguments = part.arguments ?? null;
+	if (part.name !== void 0 && part.name.length > 0) target.toolCall.function.name = part.name;
+	if (await emitToolCallReady(callbacks, readyToolCallIds, target.toolCall, { ordinal: target.ordinal }, signal, stream)) readyStreamIndexes.add(part.index);
+	return nextPending;
+}
+function getToolCallEntryByStreamIndex(message, toolCallIndexMap, streamIndex) {
+	const arrayIdx = toolCallIndexMap.get(streamIndex);
+	if (arrayIdx === void 0) return void 0;
+	const toolCall = message.toolCalls[arrayIdx];
+	return toolCall === void 0 ? void 0 : {
+		toolCall,
+		ordinal: arrayIdx
+	};
+}
+async function emitToolCallReady(callbacks, readyToolCallIds, toolCall, info, signal, stream) {
+	if (callbacks?.onToolCallReady === void 0 || readyToolCallIds.has(toolCall.id)) return false;
+	await throwIfAborted(signal, stream);
+	readyToolCallIds.add(toolCall.id);
+	await callbacks.onToolCallReady(toolCall, info);
+	return true;
 }
 /**
 * Produce a shallow-ish copy of a StreamedMessagePart.
@@ -21342,7 +21640,8 @@ var SoulPlus = class {
 			toolRegistry,
 			isToolEnabled,
 			hasSubagentInfra,
-			soulRegistry
+			soulRegistry,
+			agentTypeRegistry: deps.agentTypeRegistry
 		});
 		registerSkillTool({
 			toolRegistry,
@@ -21811,13 +22110,13 @@ var KosongAdapter = class {
 		const onDelta = params.onDelta;
 		const onThinkDelta = params.onThinkDelta;
 		const onToolCallPart = params.onToolCallPart;
+		const onToolCallReady = params.onToolCallReady;
 		const onAtomicPart = params.onAtomicPart;
 		const needMessagePart = onDelta !== void 0 || onThinkDelta !== void 0 || onToolCallPart !== void 0;
 		const toolCallsByStreamIndex = /* @__PURE__ */ new Map();
 		let lastToolCall;
-		let result;
-		try {
-			result = await generate$1(activeProvider, params.systemPrompt, kosongTools, params.messages, needMessagePart ? { onMessagePart: async (part) => {
+		const callbacks = needMessagePart || onToolCallReady !== void 0 ? {
+			...needMessagePart ? { onMessagePart: async (part) => {
 				if (part.type === "text" && onDelta !== void 0) onDelta(part.text);
 				else if (part.type === "think" && onThinkDelta !== void 0) onThinkDelta(part.think);
 				else if (part.type === "function") {
@@ -21826,16 +22125,30 @@ var KosongAdapter = class {
 						name: part.function.name
 					};
 					if (part._streamIndex !== void 0) toolCallsByStreamIndex.set(part._streamIndex, lastToolCall);
-				} else if (isToolCallPart(part) && onToolCallPart !== void 0) {
+				} else if (isToolCallPart(part)) {
 					const target = part.index !== void 0 ? toolCallsByStreamIndex.get(part.index) : lastToolCall;
-					if (target !== void 0) onToolCallPart({
+					if (target !== void 0 && onToolCallPart !== void 0) onToolCallPart({
 						type: "tool_call_part",
 						tool_call_id: target.id,
 						name: target.name,
 						...part.argumentsPart !== null ? { arguments_chunk: part.argumentsPart } : {}
 					});
 				}
-			} } : void 0, { signal: params.signal });
+			} } : {},
+			...onToolCallReady !== void 0 ? { onToolCallReady: async (toolCall, info) => {
+				const parsed = parseToolArgs(toolCall.function.arguments);
+				if (parsed.error !== void 0) return;
+				onToolCallReady({
+					id: toolCall.id,
+					name: toolCall.function.name,
+					rawArgs: toolCall.function.arguments,
+					args: parsed.args
+				}, info);
+			} } : {}
+		} : void 0;
+		let result;
+		try {
+			result = await generate$1(activeProvider, params.systemPrompt, kosongTools, params.messages, callbacks, { signal: params.signal });
 		} catch (error) {
 			if (isContextOverflowProviderError(error)) throw new ContextOverflowError(extractMessage(error));
 			throw error;
@@ -24261,6 +24574,7 @@ var ReadTool = class {
 	inputSchema = ReadInputSchema;
 	maxResultSizeChars = Number.POSITIVE_INFINITY;
 	isConcurrencySafe = (_input) => true;
+	isStreamingPrefetchSafe = (_input) => true;
 	display = {
 		getUserFacingName: () => "Read",
 		getInputDisplay: (input) => ({
@@ -29183,6 +29497,7 @@ var GrepTool = class {
 	description = "Search file contents using regular expressions (powered by ripgrep).";
 	inputSchema = GrepInputSchema;
 	isConcurrencySafe = (_input) => true;
+	isStreamingPrefetchSafe = (_input) => true;
 	constructor(kaos, workspace) {
 		this.kaos = kaos;
 		this.workspace = workspace;
@@ -29583,6 +29898,7 @@ var GlobTool = class {
 	description = GLOB_DESCRIPTION;
 	inputSchema = GlobInputSchema;
 	isConcurrencySafe = (_input) => true;
+	isStreamingPrefetchSafe = (_input) => true;
 	constructor(kaos, workspace) {
 		this.kaos = kaos;
 		this.workspace = workspace;
@@ -32187,7 +32503,7 @@ function registerProcessHandlers(ctx) {
 //#region ../../packages/kimi-core/src/wire-protocol/outbound/external-tool-proxy.ts
 function buildExternalToolProxy(options) {
 	const inputSchema = z.unknown();
-	return {
+	const tool = {
 		name: options.name,
 		description: options.description,
 		inputSchema,
@@ -32217,6 +32533,8 @@ function buildExternalToolProxy(options) {
 			}
 		}
 	};
+	if (options.concurrencySafe === true) tool.isConcurrencySafe = () => true;
+	return tool;
 }
 //#endregion
 //#region ../../packages/kimi-core/src/wire-protocol/request/handlers/tools.ts
@@ -32229,12 +32547,14 @@ const TOOLS_HANDLER_DESCRIPTORS = [
 			if (reverse === void 0) throw new Error("session.registerTool requires a reverse-RPC channel (no `server` transport wired)");
 			ctx.sessionState.get(msg.session_id).externalTools.set(payload.name, {
 				description: payload.description ?? "",
-				input_schema: payload.input_schema
+				input_schema: payload.input_schema,
+				concurrency_safe: payload.concurrency_safe === true
 			});
 			await ctx.sessionApplication.registerDynamicTool(msg.session_id, buildExternalToolProxy({
 				name: payload.name,
 				description: payload.description ?? "",
 				inputSchema: payload.input_schema,
+				concurrencySafe: payload.concurrency_safe === true,
 				sendToolCall: async (call, signal) => {
 					const data = (await reverse.sendRequest("tool.call", msg.session_id, {
 						id: call.id,
@@ -32453,7 +32773,7 @@ function registerDefaultWireHandlers(deps) {
 		pathConfig,
 		runtimeProvider: () => deps.runtimeProvider?.() ?? runtime,
 		toolsProvider: (ctx) => deps.toolsProvider?.(ctx) ?? tools,
-		...deps.enabledToolNames !== void 0 || deps.enabledToolNamesProvider !== void 0 ? { enabledToolNamesProvider: async () => deps.enabledToolNamesProvider !== void 0 ? await deps.enabledToolNamesProvider() : deps.enabledToolNames } : {},
+		...deps.enabledToolNames !== void 0 || deps.enabledToolNamesProvider !== void 0 ? { enabledToolNamesProvider: async () => deps.enabledToolNamesProvider !== void 0 ? deps.enabledToolNamesProvider() : deps.enabledToolNames } : {},
 		defaultModelProvider: () => deps.defaultModelProvider?.() ?? defaultModel,
 		...deps.defaultSystemPromptProvider !== void 0 ? { defaultSystemPromptProvider: deps.defaultSystemPromptProvider } : {},
 		compactionProviderProvider: () => deps.compactionProviderProvider?.() ?? compactionProvider,
@@ -33287,7 +33607,7 @@ function normalizeSessionTimestampSeconds(value) {
 async function readSessionInfo(paths, sessionId) {
 	const statePath = paths.statePath(sessionId);
 	const cache = new StateCache(statePath);
-	const [state, lastActivity] = await Promise.all([cache.read(), stat(statePath).then((st) => Math.floor(st.mtimeMs / 1e3), () => void 0)]);
+	const [state, lastActivity] = await Promise.all([cache.read(), stat(statePath).then((st) => Math.floor(st.mtimeMs / 1e3), () => {})]);
 	if (state !== null) return {
 		session_id: state.session_id,
 		created_at: state.created_at,
@@ -47647,6 +47967,7 @@ var AnthropicStreamedMessage = class {
 		}
 	}
 	async *_convertStreamResponse(response) {
+		const toolUseBlockIndexes = /* @__PURE__ */ new Set();
 		try {
 			for await (const event of response) {
 				const evt = event;
@@ -47680,6 +48001,7 @@ var AnthropicStreamedMessage = class {
 							};
 							break;
 						case "tool_use":
+							toolUseBlockIndexes.add(blockIndex);
 							yield {
 								type: "function",
 								id: block.id,
@@ -47723,6 +48045,15 @@ var AnthropicStreamedMessage = class {
 							};
 							break;
 					}
+				} else if (eventType === "content_block_stop") {
+					const blockIndex = evt.index;
+					if (blockIndex !== void 0 && toolUseBlockIndexes.has(blockIndex)) {
+						toolUseBlockIndexes.delete(blockIndex);
+						yield {
+							type: "tool_call_done",
+							index: blockIndex
+						};
+					}
 				} else if (eventType === "message_delta") {
 					const deltaUsage = evt.usage;
 					if (deltaUsage !== void 0) {
@@ -76942,6 +77273,7 @@ var KimiStreamedMessage = class {
 };
 var KimiChatProvider = class {
 	name = "kimi";
+	toolCallReadyStrategy = "merge-boundary";
 	_model;
 	_stream;
 	_apiKey;
@@ -77718,7 +78050,7 @@ var OpenAIResponsesStreamedMessage = class {
 				} else if (chunkType === "response.output_item.added") {
 					const item = chunk["item"];
 					if (item["type"] === "function_call") {
-						const itemId = item["id"];
+						const streamIndex = item["id"] ?? chunk["output_index"];
 						const tc = {
 							type: "function",
 							id: item["call_id"] || crypto.randomUUID(),
@@ -77727,7 +78059,7 @@ var OpenAIResponsesStreamedMessage = class {
 								arguments: item["arguments"] ?? null
 							}
 						};
-						if (itemId !== void 0) tc._streamIndex = itemId;
+						if (streamIndex !== void 0) tc._streamIndex = streamIndex;
 						yield tc;
 					}
 				} else if (chunkType === "response.output_item.done") {
@@ -77740,15 +78072,41 @@ var OpenAIResponsesStreamedMessage = class {
 						};
 						if (encContent !== void 0) thinkPart.encrypted = encContent;
 						yield thinkPart;
+					} else if (item["type"] === "function_call") {
+						const streamIndex = item["id"] ?? chunk["output_index"];
+						if (streamIndex !== void 0) {
+							const donePart = {
+								type: "tool_call_done",
+								index: streamIndex
+							};
+							const argumentsValue = item["arguments"];
+							if (typeof argumentsValue === "string") donePart.arguments = argumentsValue;
+							const name = item["name"];
+							if (typeof name === "string") donePart.name = name;
+							yield donePart;
+						}
 					}
 				} else if (chunkType === "response.function_call_arguments.delta") {
-					const itemId = chunk["item_id"];
+					const streamIndex = chunk["item_id"] ?? chunk["output_index"];
 					const part = {
 						type: "tool_call_part",
 						argumentsPart: chunk["delta"]
 					};
-					if (itemId !== void 0) part.index = itemId;
+					if (streamIndex !== void 0) part.index = streamIndex;
 					yield part;
+				} else if (chunkType === "response.function_call_arguments.done") {
+					const streamIndex = chunk["item_id"] ?? chunk["output_index"];
+					if (streamIndex !== void 0) {
+						const donePart = {
+							type: "tool_call_done",
+							index: streamIndex
+						};
+						const argumentsValue = chunk["arguments"];
+						if (typeof argumentsValue === "string") donePart.arguments = argumentsValue;
+						const name = chunk["name"];
+						if (typeof name === "string") donePart.name = name;
+						yield donePart;
+					}
 				} else if (chunkType === "response.reasoning_summary_part.added") yield {
 					type: "think",
 					think: ""
@@ -78182,12 +78540,14 @@ var DeferredOAuthChatProvider = class DeferredOAuthChatProvider {
 	name;
 	modelName;
 	thinkingEffort;
+	toolCallReadyStrategy;
 	options;
 	constructor(options) {
 		this.options = options;
 		this.name = options.providerConfig.type;
 		this.modelName = options.modelOverride ?? options.providerConfig.defaultModel ?? "";
 		this.thinkingEffort = options.thinkingEffort ?? null;
+		this.toolCallReadyStrategy = this.createProviderWithApiKey("__oauth_token_placeholder__").toolCallReadyStrategy;
 	}
 	async generate(systemPrompt, tools, history, options) {
 		return (await this.materializeProvider()).generate(systemPrompt, tools, history, options);
@@ -78208,20 +78568,20 @@ var DeferredOAuthChatProvider = class DeferredOAuthChatProvider {
 		});
 	}
 	getCapability(model) {
-		return createProvider(this.options.providerName, {
-			...this.options.providerConfig,
-			apiKey: "__oauth_token_placeholder__"
-		}, this.options.modelOverride, this.options.defaultHeaders).getCapability?.(model) ?? UNKNOWN_CAPABILITY;
+		return this.createProviderWithApiKey("__oauth_token_placeholder__").getCapability?.(model) ?? UNKNOWN_CAPABILITY;
 	}
 	async materializeProvider() {
 		const accessToken = await this.options.oauthResolver(this.options.providerName);
-		let provider = createProvider(this.options.providerName, {
-			...this.options.providerConfig,
-			apiKey: accessToken
-		}, this.options.modelOverride, this.options.defaultHeaders);
+		let provider = this.createProviderWithApiKey(accessToken);
 		if (this.thinkingEffort !== null) provider = provider.withThinking(this.thinkingEffort);
 		return provider;
 	}
+	createProviderWithApiKey(apiKey) {
+		return createProvider(this.options.providerName, {
+			...this.options.providerConfig,
+			apiKey
+		}, this.options.modelOverride, this.options.defaultHeaders);
+	}
 };
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/subagent/agent-type-registry.ts
@@ -91723,8 +92083,8 @@ async function postForm(url, params, deviceHeaders, options) {
 			body,
 			signal
 		});
-	} catch (err) {
-		throw new OAuthError(`OAuth request to ${url} failed: ${err instanceof Error ? err.message : String(err)}`);
+	} catch (error) {
+		throw new OAuthError(`OAuth request to ${url} failed: ${error instanceof Error ? error.message : String(error)}`);
 	}
 	const status = response.status;
 	let data = {};
@@ -91803,8 +92163,8 @@ async function refreshAccessToken(config, refreshToken, options = {}) {
 				grant_type: "refresh_token",
 				refresh_token: refreshToken
 			}, getDeviceHeaders()));
-		} catch (err) {
-			lastError = err instanceof Error ? err : new OAuthError(String(err));
+		} catch (error) {
+			lastError = error instanceof Error ? error : new OAuthError(String(error));
 			if (attempt < maxRetries - 1) {
 				await sleep(backoff(attempt));
 				continue;
@@ -96466,6 +96826,15 @@ var ToolCallComponent = class extends Container {
 	subagentUsage;
 	subagentResultSummary;
 	subagentError;
+	/**
+	* 当 ToolCallComponent 被 group 容器（`AgentGroupComponent` /
+	* `ReadGroupComponent`）借走做"隐身状态容器"时，由 group 注册回调；任何
+	* 状态变化（subagent meta / phase / sub-tool / result 等）都会触发它，
+	* 让 group 走节流重渲染。`undefined` 表示没人订阅，对独立单卡渲染路径
+	* 无副作用。一个 ToolCallComponent 同时只可能在一个 group 里，所以
+	* 单 listener slot 足够；后到的 listener 会覆盖前一个。
+	*/
+	onSnapshotChange;
 	constructor(toolCall, result, colors, ui, markdownTheme) {
 		super();
 		this.toolCall = toolCall;
@@ -96491,6 +96860,7 @@ var ToolCallComponent = class extends Container {
 		this.result = result;
 		this.headerText.setText(this.buildHeader());
 		this.rebuildBody();
+		this.notifySnapshotChange();
 	}
 	updateToolCall(toolCall) {
 		this.toolCall = toolCall;
@@ -96548,9 +96918,72 @@ var ToolCallComponent = class extends Container {
 		this.subagentAgentId = agentId;
 		this.subagentAgentName = agentName;
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	/**
+	* 让 group 容器（AgentGroup / ReadGroup）订阅本卡的状态变化。注册同时
+	* 立即触发一次回调，使 group 拿到当前快照（无需再调一次 getSubagentSnapshot
+	* / getReadSnapshot）。传入 `undefined` 解绑。
+	*/
+	setSnapshotListener(cb) {
+		this.onSnapshotChange = cb;
+		if (cb !== void 0) cb();
+	}
+	getSubagentSnapshot() {
+		const finished = this.finishedSubCalls.length + this.hiddenSubCallCount;
+		const tokens = this.subagentUsage ? this.subagentUsage.input + this.subagentUsage.output : 0;
+		const latestActivity = computeLatestActivity(this.ongoingSubCalls, this.finishedSubCalls, this.subagentText);
+		const derivedPhase = this.result !== void 0 ? this.result.is_error ? "failed" : "done" : this.subagentPhase;
+		return {
+			toolCallId: this.toolCall.id,
+			toolName: this.toolCall.name,
+			toolCallDescription: str(this.toolCall.args["description"]) || str(this.toolCall.description),
+			agentName: this.subagentAgentName,
+			phase: derivedPhase,
+			toolCount: finished,
+			tokens,
+			isError: derivedPhase === "failed",
+			errorText: this.subagentError ?? (derivedPhase === "failed" ? this.result?.output : void 0),
+			latestActivity
+		};
+	}
+	/**
+	* 给 `ReadGroupComponent` 用：累加同 step 多张 Read 卡的 line 数。
+	* `lines` 与单卡 chip（`pluralize(countNonEmptyLines(...), 'line')`）保持
+	* 一致，避免 group 汇总和单卡读数不对齐。
+	*/
+	getReadSnapshot() {
+		const args = this.toolCall.args;
+		const filePathRaw = args["file_path"] ?? args["path"];
+		const filePath = typeof filePathRaw === "string" ? filePathRaw : void 0;
+		if (this.result === void 0) return {
+			toolCallId: this.toolCall.id,
+			filePath,
+			phase: "pending",
+			lines: 0
+		};
+		if (this.result.is_error === true) return {
+			toolCallId: this.toolCall.id,
+			filePath,
+			phase: "failed",
+			lines: 0
+		};
+		return {
+			toolCallId: this.toolCall.id,
+			filePath,
+			phase: "done",
+			lines: countNonEmptyLines(this.result.output)
+		};
+	}
+	get toolCallView() {
+		return this.toolCall;
+	}
+	/** 给本组件内部调用：state 任何变化都通知监听者（如果已绑定 group）。 */
+	notifySnapshotChange() {
+		this.onSnapshotChange?.();
+	}
+	/**
 	* 来自 wire 'subagent.spawned'。子 agent 已被注册，但内部活动事件
 	* (content.delta / tool.call) 可能尚未到达——把 UI 切到 'spawning'
 	* 占位状态（除非 runInBackground，这种情况直接进 'backgrounded'）。
@@ -96561,6 +96994,7 @@ var ToolCallComponent = class extends Container {
 		this.subagentRunInBackground = meta.runInBackground;
 		this.subagentPhase = meta.runInBackground ? "backgrounded" : "spawning";
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	/**
@@ -96572,6 +97006,7 @@ var ToolCallComponent = class extends Container {
 		this.subagentUsage = payload.usage;
 		this.subagentResultSummary = payload.resultSummary.length > 0 ? payload.resultSummary : void 0;
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	/**
@@ -96581,12 +97016,14 @@ var ToolCallComponent = class extends Container {
 		this.subagentPhase = "failed";
 		this.subagentError = payload.error;
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	appendSubagentText(text) {
 		this.subagentText += text;
 		if (this.subagentPhase === void 0 || this.subagentPhase === "spawning") this.subagentPhase = "running";
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	appendSubToolCall(call) {
@@ -96598,6 +97035,7 @@ var ToolCallComponent = class extends Container {
 		});
 		if (this.subagentPhase === void 0 || this.subagentPhase === "spawning") this.subagentPhase = "running";
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	appendSubToolCallDelta(delta) {
@@ -96610,6 +97048,7 @@ var ToolCallComponent = class extends Container {
 			streamingArguments: nextArgsText
 		});
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	finishSubToolCall(result) {
@@ -96627,6 +97066,7 @@ var ToolCallComponent = class extends Container {
 			this.hiddenSubCallCount += 1;
 		}
 		this.rebuildContent();
+		this.notifySnapshotChange();
 		this.ui?.requestRender();
 	}
 	buildHeader() {
@@ -96651,7 +97091,7 @@ var ToolCallComponent = class extends Container {
 			const tone = isError ? chalk.hex(colors.error) : chalk.hex(colors.primary);
 			return `${bullet}${tone.bold(label)}`;
 		}
-		const verb = isFinished ? "Used" : "Using";
+		const verb = isFinished ? "Used" : toolCall.streamingArguments !== void 0 ? "Preparing" : "Using";
 		const keyArg = extractKeyArgument(toolCall.name, toolCall.args);
 		const toolRef = chalk.hex(colors.primary).bold(toolCall.name);
 		const argStr = keyArg ? chalk.dim(` (${keyArg})`) : "";
@@ -96907,6 +97347,30 @@ var ToolCallComponent = class extends Container {
 		return true;
 	}
 };
+/**
+* 推算 group line 第二级"最新活动"行：优先级
+*   1. 最近的 ongoing sub-tool（`Using {name} ({keyArg})`）
+*   2. 最近的 finished sub-tool（`Used {name} ({keyArg})`）
+*   3. subagent 累计文本的非空末行
+*/
+function computeLatestActivity(ongoing, finished, text) {
+	if (ongoing.size > 0) {
+		const lastOngoing = [...ongoing.values()].at(-1);
+		if (lastOngoing !== void 0) return formatActivityLine("Using", lastOngoing.name, lastOngoing.args);
+	}
+	if (finished.length > 0) {
+		const last = finished.at(-1);
+		if (last !== void 0) return formatActivityLine("Used", last.name, last.args);
+	}
+	if (text.length > 0) {
+		const tail = text.split("\n").toReversed().find((l) => l.trim().length > 0);
+		if (tail !== void 0) return tail.trim();
+	}
+}
+function formatActivityLine(verb, toolName, args) {
+	const keyArg = extractKeyArgument(toolName, args);
+	return keyArg ? `${verb} ${toolName} (${keyArg})` : `${verb} ${toolName}`;
+}
 //#endregion
 //#region src/tui/components/messages/user-message.ts
 /**
@@ -97602,6 +98066,7 @@ function clearTranscriptAndRedraw(state) {
 	state.transcriptContainer.clear();
 	state.pendingToolComponents.clear();
 	state.streamingComponent = void 0;
+	state.streamingTranscriptEntry = void 0;
 	state.todoPanel.clear();
 	state.todoPanelContainer.clear();
 	state.imageStore.clear();
@@ -97677,7 +98142,19 @@ function handleSubagentSourceEvent(ectx, payload) {
 	}
 }
 function handleSubagentSpawned(ectx, data) {
-	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+	if (data.run_in_background) {
+		ectx.state.backgroundAgents.add(data.agent_id);
+		syncBackgroundAgentBadge(ectx);
+		return;
+	}
+	let tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+	if (tc === void 0) {
+		const toolCall = ectx.state.activeToolCalls.get(data.parent_tool_call_id);
+		if (toolCall !== void 0) {
+			ectx.onToolCallStart(toolCall);
+			tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+		}
+	}
 	if (tc === void 0) return;
 	tc.onSubagentSpawned({
 		agentId: data.agent_id,
@@ -97686,6 +98163,7 @@ function handleSubagentSpawned(ectx, data) {
 	});
 }
 function handleSubagentCompleted(ectx, data) {
+	if (ectx.state.backgroundAgents.delete(data.agent_id)) syncBackgroundAgentBadge(ectx);
 	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
 	if (tc === void 0) return;
 	tc.onSubagentCompleted({
@@ -97694,10 +98172,15 @@ function handleSubagentCompleted(ectx, data) {
 	});
 }
 function handleSubagentFailed(ectx, data) {
+	if (ectx.state.backgroundAgents.delete(data.agent_id)) syncBackgroundAgentBadge(ectx);
 	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
 	if (tc === void 0) return;
 	tc.onSubagentFailed({ error: data.error });
 }
+function syncBackgroundAgentBadge(ectx) {
+	ectx.state.footer.setBackgroundAgentCount(ectx.state.backgroundAgents.size);
+	ectx.state.ui.requestRender();
+}
 //#endregion
 //#region src/utils/git/git-ls-files.ts
 /**
@@ -98705,6 +99188,13 @@ var FooterComponent = class {
 	gitCache;
 	gitCacheWorkDir;
 	transientHint = null;
+	/**
+	* 在跑的 background subagent 数量。`subagent.spawned (run_in_background)`
+	* 入集合 → 加 1；`subagent.completed/failed` → 减 1（详见
+	* `handlers/subagent.ts`）。0 时整块隐藏；>=1 时在 line1 的 cwd 左侧
+	* 插入 `[N agents running]` badge（位于 `agent(model ○)` 与 cwd 之间）。
+	*/
+	backgroundAgentCount = 0;
 	constructor(state, colors) {
 		this.state = state;
 		this.colors = colors;
@@ -98730,6 +99220,14 @@ var FooterComponent = class {
 	setTransientHint(hint) {
 		this.transientHint = hint;
 	}
+	/**
+	* Sync the background-agent badge with the live count. Called by
+	* `handlers/subagent.ts` after `subagent.spawned/completed/failed` mutate
+	* `state.backgroundAgents`. n=0 hides the badge entirely.
+	*/
+	setBackgroundAgentCount(n) {
+		this.backgroundAgentCount = Math.max(0, n);
+	}
 	invalidate() {}
 	attach(handlers, requestRender) {
 		const unsubStatus = handlers.onStatusUpdate((data) => {
@@ -98771,6 +99269,7 @@ var FooterComponent = class {
 			const dot = state.thinking ? "●" : "○";
 			left.push(chalk.hex(colors.text)(`agent(${model} ${dot})`));
 		}
+		if (this.backgroundAgentCount > 0) left.push(chalk.hex(colors.primary)(`[${String(this.backgroundAgentCount)} agents running]`));
 		const cwd = shortenCwd(state.workDir);
 		if (cwd) left.push(chalk.hex(colors.status)(cwd));
 		const git = this.gitCache.getStatus();
@@ -99011,11 +99510,15 @@ function createTUIState(options) {
 		phaseSpinner: void 0,
 		activeThinkingComponent: void 0,
 		streamingComponent: void 0,
+		streamingTranscriptEntry: void 0,
 		activeCompactionBlock: void 0,
 		toolOutputExpanded: false,
 		lastActivityMode: void 0,
 		lastHistoryContent: void 0,
 		pendingToolComponents: /* @__PURE__ */ new Map(),
+		pendingAgentGroup: null,
+		pendingReadGroup: null,
+		backgroundAgents: /* @__PURE__ */ new Set(),
 		sessions: [],
 		loadingSessions: false,
 		showingSessionPicker: false,
@@ -99026,6 +99529,7 @@ function createTUIState(options) {
 		fdPath: detectFdPath(),
 		gitLsFilesCache: createGitLsFilesCache(initialAppState.workDir),
 		currentTurnId: void 0,
+		currentStep: 0,
 		assistantDraft: "",
 		assistantStreamActive: false,
 		thinkingDraft: "",
@@ -99196,6 +99700,8 @@ function sendMessageInternal(state, addEntry, input, options) {
 	state.currentTurnId = void 0;
 	state.assistantDraft = "";
 	state.assistantStreamActive = false;
+	state.streamingComponent = void 0;
+	state.streamingTranscriptEntry = void 0;
 	state.thinkingDraft = "";
 	disposeActiveThinkingComponent(state);
 	state.activeToolCalls.clear();
@@ -99257,6 +99763,8 @@ function sendSkillActivation(state, addEntry, skillName, skillArgs, fullPrompt)
 	state.currentTurnId = void 0;
 	state.assistantDraft = "";
 	state.assistantStreamActive = false;
+	state.streamingComponent = void 0;
+	state.streamingTranscriptEntry = void 0;
 	state.thinkingDraft = "";
 	disposeActiveThinkingComponent(state);
 	state.activeToolCalls.clear();
@@ -99433,13 +99941,186 @@ async function performReload(state, action, hooks) {
 	state.ui.requestRender();
 }
 //#endregion
+//#region src/tui/components/messages/agent-group.ts
+const THROTTLE_MS$1 = 200;
+var AgentGroupComponent = class extends Container {
+	entries = [];
+	headerText;
+	bodyContainer;
+	throttleTimer = null;
+	lastFlushPhases = /* @__PURE__ */ new Map();
+	constructor(colors, ui) {
+		super();
+		this.colors = colors;
+		this.ui = ui;
+		this.addChild(new Spacer(1));
+		this.headerText = new Text("", 0, 0);
+		this.addChild(this.headerText);
+		this.bodyContainer = new Container();
+		this.addChild(this.bodyContainer);
+	}
+	size() {
+		return this.entries.length;
+	}
+	/**
+	* 把一个独立 `ToolCallComponent` 借进 group 做"隐身状态容器"。注册
+	* snapshot 监听 → 状态有变即触发节流刷新。多次 attach 同一个 toolCallId
+	* 是 noop。
+	*/
+	attach(toolCallId, tc) {
+		if (this.entries.some((e) => e.toolCallId === toolCallId)) return;
+		this.entries.push({
+			toolCallId,
+			tc
+		});
+		tc.setSnapshotListener(() => {
+			this.scheduleRender();
+		});
+		this.flushRender();
+	}
+	/**
+	* 立刻调度一次重绘。phase 真正跨阶段切换（spawning ↔ running ↔ done/failed）
+	* 时强制立刷新；其他变更（latestActivity / tokens / toolCount）走节流。
+	*/
+	scheduleRender() {
+		if (this.detectPhaseTransition()) {
+			this.flushRender();
+			return;
+		}
+		if (this.throttleTimer !== null) return;
+		this.throttleTimer = setTimeout(() => {
+			this.throttleTimer = null;
+			this.flushRender();
+		}, THROTTLE_MS$1);
+	}
+	/**
+	* 比较当前各 child 的 phase 与上次刷新时的 phase 快照。任意一个发生
+	* 变化即视为 phase transition，触发立刷新。
+	*/
+	detectPhaseTransition() {
+		let changed = false;
+		for (const e of this.entries) {
+			const phase = e.tc.getSubagentSnapshot().phase;
+			if (this.lastFlushPhases.get(e.toolCallId) !== phase) {
+				changed = true;
+				break;
+			}
+		}
+		return changed;
+	}
+	flushRender() {
+		if (this.throttleTimer !== null) {
+			clearTimeout(this.throttleTimer);
+			this.throttleTimer = null;
+		}
+		const snapshots = this.entries.map((e) => e.tc.getSubagentSnapshot());
+		this.headerText.setText(this.buildHeader(snapshots));
+		this.bodyContainer.clear();
+		snapshots.forEach((snap, idx) => {
+			const isLast = idx === snapshots.length - 1;
+			this.appendLines(snap, isLast);
+		});
+		this.lastFlushPhases.clear();
+		this.entries.forEach((entry, i) => {
+			const snap = snapshots[i];
+			if (snap !== void 0) this.lastFlushPhases.set(entry.toolCallId, snap.phase);
+		});
+		this.invalidate();
+		this.ui?.requestRender();
+	}
+	buildHeader(snapshots) {
+		const colors = this.colors;
+		const total = snapshots.length;
+		const done = snapshots.filter((s) => s.phase === "done").length;
+		const failed = snapshots.filter((s) => s.phase === "failed").length;
+		const finished = done + failed;
+		const allDone = finished === total;
+		const bullet = allDone ? chalk.hex(colors.success)("⏺ ") : chalk.hex(colors.roleAssistant)("⏺ ");
+		if (allDone) {
+			const types = new Set(snapshots.map((s) => s.agentName).filter((n) => n !== void 0));
+			const headerLabel = types.size === 1 ? `${String(total)} ${[...types][0]} agents finished` : `${String(total)} agents finished`;
+			const tail = formatHeaderTail(snapshots.reduce((acc, s) => acc + s.toolCount, 0), snapshots.reduce((acc, s) => acc + s.tokens, 0));
+			return `${bullet}${chalk.hex(colors.primary).bold(headerLabel)}${tail}`;
+		}
+		let headerText = `Running ${String(total)} agents`;
+		if (finished > 0) {
+			const running = total - finished;
+			const parts = [];
+			if (done > 0) parts.push(`${String(done)} done`);
+			if (failed > 0) parts.push(`${String(failed)} failed`);
+			if (running > 0) parts.push(`${String(running)} running`);
+			headerText = `Running ${String(total)} agents (${parts.join(", ")})`;
+		}
+		return `${bullet}${chalk.hex(colors.primary).bold(headerText)}`;
+	}
+	appendLines(snap, isLast) {
+		const colors = this.colors;
+		const dim = chalk.dim;
+		const branch1 = isLast ? "└─" : "├─";
+		const agentType = snap.agentName ?? "agent";
+		const desc = snap.toolCallDescription || "(no description)";
+		const tail = formatLineTail(snap, colors);
+		const line1 = `  ${branch1} ${chalk.hex(colors.primary)(agentType)} ${dim(`· ${desc}`)}${formatStats(snap)}${tail}`;
+		this.bodyContainer.addChild(new Text(line1, 0, 0));
+		const branch2 = isLast ? "   " : "│  ";
+		if (snap.phase === "failed") {
+			const errLine = (snap.errorText ?? "Failed").split("\n").at(0) ?? "Failed";
+			const errStr = chalk.hex(colors.error)(`Error: ${errLine}`);
+			this.bodyContainer.addChild(new Text(`  ${branch2}    ${errStr}`, 0, 0));
+			return;
+		}
+		if (snap.phase === "done" || snap.phase === "backgrounded") return;
+		const activity = snap.latestActivity ?? "Initializing…";
+		this.bodyContainer.addChild(new Text(`  ${branch2}    ${dim(activity)}`, 0, 0));
+	}
+	/**
+	* 给测试 / 开发期使用，立刻冲掉节流计时器并刷新。生产代码不需要主动调。
+	*/
+	flushNow() {
+		this.flushRender();
+	}
+	/** 释放节流计时器，避免组件被销毁后还触发刷新。 */
+	dispose() {
+		if (this.throttleTimer !== null) {
+			clearTimeout(this.throttleTimer);
+			this.throttleTimer = null;
+		}
+		for (const e of this.entries) e.tc.setSnapshotListener(void 0);
+	}
+};
+function formatStats(snap) {
+	const dim = chalk.dim;
+	return dim(`${` · ${String(snap.toolCount)} tool${snap.toolCount === 1 ? "" : "s"}`}${snap.tokens > 0 ? ` · ${formatTokens(snap.tokens)}` : ""}`);
+}
+function formatLineTail(snap, colors) {
+	if (snap.phase === "done") return chalk.dim(" · ") + chalk.hex(colors.success)("✓ Completed");
+	if (snap.phase === "failed") return chalk.dim(" · ") + chalk.hex(colors.error)("✗ Failed");
+	if (snap.phase === "backgrounded") return chalk.dim(" · ◐ backgrounded");
+	return "";
+}
+function formatHeaderTail(toolCount, tokens) {
+	const dim = chalk.dim;
+	const parts = [];
+	if (toolCount > 0) parts.push(`${String(toolCount)} tool${toolCount === 1 ? "" : "s"}`);
+	if (tokens > 0) parts.push(formatTokens(tokens));
+	return parts.length > 0 ? dim(` · ${parts.join(" · ")}`) : "";
+}
+function formatTokens(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M tok`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k tok`;
+	return `${String(n)} tok`;
+}
+//#endregion
 //#region src/tui/actions/replay-ops.ts
 async function hydrateTranscriptFromReplay(state, hooks, sessionId) {
 	setState(state, { isReplaying: true }, hooks);
 	try {
 		const replay = await state.client.replayRecords(sessionId);
 		const projection = projectReplayRecords(replay.records);
-		for (const entry of projection.entries) appendTranscriptEntry(state, entry);
+		hydrateProjectedEntries(state, projection.entries);
+		state.backgroundAgents = new Set(projection.backgroundAgents);
+		state.footer.setBackgroundAgentCount(state.backgroundAgents.size);
+		state.ui.requestRender();
 		if (replay.warnings !== void 0 && replay.warnings.length > 0) emitError(state, `Replay completed with ${String(replay.warnings.length)} warning(s).`);
 		return true;
 	} catch (error) {
@@ -99457,7 +100138,8 @@ function projectReplayRecords(records) {
 		assistant: {
 			thinking: [],
 			text: []
-		}
+		},
+		backgroundAgents: /* @__PURE__ */ new Set()
 	};
 	for (const envelope of records) {
 		if (envelope.source?.kind === "subagent") {
@@ -99467,7 +100149,10 @@ function projectReplayRecords(records) {
 		projectMainRecord(state, envelope.record);
 	}
 	flushAssistant(state);
-	return { entries: state.entries };
+	return {
+		entries: state.entries,
+		backgroundAgents: state.backgroundAgents
+	};
 }
 function projectMainRecord(state, rawRecord) {
 	const record = asRecord(rawRecord);
@@ -99509,6 +100194,22 @@ function projectMainRecord(state, rawRecord) {
 				text: []
 			};
 			return;
+		case "subagent_spawned": {
+			const data = record.data;
+			if (!isObject(data)) return;
+			if (data["run_in_background"] !== true) return;
+			const agentId = stringValue(data["agent_id"]);
+			if (agentId !== void 0) state.backgroundAgents.add(agentId);
+			return;
+		}
+		case "subagent_completed":
+		case "subagent_failed": {
+			const data = record.data;
+			if (!isObject(data)) return;
+			const agentId = stringValue(data["agent_id"]);
+			if (agentId !== void 0) state.backgroundAgents.delete(agentId);
+			return;
+		}
 		default: return;
 	}
 }
@@ -99557,15 +100258,19 @@ function projectSubagentRecord(state, envelope) {
 function projectToolCall(state, record) {
 	const tool = toolCallFromRecord(record);
 	if (tool === void 0) return;
+	const turnId = stringValue(record.turn_id);
+	const step = typeof record.step === "number" ? record.step : void 0;
 	const toolCall = {
 		id: tool.id,
 		name: tool.name,
 		args: tool.args,
-		description: tool.description
+		description: tool.description,
+		...step !== void 0 ? { step } : {},
+		...turnId !== void 0 ? { turnId } : {}
 	};
 	state.toolCalls.set(tool.id, toolCall);
 	state.entries.push(entry("tool_call", "", "plain", {
-		turnId: stringValue(record.turn_id),
+		turnId,
 		toolCallData: toolCall
 	}));
 }
@@ -99680,6 +100385,61 @@ function isObject(value) {
 function stringValue(value) {
 	return typeof value === "string" ? value : void 0;
 }
+/**
+* 把 projection 出的扁平 entries 注入 live state。其中相邻、同
+* `(turnId, step)` 的 ≥2 个 Agent tool_call 合并成一个 AgentGroupComponent，
+* 与 live 路径行为一致。其他 entry 走原本 `appendTranscriptEntry`。
+*
+* 注意：和 `tryAttachAgentToolCall` 不同，这里**不**写 `state.pendingAgentGroup`
+* —— replay 完成后该字段必须是 null（live 事件接管时从 zero 开始）。
+*/
+function hydrateProjectedEntries(state, entries) {
+	let i = 0;
+	while (i < entries.length) {
+		const cur = entries[i];
+		if (cur === void 0) {
+			i += 1;
+			continue;
+		}
+		const tc = cur.toolCallData;
+		if (cur.kind === "tool_call" && tc !== void 0 && tc.name === "Agent" && tc.step !== void 0) {
+			const batch = [cur];
+			let j = i + 1;
+			while (j < entries.length) {
+				const next = entries[j];
+				if (next === void 0) break;
+				const nextTc = next.toolCallData;
+				if (next.kind === "tool_call" && nextTc !== void 0 && nextTc.name === "Agent" && nextTc.step === tc.step && nextTc.turnId === tc.turnId) {
+					batch.push(next);
+					j++;
+					continue;
+				}
+				break;
+			}
+			if (batch.length >= 2) {
+				attachAgentBatchAsGroup(state, batch);
+				i = j;
+				continue;
+			}
+		}
+		appendTranscriptEntry(state, cur);
+		i++;
+	}
+}
+function attachAgentBatchAsGroup(state, batch) {
+	const group = new AgentGroupComponent(state.colors, state.ui);
+	state.transcriptContainer.addChild(group);
+	for (const item of batch) {
+		const tc = item.toolCallData;
+		if (tc === void 0) continue;
+		state.transcriptEntries.push(item);
+		const component = new ToolCallComponent(tc, tc.result, state.colors, state.ui, state.markdownTheme);
+		if (state.toolOutputExpanded) component.setExpanded(true);
+		state.pendingToolComponents.set(tc.id, component);
+		group.attach(tc.id, component);
+	}
+	state.ui.requestRender();
+}
 //#endregion
 //#region src/tui/utils/proctitle.ts
 /**
@@ -99842,6 +100602,8 @@ function releaseSessionSideEffects(state) {
 	state.currentTurnId = void 0;
 	state.assistantDraft = "";
 	state.assistantStreamActive = false;
+	state.streamingComponent = void 0;
+	state.streamingTranscriptEntry = void 0;
 	state.thinkingDraft = "";
 	disposeActiveThinkingComponent(state);
 }
@@ -99909,6 +100671,100 @@ var CompactionComponent = class extends Container {
 	}
 };
 //#endregion
+//#region src/tui/actions/agent-group-ops.ts
+/**
+* Agent 合并组挂载策略 & 打断规则。
+*
+* `tryAttachAgentToolCall`：在 `onToolCallStart` 里给 Agent 工具走的拦截
+* 点。如果当前 step 已有 `solo` 但还没升级成 group，第二个同 step 的
+* Agent 到达时会就地把 solo 替换成 `AgentGroupComponent` 并把两者塞进去。
+*
+* `closePendingAgentGroup`：所有打断点（非 Agent 工具 / step.begin /
+* turn.end / step.interrupted / session.error / assistant text）调用，
+* 清空 pending 指针。已挂出去的 group 不被销毁——它在 transcript 里
+* 作为独立组件继续工作，只是不再有新的 Agent 合并进来。
+*/
+/**
+* 把一个新创建的 Agent ToolCallComponent 挂到合适位置（合并组或单卡）。
+* 调用方负责创建 `tc` 与登记 `pendingToolComponents`，本函数只决定
+* 挂载策略并把 tc 放到 transcript 里。
+*
+* @returns true 如果走了 group 路径（已经挂好），调用方不应再调
+*           `transcriptContainer.addChild(tc)`；false 表示让调用方按
+*           原本的单卡路径自行 addChild。
+*/
+function tryAttachAgentToolCall(state, toolCall, tc) {
+	if (toolCall.name !== "Agent") {
+		closePendingAgentGroup(state);
+		return false;
+	}
+	const step = toolCall.step ?? state.currentStep;
+	const turnId = toolCall.turnId ?? state.currentTurnId;
+	const pending = state.pendingAgentGroup;
+	if (pending !== null && (pending.step !== step || pending.turnId !== turnId)) state.pendingAgentGroup = null;
+	const cur = state.pendingAgentGroup;
+	if (cur === null) {
+		state.pendingAgentGroup = {
+			step,
+			turnId,
+			solo: tc
+		};
+		state.transcriptContainer.addChild(tc);
+		state.ui.requestRender();
+		return true;
+	}
+	if (cur.group !== void 0) {
+		cur.group.attach(toolCall.id, tc);
+		return true;
+	}
+	const solo = cur.solo;
+	if (solo === void 0) {
+		state.pendingAgentGroup = {
+			step,
+			turnId,
+			solo: tc
+		};
+		state.transcriptContainer.addChild(tc);
+		state.ui.requestRender();
+		return true;
+	}
+	const group = upgradeSoloToGroup$1(state, solo);
+	group.attach(toolCall.id, tc);
+	state.pendingAgentGroup = {
+		step,
+		turnId,
+		group
+	};
+	state.ui.requestRender();
+	return true;
+}
+/**
+* 任意打断信号触发本函数。仅清空 pending 指针——已挂出去的 solo 单卡
+* 或 group 都保持原状。
+*/
+function closePendingAgentGroup(state) {
+	if (state.pendingAgentGroup === null) return;
+	state.pendingAgentGroup = null;
+}
+/**
+* 把已挂在 transcriptContainer 的 solo `ToolCallComponent` 原地替换成新建
+* 的 `AgentGroupComponent`，并把 solo 塞进 group 里继续做"隐身状态容器"。
+*
+* pi-tui 没暴露 insertChildAt / replaceChildAt，但 `Container.children`
+* 是 public 数组。这里直接 splice，再调一次 `invalidate()` 触发差分渲染。
+*/
+function upgradeSoloToGroup$1(state, solo) {
+	const group = new AgentGroupComponent(state.colors, state.ui);
+	const children = state.transcriptContainer.children;
+	const idx = children.indexOf(solo);
+	if (idx >= 0) {
+		children[idx] = group;
+		state.transcriptContainer.invalidate();
+	} else state.transcriptContainer.addChild(group);
+	group.attach(solo.toolCallView.id, solo);
+	return group;
+}
+//#endregion
 //#region src/tui/actions/plan-ops.ts
 async function refreshPlanFromCore(state) {
 	try {
@@ -99918,6 +100774,218 @@ async function refreshPlanFromCore(state) {
 	}
 }
 //#endregion
+//#region src/tui/components/messages/read-group.ts
+const THROTTLE_MS = 200;
+var ReadGroupComponent = class extends Container {
+	entries = [];
+	headerText;
+	bodyContainer;
+	throttleTimer = null;
+	lastFlushPhases = /* @__PURE__ */ new Map();
+	constructor(colors, ui) {
+		super();
+		this.colors = colors;
+		this.ui = ui;
+		this.addChild(new Spacer(1));
+		this.headerText = new Text("", 0, 0);
+		this.addChild(this.headerText);
+		this.bodyContainer = new Container();
+		this.addChild(this.bodyContainer);
+	}
+	size() {
+		return this.entries.length;
+	}
+	/**
+	* 把一个独立 `ToolCallComponent` 借进 group 做隐身状态容器。注册
+	* snapshot 监听 → 状态有变即触发节流刷新。多次 attach 同一个 toolCallId
+	* 是 noop。
+	*/
+	attach(toolCallId, tc) {
+		if (this.entries.some((e) => e.toolCallId === toolCallId)) return;
+		this.entries.push({
+			toolCallId,
+			tc
+		});
+		tc.setSnapshotListener(() => {
+			this.scheduleRender();
+		});
+		this.flushRender();
+	}
+	/**
+	* pending → done/failed 是用户最关心的转变，立刷新；其它情况节流。
+	*/
+	scheduleRender() {
+		if (this.detectPhaseTransition()) {
+			this.flushRender();
+			return;
+		}
+		if (this.throttleTimer !== null) return;
+		this.throttleTimer = setTimeout(() => {
+			this.throttleTimer = null;
+			this.flushRender();
+		}, THROTTLE_MS);
+	}
+	detectPhaseTransition() {
+		for (const e of this.entries) {
+			const phase = e.tc.getReadSnapshot().phase;
+			if (this.lastFlushPhases.get(e.toolCallId) !== phase) return true;
+		}
+		return false;
+	}
+	flushRender() {
+		if (this.throttleTimer !== null) {
+			clearTimeout(this.throttleTimer);
+			this.throttleTimer = null;
+		}
+		const snapshots = this.entries.map((e) => e.tc.getReadSnapshot());
+		let pending = 0;
+		let failed = 0;
+		let totalLines = 0;
+		for (const snap of snapshots) if (snap.phase === "pending") pending += 1;
+		else if (snap.phase === "failed") failed += 1;
+		else totalLines += snap.lines;
+		this.headerText.setText(this.buildHeader(snapshots.length, pending, failed, totalLines));
+		this.bodyContainer.clear();
+		snapshots.forEach((snap, idx) => {
+			const isLast = idx === snapshots.length - 1;
+			this.bodyContainer.addChild(new Text(this.buildBodyLine(snap, isLast), 0, 0));
+		});
+		this.lastFlushPhases.clear();
+		this.entries.forEach((entry, i) => {
+			const snap = snapshots[i];
+			if (snap !== void 0) this.lastFlushPhases.set(entry.toolCallId, snap.phase);
+		});
+		this.invalidate();
+		this.ui?.requestRender();
+	}
+	buildHeader(total, pending, failed, totalLines) {
+		const colors = this.colors;
+		const dim = chalk.dim;
+		if (pending > 0) return `${chalk.hex(colors.roleAssistant)("⏺ ")}${chalk.hex(colors.primary).bold(`Reading ${String(total)} files…`)}`;
+		if (failed === total) return `${chalk.hex(colors.error)("✗ ")}${chalk.hex(colors.error).bold(`Read ${String(total)} files`)}${chalk.hex(colors.error)(" · failed")}`;
+		return `${chalk.hex(colors.success)("⏺ ")}${chalk.hex(colors.primary).bold(`Read ${String(total)} files`)}${dim(` · ${String(totalLines)} ${totalLines === 1 ? "line" : "lines"}`)}${failed > 0 ? chalk.hex(colors.error)(` · ${String(failed)} failed`) : ""}`;
+	}
+	buildBodyLine(snap, isLast) {
+		const colors = this.colors;
+		const dim = chalk.dim;
+		const branch = isLast ? "└─" : "├─";
+		const path = snap.filePath ?? "(unknown)";
+		const pathPart = chalk.hex(colors.text)(path);
+		let tail;
+		if (snap.phase === "pending") tail = dim(" · reading…");
+		else if (snap.phase === "failed") tail = chalk.hex(colors.error)(" · failed");
+		else tail = dim(` · ${String(snap.lines)} ${snap.lines === 1 ? "line" : "lines"}`);
+		return `  ${branch} ${pathPart}${tail}`;
+	}
+	/** 给测试 / 开发期使用，立刻冲掉节流计时器并刷新。生产代码不需要主动调。 */
+	flushNow() {
+		this.flushRender();
+	}
+	/** 释放节流计时器，避免组件被销毁后还触发刷新。 */
+	dispose() {
+		if (this.throttleTimer !== null) {
+			clearTimeout(this.throttleTimer);
+			this.throttleTimer = null;
+		}
+		for (const e of this.entries) e.tc.setSnapshotListener(void 0);
+	}
+};
+//#endregion
+//#region src/tui/actions/read-group-ops.ts
+/**
+* Read 合并组挂载策略 & 打断规则。
+*
+* 与 `agent-group-ops.ts` 完全同构，只是 batch key 从「Agent 工具」换成
+* 「Read 工具」。
+*
+* `tryAttachReadToolCall`：在 `onToolCallStart` 里给 Read 工具走的拦截
+* 点。如果当前 step 已有 `solo` 但还没升级成 group，第二个同 step 的
+* Read 到达时会就地把 solo 替换成 `ReadGroupComponent` 并把两者塞进去。
+*
+* `closePendingReadGroup`：所有打断点（非 Read 工具 / step.begin /
+* turn.end / step.interrupted / session.error / assistant text /
+* thinking）调用，清空 pending 指针。已挂出去的 group 不被销毁——它在
+* transcript 里作为独立组件继续工作，只是不再有新的 Read 合并进来。
+*/
+/**
+* 把一个新创建的 Read ToolCallComponent 挂到合适位置（合并组或单卡）。
+* 调用方负责创建 `tc` 与登记 `pendingToolComponents`，本函数只决定
+* 挂载策略并把 tc 放到 transcript 里。
+*
+* @returns true 如果走了 group 路径（已经挂好），调用方不应再调
+*           `transcriptContainer.addChild(tc)`；false 表示让调用方按
+*           原本的单卡路径自行 addChild。
+*/
+function tryAttachReadToolCall(state, toolCall, tc) {
+	if (toolCall.name !== "Read") {
+		closePendingReadGroup(state);
+		return false;
+	}
+	const step = toolCall.step ?? state.currentStep;
+	const turnId = toolCall.turnId ?? state.currentTurnId;
+	const pending = state.pendingReadGroup;
+	if (pending !== null && (pending.step !== step || pending.turnId !== turnId)) state.pendingReadGroup = null;
+	const cur = state.pendingReadGroup;
+	if (cur === null) {
+		state.pendingReadGroup = {
+			step,
+			turnId,
+			solo: tc
+		};
+		state.transcriptContainer.addChild(tc);
+		state.ui.requestRender();
+		return true;
+	}
+	if (cur.group !== void 0) {
+		cur.group.attach(toolCall.id, tc);
+		return true;
+	}
+	const solo = cur.solo;
+	if (solo === void 0) {
+		state.pendingReadGroup = {
+			step,
+			turnId,
+			solo: tc
+		};
+		state.transcriptContainer.addChild(tc);
+		state.ui.requestRender();
+		return true;
+	}
+	const group = upgradeSoloToGroup(state, solo);
+	group.attach(toolCall.id, tc);
+	state.pendingReadGroup = {
+		step,
+		turnId,
+		group
+	};
+	state.ui.requestRender();
+	return true;
+}
+/**
+* 任意打断信号触发本函数。仅清空 pending 指针——已挂出去的 solo 单卡
+* 或 group 都保持原状。
+*/
+function closePendingReadGroup(state) {
+	if (state.pendingReadGroup === null) return;
+	state.pendingReadGroup = null;
+}
+/**
+* 把已挂在 transcriptContainer 的 solo `ToolCallComponent` 原地替换成新建
+* 的 `ReadGroupComponent`，并把 solo 塞进 group 里继续做隐身状态容器。
+* 与 agent-group-ops 同构：直接 splice transcriptContainer.children。
+*/
+function upgradeSoloToGroup(state, solo) {
+	const group = new ReadGroupComponent(state.colors, state.ui);
+	const children = state.transcriptContainer.children;
+	const idx = children.indexOf(solo);
+	if (idx >= 0) {
+		children[idx] = group;
+		state.transcriptContainer.invalidate();
+	} else state.transcriptContainer.addChild(group);
+	group.attach(solo.toolCallView.id, solo);
+	return group;
+}
+//#endregion
 //#region src/tui/actions/stream-ops.ts
 /**
 * Streaming / tool-call / compaction render hooks.
@@ -99927,11 +100995,23 @@ async function refreshPlanFromCore(state) {
 * on `state` is touched — state-ops.ts owns AppState / LivePane.
 */
 function onStreamingTextStart(state) {
+	closePendingAgentGroup(state);
+	closePendingReadGroup(state);
+	const entry = {
+		id: nextTranscriptId(),
+		kind: "assistant",
+		turnId: state.currentTurnId,
+		renderMode: "markdown",
+		content: ""
+	};
 	state.streamingComponent = new AssistantMessageComponent(state.markdownTheme, state.colors);
+	state.streamingTranscriptEntry = entry;
+	state.transcriptEntries.push(entry);
 	state.transcriptContainer.addChild(state.streamingComponent);
 	state.ui.requestRender();
 }
 function onStreamingTextUpdate(state, fullText) {
+	if (state.streamingTranscriptEntry !== void 0) state.streamingTranscriptEntry.content = fullText;
 	if (state.streamingComponent) {
 		state.streamingComponent.updateContent(fullText);
 		state.ui.requestRender();
@@ -99939,9 +101019,12 @@ function onStreamingTextUpdate(state, fullText) {
 }
 function onStreamingTextEnd(state) {
 	state.streamingComponent = void 0;
+	state.streamingTranscriptEntry = void 0;
 }
 function onThinkingUpdate(state, fullText) {
 	if (state.activeThinkingComponent === void 0) {
+		closePendingAgentGroup(state);
+		closePendingReadGroup(state);
 		state.activeThinkingComponent = new ThinkingComponent(fullText, state.colors, true, "live", state.ui);
 		state.transcriptContainer.addChild(state.activeThinkingComponent);
 	} else state.activeThinkingComponent.setText(fullText);
@@ -99958,8 +101041,14 @@ function onToolCallStart(state, toolCall) {
 	const tc = new ToolCallComponent(toolCall, void 0, state.colors, state.ui, state.markdownTheme);
 	if (state.toolOutputExpanded) tc.setExpanded(true);
 	state.pendingToolComponents.set(toolCall.id, tc);
-	state.transcriptContainer.addChild(tc);
-	state.ui.requestRender();
+	if (toolCall.name !== "Agent") closePendingAgentGroup(state);
+	if (toolCall.name !== "Read") closePendingReadGroup(state);
+	let handled = tryAttachAgentToolCall(state, toolCall, tc);
+	if (!handled) handled = tryAttachReadToolCall(state, toolCall, tc);
+	if (!handled) {
+		state.transcriptContainer.addChild(tc);
+		state.ui.requestRender();
+	}
 	if (toolCall.name === "ExitPlanMode" && typeof toolCall.args["plan"] !== "string") (async () => {
 		const snapshot = await refreshPlanFromCore(state);
 		tc.setPlanInfo(snapshot);
@@ -100342,6 +101431,9 @@ async function dispatchSlashCommand(input, state, buildCtx, addEntry) {
 //#region src/tui/handlers/turn-lifecycle.ts
 function handleTurnBegin(ectx, _data) {
 	ectx.state.streamingToolCallArguments.clear();
+	ectx.state.currentStep = 0;
+	closePendingAgentGroup(ectx.state);
+	closePendingReadGroup(ectx.state);
 	ectx.patchLivePane({
 		mode: "waiting",
 		thinkingText: "",
@@ -100360,9 +101452,15 @@ function handleTurnEnd(ectx, _data, sendQueued) {
 	const todos = ectx.state.todoPanel.getTodos();
 	if (todos.length > 0 && todos.every((t) => t.status === "done")) ectx.setTodoList([]);
 	ectx.state.streamingToolCallArguments.clear();
+	closePendingAgentGroup(ectx.state);
+	closePendingReadGroup(ectx.state);
 	finalizeTurn(ectx, sendQueued);
 }
-function handleStepBegin(ectx) {
+function handleStepBegin(ectx, data) {
+	ectx.state.currentStep = data.step;
+	closePendingAgentGroup(ectx.state);
+	closePendingReadGroup(ectx.state);
+	flushTurnBuffers(ectx, "waiting");
 	ectx.patchLivePane({
 		mode: "waiting",
 		pendingToolCall: null,
@@ -100375,6 +101473,8 @@ function handleStepBegin(ectx) {
 	});
 }
 function handleStepInterrupted(ectx, data) {
+	closePendingAgentGroup(ectx.state);
+	closePendingReadGroup(ectx.state);
 	flushTurnBuffers(ectx, "idle");
 	const reason = data.reason;
 	if (reason === "error") return;
@@ -100466,7 +101566,9 @@ function handleToolCall(ectx, data) {
 		id: data.id,
 		name: data.name,
 		args: data.args,
-		description: data.description
+		description: data.description,
+		step: ectx.state.currentStep,
+		turnId: ectx.state.currentTurnId
 	};
 	const existing = ectx.state.activeToolCalls.get(data.id);
 	ectx.state.activeToolCalls.set(data.id, toolCall);
@@ -100475,7 +101577,7 @@ function handleToolCall(ectx, data) {
 	if (existingComponent !== void 0) existingComponent.updateToolCall(toolCall);
 	else if (existing === void 0) {
 		flushTurnBuffers(ectx, "tool");
-		ectx.onToolCallStart(toolCall);
+		if (data.name !== "Agent") ectx.onToolCallStart(toolCall);
 	}
 	ectx.patchLivePane({
 		mode: "tool",
@@ -100498,13 +101600,15 @@ function handleToolCallDelta(ectx, data) {
 		id,
 		name,
 		args: parseStreamingArgs(argumentsText),
-		streamingArguments: argumentsText
+		streamingArguments: argumentsText,
+		step: ectx.state.currentStep,
+		turnId: ectx.state.currentTurnId
 	};
 	ectx.state.activeToolCalls.set(id, toolCall);
-	if (ectx.state.thinkingDraft.length > 0) flushTurnBuffers(ectx, "tool");
+	if (ectx.state.thinkingDraft.length > 0 || ectx.state.assistantStreamActive) flushTurnBuffers(ectx, "tool");
 	const existingComponent = ectx.state.pendingToolComponents.get(id);
 	if (existingComponent !== void 0) existingComponent.updateToolCall(toolCall);
-	else ectx.onToolCallStart(toolCall);
+	else if (name !== "Agent") ectx.onToolCallStart(toolCall);
 	ectx.patchLivePane({
 		mode: "tool",
 		pendingToolCall: toolCall,
@@ -100575,6 +101679,8 @@ function handleSessionMetaChanged(ectx, data) {
 	for (const fn of ectx.state.sessionMetaChangedListeners) fn(data);
 }
 function handleSessionError(ectx, data) {
+	closePendingAgentGroup(ectx.state);
+	closePendingReadGroup(ectx.state);
 	flushTurnBuffers(ectx, "idle");
 	const detail = data.error_type !== void 0 ? ` (${data.error_type})` : "";
 	ectx.addTranscriptEntry(makeEntry(ectx, "status", `Error${detail}: ${data.error}`, "plain", { color: ectx.colors.error }));
@@ -100643,7 +101749,7 @@ function dispatchEvent(event, ectx, sendQueued) {
 			handleTurnEnd(ectx, event.data, sendQueued);
 			break;
 		case "step.begin":
-			handleStepBegin(ectx);
+			handleStepBegin(ectx, event.data);
 			break;
 		case "step.interrupted":
 			handleStepInterrupted(ectx, event.data);