@moonshot-ai/kimi-code 0.13.0 → 0.14.0

package/dist/main.mjs

@@ -8220,15 +8220,16 @@ const OPENAI_VISION_TOOL_PREFIXES = [
 	"gpt-4.1",
 	"gpt-4.5"
 ];
-const CLAUDE_3_PREFIXES = [
+const CLAUDE_VISION_TOOL_PREFIXES = [
 	"claude-3-",
 	"claude-3.5-",
 	"claude-3.7-"
 ];
-const CLAUDE_4_PREFIXES = [
+const CLAUDE_THINKING_VISION_TOOL_PREFIXES = [
 	"claude-opus-4",
 	"claude-sonnet-4",
-	"claude-haiku-4"
+	"claude-haiku-4",
+	"claude-fable"
 ];
 const GEMINI_CATALOGUED_PREFIXES = [
 	"gemini-1.5-pro",
@@ -8316,10 +8317,10 @@ const OPENAI_RESPONSES_CAPABILITY_CATALOG = [{
 	capability: OPENAI_VISION_TOOL_CAPABILITY
 }];
 const ANTHROPIC_CAPABILITY_CATALOG = [{
-	matches: (name) => hasPrefix(name, CLAUDE_3_PREFIXES),
+	matches: (name) => hasPrefix(name, CLAUDE_VISION_TOOL_PREFIXES),
 	capability: ANTHROPIC_VISION_TOOL_CAPABILITY
 }, {
-	matches: (name) => hasPrefix(name, CLAUDE_4_PREFIXES),
+	matches: (name) => hasPrefix(name, CLAUDE_THINKING_VISION_TOOL_PREFIXES),
 	capability: ANTHROPIC_THINKING_VISION_TOOL_CAPABILITY
 }];
 function normalizeModelName(modelName) {
@@ -8552,6 +8553,7 @@ const ANTHROPIC_TOOL_CALL_ID_POLICY = {
 * family's baseline rather than the generic fallback.
 */
 const CEILING_BY_FAMILY_VERSION = {
+	"fable-5": 128e3,
 	"opus-4-7": 128e3,
 	"opus-4-6": 128e3,
 	"opus-4-5": 64e3,
@@ -8573,7 +8575,7 @@ const CEILING_BY_FAMILY_VERSION = {
 	"haiku-3": 4096
 };
 const FALLBACK_MAX_TOKENS = 32e3;
-const FAMILY_FIRST_RE = /(opus|sonnet|haiku)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
+const FAMILY_FIRST_RE = /(opus|sonnet|haiku|fable)[-._](\d{1,2})(?!\d)(?:[-._](\d{1,2})(?!\d))?/;
 const VERSION_FIRST_RE = /(\d{1,2})[-._](\d{1,2})[-._](opus|sonnet|haiku)/;
 const BARE_FAMILY_RE = /(\d{1,2})[-._](opus|sonnet|haiku)/;
 /**
@@ -8660,10 +8662,10 @@ function versionAtLeast(version, minimum) {
 }
 function supportsAdaptiveThinking(model) {
 	const version = parseClaudeAliasVersion(model);
-	if (version === null || version.minor === null) return false;
+	if (version === null) return false;
 	return versionAtLeast({
 		major: version.major,
-		minor: version.minor
+		minor: version.minor ?? 0
 	}, ADAPTIVE_MIN_VERSION);
 }
 function isOpus47(model) {
@@ -8672,6 +8674,9 @@ function isOpus47(model) {
 	const version = parseVersion(match);
 	return version.major === 4 && version.minor === 7;
 }
+function isFableModel(model) {
+	return parseClaudeAliasVersion(model)?.family === "fable";
+}
 function supportsEffortParam(model, adaptive) {
 	if (adaptive) return true;
 	const normalized = model.toLowerCase();
@@ -8679,7 +8684,7 @@ function supportsEffortParam(model, adaptive) {
 }
 function clampEffort(effort, model, adaptive) {
 	if (effort === "off") return effort;
-	if (effort === "xhigh" && !isOpus47(model)) return "high";
+	if (effort === "xhigh" && !isOpus47(model) && !isFableModel(model)) return "high";
 	if (effort === "max" && !adaptive) return "high";
 	return effort;
 }
@@ -9114,7 +9119,8 @@ var AnthropicChatProvider = class {
 		if (this._generationKwargs.temperature !== void 0) kwargs["temperature"] = this._generationKwargs.temperature;
 		if (this._generationKwargs.top_k !== void 0) kwargs["top_k"] = this._generationKwargs.top_k;
 		if (this._generationKwargs.top_p !== void 0) kwargs["top_p"] = this._generationKwargs.top_p;
-		if (this._generationKwargs.thinking !== void 0) kwargs["thinking"] = this._generationKwargs.thinking;
+		const thinking = this._generationKwargs.thinking;
+		if (thinking !== void 0 && !(thinking.type === "disabled" && isFableModel(this._model))) kwargs["thinking"] = thinking;
 		if (this._generationKwargs.output_config !== void 0) kwargs["output_config"] = this._generationKwargs.output_config;
 		const betas = this._generationKwargs.betaFeatures ?? [];
 		const extraHeaders = {};
@@ -45834,6 +45840,8 @@ const OPENAI_CHAT_TOOL_CALL_ID_POLICY = {
 	normalize: (id) => sanitizeToolCallId(id, 64),
 	maxLength: 64
 };
+const TOOL_RESULT_IMAGE_PROMPT = "Attached image(s) from tool result:";
+const TOOL_RESULT_IMAGE_PLACEHOLDER = "(see attached image)";
 function extractReasoningContent(source, explicitKey) {
 	if (typeof source !== "object" || source === null) return void 0;
 	const record = source;
@@ -45866,7 +45874,7 @@ function convertMessage$1(message, reasoningKey, toolMessageConversion) {
 	const result = { role: message.role };
 	if (message.role === "tool") {
 		const effectiveConversion = message.content.some((p) => p.type !== "text" && p.type !== "think") ? "extract_text" : toolMessageConversion;
-		if (effectiveConversion !== null) result.content = convertToolMessageContent(message, effectiveConversion);
+		if (effectiveConversion !== null) result.content = convertToolMessageContentForChat(message, effectiveConversion);
 		else {
 			const firstPart = nonThinkParts[0];
 			if (nonThinkParts.length === 1 && firstPart?.type === "text") result.content = firstPart.text;
@@ -45890,6 +45898,47 @@ function convertMessage$1(message, reasoningKey, toolMessageConversion) {
 	if (reasoningContent) result[reasoningKey ?? DEFAULT_OUTBOUND_REASONING_KEY] = reasoningContent;
 	return result;
 }
+function convertToolMessageContentForChat(message, conversion) {
+	const content = convertToolMessageContent(message, conversion);
+	if (typeof content === "string" && content.length === 0 && message.content.some((part) => part.type === "image_url")) return TOOL_RESULT_IMAGE_PLACEHOLDER;
+	return content;
+}
+function toolResultImageParts(message) {
+	const images = [];
+	for (const part of message.content) {
+		if (part.type !== "image_url") continue;
+		images.push({
+			type: "image_url",
+			image_url: part.imageUrl.id === void 0 ? { url: part.imageUrl.url } : {
+				url: part.imageUrl.url,
+				id: part.imageUrl.id
+			}
+		});
+	}
+	return images;
+}
+function appendToolResultImagesMessage(messages, pendingToolResultImages) {
+	if (pendingToolResultImages.length === 0) return;
+	messages.push({
+		role: "user",
+		content: [{
+			type: "text",
+			text: TOOL_RESULT_IMAGE_PROMPT
+		}, ...pendingToolResultImages]
+	});
+	pendingToolResultImages.length = 0;
+}
+function convertHistoryMessages(history, reasoningKey, toolMessageConversion) {
+	const messages = [];
+	const pendingToolResultImages = [];
+	for (const msg of history) {
+		if (msg.role !== "tool") appendToolResultImagesMessage(messages, pendingToolResultImages);
+		messages.push(convertMessage$1(msg, reasoningKey, toolMessageConversion));
+		if (msg.role === "tool") pendingToolResultImages.push(...toolResultImageParts(msg));
+	}
+	appendToolResultImagesMessage(messages, pendingToolResultImages);
+	return messages;
+}
 var OpenAILegacyStreamedMessage = class {
 	_id = null;
 	_usage = null;
@@ -46025,7 +46074,7 @@ var OpenAILegacyChatProvider = class {
 			content: systemPrompt
 		});
 		const normalizedHistory = normalizeToolCallIdsForProvider(history, OPENAI_CHAT_TOOL_CALL_ID_POLICY);
-		for (const msg of normalizedHistory) messages.push(convertMessage$1(msg, this._reasoningKey, this._toolMessageConversion));
+		messages.push(...convertHistoryMessages(normalizedHistory, this._reasoningKey, this._toolMessageConversion));
 		const kwargs = normalizeGenerationKwargs(this._model, this._generationKwargs);
 		let reasoningEffort = this._reasoningEffort;
 		if (reasoningEffort === void 0 && kwargs["reasoning_effort"] === void 0) {
@@ -56514,7 +56563,12 @@ var ContextMemory = class {
 		this.deferredMessages = [];
 		this.agent.microCompaction.reset(this._history.length);
 		this.agent.emitStatusUpdated();
-		if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) throw new KimiError(ErrorCodes.REQUEST_INVALID, "Nothing to undo in the active context.");
+		if (!this.agent.records.restoring && (stoppedAtBoundary || removedUserCount < count)) throw new KimiError(ErrorCodes.REQUEST_INVALID, formatUndoUnavailableMessage(count, removedUserCount, stoppedAtBoundary), { details: {
+			reason: "undo_limit",
+			requestedCount: count,
+			undoableCount: removedUserCount,
+			stoppedAtCompaction: stoppedAtBoundary
+		} });
 	}
 	applyCompaction(summary) {
 		this.agent.records.logRecord({
@@ -56683,6 +56737,13 @@ function isRealUserPrompt(message) {
 	if (origin.kind === "skill_activation") return origin.trigger === "user-slash";
 	return false;
 }
+function formatUndoUnavailableMessage(requestedCount, undoableCount, stoppedAtCompaction) {
+	const reason = stoppedAtCompaction ? " after the last compaction" : "";
+	return `Cannot undo ${formatPromptCount(requestedCount)}; only ${formatPromptCount(undoableCount)} can be undone in the active context${reason}.`;
+	function formatPromptCount(count) {
+		return `${String(count)} ${count === 1 ? "prompt" : "prompts"}`;
+	}
+}
 //#endregion
 //#region ../../packages/agent-core/src/agent/goal/index.ts
 /**
@@ -57459,6 +57520,7 @@ const HOOK_EVENT_TYPES = [
 	"UserPromptSubmit",
 	"Stop",
 	"StopFailure",
+	"Interrupt",
 	"SessionStart",
 	"SessionEnd",
 	"SubagentStart",
@@ -58449,26 +58511,6 @@ var GitControlPathAccessAskPermissionPolicy = class {
 		};
 	}
 };
-var CwdOutsideFileWriteAskPermissionPolicy = class {
-	agent;
-	name = "cwd-outside-file-write-ask";
-	constructor(agent) {
-		this.agent = agent;
-	}
-	evaluate(context) {
-		const cwd = this.agent.config.cwd;
-		if (cwd.length === 0) return;
-		const pathClass = this.agent.kaos.pathClass();
-		const access = writeFileAccesses(context).find((fileAccess) => {
-			return !isWithinDirectory(fileAccess.path, cwd, pathClass);
-		});
-		if (access === void 0) return;
-		return {
-			kind: "ask",
-			reason: fileAccessReason(access, { cwd_outside: true })
-		};
-	}
-};
 function fileAccesses(context) {
 	return context.execution.accesses?.filter((access) => access.kind === "file") ?? [];
 }
@@ -60689,7 +60731,6 @@ function createPermissionDecisionPolicies(agent) {
 		new PlanModeToolApprovePermissionPolicy(agent),
 		new SensitiveFileAccessAskPermissionPolicy(agent),
 		new GitControlPathAccessAskPermissionPolicy(agent),
-		new CwdOutsideFileWriteAskPermissionPolicy(agent),
 		new YoloModeApprovePermissionPolicy(agent),
 		new SwarmModeAgentSwarmApprovePermissionPolicy(agent),
 		new DefaultToolApprovePermissionPolicy(),
@@ -66161,6 +66202,43 @@ function truncate$1(value, max) {
 	return value.length > max ? value.slice(0, max) : value;
 }
 //#endregion
+//#region ../../packages/agent-core/src/agent/skill/prompt.ts
+function renderUserSlashSkillPrompt(input) {
+	return [
+		`User activated the skill "${escapeXml(input.skillName)}". Follow the loaded skill instructions.`,
+		"",
+		renderSkillLoadedBlock({
+			...input,
+			trigger: "user-slash"
+		})
+	].join("\n");
+}
+function renderModelToolSkillPrompt(input) {
+	return [
+		"Skill tool loaded instructions for this request. Follow them.",
+		"",
+		renderSkillLoadedBlock({
+			...input,
+			trigger: input.trigger
+		})
+	].join("\n");
+}
+function renderSkillLoadedBlock(input) {
+	return [
+		`<kimi-skill-loaded${renderSkillAttributes(input)}>`,
+		input.skillContent,
+		"</kimi-skill-loaded>"
+	].join("\n");
+}
+function renderSkillAttributes(input) {
+	return [
+		["name", input.skillName],
+		["trigger", input.trigger],
+		["source", input.skillSource],
+		["args", input.skillArgs]
+	].filter((item) => item[1] !== void 0).map(([name, value]) => ` ${name}="${escapeXml(value)}"`).join("");
+}
+//#endregion
 //#region ../../packages/agent-core/src/agent/skill/index.ts
 var SkillManager = class {
 	agent;
@@ -66173,12 +66251,16 @@ var SkillManager = class {
 		const skill = this.registry.getSkill(input.name);
 		if (skill === void 0) throw new KimiError(ErrorCodes.SKILL_NOT_FOUND, `Skill "${input.name}" was not found`);
 		if (!isUserActivatableSkillType(skill.metadata.type)) throw new KimiError(ErrorCodes.SKILL_TYPE_UNSUPPORTED, `Skill "${skill.name}" cannot be activated by the user`);
-		const skillContent = this.registry.renderSkillPrompt(skill, input.args ?? "");
-		const args = input.args;
-		const argsAttr = args ? ` args="${escapeXml(args)}"` : "";
+		const skillArgs = input.args ?? "";
+		const skillContent = this.registry.renderSkillPrompt(skill, skillArgs);
 		const wrapped = [{
 			type: "text",
-			text: `<system-reminder>\n<kimi-skill-loaded name="${escapeXml(skill.name)}"${argsAttr}>\n${skillContent}\n</kimi-skill-loaded>\n</system-reminder>`
+			text: renderUserSlashSkillPrompt({
+				skillName: skill.name,
+				skillArgs,
+				skillContent,
+				skillSource: skill.source
+			})
 		}];
 		this.recordActivation({
 			kind: "skill_activation",
@@ -74401,8 +74483,1283 @@ function makeInterruptedEvent(reason, attemptedSteps, activeStep, message) {
 	};
 }
 //#endregion
-//#region ../../packages/agent-core/src/rpc/events.ts
+//#region ../../packages/protocol/src/error-codes.ts
+/**
+* Integer namespaces:
+*   - 0          success
+*   - 4xxxx      客户端错误 (HTTP-4xx analog)
+*   - 5xxxx      daemon 内部错误
+*   - 6xxxx      工具运行时
+*   - 7xxxx      LLM provider 透传 (msg = original upstream text)
+*   - 8xxxx      MCP server 透传 (msg = original upstream text)
+*   - 9xxxx      预留
+*/
+const ErrorCode$1 = {
+	/** 成功 */
+	SUCCESS: 0,
+	/** Zod 校验失败，`details` 含字段路径列表 */
+	VALIDATION_FAILED: 40001,
+	/** JSON 解析失败、字段类型错 */
+	REQUEST_MALFORMED: 40002,
+	/** daemon 没有任何 provider 配置 */
+	AUTH_PROVISIONING_REQUIRED: 40110,
+	/** provider 存在但 token / api_key 缺失 */
+	AUTH_TOKEN_MISSING: 40111,
+	/** 刷新 token 收到 401（用户撤销了授权） */
+	AUTH_TOKEN_UNAUTHORIZED: 40112,
+	/** 默认 / 请求的 model 解析不到 provider */
+	AUTH_MODEL_NOT_RESOLVED: 40113,
+	/** session_id 不存在 */
+	SESSION_NOT_FOUND: 40401,
+	/** prompt_id 不存在 */
+	PROMPT_NOT_FOUND: 40402,
+	/** message_id 不存在 */
+	MESSAGE_NOT_FOUND: 40403,
+	/** approval_id 不存在 */
+	APPROVAL_NOT_FOUND: 40404,
+	/** question_id 不存在 */
+	QUESTION_NOT_FOUND: 40405,
+	/** task_id 不存在 */
+	TASK_NOT_FOUND: 40406,
+	/** file_id 不存在 */
+	FILE_NOT_FOUND: 40407,
+	/** mcp_server_id 不存在 */
+	MCP_SERVER_NOT_FOUND: 40408,
+	/** fs path 不存在 */
+	FS_PATH_NOT_FOUND: 40409,
+	/** workspace_id 不存在 */
+	WORKSPACE_NOT_FOUND: 40410,
+	/** fs 路径存在但当前进程无权限读取 */
+	FS_PERMISSION_DENIED: 40411,
+	/** provider_id 不存在 */
+	PROVIDER_NOT_FOUND: 40412,
+	/** model_id 不存在 */
+	MODEL_NOT_FOUND: 40413,
+	/** session 有正在进行的 prompt，拒绝新请求 */
+	SESSION_BUSY: 40901,
+	/** approval 已被其他 client 应答 */
+	APPROVAL_ALREADY_RESOLVED: 40902,
+	/** prompt 已结束（abort 幂等返回 0） */
+	PROMPT_ALREADY_COMPLETED: 40903,
+	/** task 已完结，无法取消 */
+	TASK_ALREADY_FINISHED: 40904,
+	/** mcp restart 时若已在 connecting/connected */
+	MCP_ALREADY_CONNECTED: 40905,
+	/** fs.read 请求 file，但 path 是目录 */
+	FS_IS_DIRECTORY: 40906,
+	/** fs.read 请求 utf-8，但 path 是二进制；client 改走 `:download` */
+	FS_IS_BINARY: 40907,
+	/** fs.git_status 但 session.cwd 不是 git repo */
+	FS_GIT_UNAVAILABLE: 40908,
+	/** 用户 ESC / 关闭面板放弃整组（client 调 `:dismiss`） */
+	QUESTION_DISMISSED: 40909,
+	/** 当前历史没有可 compact 的前缀 */
+	COMPACTION_UNABLE: 40910,
+	/** 当前历史没有足够的用户提示词可撤回 */
+	SESSION_UNDO_UNAVAILABLE: 40911,
+	/** approval 60s 超时 */
+	APPROVAL_EXPIRED: 41001,
+	/** question 60s 超时 */
+	QUESTION_EXPIRED: 41002,
+	/** 临时文件已过期 */
+	FILE_EXPIRED: 41003,
+	/** 上传超 50MB */
+	FILE_TOO_LARGE: 41301,
+	/** fs.read 超 10MB */
+	FS_TOO_LARGE: 41302,
+	/** fs.list / fs.search / fs.grep 命中超上限 */
+	FS_TOO_MANY_RESULTS: 41303,
+	/** path 越出 session cwd 边界 */
+	FS_PATH_ESCAPES_SESSION: 41304,
+	/** fs.grep 执行 >30s */
+	FS_GREP_TIMEOUT: 41305,
+	/** WS 单连接 watch_paths > 100 */
+	FS_WATCH_LIMIT_EXCEEDED: 42902,
+	/** 兜底 */
+	INTERNAL_ERROR: 50001,
+	/** 写入 session 持久化失败 */
+	PERSISTENCE_FAILURE: 50003,
+	/** tool 执行抛错 */
+	TOOL_EXECUTION_FAILED: 60001,
+	/** tool 在此 session 未启用 */
+	TOOL_NOT_AVAILABLE: 60002
+};
+ErrorCode$1.SUCCESS, ErrorCode$1.VALIDATION_FAILED, ErrorCode$1.REQUEST_MALFORMED, ErrorCode$1.AUTH_PROVISIONING_REQUIRED, ErrorCode$1.AUTH_TOKEN_MISSING, ErrorCode$1.AUTH_TOKEN_UNAUTHORIZED, ErrorCode$1.AUTH_MODEL_NOT_RESOLVED, ErrorCode$1.SESSION_NOT_FOUND, ErrorCode$1.PROMPT_NOT_FOUND, ErrorCode$1.MESSAGE_NOT_FOUND, ErrorCode$1.APPROVAL_NOT_FOUND, ErrorCode$1.QUESTION_NOT_FOUND, ErrorCode$1.TASK_NOT_FOUND, ErrorCode$1.FILE_NOT_FOUND, ErrorCode$1.MCP_SERVER_NOT_FOUND, ErrorCode$1.FS_PATH_NOT_FOUND, ErrorCode$1.WORKSPACE_NOT_FOUND, ErrorCode$1.FS_PERMISSION_DENIED, ErrorCode$1.PROVIDER_NOT_FOUND, ErrorCode$1.MODEL_NOT_FOUND, ErrorCode$1.SESSION_BUSY, ErrorCode$1.APPROVAL_ALREADY_RESOLVED, ErrorCode$1.PROMPT_ALREADY_COMPLETED, ErrorCode$1.TASK_ALREADY_FINISHED, ErrorCode$1.MCP_ALREADY_CONNECTED, ErrorCode$1.FS_IS_DIRECTORY, ErrorCode$1.FS_IS_BINARY, ErrorCode$1.FS_GIT_UNAVAILABLE, ErrorCode$1.QUESTION_DISMISSED, ErrorCode$1.COMPACTION_UNABLE, ErrorCode$1.SESSION_UNDO_UNAVAILABLE, ErrorCode$1.APPROVAL_EXPIRED, ErrorCode$1.QUESTION_EXPIRED, ErrorCode$1.FILE_EXPIRED, ErrorCode$1.FILE_TOO_LARGE, ErrorCode$1.FS_TOO_LARGE, ErrorCode$1.FS_TOO_MANY_RESULTS, ErrorCode$1.FS_PATH_ESCAPES_SESSION, ErrorCode$1.FS_GREP_TIMEOUT, ErrorCode$1.FS_WATCH_LIMIT_EXCEEDED, ErrorCode$1.INTERNAL_ERROR, ErrorCode$1.PERSISTENCE_FAILURE, ErrorCode$1.TOOL_EXECUTION_FAILED, ErrorCode$1.TOOL_NOT_AVAILABLE;
+//#endregion
+//#region ../../packages/protocol/src/pagination.ts
+const cursorQuerySchema = z.object({
+	before_id: z.string().min(1).optional(),
+	after_id: z.string().min(1).optional(),
+	page_size: z.number().int().min(1).max(100).optional()
+}).superRefine((value, ctx) => {
+	if (value.before_id !== void 0 && value.after_id !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "before_id and after_id are mutually exclusive",
+		path: ["before_id"],
+		params: { code: ErrorCode$1.VALIDATION_FAILED }
+	});
+});
+const pageResponseSchema = (item) => z.object({
+	items: z.array(item),
+	has_more: z.boolean()
+});
+//#endregion
+//#region ../../packages/protocol/src/time.ts
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
+const isoDateTimeSchema = z.string().refine((value) => ISO_8601_REGEX.test(value), { message: "must be an ISO 8601 datetime string" }).transform((value, ctx) => {
+	const ms = Date.parse(value);
+	if (Number.isNaN(ms)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "invalid ISO 8601 datetime"
+		});
+		return z.NEVER;
+	}
+	return new Date(ms).toISOString();
+});
+//#endregion
+//#region ../../packages/protocol/src/events.ts
 const MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE = "mcp.oauth.authorization_url";
+z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("command"),
+		command: z.string(),
+		cwd: z.string().optional(),
+		description: z.string().optional(),
+		language: z.literal("bash").optional()
+	}),
+	z.object({
+		kind: z.literal("file_io"),
+		operation: z.enum([
+			"read",
+			"write",
+			"edit",
+			"glob",
+			"grep"
+		]),
+		path: z.string(),
+		detail: z.string().optional(),
+		content: z.string().optional(),
+		before: z.string().optional(),
+		after: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("diff"),
+		path: z.string(),
+		before: z.string(),
+		after: z.string(),
+		hunks: z.number().optional()
+	}),
+	z.object({
+		kind: z.literal("search"),
+		query: z.string(),
+		scope: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("url_fetch"),
+		url: z.string(),
+		method: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("agent_call"),
+		agent_name: z.string(),
+		prompt: z.string(),
+		background: z.boolean().optional()
+	}),
+	z.object({
+		kind: z.literal("skill_call"),
+		skill_name: z.string(),
+		args: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("todo_list"),
+		items: z.array(z.object({
+			title: z.string(),
+			status: z.string()
+		}))
+	}),
+	z.object({
+		kind: z.literal("background_task"),
+		task_id: z.string(),
+		status: z.string(),
+		description: z.string(),
+		task_kind: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("task_stop"),
+		task_id: z.string(),
+		task_description: z.string()
+	}),
+	z.object({
+		kind: z.literal("plan_review"),
+		plan: z.string(),
+		path: z.string().optional(),
+		options: z.array(z.object({
+			label: z.string(),
+			description: z.string()
+		})).readonly().optional()
+	}),
+	z.object({
+		kind: z.literal("generic"),
+		summary: z.string(),
+		detail: z.unknown().optional()
+	})
+]);
+z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("command_output"),
+		exit_code: z.number(),
+		stdout: z.string().optional(),
+		stderr: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("file_content"),
+		path: z.string(),
+		content: z.string(),
+		range: z.object({
+			start: z.number(),
+			end: z.number()
+		}).optional(),
+		truncated: z.boolean().optional()
+	}),
+	z.object({
+		kind: z.literal("diff"),
+		path: z.string(),
+		before: z.string(),
+		after: z.string(),
+		hunks: z.number().optional()
+	}),
+	z.object({
+		kind: z.literal("search_results"),
+		query: z.string(),
+		matches: z.array(z.object({
+			file: z.string(),
+			line: z.number(),
+			text: z.string()
+		}))
+	}),
+	z.object({
+		kind: z.literal("url_content"),
+		url: z.string(),
+		status: z.number(),
+		preview: z.string().optional(),
+		content_type: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("agent_summary"),
+		agent_name: z.string(),
+		result: z.string().optional(),
+		steps: z.number().optional()
+	}),
+	z.object({
+		kind: z.literal("background_task"),
+		task_id: z.string(),
+		status: z.string(),
+		description: z.string()
+	}),
+	z.object({
+		kind: z.literal("todo_list"),
+		items: z.array(z.object({
+			title: z.string(),
+			status: z.string()
+		}))
+	}),
+	z.object({
+		kind: z.literal("structured"),
+		data: z.unknown()
+	}),
+	z.object({
+		kind: z.literal("text"),
+		text: z.string(),
+		truncated: z.boolean().optional()
+	}),
+	z.object({
+		kind: z.literal("error"),
+		message: z.string(),
+		code: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("generic"),
+		summary: z.string(),
+		detail: z.unknown().optional()
+	})
+]);
+//#endregion
+//#region ../../packages/protocol/src/ws-control.ts
+/**
+*   Event:   { type, seq, session_id?, timestamp, payload }
+*   Control: { type, id?, payload }
+*   Ack:     { type: 'ack', id, code, msg, payload }
+*/
+const serverHelloPayloadSchema = z.object({
+	ws_connection_id: z.string(),
+	heartbeat_ms: z.number().int().positive(),
+	max_event_buffer_size: z.number().int().positive(),
+	capabilities: z.object({
+		event_batching: z.boolean(),
+		compression: z.boolean()
+	})
+});
+const serverHelloMessageSchema = z.object({
+	type: z.literal("server_hello"),
+	timestamp: isoDateTimeSchema,
+	payload: serverHelloPayloadSchema
+});
+const clientHelloPayloadSchema = z.object({
+	client_id: z.string(),
+	subscriptions: z.array(z.string()),
+	last_seq_by_session: z.record(z.string(), z.number().int().nonnegative()).optional()
+});
+const clientHelloMessageSchema = z.object({
+	type: z.literal("client_hello"),
+	id: z.string(),
+	payload: clientHelloPayloadSchema
+});
+z.object({
+	accepted_subscriptions: z.array(z.string()).optional(),
+	accepted: z.array(z.string()).optional(),
+	not_found: z.array(z.string()).optional(),
+	resync_required: z.array(z.string())
+});
+const watchFsConfigSchema = z.object({
+	paths: z.array(z.string()),
+	recursive: z.boolean().optional()
+});
+const subscribePayloadSchema = z.object({
+	session_ids: z.array(z.string()),
+	last_seq_by_session: z.record(z.string(), z.number().int().nonnegative()).optional(),
+	watch_fs: z.record(z.string(), watchFsConfigSchema).optional()
+});
+const subscribeMessageSchema = z.object({
+	type: z.literal("subscribe"),
+	id: z.string(),
+	payload: subscribePayloadSchema
+});
+const unsubscribePayloadSchema = z.object({ session_ids: z.array(z.string()) });
+const unsubscribeMessageSchema = z.object({
+	type: z.literal("unsubscribe"),
+	id: z.string(),
+	payload: unsubscribePayloadSchema
+});
+const watchFsAddPayloadSchema = z.object({
+	session_id: z.string(),
+	paths: z.array(z.string()),
+	recursive: z.boolean().optional()
+});
+const watchFsAddMessageSchema = z.object({
+	type: z.literal("watch_fs_add"),
+	id: z.string(),
+	payload: watchFsAddPayloadSchema
+});
+const watchFsRemovePayloadSchema = z.object({
+	session_id: z.string(),
+	paths: z.array(z.string())
+});
+const watchFsRemoveMessageSchema = z.object({
+	type: z.literal("watch_fs_remove"),
+	id: z.string(),
+	payload: watchFsRemovePayloadSchema
+});
+z.object({
+	watched_paths: z.array(z.string()).optional(),
+	current_count: z.number().int().nonnegative().optional()
+});
+const abortPayloadSchema = z.object({
+	session_id: z.string(),
+	prompt_id: z.string()
+});
+const abortMessageSchema = z.object({
+	type: z.literal("abort"),
+	id: z.string(),
+	payload: abortPayloadSchema
+});
+z.object({
+	aborted: z.boolean().optional(),
+	at_seq: z.number().int().nonnegative().optional()
+});
+const pingPayloadSchema = z.object({ nonce: z.string() });
+const pingMessageSchema = z.object({
+	type: z.literal("ping"),
+	timestamp: isoDateTimeSchema,
+	payload: pingPayloadSchema
+});
+const pongPayloadSchema = z.object({ nonce: z.string() });
+const pongMessageSchema = z.object({
+	type: z.literal("pong"),
+	payload: pongPayloadSchema
+});
+const resyncRequiredPayloadSchema = z.object({
+	session_id: z.string(),
+	reason: z.enum(["buffer_overflow", "session_recreated"]),
+	current_seq: z.number().int().nonnegative()
+});
+const resyncRequiredMessageSchema = z.object({
+	type: z.literal("resync_required"),
+	timestamp: isoDateTimeSchema,
+	payload: resyncRequiredPayloadSchema
+});
+const wsErrorPayloadSchema = z.object({
+	code: z.number().int(),
+	msg: z.string(),
+	fatal: z.boolean(),
+	request_id: z.string().optional(),
+	details: z.unknown().optional()
+});
+const wsErrorMessageSchema = z.object({
+	type: z.literal("error"),
+	timestamp: isoDateTimeSchema,
+	payload: wsErrorPayloadSchema
+});
+z.discriminatedUnion("type", [
+	clientHelloMessageSchema,
+	subscribeMessageSchema,
+	unsubscribeMessageSchema,
+	watchFsAddMessageSchema,
+	watchFsRemoveMessageSchema,
+	abortMessageSchema,
+	pongMessageSchema
+]);
+z.discriminatedUnion("type", [
+	serverHelloMessageSchema,
+	pingMessageSchema,
+	resyncRequiredMessageSchema,
+	wsErrorMessageSchema
+]);
+//#endregion
+//#region ../../packages/protocol/src/message.ts
+const messageRoleSchema = z.enum([
+	"user",
+	"assistant",
+	"tool",
+	"system"
+]);
+const textContentSchema = z.object({
+	type: z.literal("text"),
+	text: z.string()
+});
+const toolUseContentSchema = z.object({
+	type: z.literal("tool_use"),
+	tool_call_id: z.string().min(1),
+	tool_name: z.string().min(1),
+	input: z.unknown()
+});
+const toolResultContentSchema = z.object({
+	type: z.literal("tool_result"),
+	tool_call_id: z.string().min(1),
+	output: z.unknown(),
+	is_error: z.boolean().optional()
+});
+const imageSourceSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("url"),
+		url: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("base64"),
+		media_type: z.string().min(1),
+		data: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("file"),
+		file_id: z.string().min(1)
+	})
+]);
+const imageContentSchema = z.object({
+	type: z.literal("image"),
+	source: imageSourceSchema
+});
+const fileContentSchema = z.object({
+	type: z.literal("file"),
+	file_id: z.string().min(1),
+	name: z.string(),
+	media_type: z.string().min(1),
+	size: z.number().int().nonnegative()
+});
+const thinkingContentSchema = z.object({
+	type: z.literal("thinking"),
+	thinking: z.string(),
+	signature: z.string().optional()
+});
+const messageContentSchema = z.discriminatedUnion("type", [
+	textContentSchema,
+	toolUseContentSchema,
+	toolResultContentSchema,
+	imageContentSchema,
+	fileContentSchema,
+	thinkingContentSchema
+]);
+const messageSchema = z.object({
+	id: z.string().min(1),
+	session_id: z.string().min(1),
+	role: messageRoleSchema,
+	content: z.array(messageContentSchema),
+	created_at: isoDateTimeSchema,
+	prompt_id: z.string().min(1).optional(),
+	parent_message_id: z.string().min(1).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/rest/prompt.ts
+/**
+*   POST /v1/sessions/{sid}/prompts
+*     Body:  PromptSubmission {
+*              content: MessageContent[],
+*              metadata?: ...,
+*              model?: string,
+*              thinking?: 'off'|'low'|'medium'|'high'|'xhigh'|'max',
+*              permission_mode?: 'manual'|'yolo'|'auto',
+*              plan_mode?: boolean,
+*            }
+*     Reply: PromptSubmitResult { prompt_id, user_message_id, status, content, created_at }
+*            status='running' when sent immediately, status='queued' when
+*            another prompt is already active.
+*
+*   GET /v1/sessions/{sid}/prompts
+*     Reply: { active: PromptItem | null, queued: PromptItem[] }
+*
+*   POST /v1/sessions/{sid}/prompts/{pid}:steer
+*   POST /v1/sessions/{sid}/prompts:steer
+*     Body:  { prompt_ids: string[] } for the collection route
+*     Reply: { steered: true, prompt_ids: string[] }
+*
+*   POST /v1/sessions/{sid}/prompts/{pid}:abort
+*     Body:  empty
+*     Reply: { aborted: true, at_seq: number }   (envelope code 0)
+*            { aborted: false, at_seq: number }  (envelope code 40903, idempotent)
+*/
+const promptThinkingSchema = z.enum([
+	"off",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+]);
+const promptPermissionModeSchema = z.enum([
+	"manual",
+	"yolo",
+	"auto"
+]);
+z.object({
+	content: z.array(messageContentSchema).min(1),
+	metadata: z.record(z.string(), z.unknown()).optional(),
+	model: z.string().min(1).optional(),
+	thinking: promptThinkingSchema.optional(),
+	permission_mode: promptPermissionModeSchema.optional(),
+	plan_mode: z.boolean().optional()
+});
+const promptStatusSchema = z.enum(["running", "queued"]);
+const promptItemSchema = z.object({
+	prompt_id: z.string().min(1),
+	user_message_id: z.string().min(1),
+	status: promptStatusSchema,
+	content: z.array(messageContentSchema).min(1),
+	created_at: isoDateTimeSchema
+});
+z.object({
+	active: promptItemSchema.nullable(),
+	queued: z.array(promptItemSchema)
+});
+z.object({ prompt_ids: z.array(z.string().min(1)).min(1) });
+z.object({
+	steered: z.literal(true),
+	prompt_ids: z.array(z.string().min(1)).min(1)
+});
+z.object({
+	aborted: z.boolean(),
+	at_seq: z.number().int().nonnegative().optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/workspace.ts
+const workspaceIdSchema = z.string().regex(/^wd_[a-z0-9._-]+_[0-9a-f]{12}$/, { message: "workspace_id must be a wd_<slug>_<hash12> string" });
+const workspaceSchema = z.object({
+	id: workspaceIdSchema,
+	root: z.string().min(1),
+	name: z.string().min(1).max(100),
+	is_git_repo: z.boolean(),
+	branch: z.string().nullable(),
+	created_at: isoDateTimeSchema,
+	last_opened_at: isoDateTimeSchema,
+	session_count: z.number().int().nonnegative()
+});
+z.object({
+	root: z.string().min(1),
+	name: z.string().min(1).max(100).optional()
+});
+z.object({ name: z.string().min(1).max(100) });
+//#endregion
+//#region ../../packages/protocol/src/session.ts
+const sessionStatusSchema = z.enum([
+	"idle",
+	"running",
+	"awaiting_approval",
+	"awaiting_question",
+	"aborted"
+]);
+const sessionUsageSchema = z.object({
+	input_tokens: z.number().int().nonnegative(),
+	output_tokens: z.number().int().nonnegative(),
+	cache_read_tokens: z.number().int().nonnegative(),
+	cache_creation_tokens: z.number().int().nonnegative(),
+	total_cost_usd: z.number().nonnegative(),
+	context_tokens: z.number().int().nonnegative(),
+	context_limit: z.number().int().nonnegative(),
+	turn_count: z.number().int().nonnegative()
+});
+const permissionRuleMatcherSchema = z.object({
+	kind: z.enum([
+		"command_prefix",
+		"path_glob",
+		"exact_input",
+		"always"
+	]),
+	value: z.string().optional()
+});
+const permissionRuleSchema = z.object({
+	id: z.string().min(1),
+	tool_name: z.string().min(1),
+	matcher: permissionRuleMatcherSchema.optional(),
+	decision: z.literal("approved"),
+	created_at: isoDateTimeSchema,
+	created_by: z.enum(["user", "agent"])
+});
+const sessionAgentConfigSchema = z.object({
+	model: z.string(),
+	system_prompt: z.string().optional(),
+	tools: z.array(z.string()).optional(),
+	mcp_servers: z.array(z.string()).optional(),
+	thinking: promptThinkingSchema.optional(),
+	permission_mode: promptPermissionModeSchema.optional(),
+	plan_mode: z.boolean().optional()
+});
+const sessionAgentConfigPartialSchema = sessionAgentConfigSchema.partial();
+const sessionMetadataSchema = z.object({ cwd: z.string().min(1) }).catchall(z.unknown());
+const sessionSchema = z.object({
+	id: z.string().min(1),
+	workspace_id: workspaceIdSchema,
+	title: z.string(),
+	created_at: isoDateTimeSchema,
+	updated_at: isoDateTimeSchema,
+	status: sessionStatusSchema,
+	current_prompt_id: z.string().min(1).optional(),
+	metadata: sessionMetadataSchema,
+	agent_config: sessionAgentConfigSchema,
+	usage: sessionUsageSchema,
+	permission_rules: z.array(permissionRuleSchema),
+	message_count: z.number().int().nonnegative(),
+	last_seq: z.number().int().nonnegative()
+});
+z.object({
+	title: z.string().min(1).optional(),
+	metadata: sessionMetadataSchema.optional(),
+	agent_config: sessionAgentConfigPartialSchema.optional(),
+	workspace_id: workspaceIdSchema.optional()
+});
+z.object({
+	title: z.string().min(1).optional(),
+	metadata: sessionMetadataSchema.partial().optional(),
+	agent_config: sessionAgentConfigPartialSchema.optional(),
+	permission_rules: z.array(permissionRuleSchema).optional()
+});
+z.object({
+	title: z.string().min(1).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+	title: z.string().min(1).optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/approval.ts
+const approvalDecisionSchema = z.enum([
+	"approved",
+	"rejected",
+	"cancelled"
+]);
+const approvalScopeSchema = z.enum(["session"]);
+const approvalRequestSchema = z.object({
+	approval_id: z.string().min(1),
+	session_id: z.string().min(1),
+	turn_id: z.number().int().nonnegative().optional(),
+	tool_call_id: z.string().min(1),
+	tool_name: z.string().min(1),
+	action: z.string(),
+	tool_input_display: z.unknown(),
+	created_at: isoDateTimeSchema,
+	expires_at: isoDateTimeSchema
+});
+z.object({
+	decision: approvalDecisionSchema,
+	scope: approvalScopeSchema.optional(),
+	feedback: z.string().optional(),
+	selected_label: z.string().optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/question.ts
+const questionOptionSchema = z.object({
+	id: z.string().min(1),
+	label: z.string().min(1),
+	description: z.string().optional()
+});
+const questionItemSchema = z.object({
+	id: z.string().min(1),
+	question: z.string().min(1),
+	header: z.string().optional(),
+	body: z.string().optional(),
+	options: z.array(questionOptionSchema).min(2).max(4),
+	multi_select: z.boolean().optional(),
+	allow_other: z.boolean().optional(),
+	other_label: z.string().optional(),
+	other_description: z.string().optional()
+});
+const questionRequestSchema = z.object({
+	question_id: z.string().min(1),
+	session_id: z.string().min(1),
+	turn_id: z.number().int().nonnegative().optional(),
+	tool_call_id: z.string().min(1).optional(),
+	questions: z.array(questionItemSchema).min(1).max(4),
+	created_at: isoDateTimeSchema,
+	expires_at: isoDateTimeSchema
+});
+const questionAnswerSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("single"),
+		option_id: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("multi"),
+		option_ids: z.array(z.string().min(1)).min(1)
+	}),
+	z.object({
+		kind: z.literal("other"),
+		text: z.string()
+	}),
+	z.object({
+		kind: z.literal("multi_with_other"),
+		option_ids: z.array(z.string().min(1)),
+		other_text: z.string()
+	}),
+	z.object({ kind: z.literal("skipped") })
+]);
+const questionAnswerMethodSchema = z.enum([
+	"enter",
+	"space",
+	"number_key",
+	"click"
+]);
+z.object({
+	answers: z.record(z.string().min(1), questionAnswerSchema),
+	method: questionAnswerMethodSchema.optional(),
+	note: z.string().optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/tool.ts
+const toolSourceSchema = z.enum([
+	"builtin",
+	"skill",
+	"mcp"
+]);
+const toolDescriptorSchema = z.object({
+	name: z.string().min(1),
+	description: z.string(),
+	input_schema: z.unknown(),
+	source: toolSourceSchema,
+	mcp_server_id: z.string().min(1).optional()
+});
+const mcpServerStatusSchema = z.enum([
+	"connected",
+	"connecting",
+	"disconnected",
+	"error"
+]);
+const mcpServerTransportSchema = z.enum([
+	"stdio",
+	"http",
+	"sse"
+]);
+const mcpServerSchema = z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	transport: mcpServerTransportSchema,
+	status: mcpServerStatusSchema,
+	last_error: z.string().optional(),
+	tool_count: z.number().int().nonnegative()
+});
+//#endregion
+//#region ../../packages/protocol/src/task.ts
+const backgroundTaskKindSchema = z.enum([
+	"subagent",
+	"bash",
+	"tool"
+]);
+const backgroundTaskStatusSchema = z.enum([
+	"running",
+	"completed",
+	"failed",
+	"cancelled"
+]);
+const backgroundTaskSchema = z.object({
+	id: z.string().min(1),
+	session_id: z.string().min(1),
+	kind: backgroundTaskKindSchema,
+	description: z.string(),
+	status: backgroundTaskStatusSchema,
+	created_at: isoDateTimeSchema,
+	started_at: isoDateTimeSchema.optional(),
+	completed_at: isoDateTimeSchema.optional(),
+	output_preview: z.string().optional(),
+	output_bytes: z.number().int().nonnegative().optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/fs.ts
+const fsKindSchema = z.enum([
+	"file",
+	"directory",
+	"symlink"
+]);
+const fsGitStatusSchema = z.enum([
+	"clean",
+	"modified",
+	"added",
+	"deleted",
+	"renamed",
+	"untracked",
+	"ignored",
+	"conflicted"
+]);
+const fsEntrySchema = z.object({
+	path: z.string(),
+	name: z.string(),
+	kind: fsKindSchema,
+	size: z.number().int().nonnegative().optional(),
+	modified_at: isoDateTimeSchema,
+	etag: z.string().optional(),
+	mime: z.string().optional(),
+	language_id: z.string().optional(),
+	is_binary: z.boolean().optional(),
+	is_symlink_to: z.string().optional(),
+	git_status: fsGitStatusSchema.optional(),
+	child_count: z.number().int().nonnegative().optional()
+});
+const fsSearchHitSchema = z.object({
+	path: z.string(),
+	name: z.string(),
+	kind: fsKindSchema,
+	score: z.number().min(0).max(1),
+	match_positions: z.array(z.number().int().nonnegative())
+});
+const fsGrepMatchSchema = z.object({
+	line: z.number().int().positive(),
+	col: z.number().int().positive(),
+	text: z.string(),
+	before: z.array(z.string()),
+	after: z.array(z.string())
+});
+const fsGrepFileHitSchema = z.object({
+	path: z.string(),
+	matches: z.array(fsGrepMatchSchema)
+});
+z.object({
+	path: z.string(),
+	status: fsGitStatusSchema,
+	rename_from: z.string().optional()
+});
+const fsChangeKindSchema = z.enum([
+	"file",
+	"directory",
+	"symlink"
+]);
+const fsChangeActionSchema = z.enum([
+	"created",
+	"modified",
+	"deleted"
+]);
+const fsChangeEntrySchema = z.object({
+	path: z.string(),
+	change: fsChangeActionSchema,
+	kind: fsChangeKindSchema,
+	size_delta: z.number().int().optional(),
+	etag: z.string().optional()
+});
+z.object({
+	changes: z.array(fsChangeEntrySchema),
+	coalesced_window_ms: z.number().int().positive(),
+	truncated: z.boolean().optional(),
+	count: z.number().int().nonnegative().optional()
+});
+z.object({
+	id: z.string().min(1),
+	name: z.string().min(1),
+	media_type: z.string().min(1),
+	size: z.number().int().nonnegative(),
+	created_at: isoDateTimeSchema,
+	expires_at: isoDateTimeSchema.optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/modelCatalog.ts
+const modelCatalogItemSchema = z.object({
+	provider: z.string().min(1),
+	model: z.string().min(1),
+	display_name: z.string().min(1).optional(),
+	max_context_size: z.number().int().min(1),
+	capabilities: z.array(z.string()).optional()
+});
+const providerCatalogStatusSchema = z.enum([
+	"connected",
+	"error",
+	"unconfigured"
+]);
+const providerCatalogItemSchema = z.object({
+	id: z.string().min(1),
+	type: z.string().min(1),
+	base_url: z.string().min(1).optional(),
+	default_model: z.string().min(1).optional(),
+	has_api_key: z.boolean(),
+	status: providerCatalogStatusSchema,
+	models: z.array(z.string().min(1)).optional()
+});
+//#endregion
+//#region ../../packages/protocol/src/rest/meta.ts
+/**
+* GET /v1/meta
+*   Reply: MetaResponse {
+*     daemon_version,
+*     capabilities,
+*     daemon_id,
+*     started_at
+*   }
+*/
+const metaCapabilitiesSchema = z.object({
+	websocket: z.literal(true),
+	file_upload: z.literal(true),
+	fs_query: z.literal(true),
+	mcp: z.literal(true),
+	background_tasks: z.literal(true)
+});
+z.object({
+	daemon_version: z.string().min(1),
+	capabilities: metaCapabilitiesSchema,
+	daemon_id: z.string().min(1),
+	started_at: isoDateTimeSchema
+});
+//#endregion
+//#region ../../packages/protocol/src/rest/auth.ts
+/**
+* GET /v1/auth
+*   Reply: AuthSummary {
+*     ready,
+*     providers_count,
+*     default_model,
+*     managed_provider
+*   }
+*/
+const managedProviderStatusSchema = z.enum([
+	"authenticated",
+	"expired",
+	"revoked",
+	"unauthenticated"
+]);
+const managedProviderSummarySchema = z.object({
+	name: z.string().min(1),
+	status: managedProviderStatusSchema
+});
+z.object({
+	ready: z.boolean(),
+	providers_count: z.number().int().nonnegative(),
+	default_model: z.string().nullable(),
+	managed_provider: managedProviderSummarySchema.nullable()
+});
+//#endregion
+//#region ../../packages/protocol/src/rest/oauth.ts
+/**
+*   POST   /v1/oauth/login   body: { provider? }   data: OAuthFlowStart
+*   GET    /v1/oauth/login   query: { provider? }  data: OAuthFlowStatus | null
+*   DELETE /v1/oauth/login   query: { provider? }  data: { cancelled, status }
+*   POST   /v1/oauth/logout  body: { provider? }   data: { logged_out, provider }
+*/
+const oauthFlowStatusEnum = z.enum([
+	"pending",
+	"authenticated",
+	"denied",
+	"expired",
+	"cancelled"
+]);
+z.object({ provider: z.string().min(1).optional() });
+z.object({
+	flow_id: z.string().min(1),
+	provider: z.string().min(1),
+	verification_uri: z.string().url(),
+	verification_uri_complete: z.string().url(),
+	user_code: z.string().min(1),
+	expires_in: z.number().int().positive(),
+	interval: z.number().int().positive(),
+	status: z.literal("pending"),
+	expires_at: isoDateTimeSchema
+});
+z.object({
+	flow_id: z.string().min(1),
+	provider: z.string().min(1),
+	status: oauthFlowStatusEnum,
+	verification_uri: z.string().url(),
+	verification_uri_complete: z.string().url(),
+	user_code: z.string().min(1),
+	expires_in: z.number().int().positive(),
+	expires_at: isoDateTimeSchema,
+	interval: z.number().int().positive(),
+	resolved_at: isoDateTimeSchema.optional(),
+	error_message: z.string().optional()
+});
+z.object({ provider: z.string().min(1).optional() });
+z.object({
+	cancelled: z.boolean(),
+	status: oauthFlowStatusEnum
+});
+z.object({ provider: z.string().min(1).optional() });
+z.object({
+	logged_out: z.literal(true),
+	provider: z.string().min(1)
+});
+cursorQuerySchema.and(z.object({ status: sessionStatusSchema.optional() }));
+pageResponseSchema(sessionSchema);
+const sessionStatusResponseSchema = z.object({
+	model: z.string().optional(),
+	thinking_level: z.string(),
+	permission: z.string(),
+	plan_mode: z.boolean(),
+	context_tokens: z.number().int().nonnegative(),
+	max_context_tokens: z.number().int().nonnegative(),
+	context_usage: z.number().min(0).max(1)
+});
+z.preprocess((value) => value === void 0 ? {} : value, z.object({ instruction: z.string().optional() }));
+z.object({});
+z.preprocess((value) => value === void 0 ? {} : value, z.object({
+	count: z.number().int().positive().default(1),
+	page_size: z.number().int().min(1).max(100).optional()
+}));
+z.object({
+	messages: pageResponseSchema(messageSchema),
+	status: sessionStatusResponseSchema
+});
+z.object({ deleted: z.literal(true) });
+z.object({ items: z.array(workspaceSchema) });
+z.object({ workspace_id: workspaceIdSchema });
+z.object({ deleted: z.literal(true) });
+z.object({ path: z.string().min(1).optional() });
+const fsBrowseEntrySchema = z.object({
+	name: z.string().min(1),
+	path: z.string().min(1),
+	is_dir: z.literal(true),
+	is_git_repo: z.boolean(),
+	branch: z.string().optional()
+});
+z.object({
+	path: z.string().min(1),
+	parent: z.string().min(1).nullable(),
+	entries: z.array(fsBrowseEntrySchema)
+});
+z.object({
+	home: z.string().min(1),
+	recent_roots: z.array(z.string().min(1))
+});
+cursorQuerySchema.and(z.object({ role: messageRoleSchema.optional() }));
+z.object({
+	items: z.array(messageSchema),
+	has_more: z.boolean()
+});
+z.object({ status: z.literal("pending") });
+z.object({ items: z.array(approvalRequestSchema) });
+z.object({
+	resolved: z.literal(true),
+	resolved_at: isoDateTimeSchema
+});
+z.object({ resolved: z.literal(false) });
+z.object({ status: z.literal("pending") });
+z.object({ items: z.array(questionRequestSchema) });
+z.object({
+	resolved: z.literal(true),
+	resolved_at: isoDateTimeSchema
+});
+z.object({ resolved: z.literal(false) });
+z.object({
+	dismissed: z.literal(true),
+	dismissed_at: isoDateTimeSchema
+});
+z.object({ session_id: z.string().min(1).optional() });
+z.object({ tools: z.array(toolDescriptorSchema) });
+z.object({ servers: z.array(mcpServerSchema) });
+z.object({ restarting: z.literal(true) });
+z.object({ status: backgroundTaskStatusSchema.optional() });
+z.object({ items: z.array(backgroundTaskSchema) });
+z.object({
+	with_output: z.coerce.boolean().optional(),
+	output_bytes: z.coerce.number().int().nonnegative().optional()
+});
+z.object({ cancelled: z.literal(true) });
+z.object({ cancelled: z.literal(false) });
+//#endregion
+//#region ../../packages/protocol/src/rest/fs.ts
+/**
+*   POST /v1/sessions/{sid}/fs:list
+*     Body: FsListRequest
+*     Response data: FsListResponse  { items, children_by_path?, truncated }
+*     Errors: 40401, 40409, 41304, 41303
+*
+*   POST /v1/sessions/{sid}/fs:read
+*     Body: FsReadRequest
+*     Response data: FsReadResponse
+*     Errors: 40401, 40409, 40906, 40907, 41302, 41304
+*   POST /v1/sessions/{sid}/fs:list_many
+*     Body: FsListManyRequest  (paths[] up to 100)
+*     Response data: FsListManyResponse  { results, truncated_paths?,
+*                                          partial_errors? }
+*
+*   POST /v1/sessions/{sid}/fs:stat
+*     Body: FsStatRequest
+*     Response data: FsEntry
+*     Errors: 40401, 40409, 41304
+*
+*   POST /v1/sessions/{sid}/fs:stat_many
+*     Body: FsStatManyRequest  (paths[] up to 1000)
+*     Response data: FsStatManyResponse  { entries: { [path]: FsEntry | null } }
+*     Per-path failures land as `null` (REST.md §3.9 line 524); only
+*     path-safety (41304) fails the whole call.
+*   POST /v1/sessions/{sid}/fs:search
+*     Body: FsSearchRequest   { query, limit?, include_globs?, exclude_globs?,
+*                               follow_gitignore? }
+*     Response data: FsSearchResponse  { items, truncated }
+*     Errors: 40401, 41303, 41304
+*
+*   POST /v1/sessions/{sid}/fs:grep
+*     Body: FsGrepRequest
+*     Response data: FsGrepResponse  { files, files_scanned, truncated,
+*                                      elapsed_ms }
+*     Errors: 40401, 41303, 41304, 41305 (>30s grep timeout)
+*   POST /v1/sessions/{sid}/fs:git_status
+*     Body: FsGitStatusRequest  { paths? }
+*     Response data: FsGitStatusResponse  { branch, ahead, behind, entries }
+*     Errors: 40401, 40908 (not a git repo), 41304
+*
+*   GET /v1/sessions/{sid}/fs/{path}:download
+*     Response: binary stream or envelope (40401 / 40409 / 41304)
+*/
+const fsListSortSchema = z.enum([
+	"type_first",
+	"name_asc",
+	"name_desc",
+	"mtime_desc",
+	"size_desc"
+]);
+z.object({
+	path: z.string().default("."),
+	depth: z.number().int().min(1).max(10).default(1),
+	limit: z.number().int().min(1).max(1e3).default(200),
+	show_hidden: z.boolean().default(false),
+	follow_gitignore: z.boolean().default(true),
+	exclude_globs: z.array(z.string()).optional(),
+	sort: fsListSortSchema.default("type_first"),
+	include_git_status: z.boolean().default(false)
+});
+z.object({
+	items: z.array(fsEntrySchema),
+	children_by_path: z.record(z.string(), z.array(fsEntrySchema)).optional(),
+	truncated: z.boolean()
+});
+const fsReadEncodingRequestSchema = z.enum([
+	"auto",
+	"utf-8",
+	"base64"
+]);
+const fsReadEncodingResponseSchema = z.enum(["utf-8", "base64"]);
+z.object({
+	path: z.string().min(1),
+	offset: z.number().int().nonnegative().default(0),
+	length: z.number().int().min(1).max(10485760).default(1048576),
+	encoding: fsReadEncodingRequestSchema.default("auto")
+});
+z.object({
+	path: z.string(),
+	content: z.string(),
+	encoding: fsReadEncodingResponseSchema,
+	size: z.number().int().nonnegative(),
+	truncated: z.boolean(),
+	etag: z.string(),
+	mime: z.string(),
+	language_id: z.string().optional(),
+	line_count: z.number().int().nonnegative().optional(),
+	is_binary: z.boolean()
+});
+z.object({
+	paths: z.array(z.string().min(1)).min(1).max(100),
+	depth: z.number().int().min(1).max(10).default(1),
+	limit: z.number().int().min(1).max(1e3).default(200),
+	show_hidden: z.boolean().default(false),
+	follow_gitignore: z.boolean().default(true),
+	exclude_globs: z.array(z.string()).optional(),
+	sort: fsListSortSchema.default("type_first"),
+	include_git_status: z.boolean().default(false)
+});
+const fsListManyPartialErrorSchema = z.object({
+	code: z.number().int(),
+	msg: z.string()
+});
+z.object({
+	results: z.record(z.string(), z.array(fsEntrySchema)),
+	truncated_paths: z.array(z.string()).optional(),
+	partial_errors: z.record(z.string(), fsListManyPartialErrorSchema).optional()
+});
+z.object({ path: z.string().min(1) });
+z.object({ paths: z.array(z.string().min(1)).min(1).max(1e3) });
+z.object({ entries: z.record(z.string(), fsEntrySchema.nullable()) });
+z.object({
+	query: z.string().min(1),
+	limit: z.number().int().min(1).max(200).default(50),
+	include_globs: z.array(z.string()).optional(),
+	exclude_globs: z.array(z.string()).optional(),
+	follow_gitignore: z.boolean().default(true)
+});
+z.object({
+	items: z.array(fsSearchHitSchema),
+	truncated: z.boolean()
+});
+z.object({
+	pattern: z.string().min(1),
+	regex: z.boolean().default(false),
+	case_sensitive: z.boolean().default(true),
+	include_globs: z.array(z.string()).optional(),
+	exclude_globs: z.array(z.string()).optional(),
+	follow_gitignore: z.boolean().default(true),
+	max_files: z.number().int().min(1).max(1e4).default(200),
+	max_matches_per_file: z.number().int().min(1).max(1e4).default(50),
+	max_total_matches: z.number().int().min(1).max(1e5).default(5e3),
+	context_lines: z.number().int().min(0).max(10).default(2)
+});
+z.object({
+	files: z.array(fsGrepFileHitSchema),
+	files_scanned: z.number().int().nonnegative(),
+	truncated: z.boolean(),
+	elapsed_ms: z.number().int().nonnegative()
+});
+z.object({ paths: z.array(z.string().min(1)).optional() });
+z.object({
+	branch: z.string(),
+	ahead: z.number().int().nonnegative(),
+	behind: z.number().int().nonnegative(),
+	entries: z.record(z.string(), fsGitStatusSchema)
+});
+z.object({
+	path: z.string().min(1),
+	range: z.string().optional(),
+	if_none_match: z.string().optional()
+});
+z.object({ file_id: z.string().min(1) });
+z.object({ file_id: z.string().min(1) });
+z.object({ deleted: z.literal(true) });
+z.object({ items: z.array(modelCatalogItemSchema) });
+z.object({ items: z.array(providerCatalogItemSchema) });
+z.object({
+	default_model: z.string().min(1),
+	model: modelCatalogItemSchema
+});
 //#endregion
 //#region ../../packages/agent-core/src/mcp/oauth/callback-server.ts
 /**
@@ -80754,9 +82111,19 @@ var SkillTool = class SkillTool {
 		const skillArgs = args.args ?? "";
 		if (!isInlineSkillType(skill.metadata.type)) return errorResult(`Skill "${skill.name}" is not an inline skill and cannot be invoked by the model in v1.`);
 		const origin = skillOrigin(skill, skillArgs, currentDepth);
+		const promptTrigger = origin.trigger === "nested-skill" ? "nested-skill" : "model-tool";
 		skills.recordActivation(origin);
 		const skillContent = skills.registry.renderSkillPrompt(skill, skillArgs);
-		this.agent.context.appendSystemReminder(`<kimi-skill-loaded name="${escapeXml(skill.name)}" args="${escapeXml(skillArgs)}">\n${skillContent}\n</kimi-skill-loaded>`, origin);
+		this.agent.context.appendUserMessage([{
+			type: "text",
+			text: renderModelToolSkillPrompt({
+				skillName: skill.name,
+				skillArgs,
+				skillContent,
+				skillSource: skill.source,
+				trigger: promptTrigger
+			})
+		}], origin);
 		return { output: `Skill "${skill.name}" loaded inline. Follow its instructions.` };
 	}
 };
@@ -80816,7 +82183,7 @@ function makeCarriageReturnsVisible(text) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/edit.md
-var edit_default = "Perform exact string replacements against the text view returned by Read.\n\n- When copying from Read output, omit the line-number prefix and tab; match only the file content.\n- By default, old_string must occur exactly once. If it matches multiple locations, add surrounding context or set replace_all when every occurrence should change.\n- Prefer Edit for targeted changes to existing files; use Write only for new files or complete overwrites.\n- To modify a file, always use Edit; do not run a Shell `sed` command for edits.\n- When making several independent changes, issue multiple Edit calls in parallel within a single response; edits to the same file are serialized automatically by a write lock.\n- When several parallel Edit calls target the same file, a write lock serializes them; they apply in the order the calls appear in your response. An edit fails with `old_string not found` if its old_string was taken from text an earlier edit already replaced — base every old_string on the latest Read view and order dependent edits accordingly.\n- For pure CRLF files, Read shows LF and Edit.old_string/new_string should use LF; Edit writes the file back with CRLF preserved.\n- For mixed line endings or lone carriage returns, Read displays carriage returns as \\r; include actual \\r escapes in old_string/new_string for those positions.";
+var edit_default = "Perform exact replacements in existing files.\n\n- Edit is mandatory for every incremental change, especially small edits. DO NOT use Write or Bash `sed`.\n- Read the target file before every Edit. DO NOT call Edit from memory, stale context, or a guessed `old_string`.\n- Take `old_string` and `new_string` from the Read output view.\n- Drop the line-number prefix and tab; match only file content.\n- `old_string` must be unique unless `replace_all` is set.\n- If `old_string` is ambiguous, add surrounding context. Use `replace_all` only when every occurrence should change.\n- Multiple Edit calls may run in one response only when they do not target the same file.\n- DO NOT issue consecutive Edit calls on the same file. A previous Edit can invalidate a later Edit's `old_string`, causing `old_string not found`. Read the file again before the next Edit.\n- A write lock serializes same-file edits in response order, but serialization does not make stale `old_string` valid.\n- For pure CRLF files, Read shows LF; use LF in `old_string` and `new_string`, and Edit writes CRLF back.\n- For mixed endings or lone carriage returns, Read shows carriage returns as \\r; include actual \\r escapes in those positions.\n";
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/edit.ts
 const EditInputSchema = z.object({
@@ -87103,7 +88470,7 @@ var ReadMediaFileTool = class {
 };
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/write.md
-var write_default = "Overwrite or append to a file with content exactly as provided, creating the file if needed; the parent directory must already exist. Defaults to overwrite; append adds content to the end without adding a newline. Write does not use the Read/Edit model text view and does not preserve or infer the previous line-ending style: \\n stays LF, \\r\\n stays CRLF. Use Edit for targeted changes to existing files. When the content is very large, you can split it across multiple calls: write the first chunk with overwrite, then add the remaining chunks with append.\n";
+var write_default = "Create, append to, or replace a file entirely.\n\n- The parent directory must already exist.\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- For new content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\n";
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/write.ts
 /** Mask isolating the file-type bits of a stat mode. */
@@ -87893,6 +89260,10 @@ var TurnFlow = class {
 			}
 		}
 		if (this.currentId === turnId) this.agent.usage.endTurn();
+		if (ended.reason === "cancelled" && isUserCancellation(signal.reason)) this.agent.hooks?.fireAndForgetTrigger("Interrupt", { inputData: {
+			turnId,
+			reason: "cancelled"
+		} });
 		this.agent.emitEvent(ended);
 		if (standalone && this.currentId === turnId) this.activeTurn = null;
 		if (this.agent.swarmMode.shouldAutoExit) this.agent.swarmMode.exit();
@@ -137212,6 +138583,9 @@ new AsyncLocalStorage();
 //#endregion
 //#region ../../packages/agent-core/src/rpc/core-impl.ts
 const KIMI_CODE_PROVIDER_NAME$1 = "managed:kimi-code";
+const KIMI_CODE_BASE_URL_ENV = "KIMI_CODE_BASE_URL";
+const KIMI_CODE_OAUTH_HOST_ENV = "KIMI_CODE_OAUTH_HOST";
+const KIMI_OAUTH_HOST_ENV = "KIMI_OAUTH_HOST";
 var KimiCore = class {
 	rpcClient;
 	sdk;
@@ -137417,6 +138791,7 @@ var KimiCore = class {
 	async forkSession(input) {
 		const source = await this.sessionStore.get(input.sessionId);
 		const active = this.sessions.get(source.id);
+		if (active?.hasActiveTurn === true) throw new KimiError(ErrorCodes.SESSION_FORK_ACTIVE_TURN, `Session "${source.id}" cannot be forked while a turn is running`, { details: { sessionId: source.id } });
 		if (active !== void 0) await active.flushMetadata();
 		const id = input.id ?? createSessionId();
 		await this.sessionStore.fork({
@@ -137700,13 +139075,38 @@ var KimiCore = class {
 		});
 	}
 	mergePluginMcpConfig(base) {
-		const pluginServers = this.plugins.enabledMcpServers();
+		const pluginServers = this.withManagedKimiPluginEnv(this.plugins.enabledMcpServers());
 		if (Object.keys(pluginServers).length === 0) return base;
 		return { servers: {
 			...base?.servers,
 			...pluginServers
 		} };
 	}
+	withManagedKimiPluginEnv(pluginServers) {
+		const managedEnv = this.managedKimiCodeEnvForPlugins();
+		if (Object.keys(managedEnv).length === 0) return pluginServers;
+		const out = {};
+		for (const [name, server] of Object.entries(pluginServers)) out[name] = server.transport === "stdio" ? {
+			...server,
+			env: {
+				...server.env,
+				...managedEnv
+			}
+		} : server;
+		return out;
+	}
+	managedKimiCodeEnvForPlugins() {
+		const provider = this.config.providers[KIMI_CODE_PROVIDER_NAME$1];
+		const envBaseUrl = process.env[KIMI_CODE_BASE_URL_ENV];
+		const envOAuthHost = process.env[KIMI_CODE_OAUTH_HOST_ENV] ?? process.env[KIMI_OAUTH_HOST_ENV];
+		const hasEnvOverride = envBaseUrl !== void 0 || envOAuthHost !== void 0;
+		const baseUrl = envBaseUrl !== void 0 ? envBaseUrl.replace(/\/+$/, "") : provider?.baseUrl;
+		const oauthHost = hasEnvOverride ? envOAuthHost : provider?.oauth?.oauthHost;
+		const env = {};
+		if (baseUrl !== void 0) env[KIMI_CODE_BASE_URL_ENV] = baseUrl;
+		if (oauthHost !== void 0) env[KIMI_CODE_OAUTH_HOST_ENV] = oauthHost;
+		return env;
+	}
 	sessionApi(sessionId) {
 		const session = this.sessions.get(sessionId);
 		if (session === void 0) throw new KimiError(ErrorCodes.SESSION_NOT_FOUND, `Session "${sessionId}" was not found`, { details: { sessionId } });
@@ -160203,6 +161603,163 @@ var WelcomeComponent = class {
 	}
 };
 //#endregion
+//#region src/tui/components/dialogs/compaction.ts
+/**
+* Renders a compaction block in the transcript.
+*
+* Lifecycle:
+*   - constructed on `compaction.started` → blinking white bullet +
+*     "Compacting context..." and optional custom instruction
+*   - `markDone()` on `compaction.completed` → solid green bullet +
+*     "Compaction complete (X → Y tokens)"
+*   - `markCanceled()` on `compaction.cancelled` → solid warning bullet +
+*     "Compaction cancelled"
+*
+* Bullet animation mirrors `ToolCallComponent` (500ms blink) so the user
+* reads the same "work in progress" signal across the UI.
+*/
+const BLINK_INTERVAL = 500;
+var CompactionComponent = class extends Container {
+	ui;
+	headerText;
+	instruction;
+	blinkOn = true;
+	blinkTimer = null;
+	done = false;
+	canceled = false;
+	tokensBefore;
+	tokensAfter;
+	constructor(ui, instruction) {
+		super();
+		this.ui = ui;
+		this.instruction = instruction;
+		this.addChild(new Spacer(1));
+		this.headerText = new Text(this.buildHeader(), 0, 0);
+		this.addChild(this.headerText);
+		this.addInstructionChild();
+		this.startBlink();
+	}
+	addInstructionChild() {
+		if (this.instruction !== void 0) this.addChild(new Text(currentTheme.dim(`  ${this.instruction}`), 0, 0));
+	}
+	invalidate() {
+		this.headerText.setText(this.buildHeader());
+		if (this.instruction !== void 0) {
+			if (this.children.length > 2) this.children.pop();
+			this.addInstructionChild();
+		}
+		super.invalidate();
+	}
+	markDone(tokensBefore, tokensAfter) {
+		if (this.done || this.canceled) return;
+		this.done = true;
+		this.tokensBefore = tokensBefore;
+		this.tokensAfter = tokensAfter;
+		this.stopBlink();
+		this.headerText.setText(this.buildHeader());
+		this.ui?.requestRender();
+	}
+	markCanceled() {
+		if (this.done || this.canceled) return;
+		this.canceled = true;
+		this.stopBlink();
+		this.headerText.setText(this.buildHeader());
+		this.ui?.requestRender();
+	}
+	dispose() {
+		this.stopBlink();
+	}
+	buildHeader() {
+		if (this.done) return `${currentTheme.fg("success", STATUS_BULLET)}${currentTheme.boldFg("success", "Compaction complete")}${this.tokensBefore !== void 0 && this.tokensAfter !== void 0 ? currentTheme.dim(` (${String(this.tokensBefore)} → ${String(this.tokensAfter)} tokens)`) : ""}`;
+		if (this.canceled) return `${currentTheme.fg("warning", STATUS_BULLET)}${currentTheme.boldFg("warning", "Compaction cancelled")}`;
+		return `${this.blinkOn ? currentTheme.fg("text", STATUS_BULLET) : "  "}${currentTheme.boldFg("primary", "Compacting context...")}`;
+	}
+	startBlink() {
+		this.blinkTimer = setInterval(() => {
+			this.blinkOn = !this.blinkOn;
+			this.headerText.setText(this.buildHeader());
+			this.ui?.requestRender();
+		}, BLINK_INTERVAL);
+	}
+	stopBlink() {
+		if (this.blinkTimer !== null) {
+			clearInterval(this.blinkTimer);
+			this.blinkTimer = null;
+		}
+	}
+};
+//#endregion
+//#region src/tui/components/dialogs/undo-selector.ts
+const MAX_VISIBLE_CHOICES = 5;
+const PREFERRED_SELECTED_OFFSET = 2;
+var UndoSelectorComponent = class extends Container {
+	focused = false;
+	opts;
+	list;
+	submitted = false;
+	constructor(opts) {
+		super();
+		this.opts = opts;
+		this.list = new SearchableList({
+			items: opts.choices,
+			toSearchText: (choice) => choice.label,
+			initialIndex: Math.max(0, opts.choices.length - 1)
+		});
+	}
+	handleInput(data) {
+		if (this.submitted) return;
+		if (matchesKey(data, Key.escape)) {
+			this.opts.onCancel();
+			return;
+		}
+		if (this.list.handleKey(data)) return;
+		if (matchesKey(data, Key.enter)) {
+			const selected = this.list.selected();
+			if (selected !== void 0) {
+				this.submitted = true;
+				this.opts.onSelect(selected);
+			}
+		}
+	}
+	render(width) {
+		const view = this.list.view();
+		const lines = [
+			currentTheme.fg("primary", "─".repeat(width)),
+			currentTheme.boldFg("primary", " Select messages to undo"),
+			currentTheme.fg("textMuted", " " + [
+				"↑↓ navigate",
+				"Enter select",
+				"Esc cancel"
+			].join(" · ")),
+			""
+		];
+		if (view.items.length === 0) lines.push(currentTheme.fg("textMuted", "   No messages"));
+		else {
+			const visibleCount = Math.min(MAX_VISIBLE_CHOICES, view.items.length);
+			const maxStart = view.items.length - visibleCount;
+			const start = Math.min(Math.max(0, view.selectedIndex - PREFERRED_SELECTED_OFFSET), maxStart);
+			const end = start + visibleCount;
+			for (let i = start; i < end; i++) {
+				const choice = view.items[i];
+				if (choice === void 0) continue;
+				lines.push(this.renderChoiceLine(choice, i === view.selectedIndex, i > view.selectedIndex, width));
+			}
+		}
+		lines.push("");
+		lines.push(currentTheme.fg("primary", "─".repeat(width)));
+		return lines.map((line) => truncateToWidth(line, width));
+	}
+	renderChoiceLine(choice, isSelected, inUndoRange, width) {
+		const prefix = `  ${isSelected ? "❯" : " "} `;
+		const labelBudget = Math.max(8, width - visibleWidth(prefix));
+		const label = truncateToWidth(choice.label, labelBudget, "…");
+		const token = isSelected ? "primary" : inUndoRange ? "textDim" : "text";
+		let line = currentTheme.fg(isSelected ? "primary" : "textDim", prefix);
+		line += isSelected ? currentTheme.boldFg(token, label) : currentTheme.fg(token, label);
+		return line;
+	}
+};
+//#endregion
 //#region src/tui/components/messages/agent-group.ts
 const THROTTLE_MS$1 = 200;
 var AgentGroupComponent = class extends Container {
@@ -164517,34 +166074,64 @@ function getTranscriptComponentEntry(component) {
 	return componentEntries.get(component);
 }
 //#endregion
+//#region src/tui/utils/transcript-id.ts
+let transcriptIdCounter = 0;
+function nextTranscriptId() {
+	transcriptIdCounter += 1;
+	return `entry-${String(transcriptIdCounter)}`;
+}
+//#endregion
 //#region src/tui/commands/undo.ts
+const UNDO_LIMIT_STATUS_TURN_ID = "undo-limit-status";
 async function handleUndoCommand(host, args = "") {
 	if (host.state.appState.streamingPhase !== "idle") {
 		host.showError("Cannot undo while streaming — press Esc or Ctrl-C first.");
 		return;
 	}
-	const count = parseUndoCount(args);
+	const trimmed = args.trim();
+	if (trimmed.length === 0) {
+		await showUndoSelector(host);
+		return;
+	}
+	const count = parseUndoCount(trimmed);
 	if (count === void 0) {
 		host.showError("Usage: /undo [count], where count is a positive integer.");
 		return;
 	}
+	if (host.session === void 0) {
+		host.showError(NO_ACTIVE_SESSION_MESSAGE);
+		return;
+	}
+	const availability = await resolveUndoAvailability(host);
+	if (count > availability.maxCount) {
+		showUndoLimitStatus(host, formatUndoLimitMessage(count, availability));
+		return;
+	}
+	await undoByCount(host, count);
+}
+async function undoByCount(host, count) {
 	const session = host.session;
 	if (session === void 0) {
 		host.showError(NO_ACTIVE_SESSION_MESSAGE);
-		return;
+		return false;
 	}
 	const entries = host.state.transcriptEntries;
 	const lastUserIndex = findUndoAnchorEntryIndex(entries, count);
 	if (lastUserIndex === void 0) {
-		host.showError("Nothing to undo.");
-		return;
+		showUndoLimitStatus(host, "Nothing to undo.");
+		return false;
 	}
 	try {
 		await session.undoHistory(count);
 	} catch (error) {
+		const limit = undoLimitFromError(error);
+		if (limit !== void 0) {
+			showUndoLimitStatus(host, formatUndoLimitMessage(limit.requestedCount, limit));
+			return false;
+		}
 		const message = formatErrorMessage$2(error);
 		host.showError(`Failed to undo: ${message}`);
-		return;
+		return false;
 	}
 	const children = host.state.transcriptContainer.children;
 	const lastUserComponentIndex = findUndoAnchorComponentIndex(children, count);
@@ -164556,6 +166143,34 @@ async function handleUndoCommand(host, args = "") {
 	entries.splice(lastUserIndex, entries.length - lastUserIndex, ...preservedEntries);
 	if (entries.length === 0) renderWelcome(host);
 	host.state.ui.requestRender();
+	return true;
+}
+async function showUndoSelector(host) {
+	if (host.session === void 0) {
+		host.showError(NO_ACTIVE_SESSION_MESSAGE);
+		return;
+	}
+	const availability = await resolveUndoAvailability(host);
+	const choices = createUndoChoices(host.state.transcriptEntries, host.state.transcriptContainer.children, availability.maxCount);
+	if (choices.length === 0) {
+		showUndoLimitStatus(host, formatNothingToUndoMessage(availability));
+		return;
+	}
+	host.mountEditorReplacement(new UndoSelectorComponent({
+		choices,
+		onSelect: (choice) => {
+			undoByCount(host, choice.count).then((undone) => {
+				if (undone) {
+					host.restoreInputText(choice.input);
+					return;
+				}
+				host.restoreEditor();
+			});
+		},
+		onCancel: () => {
+			host.restoreEditor();
+		}
+	}));
 }
 function parseUndoCount(args) {
 	const value = args.trim();
@@ -164564,6 +166179,138 @@ function parseUndoCount(args) {
 	const count = Number(value);
 	return Number.isSafeInteger(count) ? count : void 0;
 }
+async function resolveUndoAvailability(host) {
+	const local = undoAvailabilityFromTranscript(host.state.transcriptEntries, host.state.transcriptContainer.children);
+	const context = await getSessionContext(host.session);
+	if (context === void 0) return local;
+	const activeContext = undoAvailabilityFromContext(context.history);
+	return {
+		maxCount: Math.min(local.maxCount, activeContext.maxCount),
+		stoppedAtCompaction: local.stoppedAtCompaction || activeContext.stoppedAtCompaction
+	};
+}
+async function getSessionContext(session) {
+	const getContext = session?.getContext;
+	if (session === void 0 || getContext === void 0) return void 0;
+	try {
+		return await getContext.call(session);
+	} catch {
+		return;
+	}
+}
+function undoAvailabilityFromTranscript(entries, children) {
+	const { anchors, stoppedAtCompaction } = activeUndoAnchorEntries(entries, children);
+	return {
+		maxCount: anchors.length,
+		stoppedAtCompaction
+	};
+}
+function undoAvailabilityFromContext(history) {
+	let maxCount = 0;
+	let stoppedAtCompaction = false;
+	for (let i = history.length - 1; i >= 0; i--) {
+		const message = history[i];
+		if (message === void 0) continue;
+		if (message.origin?.kind === "injection") continue;
+		if (message.origin?.kind === "compaction_summary") {
+			stoppedAtCompaction = true;
+			break;
+		}
+		if (isContextUndoAnchor(message)) maxCount++;
+	}
+	return {
+		maxCount,
+		stoppedAtCompaction
+	};
+}
+function isContextUndoAnchor(message) {
+	if (message.role !== "user") return false;
+	const origin = message.origin;
+	if (origin === void 0 || origin.kind === "user") return true;
+	if (origin.kind === "skill_activation") return origin.trigger === "user-slash";
+	return false;
+}
+function createUndoChoices(entries, children, maxCount) {
+	if (maxCount <= 0) return [];
+	const anchors = activeUndoAnchorEntries(entries, children).anchors.slice(-maxCount);
+	return anchors.map((entry, index) => ({
+		id: entry.id,
+		count: anchors.length - index,
+		input: formatUndoChoiceInput(entry),
+		label: formatUndoChoiceLabel(entry)
+	}));
+}
+function activeUndoAnchorEntries(entries, children) {
+	const lastCompactionChildIndex = children.findLastIndex((child) => child instanceof CompactionComponent);
+	if (lastCompactionChildIndex >= 0) return {
+		anchors: children.slice(lastCompactionChildIndex + 1).map((child) => getTranscriptComponentEntry(child)).filter((entry) => entry !== void 0).filter(isUndoAnchorEntry),
+		stoppedAtCompaction: true
+	};
+	const lastCompactionEntryIndex = entries.findLastIndex((entry) => entry.compactionData !== void 0);
+	return {
+		anchors: (lastCompactionEntryIndex >= 0 ? entries.slice(lastCompactionEntryIndex + 1) : entries).filter(isUndoAnchorEntry),
+		stoppedAtCompaction: lastCompactionEntryIndex >= 0
+	};
+}
+function formatUndoChoiceLabel(entry) {
+	if (entry.kind === "skill_activation") {
+		const name = singleLine$2(entry.skillName ?? entry.content.replace(/^Activated skill:\s*/, ""));
+		const args = singleLine$2(entry.skillArgs ?? "");
+		if (name.length === 0) return "Skill: unknown";
+		return args.length > 0 ? `/${name} ${args}` : `/${name}`;
+	}
+	const content = singleLine$2(entry.content);
+	const imageCount = entry.imageAttachmentIds?.length ?? 0;
+	if (content.length > 0) return content;
+	if (imageCount > 0) return `User message (${String(imageCount)} ${imageCount === 1 ? "image" : "images"})`;
+	return "User message";
+}
+function formatUndoChoiceInput(entry) {
+	if (entry.kind === "skill_activation") {
+		const name = singleLine$2(entry.skillName ?? entry.content.replace(/^Activated skill:\s*/, ""));
+		const args = singleLine$2(entry.skillArgs ?? "");
+		if (name.length === 0) return "";
+		return args.length > 0 ? `/${name} ${args}` : `/${name}`;
+	}
+	return entry.content;
+}
+function singleLine$2(text) {
+	return text.replaceAll(/\s+/g, " ").trim();
+}
+function formatUndoLimitMessage(requestedCount, availability) {
+	const reason = availability.stoppedAtCompaction ? " after the last compaction" : "";
+	return `Cannot undo ${formatPromptCount(requestedCount)}; only ${formatPromptCount(availability.maxCount)} can be undone in the active context${reason}.`;
+}
+function formatNothingToUndoMessage(availability) {
+	if (availability.stoppedAtCompaction) return "Nothing to undo after the last compaction.";
+	return "Nothing to undo.";
+}
+function formatPromptCount(count) {
+	return `${String(count)} ${count === 1 ? "prompt" : "prompts"}`;
+}
+function showUndoLimitStatus(host, message) {
+	host.appendTranscriptEntry({
+		id: nextTranscriptId(),
+		kind: "status",
+		turnId: UNDO_LIMIT_STATUS_TURN_ID,
+		renderMode: "plain",
+		content: message
+	});
+}
+function undoLimitFromError(error) {
+	if (!isKimiError(error)) return void 0;
+	const details = error.details;
+	if (details?.["reason"] !== "undo_limit") return void 0;
+	const requestedCount = details["requestedCount"];
+	const maxCount = details["undoableCount"];
+	const stoppedAtCompaction = details["stoppedAtCompaction"];
+	if (typeof requestedCount !== "number" || typeof maxCount !== "number" || typeof stoppedAtCompaction !== "boolean") return;
+	return {
+		requestedCount,
+		maxCount,
+		stoppedAtCompaction
+	};
+}
 function isUndoAnchorEntry(entry) {
 	return entry.kind === "user" || entry.kind === "skill_activation" && entry.skillTrigger === "user-slash";
 }
@@ -166187,92 +167934,6 @@ function stripLeadingSpace(s) {
 	return s.replace(/^ +/, "");
 }
 //#endregion
-//#region src/tui/components/dialogs/compaction.ts
-/**
-* Renders a compaction block in the transcript.
-*
-* Lifecycle:
-*   - constructed on `compaction.started` → blinking white bullet +
-*     "Compacting context..." and optional custom instruction
-*   - `markDone()` on `compaction.completed` → solid green bullet +
-*     "Compaction complete (X → Y tokens)"
-*   - `markCanceled()` on `compaction.cancelled` → solid warning bullet +
-*     "Compaction cancelled"
-*
-* Bullet animation mirrors `ToolCallComponent` (500ms blink) so the user
-* reads the same "work in progress" signal across the UI.
-*/
-const BLINK_INTERVAL = 500;
-var CompactionComponent = class extends Container {
-	ui;
-	headerText;
-	instruction;
-	blinkOn = true;
-	blinkTimer = null;
-	done = false;
-	canceled = false;
-	tokensBefore;
-	tokensAfter;
-	constructor(ui, instruction) {
-		super();
-		this.ui = ui;
-		this.instruction = instruction;
-		this.addChild(new Spacer(1));
-		this.headerText = new Text(this.buildHeader(), 0, 0);
-		this.addChild(this.headerText);
-		this.addInstructionChild();
-		this.startBlink();
-	}
-	addInstructionChild() {
-		if (this.instruction !== void 0) this.addChild(new Text(currentTheme.dim(`  ${this.instruction}`), 0, 0));
-	}
-	invalidate() {
-		this.headerText.setText(this.buildHeader());
-		if (this.instruction !== void 0) {
-			if (this.children.length > 2) this.children.pop();
-			this.addInstructionChild();
-		}
-		super.invalidate();
-	}
-	markDone(tokensBefore, tokensAfter) {
-		if (this.done || this.canceled) return;
-		this.done = true;
-		this.tokensBefore = tokensBefore;
-		this.tokensAfter = tokensAfter;
-		this.stopBlink();
-		this.headerText.setText(this.buildHeader());
-		this.ui?.requestRender();
-	}
-	markCanceled() {
-		if (this.done || this.canceled) return;
-		this.canceled = true;
-		this.stopBlink();
-		this.headerText.setText(this.buildHeader());
-		this.ui?.requestRender();
-	}
-	dispose() {
-		this.stopBlink();
-	}
-	buildHeader() {
-		if (this.done) return `${currentTheme.fg("success", STATUS_BULLET)}${currentTheme.boldFg("success", "Compaction complete")}${this.tokensBefore !== void 0 && this.tokensAfter !== void 0 ? currentTheme.dim(` (${String(this.tokensBefore)} → ${String(this.tokensAfter)} tokens)`) : ""}`;
-		if (this.canceled) return `${currentTheme.fg("warning", STATUS_BULLET)}${currentTheme.boldFg("warning", "Compaction cancelled")}`;
-		return `${this.blinkOn ? currentTheme.fg("text", STATUS_BULLET) : "  "}${currentTheme.boldFg("primary", "Compacting context...")}`;
-	}
-	startBlink() {
-		this.blinkTimer = setInterval(() => {
-			this.blinkOn = !this.blinkOn;
-			this.headerText.setText(this.buildHeader());
-			this.ui?.requestRender();
-		}, BLINK_INTERVAL);
-	}
-	stopBlink() {
-		if (this.blinkTimer !== null) {
-			clearInterval(this.blinkTimer);
-			this.blinkTimer = null;
-		}
-	}
-};
-//#endregion
 //#region src/tui/components/dialogs/help-panel.ts
 /**
 * HelpPanel — modal `/help` display. Lists keyboard shortcuts, slash
@@ -169022,6 +170683,14 @@ var EditorKeyboardController = class {
 };
 //#endregion
 //#region src/tui/components/messages/goal-markers.ts
+/**
+* Low-profile transcript markers for the autonomous goal loop.
+*
+* Lifecycle changes (paused / resumed / cancelled) and `no_progress` verdicts
+* render as a single dim line — `◦ Goal paused` — that expands (ctrl+o, shared
+* with tool output) to show the reason when there is one. Terminal outcomes use
+* the richer completion card (the `/goal` box), not this marker.
+*/
 const HEAD_INDENT = "  ";
 const DETAIL_INDENT = "    ";
 var GoalMarkerComponent = class {
@@ -169051,13 +170720,18 @@ var GoalMarkerComponent = class {
 	render(width) {
 		const dot = currentTheme.fg(this.accentToken, this.marker);
 		const head = currentTheme.fg(this.textToken, this.headline);
-		if (!(this.detail !== void 0 && this.detail.length > 0)) return this.withLeadingBlank([`${this.indent}${dot} ${head}`]);
-		if (!this.expandable) return this.withLeadingBlank([`${this.indent}${dot} ${head}`]);
-		if (!this.expanded) return this.withLeadingBlank([`${this.indent}${dot} ${head} ${currentTheme.fg("textMuted", "(ctrl+o)")}`]);
+		if (!(this.detail !== void 0 && this.detail.length > 0)) return this.clampToWidth([`${this.indent}${dot} ${head}`], width);
+		if (!this.expandable) return this.clampToWidth([`${this.indent}${dot} ${head}`], width);
+		if (!this.expanded) return this.clampToWidth([`${this.indent}${dot} ${head} ${currentTheme.fg("textMuted", "(ctrl+o)")}`], width);
 		const out = [`${this.indent}${dot} ${head}`];
 		const wrapWidth = Math.max(20, width - 4);
 		for (const line of wrap(this.detail, wrapWidth)) out.push(DETAIL_INDENT + currentTheme.fg("textDim", line));
-		return this.withLeadingBlank(out);
+		return this.clampToWidth(out, width);
+	}
+	clampToWidth(lines, width) {
+		const withBlank = this.withLeadingBlank(lines);
+		if (width <= 0) return withBlank.map(() => "");
+		return withBlank.map((line) => truncateToWidth(line, width));
 	}
 	withLeadingBlank(lines) {
 		return this.leadingBlank ? ["", ...lines] : lines;
@@ -169118,7 +170792,7 @@ function lowercaseFirst(text) {
 	return text.length === 0 ? text : `${text[0].toLowerCase()}${text.slice(1)}`;
 }
 function wrap(text, width) {
-	const words = text.replace(/\s+/g, " ").trim().split(" ");
+	const words = text.replaceAll(/\s+/g, " ").trim().split(" ");
 	const lines = [];
 	let current = "";
 	for (const word of words) {
@@ -169381,13 +171055,6 @@ function formatDuration(ms) {
 	return `${(ms / 1e3).toFixed(1)}s`;
 }
 //#endregion
-//#region src/tui/utils/transcript-id.ts
-let transcriptIdCounter = 0;
-function nextTranscriptId() {
-	transcriptIdCounter += 1;
-	return `entry-${String(transcriptIdCounter)}`;
-}
-//#endregion
 //#region src/tui/utils/background-agent-status.ts
 const MAX_BACKGROUND_FIELD_LENGTH = 240;
 function normalizeBackgroundField(value) {