kfc-code-cli 0.0.1-alpha.3 → 0.0.1-alpha.5

package/dist/main.mjs

@@ -33,7 +33,7 @@ import { writeFile as writeFile$1 } from "fs/promises";
 import { AsyncLocalStorage } from "node:async_hooks";
 import "yazl";
 import pino from "pino";
-import { CombinedAutocompleteProvider, Container, Editor, Image, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, fuzzyFilter, fuzzyMatch, getCapabilities, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Editor, Image, Input, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, fuzzyFilter, fuzzyMatch, getCapabilities, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import chalk from "chalk";
 import { highlight } from "cli-highlight";
 import { gt, valid } from "semver";
@@ -1026,26 +1026,12 @@ var BaseContextState = class {
 				this._systemPrompt = event.new_prompt;
 				return;
 			case "model_changed":
-				await this.journalWriter.append({
-					type: "model_changed",
-					old_model: event.old_model,
-					new_model: event.new_model
-				});
 				this._model = event.new_model;
 				return;
 			case "thinking_changed":
-				await this.journalWriter.append({
-					type: "thinking_changed",
-					level: event.level
-				});
 				this._thinkingLevel = event.level;
 				return;
-			case "plan_mode_changed":
-				await this.journalWriter.append({
-					type: "plan_mode_changed",
-					enabled: event.enabled
-				});
-				return;
+			case "plan_mode_changed": return;
 			case "tools_changed":
 				await this.journalWriter.append({
 					type: "tools_changed",
@@ -1146,9 +1132,6 @@ var WiredSessionJournalImpl = class {
 	async appendTeamMail(data) {
 		await this.journalWriter.append(data);
 	}
-	async appendPermissionModeChanged(data) {
-		await this.journalWriter.append(data);
-	}
 	async appendToolDenied(data) {
 		await this.journalWriter.append(data);
 	}
@@ -1164,9 +1147,6 @@ var WiredSessionJournalImpl = class {
 	async appendOwnershipChanged(data) {
 		await this.journalWriter.append(data);
 	}
-	async appendSessionMetaChanged(data) {
-		await this.journalWriter.append(data);
-	}
 };
 //#endregion
 //#region ../../packages/kimi-core/src/storage/schema/records.ts
@@ -1284,25 +1264,6 @@ const _rawSystemPromptChangedRecordSchema = z.object({
 	time: z.number(),
 	new_prompt: z.string()
 });
-const _rawModelChangedRecordSchema = z.object({
-	type: z.literal("model_changed"),
-	seq: z.number(),
-	time: z.number(),
-	old_model: z.string(),
-	new_model: z.string()
-});
-const _rawThinkingChangedRecordSchema = z.object({
-	type: z.literal("thinking_changed"),
-	seq: z.number(),
-	time: z.number(),
-	level: z.string()
-});
-const _rawPlanModeChangedRecordSchema = z.object({
-	type: z.literal("plan_mode_changed"),
-	seq: z.number(),
-	time: z.number(),
-	enabled: z.boolean()
-});
 const _rawToolsChangedRecordSchema = z.object({
 	type: z.literal("tools_changed"),
 	seq: z.number(),
@@ -1359,17 +1320,6 @@ const _rawNotificationRecordSchema = z.object({
 		envelope_id: z.string().optional()
 	})
 });
-const _rawPermissionModeChangedRecordSchema = z.object({
-	type: z.literal("permission_mode_changed"),
-	seq: z.number(),
-	time: z.number(),
-	turn_id: z.string().optional(),
-	data: z.object({
-		from: z.string(),
-		to: z.string(),
-		reason: z.string()
-	})
-});
 const _rawToolDeniedRecordSchema = z.object({
 	type: z.literal("tool_denied"),
 	seq: z.number(),
@@ -1611,25 +1561,6 @@ const _rawOwnershipChangedRecordSchema = z.object({
 	old_owner: z.string().nullable(),
 	new_owner: z.string()
 });
-const _rawSessionMetaChangedRecordSchema = z.object({
-	type: z.literal("session_meta_changed"),
-	seq: z.number(),
-	time: z.number(),
-	patch: z.object({
-		title: z.string().optional(),
-		tags: z.array(z.string()).optional(),
-		description: z.string().optional(),
-		archived: z.boolean().optional(),
-		color: z.string().optional(),
-		plan_slug: z.string().optional()
-	}),
-	source: z.enum([
-		"user",
-		"auto",
-		"system"
-	]),
-	reason: z.string().optional()
-});
 const _rawContextEditRecordSchema = z.object({
 	type: z.literal("context_edit"),
 	seq: z.number(),
@@ -1662,15 +1593,15 @@ const _sessionInitializedCommonShape = {
 	seq: z.number(),
 	time: z.number(),
 	system_prompt: z.string(),
-	model: z.string(),
 	active_tools: z.array(z.string()),
+	model: z.string().optional(),
 	permission_mode: z.enum([
 		"default",
 		"acceptEdits",
 		"bypassPermissions"
-	]),
-	plan_mode: z.boolean(),
-	workspace_dir: z.string(),
+	]).optional(),
+	plan_mode: z.boolean().optional(),
+	workspace_dir: z.string().optional(),
 	thinking_level: z.string().optional()
 };
 const _rawSessionInitializedMainSchema = z.object({
@@ -1707,13 +1638,9 @@ const WireRecordSchema = z.discriminatedUnion("type", [
 	_rawToolResultRecordSchema,
 	_rawCompactionRecordSchema,
 	_rawSystemPromptChangedRecordSchema,
-	_rawModelChangedRecordSchema,
-	_rawThinkingChangedRecordSchema,
-	_rawPlanModeChangedRecordSchema,
 	_rawToolsChangedRecordSchema,
 	_rawSystemReminderRecordSchema,
 	_rawNotificationRecordSchema,
-	_rawPermissionModeChangedRecordSchema,
 	_rawToolDeniedRecordSchema,
 	_rawStepBeginRecordSchema,
 	_rawStepEndRecordSchema,
@@ -1730,7 +1657,6 @@ const WireRecordSchema = z.discriminatedUnion("type", [
 	_rawOwnershipChangedRecordSchema,
 	_rawContextEditRecordSchema,
 	_rawContextClearedRecordSchema,
-	_rawSessionMetaChangedRecordSchema,
 	_rawSessionInitializedRecordSchema
 ]);
 //#endregion
@@ -1849,13 +1775,9 @@ const KNOWN_RECORD_TYPES = new Set([
 	"tool_result",
 	"compaction",
 	"system_prompt_changed",
-	"model_changed",
-	"thinking_changed",
-	"plan_mode_changed",
 	"tools_changed",
 	"system_reminder",
 	"notification",
-	"permission_mode_changed",
 	"tool_denied",
 	"step_begin",
 	"step_end",
@@ -1871,8 +1793,7 @@ const KNOWN_RECORD_TYPES = new Set([
 	"subagent_failed",
 	"ownership_changed",
 	"context_edit",
-	"context_cleared",
-	"session_meta_changed"
+	"context_cleared"
 ]);
 //#endregion
 //#region ../../packages/kimi-core/src/storage/journal/rotation.ts
@@ -2286,6 +2207,15 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 			if (steps >= maxSteps) throw new MaxStepsExceededError(maxSteps);
 			steps += 1;
 			const currentStep = steps;
+			const turnId = context.currentTurnId?.() ?? UNKNOWN_TURN_ID;
+			if (config.beforeStep !== void 0) {
+				const beforeStep = await config.beforeStep({
+					turnId,
+					stepNumber: currentStep,
+					context
+				}, signal);
+				if (beforeStep?.block === true) throw new Error(beforeStep.reason ?? `Step ${String(currentStep)} was blocked`);
+			}
 			safeEmit(sink, {
 				type: "step.begin",
 				step: currentStep
@@ -2298,7 +2228,6 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 			const visibleTools = buildLLMVisibleTools(config.tools, overrides?.activeTools);
 			const messages = context.buildMessages();
 			const stepUuid = randomUUID();
-			const turnId = context.currentTurnId?.() ?? UNKNOWN_TURN_ID;
 			const toolCallByProviderId = /* @__PURE__ */ new Map();
 			const prefetchedResults = /* @__PURE__ */ new Map();
 			await context.appendStepBegin({
@@ -2420,6 +2349,14 @@ async function runSoulTurn(config, context, runtime, sink, signal, overrides) {
 				step: currentStep
 			});
 			const sr = response.stopReason ?? "end_turn";
+			if (config.afterStep !== void 0) try {
+				await config.afterStep({
+					turnId,
+					stepNumber: currentStep,
+					context,
+					stopReason: sr
+				}, signal);
+			} catch {}
 			if (sr === "tool_use") continue;
 			stopReason = sr;
 			break;
@@ -2929,21 +2866,26 @@ function hookDedupeKey(hook) {
 /**
 * Extracts the string fed to a hook's matcher regex. Event-dependent:
 *
+*   - `PreTurn` / `UserPromptSubmit` — the prompt text itself.
+*   - `PostTurn` / `Stop` — the turn reason (`done` / `cancelled` /
+*     `error`), so hooks can filter e.g. `/^error$/`.
+*   - `PreStep` / `PostStep` — the step number as a string.
 *   - `PreToolUse` / `PostToolUse` / `OnToolFailure` — tool name
 *     (mirrors Python's `matcher_value=toolCall.name` contract).
-*   - `UserPromptSubmit` — the prompt text itself (Python parity).
-*   - `Stop` — the turn reason (`done` / `cancelled` / `error`), so
-*     hooks can filter e.g. `/^error$/`.
 *   - `Notification` — the notification type string, so a single hook
 *     can subscribe to an entire notification class via regex.
 */
 function extractMatcherValue(input) {
 	switch (input.event) {
+		case "PreTurn":
+		case "UserPromptSubmit": return input.prompt;
+		case "PostTurn":
+		case "Stop": return input.reason;
+		case "PreStep":
+		case "PostStep": return String(input.stepNumber);
 		case "PreToolUse":
 		case "PostToolUse":
 		case "OnToolFailure": return input.toolCall.name;
-		case "UserPromptSubmit": return input.prompt;
-		case "Stop": return input.reason;
 		case "Notification": return input.notificationType;
 		case "StopFailure": return input.error;
 		case "SubagentStart":
@@ -2953,6 +2895,7 @@ function extractMatcherValue(input) {
 		case "PreCompact":
 		case "PostCompact": return "";
 	}
+	return input;
 }
 const AgentToolInputSchema = z.preprocess((input) => {
 	if (typeof input !== "object" || input === null || Array.isArray(input)) return input;
@@ -3252,7 +3195,7 @@ var EnterPlanModeTool = class {
 			isError: true,
 			content: "Plan mode is already active. Use ExitPlanMode when the plan is ready."
 		};
-		if (this.deps.isYoloMode()) {
+		if (this.deps.isYoloMode() || this.deps.shouldAutoApprove?.() === true) {
 			try {
 				await this.deps.setPlanMode(true);
 			} catch (error) {
@@ -3588,15 +3531,10 @@ var CompactionOrchestrator = class {
 			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 runtime = this.deps.runtimeStateProvider();
 			const cs = this.deps.contextState;
 			const sessionInitialized = applyRuntimeOverlay(baselineInit, {
 				system_prompt: cs.systemPrompt,
-				model: cs.model,
-				active_tools: [...cs.activeTools],
-				permission_mode: runtime.permissionMode,
-				plan_mode: runtime.planMode,
-				thinking_level: runtime.thinkingLevel
+				active_tools: [...cs.activeTools]
 			});
 			await this.deps.journalWriter.flush();
 			const rotateResult = await this.deps.journalCapability.rotate({
@@ -3663,16 +3601,15 @@ var CompactionOrchestrator = class {
 };
 /**
 * Phase 23 fix — overlay the runtime-mutable subset of a baseline
-* `session_initialized` with the live ContextState + TurnManager state.
+* `session_initialized` with the live wire-owned ContextState baseline.
 *
 * Identity-class fields (`type`, `seq`, `time`, `agent_type`, `session_id`,
-* `agent_id`, parent lineage, `workspace_dir`) are preserved verbatim
+* `agent_id`, parent lineage) are preserved verbatim
 * because they cannot legally mutate at runtime — see the discriminated-union
-* shape in `wire-record.ts`. The mutable fields (`system_prompt`, `model`,
-* `active_tools`, `permission_mode`, `plan_mode`, `thinking_level`) are
-* overwritten so the post-rotate baseline reflects the compaction-time
-* snapshot rather than the original startup config. `thinking_level` is
-* mutable: `session.setThinking` (Phase 24 24b) changes it at runtime.
+* shape in `wire-record.ts`. The mutable wire-owned fields
+* (`system_prompt`, `active_tools`) are overwritten so the post-rotate
+* baseline reflects the compaction-time snapshot rather than the original
+* startup config. Runtime/session fields live in state.json.
 *
 * The generic preserves the discriminated-union narrowing so each branch
 * (main / sub / independent) returns its own concrete type.
@@ -3681,11 +3618,7 @@ function applyRuntimeOverlay(baseline, overlay) {
 	return {
 		...baseline,
 		system_prompt: overlay.system_prompt,
-		model: overlay.model,
-		active_tools: [...overlay.active_tools],
-		permission_mode: overlay.permission_mode,
-		plan_mode: overlay.plan_mode,
-		...overlay.thinking_level !== void 0 ? { thinking_level: overlay.thinking_level } : {}
+		active_tools: [...overlay.active_tools]
 	};
 }
 /**
@@ -4449,11 +4382,13 @@ var DefaultSessionControl = class {
 	contextState;
 	sessionJournal;
 	setPlanModeOverride;
+	setYoloOverride;
 	constructor(deps) {
 		this.turnManager = deps.turnManager;
 		this.contextState = deps.contextState;
 		this.sessionJournal = deps.sessionJournal;
 		this.setPlanModeOverride = deps.setPlanModeOverride;
+		this.setYoloOverride = deps.setYoloOverride;
 	}
 	async compact(customInstruction) {
 		await this.turnManager.triggerCompaction(customInstruction);
@@ -4478,18 +4413,15 @@ var DefaultSessionControl = class {
 		this.turnManager.setPlanMode(enabled);
 	}
 	async setYolo(enabled) {
+		if (this.setYoloOverride !== void 0) {
+			await this.setYoloOverride(enabled);
+			return;
+		}
 		const previousMode = this.turnManager.getPermissionMode();
 		const newMode = enabled ? "bypassPermissions" : "default";
 		if (previousMode === newMode) return;
 		this.turnManager.setPermissionMode(newMode);
-		await this.sessionJournal.appendPermissionModeChanged({
-			type: "permission_mode_changed",
-			data: {
-				from: previousMode,
-				to: newMode,
-				reason: enabled ? "/yolo on" : "/yolo off"
-			}
-		});
+		this.sessionJournal;
 	}
 };
 //#endregion
@@ -4591,19 +4523,16 @@ var SessionMetaService = class {
 		}
 	}
 	async applyPatch(patch, source, reason) {
-		await this.deps.sessionJournal.appendSessionMetaChanged({
-			type: "session_meta_changed",
-			patch: toWirePatch(patch),
-			source,
-			...reason !== void 0 ? { reason } : {}
-		});
-		if (patch.title !== void 0) this.meta.title = patch.title;
-		if (patch.tags !== void 0) this.meta.tags = [...patch.tags];
-		if (patch.description !== void 0) this.meta.description = patch.description;
-		if (patch.archived !== void 0) this.meta.archived = patch.archived;
-		if (patch.color !== void 0) this.meta.color = patch.color;
-		if (patch.plan_slug !== void 0) this.meta.plan_slug = patch.plan_slug;
-		this.meta.last_updated = Date.now();
+		const next = cloneMeta(this.meta);
+		if (patch.title !== void 0) next.title = patch.title;
+		if (patch.tags !== void 0) next.tags = [...patch.tags];
+		if (patch.description !== void 0) next.description = patch.description;
+		if (patch.archived !== void 0) next.archived = patch.archived;
+		if (patch.color !== void 0) next.color = patch.color;
+		if (patch.plan_slug !== void 0) next.plan_slug = patch.plan_slug;
+		next.last_updated = Date.now();
+		await this.flushStateJson(next);
+		this.meta = next;
 		this.deps.eventBus.emit({
 			type: "session_meta.changed",
 			data: {
@@ -4636,7 +4565,7 @@ var SessionMetaService = class {
 		if (this.flushTimer !== null) return;
 		this.flushTimer = setTimeout(() => {
 			this.flushTimer = null;
-			this.flushStateJson().catch(() => {});
+			this.flushStateJson(this.meta).catch(() => {});
 		}, this.flushDebounceMs);
 		this.flushTimer.unref?.();
 	}
@@ -4651,25 +4580,27 @@ var SessionMetaService = class {
 	* because createSession / closeSession / plan_mode / yolo all need
 	* to migrate off direct state.json writes first.
 	*/
-	async flushStateJson() {
-		const next = {
-			...await this.deps.stateCache.read() ?? {
-				session_id: this.meta.session_id,
-				created_at: this.meta.created_at,
-				updated_at: this.meta.last_updated
+	async flushStateJson(meta = this.meta) {
+		await this.deps.stateCache.update((existing) => ({
+			...existing ?? {
+				session_id: meta.session_id,
+				created_at: meta.created_at,
+				updated_at: meta.last_updated
 			},
-			session_id: this.meta.session_id,
-			created_at: this.meta.created_at,
-			updated_at: this.meta.last_updated,
-			...this.meta.title !== void 0 ? { custom_title: this.meta.title } : {},
-			...this.meta.tags !== void 0 ? { tags: [...this.meta.tags] } : {},
-			...this.meta.description !== void 0 ? { description: this.meta.description } : {},
-			...this.meta.archived !== void 0 ? { archived: this.meta.archived } : {},
-			...this.meta.last_model !== void 0 ? { model: this.meta.last_model } : {},
-			...this.meta.plan_slug !== void 0 ? { plan_slug: this.meta.plan_slug } : {},
-			...this.meta.producer !== void 0 ? { producer: { ...this.meta.producer } } : {}
-		};
-		await this.deps.stateCache.write(next);
+			session_id: meta.session_id,
+			created_at: meta.created_at,
+			updated_at: meta.last_updated,
+			...meta.title !== void 0 ? { custom_title: meta.title } : {},
+			...meta.tags !== void 0 ? { tags: [...meta.tags] } : {},
+			...meta.description !== void 0 ? { description: meta.description } : {},
+			...meta.archived !== void 0 ? { archived: meta.archived } : {},
+			...meta.color !== void 0 ? { color: meta.color } : {},
+			...meta.last_model !== void 0 ? { model: meta.last_model } : {},
+			turn_count: meta.turn_count,
+			...meta.plan_slug !== void 0 ? { plan_slug: meta.plan_slug } : {},
+			...meta.producer !== void 0 ? { producer: { ...meta.producer } } : {},
+			last_exit_code: "dirty"
+		}));
 	}
 };
 function cloneMeta(meta) {
@@ -5258,11 +5189,7 @@ async function runSubagentTurn(deps, agentId, request, signal) {
 			parent_tool_call_id: request.parentToolCallId,
 			run_in_background: request.runInBackground ?? false,
 			system_prompt: childSystemPrompt ?? "",
-			model: childModel,
-			active_tools: childActiveTools,
-			permission_mode: "default",
-			plan_mode: false,
-			workspace_dir: deps.workDir ?? process.cwd()
+			active_tools: childActiveTools
 		};
 		await childJournalWriter.append(subInitInput);
 		childContext = new WiredContextState({
@@ -19848,6 +19775,49 @@ OpenAI.Containers = Containers;
 OpenAI.Skills = Skills$1;
 OpenAI.Videos = Videos;
 //#endregion
+//#region ../../packages/kimi-core/src/hooks/execution-pipeline.ts
+const ALLOW = Object.freeze({
+	blockAction: false,
+	additionalContext: []
+});
+var ExecutionHookBlockedError = class extends Error {
+	event;
+	reason;
+	constructor(event, reason) {
+		super(reason !== void 0 ? `${event} hook blocked: ${reason}` : `${event} hook blocked`);
+		this.name = "ExecutionHookBlockedError";
+		this.event = event;
+		this.reason = reason;
+	}
+};
+/**
+* Awaited execution-hook adapter.
+*
+* This sits on the execution side of the architecture, separate from the
+* wire-event publication pipeline. Pre hooks can block real work before it
+* happens; post hooks can still run in order without being able to rewrite
+* already-durable facts unless their caller explicitly interprets a result.
+*/
+var ExecutionHookPipeline = class {
+	hookEngine;
+	constructor(options) {
+		this.hookEngine = options.hookEngine;
+	}
+	async run(input, signal) {
+		if (this.hookEngine === void 0) return ALLOW;
+		return this.hookEngine.executeHooks(input.event, input, signal);
+	}
+	async runBlocking(input, signal) {
+		const result = await this.run(input, signal);
+		if (result.blockAction) throw new ExecutionHookBlockedError(input.event, result.reason);
+		return result;
+	}
+	dispatch(input) {
+		const controller = new AbortController();
+		this.run(input, controller.signal).catch(() => {});
+	}
+};
+//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/capability-check.ts
 function checkLLMCapabilities(opts) {
 	if (opts.model === "") return;
@@ -19944,7 +19914,10 @@ var TurnManager = class {
 	runtimeSlot;
 	compactionConfig;
 	sessionId;
+	executionHooks;
 	activeToolExecutionScope;
+	pendingLaunchController;
+	pendingLaunchDrain;
 	/**
 	* Phase 18 A.13 — terminal reason per turn id for callers that
 	* observe the turn lifecycle out-of-band (after the `end` event
@@ -19972,6 +19945,7 @@ var TurnManager = class {
 		this.runtimeSlot = deps.runtimeSlot;
 		this.compactionConfig = deps.compactionConfig;
 		this.sessionId = deps.sessionId ?? "unknown";
+		this.executionHooks = new ExecutionHookPipeline({ hookEngine: deps.hookEngine });
 	}
 	setPermissionMode(mode) {
 		this.permissionMode = mode;
@@ -20154,6 +20128,13 @@ var TurnManager = class {
 		};
 		const scope = this.activeToolExecutionScope;
 		this.deps.approvalRuntime?.cancelBySource(source);
+		if (this.pendingLaunchTurnId === turnId && this.pendingLaunchController !== void 0) {
+			this.pendingLaunchController.abort();
+			try {
+				await this.pendingLaunchDrain;
+			} catch {}
+			return;
+		}
 		scope?.discardStreaming?.("aborted");
 		await this.deps.lifecycle.cancelTurn(turnId);
 		scope?.drainPrefetched?.();
@@ -20178,8 +20159,16 @@ var TurnManager = class {
 			if (mismatch !== void 0) throw mismatch;
 		}
 		const turnId = this.deps.lifecycle.allocateTurnId();
+		const pendingLaunchController = new AbortController();
 		this.pendingLaunchTurnId = turnId;
+		this.pendingLaunchController = pendingLaunchController;
+		let releasePendingLaunch;
+		this.pendingLaunchDrain = new Promise((resolve) => {
+			releasePendingLaunch = resolve;
+		});
 		try {
+			await this.executePreTurnHook(turnId, input, pendingLaunchController.signal);
+			pendingLaunchController.signal.throwIfAborted();
 			await this.deps.sessionJournal.appendTurnBegin({
 				type: "turn_begin",
 				turn_id: turnId,
@@ -20210,17 +20199,23 @@ var TurnManager = class {
 			};
 			this.launchTurn(turnId, trigger);
 			this.pendingLaunchTurnId = void 0;
+			this.pendingLaunchController = void 0;
+			this.pendingLaunchDrain = void 0;
+			releasePendingLaunch();
 			return {
 				turn_id: turnId,
 				status: "started"
 			};
 		} catch (error) {
 			this.pendingLaunchTurnId = void 0;
+			this.pendingLaunchController = void 0;
+			this.pendingLaunchDrain = void 0;
+			releasePendingLaunch();
 			throw error;
 		}
 	}
 	async handleCancel(req) {
-		const requestedId = req.data.turn_id ?? this.deps.lifecycle.getCurrentTurnId();
+		const requestedId = req.data.turn_id ?? this.getCurrentTurnId();
 		if (requestedId === void 0) return { ok: true };
 		await this.abortTurn(requestedId, "dispatch-cancel");
 		return { ok: true };
@@ -20258,16 +20253,27 @@ var TurnManager = class {
 		const parsed = Number.parseInt(match[1] ?? "1", 10);
 		return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
 	}
+	async executePreTurnHook(turnId, input, signal) {
+		try {
+			await this.executionHooks.runBlocking({
+				event: "PreTurn",
+				sessionId: this.sessionId,
+				turnId,
+				agentId: this.agentId,
+				prompt: input.text,
+				inputKind: "user"
+			}, signal);
+		} catch (error) {
+			if (error instanceof ExecutionHookBlockedError) throw error;
+		}
+	}
 	/**
-	* Fire-and-forget dispatch of a lifecycle hook event. Tool-scoped
+	* Fire-and-forget dispatch for legacy lifecycle hook events. Tool-scoped
 	* events go through the actor-local `ToolExecutionScope`; this helper
-	* only covers the lifecycle events TurnManager owns.
+	* only covers compatibility events TurnManager owns.
 	*/
 	dispatchLifecycleHook(input) {
-		const engine = this.deps.hookEngine;
-		if (engine === void 0) return;
-		const controller = new AbortController();
-		engine.executeHooks(input.event, input, controller.signal).catch(() => {});
+		this.executionHooks.dispatch(input);
 	}
 	launchTurn(turnId, trigger) {
 		const controller = this.deps.soulRegistry.getOrCreate("main").abortController;
@@ -20312,6 +20318,32 @@ var TurnManager = class {
 			compactionConfig,
 			contextWindow: compactionConfig.maxContextSize
 		};
+		if (this.deps.hookEngine !== void 0) soulConfig = {
+			...soulConfig,
+			beforeStep: async (ctx, signal) => {
+				const result = await this.executionHooks.run({
+					event: "PreStep",
+					sessionId: this.sessionId,
+					turnId: ctx.turnId,
+					stepNumber: ctx.stepNumber,
+					agentId: this.agentId
+				}, signal);
+				if (result.blockAction) return {
+					block: true,
+					...result.reason !== void 0 ? { reason: result.reason } : {}
+				};
+			},
+			afterStep: async (ctx, signal) => {
+				await this.executionHooks.run({
+					event: "PostStep",
+					sessionId: this.sessionId,
+					turnId: ctx.turnId,
+					stepNumber: ctx.stepNumber,
+					agentId: this.agentId,
+					stopReason: ctx.stopReason
+				}, signal);
+			}
+		};
 		const input = trigger.input;
 		const runPromise = this.runTurn(turnId, input, soulConfig, runtimeForTurn, controller.signal);
 		runPromise.catch(() => {});
@@ -20418,6 +20450,16 @@ var TurnManager = class {
 				...result.usage.cache_write !== void 0 ? { cache_write_tokens: result.usage.cache_write } : {}
 			};
 			await this.deps.sessionJournal.appendTurnEnd(turnEnd);
+			try {
+				await this.executionHooks.run({
+					event: "PostTurn",
+					sessionId: this.sessionId,
+					turnId,
+					agentId: this.agentId,
+					reason,
+					success: reason === "done"
+				}, new AbortController().signal);
+			} catch {}
 			this.dispatchLifecycleHook({
 				event: "Stop",
 				sessionId: this.sessionId,
@@ -20670,6 +20712,7 @@ var SoulPlus = class {
 	hostToolNames;
 	planController;
 	setPlanModeImpl;
+	stateCache;
 	/**
 	* Phase 18 A.3–A.6 — lazy `SessionControlHandler` owned by the
 	* facade. External hosts (SessionManager) still construct their own
@@ -20681,6 +20724,7 @@ var SoulPlus = class {
 	sessionControlInstance;
 	constructor(deps) {
 		this.sessionId = deps.sessionId;
+		this.stateCache = deps.stateCache;
 		const eventBus = deps.eventBus;
 		const toolRegistry = [...deps.tools];
 		const enabledToolNames = deps.enabledToolNames !== void 0 ? new Set(deps.enabledToolNames) : void 0;
@@ -20703,7 +20747,6 @@ var SoulPlus = class {
 		const approvalRuntime = deps.approvalRuntime;
 		const sessionMeta = deps.stateCache !== void 0 && deps.initialMeta !== void 0 ? new SessionMetaService({
 			sessionId: deps.sessionId,
-			sessionJournal,
 			eventBus,
 			stateCache: deps.stateCache,
 			initialMeta: deps.initialMeta
@@ -20838,6 +20881,19 @@ var SoulPlus = class {
 		const setPlanMode = async (enabled) => {
 			if (enabled) {
 				await planController.ensurePlanFilePath();
+				await deps.stateCache?.update((current) => {
+					const now = Date.now();
+					return {
+						...current ?? {
+							session_id: deps.sessionId,
+							created_at: now,
+							updated_at: now
+						},
+						plan_mode: true,
+						updated_at: now,
+						last_exit_code: "dirty"
+					};
+				});
 				await contextState.applyConfigChange({
 					type: "plan_mode_changed",
 					enabled
@@ -20845,6 +20901,19 @@ var SoulPlus = class {
 				turnManager.setPlanMode(enabled);
 				return;
 			}
+			await deps.stateCache?.update((current) => {
+				const now = Date.now();
+				return {
+					...current ?? {
+						session_id: deps.sessionId,
+						created_at: now,
+						updated_at: now
+					},
+					plan_mode: false,
+					updated_at: now,
+					last_exit_code: "dirty"
+				};
+			});
 			await contextState.applyConfigChange({
 				type: "plan_mode_changed",
 				enabled
@@ -20862,6 +20931,7 @@ var SoulPlus = class {
 				isPlanModeActive: () => turnManager.getPlanMode(),
 				setPlanMode,
 				isYoloMode: () => turnManager.getPermissionMode() === "bypassPermissions",
+				shouldAutoApprove: () => true,
 				requestApproval: enterPlanRequestApproval,
 				getPlanFilePath: () => planController.getPlanFilePath()
 			}));
@@ -21098,19 +21168,49 @@ var SoulPlus = class {
 			turnManager: this.components.turnManager,
 			contextState: this.journal.contextState,
 			sessionJournal: this.journal.sessionJournal,
-			setPlanModeOverride: (enabled) => this.setPlanMode(enabled)
+			setPlanModeOverride: (enabled) => this.setPlanMode(enabled),
+			setYoloOverride: async (enabled) => {
+				const permissionMode = enabled ? "bypassPermissions" : "default";
+				await this.stateCache?.update((current) => {
+					const now = Date.now();
+					return {
+						...current ?? {
+							session_id: this.sessionId,
+							created_at: now,
+							updated_at: now
+						},
+						permission_mode: permissionMode,
+						updated_at: now,
+						last_exit_code: "dirty"
+					};
+				});
+				this.components.turnManager.setPermissionMode(permissionMode);
+			}
 		});
 		return this.sessionControlInstance;
 	}
 	/**
 	* Phase 18 A.3 — programmatic model change. Applies the config
-	* change event to ContextState (WAL `model_changed`) and emits a
+	* change event to ContextState, persists state.json, and emits a
 	* fresh `status.update` so downstream observers pick up the new
 	* model without waiting for the next turn boundary.
 	*/
 	async setModel(model) {
 		const oldModel = this.journal.contextState.model;
 		if (oldModel === model) return;
+		await this.stateCache?.update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? {
+					session_id: this.sessionId,
+					created_at: now,
+					updated_at: now
+				},
+				model,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
 		await this.journal.contextState.applyConfigChange({
 			type: "model_changed",
 			old_model: oldModel,
@@ -21127,8 +21227,7 @@ var SoulPlus = class {
 	}
 	/**
 	* Phase 18 A.6 / Phase 21 §A — programmatic thinking-level change.
-	* Journals a `thinking_changed` WAL record (via
-	* ContextState.applyConfigChange) and emits two SoulEvents:
+	* Persists state.json, updates ContextState, and emits two SoulEvents:
 	*   1. `thinking.changed` — distinct event the wire bridge maps to a
 	*      `thinking.changed` wire event with the bridge's per-session
 	*      `seq` counter (replaces the old `seq: 0` direct send from
@@ -21137,6 +21236,19 @@ var SoulPlus = class {
 	*      can repaint without subscribing to the dedicated event.
 	*/
 	async setThinking(level) {
+		await this.stateCache?.update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? {
+					session_id: this.sessionId,
+					created_at: now,
+					updated_at: now
+				},
+				thinking_level: level,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
 		await this.journal.contextState.applyConfigChange({
 			type: "thinking_changed",
 			level
@@ -21288,17 +21400,35 @@ var KosongAdapter = class {
 		}));
 		const onDelta = params.onDelta;
 		const onThinkDelta = params.onThinkDelta;
+		const onToolCallPart = params.onToolCallPart;
 		const onAtomicPart = params.onAtomicPart;
-		const needMessagePart = onDelta !== void 0 || onThinkDelta !== void 0;
+		const needMessagePart = onDelta !== void 0 || onThinkDelta !== void 0 || onToolCallPart !== void 0;
+		const toolCallsByStreamIndex = /* @__PURE__ */ new Map();
+		let lastToolCall;
 		let result;
 		try {
 			result = await generate$1(activeProvider, params.systemPrompt, kosongTools, params.messages, needMessagePart ? { onMessagePart: async (part) => {
 				if (part.type === "text" && onDelta !== void 0) onDelta(part.text);
 				else if (part.type === "think" && onThinkDelta !== void 0) onThinkDelta(part.think);
+				else if (part.type === "function") {
+					lastToolCall = {
+						id: part.id,
+						name: part.function.name
+					};
+					if (part._streamIndex !== void 0) toolCallsByStreamIndex.set(part._streamIndex, lastToolCall);
+				} else if (isToolCallPart(part) && onToolCallPart !== void 0) {
+					const target = part.index !== void 0 ? toolCallsByStreamIndex.get(part.index) : lastToolCall;
+					if (target !== void 0) onToolCallPart({
+						type: "tool_call_part",
+						tool_call_id: target.id,
+						name: target.name,
+						...part.argumentsPart !== null ? { arguments_chunk: part.argumentsPart } : {}
+					});
+				}
 			} } : void 0, { signal: params.signal });
-		} catch (err) {
-			if (isContextOverflowProviderError(err)) throw new ContextOverflowError(extractMessage(err));
-			throw err;
+		} catch (error) {
+			if (isContextOverflowProviderError(error)) throw new ContextOverflowError(extractMessage(error));
+			throw error;
 		}
 		if (onAtomicPart !== void 0) {
 			for (const part of result.message.content) if (part.type === "text" || part.type === "think") await onAtomicPart({
@@ -29313,6 +29443,28 @@ var SetTodoListTool = class {
 		}));
 	}
 };
+//#endregion
+//#region ../../packages/kimi-core/src/hooks/supported-events.ts
+const SUPPORTED_HOOK_EVENTS = [
+	"PreTurn",
+	"PostTurn",
+	"PreStep",
+	"PostStep",
+	"PreToolUse",
+	"PostToolUse",
+	"OnToolFailure",
+	"UserPromptSubmit",
+	"Stop",
+	"StopFailure",
+	"Notification",
+	"SubagentStart",
+	"SubagentStop",
+	"SessionStart",
+	"SessionEnd",
+	"PreCompact",
+	"PostCompact"
+];
+new Set(SUPPORTED_HOOK_EVENTS);
 const _rawWireErrorSchema = z.object({
 	code: z.number(),
 	message: z.string(),
@@ -29505,188 +29657,332 @@ function createWireEvent(options) {
 	};
 }
 //#endregion
+//#region ../../packages/kimi-core/src/wire-protocol/event-pipeline.ts
+/**
+* WireEventPipeline is the ordered, awaited publication path from a translated
+* `WireEventDraft` to one or more event consumers.
+*
+* `enqueue()` intentionally returns void: upstream Soul/SoulPlus emitters must
+* not be back-pressured by transport, telemetry, or debug consumers. The
+* pipeline drains in the background and awaits each middleware/consumer
+* internally to preserve per-session event ordering.
+*/
+var WireEventPipeline = class {
+	sessionId;
+	getEventFilter;
+	middlewares;
+	consumers;
+	queue = [];
+	idleWaiters = [];
+	draining = false;
+	seq = 0;
+	constructor(options) {
+		this.sessionId = options.sessionId;
+		this.getEventFilter = options.getEventFilter;
+		this.consumers = options.consumers ?? [createTransportWireEventConsumer({
+			transport: options.transport,
+			codec: options.codec
+		})];
+		this.middlewares = [
+			createWireEventFilterMiddleware(this.getEventFilter),
+			...options.middlewares ?? [],
+			this.createFrameMiddleware(),
+			createWireEventConsumerMiddleware(this.consumers)
+		];
+	}
+	enqueue(draft) {
+		this.queue.push(draft);
+		if (!this.draining) this.drain();
+	}
+	/**
+	* Test / controlled-host helper: resolves once the queue that is currently
+	* known to the pipeline has drained. Normal production callers should use
+	* fire-and-forget `enqueue()`.
+	*/
+	async flush() {
+		if (!this.draining && this.queue.length === 0) return;
+		await new Promise((resolve) => {
+			this.idleWaiters.push(resolve);
+		});
+	}
+	async drain() {
+		this.draining = true;
+		let restart = false;
+		try {
+			while (this.queue.length > 0) {
+				const draft = this.queue.shift();
+				if (draft === void 0) continue;
+				await this.processOne(draft);
+			}
+		} finally {
+			this.draining = false;
+			if (this.queue.length > 0) restart = true;
+			else {
+				const waiters = this.idleWaiters.splice(0);
+				for (const resolve of waiters) resolve();
+			}
+		}
+		if (restart) this.drain();
+	}
+	async processOne(draft) {
+		const ctx = {
+			sessionId: this.sessionId,
+			draft
+		};
+		try {
+			await composeWireEventMiddlewares(this.middlewares)(ctx);
+		} catch {}
+	}
+	createFrameMiddleware() {
+		return async (ctx, next) => {
+			ctx.event = createWireEvent({
+				method: ctx.draft.method,
+				sessionId: ctx.sessionId,
+				seq: this.seq++,
+				...ctx.draft.requestId !== void 0 ? { requestId: ctx.draft.requestId } : {},
+				...ctx.draft.turnId !== void 0 ? { turnId: ctx.draft.turnId } : {},
+				agentType: ctx.draft.agentType ?? "main",
+				...ctx.draft.source !== void 0 ? { source: ctx.draft.source } : {},
+				data: ctx.draft.data
+			});
+			await next();
+		};
+	}
+};
+function createWireEventFilterMiddleware(getEventFilter) {
+	return async (ctx, next) => {
+		if (getEventFilter !== void 0) {
+			const filter = getEventFilter();
+			if (filter !== void 0 && !filter.has(ctx.draft.method)) return;
+		}
+		await next();
+	};
+}
+function createTransportWireEventConsumer(options) {
+	const codec = options.codec ?? new WireCodec();
+	return {
+		name: "transport",
+		async consume(event) {
+			try {
+				await options.transport.send(codec.encode(event));
+			} catch {}
+		}
+	};
+}
+function createWireEventConsumerMiddleware(consumers) {
+	return async (ctx) => {
+		if (ctx.event === void 0) return;
+		const snapshot = [...consumers];
+		for (const consumer of snapshot) try {
+			await consumer.consume(ctx.event, {
+				sessionId: ctx.sessionId,
+				draft: ctx.draft
+			});
+		} catch {}
+	};
+}
+function composeWireEventMiddlewares(middlewares) {
+	return async (ctx) => {
+		let index = -1;
+		const dispatch = async (i) => {
+			if (i <= index) throw new Error("wire event middleware called next() multiple times");
+			index = i;
+			const middleware = middlewares[i];
+			if (middleware === void 0) return;
+			await middleware(ctx, () => dispatch(i + 1));
+		};
+		await dispatch(0);
+	};
+}
+//#endregion
+//#region ../../packages/kimi-core/src/wire-protocol/event-translators.ts
+function draft(event, ctx, method, data) {
+	return {
+		method,
+		data,
+		...ctx.currentTurnId !== void 0 ? { turnId: ctx.currentTurnId } : {},
+		...event.source !== void 0 ? { source: event.source } : {}
+	};
+}
+const BUS_EVENT_TRANSLATORS = {
+	"step.begin": (event, ctx) => {
+		return draft(event, ctx, "step.begin", { step: event.step });
+	},
+	"step.end": (event, ctx) => {
+		return draft(event, ctx, "step.end", { step: event.step });
+	},
+	"step.interrupted": (event, ctx) => {
+		return draft(event, ctx, "step.interrupted", {
+			step: event.step,
+			reason: event.reason
+		});
+	},
+	"content.delta": (event, ctx) => {
+		return draft(event, ctx, "content.delta", {
+			type: "text",
+			text: event.delta
+		});
+	},
+	"thinking.delta": (event, ctx) => {
+		return draft(event, ctx, "content.delta", {
+			type: "thinking",
+			thinking: event.delta
+		});
+	},
+	tool_call_part: (event, ctx) => {
+		return draft(event, ctx, "tool.call.delta", {
+			tool_call_id: event.tool_call_id,
+			...event.name !== void 0 ? { name: event.name } : {},
+			arguments_part: event.arguments_chunk ?? null
+		});
+	},
+	"tool.call": (event, ctx) => {
+		return draft(event, ctx, "tool.call", {
+			id: event.toolCallId,
+			name: event.name,
+			args: event.args
+		});
+	},
+	"tool.progress": (event, ctx) => draft(event, ctx, "tool.progress", {
+		id: event.toolCallId,
+		update: event.update
+	}),
+	"tool.result": (event, ctx) => {
+		return draft(event, ctx, "tool.result", {
+			tool_call_id: event.toolCallId,
+			output: event.output,
+			...event.isError !== void 0 ? { is_error: event.isError } : {}
+		});
+	},
+	"compaction.begin": (event, ctx) => {
+		return draft(event, ctx, "compaction.begin", {});
+	},
+	"compaction.end": (event, ctx) => {
+		return draft(event, ctx, "compaction.end", {
+			...event.tokensBefore !== void 0 ? { tokens_before: event.tokensBefore } : {},
+			...event.tokensAfter !== void 0 ? { tokens_after: event.tokensAfter } : {}
+		});
+	},
+	"session.error": (event, ctx) => {
+		return draft(event, ctx, "session.error", {
+			error: event.error,
+			...event.error_type !== void 0 ? { error_type: event.error_type } : {},
+			...event.retry_after_ms !== void 0 ? { retry_after_ms: event.retry_after_ms } : {},
+			...event.details !== void 0 ? { details: event.details } : {}
+		});
+	},
+	"hook.triggered": (event, ctx) => draft(event, ctx, "hook.triggered", {
+		event: event.event,
+		matchers: event.matchers,
+		matched_count: event.matched_count
+	}),
+	"hook.resolved": (event, ctx) => draft(event, ctx, "hook.resolved", {
+		hook_id: event.hook_id,
+		outcome: event.outcome
+	}),
+	"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 }),
+	"skill.invoked": (event, ctx) => draft(event, ctx, "skill.invoked", event.data),
+	"skill.completed": (event, ctx) => draft(event, ctx, "skill.completed", event.data),
+	"mcp.loading": (event, ctx) => draft(event, ctx, "mcp.loading", event.data),
+	"mcp.connected": (event, ctx) => draft(event, ctx, "mcp.connected", event.data),
+	"mcp.disconnected": (event, ctx) => draft(event, ctx, "mcp.disconnected", event.data),
+	"mcp.error": (event, ctx) => draft(event, ctx, "mcp.error", event.data),
+	"mcp.tools_changed": (event, ctx) => draft(event, ctx, "mcp.tools_changed", event.data),
+	"mcp.resources_changed": (event, ctx) => draft(event, ctx, "mcp.resources_changed", event.data),
+	"mcp.auth_required": (event, ctx) => draft(event, ctx, "mcp.auth_required", event.data),
+	"status.update.mcp_status": (event, ctx) => draft(event, ctx, "status.update.mcp_status", event.data),
+	"subagent.spawned": (event, ctx) => draft(event, ctx, "subagent.spawned", event.data),
+	"subagent.completed": (event, ctx) => draft(event, ctx, "subagent.completed", event.data),
+	"subagent.failed": (event, ctx) => draft(event, ctx, "subagent.failed", event.data),
+	"model.changed": () => {},
+	"turn.end": () => {}
+};
+function translateBusEvent(event, currentTurnId) {
+	const translator = BUS_EVENT_TRANSLATORS[event.type];
+	return translator(event, currentTurnId !== void 0 ? { currentTurnId } : {});
+}
+function translateNotificationEvent(notif) {
+	return {
+		method: "notification",
+		data: notif
+	};
+}
+function translateTurnLifecycleEvent(event, currentTurnId) {
+	if (event.kind === "begin") return {
+		draft: {
+			method: "turn.begin",
+			data: {
+				turn_id: event.turnId,
+				user_input: event.userInputParts ?? event.userInput,
+				input_kind: event.inputKind
+			},
+			turnId: event.turnId
+		},
+		nextTurnId: event.turnId
+	};
+	return {
+		draft: {
+			method: "turn.end",
+			data: {
+				turn_id: event.turnId,
+				reason: event.reason,
+				success: event.success,
+				...event.usage !== void 0 ? { usage: {
+					input_tokens: event.usage.input,
+					output_tokens: event.usage.output,
+					...event.usage.cache_read !== void 0 ? { cache_read_tokens: event.usage.cache_read } : {},
+					...event.usage.cache_write !== void 0 ? { cache_write_tokens: event.usage.cache_write } : {}
+				} } : {}
+			},
+			turnId: event.turnId
+		},
+		...currentTurnId === event.turnId && currentTurnId !== void 0 ? {} : currentTurnId !== void 0 ? { nextTurnId: currentTurnId } : {}
+	};
+}
+//#endregion
 //#region ../../packages/kimi-core/src/wire-protocol/event-bridge.ts
 /**
-* WireEventBridge — SoulEvent + TurnLifecycleEvent → WireEvent translator
+* WireEventBridge — SoulEvent + TurnLifecycleEvent → WireEventDraft adapter
 * (Phase 17 §A.1).
 *
-* Subscribes to two input channels (SessionEventBus + TurnLifecycleTracker)
-* and forwards translated frames through a provided transport `send`.
-* Each bridge instance owns its own `seq` counter and `currentTurnId`
-* pointer — multi-session safe (fixes the single-ref aliasing in the
-* Phase 10 test helper).
+* Subscribes to three input channels (SessionEventBus + notification channel
+* + TurnLifecycleTracker) and forwards translated drafts through a
+* per-session WireEventPipeline. Each bridge instance owns its own
+* `currentTurnId` pointer; the pipeline owns the per-session wire `seq`.
 *
 * Invariants (§5.0):
-*   - L4: listeners return `void`; the bridge never awaits `transport.send`
+*   - L4: listeners return `void`; the bridge never awaits pipeline drain
 *   - L5: listener does not touch wire.jsonl — translation is write-only
 *     toward the transport
 */
-const codec = new WireCodec();
 function installWireEventBridge(opts) {
 	const { server, eventBus, addTurnLifecycleListener, sessionId, getEventFilter } = opts;
-	let seq = 0;
 	let currentTurnId;
-	const sendWire = (method, data, turnId, source) => {
-		if (getEventFilter !== void 0) {
-			const filter = getEventFilter();
-			if (filter !== void 0 && !filter.has(method)) return;
-		}
-		const frame = codec.encode(createWireEvent({
-			method,
-			sessionId,
-			seq: seq++,
-			...turnId !== void 0 ? { turnId } : {},
-			agentType: "main",
-			...source !== void 0 ? { source } : {},
-			data
-		}));
-		server.send(frame).catch(() => {});
-	};
+	const pipeline = new WireEventPipeline({
+		sessionId,
+		transport: server,
+		...getEventFilter !== void 0 ? { getEventFilter } : {}
+	});
 	const soulListener = (event) => {
-		switch (event.type) {
-			case "step.begin":
-				sendWire("step.begin", { step: event.step }, currentTurnId, event.source);
-				return;
-			case "step.end":
-				sendWire("step.end", { step: event.step }, currentTurnId, event.source);
-				return;
-			case "step.interrupted":
-				sendWire("step.interrupted", {
-					step: event.step,
-					reason: event.reason
-				}, currentTurnId, event.source);
-				return;
-			case "content.delta":
-				sendWire("content.delta", {
-					type: "text",
-					text: event.delta
-				}, currentTurnId, event.source);
-				return;
-			case "thinking.delta":
-				sendWire("content.delta", {
-					type: "thinking",
-					thinking: event.delta
-				}, currentTurnId, event.source);
-				return;
-			case "tool_call_part":
-				sendWire("content.delta", {
-					type: "tool_call_part",
-					tool_call_id: event.tool_call_id,
-					...event.name !== void 0 ? { name: event.name } : {},
-					...event.arguments_chunk !== void 0 ? { arguments_chunk: event.arguments_chunk } : {}
-				}, currentTurnId, event.source);
-				return;
-			case "tool.call":
-				sendWire("tool.call", {
-					id: event.toolCallId,
-					name: event.name,
-					args: event.args
-				}, currentTurnId, event.source);
-				return;
-			case "tool.progress":
-				sendWire("tool.progress", {
-					id: event.toolCallId,
-					update: event.update
-				}, currentTurnId, event.source);
-				return;
-			case "tool.result":
-				sendWire("tool.result", {
-					tool_call_id: event.toolCallId,
-					output: event.output,
-					...event.isError !== void 0 ? { is_error: event.isError } : {}
-				}, currentTurnId, event.source);
-				return;
-			case "compaction.begin":
-				sendWire("compaction.begin", {}, currentTurnId, event.source);
-				return;
-			case "compaction.end":
-				sendWire("compaction.end", {
-					...event.tokensBefore !== void 0 ? { tokens_before: event.tokensBefore } : {},
-					...event.tokensAfter !== void 0 ? { tokens_after: event.tokensAfter } : {}
-				}, currentTurnId, event.source);
-				return;
-			case "session.error":
-				sendWire("session.error", {
-					error: event.error,
-					...event.error_type !== void 0 ? { error_type: event.error_type } : {},
-					...event.retry_after_ms !== void 0 ? { retry_after_ms: event.retry_after_ms } : {},
-					...event.details !== void 0 ? { details: event.details } : {}
-				}, currentTurnId, event.source);
-				return;
-			case "hook.triggered":
-				sendWire("hook.triggered", {
-					event: event.event,
-					matchers: event.matchers,
-					matched_count: event.matched_count
-				}, currentTurnId, event.source);
-				return;
-			case "hook.resolved":
-				sendWire("hook.resolved", {
-					hook_id: event.hook_id,
-					outcome: event.outcome
-				}, currentTurnId, event.source);
-				return;
-			case "status.update":
-				sendWire("status.update", event.data, currentTurnId, event.source);
-				return;
-			case "session_meta.changed":
-				sendWire("session_meta.changed", event.data, currentTurnId, event.source);
-				return;
-			case "thinking.changed":
-				sendWire("thinking.changed", { level: event.level }, currentTurnId, event.source);
-				return;
-			case "skill.invoked":
-				sendWire("skill.invoked", event.data, currentTurnId, event.source);
-				return;
-			case "skill.completed":
-				sendWire("skill.completed", event.data, currentTurnId, event.source);
-				return;
-			case "mcp.loading":
-			case "mcp.connected":
-			case "mcp.disconnected":
-			case "mcp.error":
-			case "mcp.tools_changed":
-			case "mcp.resources_changed":
-			case "mcp.auth_required":
-			case "status.update.mcp_status":
-				sendWire(event.type, event.data, currentTurnId, event.source);
-				return;
-			case "subagent.spawned":
-			case "subagent.completed":
-			case "subagent.failed":
-				sendWire(event.type, event.data, currentTurnId, event.source);
-				return;
-			default:
-		}
+		const draft = translateBusEvent(event, currentTurnId);
+		if (draft !== void 0) pipeline.enqueue(draft);
+	};
+	const notificationListener = (notif) => {
+		pipeline.enqueue(translateNotificationEvent(notif));
 	};
 	const turnListener = (event) => {
-		if (event.kind === "begin") {
-			currentTurnId = event.turnId;
-			sendWire("turn.begin", {
-				turn_id: event.turnId,
-				user_input: event.userInputParts ?? event.userInput,
-				input_kind: event.inputKind
-			}, event.turnId);
-			return;
-		}
-		const turnId = event.turnId;
-		sendWire("turn.end", {
-			turn_id: turnId,
-			reason: event.reason,
-			success: event.success,
-			...event.usage !== void 0 ? { usage: {
-				input_tokens: event.usage.input,
-				output_tokens: event.usage.output,
-				...event.usage.cache_read !== void 0 ? { cache_read_tokens: event.usage.cache_read } : {},
-				...event.usage.cache_write !== void 0 ? { cache_write_tokens: event.usage.cache_write } : {}
-			} } : {}
-		}, turnId);
-		if (currentTurnId === turnId) currentTurnId = void 0;
+		const translated = translateTurnLifecycleEvent(event, currentTurnId);
+		currentTurnId = translated.nextTurnId;
+		pipeline.enqueue(translated.draft);
 	};
 	const unsubTurn = addTurnLifecycleListener(turnListener);
 	eventBus.on(soulListener);
+	eventBus.subscribeNotifications(notificationListener);
 	return { dispose() {
 		eventBus.off(soulListener);
+		eventBus.unsubscribeNotifications(notificationListener);
 		unsubTurn();
 	} };
 }
@@ -30116,6 +30412,48 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
+//#region ../../packages/kimi-core/src/session/state-cache.ts
+/**
+* StateCache — state.json derived cache (§9续).
+*
+* Reads / writes `state.json` in a session directory. Used by
+* SessionManager to persist session metadata and runtime state (model,
+* permission mode, plan mode, last turn index) outside the transcript.
+*
+* Writes go through `atomicWrite` (write-tmp-fsync-rename, Decision #104)
+* so a crash mid-write never leaves a half-truncated state.json that
+* subsequent reads would treat as "missing". Read-modify-write callers
+* still need their own concurrency guard for "merge then write" races
+* across processes — see SessionManager.renameSession.
+*/
+var StateCache = class {
+	writeQueue = Promise.resolve();
+	constructor(statePath) {
+		this.statePath = statePath;
+	}
+	async read() {
+		try {
+			const raw = await readFile(this.statePath, "utf-8");
+			if (raw.length === 0) return null;
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+	async write(state) {
+		await atomicWrite(this.statePath, JSON.stringify(state, null, 2));
+	}
+	async update(mutator) {
+		const nextWrite = this.writeQueue.then(async () => {
+			const next = mutator(await this.read());
+			await this.write(next);
+			return next;
+		});
+		this.writeQueue = nextWrite.then(() => {}, () => {});
+		return nextWrite;
+	}
+};
+//#endregion
 //#region ../../packages/kimi-core/src/session/session-application-service.ts
 function withCompactionConfigFallback(bundle, fallback) {
 	if (bundle.compactionConfig !== void 0 || fallback === void 0) return bundle;
@@ -30192,7 +30530,7 @@ var DefaultSessionApplicationService = class {
 			eventBus,
 			...hookEngine !== void 0 ? { hookEngine } : {}
 		});
-		const initialModel = this.deps.defaultModelProvider();
+		const initialModel = (await new StateCache(this.deps.pathConfig.statePath(sessionId)).read())?.model ?? this.deps.defaultModelProvider();
 		const runtimeBundle = await this.deps.runtimeBundleProvider?.({
 			sessionId,
 			model: initialModel
@@ -30268,22 +30606,13 @@ var DefaultSessionApplicationService = class {
 	}
 	async resumeSnapshot(sessionId) {
 		const managed = this.getManaged(sessionId);
-		let turnCount = 0;
-		let lastTurnId;
-		try {
-			const bodyLines = (await readFile(this.deps.pathConfig.wirePath(sessionId), "utf8")).split("\n").filter((line) => line.length > 0).slice(1);
-			for (const line of bodyLines) try {
-				const rec = JSON.parse(line);
-				if (rec.type === "turn_begin") {
-					turnCount += 1;
-					if (rec.turn_id !== void 0) lastTurnId = rec.turn_id;
-				}
-			} catch {}
-		} catch {}
+		const state = await managed.stateCache.read();
+		const turnCount = state?.turn_count ?? 0;
+		const lastTurnId = state?.last_turn_id;
 		managed.eventBus.emit({
 			type: "status.update",
 			data: {
-				model: this.deps.defaultModelProvider(),
+				model: managed.contextState.model,
 				plan_mode: managed.soulPlus.getTurnManager().getPlanMode(),
 				yolo: managed.soulPlus.getTurnManager().getPermissionMode() === "bypassPermissions"
 			}
@@ -30349,7 +30678,21 @@ var DefaultSessionApplicationService = class {
 	}
 	async setYolo(sessionId, enabled) {
 		const managed = this.getManaged(sessionId);
-		await managed.sessionControl.setYolo(enabled);
+		const permissionMode = enabled ? "bypassPermissions" : "default";
+		await managed.stateCache.update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? {
+					session_id: sessionId,
+					created_at: now,
+					updated_at: now
+				},
+				permission_mode: permissionMode,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
+		managed.soulPlus.getTurnManager().setPermissionMode(permissionMode);
 		if (this.deps.approvalStateStore !== void 0) await this.deps.approvalStateStore.setYolo(enabled);
 		managed.soulPlus.getTurnManager().emitStatusUpdate({
 			input: 0,
@@ -30384,6 +30727,19 @@ var DefaultSessionApplicationService = class {
 				compactionConfig
 			});
 		}
+		await managed.stateCache.update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? {
+					session_id: sessionId,
+					created_at: now,
+					updated_at: now
+				},
+				model,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
 		await managed.soulPlus.setModel(model);
 	}
 	async setSystemPrompt(sessionId, prompt) {
@@ -30393,7 +30749,21 @@ var DefaultSessionApplicationService = class {
 		});
 	}
 	async setThinking(sessionId, level) {
-		await this.getManaged(sessionId).soulPlus.setThinking(level);
+		const managed = this.getManaged(sessionId);
+		await managed.stateCache.update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? {
+					session_id: sessionId,
+					created_at: now,
+					updated_at: now
+				},
+				thinking_level: level,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
+		await managed.soulPlus.setThinking(level);
 	}
 	async addSystemReminder(sessionId, content) {
 		await this.getManaged(sessionId).soulPlus.addSystemReminder(content);
@@ -30448,7 +30818,7 @@ var ChangeListenerRegistry = class {
 	}
 };
 /**
-* Production adapter that reads / writes `auto_approve_actions` + `yolo`
+* Production adapter that reads / writes `auto_approve_actions` + `permission_mode`
 * on the session's `state.json` file via the existing `StateCache`
 * service. The rest of the state.json fields are preserved on write —
 * we only rewrite the approval-state fields.
@@ -30476,7 +30846,7 @@ var SessionStateApprovalStateStore = class {
 		const raw = state?.auto_approve_actions;
 		const actions = raw === void 0 ? /* @__PURE__ */ new Set() : new Set(raw);
 		this.cachedActions = new Set(actions);
-		this.cachedYolo = state?.yolo ?? false;
+		this.cachedYolo = permissionModeFromState(state) === "bypassPermissions";
 		return actions;
 	}
 	async save(actions) {
@@ -30487,7 +30857,7 @@ var SessionStateApprovalStateStore = class {
 	async getYolo() {
 		if (this.cachedYolo !== void 0) return this.cachedYolo;
 		const state = await this.stateCache.read();
-		this.cachedYolo = state?.yolo ?? false;
+		this.cachedYolo = permissionModeFromState(state) === "bypassPermissions";
 		this.cachedActions = new Set(state?.auto_approve_actions ?? []);
 		return this.cachedYolo;
 	}
@@ -30505,7 +30875,7 @@ var SessionStateApprovalStateStore = class {
 		const current = await this.stateCache.read();
 		const now = this.now();
 		const nextActions = patch.actions !== void 0 ? [...patch.actions] : current?.auto_approve_actions !== void 0 ? [...current.auto_approve_actions] : void 0;
-		const nextYolo = patch.yolo !== void 0 ? patch.yolo : current?.yolo;
+		const nextMode = patch.yolo !== void 0 ? patch.yolo ? "bypassPermissions" : "default" : permissionModeFromState(current);
 		const next = {
 			...current ? {
 				...current,
@@ -30516,7 +30886,7 @@ var SessionStateApprovalStateStore = class {
 				updated_at: now
 			},
 			...nextActions !== void 0 ? { auto_approve_actions: nextActions } : {},
-			...nextYolo !== void 0 ? { yolo: nextYolo } : {}
+			permission_mode: nextMode
 		};
 		await this.stateCache.write(next);
 	}
@@ -30527,6 +30897,11 @@ var SessionStateApprovalStateStore = class {
 		});
 	}
 };
+function permissionModeFromState(state) {
+	const mode = state?.permission_mode;
+	if (mode === "acceptEdits" || mode === "bypassPermissions") return mode;
+	return "default";
+}
 //#endregion
 //#region ../../packages/kimi-core/src/wire-protocol/reverse-rpc.ts
 /**
@@ -30686,6 +31061,10 @@ function buildHookRequestData(subscriptionId, input) {
 		base["tool_call_id"] = input.toolCall.id;
 		base["args"] = input.toolCall.args;
 	}
+	if (input.event === "PreTurn" || input.event === "UserPromptSubmit") base["prompt"] = input.prompt;
+	if (input.event === "PostTurn" || input.event === "Stop") base["reason"] = input.reason;
+	if (input.event === "PreStep" || input.event === "PostStep") base["step_number"] = input.stepNumber;
+	if (input.event === "PostStep") base["stop_reason"] = input.stopReason;
 	return base;
 }
 //#endregion
@@ -30728,21 +31107,6 @@ function buildHookRequestData(subscriptionId, input) {
 *   - `registerDefaultWireHandlers` returns a handle so the host can
 *     plug per-session state (event filter for now) into the bridge.
 */
-const HOOK_SUPPORTED_EVENTS = [
-	"PreToolUse",
-	"PostToolUse",
-	"OnToolFailure",
-	"UserPromptSubmit",
-	"Stop",
-	"StopFailure",
-	"Notification",
-	"SubagentStart",
-	"SubagentStop",
-	"SessionStart",
-	"SessionEnd",
-	"PreCompact",
-	"PostCompact"
-];
 const SUPPORTED_WIRE_EVENTS = [
 	"turn.begin",
 	"turn.end",
@@ -30981,7 +31345,7 @@ function registerDefaultWireHandlers(deps) {
 				events: [...SUPPORTED_WIRE_EVENTS],
 				methods: [...SUPPORTED_WIRE_METHODS],
 				hooks: {
-					supported_events: HOOK_SUPPORTED_EVENTS,
+					supported_events: SUPPORTED_HOOK_EVENTS,
 					configured: initialHooks.map((h) => ({
 						event: h.event,
 						...typeof h.matcher === "string" && h.matcher.length > 0 ? { matcher: h.matcher } : {}
@@ -32063,12 +32427,6 @@ async function repairJournal(options) {
 }
 //#endregion
 //#region ../../packages/kimi-core/src/session/replay-projector.ts
-/** Whitelist of valid PermissionMode values for safe runtime validation. */
-const VALID_PERMISSION_MODES = new Set([
-	"default",
-	"acceptEdits",
-	"bypassPermissions"
-]);
 function isContentPart(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const part = value;
@@ -32084,26 +32442,26 @@ function cloneContentPart(part) {
 * Project replayed WireRecords into the initial state needed to hydrate a
 * resumed `WiredContextState`.
 *
-* Phase 23 — the `sessionInitialized` baseline is the truth source for
-* startup config (system_prompt / model / active_tools / permission_mode /
-* plan_mode / workspace_dir). Subsequent `*_changed` records in `records`
-* overlay the baseline.
+* `sessionInitialized` is the truth source for wire-owned startup context
+* (system_prompt / active_tools). Runtime/session config (model,
+* permission_mode, plan_mode, workspace_dir, thinking_level) comes from
+* `runtimeBaseline`, which is built from state.json by SessionManager.
 *
 * @param records — ordered records from `replayWire().records`
 * @param sessionInitialized — the line-2 baseline from `replayWire().sessionInitialized`
 * @returns Projected state suitable for `WiredContextState` constructor.
 */
-function projectReplayState(records, sessionInitialized) {
+function projectReplayState(records, sessionInitialized, runtimeBaseline) {
 	let messages = [];
-	let model = sessionInitialized.model;
+	let model = runtimeBaseline?.model ?? sessionInitialized.model ?? "";
 	let systemPrompt = sessionInitialized.system_prompt;
 	const activeTools = new Set(sessionInitialized.active_tools);
 	let lastSeq = 0;
-	let permissionMode = sessionInitialized.permission_mode;
+	let permissionMode = runtimeBaseline?.permissionMode ?? sessionInitialized.permission_mode ?? "default";
 	let tokenCount = 0;
-	let planMode = sessionInitialized.plan_mode;
-	let thinkingLevel = sessionInitialized.thinking_level;
-	const workspaceDir = sessionInitialized.workspace_dir;
+	let planMode = runtimeBaseline?.planMode ?? sessionInitialized.plan_mode ?? false;
+	let thinkingLevel = runtimeBaseline?.thinkingLevel ?? sessionInitialized.thinking_level;
+	const workspaceDir = runtimeBaseline?.workspaceDir ?? sessionInitialized.workspace_dir ?? process.cwd();
 	const sessionMetaPatch = { turn_count: 0 };
 	let todos = [];
 	const pendingTodoWrites = /* @__PURE__ */ new Map();
@@ -32184,21 +32542,9 @@ function projectReplayState(records, sessionInitialized) {
 				}];
 				tokenCount = r.post_compact_tokens;
 				break;
-			case "model_changed":
-				model = r.new_model;
-				sessionMetaPatch.last_model = r.new_model;
-				break;
 			case "turn_begin":
 				sessionMetaPatch.turn_count += 1;
 				break;
-			case "session_meta_changed":
-				if (r.patch.title !== void 0) sessionMetaPatch.title = r.patch.title;
-				if (r.patch.tags !== void 0) sessionMetaPatch.tags = [...r.patch.tags];
-				if (r.patch.description !== void 0) sessionMetaPatch.description = r.patch.description;
-				if (r.patch.archived !== void 0) sessionMetaPatch.archived = r.patch.archived;
-				if (r.patch.color !== void 0) sessionMetaPatch.color = r.patch.color;
-				if (r.patch.plan_slug !== void 0) sessionMetaPatch.plan_slug = r.patch.plan_slug;
-				break;
 			case "system_prompt_changed":
 				systemPrompt = r.new_prompt;
 				break;
@@ -32209,15 +32555,6 @@ function projectReplayState(records, sessionInitialized) {
 				} else if (r.operation === "register") for (const t of r.tools) activeTools.add(t);
 				else if (r.operation === "remove") for (const t of r.tools) activeTools.delete(t);
 				break;
-			case "permission_mode_changed":
-				if (VALID_PERMISSION_MODES.has(r.data.to)) permissionMode = r.data.to;
-				break;
-			case "plan_mode_changed":
-				planMode = r.enabled;
-				break;
-			case "thinking_changed":
-				thinkingLevel = r.level;
-				break;
 			case "context_cleared":
 				flushOpenStep();
 				messages = [];
@@ -32362,38 +32699,6 @@ var SessionTodoStore = class {
 	}
 };
 //#endregion
-//#region ../../packages/kimi-core/src/session/state-cache.ts
-/**
-* StateCache — state.json derived cache (§9续).
-*
-* Reads / writes `state.json` in a session directory. Used by
-* SessionManager to persist quick-access session metadata (model,
-* status, last turn timestamp) without replaying the full wire.jsonl.
-*
-* Writes go through `atomicWrite` (write-tmp-fsync-rename, Decision #104)
-* so a crash mid-write never leaves a half-truncated state.json that
-* subsequent reads would treat as "missing". Read-modify-write callers
-* still need their own concurrency guard for "merge then write" races
-* across processes — see SessionManager.renameSession.
-*/
-var StateCache = class {
-	constructor(statePath) {
-		this.statePath = statePath;
-	}
-	async read() {
-		try {
-			const raw = await readFile(this.statePath, "utf-8");
-			if (raw.length === 0) return null;
-			return JSON.parse(raw);
-		} catch {
-			return null;
-		}
-	}
-	async write(state) {
-		await atomicWrite(this.statePath, JSON.stringify(state, null, 2));
-	}
-};
-//#endregion
 //#region ../../packages/kimi-core/src/session/usage-aggregator.ts
 /**
 * Token usage aggregator — replays a wire.jsonl and sums usage from
@@ -32553,6 +32858,17 @@ function normalizeRuntimeSlot(slot, fallback) {
 	});
 	return runtimeSlot;
 }
+function normalizePermissionMode(value) {
+	if (value === "acceptEdits" || value === "bypassPermissions") return value;
+	return "default";
+}
+function createFallbackState(sessionId, now) {
+	return {
+		session_id: sessionId,
+		created_at: now,
+		updated_at: now
+	};
+}
 var SessionManager = class {
 	paths;
 	producer;
@@ -32590,6 +32906,29 @@ var SessionManager = class {
 		this.stateWriteMutex.set(sessionId, next.then(() => {}, () => {}));
 		return next;
 	}
+	attachStateTracker(sessionId, stateCache, turnManager) {
+		return turnManager.addTurnLifecycleListener((event) => {
+			const now = Date.now();
+			stateCache.update((current) => {
+				const base = current ?? createFallbackState(sessionId, now);
+				if (event.kind === "begin") return {
+					...base,
+					last_turn_id: event.turnId,
+					last_turn_time: now,
+					updated_at: now,
+					last_exit_code: "dirty"
+				};
+				return {
+					...base,
+					turn_count: (base.turn_count ?? 0) + 1,
+					last_turn_id: event.turnId,
+					last_turn_time: now,
+					updated_at: now,
+					last_exit_code: "dirty"
+				};
+			}).catch(() => {});
+		});
+	}
 	async createSession(options) {
 		const sessionId = options.sessionId ?? `ses_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
 		if (this.sessions.has(sessionId)) throw new Error(`Session already exists: ${sessionId}`);
@@ -32623,11 +32962,7 @@ var SessionManager = class {
 			agent_type: "main",
 			session_id: sessionId,
 			system_prompt: options.systemPrompt ?? "",
-			model: options.model,
-			active_tools: sessionTools.map((t) => t.name),
-			permission_mode: options.permissionMode ?? "default",
-			plan_mode: false,
-			workspace_dir: options.workspaceDir
+			active_tools: sessionTools.map((t) => t.name)
 		};
 		await journalWriter.append(mainInitInput);
 		const sessionJournal = new WiredSessionJournalImpl(journalWriter);
@@ -32643,10 +32978,12 @@ var SessionManager = class {
 		await stateCache.write({
 			session_id: sessionId,
 			model: options.model,
-			status: "active",
 			created_at: now,
 			updated_at: now,
 			workspace_dir: options.workspaceDir,
+			permission_mode: options.permissionMode ?? "default",
+			plan_mode: false,
+			turn_count: 0,
 			last_exit_code: "dirty",
 			producer: this.producer,
 			todos: []
@@ -32703,6 +33040,7 @@ var SessionManager = class {
 			...options.logger !== void 0 ? { logger: options.logger } : {}
 		});
 		turnManagerRef = soulPlus.getTurnManager();
+		const disposeStateTracking = this.attachStateTracker(sessionId, stateCache, turnManagerRef);
 		await soulPlus.init();
 		if (options.permissionMode !== void 0) turnManagerRef.setPermissionMode(options.permissionMode);
 		const managed = {
@@ -32712,7 +33050,20 @@ var SessionManager = class {
 				turnManager: turnManagerRef,
 				contextState,
 				sessionJournal,
-				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled)
+				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled),
+				setYoloOverride: async (enabled) => {
+					const permissionMode = enabled ? "bypassPermissions" : "default";
+					await stateCache.update((current) => {
+						const now = Date.now();
+						return {
+							...current ?? createFallbackState(sessionId, now),
+							permission_mode: permissionMode,
+							updated_at: now,
+							last_exit_code: "dirty"
+						};
+					});
+					turnManagerRef.setPermissionMode(permissionMode);
+				}
 			}),
 			contextState,
 			eventBus,
@@ -32721,6 +33072,7 @@ var SessionManager = class {
 			journalWriter,
 			runtimeSlot,
 			lifecycleStateMachine,
+			disposeStateTracking,
 			todoStore
 		};
 		this.sessions.set(sessionId, managed);
@@ -32743,7 +33095,18 @@ var SessionManager = class {
 			throw new Error(`Failed to replay session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}
 		if (replayResult.sessionInitialized.agent_type !== "main") throw new MalformedWireError("agent-type-mismatch", `resumeSession expected agent_type='main' on wire line 2 for "${sessionId}", got agent_type='${replayResult.sessionInitialized.agent_type}'`);
-		const projected = projectReplayState(replayResult.records, replayResult.sessionInitialized);
+		const stateCache = new StateCache(this.paths.statePath(sessionId));
+		const stateData = await stateCache.read();
+		if (stateData === null) throw new Error(`resumeSession: state.json missing or unreadable for session "${sessionId}"`);
+		if (stateData.model === void 0 || stateData.model.length === 0) throw new Error(`resumeSession: state.json missing model for session "${sessionId}"`);
+		const statePermissionMode = normalizePermissionMode(stateData.permission_mode);
+		const projected = projectReplayState(replayResult.records, replayResult.sessionInitialized, {
+			model: stateData.model,
+			permissionMode: statePermissionMode,
+			planMode: stateData.plan_mode ?? false,
+			workspaceDir: stateData.workspace_dir ?? process.cwd(),
+			...stateData.thinking_level !== void 0 ? { thinkingLevel: stateData.thinking_level } : {}
+		});
 		const lifecycleStateMachine = new SessionLifecycleStateMachine();
 		const lifecycleGate = new SoulLifecycleGate(lifecycleStateMachine);
 		let contextStateRef;
@@ -32778,10 +33141,7 @@ var SessionManager = class {
 			sessionJournal,
 			currentTurnId: () => turnManagerRef?.getCurrentTurnId() ?? "recovery"
 		});
-		const stateCache = new StateCache(this.paths.statePath(sessionId));
-		const stateData = await stateCache.read();
-		const isClean = stateData?.last_exit_code === "clean";
-		const initialTodos = isClean ? cloneTodos(stateData?.todos ?? projected.todos) : cloneTodos(projected.todos);
+		const initialTodos = stateData.last_exit_code === "clean" ? cloneTodos(stateData.todos ?? projected.todos) : cloneTodos(projected.todos);
 		const todoStore = new SessionTodoStore(stateCache, initialTodos);
 		const sessionTools = bindTodoStore(options.tools, todoStore);
 		const runtimeSlot = normalizeRuntimeSlot(options.runtimeSlot, {
@@ -32791,32 +33151,25 @@ var SessionManager = class {
 			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {}
 		});
 		const runtimeBundle = runtimeSlot.current();
-		if (stateData !== null) await stateCache.write({
+		await stateCache.write({
 			...stateData,
-			status: "active",
 			updated_at: Date.now(),
 			todos: initialTodos,
 			last_exit_code: "dirty"
 		});
-		const replayedMeta = projected.sessionMetaPatch;
 		const now = Date.now();
-		const pickTitle = isClean ? stateData?.custom_title ?? replayedMeta.title : replayedMeta.title ?? stateData?.custom_title;
-		const pickTags = isClean ? stateData?.tags ?? replayedMeta.tags : replayedMeta.tags ?? stateData?.tags;
-		const pickDescription = isClean ? stateData?.description ?? replayedMeta.description : replayedMeta.description ?? stateData?.description;
-		const pickArchived = isClean ? stateData?.archived ?? replayedMeta.archived : replayedMeta.archived ?? stateData?.archived;
-		const pickLastModel = isClean ? stateData?.model ?? replayedMeta.last_model : replayedMeta.last_model ?? stateData?.model;
-		const pickPlanSlug = isClean ? stateData?.plan_slug ?? replayedMeta.plan_slug : replayedMeta.plan_slug ?? stateData?.plan_slug;
 		const initialMeta = {
 			session_id: sessionId,
-			created_at: stateData?.created_at ?? now,
-			turn_count: replayedMeta.turn_count,
-			last_updated: stateData?.updated_at ?? now,
-			...pickTitle !== void 0 ? { title: pickTitle } : {},
-			...pickTags !== void 0 ? { tags: [...pickTags] } : {},
-			...pickDescription !== void 0 ? { description: pickDescription } : {},
-			...pickArchived !== void 0 ? { archived: pickArchived } : {},
-			...pickLastModel !== void 0 ? { last_model: pickLastModel } : {},
-			...pickPlanSlug !== void 0 ? { plan_slug: pickPlanSlug } : {},
+			created_at: stateData.created_at ?? now,
+			turn_count: stateData.turn_count ?? 0,
+			last_updated: stateData.updated_at ?? now,
+			...stateData.custom_title !== void 0 ? { title: stateData.custom_title } : {},
+			...stateData.tags !== void 0 ? { tags: [...stateData.tags] } : {},
+			...stateData.description !== void 0 ? { description: stateData.description } : {},
+			...stateData.archived !== void 0 ? { archived: stateData.archived } : {},
+			...stateData.color !== void 0 ? { color: stateData.color } : {},
+			last_model: stateData.model,
+			...stateData.plan_slug !== void 0 ? { plan_slug: stateData.plan_slug } : {},
 			producer: replayResult.producer,
 			last_exit_code: "dirty"
 		};
@@ -32865,11 +33218,12 @@ var SessionManager = class {
 				subagentStore,
 				agentTypeRegistry: options.agentTypeRegistry,
 				sessionDir,
-				workDir: stateData?.workspace_dir ?? process.cwd()
+				workDir: stateData.workspace_dir ?? process.cwd()
 			} : {},
 			...options.logger !== void 0 ? { logger: options.logger } : {}
 		});
 		turnManagerRef = soulPlus.getTurnManager();
+		const disposeStateTracking = this.attachStateTracker(sessionId, stateCache, turnManagerRef);
 		await soulPlus.init();
 		turnManagerRef.setPermissionMode(effectivePermissionMode);
 		if (projected.thinkingLevel !== void 0) turnManagerRef.setThinkingLevel(projected.thinkingLevel);
@@ -32896,7 +33250,20 @@ var SessionManager = class {
 				turnManager: turnManagerRef,
 				contextState,
 				sessionJournal,
-				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled)
+				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled),
+				setYoloOverride: async (enabled) => {
+					const permissionMode = enabled ? "bypassPermissions" : "default";
+					await stateCache.update((current) => {
+						const now = Date.now();
+						return {
+							...current ?? createFallbackState(sessionId, now),
+							permission_mode: permissionMode,
+							updated_at: now,
+							last_exit_code: "dirty"
+						};
+					});
+					turnManagerRef.setPermissionMode(permissionMode);
+				}
 			}),
 			contextState,
 			eventBus,
@@ -32905,6 +33272,7 @@ var SessionManager = class {
 			journalWriter,
 			runtimeSlot,
 			lifecycleStateMachine,
+			disposeStateTracking,
 			todoStore
 		};
 		this.sessions.set(sessionId, managed);
@@ -32926,7 +33294,6 @@ var SessionManager = class {
 				session_id: state.session_id,
 				created_at: state.created_at,
 				...state.model !== void 0 ? { model: state.model } : {},
-				...state.status !== void 0 ? { status: state.status } : {},
 				...state.workspace_dir !== void 0 ? { workspace_dir: state.workspace_dir } : {},
 				...state.custom_title !== void 0 ? { title: state.custom_title } : {},
 				...lastActivity !== void 0 ? { last_activity: lastActivity } : {},
@@ -32970,7 +33337,8 @@ var SessionManager = class {
 			await cache.write({
 				...existing,
 				custom_title: trimmed,
-				updated_at: Date.now()
+				updated_at: Date.now(),
+				last_exit_code: "dirty"
 			});
 			this.usageAggregator.invalidate(this.paths.wirePath(sessionId));
 		});
@@ -32995,7 +33363,8 @@ var SessionManager = class {
 			await cache.write({
 				...existing,
 				tags: next,
-				updated_at: Date.now()
+				updated_at: Date.now(),
+				last_exit_code: "dirty"
 			});
 			this.usageAggregator.invalidate(this.paths.wirePath(sessionId));
 		});
@@ -33079,7 +33448,29 @@ var SessionManager = class {
 			keepUpToLine = turnBeginIndices[totalTurns - nTurnsBack];
 			newTurnCount = totalTurns - nTurnsBack;
 		}
-		await atomicWrite(wirePath, `${lines.slice(0, keepUpToLine).join("\n")}\n`);
+		const kept = lines.slice(0, keepUpToLine);
+		await atomicWrite(wirePath, `${kept.join("\n")}\n`);
+		let lastTurnId;
+		let lastTurnTime;
+		for (let i = kept.length - 1; i >= 0; i--) try {
+			const rec = JSON.parse(kept[i] ?? "");
+			if (rec.type === "turn_begin" && rec.turn_id !== void 0) {
+				lastTurnId = rec.turn_id;
+				if (typeof rec.time === "number") lastTurnTime = rec.time;
+				break;
+			}
+		} catch {}
+		await new StateCache(this.paths.statePath(sessionId)).update((current) => {
+			const now = Date.now();
+			return {
+				...current ?? createFallbackState(sessionId, now),
+				turn_count: newTurnCount,
+				last_turn_id: lastTurnId,
+				last_turn_time: lastTurnTime,
+				updated_at: now,
+				last_exit_code: "dirty"
+			};
+		});
 		this.usageAggregator.invalidate(wirePath);
 		return { new_turn_count: newTurnCount };
 	}
@@ -33091,18 +33482,8 @@ var SessionManager = class {
 	async getSessionStatus(sessionId) {
 		const live = this.sessions.get(sessionId);
 		if (live !== void 0) return live.lifecycleStateMachine.state;
-		const state = await new StateCache(this.paths.statePath(sessionId)).read();
-		if (state === null) throw new Error(`getSessionStatus: session "${sessionId}" not found`);
-		const validStatuses = new Set([
-			"idle",
-			"active",
-			"completing",
-			"compacting",
-			"destroying",
-			"closed"
-		]);
-		if (state.status !== void 0 && validStatuses.has(state.status)) return state.status;
-		return "idle";
+		if (await new StateCache(this.paths.statePath(sessionId)).read() === null) throw new Error(`getSessionStatus: session "${sessionId}" not found`);
+		return "closed";
 	}
 	/**
 	* Return aggregated token usage for a session.
@@ -33141,33 +33522,43 @@ var SessionManager = class {
 			await managed.todoStore?.flushPending();
 			const existing = await managed.stateCache.read();
 			const now = Date.now();
-			const currentPlanMode = managed.soulPlus.getTurnManager().getPlanMode();
+			const turnManager = managed.soulPlus.getTurnManager();
+			const currentPlanMode = turnManager.getPlanMode();
+			const currentPermissionMode = turnManager.getPermissionMode();
+			const currentThinkingLevel = turnManager.getThinkingLevel();
 			const currentTodos = managed.todoStore?.getTodos() ?? [];
 			const meta = sessionMetaService?.get();
 			const stateToFlush = existing ? {
 				...existing,
-				status: "closed",
 				updated_at: now,
+				model: managed.contextState.model,
+				permission_mode: currentPermissionMode,
 				...meta?.title !== void 0 ? { custom_title: meta.title } : {},
 				...meta?.tags !== void 0 ? { tags: [...meta.tags] } : {},
 				...meta?.description !== void 0 ? { description: meta.description } : {},
 				...meta?.archived !== void 0 ? { archived: meta.archived } : {},
-				...meta?.last_model !== void 0 ? { model: meta.last_model } : {},
+				...meta?.color !== void 0 ? { color: meta.color } : {},
+				turn_count: meta?.turn_count ?? existing.turn_count ?? 0,
 				...meta?.plan_slug !== void 0 ? { plan_slug: meta.plan_slug } : {},
+				...currentThinkingLevel !== void 0 ? { thinking_level: currentThinkingLevel } : {},
 				...currentPlanMode ? { plan_mode: true } : { plan_mode: false },
 				todos: cloneTodos(currentTodos),
 				last_exit_code: "clean"
 			} : {
 				session_id: sessionId,
-				status: "closed",
 				created_at: now,
 				updated_at: now,
+				model: managed.contextState.model,
+				permission_mode: currentPermissionMode,
 				plan_mode: currentPlanMode,
+				turn_count: meta?.turn_count ?? 0,
+				...currentThinkingLevel !== void 0 ? { thinking_level: currentThinkingLevel } : {},
 				todos: cloneTodos(currentTodos),
 				last_exit_code: "clean"
 			};
 			await managed.stateCache.write(stateToFlush);
 			sessionMetaService?.dispose();
+			managed.disposeStateTracking?.();
 			await managed.journalWriter.close();
 			this.sessions.delete(sessionId);
 		});
@@ -94290,7 +94681,7 @@ function shellQuote(path) {
 }
 //#endregion
 //#region src/tui/components/messages/assistant-message.ts
-const BULLET$1 = "● ";
+const BULLET$1 = "⏺ ";
 const INDENT$2 = "  ";
 var AssistantMessageComponent = class {
 	contentContainer;
@@ -94363,7 +94754,7 @@ var ImageThumbnail = class extends Container {
 };
 //#endregion
 //#region src/tui/components/messages/thinking.ts
-const BULLET = "● ";
+const BULLET = "⏺ ";
 const INDENT$1 = "  ";
 const PREVIEW_LINES$1 = 3;
 var ThinkingComponent = class {
@@ -94563,6 +94954,19 @@ function extractApprovedPlan(output) {
 	if (markerIndex < 0) return "";
 	return output.slice(markerIndex + 17).trim();
 }
+function compactPreview(value) {
+	const oneLine = value.replaceAll(/\s+/g, " ").trim();
+	if (oneLine.length <= 160) return oneLine;
+	return oneLine.slice(0, 157) + "...";
+}
+function parseArgsPreview(value) {
+	if (value.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(value);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return { arguments: value };
+}
 function extractKeyArgument(toolName, args) {
 	const candidates = {
 		Shell: ["command"],
@@ -94650,6 +95054,12 @@ var ToolCallComponent = class extends Container {
 		this.headerText.setText(this.buildHeader());
 		this.rebuildContent();
 	}
+	updateToolCall(toolCall) {
+		this.toolCall = toolCall;
+		this.headerText.setText(this.buildHeader());
+		this.rebuildBody();
+		this.ui?.requestRender();
+	}
 	applySubagentReplay(subagent) {
 		if (subagent === void 0) return;
 		this.subagentAgentId = subagent.id;
@@ -94688,9 +95098,23 @@ var ToolCallComponent = class extends Container {
 		this.ui?.requestRender();
 	}
 	appendSubToolCall(call) {
+		const existing = this.ongoingSubCalls.get(call.id);
 		this.ongoingSubCalls.set(call.id, {
 			name: call.name,
-			args: call.args
+			args: call.args,
+			...existing?.streamingArguments !== void 0 ? { streamingArguments: existing.streamingArguments } : {}
+		});
+		this.rebuildContent();
+		this.ui?.requestRender();
+	}
+	appendSubToolCallDelta(delta) {
+		const existing = this.ongoingSubCalls.get(delta.id);
+		const nextArgsText = `${existing?.streamingArguments ?? ""}${delta.argumentsPart ?? ""}`;
+		const parsed = parseArgsPreview(nextArgsText);
+		this.ongoingSubCalls.set(delta.id, {
+			name: delta.name ?? existing?.name ?? "Tool",
+			args: parsed,
+			streamingArguments: nextArgsText
 		});
 		this.rebuildContent();
 		this.ui?.requestRender();
@@ -94717,8 +95141,8 @@ var ToolCallComponent = class extends Container {
 		const isFinished = result !== void 0;
 		const isError = result?.is_error ?? false;
 		let bullet;
-		if (isFinished) bullet = isError ? chalk.hex(colors.error)("✗ ") : chalk.hex(colors.success)("● ");
-		else bullet = this.blinkOn ? chalk.white("● ") : "  ";
+		if (isFinished) bullet = isError ? chalk.hex(colors.error)("✗ ") : chalk.hex(colors.success)("⏺ ");
+		else bullet = this.blinkOn ? chalk.white("⏺ ") : "  ";
 		if (toolCall.name === "ExitPlanMode") return chalk.hex(colors.primary).bold("Current plan");
 		if (toolCall.name === "AskUserQuestion") {
 			const label = isFinished ? isError ? "Could not collect your input" : "Collected your answers" : "Waiting for your input";
@@ -94736,6 +95160,13 @@ var ToolCallComponent = class extends Container {
 		this.buildContent();
 		this.buildSubagentBlock();
 	}
+	rebuildBody() {
+		while (this.children.length > 2) this.children.pop();
+		this.buildCallPreview();
+		this.callPreviewEndIndex = this.children.length;
+		this.buildContent();
+		this.buildSubagentBlock();
+	}
 	buildSubagentBlock() {
 		if (this.subagentAgentId === void 0 && this.ongoingSubCalls.size === 0 && this.finishedSubCalls.length === 0 && this.subagentText.length === 0) return;
 		const dim = chalk.dim;
@@ -94757,6 +95188,7 @@ var ToolCallComponent = class extends Container {
 			const nameCol = chalk.hex(this.colors.primary)(call.name);
 			const argCol = keyArg ? dim(` (${keyArg})`) : "";
 			this.addChild(new Text(`    ${dim("…")} Using ${nameCol}${argCol}`, 0, 0));
+			if (call.streamingArguments !== void 0 && call.streamingArguments.length > 0) this.addChild(new Text(`      ${dim(compactPreview(call.streamingArguments))}`, 0, 0));
 		}
 		if (this.subagentText.length > 0) {
 			const tailLines = this.subagentText.split("\n").slice(-3);
@@ -94773,15 +95205,19 @@ var ToolCallComponent = class extends Container {
 			this.buildPlanPreview();
 			return;
 		}
+		if (this.toolCall.streamingArguments !== void 0) {
+			this.addChild(new Text(chalk.dim(compactPreview(this.toolCall.streamingArguments)), 2, 0));
+			return;
+		}
 		if (name === "Write" || name === "WriteFile") {
 			const content = str(this.toolCall.args["content"]);
 			if (content.length === 0) return;
 			const allLines = highlightLines(content, langFromPath(str(this.toolCall.args["file_path"] ?? this.toolCall.args["path"])));
 			const shown = allLines.slice(0, CALL_PREVIEW_LINES);
 			const remaining = allLines.length - shown.length;
-			for (let i = 0; i < shown.length; i++) {
+			for (const [i, line] of shown.entries()) {
 				const lineNum = chalk.dim(String(i + 1).padStart(4) + "  ");
-				this.addChild(new Text(lineNum + shown[i], 2, 0));
+				this.addChild(new Text(lineNum + line, 2, 0));
 			}
 			if (remaining > 0) this.addChild(new Text(chalk.dim(`... (${String(remaining)} more lines, ${String(allLines.length)} total)`), 2, 0));
 		} else if (name === "Edit" || name === "EditFile") {
@@ -94815,15 +95251,14 @@ var ToolCallComponent = class extends Container {
 			return;
 		}
 		if (this.toolCall.name === "SetTodoList" && !result.is_error) return;
-		if (this.toolCall.name === "AskUserQuestion" && !result.is_error) {
-			if (this.renderAskUserQuestionResult(result.output)) return;
-		}
+		if (this.toolCall.name === "AskUserQuestion" && !result.is_error && this.renderAskUserQuestionResult(result.output)) return;
+		const tint = result.is_error ? chalk.hex(this.colors.error) : chalk.dim;
 		const lines = result.output.split("\n");
-		if (this.expanded) this.addChild(new Text(chalk.dim(result.output), 2, 0));
+		if (this.expanded) this.addChild(new Text(tint(result.output), 2, 0));
 		else {
 			const shown = lines.slice(0, PREVIEW_LINES);
 			const remaining = lines.length - shown.length;
-			this.addChild(new Text(chalk.dim(shown.join("\n")), 2, 0));
+			this.addChild(new Text(tint(shown.join("\n")), 2, 0));
 			if (remaining > 0) this.addChild(new Text(chalk.dim(`... (${String(remaining)} more lines, ctrl+o to expand)`), 2, 0));
 		}
 	}
@@ -94889,12 +95324,14 @@ var WelcomeComponent = class {
 		const gap = "  ";
 		const textWidth = Math.max(4, innerWidth - logoWidth - 2);
 		const rightRow0 = truncateToWidth(chalk.bold.hex(this.colors.primary)("Welcome to Kimi Code!"), textWidth, "…");
-		const rightRow1 = truncateToWidth(chalk.dim("Send /help for help information."), textWidth, "…");
+		const isLoggedOut = !this.state.model;
+		const rightRow1 = truncateToWidth(chalk.dim(isLoggedOut ? "Run /login to sign in." : "Send /help for help information."), textWidth, "…");
 		const headerLines = [primary(logo[0].padEnd(logoWidth)) + gap + rightRow0, primary(logo[1].padEnd(logoWidth)) + gap + rightRow1];
+		const modelValue = isLoggedOut ? chalk.yellow("(not signed in — run /login)") : this.state.model;
 		const infoLines = [
 			chalk.dim.bold("Directory: ") + this.state.workDir,
 			chalk.dim.bold("Session:   ") + this.state.sessionId,
-			chalk.dim.bold("Model:     ") + this.state.model,
+			chalk.dim.bold("Model:     ") + modelValue,
 			chalk.dim.bold("Version:   ") + this.state.version
 		];
 		const contentLines = [
@@ -95060,8 +95497,8 @@ function createTranscriptComponent(state, entry) {
 				if (state.toolOutputExpanded) tc.setExpanded(true);
 				return tc;
 			}
-			return createStatusEntry(entry.content, entry.color);
-		case "status": return createStatusEntry(entry.content, entry.color);
+			return entry.renderMode === "notice" ? createNoticeEntry(entry.content, entry.detail, state.colors) : createStatusEntry(entry.content, entry.color);
+		case "status": return entry.renderMode === "notice" ? createNoticeEntry(entry.content, entry.detail, state.colors) : createStatusEntry(entry.content, entry.color);
 		default: return null;
 	}
 }
@@ -95082,6 +95519,13 @@ function createStatusEntry(content, color) {
 	container.addChild(new Text(`  ${styled}`, 0, 0));
 	return container;
 }
+function createNoticeEntry(title, detail, colors) {
+	const container = new Container();
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(`  ${chalk.white(title)}`, 0, 0));
+	if (detail !== void 0 && detail.length > 0) container.addChild(new Text(`  ${chalk.hex(colors.textDim)(detail)}`, 0, 0));
+	return container;
+}
 /**
 * Push a new entry onto the transcript and render the matching
 * component. Equivalent to the old `KimiTUI.addTranscriptEntry`.
@@ -95113,6 +95557,16 @@ function emitStatus(state, message, color) {
 		...color !== void 0 ? { color } : {}
 	});
 }
+function emitNotice(state, title, detail) {
+	appendTranscriptEntry(state, {
+		id: nextTranscriptId(),
+		kind: "status",
+		turnId: state.currentTurnId,
+		renderMode: "notice",
+		content: title,
+		...detail !== void 0 ? { detail } : {}
+	});
+}
 /** Red. */
 function emitError(state, message) {
 	emitStatus(state, message, state.colors.error);
@@ -95125,10 +95579,6 @@ function emitSuccess(state, message) {
 function emitMuted(state, message) {
 	emitStatus(state, message, state.colors.textDim);
 }
-/** Primary (brand) color. */
-function emitPrimary(state, message) {
-	emitStatus(state, message, state.colors.primary);
-}
 //#endregion
 //#region src/tui/input/image-placeholder.ts
 const PLACEHOLDER_REGEX = /\[image #(\d+) \((\d+)×(\d+)\)\]/g;
@@ -95200,6 +95650,15 @@ function handleSubagentSourceEvent(ectx, payload) {
 		});
 		return;
 	}
+	if (payload.method === "tool.call.delta") {
+		const d = payload.data;
+		if (typeof d.tool_call_id === "string") tc.appendSubToolCallDelta({
+			id: `${payload.source_id}:${d.tool_call_id}`,
+			...typeof d.name === "string" ? { name: d.name } : {},
+			argumentsPart: typeof d.arguments_part === "string" ? d.arguments_part : null
+		});
+		return;
+	}
 	if (payload.method === "tool.result") {
 		const d = payload.data;
 		if (typeof d.tool_call_id === "string") tc.finishSubToolCall({
@@ -95494,6 +95953,10 @@ function ok$1(message) {
 	};
 	return { type: "ok" };
 }
+function showNotice(ctx, title, detail) {
+	ctx.showNotice(title, detail);
+	return ok$1();
+}
 const shellCommands = [
 	{
 		name: "exit",
@@ -95575,7 +96038,8 @@ const shellCommands = [
 			else enabled = !ctx.appState.yolo;
 			await ctx.client.setYolo(ctx.appState.sessionId, enabled);
 			ctx.setAppState({ yolo: enabled });
-			return ok$1(`YOLO mode: ${enabled ? "on" : "off"}`);
+			if (enabled) return showNotice(ctx, "YOLO mode: ON", "All actions will be approved automatically. Use with caution.");
+			return showNotice(ctx, "YOLO mode: OFF");
 		}
 	},
 	{
@@ -95600,8 +96064,9 @@ const shellCommands = [
 			else enabled = !ctx.appState.planMode;
 			const res = await ctx.client.setPlanMode(ctx.appState.sessionId, enabled);
 			ctx.setAppState({ planMode: enabled });
-			if (enabled && res.plan_path !== void 0) return ok$1(`Plan mode ON. Write your plan to: ${res.plan_path}`);
-			return ok$1(`Plan mode: ${enabled ? "on" : "off"}`);
+			if (enabled && res.plan_path !== void 0) return showNotice(ctx, "Plan mode: ON", `Plan will be created here: ${res.plan_path}`);
+			if (enabled) return showNotice(ctx, "Plan mode: ON");
+			return showNotice(ctx, "Plan mode: OFF");
 		}
 	},
 	{
@@ -95739,7 +96204,7 @@ var SlashCommandRegistry = class {
 	* 再注册当前 session 下的可用 skills。
 	*/
 	setSkillCommands(defs) {
-		for (const [name, def] of [...this.commands]) if (name.startsWith("skill:")) {
+		for (const [name, def] of this.commands) if (name.startsWith("skill:")) {
 			this.commands.delete(name);
 			this.lookup.delete(name);
 			for (const alias of def.aliases) this.lookup.delete(alias);
@@ -96540,6 +97005,7 @@ function createTUIState(options) {
 		assistantStreamActive: false,
 		thinkingDraft: "",
 		activeToolCalls: /* @__PURE__ */ new Map(),
+		streamingToolCallArguments: /* @__PURE__ */ new Map(),
 		toastTimers: /* @__PURE__ */ new Map(),
 		pendingExit: null,
 		queuedMessages: [],
@@ -96701,6 +97167,7 @@ function sendMessageInternal(state, addEntry, input, options) {
 	state.assistantStreamActive = false;
 	state.thinkingDraft = "";
 	state.activeToolCalls.clear();
+	state.streamingToolCallArguments.clear();
 	state.livePane = {
 		...state.livePane,
 		mode: "waiting",
@@ -96829,7 +97296,9 @@ async function openExternalEditor(state) {
 	state.externalEditorRunning = true;
 	const seed = state.editor.getExpandedText?.() ?? state.editor.getText();
 	state.ui.stop();
-	await new Promise((resolve) => setImmediate(resolve));
+	await new Promise((resolve) => {
+		setImmediate(resolve);
+	});
 	try {
 		const result = await editInExternalEditor(seed, cmd);
 		if (result !== void 0) state.editor.setText(result.replaceAll("\r\n", "\n").replace(/\n$/, ""));
@@ -96853,11 +97322,11 @@ async function togglePlanMode(state, hooks) {
 		return;
 	}
 	setState(state, { planMode: enabled }, hooks);
-	if (enabled && planPath !== void 0) {
-		emitPrimary(state, `Plan mode: ON. Write your plan to: ${planPath}`);
+	if (enabled) {
+		emitNotice(state, "Plan mode: ON", planPath !== void 0 ? `Plan will be created here: ${planPath}` : void 0);
 		return;
 	}
-	emitPrimary(state, `Plan mode: ${enabled ? "ON" : "OFF"}`);
+	emitNotice(state, "Plan mode: OFF");
 }
 async function performReload(state, action, hooks) {
 	if (state.appState.isStreaming) {
@@ -97319,6 +97788,7 @@ function releaseSessionSideEffects(state) {
 	state.queuedMessages = [];
 	state.queueIdCounter = 0;
 	state.activeToolCalls.clear();
+	state.streamingToolCallArguments?.clear();
 	state.currentTurnId = void 0;
 	state.assistantDraft = "";
 	state.assistantStreamActive = false;
@@ -97370,8 +97840,8 @@ var CompactionComponent = class extends Container {
 		this.stopBlink();
 	}
 	buildHeader() {
-		if (this.done) return `${chalk.hex(this.colors.success)("● ")}${chalk.hex(this.colors.success).bold("Compaction complete")}${this.tokensBefore !== void 0 && this.tokensAfter !== void 0 ? chalk.dim(` (${String(this.tokensBefore)} → ${String(this.tokensAfter)} tokens)`) : ""}`;
-		return `${this.blinkOn ? chalk.white("● ") : "  "}${chalk.hex(this.colors.primary).bold("Compacting context...")}`;
+		if (this.done) return `${chalk.hex(this.colors.success)("⏺ ")}${chalk.hex(this.colors.success).bold("Compaction complete")}${this.tokensBefore !== void 0 && this.tokensAfter !== void 0 ? chalk.dim(` (${String(this.tokensBefore)} → ${String(this.tokensAfter)} tokens)`) : ""}`;
+		return `${this.blinkOn ? chalk.white("⏺ ") : "  "}${chalk.hex(this.colors.primary).bold("Compacting context...")}`;
 	}
 	startBlink() {
 		this.blinkTimer = setInterval(() => {
@@ -97510,7 +97980,8 @@ async function dispatchSlashCommand(input, state, buildCtx, addEntry) {
 		client: ctx.client,
 		appState: ctx.appState,
 		setAppState: ctx.setAppState,
-		showStatus: ctx.showStatus
+		showStatus: ctx.showStatus,
+		showNotice: ctx.showNotice
 	};
 	let result;
 	try {
@@ -97577,6 +98048,7 @@ async function dispatchSlashCommand(input, state, buildCtx, addEntry) {
 //#endregion
 //#region src/tui/handlers/turn-lifecycle.ts
 function handleTurnBegin(ectx, _data) {
+	ectx.state.streamingToolCallArguments.clear();
 	ectx.patchLivePane({
 		mode: "waiting",
 		thinkingText: "",
@@ -97594,6 +98066,7 @@ function handleTurnBegin(ectx, _data) {
 function handleTurnEnd(ectx, _data, sendQueued) {
 	const todos = ectx.state.todoPanel.getTodos();
 	if (todos.length > 0 && todos.every((t) => t.status === "done")) ectx.setTodoList([]);
+	ectx.state.streamingToolCallArguments.clear();
 	finalizeTurn(ectx, sendQueued);
 }
 function handleStepBegin(ectx) {
@@ -97645,24 +98118,18 @@ function handleContentDelta(ectx, data) {
 			streamingPhase: "composing",
 			streamingStartTime: Date.now()
 		});
-		return;
-	}
-	if (data.type === "tool_call_part") {
-		if (ectx.state.thinkingDraft.length > 0) flushThinkingToTranscript(ectx, "idle");
-		ectx.patchLivePane({
-			mode: "idle",
-			pendingToolCall: null,
-			pendingApproval: null,
-			pendingQuestion: null
-		});
-		ectx.setAppState({
-			streamingPhase: "composing",
-			streamingStartTime: Date.now()
-		});
 	}
 }
 //#endregion
 //#region src/tui/handlers/tool.ts
+function parseStreamingArgs(argumentsText) {
+	if (argumentsText.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(argumentsText);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return { arguments: argumentsText };
+}
 function isTodoItemShape(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const rec = value;
@@ -97676,15 +98143,53 @@ function handleToolCall(ectx, data) {
 		args: data.args,
 		description: data.description
 	};
+	const existing = ectx.state.activeToolCalls.get(data.id);
 	ectx.state.activeToolCalls.set(data.id, toolCall);
-	flushTurnBuffers(ectx, "tool");
-	ectx.onToolCallStart(toolCall);
+	ectx.state.streamingToolCallArguments.delete(data.id);
+	const existingComponent = ectx.state.pendingToolComponents.get(data.id);
+	if (existingComponent !== void 0) existingComponent.updateToolCall(toolCall);
+	else if (existing === void 0) {
+		flushTurnBuffers(ectx, "tool");
+		ectx.onToolCallStart(toolCall);
+	}
+	ectx.patchLivePane({
+		mode: "tool",
+		pendingToolCall: toolCall,
+		pendingApproval: null,
+		pendingQuestion: null
+	});
+}
+function handleToolCallDelta(ectx, data) {
+	if (typeof data.tool_call_id !== "string" || data.tool_call_id.length === 0) return;
+	const id = data.tool_call_id;
+	const existing = ectx.state.streamingToolCallArguments.get(id);
+	const argumentsText = `${existing?.argumentsText ?? ""}${data.arguments_part ?? ""}`;
+	const name = data.name ?? existing?.name ?? ectx.state.activeToolCalls.get(id)?.name ?? "Tool";
+	ectx.state.streamingToolCallArguments.set(id, {
+		name,
+		argumentsText
+	});
+	const toolCall = {
+		id,
+		name,
+		args: parseStreamingArgs(argumentsText),
+		streamingArguments: argumentsText
+	};
+	ectx.state.activeToolCalls.set(id, toolCall);
+	if (ectx.state.thinkingDraft.length > 0) flushTurnBuffers(ectx, "tool");
+	const existingComponent = ectx.state.pendingToolComponents.get(id);
+	if (existingComponent !== void 0) existingComponent.updateToolCall(toolCall);
+	else ectx.onToolCallStart(toolCall);
 	ectx.patchLivePane({
 		mode: "tool",
 		pendingToolCall: toolCall,
 		pendingApproval: null,
 		pendingQuestion: null
 	});
+	ectx.setAppState({
+		streamingPhase: "composing",
+		streamingStartTime: Date.now()
+	});
 }
 function handleToolResult(ectx, data) {
 	const matchedCall = ectx.state.activeToolCalls.get(data.tool_call_id);
@@ -97698,7 +98203,7 @@ function handleToolResult(ectx, data) {
 		if (matchedCall.name === "SetTodoList" && !data.is_error) {
 			const rawTodos = matchedCall.args.todos;
 			if (Array.isArray(rawTodos)) {
-				const sanitized = rawTodos.filter(isTodoItemShape).map((t) => ({
+				const sanitized = rawTodos.filter((todo) => isTodoItemShape(todo)).map((t) => ({
 					title: t.title,
 					status: t.status
 				}));
@@ -97707,6 +98212,7 @@ function handleToolResult(ectx, data) {
 		}
 	}
 	ectx.state.activeToolCalls.delete(data.tool_call_id);
+	ectx.state.streamingToolCallArguments.delete(data.tool_call_id);
 	ectx.patchLivePane({
 		mode: "waiting",
 		pendingToolCall: null
@@ -97823,6 +98329,9 @@ function dispatchEvent(event, ectx, sendQueued) {
 		case "tool.call":
 			handleToolCall(ectx, event.data);
 			break;
+		case "tool.call.delta":
+			handleToolCallDelta(ectx, event.data);
+			break;
 		case "tool.result":
 			handleToolResult(ectx, event.data);
 			break;
@@ -99092,7 +99601,7 @@ var ApprovalPanelComponent = class extends Container {
 	focused = false;
 	selectedIndex = 0;
 	feedbackMode = false;
-	feedbackText = "";
+	feedbackInput = new Input();
 	expanded = false;
 	onResponse;
 	request;
@@ -99100,6 +99609,13 @@ var ApprovalPanelComponent = class extends Container {
 		super();
 		this.request = request;
 		this.onResponse = onResponse;
+		this.feedbackInput.onSubmit = (value) => {
+			this.submit(this.selectedIndex, value);
+		};
+		this.feedbackInput.onEscape = () => {
+			this.feedbackMode = false;
+			this.feedbackInput.setValue("");
+		};
 	}
 	submit(index, feedback = "") {
 		const option = this.choiceAt(index);
@@ -99120,21 +99636,16 @@ var ApprovalPanelComponent = class extends Container {
 	}
 	onToggleToolExpand;
 	handleInput(data) {
+		if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrl("d"))) {
+			this.onResponse({ response: "rejected" });
+			return;
+		}
 		if (matchesKey(data, Key.ctrl("o"))) {
 			this.expanded = !this.expanded;
 			this.onToggleToolExpand?.();
 			return;
 		}
 		if (this.feedbackMode) {
-			if (matchesKey(data, Key.enter)) {
-				this.submit(this.selectedIndex, this.feedbackText);
-				return;
-			}
-			if (matchesKey(data, Key.escape)) {
-				this.feedbackMode = false;
-				this.feedbackText = "";
-				return;
-			}
 			if (matchesKey(data, Key.up)) {
 				this.feedbackMode = false;
 				this.selectedIndex = (this.selectedIndex - 1 + this.choiceCount()) % this.choiceCount();
@@ -99145,16 +99656,7 @@ var ApprovalPanelComponent = class extends Container {
 				this.selectedIndex = (this.selectedIndex + 1) % this.choiceCount();
 				return;
 			}
-			if (matchesKey(data, Key.backspace)) {
-				this.feedbackText = this.feedbackText.slice(0, -1);
-				return;
-			}
-			const printable = decodeKittyPrintable(data);
-			if (printable !== void 0) {
-				this.feedbackText += printable;
-				return;
-			}
-			if (data.length > 0 && !data.startsWith("\x1B")) this.feedbackText += data;
+			this.feedbackInput.handleInput(data);
 			return;
 		}
 		if (this.choiceCount() === 0) return;
@@ -99177,6 +99679,7 @@ var ApprovalPanelComponent = class extends Container {
 	render(width) {
 		this.clear();
 		this.ensureValidSelection();
+		this.feedbackInput.focused = this.focused && this.feedbackMode;
 		const { data } = this.request;
 		const horizontalBar = borderColor("─".repeat(width));
 		const indent = (s) => `  ${s}`;
@@ -99201,12 +99704,12 @@ var ApprovalPanelComponent = class extends Container {
 			const isSelected = idx === this.selectedIndex;
 			const num = idx + 1;
 			const labelWithNum = `${String(num)}. ${option.label}`;
-			if (this.feedbackMode && option.requires_feedback === true && isSelected) lines.push(indent(`${selectColor.bold("▶")} ${selectColor.bold(labelWithNum)}  ${this.feedbackText}${selectColor("█")}`));
+			if (this.feedbackMode && option.requires_feedback === true && isSelected) lines.push(indent(this.renderInlineFeedbackLine(width - 2, labelWithNum)));
 			else if (isSelected) lines.push(indent(`${selectColor.bold("▶")} ${selectColor.bold(labelWithNum)}`));
 			else lines.push(indent(chalk.gray(`  ${labelWithNum}`)));
 		}
 		lines.push("");
-		if (this.feedbackMode) lines.push(indent(chalk.dim("Type feedback, then press Enter to submit.")));
+		if (this.feedbackMode) lines.push(indent(chalk.dim("Type feedback · ↵ submit.")));
 		else {
 			const expandHint = hasDiff ? ` · ctrl+o ${this.expanded ? "collapse" : "expand"}` : "";
 			lines.push(indent(chalk.dim(`↑/↓ select · ${buildNumericHint(data.choices.length)} choose · ↵ confirm${expandHint}`)));
@@ -99228,6 +99731,16 @@ var ApprovalPanelComponent = class extends Container {
 		}
 		if (this.selectedIndex < 0 || this.selectedIndex >= count) this.selectedIndex = Math.max(0, Math.min(this.selectedIndex, count - 1));
 	}
+	renderInlineFeedbackLine(width, labelWithNum) {
+		const prefix = `${selectColor.bold("▶")} ${selectColor.bold(labelWithNum)}  `;
+		const inputWidth = Math.max(4, width - visibleWidth(prefix) + 2);
+		const inputLine = this.feedbackInput.render(inputWidth)[0] ?? "> ";
+		return prefix + (inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine);
+	}
+	invalidate() {
+		super.invalidate();
+		this.feedbackInput.invalidate();
+	}
 };
 function buildNumericHint(count) {
 	if (count <= 0) return "↵";
@@ -99314,6 +99827,7 @@ var QuestionDialogComponent = class extends Container {
 	colors;
 	onAnswer;
 	maxVisibleOptions;
+	otherInput = new Input();
 	currentTab = 0;
 	submitActionIdx = 0;
 	editingOther = false;
@@ -99336,6 +99850,9 @@ var QuestionDialogComponent = class extends Container {
 		this.onAnswer = onAnswer;
 		this.colors = colors;
 		this.maxVisibleOptions = maxVisibleOptions;
+		this.otherInput.onSubmit = (value) => {
+			this.commitOtherInput(value);
+		};
 		const total = request.data.questions.length;
 		this.cursors = Array.from({ length: total }, () => 0);
 		this.singleSelections = Array.from({ length: total }, () => void 0);
@@ -99349,6 +99866,10 @@ var QuestionDialogComponent = class extends Container {
 			this.onAnswer([]);
 			return;
 		}
+		if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrl("d"))) {
+			this.onAnswer([]);
+			return;
+		}
 		if (this.isEditingOther()) {
 			this.handleOtherInput(data);
 			return;
@@ -99390,58 +99911,32 @@ var QuestionDialogComponent = class extends Container {
 			this.activateQuestionOption(numIdx);
 			return;
 		}
-		if (printable === " " || matchesKey(data, Key.space)) {
-			if (question.multi_select) this.activateQuestionOption(this.currentCursor());
-			return;
-		}
+		if ((printable === " " || matchesKey(data, Key.space)) && question.multi_select) this.activateQuestionOption(this.currentCursor());
 	}
 	handleOtherInput(data) {
 		const questionIdx = this.currentQuestionIndex();
 		if (questionIdx === void 0) return;
-		if (matchesKey(data, Key.left)) {
-			this.editingOther = false;
-			this.gotoTab(this.currentTab - 1);
-			return;
-		}
-		if (matchesKey(data, Key.right) || matchesKey(data, Key.tab)) {
+		if (matchesKey(data, Key.tab)) {
+			this.syncOtherDraft(questionIdx);
 			this.editingOther = false;
 			this.gotoTab(this.currentTab + 1);
 			return;
 		}
 		if (matchesKey(data, Key.up)) {
+			this.syncOtherDraft(questionIdx);
 			this.editingOther = false;
 			this.moveQuestionCursor(-1);
 			return;
 		}
 		if (matchesKey(data, Key.down)) {
+			this.syncOtherDraft(questionIdx);
 			this.editingOther = false;
 			this.moveQuestionCursor(1);
 			return;
 		}
-		if (matchesKey(data, Key.enter)) {
-			this.commitOtherInput();
-			return;
-		}
-		if (matchesKey(data, Key.backspace)) {
-			this.otherDrafts[questionIdx] = this.otherDrafts[questionIdx]?.slice(0, -1) ?? "";
-			this.reviewMessage = void 0;
-			return;
-		}
-		const printable = decodeKittyPrintable(data);
-		if (printable !== void 0) {
-			this.otherDrafts[questionIdx] = (this.otherDrafts[questionIdx] ?? "") + printable;
-			this.reviewMessage = void 0;
-			return;
-		}
-		if (data === " " || matchesKey(data, Key.space)) {
-			this.otherDrafts[questionIdx] = (this.otherDrafts[questionIdx] ?? "") + " ";
-			this.reviewMessage = void 0;
-			return;
-		}
-		if (data.length > 0 && !data.startsWith("\x1B")) {
-			this.otherDrafts[questionIdx] = (this.otherDrafts[questionIdx] ?? "") + data;
-			this.reviewMessage = void 0;
-		}
+		this.otherInput.handleInput(data);
+		this.syncOtherDraft(questionIdx);
+		this.reviewMessage = void 0;
 	}
 	handleSubmitInput(data) {
 		if (matchesKey(data, Key.up)) {
@@ -99475,7 +99970,6 @@ var QuestionDialogComponent = class extends Container {
 		if (printable === "2") {
 			this.submitActionIdx = 1;
 			this.executeSubmitAction(1);
-			return;
 		}
 	}
 	gotoTab(target) {
@@ -99524,15 +100018,17 @@ var QuestionDialogComponent = class extends Container {
 	enterOtherInput(questionIdx) {
 		this.cursors[questionIdx] = this.otherOptionIndex(questionIdx);
 		this.editingOther = true;
+		this.otherInput.setValue(this.otherDraftValue(questionIdx));
 		this.reviewMessage = void 0;
 	}
-	commitOtherInput() {
+	commitOtherInput(rawValue) {
 		const questionIdx = this.currentQuestionIndex();
 		if (questionIdx === void 0) return;
 		const question = this.request.data.questions[questionIdx];
 		if (question === void 0) return;
-		const value = this.otherDrafts[questionIdx]?.trim() ?? "";
+		const value = (rawValue ?? this.otherInput.getValue()).trim();
 		if (value.length === 0) return;
+		this.otherInput.setValue(value);
 		this.otherDrafts[questionIdx] = value;
 		this.committedOtherValues[questionIdx] = value;
 		if (question.multi_select) this.multiSelections[questionIdx]?.add(this.otherOptionIndex(questionIdx));
@@ -99599,6 +100095,7 @@ var QuestionDialogComponent = class extends Container {
 		this.onAnswer(out);
 	}
 	render(width) {
+		this.otherInput.focused = this.focused && this.isEditingOther();
 		return this.isSubmitTab() ? this.renderSubmitTab(width) : this.renderQuestionTab(width);
 	}
 	renderQuestionTab(width) {
@@ -99611,10 +100108,11 @@ var QuestionDialogComponent = class extends Container {
 		const dim = chalk.hex(colors.textDim);
 		const success = chalk.hex(colors.success);
 		const renderWidth = Math.max(1, width);
-		const lines = [];
-		lines.push(accent("─".repeat(renderWidth)));
-		lines.push(accent.bold(" question"));
-		lines.push("");
+		const lines = [
+			accent("─".repeat(renderWidth)),
+			accent.bold(" question"),
+			""
+		];
 		this.pushTabs(lines);
 		lines.push("");
 		lines.push(accent(` ? ${question.question}`));
@@ -99635,10 +100133,15 @@ var QuestionDialogComponent = class extends Container {
 		const singleSelection = this.singleSelections[questionIdx];
 		for (let i = visibleStart; i < visibleEnd; i++) {
 			const option = options[i];
+			if (option === void 0) continue;
 			const num = i + 1;
 			const isCursor = i === cursor;
 			const isOther = option.kind === "other";
 			const isSelected = question.multi_select ? multiSet.has(i) : singleSelection === i;
+			if (this.isEditingOther() && isCursor && isOther) {
+				lines.push(this.renderEditingOtherLine(renderWidth, questionIdx, option, num, isSelected));
+				continue;
+			}
 			const label = this.renderOptionLabel(questionIdx, option, isCursor);
 			let line;
 			if (question.multi_select) {
@@ -99666,10 +100169,11 @@ var QuestionDialogComponent = class extends Container {
 		const text = chalk.hex(colors.text);
 		const warning = chalk.hex(colors.warning);
 		const renderWidth = Math.max(1, width);
-		const lines = [];
-		lines.push(accent("─".repeat(renderWidth)));
-		lines.push(accent.bold(" question"));
-		lines.push("");
+		const lines = [
+			accent("─".repeat(renderWidth)),
+			accent.bold(" question"),
+			""
+		];
 		this.pushTabs(lines);
 		lines.push("");
 		lines.push(text.bold(` ${REVIEW_TITLE}`));
@@ -99678,6 +100182,7 @@ var QuestionDialogComponent = class extends Container {
 		lines.push("");
 		for (let i = 0; i < this.request.data.questions.length; i++) {
 			const question = this.request.data.questions[i];
+			if (question === void 0) continue;
 			const answer = this.answers[i];
 			lines.push(`  ${dim("Q")}  ${question.question}`);
 			if (answer !== void 0 && answer.length > 0) lines.push(`  ${accent("→")}  ${text(answer)}`);
@@ -99688,6 +100193,7 @@ var QuestionDialogComponent = class extends Container {
 		lines.push("");
 		for (let i = 0; i < SUBMIT_ACTIONS.length; i++) {
 			const label = SUBMIT_ACTIONS[i];
+			if (label === void 0) continue;
 			const num = i + 1;
 			if (i === this.submitActionIdx) lines.push(accent(`  → [${String(num)}] ${label}`));
 			else lines.push(dim(`    [${String(num)}] ${label}`));
@@ -99703,6 +100209,7 @@ var QuestionDialogComponent = class extends Container {
 		const tabs = [];
 		for (let i = 0; i < this.request.data.questions.length; i++) {
 			const question = this.request.data.questions[i];
+			if (question === void 0) continue;
 			const label = question.header !== void 0 && question.header.length > 0 ? question.header : `Q${String(i + 1)}`;
 			if (i === this.currentTab) tabs.push(active(` ${label} `));
 			else if (this.isAnswered(i)) tabs.push(chalk.green(`(✓) ${label}`));
@@ -99714,14 +100221,17 @@ var QuestionDialogComponent = class extends Container {
 		lines.push(` ${tabs.join("  ")}`);
 	}
 	buildQuestionHint(dim, questionIdx) {
-		if (this.isEditingOther()) {
-			const parts = ["type answer", "↵ save"];
-			if (this.totalTabs() > 1) parts.push("←/→/tab switch");
-			parts.push("esc dismiss");
-			return dim(`  ${parts.join("  ")}`);
-		}
+		if (this.isEditingOther()) return dim(`  ${[
+			"type answer",
+			"↵ save",
+			...this.totalTabs() > 1 ? ["tab switch"] : [],
+			"esc dismiss"
+		].join("  ")}`);
 		const optionCount = Math.min(this.displayOptions(questionIdx).length, NUMBER_KEYS.length);
-		const parts = ["▲/▼ select", `${optionCount <= 1 ? "1" : `1-${String(optionCount)}`} / ↵ ${this.request.data.questions[questionIdx].multi_select ? "toggle" : "choose"}`];
+		const numberHint = optionCount <= 1 ? "1" : `1-${String(optionCount)}`;
+		const question = this.request.data.questions[questionIdx];
+		if (question === void 0) return dim("  esc dismiss");
+		const parts = ["▲/▼ select", `${numberHint} / ↵ ${question.multi_select ? "toggle" : "choose"}`];
 		if (this.totalTabs() > 1) parts.push("←/→/tab switch");
 		parts.push("esc dismiss");
 		return dim(`  ${parts.join("  ")}`);
@@ -99783,11 +100293,33 @@ var QuestionDialogComponent = class extends Container {
 	}
 	renderOptionLabel(questionIdx, option, isCursor) {
 		if (option.kind !== "other") return option.label;
-		const value = this.otherDrafts[questionIdx] || this.committedOtherValues[questionIdx];
+		const value = this.otherDraftValue(questionIdx);
 		if (this.isEditingOther() && isCursor) return `${option.label}: ${value ?? ""}█`;
 		if (value !== void 0 && value.length > 0) return `${option.label}: ${value}`;
 		return option.label;
 	}
+	renderEditingOtherLine(width, questionIdx, option, num, isSelected) {
+		const question = this.request.data.questions[questionIdx];
+		if (question === void 0) return option.label;
+		let prefix;
+		if (question.multi_select) {
+			const body = `  [${isSelected ? "✓" : " "}] ${option.label}: `;
+			prefix = isSelected ? chalk.hex(this.colors.success).bold(body) : chalk.hex(this.colors.primary)(body);
+		} else {
+			const body = `  → [${String(num)}] ${option.label}: `;
+			prefix = isSelected && this.isAnswered(questionIdx) ? chalk.hex(this.colors.success).bold(body) : chalk.hex(this.colors.primary)(body);
+		}
+		const inputWidth = Math.max(4, width - visibleWidth(prefix) + 2);
+		const inputLine = this.otherInput.render(inputWidth)[0] ?? "> ";
+		const inlineInput = inputLine.startsWith("> ") ? inputLine.slice(2) : inputLine;
+		return prefix + inlineInput;
+	}
+	otherDraftValue(questionIdx) {
+		return this.otherDrafts[questionIdx] || this.committedOtherValues[questionIdx] || "";
+	}
+	syncOtherDraft(questionIdx) {
+		this.otherDrafts[questionIdx] = this.otherInput.getValue();
+	}
 	isAnswered(questionIdx) {
 		const answer = this.answers[questionIdx];
 		return answer !== void 0 && answer.length > 0;
@@ -99796,6 +100328,10 @@ var QuestionDialogComponent = class extends Container {
 		for (let i = 0; i < this.request.data.questions.length; i++) if (!this.isAnswered(i)) return true;
 		return false;
 	}
+	invalidate() {
+		super.invalidate();
+		this.otherInput.invalidate();
+	}
 };
 //#endregion
 //#region src/tui/reverse-rpc/question/ui.ts
@@ -100804,14 +101340,18 @@ var KimiTUI = class {
 				this.stateHooks.syncFooter();
 				this.stateHooks.refreshActivityPane();
 			},
-			showStatus: (message) => {
+			showStatus: (message, color) => {
 				addTranscriptEntry(this.state, {
 					id: `status-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
 					kind: "status",
 					renderMode: "plain",
-					content: message
+					content: message,
+					...color !== void 0 ? { color } : {}
 				});
 			},
+			showNotice: (title, detail) => {
+				emitNotice(this.state, title, detail);
+			},
 			stop: () => void this.stop(),
 			showHelpPanel: () => showHelpPanel(this.state),
 			showSessionPicker: () => showSessionPicker(this.state, this.buildSessionHooks()),
@@ -100942,6 +101482,7 @@ const MUTED = "#999999";
 const TEXT_DIM = "#6B7280";
 const INSTALL_HINT = "Install update now";
 const SKIP_HINT = "Continue with current version";
+const PRODUCT_NAME = "Kimi Code";
 function createInstallPromptChoices(target) {
 	return [{
 		value: "install",
@@ -100953,7 +101494,7 @@ function createInstallPromptChoices(target) {
 }
 function getDefaultInstallPromptSelection(choices) {
 	const installIndex = choices.findIndex((choice) => choice.value === "install");
-	return installIndex >= 0 ? installIndex : 0;
+	return Math.max(installIndex, 0);
 }
 function moveInstallPromptSelection(currentIndex, direction, choiceCount) {
 	if (direction === "up") return Math.max(0, currentIndex - 1);
@@ -100967,7 +101508,7 @@ function renderInstallPrompt(options, choices, selectedIndex) {
 	const command = chalk.hex(PRIMARY)(options.installCommand);
 	const lines = [
 		chalk.hex(PRIMARY).bold("Kimi Code Update Available"),
-		chalk.hex(MUTED)(`${NPM_PACKAGE_NAME} has a newer release ready.`),
+		chalk.hex(MUTED)(`${PRODUCT_NAME} has a newer release ready.`),
 		"",
 		`${label("Current")}  ${currentVersion}`,
 		`${label("Target ")}  ${targetVersion}  ${channel}`,
@@ -100978,6 +101519,7 @@ function renderInstallPrompt(options, choices, selectedIndex) {
 	];
 	for (let i = 0; i < choices.length; i++) {
 		const choice = choices[i];
+		if (choice === void 0) continue;
 		const isSelected = i === selectedIndex;
 		const content = ` ${isSelected ? "❯" : " "} ${choice.label}`;
 		if (isSelected) {