kfc-code-cli 0.0.1-alpha.1 → 0.0.1-alpha.2

package/dist/main.mjs

@@ -10,7 +10,7 @@ import path, { basename, dirname, extname, isAbsolute, join, normalize, posix, r
 import { finished, pipeline } from "node:stream/promises";
 import { fileURLToPath } from "node:url";
 import { ZodError, z } from "zod";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import { execFile, execSync, spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import * as nodeOs from "node:os";
@@ -34,7 +34,7 @@ import { writeFile as writeFile$1 } from "fs/promises";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { ZipFile } from "yazl";
 import pino from "pino";
-import { CombinedAutocompleteProvider, Container, Editor, Image, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, fuzzyFilter, fuzzyMatch, getCapabilities, matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Editor, Image, 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";
 //#region ../../packages/kimi-core/src/storage/fs/durability.ts
@@ -904,7 +904,7 @@ var BaseContextState = class {
 			...input.finishReason !== void 0 ? { finish_reason: input.finishReason } : {}
 		});
 		this.openSteps.delete(input.uuid);
-		if (input.usage !== void 0) this._tokenCountWithPending += input.usage.input_tokens + input.usage.output_tokens;
+		if (input.usage !== void 0) this._tokenCountWithPending = input.usage.input_tokens + input.usage.output_tokens;
 	}
 	async appendContentPart(input) {
 		this.assertNotBroken();
@@ -2092,6 +2092,19 @@ async function atomicWrite(filePath, content, _syncOverride) {
 	}
 }
 //#endregion
+//#region ../../packages/kimi-core/src/session/session-runtime-slot.ts
+function createSessionRuntimeSlot(initial) {
+	let current = initial;
+	return {
+		current() {
+			return current;
+		},
+		replace(next) {
+			current = next;
+		}
+	};
+}
+//#endregion
 //#region ../../packages/kimi-core/src/soul/adapters.ts
 /**
 * Widen `ToolCall.args` (`unknown`) into the `Record<string, unknown>`
@@ -2176,11 +2189,16 @@ function adaptToolResult(r) {
 	if (r.isError === true) payload.isError = true;
 	return payload;
 }
+const DEFAULT_RESERVED_CONTEXT_SIZE$1 = 5e4;
+const DEFAULT_RESERVED_CONTEXT_FRACTION$1 = .25;
+function defaultReservedContextSize$1(maxContextSize) {
+	return Math.max(0, Math.min(DEFAULT_RESERVED_CONTEXT_SIZE$1, Math.floor(maxContextSize * DEFAULT_RESERVED_CONTEXT_FRACTION$1)));
+}
 /** Returns true when either trigger condition fires. */
 function shouldCompact(context, config) {
 	if (config === void 0) return false;
 	const triggerRatio = config.triggerRatio ?? .85;
-	const reservedContextSize = config.reservedContextSize ?? 5e4;
+	const reservedContextSize = config.reservedContextSize ?? defaultReservedContextSize$1(config.maxContextSize);
 	const tokens = context.tokenCountWithPending;
 	if (tokens >= config.maxContextSize * triggerRatio) return true;
 	if (tokens + reservedContextSize >= config.maxContextSize) return true;
@@ -2736,6 +2754,206 @@ async function executePendingCalls(step, pending, deferred) {
 		await context.appendToolResult(toolCallByProviderId.get(toolCall.id), toolCall.id, adapted);
 	}
 }
+//#endregion
+//#region ../../packages/kimi-core/src/hooks/engine.ts
+/**
+* Synthesises a stable id for `hook.resolved` emissions. Hooks are
+* registered without an intrinsic id; we derive one from
+* `event:type:matcher`, suffixed with the hook's position inside
+* `this.hooks` (its registration order). The `registrationIndex` is
+* stable across multiple `executeHooks` calls — using the per-call
+* `settled[]` index instead would hand the same id to different hooks
+* across different dispatches, breaking client-side correlation.
+*/
+function hookId(hook, registrationIndex) {
+	return `${hook.event}:${hook.type}:${hook.matcher ?? ""}:${registrationIndex}`;
+}
+var HookEngine = class {
+	deps;
+	/**
+	* Mutable executor registry. Seeded from `deps.executors` at
+	* construction so the constructor arg can stay `ReadonlyMap`-typed
+	* while `registerExecutor` still lets callers install additional
+	* executors (e.g. `WireHookExecutor`) after the engine is wired.
+	*/
+	executors;
+	hooks = [];
+	/**
+	* Phase 18 L3-2 — invalid-regex warn dedupe. Each distinct invalid
+	* matcher fires `onInvalidMatcher` once per engine instance so a
+	* misconfigured block-action hook doesn't flood logs on every
+	* tool call.
+	*/
+	warnedInvalidMatchers = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+		this.executors = new Map(deps.executors);
+	}
+	register(hook) {
+		this.hooks.push(hook);
+	}
+	/**
+	* Phase 18 L2-4 — install / replace an executor for a given `type`
+	* label at runtime. Used by the wire layer to bolt a
+	* `WireHookExecutor` onto an engine that was constructed with only
+	* the `command` executor. Replacing an existing entry is silent;
+	* callers wanting a conflict check can probe `hasExecutor(type)`.
+	*/
+	registerExecutor(type, executor) {
+		this.executors.set(type, executor);
+	}
+	/** Returns true when an executor has been registered under `type`. */
+	hasExecutor(type) {
+		return this.executors.has(type);
+	}
+	unregister(hook) {
+		const idx = this.hooks.indexOf(hook);
+		if (idx !== -1) this.hooks.splice(idx, 1);
+	}
+	list(event) {
+		if (event === void 0) return [...this.hooks];
+		return this.hooks.filter((h) => h.event === event);
+	}
+	/**
+	* Pre-filters hooks by both `event` and `matcher` regex against the
+	* target value (tool name for tool-scoped events). Exported-ish via
+	* `executeHooks` — v2 §9-C.3 requires "getMatchingHooks(event, input)
+	* then concurrent execute" ordering.
+	*/
+	getMatchingHooks(event, input) {
+		const matcherValue = extractMatcherValue(input);
+		return this.hooks.filter((h) => {
+			if (h.event !== event) return false;
+			return this.matchesTarget(h, matcherValue);
+		});
+	}
+	matchesTarget(hook, value) {
+		const matcher = hook.matcher;
+		if (matcher === void 0 || matcher === "") return true;
+		let re;
+		try {
+			re = new RegExp(matcher);
+		} catch {
+			if (!this.warnedInvalidMatchers.has(matcher)) {
+				this.warnedInvalidMatchers.add(matcher);
+				this.deps.onInvalidMatcher?.(hook, matcher);
+			}
+			return false;
+		}
+		return re.test(value);
+	}
+	async executeHooks(event, input, signal) {
+		const deduped = dedupeByCommand(this.getMatchingHooks(event, input));
+		if (deduped.length === 0) {
+			this.deps.sink?.emit({
+				type: "hook.triggered",
+				event,
+				matchers: [],
+				matched_count: 0
+			});
+			return {
+				blockAction: false,
+				additionalContext: []
+			};
+		}
+		this.deps.sink?.emit({
+			type: "hook.triggered",
+			event,
+			matchers: deduped.map((h) => h.matcher ?? ""),
+			matched_count: deduped.length
+		});
+		const settled = await Promise.allSettled(deduped.map((hook) => {
+			const executor = this.executors.get(hook.type);
+			if (executor === void 0) return Promise.resolve(void 0);
+			return executor.execute(hook, input, signal);
+		}));
+		let blockAction = false;
+		let reason;
+		const additionalContext = [];
+		for (const [i, result] of settled.entries()) {
+			const hook = deduped[i];
+			const registrationIndex = hook !== void 0 ? this.hooks.indexOf(hook) : -1;
+			if (result.status === "rejected") {
+				if (hook !== void 0) {
+					this.deps.onExecutorError?.(hook, result.reason instanceof Error ? result.reason : new Error(String(result.reason)));
+					this.deps.sink?.emit({
+						type: "hook.resolved",
+						hook_id: hookId(hook, registrationIndex),
+						outcome: "error"
+					});
+				}
+				continue;
+			}
+			const value = result.value;
+			if (hook !== void 0) {
+				const outcome = value?.ok === false ? "error" : value?.blockAction === true ? "blocked" : "ok";
+				this.deps.sink?.emit({
+					type: "hook.resolved",
+					hook_id: hookId(hook, registrationIndex),
+					outcome
+				});
+			}
+			if (value === void 0) continue;
+			if (value.blockAction) {
+				blockAction = true;
+				if (value.reason !== void 0) reason = value.reason;
+			}
+			if (value.additionalContext !== void 0) additionalContext.push(value.additionalContext);
+		}
+		return {
+			blockAction,
+			reason,
+			additionalContext
+		};
+	}
+};
+/**
+* Collapse hook configs that share the same `command` string. `wire` hooks
+* (no `command` field) key on their subscription id so different wire
+* subscriptions still run in parallel; identical subscriptions collapse
+* like identical commands.
+*/
+function dedupeByCommand(hooks) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const hook of hooks) {
+		const key = hookDedupeKey(hook);
+		if (!seen.has(key)) seen.set(key, hook);
+	}
+	return [...seen.values()];
+}
+function hookDedupeKey(hook) {
+	if (hook.type === "command") return `command:${hook.command}`;
+	if (hook.type === "wire") return `wire:${hook.subscriptionId}`;
+	return `unknown:${JSON.stringify(hook)}`;
+}
+/**
+* Extracts the string fed to a hook's matcher regex. Event-dependent:
+*
+*   - `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 "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":
+		case "SubagentStop": return input.agentName;
+		case "SessionStart":
+		case "SessionEnd":
+		case "PreCompact":
+		case "PostCompact": return "";
+	}
+}
 const AgentToolInputSchema = z.preprocess((input) => {
 	if (typeof input !== "object" || input === null || Array.isArray(input)) return input;
 	const record = input;
@@ -3043,7 +3261,7 @@ var EnterPlanModeTool = class {
 					content: `Failed to enter plan mode: ${error instanceof Error ? error.message : "Failed to enter plan mode."}`
 				};
 			}
-			return { content: ENTERED_PLAN_MODE_MESSAGE };
+			return { content: enteredPlanModeMessage(this.deps.getPlanFilePath?.() ?? null) };
 		}
 		if (this.deps.requestApproval === void 0) return {
 			isError: true,
@@ -3067,18 +3285,32 @@ var EnterPlanModeTool = class {
 				content: `Failed to enter plan mode: ${error instanceof Error ? error.message : "Failed to enter plan mode."}`
 			};
 		}
-		return { content: ENTERED_PLAN_MODE_MESSAGE };
+		return { content: enteredPlanModeMessage(this.deps.getPlanFilePath?.() ?? null) };
 	}
 };
-const ENTERED_PLAN_MODE_MESSAGE = [
-	"Plan mode is now active. Your workflow:",
-	"",
-	"1. Use read-only tools (Read, Grep, Glob) to investigate the codebase.",
-	"2. Design a concrete, step-by-step plan.",
-	"3. When the plan is ready, call ExitPlanMode with the full plan text.",
-	"",
-	"Do NOT use Edit, Write, or Bash (non-readonly) while plan mode is active."
-].join("\n");
+function enteredPlanModeMessage(planPath) {
+	if (planPath === null) return [
+		"Plan mode is now active. Your workflow:",
+		"",
+		"1. Use read-only tools (Read, Grep, Glob) to investigate the codebase.",
+		"2. Design a concrete, step-by-step plan.",
+		"3. When the plan is ready, call ExitPlanMode with the full plan text in the `plan` parameter.",
+		"",
+		"Do NOT use Write or Edit while plan mode is active in this host; no plan file path is available."
+	].join("\n");
+	return [
+		"Plan mode is now active. Your workflow:",
+		"",
+		`Plan file: ${planPath}`,
+		"",
+		"1. Use read-only tools (Read, Grep, Glob) to investigate the codebase.",
+		"2. Design a concrete, step-by-step plan.",
+		"3. Write the plan to the plan file with Write or Edit.",
+		"4. When the plan is ready, call ExitPlanMode for user approval.",
+		"",
+		"Do NOT edit files other than the plan file while plan mode is active."
+	].join("\n");
+}
 //#endregion
 //#region ../../packages/kimi-core/src/tools/builtin/planning/exit-plan-mode.ts
 /**
@@ -3109,7 +3341,7 @@ const ENTERED_PLAN_MODE_MESSAGE = [
 * simulate a rejection.
 */
 const ExitPlanModeInputSchema = z.object({
-	plan: z.string().min(1).optional().describe("The finalised plan to present to the user. Markdown is rendered in the UI."),
+	plan: z.string().min(1).optional().describe("Legacy inline fallback only. In the default CLI runtime, write the plan file first; the host reads that file and ignores this field."),
 	options: z.array(z.object({
 		label: z.string().min(1).max(80),
 		description: z.string()
@@ -3122,7 +3354,8 @@ const DESCRIPTION$4 = `Use this tool when you are in plan mode and are ready to
 
 **Usage notes:**
 - Only call this tool after you have fully investigated the request and designed a concrete plan.
-- If the host told you to write the plan to a plan file, write that file first and call ExitPlanMode after it is complete. Otherwise pass the full plan text as \`plan\`.
+- In the default CLI runtime, write the plan to the current plan file first; this tool reads the file and presents it for approval.
+- Only pass \`plan\` when running in a host that has no plan-file support.
 - When presenting multiple approaches, pass 2-3 concrete options and do not use reserved labels like "Approve", "Reject", "Reject and Exit", or "Revise"; the host adds those controls.
 - Do NOT call this tool to ask clarifying questions (use AskUserQuestion for that). Call ExitPlanMode only when the plan is genuinely final.`;
 var ExitPlanModeTool = class {
@@ -3223,13 +3456,19 @@ var ExitPlanModeTool = class {
 					}
 				};
 			}
-			if (source === null || source.plan.trim().length === 0) return {
-				ok: false,
-				error: {
-					isError: true,
-					content: source?.path !== void 0 ? `No plan file found. Write your plan to ${source.path} first, then call ExitPlanMode.` : "No plan file found. Write your plan first, then call ExitPlanMode."
-				}
-			};
+			if (source === null || source.plan.trim().length === 0) {
+				if (args.plan !== void 0 && args.plan.trim().length > 0) return {
+					ok: true,
+					plan: args.plan
+				};
+				return {
+					ok: false,
+					error: {
+						isError: true,
+						content: source?.path !== void 0 ? `No plan file found. Write your plan to ${source.path} first, then call ExitPlanMode.` : "No plan file found. Write your plan first, then call ExitPlanMode."
+					}
+				};
+			}
 			return {
 				ok: true,
 				plan: source.plan,
@@ -3253,6 +3492,44 @@ function formatPlanForOutput(plan, path) {
 	return `Plan mode deactivated. All tools are now available.\n${path !== void 0 ? `Plan saved to: ${path}\n\n` : ""}## Approved Plan:\n${plan}`;
 }
 //#endregion
+//#region ../../packages/kimi-core/src/soul-plus/approval/approval-runtime.ts
+/**
+* Thrown when a cross-process / team forwarding hook is invoked before
+* the TeamDaemon wiring lands (Slice 2.6+). Callers should treat this as
+* an unrecoverable misconfiguration in Slice 2.3.
+*/
+var NotImplementedError = class extends Error {
+	constructor(feature) {
+		super(`${feature} not implemented in Slice 2.3 (deferred to TeamDaemon)`);
+		this.name = "NotImplementedError";
+	}
+};
+/**
+* Default stub used when no wire/UI integration is required (e.g. unit
+* tests of unrelated layers, or embedder harnesses that bypass approvals
+* entirely via their own `beforeToolCall`). Every request is immediately
+* approved and no records are written.
+*
+* For the real implementation see `./wired-approval-runtime.ts`.
+*/
+var AlwaysAllowApprovalRuntime = class {
+	async request(_req, _signal) {
+		return {
+			approved: true,
+			response: "approved"
+		};
+	}
+	async recoverPendingOnStartup() {}
+	resolve(_requestId, _response) {}
+	cancelBySource(_source) {}
+	async ingestRemoteRequest(_data) {
+		throw new NotImplementedError("ApprovalRuntime.ingestRemoteRequest");
+	}
+	resolveRemote(_data) {
+		throw new NotImplementedError("ApprovalRuntime.resolveRemote");
+	}
+};
+//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/compaction/tokens.ts
 /**
 * Token-estimation helper used by `CompactionOrchestrator` to seed
@@ -3308,7 +3585,7 @@ var CompactionOrchestrator = class {
 			signal.throwIfAborted();
 			const messages = this.deps.contextState.buildMessages();
 			const preCompactTokens = this.deps.contextState.tokenCountWithPending;
-			const summary = await this.deps.compactionProvider.run(messages, signal, customInstruction !== void 0 ? { userInstructions: customInstruction } : void 0);
+			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();
@@ -3537,6 +3814,375 @@ var SoulLifecycleGate = class {
 	}
 };
 //#endregion
+//#region ../../packages/kimi-core/src/soul-plus/plan/plan-slugs.ts
+/**
+* Plan-file slug generator — Phase 18 §D.1.
+*
+* Ports Python `kimi_cli/tools/plan/heroes.py`: each session gets a
+* human-readable slug composed of three Marvel/DC hero names joined by
+* `-`. The slug is cached per `sessionId` so repeated lookups are
+* idempotent. When the randomly-assembled slug collides with the
+* caller-supplied `existingSlugs` set 20 times in a row, we append the
+* first 8 chars of `sessionId` as a tiebreaker (matches the Python
+* fallback path `{slug}-{session_id[:8]}`).
+*
+* Note: uses `crypto.randomInt` for uniform secure randomness, matching
+* Python `secrets.choice`.
+*/
+const HERO_NAMES = [
+	"iron-man",
+	"spider-man",
+	"captain-america",
+	"thor",
+	"hulk",
+	"black-widow",
+	"hawkeye",
+	"black-panther",
+	"doctor-strange",
+	"scarlet-witch",
+	"vision",
+	"falcon",
+	"war-machine",
+	"ant-man",
+	"wasp",
+	"captain-marvel",
+	"gamora",
+	"star-lord",
+	"groot",
+	"rocket",
+	"drax",
+	"mantis",
+	"nebula",
+	"shang-chi",
+	"moon-knight",
+	"ms-marvel",
+	"she-hulk",
+	"echo",
+	"wolverine",
+	"cyclops",
+	"storm",
+	"jean-grey",
+	"rogue",
+	"beast",
+	"nightcrawler",
+	"colossus",
+	"shadowcat",
+	"jubilee",
+	"cable",
+	"deadpool",
+	"bishop",
+	"magik",
+	"iceman",
+	"archangel",
+	"psylocke",
+	"dazzler",
+	"forge",
+	"havok",
+	"polaris",
+	"emma-frost",
+	"namor",
+	"silver-surfer",
+	"adam-warlock",
+	"nova",
+	"quasar",
+	"sentry",
+	"blue-marvel",
+	"spectrum",
+	"squirrel-girl",
+	"cloak",
+	"dagger",
+	"punisher",
+	"elektra",
+	"luke-cage",
+	"iron-fist",
+	"jessica-jones",
+	"daredevil",
+	"blade",
+	"ghost-rider",
+	"morbius",
+	"venom",
+	"carnage",
+	"silk",
+	"spider-gwen",
+	"miles-morales",
+	"america-chavez",
+	"kate-bishop",
+	"yelena-belova",
+	"white-tiger",
+	"moon-girl",
+	"devil-dinosaur",
+	"amadeus-cho",
+	"riri-williams",
+	"kamala-khan",
+	"sam-alexander",
+	"nova-prime",
+	"medusa",
+	"black-bolt",
+	"crystal",
+	"karnak",
+	"gorgon",
+	"lockjaw",
+	"quake",
+	"mockingbird",
+	"bobbi-morse",
+	"maria-hill",
+	"nick-fury",
+	"phil-coulson",
+	"winter-soldier",
+	"us-agent",
+	"patriot",
+	"speed",
+	"wiccan",
+	"hulkling",
+	"stature",
+	"yellowjacket",
+	"tigra",
+	"hellcat",
+	"valkyrie",
+	"sif",
+	"beta-ray-bill",
+	"hercules",
+	"wonder-man",
+	"taskmaster",
+	"domino",
+	"cannonball",
+	"sunspot",
+	"wolfsbane",
+	"warpath",
+	"multiple-man",
+	"banshee",
+	"siryn",
+	"monet",
+	"rictor",
+	"shatterstar",
+	"longshot",
+	"daken",
+	"x-23",
+	"fantomex",
+	"batman",
+	"superman",
+	"wonder-woman",
+	"flash",
+	"aquaman",
+	"green-lantern",
+	"martian-manhunter",
+	"cyborg",
+	"hawkgirl",
+	"green-arrow",
+	"black-canary",
+	"zatanna",
+	"constantine",
+	"shazam",
+	"blue-beetle",
+	"booster-gold",
+	"firestorm",
+	"atom",
+	"hawkman",
+	"plastic-man",
+	"red-tornado",
+	"starfire",
+	"raven",
+	"beast-boy",
+	"robin",
+	"nightwing",
+	"batgirl",
+	"batwoman",
+	"red-hood",
+	"signal",
+	"orphan",
+	"spoiler",
+	"catwoman",
+	"huntress",
+	"supergirl",
+	"superboy",
+	"power-girl",
+	"steel",
+	"stargirl",
+	"wildcat",
+	"doctor-fate",
+	"mister-terrific",
+	"hourman",
+	"sandman",
+	"spectre",
+	"phantom-stranger",
+	"swamp-thing",
+	"animal-man",
+	"deadman",
+	"vixen",
+	"black-lightning",
+	"static",
+	"icon",
+	"rocket-dc",
+	"captain-atom",
+	"fire",
+	"ice",
+	"elongated-man",
+	"metamorpho",
+	"black-hawk",
+	"crimson-avenger",
+	"doctor-mid-nite",
+	"jakeem-thunder",
+	"mister-miracle",
+	"big-barda",
+	"orion",
+	"lightray",
+	"forager",
+	"killer-frost",
+	"jessica-cruz",
+	"simon-baz",
+	"john-stewart",
+	"guy-gardner",
+	"kyle-rayner",
+	"hal-jordan",
+	"wally-west",
+	"barry-allen",
+	"jay-garrick",
+	"impulse",
+	"kid-flash",
+	"donna-troy",
+	"tempest",
+	"aqualad",
+	"miss-martian",
+	"terra",
+	"jericho",
+	"ravager",
+	"red-star",
+	"pantha",
+	"argent",
+	"damage",
+	"jade",
+	"obsidian",
+	"cyclone",
+	"atom-smasher",
+	"maxima",
+	"starman",
+	"liberty-belle",
+	"dove",
+	"hawk",
+	"blue-devil",
+	"creeper",
+	"ragman",
+	"thunder"
+];
+const MAX_ATTEMPTS = 20;
+const slugCache = /* @__PURE__ */ new Map();
+function pickHero() {
+	return HERO_NAMES[randomInt(HERO_NAMES.length)] ?? HERO_NAMES[0] ?? "kimi";
+}
+function assembleSlug() {
+	return `${pickHero()}-${pickHero()}-${pickHero()}`;
+}
+/**
+* TODO(Slice 18-3): callers must scan `<KIMI_CODE_HOME>/plans/` for
+* previously-assigned slugs and pass them as `existingSlugs`. The
+* current call sites pass a literal empty `Set()` as a placeholder,
+* which means collision avoidance is only effective within a single
+* process (via `slugCache`) — two sessions that start after a process
+* restart can still collide. The plans directory scan is Slice 18-3
+* scope because it depends on PlanFileManager wiring in the host.
+*/
+function generatePlanSlug(sessionId, existingSlugs) {
+	const cached = slugCache.get(sessionId);
+	if (cached !== void 0) return cached;
+	let slug = "";
+	let collided = true;
+	for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+		slug = assembleSlug();
+		if (!existingSlugs.has(slug)) {
+			collided = false;
+			break;
+		}
+	}
+	if (collided) slug = `${slug}-${sessionId.slice(0, 8)}`;
+	slugCache.set(sessionId, slug);
+	return slug;
+}
+//#endregion
+//#region ../../packages/kimi-core/src/soul-plus/plan/plan-session-controller.ts
+/**
+* Session-scoped owner for the plan artifact.
+*
+* Plan mode is not just a boolean: it needs a stable markdown file under
+* `<KIMI_CODE_HOME>/plans/`, a persisted slug for crash/restart recovery,
+* and one write surface shared by ExitPlanMode, /plan, and Write/Edit gates.
+*/
+var PlanSessionController = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	isAvailable() {
+		return this.deps.paths !== void 0 && this.deps.sessionMeta !== void 0;
+	}
+	getPlanFilePath() {
+		const paths = this.deps.paths;
+		const slug = this.getActiveSlug();
+		if (paths === void 0 || slug === null) return null;
+		return join(paths.home, "plans", `${slug}.md`);
+	}
+	async ensurePlanFilePath(source = "system", reason = "plan mode activated") {
+		const paths = this.deps.paths;
+		const sessionMeta = this.deps.sessionMeta;
+		if (paths === void 0 || sessionMeta === void 0) return null;
+		const active = this.getActiveSlug();
+		if (active !== null) return join(paths.home, "plans", `${active}.md`);
+		const slug = generatePlanSlug(`${this.deps.sessionId}:${randomUUID()}`, await readExistingPlanSlugs(paths));
+		await sessionMeta.setPlanSlug(slug, source, reason);
+		return join(paths.home, "plans", `${slug}.md`);
+	}
+	async readCurrentPlan() {
+		const path = this.getPlanFilePath();
+		if (path === null) return null;
+		try {
+			return {
+				plan: await readFile(path, "utf8"),
+				path
+			};
+		} catch (error) {
+			if (isEnoent(error)) return {
+				plan: "",
+				path
+			};
+			throw error;
+		}
+	}
+	async writeCurrentPlan(content) {
+		const path = await this.ensurePlanFilePath();
+		if (path === null) throw new Error("Plan file is unavailable for this session.");
+		await mkdir(dirname(path), { recursive: true });
+		await atomicWrite(path, content);
+		return Buffer.byteLength(content, "utf8");
+	}
+	async clearCurrentPlan() {
+		const path = this.getPlanFilePath();
+		if (path === null) return null;
+		await rm(path, { force: true });
+		return path;
+	}
+	async deactivatePlanMode() {
+		const sessionMeta = this.deps.sessionMeta;
+		if (sessionMeta === void 0 || this.getActiveSlug() === null) return;
+		await sessionMeta.clearPlanSlug("system", "plan mode deactivated");
+	}
+	getActiveSlug() {
+		const raw = this.deps.sessionMeta?.get().plan_slug;
+		if (typeof raw !== "string") return null;
+		const trimmed = raw.trim();
+		return trimmed.length > 0 ? trimmed : null;
+	}
+};
+async function readExistingPlanSlugs(paths) {
+	try {
+		const entries = await readdir(join(paths.home, "plans"), { withFileTypes: true });
+		return new Set(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => basename(entry.name, ".md")));
+	} catch (error) {
+		if (isEnoent(error)) return /* @__PURE__ */ new Set();
+		throw error;
+	}
+}
+function isEnoent(error) {
+	return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+//#endregion
 //#region ../../packages/kimi-core/src/utils/logger.ts
 const noopLogger$3 = {
 	debug: () => {},
@@ -3802,10 +4448,12 @@ var DefaultSessionControl = class {
 	turnManager;
 	contextState;
 	sessionJournal;
+	setPlanModeOverride;
 	constructor(deps) {
 		this.turnManager = deps.turnManager;
 		this.contextState = deps.contextState;
 		this.sessionJournal = deps.sessionJournal;
+		this.setPlanModeOverride = deps.setPlanModeOverride;
 	}
 	async compact(customInstruction) {
 		await this.turnManager.triggerCompaction(customInstruction);
@@ -3819,6 +4467,10 @@ var DefaultSessionControl = class {
 		}
 	}
 	async setPlanMode(enabled) {
+		if (this.setPlanModeOverride !== void 0) {
+			await this.setPlanModeOverride(enabled);
+			return;
+		}
 		await this.contextState.applyConfigChange({
 			type: "plan_mode_changed",
 			enabled
@@ -3893,6 +4545,10 @@ var SessionMetaService = class {
 		if (this.meta.plan_slug === trimmed) return;
 		await this.applyPatch({ plan_slug: trimmed }, source, reason);
 	};
+	clearPlanSlug = async (source, reason) => {
+		if (this.meta.plan_slug === void 0 || this.meta.plan_slug.length === 0) return;
+		await this.applyPatch({ plan_slug: "" }, source, reason);
+	};
 	/**
 	* Overwrite the in-memory view with replay-derived fields (dirty-exit
 	* path). Does not emit any event and does not write wire — the caller
@@ -4078,6 +4734,39 @@ function escapeXml(input) {
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/errors.ts
 /**
+* Business-error sentinel classes — Phase 18 A.11 / A.12 / A.13
+* (v2 §3.1 wire error code table).
+*
+* Lives in `src/` rather than the test harness so production paths
+* (KosongAdapter implementations, wire server) can throw these
+* directly; the wire layer maps them onto the canonical JSON-RPC
+* style error codes:
+*
+*   -32001  LLM not configured (missing `default_model`)
+*   -32002  LLM capability mismatch (image_in / video_in / audio_in
+*           rejected by the selected model)
+*   -32003  Provider-level failure (network, rate-limit, 5xx, etc.)
+*
+* These classes extend `Error` so `instanceof` works across module
+* boundaries; the wire mapper in `classifyBusinessError` drops back
+* to a `/provider|backend|upstream/i` string heuristic when callers
+* throw vanilla `Error`s (e.g. fixture adapters that haven't been
+* migrated to `ProviderError`).
+*/
+/**
+* Phase 18 A.11 — no default LLM configured. Surfaced when a
+* session is created without a `model` AND config has no
+* `default_model` fallback. Host code can throw this at any point
+* the missing-model is observed; the wire layer maps it to code
+* -32001.
+*/
+var LLMNotSetError = class extends Error {
+	constructor(message = "No LLM configured") {
+		super(message);
+		this.name = "LLMNotSetError";
+	}
+};
+/**
 * Phase 18 A.12 — the selected LLM does not accept the input
 * modality the client supplied (image / video / audio). Thrown by
 * the wire prompt handler before the turn is armed so the client
@@ -4503,7 +5192,7 @@ var StubChildLifecycle = class {
 * `SoulRegistry.runSubagentTurn`.
 */
 async function runSubagentTurn(deps, agentId, request, signal) {
-	const { store, typeRegistry, parentTools, parentRuntime, parentEventBus, parentSessionJournal, parentModel, sessionDir, pathConfig, sessionId, parentSessionId, toolExecutionScopeFactory } = deps;
+	const { store, typeRegistry, parentTools, parentRuntime, runtimeSlot, parentEventBus, parentSessionJournal, parentModel, sessionDir, pathConfig, sessionId, parentSessionId, toolExecutionScopeFactory } = deps;
 	const typeDef = typeRegistry.resolve(request.agentName);
 	const childTools = typeRegistry.resolveToolSet(request.agentName, parentTools);
 	await store.createInstance({
@@ -4588,7 +5277,7 @@ async function runSubagentTurn(deps, agentId, request, signal) {
 		...childSystemPrompt !== void 0 ? { initialSystemPrompt: childSystemPrompt } : {}
 	});
 	const childTurnId = `${agentId}_turn`;
-	const baseChildRuntime = { kosong: parentRuntime.kosong };
+	const baseChildRuntime = { kosong: runtimeSlot?.current().runtime.kosong ?? parentRuntime.kosong };
 	const contentCollector = [];
 	let baseSink;
 	if (parentEventBus !== void 0 && childJournalWriter !== void 0) {
@@ -5353,6 +6042,138 @@ function buildBeforeToolCall(options) {
 	};
 }
 //#endregion
+//#region ../../packages/kimi-core/src/soul-plus/plan/plan-mode-checker.ts
+/**
+* Shared error message surface used by Write / Edit so the LLM always
+* sees a consistent "here's the exit" hint regardless of which tool
+* tripped the block.
+*/
+function planModeWriteBlockMessage(planPath) {
+	return `Plan mode is active. You may only write to the current plan file: ${planPath ?? "(no plan file selected yet)"}. Call ExitPlanMode to exit plan mode before editing other files.`;
+}
+/**
+* Shared error message surface for Bash mutation blocks.
+*/
+function planModeBashBlockMessage() {
+	return "Plan mode is active. This command would mutate the filesystem; plan mode forbids that. Call ExitPlanMode to exit plan mode before running mutation commands.";
+}
+/**
+* Classify a shell command as "mutation" vs read-only. Used exclusively
+* by the plan-mode hard block — the detector is conservative: the tests
+* pin seven concrete cases (rm, redirect `>`, `>>`, sed -i, git commit,
+* plus `ls` / `cat` that must NOT trip the gate). The detector leans
+* toward under-blocking (unknown-first-word = allow) so plan-mode
+* doesn't interfere with legitimate read-only explorations.
+*
+* This deliberately does NOT attempt to be a full shell parser. Known
+* and accepted false positives:
+*   - Quoted strings containing `>` are blocked (e.g.
+*     `echo "hello > world"`) because the regex does not track quote
+*     state. Plan-mode callers can work around this by avoiding
+*     redirect-like substrings in quoted output.
+*   - `&>` / `&>>` (bash stderr+stdout combined redirect) is *not*
+*     detected; those are legitimate file writes but the policy's
+*     7-case test pin does not cover them.
+*
+* Stricter parsing is out of scope for Phase 18; hosts that need
+* tighter policy should wrap or replace this helper.
+*/
+function isMutatingBashCommand(command) {
+	const trimmed = command.trim();
+	if (trimmed.length === 0) return false;
+	if (/(^|[^&0-9])>{1,2}\s*(?!&)\S/.test(trimmed)) return true;
+	const tokens = trimmed.split(/\s+/);
+	const firstToken = tokens[0] ?? "";
+	if (new Set([
+		"rm",
+		"rmdir",
+		"mv",
+		"cp",
+		"mkdir",
+		"touch",
+		"chmod",
+		"chown",
+		"ln",
+		"tee",
+		"dd",
+		"truncate",
+		"shred",
+		"patch"
+	]).has(firstToken)) return true;
+	if (firstToken === "sed" && (/\s-i(\b|\s|=)/.test(` ${trimmed}`) || trimmed.includes("--in-place"))) return true;
+	if (firstToken === "git") {
+		const gitMutating = new Set([
+			"commit",
+			"push",
+			"reset",
+			"checkout",
+			"rebase",
+			"merge",
+			"tag",
+			"stash",
+			"cherry-pick",
+			"revert",
+			"pull",
+			"add",
+			"rm",
+			"mv",
+			"clone",
+			"init",
+			"restore",
+			"apply",
+			"clean",
+			"gc",
+			"prune"
+		]);
+		const sub = tokens[1];
+		if (sub !== void 0 && gitMutating.has(sub)) return true;
+		if (sub === "branch" && /\s-[dD](\b|\s)/.test(trimmed)) return true;
+	}
+	if (new Set([
+		"npm",
+		"yarn",
+		"pnpm",
+		"pip",
+		"pip3",
+		"poetry",
+		"cargo",
+		"gem",
+		"uv"
+	]).has(firstToken)) {
+		const sub = tokens[1] ?? "";
+		if (new Set([
+			"install",
+			"i",
+			"add",
+			"remove",
+			"rm",
+			"uninstall",
+			"update",
+			"upgrade",
+			"publish",
+			"link",
+			"unlink"
+		]).has(sub)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region ../../packages/kimi-core/src/soul-plus/plan/plan-tool-call-policy.ts
+function inspectPlanModeToolCall(toolName, args, planMode) {
+	if (planMode === void 0 || !planMode.isActive()) return { kind: "none" };
+	if (toolName !== "Write" && toolName !== "Edit") return { kind: "none" };
+	if (!isRecord$9(args) || typeof args["path"] !== "string") return { kind: "none" };
+	const planPath = planMode.controller.getPlanFilePath();
+	if (planPath !== null && resolve(args["path"]) === resolve(planPath)) return { kind: "allow_plan_file" };
+	return {
+		kind: "block",
+		reason: planModeWriteBlockMessage(planPath)
+	};
+}
+function isRecord$9(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/tool-call/use-case.ts
 var DefaultToolCallUseCase = class {
 	constructor(deps) {
@@ -5384,8 +6205,15 @@ var DefaultToolCallUseCase = class {
 				block: true,
 				reason: hookResult.reason
 			};
-			const permissionResult = await permissionClosure(btcCtx, signal);
-			if (permissionResult?.block === true) return permissionResult;
+			const planModeDecision = inspectPlanModeToolCall(btcCtx.toolCall.name, btcCtx.args, this.deps.planMode);
+			if (planModeDecision.kind === "block") return {
+				block: true,
+				reason: planModeDecision.reason
+			};
+			if (planModeDecision.kind !== "allow_plan_file") {
+				const permissionResult = await permissionClosure(btcCtx, signal);
+				if (permissionResult?.block === true) return permissionResult;
+			}
 			const display = context.toolsByName?.get(btcCtx.toolCall.name)?.display;
 			const activityDescription = display?.getActivityDescription?.(btcCtx.args);
 			const userFacingName = display?.getUserFacingName?.(btcCtx.args);
@@ -5404,7 +6232,6 @@ var DefaultToolCallUseCase = class {
 				}
 			});
 			if (wireUuid !== void 0) btcCtx.toolCallByProviderId?.set(btcCtx.toolCall.id, wireUuid);
-			return permissionResult;
 		};
 	}
 	buildAfterToolCall(context, toolsByName) {
@@ -5528,10 +6355,12 @@ var DefaultToolExecutionScopeFactory = class {
 		const transcript = new ContextStateToolTranscriptRecorder();
 		const resultPolicy = this.deps.resultPolicy ?? new ArchiveToolResultPolicy();
 		const streaming = new ToolStreamingPrefetchScope();
+		const planMode = this.deps.planMode;
 		const useCase = new DefaultToolCallUseCase({
 			policy: this.deps.policy,
 			transcript,
 			resultPolicy,
+			...planMode !== void 0 ? { planMode } : {},
 			consumeToolOutcome: (toolCallId) => {
 				const outcome = outcomes.get(toolCallId);
 				outcomes.delete(toolCallId);
@@ -5545,6 +6374,8 @@ var DefaultToolExecutionScopeFactory = class {
 				inputSchema: inner.inputSchema,
 				async execute(toolCallId, args, signal, onUpdate, ctx) {
 					try {
+						const planModeResult = await maybeExecutePlanFileTool(inner.name, args, planMode);
+						if (planModeResult !== void 0) return planModeResult;
 						return await inner.execute(toolCallId, args, signal, onUpdate, ctx);
 					} catch (error) {
 						if (isAbortLike(error, signal)) outcomes.set(toolCallId, { kind: "abort" });
@@ -5600,6 +6431,19 @@ var DefaultToolExecutionScopeFactory = class {
 		};
 	}
 };
+function createPlanModeOnlyToolExecutionScopeFactory(deps) {
+	return { create(actor) {
+		return {
+			actor,
+			buildSoulConfig({ tools }) {
+				return { tools: tools.map((tool) => wrapPlanModeTool(tool, deps.planMode)) };
+			},
+			wrapRuntime(runtime) {
+				return runtime;
+			}
+		};
+	} };
+}
 /**
 * Explicit test/embedder escape hatch matching the historical
 * `runSubagentTurn` behavior: no hooks, no approval, no permission rule walk,
@@ -5635,6 +6479,109 @@ function createWalOnlyToolExecutionScopeFactory() {
 		};
 	} };
 }
+function wrapPlanModeTool(inner, planMode) {
+	const wrapped = {
+		name: inner.name,
+		description: inner.description,
+		inputSchema: inner.inputSchema,
+		async execute(toolCallId, args, signal, onUpdate, ctx) {
+			const planModeResult = await maybeExecutePlanFileTool(inner.name, args, planMode);
+			if (planModeResult !== void 0) return planModeResult;
+			return inner.execute(toolCallId, args, signal, onUpdate, ctx);
+		}
+	};
+	copyToolMetadata(inner, wrapped);
+	return wrapped;
+}
+function copyToolMetadata(inner, wrapped) {
+	if (inner.maxResultSizeChars !== void 0) wrapped.maxResultSizeChars = inner.maxResultSizeChars;
+	if (inner.display !== void 0) wrapped.display = inner.display;
+	if (inner.isConcurrencySafe !== void 0) wrapped.isConcurrencySafe = inner.isConcurrencySafe.bind(inner);
+}
+async function maybeExecutePlanFileTool(toolName, args, planMode) {
+	if (!isRecord$8(args) || typeof args["path"] !== "string") return void 0;
+	const decision = inspectPlanModeToolCall(toolName, args, planMode);
+	if (decision.kind === "none") return void 0;
+	if (decision.kind === "block") return {
+		isError: true,
+		content: decision.reason
+	};
+	if (planMode === void 0) return void 0;
+	const inputPath = args["path"];
+	if (toolName === "Write") {
+		const content = args["content"];
+		if (typeof content !== "string") return void 0;
+		const bytesWritten = await planMode.controller.writeCurrentPlan(content);
+		return {
+			content: `Wrote ${String(bytesWritten)} bytes to ${inputPath}`,
+			output: { bytesWritten }
+		};
+	}
+	const oldString = args["old_string"];
+	const newString = args["new_string"];
+	if (typeof oldString !== "string" || typeof newString !== "string") return void 0;
+	const current = await planMode.controller.readCurrentPlan();
+	if (current === null || current.plan.length === 0) return {
+		isError: true,
+		content: "The current plan file does not exist yet. Use Write to create it before calling Edit."
+	};
+	const replaceAll = args["replace_all"] === true;
+	const replacement = replacePlanText(current.plan, oldString, newString, replaceAll, inputPath);
+	if (!replacement.ok) return replacement.error;
+	await planMode.controller.writeCurrentPlan(replacement.content);
+	return {
+		content: `Replaced ${String(replacement.replacementCount)} occurrence${replacement.replacementCount === 1 ? "" : "s"} in ${inputPath}`,
+		output: { replacementCount: replacement.replacementCount }
+	};
+}
+function replacePlanText(content, oldString, newString, replaceAll, path) {
+	if (!replaceAll) {
+		let count = 0;
+		let pos = 0;
+		while (pos < content.length) {
+			const idx = content.indexOf(oldString, pos);
+			if (idx === -1) break;
+			count++;
+			pos = idx + oldString.length;
+		}
+		if (count === 0) return {
+			ok: false,
+			error: {
+				isError: true,
+				content: `old_string not found in ${path}`
+			}
+		};
+		if (count > 1) return {
+			ok: false,
+			error: {
+				isError: true,
+				content: `old_string is not unique in ${path} (found ${String(count)} occurrences)`
+			}
+		};
+		return {
+			ok: true,
+			content: content.replace(oldString, newString),
+			replacementCount: 1
+		};
+	}
+	const parts = content.split(oldString);
+	const replacementCount = parts.length - 1;
+	if (replacementCount === 0) return {
+		ok: false,
+		error: {
+			isError: true,
+			content: `old_string not found in ${path}`
+		}
+	};
+	return {
+		ok: true,
+		content: parts.join(newString),
+		replacementCount
+	};
+}
+function isRecord$8(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function isAbortLike(error, signal) {
 	if (signal.aborted) return true;
 	if (error instanceof Error && error.name === "AbortError") return true;
@@ -5788,6 +6735,7 @@ function withPlanFileFooter(body, planFilePath) {
 	return `${body}\n\nPlan file: ${planFilePath}`;
 }
 function fullReminder(planFilePath) {
+	if (planFilePath === void 0 || planFilePath.length === 0) return inlineFullReminder();
 	return withPlanFileFooter([
 		"Plan mode is active. You MUST NOT make any edits (with the exception of the current plan file), run non-readonly tools, or otherwise make changes to the system. This supersedes any other instructions you have received.",
 		"",
@@ -5811,6 +6759,7 @@ function fullReminder(planFilePath) {
 	].join("\n"), planFilePath);
 }
 function sparseReminder(planFilePath) {
+	if (planFilePath === void 0 || planFilePath.length === 0) return inlineSparseReminder();
 	return withPlanFileFooter([
 		"Plan mode still active (see full instructions earlier).",
 		"Read-only except the current plan file.",
@@ -5822,6 +6771,7 @@ function sparseReminder(planFilePath) {
 	].join(" "), planFilePath);
 }
 function reentryReminder(planFilePath) {
+	if (planFilePath === void 0 || planFilePath.length === 0) return inlineReentryReminder();
 	return withPlanFileFooter([
 		"Plan mode is active. You MUST NOT make any edits (with the exception of the current plan file), run non-readonly tools, or otherwise make changes to the system. This supersedes any other instructions you have received.",
 		"",
@@ -5838,6 +6788,50 @@ function reentryReminder(planFilePath) {
 		"Your turn must end with either AskUserQuestion (to clarify requirements) or ExitPlanMode (to request plan approval)."
 	].join("\n"), planFilePath);
 }
+function inlineFullReminder() {
+	return [
+		"Plan mode is active. You MUST NOT make any edits, run non-readonly tools, or otherwise make changes to the system. This supersedes any other instructions you have received.",
+		"",
+		"Workflow:",
+		"  1. Understand — explore the codebase with Glob, Grep, Read.",
+		"  2. Design — converge on the best approach; consider trade-offs but aim for a single recommendation.",
+		"  3. Review — re-read key files to verify understanding.",
+		"  4. Exit — call ExitPlanMode with the complete plan text in the `plan` parameter.",
+		"",
+		"## Handling multiple approaches",
+		"Keep it focused: at most 2-3 meaningfully different approaches. Do NOT pad with minor variations — if one approach is clearly superior, just propose that one.",
+		"When the best approach depends on user preferences, constraints, or context you don't have, use AskUserQuestion to clarify first.",
+		"When you do include multiple approaches in the plan, you MUST pass them as the `options` parameter when calling ExitPlanMode, so the user can select which approach to execute at approval time.",
+		"",
+		"AskUserQuestion is for clarifying missing requirements or user preferences that affect the plan.",
+		"Never ask about plan approval via text or AskUserQuestion.",
+		"Your turn must end with either AskUserQuestion (to clarify requirements or preferences) or ExitPlanMode (to request plan approval). Do NOT end your turn any other way."
+	].join("\n");
+}
+function inlineSparseReminder() {
+	return [
+		"Plan mode still active (see full instructions earlier).",
+		"Read-only; no plan file path is available in this host.",
+		"Call ExitPlanMode with the complete plan text in the `plan` parameter when ready.",
+		"Use AskUserQuestion to clarify user preferences when it helps you write a better plan.",
+		"If the plan has multiple approaches, pass options to ExitPlanMode so the user can choose.",
+		"End turns with AskUserQuestion (for clarifications) or ExitPlanMode (for approval)."
+	].join(" ");
+}
+function inlineReentryReminder() {
+	return [
+		"Plan mode is active. You MUST NOT make any edits, run non-readonly tools, or otherwise make changes to the system. This supersedes any other instructions you have received.",
+		"",
+		"## Re-entering Plan Mode",
+		"No plan file path is available in this host.",
+		"Before proceeding:",
+		"  1. Re-evaluate the user request and any existing conversation context.",
+		"  2. Use AskUserQuestion to clarify missing requirements or user preferences that affect the plan.",
+		"  3. Call ExitPlanMode with the complete revised plan text in the `plan` parameter.",
+		"",
+		"Your turn must end with either AskUserQuestion (to clarify requirements) or ExitPlanMode (to request plan approval)."
+	].join("\n");
+}
 /**
 * Yolo-mode reminder ported from Python `yolo_mode.py`. One-shot per
 * activation: the first turn after `permissionMode` flips to
@@ -18949,6 +19943,9 @@ var TurnManager = class {
 	pendingTurnOverrides;
 	planMode;
 	thinkingLevel;
+	runtime;
+	runtimeSlot;
+	compactionConfig;
 	sessionId;
 	activeToolExecutionScope;
 	/**
@@ -18974,6 +19971,9 @@ var TurnManager = class {
 		this.sessionRules = [...deps.sessionRules ?? []];
 		this.permissionMode = deps.permissionMode ?? "default";
 		this.planMode = deps.planMode ?? false;
+		this.runtime = deps.runtime;
+		this.runtimeSlot = deps.runtimeSlot;
+		this.compactionConfig = deps.compactionConfig;
 		this.sessionId = deps.sessionId ?? "unknown";
 	}
 	setPermissionMode(mode) {
@@ -18998,6 +19998,26 @@ var TurnManager = class {
 	getThinkingLevel() {
 		return this.thinkingLevel;
 	}
+	setCompactionConfig(config) {
+		if (this.runtimeSlot !== void 0) {
+			const current = this.runtimeSlot.current();
+			this.runtimeSlot.replace({
+				...current,
+				...config !== void 0 ? { compactionConfig: config } : { compactionConfig: void 0 }
+			});
+		}
+		this.compactionConfig = config;
+	}
+	setRuntime(runtime) {
+		if (this.runtimeSlot !== void 0) {
+			const current = this.runtimeSlot.current();
+			this.runtimeSlot.replace({
+				...current,
+				runtime
+			});
+		}
+		this.runtime = runtime;
+	}
 	getAgentId() {
 		return this.agentId;
 	}
@@ -19145,7 +20165,7 @@ var TurnManager = class {
 	async handlePrompt(req) {
 		if (!this.deps.lifecycleStateMachine.isIdle() || this.getCurrentTurnId() !== void 0) return { error: "agent_busy" };
 		const input = req.data.input;
-		const capability = this.deps.runtime.kosong.getCapability?.(this.deps.contextState.model);
+		const capability = ((this.runtimeSlot?.current())?.runtime ?? this.runtime).kosong.getCapability?.(this.deps.contextState.model);
 		if (capability !== void 0 && capability !== UNKNOWN_CAPABILITY$1) {
 			let inputContainsImage = false;
 			let inputContainsVideo = false;
@@ -19212,16 +20232,28 @@ var TurnManager = class {
 		this.deps.contextState.pushSteer(req.data.input);
 		return { ok: true };
 	}
-	drainDynamicInjectionsIntoContext(turnId) {
+	async drainDynamicInjectionsIntoContext(turnId) {
 		const manager = this.deps.dynamicInjectionManager;
 		if (manager === void 0) return;
+		const planFilePath = this.deps.planFilePathProvider?.();
 		const ctx = {
 			planMode: this.planMode,
 			permissionMode: this.permissionMode,
 			turnNumber: this.extractTurnNumber(turnId),
-			history: this.deps.contextState.getHistory()
-		};
-		manager.computeInjections(ctx, this.deps.contextState);
+			history: this.deps.contextState.getHistory(),
+			...planFilePath !== void 0 ? { planFilePath } : {}
+		};
+		const contextBackedWrites = [];
+		const injections = manager.computeInjections(ctx, { appendSystemReminder: (data) => {
+			const write = this.deps.contextState.appendSystemReminder(data);
+			contextBackedWrites.push(write);
+			return write;
+		} });
+		await Promise.all(contextBackedWrites);
+		for (const injection of injections) {
+			if (injection.kind !== "system_reminder") continue;
+			await this.deps.contextState.appendSystemReminder({ content: typeof injection.content === "string" ? injection.content : JSON.stringify(injection.content) });
+		}
 	}
 	extractTurnNumber(turnId) {
 		const match = /^turn_(\d+)$/.exec(turnId);
@@ -19259,7 +20291,9 @@ var TurnManager = class {
 			kind: this.agentType === "sub" ? "subagent" : this.agentType === "independent" ? "independent" : "main",
 			...this.subagentType !== void 0 ? { subagentType: this.subagentType } : {}
 		});
-		const runtimeForTurn = scope?.wrapRuntime(this.deps.runtime) ?? this.deps.runtime;
+		const runtimeBundle = this.runtimeSlot?.current();
+		const baseRuntime = runtimeBundle?.runtime ?? this.runtime;
+		const runtimeForTurn = scope?.wrapRuntime(baseRuntime) ?? baseRuntime;
 		if (scope !== void 0) {
 			this.activeToolExecutionScope = scope;
 			const scoped = scope.buildSoulConfig({
@@ -19275,10 +20309,11 @@ var TurnManager = class {
 				...scoped.afterToolCall !== void 0 ? { afterToolCall: scoped.afterToolCall } : {}
 			};
 		} else soulConfig = { tools: [...this.deps.tools] };
-		if (this.deps.compactionConfig !== void 0) soulConfig = {
+		const compactionConfig = this.runtimeSlot !== void 0 ? runtimeBundle?.compactionConfig : this.compactionConfig;
+		if (compactionConfig !== void 0) soulConfig = {
 			...soulConfig,
-			compactionConfig: this.deps.compactionConfig,
-			contextWindow: this.deps.compactionConfig.maxContextSize
+			compactionConfig,
+			contextWindow: compactionConfig.maxContextSize
 		};
 		const input = trigger.input;
 		const runPromise = this.runTurn(turnId, input, soulConfig, runtimeForTurn, controller.signal);
@@ -19287,8 +20322,7 @@ var TurnManager = class {
 		return turnId;
 	}
 	async runTurn(turnId, input, soulConfig, runtime, signal) {
-		this.drainDynamicInjectionsIntoContext(turnId);
-		await Promise.resolve();
+		await this.drainDynamicInjectionsIntoContext(turnId);
 		let result;
 		let reason;
 		try {
@@ -19433,7 +20467,7 @@ var TurnManager = class {
 	*/
 	emitStatusUpdate(tokenUsage) {
 		const used = this.deps.contextState.tokenCountWithPending;
-		const total = this.deps.compactionConfig?.maxContextSize ?? DEFAULT_CONTEXT_WINDOW;
+		const total = (this.runtimeSlot !== void 0 ? this.runtimeSlot.current().compactionConfig : this.compactionConfig)?.maxContextSize ?? DEFAULT_CONTEXT_WINDOW;
 		const data = {
 			context_usage: {
 				used,
@@ -19477,6 +20511,101 @@ var WakeQueueScheduler = class {
 };
 //#endregion
 //#region ../../packages/kimi-core/src/soul-plus/soul-plus.ts
+const PLAN_APPROVAL_APPROVE = "Approve";
+const PLAN_APPROVAL_REJECT = "Reject";
+const PLAN_APPROVAL_REJECT_AND_EXIT = "Reject and Exit";
+const PLAN_APPROVAL_REVISE = "Revise";
+function isRecord$7(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseQuestionAnswerLabels(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.length === 0) return [];
+	try {
+		const parsed = JSON.parse(trimmed);
+		const answers = isRecord$7(parsed) && isRecord$7(parsed["answers"]) ? parsed["answers"] : void 0;
+		if (answers !== void 0) return Object.values(answers).filter((value) => typeof value === "string" && value.length > 0);
+	} catch {}
+	return [trimmed];
+}
+function pushPlanApprovalOption(options, option) {
+	if (options.some((item) => item.label === option.label)) return;
+	options.push(option);
+}
+function planApprovalQuestionOptions(args) {
+	const options = args.options !== void 0 && args.options.length >= 2 ? [...args.options] : [{
+		label: PLAN_APPROVAL_APPROVE,
+		description: "Exit plan mode and start execution"
+	}];
+	pushPlanApprovalOption(options, {
+		label: PLAN_APPROVAL_REJECT,
+		description: "Reject and stay in plan mode"
+	});
+	pushPlanApprovalOption(options, {
+		label: PLAN_APPROVAL_REJECT_AND_EXIT,
+		description: "Reject and exit plan mode"
+	});
+	return options;
+}
+async function requestEnterPlanModeQuestion(questionRuntime, toolCallId, args, signal) {
+	const reasonSuffix = args.reason ? `\n\nReason: ${args.reason}` : "";
+	return { approved: parseQuestionAnswerLabels((await questionRuntime.askQuestion({
+		toolCallId,
+		questions: [{
+			header: "Plan Mode",
+			question: `Enter plan mode? In plan mode I'll investigate and design a plan before making changes.${reasonSuffix}`,
+			options: [{
+				label: "Yes",
+				description: "Enter plan mode"
+			}, {
+				label: "No",
+				description: "Proceed without planning"
+			}]
+		}],
+		signal
+	})).answer)[0] === "Yes" };
+}
+async function requestPlanApprovalQuestion(questionRuntime, args, signal) {
+	const labels = new Set((args.options ?? []).map((option) => option.label));
+	const choice = parseQuestionAnswerLabels((await questionRuntime.askQuestion({
+		toolCallId: `exit_plan_approval_${Date.now().toString(36)}`,
+		questions: [{
+			header: "Plan",
+			question: "Approve this plan?",
+			body: args.plan,
+			options: planApprovalQuestionOptions(args),
+			otherLabel: PLAN_APPROVAL_REVISE,
+			otherDescription: "Stay in plan mode and provide feedback"
+		}],
+		signal
+	})).answer)[0];
+	if (choice === void 0) return {
+		approved: false,
+		chosenLabel: PLAN_APPROVAL_REVISE,
+		feedback: "User dismissed without choosing. Plan mode remains active."
+	};
+	if (choice === PLAN_APPROVAL_REJECT_AND_EXIT) return { approved: true };
+	if (choice === PLAN_APPROVAL_REJECT) return {
+		approved: false,
+		chosenLabel: PLAN_APPROVAL_REVISE,
+		feedback: "Plan rejected by user. Stay in plan mode and wait for the user before revising."
+	};
+	if (choice === PLAN_APPROVAL_REVISE) return {
+		approved: false,
+		chosenLabel: PLAN_APPROVAL_REVISE,
+		feedback: "User requested a plan revision."
+	};
+	if (choice === PLAN_APPROVAL_APPROVE) return { approved: true };
+	if (labels.has(choice)) return {
+		approved: true,
+		chosenLabel: choice
+	};
+	return {
+		approved: false,
+		chosenLabel: PLAN_APPROVAL_REVISE,
+		feedback: `User selected "${choice}". Stay in plan mode and revise before proceeding.`
+	};
+}
 async function requestPlanApproval(approvalRuntime, turnManager, toolCallId, args, signal) {
 	const response = await approvalRuntime.request({
 		toolCallId,
@@ -19542,6 +20671,8 @@ var SoulPlus = class {
 	components;
 	infra;
 	hostToolNames;
+	planController;
+	setPlanModeImpl;
 	/**
 	* Phase 18 A.3–A.6 — lazy `SessionControlHandler` owned by the
 	* facade. External hosts (SessionManager) still construct their own
@@ -19565,14 +20696,33 @@ var SoulPlus = class {
 		const sessionJournal = deps.sessionJournal;
 		const journalWriter = contextState.journalWriter;
 		const journalCapability = deps.journalCapability;
-		const rawKosong = deps.runtime.kosong;
-		const runtime = { kosong: rawKosong };
+		const runtimeSlot = deps.runtimeSlot ?? createSessionRuntimeSlot({
+			model: contextState.model,
+			runtime: deps.runtime,
+			compactionProvider: deps.compactionProvider,
+			...deps.compactionConfig !== void 0 ? { compactionConfig: deps.compactionConfig } : {}
+		});
+		const runtime = runtimeSlot.current().runtime;
 		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
+		}) : void 0;
+		const planController = new PlanSessionController({
+			sessionId: deps.sessionId,
+			...deps.pathConfig !== void 0 ? { paths: deps.pathConfig } : {},
+			...sessionMeta !== void 0 ? { sessionMeta } : {}
+		});
+		this.planController = planController;
 		const compactionProvider = deps.compactionProvider;
 		let turnManagerRef;
 		const compaction = new CompactionOrchestrator({
 			contextState,
 			compactionProvider,
+			runtimeSlot,
 			lifecycleStateMachine: stateMachine,
 			journalCapability,
 			sink: eventBus,
@@ -19592,7 +20742,11 @@ var SoulPlus = class {
 				return turnManagerRef.getCurrentTurnId();
 			}
 		});
-		const toolExecutionScopeFactory = deps.toolExecutionScopeFactory ?? (approvalRuntime !== void 0 && deps.hookEngine !== void 0 ? new DefaultToolExecutionScopeFactory({
+		const effectiveHookEngine = deps.hookEngine ?? (approvalRuntime !== void 0 ? new HookEngine({
+			executors: /* @__PURE__ */ new Map(),
+			sink: eventBus
+		}) : void 0);
+		const toolExecutionScopeFactory = deps.toolExecutionScopeFactory ?? (approvalRuntime !== void 0 && effectiveHookEngine !== void 0 ? new DefaultToolExecutionScopeFactory({
 			policy: {
 				getPermissionMode: () => {
 					if (turnManagerRef === void 0) return "default";
@@ -19607,10 +20761,17 @@ var SoulPlus = class {
 					turnManagerRef.addSessionRule(rule);
 				},
 				approvalRuntime,
-				hookEngine: deps.hookEngine
+				hookEngine: effectiveHookEngine
 			},
-			resultPolicy: new ArchiveToolResultPolicy(deps.pathConfig !== void 0 ? { pathConfig: deps.pathConfig } : {})
-		}) : void 0);
+			resultPolicy: new ArchiveToolResultPolicy(deps.pathConfig !== void 0 ? { pathConfig: deps.pathConfig } : {}),
+			planMode: {
+				isActive: () => turnManagerRef?.getPlanMode() ?? false,
+				controller: planController
+			}
+		}) : planController.isAvailable() ? createPlanModeOnlyToolExecutionScopeFactory({ planMode: {
+			isActive: () => turnManagerRef?.getPlanMode() ?? false,
+			controller: planController
+		} }) : void 0);
 		const hasSubagentInfra = deps.subagentStore !== void 0 && deps.agentTypeRegistry !== void 0;
 		const soulRegistry = new SoulRegistry({
 			createHandle: (key, agentDepth) => ({
@@ -19625,7 +20786,8 @@ var SoulPlus = class {
 				store: deps.subagentStore,
 				typeRegistry: deps.agentTypeRegistry,
 				parentTools: deps.tools,
-				parentRuntime: { kosong: rawKosong },
+				runtimeSlot,
+				parentRuntime: runtimeSlot.current().runtime,
 				parentEventBus: eventBus,
 				sessionDir: deps.sessionDir ?? "",
 				parentModel: contextState.model,
@@ -19657,6 +20819,7 @@ var SoulPlus = class {
 			contextState,
 			sessionJournal,
 			runtime,
+			runtimeSlot,
 			sink: eventBus,
 			lifecycleStateMachine: stateMachine,
 			soulRegistry,
@@ -19666,6 +20829,7 @@ var SoulPlus = class {
 			wakeScheduler,
 			dynamicInjectionManager,
 			sessionId: deps.sessionId,
+			planFilePathProvider: () => planController.getPlanFilePath() ?? void 0,
 			...deps.sessionRules !== void 0 ? { sessionRules: deps.sessionRules } : {},
 			...deps.permissionMode !== void 0 ? { permissionMode: deps.permissionMode } : {},
 			...toolExecutionScopeFactory !== void 0 ? { toolExecutionScopeFactory } : {},
@@ -19674,25 +20838,41 @@ var SoulPlus = class {
 			...deps.compactionConfig !== void 0 ? { compactionConfig: deps.compactionConfig } : {}
 		});
 		turnManagerRef = turnManager;
-		if (deps.questionRuntime !== void 0) {
-			const questionRuntime = deps.questionRuntime;
-			const setPlanMode = async (enabled) => {
+		const setPlanMode = async (enabled) => {
+			if (enabled) {
+				await planController.ensurePlanFilePath();
 				await contextState.applyConfigChange({
 					type: "plan_mode_changed",
 					enabled
 				});
 				turnManager.setPlanMode(enabled);
-			};
+				return;
+			}
+			await contextState.applyConfigChange({
+				type: "plan_mode_changed",
+				enabled
+			});
+			turnManager.setPlanMode(enabled);
+			await planController.deactivatePlanMode();
+		};
+		this.setPlanModeImpl = setPlanMode;
+		if (deps.questionRuntime !== void 0) {
+			const questionRuntime = deps.questionRuntime;
+			const planApprovalRuntime = approvalRuntime !== void 0 && !(approvalRuntime instanceof AlwaysAllowApprovalRuntime) ? approvalRuntime : void 0;
+			const enterPlanRequestApproval = planApprovalRuntime !== void 0 ? (toolCallId, args, signal) => requestEnterPlanModeApproval(planApprovalRuntime, turnManager, toolCallId, args, signal) : (toolCallId, args, signal) => requestEnterPlanModeQuestion(questionRuntime, toolCallId, args, signal);
+			const exitPlanRequestApproval = planApprovalRuntime !== void 0 ? (toolCallId, args, signal) => requestPlanApproval(planApprovalRuntime, turnManager, toolCallId, args, signal) : (_toolCallId, args, signal) => requestPlanApprovalQuestion(questionRuntime, args, signal);
 			if (isToolEnabled("EnterPlanMode")) toolRegistry.push(new EnterPlanModeTool({
 				isPlanModeActive: () => turnManager.getPlanMode(),
 				setPlanMode,
 				isYoloMode: () => turnManager.getPermissionMode() === "bypassPermissions",
-				...approvalRuntime !== void 0 ? { requestApproval: (toolCallId, args, signal) => requestEnterPlanModeApproval(approvalRuntime, turnManager, toolCallId, args, signal) } : {}
+				requestApproval: enterPlanRequestApproval,
+				getPlanFilePath: () => planController.getPlanFilePath()
 			}));
 			if (isToolEnabled("ExitPlanMode")) toolRegistry.push(new ExitPlanModeTool({
 				isPlanModeActive: () => turnManager.getPlanMode(),
 				setPlanMode,
-				...approvalRuntime !== void 0 ? { requestApproval: (toolCallId, args, signal) => requestPlanApproval(approvalRuntime, turnManager, toolCallId, args, signal) } : {}
+				requestApproval: exitPlanRequestApproval,
+				...planController.isAvailable() ? { readPlan: () => planController.readCurrentPlan() } : {}
 			}));
 			if (isToolEnabled("AskUserQuestion")) toolRegistry.push(new AskUserQuestionTool(questionRuntime, () => turnManager.getPermissionMode()));
 		}
@@ -19703,13 +20883,6 @@ var SoulPlus = class {
 			...deps.onShellDeliver !== void 0 ? { onShellDeliver: deps.onShellDeliver } : {},
 			...deps.logger !== void 0 ? { logger: deps.logger } : {}
 		});
-		const sessionMeta = deps.stateCache !== void 0 && deps.initialMeta !== void 0 ? new SessionMetaService({
-			sessionId: deps.sessionId,
-			sessionJournal,
-			eventBus,
-			stateCache: deps.stateCache,
-			initialMeta: deps.initialMeta
-		}) : void 0;
 		this.lifecycle = {
 			stateMachine,
 			gate
@@ -19737,7 +20910,7 @@ var SoulPlus = class {
 			eventBus,
 			toolRegistry,
 			permissionRules,
-			hookEngine: deps.hookEngine
+			hookEngine: effectiveHookEngine
 		};
 		if (deps.approvalStateStore !== void 0) deps.approvalStateStore.onChanged((snapshot) => {
 			turnManager.setPermissionMode(snapshot.yolo ? "bypassPermissions" : "default");
@@ -19881,6 +21054,21 @@ var SoulPlus = class {
 	tryGetSessionMeta() {
 		return this.services.sessionMeta;
 	}
+	async setPlanMode(enabled) {
+		await this.setPlanModeImpl(enabled);
+	}
+	getPlanFilePath() {
+		return this.planController.getPlanFilePath();
+	}
+	ensurePlanFilePath() {
+		return this.planController.ensurePlanFilePath();
+	}
+	readCurrentPlan() {
+		return this.planController.readCurrentPlan();
+	}
+	clearCurrentPlan() {
+		return this.planController.clearCurrentPlan();
+	}
 	/**
 	* Activate a skill by name (Slice 2.5 inline mode). Reads the
 	* SKILL.md body from the registered `SkillDefinition`, interpolates
@@ -19912,7 +21100,8 @@ var SoulPlus = class {
 		this.sessionControlInstance = new DefaultSessionControl({
 			turnManager: this.components.turnManager,
 			contextState: this.journal.contextState,
-			sessionJournal: this.journal.sessionJournal
+			sessionJournal: this.journal.sessionJournal,
+			setPlanModeOverride: (enabled) => this.setPlanMode(enabled)
 		});
 		return this.sessionControlInstance;
 	}
@@ -20098,7 +21287,7 @@ var KosongAdapter = class {
 		const kosongTools = params.tools.map((t) => ({
 			name: t.name,
 			description: t.description,
-			parameters: isRecord$5(t.input_schema) ? t.input_schema : { type: "object" }
+			parameters: isRecord$6(t.input_schema) ? t.input_schema : { type: "object" }
 		}));
 		const onDelta = params.onDelta;
 		const onThinkDelta = params.onThinkDelta;
@@ -20196,7 +21385,7 @@ function extractMessage(err) {
 function createKosongAdapter(options) {
 	return new KosongAdapter(options);
 }
-function isRecord$5(value) {
+function isRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseToolArgs(raw) {
@@ -20483,44 +21672,6 @@ function safeDispatch(fn, arg, onError) {
 	});
 }
 //#endregion
-//#region ../../packages/kimi-core/src/soul-plus/approval/approval-runtime.ts
-/**
-* Thrown when a cross-process / team forwarding hook is invoked before
-* the TeamDaemon wiring lands (Slice 2.6+). Callers should treat this as
-* an unrecoverable misconfiguration in Slice 2.3.
-*/
-var NotImplementedError = class extends Error {
-	constructor(feature) {
-		super(`${feature} not implemented in Slice 2.3 (deferred to TeamDaemon)`);
-		this.name = "NotImplementedError";
-	}
-};
-/**
-* Default stub used when no wire/UI integration is required (e.g. unit
-* tests of unrelated layers, or embedder harnesses that bypass approvals
-* entirely via their own `beforeToolCall`). Every request is immediately
-* approved and no records are written.
-*
-* For the real implementation see `./wired-approval-runtime.ts`.
-*/
-var AlwaysAllowApprovalRuntime = class {
-	async request(_req, _signal) {
-		return {
-			approved: true,
-			response: "approved"
-		};
-	}
-	async recoverPendingOnStartup() {}
-	resolve(_requestId, _response) {}
-	cancelBySource(_source) {}
-	async ingestRemoteRequest(_data) {
-		throw new NotImplementedError("ApprovalRuntime.ingestRemoteRequest");
-	}
-	resolveRemote(_data) {
-		throw new NotImplementedError("ApprovalRuntime.resolveRemote");
-	}
-};
-//#endregion
 //#region ../../packages/kimi-core/src/soul-plus/approval/wired-approval-runtime.ts
 /**
 * WiredApprovalRuntime — the production `ApprovalRuntime` (v2 §9-G).
@@ -22798,122 +23949,6 @@ var ReadTool = class {
 	}
 };
 //#endregion
-//#region ../../packages/kimi-core/src/soul-plus/plan/plan-mode-checker.ts
-/**
-* Shared error message surface used by Write / Edit so the LLM always
-* sees a consistent "here's the exit" hint regardless of which tool
-* tripped the block.
-*/
-function planModeWriteBlockMessage(planPath) {
-	return `Plan mode is active. You may only write to the current plan file: ${planPath ?? "(no plan file selected yet)"}. Call ExitPlanMode to exit plan mode before editing other files.`;
-}
-/**
-* Shared error message surface for Bash mutation blocks.
-*/
-function planModeBashBlockMessage() {
-	return "Plan mode is active. This command would mutate the filesystem; plan mode forbids that. Call ExitPlanMode to exit plan mode before running mutation commands.";
-}
-/**
-* Classify a shell command as "mutation" vs read-only. Used exclusively
-* by the plan-mode hard block — the detector is conservative: the tests
-* pin seven concrete cases (rm, redirect `>`, `>>`, sed -i, git commit,
-* plus `ls` / `cat` that must NOT trip the gate). The detector leans
-* toward under-blocking (unknown-first-word = allow) so plan-mode
-* doesn't interfere with legitimate read-only explorations.
-*
-* This deliberately does NOT attempt to be a full shell parser. Known
-* and accepted false positives:
-*   - Quoted strings containing `>` are blocked (e.g.
-*     `echo "hello > world"`) because the regex does not track quote
-*     state. Plan-mode callers can work around this by avoiding
-*     redirect-like substrings in quoted output.
-*   - `&>` / `&>>` (bash stderr+stdout combined redirect) is *not*
-*     detected; those are legitimate file writes but the policy's
-*     7-case test pin does not cover them.
-*
-* Stricter parsing is out of scope for Phase 18; hosts that need
-* tighter policy should wrap or replace this helper.
-*/
-function isMutatingBashCommand(command) {
-	const trimmed = command.trim();
-	if (trimmed.length === 0) return false;
-	if (/(^|[^&0-9])>{1,2}\s*(?!&)\S/.test(trimmed)) return true;
-	const tokens = trimmed.split(/\s+/);
-	const firstToken = tokens[0] ?? "";
-	if (new Set([
-		"rm",
-		"rmdir",
-		"mv",
-		"cp",
-		"mkdir",
-		"touch",
-		"chmod",
-		"chown",
-		"ln",
-		"tee",
-		"dd",
-		"truncate",
-		"shred",
-		"patch"
-	]).has(firstToken)) return true;
-	if (firstToken === "sed" && (/\s-i(\b|\s|=)/.test(` ${trimmed}`) || trimmed.includes("--in-place"))) return true;
-	if (firstToken === "git") {
-		const gitMutating = new Set([
-			"commit",
-			"push",
-			"reset",
-			"checkout",
-			"rebase",
-			"merge",
-			"tag",
-			"stash",
-			"cherry-pick",
-			"revert",
-			"pull",
-			"add",
-			"rm",
-			"mv",
-			"clone",
-			"init",
-			"restore",
-			"apply",
-			"clean",
-			"gc",
-			"prune"
-		]);
-		const sub = tokens[1];
-		if (sub !== void 0 && gitMutating.has(sub)) return true;
-		if (sub === "branch" && /\s-[dD](\b|\s)/.test(trimmed)) return true;
-	}
-	if (new Set([
-		"npm",
-		"yarn",
-		"pnpm",
-		"pip",
-		"pip3",
-		"poetry",
-		"cargo",
-		"gem",
-		"uv"
-	]).has(firstToken)) {
-		const sub = tokens[1] ?? "";
-		if (new Set([
-			"install",
-			"i",
-			"add",
-			"remove",
-			"rm",
-			"uninstall",
-			"update",
-			"upgrade",
-			"publish",
-			"link",
-			"unlink"
-		]).has(sub)) return true;
-	}
-	return false;
-}
-//#endregion
 //#region ../../packages/kimi-core/src/tools/builtin/file/write.ts
 /**
 * WriteTool — overwrite-write a file (§9-F / Appendix E.2).
@@ -28384,206 +29419,6 @@ var SetTodoListTool = class {
 		}));
 	}
 };
-//#endregion
-//#region ../../packages/kimi-core/src/hooks/engine.ts
-/**
-* Synthesises a stable id for `hook.resolved` emissions. Hooks are
-* registered without an intrinsic id; we derive one from
-* `event:type:matcher`, suffixed with the hook's position inside
-* `this.hooks` (its registration order). The `registrationIndex` is
-* stable across multiple `executeHooks` calls — using the per-call
-* `settled[]` index instead would hand the same id to different hooks
-* across different dispatches, breaking client-side correlation.
-*/
-function hookId(hook, registrationIndex) {
-	return `${hook.event}:${hook.type}:${hook.matcher ?? ""}:${registrationIndex}`;
-}
-var HookEngine = class {
-	deps;
-	/**
-	* Mutable executor registry. Seeded from `deps.executors` at
-	* construction so the constructor arg can stay `ReadonlyMap`-typed
-	* while `registerExecutor` still lets callers install additional
-	* executors (e.g. `WireHookExecutor`) after the engine is wired.
-	*/
-	executors;
-	hooks = [];
-	/**
-	* Phase 18 L3-2 — invalid-regex warn dedupe. Each distinct invalid
-	* matcher fires `onInvalidMatcher` once per engine instance so a
-	* misconfigured block-action hook doesn't flood logs on every
-	* tool call.
-	*/
-	warnedInvalidMatchers = /* @__PURE__ */ new Set();
-	constructor(deps) {
-		this.deps = deps;
-		this.executors = new Map(deps.executors);
-	}
-	register(hook) {
-		this.hooks.push(hook);
-	}
-	/**
-	* Phase 18 L2-4 — install / replace an executor for a given `type`
-	* label at runtime. Used by the wire layer to bolt a
-	* `WireHookExecutor` onto an engine that was constructed with only
-	* the `command` executor. Replacing an existing entry is silent;
-	* callers wanting a conflict check can probe `hasExecutor(type)`.
-	*/
-	registerExecutor(type, executor) {
-		this.executors.set(type, executor);
-	}
-	/** Returns true when an executor has been registered under `type`. */
-	hasExecutor(type) {
-		return this.executors.has(type);
-	}
-	unregister(hook) {
-		const idx = this.hooks.indexOf(hook);
-		if (idx !== -1) this.hooks.splice(idx, 1);
-	}
-	list(event) {
-		if (event === void 0) return [...this.hooks];
-		return this.hooks.filter((h) => h.event === event);
-	}
-	/**
-	* Pre-filters hooks by both `event` and `matcher` regex against the
-	* target value (tool name for tool-scoped events). Exported-ish via
-	* `executeHooks` — v2 §9-C.3 requires "getMatchingHooks(event, input)
-	* then concurrent execute" ordering.
-	*/
-	getMatchingHooks(event, input) {
-		const matcherValue = extractMatcherValue(input);
-		return this.hooks.filter((h) => {
-			if (h.event !== event) return false;
-			return this.matchesTarget(h, matcherValue);
-		});
-	}
-	matchesTarget(hook, value) {
-		const matcher = hook.matcher;
-		if (matcher === void 0 || matcher === "") return true;
-		let re;
-		try {
-			re = new RegExp(matcher);
-		} catch {
-			if (!this.warnedInvalidMatchers.has(matcher)) {
-				this.warnedInvalidMatchers.add(matcher);
-				this.deps.onInvalidMatcher?.(hook, matcher);
-			}
-			return false;
-		}
-		return re.test(value);
-	}
-	async executeHooks(event, input, signal) {
-		const deduped = dedupeByCommand(this.getMatchingHooks(event, input));
-		if (deduped.length === 0) {
-			this.deps.sink?.emit({
-				type: "hook.triggered",
-				event,
-				matchers: [],
-				matched_count: 0
-			});
-			return {
-				blockAction: false,
-				additionalContext: []
-			};
-		}
-		this.deps.sink?.emit({
-			type: "hook.triggered",
-			event,
-			matchers: deduped.map((h) => h.matcher ?? ""),
-			matched_count: deduped.length
-		});
-		const settled = await Promise.allSettled(deduped.map((hook) => {
-			const executor = this.executors.get(hook.type);
-			if (executor === void 0) return Promise.resolve(void 0);
-			return executor.execute(hook, input, signal);
-		}));
-		let blockAction = false;
-		let reason;
-		const additionalContext = [];
-		for (const [i, result] of settled.entries()) {
-			const hook = deduped[i];
-			const registrationIndex = hook !== void 0 ? this.hooks.indexOf(hook) : -1;
-			if (result.status === "rejected") {
-				if (hook !== void 0) {
-					this.deps.onExecutorError?.(hook, result.reason instanceof Error ? result.reason : new Error(String(result.reason)));
-					this.deps.sink?.emit({
-						type: "hook.resolved",
-						hook_id: hookId(hook, registrationIndex),
-						outcome: "error"
-					});
-				}
-				continue;
-			}
-			const value = result.value;
-			if (hook !== void 0) {
-				const outcome = value?.ok === false ? "error" : value?.blockAction === true ? "blocked" : "ok";
-				this.deps.sink?.emit({
-					type: "hook.resolved",
-					hook_id: hookId(hook, registrationIndex),
-					outcome
-				});
-			}
-			if (value === void 0) continue;
-			if (value.blockAction) {
-				blockAction = true;
-				if (value.reason !== void 0) reason = value.reason;
-			}
-			if (value.additionalContext !== void 0) additionalContext.push(value.additionalContext);
-		}
-		return {
-			blockAction,
-			reason,
-			additionalContext
-		};
-	}
-};
-/**
-* Collapse hook configs that share the same `command` string. `wire` hooks
-* (no `command` field) key on their subscription id so different wire
-* subscriptions still run in parallel; identical subscriptions collapse
-* like identical commands.
-*/
-function dedupeByCommand(hooks) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const hook of hooks) {
-		const key = hookDedupeKey(hook);
-		if (!seen.has(key)) seen.set(key, hook);
-	}
-	return [...seen.values()];
-}
-function hookDedupeKey(hook) {
-	if (hook.type === "command") return `command:${hook.command}`;
-	if (hook.type === "wire") return `wire:${hook.subscriptionId}`;
-	return `unknown:${JSON.stringify(hook)}`;
-}
-/**
-* Extracts the string fed to a hook's matcher regex. Event-dependent:
-*
-*   - `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 "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":
-		case "SubagentStop": return input.agentName;
-		case "SessionStart":
-		case "SessionEnd":
-		case "PreCompact":
-		case "PostCompact": return "";
-	}
-}
 const _rawWireErrorSchema = z.object({
 	code: z.number(),
 	message: z.string(),
@@ -29388,6 +30223,13 @@ function errorMessage(error) {
 }
 //#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;
+	return {
+		...bundle,
+		compactionConfig: fallback
+	};
+}
 var DefaultSessionApplicationService = class {
 	constructor(deps) {
 		this.deps = deps;
@@ -29404,18 +30246,33 @@ var DefaultSessionApplicationService = class {
 			eventBus,
 			...hookEngine !== void 0 ? { hookEngine } : {}
 		});
-		const systemPrompt = input.systemPrompt !== void 0 ? input.systemPrompt : this.deps.defaultSystemPromptProvider?.();
+		const systemPrompt = input.systemPrompt ?? this.deps.defaultSystemPromptProvider?.();
 		const enabledToolNames = this.deps.enabledToolNamesProvider?.();
+		const model = input.model ?? this.deps.defaultModelProvider();
+		const runtimeBundle = await this.deps.runtimeBundleProvider?.({
+			sessionId,
+			model
+		});
+		const compactionConfig = runtimeBundle?.compactionConfig ?? this.deps.compactionConfigProvider?.({
+			sessionId,
+			model
+		});
+		const runtimeSlotBundle = runtimeBundle !== void 0 ? withCompactionConfigFallback(runtimeBundle, compactionConfig) : void 0;
+		const runtime = runtimeSlotBundle?.runtime ?? this.deps.runtimeProvider();
+		const compactionProvider = runtimeSlotBundle?.compactionProvider ?? this.deps.compactionProviderProvider();
+		const runtimeSlot = runtimeSlotBundle !== void 0 ? createSessionRuntimeSlot(runtimeSlotBundle) : void 0;
 		const managed = await this.deps.sessionManager.createSession({
 			sessionId,
-			runtime: this.deps.runtimeProvider(),
+			runtime,
+			...runtimeSlot !== void 0 ? { runtimeSlot } : {},
 			tools: this.deps.toolsProvider(),
 			...enabledToolNames !== void 0 ? { enabledToolNames } : {},
-			model: input.model ?? this.deps.defaultModelProvider(),
+			model,
 			...systemPrompt !== void 0 ? { systemPrompt } : {},
 			eventBus,
 			workspaceDir: this.deps.workspaceDir,
-			compactionProvider: this.deps.compactionProviderProvider(),
+			compactionProvider,
+			...compactionConfig !== void 0 ? { compactionConfig } : {},
 			...this.deps.approvalRuntime !== void 0 ? { approvalRuntime: this.deps.approvalRuntime } : {},
 			...this.deps.approvalRuntimeFactory !== void 0 ? { approvalRuntimeFactory: this.deps.approvalRuntimeFactory } : {},
 			...hookEngine !== void 0 ? { hookEngine } : {},
@@ -29441,11 +30298,26 @@ var DefaultSessionApplicationService = class {
 			eventBus,
 			...hookEngine !== void 0 ? { hookEngine } : {}
 		});
+		const initialModel = this.deps.defaultModelProvider();
+		const runtimeBundle = await this.deps.runtimeBundleProvider?.({
+			sessionId,
+			model: initialModel
+		});
+		const compactionConfig = runtimeBundle?.compactionConfig ?? this.deps.compactionConfigProvider?.({
+			sessionId,
+			model: initialModel
+		});
+		const runtimeSlotBundle = runtimeBundle !== void 0 ? withCompactionConfigFallback(runtimeBundle, compactionConfig) : void 0;
+		const runtime = runtimeSlotBundle?.runtime ?? this.deps.runtimeProvider();
+		const compactionProvider = runtimeSlotBundle?.compactionProvider ?? this.deps.compactionProviderProvider();
+		const runtimeSlot = runtimeSlotBundle !== void 0 ? createSessionRuntimeSlot(runtimeSlotBundle) : void 0;
 		const managed = await this.deps.sessionManager.resumeSession(sessionId, {
-			runtime: this.deps.runtimeProvider(),
+			runtime,
+			...runtimeSlot !== void 0 ? { runtimeSlot } : {},
 			tools: this.deps.toolsProvider(),
 			eventBus,
-			compactionProvider: this.deps.compactionProviderProvider(),
+			compactionProvider,
+			...compactionConfig !== void 0 ? { compactionConfig } : {},
 			...this.deps.approvalRuntime !== void 0 ? { approvalRuntime: this.deps.approvalRuntime } : {},
 			...this.deps.approvalRuntimeFactory !== void 0 ? { approvalRuntimeFactory: this.deps.approvalRuntimeFactory } : {},
 			...hookEngine !== void 0 ? { hookEngine } : {},
@@ -29454,6 +30326,21 @@ var DefaultSessionApplicationService = class {
 			...this.deps.questionRuntimeProvider !== void 0 ? { questionRuntime: this.deps.questionRuntimeProvider({ sessionId }) } : {},
 			...this.deps.logger !== void 0 ? { logger: this.deps.logger } : {}
 		});
+		const runtimeBundleProvider = this.deps.runtimeBundleProvider;
+		if (runtimeSlot !== void 0 && runtimeBundleProvider !== void 0 && managed.contextState.model !== runtimeSlot.current().model) {
+			const next = await runtimeBundleProvider({
+				sessionId,
+				model: managed.contextState.model
+			});
+			const nextConfig = next.compactionConfig ?? this.deps.compactionConfigProvider?.({
+				sessionId,
+				model: managed.contextState.model
+			});
+			runtimeSlot.replace(withCompactionConfigFallback(next, nextConfig));
+		} else if (runtimeSlot === void 0) managed.soulPlus.getTurnManager().setCompactionConfig(this.deps.compactionConfigProvider?.({
+			sessionId,
+			model: managed.contextState.model
+		}));
 		this.deps.sessionLifecycle?.onSessionCreated?.(managed);
 		return {
 			sessionId: managed.sessionId,
@@ -29557,6 +30444,15 @@ var DefaultSessionApplicationService = class {
 	async setPlanMode(sessionId, enabled) {
 		await this.getManaged(sessionId).sessionControl.setPlanMode(enabled);
 	}
+	getPlanFilePath(sessionId) {
+		return this.getManaged(sessionId).soulPlus.getPlanFilePath();
+	}
+	readCurrentPlan(sessionId) {
+		return this.getManaged(sessionId).soulPlus.readCurrentPlan();
+	}
+	clearCurrentPlan(sessionId) {
+		return this.getManaged(sessionId).soulPlus.clearCurrentPlan();
+	}
 	async setYolo(sessionId, enabled) {
 		const managed = this.getManaged(sessionId);
 		await managed.sessionControl.setYolo(enabled);
@@ -29568,9 +30464,31 @@ var DefaultSessionApplicationService = class {
 	}
 	async setModel(sessionId, model) {
 		const managed = this.getManaged(sessionId);
-		if (this.deps.rebuildRuntimeForModel !== void 0) {
+		const compactionConfig = this.deps.compactionConfigProvider?.({
+			sessionId,
+			model
+		});
+		if (this.deps.runtimeBundleProvider !== void 0) {
+			const next = await this.deps.runtimeBundleProvider({
+				sessionId,
+				model
+			});
+			managed.runtimeSlot.replace(withCompactionConfigFallback(next, compactionConfig));
+		} else if (this.deps.rebuildRuntimeForModel !== void 0) {
 			await this.deps.rebuildRuntimeForModel(sessionId, model);
-			return;
+			managed.runtimeSlot.replace({
+				model,
+				runtime: this.deps.runtimeProvider(),
+				compactionProvider: this.deps.compactionProviderProvider(),
+				compactionConfig
+			});
+		} else {
+			const current = managed.runtimeSlot.current();
+			managed.runtimeSlot.replace({
+				...current,
+				model,
+				compactionConfig
+			});
 		}
 		await managed.soulPlus.setModel(model);
 	}
@@ -30012,6 +30930,8 @@ const SUPPORTED_WIRE_METHODS = [
 	"session.listSkills",
 	"session.activateSkill",
 	"session.setPlanMode",
+	"session.getPlan",
+	"session.clearPlan",
 	"session.setYolo",
 	"session.setModel",
 	"session.setThinking",
@@ -30132,6 +31052,8 @@ function registerDefaultWireHandlers(deps) {
 		defaultModelProvider: () => deps.defaultModelProvider?.() ?? defaultModel,
 		...deps.defaultSystemPromptProvider !== void 0 ? { defaultSystemPromptProvider: deps.defaultSystemPromptProvider } : {},
 		compactionProviderProvider: () => deps.compactionProviderProvider?.() ?? compactionProvider,
+		...deps.compactionConfigProvider !== void 0 ? { compactionConfigProvider: deps.compactionConfigProvider } : {},
+		...deps.runtimeBundleProvider !== void 0 ? { runtimeBundleProvider: deps.runtimeBundleProvider } : {},
 		eventBusProvider: () => eventBusProvider?.() ?? eventBus,
 		...approvalRuntime !== void 0 ? { approvalRuntime } : {},
 		...approvalRuntimeFactory !== void 0 ? { approvalRuntimeFactory } : {},
@@ -30288,8 +31210,16 @@ function registerDefaultWireHandlers(deps) {
 			data: { ok: true }
 		});
 	});
-	router.registerMethod("session.prompt", "conversation", async (msg) => {
+	router.registerMethod("session.prompt", "conversation", async (msg, _transport, session) => {
 		const payload = SessionPromptSchema.parse(msg.data ?? {});
+		if (session?.contextState.model === "") return createWireResponse({
+			requestId: msg.id,
+			sessionId: msg.session_id,
+			error: {
+				code: -32001,
+				message: "No LLM configured. Run /login to authenticate."
+			}
+		});
 		let inputText;
 		let inputParts;
 		if (typeof payload.input === "string") {
@@ -30527,10 +31457,39 @@ function registerDefaultWireHandlers(deps) {
 	router.registerMethod("session.setPlanMode", "config", async (msg, _t, session) => {
 		const payload = z.object({ enabled: z.boolean() }).parse(msg.data ?? {});
 		await sessionApplication.setPlanMode(msg.session_id, payload.enabled);
+		const planPath = sessionApplication.getPlanFilePath(msg.session_id);
 		return createWireResponse({
 			requestId: msg.id,
 			sessionId: msg.session_id,
-			data: { ok: true }
+			data: {
+				ok: true,
+				...planPath !== null ? { plan_path: planPath } : {}
+			}
+		});
+	});
+	router.registerMethod("session.getPlan", "config", async (msg) => {
+		const current = await sessionApplication.readCurrentPlan(msg.session_id);
+		return createWireResponse({
+			requestId: msg.id,
+			sessionId: msg.session_id,
+			data: {
+				ok: true,
+				...current !== null ? {
+					plan: current.plan,
+					path: current.path
+				} : {}
+			}
+		});
+	});
+	router.registerMethod("session.clearPlan", "config", async (msg) => {
+		const path = await sessionApplication.clearCurrentPlan(msg.session_id);
+		return createWireResponse({
+			requestId: msg.id,
+			sessionId: msg.session_id,
+			data: {
+				ok: true,
+				...path !== null ? { path } : {}
+			}
 		});
 	});
 	router.registerMethod("session.setYolo", "config", async (msg, _t, session) => {
@@ -30740,7 +31699,10 @@ function createWireQuestionRuntime(reverse, sessionId) {
 			questions: req.questions.map((q) => ({
 				question: q.question,
 				...q.header !== void 0 ? { header: q.header } : {},
+				...q.body !== void 0 ? { body: q.body } : {},
 				multi_select: q.multiSelect ?? false,
+				...q.otherLabel !== void 0 ? { other_label: q.otherLabel } : {},
+				...q.otherDescription !== void 0 ? { other_description: q.otherDescription } : {},
 				options: q.options.map((o) => ({
 					label: o.label,
 					...o.description !== void 0 ? { description: o.description } : {}
@@ -31421,7 +32383,7 @@ function projectReplayState(records, sessionInitialized) {
 			case "step_end":
 				if (openStep !== null && openStep.stepUuid === r.uuid) {
 					openStep.hasStepEnd = true;
-					if (r.usage !== void 0) tokenCount += r.usage.input_tokens + r.usage.output_tokens;
+					if (r.usage !== void 0) tokenCount = r.usage.input_tokens + r.usage.output_tokens;
 				}
 				flushOpenStep();
 				break;
@@ -31688,6 +32650,15 @@ function bindTodoStore(tools, todoStore) {
 		return tool;
 	});
 }
+function normalizeRuntimeSlot(slot, fallback) {
+	const runtimeSlot = slot ?? createSessionRuntimeSlot(fallback);
+	const current = runtimeSlot.current();
+	if (current.compactionConfig === void 0 && fallback.compactionConfig !== void 0) runtimeSlot.replace({
+		...current,
+		compactionConfig: fallback.compactionConfig
+	});
+	return runtimeSlot;
+}
 var SessionManager = class {
 	paths;
 	producer;
@@ -31746,6 +32717,13 @@ var SessionManager = class {
 		const stateCache = new StateCache(this.paths.statePath(sessionId));
 		const todoStore = new SessionTodoStore(stateCache, []);
 		const sessionTools = bindTodoStore(options.tools, todoStore);
+		const runtimeSlot = normalizeRuntimeSlot(options.runtimeSlot, {
+			model: options.model,
+			runtime: options.runtime,
+			compactionProvider: options.compactionProvider,
+			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {}
+		});
+		const runtimeBundle = runtimeSlot.current();
 		const mainInitInput = {
 			type: "session_initialized",
 			agent_type: "main",
@@ -31796,7 +32774,8 @@ var SessionManager = class {
 			sessionId,
 			contextState,
 			sessionJournal,
-			runtime: options.runtime,
+			runtimeSlot,
+			runtime: runtimeBundle.runtime,
 			eventBus,
 			tools: sessionTools,
 			...options.enabledToolNames !== void 0 ? { enabledToolNames: options.enabledToolNames } : {},
@@ -31805,8 +32784,8 @@ var SessionManager = class {
 			...options.onShellDeliver !== void 0 ? { onShellDeliver: options.onShellDeliver } : {},
 			...options.skillManager !== void 0 ? { skillManager: options.skillManager } : {},
 			...options.questionRuntime !== void 0 ? { questionRuntime: options.questionRuntime } : {},
-			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {},
-			compactionProvider: options.compactionProvider,
+			...runtimeBundle.compactionConfig !== void 0 ? { compactionConfig: runtimeBundle.compactionConfig } : {},
+			compactionProvider: runtimeBundle.compactionProvider,
 			journalCapability: options.journalCapability ?? createWiredJournalCapability({
 				sessionDir,
 				journalWriter,
@@ -31838,13 +32817,15 @@ var SessionManager = class {
 			sessionControl: new DefaultSessionControl({
 				turnManager: turnManagerRef,
 				contextState,
-				sessionJournal
+				sessionJournal,
+				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled)
 			}),
 			contextState,
 			eventBus,
 			stateCache,
 			sessionJournal,
 			journalWriter,
+			runtimeSlot,
 			lifecycleStateMachine,
 			todoStore
 		};
@@ -31909,6 +32890,13 @@ var SessionManager = class {
 		const initialTodos = isClean ? 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, {
+			model: projected.model,
+			runtime: options.runtime,
+			compactionProvider: options.compactionProvider,
+			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {}
+		});
+		const runtimeBundle = runtimeSlot.current();
 		if (stateData !== null) await stateCache.write({
 			...stateData,
 			status: "active",
@@ -31923,6 +32911,7 @@ var SessionManager = class {
 		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,
@@ -31933,6 +32922,7 @@ var SessionManager = class {
 			...pickDescription !== void 0 ? { description: pickDescription } : {},
 			...pickArchived !== void 0 ? { archived: pickArchived } : {},
 			...pickLastModel !== void 0 ? { last_model: pickLastModel } : {},
+			...pickPlanSlug !== void 0 ? { plan_slug: pickPlanSlug } : {},
 			producer: replayResult.producer,
 			last_exit_code: "dirty"
 		};
@@ -31951,7 +32941,8 @@ var SessionManager = class {
 			sessionId,
 			contextState,
 			sessionJournal,
-			runtime: options.runtime,
+			runtimeSlot,
+			runtime: runtimeBundle.runtime,
 			eventBus,
 			tools: sessionTools,
 			...options.enabledToolNames !== void 0 ? { enabledToolNames: options.enabledToolNames } : {},
@@ -31960,8 +32951,8 @@ var SessionManager = class {
 			...options.onShellDeliver !== void 0 ? { onShellDeliver: options.onShellDeliver } : {},
 			...options.skillManager !== void 0 ? { skillManager: options.skillManager } : {},
 			...options.questionRuntime !== void 0 ? { questionRuntime: options.questionRuntime } : {},
-			...options.compactionConfig !== void 0 ? { compactionConfig: options.compactionConfig } : {},
-			compactionProvider: options.compactionProvider,
+			...runtimeBundle.compactionConfig !== void 0 ? { compactionConfig: runtimeBundle.compactionConfig } : {},
+			compactionProvider: runtimeBundle.compactionProvider,
 			journalCapability: options.journalCapability ?? createWiredJournalCapability({
 				sessionDir,
 				journalWriter,
@@ -31988,7 +32979,10 @@ var SessionManager = class {
 		await soulPlus.init();
 		turnManagerRef.setPermissionMode(effectivePermissionMode);
 		if (projected.thinkingLevel !== void 0) turnManagerRef.setThinkingLevel(projected.thinkingLevel);
-		if (projected.planMode) turnManagerRef.setPlanMode(true);
+		if (projected.planMode) {
+			await soulPlus.ensurePlanFilePath();
+			turnManagerRef.setPlanMode(true);
+		}
 		const notificationRecords = replayResult.records.filter((r) => r.type === "notification");
 		if (notificationRecords.length > 0) soulPlus.getNotificationManager().primeDedupeIndex(notificationRecords);
 		for (const agentId of lostSubagentIds) await soulPlus.emitNotification({
@@ -32007,13 +33001,15 @@ var SessionManager = class {
 			sessionControl: new DefaultSessionControl({
 				turnManager: turnManagerRef,
 				contextState,
-				sessionJournal
+				sessionJournal,
+				setPlanModeOverride: (enabled) => soulPlus.setPlanMode(enabled)
 			}),
 			contextState,
 			eventBus,
 			stateCache,
 			sessionJournal,
 			journalWriter,
+			runtimeSlot,
 			lifecycleStateMachine,
 			todoStore
 		};
@@ -32263,6 +33259,7 @@ var SessionManager = class {
 				...meta?.description !== void 0 ? { description: meta.description } : {},
 				...meta?.archived !== void 0 ? { archived: meta.archived } : {},
 				...meta?.last_model !== void 0 ? { model: meta.last_model } : {},
+				...meta?.plan_slug !== void 0 ? { plan_slug: meta.plan_slug } : {},
 				...currentPlanMode ? { plan_mode: true } : { plan_mode: false },
 				todos: cloneTodos(currentTodos),
 				last_exit_code: "clean"
@@ -39213,7 +40210,7 @@ async function loadAgentBlock(filePath, visited = /* @__PURE__ */ new Set()) {
 }
 async function readAgentBlock(absPath) {
 	const record = asRecord$1(load$2(await readFile(absPath, "utf-8")), `agent yaml root (${absPath})`);
-	if (isRecord$4(record["agent"])) throw new Error(`Invalid agent YAML: ${absPath} uses an unsupported 'agent:' wrapper. Use TS-native root fields.`);
+	if (isRecord$5(record["agent"])) throw new Error(`Invalid agent YAML: ${absPath} uses an unsupported 'agent:' wrapper. Use TS-native root fields.`);
 	return normalizeNativeAgent(record, absPath);
 }
 function normalizeNativeAgent(raw, source) {
@@ -39348,11 +40345,11 @@ async function getBundledAgentYamlPath() {
 	} catch {}
 	throw new Error(`getBundledAgentYamlPath: unable to locate bundled agent.yaml. Checked: ${candidates.join(", ")}`);
 }
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asRecord$1(value, label) {
-	if (!isRecord$4(value)) throw new Error(`Invalid agent YAML: ${label} must be a mapping`);
+	if (!isRecord$5(value)) throw new Error(`Invalid agent YAML: ${label} must be a mapping`);
 	return value;
 }
 function asOptionalRecord(value, label) {
@@ -40653,6 +41650,10 @@ const ThinkingConfigSchema = z.object({
 	]).optional(),
 	effort: z.string().optional()
 });
+const LoopControlSchema = z.object({
+	reservedContextSize: z.number().int().min(0).optional(),
+	compactionTriggerRatio: z.number().min(.5).max(.99).optional()
+});
 const MoonshotServiceConfigSchema = z.object({
 	baseUrl: z.string().optional(),
 	apiKey: z.string().optional(),
@@ -40680,6 +41681,7 @@ const KimiConfigSchema = z.object({
 	services: ServicesConfigSchema.optional(),
 	mergeAllAvailableSkills: z.boolean().optional(),
 	showThinkingStream: z.boolean().optional(),
+	loopControl: LoopControlSchema.optional(),
 	raw: z.record(z.string(), z.unknown()).optional()
 });
 //#endregion
@@ -40861,6 +41863,12 @@ function serviceToToml(service, rawService) {
 	if (service?.customHeaders !== void 0) out["custom_headers"] = service.customHeaders;
 	return out;
 }
+function loopControlToToml(loopControl, rawLoopControl) {
+	const out = cloneRecord(rawLoopControl);
+	setDefined(out, "reserved_context_size", loopControl.reservedContextSize);
+	setDefined(out, "compaction_trigger_ratio", loopControl.compactionTriggerRatio);
+	return out;
+}
 function configToTomlData(config) {
 	const out = cloneRecord(config.raw);
 	setDefined(out, "default_provider", config.defaultProvider);
@@ -40885,6 +41893,7 @@ function configToTomlData(config) {
 	if (config.services?.moonshotSearch !== void 0) services["moonshot_search"] = serviceToToml(config.services.moonshotSearch, services["moonshot_search"]);
 	if (config.services?.moonshotFetch !== void 0) services["moonshot_fetch"] = serviceToToml(config.services.moonshotFetch, services["moonshot_fetch"]);
 	if (Object.keys(services).length > 0) out["services"] = services;
+	if (config.loopControl !== void 0) out["loop_control"] = loopControlToToml(config.loopControl, out["loop_control"]);
 	return out;
 }
 //#endregion
@@ -77282,7 +78291,7 @@ function createVideoUploader(provider) {
 }
 function resolveDefaultSoulPlusDefaultModel(options) {
 	const defaultModel = options.defaultModel ?? options.modelAlias ?? options.kimiConfig?.defaultModel;
-	if (defaultModel === void 0 || defaultModel.length === 0) throw new Error("createDefaultSoulPlusWireClient: defaultModel/modelAlias is required when config has no defaultModel");
+	if (defaultModel === void 0 || defaultModel.length === 0) return "";
 	return defaultModel;
 }
 function getDefaultSoulPlusMaxContextSize(options, defaultModel) {
@@ -77298,6 +78307,12 @@ async function createDefaultSoulPlusRuntimeBundle(options) {
 		maxContextSize
 	};
 	if (options.runtime !== void 0 || options.compactionProvider !== void 0) throw new Error("createDefaultSoulPlusWireClient: runtime and compactionProvider must be provided together");
+	if (defaultModel.length === 0) return {
+		runtime: createRuntime({ kosong: new UnconfiguredKosongAdapter() }),
+		compactionProvider: new UnconfiguredCompactionProvider(),
+		defaultModel,
+		maxContextSize
+	};
 	if (options.kimiConfig === void 0) throw new Error("createDefaultSoulPlusWireClient: provide either runtime+compactionProvider or kimiConfig");
 	const provider = await createProviderFromConfig(options.kimiConfig, defaultModel, {
 		...options.oauthResolver !== void 0 ? { oauthResolver: options.oauthResolver } : {},
@@ -77316,6 +78331,17 @@ async function createDefaultSoulPlusRuntimeBundle(options) {
 		...videoUploader !== void 0 ? { videoUploader } : {}
 	};
 }
+const LLM_NOT_CONFIGURED_MESSAGE = "No LLM configured. Run /login to authenticate.";
+var UnconfiguredKosongAdapter = class {
+	async chat(_params) {
+		throw new LLMNotSetError(LLM_NOT_CONFIGURED_MESSAGE);
+	}
+};
+var UnconfiguredCompactionProvider = class {
+	async run() {
+		throw new LLMNotSetError(LLM_NOT_CONFIGURED_MESSAGE);
+	}
+};
 //#endregion
 //#region ../../packages/kaos/src/errors.ts
 /**
@@ -90347,7 +91373,7 @@ function tokenFromWire(wire) {
 * Load semantics: missing file → undefined. Corrupt JSON / wrong shape →
 * undefined (never throws). Callers treat undefined as "no token stored".
 */
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var FileTokenStorage = class {
@@ -90383,7 +91409,7 @@ var FileTokenStorage = class {
 		} catch {
 			return;
 		}
-		if (!isRecord$3(parsed)) return void 0;
+		if (!isRecord$4(parsed)) return void 0;
 		return tokenFromWire(parsed);
 	}
 	async save(name, token) {
@@ -90522,7 +91548,7 @@ const RETRYABLE_STATUSES = new Set([
 	503,
 	504
 ]);
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function pickErrorDetail(data) {
@@ -90576,7 +91602,7 @@ async function postForm(url, params, deviceHeaders, options) {
 		const text = await response.text();
 		if (text.length > 0) {
 			const parsed = JSON.parse(text);
-			if (isRecord$2(parsed)) data = parsed;
+			if (isRecord$3(parsed)) data = parsed;
 		}
 	} catch {}
 	return {
@@ -92211,9 +93237,9 @@ function parseManagedUsagePayload(payload) {
 		const item = rawLimits[idx];
 		if (!item || typeof item !== "object") continue;
 		const detailRaw = item["detail"];
-		const detail = isRecord$1(detailRaw) ? detailRaw : item;
+		const detail = isRecord$2(detailRaw) ? detailRaw : item;
 		const windowRaw = item["window"];
-		const row = toUsageRow(detail, limitLabel(item, detail, isRecord$1(windowRaw) ? windowRaw : {}, idx));
+		const row = toUsageRow(detail, limitLabel(item, detail, isRecord$2(windowRaw) ? windowRaw : {}, idx));
 		if (row !== null) limits.push(row);
 	}
 	return {
@@ -92222,7 +93248,7 @@ function parseManagedUsagePayload(payload) {
 	};
 }
 function toUsageRow(raw, defaultLabel) {
-	if (!isRecord$1(raw)) return null;
+	if (!isRecord$2(raw)) return null;
 	const limit = toInt(raw["limit"]);
 	let used = toInt(raw["used"]);
 	if (used === null) {
@@ -92316,7 +93342,7 @@ function toInt(value) {
 	}
 	return null;
 }
-function isRecord$1(v) {
+function isRecord$2(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 async function fetchManagedUsage(url, accessToken, opts = {}) {
@@ -92382,11 +93408,11 @@ function capabilitiesForModel(model) {
 function defaultBaseUrl(baseUrl) {
 	return (baseUrl ?? kimiCodeBaseUrl()).replace(/\/+$/, "");
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toModelInfo(item) {
-	if (!isRecord(item) || typeof item["id"] !== "string" || item["id"].length === 0) return;
+	if (!isRecord$1(item) || typeof item["id"] !== "string" || item["id"].length === 0) return;
 	const displayName = item["display_name"];
 	return {
 		id: item["id"],
@@ -92406,7 +93432,7 @@ async function fetchManagedKimiCodeModels(options) {
 	} });
 	if (!response.ok) throw new Error(`Failed to list Kimi Code models (HTTP ${response.status}).`);
 	const payload = await response.json();
-	if (!isRecord(payload) || !Array.isArray(payload["data"])) throw new Error(`Unexpected models response for ${baseUrl}.`);
+	if (!isRecord$1(payload) || !Array.isArray(payload["data"])) throw new Error(`Unexpected models response for ${baseUrl}.`);
 	return payload["data"].map((item) => toModelInfo(item)).filter((item) => item !== void 0);
 }
 function applyManagedKimiCodeConfig(config, options) {
@@ -92730,6 +93756,7 @@ var DefaultSoulPlusOAuthServiceImpl = class {
 		this.oauthResolver = async (providerName) => this.managerFor(providerName).ensureFresh();
 	}
 	prepareRequiredManagers() {
+		if (this.options.forceManagedKimiCodeOAuth === true) this.managerFor(KIMI_CODE_PROVIDER_NAME);
 		const selected = this.resolveSelectedProvider();
 		if (selected.selectedProviderNeedsOAuth && selected.providerName !== "managed:kimi-code") throw new Error(`OAuth provider "${selected.providerName}" is not yet supported. Only managed:kimi-code device-code OAuth is wired for the default SoulPlus host.`);
 		if (selected.providerName === "managed:kimi-code" && selected.selectedProviderNeedsOAuth) this.managerFor(KIMI_CODE_PROVIDER_NAME);
@@ -92757,6 +93784,7 @@ var DefaultSoulPlusOAuthServiceImpl = class {
 			pathConfig: this.options.pathConfig,
 			accessToken
 		});
+		await this.options.onConfigProvisioned?.(loadConfig({ pathConfig: this.options.pathConfig }));
 		return {
 			provider_name: name,
 			ok: true
@@ -93330,6 +94358,12 @@ var KimiWireClient = class {
 	setPlanMode(sessionId, enabled) {
 		return this.request("session.setPlanMode", { enabled }, { sessionId });
 	}
+	getPlan(sessionId) {
+		return this.request("session.getPlan", {}, { sessionId });
+	}
+	clearPlan(sessionId) {
+		return this.request("session.clearPlan", {}, { sessionId });
+	}
 	setYolo(sessionId, enabled) {
 		return this.request("session.setYolo", { enabled }, { sessionId });
 	}
@@ -93547,6 +94581,8 @@ async function startCoreWireServer(options) {
 		...options.runtimeProvider !== void 0 ? { runtimeProvider: options.runtimeProvider } : {},
 		...options.defaultModelProvider !== void 0 ? { defaultModelProvider: options.defaultModelProvider } : {},
 		...options.compactionProviderProvider !== void 0 ? { compactionProviderProvider: options.compactionProviderProvider } : {},
+		...options.compactionConfigProvider !== void 0 ? { compactionConfigProvider: options.compactionConfigProvider } : {},
+		...options.runtimeBundleProvider !== void 0 ? { runtimeBundleProvider: options.runtimeBundleProvider } : {},
 		...options.rebuildRuntimeForModel !== void 0 ? { rebuildRuntimeForModel: options.rebuildRuntimeForModel } : {},
 		...options.defaultSystemPromptProvider !== void 0 ? { defaultSystemPromptProvider: options.defaultSystemPromptProvider } : {},
 		pathConfig: options.pathConfig,
@@ -93630,38 +94666,71 @@ async function createInProcessWireClient(options) {
 }
 //#endregion
 //#region ../../packages/kimi-sdk/src/default-soul-plus-wire-client.ts
+const DEFAULT_RESERVED_CONTEXT_SIZE = 5e4;
+const DEFAULT_RESERVED_CONTEXT_FRACTION = .25;
 async function createDefaultSoulPlusWireClient(options) {
 	const pathConfig = options.pathConfig ?? new PathConfig();
-	const kimiConfig = options.kimiConfig ?? loadConfig({
+	const loadHostConfig = () => options.kimiConfig ?? loadConfig({
 		pathConfig,
 		workspaceDir: options.workspaceDir
 	});
-	const requestedDefaultModel = resolveDefaultSoulPlusDefaultModel({
-		...options,
-		kimiConfig
-	});
-	const effectiveConfig = resolveEffectiveConfig(kimiConfig, { requestedModel: requestedDefaultModel });
-	const defaultModel = resolveDefaultSoulPlusDefaultModel({
-		...options,
-		kimiConfig: effectiveConfig,
-		defaultModel: requestedDefaultModel
-	});
-	const authService = createDefaultSoulPlusOAuthService({
+	const resolveHostConfig = (config) => {
+		const requestedDefaultModel = resolveDefaultSoulPlusDefaultModel({
+			...options,
+			kimiConfig: config
+		});
+		const effective = resolveEffectiveConfig(config, { requestedModel: requestedDefaultModel });
+		return {
+			effectiveConfig: effective,
+			defaultModel: resolveDefaultSoulPlusDefaultModel({
+				...options,
+				kimiConfig: effective,
+				defaultModel: requestedDefaultModel
+			})
+		};
+	};
+	let { effectiveConfig, defaultModel } = resolveHostConfig(loadHostConfig());
+	let authService;
+	let activeVideoUploader;
+	let activeDefaultModel = defaultModel;
+	let activeMaxContextSize = 2e5;
+	const buildRuntimeBundle = async (model) => {
+		const next = await createDefaultSoulPlusRuntimeBundle({
+			...options,
+			kimiConfig: effectiveConfig,
+			defaultModel: model,
+			oauthResolver: authService.oauthResolver,
+			deferOAuth: true,
+			tokenRefresher: authService
+		});
+		activeVideoUploader = next.videoUploader;
+		return {
+			model: next.defaultModel,
+			runtime: next.runtime,
+			compactionProvider: next.compactionProvider,
+			compactionConfig: buildCompactionConfig(effectiveConfig, next.defaultModel, next.maxContextSize)
+		};
+	};
+	const reloadConfigFromDisk = async () => {
+		if (options.kimiConfig !== void 0) return;
+		const resolved = resolveHostConfig(loadHostConfig());
+		effectiveConfig = resolved.effectiveConfig;
+		defaultModel = resolved.defaultModel;
+		activeDefaultModel = defaultModel;
+		activeMaxContextSize = getDefaultSoulPlusMaxContextSize({
+			kimiConfig: effectiveConfig,
+			defaultModel
+		}, defaultModel);
+	};
+	authService = createDefaultSoulPlusOAuthService({
 		kimiConfig: effectiveConfig,
 		modelAlias: defaultModel,
-		pathConfig
-	});
-	const initialRuntimeBundle = await createDefaultSoulPlusRuntimeBundle({
-		...options,
-		kimiConfig: effectiveConfig,
-		defaultModel,
-		oauthResolver: authService.oauthResolver,
-		deferOAuth: true,
-		tokenRefresher: authService
+		pathConfig,
+		forceManagedKimiCodeOAuth: defaultModel.length === 0,
+		onConfigProvisioned: reloadConfigFromDisk
 	});
-	let activeRuntime = initialRuntimeBundle.runtime;
-	let activeCompactionProvider = initialRuntimeBundle.compactionProvider;
-	let activeDefaultModel = defaultModel;
+	const initialRuntimeBundle = await buildRuntimeBundle(defaultModel);
+	activeMaxContextSize = initialRuntimeBundle.compactionConfig?.maxContextSize ?? 2e5;
 	const defaults = await prepareDefaultSoulPlusSessionDefaults({
 		workspaceDir: options.workspaceDir,
 		pathConfig
@@ -93679,41 +94748,27 @@ async function createDefaultSoulPlusWireClient(options) {
 		enabledToolNames: defaults.enabledToolNames,
 		webSearchProvider: webProviders.webSearchProvider,
 		urlFetcher: webProviders.urlFetcher,
-		...initialRuntimeBundle.videoUploader !== void 0 ? { videoUploader: initialRuntimeBundle.videoUploader } : {}
+		...activeVideoUploader !== void 0 ? { videoUploader: activeVideoUploader } : {}
 	});
 	const backgroundManager = builtin.backgroundManager;
 	const handle = await createInProcessWireClient({
 		pathConfig,
-		runtime: activeRuntime,
-		runtimeProvider: () => activeRuntime,
-		compactionProvider: activeCompactionProvider,
-		compactionProviderProvider: () => activeCompactionProvider,
+		runtime: initialRuntimeBundle.runtime,
+		compactionProvider: initialRuntimeBundle.compactionProvider,
+		runtimeBundleProvider: ({ model }) => buildRuntimeBundle(model),
 		workspaceDir: options.workspaceDir,
 		defaultModel: activeDefaultModel,
 		defaultModelProvider: () => activeDefaultModel,
 		enabledToolNames: defaults.enabledToolNames,
 		enableWiredApprovals: true,
-		rebuildRuntimeForModel: async (_sessionId, model) => {
-			const next = await createDefaultSoulPlusRuntimeBundle({
-				...options,
-				kimiConfig: effectiveConfig,
-				defaultModel: model,
-				oauthResolver: authService.oauthResolver,
-				deferOAuth: true,
-				tokenRefresher: authService
-			});
-			activeRuntime = next.runtime;
-			activeCompactionProvider = next.compactionProvider;
-			activeDefaultModel = next.defaultModel;
-		},
 		defaultSystemPromptProvider: () => defaults.systemPrompt,
 		tools: builtin.tools,
 		skillManager: defaults.skillManager,
 		...defaults.agentTypeRegistry !== void 0 ? { agentTypeRegistry: defaults.agentTypeRegistry } : {},
 		authService,
 		modelsProvider: () => ({
-			models: Object.keys(kimiConfig.models ?? {}),
-			default_model: effectiveConfig.defaultModel
+			models: Object.keys(effectiveConfig.models ?? {}),
+			...activeDefaultModel.length > 0 ? { default_model: activeDefaultModel } : {}
 		}),
 		configProvider: () => effectiveConfig,
 		...options.logger !== void 0 ? { logger: options.logger } : {},
@@ -93726,14 +94781,30 @@ async function createDefaultSoulPlusWireClient(options) {
 			await handle.dispose();
 		},
 		workspaceDir: options.workspaceDir,
-		defaultModel,
-		maxContextSize: initialRuntimeBundle.maxContextSize,
-		defaultThinking: effectiveConfig.defaultThinking ?? false,
-		defaultYolo: effectiveConfig.yolo ?? effectiveConfig.defaultYolo ?? false,
-		defaultPlanMode: effectiveConfig.planMode ?? effectiveConfig.defaultPlanMode ?? false,
-		theme: effectiveConfig.theme === "light" ? "light" : "dark",
-		defaultEditor: effectiveConfig.defaultEditor ?? "",
-		availableModels: effectiveConfig.models ?? {},
+		get defaultModel() {
+			return activeDefaultModel;
+		},
+		get maxContextSize() {
+			return activeMaxContextSize;
+		},
+		get defaultThinking() {
+			return effectiveConfig.defaultThinking ?? false;
+		},
+		get defaultYolo() {
+			return effectiveConfig.yolo ?? effectiveConfig.defaultYolo ?? false;
+		},
+		get defaultPlanMode() {
+			return effectiveConfig.planMode ?? effectiveConfig.defaultPlanMode ?? false;
+		},
+		get theme() {
+			return effectiveConfig.theme === "light" ? "light" : "dark";
+		},
+		get defaultEditor() {
+			return effectiveConfig.defaultEditor ?? "";
+		},
+		get availableModels() {
+			return effectiveConfig.models ?? {};
+		},
 		async syncSessionRuntime(sessionId, syncOptions = {}) {
 			if (syncOptions.plan === true) await handle.client.setPlanMode(sessionId, true);
 			if (syncOptions.yolo === true) await handle.client.setYolo(sessionId, true);
@@ -93745,6 +94816,21 @@ async function createDefaultSoulPlusWireClient(options) {
 		}
 	};
 }
+function buildCompactionConfig(config, model, maxContextSize) {
+	const loop = config.loopControl;
+	const resolvedMaxContextSize = config.models?.[model] !== void 0 ? getDefaultSoulPlusMaxContextSize({
+		kimiConfig: config,
+		defaultModel: model
+	}, model) : maxContextSize;
+	return {
+		maxContextSize: resolvedMaxContextSize,
+		...loop?.compactionTriggerRatio !== void 0 ? { triggerRatio: loop.compactionTriggerRatio } : {},
+		reservedContextSize: loop?.reservedContextSize ?? defaultReservedContextSize(resolvedMaxContextSize)
+	};
+}
+function defaultReservedContextSize(maxContextSize) {
+	return Math.max(0, Math.min(DEFAULT_RESERVED_CONTEXT_SIZE, Math.floor(maxContextSize * DEFAULT_RESERVED_CONTEXT_FRACTION)));
+}
 function inferUserAgent(defaultHeaders) {
 	return defaultHeaders?.["User-Agent"] ?? "KimiCLI/unknown";
 }
@@ -94504,6 +95590,49 @@ async function createKimiAgent() {
 	};
 }
 //#endregion
+//#region src/utils/history/input-history.ts
+/**
+* User input history persistence — JSONL file with `{"content": "..."}` per line.
+*
+* Mirrors the Python implementation in `kimi_cli/ui/shell/prompt.py`:
+* - One JSON object per line (`_HistoryEntry { content }`)
+* - Append-only writes
+* - Skip empty entries
+* - Skip when same as last entry (consecutive deduplication)
+* - Tolerate corrupt lines: log + skip, do not abort load
+*/
+async function loadInputHistory(file) {
+	let raw;
+	try {
+		raw = await readFile(file, "utf-8");
+	} catch (err) {
+		if (err.code === "ENOENT") return [];
+		throw err;
+	}
+	const entries = [];
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (typeof parsed === "object" && parsed !== null && typeof parsed.content === "string") entries.push({ content: parsed.content });
+		} catch {}
+	}
+	return entries;
+}
+/**
+* Append an entry to the history file. Returns true if written, false if
+* skipped (empty or equal to `lastContent`).
+*/
+async function appendInputHistory(file, text, lastContent) {
+	const content = text.trim();
+	if (content.length === 0) return false;
+	if (content === lastContent) return false;
+	await mkdir(dirname(file), { recursive: true });
+	await appendFile(file, `${JSON.stringify({ content })}\n`, "utf-8");
+	return true;
+}
+//#endregion
 //#region src/utils/process/external-editor.ts
 /**
 * External-editor helper — spawn $VISUAL / $EDITOR (or a configured
@@ -94552,99 +95681,6 @@ function shellQuote(path) {
 	return `'${path.replace(/'/g, "'\\''")}'`;
 }
 //#endregion
-//#region src/utils/history/input-history.ts
-/**
-* User input history persistence — JSONL file with `{"content": "..."}` per line.
-*
-* Mirrors the Python implementation in `kimi_cli/ui/shell/prompt.py`:
-* - One JSON object per line (`_HistoryEntry { content }`)
-* - Append-only writes
-* - Skip empty entries
-* - Skip when same as last entry (consecutive deduplication)
-* - Tolerate corrupt lines: log + skip, do not abort load
-*/
-async function loadInputHistory(file) {
-	let raw;
-	try {
-		raw = await readFile(file, "utf-8");
-	} catch (err) {
-		if (err.code === "ENOENT") return [];
-		throw err;
-	}
-	const entries = [];
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trim();
-		if (trimmed.length === 0) continue;
-		try {
-			const parsed = JSON.parse(trimmed);
-			if (typeof parsed === "object" && parsed !== null && typeof parsed.content === "string") entries.push({ content: parsed.content });
-		} catch {}
-	}
-	return entries;
-}
-/**
-* Append an entry to the history file. Returns true if written, false if
-* skipped (empty or equal to `lastContent`).
-*/
-async function appendInputHistory(file, text, lastContent) {
-	const content = text.trim();
-	if (content.length === 0) return false;
-	if (content === lastContent) return false;
-	await mkdir(dirname(file), { recursive: true });
-	await appendFile(file, `${JSON.stringify({ content })}\n`, "utf-8");
-	return true;
-}
-//#endregion
-//#region src/tui/input/image-placeholder.ts
-const PLACEHOLDER_REGEX = /\[image #(\d+) \((\d+)×(\d+)\)\]/g;
-function extractImageAttachments(text, store) {
-	const parts = [];
-	const cleanedSegments = [];
-	const attachmentIds = [];
-	let cursor = 0;
-	let hasImages = false;
-	PLACEHOLDER_REGEX.lastIndex = 0;
-	let match;
-	while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
-		const [literal, idStr] = match;
-		if (idStr === void 0) continue;
-		const id = Number.parseInt(idStr, 10);
-		const attachment = store.get(id);
-		if (attachment === void 0) continue;
-		const before = text.slice(cursor, match.index);
-		pushText(parts, before);
-		cleanedSegments.push(before);
-		parts.push(buildImagePart(attachment));
-		attachmentIds.push(id);
-		hasImages = true;
-		cursor = match.index + literal.length;
-	}
-	const tail = text.slice(cursor);
-	pushText(parts, tail);
-	cleanedSegments.push(tail);
-	return {
-		parts: hasImages ? parts : [],
-		hasImages,
-		cleanedText: cleanedSegments.join("").replaceAll(/\s+/g, " ").trim(),
-		attachmentIds
-	};
-}
-function pushText(parts, segment) {
-	if (segment.length === 0) return;
-	if (segment.trim().length === 0) return;
-	parts.push({
-		type: "text",
-		text: segment
-	});
-}
-function buildImagePart(att) {
-	const base64 = Buffer.from(att.bytes).toString("base64");
-	return {
-		type: "image_url",
-		image_url: { url: `data:${att.mime};base64,${base64}` }
-	};
-}
-//#endregion
 //#region src/tui/components/messages/assistant-message.ts
 const BULLET$1 = "● ";
 const INDENT$2 = "  ";
@@ -95483,6 +96519,56 @@ 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;
+function extractImageAttachments(text, store) {
+	const parts = [];
+	const cleanedSegments = [];
+	const attachmentIds = [];
+	let cursor = 0;
+	let hasImages = false;
+	PLACEHOLDER_REGEX.lastIndex = 0;
+	let match;
+	while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
+		const [literal, idStr] = match;
+		if (idStr === void 0) continue;
+		const id = Number.parseInt(idStr, 10);
+		const attachment = store.get(id);
+		if (attachment === void 0) continue;
+		const before = text.slice(cursor, match.index);
+		pushText(parts, before);
+		cleanedSegments.push(before);
+		parts.push(buildImagePart(attachment));
+		attachmentIds.push(id);
+		hasImages = true;
+		cursor = match.index + literal.length;
+	}
+	const tail = text.slice(cursor);
+	pushText(parts, tail);
+	cleanedSegments.push(tail);
+	return {
+		parts: hasImages ? parts : [],
+		hasImages,
+		cleanedText: cleanedSegments.join("").replaceAll(/\s+/g, " ").trim(),
+		attachmentIds
+	};
+}
+function pushText(parts, segment) {
+	if (segment.length === 0) return;
+	if (segment.trim().length === 0) return;
+	parts.push({
+		type: "text",
+		text: segment
+	});
+}
+function buildImagePart(att) {
+	const base64 = Buffer.from(att.bytes).toString("base64");
+	return {
+		type: "image_url",
+		image_url: { url: `data:${att.mime};base64,${base64}` }
+	};
+}
+//#endregion
 //#region src/utils/git/git-ls-files.ts
 /**
 * Git-aware file listing + relevance signals with a short-TTL cache.
@@ -95679,6 +96765,38 @@ function openUrl(url) {
 	]] : ["xdg-open", [url]];
 	execFile(args[0], args[1], () => {});
 }
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readAvailableModels(config) {
+	if (!isRecord(config) || !isRecord(config["models"])) return {};
+	const out = {};
+	for (const [alias, raw] of Object.entries(config["models"])) {
+		if (!isRecord(raw) || typeof raw["provider"] !== "string" || typeof raw["model"] !== "string") continue;
+		out[alias] = {
+			provider: raw["provider"],
+			model: raw["model"],
+			...typeof raw["maxContextSize"] === "number" ? { maxContextSize: raw["maxContextSize"] } : {},
+			...Array.isArray(raw["capabilities"]) ? { capabilities: raw["capabilities"].filter((v) => typeof v === "string") } : {}
+		};
+	}
+	return out;
+}
+async function refreshConfigAfterLogin(client, ctx) {
+	const [modelsResponse, configResponse] = await Promise.all([client.getModels(), client.getConfig()]);
+	const config = isRecord(configResponse.config) ? configResponse.config : {};
+	const availableModels = readAvailableModels(config);
+	const defaultModel = modelsResponse.default_model ?? (typeof config["defaultModel"] === "string" ? config["defaultModel"] : void 0);
+	const selected = defaultModel !== void 0 ? availableModels[defaultModel] : void 0;
+	const patch = {
+		availableModels,
+		...defaultModel !== void 0 ? { model: defaultModel } : {},
+		...selected?.maxContextSize !== void 0 ? { maxContextTokens: selected.maxContextSize } : {},
+		...typeof config["defaultThinking"] === "boolean" ? { thinking: config["defaultThinking"] } : {}
+	};
+	if (defaultModel !== void 0 && typeof ctx.appState.sessionId === "string" && ctx.appState.sessionId.length > 0) await client.setModel(ctx.appState.sessionId, defaultModel);
+	ctx.setAppState(patch);
+}
 function createAuthCommands(deps = {}) {
 	const providerName = deps.defaultProviderName ?? "managed:kimi-code";
 	return [{
@@ -95708,6 +96826,11 @@ function createAuthCommands(deps = {}) {
 			});
 			try {
 				await deps.client.authLogin(providerName);
+				try {
+					await refreshConfigAfterLogin(deps.client, ctx);
+				} catch (refreshError) {
+					return ok$2(`Login successful, but failed to refresh config: ${refreshError instanceof Error ? refreshError.message : String(refreshError)}`);
+				}
 				return {
 					type: "ok",
 					message: "✓ Login successful!",
@@ -95814,8 +96937,8 @@ const shellCommands = [
 			const newTitle = trimmed.slice(0, 200);
 			try {
 				await ctx.client.rename(ctx.appState.sessionId, newTitle);
-			} catch (err) {
-				return ok$1(`Failed to set title: ${err instanceof Error ? err.message : String(err)}`);
+			} catch (error) {
+				return ok$1(`Failed to set title: ${error instanceof Error ? error.message : String(error)}`);
 			}
 			return ok$1(`Session title set to: ${newTitle}`);
 		}
@@ -95841,12 +96964,23 @@ const shellCommands = [
 		description: "Toggle plan mode",
 		mode: "both",
 		async execute(args, ctx) {
+			const subcmd = args.trim().toLowerCase();
+			if (subcmd === "view") {
+				const res = await ctx.client.getPlan(ctx.appState.sessionId);
+				if (res.plan !== void 0 && res.plan.length > 0) return ok$1(res.plan);
+				return ok$1("No plan file found for this session.");
+			}
+			if (subcmd === "clear") {
+				await ctx.client.clearPlan(ctx.appState.sessionId);
+				return ok$1("Plan cleared.");
+			}
 			let enabled;
-			if (args === "on") enabled = true;
-			else if (args === "off") enabled = false;
+			if (subcmd === "on") enabled = true;
+			else if (subcmd === "off") enabled = false;
 			else enabled = !ctx.appState.planMode;
-			await ctx.client.setPlanMode(ctx.appState.sessionId, enabled);
+			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"}`);
 		}
 	},
@@ -96008,6 +97142,40 @@ function createDefaultRegistry(authDeps) {
 * Custom editor extending pi-tui Editor with app-level keybindings.
 */
 const ANSI_SGR = /\x1b\[[0-9;]*m/g;
+const KITTY_CSI_U = /^\x1b\[(\d+);(\d+)((?::\d+)*)u$/;
+const CAPS_LOCK_BIT = 64;
+const CTRL_BIT = 4;
+const SHIFT_BIT = 1;
+/**
+* Workaround for a pi-tui bug that surfaces when Kitty keyboard protocol
+* is active AND caps_lock is on. In that state terminals emit, e.g.,
+* `ESC[68;69u` for ctrl+d (codepoint=68=`D`, modifier=ctrl|caps_lock).
+* pi-tui's `matchesKittySequence` masks `caps_lock` out of the *modifier*
+* but leaves the *codepoint* capitalised, so `matchesKey(data, "ctrl+d")`
+* (which expects codepoint=100=`d`) fails and every ctrl-shortcut is
+* silently dropped.
+*
+* We rewrite the sequence back to its unlocked form before dispatching,
+* but only when ctrl is held and shift is not — i.e. exactly the
+* `ctrl+<letter>` case. Plain uppercase (caps_lock only, no ctrl) and
+* explicit ctrl+shift+<letter> are left alone.
+*/
+function normalizeCapsLockedCtrl(data) {
+	const m = data.match(KITTY_CSI_U);
+	if (m === null) return data;
+	const codepoint = Number(m[1]);
+	const modifierPlus1 = Number(m[2]);
+	const tail = m[3] ?? "";
+	if (!Number.isFinite(codepoint) || !Number.isFinite(modifierPlus1)) return data;
+	const modifier = modifierPlus1 - 1;
+	if ((modifier & CAPS_LOCK_BIT) === 0) return data;
+	if ((modifier & CTRL_BIT) === 0) return data;
+	if ((modifier & SHIFT_BIT) !== 0) return data;
+	if (codepoint < 65 || codepoint > 90) return data;
+	const loweredCodepoint = codepoint + 32;
+	const strippedModifier = (modifier & ~CAPS_LOCK_BIT) + 1;
+	return `\x1b[${String(loweredCodepoint)};${String(strippedModifier)}${tail}u`;
+}
 /** Convert a visible-char index (ANSI-stripped) back to an index into the raw ANSI-bearing string. */
 function mapVisibleIdxToRaw(line, visibleIdx) {
 	let visibleCount = 0;
@@ -96073,51 +97241,52 @@ var CustomEditor = class extends Editor {
 		return lines;
 	}
 	handleInput(data) {
-		if (matchesKey(data, process.platform === "win32" ? "alt+v" : Key.ctrl("v")) && this.onPasteImage !== void 0) {
+		const normalized = normalizeCapsLockedCtrl(data);
+		if (matchesKey(normalized, process.platform === "win32" ? "alt+v" : Key.ctrl("v")) && this.onPasteImage !== void 0) {
 			const handler = this.onPasteImage;
 			handler().then((handled) => {
-				if (!handled) super.handleInput.call(this, data);
+				if (!handled) super.handleInput.call(this, normalized);
 			});
 			return;
 		}
-		if (matchesKey(data, Key.ctrl("d"))) {
+		if (matchesKey(normalized, Key.ctrl("d"))) {
 			if (this.getText().length === 0) {
 				this.onCtrlD?.();
 				return;
 			}
 		}
-		if (matchesKey(data, Key.ctrl("c"))) {
+		if (matchesKey(normalized, Key.ctrl("c"))) {
 			this.onCtrlC?.();
 			return;
 		}
-		if (matchesKey(data, Key.ctrl("g"))) {
+		if (matchesKey(normalized, Key.ctrl("g"))) {
 			this.onOpenExternalEditor?.();
 			return;
 		}
-		if (matchesKey(data, Key.ctrl("o"))) {
+		if (matchesKey(normalized, Key.ctrl("o"))) {
 			this.onToggleToolExpand?.();
 			return;
 		}
-		if (matchesKey(data, Key.ctrl("s"))) {
+		if (matchesKey(normalized, Key.ctrl("s"))) {
 			this.onCtrlS?.();
 			return;
 		}
-		if (matchesKey(data, "shift+tab")) {
+		if (matchesKey(normalized, "shift+tab")) {
 			this.onShiftTab?.();
 			return;
 		}
-		if (matchesKey(data, Key.up)) {
+		if (matchesKey(normalized, Key.up)) {
 			if (this.getText().length === 0 && this.onUpArrowEmpty) {
 				if (this.onUpArrowEmpty()) return;
 			}
 		}
-		if (matchesKey(data, Key.escape)) {
+		if (matchesKey(normalized, Key.escape)) {
 			if (!this.isShowingAutocomplete()) {
 				this.onEscape?.();
 				return;
 			}
 		}
-		super.handleInput(data);
+		super.handleInput(normalized);
 	}
 };
 /**
@@ -96972,6 +98141,10 @@ function cancelStream(state) {
 }
 //#endregion
 //#region src/tui/actions/input-ops.ts
+/**
+* User input orchestration: submission / history / external editor /
+* plan-mode toggle / reload.
+*/
 function handleUserInput(state, text, hooks, onSlash) {
 	if (text.trim().length === 0) return;
 	if (state.appState.isReplaying) {
@@ -97017,9 +98190,9 @@ async function openExternalEditor(state) {
 	await new Promise((resolve) => setImmediate(resolve));
 	try {
 		const result = await editInExternalEditor(seed, cmd);
-		if (result !== void 0) state.editor.setText(result.replace(/\r\n/g, "\n").replace(/\n$/, ""));
-	} catch (err) {
-		emitError(state, `External editor failed: ${err instanceof Error ? err.message : String(err)}`);
+		if (result !== void 0) state.editor.setText(result.replaceAll("\r\n", "\n").replace(/\n$/, ""));
+	} catch (error) {
+		emitError(state, `External editor failed: ${error instanceof Error ? error.message : String(error)}`);
 	} finally {
 		if (typeof process.stdin.pause === "function") process.stdin.pause();
 		state.ui.start();
@@ -97030,13 +98203,18 @@ async function openExternalEditor(state) {
 }
 async function togglePlanMode(state, hooks) {
 	const enabled = !state.appState.planMode;
+	let planPath;
 	try {
-		await state.client.setPlanMode(state.appState.sessionId, enabled);
-	} catch (err) {
-		emitError(state, `Failed to toggle plan mode: ${err instanceof Error ? err.message : String(err)}`);
+		planPath = (await state.client.setPlanMode(state.appState.sessionId, enabled)).plan_path;
+	} catch (error) {
+		emitError(state, `Failed to toggle plan mode: ${error instanceof Error ? error.message : String(error)}`);
 		return;
 	}
 	setState(state, { planMode: enabled }, hooks);
+	if (enabled && planPath !== void 0) {
+		emitPrimary(state, `Plan mode: ON. Write your plan to: ${planPath}`);
+		return;
+	}
 	emitPrimary(state, `Plan mode: ${enabled ? "ON" : "OFF"}`);
 }
 async function performReload(state, action, hooks) {
@@ -97825,6 +99003,20 @@ 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
@@ -97874,7 +99066,7 @@ function handleToolResult(ectx, data) {
 	}
 	ectx.state.activeToolCalls.delete(data.tool_call_id);
 	ectx.patchLivePane({
-		mode: "idle",
+		mode: "waiting",
 		pendingToolCall: null
 	});
 }
@@ -98299,6 +99491,12 @@ var ApprovalPanelComponent = class extends Container {
 				this.rebuildOptions();
 				return;
 			}
+			const printable = decodeKittyPrintable(data);
+			if (printable !== void 0) {
+				this.feedbackText += printable;
+				this.rebuildOptions();
+				return;
+			}
 			if (data.length > 0 && !data.startsWith("\x1B")) {
 				this.feedbackText += data;
 				this.rebuildOptions();
@@ -98320,7 +99518,8 @@ var ApprovalPanelComponent = class extends Container {
 			this.selectAndSubmit(this.selectedIndex);
 			return;
 		}
-		const numericIndex = Number(data) - 1;
+		const printable = decodeKittyPrintable(data) ?? data;
+		const numericIndex = Number(printable) - 1;
 		if (Number.isInteger(numericIndex) && numericIndex >= 0 && numericIndex < this.choiceCount()) this.selectAndSubmit(numericIndex);
 	}
 	render(width) {
@@ -98530,13 +99729,14 @@ var QuestionDialogComponent = class extends Container {
 			this.activateQuestionOption(this.currentCursor());
 			return;
 		}
-		const numIdx = NUMBER_KEYS.indexOf(data);
+		const printable = decodeKittyPrintable(data) ?? data;
+		const numIdx = NUMBER_KEYS.indexOf(printable);
 		if (numIdx >= 0 && numIdx < optionCount) {
 			this.cursors[questionIdx] = numIdx;
 			this.activateQuestionOption(numIdx);
 			return;
 		}
-		if (data === " " || matchesKey(data, Key.space)) {
+		if (printable === " " || matchesKey(data, Key.space)) {
 			if (question.multi_select) this.activateQuestionOption(this.currentCursor());
 			return;
 		}
@@ -98573,6 +99773,12 @@ var QuestionDialogComponent = class extends Container {
 			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;
@@ -98606,12 +99812,13 @@ var QuestionDialogComponent = class extends Container {
 			this.executeSubmitAction(this.submitActionIdx);
 			return;
 		}
-		if (data === "1") {
+		const printable = decodeKittyPrintable(data) ?? data;
+		if (printable === "1") {
 			this.submitActionIdx = 0;
 			this.executeSubmitAction(0);
 			return;
 		}
-		if (data === "2") {
+		if (printable === "2") {
 			this.submitActionIdx = 1;
 			this.executeSubmitAction(1);
 			return;
@@ -99155,7 +100362,8 @@ var HelpPanelComponent = class extends Container {
 		this.opts = opts;
 	}
 	handleInput(data) {
-		if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter) || data === "q" || data === "Q") {
+		const printable = decodeKittyPrintable(data) ?? data;
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter) || printable === "q" || printable === "Q") {
 			this.opts.onClose();
 			return;
 		}
@@ -99714,6 +100922,14 @@ var MoonLoader = class extends Text {
 			this.intervalId = null;
 		}
 	}
+	setLabel(label) {
+		this.label = label;
+		this.updateDisplay();
+	}
+	setColorFn(colorFn) {
+		this.colorFn = colorFn;
+		this.updateDisplay();
+	}
 	updateDisplay() {
 		const frame = this.frames[this.currentFrame];
 		const coloredFrame = this.colorFn ? this.colorFn(frame) : frame;
@@ -99768,6 +100984,10 @@ function updateActivityPane(state) {
 		case "composing":
 			stopLoader(state);
 			if (!state.phaseSpinner) state.phaseSpinner = new MoonLoader(state.ui, "braille", (s) => chalk.hex(state.colors.primary)(s), "working...");
+			else {
+				state.phaseSpinner.setLabel("working...");
+				state.phaseSpinner.setColorFn((s) => chalk.hex(state.colors.primary)(s));
+			}
 			state.activityContainer.addChild(state.phaseSpinner);
 			break;
 		case "tool":
@@ -100710,6 +101930,9 @@ var KimiTUI = class {
 	getCurrentSessionId() {
 		return this.state.appState.sessionId;
 	}
+	hasSessionContent() {
+		return this.state.transcriptEntries.length > 0;
+	}
 	startWireSubscription() {
 		const ectx = buildEventCtx(this.state, this.stateHooks, this.streamCallbacks, (entry) => this.addEntry(entry));
 		const sendQueued = (text) => {
@@ -100792,9 +102015,6 @@ var KimiTUI = class {
 //#region src/cli/run-shell.ts
 /**
 * Shell runner —— 把 `AgentContext` 接进 `KimiTUI`。
-*
-* 新 wire 架构下不再有 "resume this session: kimi -r" 的提示（方案明确
-* 不支持 session 重新打开）。
 */
 function toInitialSessionIntent(opts) {
 	if (opts.session === "") return { kind: "picker" };
@@ -100836,7 +102056,11 @@ async function runShell(opts, version) {
 		syncSessionRuntime: ctx.syncSessionRuntime
 	} });
 	tui.onExit = async () => {
+		const sessionId = tui.getCurrentSessionId();
+		const hasContent = tui.hasSessionContent();
 		await ctx.dispose();
+		process.stdout.write("Bye!\n");
+		if (sessionId !== "" && hasContent) process.stderr.write(`\nTo resume this session: kimi -r ${sessionId}\n`);
 		process.exit(0);
 	};
 	try {