kfc-code-cli 0.0.1-alpha.13 → 0.0.1-alpha.15

package/dist/main.mjs

@@ -183,75 +183,894 @@ var ContextStateBrokenError = class extends Error {
 	}
 };
 //#endregion
-//#region ../../packages/kimi-core/src/storage/journal/writer.ts
-/**
-* Record types the compaction path itself is allowed to write while the
-* lifecycle gate is in `compacting` state (§5.1.7 / v2 L2663-L2690).
-*
-* Background (Slice 6 audit M02): every non-compaction write is drained
-* during `compacting` so the in-flight compaction is not racing against
-* new Soul output. But compaction still needs to persist its own
-* `CompactionRecord` via `context.resetToSummary()`, which goes through
-* the same `JournalWriter.append()` entry point. Blanket-rejecting all
-* writes in `compacting` would deadlock compaction against itself, so
-* this whitelist names the record types that are considered
-* "compaction's own writes" and allowed through the gate.
-*
-* Keep this list narrow: only record types that are *only* emitted from
-* inside `TurnManager.executeCompaction` (Phase 2; previously
-* `runCompaction`) belong here. Any future compaction-path record
-* must be added explicitly.
-*/
-const COMPACTION_OWN_WRITE_TYPES = new Set(["compaction", "session_initialized"]);
+//#region ../../packages/kimi-core/src/storage/schema/records.ts
 /**
-* Record types that must be durable on disk before `append()` resolves
-* (§4.5.4 — force-flush kinds). Recovery-critical boundary markers live
-* here: their absence at replay time breaks the contracts §9.x relies on.
-*
-* Declared as `ReadonlySet<string>` so we can include future union-member
-* strings (e.g. `subagent_completed` / `subagent_failed` from the
-* subagent slice) without forcing an out-of-slice edit to `WireRecord`.
+* Fallback producer identity used when the host hasn't supplied one.
+* Version marker makes unset state easy to spot in field reports.
 */
