@khorsheed/dsh-local-agent-kimi 0.1.0-rc.6

package/lib/index.js

@@ -0,0 +1,4716 @@
+import z from "@deepseek-ai/schemastery";
+import { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, modelDirectoryContextKey, persistChildSession, probeCliVersion, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol } from "@khorsheed/dsh-local-agent";
+import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV, endpointHost } from "@khorsheed/dsh-local-agent/types";
+import { randomUUID } from "node:crypto";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { NO_START_CAPABILITIES, settleRunResult, subprocessRunHandle } from "@deepseek-ai/dsh-subagent";
+import { join } from "node:path";
+import { copyFile, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+import { createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { readFileSync, writeFileSync } from "node:fs";
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class TomlDate extends Date {
+	#hasDate = false;
+	#hasTime = false;
+	#offset = null;
+	constructor(date) {
+		let hasDate = true;
+		let hasTime = true;
+		let offset = "Z";
+		if (typeof date === "string") {
+			let match = date.match(DATE_TIME_RE);
+			if (match) {
+				if (!match[1]) {
+					hasDate = false;
+					date = `0000-01-01T${date}`;
+				}
+				hasTime = !!match[2];
+				hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+				if (match[2] && +match[2] > 23) date = "";
+				else {
+					offset = match[3] || null;
+					date = date.toUpperCase();
+					if (!offset && hasTime) date += "Z";
+				}
+			} else date = "";
+		}
+		super(date);
+		if (!isNaN(this.getTime())) {
+			this.#hasDate = hasDate;
+			this.#hasTime = hasTime;
+			this.#offset = offset;
+		}
+	}
+	isDateTime() {
+		return this.#hasDate && this.#hasTime;
+	}
+	isLocal() {
+		return !this.#hasDate || !this.#hasTime || !this.#offset;
+	}
+	isDate() {
+		return this.#hasDate && !this.#hasTime;
+	}
+	isTime() {
+		return this.#hasTime && !this.#hasDate;
+	}
+	isValid() {
+		return this.#hasDate || this.#hasTime;
+	}
+	toISOString() {
+		let iso = super.toISOString();
+		if (this.isDate()) return iso.slice(0, 10);
+		if (this.isTime()) return iso.slice(11, 23);
+		if (this.#offset === null) return iso.slice(0, -1);
+		if (this.#offset === "Z") return iso;
+		let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+		offset = this.#offset[0] === "-" ? offset : -offset;
+		return (/* @__PURE__ */ new Date(this.getTime() - offset * 6e4)).toISOString().slice(0, -1) + this.#offset;
+	}
+	static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+		let date = new TomlDate(jsDate);
+		date.#offset = offset;
+		return date;
+	}
+	static wrapAsLocalDateTime(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalDate(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#hasTime = false;
+		date.#offset = null;
+		return date;
+	}
+	static wrapAsLocalTime(jsDate) {
+		let date = new TomlDate(jsDate);
+		date.#hasDate = false;
+		date.#offset = null;
+		return date;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function getLineColFromPtr(string, ptr) {
+	let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+	return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+	let lines = string.split(/\r\n|\n|\r/g);
+	let codeblock = "";
+	let numberLen = (Math.log10(line + 1) | 0) + 1;
+	for (let i = line - 1; i <= line + 1; i++) {
+		let l = lines[i - 1];
+		if (!l) continue;
+		codeblock += i.toString().padEnd(numberLen, " ");
+		codeblock += ":  ";
+		codeblock += l;
+		codeblock += "\n";
+		if (i === line) {
+			codeblock += " ".repeat(numberLen + column + 2);
+			codeblock += "^\n";
+		}
+	}
+	return codeblock;
+}
+var TomlError = class extends Error {
+	line;
+	column;
+	codeblock;
+	constructor(message, options) {
+		const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+		const codeblock = makeCodeBlock(options.toml, line, column);
+		super(`Invalid TOML document: ${message}\n\n${codeblock}`, options);
+		this.line = line;
+		this.column = column;
+		this.codeblock = codeblock;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/** @internal */
+function indexOfNewline(str, start = 0) {
+	let idx = str.indexOf("\n", start);
+	if (str.charCodeAt(idx - 1) === 13) idx--;
+	return idx;
+}
+/** @internal */
+function skipComment(ctx) {
+	for (; ctx.p < ctx.s.length; ctx.p++) {
+		let c = ctx.s.charCodeAt(ctx.p);
+		if (c === 10) break;
+		if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+			ctx.p++;
+			break;
+		}
+		if (c < 32 && c !== 9 || c === 127) throw new TomlError("control characters are not allowed in comments", {
+			toml: ctx.s,
+			ptr: ctx.p
+		});
+	}
+}
+/** @internal */
+function skipVoid(ctx, banNewLines, banComments) {
+	let c;
+	while (1) {
+		while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) ctx.p++;
+		if (banComments || c !== 35) break;
+		skipComment(ctx);
+	}
+}
+/** @internal */
+function skipUntil(ctx, sep, end) {
+	let ptr = ctx.p;
+	if (!end) {
+		ptr = indexOfNewline(ctx.s, ptr);
+		ctx.p = ptr < 0 ? ctx.s.length : ptr;
+		return;
+	}
+	for (; ctx.p < ctx.s.length; ctx.p++) {
+		let c = ctx.s.charCodeAt(ctx.p);
+		if (c === 35) skipComment(ctx);
+		else if (c === end || c === sep) return;
+	}
+	throw new TomlError("cannot find end of structure", {
+		toml: ctx.s,
+		ptr
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+let FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+let LEADING_ZERO = /^[+-]?0[0-9_]/;
+/** @internal */
+function parseString(ctx) {
+	let start = ctx.p;
+	let c = ctx.s.charCodeAt(ctx.p++);
+	let first = c;
+	let isLiteral = c === 39;
+	let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+	if (isMultiline) {
+		if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10) ctx.p++;
+		else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) ctx.p += 2;
+	}
+	let parsed = "";
+	let sliceStart = ctx.p;
+	let state = 0;
+	for (; ctx.p < ctx.s.length; ctx.p++) {
+		c = ctx.s.charCodeAt(ctx.p);
+		if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) state = state && 3;
+		else if (c < 32 && c !== 9 || c === 127) throw new TomlError("control characters are not allowed in strings", {
+			toml: ctx.s,
+			ptr: ctx.p
+		});
+		else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+			if (isMultiline) {
+				if (ctx.s.charCodeAt(ctx.p + 3) === first) ctx.p++;
+				if (ctx.s.charCodeAt(ctx.p + 3) === first) ctx.p++;
+			}
+			if (!state) parsed += ctx.s.slice(sliceStart, ctx.p);
+			ctx.p += isMultiline ? 3 : 1;
+			return parsed;
+		} else if (!state) {
+			if (!isLiteral && c === 92) {
+				parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+				state = 1;
+			}
+		} else if (state === 1) {
+			if (c === 120 || c === 117 || c === 85) {
+				let value = 0;
+				let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+				for (let j = 0; j < len; j++, ctx.p++) {
+					let hex = ctx.s.charCodeAt(ctx.p + 1);
+					let digit = hex >= 48 && hex <= 57 ? hex - 48 : hex >= 65 && hex <= 70 ? hex - 65 + 10 : hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1;
+					if (digit < 0) throw new TomlError("invalid non-hex character in unicode escape", {
+						toml: ctx.s,
+						ptr: ctx.p + 1
+					});
+					value = value << 4 | digit;
+				}
+				if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) throw new TomlError("invalid unicode escape", {
+					toml: ctx.s,
+					ptr: ctx.p
+				});
+				parsed += String.fromCodePoint(value);
+				sliceStart = ctx.p + 1;
+				state = 0;
+			} else if (c === 32 || c === 9) state = 2;
+			else {
+				if (c === 98) parsed += "\b";
+				else if (c === 116) parsed += "	";
+				else if (c === 110) parsed += "\n";
+				else if (c === 102) parsed += "\f";
+				else if (c === 114) parsed += "\r";
+				else if (c === 101) parsed += "\x1B";
+				else if (c === 34) parsed += "\"";
+				else if (c === 92) parsed += "\\";
+				else throw new TomlError("unrecognized escape sequence", {
+					toml: ctx.s,
+					ptr: ctx.p
+				});
+				sliceStart = ctx.p + 1;
+				state = 0;
+			}
+		} else if (c !== 32 && c !== 9) {
+			if (state === 2) throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+				toml: ctx.s,
+				ptr: sliceStart
+			});
+			state = !isLiteral && c === 92 ? 1 : 0;
+			sliceStart = ctx.p;
+		}
+	}
+	throw new TomlError("unfinished string", {
+		toml: ctx.s,
+		ptr: start
+	});
+}
+function sliceAndTrimEndOf(ctx, start, end) {
+	let value = ctx.s.slice(start, end);
+	let commentIdx = value.indexOf("#");
+	if (commentIdx > 0) {
+		skipComment({
+			s: value,
+			p: commentIdx,
+			d: 0
+		});
+		value = value.slice(0, commentIdx);
+	}
+	return value.trimEnd();
+}
+/** @internal */
+function parseValue(ctx, integersAsBigInt, end) {
+	let ptr = ctx.p;
+	let err = {
+		toml: ctx.s,
+		ptr
+	};
+	skipUntil(ctx, 44, end);
+	let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+	if (!value) throw new TomlError("incomplete declaration: value expected", err);
+	if (value === "-inf") return -Infinity;
+	if (value === "inf" || value === "+inf") return Infinity;
+	if (value === "nan" || value === "+nan" || value === "-nan") return NaN;
+	if (value === "-0") return integersAsBigInt ? 0n : 0;
+	let isInt = INT_REGEX.test(value);
+	if (isInt || FLOAT_REGEX.test(value)) {
+		if (LEADING_ZERO.test(value)) throw new TomlError("leading zeroes are not allowed", err);
+		value = value.replace(/_/g, "");
+		let numeric = +value;
+		if (isNaN(numeric)) throw new TomlError("invalid number", err);
+		if (isInt) {
+			if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) throw new TomlError("integer value cannot be represented losslessly", err);
+			if (isInt || integersAsBigInt === true) numeric = BigInt(value);
+		}
+		return numeric;
+	}
+	const date = new TomlDate(value);
+	if (!date.isValid()) throw new TomlError("invalid value", err);
+	return date;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/extract.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/** @internal */
+function extractValue(ctx, end, integersAsBigInt) {
+	let ptr = ctx.p;
+	let c = ctx.s.charCodeAt(ptr);
+	if (c === 91 || c === 123) {
+		if (!ctx.d--) throw new TomlError("document contains excessively nested structures. aborting.", {
+			toml: ctx.s,
+			ptr
+		});
+		let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+		ctx.d++;
+		return value;
+	}
+	if (c === 34 || c === 39) return parseString(ctx);
+	if (c === 116) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101) throw new TomlError("invalid value", {
+			toml: ctx.s,
+			ptr
+		});
+		ctx.p++;
+		return true;
+	}
+	if (c === 102) {
+		if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101) throw new TomlError("invalid value", {
+			toml: ctx.s,
+			ptr
+		});
+		ctx.p++;
+		return false;
+	}
+	return parseValue(ctx, integersAsBigInt, end);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/struct.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+/** @internal */
+function parseKey(ctx, end = "=") {
+	let start = ctx.p;
+	let dot = start - 1;
+	let parsed = [];
+	let endPtr = ctx.s.indexOf(end, start);
+	if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+		toml: ctx.s,
+		ptr: start
+	});
+	do {
+		let c = ctx.s.charCodeAt(ctx.p = ++dot);
+		if (c !== 32 && c !== 9) {
+			if (c === 34 || c === 39) {
+				if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) throw new TomlError("multiline strings are not allowed in keys", {
+					toml: ctx.s,
+					ptr: ctx.p
+				});
+				let part = parseString(ctx);
+				dot = ctx.s.indexOf(".", ctx.p);
+				let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+				let newLine = indexOfNewline(strEnd);
+				if (newLine > -1) throw new TomlError("newlines are not allowed in keys", {
+					toml: ctx.s,
+					ptr: newLine
+				});
+				if (strEnd.trimStart()) throw new TomlError("found extra tokens after the string part", {
+					toml: ctx.s,
+					ptr: ctx.p
+				});
+				if (endPtr < ctx.p) {
+					endPtr = ctx.s.indexOf(end, ctx.p);
+					if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+						toml: ctx.s,
+						ptr: start
+					});
+				}
+				parsed.push(part);
+			} else {
+				dot = ctx.s.indexOf(".", ctx.p);
+				let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+				if (!KEY_PART_RE.test(part)) throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+					toml: ctx.s,
+					ptr: ctx.p
+				});
+				parsed.push(part.trimEnd());
+			}
+		}
+	} while (dot + 1 && dot < endPtr);
+	ctx.p = endPtr + 1;
+	skipVoid(ctx, true, true);
+	return parsed;
+}
+/** @internal */
+function parseInlineTable(ctx, integersAsBigInt) {
+	let res = {};
+	let seen = /* @__PURE__ */ new Set();
+	let c;
+	ctx.p++;
+	while (ctx.p < ctx.s.length) {
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+			ctx.p++;
+			return res;
+		}
+		let k;
+		let t = res;
+		let hasOwn = false;
+		let p = ctx.p;
+		let key = parseKey(ctx);
+		for (let i = 0; i < key.length; i++) {
+			if (i) t = hasOwn ? t[k] : t[k] = {};
+			k = key[i];
+			if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) throw new TomlError("trying to redefine an already defined value", {
+				toml: ctx.s,
+				ptr: p
+			});
+			if (!hasOwn && k === "__proto__") Object.defineProperty(t, k, {
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		}
+		if (hasOwn) throw new TomlError("trying to redefine an already defined value", {
+			toml: ctx.s,
+			ptr: ctx.p
+		});
+		let value = extractValue(ctx, 125, integersAsBigInt);
+		seen.add(t[k] = value);
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) return res;
+		if (c !== 44) throw new TomlError("expected comma or end of structure", {
+			toml: ctx.s,
+			ptr: ctx.p - 1
+		});
+	}
+	throw new TomlError("unfinished table encountered", {
+		toml: ctx.s,
+		ptr: ctx.p
+	});
+}
+/** @internal */
+function parseArray(ctx, integersAsBigInt) {
+	let res = [];
+	let c;
+	ctx.p++;
+	while (ctx.p < ctx.s.length) {
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+			ctx.p++;
+			return res;
+		}
+		res.push(extractValue(ctx, 93, integersAsBigInt));
+		skipVoid(ctx);
+		if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) return res;
+		if (c !== 44) throw new TomlError("expected comma or end of structure", {
+			toml: ctx.s,
+			ptr: ctx.p - 1
+		});
+	}
+	throw new TomlError("unfinished array encountered", {
+		toml: ctx.s,
+		ptr: ctx.p
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/parse.js
+/*!
+* Copyright (c) Squirrel Chat et al., All rights reserved.
+* SPDX-License-Identifier: BSD-3-Clause
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* 1. Redistributions of source code must retain the above copyright notice, this
+*    list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. Neither the name of the copyright holder nor the names of its contributors
+*    may be used to endorse or promote products derived from this software without
+*    specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+function peekTable(key, table, meta, type) {
+	let t = table;
+	let m = meta;
+	let k;
+	let hasOwn = false;
+	let state;
+	for (let i = 0; i < key.length; i++) {
+		if (i) {
+			t = hasOwn ? t[k] : t[k] = {};
+			m = (state = m[k]).c;
+			if (type === 0 && (state.t === 1 || state.t === 2)) return null;
+			if (state.t === 2) {
+				let l = t.length - 1;
+				t = t[l];
+				m = m[l].c;
+			}
+		}
+		k = key[i];
+		if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) return null;
+		if (!hasOwn) {
+			if (k === "__proto__") {
+				Object.defineProperty(t, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+				Object.defineProperty(m, k, {
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			m[k] = {
+				t: i < key.length - 1 && type === 2 ? 3 : type,
+				d: false,
+				i: 0,
+				c: {}
+			};
+		}
+	}
+	state = m[k];
+	if (state.t !== type && !(type === 1 && state.t === 3)) return null;
+	if (type === 2) {
+		if (!state.d) {
+			state.d = true;
+			t[k] = [];
+		}
+		t[k].push(t = {});
+		state.c[state.i++] = state = {
+			t: 1,
+			d: false,
+			i: 0,
+			c: {}
+		};
+	}
+	if (state.d) return null;
+	state.d = true;
+	if (type === 1) t = hasOwn ? t[k] : t[k] = {};
+	else if (type === 0 && hasOwn) return null;
+	return [
+		k,
+		t,
+		state.c
+	];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+	let ctx = {
+		s: toml,
+		p: 0,
+		d: maxDepth
+	};
+	let res = {};
+	let meta = {};
+	let tmp;
+	let tbl = res;
+	let m = meta;
+	skipVoid(ctx);
+	while (ctx.p < toml.length) {
+		if (toml.charCodeAt(ctx.p) === 91) {
+			let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+			tmp = ctx.p += +isTableArray;
+			let k = parseKey(ctx, "]");
+			if (isTableArray) {
+				if (toml.charCodeAt(ctx.p - 1) !== 93) throw new TomlError("expected end of table declaration", {
+					toml,
+					ptr: ctx.p - 1
+				});
+				ctx.p++;
+			}
+			let p = peekTable(k, res, meta, isTableArray ? 2 : 1);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr: tmp
+			});
+			m = p[2];
+			tbl = p[1];
+		} else {
+			tmp = ctx.p;
+			let p = peekTable(parseKey(ctx), tbl, m, 0);
+			if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+				toml,
+				ptr: tmp
+			});
+			p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+		}
+		skipVoid(ctx, true);
+		if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+			toml,
+			ptr: ctx.p
+		});
+		skipVoid(ctx);
+	}
+	return res;
+}
+//#endregion
+//#region lib/types/model-configuration.js
+const table = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+const string = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+/** Native configuration metadata only; provider credentials never leave this function. */
+async function readKimiModelConfiguration(home, selectedModel) {
+	let text;
+	try {
+		text = await readFile(join(home, "config.toml"), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return { entries: [] };
+		throw error;
+	}
+	const config = parse(text);
+	const models = table(config["models"]);
+	const entries = Object.entries(models).map(([value, raw]) => {
+		const model = table(raw);
+		const efforts = model["support_efforts"];
+		const defaultEffort = string(model["default_effort"]);
+		return {
+			value,
+			label: string(model["display_name"]) ?? value,
+			source: "configuration",
+			...!Array.isArray(efforts) ? {} : { reasoning: {
+				options: efforts.flatMap((value) => typeof value === "string" ? [{
+					value,
+					label: value
+				}] : []),
+				...defaultEffort === void 0 ? {} : { default: defaultEffort }
+			} }
+		};
+	});
+	const defaultModel = string(config["default_model"]);
+	const selected = selectedModel ?? defaultModel;
+	const model = table(selected === void 0 ? void 0 : models[selected]);
+	const provider = table(table(config["providers"])[string(model["provider"]) ?? ""]);
+	const protocol = string(model["protocol"]) ?? string(provider["type"]);
+	const thinking = table(config["thinking"]);
+	const requestedEffort = string(thinking["effort"]);
+	const options = entries.find((entry) => entry.value === selected)?.reasoning?.options;
+	const effort = thinking["enabled"] === false ? void 0 : requestedEffort !== void 0 && options?.some((option) => option.value === requestedEffort) ? requestedEffort : string(model["default_effort"]);
+	return {
+		entries,
+		...defaultModel === void 0 ? {} : { defaultModel },
+		...effort === void 0 ? {} : { effort },
+		...protocol === void 0 ? {} : { protocol }
+	};
+}
+/** Only the native Kimi protocol advertises a general exec effort override. */
+async function kimiExecConfiguration(home, model, effort) {
+	if (effort === void 0) return {};
+	const config = await readKimiModelConfiguration(home, model);
+	if (!config.entries.find((entry) => entry.value === (model ?? config.defaultModel))?.reasoning?.options.some((option) => option.value === effort)) throw new Error("Kimi configuration does not advertise this model/effort combination");
+	if (config.protocol !== "kimi") throw new Error("This Kimi model protocol has no per-invocation exec effort control; use ACP live mode");
+	return { KIMI_MODEL_THINKING_EFFORT: effort };
+}
+//#endregion
+//#region lib/types/model-catalog.js
+const object = (value) => typeof value === "object" && value !== null ? value : void 0;
+function options(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((candidate) => {
+		const entry = object(candidate);
+		if (entry === void 0) return [];
+		if (Array.isArray(entry["options"])) return options(entry["options"]);
+		if (typeof entry["value"] !== "string") return [];
+		return [{
+			value: entry["value"],
+			label: typeof entry["name"] === "string" ? entry["name"] : entry["value"],
+			...typeof entry["description"] === "string" ? { description: entry["description"] } : {}
+		}];
+	});
+}
+/** ACP v1 configOptions are authoritative; old models metadata is a read-only fallback. */
+function kimiNativeConfiguration(value) {
+	const response = object(value);
+	if (response === void 0) return void 0;
+	const configuration = response["configOptions"];
+	if (Array.isArray(configuration)) {
+		const choices = configuration.map(object).filter((entry) => entry !== void 0 && entry["type"] === "select");
+		const model = choices.find((entry) => entry["category"] === "model");
+		const effort = choices.find((entry) => entry["category"] === "thought_level");
+		if (model !== void 0) {
+			const currentModel = typeof model["currentValue"] === "string" ? model["currentValue"] : void 0;
+			return {
+				directory: {
+					entries: options(model["options"]).map((option) => ({
+						...option,
+						source: "native",
+						...effort === void 0 || option.value !== currentModel ? {} : { reasoning: { options: options(effort["options"]) } }
+					})),
+					complete: true,
+					customInput: false
+				},
+				...typeof model["id"] === "string" ? { modelConfigId: model["id"] } : {},
+				...typeof effort?.["id"] === "string" ? { effortConfigId: effort["id"] } : {},
+				...currentModel === void 0 ? {} : { currentModel },
+				...typeof effort?.["currentValue"] === "string" ? { currentEffort: effort["currentValue"] } : {}
+			};
+		}
+	}
+	const legacy = object(response["models"]);
+	if (!Array.isArray(legacy?.["availableModels"])) return void 0;
+	return {
+		directory: {
+			entries: legacy["availableModels"].flatMap((candidate) => {
+				const model = object(candidate);
+				if (typeof model?.["modelId"] !== "string") return [];
+				return [{
+					value: model["modelId"],
+					label: typeof model["name"] === "string" ? model["name"] : model["modelId"],
+					source: "native",
+					...typeof model["description"] === "string" ? { description: model["description"] } : {}
+				}];
+			}),
+			complete: true,
+			customInput: false
+		},
+		...typeof legacy["currentModelId"] === "string" ? { currentModel: legacy["currentModelId"] } : {}
+	};
+}
+/** Reads configuration before a session exists; never starts a disposable ACP session. */
+var KimiModelCatalog = class {
+	context;
+	cache = new ModelDirectoryCache({ load: async (key) => {
+		const context = JSON.parse(key);
+		if (context.native !== void 0) return context.native;
+		const { entries, defaultModel } = await readKimiModelConfiguration(context.homeDir);
+		return {
+			entries,
+			...defaultModel === void 0 ? {} : { defaultModel },
+			complete: false,
+			customInput: true,
+			reason: "Configured candidates; native session model metadata is not available yet"
+		};
+	} });
+	constructor(context) {
+		this.context = context;
+	}
+	key(childSessionId) {
+		const context = this.context(childSessionId);
+		const stamp = modelDirectoryContextKey({
+			provider: "kimi",
+			homeDir: context.homeDir,
+			cwd: context.cwd ?? context.homeDir,
+			cli: ["kimi"],
+			files: [join(context.homeDir, "config.toml"), join(context.homeDir, "credentials", "kimi-code.json")]
+		});
+		return JSON.stringify({
+			homeDir: context.homeDir,
+			stamp,
+			childSessionId,
+			...context.native === void 0 ? {} : { native: context.native.directory }
+		});
+	}
+	read(childSessionId) {
+		return this.cache.read(this.key(childSessionId));
+	}
+	refresh(childSessionId) {
+		return this.cache.refresh(this.key(childSessionId));
+	}
+	follow(childSessionId, signal) {
+		return this.cache.follow(() => this.key(childSessionId), signal);
+	}
+	dispose() {
+		this.cache.dispose();
+	}
+};
+//#endregion
+//#region lib/types/session-configuration.js
+/** Confirm model first: its returned options determine which efforts are valid. */
+async function configureKimiSession(sessionId, initial, desired, request) {
+	let current = initial;
+	if (desired.model !== void 0 && current?.currentModel !== desired.model) {
+		if (current?.modelConfigId === void 0) throw new Error("This Kimi ACP session exposes no verified model selection control");
+		if (!current.directory.entries.some((entry) => entry.value === desired.model)) throw new Error("The running Kimi session does not advertise this model");
+		current = kimiNativeConfiguration(await request("session/set_config_option", {
+			sessionId,
+			configId: current.modelConfigId,
+			value: desired.model
+		}));
+		if (current?.currentModel !== desired.model) throw new Error("Kimi did not confirm the requested model");
+	}
+	if (desired.effort !== void 0 && current?.currentEffort !== desired.effort) {
+		const currentModel = current?.currentModel;
+		const entry = current?.directory.entries.find((entry) => entry.value === currentModel);
+		if (current?.effortConfigId === void 0 || !entry?.reasoning?.options.some((option) => option.value === desired.effort)) throw new Error("The running Kimi session does not advertise this model/effort combination");
+		current = kimiNativeConfiguration(await request("session/set_config_option", {
+			sessionId,
+			configId: current.effortConfigId,
+			value: desired.effort
+		}));
+		if (current?.currentEffort !== desired.effort || desired.model !== void 0 && current.currentModel !== desired.model) throw new Error("Kimi did not confirm the requested model/effort configuration");
+	}
+	return current;
+}
+//#endregion
+//#region lib/types/session-view.js
+/**
+* Kimi session viewer: read a scoped-home session's `wire.jsonl` event log
+* and render a readable transcript (user prompts, assistant thinking and
+* replies, tool calls with arguments and results). The kimi ACP mode writes
+* responses to the session file rather than pushing them over the protocol,
+* and the dsh subagent record for a one-shot run carries only the final
+* output — this is the way to see what the kimi subagent actually did.
+*
+* The transcript is harness-comparison grade: every line is tagged with its
+* wire turn number (1-based, matching the dsh child session's `turn/start`
+* numbering), kimi's auto-permission `<system-reminder>` user messages are
+* filtered out, tool calls carry their rendered arguments, tool results are
+* matched to their owning call by `parentUuid`, and every `usage.record`
+* (kimi reports accounting per LLM request, not cumulative) is surfaced with
+* its transcript position so a delta mirror can sum a round's total.
+* @module @khorsheed/dsh-local-agent-kimi/session-view
+*/
+/** The wire event log path for a session directory. */
+function wirePath(sessionDir) {
+	return join(sessionDir, "agents", "main", "wire.jsonl");
+}
+/**
+* Find a session directory under `<homeDir>/sessions/wd_*` whose id matches.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param sessionId - the kimi session id.
+* @returns the session directory, or undefined when absent.
+*/
+async function findKimiSessionDir(homeDir, sessionId) {
+	const sessionsRoot = join(homeDir, "sessions");
+	let workspaces;
+	try {
+		workspaces = await readdir(sessionsRoot);
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	for (const workspace of workspaces) {
+		const sessionDir = join(sessionsRoot, workspace, `session_${sessionId}`);
+		try {
+			await readFile(wirePath(sessionDir));
+			return sessionDir;
+		} catch {}
+	}
+}
+/** Whether a user message is kimi's auto-permission reminder, never real task text. */
+function isSystemReminder(text) {
+	return text.startsWith("<system-reminder>");
+}
+/** Flatten the text blocks of a message content array. */
+function textOf(content) {
+	return (content ?? []).filter((block) => typeof block === "object" && block !== null && block.type === "text").map((block) => block.text ?? "").join("");
+}
+/**
+* Render a file-editing tool call's arguments apply-patch style: the path
+* plus the old/new content. Without this a delegation's edits collapsed to
+* the bare path (or nothing) and the transcript hid what the member actually
+* changed — the kimi twin of codex's fileChange → ApplyPatch fold.
+* @param name - the tool name the wire recorded.
+* @param record - the call's argument object.
+* @returns the patch-style summary, or undefined when the tool is not a
+*   known file-editing shape.
+*/
+function editArgsOf(name, record) {
+	const path = typeof record["path"] === "string" ? record["path"] : void 0;
+	if (name === "Edit" || name === "MultiEdit") {
+		if (path === void 0 || path.trim() === "") return void 0;
+		const edits = Array.isArray(record["edits"]) ? record["edits"] : [record];
+		const hunks = [];
+		for (const edit of edits) {
+			const oldText = typeof edit["old_string"] === "string" ? edit["old_string"] : "";
+			const newText = typeof edit["new_string"] === "string" ? edit["new_string"] : "";
+			if (oldText === "" && newText === "") continue;
+			hunks.push("@@", ...oldText.split("\n").map((line) => `-${line}`), ...newText.split("\n").map((line) => `+${line}`));
+		}
+		if (hunks.length === 0) return void 0;
+		return [`update: ${path}`, ...hunks].join("\n");
+	}
+	if (name === "Write") {
+		if (path === void 0 || path.trim() === "") return void 0;
+		const content = typeof record["content"] === "string" ? record["content"] : "";
+		if (content === "") return void 0;
+		return [`add: ${path}`, ...content.split("\n").map((line) => `+${line}`)].join("\n");
+	}
+	const patch = record["patch"] ?? record["diff"];
+	if (typeof patch === "string" && patch.trim() !== "") return patch;
+}
+/** Render a tool call's arguments into a compact summary. */
+function argsOf(name, args) {
+	if (args === void 0) return void 0;
+	if (typeof args === "string") return args.trim() === "" ? void 0 : args;
+	if (typeof args !== "object" || args === null || Array.isArray(args)) return void 0;
+	const record = args;
+	const edit = editArgsOf(name, record);
+	if (edit !== void 0) return edit;
+	for (const key of [
+		"query",
+		"url",
+		"path",
+		"command"
+	]) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim() !== "") return value.trim();
+	}
+	const pairs = [];
+	for (const [key, value] of Object.entries(record)) if (typeof value === "string" && value.trim() !== "") pairs.push(`${key}=${value.trim()}`);
+	else if (typeof value === "number" || typeof value === "boolean") pairs.push(`${key}=${String(value)}`);
+	if (pairs.length === 0) return void 0;
+	const summary = pairs.join(" ");
+	return summary.length > 200 ? `${summary.slice(0, 200)}…` : summary;
+}
+/**
+* Parse a session's wire log into transcript lines plus every usage record.
+* @param sessionDir - the session directory.
+* @returns the transcript.
+*/
+async function readKimiTranscript(sessionDir) {
+	const sessionId = sessionDir.split("session_").pop() ?? sessionDir;
+	const lines = [];
+	const usageRecords = [];
+	let model;
+	let modelTurn;
+	let lineModel;
+	const push = (line) => {
+		lines.push({
+			...line,
+			...lineModel === void 0 ? {} : { model: lineModel }
+		});
+	};
+	let turn = 0;
+	let turnSeen = false;
+	const callsByUuid = /* @__PURE__ */ new Map();
+	const callsByToolCallId = /* @__PURE__ */ new Map();
+	let text;
+	try {
+		text = await readFile(wirePath(sessionDir), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			sessionId,
+			lines,
+			usageRecords
+		};
+		throw error;
+	}
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "") continue;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (event.type === "usage.record") {
+			if (typeof event.model === "string" && event.model !== "") {
+				model = lineModel = event.model;
+				modelTurn = turn || 1;
+			}
+			const usage = usageFromWire(event.usage);
+			if (usage !== void 0) usageRecords.push({
+				line: lines.length,
+				usage
+			});
+			continue;
+		}
+		if (event.type === "llm.request") {
+			lineModel = typeof event.model === "string" && event.model !== "" ? event.model : void 0;
+			if (typeof event.model === "string" && event.model !== "") {
+				model = event.model;
+				modelTurn = turn || 1;
+			}
+			continue;
+		}
+		if (event.type === "turn.prompt") {
+			lineModel = void 0;
+			turnSeen = true;
+			turn += 1;
+			const prompt = textOf(event.input ?? []);
+			if (prompt.trim() !== "" && !isSystemReminder(prompt)) push({
+				kind: "user",
+				text: prompt,
+				turn: turn === 0 ? 1 : turn
+			});
+			continue;
+		}
+		if (event.type === "context.append_message") {
+			const message = event.message;
+			const role = message?.role;
+			const textContent = textOf(message?.content ?? []);
+			if (role === "user" && textContent.trim() !== "" && !isSystemReminder(textContent)) {
+				const last = lines[lines.length - 1];
+				if (turnSeen && last?.kind === "user" && last.text === textContent) continue;
+				turnSeen = true;
+				turn += 1;
+				lineModel = void 0;
+				push({
+					kind: "user",
+					text: textContent,
+					turn: turn === 0 ? 1 : turn
+				});
+			} else if (role === "assistant" && textContent.trim() !== "") push({
+				kind: "assistant",
+				text: textContent,
+				turn: turn === 0 ? 1 : turn
+			});
+			continue;
+		}
+		if (event.type === "context.append_loop_event") {
+			const loop = event.event;
+			if (loop === void 0) continue;
+			const loopTurn = typeof loop.turnId === "number" ? loop.turnId + 1 : void 0;
+			if (loopTurn !== void 0) {
+				turn = Math.max(turn, loopTurn);
+				turnSeen = true;
+			}
+			const part = loop.part;
+			const lineTurn = turn === 0 ? 1 : turn;
+			if (part?.type === "text" && part.text !== void 0 && part.text.trim() !== "") push({
+				kind: "assistant",
+				text: part.text,
+				turn: lineTurn
+			});
+			else if (part?.type === "think" && part.think !== void 0 && part.think.trim() !== "") push({
+				kind: "think",
+				text: part.think,
+				turn: lineTurn
+			});
+			else if (loop.type === "tool.call") {
+				const call = loop;
+				const name = call.toolCall?.name ?? call.name ?? "tool";
+				const args = argsOf(name, call.toolCall?.args ?? call.args);
+				const lineIndex = lines.length;
+				push({
+					kind: "tool",
+					id: typeof call.toolCallId === "string" ? call.toolCallId : typeof call.uuid === "string" ? call.uuid : `kimi-tool-${lineIndex}`,
+					name,
+					...args === void 0 ? {} : { args },
+					turn: lineTurn
+				});
+				if (typeof call.uuid === "string") callsByUuid.set(call.uuid, lineIndex);
+				if (typeof call.toolCallId === "string") callsByToolCallId.set(call.toolCallId, lineIndex);
+			} else if (loop.type === "tool.result") {
+				const result = loop;
+				const output = result.result?.output;
+				let target = typeof result.parentUuid === "string" ? callsByUuid.get(result.parentUuid) : void 0;
+				if (target === void 0 && typeof result.toolCallId === "string") target = callsByToolCallId.get(result.toolCallId);
+				if (target === void 0) {
+					for (let index = lines.length - 1; index >= 0; index -= 1) if (lines[index]?.kind === "tool") {
+						target = index;
+						break;
+					}
+				}
+				if (output !== void 0 && output.trim() !== "" && target !== void 0) {
+					const current = lines[target];
+					if (current !== void 0 && current.kind === "tool") lines[target] = {
+						...current,
+						result: output
+					};
+				}
+			} else if (loop.type === "content.part" && part?.type !== void 0 && part.type !== "text" && part.type !== "think") push({
+				kind: "assistant",
+				text: `[未支持的内容类型 ${part.type}]`,
+				turn: lineTurn
+			});
+		}
+	}
+	return {
+		sessionId,
+		lines,
+		usageRecords,
+		...model === void 0 ? {} : { model },
+		...modelTurn === void 0 ? {} : { modelTurn }
+	};
+}
+/**
+* Map a wire `usage.record` payload onto the shared usage contract. kimi
+* reports input (uncached), cache read, cache creation, and output; the
+* creation counter is its cache-write analog. Non-numeric or missing
+* counters are dropped so the record stays usable when kimi omits a field.
+* @param raw - the event's `usage` value.
+* @returns the shared usage record, or undefined when nothing was reported.
+*/
+function usageFromWire(raw) {
+	const counters = raw;
+	if (counters === void 0 || typeof counters !== "object") return void 0;
+	const num = (value) => {
+		const n = Number(value);
+		return Number.isFinite(n) ? n : void 0;
+	};
+	const input = num(counters.inputOther);
+	const output = num(counters.output);
+	const cacheRead = num(counters.inputCacheRead);
+	const cacheWrite = num(counters.inputCacheCreation);
+	if (input === void 0 && output === void 0 && cacheRead === void 0 && cacheWrite === void 0) return;
+	const usage = {
+		inputTokens: input ?? 0,
+		outputTokens: output ?? 0
+	};
+	if (cacheRead !== void 0 && cacheRead > 0) usage.cacheReadTokens = cacheRead;
+	if (cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+	return usage;
+}
+/**
+* Sum per-request usage records into one round total. Each `usage.record` is
+* a single LLM request's accounting, so a round's totals are the sum of the
+* records inside it.
+* @param records - the usage records to add.
+* @returns the summed usage, or undefined when the list is empty.
+*/
+function sumUsageRecords(records) {
+	let input = 0;
+	let output = 0;
+	let cacheRead = 0;
+	let cacheWrite = 0;
+	for (const record of records) {
+		input += record.usage.inputTokens ?? 0;
+		output += record.usage.outputTokens ?? 0;
+		cacheRead += record.usage.cacheReadTokens ?? 0;
+		cacheWrite += record.usage.cacheWriteTokens ?? 0;
+	}
+	if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) return void 0;
+	const usage = {
+		inputTokens: input,
+		outputTokens: output
+	};
+	if (cacheRead > 0) usage.cacheReadTokens = cacheRead;
+	if (cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+	return usage;
+}
+/**
+* Merge two usage windows into one running total — the delegation run's
+* per-round accumulator: each mirror pass (live poll, settle) returns its
+* own window's accounting, and the disjoint windows sum to the round's
+* total. `undefined` operands pass through, so callers accumulate without
+* absence checks.
+* @param left - the running total, or undefined before the first window.
+* @param right - the next window's usage, or undefined when it had none.
+* @returns the merged total, or undefined when both operands are absent.
+*/
+function addTokenUsage(left, right) {
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	return sumUsageRecords([{
+		line: 0,
+		usage: left
+	}, {
+		line: 0,
+		usage: right
+	}]);
+}
+/** Render a transcript as command-reply text. */
+function renderTranscript(transcript) {
+	if (transcript.lines.length === 0) return `kimi session ${transcript.sessionId}: no readable transcript yet.`;
+	const parts = [`kimi session ${transcript.sessionId}:`];
+	for (const line of transcript.lines) if (line.kind === "user") parts.push(`\n用户: ${line.text}`);
+	else if (line.kind === "assistant") parts.push(`\nkimi: ${line.text}`);
+	else if (line.kind === "think") parts.push(`\n[思考] ${line.text}`);
+	else {
+		const call = `[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}`;
+		parts.push(`\n  ↳ ${call}${line.result !== void 0 ? ` → ${line.result}` : ""}`);
+	}
+	return parts.join("\n");
+}
+//#endregion
+//#region lib/types/session-mirror.js
+/**
+* Mirror a kimi session's transcript into a dsh subagent session, so the
+* delegation shows up in the standard 子代理 surface and opening the child
+* session shows the full conversation (user prompts, kimi replies, thinking,
+* and tool activity with arguments and results) instead of a silent one-shot
+* call.
+* @module @khorsheed/dsh-local-agent-kimi/session-mirror
+*/
+/** One user-role message event. */
+function userEvent(text) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: { kind: "user" }
+	});
+}
+/** One assistant-role message event, attributed to the kimi route. */
+function assistantEvent(blocks, model) {
+	return createAssistantMessage({
+		content: blocks,
+		source: {
+			provider: "kimi-cli",
+			model: model ?? "unobserved"
+		}
+	});
+}
+/**
+* The step the next fold pass would assign in one turn (the max existing
+* step + 1). The token-granularity live
+* driver reserves its stream merge key here LAZILY at the first delta, so
+* tool cards folded before the stream started keep their chronological
+* place below it instead of the stream squatting on step 1.
+* @param childSession - the run's child session.
+* @param turn - the round's turn number.
+* @returns the next free step in the turn.
+*/
+function nextKimiSessionStep(childSession, turn) {
+	let next = 1;
+	for (const event of childSession.snapshotEvents()) {
+		const data = event.data;
+		if (data.turn === turn && typeof data.step === "number") next = Math.max(next, data.step + 1);
+	}
+	return next;
+}
+/**
+* Fold one non-tool transcript line into message blocks. Thinking maps to
+* the native `reasoning` block so the standard conversation renders it as
+* thinking rather than a `[思考]` text prefix; reply text stays text (content
+* is never filtered — kimi's own injections remain visible). Tool lines are
+* NOT folded here: they become native `tool/call`/`tool/result` event pairs
+* (see the mirror loop), so the standard conversation renders them as tool
+* cards instead of `[工具 X]` text.
+*/
+function lineBlocks(line) {
+	if (line.kind === "think") return [{
+		type: "reasoning",
+		text: line.text
+	}];
+	return [{
+		type: "text",
+		text: line.text
+	}];
+}
+/** The run-progress delta text for one transcript line (any kind). */
+function kimiLineProgressText(line) {
+	if (line.kind !== "tool") return line.text;
+	return `${`[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}`}${line.result !== void 0 ? ` → ${line.result}` : ""}`;
+}
+/**
+* Mirror one kimi session's transcript into the dsh subagent session: each
+* user prompt becomes a `user/message`, each assistant reply (including
+* folded thinking and tool activity) an `assistant/message`, then the events
+* are appended to persistence so the child session is viewable.
+*
+* A resumed round (or a live poll) passes the already-mirrored
+* transcript-line count so only the delta is appended — re-mirroring earlier
+* lines would duplicate their messages. Turn numbers come from the transcript
+* lines themselves (the wire's 1-based turn, matching the provider's
+* `turn/start` numbering); step numbers CONTINUE from the assistant messages
+* already in the child session, so a round mirrored across several live polls
+* does not restart step 1 per poll.
+*
+* Every folded step is wrapped in the `step/start`–`step/end` boundary pair
+* the live conversation assembler requires: without a boundary the step never
+* enters the location index, the assistant message resolves to a turn-level
+* location, and the real-time view renders nothing (only a full rebuild,
+* which mints step drafts from the explicit coordinates, recovers it). A
+* think/assistant line that completes an in-flight stream folds at the
+* stream's reserved step instead (see {@link KimiMirrorStreams}), and a
+* sequential fold never takes a step a stream reserved.
+*
+* Usage accounting is exactly-once ACROSS passes: each `usage.record` is
+* tagged with the transcript position it occurred at, and a pass attaches the
+* records in the half-open range `(fromLines, newTotal]` — the records that
+* trail THIS pass's lines — summed onto the delta's final assistant message.
+* (A record flushed only after its line was already mirrored belongs to no
+* later pass and is dropped; kimi flushes content and usage together per
+* request, so this window is a flush race, not the norm.)
+* @param ctx - host context carrying the session persistence service.
+* @param childSession - the dsh subagent session created for this delegation.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param kimiSessionId - the kimi session to mirror; omitted mirrors the most
+*   recent session (a one-shot `kimi -p` run always creates a fresh one).
+* @param fromLines - transcript lines already mirrored into the child session
+*   (0 for the first round); only lines after this offset are appended.
+* @returns the new total and the newly mirrored lines' texts.
+*/
+async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, fromLines = 0, options) {
+	let workspaces;
+	try {
+		workspaces = await readdir(join(homeDir, "sessions"));
+	} catch {
+		return {
+			total: 0,
+			texts: []
+		};
+	}
+	let transcript;
+	if (kimiSessionId !== void 0) {
+		const dirName = kimiSessionId.startsWith("session_") ? kimiSessionId : `session_${kimiSessionId}`;
+		for (const workspace of workspaces) {
+			const dir = join(homeDir, "sessions", workspace, dirName);
+			try {
+				transcript = await readKimiTranscript(dir);
+			} catch {
+				continue;
+			}
+			if (transcript.lines.length > 0) break;
+		}
+	} else {
+		let newest;
+		for (const workspace of workspaces) {
+			let sessions;
+			try {
+				sessions = await readdir(join(homeDir, "sessions", workspace));
+			} catch {
+				continue;
+			}
+			for (const name of sessions) {
+				if (!name.startsWith("session_")) continue;
+				const dir = join(homeDir, "sessions", workspace, name);
+				const meta = await stat(dir);
+				if (newest === void 0 || meta.mtimeMs > newest.time) newest = {
+					dir,
+					time: meta.mtimeMs
+				};
+			}
+		}
+		if (newest !== void 0) try {
+			transcript = await readKimiTranscript(newest.dir);
+		} catch {
+			transcript = void 0;
+		}
+	}
+	if (transcript === void 0 || transcript.lines.length === 0) return {
+		total: 0,
+		texts: []
+	};
+	const newTotal = transcript.lines.length;
+	const delta = transcript.lines.slice(fromLines);
+	const observedModel = options?.turn === void 0 || transcript.modelTurn === options.turn ? transcript.model : void 0;
+	const toolCalls = roundToolCalls(transcript.lines, options?.turn);
+	const deltaUsage = sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= fromLines && record.line <= newTotal));
+	let lastAssistant = -1;
+	for (let index = 0; index < delta.length; index += 1) {
+		const line = delta[index];
+		if (line !== void 0 && line.kind !== "user" && line.kind !== "tool") lastAssistant = index;
+	}
+	const steps = /* @__PURE__ */ new Map();
+	const openCalls = /* @__PURE__ */ new Map();
+	const settledCalls = /* @__PURE__ */ new Set();
+	for (const event of childSession.snapshotEvents()) {
+		const data = event.data;
+		if (typeof data.turn === "number" && typeof data.step === "number") steps.set(data.turn, Math.max(steps.get(data.turn) ?? 0, data.step + 1));
+		if (event.type === "tool/call") {
+			const call = event.data;
+			openCalls.set(call.callId, {
+				turn: call.turn,
+				step: call.step,
+				seq: event.seq
+			});
+		} else if (event.type === "tool/result") {
+			const message = event.data.message;
+			const id = message?.toolCallId ?? message?.content?.[0]?.toolCallId;
+			if (id !== void 0) {
+				openCalls.delete(id);
+				settledCalls.add(id);
+			}
+		}
+	}
+	/**
+	* The next sequential fold step in one turn: the running counter, shifted
+	* past every step an in-flight stream reserved (a stream's snapshots and
+	* its completion fold live at the reserved coordinate — a sequential fold
+	* landing there would write a second step/start, which the assembler
+	* rejects).
+	*/
+	const nextFoldStep = (turn) => {
+		let step = steps.get(turn) ?? 1;
+		const reserved = options?.streams?.reservedSteps(turn);
+		if (reserved !== void 0 && reserved.length > 0) {
+			const skip = new Set(reserved);
+			while (skip.has(step)) step += 1;
+		}
+		steps.set(turn, step + 1);
+		return step;
+	};
+	/** Whether this pass attached its window's usage to a folded message. */
+	let usageAttached = false;
+	const texts = [];
+	for (let index = 0; index < fromLines && index < transcript.lines.length; index += 1) {
+		const line = transcript.lines[index];
+		if (line === void 0 || line.kind !== "tool" || line.result === void 0) continue;
+		const call = openCalls.get(line.id);
+		if (call === void 0) continue;
+		openCalls.delete(line.id);
+		settledCalls.add(line.id);
+		childSession.append("tool/result", {
+			turn: call.turn,
+			step: call.step,
+			message: createToolResultMessage({
+				callId: line.id,
+				content: [{
+					type: "text",
+					text: line.result
+				}],
+				isError: false
+			})
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: [call.seq]
+		});
+		texts.push(kimiLineProgressText(line));
+	}
+	if (delta.length === 0) {
+		if (texts.length > 0) await persistChildSession(ctx, childSession);
+		return {
+			total: newTotal,
+			texts,
+			...deltaUsage !== void 0 ? { usage: deltaUsage } : {},
+			...usageAttached ? { usageAttached: true } : {},
+			...observedModel !== void 0 ? { model: observedModel } : {},
+			...toolCalls !== void 0 ? { toolCalls } : {}
+		};
+	}
+	for (let index = 0; index < delta.length; index += 1) {
+		const line = delta[index];
+		if (line === void 0) continue;
+		const turn = line.turn;
+		if (line.kind === "user") {
+			if (userAlreadyAppended(childSession, turn, line.text)) continue;
+			steps.set(turn, 1);
+			childSession.append("user/message", userEvent(line.text), { surfaceOp: "append" });
+			texts.push(line.text);
+		} else if (line.kind === "tool") {
+			const reserved = options?.streams?.completeTool?.(line);
+			const step = reserved?.step ?? nextFoldStep(turn);
+			steps.set(turn, Math.max(steps.get(turn) ?? 1, step + 1));
+			if (reserved?.opened !== true) childSession.append("step/start", {
+				turn,
+				step
+			});
+			const call = childSession.append("tool/call", {
+				turn,
+				step,
+				callId: line.id,
+				name: line.name,
+				arguments: line.args ?? ""
+			});
+			texts.push(kimiLineProgressText(line));
+			if (line.result !== void 0) childSession.append("tool/result", {
+				turn,
+				step,
+				message: createToolResultMessage({
+					callId: line.id,
+					content: [{
+						type: "text",
+						text: line.result
+					}],
+					isError: false
+				})
+			}, {
+				surfaceOp: "append",
+				sourceEventSeqs: [call.seq]
+			});
+			childSession.append("step/end", {
+				turn,
+				step
+			});
+		} else {
+			const completion = options?.streams?.completeStream(line);
+			if (completion !== void 0) {
+				steps.set(turn, Math.max(steps.get(turn) ?? 1, completion.step + 1));
+				if (!completion.opened) childSession.append("step/start", {
+					turn,
+					step: completion.step
+				});
+				if (index === lastAssistant && deltaUsage !== void 0) usageAttached = true;
+				childSession.append("assistant/message", {
+					turn,
+					step: completion.step,
+					message: assistantEvent(lineBlocks(line), line.model),
+					stream: [],
+					...index === lastAssistant && deltaUsage !== void 0 ? { usage: deltaUsage } : {}
+				}, { surfaceOp: "append" });
+				childSession.append("step/end", {
+					turn,
+					step: completion.step
+				});
+				texts.push(kimiLineProgressText(line));
+				continue;
+			}
+			const step = nextFoldStep(turn);
+			childSession.append("step/start", {
+				turn,
+				step
+			});
+			if (index === lastAssistant && deltaUsage !== void 0) usageAttached = true;
+			childSession.append("assistant/message", {
+				turn,
+				step,
+				message: assistantEvent(lineBlocks(line), line.model),
+				stream: [],
+				...index === lastAssistant && deltaUsage !== void 0 ? { usage: deltaUsage } : {}
+			}, { surfaceOp: "append" });
+			childSession.append("step/end", {
+				turn,
+				step
+			});
+			texts.push(kimiLineProgressText(line));
+		}
+	}
+	await persistChildSession(ctx, childSession);
+	return {
+		total: newTotal,
+		texts,
+		...deltaUsage !== void 0 ? { usage: deltaUsage } : {},
+		...usageAttached ? { usageAttached: true } : {},
+		...observedModel !== void 0 ? { model: observedModel } : {},
+		...toolCalls !== void 0 ? { toolCalls } : {}
+	};
+}
+/**
+* Count one round's tool calls out of a kimi transcript, keyed by the name the
+* wire gave each tool. No turn named, or no `tool.call` line carrying it,
+* yields undefined — a round reports nothing rather than a zero it did not
+* observe. Reads only the transcript lines the mirror already folded.
+* @param lines - the whole session transcript.
+* @param turn - the round's 1-based turn, when the caller named one.
+* @returns the round's accounting, or undefined.
+*/
+function roundToolCalls(lines, turn) {
+	if (turn === void 0) return void 0;
+	const byName = {};
+	let count = 0;
+	for (const line of lines) {
+		if (line.kind !== "tool" || line.turn !== turn) continue;
+		count += 1;
+		byName[line.name] = (byName[line.name] ?? 0) + 1;
+	}
+	return count === 0 ? void 0 : {
+		count,
+		byName
+	};
+}
+/**
+* Whether the turn already carries a user/message with this exact text (the
+* live driver's round-start append). Scoped to the events at or after this
+* turn's turn/start so identical prompts across rounds stay independent.
+*/
+function userAlreadyAppended(childSession, turn, text) {
+	let turnStartSeq = -1;
+	for (const event of childSession.snapshotEvents()) if (event.type === "turn/start" && event.data.turn === turn) turnStartSeq = event.seq;
+	if (turnStartSeq < 0) return false;
+	for (const event of childSession.snapshotEvents()) {
+		if (event.seq < turnStartSeq || event.type !== "user/message") continue;
+		if ((event.data.content ?? []).map((block) => block.text ?? "").join("") === text) return true;
+	}
+	return false;
+}
+//#endregion
+//#region lib/types/credential-guard.js
+/**
+* Kimi credential sentinel. The kimi CLI occasionally wipes
+* `credentials/kimi-code.json` into an empty shell (both tokens zero-length)
+* on its own failure paths — observed twice in production, each time killing
+* every later delegation with "Authentication required" until someone
+* restored the file by hand. The sentinel:
+*
+* - backs the file up whenever a VALID credential is observed (the backup
+*   lives inside `credentials/` so the family's logout — a directory delete —
+*   clears it too);
+* - restores the backup when the file is an exact empty shell (both tokens
+*   empty strings) — the only corruption signature we trust;
+* - logs every state transition with a process snapshot, so the next wipe
+*   can be attributed (which process, at which moment).
+*
+* Restore is deliberately narrow: a revoked-elsewhere credential never takes
+* the empty-shell shape, and a stale backup at worst produces one more loud
+* 401, never silent misbehavior.
+* @module @khorsheed/dsh-local-agent-kimi/credential-guard
+*/
+/** The credential file inside the scoped home, and its sentinel backup. */
+const CREDENTIAL_REL = join("credentials", "kimi-code.json");
+const BACKUP_REL = `${CREDENTIAL_REL}.bak`;
+/** Last observed state signature per home (`${mtimeMs}:${kind}`) — transition logging. */
+const lastSeen = /* @__PURE__ */ new Map();
+/** A one-line process snapshot for wipe attribution (kimi/dsh processes only). */
+function processSnapshot() {
+	return new Promise((resolve) => {
+		execFile("ps", ["-eo", "pid,ppid,etime,command"], { timeout: 5e3 }, (error, stdout) => {
+			if (error !== null) {
+				resolve(`(ps failed: ${error.message})`);
+				return;
+			}
+			resolve(stdout.split("\n").filter((line) => /\bkimi\b|dsh/.test(line) && !line.includes("grep")).slice(0, 12).join(" ; "));
+		});
+	});
+}
+/** Classify the credential file's current content. */
+async function observe(file) {
+	let raw;
+	try {
+		raw = await readFile(file, "utf8");
+	} catch {
+		return {
+			state: "absent",
+			mtimeMs: 0
+		};
+	}
+	let mtimeMs = 0;
+	try {
+		mtimeMs = (await stat(file)).mtimeMs;
+	} catch {}
+	try {
+		const parsed = JSON.parse(raw);
+		const empty = (v) => typeof v === "string" && v.length === 0;
+		if (empty(parsed.access_token) && empty(parsed.refresh_token)) return {
+			state: "empty-shell",
+			mtimeMs
+		};
+		return {
+			state: "valid",
+			mtimeMs
+		};
+	} catch {
+		return {
+			state: "absent",
+			mtimeMs
+		};
+	}
+}
+/**
+* Guard the scoped home's kimi credential: back up a valid file, restore the
+* backup over an empty shell, log transitions.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param log - warn channel (plugin logger when available).
+* @returns true when a usable credential exists after the guard ran.
+*/
+async function guardKimiCredential(homeDir, log) {
+	const file = join(homeDir, CREDENTIAL_REL);
+	const backup = join(homeDir, BACKUP_REL);
+	const { state, mtimeMs } = await observe(file);
+	const signature = `${mtimeMs}:${state}`;
+	const previous = lastSeen.get(homeDir);
+	lastSeen.set(homeDir, signature);
+	if (state === "valid") {
+		if (previous !== void 0 && previous !== signature) log?.(`local-agent-kimi: credential refreshed (mtime ${new Date(mtimeMs).toISOString()}), snapshotting the backup`);
+		await writeFile(backup, await readFile(file), { mode: 384 });
+		return true;
+	}
+	if (state === "empty-shell") {
+		const snapshot = await processSnapshot();
+		log?.(`local-agent-kimi: CREDENTIAL EMPTY SHELL detected (mtime ${new Date(mtimeMs).toISOString()}); previous state ${previous ?? "unknown"}; processes: ${snapshot}`);
+		let backupState = "absent";
+		try {
+			backupState = (await observe(backup)).state;
+		} catch {}
+		if (backupState === "valid") {
+			await copyFile(backup, file);
+			log?.("local-agent-kimi: credential restored from the sentinel backup — the next delegation should succeed");
+			return true;
+		}
+		log?.("local-agent-kimi: no usable backup to restore; the harness needs a fresh login");
+		return false;
+	}
+	return false;
+}
+//#endregion
+//#region lib/types/provision.js
+/**
+* Kimi Code scoped-home provisioning: a working `config.toml` (provider and
+* model definitions) is required for the ACP server to authenticate. The
+* scoped home is provisioned once — from the user's own config, redacted —
+* so the scoped setup mirrors the user's models while carrying no secrets.
+* Sign-out removes the credentials and OAuth cache so a later login can
+* authorize a different account. The agent preset the delegation tool row
+* needs is bootstrapped into the user preset root on first boot, so
+* installing the bundle needs no manual copy step.
+* @module @khorsheed/dsh-local-agent-kimi/provision
+*/
+const REAL_CONFIG = join(homedir(), ".kimi-code", "config.toml");
+/** Credentials directory inside the scoped home; its presence marks auth. */
+const CREDENTIALS_DIR$1 = "credentials";
+/** OAuth token cache directory inside the scoped home. */
+const OAUTH_DIR = "oauth";
+/**
+* The managed provider's endpoint, written into a fresh scoped config and the
+* baseline the eval snapshot compares against: a scoped config still pointing
+* here routes through kimi's own service, i.e. no custom endpoint is in force.
+*/
+const KIMI_MANAGED_BASE_URL = "https://api.kimi.com/coding/v1";
+/** Minimal managed config for a fresh home with no user config to mirror. */
+function minimalConfig(model, thinkingEffort) {
+	return `default_model = "${model}"
+
+[thinking]
+enabled = true
+effort = "${thinkingEffort}"
+
+[providers."managed:kimi-code"]
+base_url = "${KIMI_MANAGED_BASE_URL}"
+type = "kimi"
+api_key = ""
+
+[providers."managed:kimi-code".oauth]
+storage = "file"
+key = "oauth/kimi-code"
+
+[models."${model}"]
+provider = "managed:kimi-code"
+model = "${model.split("/").pop()}"
+max_context_size = 1048576
+capabilities = [ "thinking", "always_thinking", "image_in", "video_in", "tool_use" ]
+display_name = "${model}"
+support_efforts = [ "low", "high", "max" ]
+default_effort = "${thinkingEffort}"
+`;
+}
+/**
+* Redact every api_key value so the scoped copy carries no secrets. The
+* kimi-managed provider keeps an empty api_key (its auth routes through
+* oauth), which is exactly what an empty value means here.
+* @param config - the user's config text.
+* @returns the same config with all api_key values blanked.
+*/
+function redactApiKeys(config) {
+	return config.replace(/api_key\s*=\s*"[^"]*"/gu, "api_key = \"\"");
+}
+/**
+* Provision `<homeDir>/config.toml` unless one already exists. A present
+* config is respected untouched (a person may have edited it); otherwise the
+* user's own real config is copied redacted so the scoped home mirrors the
+* user's models; with no real config, a minimal kimi-managed config is
+* written. `thinkingEffort` feeds the minimal config's `[thinking] effort`
+* (and the model's `default_effort`) — it applies at provision time only,
+* never retroactively to an existing config.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param model - the kimi-managed model id for a fresh minimal config.
+* @param thinkingEffort - the reasoning effort a fresh minimal config pins.
+* @returns true when a config was written, false when one already existed.
+*/
+async function provisionKimiConfig(homeDir, model, thinkingEffort) {
+	try {
+		await readFile(join(homeDir, "config.toml"));
+		return false;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	let config = minimalConfig(model, thinkingEffort);
+	try {
+		config = redactApiKeys(await readFile(REAL_CONFIG, "utf8"));
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	await writeFile(join(homeDir, "config.toml"), config, { flag: "wx" });
+	return true;
+}
+/** The managed-service provider section provisioned into the scoped config. */
+const MANAGED_PROVIDER_SECTION = "providers.\"managed:kimi-code\"";
+/**
+* Read the scoped config's effective LLM endpoint: the
+* `[providers."managed:kimi-code"].base_url` key, if present. A missing or
+* malformed config yields undefined (the CLI falls back to its default
+* endpoint). Used only for diagnostics — the config itself is authoritative,
+* and a user-edited value is respected untouched.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the configured base URL, or undefined when absent/unreadable.
+*/
+async function readKimiBaseUrl(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return;
+	}
+	let section = "";
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		if (section === MANAGED_PROVIDER_SECTION) {
+			const match = /^base_url\s*=\s*"([^"]*)"$/.exec(line);
+			if (match !== null) return match[1];
+		}
+	}
+}
+/**
+* Read the scoped config's configured default model: the top-level
+* `default_model` key — the selection a plain `kimi -p` round runs with. A
+* missing or malformed config, or no key, yields undefined — the honest
+* "unknown", never a guessed default. Read-only: the config is authoritative
+* and a user-edited value is reported as-is.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the configured model identifier, or undefined when none is set.
+*/
+async function readKimiDefaultModel(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return;
+	}
+	let section = "";
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		if (section !== "") continue;
+		const key = /^(\w+)\s*=\s*"([^"]*)"$/.exec(line);
+		if (key !== null && key[1] === "default_model") return key[2];
+	}
+}
+/**
+* List the model identifiers the scoped config DEFINES: every
+* `[models."…"]` table key (bare `[models.x]` keys included). This is the
+* pickable vocabulary a model surface can offer without hardcoding a catalog —
+* the same table `-m` resolves against. A missing or malformed config yields
+* an empty list. Read-only: the config is authoritative.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the defined model identifiers, in file order, deduplicated.
+*/
+async function listKimiConfigModels(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return [];
+	}
+	const models = [];
+	for (const rawLine of text.split("\n")) {
+		const header = /^\[+([^\]]+)\]+$/.exec(rawLine.trim());
+		if (header === null) continue;
+		const table = /^models\.(?:"([^"]+)"|([\w-]+))$/.exec(header[1]);
+		const name = table?.[1] ?? table?.[2];
+		if (name !== void 0 && name !== "" && !models.includes(name)) models.push(name);
+	}
+	return models;
+}
+/**
+* Rewrite the scoped config's top-level `default_model` to `model`, so the
+* NEXT process started under this home runs that model. This is the resident
+* path's only lever: `kimi acp` takes no model flag (verified against kimi
+* 0.39.1), while `kimi -p` takes `-m` — so the one-shot rounds pass the flag
+* and the live driver writes the file before spawning its runtime.
+*
+* The write is surgical: the first top-level `default_model` assignment is
+* replaced in place and everything else — model tables, providers, thinking
+* effort, comments, key order — is left byte-identical. A config with no
+* top-level `default_model` gains one as its first line; an absent or
+* unreadable config is left alone (provisioning owns creation, and inventing
+* a config here would hide a broken home).
+* @param homeDir - the `kimi` harness's scoped home.
+* @param model - the model identifier to pin as the default.
+* @returns true when the file now names `model`, false when there was no
+*   config to write into.
+*/
+async function writeKimiDefaultModel(homeDir, model) {
+	const path = join(homeDir, "config.toml");
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return false;
+	}
+	const assignment = `default_model = "${model.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"")}"`;
+	const lines = text.split("\n");
+	let section = "";
+	for (const [index, rawLine] of lines.entries()) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		if (section !== "") continue;
+		const key = /^(\w+)\s*=/.exec(line);
+		if (key === null || key[1] !== "default_model") continue;
+		if (line === assignment) return true;
+		lines[index] = assignment;
+		await writeFile(path, lines.join("\n"), "utf8");
+		return true;
+	}
+	await writeFile(path, `${assignment}\n${text}`, "utf8");
+	return true;
+}
+/**
+* Read the scoped config's effective reasoning effort: the `[thinking] effort`
+* key, falling back to a `[models."…"]` section's `default_effort` when the
+* thinking table carries none (the CLI resolves effort the same way). A
+* missing or malformed config, or no effort key anywhere, yields undefined —
+* the honest "unknown", never a guessed default. Read-only: the config is
+* authoritative, a user-edited value is reported as-is.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the effective effort, or undefined when it cannot be determined.
+*/
+async function readKimiReasoningEffort(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return;
+	}
+	let section = "";
+	let thinkingEffort;
+	let modelDefaultEffort;
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		const key = /^(\w+)\s*=\s*"([^"]*)"$/.exec(line);
+		if (key === null) continue;
+		if (section === "thinking" && key[1] === "effort" && thinkingEffort === void 0) thinkingEffort = key[2];
+		if (section.startsWith("models.") && key[1] === "default_effort" && modelDefaultEffort === void 0) modelDefaultEffort = key[2];
+	}
+	return thinkingEffort ?? modelDefaultEffort;
+}
+/**
+* Whether the scoped config's permission rules auto-approve the subagent's
+* tool use: the `Bash(*)` allow rule the provisioning gate
+* ({@link ensureKimiPermissions}) keys on, detected with the exact same
+* substring so the snapshot and the provisioning can never disagree about
+* the same file.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns whether the auto-approve rule is present.
+*/
+async function readKimiAutoApprove(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return false;
+	}
+	return text.includes("pattern = \"Bash(*)");
+}
+/** Permission rule block letting the kimi subagent run shell commands. */
+const KIMI_PERMISSION_BLOCK = `
+[[permission.rules]]
+decision = "allow"
+pattern = "Bash(*)"
+reason = "let the kimi subagent run shell commands"
+`;
+/**
+* Ensure the scoped config allows the subagent's tool use. The one-shot
+* `kimi -p` child uses the config's permission rules, so without a rule it
+* answers without executing tools. Idempotent; an existing rule is respected.
+* @param homeDir - the `kimi` harness's scoped home.
+*/
+async function ensureKimiPermissions(homeDir) {
+	const file = join(homeDir, "config.toml");
+	let content;
+	try {
+		content = await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	if (content.includes("pattern = \"Bash(*)")) return;
+	await writeFile(file, `${content.trimEnd()}\n${KIMI_PERMISSION_BLOCK}`);
+}
+/**
+* Sign out of the scoped account: remove the credentials and OAuth token
+* cache, so `/<name> status` reports not authenticated and the next login
+* authorizes a fresh account. The kimi CLI has no `logout` command, so the
+* scoped files are the logout path.
+* @param homeDir - the `kimi` harness's scoped home.
+*/
+async function kimiLogout(homeDir) {
+	await Promise.all([rm(join(homeDir, CREDENTIALS_DIR$1), {
+		recursive: true,
+		force: true
+	}), rm(join(homeDir, OAUTH_DIR), {
+		recursive: true,
+		force: true
+	})]);
+}
+//#endregion
+//#region lib/types/live-driver.js
+/**
+* The kimi provider's live driver: one resident `kimi acp` process per member
+* (child session), driven over the vendor's Agent Client Protocol (ACP) —
+* JSON-RPC NDJSON over stdio (protocol-probed against kimi 0.36.1; the
+* harness `subagent-acp` package is the reference implementation). A
+* delegation round is a `session/prompt` on the member's resident session
+* instead of a fresh `kimi -p` process, which buys what the process boundary
+* could not: runtime-level graceful interrupt (`session/cancel`; the process
+* survives and the session stays continuable) and push-driven mirroring
+* (`session/update` notifications trigger throttled file-mirror passes — see
+* below why the transcript itself stays file-sourced).
+*
+* Mirroring contract (the kimi-specific call): kimi's ACP updates are
+* token-level chunks, NOT the wire.jsonl line fold the exec mirror owns — so
+* completed items always fold from the file: push events merely TRIGGER
+* throttled `mirrorKimiDelta` passes and the settle pass stays authoritative
+* (one fold, one offset, zero divergence between the two drivers). Every
+* transcript item folds 1:1 into the child session log.
+* Live output also mirrors the in-flight item: chunk
+* deltas accumulate per streaming item and append throttled snapshot
+* assistant/messages at the item's reserved (turn, step) — the host folds
+* repeated settles at one coordinate into one live-updating chat node — and
+* the wire line completing the item folds at the same step, finalizing it.
+*
+* Lifecycle mirrors the dsh/codex live drivers' discipline: lazy spawn with an
+* initialize handshake (loadSession capability required — crash recovery is
+* `session/load` of the recorded session id), one in-flight spawn per member,
+* idle-timeout reclaim (stdin EOF → grace → SIGTERM ladder), a channel breaker
+* with cooldown, `disposeAll` on unload, and cancellation honored in every
+* window. The wire adapter is self-contained (no `@agentclientprotocol/sdk`
+* dependency): StringDecoder framing, request correlation, and unattended
+* auto-answers for `session/request_permission` (allow — matching the exec
+* mode's auto-approve behavior; the proposal's default policy).
+* @module @khorsheed/dsh-local-agent-kimi/live-driver
+*/
+/** Default idle lifetime of an unused resident runtime before reclaim. */
+const DEFAULT_LIVE_IDLE_MS = 18e5;
+/** Default timeout for a wire request acknowledgement (never for session/prompt). */
+const DEFAULT_LIVE_REQUEST_TIMEOUT_MS = 3e4;
+/** Default timeout for the ACP handshake (a cold boot can be slow). */
+const DEFAULT_LIVE_INITIALIZE_TIMEOUT_MS = 6e4;
+/** Bounded wait for an interrupted turn to converge while a run disposes. */
+const DEFAULT_LIVE_DISPOSE_CONVERGE_MS = 5e3;
+/** How long a tripped channel breaker stays on the exec fallback. */
+const DEFAULT_LIVE_CHANNEL_RETRY_MS = 3e5;
+/** Default minimum interval between one streaming item's snapshot messages. */
+const DEFAULT_SNAPSHOT_MIN_INTERVAL_MS = LIVE_FLUSH_INTERVAL_MS;
+/** Grace between stdin EOF and SIGTERM when reclaiming an ACP server. */
+const RECLAIM_EOF_GRACE_MS = 1e3;
+/** The ACP protocol version this driver speaks (kimi 0.36.1 probe). */
+const ACP_PROTOCOL_VERSION = 1;
+/**
+* The ACP channel could not come up (spawn failure, handshake
+* timeout/mismatch, or a missing loadSession capability). The provider
+* catches exactly this and falls back to the exec one-shot; any other error
+* is a real round failure.
+*/
+var LiveChannelUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LiveChannelUnavailableError";
+	}
+};
+const DEFAULT_TIMEOUTS = {
+	initializeMs: DEFAULT_LIVE_INITIALIZE_TIMEOUT_MS,
+	requestMs: DEFAULT_LIVE_REQUEST_TIMEOUT_MS,
+	convergeMs: DEFAULT_LIVE_DISPOSE_CONVERGE_MS,
+	channelRetryMs: DEFAULT_LIVE_CHANNEL_RETRY_MS,
+	mirrorThrottleMs: 500
+};
+/** Settle-mirror quiescence: poll cadence, required consecutive stable reads, and the overall bound. */
+const SETTLE_MIRROR_POLL_MS = 300;
+const SETTLE_MIRROR_STABLE_READS = 3;
+const SETTLE_MIRROR_QUIESCE_MS = 3e3;
+function thrown$1(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Auth-shaped failure signatures in kimi's error output: the endpoint
+* rejected the credential. Mirrors the exec path's detector
+* (KIMI_AUTH_FAILURE in kimi-cli-provider.ts); the live path matches against
+* session/prompt failure messages, which is where a mid-run 401 surfaces
+* when the process does not exit.
+*/
+const KIMI_LIVE_AUTH_FAILURE = /401|unauthorized|invalid api key|not authenticated|authentication required/i;
+/**
+* kimi ACP session ids are directory names (`session_<uuid>`); the family
+* delegation record convention is the bare uuid (the exec path's settle-time
+* stderr parse). Strip the prefix so live- and exec-written records stay
+* interchangeable.
+*/
+function bareKimiSessionId(acpSessionId) {
+	return acpSessionId.startsWith("session_") ? acpSessionId.slice(8) : acpSessionId;
+}
+/** The ACP-native form of a recorded kimi session id (idempotent). */
+function acpKimiSessionId(recordedId) {
+	return recordedId.startsWith("session_") ? recordedId : `session_${recordedId}`;
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Map an ACP prompt stop reason onto the shared stop contract (the harness
+* subagent-acp mapping, verbatim): an unclean stop is never 'completed'.
+*/
+function acpStopReasonToHarness(reason) {
+	switch (reason) {
+		case "end_turn": return "completed";
+		case "max_tokens": return "max-tokens";
+		case "refusal": return "refusal";
+		case "cancelled": return "aborted";
+		default: return "error";
+	}
+}
+/**
+* The ACP wire peer: newline-delimited JSON-RPC over the child's stdio.
+* Self-contained on purpose (no SDK dependency): StringDecoder framing for
+* split UTF-8 tails, request correlation, and server→client request answering
+* (the permission surface).
+*/
+var AcpWirePeer = class {
+	output;
+	warn;
+	onServerRequest;
+	onNotification;
+	requestMs;
+	buffer = "";
+	decoder = new StringDecoder("utf8");
+	nextId = 0;
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(input, output, warn, onServerRequest, onNotification, requestMs) {
+		this.output = output;
+		this.warn = warn;
+		this.onServerRequest = onServerRequest;
+		this.onNotification = onNotification;
+		this.requestMs = requestMs;
+		input?.on("data", (chunk) => {
+			this.feed(this.decoder.write(chunk));
+		});
+	}
+	write(message) {
+		this.output?.write(JSON.stringify(message) + "\n");
+	}
+	/** Send one request; `timeoutMs` 0 means turn-length (no timer — session/prompt). */
+	request(method, params, timeoutMs) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("subagent-kimi live: the wire is closed"));
+		this.nextId += 1;
+		const id = `req_${this.nextId}`;
+		const timeout = timeoutMs ?? this.requestMs;
+		return new Promise((resolve, reject) => {
+			let timer;
+			if (timeout > 0) {
+				timer = setTimeout(() => {
+					this.pending.delete(id);
+					reject(/* @__PURE__ */ new Error(`subagent-kimi live: ${method} timed out`));
+					timer?.unref();
+				}, timeout);
+				timer.unref();
+			}
+			this.pending.set(id, {
+				resolve: (result) => resolve(result),
+				reject,
+				timer
+			});
+			this.write({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			});
+		});
+	}
+	notify(method, params) {
+		this.write(params === void 0 ? {
+			jsonrpc: "2.0",
+			method
+		} : {
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	/** Detach and reject every outstanding request (a turn-length prompt settles here on teardown). */
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const request of this.pending.values()) {
+			if (request.timer !== void 0) clearTimeout(request.timer);
+			request.reject(/* @__PURE__ */ new Error("subagent-kimi live: the wire closed"));
+		}
+		this.pending.clear();
+	}
+	feed(text) {
+		this.buffer += text;
+		let index = this.buffer.indexOf("\n");
+		while (index >= 0) {
+			const line = this.buffer.slice(0, index);
+			this.buffer = this.buffer.slice(index + 1);
+			index = this.buffer.indexOf("\n");
+			if (line.trim() !== "") this.dispatchLine(line);
+		}
+	}
+	/** Handle one wire line; a malformed or hostile line never escapes this frame. */
+	dispatchLine(line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			this.warn("subagent-kimi live: ignored a malformed wire line");
+			return;
+		}
+		try {
+			const hasId = typeof message.id === "string" || typeof message.id === "number";
+			if (hasId && typeof message.method === "string") {
+				const id = message.id;
+				try {
+					const result = this.onServerRequest(message.method, message.params ?? {});
+					this.write({
+						jsonrpc: "2.0",
+						id,
+						result
+					});
+				} catch (error) {
+					this.write({
+						jsonrpc: "2.0",
+						id,
+						error: {
+							code: -32603,
+							message: thrown$1(error).message
+						}
+					});
+				}
+				return;
+			}
+			if (hasId && ("result" in message || "error" in message)) {
+				const request = this.pending.get(String(message.id));
+				if (request === void 0) return;
+				this.pending.delete(String(message.id));
+				if (request.timer !== void 0) clearTimeout(request.timer);
+				const wireError = message.error;
+				if (wireError !== void 0 && wireError !== null) request.reject(/* @__PURE__ */ new Error(`subagent-kimi live: ${wireError.message ?? "wire error"}`));
+				else request.resolve(message.result);
+				return;
+			}
+			if (typeof message.method === "string") this.onNotification(message.method, message.params ?? {});
+		} catch (error) {
+			this.warn(`subagent-kimi live: wire line handler failed: ${thrown$1(error).message}`);
+		}
+	}
+};
+/**
+* One resident `kimi acp` process: the wire peer, the loaded session id, the
+* per-session turn chain (one prompt at a time — a cancelled turn converges
+* before the next prompt goes out), and the reclaim ladder.
+*/
+var KimiLiveRuntime = class {
+	child;
+	dead = false;
+	reclaimed = false;
+	peer;
+	/** The member's ACP session; assigned by the first round's session/new or session/load. */
+	sessionId;
+	/**
+	* The model this process was spawned with (the scoped `default_model` value
+	* rewritten just before spawn; undefined means the config decided). A round
+	* resolving a different model for the member retires this runtime so the
+	* respawn binds the new one.
+	*/
+	configurationKey;
+	boundModel;
+	modelConfiguration;
+	/** Serializes session/prompt per member (converge-before-next-turn). */
+	turnChain = Promise.resolve();
+	/** The active round's notification sink; installed per round, cleared at settle. */
+	onSessionUpdate;
+	onDead;
+	stderrTail = "";
+	stderrDecoder = new StringDecoder("utf8");
+	constructor(child, onServerRequest, warn, requestMs) {
+		this.child = child;
+		this.peer = new AcpWirePeer(child.stdout, child.stdin, warn, onServerRequest, (method, params) => {
+			if (method !== "session/update") return;
+			if (params["sessionId"] !== this.sessionId) return;
+			const update = params["update"] ?? {};
+			if (update["sessionUpdate"] === "config_option_update") this.modelConfiguration = kimiNativeConfiguration(update);
+			this.onSessionUpdate?.(update);
+		}, requestMs);
+		child.stderr?.on("data", (chunk) => {
+			this.stderrTail = (this.stderrTail + this.stderrDecoder.write(chunk)).slice(-4096);
+		});
+		child.done.then(() => {
+			this.markDead();
+		}, () => {
+			this.markDead();
+		});
+	}
+	get diagnostics() {
+		return this.stderrTail.trim();
+	}
+	markDead() {
+		if (this.dead) return;
+		this.dead = true;
+		this.peer.close();
+		this.onDead?.();
+	}
+	/** Graceful teardown: close the wire, EOF stdin, grace, then the terminate ladder. */
+	async reclaim() {
+		if (this.reclaimed) return;
+		this.reclaimed = true;
+		this.peer.close();
+		if (!this.dead) {
+			this.child.stdin?.end();
+			await Promise.race([this.child.done.catch(() => {}), delay(RECLAIM_EOF_GRACE_MS)]);
+		}
+		if (!this.dead) {
+			this.child.terminate();
+			await this.child.waitForExit();
+		}
+		await this.child.done.catch(() => {});
+		this.markDead();
+	}
+};
+/**
+* The kimi live driver owns every resident ACP runtime of this provider
+* generation. Created only when `live: true`; disposed with the plugin.
+*/
+var KimiAcpLiveDriver = class {
+	ctx;
+	config;
+	timeouts;
+	runtimes = /* @__PURE__ */ new Map();
+	ensuring = /* @__PURE__ */ new Map();
+	/** The model each in-flight spawn is binding (a stale-model spawn never serves a switched member). */
+	ensuringModel = /* @__PURE__ */ new Map();
+	ensuringConfiguration = /* @__PURE__ */ new Map();
+	idleTimers = /* @__PURE__ */ new Map();
+	/** Per-member round serialization (the resume lock covers resume-vs-resume only). */
+	roundChains = /* @__PURE__ */ new Map();
+	channelBrokenAt;
+	disposed = false;
+	/**
+	* Set by drain() (a settings-driven generation handoff): new rounds are
+	* refused so the provider falls back to exec, while in-flight rounds finish
+	* on their runtime undisturbed. Unlike `disposed`, the driver still serves
+	* what it already accepted.
+	*/
+	draining = false;
+	disposeController = new AbortController();
+	constructor(ctx, config = {}, timeouts = DEFAULT_TIMEOUTS) {
+		this.ctx = ctx;
+		this.config = config;
+		this.timeouts = timeouts;
+	}
+	/** Whether the channel is in its post-failure cooldown (rounds fall back to exec). */
+	get disabled() {
+		return this.channelBrokenAt !== void 0 && Date.now() - this.channelBrokenAt < (this.timeouts.channelRetryMs ?? 3e5);
+	}
+	/** Count of resident runtimes currently registered (zombie accounting in tests). */
+	get liveCount() {
+		return this.runtimes.size;
+	}
+	clearIdleTimer(key) {
+		const timer = this.idleTimers.get(key);
+		if (timer !== void 0) clearTimeout(timer);
+		this.idleTimers.delete(key);
+	}
+	armIdleTimer(key) {
+		this.clearIdleTimer(key);
+		const idleMs = this.config.liveIdleMs ?? 18e5;
+		const timer = setTimeout(() => {
+			this.reclaim(key);
+		}, idleMs);
+		timer.unref();
+		this.idleTimers.set(key, timer);
+	}
+	async reclaim(key) {
+		const runtime = this.runtimes.get(key);
+		this.clearIdleTimer(key);
+		if (runtime === void 0) return;
+		this.runtimes.delete(key);
+		await runtime.reclaim();
+	}
+	/** Reclaim every runtime (plugin unload); no process survives the profile. */
+	async disposeAll() {
+		this.disposed = true;
+		this.disposeController.abort();
+		await Promise.all([...this.ensuring.values()].map((pending) => pending.catch(() => void 0)));
+		for (const key of [...this.runtimes.keys()]) await this.reclaim(key);
+	}
+	/**
+	* True while the member's runtime exists or is being spawned. The settings
+	* controller gates a new generation on this: a fresh driver must not serve
+	* a member whose retiring generation still hosts the (same) kimi session.
+	*/
+	hasRuntime(key) {
+		return this.runtimes.has(key) || this.ensuring.has(key);
+	}
+	/** @deprecated Compatibility no-op: live output is always incremental. */
+	setLiveMirrorGranularity(_granularity) {}
+	/**
+	* Drain for a settings-driven generation handoff: refuse new rounds (the
+	* provider's catch falls back to exec), let every in-flight round finish on
+	* its runtime, then reclaim. Resolves when no runtime or spawn remains.
+	* Unlike disposeAll, in-flight work is never interrupted.
+	*/
+	async drain() {
+		this.draining = true;
+		const keys = /* @__PURE__ */ new Set([
+			...this.runtimes.keys(),
+			...this.ensuring.keys(),
+			...this.roundChains.keys()
+		]);
+		await Promise.all([...keys].map(async (key) => {
+			await (this.roundChains.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await (this.ensuring.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await this.reclaim(key);
+		}));
+	}
+	/** The model a runtime spawned for this member right now would bind. */
+	resolveBoundModel(key) {
+		const model = this.config.model?.(key)?.trim();
+		return model === void 0 || model === "" ? void 0 : model;
+	}
+	ensureRuntime(spec, signal) {
+		const key = String(spec.childSession.id);
+		const model = spec.configuration === void 0 ? this.resolveBoundModel(key) : spec.configuration.model;
+		const configurationKey = spec.configuration === void 0 ? void 0 : JSON.stringify(spec.configuration);
+		const existing = this.runtimes.get(key);
+		if (existing !== void 0 && !existing.dead && existing.boundModel === model && existing.configurationKey === configurationKey) {
+			this.clearIdleTimer(key);
+			return Promise.resolve(existing);
+		}
+		if (existing !== void 0) {
+			this.runtimes.delete(key);
+			this.clearIdleTimer(key);
+			if (!existing.dead) existing.reclaim();
+		}
+		const pending = this.ensuring.get(key);
+		if (pending !== void 0 && this.ensuringModel.get(key) === model && this.ensuringConfiguration.get(key) === configurationKey) return pending;
+		const spawn = (pending ?? Promise.resolve()).catch(() => void 0).then(async (stale) => {
+			if (stale !== void 0 && !stale.dead) {
+				if (this.runtimes.get(key) === stale) this.runtimes.delete(key);
+				await stale.reclaim();
+			}
+			return this.spawnRuntime(spec, signal, model);
+		}).finally(() => {
+			if (this.ensuring.get(key) === spawn) {
+				this.ensuring.delete(key);
+				this.ensuringModel.delete(key);
+				this.ensuringConfiguration.delete(key);
+			}
+		});
+		this.ensuring.set(key, spawn);
+		this.ensuringModel.set(key, model);
+		this.ensuringConfiguration.set(key, configurationKey);
+		return spawn;
+	}
+	/**
+	* Retire one member's resident runtime (a composer-driven model switch):
+	* the process is reclaimed and the member's next round respawns onto the
+	* new model, resuming the same CLI session. A member with no runtime (or
+	* only a dead one) is a no-op. Lazy: nothing spawns here.
+	*/
+	async retireRuntime(childSessionId) {
+		const pending = this.ensuring.get(childSessionId);
+		if (pending !== void 0) await pending.catch(() => void 0);
+		await this.reclaim(childSessionId);
+	}
+	/**
+	* The model the member's live runtime is bound to, or undefined when the
+	* member has no live runtime (or it bound none). The broker compares this
+	* against the post-switch effective model to make a same-model set a no-op.
+	*/
+	runtimeModel(childSessionId) {
+		const runtime = this.runtimes.get(childSessionId);
+		return runtime === void 0 || runtime.dead ? void 0 : runtime.boundModel;
+	}
+	runtimeConfiguration(childSessionId) {
+		const runtime = this.runtimes.get(childSessionId);
+		return runtime === void 0 || runtime.dead ? void 0 : runtime.modelConfiguration;
+	}
+	/**
+	* Spawn the member's resident `kimi acp` and prove the wire: initialize +
+	* the loadSession capability (crash recovery needs it — without it the
+	* channel is not live-capable and the breaker trips). A cancellation
+	* mid-spawn reclaims the half-started process without touching the breaker.
+	*/
+	async spawnRuntime(spec, signal, boundModel) {
+		const key = String(spec.childSession.id);
+		if (this.disposed) throw new LiveChannelUnavailableError("the live driver is disposed");
+		const member = this.registerMember(spec);
+		if (spec.configuration === void 0 && boundModel !== void 0) await writeKimiDefaultModel(spec.homeDir, boundModel).catch((error) => {
+			this.ctx.logger.warn(`local-agent-kimi: pinning default_model for the resident runtime failed: ${thrown$1(error).message}`);
+			return false;
+		});
+		const spawnSpec = {
+			argv: [
+				"kimi",
+				...spec.configuration?.model === void 0 ? [] : ["--model", spec.configuration.model],
+				"acp"
+			],
+			cwd: spec.cwd,
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe"
+			},
+			graceMs: DEFAULT_DISPOSE_GRACE_MS,
+			env: delegationEnv({ KIMI_CODE_HOME: spec.homeDir })
+		};
+		let child;
+		try {
+			child = this.ctx.subprocess.spawn(spawnSpec);
+		} catch (error) {
+			member?.release();
+			this.markChannelBroken();
+			throw new LiveChannelUnavailableError(`kimi acp failed to spawn: ${thrown$1(error).message}`);
+		}
+		const runtime = new KimiLiveRuntime(child, (method, params) => this.answerServerRequest(method, params), (message) => {
+			this.ctx.logger.warn(message);
+		}, this.timeouts.requestMs);
+		runtime.onDead = () => {
+			if (this.runtimes.get(key) === runtime) this.runtimes.delete(key);
+			this.clearIdleTimer(key);
+			member?.release();
+		};
+		const aborted = new Promise((_, reject) => {
+			const cancel = () => {
+				reject(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally"));
+			};
+			const unload = () => {
+				reject(new LiveChannelUnavailableError("the live driver was disposed during spawn"));
+			};
+			if (signal.aborted) {
+				cancel();
+				return;
+			}
+			if (this.disposeController.signal.aborted) {
+				unload();
+				return;
+			}
+			signal.addEventListener("abort", cancel, { once: true });
+			this.disposeController.signal.addEventListener("abort", unload, { once: true });
+		});
+		aborted.catch(() => {});
+		try {
+			if ((await Promise.race([runtime.peer.request("initialize", {
+				protocolVersion: ACP_PROTOCOL_VERSION,
+				clientCapabilities: {}
+			}, this.timeouts.initializeMs), aborted]))?.agentCapabilities?.loadSession !== true) throw new Error("kimi acp does not advertise loadSession (crash recovery requires it)");
+		} catch (error) {
+			await runtime.reclaim();
+			if (signal.aborted) throw thrown$1(error);
+			this.markChannelBroken();
+			throw new LiveChannelUnavailableError(`the kimi acp handshake failed: ${thrown$1(error).message}`);
+		}
+		if (this.disposed) {
+			await runtime.reclaim();
+			throw new LiveChannelUnavailableError("the live driver was disposed during spawn");
+		}
+		this.channelBrokenAt = void 0;
+		runtime.boundModel = boundModel;
+		runtime.configurationKey = spec.configuration === void 0 ? void 0 : JSON.stringify(spec.configuration);
+		this.runtimes.set(key, runtime);
+		runtimeMember.set(runtime, member);
+		return runtime;
+	}
+	markChannelBroken() {
+		this.channelBrokenAt = Date.now();
+	}
+	/**
+	* Report an auth-shaped round failure to the family registry's auth-failure
+	* mark (the exec path's post-exit 401 detection ported to a process that
+	* never exits: the match runs against the settled error instead). Degrades
+	* silently on a core predating reportAuthFailure.
+	*/
+	reportAuthIfShaped(error, homeDir) {
+		if (!KIMI_LIVE_AUTH_FAILURE.test(error.message)) return;
+		if (homeDir !== void 0) guardKimiCredential(homeDir, (message) => {
+			this.ctx.logger.warn(message);
+		});
+		const registry = this.ctx.localAgent;
+		if (typeof registry.reportAuthFailure === "function") registry.reportAuthFailure("kimi", error.message.split("\n").find((line) => line.trim() !== "") ?? error.message);
+	}
+	/**
+	* Register the member channel for one resident process (token + bridge
+	* coordinates), duck-typed like the exec path's memberRun but WITHOUT the
+	* mcp.json write — the ACP session declares the bridge inline.
+	*/
+	registerMember(spec) {
+		const registry = this.ctx.localAgent;
+		if (typeof registry.registerMemberRun !== "function" || typeof registry.memberBridgeSocketPath !== "function" || typeof registry.memberBridgeCommand !== "function") return void 0;
+		const token = registry.registerMemberRun({
+			childSessionId: String(spec.childSession.id),
+			parentSessionId: spec.parentSessionId,
+			provider: "kimi-cli"
+		});
+		const bridge = registry.memberBridgeCommand();
+		let released = false;
+		return {
+			mcpServers: [{
+				name: "dsh-member",
+				command: bridge.command,
+				args: [...bridge.args],
+				env: [{
+					name: MEMBER_BRIDGE_SOCKET_ENV,
+					value: registry.memberBridgeSocketPath()
+				}, {
+					name: MEMBER_BRIDGE_TOKEN_ENV,
+					value: token
+				}]
+			}],
+			release: () => {
+				if (released) return;
+				released = true;
+				registry.unregisterMemberRun(token);
+			}
+		};
+	}
+	/**
+	* Auto-answer the ACP permission surface unattended. `session/request_permission`
+	* selects the first allow option (allow_once/allow_always) — matching the
+	* exec mode's auto-approve behavior for `kimi -p` — and cancels when the
+	* child offered none. Anything else (fs/terminal, which we never
+	* advertised) is an error response.
+	*/
+	answerServerRequest(method, params) {
+		if (method === "session/request_permission") {
+			const allow = (Array.isArray(params["options"]) ? params["options"] : []).find((o) => o.kind === "allow_once" || o.kind === "allow_always");
+			if (allow !== void 0 && typeof allow.optionId === "string") return { outcome: {
+				outcome: "selected",
+				optionId: allow.optionId
+			} };
+			return { outcome: { outcome: "cancelled" } };
+		}
+		throw new Error(`subagent-kimi live: unsupported ACP request ${method}`);
+	}
+	/**
+	* Drive one delegation round on the member's resident ACP session. Mirrors
+	* the exec run's settlement contract exactly (settleRunResult + turn/end
+	* bookkeeping); cancel is `session/cancel` and the process survives.
+	*/
+	/** Initialize the native session and model controls without sending a prompt. */
+	async prepare(spec, signal) {
+		signal.throwIfAborted();
+		if (this.draining || this.disabled) throw new LiveChannelUnavailableError("the live driver is unavailable for preparation");
+		try {
+			const runtime = await this.ensureRuntime(spec, signal);
+			await this.configureSession(runtime, spec);
+			signal.throwIfAborted();
+			this.armIdleTimer(String(spec.childSession.id));
+		} catch (error) {
+			await this.reclaim(String(spec.childSession.id));
+			throw error;
+		}
+	}
+	async configureSession(rt, spec) {
+		const member = runtimeMember.get(rt);
+		if (rt.sessionId === void 0) {
+			if (spec.resume === void 0) {
+				const response = await rt.peer.request("session/new", {
+					cwd: spec.cwd,
+					mcpServers: member?.mcpServers ?? []
+				});
+				if (typeof response?.sessionId !== "string") throw new Error("subagent-kimi live: session/new returned no session id");
+				rt.sessionId = response.sessionId;
+				rt.modelConfiguration = kimiNativeConfiguration(response);
+			} else {
+				rt.sessionId = acpKimiSessionId(spec.resume.cliSessionId);
+				rt.modelConfiguration = kimiNativeConfiguration(await rt.peer.request("session/load", {
+					sessionId: rt.sessionId,
+					cwd: spec.cwd,
+					mcpServers: member?.mcpServers ?? []
+				}));
+			}
+		}
+		if (spec.configuration !== void 0) rt.modelConfiguration = await configureKimiSession(rt.sessionId, rt.modelConfiguration, spec.configuration, (method, params) => rt.peer.request(method, params));
+		if (spec.resume === void 0 && rt.sessionId !== void 0) spec.onCliSessionId?.(bareKimiSessionId(rt.sessionId));
+	}
+	async startRound(request, spec) {
+		if (this.draining) throw new LiveChannelUnavailableError("the live driver is draining (a settings change retired this generation)");
+		const key = String(spec.childSession.id);
+		const round = (this.roundChains.get(key) ?? Promise.resolve()).catch(() => {}).then(() => this.startRoundLocked(request, spec));
+		this.roundChains.set(key, round.then((handle) => handle.result.catch(() => ({})), () => ({})));
+		return round;
+	}
+	/** The serialized round body. */
+	async startRoundLocked(request, spec) {
+		const task = textTask(request.prompt);
+		if (request.signal.aborted) throw new Error("subagent-kimi: request was aborted before the run started");
+		if (this.draining) throw new LiveChannelUnavailableError("the live driver is draining (a settings change retired this generation)");
+		if (this.disposed) throw new Error("subagent-kimi: the live driver is disposed");
+		const turn = spec.resume?.turn ?? 1;
+		const childSession = spec.childSession;
+		const localAgent = this.ctx.get("localAgent");
+		const runAbort = new AbortController();
+		let roundSettled = false;
+		let runtime;
+		/** True while this round's session/prompt is in flight (cancel targets it). */
+		let promptInFlight = false;
+		let turnOpened = false;
+		/** The round's accumulated assistant text (the run output — chunks are the only source). */
+		let roundText = "";
+		/**
+		* The step ledger: every step a stream reservation consumed this round
+		* (in increasing order — permanently, whether the stream later completes
+		* or stays an orphan snapshot). The file fold skips these steps for its
+		* sequential folds, so a tool card folded mid-stream lands ABOVE the
+		* stream's step and the projection renders the round's chronological
+		* order.
+		*/
+		const reservedSteps = [];
+		/**
+		* The streaming items seen this round . kimi's ACP
+		* chunks carry no item id, so the stream key is synthetic per kind per
+		* round (the codex live driver's fallback shape): thought chunks share
+		* one stream, message chunks another. Deltas accumulate into throttled
+		* snapshot assistant/messages appended at the stream's reserved
+		* (turn, step) — the host folds repeated settles at one coordinate into
+		* one live-updating chat node. The wire line that completes the stream's
+		* kind folds at the same step and finalizes it; an entry whose completion
+		* never folds is force-finalized at settle.
+		*/
+		const streams = /* @__PURE__ */ new Map();
+		/** The stream the latest delta accumulated into (a kind switch force-snapshots it). */
+		let activeStream;
+		/**
+		* The round's usage NOT carried by a folded line, summed across mirror
+		* passes (each pass's window is disjoint). The settle's final snapshot
+		* carries the remainder when no folded message did — host 0.1.5 has no
+		* usage-backfill event.
+		*/
+		let roundUsage;
+		/**
+		* The model identifier the wire named this round (a mirror pass's
+		* `usage.record` / `llm.request` `model`, last one seen), reported as the
+		* round's settled observation — the live drive's half of the exec path's
+		* settle-mirror read-back.
+		*/
+		let roundModel;
+		let lastMirrorAt = 0;
+		let mirrorQueue = Promise.resolve();
+		let persistQueue = Promise.resolve();
+		const persist = () => {
+			persistQueue = persistQueue.then(() => persistChildSession(this.ctx, childSession)).catch((error) => {
+				this.ctx.logger.warn(`subagent-kimi: live persistence failed: ${thrown$1(error).message}`);
+			});
+		};
+		/** A stream's synthetic key: kimi's ACP deltas carry no item id, so kind + turn pairs them. */
+		let generation = 0;
+		const seenToolCalls = /* @__PURE__ */ new Set();
+		const toolSteps = /* @__PURE__ */ new Map();
+		const streamKey = (kind) => `kimi-stream-${kind}-${turn}-${generation}`;
+		/** The plan stream's key: a snapshot stream beside the think/text delta streams. */
+		const planKey = `kimi-stream-plan-${turn}`;
+		/**
+		* Fold one non-text chunk as a placeholder: image/resource_link content
+		* has no text channel, so the transcript keeps a visible marker (and the
+		* run output notes the drop) instead of the chunk vanishing. Flows exactly
+		* like a text delta from here.
+		*/
+		const foldDelta = (text) => {
+			roundText += text;
+			const key = streamKey("text");
+			reserveStream(key, "text");
+			const stream = streams.get(key);
+			if (stream !== void 0) {
+				stream.text += text;
+				appendStreamSnapshot(stream, false, false);
+			}
+			localAgent?.reportRunProgress(childSession.id, {
+				kind: "delta",
+				text
+			});
+		};
+		/**
+		* Render one ACP plan snapshot ({entries: [{content, status}]}) as
+		* think-style lines. Each update carries the WHOLE plan, so the fold
+		* replaces rather than appends.
+		*/
+		const renderPlan = (update) => {
+			return (Array.isArray(update["entries"]) ? update["entries"] : []).map((entry) => {
+				const content = typeof entry["content"] === "string" ? entry["content"] : "";
+				const status = entry["status"];
+				return `${status === "completed" ? "☑" : status === "in_progress" ? "▶" : "☐"} ${content}`;
+			}).filter((line) => line.trim() !== "☐" && line !== "").join("\n");
+		};
+		const foldPlan = (update) => {
+			const plan = renderPlan(update);
+			if (plan === "") return;
+			reserveStream(planKey, "think");
+			const stream = streams.get(planKey);
+			if (stream !== void 0 && stream.text !== plan) {
+				stream.text = plan;
+				appendStreamSnapshot(stream, true, false);
+			}
+		};
+		/**
+		* Append one snapshot of a streaming item at its reserved (turn, step).
+		* Batched per stream on a bounded deadline unless `force`; the forced
+		* final snapshot carries `interrupted` (a cancelled turn reads 已停止
+		* legitimately) and, when `withUsage`, the round's uncarried usage. An
+		* empty stream leaves no boundary at all.
+		*/
+		const streamPublisher = localAgent?.liveStreams === void 0 ? void 0 : new LiveStreamPublisher(localAgent.liveStreams, childSession, turn, persist, (error) => this.ctx.logger.warn(`live checkpoint failed: ${String(error)}`));
+		const liveFlush = new LiveFlush((error) => this.ctx.logger.warn(`live mirror flush failed: ${String(error)}`), this.config.snapshotMinIntervalMs ?? DEFAULT_SNAPSHOT_MIN_INTERVAL_MS);
+		const pendingStreamArrival = /* @__PURE__ */ new Map();
+		const appendStreamSnapshot = (stream, force, interrupted, withUsage = false, final = false) => {
+			if (stream.text.trim() === "") return;
+			const now = Date.now();
+			if (!force) {
+				if (!pendingStreamArrival.has(stream.step)) pendingStreamArrival.set(stream.step, now);
+				liveFlush.schedule(stream.step, () => appendStreamSnapshot(stream, true, interrupted, withUsage));
+				return;
+			}
+			liveFlush.cancel(stream.step);
+			const receivedAt = pendingStreamArrival.get(stream.step) ?? now;
+			pendingStreamArrival.delete(stream.step);
+			if (streamPublisher !== void 0 && !final) {
+				if (!stream.opened) {
+					childSession.append("step/start", {
+						turn,
+						step: stream.step
+					});
+					stream.opened = true;
+				}
+				streamPublisher.update(stream.step, stream.kind, stream.text, { receivedAt });
+				stream.lastSnapshotAt = now;
+				stream.lastSnapshotLen = stream.text.length;
+				return;
+			}
+			if (!stream.opened) {
+				childSession.append("step/start", {
+					turn,
+					step: stream.step
+				});
+				stream.opened = true;
+			}
+			childSession.append("assistant/message", {
+				turn,
+				step: stream.step,
+				message: assistantEvent([stream.kind === "think" ? {
+					type: "reasoning",
+					text: stream.text
+				} : {
+					type: "text",
+					text: stream.text
+				}], runtime?.modelConfiguration?.currentModel ?? roundModel),
+				stream: [],
+				...withUsage && roundUsage !== void 0 ? { usage: roundUsage } : {},
+				...interrupted ? { interrupted: true } : {}
+			}, { surfaceOp: "append" });
+			if (withUsage) roundUsage = void 0;
+			stream.lastSnapshotAt = now;
+			stream.lastSnapshotLen = stream.text.length;
+			persist();
+		};
+		/**
+		* Reserve the step one streaming item will occupy — past every folded
+		* line (the session's own event ledger: the file fold writes events
+		* synchronously) and every earlier reservation. A kind switch forces one
+		* freshness snapshot of the current stream (skipped when its text has not
+		* grown since the last one); its completion still folds at its own
+		* reserved step when the wire line lands.
+		*/
+		const reserveStream = (key, kind) => {
+			if (activeStream !== void 0 && activeStream !== key) {
+				const previous = streams.get(activeStream);
+				if (previous !== void 0 && previous.text.length !== previous.lastSnapshotLen) appendStreamSnapshot(previous, true, false);
+				activeStream = void 0;
+			}
+			let stream = streams.get(key);
+			if (stream === void 0) {
+				let step = nextKimiSessionStep(childSession, turn);
+				for (const reserved of reservedSteps) step = Math.max(step, reserved + 1);
+				reservedSteps.push(step);
+				stream = {
+					kind,
+					step,
+					text: "",
+					lastSnapshotAt: 0,
+					lastSnapshotLen: 0,
+					opened: false
+				};
+				streams.set(key, stream);
+			}
+			activeStream = key;
+		};
+		/**
+		* The fold-pass coordination surface : the file
+		* fold skips reserved steps for sequential folds and pairs a completed
+		* think/assistant line with its stream — scoped to THIS round's turn, so
+		* an earlier round's leftover lines never consume this round's stream.
+		*/
+		const mirrorStreams = {
+			reservedSteps: (t) => t === turn ? reservedSteps : [],
+			completeTool: (line) => {
+				if (line.turn !== turn) return void 0;
+				const step = toolSteps.get(line.id);
+				if (step === void 0) return void 0;
+				toolSteps.delete(line.id);
+				return {
+					step,
+					opened: true
+				};
+			},
+			completeStream: (line) => {
+				if (line.turn !== turn) return void 0;
+				const kind = line.kind === "think" ? "think" : "text";
+				const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
+				if (entry === void 0) return void 0;
+				const [key, stream] = entry;
+				liveFlush.cancel(stream.step);
+				streamPublisher?.finish(stream.step);
+				streams.delete(key);
+				if (activeStream === key) activeStream = void 0;
+				return {
+					step: stream.step,
+					opened: stream.opened
+				};
+			}
+		};
+		const mirrorOptions = () => ({ streams: mirrorStreams });
+		/**
+		* Observation accounting across mirror passes: a pass whose window
+		* attached its usage to a folded message is already carried; anything else
+		* sums into the round's uncarried remainder (the final snapshot's payload).
+		* The wire's model rides every pass that saw one — the settle report reads
+		* the latest.
+		*/
+		const noteMirrorUsage = (delta) => {
+			if (delta.usage !== void 0 && delta.usageAttached !== true) roundUsage = addTokenUsage(roundUsage, delta.usage);
+			if (delta.model !== void 0) roundModel = delta.model;
+		};
+		/** Throttled push-triggered mirror pass; the file fold stays the only transcript source. */
+		const triggerMirror = () => {
+			const now = Date.now();
+			if (now - lastMirrorAt < this.timeouts.mirrorThrottleMs) return;
+			lastMirrorAt = now;
+			mirrorQueue = mirrorQueue.then(() => mirrorKimiDelta(this.ctx, childSession, spec.homeDir, runtime?.sessionId === void 0 ? void 0 : bareKimiSessionId(runtime.sessionId), mirrorOptions()).then((delta) => {
+				noteMirrorUsage(delta);
+			}).catch((error) => {
+				this.ctx.logger.warn(`subagent-kimi: live mirror pass failed: ${thrown$1(error).message}`);
+			}));
+		};
+		const requestCancel = () => {
+			if (roundSettled || runAbort.signal.aborted) return;
+			runAbort.abort(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally"));
+			if (promptInFlight && runtime?.sessionId !== void 0 && !runtime.dead) runtime.peer.notify("session/cancel", { sessionId: runtime.sessionId });
+		};
+		const onAbort = () => {
+			requestCancel();
+		};
+		request.signal.addEventListener("abort", onAbort, { once: true });
+		const abortBranch = new Promise((_, reject) => {
+			runAbort.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally")), { once: true });
+		});
+		const collectOutput = () => {
+			return roundText.trim() === "" ? [] : [{
+				type: "text",
+				text: roundText
+			}];
+		};
+		/** The round's update sink (installed on the runtime while it runs). */
+		const onSessionUpdate = (update) => {
+			const kind = update["sessionUpdate"];
+			if (kind === "agent_message_chunk") {
+				const content = update["content"];
+				if (content !== void 0 && content.type !== void 0 && content.type !== "text") {
+					foldDelta(`[未支持的内容类型 ${content.type}]`);
+					triggerMirror();
+					return;
+				}
+				const text = content?.text ?? "";
+				if (text !== "") foldDelta(text);
+			} else if (kind === "agent_thought_chunk") {
+				const text = update["content"]?.text ?? "";
+				if (text !== "") {
+					const key = streamKey("think");
+					reserveStream(key, "think");
+					const stream = streams.get(key);
+					if (stream !== void 0) {
+						stream.text += text;
+						appendStreamSnapshot(stream, false, false);
+					}
+				}
+			} else if (kind === "tool_call") {
+				const id = typeof update["toolCallId"] === "string" ? update["toolCallId"] : void 0;
+				if (id === void 0 || !seenToolCalls.has(id)) {
+					if (id !== void 0) {
+						seenToolCalls.add(id);
+						let step = nextKimiSessionStep(childSession, turn);
+						for (const reserved of reservedSteps) step = Math.max(step, reserved + 1);
+						reservedSteps.push(step);
+						toolSteps.set(id, step);
+						childSession.append("step/start", {
+							turn,
+							step
+						});
+						persist();
+					}
+					generation++;
+				}
+			} else if (kind === "plan") foldPlan(update);
+			triggerMirror();
+		};
+		const accepted = (async () => {
+			const rt = await this.ensureRuntime(spec, request.signal);
+			runtime = rt;
+			if (runAbort.signal.aborted) {
+				await this.reclaim(String(childSession.id));
+				throw new Error("subagent-kimi: run cancelled locally");
+			}
+			try {
+				await this.configureSession(rt, spec);
+			} catch (error) {
+				if (!runAbort.signal.aborted) await this.reclaim(String(childSession.id));
+				throw thrown$1(error);
+			}
+			rt.onSessionUpdate = onSessionUpdate;
+			childSession.append("turn/start", { turn });
+			childSession.append("user/message", createUserMessage({
+				content: [{
+					type: "text",
+					text: task
+				}],
+				source: { kind: "user" }
+			}), { surfaceOp: "append" });
+			turnOpened = true;
+		})();
+		const attempt = accepted.then(async () => {
+			if (runAbort.signal.aborted) throw new Error("subagent-kimi: run cancelled locally");
+			const rt = runtime;
+			const processFailure = rt.child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-kimi: the live runtime exited mid-round (code ${String(outcome.exitCode)}, signal ${String(outcome.signal)})`)), (error) => Promise.reject(thrown$1(error)));
+			processFailure.catch(() => {});
+			const sendPrompt = () => {
+				if (runAbort.signal.aborted) return Promise.reject(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally"));
+				promptInFlight = true;
+				return rt.peer.request("session/prompt", {
+					sessionId: rt.sessionId,
+					prompt: [{
+						type: "text",
+						text: task
+					}]
+				}, 0);
+			};
+			const promptPromise = rt.turnChain.catch(() => {}).then(sendPrompt);
+			rt.turnChain = promptPromise;
+			const promptResult = await Promise.race([promptPromise, processFailure]);
+			const stopReason = acpStopReasonToHarness(String(promptResult?.stopReason ?? ""));
+			if (stopReason === "completed" && collectOutput().length === 0) throw new Error("subagent-kimi live: the turn completed but produced no answer");
+			return {
+				output: collectOutput(),
+				stopReason
+			};
+		});
+		/**
+		* Settle reconciliation: the kimi wire flushes asynchronously past the
+		* prompt response (prompt lines early, the answer by turn end), so the
+		* final mirror folds until consecutive reads see no growth — bounded, so
+		* a stuck flush cannot pin the round beyond the quiescence window.
+		*/
+		const settleMirror = async () => {
+			await mirrorQueue.catch(() => {});
+			const sessionId = runtime?.sessionId === void 0 ? void 0 : bareKimiSessionId(runtime.sessionId);
+			let lastTotal = -1;
+			let stableReads = 0;
+			const deadline = Date.now() + SETTLE_MIRROR_QUIESCE_MS;
+			for (;;) {
+				const delta = await mirrorKimiDelta(this.ctx, childSession, spec.homeDir, sessionId, mirrorOptions());
+				noteMirrorUsage(delta);
+				localAgent?.reportRunProgress(childSession.id, {
+					kind: "mirror",
+					mirroredLines: delta.total
+				});
+				stableReads = delta.total === lastTotal ? stableReads + 1 : 0;
+				lastTotal = delta.total;
+				if (stableReads >= SETTLE_MIRROR_STABLE_READS) break;
+				if (Date.now() >= deadline) break;
+				await delay(SETTLE_MIRROR_POLL_MS);
+			}
+		};
+		const result = settleRunResult({
+			attempt: () => Promise.race([attempt, abortBranch]),
+			collectOutput,
+			cancelled: () => runAbort.signal.aborted,
+			onError: (error, stopReason) => {
+				const diagnostics = runtime?.diagnostics ?? "";
+				const suffix = diagnostics === "" ? "" : `; ${diagnostics}`;
+				this.ctx.logger.warn(`subagent-kimi: live round failed (${stopReason}): ${error.message}${suffix}`);
+				this.reportAuthIfShaped(error, spec.homeDir);
+			},
+			signal: request.signal,
+			onAbort
+		}).then(async (settled) => {
+			roundSettled = true;
+			liveFlush.dispose();
+			promptInFlight = false;
+			if (turnOpened) {
+				try {
+					await settleMirror();
+				} catch (error) {
+					this.ctx.logger.warn(`subagent-kimi: live settle mirror failed: ${thrown$1(error).message}`);
+				}
+				if (streams.size > 0) {
+					const remaining = [...streams.values()];
+					for (const [position, stream] of remaining.entries()) {
+						appendStreamSnapshot(stream, true, settled.stopReason !== "completed", position === remaining.length - 1, true);
+						streamPublisher?.finish(stream.step);
+						if (stream.opened) childSession.append("step/end", {
+							turn,
+							step: stream.step
+						});
+					}
+					streams.clear();
+					activeStream = void 0;
+					persist();
+				}
+				for (const step of toolSteps.values()) childSession.append("step/end", {
+					turn,
+					step
+				});
+				toolSteps.clear();
+				if (settled.stopReason === "completed") childSession.append("turn/end", {
+					turn,
+					reason: { kind: "completed" }
+				});
+				else if (settled.stopReason === "aborted") childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "aborted",
+						reason: { kind: "parent" }
+					}
+				});
+				else childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "error",
+						error: {
+							message: "the live round did not complete",
+							code: "UNKNOWN"
+						}
+					}
+				});
+			}
+			streamPublisher?.dispose();
+			if (runtime !== void 0) runtime.onSessionUpdate = void 0;
+			if (turnOpened) {
+				persist();
+				await persistQueue;
+			}
+			return settled;
+		});
+		result.then(() => {
+			if (turnOpened) {
+				const round = { ...roundModel === void 0 ? {} : { observedModel: roundModel } };
+				localAgent?.recordRoundSettled?.(childSession.id, round);
+			}
+			this.armIdleTimer(String(childSession.id));
+		});
+		await Promise.race([accepted, abortBranch.catch(() => void 0)]);
+		return subprocessRunHandle({
+			id: childSession.id,
+			result,
+			signal: request.signal,
+			onAbort,
+			requestCancel,
+			teardown: async () => {
+				if (roundSettled) return;
+				const rt = runtime;
+				if (rt === void 0) return;
+				await Promise.race([rt.turnChain.catch(() => {}), delay(this.timeouts.convergeMs)]);
+			}
+		});
+	}
+};
+/** The member handle each runtime carries (for its session declarations). */
+const runtimeMember = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region lib/types/member-bridge-config.js
+/**
+* Kimi scoped-home MCP config injection for the member bridge. Kimi declares
+* stdio MCP servers in `$KIMI_CODE_HOME/mcp.json` (`mcpServers` map); the file
+* is read once per CLI session start, and edits never interrupt an open
+* session — so the family writes one entry PER RUN (keyed by the run's token
+* suffix, keeping concurrent delegations of the same scoped home race-free),
+* prunes it when the run settles, and drops stale family entries (crashed
+* host) on every write. User-declared servers are preserved verbatim.
+* @module @khorsheed/dsh-local-agent-kimi/member-bridge-config
+*/
+/** Kimi's user-level MCP config filename inside the scoped home. */
+const MCP_CONFIG_FILENAME = "mcp.json";
+/** Server-key prefix marking the family's per-run bridge entries. */
+const MEMBER_BRIDGE_SERVER_PREFIX = "dsh-member-";
+/**
+* The per-run MCP server key. The run's token suffix keeps concurrent runs
+* distinct; each `kimi -p` round is a fresh CLI session, so per-run (rather
+* than per-member) naming costs nothing.
+* @param token - the run's member-channel token.
+* @returns the mcp.json server key.
+*/
+function memberBridgeServerKey(token) {
+	return `${MEMBER_BRIDGE_SERVER_PREFIX}${token.slice(0, 8)}`;
+}
+/** Read the scoped mcp.json; a missing or malformed file reads as empty. */
+function readMcpConfig(file) {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return {};
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+	return parsed;
+}
+/** Write the config back, preserving every non-family key. */
+function writeMcpConfig(file, config) {
+	writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+}
+/**
+* Declare the member bridge for one run: set the per-run server entry and
+* prune other family entries (settled or crashed runs — an open session's
+* already-registered server is unaffected, per kimi's mid-session semantics).
+* Synchronous read-modify-write: single-process callers race-free by event
+* loop; the file is small and written once per run.
+* @param homeDir - the kimi scoped home.
+* @param key - this run's server key ({@link memberBridgeServerKey}).
+* @param command - the bridge spawn command (`node` + entry path).
+* @param env - the bridge environment (socket path + per-run token).
+*/
+function injectMemberBridge(homeDir, key, command, env) {
+	const file = join(homeDir, MCP_CONFIG_FILENAME);
+	const config = readMcpConfig(file);
+	const servers = { ...config.mcpServers ?? {} };
+	for (const name of Object.keys(servers)) if (name.startsWith("dsh-member-") && name !== key) delete servers[name];
+	servers[key] = {
+		command: command.command,
+		args: command.args,
+		env
+	};
+	writeMcpConfig(file, {
+		...config,
+		mcpServers: servers
+	});
+}
+/**
+* Remove one run's bridge entry (settle path). Absent entries and a missing
+* config are no-ops.
+* @param homeDir - the kimi scoped home.
+* @param key - the run's server key.
+*/
+function removeMemberBridge(homeDir, key) {
+	const file = join(homeDir, MCP_CONFIG_FILENAME);
+	const config = readMcpConfig(file);
+	if (config.mcpServers === void 0 || !(key in config.mcpServers)) return;
+	const servers = { ...config.mcpServers };
+	delete servers[key];
+	writeMcpConfig(file, {
+		...config,
+		mcpServers: servers
+	});
+}
+//#endregion
+//#region lib/types/kimi-cli-provider.js
+/**
+* One-shot and resumable Kimi CLI subagent lifecycle: spawn `kimi -p "<task>"`
+* through the subprocess seam, capture its printed response as the run output,
+* and dispose to whole-tree quiescence. Mirrors the official one-shot Codex
+* provider, and adds the family's own resume: a later round calls the tool with
+* the first round's dsh child session id, the family registry maps it back to
+* the kimi session, and the provider spawns `kimi -S session_<id> -p` so the
+* SAME kimi conversation continues inside the SAME dsh child session.
+* @module @khorsheed/dsh-local-agent-kimi/kimi-cli-provider
+*/
+/** Default POSIX grace between subprocess termination tiers. */
+const DEFAULT_DISPOSE_GRACE_MS = 3e3;
+/**
+* Auth-shaped failure signatures in kimi's stderr or output: the endpoint
+* rejected the credential. Narrow on purpose — matched against
+* provider-controlled error output only.
+*/
+const KIMI_AUTH_FAILURE = /401|unauthorized|invalid api key|not authenticated/i;
+/**
+* One-shot Kimi CLI subagent provider: every accepted fresh run starts a
+* fresh `kimi -p` process in the delegating Session's workspace, under the
+* harness scoped home; a resume round (the family tool's staged resume intent)
+* continues the SAME kimi session with `kimi -S session_<id> -p` inside the
+* SAME dsh child session. Mirrors the official one-shot Codex provider for the
+* fresh path, including `NO_START_CAPABILITIES` — continuation is the family's
+* own resume mechanism, not the official Agent-type continuable seam.
+*/
+/**
+* Mark the harness credential verified after a completed round, degrading
+* silently on a core that predates the mark (the family's companion-pair
+* rule: a provider paired with an older core loses the grade, never the run).
+* @param ctx - host context carrying the family registry.
+*/
+function markCredentialVerified(ctx, scope) {
+	const registry = ctx.get("localAgent");
+	if (registry === void 0 || typeof registry.reportAuthSuccess !== "function") return;
+	registry.reportAuthSuccess("kimi", scope);
+}
+/**
+* The version `kimi --version` reports, probed through the shared subprocess
+* seam inside the SCOPED home (never the user's own installation) and cached
+* by the family probe against the executable's identity. Kimi's wire log names
+* no build, so this is the only version channel the harness has — both the
+* effective-settings snapshot and a settled round's read-back read it.
+* @param ctx - host context carrying the subprocess seam.
+* @param homeDir - the harness's scoped home.
+* @returns the version, or undefined when the CLI cannot be asked.
+*/
+function kimiCliVersion(ctx, homeDir) {
+	const subprocess = ctx.get("subprocess");
+	if (subprocess === void 0) return Promise.resolve(void 0);
+	return probeCliVersion({
+		argv: ["kimi", "--version"],
+		cwd: homeDir,
+		spawn: (spec) => subprocess.spawn(spec),
+		env: delegationEnv({ KIMI_CODE_HOME: homeDir })
+	});
+}
+var KimiCliProvider = class {
+	ctx;
+	live;
+	model;
+	memberModels;
+	name = "kimi-cli";
+	capabilities = NO_START_CAPABILITIES;
+	inheritsParentContext = false;
+	/**
+	* @param live - the live driver, or a resolver returning the current
+	*   generation's driver per member (the settings toggle swaps generations;
+	*   a resolver may return undefined to steer one member's round to exec
+	*   while a retiring generation still hosts it).
+	* @param model - resolver for the configured model, read PER ROUND so a
+	*   settings-card write takes effect on the next delegation without a
+	*   reload. Undefined (the resolver absent, or returning undefined) leaves
+	*   the argv exactly as it was before the key rode every round — the scoped
+	*   config.toml's `default_model` then decides, as it always did.
+	* @param memberModels - the broker's member-model ledger: the provider
+	*   records each delegation's start model here (the live driver's spawn
+	*   resolver binds it) and reads the session-level override as the exec
+	*   path's top layer. Absent (older wiring), both drop out.
+	*/
+	constructor(ctx, live, model, memberModels) {
+		this.ctx = ctx;
+		this.live = live;
+		this.model = model;
+		this.memberModels = memberModels;
+	}
+	/** Resolve the live driver for one round's member, if live is on for it. */
+	liveDriver(childSessionId) {
+		const live = this.live;
+		if (live === void 0) return void 0;
+		return typeof live === "function" ? live(childSessionId) : live;
+	}
+	/**
+	* Register one run with the member channel and declare the bridge MCP server
+	* in the scoped home's mcp.json (per-run entry, socket + token in its env).
+	* Returns the release handle, or undefined when the mounted core
+	* predates the member channel (declare-and-degrade: the run proceeds
+	* exactly as before). Token-only auth: host 0.1.5 removed the child pid the
+	* parentage cross-check used; the per-run token is the sole credential (see
+	* the package README's threat model). `release` invalidates the token and
+	* prunes the config entry on any settle path.
+	*/
+	memberRun(childSessionId, parentSessionId, homeDir) {
+		const registry = this.ctx.localAgent;
+		if (typeof registry.registerMemberRun !== "function" || typeof registry.memberBridgeSocketPath !== "function" || typeof registry.memberBridgeCommand !== "function") return void 0;
+		const token = registry.registerMemberRun({
+			childSessionId,
+			parentSessionId,
+			provider: this.name
+		});
+		const key = memberBridgeServerKey(token);
+		try {
+			injectMemberBridge(homeDir, key, registry.memberBridgeCommand(), {
+				[MEMBER_BRIDGE_SOCKET_ENV]: registry.memberBridgeSocketPath(),
+				[MEMBER_BRIDGE_TOKEN_ENV]: token
+			});
+		} catch (error) {
+			registry.unregisterMemberRun(token);
+			this.ctx.logger.warn(`subagent-kimi: member bridge config injection failed: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		let released = false;
+		return { release: () => {
+			if (released) return;
+			released = true;
+			registry.unregisterMemberRun(token);
+			try {
+				removeMemberBridge(homeDir, key);
+			} catch (error) {
+				this.ctx.logger.warn(`subagent-kimi: member bridge config cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		} };
+	}
+	async start(request) {
+		const intent = this.ctx.localAgent.takeDelegationIntent(request.parent.session.id, this.name);
+		const scope = intent?.scope;
+		const homeDir = this.ctx.localAgent.homeDir("kimi", scope);
+		const cwd = resolveChildCwd(request.parent.session.header.cwd, intent?.cwd);
+		if (cwd === void 0) throw new Error("subagent-kimi: the parent session has no working directory to run the CLI in");
+		const exec = intent?.exec;
+		if (exec !== void 0) containerScopedHome(exec, "KIMI_CODE_HOME", "subagent-kimi");
+		if (intent !== void 0 && intent.kind === "resume") {
+			const record = this.ctx.localAgent.getDelegation(intent.childSessionId);
+			assertResumeCwdUnchanged(record, cwd, "subagent-kimi");
+			assertResumeScopeUnchanged(record, scope, "subagent-kimi");
+			if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") return this.startKimiResume(request, intent, cwd, homeDir, exec, scope, record?.model);
+			return this.ctx.localAgent.withMemberConfigurationRound({
+				childSessionId: intent.childSessionId,
+				provider: this.name,
+				parentSessionId: request.parent.session.id,
+				cwd,
+				...scope === void 0 ? {} : { scope },
+				...record?.model === void 0 ? {} : { model: record.model },
+				...record?.effort === void 0 ? {} : { effort: record.effort },
+				...record?.configurationLock === void 0 ? {} : { configurationLock: record.configurationLock }
+			}, (configuration) => this.startKimiResume(request, intent, cwd, homeDir, exec, scope, record?.model, configuration), request.signal, intent?.onAdmitted);
+		}
+		const childSessionId = SessionId(intent?.preparedMemberId ?? randomUUID());
+		if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") {
+			if (intent?.effort !== void 0) throw new Error("Kimi effort requires the configuration admission core");
+			return this.startKimiFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId);
+		}
+		return this.ctx.localAgent.withMemberConfigurationRound({
+			childSessionId,
+			provider: this.name,
+			parentSessionId: request.parent.session.id,
+			cwd,
+			...scope === void 0 ? {} : { scope },
+			...intent?.model === void 0 ? {} : { model: intent.model },
+			...intent?.effort === void 0 ? {} : { effort: intent.effort },
+			...intent?.configurationLock === void 0 ? {} : { configurationLock: intent.configurationLock }
+		}, (configuration) => this.startKimiFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId, configuration), request.signal, intent?.onAdmitted);
+	}
+	/** Fresh round: record the child session, spawn `kimi -p`, mirror after settle. */
+	async startKimiFresh(request, cwd, homeDir, exec, scope, requestedModel, runId, configuration) {
+		let childSession;
+		try {
+			const sessions = this.ctx.get("sessions");
+			if (sessions === void 0) throw new Error("the sessions service is not mounted");
+			childSession = sessions.get(runId) ?? sessions.create(runId, { meta: {
+				cwd,
+				parentSession: request.parent.session.id,
+				origin: "subagent",
+				delegationDepth: (request.parent.session.header.delegationDepth ?? 0) + 1
+			} });
+			const harness = this.ctx.localAgent.get("kimi");
+			const label = subagentDelegationLabel(harness?.displayName ?? "kimi", request.descriptor.label);
+			childSession.append("subagent/descriptor", {
+				...request.descriptor,
+				label
+			});
+			establishSubagentCatalogChild(request.parent.session, childSession.header, label);
+		} catch (error) {
+			this.ctx.logger.warn(`subagent-kimi: subagent session record failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const baseUrl = await readKimiBaseUrl(homeDir).catch(() => void 0);
+		this.ctx.logger.info(`subagent-kimi: delegating via ${baseUrl ?? "kimi default endpoint"}`);
+		const live = exec === void 0 ? this.liveDriver(runId) : void 0;
+		if (live !== void 0 && childSession !== void 0 && !live.disabled) {
+			if (requestedModel !== void 0) this.memberModels?.noteStartModel(runId, requestedModel);
+			try {
+				return await live.startRound(request, {
+					cwd,
+					homeDir,
+					childSession,
+					...configuration === void 0 ? {} : { configuration: configuration.resolved },
+					parentSessionId: request.parent.session.id,
+					onCliSessionId: (cliSessionId) => {
+						this.ctx.localAgent.recordDelegation({
+							childSessionId: runId,
+							provider: this.name,
+							parentSessionId: request.parent.session.id,
+							cliSessionId,
+							cwd,
+							...scope === void 0 ? {} : { scope },
+							...requestedModel === void 0 ? {} : { model: requestedModel }
+						});
+					}
+				});
+			} catch (error) {
+				if (!(error instanceof LiveChannelUnavailableError) || request.signal.aborted) throw error;
+				this.ctx.logger.warn(`subagent-kimi: live driver unavailable, using the exec one-shot: ${error.message}`);
+			}
+		}
+		const member = exec === void 0 && scope === void 0 ? this.memberRun(runId, request.parent.session.id, homeDir) : void 0;
+		try {
+			const run = await startKimiCliRun(request, {
+				cwd,
+				env: delegationEnv({ KIMI_CODE_HOME: homeDir }),
+				...exec === void 0 ? {} : { exec },
+				endpointLabel: baseUrl,
+				...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(runId) ?? requestedModel, this.model),
+				...configuration === void 0 ? {} : { controlled: true },
+				disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+				spawn: (spec) => this.ctx.subprocess.spawn(spec),
+				onError: (error, stopReason) => {
+					this.ctx.logger.warn(`subagent-kimi: child run failed (${stopReason}) via ${baseUrl ?? "kimi default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+				},
+				onAuthFailure: (detail) => {
+					guardKimiCredential(homeDir, (message) => {
+						this.ctx.logger.warn(message);
+					});
+					this.ctx.localAgent.reportAuthFailure("kimi", detail, scope);
+				},
+				onAuthSuccess: () => {
+					markCredentialVerified(this.ctx, scope);
+				},
+				cliVersion: () => kimiCliVersion(this.ctx, homeDir),
+				childSession,
+				homeDir,
+				ctx: this.ctx,
+				onCliSessionId: (cliSessionId) => {
+					if (cliSessionId === void 0) return;
+					this.ctx.localAgent.recordDelegation({
+						childSessionId: runId,
+						provider: this.name,
+						parentSessionId: request.parent.session.id,
+						cliSessionId,
+						cwd,
+						...scope === void 0 ? {} : { scope },
+						...requestedModel === void 0 ? {} : { model: requestedModel }
+					});
+				},
+				onRoundSettled: (round) => {
+					this.ctx.localAgent.recordRoundSettled(runId, round);
+				}
+			});
+			if (member !== void 0) run.result.then(member.release, member.release);
+			return run;
+		} catch (error) {
+			member?.release();
+			throw error;
+		}
+	}
+	/** Resume round: continue the recorded kimi session inside the existing child session. */
+	async startKimiResume(request, intent, cwd, homeDir, exec, scope, requestedModel, configuration) {
+		if (!this.ctx.localAgent.acquireResumeLock(intent.childSessionId)) throw new Error(`subagent-kimi: 该子会话有进行中的委派，等其完成后再追问 (child session ${intent.childSessionId})`);
+		try {
+			const childSession = this.ctx.get("sessions")?.get(SessionId(intent.childSessionId));
+			if (childSession === void 0) throw new Error(`subagent-kimi: resume target child session ${intent.childSessionId} is not live — start a fresh delegation instead`);
+			const nextTurn = childSession.snapshotEvents().filter((event) => event.type === "turn/start").length + 1;
+			const live = exec === void 0 ? this.liveDriver(intent.childSessionId) : void 0;
+			if (live !== void 0 && !live.disabled) {
+				if (requestedModel !== void 0) this.memberModels?.noteStartModel(intent.childSessionId, requestedModel);
+				try {
+					const liveRun = await live.startRound(request, {
+						cwd,
+						homeDir,
+						childSession,
+						...configuration === void 0 ? {} : { configuration: configuration.resolved },
+						parentSessionId: request.parent.session.id,
+						resume: {
+							cliSessionId: intent.cliSessionId,
+							turn: nextTurn
+						}
+					});
+					liveRun.result.then(() => {
+						this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+					}, () => {
+						this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+					});
+					return liveRun;
+				} catch (error) {
+					if (!(error instanceof LiveChannelUnavailableError) || request.signal.aborted) throw error;
+					this.ctx.logger.warn(`subagent-kimi: live driver unavailable, using the exec one-shot: ${error.message}`);
+				}
+			}
+			const member = exec === void 0 && scope === void 0 ? this.memberRun(intent.childSessionId, request.parent.session.id, homeDir) : void 0;
+			const baseUrl = await readKimiBaseUrl(homeDir).catch(() => void 0);
+			this.ctx.logger.info(`subagent-kimi: resuming via ${baseUrl ?? "kimi default endpoint"}`);
+			let run;
+			try {
+				run = await startKimiCliRun(request, {
+					cwd,
+					env: delegationEnv({ KIMI_CODE_HOME: homeDir }),
+					...exec === void 0 ? {} : { exec },
+					endpointLabel: baseUrl,
+					...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(intent.childSessionId) ?? requestedModel, this.model),
+					...configuration === void 0 ? {} : { controlled: true },
+					disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+					spawn: (spec) => this.ctx.subprocess.spawn(spec),
+					onError: (error, stopReason) => {
+						this.ctx.logger.warn(`subagent-kimi: child run failed (${stopReason}) via ${baseUrl ?? "kimi default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+					},
+					onAuthFailure: (detail) => {
+						guardKimiCredential(homeDir, (message) => {
+							this.ctx.logger.warn(message);
+						});
+						this.ctx.localAgent.reportAuthFailure("kimi", detail, scope);
+					},
+					onAuthSuccess: () => {
+						markCredentialVerified(this.ctx, scope);
+					},
+					cliVersion: () => kimiCliVersion(this.ctx, homeDir),
+					childSession,
+					homeDir,
+					ctx: this.ctx,
+					resume: {
+						cliSessionId: intent.cliSessionId,
+						turn: nextTurn
+					},
+					onRoundSettled: (round) => {
+						this.ctx.localAgent.recordRoundSettled(intent.childSessionId, round);
+					}
+				});
+			} catch (error) {
+				member?.release();
+				throw error;
+			}
+			run.result.then(() => {
+				this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				member?.release();
+			}, () => {
+				this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				member?.release();
+			});
+			return run;
+		} catch (error) {
+			this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+			throw error;
+		}
+	}
+};
+function thrown(value) {
+	/* v8 ignore next -- typed subprocess failures reject with Error. */
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Extract the kimi session id from the CLI's printed response. `kimi -p`
+* prints a resume hint (`To resume this session: kimi -r session_<id>`) on
+* stdout after a run; mirroring that exact session instead of the newest-by-
+* mtime keeps concurrent delegations from cross-mirroring.
+* @param output - the collected CLI stdout.
+* @returns the session id, or undefined when the hint is absent.
+*/
+function kimiSessionIdFromOutput(output) {
+	return /kimi -r session_([0-9a-fA-F-]+)/.exec(output)?.[1];
+}
+/**
+* Validate and join the one-shot task before crossing the process boundary.
+* @param prompt - task content accepted from the shared subagent service.
+* @returns the joined non-empty text.
+*/
+function textTask(prompt) {
+	if (prompt.length === 0) throw new Error("subagent-kimi: the one-shot task must contain only text blocks");
+	const texts = [];
+	for (const block of prompt) {
+		if (block.type !== "text") throw new Error("subagent-kimi: the one-shot task must contain only text blocks");
+		texts.push(block.text);
+	}
+	if (texts.every((text) => text.trim().length === 0)) throw new Error("subagent-kimi: the one-shot task must not be empty");
+	return texts.join("\n");
+}
+/**
+* Mirror the transcript delta after the recorded offset, advance the offset,
+* and report one `delta` progress per newly mirrored line. Shared by the live
+* poll and the settle-time mirror so the two paths cannot drift. The offset
+* read (`kimiMirroredLines`) and write (`setKimiMirroredLines`) are the same
+* bookkeeping the settle path used before live mirroring existed.
+* @param ctx - host context carrying localAgent and session persistence.
+* @param childSession - the dsh child session being mirrored into.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param kimiSessionId - the kimi session to mirror.
+* @returns the mirror delta (new total + newly mirrored line texts).
+*/
+async function mirrorKimiDelta(ctx, childSession, homeDir, kimiSessionId, options) {
+	const localAgent = ctx.get("localAgent");
+	const delta = await mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, localAgent?.kimiMirroredLines(childSession.id) ?? 0, options);
+	if (delta.texts.length === 0) return delta;
+	localAgent?.setKimiMirroredLines(childSession.id, delta.total);
+	for (const text of delta.texts) localAgent?.reportRunProgress(childSession.id, {
+		kind: "delta",
+		text
+	});
+	return delta;
+}
+/**
+* Mirror the kimi session's transcript into the child session AFTER the CLI
+* process has exited, whatever its stop reason. A cancelled or failed round
+* still preserves whatever the wire already recorded (partial answer, tool
+* activity, usage) instead of leaving the child blank — the run result
+* settles 'aborted'/'error' at the cancel moment, but the CLI may have
+* produced content before the kill landed, and that content belongs in the
+* 子代理 surface with its real token accounting. Also records the delegation
+* (fresh rounds) so a later resume can continue the session.
+* @param spec - the run spec carrying the child session, home, and context.
+* @param stderr - the collected CLI stderr (the resume hint lives here).
+* @returns this pass's observation — the wire's model identifier and the
+*   window's usage — or undefined when nothing was mirrored; the caller sums
+*   the window usage into the round total and reports the round's settled
+*   observation.
+*/
+async function mirrorKimiAfterExit(spec, stderr) {
+	if (spec.childSession === void 0 || spec.homeDir === void 0 || spec.ctx === void 0) return void 0;
+	try {
+		const kimiSessionId = spec.resume?.cliSessionId ?? kimiSessionIdFromOutput(stderr);
+		if (spec.resume === void 0) spec.onCliSessionId?.(kimiSessionId);
+		const delta = await mirrorKimiDelta(spec.ctx, spec.childSession, spec.homeDir, kimiSessionId, { turn: spec.resume?.turn ?? 1 });
+		spec.ctx.get("localAgent")?.reportRunProgress(spec.childSession.id, {
+			kind: "mirror",
+			mirroredLines: delta.total
+		});
+		return {
+			...delta.model === void 0 ? {} : { model: delta.model },
+			...delta.usage === void 0 ? {} : { usage: delta.usage },
+			...delta.toolCalls === void 0 ? {} : { toolCalls: delta.toolCalls }
+		};
+	} catch (error) {
+		spec.onError?.(thrown(error), "error");
+		return;
+	}
+}
+/**
+* Start the real `kimi -p` (fresh) or `kimi -S session_<id> -p` (resume)
+* child and publish its run. The kimi response is printed to stdout; stderr
+* is inherited for diagnostics. The run id is the child session id for a
+* session-backed run, so the tool's `resume="<id>"` self-description names
+* the same handle the registry records.
+* @param request - resolved shared subagent request.
+* @param spec - workspace, environment, process service, and diagnostic policy.
+* @returns the published run after the child starts.
+*/
+async function startKimiCliRun(request, spec) {
+	const task = textTask(request.prompt);
+	if (request.signal.aborted) throw new Error("subagent-kimi: request was aborted before the CLI started");
+	const turn = spec.resume?.turn ?? 1;
+	spec.childSession?.append("turn/start", { turn });
+	const modelArgv = spec.model === void 0 ? [] : ["-m", spec.model];
+	const argv = spec.resume === void 0 ? [
+		"kimi",
+		...modelArgv,
+		"-p",
+		task
+	] : [
+		"kimi",
+		"-S",
+		spec.resume.cliSessionId.startsWith("session_") ? spec.resume.cliSessionId : `session_${spec.resume.cliSessionId}`,
+		...modelArgv,
+		"-p",
+		task
+	];
+	const configurationHome = spec.homeDir ?? spec.env["KIMI_CODE_HOME"];
+	if (spec.controlled && spec.effort !== void 0 && !configurationHome) throw new Error("Kimi effort requires an explicit scoped configuration home");
+	const configEnv = spec.controlled && spec.effort !== void 0 ? await kimiExecConfiguration(configurationHome, spec.model, spec.effort) : {};
+	const env = {
+		...spec.env,
+		...configEnv
+	};
+	const launch = spec.exec === void 0 ? {
+		argv,
+		env
+	} : containerExecSpawn(spec.exec, {
+		argv,
+		env
+	}, "subagent-kimi");
+	const child = spec.spawn({
+		argv: launch.argv,
+		cwd: spec.cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe"
+		},
+		graceMs: spec.disposeGraceMs,
+		env: launch.env
+	});
+	let output = "";
+	child.stdout?.on("data", (chunk) => {
+		output += chunk.toString();
+	});
+	let stderr = "";
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+	let roundUsage;
+	const addRoundUsage = (usage) => {
+		roundUsage = addTokenUsage(roundUsage, usage);
+	};
+	let mirrorQueue = Promise.resolve();
+	const enqueueMirror = (task) => {
+		mirrorQueue = mirrorQueue.then(task);
+	};
+	if (spec.childSession !== void 0 && spec.homeDir !== void 0 && spec.ctx !== void 0) {
+		const childSession = spec.childSession;
+		const homeDir = spec.homeDir;
+		const mirrorCtx = spec.ctx;
+		const poll = async () => {
+			const kimiSessionId = spec.resume?.cliSessionId ?? kimiSessionIdFromOutput(stderr);
+			if (kimiSessionId === void 0) return;
+			const delta = await mirrorKimiDelta(mirrorCtx, childSession, homeDir, kimiSessionId);
+			addRoundUsage(delta.usage);
+			if (delta.texts.length > 0) mirrorCtx.get("localAgent")?.reportRunProgress(childSession.id, {
+				kind: "mirror",
+				mirroredLines: delta.total
+			});
+		};
+		const liveMirror = setInterval(() => {
+			enqueueMirror(async () => {
+				try {
+					await poll();
+				} catch (error) {
+					mirrorCtx.logger.warn(`subagent-kimi: live mirror poll failed: ${thrown(error).message}`);
+				}
+			});
+		}, spec.liveMirrorIntervalMs ?? 2e3);
+		liveMirror.unref();
+		child.done.then(() => {
+			clearInterval(liveMirror);
+		}, () => {
+			clearInterval(liveMirror);
+		});
+	}
+	const disposeProcess = async () => {
+		child.terminate();
+		await child.waitForExit().catch(() => false);
+		await child.done.catch(() => {});
+	};
+	const runAbort = new AbortController();
+	const requestCancel = () => {
+		if (runAbort.signal.aborted) return;
+		runAbort.abort(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally"));
+	};
+	const onAbort = () => {
+		requestCancel();
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	const abortBranch = new Promise((_, reject) => {
+		runAbort.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("subagent-kimi: run cancelled locally")), { once: true });
+	});
+	const processFailure = child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-kimi: CLI exited before the run settled (code ${String(outcome.exitCode)}, signal ${String(outcome.signal)})`)), (error) => Promise.reject(thrown(error)));
+	processFailure.catch(() => {});
+	const collectOutput = () => {
+		const drained = child.collected.stdout?.readFrom(0).text;
+		const text = (drained !== void 0 && drained !== "" ? drained : output).trim();
+		return text === "" ? [] : [{
+			type: "text",
+			text
+		}];
+	};
+	const result = settleRunResult({
+		attempt: () => Promise.race([
+			child.done.then((outcome) => {
+				if (outcome.exitCode !== 0) {
+					const via = spec.endpointLabel ?? "kimi default endpoint";
+					throw new Error(`subagent-kimi: kimi -p exited with code ${String(outcome.exitCode)} via ${via}`);
+				}
+				const output = collectOutput();
+				if (output.length === 0) throw new Error("subagent-kimi: kimi -p exited 0 but produced no answer");
+				return {
+					output,
+					stopReason: "completed"
+				};
+			}),
+			processFailure,
+			abortBranch
+		]),
+		collectOutput,
+		cancelled: () => runAbort.signal.aborted,
+		onError: spec.onError,
+		signal: request.signal,
+		onAbort
+	}).then((settled) => {
+		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
+		if (spec.childSession !== void 0) {
+			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
+				turn,
+				reason: { kind: "completed" }
+			});
+			else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "aborted",
+					reason: { kind: "parent" }
+				}
+			});
+			else spec.childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "error",
+					error: {
+						message: "kimi -p exited before the run completed",
+						code: "UNKNOWN"
+					}
+				}
+			});
+		}
+		return settled;
+	});
+	result.then(() => child.done).then(() => {
+		if (spec.onAuthFailure !== void 0) {
+			const authDetail = `${child.collected.stderr?.readFrom(0).text || stderr}\n${child.collected.stdout?.readFrom(0).text || output}`;
+			if (KIMI_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
+		}
+		enqueueMirror(async () => {
+			const settled = await mirrorKimiAfterExit(spec, stderr);
+			addRoundUsage(settled?.usage);
+			const cliVersion = await spec.cliVersion?.();
+			spec.onRoundSettled?.({
+				...settled?.model === void 0 ? {} : { observedModel: settled.model },
+				...cliVersion === void 0 ? {} : { cliVersion },
+				...roundUsage === void 0 ? {} : { usage: roundUsage },
+				...settled?.toolCalls === void 0 ? {} : { toolCalls: settled.toolCalls }
+			});
+		});
+	}, () => {});
+	return Promise.resolve(subprocessRunHandle({
+		id: spec.childSession?.id ?? SessionId(randomUUID()),
+		result,
+		signal: request.signal,
+		onAbort,
+		requestCancel,
+		teardown: disposeProcess
+	}));
+}
+//#endregion
+//#region lib/types/live-switch.js
+/**
+* The settings-driven live-driver switch: owns the active driver generation
+* and retires old ones on a settings change, without a plugin reload.
+*
+* Toggle OFF (or unload): the retiring generation is DRAINED, not killed —
+* new rounds are refused (the provider's catch falls back to exec), in-flight
+* rounds finish on their runtime, idle runtimes are reclaimed at once.
+* Toggling ON builds the next generation lazily (no process until the first
+* round). Legacy granularity settings are ignored.
+*
+* @module @khorsheed/dsh-local-agent-kimi — internal, unit-tested directly.
+*/
+var LiveDriverSwitch = class {
+	ctx;
+	liveIdleMs;
+	model;
+	liveOn = false;
+	active;
+	/** Retiring generations still draining their in-flight rounds. */
+	draining = /* @__PURE__ */ new Set();
+	unwatch;
+	constructor(ctx, face, liveIdleMs, model) {
+		this.ctx = ctx;
+		this.liveIdleMs = liveIdleMs;
+		this.model = model;
+		this.apply(face.get());
+		this.unwatch = face.watch((next) => {
+			this.apply(next);
+		});
+	}
+	/**
+	* Resolve the live driver for one round's member (the provider's call
+	* site). A retiring generation still hosting the member gates the new one —
+	* the round falls back to exec rather than double-loading the same kimi
+	* session into two processes.
+	*/
+	resolve = (childSessionId) => {
+		if (this.active === void 0) return void 0;
+		for (const retiring of this.draining) if (retiring.hasRuntime(childSessionId)) return void 0;
+		return this.active;
+	};
+	/** Mirror the resolved settings into the driver generation. */
+	apply(next) {
+		if (next.live === this.liveOn) return;
+		this.liveOn = next.live;
+		const retiring = this.active;
+		this.active = next.live ? new KimiAcpLiveDriver(this.ctx, {
+			...this.liveIdleMs === void 0 ? {} : { liveIdleMs: this.liveIdleMs },
+			...this.model === void 0 ? {} : { model: this.model }
+		}) : void 0;
+		if (retiring !== void 0) {
+			this.draining.add(retiring);
+			retiring.drain().then(() => {
+				this.draining.delete(retiring);
+			}, (error) => {
+				this.draining.delete(retiring);
+				this.ctx.logger.warn(`local-agent-kimi: live driver drain failed: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		}
+	}
+	/**
+	* Retire one member's runtime on the ACTIVE generation (a composer-driven
+	* model switch): the next round respawns onto the new model. A member still
+	* hosted by a draining generation is left alone — its rounds already gate
+	* to exec, and the drain reclaims the process.
+	*/
+	async retireMemberRuntime(childSessionId) {
+		await this.active?.retireRuntime(childSessionId);
+	}
+	/**
+	* The model the member's active-generation runtime is bound to, or
+	* undefined when no live runtime serves the member (the broker's
+	* same-model no-op check).
+	*/
+	memberRuntimeModel(childSessionId) {
+		return this.active?.runtimeModel(childSessionId);
+	}
+	/**
+	* Whether the active generation hosts (or is spawning) the member's
+	* runtime — the broker's retire decision needs this apart from the bound
+	* model, since a runtime that bound NO model reports undefined either way.
+	*/
+	memberHasRuntime(childSessionId) {
+		return this.active?.hasRuntime(childSessionId) ?? false;
+	}
+	memberRuntimeConfiguration(childSessionId) {
+		for (const driver of [this.active, ...this.draining]) {
+			const configuration = driver?.runtimeConfiguration(childSessionId);
+			if (configuration !== void 0) return configuration;
+		}
+	}
+	/** Plugin unload: interrupt whatever survives (disposeAll, not drain). */
+	dispose() {
+		this.unwatch();
+		this.active?.disposeAll();
+		for (const retiring of this.draining) retiring.disposeAll();
+		this.draining.clear();
+	}
+};
+//#endregion
+//#region lib/types/model-broker.js
+/**
+* The kimi harness's model broker: the member/harness model surface the
+* family gateway routes to (`harnessModel` for the settings card,
+* `memberModel`/`setMemberModel` for the composer picker). Resolution follows
+* the family's fixed order — the session-level override (the composer's
+* picker write) first, then the delegation's recorded model, then the
+* plugin-config `model` key, then the scoped config's own `default_model`,
+* and last the CLI's built-in default, which names nothing.
+*
+* Per-member state is IN MEMORY by design: the session-level override is a
+* composer gesture that deliberately does not survive a host restart, and the
+* start-model ledger only mirrors what the delegation records already persist
+* (the core hands the recorded value back as `delegationModel` on reads).
+* The spawn side of a switch is lazy: `setMemberModel` retires the member's
+* resident runtime when its bound model no longer matches, and the member's
+* next round respawns onto the new model, `session/load`-ing the same CLI
+* session — the conversation carries over, the process fact changes.
+* @module @khorsheed/dsh-local-agent-kimi/model-broker
+*/
+/** The refusal a mid-round switch gets (in flight = the runtime must not die). */
+const SWITCH_IN_FLIGHT_REASON = "该成员有进行中的委派轮次，等其完成后再切换模型";
+/** Dedupe a candidate list, dropping blanks and keeping first-seen order. */
+function dedupe(candidates) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const candidate of candidates) {
+		const value = candidate?.trim();
+		if (value === void 0 || value === "" || seen.has(value)) continue;
+		seen.add(value);
+		out.push(value);
+	}
+	return out;
+}
+/**
+* The kimi harness's {@link LocalAgentModelBroker}. Also the provider-facing
+* member-model ledger: the provider records each delegation's start model
+* here and reads the session-level override for its exec-path resolution, so
+* the picker write reaches the very next round on either driver.
+*/
+var KimiModelBroker = class {
+	ctx;
+	deps;
+	/** Session-level overrides per member (the composer picker's writes). */
+	overrides = /* @__PURE__ */ new Map();
+	/** Each member's START model — the model its delegation's first round named. */
+	startModels = /* @__PURE__ */ new Map();
+	/**
+	* @param ctx - plugin context carrying the family registry (the in-flight
+	*   read behind `switchable`).
+	* @param deps - the harness's live readers: the scoped home, the settings
+	*   layer, the card's recent-model memory, the live toggle, and the driver
+	*   switch a switch retires runtimes through.
+	*/
+	constructor(ctx, deps) {
+		this.ctx = ctx;
+		this.deps = deps;
+	}
+	configurationAdapter(binding) {
+		const home = this.ctx.localAgent.homeDir("kimi", binding.scope);
+		const resolve = async (selection) => {
+			const model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel() ?? await readKimiDefaultModel(home);
+			const configured = await readKimiModelConfiguration(home, model);
+			const entry = this.deps.liveSwitch.memberRuntimeConfiguration(binding.childSessionId)?.directory.entries.find((entry) => entry.value === model) ?? configured.entries.find((entry) => entry.value === model);
+			const effort = (selection.effort.mode === "value" ? selection.effort.value : selection.effort.mode === "inherit" ? binding.effort : void 0) ?? configured.effort;
+			if (effort !== void 0 && entry?.reasoning !== void 0 && !entry.reasoning.options.some((option) => option.value === effort)) throw new Error("Kimi has not advertised this reasoning effort for the selected model");
+			if (!this.deps.isLive() && effort !== void 0 && configured.protocol !== "kimi") throw new Error("This model protocol has no Kimi exec effort override; use ACP live mode");
+			return {
+				...model === void 0 ? {} : { model },
+				...effort === void 0 ? {} : { effort }
+			};
+		};
+		return {
+			validate: async (selection) => {
+				await resolve(selection);
+			},
+			prepare: resolve,
+			apply: async (selection) => {
+				const resolved = await resolve(selection);
+				await this.deps.liveSwitch.retireMemberRuntime(binding.childSessionId);
+				return resolved;
+			},
+			reconcile: async (state) => {
+				if (this.ctx.localAgent.isDelegationActive(binding.childSessionId)) return {
+					active: true,
+					matches: "unknown",
+					resolved: {}
+				};
+				await this.deps.liveSwitch.retireMemberRuntime(binding.childSessionId);
+				return {
+					active: false,
+					matches: "current",
+					resolved: await resolve(state.current.selection)
+				};
+			}
+		};
+	}
+	async modelDirectory(childSessionId, refresh = false) {
+		if (refresh) await this.deps.catalog?.refresh(childSessionId);
+		return (await this.modelInfo(childSessionId)).directory ?? {
+			entries: [],
+			complete: false,
+			customInput: true,
+			status: "unsupported",
+			refreshing: false,
+			revision: 0
+		};
+	}
+	async *followModelDirectory(childSessionId, signal) {
+		if (this.deps.catalog === void 0) {
+			yield await this.modelDirectory(childSessionId);
+			return;
+		}
+		for await (const _snapshot of this.deps.catalog.follow(childSessionId, signal)) yield await this.modelDirectory(childSessionId);
+	}
+	/**
+	* Record the model a member's delegation STARTED with (the provider's call
+	* site, fresh and resume rounds alike). The live driver's spawn resolver
+	* ranks it between the override and the settings layer.
+	*/
+	noteStartModel(childSessionId, model) {
+		const value = model.trim();
+		if (value !== "") this.startModels.set(childSessionId, value);
+	}
+	/**
+	* The member's session-level override, when the composer picker set one —
+	* the exec path's top layer (it outranks even the delegation's recorded
+	* model, so the provider folds it into the requested slot).
+	*/
+	overrideFor(childSessionId) {
+		return this.overrides.get(childSessionId);
+	}
+	/**
+	* The member's spawn-binding resolver (the live driver config): override,
+	* then the member's start model, then the settings layer. Undefined writes
+	* nothing — the scoped config's own `default_model` decides, as it always
+	* did.
+	*/
+	spawnModel = (childSessionId) => this.overrideFor(childSessionId) ?? this.startModels.get(childSessionId) ?? this.deps.settingsModel();
+	/**
+	* Read the model surface. With no member this is the harness default (the
+	* settings card's "what would a round run with"): override and delegation
+	* stay absent by construction.
+	*/
+	async modelInfo(childSessionId, delegationModel) {
+		const override = childSessionId === void 0 ? void 0 : this.overrideFor(childSessionId);
+		const delegation = childSessionId === void 0 ? void 0 : delegationModel ?? this.startModels.get(childSessionId);
+		const settings = this.deps.settingsModel();
+		const homeDir = this.deps.homeDir(childSessionId);
+		const native = this.deps.catalog?.read(childSessionId);
+		const [cliDefault, discovered] = await Promise.all([readKimiDefaultModel(homeDir).catch(() => void 0), listKimiConfigModels(homeDir).catch(() => [])]);
+		const choices = dedupe([
+			settings,
+			cliDefault,
+			...discovered,
+			...native?.entries.filter((entry) => !entry.hidden).map((entry) => entry.value) ?? [],
+			...this.deps.recentModels()
+		]);
+		const [effective, source] = override !== void 0 ? [override, "override"] : delegation !== void 0 ? [delegation, "delegation"] : settings !== void 0 ? [settings, "settings"] : cliDefault !== void 0 ? [cliDefault, "cli-config"] : [void 0, "cli-builtin"];
+		const inFlight = childSessionId !== void 0 && this.ctx.localAgent.activeDelegations().includes(childSessionId);
+		return {
+			...effective === void 0 ? {} : { effective },
+			source,
+			...override === void 0 ? {} : { override },
+			...delegation === void 0 ? {} : { delegation },
+			...settings === void 0 ? {} : { settings },
+			...cliDefault === void 0 ? {} : { cliDefault },
+			choices,
+			...native === void 0 ? {} : { directory: extendModelDirectory(native, [
+				settings,
+				cliDefault,
+				...discovered
+			], this.deps.recentModels()) },
+			live: this.deps.isLive(),
+			switchable: !inFlight,
+			...inFlight ? { reason: SWITCH_IN_FLIGHT_REASON } : {}
+		};
+	}
+	/**
+	* Set (or clear) the member's session-level override. Throws while a round
+	* is in flight for the member — the switch retires the resident runtime,
+	* and retiring mid-round would kill the run. A same-value set (or clearing
+	* an unset override) is a no-op; otherwise a live runtime whose bound model
+	* differs from the new effective model is retired so the next round
+	* respawns onto it, resuming the same CLI session.
+	*/
+	async setMemberModel(childSessionId, model) {
+		if (typeof this.ctx.localAgent.setMemberModel === "function") return this.ctx.localAgent.setMemberModel(childSessionId, model);
+		if (this.ctx.localAgent.activeDelegations().includes(childSessionId)) throw new Error(SWITCH_IN_FLIGHT_REASON);
+		const value = model?.trim();
+		const previous = this.overrides.get(childSessionId);
+		if (value === void 0 || value === "") {
+			if (previous === void 0) return;
+			this.overrides.delete(childSessionId);
+		} else {
+			if (previous === value) return;
+			this.overrides.set(childSessionId, value);
+		}
+		const effective = (await this.modelInfo(childSessionId)).effective;
+		if (this.deps.liveSwitch.memberHasRuntime(childSessionId) && this.deps.liveSwitch.memberRuntimeModel(childSessionId) !== effective) await this.deps.liveSwitch.retireMemberRuntime(childSessionId);
+	}
+};
+//#endregion
+//#region lib/types/records.js
+/**
+* Kimi Code session records adapter: reads the scoped home's
+* `session_index.jsonl`, kimi's own append-only index.
+* @module @khorsheed/dsh-local-agent-kimi/records
+*/
+/** Credentials live under this directory inside the scoped home. */
+const CREDENTIALS_DIR = "credentials";
+/**
+* Whether the scoped home holds usable login credentials, guarded by the
+* credential sentinel: a VALID credential file (both tokens non-empty) reads
+* true and refreshes the backup; an empty shell (the kimi CLI's failure-path
+* wipe) restores the backup when one exists and reads false otherwise. The
+* pre-sentinel "directory non-empty" check could not tell the empty shell
+* from a real credential at all.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns true when usable credentials are present (after any restore).
+*/
+async function kimiAuthenticated(homeDir) {
+	return guardKimiCredential(homeDir);
+}
+/**
+* The newest credential file's modification stamp (epoch ms), undefined when
+* no credential exists. A completed device-code login rewrites the
+* credentials directory, so the stamp distinguishes a fresh login from a
+* leftover (possibly expired) credential.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the newest credential mtime, or undefined when none exists.
+*/
+async function kimiCredentialStamp(homeDir) {
+	try {
+		const entries = await readdir(join(homeDir, CREDENTIALS_DIR));
+		let newest;
+		for (const entry of entries) {
+			const { mtimeMs } = await stat(join(homeDir, CREDENTIALS_DIR, entry));
+			if (newest === void 0 || mtimeMs > newest) newest = mtimeMs;
+		}
+		return newest;
+	} catch {
+		return;
+	}
+}
+/**
+* Read the scoped home's session index. The index is kimi's own
+* newline-delimited JSONL; a torn tail line (the file is append-only) is
+* skipped rather than failing the whole list.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the parsed records in file order, empty when no index exists yet.
+*/
+async function listKimiSessions(homeDir) {
+	const indexPath = join(homeDir, "session_index.jsonl");
+	let text;
+	try {
+		text = await readFile(indexPath, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	const records = [];
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed === "") continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			records.push({
+				id: parsed.sessionId,
+				workDir: parsed.workDir,
+				...parsed.title !== void 0 && typeof parsed.title === "string" && { title: parsed.title },
+				...parsed.createdAt !== void 0 && typeof parsed.createdAt === "string" && { startedAt: Date.parse(parsed.createdAt) }
+			});
+		} catch {}
+	}
+	return records;
+}
+//#endregion
+//#region lib/types/preset-tools.js
+/**
+* Legacy kimi preset-variant cleanup. Earlier versions of this bundle
+* bootstrapped `standard-kimi`, `code-kimi`, `minimal-kimi`, and `kimi`
+* preset variants into the user preset root so an official-style preset could
+* carry the `subagent_kimi` tool row. The tool row now mounts at the profile
+* root (see the bundle patch), so every preset delegates without variants;
+* this module removes the leftovers once on startup. The repo is pre-release,
+* so no compatibility path is kept — variants that still exist are deleted.
+* @module @khorsheed/dsh-local-agent-kimi/preset-tools
+*/
+/** The variant preset ids earlier bundle versions bootstrapped. */
+const LEGACY_VARIANTS = [
+	"standard-kimi",
+	"code-kimi",
+	"minimal-kimi",
+	"kimi"
+];
+/**
+* Remove the legacy kimi preset variants from the user preset root. Uses the
+* agent-presets service's remove (which also clears a default that named one
+* of them), so a session later created under a different default no longer
+* points at a deleted composition.
+* @param ctx - host context carrying the agent-presets service.
+*/
+async function removeLegacyVariants(ctx) {
+	const presets = ctx.get("agentPresets");
+	if (presets === void 0) return;
+	for (const id of LEGACY_VARIANTS) try {
+		await presets.remove(id);
+	} catch (error) {
+		if (error.code === "ENOENT") continue;
+		throw error;
+	}
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Kimi Code harness instantiation of the local-agent family. Registers the
+* `kimi` harness into the core registry: scoped home under the shared homes
+* root (`KIMI_CODE_HOME`), device-code login through `kimi login`, and the
+* `session_index.jsonl` records adapter. Delegation mounts through the
+* `kimi-cli` provider (one-shot `kimi -p` under the scoped home); the
+* bundle patch's `tool-subagent-kimi` row puts the `subagent_kimi` tool on
+* the profile root, so every agent preset can delegate without variants.
+*
+* @module @khorsheed/dsh-local-agent-kimi
+*/
+/** Stable Cordis plugin name; the bundle patch row id. */
+const name = "local-agent-kimi";
+/** Services required before the harness can register. */
+const inject = [
+	"localAgent",
+	"subagents",
+	"subprocess",
+	"settings"
+];
+/**
+* The settings fields (`live`, `liveMirrorGranularity`, `model`,
+* `recentModels`) ride the plugin Config, marked `.volatile()` where the
+* host's schemastery has it (3.18.4+, the rc.1 line — probed, never sniffed):
+* there the SettingsForms writes hot-track the running fiber's Volatile
+* references without a remount, and the official one-shot import moves an old
+* settings.yaml section into this row's config. On 0.1.5 the call is absent,
+* the fields stay plain config keys (a semantic superset — the profile row
+* can now preset them too), and the legacy settings namespace below carries
+* the user layer exactly as before.
+*/
+const SETTINGS_FIELDS = {
+	live: z.boolean().default(false),
+	liveMirrorGranularity: z.union([z.const("event"), z.const("token")]).default("token"),
+	model: z.string(),
+	recentModels: z.array(z.string()).default([])
+};
+/** Mark one schema field volatile when the host's schemastery has the method (rc.1), pass it through plain when not (0.1.5). */
+function volatilize(field) {
+	return typeof field.volatile === "function" ? field.volatile() : field;
+}
+const Config = z.object({
+	model: volatilize(SETTINGS_FIELDS.model),
+	thinkingEffort: z.union([
+		z.const("low"),
+		z.const("high"),
+		z.const("max")
+	]),
+	live: volatilize(SETTINGS_FIELDS.live),
+	liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
+	liveMirrorGranularity: volatilize(SETTINGS_FIELDS.liveMirrorGranularity),
+	recentModels: volatilize(SETTINGS_FIELDS.recentModels)
+});
+/**
+* Settings namespace for the settings-page card. The Cordis config feeds the
+* composition `base` layer, so a field absent from the user layer inherits the
+* YAML value — the card only ever stores deliberate overrides.
+*/
+const KIMI_SETTINGS_NAMESPACE = "local-agent-kimi";
+/**
+* The card's schema; field defaults are the innermost layer below `base`.
+* `model` deliberately carries NO default: an unset key must resolve to
+* undefined, which is what keeps the pre-key behavior byte-identical.
+*/
+const KIMI_SETTINGS_SCHEMA = z.object(SETTINGS_FIELDS);
+/**
+* Handle the harness's extra subcommands: `session <id>` renders a kimi
+* session transcript. Returns synchronously with undefined for any input
+* that is not this harness's own.
+* @param input - the trimmed subcommand input.
+* @param invocation - the full command invocation.
+* @returns the command result promise, or undefined when not this harness's.
+*/
+function handleSubcommand(input, invocation) {
+	const [verb] = input.split(/\s+/);
+	if (verb === "session") return handleSessionSubcommand(input, invocation);
+}
+/** Run one `session` subcommand: render the transcript of a kimi session. */
+async function handleSessionSubcommand(input, invocation) {
+	const id = input.split(/\s+/)[1];
+	if (id === void 0) return {
+		kind: "error",
+		text: "Usage: /kimi session <session-id> (see /kimi sessions for ids)"
+	};
+	const sessionDir = await findKimiSessionDir(invocation.agent.ctx.localAgent.homeDir("kimi"), id);
+	if (sessionDir === void 0) return {
+		kind: "error",
+		text: `no kimi session "${id}" in the scoped home`
+	};
+	try {
+		return {
+			kind: "success",
+			text: renderTranscript(await readKimiTranscript(sessionDir))
+		};
+	} catch (error) {
+		return {
+			kind: "error",
+			text: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Register the Kimi harness into the local-agent registry.
+* @param ctx - plugin context carrying the registry.
+*/
+function apply(ctx, config) {
+	ctx.effect(() => {
+		const homeDir = ctx.localAgent.homeDir("kimi");
+		const thinkingEffort = config.thinkingEffort ?? "high";
+		removeLegacyVariants(ctx).catch((error) => {
+			ctx.logger.warn(`local-agent-kimi: legacy preset cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+		provisionKimiConfig(homeDir, vol(config.model) ?? "kimi-code/k3", thinkingEffort).then(() => ensureKimiPermissions(homeDir)).catch((error) => {
+			ctx.logger.warn(`local-agent-kimi: config provisioning failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+		const readSettings = () => {
+			const model = vol(config.model);
+			const recentModels = vol(config.recentModels);
+			return {
+				live: vol(config.live) ?? false,
+				liveMirrorGranularity: vol(config.liveMirrorGranularity) ?? "token",
+				...model === void 0 ? {} : { model },
+				...recentModels === void 0 ? {} : { recentModels }
+			};
+		};
+		const legacyBase = {};
+		for (const field of [
+			"live",
+			"liveMirrorGranularity",
+			"model"
+		]) {
+			const value = vol(config[field]);
+			if (value !== void 0) legacyBase[field] = value;
+		}
+		const face = settingsFace(ctx, {
+			namespace: KIMI_SETTINGS_NAMESPACE,
+			legacySchema: KIMI_SETTINGS_SCHEMA,
+			legacyBase,
+			read: readSettings
+		});
+		const resolveModel = () => {
+			const model = face.get().model?.trim();
+			return model === void 0 || model === "" ? void 0 : model;
+		};
+		let broker;
+		const liveSwitch = new LiveDriverSwitch(ctx, face, config.liveIdleMs, (child) => broker.spawnModel(child));
+		const modelCatalog = new KimiModelCatalog((childSessionId) => {
+			const record = childSessionId === void 0 ? void 0 : ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId);
+			const native = childSessionId === void 0 ? void 0 : liveSwitch.memberRuntimeConfiguration(childSessionId);
+			return {
+				homeDir: ctx.localAgent.homeDir("kimi", record?.scope),
+				...record?.cwd === void 0 ? {} : { cwd: record.cwd },
+				...native === void 0 ? {} : { native }
+			};
+		});
+		broker = new KimiModelBroker(ctx, {
+			homeDir: (childSessionId) => ctx.localAgent.homeDir("kimi", childSessionId === void 0 ? void 0 : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.scope),
+			catalog: modelCatalog,
+			settingsModel: resolveModel,
+			recentModels: () => face.get().recentModels ?? [],
+			isLive: () => face.get().live,
+			liveSwitch
+		});
+		const disposeProvider = ctx.subagents.registerProvider(new KimiCliProvider(ctx, liveSwitch.resolve, resolveModel, broker));
+		const disposeHarness = ctx.localAgent.register({
+			prepareMember: async ({ binding, childSession, configuration, signal }) => {
+				const driver = liveSwitch.resolve(binding.childSessionId);
+				if (driver === void 0 || driver.disabled) throw new Error("Enable the native live harness before preparing a coordinator");
+				await driver.prepare({
+					cwd: binding.cwd,
+					homeDir: ctx.localAgent.homeDir("kimi", binding.scope),
+					childSession,
+					parentSessionId: binding.parentSessionId,
+					configuration: configuration.resolved
+				}, signal);
+			},
+			name: "kimi",
+			displayName: "Kimi Code",
+			homeEnvVar: "KIMI_CODE_HOME",
+			delegationProvider: "kimi-cli",
+			login: {
+				command: "kimi",
+				args: ["login"]
+			},
+			records: { listSessions: (homeDir) => listKimiSessions(homeDir) },
+			provision: async (scopedHome) => {
+				await provisionKimiConfig(scopedHome, vol(config.model) ?? "kimi-code/k3", thinkingEffort);
+				await ensureKimiPermissions(scopedHome);
+			},
+			isAuthenticated: kimiAuthenticated,
+			credentialStamp: kimiCredentialStamp,
+			logout: kimiLogout,
+			subcommand: handleSubcommand,
+			modelBroker: broker,
+			effectiveSettings: async (scopedHome) => {
+				const [reasoningEffort, baseUrl, autoApprove, defaultModel, cliVersion] = await Promise.all([
+					readKimiReasoningEffort(scopedHome).catch(() => void 0),
+					readKimiBaseUrl(scopedHome).catch(() => void 0),
+					readKimiAutoApprove(scopedHome).catch(() => false),
+					readKimiDefaultModel(scopedHome).catch(() => void 0),
+					kimiCliVersion(ctx, scopedHome).catch(() => void 0)
+				]);
+				const custom = baseUrl !== void 0 && baseUrl !== "https://api.kimi.com/coding/v1";
+				const baseUrlHost = custom ? endpointHost(baseUrl) : void 0;
+				const model = resolveModel() ?? defaultModel;
+				return {
+					drive: face.get().live ? "live" : "exec",
+					autoApprove,
+					...reasoningEffort !== void 0 ? { reasoningEffort } : {},
+					baseUrlSet: custom,
+					...baseUrlHost !== void 0 ? { baseUrlHost } : {},
+					...model !== void 0 ? { model } : {},
+					...cliVersion !== void 0 ? { cliVersion } : {}
+				};
+			}
+		});
+		return () => {
+			modelCatalog.dispose();
+			disposeProvider();
+			disposeHarness();
+			liveSwitch.dispose();
+		};
+	}, "local-agent-kimi: harness");
+}
+//#endregion
+export { Config, KIMI_SETTINGS_NAMESPACE, apply, inject, name };