-const FORCE_FLUSH_KINDS = new Set([
-	"approval_response",
-	"turn_end",
-	"subagent_completed",
-	"subagent_failed",
-	"session_initialized",
-	"context_cleared",
-	"tools_changed"
+const DEFAULT_PRODUCER = {
+	kind: "typescript",
+	name: "@moonshot-ai/core",
+	version: "0.0.0-unset"
+};
+const agentTypeEnum = z.enum([
+	"main",
+	"sub",
+	"independent"
 ]);
-const DEFAULT_PROTOCOL_VERSION = "2.1";
+const _rawWireProducerSchema = z.object({
+	kind: z.enum(["python", "typescript"]),
+	name: z.string(),
+	version: z.string()
+});
+const WireFileMetadataSchema = z.object({
+	type: z.literal("metadata"),
+	protocol_version: z.string(),
+	created_at: z.number(),
+	kimi_version: z.string().optional(),
+	producer: _rawWireProducerSchema.optional()
+});
+const _rawTurnBeginRecordSchema = z.object({
+	type: z.literal("turn_begin"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	agent_type: agentTypeEnum,
+	user_input: z.string().optional(),
+	input_kind: z.enum(["user", "system_trigger"]),
+	trigger_source: z.string().optional()
+});
+const _rawTurnEndRecordSchema = z.object({
+	type: z.literal("turn_end"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	agent_type: agentTypeEnum,
+	success: z.boolean(),
+	reason: z.enum([
+		"done",
+		"cancelled",
+		"error",
+		"interrupted"
+	]),
+	usage: z.object({
+		input_tokens: z.number(),
+		output_tokens: z.number(),
+		cache_read_tokens: z.number().optional(),
+		cache_write_tokens: z.number().optional(),
+		cost_usd: z.number().optional()
+	}).optional(),
+	synthetic: z.boolean().optional()
+});
+const _userInputPartSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("image_url"),
+		image_url: z.object({ url: z.string() })
+	}),
+	z.object({
+		type: z.literal("video_url"),
+		video_url: z.object({ url: z.string() })
+	})
+]);
+const _rawUserMessageRecordSchema = z.object({
+	type: z.literal("user_message"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	content: z.union([z.string(), z.array(_userInputPartSchema).readonly()]),
+	uuid: z.string().optional()
+});
+const _rawToolResultRecordSchema = z.object({
+	type: z.literal("tool_result"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	tool_call_id: z.string(),
+	output: z.unknown(),
+	is_error: z.boolean().optional(),
+	synthetic: z.boolean().optional(),
+	uuid: z.string().optional(),
+	parent_uuid: z.string().optional()
+});
+const _rawCompactionRecordSchema = z.object({
+	type: z.literal("compaction"),
+	seq: z.number(),
+	time: z.number(),
+	summary: z.string(),
+	compacted_range: z.object({
+		from_turn: z.number(),
+		to_turn: z.number(),
+		message_count: z.number()
+	}),
+	pre_compact_tokens: z.number(),
+	post_compact_tokens: z.number(),
+	trigger: z.enum(["auto", "manual"]),
+	archive_file: z.string().optional(),
+	uuid: z.string().optional()
+});
+const _rawSystemPromptChangedRecordSchema = z.object({
+	type: z.literal("system_prompt_changed"),
+	seq: z.number(),
+	time: z.number(),
+	new_prompt: z.string()
+});
+const _rawToolsChangedRecordSchema = z.object({
+	type: z.literal("tools_changed"),
+	seq: z.number(),
+	time: z.number(),
+	operation: z.enum([
+		"register",
+		"remove",
+		"set_active"
+	]),
+	tools: z.array(z.string())
+});
+const _rawSystemReminderRecordSchema = z.object({
+	type: z.literal("system_reminder"),
+	seq: z.number(),
+	time: z.number(),
+	content: z.string(),
+	consumed_at_turn: z.number().optional()
+});
+const _rawNotificationRecordSchema = z.object({
+	type: z.literal("notification"),
+	seq: z.number(),
+	time: z.number(),
+	data: z.object({
+		id: z.string(),
+		category: z.enum([
+			"task",
+			"agent",
+			"system",
+			"team"
+		]),
+		type: z.string(),
+		source_kind: z.string(),
+		source_id: z.string(),
+		title: z.string(),
+		body: z.string(),
+		severity: z.enum([
+			"info",
+			"success",
+			"warning",
+			"error"
+		]),
+		payload: z.record(z.string(), z.unknown()).optional(),
+		targets: z.array(z.enum([
+			"llm",
+			"wire",
+			"shell"
+		])),
+		dedupe_key: z.string().optional(),
+		delivered_at: z.object({
+			llm: z.number().optional(),
+			wire: z.number().optional(),
+			shell: z.number().optional()
+		}).optional(),
+		envelope_id: z.string().optional()
+	})
+});
+const _rawToolDeniedRecordSchema = z.object({
+	type: z.literal("tool_denied"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	step: z.number(),
+	data: z.object({
+		tool_call_id: z.string(),
+		tool_name: z.string(),
+		rule_id: z.string(),
+		reason: z.string()
+	})
+});
+const _rawStepBeginRecordSchema = z.object({
+	type: z.literal("step_begin"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string(),
+	turn_id: z.string(),
+	step: z.number()
+});
+const _rawStepEndRecordSchema = z.object({
+	type: z.literal("step_end"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string(),
+	turn_id: z.string(),
+	step: z.number(),
+	usage: z.object({
+		input_tokens: z.number(),
+		output_tokens: z.number(),
+		cache_read_tokens: z.number().optional(),
+		cache_write_tokens: z.number().optional()
+	}).optional(),
+	finish_reason: z.string().optional()
+});
+const _contentPartBodySchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("text"),
+	text: z.string()
+}), z.object({
+	kind: z.literal("think"),
+	think: z.string(),
+	encrypted: z.string().optional()
+})]);
+const _rawContentPartRecordSchema = z.object({
+	type: z.literal("content_part"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string(),
+	turn_id: z.string(),
+	step: z.number(),
+	step_uuid: z.string(),
+	role: z.literal("assistant"),
+	part: _contentPartBodySchema
+});
+const _rawToolCallRecordSchema = z.object({
+	type: z.literal("tool_call"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string(),
+	turn_id: z.string(),
+	step: z.number(),
+	step_uuid: z.string(),
+	data: z.object({
+		tool_call_id: z.string(),
+		tool_name: z.string(),
+		args: z.unknown(),
+		activity_description: z.string().optional(),
+		user_facing_name: z.string().optional(),
+		input_display: z.unknown().optional()
+	})
+});
 /**
-* Chains work onto a single promise so all callers are serialised in the
-* order `run` was invoked, regardless of when each task resolves.
+* Storage persists the approval display as an opaque blob. Write-trust
+* / read-passthrough: the concrete `ToolInputDisplay` union lives in
+* `display/` and is the responsibility of the host layer to validate
+* at render time.
 */
-var AsyncSerialQueue = class {
-	tail = Promise.resolve();
-	run(task) {
-		const next = this.tail.then(task, task);
-		this.tail = next.catch(() => {});
-		return next;
-	}
+const ApprovalDisplaySchema = z.unknown();
+const ApprovalSourceSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("soul"),
+		agent_id: z.string()
+	}),
+	z.object({
+		kind: z.literal("subagent"),
+		agent_id: z.string(),
+		subagent_type: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("turn"),
+		turn_id: z.string()
+	}),
+	z.object({
+		kind: z.literal("session"),
+		session_id: z.string()
+	}),
+	z.object({
+		kind: z.literal("mcp"),
+		server_id: z.string(),
+		reason: z.enum([
+			"elicitation",
+			"auth",
+			"tool_call"
+		])
+	})
+]);
+const skillInvocationTriggerEnum = z.enum([
+	"user-slash",
+	"claude-proactive",
+	"nested-skill"
+]);
+const _rawSkillInvokedRecordSchema = z.object({
+	type: z.literal("skill_invoked"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	agent_type: agentTypeEnum.optional(),
+	data: z.object({
+		skill_name: z.string(),
+		execution_mode: z.enum(["inline", "fork"]),
+		original_input: z.string(),
+		sub_agent_id: z.string().optional(),
+		invocation_trigger: skillInvocationTriggerEnum.optional(),
+		query_depth: z.number().optional()
+	})
+});
+const _rawSkillCompletedRecordSchema = z.object({
+	type: z.literal("skill_completed"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	agent_type: agentTypeEnum.optional(),
+	data: z.object({
+		skill_name: z.string(),
+		execution_mode: z.enum(["inline", "fork"]),
+		success: z.boolean(),
+		error: z.string().optional(),
+		sub_agent_id: z.string().optional(),
+		invocation_trigger: skillInvocationTriggerEnum.optional(),
+		query_depth: z.number().optional()
+	})
+});
+const _rawApprovalRequestRecordSchema = z.object({
+	type: z.literal("approval_request"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	step: z.number(),
+	data: z.object({
+		request_id: z.string(),
+		tool_call_id: z.string(),
+		tool_name: z.string(),
+		action: z.string(),
+		display: ApprovalDisplaySchema,
+		source: ApprovalSourceSchema
+	})
+});
+const _rawApprovalResponseRecordSchema = z.object({
+	type: z.literal("approval_response"),
+	seq: z.number(),
+	time: z.number(),
+	turn_id: z.string(),
+	step: z.number(),
+	data: z.object({
+		request_id: z.string(),
+		response: z.enum([
+			"approved",
+			"rejected",
+			"cancelled"
+		]),
+		feedback: z.string().optional(),
+		selected_label: z.string().optional(),
+		synthetic: z.boolean().optional()
+	})
+});
+const _rawTeamMailRecordSchema = z.object({
+	type: z.literal("team_mail"),
+	seq: z.number(),
+	time: z.number(),
+	data: z.object({
+		mail_id: z.string(),
+		reply_to: z.string().optional(),
+		from_agent: z.string(),
+		to_agent: z.string(),
+		content: z.string(),
+		summary: z.string().optional()
+	})
+});
+const _rawTokenUsageSchema = z.object({
+	input: z.number().int().nonnegative(),
+	output: z.number().int().nonnegative(),
+	cache_read: z.number().int().nonnegative().optional(),
+	cache_write: z.number().int().nonnegative().optional()
+});
+const _rawSubagentSpawnedRecordSchema = z.object({
+	type: z.literal("subagent_spawned"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string().optional(),
+	data: z.object({
+		agent_id: z.string(),
+		agent_name: z.string().optional(),
+		parent_tool_call_id: z.string(),
+		parent_agent_id: z.string().optional(),
+		parent_tool_call_uuid: z.string().optional(),
+		run_in_background: z.boolean()
+	})
+});
+const _rawSubagentCompletedRecordSchema = z.object({
+	type: z.literal("subagent_completed"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string().optional(),
+	parent_uuid: z.string().optional(),
+	data: z.object({
+		agent_id: z.string(),
+		parent_tool_call_id: z.string(),
+		result_summary: z.string(),
+		usage: _rawTokenUsageSchema.optional()
+	})
+});
+const _rawSubagentFailedRecordSchema = z.object({
+	type: z.literal("subagent_failed"),
+	seq: z.number(),
+	time: z.number(),
+	uuid: z.string().optional(),
+	parent_uuid: z.string().optional(),
+	data: z.object({
+		agent_id: z.string(),
+		parent_tool_call_id: z.string(),
+		error: z.string()
+	})
+});
+const _rawOwnershipChangedRecordSchema = z.object({
+	type: z.literal("ownership_changed"),
+	seq: z.number(),
+	time: z.number(),
+	old_owner: z.string().nullable(),
+	new_owner: z.string()
+});
+const _rawContextEditRecordSchema = z.object({
+	type: z.literal("context_edit"),
+	seq: z.number(),
+	time: z.number(),
+	operation: z.enum([
+		"edit_message",
+		"delete_message",
+		"rewind",
+		"insert_message",
+		"replace_message"
+	]),
+	target_seq: z.number().optional(),
+	to_turn: z.number().optional(),
+	after_seq: z.number().optional(),
+	new_content: z.string().optional(),
+	new_role: z.enum([
+		"user",
+		"assistant",
+		"system"
+	]).optional(),
+	cascade: z.boolean().optional()
+});
+const _rawContextClearedRecordSchema = z.object({
+	type: z.literal("context_cleared"),
+	seq: z.number(),
+	time: z.number()
+});
+const _sessionInitializedCommonShape = {
+	type: z.literal("session_initialized"),
+	seq: z.number(),
+	time: z.number(),
+	system_prompt: z.string(),
+	active_tools: z.array(z.string()),
+	model: z.string().optional(),
+	permission_mode: z.enum([
+		"default",
+		"acceptEdits",
+		"bypassPermissions"
+	]).optional(),
+	plan_mode: z.boolean().optional(),
+	workspace_dir: z.string().optional(),
+	thinking_level: z.string().optional()
 };
-/** Real fs-backed JournalWriter. */
-var WiredJournalWriter = class {
-	filePath;
-	lifecycle;
-	producer;
-	protocolVersion;
-	kimiVersion;
-	now;
-	queue = new AsyncSerialQueue();
-	seq = 0;
-	metadataWritten = false;
-	/**
-	* Tracks whether the parent directory entry for `filePath` has been
-	* fsynced. Under POSIX semantics, `fh.sync()` flushes file *contents* but
-	* does not guarantee the directory entry for a freshly created file has
-	* been durably committed — a crash between the first append and the next
-	* parent-directory fsync can leave the file's contents on disk with no
-	* visible dirent. We fsync the parent directory once, after the first
+const _rawSessionInitializedMainSchema = z.object({
+	..._sessionInitializedCommonShape,
+	agent_type: z.literal("main"),
+	session_id: z.string()
+});
+const _rawSessionInitializedSubSchema = z.object({
+	..._sessionInitializedCommonShape,
+	agent_type: z.literal("sub"),
+	agent_id: z.string(),
+	agent_name: z.string().optional(),
+	parent_session_id: z.string(),
+	parent_agent_id: z.string().optional(),
+	parent_tool_call_id: z.string(),
+	run_in_background: z.boolean()
+});
+const _rawSessionInitializedIndependentSchema = z.object({
+	..._sessionInitializedCommonShape,
+	agent_type: z.literal("independent"),
+	agent_id: z.string(),
+	agent_name: z.string().optional()
+});
+const _rawSessionInitializedRecordSchema = z.discriminatedUnion("agent_type", [
+	_rawSessionInitializedMainSchema,
+	_rawSessionInitializedSubSchema,
+	_rawSessionInitializedIndependentSchema
+]);
+const SessionInitializedRecordSchema = _rawSessionInitializedRecordSchema;
+const WireRecordSchema = z.discriminatedUnion("type", [
+	_rawTurnBeginRecordSchema,
+	_rawTurnEndRecordSchema,
+	_rawUserMessageRecordSchema,
+	_rawToolResultRecordSchema,
+	_rawCompactionRecordSchema,
+	_rawSystemPromptChangedRecordSchema,
+	_rawToolsChangedRecordSchema,
+	_rawSystemReminderRecordSchema,
+	_rawNotificationRecordSchema,
+	_rawToolDeniedRecordSchema,
+	_rawStepBeginRecordSchema,
+	_rawStepEndRecordSchema,
+	_rawContentPartRecordSchema,
+	_rawToolCallRecordSchema,
+	_rawSkillInvokedRecordSchema,
+	_rawSkillCompletedRecordSchema,
+	_rawApprovalRequestRecordSchema,
+	_rawApprovalResponseRecordSchema,
+	_rawTeamMailRecordSchema,
+	_rawSubagentSpawnedRecordSchema,
+	_rawSubagentCompletedRecordSchema,
+	_rawSubagentFailedRecordSchema,
+	_rawOwnershipChangedRecordSchema,
+	_rawContextEditRecordSchema,
+	_rawContextClearedRecordSchema,
+	_rawSessionInitializedRecordSchema
+]);
+//#endregion
+//#region ../../packages/kimi-core/src/storage/journal/reader.ts
+async function defaultReadLines(path) {
+	const parts = (await readFile(path, "utf8")).split("\n");
+	if (parts.length > 0 && parts.at(-1) === "") parts.pop();
+	return parts;
+}
+/**
+* Replay a wire.jsonl into an ordered list of valid WireRecords plus a
+* health signal. Does not construct a ContextState — that concern lives in
+* WiredContextState which drives its internal mirror from these records.
+*
+* Error policy (§4.1.1 / §8.4):
+*   - unknown record type at any line → skip + warn
+*   - JSON.parse failure on the LAST body line → skip + warn (tail truncation)
+*   - JSON.parse failure on any earlier line → health = 'broken'
+*   - major version higher than supportedMajor → throw IncompatibleVersionError
+*/
+async function replayWire(path, options) {
+	const lines = await (options.readLines ?? defaultReadLines)(path);
+	if (lines.length === 0) throw new WireJournalCorruptError(`wire.jsonl is empty at ${path}`);
+	const firstLine = lines[0];
+	if (firstLine === void 0) throw new WireJournalCorruptError(`wire.jsonl is empty at ${path}`);
+	let meta;
+	try {
+		meta = WireFileMetadataSchema.parse(JSON.parse(firstLine));
+	} catch (error) {
+		throw new WireJournalCorruptError(`wire.jsonl metadata header (line 1) is invalid: ${String(error)}`);
+	}
+	const majorStr = meta.protocol_version.split(".")[0] ?? "0";
+	const major = Number.parseInt(majorStr, 10);
+	if (!Number.isFinite(major)) throw new IncompatibleVersionError(`wire.jsonl metadata.protocol_version "${meta.protocol_version}" is not a valid version string`);
+	if (major > options.supportedMajor) throw new IncompatibleVersionError(`wire.jsonl version ${meta.protocol_version} is not supported (max major: ${options.supportedMajor}). Please upgrade Kimi CLI.`);
+	if (meta.producer === void 0) throw new UnsupportedProducerError("legacy", "metadata-missing-producer");
+	if (meta.producer.kind !== "typescript") throw new UnsupportedProducerError(meta.producer.kind === "python" ? "python" : "unknown", "cross-producer-not-supported");
+	const producer = meta.producer;
+	const initLine = lines[1];
+	if (initLine === void 0) throw new MalformedWireError("session-initialized-missing", `wire.jsonl has no line 2 (session_initialized) at ${path}`);
+	let initRaw;
+	try {
+		initRaw = JSON.parse(initLine);
+	} catch (error) {
+		throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 failed JSON.parse: ${String(error)}`);
+	}
+	const initTypeField = initRaw?.type;
+	if (initTypeField !== "session_initialized") throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 has type="${String(initTypeField)}"; expected "session_initialized"`);
+	const initParsed = SessionInitializedRecordSchema.safeParse(initRaw);
+	if (!initParsed.success) throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 failed zod parse: ${initParsed.error.message}`);
+	const sessionInitialized = initParsed.data;
+	const records = [];
+	const warnings = [];
+	const bodyLines = lines.slice(2);
+	for (const [i, line] of bodyLines.entries()) {
+		const physicalLineNo = i + 3;
+		const isLastLine = i === bodyLines.length - 1;
+		const snippet = line.slice(0, 100);
+		let raw;
+		try {
+			raw = JSON.parse(line);
+		} catch (error) {
+			if (isLastLine) {
+				warnings.push(`Tail line truncated at line ${physicalLineNo}, skipping: ${snippet}`);
+				continue;
+			}
+			const reason = `wire.jsonl mid-file corruption at line ${physicalLineNo}: ${String(error)}`;
+			return {
+				records,
+				protocolVersion: meta.protocol_version,
+				health: "broken",
+				brokenReason: reason,
+				warnings,
+				producer,
+				sessionInitialized
+			};
+		}
+		const typeField = raw?.type;
+		if (typeField === "session_initialized") throw new MalformedWireError("session-initialized-position-wrong", `wire.jsonl has a session_initialized record at line ${physicalLineNo}; only line 2 is permitted`);
+		if (typeof typeField !== "string" || !KNOWN_RECORD_TYPES.has(typeField)) {
+			if (typeof typeField === "string" && LEGACY_RECORD_TYPES.has(typeField)) warnings.push(`Skipping legacy record type "${typeField}" at line ${physicalLineNo} (migrated to state.json)`);
+			else warnings.push(`Skipping unrecognized record type "${String(typeField)}" at line ${physicalLineNo}: ${snippet}`);
+			continue;
+		}
+		const parsed = WireRecordSchema.safeParse(raw);
+		if (!parsed.success) {
+			if (isLastLine) {
+				warnings.push(`Tail record failed schema validation at line ${physicalLineNo}, skipping: ${snippet}`);
+				continue;
+			}
+			const reason = `wire.jsonl schema violation at line ${physicalLineNo}: ${parsed.error.message}`;
+			return {
+				records,
+				protocolVersion: meta.protocol_version,
+				health: "broken",
+				brokenReason: reason,
+				warnings,
+				producer,
+				sessionInitialized
+			};
+		}
+		records.push(parsed.data);
+	}
+	return {
+		records,
+		protocolVersion: meta.protocol_version,
+		health: "ok",
+		warnings,
+		producer,
+		sessionInitialized
+	};
+}
+const KNOWN_RECORD_TYPES = new Set([
+	"turn_begin",
+	"turn_end",
+	"user_message",
+	"tool_result",
+	"compaction",
+	"system_prompt_changed",
+	"tools_changed",
+	"system_reminder",
+	"notification",
+	"tool_denied",
+	"step_begin",
+	"step_end",
+	"content_part",
+	"tool_call",
+	"skill_invoked",
+	"skill_completed",
+	"approval_request",
+	"approval_response",
+	"team_mail",
+	"subagent_spawned",
+	"subagent_completed",
+	"subagent_failed",
+	"ownership_changed",
+	"context_edit",
+	"context_cleared"
+]);
+/**
+* Record types that earlier schema versions persisted to `wire.jsonl`
+* but have since been migrated to `state.json` as the truth source.
+*
+* Sessions written by older binaries still carry rows of these types.
+* Keeping them in a dedicated set lets the replay loop emit an
+* informational "legacy" warning instead of the forward-compat
+* "unrecognized" warning, so it is clear these rows are expected to be
+* dropped rather than being an unknown future-version type.
+*/
+const LEGACY_RECORD_TYPES = new Set([
+	"permission_mode_changed",
+	"model_changed",
+	"thinking_changed",
+	"plan_mode_changed",
+	"session_meta_changed"
+]);
+//#endregion
+//#region ../../packages/kimi-core/src/storage/journal/rotation.ts
+/**
+* Storage-layer compaction utilities — file rotation and cross-file replay
+* (§4.7 / §4.1.1).
+*
+* File rotation is the physical counterpart to TurnManager's
+* `executeCompaction` (Phase 2; previously Soul's `runCompaction`):
+*   1. Rename `wire.jsonl` → `wire.N.jsonl` (frozen archive)
+*   2. Create new `wire.jsonl` with metadata header + CompactionRecord
+*
+* Cross-file replay reads all wire files in a session directory
+* (wire.N.jsonl → ... → wire.1.jsonl → wire.jsonl) and produces a
+* unified record stream.
+*
+* Crash recovery detects "wire.jsonl missing but wire.N.jsonl exists"
+* and rolls back the lowest-numbered archive to `wire.jsonl`.
+*/
+const ARCHIVE_PATTERN = /^wire\.(\d+)\.jsonl$/;
+function extractArchiveNumber(name) {
+	const captured = ARCHIVE_PATTERN.exec(name)?.[1];
+	return captured !== void 0 ? Number.parseInt(captured, 10) : 0;
+}
+/**
+* Compute the next archive filename for a rotation:
+*   - No archives exist → `wire.1.jsonl`
+*   - Highest existing is `wire.3.jsonl` → `wire.4.jsonl`
+*/
+function nextArchiveName(sessionDir, existingArchives) {
+	let maxN = 0;
+	for (const archive of existingArchives) {
+		const n = extractArchiveNumber(archive);
+		if (n > maxN) maxN = n;
+	}
+	return join(sessionDir, `wire.${maxN + 1}.jsonl`);
+}
+async function rotateJournal(sessionDir, options) {
+	const { producer, protocolVersion, ...deps } = options;
+	const version = protocolVersion ?? "2.1";
+	const currentPath = join(sessionDir, "wire.jsonl");
+	const archivePath = nextArchiveName(sessionDir, (await readdir(sessionDir)).filter((e) => ARCHIVE_PATTERN.test(e)));
+	const renameFn = deps.renameFn ?? rename;
+	const retryDelayMs = deps.retryDelayMs ?? 500;
+	try {
+		await renameFn(currentPath, archivePath);
+	} catch (error) {
+		const code = error.code;
+		if (process.platform === "win32" && code === "EPERM") {
+			await new Promise((resolve, reject) => {
+				const timer = setTimeout(resolve, retryDelayMs);
+				const abortSignal = deps.signal;
+				if (abortSignal !== void 0) {
+					const onAbort = () => {
+						clearTimeout(timer);
+						reject(abortSignal.reason ?? /* @__PURE__ */ new Error("aborted"));
+					};
+					if (abortSignal.aborted) onAbort();
+					else abortSignal.addEventListener("abort", onAbort, { once: true });
+				}
+			});
+			await renameFn(currentPath, archivePath);
+		} else throw error;
+	}
+	await writeFileAtomicDurable(currentPath, JSON.stringify({
+		type: "metadata",
+		protocol_version: version,
+		created_at: Date.now(),
+		producer,
+		kimi_version: producer.version
+	}) + "\n");
+	await syncDir(sessionDir);
+	return {
+		archivePath,
+		newCurrentPath: currentPath
+	};
+}
+/**
+* Find the highest-numbered archive in a list of archive filenames.
+* Returns the filename and its number, or `undefined` if the list is empty.
+*/
+function findHighestArchive(archives) {
+	let highestN = 0;
+	let result;
+	for (const name of archives) {
+		const n = extractArchiveNumber(name);
+		if (n > highestN) {
+			highestN = n;
+			result = name;
+		}
+	}
+	return result !== void 0 ? {
+		name: result,
+		n: highestN
+	} : void 0;
+}
+/**
+* Detect and recover from a crash between file rotation steps.
+*
+* Three scenarios are handled:
+*
+* 1. **wire.jsonl missing**: `wire.jsonl` was renamed to `wire.N.jsonl`
+*    but the process crashed before the new `wire.jsonl` was created.
+*    Recovery: roll back the highest-numbered archive to `wire.jsonl`.
+*
+* 2. **wire.jsonl is metadata-only** (Slice 3.3 / M04): the rename
+*    succeeded AND the new `wire.jsonl` was created with a metadata
+*    header, but the process crashed before `appendBoundary` ran. The
+*    new file has only the metadata line — no session_initialized, no
+*    compaction record. Recovery: remove the half-complete file and
+*    roll back the highest archive.
+*
+* 3. **wire.jsonl has metadata + session_initialized only** (Phase 23 /
+*    T7.7): `appendBoundary` copied `session_initialized` through as the
+*    second line, but the process crashed before the compaction record
+*    landed. Without the compaction record, the archived conversation is
+*    orphaned — replay of the new wire would show an empty post-boundary
+*    window and the archive would never be re-read. Recovery: same as
+*    case 2 — remove the half-complete file and restore the archive.
+*
+* Returns `true` if recovery was performed, `false` if no recovery was needed.
+*/
+async function recoverRotation(sessionDir) {
+	const entries = await readdir(sessionDir);
+	const archives = entries.filter((e) => ARCHIVE_PATTERN.test(e));
+	if (!entries.includes("wire.jsonl")) {
+		const highest = findHighestArchive(archives);
+		if (highest === void 0) return false;
+		await rename(join(sessionDir, highest.name), join(sessionDir, "wire.jsonl"));
+		return true;
+	}
+	if (archives.length > 0) {
+		const currentPath = join(sessionDir, "wire.jsonl");
+		const lines = (await readFile(currentPath, "utf8")).trim().split("\n").filter((l) => l.length > 0);
+		if (lines.length === 1 || lines.length === 2) {
+			const parsedLines = lines.map((l) => {
+				try {
+					return JSON.parse(l);
+				} catch {
+					return null;
+				}
+			});
+			const isMetadata = parsedLines[0]?.["type"] === "metadata";
+			if (lines.length === 1 ? isMetadata : isMetadata && parsedLines[1]?.["type"] === "session_initialized") {
+				const highest = findHighestArchive(archives);
+				if (highest !== void 0) {
+					await unlink(currentPath);
+					await rename(join(sessionDir, highest.name), join(sessionDir, "wire.jsonl"));
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+//#endregion
+//#region ../../packages/kimi-core/src/storage/journal/writer.ts
+/**
+* Record types the compaction path itself is allowed to write while the
+* lifecycle gate is in `compacting` state (§5.1.7 / v2 L2663-L2690).
+*
+* Background (Slice 6 audit M02): every non-compaction write is drained
+* during `compacting` so the in-flight compaction is not racing against
+* new Soul output. But compaction still needs to persist its own
+* `CompactionRecord` via `context.resetToSummary()`, which goes through
+* the same `JournalWriter.append()` entry point. Blanket-rejecting all
+* writes in `compacting` would deadlock compaction against itself, so
+* this whitelist names the record types that are considered
+* "compaction's own writes" and allowed through the gate.
+*
+* Keep this list narrow: only record types that are *only* emitted from
+* inside `TurnManager.executeCompaction` (Phase 2; previously
+* `runCompaction`) belong here. Any future compaction-path record
+* must be added explicitly.
+*/
+const COMPACTION_OWN_WRITE_TYPES = new Set(["compaction", "session_initialized"]);
+/**
+* Record types that must be durable on disk before `append()` resolves
+* (§4.5.4 — force-flush kinds). Recovery-critical boundary markers live
+* here: their absence at replay time breaks the contracts §9.x relies on.
+*
+* Declared as `ReadonlySet<string>` so we can include future union-member
+* strings (e.g. `subagent_completed` / `subagent_failed` from the
+* subagent slice) without forcing an out-of-slice edit to `WireRecord`.
+*/
+const FORCE_FLUSH_KINDS = new Set([
+	"approval_response",
+	"turn_end",
+	"subagent_completed",
+	"subagent_failed",
+	"session_initialized",
+	"context_cleared",
+	"tools_changed"
+]);
+const DEFAULT_PROTOCOL_VERSION = "2.1";
+/**
+* Chains work onto a single promise so all callers are serialised in the
+* order `run` was invoked, regardless of when each task resolves.
+*/
+var AsyncSerialQueue = class {
+	tail = Promise.resolve();
+	run(task) {
+		const next = this.tail.then(task, task);
+		this.tail = next.catch(() => {});
+		return next;
+	}
+};
+/** Real fs-backed JournalWriter. */
+var WiredJournalWriter = class {
+	filePath;
+	lifecycle;
+	producer;
+	protocolVersion;
+	kimiVersion;
+	now;
+	queue = new AsyncSerialQueue();
+	seq = 0;
+	metadataWritten = false;
+	/**
+	* Tracks whether the parent directory entry for `filePath` has been
+	* fsynced. Under POSIX semantics, `fh.sync()` flushes file *contents* but
+	* does not guarantee the directory entry for a freshly created file has
+	* been durably committed — a crash between the first append and the next
+	* parent-directory fsync can leave the file's contents on disk with no
+	* visible dirent. We fsync the parent directory once, after the first
 	* successful write, and never again for the lifetime of this writer.
 	*/
 	directorySynced = false;
@@ -296,6 +1115,32 @@ var WiredJournalWriter = class {
 	get pendingRecords() {
 		return this.pending;
 	}
+	get sessionDir() {
+		return dirname(this.filePath);
+	}
+	get rotateCapability() {
+		return {
+			sessionDir: this.sessionDir,
+			rotate: async () => {
+				await this.flush();
+				const result = await rotateJournal(this.sessionDir, { producer: this.producer });
+				this.resetForRotation();
+				return result;
+			},
+			readSessionInitialized: async () => {
+				const lines = (await readFile(this.filePath, "utf-8")).split("\n").filter((l) => l.length > 0);
+				if (lines.length < 2) throw new Error(`readSessionInitialized: wire.jsonl at ${this.filePath} has fewer than 2 lines`);
+				const parsed = JSON.parse(lines[1]);
+				const result = SessionInitializedRecordSchema.safeParse(parsed);
+				if (!result.success) throw new Error(`readSessionInitialized: wire.jsonl line 2 at ${this.filePath} is not a valid session_initialized record: ${result.error.message}`);
+				return result.data;
+			},
+			appendBoundary: async (sessionInitialized) => {
+				const { seq: _seq, time: _time, ...input } = sessionInitialized;
+				await this.append(input);
+			}
+		};
+	}
 	/**
 	* Reset writer state after a compaction rotation (Slice 3.3 / M04).
 	*
@@ -306,9 +1151,6 @@ var WiredJournalWriter = class {
 	* mark it as written. The new file's directory entry was durably
 	* committed by `rotateJournal`'s `syncDir`, so `directorySynced` is
 	* also set.
-	*
-	* Only the compaction path (via `WiredJournalCapability`) should call
-	* this method — normal appends must never touch the seq counter.
 	*/
 	resetForRotation() {
 		this.seq = 0;
@@ -453,7 +1295,7 @@ var WiredJournalWriter = class {
 		}
 	}
 	async ensureDir() {
-		await mkdir(dirname(this.filePath), { recursive: true });
+		await mkdir(this.sessionDir, { recursive: true });
 	}
 	async writeAndSync(line) {
 		const fh = await open(this.filePath, "a");
@@ -487,7 +1329,7 @@ var WiredJournalWriter = class {
 	}
 	/** Async parent-directory fsync. Tests may spy on this method by name. */
 	async syncParentDir() {
-		await syncDir(dirname(this.filePath));
+		await syncDir(this.sessionDir);
 	}
 };
 /** No-op writer used by InMemory state implementations. */
@@ -546,1492 +1388,673 @@ var ContextStateMemory = class {
 	get tokenCountWithPending() {
 		return this._tokenCountWithPending;
 	}
-	get thinkingLevel() {
-		return this._thinkingLevel;
-	}
-	get beforeStep() {
-		return this._beforeStep;
-	}
-	setBeforeStepHook(fn) {
-		this._beforeStep = fn;
-	}
-	getHistory() {
-		return this.history;
-	}
-	drainSteerMessages() {
-		const drained = this.steerBuffer;
-		this.steerBuffer = [];
-		return drained;
-	}
-	pushSteer(input) {
-		this.steerBuffer.push({ ...input });
-	}
-	appendUserContent(content) {
-		this.history.push({
-			role: "user",
-			content,
-			toolCalls: []
-		});
-	}
-	appendToolResult(toolCallId, content) {
-		this.history.push({
-			role: "tool",
-			content,
-			toolCalls: [],
-			toolCallId
-		});
-	}
-	openStep(uuid) {
-		const message = {
-			role: "assistant",
-			content: [],
-			toolCalls: []
-		};
-		this.history.push(message);
-		this.openSteps.set(uuid, message);
-	}
-	closeStep(uuid, usage) {
-		this.openSteps.delete(uuid);
-		if (usage !== void 0) this._tokenCountWithPending = usage.input_tokens + usage.output_tokens;
-	}
-	getOpenStep(uuid) {
-		return this.openSteps.get(uuid);
-	}
-	appendOpenStepContent(stepUuid, part) {
-		this.openSteps.get(stepUuid)?.content.push(part);
-	}
-	appendOpenStepToolCall(stepUuid, toolCall) {
-		this.openSteps.get(stepUuid)?.toolCalls.push(toolCall);
-	}
-	clearConversation() {
-		this.history = [];
-		this.openSteps.clear();
-		this._tokenCountWithPending = 0;
-	}
-	setSystemPrompt(systemPrompt) {
-		this._systemPrompt = systemPrompt;
-	}
-	setModel(model) {
-		this._model = model;
-	}
-	setThinkingLevel(level) {
-		this._thinkingLevel = level;
-	}
-	applyToolsChanged(operation, tools) {
-		if (operation === "set_active") {
-			this._activeTools = new Set(tools);
-			return;
-		}
-		if (operation === "register") {
-			for (const tool of tools) this._activeTools.add(tool);
-			return;
-		}
-		for (const tool of tools) this._activeTools.delete(tool);
-	}
-	resetToSummary(summary) {
-		this.history = [{
-			role: "assistant",
-			content: [{
-				type: "text",
-				text: summary.summary
-			}],
-			toolCalls: []
-		}];
-		this.openSteps.clear();
-		this._tokenCountWithPending = summary.postCompactTokens;
-	}
-};
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/message-mirror.ts
-function userInputToContentParts(input) {
-	if (input.parts !== void 0 && input.parts.some((part) => part.type !== "text") && input.parts !== void 0) return input.parts.map(userInputPartToContentPart);
-	return [{
-		type: "text",
-		text: input.parts !== void 0 ? input.parts.filter((part) => part.type === "text").map((part) => part.text).join("") : input.text
-	}];
-}
-function toolResultOutputToContentParts(output) {
-	if (isContentPartArray$1(output)) return output.map((part) => cloneContentPart$1(part));
-	return [{
-		type: "text",
-		text: typeof output === "string" ? output : JSON.stringify(output)
-	}];
-}
-function atomicPartToContentPart(part) {
-	if (part.kind === "text") return {
-		type: "text",
-		text: part.text
-	};
-	const thinkPart = {
-		type: "think",
-		think: part.think
-	};
-	if (part.encrypted !== void 0) thinkPart.encrypted = part.encrypted;
-	return thinkPart;
-}
-function sanitizeToolCallData(data) {
-	return {
-		tool_call_id: data.tool_call_id,
-		tool_name: data.tool_name,
-		args: data.args,
-		...data.activity_description !== void 0 ? { activity_description: data.activity_description } : {},
-		user_facing_name: data.user_facing_name,
-		input_display: data.input_display
-	};
-}
-function toolCallDataToKosongToolCall(data) {
-	return {
-		type: "function",
-		id: data.tool_call_id,
-		function: {
-			name: data.tool_name,
-			arguments: data.args === void 0 ? null : JSON.stringify(data.args)
-		}
-	};
-}
-function userInputPartToContentPart(part) {
-	if (part.type === "text") return {
-		type: "text",
-		text: part.text
-	};
-	if (part.type === "image_url") return {
-		type: "image_url",
-		imageUrl: part.image_url
-	};
-	return {
-		type: "video_url",
-		videoUrl: part.video_url
-	};
-}
-function isContentPart$2(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const part = value;
-	return part.type === "text" || part.type === "think" || part.type === "image_url" || part.type === "audio_url" || part.type === "video_url";
-}
-function isContentPartArray$1(value) {
-	return Array.isArray(value) && value.every((part) => isContentPart$2(part));
-}
-function cloneContentPart$1(part) {
-	return { ...part };
-}
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/notification-xml.ts
-/**
-* Notification XML rendering — shared between ContextState and
-* ConversationProjector so both produce byte-identical chat-history
-* injection text.
-*
-* Output shape:
-*   <notification id="..." category="..." type="..." source_kind="..." source_id="...">
-*   Title: ...
-*   Severity: ...
-*   <body>
-*   <task-notification>   (only when source_kind === 'background_task' and tail_output is non-empty)
-*   <truncated tail>
-*   </task-notification>
-*   </notification>
-*
-* The opening-tag names (`<notification ` / `<task-notification>`) are
-* load-bearing for the projector's `mergeAdjacentUserMessages` detector
-* — rename requires updating the detector too.
-*/
-function renderNotificationXml(data) {
-	const id = stringAttr(data["id"], "unknown");
-	const category = stringAttr(data["category"], "unknown");
-	const type = stringAttr(data["type"], "unknown");
-	const sourceKind = stringAttr(data["source_kind"], "unknown");
-	const sourceId = stringAttr(data["source_id"], "unknown");
-	const title = typeof data["title"] === "string" ? data["title"] : "";
-	const severity = typeof data["severity"] === "string" ? data["severity"] : "";
-	const body = typeof data["body"] === "string" ? data["body"] : "";
-	const lines = [`<notification id="${id}" category="${category}" type="${type}" source_kind="${sourceKind}" source_id="${sourceId}">`];
-	if (title.length > 0) lines.push(`Title: ${title}`);
-	if (severity.length > 0) lines.push(`Severity: ${severity}`);
-	if (body.length > 0) lines.push(body);
-	if (data["source_kind"] === "background_task") {
-		const tailRaw = typeof data["tail_output"] === "string" ? data["tail_output"] : "";
-		if (tailRaw.length > 0) {
-			const truncated = truncateTailOutput(tailRaw, 20, 3e3);
-			lines.push("<task-notification>");
-			lines.push(truncated);
-			lines.push("</task-notification>");
-		}
-	}
-	lines.push("</notification>");
-	return lines.join("\n");
-}
-/**
-* Truncate tail output to at most `maxLines` lines and `maxChars`
-* characters. Takes the *last* N lines, then trims from the front if
-* the character budget is exceeded.
-*/
-function truncateTailOutput(raw, maxLines, maxChars) {
-	const allLines = raw.split("\n");
-	let result = (allLines.length > maxLines ? allLines.slice(-maxLines) : allLines).join("\n");
-	if (result.length > maxChars) result = result.slice(-maxChars);
-	return result;
-}
-function stringAttr(value, fallback) {
-	if (typeof value !== "string" || value.length === 0) return fallback;
-	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;");
-}
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/projector.ts
-/**
-* Pure read-side projector for provider-visible messages. It passes through
-* persisted history, merges adjacent user messages, filters incomplete
-* assistant placeholders, and injects ephemeral annotations without writing
-* anything back to the journal.
-*
-* The system prompt is not injected here; it is forwarded separately through
-* provider chat parameters to avoid duplicate system messages.
-*/
-var DefaultConversationProjector = class {
-	project(snapshot, ephemeralInjectionsOrOptions, options) {
-		const ephemeralInjections = Array.isArray(ephemeralInjectionsOrOptions) ? ephemeralInjectionsOrOptions : [];
-		const merged = mergeAdjacentUserMessages(snapshot.history.filter((m) => m.partial !== true && !(m.role === "assistant" && m.content.length === 0 && m.toolCalls.length === 0)));
-		return [...ephemeralInjections.length === 0 ? [] : ephemeralInjections.map((injection) => renderInjection(injection)), ...merged];
-	}
-};
-/**
-* Render an EphemeralInjection into a synthetic user message. System
-* reminders and pending notifications use XML wrappers so the model can
-* distinguish host annotations from genuine user text. `memory_recall`
-* stays as free text.
-*
-* The merge-guard logic downstream (`mergeAdjacentUserMessages`) uses
-* the `<notification ` / `<system-reminder>` opening tag to detect
-* these messages, so the exact tag names are load-bearing for
-* projector correctness — do not rename without also updating
-* `isInjectionUserMessage` below.
-*/
-function renderInjection(injection) {
-	return {
-		role: "user",
-		content: [{
-			type: "text",
-			text: renderInjectionText(injection)
-		}],
-		toolCalls: []
-	};
-}
-function renderInjectionText(injection) {
-	const { kind, content } = injection;
-	if (kind === "pending_notification") {
-		if (typeof content === "string") return `<notification>\n${content}\n</notification>`;
-		return renderNotificationXml(content);
-	}
-	if (kind === "system_reminder") return `<system-reminder>\n${typeof content === "string" ? content : JSON.stringify(content)}\n</system-reminder>`;
-	return typeof content === "string" ? content : JSON.stringify(content);
-}
-/**
-* Detect whether a user message was produced by the ephemeral injection
-* pipeline (system_reminder or notification XML tag). Such messages
-* must never be merged with an adjacent real user turn — doing so would
-* smear the injection's XML wrapper into the user's actual prompt and
-* confuse the LLM about where the system annotation ends.
-*
-*/
-function isInjectionUserMessage(message) {
-	if (message.role !== "user") return false;
-	const trimmed = extractTextOnly(message).trimStart();
-	if (trimmed.startsWith("<notification ")) return true;
-	if (trimmed.startsWith("<system-reminder>")) return true;
-	return false;
-}
-function mergeAdjacentUserMessages(history) {
-	const out = [];
-	for (const message of history) {
-		const previous = out.at(-1);
-		if (message.role === "user" && previous !== void 0 && previous.role === "user" && !isInjectionUserMessage(message) && !isInjectionUserMessage(previous)) {
-			out[out.length - 1] = mergeTwoUserMessages(previous, message);
-			continue;
-		}
-		out.push(cloneMessage(message));
-	}
-	return out;
-}
-function mergeTwoUserMessages(a, b) {
-	const aText = extractTextOnly(a);
-	const bText = extractTextOnly(b);
-	const nonTextParts = [...a.content.filter((p) => p.type !== "text"), ...b.content.filter((p) => p.type !== "text")];
-	return {
-		role: "user",
-		content: [{
-			type: "text",
-			text: `${aText}\n\n${bText}`
-		}, ...nonTextParts],
-		toolCalls: []
-	};
-}
-function extractTextOnly(message) {
-	return message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
-}
-function cloneMessage(message) {
-	return {
-		role: message.role,
-		name: message.name,
-		content: message.content.map((p) => ({ ...p })),
-		toolCalls: message.toolCalls.map((tc) => ({ ...tc })),
-		toolCallId: message.toolCallId,
-		partial: message.partial
-	};
-}
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/record-builders.ts
-function buildUserMessageRecord(turnId, input) {
-	return {
-		type: "user_message",
-		turn_id: turnId,
-		content: input.parts !== void 0 ? input.parts : input.text
-	};
-}
-function buildToolResultRecord(turnId, parentUuid, toolCallId, normalisedOutput, result) {
-	return {
-		type: "tool_result",
-		turn_id: turnId,
-		tool_call_id: toolCallId,
-		output: normalisedOutput,
-		parent_uuid: parentUuid,
-		is_error: result.isError,
-		synthetic: result.synthetic
-	};
-}
-function buildStepBeginRecord(input) {
-	return {
-		type: "step_begin",
-		uuid: input.uuid,
-		turn_id: input.turnId,
-		step: input.step
-	};
-}
-function buildStepEndRecord(input) {
-	return {
-		type: "step_end",
-		uuid: input.uuid,
-		turn_id: input.turnId,
-		step: input.step,
-		usage: input.usage,
-		finish_reason: input.finishReason
-	};
-}
-function buildContentPartRecord(input) {
-	return {
-		type: "content_part",
-		uuid: input.uuid,
-		turn_id: input.turnId,
-		step: input.step,
-		step_uuid: input.stepUuid,
-		role: "assistant",
-		part: input.part.kind === "text" ? {
-			kind: "text",
-			text: input.part.text
-		} : input.part.encrypted !== void 0 ? {
-			kind: "think",
-			think: input.part.think,
-			encrypted: input.part.encrypted
-		} : {
-			kind: "think",
-			think: input.part.think
-		}
-	};
-}
-function buildToolCallRecord(input, data) {
-	return {
-		type: "tool_call",
-		uuid: input.uuid,
-		turn_id: input.turnId,
-		step: input.step,
-		step_uuid: input.stepUuid,
-		data
-	};
-}
-function buildNotificationRecord(data) {
-	return {
-		type: "notification",
-		data
-	};
-}
-function buildSystemReminderRecord(data) {
-	return {
-		type: "system_reminder",
-		content: data.content
-	};
-}
-function buildClearRecord() {
-	return { type: "context_cleared" };
-}
-function buildConfigChangeRecord(event) {
-	switch (event.type) {
-		case "system_prompt_changed": return {
-			type: "system_prompt_changed",
-			new_prompt: event.new_prompt
-		};
-		case "tools_changed": return {
-			type: "tools_changed",
-			operation: event.operation,
-			tools: event.tools
-		};
-	}
-}
-function buildCompactionRecord(summary) {
-	return {
-		type: "compaction",
-		summary: summary.summary,
-		compacted_range: {
-			from_turn: summary.compactedRange.fromTurn,
-			to_turn: summary.compactedRange.toTurn,
-			message_count: summary.compactedRange.messageCount
-		},
-		pre_compact_tokens: summary.preCompactTokens,
-		post_compact_tokens: summary.postCompactTokens,
-		trigger: summary.trigger,
-		archive_file: summary.archiveFile
-	};
-}
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/context-state.ts
-/**
-* Core ContextState logic. Both `WiredContextState` and
-* `InMemoryContextState` are thin wrappers that differ only in the journal
-* writer they supply and the constructor shape they expose.
-*
-* WAL-then-mirror atomicity:
-*   1. build the WireRecord
-*   2. await journalWriter.append(...)
-*   3. on success only, update the in-memory projection
-*
-* If step 2 throws, the in-memory state is unchanged.
-*/
-var BaseContextState = class {
-	journalWriter;
-	projector;
-	currentTurnId;
-	memory;
-	_broken = false;
-	_brokenError;
-	/**
-	* Marks all future write entry points as failed. Read methods remain
-	* callable so callers can still inspect the last valid in-memory state.
-	*/
-	markBroken(error) {
-		if (this._broken) return;
-		this._broken = true;
-		this._brokenError = error;
-	}
-	assertNotBroken() {
-		if (this._broken) throw new ContextStateBrokenError("ContextState is broken due to a prior persist error", this._brokenError);
-	}
-	constructor(opts) {
-		this.journalWriter = opts.journalWriter;
-		this.projector = opts.projector ?? new DefaultConversationProjector();
-		this.currentTurnId = opts.currentTurnId;
-		this.memory = new ContextStateMemory(opts);
-	}
-	get model() {
-		return this.memory.model;
-	}
-	get systemPrompt() {
-		return this.memory.systemPrompt;
-	}
-	get activeTools() {
-		return this.memory.activeTools;
-	}
-	get tokenCountWithPending() {
-		return this.memory.tokenCountWithPending;
-	}
-	get thinkingLevel() {
-		return this.memory.thinkingLevel;
-	}
-	get beforeStep() {
-		return this.memory.beforeStep;
-	}
-	buildMessages() {
-		return this.projector.project({
-			history: this.memory.getHistory(),
-			systemPrompt: this.memory.systemPrompt,
-			model: this.memory.model,
-			activeTools: this.memory.activeTools
-		});
-	}
-	async applySteerMessages() {
-		const steers = this.memory.drainSteerMessages();
-		if (steers.length === 0) return false;
-		this.assertNotBroken();
-		for (const steer of steers) await this.appendUserMessage(steer);
-		return true;
-	}
-	pushSteer(input) {
-		this.memory.pushSteer(input);
-	}
-	setBeforeStepHook(fn) {
-		this.memory.setBeforeStepHook(fn);
-	}
-	getHistory() {
-		return this.memory.getHistory();
-	}
-	async appendUserMessage(input, turnIdOverride) {
-		this.assertNotBroken();
-		const turnId = turnIdOverride ?? this.currentTurnId();
-		await this.journalWriter.append(buildUserMessageRecord(turnId, input));
-		this.memory.appendUserContent(userInputToContentParts(input));
-	}
-	async appendToolResult(parentUuid, toolCallId, result) {
-		this.assertNotBroken();
-		const normalisedOutput = result.output === void 0 ? null : result.output;
-		const turnId = this.currentTurnId();
-		await this.journalWriter.append(buildToolResultRecord(turnId, parentUuid, toolCallId, normalisedOutput, result));
-		this.memory.appendToolResult(toolCallId, toolResultOutputToContentParts(normalisedOutput));
-	}
-	async appendStepBegin(input) {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildStepBeginRecord(input));
-		this.memory.openStep(input.uuid);
-	}
-	async appendStepEnd(input) {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildStepEndRecord(input));
-		this.memory.closeStep(input.uuid, input.usage);
-	}
-	async appendContentPart(input) {
-		this.assertNotBroken();
-		if (this.memory.getOpenStep(input.stepUuid) === void 0) throw new Error(`appendContentPart: unknown stepUuid '${input.stepUuid}' (no open step_begin)`);
-		await this.journalWriter.append(buildContentPartRecord(input));
-		this.memory.appendOpenStepContent(input.stepUuid, atomicPartToContentPart(input.part));
-	}
-	async appendToolCall(input) {
-		this.assertNotBroken();
-		if (this.memory.getOpenStep(input.stepUuid) === void 0) throw new Error(`appendToolCall: unknown stepUuid '${input.stepUuid}' (no open step_begin)`);
-		const data = sanitizeToolCallData(input.data);
-		await this.journalWriter.append(buildToolCallRecord(input, data));
-		this.memory.appendOpenStepToolCall(input.stepUuid, toolCallDataToKosongToolCall(input.data));
-	}
-	async appendNotification(data) {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildNotificationRecord(data));
-		const text = renderNotificationXml(data);
-		this.memory.appendUserContent([{
-			type: "text",
-			text
-		}]);
-	}
-	async appendSystemReminder(data) {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildSystemReminderRecord(data));
-		const text = `<system-reminder>\n${data.content}\n</system-reminder>`;
-		this.memory.appendUserContent([{
-			type: "text",
-			text
-		}]);
-	}
-	async clear() {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildClearRecord());
-		this.memory.clearConversation();
-	}
-	async applyConfigChange(event) {
-		this.assertNotBroken();
-		switch (event.type) {
-			case "system_prompt_changed":
-				await this.journalWriter.append(buildConfigChangeRecord(event));
-				this.memory.setSystemPrompt(event.new_prompt);
-				return;
-			case "tools_changed":
-				await this.journalWriter.append(buildConfigChangeRecord(event));
-				this.memory.applyToolsChanged(event.operation, event.tools);
-		}
-	}
-	setModel(model) {
-		this.memory.setModel(model);
-	}
-	setThinkingLevel(level) {
-		this.memory.setThinkingLevel(level);
-	}
-	async resetToSummary(summary) {
-		this.assertNotBroken();
-		await this.journalWriter.append(buildCompactionRecord(summary));
-		this.memory.resetToSummary(summary);
-	}
-};
-var WiredContextState = class extends BaseContextState {};
-var InMemoryContextState = class extends BaseContextState {
-	constructor(opts) {
-		super({
-			...opts,
-			currentTurnId: opts.currentTurnId ?? (() => "embedded"),
-			journalWriter: new NoopJournalWriter()
-		});
-	}
-};
-//#endregion
-//#region ../../packages/kimi-core/src/storage/state/session-journal.ts
-/**
-* Production `SessionJournal` implementation — delegates every append to the
-* shared `JournalWriter`, which in turn serialises to wire.jsonl.
-*
-* Does not mutate any conversation projection state; management records do
-* not change buildMessages().
-*/
-var WiredSessionJournalImpl = class {
-	constructor(journalWriter) {
-		this.journalWriter = journalWriter;
-	}
-	async appendTurnBegin(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendTurnEnd(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendSkillInvoked(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendSkillCompleted(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendApprovalRequest(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendApprovalResponse(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendTeamMail(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendToolDenied(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendSubagentSpawned(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendSubagentCompleted(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendSubagentFailed(data) {
-		await this.journalWriter.append(data);
-	}
-	async appendOwnershipChanged(data) {
-		await this.journalWriter.append(data);
-	}
-};
-//#endregion
-//#region ../../packages/kimi-core/src/storage/schema/records.ts
-/**
-* Fallback producer identity used when the host hasn't supplied one.
-* Version marker makes unset state easy to spot in field reports.
-*/
-const DEFAULT_PRODUCER = {
-	kind: "typescript",
-	name: "@moonshot-ai/core",
-	version: "0.0.0-unset"
-};
-const agentTypeEnum = z.enum([
-	"main",
-	"sub",
-	"independent"
-]);
-const _rawWireProducerSchema = z.object({
-	kind: z.enum(["python", "typescript"]),
-	name: z.string(),
-	version: z.string()
-});
-const WireFileMetadataSchema = z.object({
-	type: z.literal("metadata"),
-	protocol_version: z.string(),
-	created_at: z.number(),
-	kimi_version: z.string().optional(),
-	producer: _rawWireProducerSchema.optional()
-});
-const _rawTurnBeginRecordSchema = z.object({
-	type: z.literal("turn_begin"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	agent_type: agentTypeEnum,
-	user_input: z.string().optional(),
-	input_kind: z.enum(["user", "system_trigger"]),
-	trigger_source: z.string().optional()
-});
-const _rawTurnEndRecordSchema = z.object({
-	type: z.literal("turn_end"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	agent_type: agentTypeEnum,
-	success: z.boolean(),
-	reason: z.enum([
-		"done",
-		"cancelled",
-		"error",
-		"interrupted"
-	]),
-	usage: z.object({
-		input_tokens: z.number(),
-		output_tokens: z.number(),
-		cache_read_tokens: z.number().optional(),
-		cache_write_tokens: z.number().optional(),
-		cost_usd: z.number().optional()
-	}).optional(),
-	synthetic: z.boolean().optional()
-});
-const _userInputPartSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("text"),
-		text: z.string()
-	}),
-	z.object({
-		type: z.literal("image_url"),
-		image_url: z.object({ url: z.string() })
-	}),
-	z.object({
-		type: z.literal("video_url"),
-		video_url: z.object({ url: z.string() })
-	})
-]);
-const _rawUserMessageRecordSchema = z.object({
-	type: z.literal("user_message"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	content: z.union([z.string(), z.array(_userInputPartSchema).readonly()]),
-	uuid: z.string().optional()
-});
-const _rawToolResultRecordSchema = z.object({
-	type: z.literal("tool_result"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	tool_call_id: z.string(),
-	output: z.unknown(),
-	is_error: z.boolean().optional(),
-	synthetic: z.boolean().optional(),
-	uuid: z.string().optional(),
-	parent_uuid: z.string().optional()
-});
-const _rawCompactionRecordSchema = z.object({
-	type: z.literal("compaction"),
-	seq: z.number(),
-	time: z.number(),
-	summary: z.string(),
-	compacted_range: z.object({
-		from_turn: z.number(),
-		to_turn: z.number(),
-		message_count: z.number()
-	}),
-	pre_compact_tokens: z.number(),
-	post_compact_tokens: z.number(),
-	trigger: z.enum(["auto", "manual"]),
-	archive_file: z.string().optional(),
-	uuid: z.string().optional()
-});
-const _rawSystemPromptChangedRecordSchema = z.object({
-	type: z.literal("system_prompt_changed"),
-	seq: z.number(),
-	time: z.number(),
-	new_prompt: z.string()
-});
-const _rawToolsChangedRecordSchema = z.object({
-	type: z.literal("tools_changed"),
-	seq: z.number(),
-	time: z.number(),
-	operation: z.enum([
-		"register",
-		"remove",
-		"set_active"
-	]),
-	tools: z.array(z.string())
-});
-const _rawSystemReminderRecordSchema = z.object({
-	type: z.literal("system_reminder"),
-	seq: z.number(),
-	time: z.number(),
-	content: z.string(),
-	consumed_at_turn: z.number().optional()
-});
-const _rawNotificationRecordSchema = z.object({
-	type: z.literal("notification"),
-	seq: z.number(),
-	time: z.number(),
-	data: z.object({
-		id: z.string(),
-		category: z.enum([
-			"task",
-			"agent",
-			"system",
-			"team"
-		]),
-		type: z.string(),
-		source_kind: z.string(),
-		source_id: z.string(),
-		title: z.string(),
-		body: z.string(),
-		severity: z.enum([
-			"info",
-			"success",
-			"warning",
-			"error"
-		]),
-		payload: z.record(z.string(), z.unknown()).optional(),
-		targets: z.array(z.enum([
-			"llm",
-			"wire",
-			"shell"
-		])),
-		dedupe_key: z.string().optional(),
-		delivered_at: z.object({
-			llm: z.number().optional(),
-			wire: z.number().optional(),
-			shell: z.number().optional()
-		}).optional(),
-		envelope_id: z.string().optional()
-	})
-});
-const _rawToolDeniedRecordSchema = z.object({
-	type: z.literal("tool_denied"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	step: z.number(),
-	data: z.object({
-		tool_call_id: z.string(),
-		tool_name: z.string(),
-		rule_id: z.string(),
-		reason: z.string()
-	})
-});
-const _rawStepBeginRecordSchema = z.object({
-	type: z.literal("step_begin"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string(),
-	turn_id: z.string(),
-	step: z.number()
-});
-const _rawStepEndRecordSchema = z.object({
-	type: z.literal("step_end"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string(),
-	turn_id: z.string(),
-	step: z.number(),
-	usage: z.object({
-		input_tokens: z.number(),
-		output_tokens: z.number(),
-		cache_read_tokens: z.number().optional(),
-		cache_write_tokens: z.number().optional()
-	}).optional(),
-	finish_reason: z.string().optional()
-});
-const _contentPartBodySchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("text"),
-	text: z.string()
-}), z.object({
-	kind: z.literal("think"),
-	think: z.string(),
-	encrypted: z.string().optional()
-})]);
-const _rawContentPartRecordSchema = z.object({
-	type: z.literal("content_part"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string(),
-	turn_id: z.string(),
-	step: z.number(),
-	step_uuid: z.string(),
-	role: z.literal("assistant"),
-	part: _contentPartBodySchema
-});
-const _rawToolCallRecordSchema = z.object({
-	type: z.literal("tool_call"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string(),
-	turn_id: z.string(),
-	step: z.number(),
-	step_uuid: z.string(),
-	data: z.object({
-		tool_call_id: z.string(),
-		tool_name: z.string(),
-		args: z.unknown(),
-		activity_description: z.string().optional(),
-		user_facing_name: z.string().optional(),
-		input_display: z.unknown().optional()
-	})
-});
-/**
-* Storage persists the approval display as an opaque blob. Write-trust
-* / read-passthrough: the concrete `ToolInputDisplay` union lives in
-* `display/` and is the responsibility of the host layer to validate
-* at render time.
-*/
-const ApprovalDisplaySchema = z.unknown();
-const ApprovalSourceSchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("soul"),
-		agent_id: z.string()
-	}),
-	z.object({
-		kind: z.literal("subagent"),
-		agent_id: z.string(),
-		subagent_type: z.string().optional()
-	}),
-	z.object({
-		kind: z.literal("turn"),
-		turn_id: z.string()
-	}),
-	z.object({
-		kind: z.literal("session"),
-		session_id: z.string()
-	}),
-	z.object({
-		kind: z.literal("mcp"),
-		server_id: z.string(),
-		reason: z.enum([
-			"elicitation",
-			"auth",
-			"tool_call"
-		])
-	})
-]);
-const skillInvocationTriggerEnum = z.enum([
-	"user-slash",
-	"claude-proactive",
-	"nested-skill"
-]);
-const _rawSkillInvokedRecordSchema = z.object({
-	type: z.literal("skill_invoked"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	agent_type: agentTypeEnum.optional(),
-	data: z.object({
-		skill_name: z.string(),
-		execution_mode: z.enum(["inline", "fork"]),
-		original_input: z.string(),
-		sub_agent_id: z.string().optional(),
-		invocation_trigger: skillInvocationTriggerEnum.optional(),
-		query_depth: z.number().optional()
-	})
-});
-const _rawSkillCompletedRecordSchema = z.object({
-	type: z.literal("skill_completed"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	agent_type: agentTypeEnum.optional(),
-	data: z.object({
-		skill_name: z.string(),
-		execution_mode: z.enum(["inline", "fork"]),
-		success: z.boolean(),
-		error: z.string().optional(),
-		sub_agent_id: z.string().optional(),
-		invocation_trigger: skillInvocationTriggerEnum.optional(),
-		query_depth: z.number().optional()
-	})
-});
-const _rawApprovalRequestRecordSchema = z.object({
-	type: z.literal("approval_request"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	step: z.number(),
-	data: z.object({
-		request_id: z.string(),
-		tool_call_id: z.string(),
-		tool_name: z.string(),
-		action: z.string(),
-		display: ApprovalDisplaySchema,
-		source: ApprovalSourceSchema
-	})
-});
-const _rawApprovalResponseRecordSchema = z.object({
-	type: z.literal("approval_response"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string(),
-	step: z.number(),
-	data: z.object({
-		request_id: z.string(),
-		response: z.enum([
-			"approved",
-			"rejected",
-			"cancelled"
-		]),
-		feedback: z.string().optional(),
-		selected_label: z.string().optional(),
-		synthetic: z.boolean().optional()
-	})
-});
-const _rawTeamMailRecordSchema = z.object({
-	type: z.literal("team_mail"),
-	seq: z.number(),
-	time: z.number(),
-	data: z.object({
-		mail_id: z.string(),
-		reply_to: z.string().optional(),
-		from_agent: z.string(),
-		to_agent: z.string(),
-		content: z.string(),
-		summary: z.string().optional()
-	})
-});
-const _rawTokenUsageSchema = z.object({
-	input: z.number().int().nonnegative(),
-	output: z.number().int().nonnegative(),
-	cache_read: z.number().int().nonnegative().optional(),
-	cache_write: z.number().int().nonnegative().optional()
-});
-const _rawSubagentSpawnedRecordSchema = z.object({
-	type: z.literal("subagent_spawned"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string().optional(),
-	data: z.object({
-		agent_id: z.string(),
-		agent_name: z.string().optional(),
-		parent_tool_call_id: z.string(),
-		parent_agent_id: z.string().optional(),
-		parent_tool_call_uuid: z.string().optional(),
-		run_in_background: z.boolean()
-	})
-});
-const _rawSubagentCompletedRecordSchema = z.object({
-	type: z.literal("subagent_completed"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string().optional(),
-	parent_uuid: z.string().optional(),
-	data: z.object({
-		agent_id: z.string(),
-		parent_tool_call_id: z.string(),
-		result_summary: z.string(),
-		usage: _rawTokenUsageSchema.optional()
-	})
-});
-const _rawSubagentFailedRecordSchema = z.object({
-	type: z.literal("subagent_failed"),
-	seq: z.number(),
-	time: z.number(),
-	uuid: z.string().optional(),
-	parent_uuid: z.string().optional(),
-	data: z.object({
-		agent_id: z.string(),
-		parent_tool_call_id: z.string(),
-		error: z.string()
-	})
-});
-const _rawOwnershipChangedRecordSchema = z.object({
-	type: z.literal("ownership_changed"),
-	seq: z.number(),
-	time: z.number(),
-	old_owner: z.string().nullable(),
-	new_owner: z.string()
-});
-const _rawContextEditRecordSchema = z.object({
-	type: z.literal("context_edit"),
-	seq: z.number(),
-	time: z.number(),
-	operation: z.enum([
-		"edit_message",
-		"delete_message",
-		"rewind",
-		"insert_message",
-		"replace_message"
-	]),
-	target_seq: z.number().optional(),
-	to_turn: z.number().optional(),
-	after_seq: z.number().optional(),
-	new_content: z.string().optional(),
-	new_role: z.enum([
-		"user",
-		"assistant",
-		"system"
-	]).optional(),
-	cascade: z.boolean().optional()
-});
-const _rawContextClearedRecordSchema = z.object({
-	type: z.literal("context_cleared"),
-	seq: z.number(),
-	time: z.number()
-});
-const _sessionInitializedCommonShape = {
-	type: z.literal("session_initialized"),
-	seq: z.number(),
-	time: z.number(),
-	system_prompt: z.string(),
-	active_tools: z.array(z.string()),
-	model: z.string().optional(),
-	permission_mode: z.enum([
-		"default",
-		"acceptEdits",
-		"bypassPermissions"
-	]).optional(),
-	plan_mode: z.boolean().optional(),
-	workspace_dir: z.string().optional(),
-	thinking_level: z.string().optional()
-};
-const _rawSessionInitializedMainSchema = z.object({
-	..._sessionInitializedCommonShape,
-	agent_type: z.literal("main"),
-	session_id: z.string()
-});
-const _rawSessionInitializedSubSchema = z.object({
-	..._sessionInitializedCommonShape,
-	agent_type: z.literal("sub"),
-	agent_id: z.string(),
-	agent_name: z.string().optional(),
-	parent_session_id: z.string(),
-	parent_agent_id: z.string().optional(),
-	parent_tool_call_id: z.string(),
-	run_in_background: z.boolean()
-});
-const _rawSessionInitializedIndependentSchema = z.object({
-	..._sessionInitializedCommonShape,
-	agent_type: z.literal("independent"),
-	agent_id: z.string(),
-	agent_name: z.string().optional()
-});
-const _rawSessionInitializedRecordSchema = z.discriminatedUnion("agent_type", [
-	_rawSessionInitializedMainSchema,
-	_rawSessionInitializedSubSchema,
-	_rawSessionInitializedIndependentSchema
-]);
-const SessionInitializedRecordSchema = _rawSessionInitializedRecordSchema;
-const WireRecordSchema = z.discriminatedUnion("type", [
-	_rawTurnBeginRecordSchema,
-	_rawTurnEndRecordSchema,
-	_rawUserMessageRecordSchema,
-	_rawToolResultRecordSchema,
-	_rawCompactionRecordSchema,
-	_rawSystemPromptChangedRecordSchema,
-	_rawToolsChangedRecordSchema,
-	_rawSystemReminderRecordSchema,
-	_rawNotificationRecordSchema,
-	_rawToolDeniedRecordSchema,
-	_rawStepBeginRecordSchema,
-	_rawStepEndRecordSchema,
-	_rawContentPartRecordSchema,
-	_rawToolCallRecordSchema,
-	_rawSkillInvokedRecordSchema,
-	_rawSkillCompletedRecordSchema,
-	_rawApprovalRequestRecordSchema,
-	_rawApprovalResponseRecordSchema,
-	_rawTeamMailRecordSchema,
-	_rawSubagentSpawnedRecordSchema,
-	_rawSubagentCompletedRecordSchema,
-	_rawSubagentFailedRecordSchema,
-	_rawOwnershipChangedRecordSchema,
-	_rawContextEditRecordSchema,
-	_rawContextClearedRecordSchema,
-	_rawSessionInitializedRecordSchema
-]);
-//#endregion
-//#region ../../packages/kimi-core/src/storage/journal/reader.ts
-async function defaultReadLines(path) {
-	const parts = (await readFile(path, "utf8")).split("\n");
-	if (parts.length > 0 && parts.at(-1) === "") parts.pop();
-	return parts;
-}
-/**
-* Replay a wire.jsonl into an ordered list of valid WireRecords plus a
-* health signal. Does not construct a ContextState — that concern lives in
-* WiredContextState which drives its internal mirror from these records.
-*
-* Error policy (§4.1.1 / §8.4):
-*   - unknown record type at any line → skip + warn
-*   - JSON.parse failure on the LAST body line → skip + warn (tail truncation)
-*   - JSON.parse failure on any earlier line → health = 'broken'
-*   - major version higher than supportedMajor → throw IncompatibleVersionError
-*/
-async function replayWire(path, options) {
-	const lines = await (options.readLines ?? defaultReadLines)(path);
-	if (lines.length === 0) throw new WireJournalCorruptError(`wire.jsonl is empty at ${path}`);
-	const firstLine = lines[0];
-	if (firstLine === void 0) throw new WireJournalCorruptError(`wire.jsonl is empty at ${path}`);
-	let meta;
-	try {
-		meta = WireFileMetadataSchema.parse(JSON.parse(firstLine));
-	} catch (error) {
-		throw new WireJournalCorruptError(`wire.jsonl metadata header (line 1) is invalid: ${String(error)}`);
-	}
-	const majorStr = meta.protocol_version.split(".")[0] ?? "0";
-	const major = Number.parseInt(majorStr, 10);
-	if (!Number.isFinite(major)) throw new IncompatibleVersionError(`wire.jsonl metadata.protocol_version "${meta.protocol_version}" is not a valid version string`);
-	if (major > options.supportedMajor) throw new IncompatibleVersionError(`wire.jsonl version ${meta.protocol_version} is not supported (max major: ${options.supportedMajor}). Please upgrade Kimi CLI.`);
-	if (meta.producer === void 0) throw new UnsupportedProducerError("legacy", "metadata-missing-producer");
-	if (meta.producer.kind !== "typescript") throw new UnsupportedProducerError(meta.producer.kind === "python" ? "python" : "unknown", "cross-producer-not-supported");
-	const producer = meta.producer;
-	const initLine = lines[1];
-	if (initLine === void 0) throw new MalformedWireError("session-initialized-missing", `wire.jsonl has no line 2 (session_initialized) at ${path}`);
-	let initRaw;
-	try {
-		initRaw = JSON.parse(initLine);
-	} catch (error) {
-		throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 failed JSON.parse: ${String(error)}`);
+	get thinkingLevel() {
+		return this._thinkingLevel;
 	}
-	const initTypeField = initRaw?.type;
-	if (initTypeField !== "session_initialized") throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 has type="${String(initTypeField)}"; expected "session_initialized"`);
-	const initParsed = SessionInitializedRecordSchema.safeParse(initRaw);
-	if (!initParsed.success) throw new MalformedWireError("session-initialized-missing", `wire.jsonl line 2 failed zod parse: ${initParsed.error.message}`);
-	const sessionInitialized = initParsed.data;
-	const records = [];
-	const warnings = [];
-	const bodyLines = lines.slice(2);
-	for (const [i, line] of bodyLines.entries()) {
-		const physicalLineNo = i + 3;
-		const isLastLine = i === bodyLines.length - 1;
-		const snippet = line.slice(0, 100);
-		let raw;
-		try {
-			raw = JSON.parse(line);
-		} catch (error) {
-			if (isLastLine) {
-				warnings.push(`Tail line truncated at line ${physicalLineNo}, skipping: ${snippet}`);
-				continue;
-			}
-			const reason = `wire.jsonl mid-file corruption at line ${physicalLineNo}: ${String(error)}`;
-			return {
-				records,
-				protocolVersion: meta.protocol_version,
-				health: "broken",
-				brokenReason: reason,
-				warnings,
-				producer,
-				sessionInitialized
-			};
-		}
-		const typeField = raw?.type;
-		if (typeField === "session_initialized") throw new MalformedWireError("session-initialized-position-wrong", `wire.jsonl has a session_initialized record at line ${physicalLineNo}; only line 2 is permitted`);
-		if (typeof typeField !== "string" || !KNOWN_RECORD_TYPES.has(typeField)) {
-			if (typeof typeField === "string" && LEGACY_RECORD_TYPES.has(typeField)) warnings.push(`Skipping legacy record type "${typeField}" at line ${physicalLineNo} (migrated to state.json)`);
-			else warnings.push(`Skipping unrecognized record type "${String(typeField)}" at line ${physicalLineNo}: ${snippet}`);
-			continue;
+	get beforeStep() {
+		return this._beforeStep;
+	}
+	setBeforeStepHook(fn) {
+		this._beforeStep = fn;
+	}
+	getHistory() {
+		return this.history;
+	}
+	drainSteerMessages() {
+		const drained = this.steerBuffer;
+		this.steerBuffer = [];
+		return drained;
+	}
+	pushSteer(input) {
+		this.steerBuffer.push({ ...input });
+	}
+	appendUserContent(content) {
+		this.history.push({
+			role: "user",
+			content,
+			toolCalls: []
+		});
+	}
+	appendToolResult(toolCallId, content) {
+		this.history.push({
+			role: "tool",
+			content,
+			toolCalls: [],
+			toolCallId
+		});
+	}
+	openStep(uuid) {
+		const message = {
+			role: "assistant",
+			content: [],
+			toolCalls: []
+		};
+		this.history.push(message);
+		this.openSteps.set(uuid, message);
+	}
+	closeStep(uuid, usage) {
+		this.openSteps.delete(uuid);
+		if (usage !== void 0) this._tokenCountWithPending = usage.input_tokens + usage.output_tokens;
+	}
+	getOpenStep(uuid) {
+		return this.openSteps.get(uuid);
+	}
+	appendOpenStepContent(stepUuid, part) {
+		this.openSteps.get(stepUuid)?.content.push(part);
+	}
+	appendOpenStepToolCall(stepUuid, toolCall) {
+		this.openSteps.get(stepUuid)?.toolCalls.push(toolCall);
+	}
+	clearConversation() {
+		this.history = [];
+		this.openSteps.clear();
+		this._tokenCountWithPending = 0;
+	}
+	setSystemPrompt(systemPrompt) {
+		this._systemPrompt = systemPrompt;
+	}
+	setModel(model) {
+		this._model = model;
+	}
+	setThinkingLevel(level) {
+		this._thinkingLevel = level;
+	}
+	applyToolsChanged(operation, tools) {
+		if (operation === "set_active") {
+			this._activeTools = new Set(tools);
+			return;
 		}
-		const parsed = WireRecordSchema.safeParse(raw);
-		if (!parsed.success) {
-			if (isLastLine) {
-				warnings.push(`Tail record failed schema validation at line ${physicalLineNo}, skipping: ${snippet}`);
-				continue;
-			}
-			const reason = `wire.jsonl schema violation at line ${physicalLineNo}: ${parsed.error.message}`;
-			return {
-				records,
-				protocolVersion: meta.protocol_version,
-				health: "broken",
-				brokenReason: reason,
-				warnings,
-				producer,
-				sessionInitialized
-			};
+		if (operation === "register") {
+			for (const tool of tools) this._activeTools.add(tool);
+			return;
 		}
-		records.push(parsed.data);
+		for (const tool of tools) this._activeTools.delete(tool);
+	}
+	resetToSummary(summary) {
+		this.history = [{
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: summary.summary
+			}],
+			toolCalls: []
+		}];
+		this.openSteps.clear();
+		this._tokenCountWithPending = summary.postCompactTokens;
 	}
+};
+//#endregion
+//#region ../../packages/kimi-core/src/storage/state/message-mirror.ts
+function userInputToContentParts(input) {
+	if (input.parts !== void 0 && input.parts.some((part) => part.type !== "text") && input.parts !== void 0) return input.parts.map(userInputPartToContentPart);
+	return [{
+		type: "text",
+		text: input.parts !== void 0 ? input.parts.filter((part) => part.type === "text").map((part) => part.text).join("") : input.text
+	}];
+}
+function toolResultOutputToContentParts(output) {
+	if (isContentPartArray$1(output)) return output.map((part) => cloneContentPart$1(part));
+	return [{
+		type: "text",
+		text: typeof output === "string" ? output : JSON.stringify(output)
+	}];
+}
+function atomicPartToContentPart(part) {
+	if (part.kind === "text") return {
+		type: "text",
+		text: part.text
+	};
+	const thinkPart = {
+		type: "think",
+		think: part.think
+	};
+	if (part.encrypted !== void 0) thinkPart.encrypted = part.encrypted;
+	return thinkPart;
+}
+function sanitizeToolCallData(data) {
 	return {
-		records,
-		protocolVersion: meta.protocol_version,
-		health: "ok",
-		warnings,
-		producer,
-		sessionInitialized
+		tool_call_id: data.tool_call_id,
+		tool_name: data.tool_name,
+		args: data.args,
+		...data.activity_description !== void 0 ? { activity_description: data.activity_description } : {},
+		user_facing_name: data.user_facing_name,
+		input_display: data.input_display
 	};
 }
-const KNOWN_RECORD_TYPES = new Set([
-	"turn_begin",
-	"turn_end",
-	"user_message",
-	"tool_result",
-	"compaction",
-	"system_prompt_changed",
-	"tools_changed",
-	"system_reminder",
-	"notification",
-	"tool_denied",
-	"step_begin",
-	"step_end",
-	"content_part",
-	"tool_call",
-	"skill_invoked",
-	"skill_completed",
-	"approval_request",
-	"approval_response",
-	"team_mail",
-	"subagent_spawned",
-	"subagent_completed",
-	"subagent_failed",
-	"ownership_changed",
-	"context_edit",
-	"context_cleared"
-]);
+function toolCallDataToKosongToolCall(data) {
+	return {
+		type: "function",
+		id: data.tool_call_id,
+		function: {
+			name: data.tool_name,
+			arguments: data.args === void 0 ? null : JSON.stringify(data.args)
+		}
+	};
+}
+function userInputPartToContentPart(part) {
+	if (part.type === "text") return {
+		type: "text",
+		text: part.text
+	};
+	if (part.type === "image_url") return {
+		type: "image_url",
+		imageUrl: part.image_url
+	};
+	return {
+		type: "video_url",
+		videoUrl: part.video_url
+	};
+}
+function isContentPart$2(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const part = value;
+	return part.type === "text" || part.type === "think" || part.type === "image_url" || part.type === "audio_url" || part.type === "video_url";
+}
+function isContentPartArray$1(value) {
+	return Array.isArray(value) && value.every((part) => isContentPart$2(part));
+}
+function cloneContentPart$1(part) {
+	return { ...part };
+}
+//#endregion
+//#region ../../packages/kimi-core/src/storage/state/notification-xml.ts
 /**
-* Record types that earlier schema versions persisted to `wire.jsonl`
-* but have since been migrated to `state.json` as the truth source.
+* Notification XML rendering — shared between ContextState and
+* ConversationProjector so both produce byte-identical chat-history
+* injection text.
 *
-* Sessions written by older binaries still carry rows of these types.
-* Keeping them in a dedicated set lets the replay loop emit an
-* informational "legacy" warning instead of the forward-compat
-* "unrecognized" warning, so it is clear these rows are expected to be
-* dropped rather than being an unknown future-version type.
+* Output shape:
+*   <notification id="..." category="..." type="..." source_kind="..." source_id="...">
+*   Title: ...
+*   Severity: ...
+*   <body>
+*   <task-notification>   (only when source_kind === 'background_task' and tail_output is non-empty)
+*   <truncated tail>
+*   </task-notification>
+*   </notification>
+*
+* The opening-tag names (`<notification ` / `<task-notification>`) are
+* load-bearing for the projector's `mergeAdjacentUserMessages` detector
+* — rename requires updating the detector too.
 */
-const LEGACY_RECORD_TYPES = new Set([
-	"permission_mode_changed",
-	"model_changed",
-	"thinking_changed",
-	"plan_mode_changed",
-	"session_meta_changed"
-]);
+function renderNotificationXml(data) {
+	const id = stringAttr(data["id"], "unknown");
+	const category = stringAttr(data["category"], "unknown");
+	const type = stringAttr(data["type"], "unknown");
+	const sourceKind = stringAttr(data["source_kind"], "unknown");
+	const sourceId = stringAttr(data["source_id"], "unknown");
+	const title = typeof data["title"] === "string" ? data["title"] : "";
+	const severity = typeof data["severity"] === "string" ? data["severity"] : "";
+	const body = typeof data["body"] === "string" ? data["body"] : "";
+	const lines = [`<notification id="${id}" category="${category}" type="${type}" source_kind="${sourceKind}" source_id="${sourceId}">`];
+	if (title.length > 0) lines.push(`Title: ${title}`);
+	if (severity.length > 0) lines.push(`Severity: ${severity}`);
+	if (body.length > 0) lines.push(body);
+	if (data["source_kind"] === "background_task") {
+		const tailRaw = typeof data["tail_output"] === "string" ? data["tail_output"] : "";
+		if (tailRaw.length > 0) {
+			const truncated = truncateTailOutput(tailRaw, 20, 3e3);
+			lines.push("<task-notification>");
+			lines.push(truncated);
+			lines.push("</task-notification>");
+		}
+	}
+	lines.push("</notification>");
+	return lines.join("\n");
+}
+/**
+* Truncate tail output to at most `maxLines` lines and `maxChars`
+* characters. Takes the *last* N lines, then trims from the front if
+* the character budget is exceeded.
+*/
+function truncateTailOutput(raw, maxLines, maxChars) {
+	const allLines = raw.split("\n");
+	let result = (allLines.length > maxLines ? allLines.slice(-maxLines) : allLines).join("\n");
+	if (result.length > maxChars) result = result.slice(-maxChars);
+	return result;
+}
+function stringAttr(value, fallback) {
+	if (typeof value !== "string" || value.length === 0) return fallback;
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;");
+}
 //#endregion
-//#region ../../packages/kimi-core/src/storage/journal/rotation.ts
+//#region ../../packages/kimi-core/src/storage/state/projector.ts
 /**
-* Storage-layer compaction utilities — file rotation and cross-file replay
-* (§4.7 / §4.1.1).
+* Pure read-side projector for provider-visible messages. It passes through
+* persisted history, merges adjacent user messages, filters incomplete
+* assistant placeholders, and injects ephemeral annotations without writing
+* anything back to the journal.
 *
-* File rotation is the physical counterpart to TurnManager's
-* `executeCompaction` (Phase 2; previously Soul's `runCompaction`):
-*   1. Rename `wire.jsonl` → `wire.N.jsonl` (frozen archive)
-*   2. Create new `wire.jsonl` with metadata header + CompactionRecord
+* The system prompt is not injected here; it is forwarded separately through
+* provider chat parameters to avoid duplicate system messages.
+*/
+var DefaultConversationProjector = class {
+	project(snapshot, ephemeralInjectionsOrOptions, options) {
+		const ephemeralInjections = Array.isArray(ephemeralInjectionsOrOptions) ? ephemeralInjectionsOrOptions : [];
+		const merged = mergeAdjacentUserMessages(snapshot.history.filter((m) => m.partial !== true && !(m.role === "assistant" && m.content.length === 0 && m.toolCalls.length === 0)));
+		return [...ephemeralInjections.length === 0 ? [] : ephemeralInjections.map((injection) => renderInjection(injection)), ...merged];
+	}
+};
+/**
+* Render an EphemeralInjection into a synthetic user message. System
+* reminders and pending notifications use XML wrappers so the model can
+* distinguish host annotations from genuine user text. `memory_recall`
+* stays as free text.
 *
-* Cross-file replay reads all wire files in a session directory
-* (wire.N.jsonl → ... → wire.1.jsonl → wire.jsonl) and produces a
-* unified record stream.
+* The merge-guard logic downstream (`mergeAdjacentUserMessages`) uses
+* the `<notification ` / `<system-reminder>` opening tag to detect
+* these messages, so the exact tag names are load-bearing for
+* projector correctness — do not rename without also updating
+* `isInjectionUserMessage` below.
+*/
+function renderInjection(injection) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: renderInjectionText(injection)
+		}],
+		toolCalls: []
+	};
+}
+function renderInjectionText(injection) {
+	const { kind, content } = injection;
+	if (kind === "pending_notification") {
+		if (typeof content === "string") return `<notification>\n${content}\n</notification>`;
+		return renderNotificationXml(content);
+	}
+	if (kind === "system_reminder") return `<system-reminder>\n${typeof content === "string" ? content : JSON.stringify(content)}\n</system-reminder>`;
+	return typeof content === "string" ? content : JSON.stringify(content);
+}
+/**
+* Detect whether a user message was produced by the ephemeral injection
+* pipeline (system_reminder or notification XML tag). Such messages
+* must never be merged with an adjacent real user turn — doing so would
+* smear the injection's XML wrapper into the user's actual prompt and
+* confuse the LLM about where the system annotation ends.
 *
-* Crash recovery detects "wire.jsonl missing but wire.N.jsonl exists"
-* and rolls back the lowest-numbered archive to `wire.jsonl`.
 */
-const ARCHIVE_PATTERN = /^wire\.(\d+)\.jsonl$/;
-function extractArchiveNumber(name) {
-	const captured = ARCHIVE_PATTERN.exec(name)?.[1];
-	return captured !== void 0 ? Number.parseInt(captured, 10) : 0;
+function isInjectionUserMessage(message) {
+	if (message.role !== "user") return false;
+	const trimmed = extractTextOnly(message).trimStart();
+	if (trimmed.startsWith("<notification ")) return true;
+	if (trimmed.startsWith("<system-reminder>")) return true;
+	return false;
+}
+function mergeAdjacentUserMessages(history) {
+	const out = [];
+	for (const message of history) {
+		const previous = out.at(-1);
+		if (message.role === "user" && previous !== void 0 && previous.role === "user" && !isInjectionUserMessage(message) && !isInjectionUserMessage(previous)) {
+			out[out.length - 1] = mergeTwoUserMessages(previous, message);
+			continue;
+		}
+		out.push(cloneMessage(message));
+	}
+	return out;
+}
+function mergeTwoUserMessages(a, b) {
+	const aText = extractTextOnly(a);
+	const bText = extractTextOnly(b);
+	const nonTextParts = [...a.content.filter((p) => p.type !== "text"), ...b.content.filter((p) => p.type !== "text")];
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: `${aText}\n\n${bText}`
+		}, ...nonTextParts],
+		toolCalls: []
+	};
+}
+function extractTextOnly(message) {
+	return message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+}
+function cloneMessage(message) {
+	return {
+		role: message.role,
+		name: message.name,
+		content: message.content.map((p) => ({ ...p })),
+		toolCalls: message.toolCalls.map((tc) => ({ ...tc })),
+		toolCallId: message.toolCallId,
+		partial: message.partial
+	};
+}
+//#endregion
+//#region ../../packages/kimi-core/src/storage/state/record-builders.ts
+function buildUserMessageRecord(turnId, input) {
+	return {
+		type: "user_message",
+		turn_id: turnId,
+		content: input.parts !== void 0 ? input.parts : input.text
+	};
+}
+function buildToolResultRecord(turnId, parentUuid, toolCallId, normalisedOutput, result) {
+	return {
+		type: "tool_result",
+		turn_id: turnId,
+		tool_call_id: toolCallId,
+		output: normalisedOutput,
+		parent_uuid: parentUuid,
+		is_error: result.isError,
+		synthetic: result.synthetic
+	};
+}
+function buildStepBeginRecord(input) {
+	return {
+		type: "step_begin",
+		uuid: input.uuid,
+		turn_id: input.turnId,
+		step: input.step
+	};
+}
+function buildStepEndRecord(input) {
+	return {
+		type: "step_end",
+		uuid: input.uuid,
+		turn_id: input.turnId,
+		step: input.step,
+		usage: input.usage,
+		finish_reason: input.finishReason
+	};
+}
+function buildContentPartRecord(input) {
+	return {
+		type: "content_part",
+		uuid: input.uuid,
+		turn_id: input.turnId,
+		step: input.step,
+		step_uuid: input.stepUuid,
+		role: "assistant",
+		part: input.part.kind === "text" ? {
+			kind: "text",
+			text: input.part.text
+		} : input.part.encrypted !== void 0 ? {
+			kind: "think",
+			think: input.part.think,
+			encrypted: input.part.encrypted
+		} : {
+			kind: "think",
+			think: input.part.think
+		}
+	};
+}
+function buildToolCallRecord(input, data) {
+	return {
+		type: "tool_call",
+		uuid: input.uuid,
+		turn_id: input.turnId,
+		step: input.step,
+		step_uuid: input.stepUuid,
+		data
+	};
 }
-/**
-* Compute the next archive filename for a rotation:
-*   - No archives exist → `wire.1.jsonl`
-*   - Highest existing is `wire.3.jsonl` → `wire.4.jsonl`
-*/
-function nextArchiveName(sessionDir, existingArchives) {
-	let maxN = 0;
-	for (const archive of existingArchives) {
-		const n = extractArchiveNumber(archive);
-		if (n > maxN) maxN = n;
-	}
-	return join(sessionDir, `wire.${maxN + 1}.jsonl`);
+function buildNotificationRecord(data) {
+	return {
+		type: "notification",
+		data
+	};
 }
-async function rotateJournal(sessionDir, options) {
-	const { producer, protocolVersion, ...deps } = options;
-	const version = protocolVersion ?? "2.1";
-	const currentPath = join(sessionDir, "wire.jsonl");
-	const archivePath = nextArchiveName(sessionDir, (await readdir(sessionDir)).filter((e) => ARCHIVE_PATTERN.test(e)));
-	const renameFn = deps.renameFn ?? rename;
-	const retryDelayMs = deps.retryDelayMs ?? 500;
-	try {
-		await renameFn(currentPath, archivePath);
-	} catch (error) {
-		const code = error.code;
-		if (process.platform === "win32" && code === "EPERM") {
-			await new Promise((resolve, reject) => {
-				const timer = setTimeout(resolve, retryDelayMs);
-				const abortSignal = deps.signal;
-				if (abortSignal !== void 0) {
-					const onAbort = () => {
-						clearTimeout(timer);
-						reject(abortSignal.reason ?? /* @__PURE__ */ new Error("aborted"));
-					};
-					if (abortSignal.aborted) onAbort();
-					else abortSignal.addEventListener("abort", onAbort, { once: true });
-				}
-			});
-			await renameFn(currentPath, archivePath);
-		} else throw error;
-	}
-	await writeFileAtomicDurable(currentPath, JSON.stringify({
-		type: "metadata",
-		protocol_version: version,
-		created_at: Date.now(),
-		producer,
-		kimi_version: producer.version
-	}) + "\n");
-	await syncDir(sessionDir);
+function buildSystemReminderRecord(data) {
 	return {
-		archivePath,
-		newCurrentPath: currentPath
+		type: "system_reminder",
+		content: data.content
 	};
 }
-/**
-* Find the highest-numbered archive in a list of archive filenames.
-* Returns the filename and its number, or `undefined` if the list is empty.
-*/
-function findHighestArchive(archives) {
-	let highestN = 0;
-	let result;
-	for (const name of archives) {
-		const n = extractArchiveNumber(name);
-		if (n > highestN) {
-			highestN = n;
-			result = name;
-		}
+function buildClearRecord() {
+	return { type: "context_cleared" };
+}
+function buildConfigChangeRecord(event) {
+	switch (event.type) {
+		case "system_prompt_changed": return {
+			type: "system_prompt_changed",
+			new_prompt: event.new_prompt
+		};
+		case "tools_changed": return {
+			type: "tools_changed",
+			operation: event.operation,
+			tools: event.tools
+		};
 	}
-	return result !== void 0 ? {
-		name: result,
-		n: highestN
-	} : void 0;
 }
+function buildCompactionRecord(summary) {
+	return {
+		type: "compaction",
+		summary: summary.summary,
+		compacted_range: {
+			from_turn: summary.compactedRange.fromTurn,
+			to_turn: summary.compactedRange.toTurn,
+			message_count: summary.compactedRange.messageCount
+		},
+		pre_compact_tokens: summary.preCompactTokens,
+		post_compact_tokens: summary.postCompactTokens,
+		trigger: summary.trigger,
+		archive_file: summary.archiveFile
+	};
+}
+//#endregion
+//#region ../../packages/kimi-core/src/storage/state/context-state.ts
 /**
-* Detect and recover from a crash between file rotation steps.
-*
-* Three scenarios are handled:
-*
-* 1. **wire.jsonl missing**: `wire.jsonl` was renamed to `wire.N.jsonl`
-*    but the process crashed before the new `wire.jsonl` was created.
-*    Recovery: roll back the highest-numbered archive to `wire.jsonl`.
-*
-* 2. **wire.jsonl is metadata-only** (Slice 3.3 / M04): the rename
-*    succeeded AND the new `wire.jsonl` was created with a metadata
-*    header, but the process crashed before `appendBoundary` ran. The
-*    new file has only the metadata line — no session_initialized, no
-*    compaction record. Recovery: remove the half-complete file and
-*    roll back the highest archive.
+* Core ContextState logic. Both `WiredContextState` and
+* `InMemoryContextState` are thin wrappers that differ only in the journal
+* writer they supply and the constructor shape they expose.
 *
-* 3. **wire.jsonl has metadata + session_initialized only** (Phase 23 /
-*    T7.7): `appendBoundary` copied `session_initialized` through as the
-*    second line, but the process crashed before the compaction record
-*    landed. Without the compaction record, the archived conversation is
-*    orphaned — replay of the new wire would show an empty post-boundary
-*    window and the archive would never be re-read. Recovery: same as
-*    case 2 — remove the half-complete file and restore the archive.
+* WAL-then-mirror atomicity:
+*   1. build the WireRecord
+*   2. await journalWriter.append(...)
+*   3. on success only, update the in-memory projection
 *
-* Returns `true` if recovery was performed, `false` if no recovery was needed.
+* If step 2 throws, the in-memory state is unchanged.
 */
-async function recoverRotation(sessionDir) {
-	const entries = await readdir(sessionDir);
-	const archives = entries.filter((e) => ARCHIVE_PATTERN.test(e));
-	if (!entries.includes("wire.jsonl")) {
-		const highest = findHighestArchive(archives);
-		if (highest === void 0) return false;
-		await rename(join(sessionDir, highest.name), join(sessionDir, "wire.jsonl"));
+var BaseContextState = class {
+	journalWriter;
+	projector;
+	currentTurnId;
+	memory;
+	_broken = false;
+	_brokenError;
+	/**
+	* Marks all future write entry points as failed. Read methods remain
+	* callable so callers can still inspect the last valid in-memory state.
+	*/
+	markBroken(error) {
+		if (this._broken) return;
+		this._broken = true;
+		this._brokenError = error;
+	}
+	assertNotBroken() {
+		if (this._broken) throw new ContextStateBrokenError("ContextState is broken due to a prior persist error", this._brokenError);
+	}
+	constructor(opts) {
+		this.journalWriter = opts.journalWriter;
+		this.projector = opts.projector ?? new DefaultConversationProjector();
+		this.currentTurnId = opts.currentTurnId;
+		this.memory = new ContextStateMemory(opts);
+	}
+	get model() {
+		return this.memory.model;
+	}
+	get systemPrompt() {
+		return this.memory.systemPrompt;
+	}
+	get activeTools() {
+		return this.memory.activeTools;
+	}
+	get tokenCountWithPending() {
+		return this.memory.tokenCountWithPending;
+	}
+	get thinkingLevel() {
+		return this.memory.thinkingLevel;
+	}
+	get beforeStep() {
+		return this.memory.beforeStep;
+	}
+	buildMessages() {
+		return this.projector.project({
+			history: this.memory.getHistory(),
+			systemPrompt: this.memory.systemPrompt,
+			model: this.memory.model,
+			activeTools: this.memory.activeTools
+		});
+	}
+	async applySteerMessages() {
+		const steers = this.memory.drainSteerMessages();
+		if (steers.length === 0) return false;
+		this.assertNotBroken();
+		for (const steer of steers) await this.appendUserMessage(steer);
 		return true;
 	}
-	if (archives.length > 0) {
-		const currentPath = join(sessionDir, "wire.jsonl");
-		const lines = (await readFile(currentPath, "utf8")).trim().split("\n").filter((l) => l.length > 0);
-		if (lines.length === 1 || lines.length === 2) {
-			const parsedLines = lines.map((l) => {
-				try {
-					return JSON.parse(l);
-				} catch {
-					return null;
-				}
-			});
-			const isMetadata = parsedLines[0]?.["type"] === "metadata";
-			if (lines.length === 1 ? isMetadata : isMetadata && parsedLines[1]?.["type"] === "session_initialized") {
-				const highest = findHighestArchive(archives);
-				if (highest !== void 0) {
-					await unlink(currentPath);
-					await rename(join(sessionDir, highest.name), join(sessionDir, "wire.jsonl"));
-					return true;
-				}
-			}
+	pushSteer(input) {
+		this.memory.pushSteer(input);
+	}
+	setBeforeStepHook(fn) {
+		this.memory.setBeforeStepHook(fn);
+	}
+	getHistory() {
+		return this.memory.getHistory();
+	}
+	async appendUserMessage(input, turnIdOverride) {
+		this.assertNotBroken();
+		const turnId = turnIdOverride ?? this.currentTurnId();
+		await this.journalWriter.append(buildUserMessageRecord(turnId, input));
+		this.memory.appendUserContent(userInputToContentParts(input));
+	}
+	async appendToolResult(parentUuid, toolCallId, result) {
+		this.assertNotBroken();
+		const normalisedOutput = result.output === void 0 ? null : result.output;
+		const turnId = this.currentTurnId();
+		await this.journalWriter.append(buildToolResultRecord(turnId, parentUuid, toolCallId, normalisedOutput, result));
+		this.memory.appendToolResult(toolCallId, toolResultOutputToContentParts(normalisedOutput));
+	}
+	async appendStepBegin(input) {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildStepBeginRecord(input));
+		this.memory.openStep(input.uuid);
+	}
+	async appendStepEnd(input) {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildStepEndRecord(input));
+		this.memory.closeStep(input.uuid, input.usage);
+	}
+	async appendContentPart(input) {
+		this.assertNotBroken();
+		if (this.memory.getOpenStep(input.stepUuid) === void 0) throw new Error(`appendContentPart: unknown stepUuid '${input.stepUuid}' (no open step_begin)`);
+		await this.journalWriter.append(buildContentPartRecord(input));
+		this.memory.appendOpenStepContent(input.stepUuid, atomicPartToContentPart(input.part));
+	}
+	async appendToolCall(input) {
+		this.assertNotBroken();
+		if (this.memory.getOpenStep(input.stepUuid) === void 0) throw new Error(`appendToolCall: unknown stepUuid '${input.stepUuid}' (no open step_begin)`);
+		const data = sanitizeToolCallData(input.data);
+		await this.journalWriter.append(buildToolCallRecord(input, data));
+		this.memory.appendOpenStepToolCall(input.stepUuid, toolCallDataToKosongToolCall(input.data));
+	}
+	async appendNotification(data) {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildNotificationRecord(data));
+		const text = renderNotificationXml(data);
+		this.memory.appendUserContent([{
+			type: "text",
+			text
+		}]);
+	}
+	async appendSystemReminder(data) {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildSystemReminderRecord(data));
+		const text = `<system-reminder>\n${data.content}\n</system-reminder>`;
+		this.memory.appendUserContent([{
+			type: "text",
+			text
+		}]);
+	}
+	async clear() {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildClearRecord());
+		this.memory.clearConversation();
+	}
+	async applyConfigChange(event) {
+		this.assertNotBroken();
+		switch (event.type) {
+			case "system_prompt_changed":
+				await this.journalWriter.append(buildConfigChangeRecord(event));
+				this.memory.setSystemPrompt(event.new_prompt);
+				return;
+			case "tools_changed":
+				await this.journalWriter.append(buildConfigChangeRecord(event));
+				this.memory.applyToolsChanged(event.operation, event.tools);
 		}
 	}
-	return false;
-}
+	setModel(model) {
+		this.memory.setModel(model);
+	}
+	setThinkingLevel(level) {
+		this.memory.setThinkingLevel(level);
+	}
+	async resetToSummary(summary) {
+		this.assertNotBroken();
+		await this.journalWriter.append(buildCompactionRecord(summary));
+		this.memory.resetToSummary(summary);
+	}
+};
+var WiredContextState = class extends BaseContextState {};
+var InMemoryContextState = class extends BaseContextState {
+	constructor(opts) {
+		super({
+			...opts,
+			currentTurnId: opts.currentTurnId ?? (() => "embedded"),
+			journalWriter: new NoopJournalWriter()
+		});
+	}
+};
+//#endregion
+//#region ../../packages/kimi-core/src/storage/state/session-journal.ts
+/**
+* Production `SessionJournal` implementation — delegates every append to the
+* shared `JournalWriter`, which in turn serialises to wire.jsonl.
+*
+* Does not mutate any conversation projection state; management records do
+* not change buildMessages().
+*/
+var WiredSessionJournalImpl = class {
+	constructor(journalWriter) {
+		this.journalWriter = journalWriter;
+	}
+	async appendTurnBegin(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendTurnEnd(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendSkillInvoked(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendSkillCompleted(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendApprovalRequest(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendApprovalResponse(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendTeamMail(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendToolDenied(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendSubagentSpawned(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendSubagentCompleted(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendSubagentFailed(data) {
+		await this.journalWriter.append(data);
+	}
+	async appendOwnershipChanged(data) {
+		await this.journalWriter.append(data);
+	}
+};
 //#endregion
 //#region ../../packages/kimi-core/src/storage/fs/atomic-write.ts
 /**
@@ -2599,10 +2622,8 @@ async function raceExecuteWithGraceTimeout(executePromise, signal, toolName) {
 * later abort during tool execution does not lose the LLM usage that was
 * already spent.
 */
-const UNKNOWN_TURN_ID = "unknown-turn";
 async function executeSoulStep(deps) {
-	const { config, context, runtime, signal, overrides, currentStep, emit, recordUsage } = deps;
-	const turnId = context.currentTurnId?.() ?? UNKNOWN_TURN_ID;
+	const { config, context, turnId, runtime, signal, overrides, currentStep, emit, recordUsage } = deps;
 	if (config.beforeStep !== void 0) {
 		const beforeStep = await config.beforeStep({
 			turnId,
@@ -2700,6 +2721,7 @@ function toStepEndUsage(usage) {
 //#endregion
 //#region ../../packages/kimi-core/src/soul/run-turn.ts
 const DEFAULT_MAX_STEPS = 100;
+const UNKNOWN_TURN_ID = "unknown-turn";
 async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 	const maxSteps = config.maxSteps ?? DEFAULT_MAX_STEPS;
 	const usage = {
@@ -2710,6 +2732,7 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 	};
 	let steps = 0;
 	let stopReason = "end_turn";
+	const turnId = context.currentTurnId?.() ?? UNKNOWN_TURN_ID;
 	try {
 		while (true) {
 			signal.throwIfAborted();
@@ -2721,6 +2744,7 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 			steps += 1;
 			const stepResult = await executeSoulStep({
 				config,
+				turnId,
 				context,
 				runtime,
 				signal,
@@ -2735,7 +2759,12 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 			});
 			if (stepResult.stopReason === "tool_use") continue;
 			stopReason = stepResult.stopReason;
-			if (!(await config.beforeTurnCompletes?.())?.continue) break;
+			if (!(await config.beforeTurnCompletes?.({
+				...stepResult,
+				turnId,
+				stepNumber: steps,
+				context
+			}))?.continue) break;
 		}
 	} catch (error) {
 		if (isAbortError$3(error) || signal.aborted) {
@@ -3065,6 +3094,25 @@ var SubagentTooDeepError = class extends Error {
 		this.limit = limit;
 	}
 };
+function classifyBusinessError(error) {
+	if (error instanceof LLMNotSetError) return {
+		code: -32001,
+		message: error.message
+	};
+	if (error instanceof LLMCapabilityMismatchError) return {
+		code: -32002,
+		message: error.message
+	};
+	if (error instanceof ProviderError) return {
+		code: -32003,
+		message: error.message
+	};
+	if (error instanceof Error && /provider|backend|upstream/i.test(error.message)) return {
+		code: -32003,
+		message: error.message
+	};
+	return null;
+}
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/soul-registry.ts
 /**
@@ -5721,14 +5769,19 @@ function registerInteractiveTools(options) {
 * precomputed `tokenCountWithPending` off `SoulContextState`.
 */
 /**
-* Estimate token count from text using a character-based heuristic
-* (~4 chars per token for English; underestimates for CJK). The
-* estimate is transient — the next LLM call returns the real count
+* Estimate token count from text using a character-based heuristic.
+*   - ASCII (~4 chars per token)
+*   - CJK and other non-ASCII (~1 char per token)
+* The estimate is transient — the next LLM call returns the real count
 * and supersedes this value. Used to keep `tokenCountWithPending`
 * monotonic between LLM round-trips without paying for a tokenizer.
 */
 function estimateTokens(text) {
-	return Math.ceil(text.length / 4);
+	let asciiCount = 0;
+	let nonAsciiCount = 0;
+	for (const char of text) if (char.codePointAt(0) <= 127) asciiCount++;
+	else nonAsciiCount++;
+	return Math.ceil(asciiCount / 4) + nonAsciiCount;
 }
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/compaction/compaction-orchestrator.ts
@@ -5744,7 +5797,7 @@ var CompactionOrchestrator = class {
 	*   2. emit compaction.begin
 	*   3. provider.run(messages, signal, {userInstructions?})
 	*   4. journalWriter.flush()           (Phase 3 铁律 — before rotate)
-	*   5. journalCapability.rotate(...)
+	*   5. journalWriter.rotate(...)
 	*   6. contextState.resetToSummary(storageSummary)
 	*   7. emit compaction.end
 	*   8. finally: transitionTo('active')
@@ -5758,6 +5811,8 @@ var CompactionOrchestrator = class {
 	* CompactionRecord.
 	*/
 	async executeCompaction(signal, customInstruction, trigger = "auto") {
+		const rotateCapability = this.deps.journalWriter.rotateCapability;
+		if (!rotateCapability) throw new Error("JournalWriter missing rotate capability");
 		const machine = this.deps.lifecycleStateMachine;
 		machine.transitionTo("compacting");
 		let tailUserText;
@@ -5768,22 +5823,17 @@ var CompactionOrchestrator = class {
 			const preCompactTokens = this.deps.contextState.tokenCountWithPending;
 			const summary = await (this.deps.runtimeSlot?.current().compactionProvider ?? this.deps.compactionProvider).run(messages, signal, customInstruction !== void 0 ? { userInstructions: customInstruction } : void 0);
 			signal.throwIfAborted();
-			const baselineInit = await this.deps.journalCapability.readSessionInitialized();
+			const baselineInit = await rotateCapability.readSessionInitialized();
 			const cs = this.deps.contextState;
 			const sessionInitialized = applyRuntimeOverlay(baselineInit, {
 				system_prompt: cs.systemPrompt,
 				active_tools: [...cs.activeTools]
 			});
-			await this.deps.journalWriter.flush();
-			const rotateResult = await this.deps.journalCapability.rotate({
-				type: "compaction_boundary",
-				summary,
-				parent_file: ""
-			});
-			await this.deps.journalCapability.appendBoundary(sessionInitialized);
-			const storageSummary = bridgeSummaryMessage(summary, messages.length, preCompactTokens, trigger, rotateResult.archiveFile);
-			await this.deps.contextState.resetToSummary(storageSummary);
+			const rotateResult = await rotateCapability.rotate();
+			await rotateCapability.appendBoundary(sessionInitialized);
 			tailUserText = extractUnpairedTailUserText(messages);
+			const storageSummary = bridgeSummaryMessage(summary, messages.length, preCompactTokens, trigger, rotateResult.archivePath, this.deps.contextState.systemPrompt, tailUserText);
+			await this.deps.contextState.resetToSummary(storageSummary);
 			this.deps.sink.emit({
 				type: "compaction.end",
 				tokensBefore: preCompactTokens,
@@ -5887,7 +5937,10 @@ function extractUnpairedTailUserText(messages) {
 		return parts.length > 0 ? parts.join("") : void 0;
 	}
 }
-function bridgeSummaryMessage(providerSummary, messagesCount, preCompactTokens, trigger, archiveFile) {
+function bridgeSummaryMessage(providerSummary, messagesCount, preCompactTokens, trigger, archivePath, systemPrompt, tailUserText) {
+	const summaryTokens = estimateTokens(providerSummary.content);
+	const systemTokens = systemPrompt ? estimateTokens(systemPrompt) : 0;
+	const tailTokens = tailUserText ? estimateTokens(tailUserText) : 0;
 	return {
 		summary: providerSummary.content,
 		compactedRange: {
@@ -5896,9 +5949,9 @@ function bridgeSummaryMessage(providerSummary, messagesCount, preCompactTokens,
 			messageCount: messagesCount
 		},
 		preCompactTokens,
-		postCompactTokens: estimateTokens(providerSummary.content),
+		postCompactTokens: summaryTokens + systemTokens + tailTokens,
 		trigger,
-		archiveFile
+		archivePath
 	};
 }
 //#endregion
@@ -5924,7 +5977,6 @@ function createSoulPlusCompactionOrchestrator(deps) {
 		compactionProvider: deps.compactionProvider,
 		runtimeSlot: deps.runtimeSlot,
 		lifecycleStateMachine: deps.lifecycleStateMachine,
-		journalCapability: deps.journalCapability,
 		sink: deps.sink,
 		journalWriter: deps.journalWriter,
 		sessionId: deps.sessionId,
@@ -6922,53 +6974,84 @@ function toWirePatch(p) {
 	return out;
 }
 //#endregion
-//#region ../../packages/kimi-core/src/soul-plus/turn/dynamic-injection.ts
-var DynamicInjectionManager = class {
-	providers = [];
-	onProviderError;
-	constructor(options = {}) {
-		if (options.initialProviders !== void 0) for (const provider of options.initialProviders) this.register(provider);
-		this.onProviderError = options.onProviderError;
-	}
-	/**
-	* Register a provider. Registration is idempotent on `id`: a second
-	* register with the same id replaces the previous entry in place.
-	* This keeps host-side re-initialisation (e.g. SessionManager resume)
-	* from double-injecting a built-in reminder.
-	*/
-	register(provider) {
-		const existing = this.providers.findIndex((p) => p.id === provider.id);
-		if (existing === -1) {
-			this.providers.push(provider);
-			return;
+//#region ../../packages/kimi-core/src/soul-plus/injection/types.ts
+/**
+* Extract the text content from a history message.
+*/
+function historyMessageText(msg) {
+	return msg.content.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+}
+/**
+* Scan history backwards and classify the plan-mode dedup state.
+*
+* The scan stops at the first `user` message it encounters going
+* backwards:
+*   - If that user message is a plan-mode reminder → returns
+*     `{found:true, newUserSinceReminder:false, assistantTurnsSince}`.
+*     The caller decides dedup vs sparse vs full by consulting the
+*     assistant-turn counter.
+*   - If that user message is a real user prompt (not a reminder) →
+*     returns `{found:false, newUserSinceReminder:true, …}`. The caller
+*     treats this as a fresh turn and emits the full reminder.
+*   - If no user message exists at all → returns
+*     `{found:false, newUserSinceReminder:false, …}`. First-time
+*     injection.
+*
+* Only counts ASSISTANT messages between the tail and the reminder.
+* Non-reminder user messages never appear inside that window because
+* the scan stops at them.
+*/
+function scanPlanReminderHistory(history) {
+	let assistantTurnsSince = 0;
+	for (let i = history.length - 1; i >= 0; i--) {
+		const msg = history[i];
+		if (msg === void 0) continue;
+		if (msg.role === "assistant") {
+			assistantTurnsSince += 1;
+			continue;
 		}
-		this.providers[existing] = provider;
-	}
-	unregister(id) {
-		const idx = this.providers.findIndex((p) => p.id === id);
-		if (idx !== -1) this.providers.splice(idx, 1);
-	}
-	/** Read-only view of registered providers. Primarily for tests. */
-	list() {
-		return this.providers;
-	}
-	/**
-	* Collect every active injection for the upcoming LLM step. Providers
-	* are iterated in registration order; a provider that throws is
-	* isolated (error forwarded to `onProviderError`, remaining providers
-	* still run). Same error-isolation pattern as HookEngine / SessionEventBus.
-	*/
-	computeInjections(ctx, contextState) {
-		const out = [];
-		for (const provider of this.providers) try {
-			const injections = provider.getInjections(ctx, contextState);
-			if (injections !== void 0 && injections !== null && Array.isArray(injections) && injections.length > 0) out.push(...injections);
-		} catch (error) {
-			this.onProviderError?.(provider, error instanceof Error ? error : new Error(String(error)));
+		if (msg.role === "user") {
+			if (isPlanReminderMessage(msg)) return {
+				found: true,
+				newUserSinceReminder: false,
+				assistantTurnsSince
+			};
+			return {
+				found: false,
+				newUserSinceReminder: true,
+				assistantTurnsSince
+			};
 		}
-		return out;
 	}
-};
+	return {
+		found: false,
+		newUserSinceReminder: false,
+		assistantTurnsSince
+	};
+}
+function isPlanReminderMessage(msg) {
+	const text = historyMessageText(msg);
+	if (!text.trimStart().startsWith("<system-reminder>")) return false;
+	return text.includes("Plan mode is active") || text.includes("Plan mode still active") || text.includes("Re-entering Plan Mode");
+}
+/**
+* Same as above but for yolo mode reminder.
+*/
+function hasYoloReminderWithoutNewUser(history) {
+	return hasReminderWithoutNewUser(history, "yolo");
+}
+function hasReminderWithoutNewUser(history, fingerprint) {
+	for (let i = history.length - 1; i >= 0; i--) {
+		const msg = history[i];
+		if (msg === void 0) continue;
+		const text = historyMessageText(msg);
+		if (msg.role === "user" && text.trimStart().startsWith("<system-reminder>") && text.toLowerCase().includes(fingerprint.toLowerCase())) return true;
+		if (msg.role === "user" && !text.trimStart().startsWith("<system-reminder>") && !text.trimStart().startsWith("<notification")) return false;
+	}
+	return false;
+}
+//#endregion
+//#region ../../packages/kimi-core/src/soul-plus/injection/plan-mode.ts
 /**
 * Phase 18 §D.6 — reminder cadence constants.
 *
@@ -7033,7 +7116,7 @@ var PlanModeInjectionProvider = class {
 		if (scan.assistantTurnsSince >= PLAN_MODE_DEDUP_MIN_TURNS) return "sparse";
 		return null;
 	}
-	getInjections(ctx, contextState) {
+	getInjections(ctx) {
 		if (!ctx.planMode) {
 			this.pendingReentry = false;
 			return [];
@@ -7041,23 +7124,19 @@ var PlanModeInjectionProvider = class {
 		const planFilePath = ctx.planFilePath;
 		if (this.pendingReentry) {
 			this.pendingReentry = false;
-			return emit$1(contextState, reentryReminder(planFilePath));
+			return [{
+				kind: "system_reminder",
+				content: reentryReminder(planFilePath)
+			}];
 		}
 		const variant = this.getVariant(ctx);
 		if (variant === null) return [];
-		return emit$1(contextState, variant === "full" ? fullReminder(planFilePath) : variant === "sparse" ? sparseReminder(planFilePath) : reentryReminder(planFilePath));
+		return [{
+			kind: "system_reminder",
+			content: variant === "full" ? fullReminder(planFilePath) : variant === "sparse" ? sparseReminder(planFilePath) : reentryReminder(planFilePath)
+		}];
 	}
 };
-function emit$1(contextState, content) {
-	if (contextState !== void 0) {
-		contextState.appendSystemReminder({ content });
-		return;
-	}
-	return [{
-		kind: "system_reminder",
-		content
-	}];
-}
 /**
 * Phase 18 §D.7 — when the host has resolved the session's plan-file
 * path, append a `Plan file: {path}` footer so the LLM can target
@@ -7166,6 +7245,13 @@ function inlineReentryReminder() {
 		"Your turn must end with either AskUserQuestion (to clarify requirements) or ExitPlanMode (to request plan approval)."
 	].join("\n");
 }
+//#endregion
+//#region ../../packages/kimi-core/src/soul-plus/injection/yolo-mode.ts
+const YOLO_MODE_REMINDER = [
+	"You are running in non-interactive (yolo) mode. The user cannot answer questions or provide feedback during execution.",
+	"  - Do NOT call AskUserQuestion. If you need to make a decision, make your best judgment and proceed.",
+	"  - For ExitPlanMode, it will be auto-approved. You can use it normally but expect no user feedback."
+].join("\n");
 /**
 * Yolo-mode reminder ported from Python `yolo_mode.py`. One-shot per
 * activation: the first turn after `permissionMode` flips to
@@ -7176,7 +7262,7 @@ function inlineReentryReminder() {
 var YoloModeInjectionProvider = class {
 	id = "yolo_mode";
 	injected = false;
-	getInjections(ctx, contextState) {
+	getInjections(ctx) {
 		if (ctx.permissionMode !== "bypassPermissions") {
 			this.injected = false;
 			return [];
@@ -7184,101 +7270,62 @@ var YoloModeInjectionProvider = class {
 		if (ctx.history !== void 0 && hasYoloReminderWithoutNewUser(ctx.history)) return [];
 		if (this.injected) return [];
 		this.injected = true;
-		if (contextState !== void 0) {
-			contextState.appendSystemReminder({ content: YOLO_MODE_REMINDER });
-			return;
-		}
 		return [{
 			kind: "system_reminder",
 			content: YOLO_MODE_REMINDER
 		}];
 	}
 };
-const YOLO_MODE_REMINDER = [
-	"You are running in non-interactive (yolo) mode. The user cannot answer questions or provide feedback during execution.",
-	"  - Do NOT call AskUserQuestion. If you need to make a decision, make your best judgment and proceed.",
-	"  - For ExitPlanMode, it will be auto-approved. You can use it normally but expect no user feedback."
-].join("\n");
-/**
-* Extract the text content from a history message.
-*/
-function historyMessageText(msg) {
-	return msg.content.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
-}
-/**
-* Scan history backwards for the most recent `<system-reminder>` that
-* contains the plan mode fingerprint. If found and no new user message
-* has appeared since, return true (dedup hit).
-*/
-/**
-* Scan history backwards and classify the plan-mode dedup state.
-*
-* The scan stops at the first `user` message it encounters going
-* backwards:
-*   - If that user message is a plan-mode reminder → returns
-*     `{found:true, newUserSinceReminder:false, assistantTurnsSince}`.
-*     The caller decides dedup vs sparse vs full by consulting the
-*     assistant-turn counter.
-*   - If that user message is a real user prompt (not a reminder) →
-*     returns `{found:false, newUserSinceReminder:true, …}`. The caller
-*     treats this as a fresh turn and emits the full reminder.
-*   - If no user message exists at all → returns
-*     `{found:false, newUserSinceReminder:false, …}`. First-time
-*     injection.
-*
-* Only counts ASSISTANT messages between the tail and the reminder.
-* Non-reminder user messages never appear inside that window because
-* the scan stops at them.
-*/
-function scanPlanReminderHistory(history) {
-	let assistantTurnsSince = 0;
-	for (let i = history.length - 1; i >= 0; i--) {
-		const msg = history[i];
-		if (msg === void 0) continue;
-		if (msg.role === "assistant") {
-			assistantTurnsSince += 1;
-			continue;
-		}
-		if (msg.role === "user") {
-			if (isPlanReminderMessage(msg)) return {
-				found: true,
-				newUserSinceReminder: false,
-				assistantTurnsSince
-			};
-			return {
-				found: false,
-				newUserSinceReminder: true,
-				assistantTurnsSince
-			};
+//#endregion
+//#region ../../packages/kimi-core/src/soul-plus/injection/manager.ts
+var DynamicInjectionManager = class {
+	providers = [];
+	onProviderError;
+	constructor(options = {}) {
+		if (options.initialProviders !== void 0) for (const provider of options.initialProviders) this.register(provider);
+		this.onProviderError = options.onProviderError;
+	}
+	/**
+	* Register a provider. Registration is idempotent on `id`: a second
+	* register with the same id replaces the previous entry in place.
+	* This keeps host-side re-initialisation (e.g. SessionManager resume)
+	* from double-injecting a built-in reminder.
+	*/
+	register(provider) {
+		const existing = this.providers.findIndex((p) => p.id === provider.id);
+		if (existing === -1) {
+			this.providers.push(provider);
+			return;
 		}
+		this.providers[existing] = provider;
 	}
-	return {
-		found: false,
-		newUserSinceReminder: false,
-		assistantTurnsSince
-	};
-}
-function isPlanReminderMessage(msg) {
-	const text = historyMessageText(msg);
-	if (!text.trimStart().startsWith("<system-reminder>")) return false;
-	return text.includes("Plan mode is active") || text.includes("Plan mode still active") || text.includes("Re-entering Plan Mode");
-}
-/**
-* Same as above but for yolo mode reminder.
-*/
-function hasYoloReminderWithoutNewUser(history) {
-	return hasReminderWithoutNewUser(history, "yolo");
-}
-function hasReminderWithoutNewUser(history, fingerprint) {
-	for (let i = history.length - 1; i >= 0; i--) {
-		const msg = history[i];
-		if (msg === void 0) continue;
-		const text = historyMessageText(msg);
-		if (msg.role === "user" && text.trimStart().startsWith("<system-reminder>") && text.toLowerCase().includes(fingerprint.toLowerCase())) return true;
-		if (msg.role === "user" && !text.trimStart().startsWith("<system-reminder>") && !text.trimStart().startsWith("<notification")) return false;
+	unregister(id) {
+		const idx = this.providers.findIndex((p) => p.id === id);
+		if (idx !== -1) this.providers.splice(idx, 1);
 	}
-	return false;
-}
+	/** Read-only view of registered providers. Primarily for tests. */
+	list() {
+		return this.providers;
+	}
+	/**
+	* Collect every active injection for the upcoming LLM step. Providers
+	* are iterated in registration order; a provider that throws is
+	* isolated (error forwarded to `onProviderError`, remaining providers
+	* still run). Same error-isolation pattern as HookEngine / SessionEventBus.
+	*/
+	computeInjections(ctx, contextState) {
+		const out = [];
+		for (const provider of this.providers) try {
+			const injections = provider.getInjections(ctx);
+			if (injections !== void 0 && injections !== null && Array.isArray(injections) && injections.length > 0) if (contextState !== void 0) for (const injection of injections) if (injection.kind === "system_reminder" && typeof injection.content === "string") contextState.appendSystemReminder({ content: injection.content });
+			else throw new Error(`Unsupported injection kind "${injection.kind}" from provider "${provider.id}"`);
+			else out.push(...injections);
+		} catch (error) {
+			this.onProviderError?.(provider, error instanceof Error ? error : new Error(String(error)));
+		}
+		return out;
+	}
+};
 /**
 * Build a DynamicInjectionManager pre-populated with the two Phase 3
 * built-in providers (plan-mode + yolo-mode). Hosts that want additional
@@ -7442,19 +7489,25 @@ function extractText(message, sep = "") {
 }
 //#endregion
 //#region ../../packages/kosong/src/capability.ts
+const UNKNOWN_CAPABILITY_MARKER = Symbol.for("moonshot-ai.kosong.UNKNOWN_CAPABILITY");
 /**
 * Shared read-only default returned when a provider has not catalogued a
 * given model. Frozen so accidental mutation at one call site cannot leak
 * into another.
 */
-const UNKNOWN_CAPABILITY = Object.freeze({
+const UNKNOWN_CAPABILITY = Object.freeze(Object.defineProperty({
 	image_in: false,
 	video_in: false,
 	audio_in: false,
 	thinking: false,
 	tool_use: false,
 	max_context_tokens: 0
-});
+}, UNKNOWN_CAPABILITY_MARKER, { value: true }));
+function isUnknownCapability(capability) {
+	if (capability === UNKNOWN_CAPABILITY) return true;
+	if (capability[UNKNOWN_CAPABILITY_MARKER] === true) return true;
+	return capability.image_in === false && capability.video_in === false && capability.audio_in === false && capability.thinking === false && capability.tool_use === false && capability.max_context_tokens === 0;
+}
 //#endregion
 //#region ../../packages/kosong/src/errors.ts
 /**
@@ -20511,6 +20564,17 @@ function zeroUsage() {
 		output: 0
 	};
 }
+function configuredCapabilitiesToModelCapability(capabilities, maxContextTokens) {
+	const caps = new Set(capabilities.map((cap) => cap.toLowerCase()));
+	return {
+		image_in: caps.has("image_in"),
+		video_in: caps.has("video_in"),
+		audio_in: caps.has("audio_in"),
+		thinking: caps.has("thinking") || caps.has("always_thinking"),
+		tool_use: caps.has("tool_use"),
+		max_context_tokens: maxContextTokens
+	};
+}
 function mergeTurnRules(sessionRules, pendingOverrides) {
 	if (pendingOverrides === void 0) return sessionRules;
 	const turnRules = [];
@@ -20771,8 +20835,12 @@ var TurnManager = class {
 	async handlePrompt(req) {
 		if (!this.deps.lifecycleStateMachine.isIdle() || this.getCurrentTurnId() !== void 0) return { error: "agent_busy" };
 		const input = req.data.input;
-		const capability = ((this.runtimeSlot?.current())?.runtime ?? this.runtime).kosong.getCapability?.(this.deps.contextState.model);
-		if (capability !== void 0 && capability !== UNKNOWN_CAPABILITY) {
+		const runtimeBundle = this.runtimeSlot?.current();
+		const runtime = runtimeBundle?.runtime ?? this.runtime;
+		const configuredCapabilities = runtimeBundle !== void 0 ? runtimeBundle.modelCapabilities : this.deps.modelCapabilities;
+		const capability = configuredCapabilities !== void 0 ? configuredCapabilitiesToModelCapability(configuredCapabilities, runtimeBundle?.compactionConfig?.maxContextSize ?? this.compactionConfig?.maxContextSize ?? 0) : runtime.kosong.getCapability?.();
+		const capabilityIsAuthoritative = configuredCapabilities !== void 0 || capability !== void 0 && !isUnknownCapability(capability);
+		if (capability !== void 0 && capabilityIsAuthoritative) {
 			let inputContainsImage = false;
 			let inputContainsVideo = false;
 			for (const part of input.parts ?? []) if (part.type === "image_url") inputContainsImage = true;
@@ -21211,7 +21279,6 @@ var SoulPlus = class {
 		const contextState = deps.contextState;
 		const sessionJournal = deps.sessionJournal;
 		const journalWriter = contextState.journalWriter;
-		const journalCapability = deps.journalCapability;
 		const runtimeSlot = deps.runtimeSlot ?? createSessionRuntimeSlot({
 			model: contextState.model,
 			runtime: deps.runtime,
@@ -21239,7 +21306,6 @@ var SoulPlus = class {
 			compactionProvider,
 			runtimeSlot,
 			lifecycleStateMachine: stateMachine,
-			journalCapability,
 			sink: eventBus,
 			journalWriter,
 			sessionId: deps.sessionId,
@@ -21307,7 +21373,8 @@ var SoulPlus = class {
 			toolExecutionScopeFactory,
 			approvalRuntime,
 			hookEngine: deps.hookEngine,
-			compactionConfig: deps.compactionConfig
+			compactionConfig: deps.compactionConfig,
+			modelCapabilities: deps.modelCapabilities
 		});
 		turnManagerRef.bind(turnManager);
 		const setPlanMode = createPlanModeSetter({
@@ -21340,8 +21407,7 @@ var SoulPlus = class {
 		this.journal = {
 			writer: journalWriter,
 			contextState,
-			sessionJournal,
-			capability: journalCapability
+			sessionJournal
 		};
 		this.services = {
 			approvalRuntime,
@@ -21964,17 +22030,42 @@ const COMPACTION_SYSTEM_PROMPT = "You are a helpful assistant that compacts conv
 /**
 * Build the compaction prompt from conversation messages.
 *
-* Each message is formatted as a numbered block with its role and text
-* content. Non-text content (images, tool calls, etc.) is omitted —
-* the summary is text-only, matching the Python implementation.
+* Mirrors Python's `SimpleCompaction.prepare()` serialization:
+*   - Each message becomes a block: `## Message N\nRole: X\nContent:\n<text>`
+*   - Only TextPart is retained; think / image / audio / video are dropped.
+*   - Tool results are folded into the assistant message that issued the
+*     call, so the summary sees both the invocation and its result.
+*   - Message blocks are concatenated without separators, matching Python's
+*     `compact_message.content.extend()` behaviour.
+*   - The instruction suffix is joined with a single `\n` to match Python's
+*     `prompt_text = "\n" + prompts.COMPACT`.
 */
 function buildCompactionPrompt(messages, userInstructions) {
+	const toolResultsById = /* @__PURE__ */ new Map();
+	for (const msg of messages) if (msg.role === "tool" && msg.toolCallId) {
+		const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+		toolResultsById.set(msg.toolCallId, text);
+	}
 	const parts = [];
-	for (const [i, msg] of messages.entries()) {
-		const textParts = msg.content.filter((p) => p.type === "text").map((p) => p.text);
-		if (textParts.length > 0) parts.push(`## Message ${i + 1}\nRole: ${msg.role}\nContent:\n${textParts.join("\n")}`);
+	let seq = 1;
+	for (const msg of messages) {
+		if (msg.role === "tool") continue;
+		const body = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+		let block = `## Message ${seq}\nRole: ${msg.role}\nContent:\n${body}`;
+		if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) for (const tc of msg.toolCalls) {
+			let argsDisplay = tc.function.arguments ?? "";
+			try {
+				const parsed = JSON.parse(argsDisplay);
+				argsDisplay = JSON.stringify(parsed);
+			} catch {}
+			const result = toolResultsById.get(tc.id);
+			const resultStr = result !== void 0 ? ` ->\n${result}` : "";
+			block += `\n[Tool: ${tc.function.name}(${argsDisplay})]${resultStr}`;
+		}
+		parts.push((block.endsWith("\n") ? block : block + "\n") + "\n");
+		seq++;
 	}
-	let prompt = parts.join("\n\n") + "\n\nSummarize the above conversation. Preserve:\n- Key decisions and their reasoning\n- Important code snippets, file paths, and technical details\n- Action items and their status\n- Any constraints or requirements mentioned\n\nBe concise but thorough. Do not lose critical context.";
+	let prompt = parts.join("") + "\nSummarize the above conversation. Preserve:\n- Key decisions and their reasoning\n- Important code snippets, file paths, and technical details\n- Action items and their status\n- Any constraints or requirements mentioned\n\nBe concise but thorough. Do not lose critical context.";
 	if (userInstructions !== void 0 && userInstructions.length > 0) prompt += "\n\n**User's Custom Compaction Instruction:**\nThe user has specifically requested the following focus during compaction. You MUST prioritize this instruction above the default compression priorities:\n" + userInstructions;
 	return prompt;
 }
@@ -21993,7 +22084,7 @@ var KosongCompactionProvider = class {
 			toolCalls: []
 		};
 		return {
-			content: (await generate$1(this.provider, COMPACTION_SYSTEM_PROMPT, [], [compactionMessage], void 0, { signal })).message.content.filter((p) => p.type === "text").map((p) => p.text).join("\n"),
+			content: (await generate$1(this.provider, COMPACTION_SYSTEM_PROMPT, [], [compactionMessage], void 0, { signal })).message.content.filter((p) => p.type === "text").map((p) => p.text).join(""),
 			original_turn_count: messages.length
 		};
 	}
@@ -22002,48 +22093,6 @@ function createKosongCompactionProvider(provider) {
 	return new KosongCompactionProvider(provider);
 }
 //#endregion
-//#region ../../packages/kimi-core/src/soul-plus/compaction/journal-capability.ts
-/**
-* WiredJournalCapability — real JournalCapability backed by physical
-* wire.jsonl rotation (Slice 3.3 / M05).
-*
-* Replaces `createStubJournalCapability()` from Slice 3 for production
-* use. Wraps `rotateJournal()` from `src/storage/compaction.ts` and
-* coordinates with `WiredJournalWriter.resetForRotation()` so the
-* journal's monotonic seq counter restarts at 0 in the new file.
-*/
-var WiredJournalCapability = class {
-	sessionDir;
-	journalWriter;
-	producer;
-	constructor(deps) {
-		this.sessionDir = deps.sessionDir;
-		this.journalWriter = deps.journalWriter;
-		this.producer = deps.producer;
-	}
-	async rotate(_boundaryRecord) {
-		const result = await rotateJournal(this.sessionDir, { producer: this.producer });
-		this.journalWriter.resetForRotation();
-		return { archiveFile: basename(result.archivePath) };
-	}
-	async readSessionInitialized() {
-		const wirePath = join(this.sessionDir, "wire.jsonl");
-		const lines = (await readFile(wirePath, "utf-8")).split("\n").filter((l) => l.length > 0);
-		if (lines.length < 2) throw new Error(`readSessionInitialized: wire.jsonl at ${wirePath} has fewer than 2 lines`);
-		const parsed = JSON.parse(lines[1]);
-		const result = SessionInitializedRecordSchema.safeParse(parsed);
-		if (!result.success) throw new Error(`readSessionInitialized: wire.jsonl line 2 at ${wirePath} is not a valid session_initialized record: ${result.error.message}`);
-		return result.data;
-	}
-	async appendBoundary(sessionInitialized) {
-		const { seq: _seq, time: _time, ...input } = sessionInitialized;
-		await this.journalWriter.append(input);
-	}
-};
-function createWiredJournalCapability(deps) {
-	return new WiredJournalCapability(deps);
-}
-//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/approval/wired-approval-runtime.ts
 /**
 * WiredApprovalRuntime — the production `ApprovalRuntime` (v2 §9-G).
@@ -30264,6 +30313,10 @@ const BUS_EVENT_TRANSLATORS = {
 		hook_id: event.hook_id,
 		outcome: event.outcome
 	}),
+	"session.created": (event, ctx) => {
+		const data = event.data;
+		return draft(event, ctx, "session.created", data);
+	},
 	"status.update": (event, ctx) => draft(event, ctx, "status.update", event.data),
 	"session_meta.changed": (event, ctx) => draft(event, ctx, "session_meta.changed", event.data),
 	"thinking.changed": (event, ctx) => draft(event, ctx, "thinking.changed", { level: event.level }),
@@ -30374,6 +30427,9 @@ function installWireEventBridge(opts) {
 *   -32700  Parse error      — codec decode failure (unparseable frame)
 *   -32600  Invalid request  — envelope schema rejection
 *   -32602  Invalid params   — zod-validated method params failure
+*   -32001  LLM not configured
+*   -32002  LLM capability mismatch
+*   -32003  Provider-level failure
 *   -32603  Internal error   — fallback
 */
 function mapToWireError(err) {
@@ -30417,6 +30473,11 @@ function mapToWireError(err) {
 			details: { session_id: err.sessionId }
 		}
 	};
+	const businessError = classifyBusinessError(err);
+	if (businessError !== null) return {
+		request_id: null,
+		error: businessError
+	};
 	return {
 		request_id: null,
 		error: {
@@ -30848,8 +30909,8 @@ var DefaultSessionApplicationService = class {
 			eventBus,
 			hookEngine
 		});
-		const systemPrompt = input.systemPrompt ?? this.deps.defaultSystemPromptProvider?.();
-		const enabledToolNames = this.deps.enabledToolNamesProvider?.();
+		const systemPrompt = input.systemPrompt ?? await this.deps.defaultSystemPromptProvider?.();
+		const enabledToolNames = await this.deps.enabledToolNamesProvider?.();
 		const model = input.model ?? this.deps.defaultModelProvider();
 		const runtimeBundle = await this.deps.runtimeBundleProvider?.({
 			sessionId,
@@ -30863,11 +30924,17 @@ var DefaultSessionApplicationService = class {
 		const runtime = runtimeSlotBundle?.runtime ?? this.deps.runtimeProvider();
 		const compactionProvider = runtimeSlotBundle?.compactionProvider ?? this.deps.compactionProviderProvider();
 		const runtimeSlot = runtimeSlotBundle !== void 0 ? createSessionRuntimeSlot(runtimeSlotBundle) : void 0;
+		const tools = await this.deps.toolsProvider({
+			sessionId,
+			model
+		});
+		const skillManager = await this.deps.skillManagerProvider?.() ?? this.deps.skillManager;
+		const agentTypeRegistry = await this.deps.agentTypeRegistryProvider?.() ?? this.deps.agentTypeRegistry;
 		const managed = await this.deps.sessionManager.createSession({
 			sessionId,
 			runtime,
 			runtimeSlot,
-			tools: this.deps.toolsProvider(),
+			tools,
 			enabledToolNames,
 			model,
 			systemPrompt,
@@ -30878,12 +30945,19 @@ var DefaultSessionApplicationService = class {
 			approvalRuntime: this.deps.approvalRuntime,
 			approvalRuntimeFactory: this.deps.approvalRuntimeFactory,
 			hookEngine,
-			skillManager: this.deps.skillManager,
-			agentTypeRegistry: this.deps.agentTypeRegistry,
+			skillManager,
+			agentTypeRegistry,
 			questionRuntime: this.deps.questionRuntimeProvider?.({ sessionId }),
 			logger: this.deps.logger
 		});
 		this.deps.sessionLifecycle?.onSessionCreated?.(managed);
+		managed.eventBus?.emit({
+			type: "session.created",
+			data: {
+				session_id: managed.sessionId,
+				model
+			}
+		});
 		return {
 			sessionId: managed.sessionId,
 			managed
@@ -30913,18 +30987,24 @@ var DefaultSessionApplicationService = class {
 		const runtime = runtimeSlotBundle?.runtime ?? this.deps.runtimeProvider();
 		const compactionProvider = runtimeSlotBundle?.compactionProvider ?? this.deps.compactionProviderProvider();
 		const runtimeSlot = runtimeSlotBundle !== void 0 ? createSessionRuntimeSlot(runtimeSlotBundle) : void 0;
+		const tools = await this.deps.toolsProvider({
+			sessionId,
+			model: initialModel
+		});
+		const skillManager = await this.deps.skillManagerProvider?.() ?? this.deps.skillManager;
+		const agentTypeRegistry = await this.deps.agentTypeRegistryProvider?.() ?? this.deps.agentTypeRegistry;
 		const managed = await this.deps.sessionManager.resumeSession(sessionId, {
 			runtime,
 			runtimeSlot,
-			tools: this.deps.toolsProvider(),
+			tools,
 			eventBus,
 			compactionProvider,
 			compactionConfig,
 			approvalRuntime: this.deps.approvalRuntime,
 			approvalRuntimeFactory: this.deps.approvalRuntimeFactory,
 			hookEngine,
-			skillManager: this.deps.skillManager,
-			agentTypeRegistry: this.deps.agentTypeRegistry,
+			skillManager,
+			agentTypeRegistry,
 			questionRuntime: this.deps.questionRuntimeProvider?.({ sessionId }),
 			logger: this.deps.logger
 		});
@@ -31116,17 +31196,20 @@ var DefaultSessionApplicationService = class {
 	}
 	async getBackgroundTasks(sessionId) {
 		return {
-			background_tasks: this.deps.backgroundProcessManager?.list() ?? [],
+			background_tasks: this.backgroundProcessManager()?.list() ?? [],
 			agent_instances: await new SubagentStore(this.deps.pathConfig.sessionDir(sessionId)).listInstances()
 		};
 	}
 	async stopBackgroundTask(taskId) {
-		const manager = this.deps.backgroundProcessManager;
+		const manager = this.backgroundProcessManager();
 		if (manager === void 0) throw new Error(`session.stopBackgroundTask: no BackgroundProcessManager wired (task ${taskId})`);
 		if (await manager.stop(taskId) === void 0) throw new Error(`Background task not found: ${taskId}`);
 	}
 	getBackgroundTaskOutput(taskId, tail) {
-		return this.deps.backgroundProcessManager?.getOutput(taskId, tail) ?? "";
+		return this.backgroundProcessManager()?.getOutput(taskId, tail) ?? "";
+	}
+	backgroundProcessManager() {
+		return this.deps.backgroundProcessManagerProvider?.() ?? this.deps.backgroundProcessManager;
 	}
 	getManaged(sessionId) {
 		const managed = this.deps.sessionManager.get(sessionId);
@@ -31603,15 +31686,25 @@ const CONVERSATION_HANDLER_DESCRIPTORS = [
 				}).join("");
 				inputParts = payload.input;
 			}
-			const dispatch = await ctx.sessionApplication.prompt(msg.session_id, {
-				text: inputText,
-				parts: inputParts
-			});
-			return createWireResponse({
-				requestId: msg.id,
-				sessionId: msg.session_id,
-				data: dispatch
-			});
+			try {
+				const dispatch = await ctx.sessionApplication.prompt(msg.session_id, {
+					text: inputText,
+					parts: inputParts
+				});
+				return createWireResponse({
+					requestId: msg.id,
+					sessionId: msg.session_id,
+					data: dispatch
+				});
+			} catch (error) {
+				const classified = classifyBusinessError(error);
+				if (classified !== null) return createWireResponse({
+					requestId: msg.id,
+					sessionId: msg.session_id,
+					error: classified
+				});
+				throw error;
+			}
 		});
 	}),
 	defineWireMethodDescriptor("session.steer", "conversation", (ctx) => {
@@ -32260,6 +32353,7 @@ const SUPPORTED_WIRE_EVENTS = [
 	"notification",
 	"hook.triggered",
 	"hook.resolved",
+	"session.created",
 	"session.error",
 	"session.replay.chunk",
 	"session.replay.end",
@@ -32358,8 +32452,8 @@ function registerDefaultWireHandlers(deps) {
 		sessionManager,
 		pathConfig,
 		runtimeProvider: () => deps.runtimeProvider?.() ?? runtime,
-		toolsProvider: () => tools,
-		...deps.enabledToolNames !== void 0 ? { enabledToolNamesProvider: () => deps.enabledToolNames } : {},
+		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 } : {},
 		defaultModelProvider: () => deps.defaultModelProvider?.() ?? defaultModel,
 		...deps.defaultSystemPromptProvider !== void 0 ? { defaultSystemPromptProvider: deps.defaultSystemPromptProvider } : {},
 		compactionProviderProvider: () => deps.compactionProviderProvider?.() ?? compactionProvider,
@@ -32371,10 +32465,13 @@ function registerDefaultWireHandlers(deps) {
 		workspaceDir,
 		approvalStateStore,
 		skillManager: deps.skillManager,
+		...deps.skillManagerProvider !== void 0 ? { skillManagerProvider: deps.skillManagerProvider } : {},
 		agentTypeRegistry: deps.agentTypeRegistry,
+		...deps.agentTypeRegistryProvider !== void 0 ? { agentTypeRegistryProvider: deps.agentTypeRegistryProvider } : {},
 		questionRuntimeProvider: ({ sessionId }) => reverse !== void 0 ? createWireQuestionRuntime(reverse, sessionId) : void 0,
 		rebuildRuntimeForModel,
 		backgroundProcessManager,
+		...deps.backgroundProcessManagerProvider !== void 0 ? { backgroundProcessManagerProvider: deps.backgroundProcessManagerProvider } : {},
 		sessionLifecycle: {
 			onSessionCreated: (managed) => deps.sessionLifecycle?.onSessionCreated?.(managed),
 			onSessionDestroyed: (sessionId) => {
@@ -33461,7 +33558,8 @@ var SessionManager = class {
 			model: options.model,
 			runtime: options.runtime,
 			compactionProvider: options.compactionProvider,
-			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {}
+			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {},
+			...options.modelCapabilities !== void 0 ? { modelCapabilities: options.modelCapabilities } : {}
 		});
 		const runtimeBundle = runtimeSlot.current();
 		const mainInitInput = {
@@ -33523,12 +33621,8 @@ var SessionManager = class {
 			skillManager: options.skillManager,
 			questionRuntime: options.questionRuntime,
 			compactionConfig: runtimeBundle.compactionConfig,
+			modelCapabilities: runtimeBundle.modelCapabilities,
 			compactionProvider: runtimeBundle.compactionProvider,
-			journalCapability: options.journalCapability ?? createWiredJournalCapability({
-				sessionDir,
-				journalWriter,
-				producer: this.producer
-			}),
 			approvalRuntime,
 			hookEngine: options.hookEngine,
 			toolExecutionScopeFactory: options.toolExecutionScopeFactory,
@@ -33654,7 +33748,8 @@ var SessionManager = class {
 			model: projected.model,
 			runtime: options.runtime,
 			compactionProvider: options.compactionProvider,
-			compactionConfig: options.compactionConfig
+			compactionConfig: options.compactionConfig,
+			...options.modelCapabilities !== void 0 ? { modelCapabilities: options.modelCapabilities } : {}
 		});
 		const runtimeBundle = runtimeSlot.current();
 		await stateCache.write({
@@ -33702,12 +33797,8 @@ var SessionManager = class {
 			skillManager: options.skillManager,
 			...options.questionRuntime !== void 0 ? { questionRuntime: options.questionRuntime } : {},
 			...runtimeBundle.compactionConfig !== void 0 ? { compactionConfig: runtimeBundle.compactionConfig } : {},
+			...runtimeBundle.modelCapabilities !== void 0 ? { modelCapabilities: runtimeBundle.modelCapabilities } : {},
 			compactionProvider: runtimeBundle.compactionProvider,
-			journalCapability: options.journalCapability ?? createWiredJournalCapability({
-				sessionDir,
-				journalWriter,
-				producer: this.producer
-			}),
 			approvalRuntime,
 			hookEngine: options.hookEngine,
 			...options.toolExecutionScopeFactory !== void 0 ? { toolExecutionScopeFactory: options.toolExecutionScopeFactory } : {},
@@ -42000,6 +42091,16 @@ function injectEnvVars(config) {
 		yolo
 	};
 }
+function parseTomlData(data) {
+	const raw = JSON.parse(JSON.stringify(data));
+	const transformed = transformTomlData(data);
+	transformed["raw"] = raw;
+	try {
+		return KimiConfigSchema.parse(transformed);
+	} catch (error) {
+		throw new ConfigError(`Invalid configuration: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
 /**
 * Load and merge configuration from global, project, and override layers.
 *
@@ -42027,6 +42128,16 @@ function loadConfig(options) {
 	return config;
 }
 /**
+* Load configuration from exactly one TOML file.
+*
+* Missing files are treated as an empty config. This is the preferred entry
+* point for default-host assembly, where the caller owns the config path and
+* no global/project layering should be inferred.
+*/
+function loadConfigFile(filePath) {
+	return injectEnvVars(parseTomlData(readTomlFile(filePath) ?? {}));
+}
+/**
 * Save a validated {@link KimiConfig} to TOML. Existing raw keys loaded from
 * disk are preserved when `config.raw` is present; typed fields are overlaid
 * in snake_case so the file remains compatible with the user-facing format.
@@ -78233,6 +78344,50 @@ async function loadBundledAgentTypeRegistry(defaultAgentYamlPath, onWarning) {
 	return { agentTypeRegistry: registry };
 }
 //#endregion
+//#region ../../packages/kimi-core/src/soul-plus/host/config.ts
+const DEFAULT_SOUL_PLUS_CONFIG = {
+	providers: {},
+	defaultProvider: void 0,
+	defaultModel: void 0,
+	models: void 0,
+	thinking: void 0,
+	planMode: void 0,
+	yolo: void 0,
+	defaultThinking: false,
+	defaultYolo: false,
+	defaultPlanMode: false,
+	hooks: void 0,
+	services: void 0,
+	mergeAllAvailableSkills: false,
+	loopControl: {
+		reservedContextSize: 5e4,
+		compactionTriggerRatio: .85
+	},
+	raw: void 0
+};
+function normalizeDefaultSoulPlusConfig(config) {
+	return {
+		...DEFAULT_SOUL_PLUS_CONFIG,
+		...config,
+		providers: {
+			...DEFAULT_SOUL_PLUS_CONFIG.providers,
+			...config.providers
+		},
+		...DEFAULT_SOUL_PLUS_CONFIG.services !== void 0 || config.services !== void 0 ? { services: {
+			...DEFAULT_SOUL_PLUS_CONFIG.services,
+			...config.services
+		} } : {},
+		loopControl: {
+			...DEFAULT_SOUL_PLUS_CONFIG.loopControl,
+			...config.loopControl
+		},
+		raw: config.raw
+	};
+}
+function loadDefaultSoulPlusConfig(configPath) {
+	return normalizeDefaultSoulPlusConfig(loadConfigFile(configPath));
+}
+//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/host/runtime.ts
 function isVideoUploadCapableProvider(value) {
 	return typeof value === "object" && value !== null && typeof value.uploadVideo === "function";
@@ -78265,21 +78420,27 @@ function resolveDefaultSoulPlusDefaultModel(options) {
 function getDefaultSoulPlusMaxContextSize(options, defaultModel) {
 	return options.kimiConfig?.models?.[defaultModel]?.maxContextSize ?? 2e5;
 }
+function getDefaultSoulPlusModelCapabilities(options, defaultModel) {
+	return options.kimiConfig?.models?.[defaultModel]?.capabilities;
+}
 async function createDefaultSoulPlusRuntimeBundle(options) {
 	const defaultModel = resolveDefaultSoulPlusDefaultModel(options);
 	const maxContextSize = getDefaultSoulPlusMaxContextSize(options, defaultModel);
+	const modelCapabilities = getDefaultSoulPlusModelCapabilities(options, defaultModel);
 	if (options.runtime !== void 0 && options.compactionProvider !== void 0) return {
 		runtime: options.runtime,
 		compactionProvider: options.compactionProvider,
 		defaultModel,
-		maxContextSize
+		maxContextSize,
+		...modelCapabilities !== void 0 ? { modelCapabilities } : {}
 	};
 	if (options.runtime !== void 0 || options.compactionProvider !== void 0) throw new Error("createDefaultSoulPlusWireClient: runtime and compactionProvider must be provided together");
 	if (defaultModel.length === 0) return {
 		runtime: createRuntime({ kosong: new UnconfiguredKosongAdapter() }),
 		compactionProvider: new UnconfiguredCompactionProvider(),
 		defaultModel,
-		maxContextSize
+		maxContextSize,
+		...modelCapabilities !== void 0 ? { modelCapabilities } : {}
 	};
 	if (options.kimiConfig === void 0) throw new Error("createDefaultSoulPlusWireClient: provide either runtime+compactionProvider or kimiConfig");
 	const provider = await createProviderFromConfig(options.kimiConfig, defaultModel, {
@@ -78296,6 +78457,7 @@ async function createDefaultSoulPlusRuntimeBundle(options) {
 		compactionProvider: createKosongCompactionProvider(provider),
 		defaultModel,
 		maxContextSize,
+		...modelCapabilities !== void 0 ? { modelCapabilities } : {},
 		videoUploader
 	};
 }
@@ -78783,7 +78945,7 @@ new AsyncLocalStorage();
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/host/tools.ts
 async function createDefaultSoulPlusBuiltinTools(options) {
-	const backgroundManager = new BackgroundProcessManager();
+	const backgroundManager = options.backgroundManager ?? new BackgroundProcessManager();
 	const todoStore = new InMemoryTodoStore();
 	const hostEnvironment = await detectEnvironmentFromNode();
 	const defaultCapabilities = new Set(resolveModelCapabilities(options));
@@ -93460,18 +93622,21 @@ function applyManagedKimiCodeConfig(config, options) {
 }
 async function provisionManagedKimiCodeConfigAfterLogin(options) {
 	const models = await fetchManagedKimiCodeModels(options);
-	const config = loadConfig({ pathConfig: options.pathConfig });
+	const config = options.configPath !== void 0 ? loadConfigFile(options.configPath) : loadConfig({ pathConfig: options.pathConfig });
 	const applied = applyManagedKimiCodeConfig(config, {
 		models,
 		baseUrl: options.baseUrl
 	});
-	await saveConfig(config, { pathConfig: options.pathConfig });
+	await saveConfig(config, {
+		pathConfig: options.pathConfig,
+		filePath: options.configPath
+	});
 	return {
 		providerName: KIMI_CODE_PROVIDER_NAME,
 		defaultModel: applied.defaultModel,
 		defaultThinking: applied.defaultThinking,
 		models,
-		configPath: join(options.pathConfig.home, "config.toml")
+		configPath: options.configPath ?? join(options.pathConfig.home, "config.toml")
 	};
 }
 //#endregion
@@ -93750,9 +93915,11 @@ var DefaultSoulPlusOAuthServiceImpl = class {
 		})).accessToken;
 		await provisionManagedKimiCodeConfigAfterLogin({
 			pathConfig: this.options.pathConfig,
+			configPath: this.options.configPath,
 			accessToken
 		});
-		await this.options.onConfigProvisioned?.(loadConfig({ pathConfig: this.options.pathConfig }));
+		const config = this.options.configPath !== void 0 ? loadConfigFile(this.options.configPath) : loadConfig({ pathConfig: this.options.pathConfig });
+		await this.options.onConfigProvisioned?.(config);
 		return {
 			provider_name: name,
 			ok: true
@@ -94646,7 +94813,9 @@ async function startCoreWireServer(options) {
 		compactionProvider: options.compactionProvider,
 		kosong: options.runtime.kosong,
 		tools: options.tools ?? [],
+		...options.toolsProvider !== void 0 ? { toolsProvider: options.toolsProvider } : {},
 		...options.enabledToolNames !== void 0 ? { enabledToolNames: options.enabledToolNames } : {},
+		...options.enabledToolNamesProvider !== void 0 ? { enabledToolNamesProvider: options.enabledToolNamesProvider } : {},
 		approval: options.approval,
 		...options.enableWiredApprovals !== void 0 ? { enableWiredApprovals: options.enableWiredApprovals } : {},
 		eventBus,
@@ -94668,10 +94837,13 @@ async function startCoreWireServer(options) {
 		server: options.transport,
 		hookEngine,
 		skillManager: options.skillManager,
+		...options.skillManagerProvider !== void 0 ? { skillManagerProvider: options.skillManagerProvider } : {},
 		...options.agentTypeRegistry !== void 0 ? { agentTypeRegistry: options.agentTypeRegistry } : {},
+		...options.agentTypeRegistryProvider !== void 0 ? { agentTypeRegistryProvider: options.agentTypeRegistryProvider } : {},
 		mcpRegistry: options.mcpRegistry,
 		authService: options.authService,
 		...options.backgroundProcessManager !== void 0 ? { backgroundProcessManager: options.backgroundProcessManager } : {},
+		...options.backgroundProcessManagerProvider !== void 0 ? { backgroundProcessManagerProvider: options.backgroundProcessManagerProvider } : {},
 		sessionLifecycle: {
 			onSessionCreated: installBridge,
 			onSessionDestroyed: disposeBridge
@@ -94748,10 +94920,8 @@ const DEFAULT_RESERVED_CONTEXT_SIZE = 5e4;
 const DEFAULT_RESERVED_CONTEXT_FRACTION = .25;
 async function createDefaultSoulPlusWireClient(options) {
 	const pathConfig = options.pathConfig ?? new PathConfig();
-	const loadHostConfig = () => options.kimiConfig ?? loadConfig({
-		pathConfig,
-		workspaceDir: options.workspaceDir
-	});
+	const configPath = options.configPath ?? join(pathConfig.home, "config.toml");
+	const loadHostConfig = () => options.kimiConfig !== void 0 ? normalizeDefaultSoulPlusConfig(options.kimiConfig) : loadDefaultSoulPlusConfig(configPath);
 	const resolveHostConfig = (config) => {
 		const requestedDefaultModel = resolveDefaultSoulPlusDefaultModel({
 			...options,
@@ -94771,7 +94941,45 @@ async function createDefaultSoulPlusWireClient(options) {
 	let authService;
 	let activeVideoUploader;
 	let activeDefaultModel = defaultModel;
-	let activeMaxContextSize = 2e5;
+	let activeMaxContextSize = getDefaultSoulPlusMaxContextSize({
+		kimiConfig: effectiveConfig,
+		defaultModel
+	}, defaultModel);
+	const backgroundManager = new BackgroundProcessManager();
+	let defaultsPromise;
+	const builtinByModel = /* @__PURE__ */ new Map();
+	const ensureDefaults = () => {
+		defaultsPromise ??= prepareDefaultSoulPlusSessionDefaults({
+			workspaceDir: options.workspaceDir,
+			pathConfig
+		});
+		return defaultsPromise;
+	};
+	const ensureBuiltin = (model) => {
+		let existing = builtinByModel.get(model);
+		if (existing !== void 0) return existing;
+		existing = (async () => {
+			const defaults = await ensureDefaults();
+			const webProviders = createDefaultSoulPlusWebProviders({
+				kimiConfig: effectiveConfig,
+				oauthManagers: authService.oauthManagers,
+				userAgent: options.userAgent ?? inferUserAgent(options.defaultHeaders)
+			});
+			return createDefaultSoulPlusBuiltinTools({
+				workspaceDir: options.workspaceDir,
+				workspace: defaults.workspace,
+				kimiConfig: effectiveConfig,
+				modelAlias: model,
+				enabledToolNames: defaults.enabledToolNames,
+				webSearchProvider: webProviders.webSearchProvider,
+				urlFetcher: webProviders.urlFetcher,
+				videoUploader: activeVideoUploader,
+				backgroundManager
+			});
+		})();
+		builtinByModel.set(model, existing);
+		return existing;
+	};
 	const buildRuntimeBundle = async (model) => {
 		const next = await createDefaultSoulPlusRuntimeBundle({
 			...options,
@@ -94786,7 +94994,8 @@ async function createDefaultSoulPlusWireClient(options) {
 			model: next.defaultModel,
 			runtime: next.runtime,
 			compactionProvider: next.compactionProvider,
-			compactionConfig: buildCompactionConfig(effectiveConfig, next.defaultModel, next.maxContextSize)
+			compactionConfig: buildCompactionConfig(effectiveConfig, next.defaultModel, next.maxContextSize),
+			...next.modelCapabilities !== void 0 ? { modelCapabilities: next.modelCapabilities } : {}
 		};
 	};
 	const reloadConfigFromDisk = async () => {
@@ -94795,6 +95004,7 @@ async function createDefaultSoulPlusWireClient(options) {
 		effectiveConfig = resolved.effectiveConfig;
 		defaultModel = resolved.defaultModel;
 		activeDefaultModel = defaultModel;
+		builtinByModel.clear();
 		activeMaxContextSize = getDefaultSoulPlusMaxContextSize({
 			kimiConfig: effectiveConfig,
 			defaultModel
@@ -94804,45 +95014,28 @@ async function createDefaultSoulPlusWireClient(options) {
 		kimiConfig: effectiveConfig,
 		modelAlias: defaultModel,
 		pathConfig,
+		configPath,
 		forceManagedKimiCodeOAuth: defaultModel.length === 0,
 		onConfigProvisioned: reloadConfigFromDisk
 	});
-	const initialRuntimeBundle = await buildRuntimeBundle(defaultModel);
-	activeMaxContextSize = initialRuntimeBundle.compactionConfig?.maxContextSize ?? 2e5;
-	const defaults = await prepareDefaultSoulPlusSessionDefaults({
-		workspaceDir: options.workspaceDir,
-		pathConfig
-	});
-	const webProviders = createDefaultSoulPlusWebProviders({
-		kimiConfig: effectiveConfig,
-		oauthManagers: authService.oauthManagers,
-		userAgent: options.userAgent ?? inferUserAgent(options.defaultHeaders)
-	});
-	const builtin = await createDefaultSoulPlusBuiltinTools({
-		workspaceDir: options.workspaceDir,
-		workspace: defaults.workspace,
-		kimiConfig: effectiveConfig,
-		modelAlias: defaultModel,
-		enabledToolNames: defaults.enabledToolNames,
-		webSearchProvider: webProviders.webSearchProvider,
-		urlFetcher: webProviders.urlFetcher,
-		videoUploader: activeVideoUploader
+	const fallbackRuntimeBundle = await createDefaultSoulPlusRuntimeBundle({
+		defaultModel: "",
+		kimiConfig: effectiveConfig
 	});
-	const backgroundManager = builtin.backgroundManager;
 	const handle = await createInProcessWireClient({
 		pathConfig,
-		runtime: initialRuntimeBundle.runtime,
-		compactionProvider: initialRuntimeBundle.compactionProvider,
+		runtime: fallbackRuntimeBundle.runtime,
+		compactionProvider: fallbackRuntimeBundle.compactionProvider,
 		runtimeBundleProvider: ({ model }) => buildRuntimeBundle(model),
 		workspaceDir: options.workspaceDir,
 		defaultModel: activeDefaultModel,
 		defaultModelProvider: () => activeDefaultModel,
-		enabledToolNames: defaults.enabledToolNames,
+		enabledToolNamesProvider: async () => (await ensureDefaults()).enabledToolNames,
 		enableWiredApprovals: true,
-		defaultSystemPromptProvider: () => defaults.systemPrompt,
-		tools: builtin.tools,
-		skillManager: defaults.skillManager,
-		...defaults.agentTypeRegistry !== void 0 ? { agentTypeRegistry: defaults.agentTypeRegistry } : {},
+		defaultSystemPromptProvider: async () => (await ensureDefaults()).systemPrompt,
+		toolsProvider: async ({ model }) => (await ensureBuiltin(model)).tools,
+		skillManagerProvider: async () => (await ensureDefaults()).skillManager,
+		agentTypeRegistryProvider: async () => (await ensureDefaults()).agentTypeRegistry,
 		authService,
 		modelsProvider: () => ({
 			models: Object.keys(effectiveConfig.models ?? {}),
@@ -96076,6 +96269,12 @@ const APPROVED_PLAN_MARKER = "## Approved Plan:";
 function str(v) {
 	return typeof v === "string" ? v : "";
 }
+function formatSubagentTokens(usage) {
+	if (usage === void 0) return void 0;
+	const total = usage.input + usage.output;
+	if (total <= 0) return void 0;
+	return `${total >= 1e3 ? `${(total / 1e3).toFixed(1)}k` : String(total)} tok`;
+}
 function extractApprovedPlan(output) {
 	const markerIndex = output.indexOf(APPROVED_PLAN_MARKER);
 	if (markerIndex < 0) return "";
@@ -96262,6 +96461,11 @@ var ToolCallComponent = class extends Container {
 	* 最后几行，避免占用过多屏幕。
 	*/
 	subagentText = "";
+	subagentPhase;
+	subagentRunInBackground = false;
+	subagentUsage;
+	subagentResultSummary;
+	subagentError;
 	constructor(toolCall, result, colors, ui, markdownTheme) {
 		super();
 		this.toolCall = toolCall;
@@ -96346,8 +96550,42 @@ var ToolCallComponent = class extends Container {
 		this.rebuildContent();
 		this.ui?.requestRender();
 	}
+	/**
+	* 来自 wire 'subagent.spawned'。子 agent 已被注册，但内部活动事件
+	* (content.delta / tool.call) 可能尚未到达——把 UI 切到 'spawning'
+	* 占位状态（除非 runInBackground，这种情况直接进 'backgrounded'）。
+	*/
+	onSubagentSpawned(meta) {
+		this.subagentAgentId = meta.agentId;
+		this.subagentAgentName = meta.agentName;
+		this.subagentRunInBackground = meta.runInBackground;
+		this.subagentPhase = meta.runInBackground ? "backgrounded" : "spawning";
+		this.rebuildContent();
+		this.ui?.requestRender();
+	}
+	/**
+	* 来自 wire 'subagent.completed'。把 phase 切到 'done'，记录 token
+	* usage 与 result summary（用于头部右侧 chip + 尾部摘要行）。
+	*/
+	onSubagentCompleted(payload) {
+		this.subagentPhase = "done";
+		this.subagentUsage = payload.usage;
+		this.subagentResultSummary = payload.resultSummary.length > 0 ? payload.resultSummary : void 0;
+		this.rebuildContent();
+		this.ui?.requestRender();
+	}
+	/**
+	* 来自 wire 'subagent.failed'。
+	*/
+	onSubagentFailed(payload) {
+		this.subagentPhase = "failed";
+		this.subagentError = payload.error;
+		this.rebuildContent();
+		this.ui?.requestRender();
+	}
 	appendSubagentText(text) {
 		this.subagentText += text;
+		if (this.subagentPhase === void 0 || this.subagentPhase === "spawning") this.subagentPhase = "running";
 		this.rebuildContent();
 		this.ui?.requestRender();
 	}
@@ -96358,6 +96596,7 @@ var ToolCallComponent = class extends Container {
 			args: call.args,
 			...existing?.streamingArguments !== void 0 ? { streamingArguments: existing.streamingArguments } : {}
 		});
+		if (this.subagentPhase === void 0 || this.subagentPhase === "spawning") this.subagentPhase = "running";
 		this.rebuildContent();
 		this.ui?.requestRender();
 	}
@@ -96440,10 +96679,11 @@ var ToolCallComponent = class extends Container {
 		this.buildSubagentBlock();
 	}
 	buildSubagentBlock() {
-		if (this.subagentAgentId === void 0 && this.ongoingSubCalls.size === 0 && this.finishedSubCalls.length === 0 && this.subagentText.length === 0) return;
+		if (this.subagentAgentId === void 0 && this.ongoingSubCalls.size === 0 && this.finishedSubCalls.length === 0 && this.subagentText.length === 0 && this.subagentPhase === void 0) return;
 		const dim = chalk.dim;
-		const header = this.subagentAgentName !== void 0 ? `subagent ${this.subagentAgentName} (${this.formatAgentId()})` : `subagent (${this.formatAgentId()})`;
-		this.addChild(new Text(dim(`  ↳ ${header}`), 0, 0));
+		const phaseChip = this.formatPhaseChip();
+		const headerLabel = this.subagentAgentName !== void 0 ? `subagent ${this.subagentAgentName} (${this.formatAgentId()})` : `subagent (${this.formatAgentId()})`;
+		this.addChild(new Text(`  ${dim(`↳ ${headerLabel}`)}${phaseChip}`, 0, 0));
 		if (this.hiddenSubCallCount > 0) {
 			const suffix = this.hiddenSubCallCount > 1 ? "s" : "";
 			this.addChild(new Text(dim.italic(`    ${String(this.hiddenSubCallCount)} more tool call${suffix} ...`), 0, 0));
@@ -96465,6 +96705,50 @@ var ToolCallComponent = class extends Container {
 			const tailLines = this.subagentText.split("\n").slice(-3);
 			for (const line of tailLines) this.addChild(new Text(`    ${dim(line)}`, 0, 0));
 		}
+		if (this.subagentPhase === "done" && this.subagentResultSummary !== void 0) {
+			const summaryLines = this.subagentResultSummary.split("\n").slice(0, 2);
+			for (const line of summaryLines) this.addChild(new Text(`    ${dim("└")} ${line}`, 0, 0));
+		}
+		if (this.subagentPhase === "failed" && this.subagentError !== void 0) {
+			const errLines = this.subagentError.split("\n");
+			for (const line of errLines) this.addChild(new Text(`    ${chalk.hex(this.colors.error)("└")} ${line}`, 0, 0));
+		}
+	}
+	/**
+	* 头部右侧 phase / token chip。phase=undefined 时无 chip。
+	*   spawning      → ↻ starting…
+	*   running       → ↻ running
+	*   done          → ✓ N tools · 8.4k tok
+	*   failed        → ✗ failed
+	*   backgrounded  → ◐ backgrounded
+	*/
+	formatPhaseChip() {
+		if (this.subagentPhase === void 0) return "";
+		const dim = chalk.dim;
+		const parts = [];
+		switch (this.subagentPhase) {
+			case "spawning":
+				parts.push("↻ starting…");
+				break;
+			case "running":
+				parts.push("↻ running");
+				break;
+			case "done": {
+				parts.push(chalk.hex(this.colors.success)("✓ done"));
+				const toolCount = this.finishedSubCalls.length + this.hiddenSubCallCount;
+				if (toolCount > 0) parts.push(`${String(toolCount)} tool${toolCount > 1 ? "s" : ""}`);
+				const tokens = formatSubagentTokens(this.subagentUsage);
+				if (tokens !== void 0) parts.push(tokens);
+				break;
+			}
+			case "failed":
+				parts.push(chalk.hex(this.colors.error)("✗ failed"));
+				break;
+			case "backgrounded":
+				parts.push("◐ backgrounded");
+				break;
+		}
+		return parts.length > 0 ? dim(` · ${parts.join(" · ")}`) : "";
 	}
 	formatAgentId() {
 		const id = this.subagentAgentId ?? "";
@@ -97392,6 +97676,28 @@ function handleSubagentSourceEvent(ectx, payload) {
 		});
 	}
 }
+function handleSubagentSpawned(ectx, data) {
+	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+	if (tc === void 0) return;
+	tc.onSubagentSpawned({
+		agentId: data.agent_id,
+		agentName: data.agent_name,
+		runInBackground: data.run_in_background
+	});
+}
+function handleSubagentCompleted(ectx, data) {
+	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+	if (tc === void 0) return;
+	tc.onSubagentCompleted({
+		usage: data.usage,
+		resultSummary: data.result_summary
+	});
+}
+function handleSubagentFailed(ectx, data) {
+	const tc = ectx.state.pendingToolComponents.get(data.parent_tool_call_id);
+	if (tc === void 0) return;
+	tc.onSubagentFailed({ error: data.error });
+}
 //#endregion
 //#region src/utils/git/git-ls-files.ts
 /**
@@ -100372,6 +100678,15 @@ function dispatchEvent(event, ectx, sendQueued) {
 		case "notification":
 			handleNotification(ectx, event.data);
 			break;
+		case "subagent.spawned":
+			handleSubagentSpawned(ectx, event.data);
+			break;
+		case "subagent.completed":
+			handleSubagentCompleted(ectx, event.data);
+			break;
+		case "subagent.failed":
+			handleSubagentFailed(ectx, event.data);
+			break;
 		default: break;
 	}
 }