@khorsheed/dsh-local-agent-kimi 0.2.0-rc.1 → 0.2.0

package/lib/index.js

@@ -1,16 +1,295 @@
 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 { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, firstModelOf, modelDirectoryContextKey, persistChildSession, probeCliVersion, readModelList, readModelListSync, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol, writeModelList } 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 { NO_START_CAPABILITIES, SUBAGENT_DESCRIPTOR_VERSION, settleRunResult, subprocessRunHandle } from "@deepseek-ai/dsh-subagent";
 import { join } from "node:path";
-import { copyFile, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, 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 lib/types/endpoint-auth.js
+/**
+* Endpoint-key authentication — the kimi harness's ONLY auth mode. There is
+* no OAuth anywhere in this package: the scoped config's managed provider
+* (`managed:kimi-code`) declares `api_key_env = "DSH_KIMI_ENDPOINT_KEY"`
+* (kimi-cli ≥2.1 reads the key from that environment variable — verified by
+* the CLI's own "declares api_key_env but the environment variable is not
+* set" diagnostic), the key itself lives only here and in the child process's
+* environment, and `config.toml` carries no secret, so it stays a legitimate
+* evaluation-condition input.
+*
+* Two layers, merged per field, file over config:
+*
+* - `<scopedHome>/endpoint-auth.json` (mode 0600) — the per-scope credential.
+*   Its name deliberately matches the eval contract hash's credential denylist
+*   (`auth`), so the key material never enters an evaluation's condition
+*   fingerprint; the file's mtime serves as the credential stamp, which makes
+*   "edit the file" the recovery gesture for a `rejected` grade.
+* - The plugin config's `baseUrl` / `apiKey` — the deployment default every
+*   scope without a file shares. Read PER ROUND from the apply-time snapshot,
+*   so a profile edit applies to the next round (and a host restart clears
+*   the in-memory `rejected` mark).
+*
+* `baseUrl` is optional: absent means kimi's own coding service
+* ({@link KIMI_MANAGED_BASE_URL} — an official platform key needs no relay).
+* A present baseUrl is written into the managed provider's `base_url` by the
+* config surgery (provision.ts), which is also what keeps the two layers'
+* merge honest: the file the CLI reads always shows the effective endpoint.
+*
+* The env layer rides the family's existing plumbing: `delegationEnv` on the
+* host, `containerExecSpawn`'s name-only `-e` forwarding into a container —
+* a containerized round authenticates with the same credential as the host,
+* nothing is authorized inside the unit.
+* @module @khorsheed/dsh-local-agent-kimi/endpoint-auth
+*/
+/**
+* The scoped-home credential file's name. Chosen to match the eval contract
+* hash's credential-shaped denylist (`/token|key|credential|secret|password|auth|\.env/i`),
+* so the file is excluded from condition fingerprints by name.
+*/
+const ENDPOINT_AUTH_FILE = "endpoint-auth.json";
+/**
+* The environment variable the managed provider's `api_key_env` names. The
+* key material only ever lives in endpoint-auth.json and in the child
+* process's environment under this name.
+*/
+const ENDPOINT_ENV_KEY = "DSH_KIMI_ENDPOINT_KEY";
+/** Trim and normalize one credential field; blank reads as absent. */
+function field(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+/** Whether a resolved endpoint carries a usable credential. */
+function hasEndpointCredential(auth) {
+	return auth !== void 0 && field(auth.apiKey) !== void 0;
+}
+/**
+* Read the scope's endpoint-auth.json. Absent or unreadable yields undefined
+* (the caller falls back to the plugin config); malformed JSON or a non-object
+* payload also yields undefined — a torn file must not fail a status read.
+* Non-string fields are dropped, never carried through.
+* @param homeDir - the `kimi` harness's scoped home.
+* @returns the file's endpoint credential, or undefined.
+*/
+async function readEndpointAuthFile(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, ENDPOINT_AUTH_FILE), "utf8");
+	} catch {
+		return;
+	}
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const baseUrl = field(parsed["baseUrl"]);
+		const apiKey = field(parsed["apiKey"]);
+		return {
+			...baseUrl === void 0 ? {} : { baseUrl },
+			...apiKey === void 0 ? {} : { apiKey }
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Resolve one scope's effective endpoint credential: the scope's
+* endpoint-auth.json merged FIELD BY FIELD over the plugin config's
+* `baseUrl` / `apiKey` (a file that names only a key rotates the key while
+* keeping the deployment's endpoint). The result may carry no credential at
+* all — {@link hasEndpointCredential} is the judgment, kept separate so the
+* caller can still route/log the resolved baseUrl.
+* @param homeDir - the scope's scoped home.
+* @param config - the plugin config's deployment-level endpoint pair.
+* @returns the merged endpoint auth.
+*/
+async function resolveEndpointAuth(homeDir, config) {
+	const file = await readEndpointAuthFile(homeDir);
+	const configBaseUrl = field(config.baseUrl);
+	const configApiKey = field(config.apiKey);
+	return {
+		...configBaseUrl === void 0 ? {} : { baseUrl: configBaseUrl },
+		...configApiKey === void 0 ? {} : { apiKey: configApiKey },
+		...file
+	};
+}
+/**
+* The spawn-env layer for a resolved endpoint: the key under the managed
+* provider's `api_key_env` name, nothing else. A credential-less resolution
+* yields an empty layer — the spread then adds no keys at all, byte-identical
+* to the pre-endpoint env.
+* @param auth - the resolved endpoint auth, or undefined.
+* @returns the explicit env entries for the delegation spawn.
+*/
+function endpointAuthEnv(auth) {
+	const apiKey = field(auth?.apiKey);
+	return apiKey === void 0 ? {} : { [ENDPOINT_ENV_KEY]: apiKey };
+}
+/**
+* The credential marker's modification stamp (epoch ms): the endpoint file's
+* mtime, or undefined when the scope has no file (a config-sourced credential
+* has no marker — rotating it pairs with the profile edit and instance
+* restart that clear the in-memory grade marks). A fresh file write is a
+* fresh stamp, which is how an edited-in key recovers a `rejected` grade.
+* @param homeDir - the scope's scoped home.
+* @returns the stamp, or undefined.
+*/
+async function endpointAuthStamp(homeDir) {
+	try {
+		return (await stat(join(homeDir, ENDPOINT_AUTH_FILE))).mtimeMs;
+	} catch {
+		return;
+	}
+}
+/** Whether the scope carries its own endpoint file at all. */
+async function endpointAuthFileExists(homeDir) {
+	return await endpointAuthStamp(homeDir) !== void 0;
+}
+/**
+* Write the scope's endpoint-auth.json (mode 0600, mkdir -p first).
+* Whole-file write: the payload is exactly what {@link readEndpointAuthFile}
+* parses back.
+* @param homeDir - the scope's scoped home.
+* @param auth - the endpoint credential to persist.
+*/
+async function writeEndpointAuth(homeDir, auth) {
+	await mkdir(homeDir, { recursive: true });
+	const baseUrl = field(auth.baseUrl);
+	const apiKey = field(auth.apiKey);
+	const payload = {
+		...baseUrl === void 0 ? {} : { baseUrl },
+		...apiKey === void 0 ? {} : { apiKey }
+	};
+	await writeFile(join(homeDir, ENDPOINT_AUTH_FILE), JSON.stringify(payload, void 0, 2) + "\n", { mode: 384 });
+}
+/**
+* Clear the scope's OWN endpoint credential (the endpoint-auth.json file).
+* A deployment-level credential from the plugin config is untouched — the
+* core's logout reply then names the profile row as the place to edit.
+* @param homeDir - the scope's scoped home.
+*/
+async function clearEndpointAuth(homeDir) {
+	await rm(join(homeDir, ENDPOINT_AUTH_FILE), { force: true });
+}
+/**
+* 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.
+* It lives in THIS module (not provision.ts) because the endpoint check and
+* the model catalog need it without a cycle — provision.ts already imports
+* {@link ENDPOINT_ENV_KEY} from here.
+*/
+const KIMI_MANAGED_BASE_URL = "https://api.kimi.com/coding/v1";
+/** How many served model ids the check reply lists before truncating. */
+const CHECK_MODEL_LIST_LIMIT = 8;
+/** Bound on the error-body excerpt a failed check reports. */
+const CHECK_ERROR_BODY_LIMIT = 200;
+/**
+* `GET <baseUrl>/v1/models` with `Authorization: Bearer <key>` — the
+* token-free endpoint probe shared by the settings card's verify button
+* (`checkEndpoint`) and the model catalog. Kimi's own coding service answers
+* it with the managed key (verified 2026-10-22 against
+* `https://api.kimi.com/coding/v1`: 200 with Bearer — the sibling x-api-key
+* header also works, but Bearer is the one convention this package sends).
+* The reply carries kimi's own fields — `display_name`,
+* `think_efforts.valid_efforts`/`default_effort` (a sibling
+* `reasoning.effort.valid`/`default` carries the same data; `think_efforts`
+* is the field this reads), `context_length` — while a generic
+* OpenAI-shaped relay answers ids only, so every optional field tolerates
+* absence. Never throws: every failure mode folds into the result.
+* @param endpoint - the resolved endpoint auth (caller checks the credential).
+* @param fetchImpl - the HTTP fetch; default the host's global fetch.
+* @param signal - abort for the whole probe (timeout bundled by the caller).
+* @returns the folded result.
+*/
+async function fetchEndpointModels(endpoint, fetchImpl, signal) {
+	const headers = {};
+	if (endpoint.apiKey !== void 0) headers["authorization"] = `Bearer ${endpoint.apiKey}`;
+	const fetcher = fetchImpl ?? globalThis.fetch;
+	const root = endpoint.baseUrl.replace(/\/+$/, "");
+	const url = `${root}${root.endsWith("/v1") ? "" : "/v1"}/models`;
+	let response;
+	try {
+		response = await fetcher(url, {
+			headers,
+			signal: signal ?? AbortSignal.timeout(8e3)
+		});
+	} catch (error) {
+		return {
+			kind: "unreachable",
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	if (!response.ok) return {
+		kind: "http",
+		status: response.status,
+		body: (await response.text().catch(() => "")).slice(0, CHECK_ERROR_BODY_LIMIT)
+	};
+	let data;
+	try {
+		data = JSON.parse(await response.text()).data;
+	} catch {
+		return { kind: "malformed" };
+	}
+	if (!Array.isArray(data)) return { kind: "malformed" };
+	const models = [];
+	for (const entry of data) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		if (typeof record.id !== "string" || record.id === "") continue;
+		const thinkEfforts = typeof record.think_efforts === "object" && record.think_efforts !== null ? record.think_efforts : void 0;
+		const efforts = thinkEfforts?.valid_efforts;
+		models.push({
+			id: record.id,
+			...typeof record.display_name === "string" && record.display_name !== "" ? { displayName: record.display_name } : {},
+			...Array.isArray(efforts) && efforts.some((effort) => typeof effort === "string" && effort !== "") ? { efforts: efforts.filter((effort) => typeof effort === "string" && effort !== "") } : {},
+			...typeof thinkEfforts?.default_effort === "string" && thinkEfforts.default_effort !== "" ? { defaultEffort: thinkEfforts.default_effort } : {},
+			...typeof record.context_length === "number" && Number.isFinite(record.context_length) ? { contextSize: record.context_length } : {}
+		});
+	}
+	return {
+		kind: "models",
+		models
+	};
+}
+/**
+* Probe the resolved endpoint with a cheap, token-free round-trip: `GET
+* <baseUrl>/v1/models` with the resolved credential's Bearer header. A 200
+* proves both reachability and credential validity — the exact evidence a
+* "verify" button needs — and the served model list rides the reply so the
+* user sees what the endpoint offers. One transport-level retry rides along:
+* a local proxy restart (a Surge/clash reload) stalls the first attempt into
+* the timeout and answers the retry immediately. Never throws: every failure
+* mode folds into the reply text, since the reply IS the diagnostic.
+* @param endpoint - the resolved endpoint auth (scope file over settings).
+* @param fetchImpl - the HTTP fetch; default the host's global fetch.
+* @param timeoutMs - one attempt's deadline (two attempts at most).
+* @returns the human-readable verdict for the check reply.
+*/
+async function checkKimiEndpoint(endpoint, fetchImpl, timeoutMs = 2e4) {
+	if (!hasEndpointCredential(endpoint)) return "No endpoint credential configured — fill API Key on the settings card (or the profile row) first.";
+	const baseUrl = (endpoint.baseUrl ?? "https://api.kimi.com/coding/v1").replace(/\/+$/, "");
+	let result = await fetchEndpointModels({
+		...endpoint,
+		baseUrl
+	}, fetchImpl, AbortSignal.timeout(timeoutMs));
+	if (result.kind === "unreachable") result = await fetchEndpointModels({
+		...endpoint,
+		baseUrl
+	}, fetchImpl, AbortSignal.timeout(timeoutMs));
+	if (result.kind === "unreachable") return `Endpoint unreachable (${baseUrl}): ${result.message}`;
+	if (result.kind === "http") return `Endpoint answered HTTP ${String(result.status)} (${baseUrl})${result.body === "" ? "" : `: ${result.body}`}`;
+	if (result.kind === "malformed") return `Endpoint reachable (${baseUrl}) but the model list did not parse — the credential worked, the reply was not /v1/models-shaped.`;
+	if (result.models.length === 0) return `Endpoint reachable (${baseUrl}); it serves no models.`;
+	const ids = result.models.map((model) => model.id);
+	const listed = ids.slice(0, CHECK_MODEL_LIST_LIMIT).join(", ");
+	const more = ids.length > CHECK_MODEL_LIST_LIMIT ? `, … +${String(ids.length - CHECK_MODEL_LIST_LIMIT)} more` : "";
+	return `Endpoint reachable (${baseUrl}): ${String(ids.length)} model(s) served — ${listed}${more}`;
+}
+//#endregion
 //#region ../../node_modules/.pnpm/smol-toml@1.9.0/node_modules/smol-toml/dist/error.js
 /*!
 * Copyright (c) Squirrel Chat et al., All rights reserved.
@@ -856,6 +1135,47 @@ function parse(toml, options = {}) {
 //#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;
+/**
+* List the scoped config's `[models.*]` tables (quoted and bare keys alike —
+* smol-toml folds both to the same object keys). An absent, unreadable, or
+* malformed config yields an empty list: the catalog's enrichment layer then
+* simply has nothing to enrich with. Read-only: the config is authoritative.
+* @param home - the `kimi` harness's scoped home.
+* @returns the model tables, in file order.
+*/
+async function readKimiModelTables(home) {
+	let text;
+	try {
+		text = await readFile(join(home, "config.toml"), "utf8");
+	} catch {
+		return [];
+	}
+	let config;
+	try {
+		config = parse(text);
+	} catch {
+		return [];
+	}
+	const models = table(config["models"]);
+	return Object.entries(models).map(([key, raw]) => {
+		const model = table(raw);
+		const provider = string(model["provider"]);
+		const upstream = string(model["model"]);
+		const displayName = string(model["display_name"]);
+		const efforts = model["support_efforts"];
+		const defaultEffort = string(model["default_effort"]);
+		const contextSize = model["max_context_size"];
+		return {
+			key,
+			...provider === void 0 ? {} : { provider },
+			...upstream === void 0 ? {} : { model: upstream },
+			...displayName === void 0 ? {} : { displayName },
+			...!Array.isArray(efforts) ? {} : { efforts: efforts.filter((effort) => typeof effort === "string" && effort !== "") },
+			...defaultEffort === void 0 ? {} : { defaultEffort },
+			...typeof contextSize === "number" && Number.isFinite(contextSize) ? { contextSize } : {}
+		};
+	});
+}
 /** Native configuration metadata only; provider credentials never leave this function. */
 async function readKimiModelConfiguration(home, selectedModel) {
 	let text;
@@ -973,52 +1293,149 @@ function kimiNativeConfiguration(value) {
 		...typeof legacy["currentModelId"] === "string" ? { currentModel: legacy["currentModelId"] } : {}
 	};
 }
-/** Reads configuration before a session exists; never starts a disposable ACP session. */
+/** One directory answer that names why it is empty. kimi never offers custom
+* input: a free-typed value names no `[models.…]` table, and kimi-cli refuses
+* `-m` values without one (verified 2.1.1) — unlike claude, only the
+* listed/configured models are runnable. */
+function unsupported(reason) {
+	return {
+		entries: [],
+		complete: false,
+		customInput: false,
+		unsupported: true,
+		reason
+	};
+}
+/**
+* The model directory, sourced from the configured ENDPOINT (`GET
+* <baseUrl>/v1/models` with the resolved credential's Bearer header — kimi's
+* own coding service answers it with the managed key, verified 2026-10-22) —
+* never from the scoped config's model tables alone: what the picker lists is
+* exactly what the endpoint serves, so a credential that does not work can
+* never hide behind a locally-known list. The answers are deliberate:
+*
+* - no credential resolved → empty with a "save a key first" reason;
+* - 401/403 → empty with the rejection (definitive — cached as data);
+* - another HTTP status → empty with it (the relay serves no model route);
+* - a transport failure THROWS, so the cache keeps the last good list and
+*   retries on schedule instead of blanking a momentarily-down endpoint.
+*
+* The config's `[models.…]` tables survive as METADATA ENRICHMENT: a served
+* model whose upstream id matches a managed table's `model` takes that
+* table's KEY as its value — the runnable name `-m` resolves against — and
+* the table's display_name/support_efforts/default_effort fill whatever the
+* endpoint did not advertise; a served id with no managed table stays the
+* bare id, which the model list's write face provisions a table for
+* (provision.ts's `ensureKimiModelTables`). Reads before a session exists
+* never start 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) {
+	deps;
+	cache;
+	constructor(context, deps) {
 		this.context = context;
+		this.deps = deps;
+		this.cache = new ModelDirectoryCache({
+			load: (key, signal) => {
+				const context = JSON.parse(key);
+				if (context.native !== void 0) return Promise.resolve(context.native);
+				return this.probe(context.homeDir, signal);
+			},
+			...deps.ttlMs === void 0 ? {} : { ttlMs: deps.ttlMs },
+			onError: (error) => deps.warn?.(`Kimi model discovery failed: ${error instanceof Error ? error.message : String(error)}`)
+		});
 	}
-	key(childSessionId) {
-		const context = this.context(childSessionId);
-		const stamp = modelDirectoryContextKey({
+	stamp(homeDir, cwd) {
+		return modelDirectoryContextKey({
 			provider: "kimi",
-			homeDir: context.homeDir,
-			cwd: context.cwd ?? context.homeDir,
+			homeDir,
+			cwd: cwd ?? homeDir,
 			cli: ["kimi"],
-			files: [join(context.homeDir, "config.toml"), join(context.homeDir, "credentials", "kimi-code.json")]
+			files: [join(homeDir, "config.toml"), join(homeDir, "endpoint-auth.json")]
 		});
+	}
+	key(childSessionId) {
+		const context = this.context(childSessionId);
 		return JSON.stringify({
 			homeDir: context.homeDir,
-			stamp,
+			stamp: this.stamp(context.homeDir, context.cwd),
 			childSessionId,
 			...context.native === void 0 ? {} : { native: context.native.directory }
 		});
 	}
+	/**
+	* The cache key for one scoped home directly (no member, no native): the
+	* model-list write face's read — its entries carry the metadata the write
+	* face's table provisioning (provision.ts's `ensureKimiModelTables`)
+	* stamps into the tables it creates.
+	*/
+	homeKey(homeDir) {
+		return JSON.stringify({
+			homeDir,
+			stamp: this.stamp(homeDir)
+		});
+	}
 	read(childSessionId) {
 		return this.cache.read(this.key(childSessionId));
 	}
 	refresh(childSessionId) {
 		return this.cache.refresh(this.key(childSessionId));
 	}
+	readHome(homeDir) {
+		return this.cache.read(this.homeKey(homeDir));
+	}
+	refreshHome(homeDir) {
+		return this.cache.refresh(this.homeKey(homeDir));
+	}
 	follow(childSessionId, signal) {
 		return this.cache.follow(() => this.key(childSessionId), signal);
 	}
 	dispose() {
 		this.cache.dispose();
 	}
+	async probe(homeDir, signal) {
+		const endpoint = await this.deps.endpoint(homeDir);
+		if (!hasEndpointCredential(endpoint)) return unsupported("No endpoint credential configured — the model list loads from the endpoint once an API Key is saved");
+		const result = await fetchEndpointModels({
+			...endpoint,
+			baseUrl: endpoint.baseUrl ?? "https://api.kimi.com/coding/v1"
+		}, this.deps.fetchImpl, AbortSignal.any([signal, AbortSignal.timeout(this.deps.timeoutMs ?? 2e4)]));
+		if (result.kind === "unreachable") throw new Error(`endpoint unreachable: ${result.message}`);
+		if (result.kind === "malformed") return unsupported("The endpoint answered but the model list did not parse (not a /models-shaped reply)");
+		if (result.kind === "http") {
+			if (result.status === 401 || result.status === 403) return unsupported(`The endpoint rejected the credential (HTTP ${String(result.status)}) — the list loads once a valid key is saved`);
+			return unsupported(`The endpoint does not serve a model list (HTTP ${String(result.status)})`);
+		}
+		if (result.models.length === 0) return unsupported("The endpoint serves no models");
+		const byUpstream = /* @__PURE__ */ new Map();
+		for (const modelTable of await readKimiModelTables(homeDir)) {
+			if (modelTable.provider !== "managed:kimi-code" || modelTable.model === void 0) continue;
+			if (!byUpstream.has(modelTable.model)) byUpstream.set(modelTable.model, modelTable);
+		}
+		return {
+			entries: result.models.map((model) => {
+				const modelTable = byUpstream.get(model.id);
+				const value = modelTable?.key ?? model.id;
+				const efforts = model.efforts ?? modelTable?.efforts;
+				const defaultEffort = model.defaultEffort ?? modelTable?.defaultEffort;
+				return {
+					value,
+					label: model.displayName ?? modelTable?.displayName ?? value,
+					source: "native",
+					...efforts === void 0 || efforts.length === 0 ? {} : { reasoning: {
+						options: efforts.map((effort) => ({
+							value: effort,
+							label: effort
+						})),
+						...defaultEffort === void 0 ? {} : { default: defaultEffort }
+					} }
+				};
+			}),
+			complete: true,
+			customInput: false
+		};
+	}
 };
 //#endregion
 //#region lib/types/session-configuration.js
@@ -1049,1177 +1466,1307 @@ async function configureKimiSession(sessionId, initial, desired, request) {
 	return current;
 }
 //#endregion
-//#region lib/types/session-view.js
+//#region lib/types/provision.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
+* Kimi Code scoped-home provisioning: a working `config.toml` (provider and
+* model definitions) is required for the ACP server to run. 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. Authentication
+* is endpoint-key only (endpoint-auth.ts): the managed provider declares
+* `api_key_env = "DSH_KIMI_ENDPOINT_KEY"` and the key rides the child
+* process's environment, so `config.toml` itself never holds a secret.
+* Provisioning also sweeps the OAuth era's leftovers (`credentials/`,
+* `oauth/`) and migrates an existing managed-provider section onto the
+* env-key shape. 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
 */
-/** The wire event log path for a session directory. */
-function wirePath(sessionDir) {
-	return join(sessionDir, "agents", "main", "wire.jsonl");
-}
+const REAL_CONFIG = join(homedir(), ".kimi-code", "config.toml");
+/** Credentials directory inside the scoped home — the OAuth era's grant. */
+const CREDENTIALS_DIR = "credentials";
+/** OAuth token cache directory inside the scoped home. */
+const OAUTH_DIR = "oauth";
 /**
-* 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.
+* The capability list every managed model table carries — the minimal
+* config's own, hoisted so the write face's on-add table provisioning
+* ({@link ensureKimiModelTables}) stamps the same shape.
 */
-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 {}
-	}
+const KIMI_MODEL_CAPABILITIES = "capabilities = [ \"thinking\", \"always_thinking\", \"image_in\", \"video_in\", \"tool_use\" ]";
+/** Quote one TOML basic string (model ids take backslash escapes). */
+function tomlString(value) {
+	return `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"")}"`;
 }
-/** Whether a user message is kimi's auto-permission reminder, never real task text. */
-function isSystemReminder(text) {
-	return text.startsWith("<system-reminder>");
+/** 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_env = "${ENDPOINT_ENV_KEY}"
+
+[models."${model}"]
+provider = "managed:kimi-code"
+model = "${model.split("/").pop()}"
+max_context_size = 1048576
+${KIMI_MODEL_CAPABILITIES}
+display_name = "${model}"
+support_efforts = [ "low", "high", "max" ]
+default_effort = "${thinkingEffort}"
+`;
 }
-/** 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("");
+/**
+* Redact every api_key value so the scoped copy carries no secrets. The
+* kimi-managed provider's key comes from the `api_key_env` indirection (the
+* endpoint credential), 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 = \"\"");
 }
+/** The managed provider's section header (the colon forces the quoted form). */
+const MANAGED_PROVIDER_HEADER = "[providers.\"managed:kimi-code\"]";
+/** The OAuth sub-table the endpoint-key shape drops. */
+const MANAGED_OAUTH_HEADER = "[providers.\"managed:kimi-code\".oauth]";
 /**
-* 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.
+* Migrate the managed provider section of a config.toml onto the endpoint-key
+* shape, as a pure text transform:
+*
+* - the section's `api_key = "…"` line (any value — a mirrored config is
+*   already redacted, and a live one must not keep a secret in a hashed
+*   file) is replaced by `api_key_env = "<ENDPOINT_ENV_KEY>"`;
+* - the `[providers."managed:kimi-code".oauth]` sub-table is dropped (the
+*   OAuth flow is gone);
+* - when `baseUrl` is given, the section's `base_url` is set to it (the
+*   endpoint credential owns the managed provider's endpoint; a hand-edit
+*   is re-pointed at the next surgery).
+*
+* Other sections — user-added providers, model tables, permission rules —
+* are byte-preserved. A config without the managed provider section is
+* returned unchanged (a hand-built config's own providers are the user's
+* business). Idempotent: an in-sync input comes back byte-identical, so the
+* caller writes only on drift.
+* @param config - the config.toml text.
+* @param baseUrl - the endpoint to pin, or undefined to keep the file's own.
+* @returns the migrated config text.
 */
-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}`));
+function migrateManagedProviderConfig(config, baseUrl) {
+	const lines = config.split("\n");
+	const start = lines.findIndex((line) => line.trim() === MANAGED_PROVIDER_HEADER);
+	if (start === -1) return config;
+	let bodyEnd = lines.length;
+	for (let index = start + 1; index < lines.length; index += 1) if (/^\s*\[/.test(lines[index])) {
+		bodyEnd = index;
+		break;
+	}
+	let end = bodyEnd;
+	if (lines[bodyEnd]?.trim() === MANAGED_OAUTH_HEADER) {
+		end = lines.length;
+		for (let index = bodyEnd + 1; index < lines.length; index += 1) if (/^\s*\[/.test(lines[index])) {
+			end = index;
+			break;
 		}
-		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 section = lines.slice(start + 1, bodyEnd);
+	const tail = lines.slice(end);
+	const out = [];
+	let sawEnvKey = false;
+	let sawBaseUrl = false;
+	for (const raw of section) {
+		const trimmed = raw.trim();
+		if (/^api_key\s*=/.test(trimmed)) continue;
+		if (/^api_key_env\s*=/.test(trimmed)) {
+			if (sawEnvKey) continue;
+			sawEnvKey = true;
+			out.push(`api_key_env = "${ENDPOINT_ENV_KEY}"`);
+			continue;
+		}
+		if (baseUrl !== void 0 && /^base_url\s*=/.test(trimmed)) {
+			if (sawBaseUrl) continue;
+			sawBaseUrl = true;
+			out.push(`base_url = "${baseUrl.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
+			continue;
+		}
+		out.push(raw);
 	}
-	const patch = record["patch"] ?? record["diff"];
-	if (typeof patch === "string" && patch.trim() !== "") return patch;
+	if (!sawEnvKey) out.push(`api_key_env = "${ENDPOINT_ENV_KEY}"`);
+	if (baseUrl !== void 0 && !sawBaseUrl) out.unshift(`base_url = "${baseUrl.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`);
+	return [
+		...lines.slice(0, start + 1),
+		...out,
+		...tail
+	].join("\n");
 }
-/** 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();
+/**
+* Ensure the scoped config's managed provider runs on the endpoint-key
+* shape (see {@link migrateManagedProviderConfig}); writes only on drift.
+* Called at provision, at boot, on the card's credential save, and before
+* each spawn — the last makes a hand-edited endpoint-auth.json's baseUrl
+* land without a restart.
+* @param homeDir - the `kimi` harness's scoped home.
+* @param baseUrl - the resolved endpoint's baseUrl, when one is configured.
+* @returns true when the config was rewritten, false when already in sync
+*   (or absent — provisioning owns creation).
+*/
+async function ensureKimiEndpointProvider(homeDir, baseUrl) {
+	const file = join(homeDir, "config.toml");
+	let text;
+	try {
+		text = await readFile(file, "utf8");
+	} catch {
+		return false;
 	}
-	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;
+	const migrated = migrateManagedProviderConfig(text, baseUrl);
+	if (migrated === text) return false;
+	await writeFile(file, migrated, "utf8");
+	return true;
 }
 /**
-* Parse a session's wire log into transcript lines plus every usage record.
-* @param sessionDir - the session directory.
-* @returns the transcript.
+* Sweep the OAuth era's leftovers (the credentials directory and the oauth
+* token cache). The harness no longer reads either; a leftover grant would
+* keep authenticating nothing (the managed provider no longer declares an
+* oauth section), and removing them keeps the scoped home honest about its
+* only credential being the endpoint key. Idempotent.
+* @param homeDir - the `kimi` harness's scoped home.
 */
-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;
+async function sweepKimiOauthLeftovers(homeDir) {
+	await Promise.all([rm(join(homeDir, CREDENTIALS_DIR), {
+		recursive: true,
+		force: true
+	}), rm(join(homeDir, OAUTH_DIR), {
+		recursive: true,
+		force: true
+	})]);
+}
+/**
+* Provision `<homeDir>/config.toml` unless one already exists, and always
+* sweep the OAuth era's leftovers. A present config is migrated onto the
+* endpoint-key shape (managed provider onto `api_key_env`, oauth sub-table
+* dropped) but otherwise respected; otherwise the user's own real config is
+* copied redacted AND migrated, so the scoped home mirrors the user's models
+* while carrying no secrets; 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.
+* @param baseUrl - the deployment endpoint to pin on the managed provider,
+*   when the plugin config names one (the scope file's own baseUrl lands via
+*   the card save / the per-spawn surgery).
+* @returns true when a config was written, false when one already existed.
+*/
+async function provisionKimiConfig(homeDir, model, thinkingEffort, baseUrl) {
+	await sweepKimiOauthLeftovers(homeDir);
+	let existed = true;
 	try {
-		text = await readFile(wirePath(sessionDir), "utf8");
+		await readFile(join(homeDir, "config.toml"));
 	} catch (error) {
-		if (error.code === "ENOENT") return {
-			sessionId,
-			lines,
-			usageRecords
-		};
-		throw error;
+		if (error.code !== "ENOENT") throw error;
+		existed = false;
 	}
-	for (const raw of text.split("\n")) {
-		const line = raw.trim();
-		if (line === "") continue;
-		let event;
-		try {
-			event = JSON.parse(line);
-		} catch {
+	if (existed) {
+		await ensureKimiEndpointProvider(homeDir, baseUrl);
+		return false;
+	}
+	let config = minimalConfig(model, thinkingEffort);
+	try {
+		config = migrateManagedProviderConfig(redactApiKeys(await readFile(REAL_CONFIG, "utf8")), baseUrl);
+	} 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 (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 (section === MANAGED_PROVIDER_SECTION) {
+			const match = /^base_url\s*=\s*"([^"]*)"$/.exec(line);
+			if (match !== null) return match[1];
 		}
-		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;
-			}
+	}
+}
+/**
+* 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 (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
-			});
+		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;
+}
+/**
+* The header scan's one table key: a quoted `models."…"` key (unescaped — the
+* writer escapes, so the reader must fold back) or a bare `models.x` one.
+*/
+function modelTableKey(header) {
+	const table = /^models\.(?:"((?:[^"\\]|\\.)*)"|([\w-]+))$/.exec(header);
+	const raw = table?.[1];
+	if (raw !== void 0) return raw.replace(/\\(["\\])/gu, "$1");
+	return table?.[2];
+}
+/** Whether the config text already keys a `[models.…]` table for `value`. */
+function hasModelTable(text, value) {
+	for (const rawLine of text.split("\n")) {
+		const header = /^\[+([^\]]+)\]+$/.exec(rawLine.trim());
+		if (header !== null && modelTableKey(header[1]) === value) return true;
+	}
+	return false;
+}
+/**
+* Give every listed model value a `[models."<value>"]` table in the scoped
+* config — the runnable name `-m` resolves against. kimi-cli ≥2.1 REQUIRES
+* the table: `kimi -m k3` fails with `Model "k3" is not configured in
+* config.toml` when only `[models."kimi-code/k3"]` (carrying `model = "k3"`)
+* exists (verified against kimi-cli 2.1.1), so an endpoint-served id the
+* catalog lists is not directly runnable until its table exists. The model
+* list's write face calls this after each save so an added endpoint id is
+* runnable from that round on.
+*
+* Only MISSING values get a table: an existing key (quoted or bare) is the
+* user's own definition and stays untouched. The appended table mirrors the
+* minimal config's managed shape — `provider = "managed:kimi-code"`, `model`
+* = the value, `max_context_size` (the metadata's endpoint-reported size,
+* else 1048576 — the minimal template's value), the shared capabilities
+* list, `display_name` (the metadata's label, else the value), and
+* `support_efforts`/`default_effort` when the metadata carries them. An
+* absent or unreadable config yields [] (provisioning owns creation;
+* inventing a whole config here would hide a broken home). Idempotent: all
+* values already keyed → no write, [].
+* @param homeDir - the `kimi` harness's scoped home.
+* @param models - the model values that must be runnable (already normalized).
+* @param metadata - per-value lookup of the catalog's endpoint/table facts.
+* @returns the table keys this call created, in the order listed.
+*/
+async function ensureKimiModelTables(homeDir, models, metadata) {
+	const path = join(homeDir, "config.toml");
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch {
+		return [];
+	}
+	const created = [];
+	let fragment = "";
+	for (const value of models) {
+		if (value === "" || hasModelTable(text, value) || created.includes(value)) continue;
+		const facts = metadata?.(value);
+		fragment += `\n[models.${tomlString(value)}]\nprovider = "managed:kimi-code"
+model = ${tomlString(value)}\nmax_context_size = ${String(facts?.contextSize ?? 1048576)}\n${KIMI_MODEL_CAPABILITIES}\ndisplay_name = ${tomlString(facts?.label ?? value)}\n` + (facts?.efforts === void 0 || facts.efforts.length === 0 ? "" : `support_efforts = [ ${facts.efforts.map(tomlString).join(", ")} ]\n`) + (facts?.defaultEffort === void 0 ? "" : `default_effort = ${tomlString(facts.defaultEffort)}\n`);
+		created.push(value);
+	}
+	if (created.length === 0) return [];
+	await writeFile(path, `${text.trimEnd()}\n${fragment}`, "utf8");
+	return created;
+}
+/**
+* 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 (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
-			});
+		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;
 		}
-		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
-			});
-		}
+		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 {
-		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;
+	return thinkingEffort ?? modelDefaultEffort;
 }
 /**
-* 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.
+* 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.
 */
-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;
+async function readKimiAutoApprove(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return false;
 	}
-	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;
+	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"
+`;
 /**
-* 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.
+* 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.
 */
-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}` : ""}`);
+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;
 	}
-	return parts.join("\n");
+	if (content.includes("pattern = \"Bash(*)")) return;
+	await writeFile(file, `${content.trimEnd()}\n${KIMI_PERMISSION_BLOCK}`);
 }
 //#endregion
-//#region lib/types/session-mirror.js
+//#region lib/types/session-view.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
+* 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
 */
-/** 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 wire event log path for a session directory. */
+function wirePath(sessionDir) {
+	return join(sessionDir, "agents", "main", "wire.jsonl");
 }
 /**
-* 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.
+* 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.
 */
-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);
+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;
 	}
-	return next;
+	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("");
 }
 /**
-* 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.
+* 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 lineBlocks(line) {
-	if (line.kind === "think") return [{
-		type: "reasoning",
-		text: line.text
-	}];
-	return [{
-		type: "text",
-		text: line.text
-	}];
+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;
 }
-/** 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}` : ""}`;
+/** 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;
 }
 /**
-* 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.
+* Parse a session's wire log into transcript lines plus every usage record.
+* @param sessionDir - the session directory.
+* @returns the transcript.
 */
-async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, fromLines = 0, options) {
-	let workspaces;
+async function readKimiTranscript(sessionDir) {
+	const sessionId = sessionDir.split("session_").pop() ?? sessionDir;
+	const lines = [];
+	const usageRecords = [];
+	const closedSteps = /* @__PURE__ */ new Set();
+	let model;
+	let modelTurn;
+	let lineModel;
+	let lineConfig;
+	const push = (line) => {
+		lines.push({
+			...line,
+			...lineModel === void 0 ? {} : { model: lineModel },
+			...line.kind !== "user" && lineConfig !== void 0 ? { requestConfig: { ...lineConfig } } : {}
+		});
+	};
+	let turn = 0;
+	let turnSeen = false;
+	const callsByUuid = /* @__PURE__ */ new Map();
+	const callsByToolCallId = /* @__PURE__ */ new Map();
+	let text;
 	try {
-		workspaces = await readdir(join(homeDir, "sessions"));
-	} catch {
-		return {
-			total: 0,
-			texts: []
+		text = await readFile(wirePath(sessionDir), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			sessionId,
+			lines,
+			usageRecords,
+			closedSteps
 		};
+		throw error;
 	}
-	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;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "") continue;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			continue;
 		}
-	} 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 (event.type === "usage.record") {
+			if (typeof event.model === "string" && event.model !== "") {
+				model = lineModel = event.model;
+				modelTurn = turn || 1;
+				if (lineConfig !== void 0) lineConfig = {
+					...lineConfig,
+					model: event.model
 				};
 			}
-		}
-		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
+			const usage = usageFromWire(event.usage);
+			if (usage !== void 0) usageRecords.push({
+				line: lines.length,
+				usage
 			});
-		} 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);
-			}
+			continue;
 		}
-	}
-	/**
-	* 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;
+		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;
+			}
+			lineConfig = lineModel === void 0 ? void 0 : {
+				model: lineModel,
+				...typeof event.thinkingEffort === "string" && event.thinkingEffort !== "" ? { reasoningEffort: event.thinkingEffort } : {},
+				...typeof event.maxTokens === "number" && Number.isFinite(event.maxTokens) ? { maxTokens: event.maxTokens } : {}
+			};
+			continue;
 		}
-		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
+		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
 			});
-			const call = childSession.append("tool/call", {
-				turn,
-				step,
-				callId: line.id,
-				name: line.name,
-				arguments: line.args ?? ""
+			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
 			});
-			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]
+			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 wireStep = typeof loop.step === "number" ? loop.step : void 0;
+			const part = loop.part;
+			const lineTurn = turn === 0 ? 1 : turn;
+			if (loop.type === "step.end" && wireStep !== void 0) closedSteps.add(`${lineTurn}:${wireStep}`);
+			if (part?.type === "text" && part.text !== void 0 && part.text.trim() !== "") push({
+				kind: "assistant",
+				text: part.text,
+				turn: lineTurn,
+				...wireStep === void 0 ? {} : { wireStep }
 			});
-			childSession.append("step/end", {
-				turn,
-				step
+			else if (part?.type === "think" && part.think !== void 0 && part.think.trim() !== "") push({
+				kind: "think",
+				text: part.think,
+				turn: lineTurn,
+				...wireStep === void 0 ? {} : { wireStep }
 			});
-		} 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
+			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,
+					...wireStep === void 0 ? {} : { wireStep }
 				});
-				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
+				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
 			});
-			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 } : {}
+		sessionId,
+		lines,
+		usageRecords,
+		closedSteps,
+		...model === void 0 ? {} : { model },
+		...modelTurn === void 0 ? {} : { modelTurn }
 	};
 }
 /**
-* 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.
+* 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;
+* a reported cache-read counter is always written (zero included), so a
+* reader can tell "no hits" from "not reported".
+* @param raw - the event's `usage` value.
+* @returns the shared usage record, or undefined when nothing was reported.
 */
-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
+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) usage.cacheReadTokens = cacheRead;
+	if (cacheWrite !== void 0 && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
+	return usage;
 }
 /**
-* 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.
+* 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 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;
+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;
 	}
-	return false;
+	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;
 }
-//#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
+* 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.
 */
-/** 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
-		};
-	}
+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
+	}]);
 }
-/**
-* 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;
+/** 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 false;
+	return parts.join("\n");
 }
 //#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 = \"\"");
-}
+//#region lib/types/session-mirror.js
 /**
-* 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.
+* 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
 */
-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.
+* The synthesized result for a call whose result the wire never recorded
+* (a settle-pass fold, or a live reservation kimi never logged). The
+* released-log contract resolves every advertised call before its step
+* closes, so an interrupted call folds with this error result.
 */
-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];
+const KIMI_INTERRUPTED_TOOL_RESULT = "（工具调用被中断，未能记录返回结果）";
+/** 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"
 		}
-	}
+	});
 }
 /**
-* 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.
+* The step the next fold pass would assign in one turn: the smallest step
+* nothing holds (never written, never reserved at call time — callers skip
+* their own reservations on top). Filling the smallest free step keeps the
+* stored log dense: the released-log reader admits only dense, strictly
+* sequential steps, and a reservation released mid-round (its content rode an
+* earlier fold) leaves a gap only the next first-free write fills.
+* @param childSession - the run's child session.
+* @param turn - the round's turn number.
+* @returns the smallest free step in the turn.
 */
-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];
+function nextKimiSessionStep(childSession, turn) {
+	const taken = /* @__PURE__ */ new Set();
+	for (const event of childSession.snapshotEvents()) {
+		const data = event.data;
+		if (data.turn === turn && typeof data.step === "number") taken.add(data.step);
 	}
+	let next = 1;
+	while (taken.has(next)) next += 1;
+	return next;
 }
 /**
-* 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.
+* The step a durable write takes: one past the highest step this turn has
+* opened in the log. The released-log reader admits steps only in order —
+* one past the last, never below it — so the coordinate is decided when the
+* step is written, never reserved ahead (a reservation filled later lands
+* below a higher step already written: a gap, then a step out of order).
+* Stream and tool reservations only key the live preview.
 */
-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);
+function nextWrittenKimiStep(childSession, turn) {
+	let last = 0;
+	for (const event of childSession.snapshotEvents()) {
+		if (event.type !== "step/start") continue;
+		const data = event.data;
+		if (data.turn === turn && typeof data.step === "number" && data.step > last) last = data.step;
 	}
-	return models;
+	return last + 1;
+}
+/** 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}` : ""}`;
 }
 /**
-* 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.
+* Mirror one kimi session's transcript into a dsh subagent session: each
+* user prompt becomes a `user/message`, and each WIRE STEP (one LLM request:
+* its thinking, reply text and tool calls share the wire's own step number)
+* folds into one dsh step whose `assistant/message` carries the reasoning,
+* text and tool-call blocks together — the host session's own shape, so the
+* standard surfaces (conversation, Context Lens) read one request per LLM
+* call. Then the events are appended to persistence so the child session is
+* viewable.
 *
-* 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).
+* 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 one ATOMIC `step/start`–`step/end` triple, written
+* only when its content lands: the released-log reader admits only dense,
+* strictly sequential steps (one open at a time — a second `step/start`
+* while another step is open fails the session's reload validation), and the
+* live conversation assembler needs the boundary to materialize the step at
+* all. A fold paired with in-flight streams lands at the earliest consumed
+* reservation (see {@link KimiMirrorStreams}), after `finalizeBefore` has
+* closed every stream reservation below it; a sequential fold never takes a
+* step a stream reserved. Mid-round, a wire step the wire has not CLOSED yet
+* (no `step.end`) holds the pass — its parts may still arrive — and so does
+* an unresulted tool call (the reader resolves every advertised call before
+* the step closes; the result merges into the call's line in place, so the
+* next pass sees it). The settle pass folds the remainder with a synthesized
+* interrupted result. Lines the wire never step-tagged (older kimi) fold one
+* by one, immediately, as before.
+*
+* Usage accounting is exactly-once ACROSS passes: each `usage.record` is
+* tagged with the transcript position it occurred at, a pass owns the records
+* between the old offset and its own consumed end, and inside the window each
+* record rides the unit whose line span encloses it — one record per wire
+* step, landing on its own step's message. (A record raced PAST its content
+* encloses into the next unit instead: attribution off by one in a flush
+* race, totals still exact.)
+* @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 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.
+* @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 mirror offset and the newly mirrored lines' texts. A held
+*   unit (open wire step or unresulted tool) stops the offset before itself;
+*   the next pass retries from there.
 */
-async function writeKimiDefaultModel(homeDir, model) {
-	const path = join(homeDir, "config.toml");
-	let text;
+async function mirrorKimiSessionDelta(ctx, childSession, homeDir, kimiSessionId, fromLines = 0, options) {
+	let workspaces;
 	try {
-		text = await readFile(path, "utf8");
+		workspaces = await readdir(join(homeDir, "sessions"));
 	} catch {
-		return false;
+		return {
+			total: 0,
+			texts: []
+		};
 	}
-	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];
+	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 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 units = [];
+	for (const line of delta) {
+		if (line === void 0) continue;
+		const last = units.at(-1);
+		const head = last?.[0];
+		if (last !== void 0 && head !== void 0 && line.kind !== "user" && head.kind !== "user" && line.wireStep !== void 0 && line.wireStep === head.wireStep && line.turn === head.turn) {
+			last.push(line);
 			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;
+		units.push([line]);
+	}
+	let holdAt = -1;
+	if (options?.settle !== true) for (let index = 0; index < units.length; index += 1) {
+		const unit = units[index];
+		const head = unit[0];
+		if (head.kind !== "user" && head.wireStep !== void 0 && !transcript.closedSteps.has(`${head.turn}:${head.wireStep}`) || unit.some((line) => line.kind === "tool" && line.result === void 0)) {
+			holdAt = index;
+			break;
+		}
 	}
-	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;
+	const foldedUnits = holdAt < 0 ? units : units.slice(0, holdAt);
+	const consumedTotal = fromLines + foldedUnits.reduce((n, unit) => n + unit.length, 0);
+	const unitUsage = [];
+	const claimed = [];
+	let unitStart = fromLines;
+	for (const unit of foldedUnits) {
+		const start = unitStart;
+		unitStart += unit.length;
+		const head = unit[0];
+		if (head.kind !== "user" && head.wireStep !== void 0) {
+			claimed.push({
+				from: start,
+				to: unitStart
+			});
+			unitUsage.push(sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= start && record.line < unitStart)));
+		} else unitUsage.push(void 0);
 	}
-	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];
+	const unclaimedUsage = sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= fromLines && record.line <= consumedTotal && !claimed.some((span) => record.line >= span.from && record.line < span.to)));
+	const deltaUsage = sumUsageRecords(transcript.usageRecords.filter((record) => record.line >= fromLines && record.line <= consumedTotal));
+	const takenSteps = /* @__PURE__ */ new Map();
+	for (const event of childSession.snapshotEvents()) {
+		const data = event.data;
+		if (typeof data.turn === "number" && typeof data.step === "number") {
+			const taken = takenSteps.get(data.turn) ?? /* @__PURE__ */ new Set();
+			taken.add(data.step);
+			takenSteps.set(data.turn, taken);
+		}
+	}
+	/**
+	* The fold's coordinate: the smallest step of the turn that nothing holds
+	* — neither written nor currently reserved. Filling the smallest free step
+	* keeps the stored log dense even when a stream reservation below was
+	* released mid-round (its content rode an earlier fold's step).
+	*/
+	const nextFoldStep = (turn) => {
+		const taken = new Set(takenSteps.get(turn));
+		for (const reserved of options?.streams?.reservedSteps(turn) ?? []) taken.add(reserved);
+		let step = 1;
+		while (taken.has(step)) step += 1;
+		return step;
+	};
+	/** Record a fold's coordinate chosen by a stream pairing. */
+	const markTaken = (turn, step) => {
+		const written = takenSteps.get(turn) ?? /* @__PURE__ */ new Set();
+		written.add(step);
+		takenSteps.set(turn, written);
+	};
+	/** The window's accounting that no fold carried (dropped units' sums). */
+	let carryUsage;
+	let lastContentUnit = -1;
+	for (let index = foldedUnits.length - 1; index >= 0; index -= 1) if (foldedUnits[index][0]?.kind !== "user") {
+		lastContentUnit = index;
+		break;
+	}
+	const texts = [];
+	for (let unitIndex = 0; unitIndex < foldedUnits.length; unitIndex += 1) {
+		const unit = foldedUnits[unitIndex];
+		const head = unit[0];
+		let usage = addTokenUsage(carryUsage, unitUsage[unitIndex]);
+		carryUsage = void 0;
+		if (unitIndex === lastContentUnit) usage = addTokenUsage(usage, unclaimedUsage);
+		const turn = head.turn;
+		if (head.kind === "user") {
+			if (userAlreadyAppended(childSession, turn, head.text)) continue;
+			childSession.append("user/message", userEvent(head.text), { surfaceOp: "append" });
+			texts.push(head.text);
+			carryUsage = usage;
 			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];
+		const toolLines = unit.filter((line) => line.kind === "tool");
+		const reasoning = unit.filter((line) => line.kind === "think").map((line) => line.text).join("");
+		const text = unit.filter((line) => line.kind === "assistant").map((line) => line.text).join("");
+		const kinds = [...reasoning.trim() === "" ? [] : ["think"], ...text.trim() === "" ? [] : ["text"]];
+		const pairing = kinds.length === 0 ? void 0 : options?.streams?.completeStreams(turn, kinds);
+		const sealed = new Set(pairing?.sealed ?? []);
+		const blocks = [];
+		if (reasoning.trim() !== "" && !sealed.has("think")) blocks.push({
+			type: "reasoning",
+			text: reasoning
+		});
+		if (text.trim() !== "" && !sealed.has("text")) blocks.push({
+			type: "text",
+			text
+		});
+		for (const line of toolLines) blocks.push({
+			type: "tool-call",
+			id: line.id,
+			name: line.name,
+			arguments: line.args ?? ""
+		});
+		for (const line of unit) texts.push(kimiLineProgressText(line));
+		if (blocks.length === 0) {
+			carryUsage = usage;
+			continue;
+		}
+		for (const line of toolLines) options?.streams?.releaseTool?.(line);
+		let step = pairing?.step ?? nextFoldStep(turn);
+		options?.streams?.finalizeBefore?.(turn, step);
+		let sequential = nextKimiSessionStep(childSession, turn);
+		const reservedAfter = options?.streams?.reservedSteps(turn) ?? [];
+		while (reservedAfter.includes(sequential)) sequential += 1;
+		step = Math.min(step, sequential);
+		markTaken(turn, step);
+		step = nextWrittenKimiStep(childSession, turn);
+		const requestConfig = unit.map((line) => line.kind !== "user" ? line.requestConfig : void 0).find((config) => config !== void 0);
+		if (requestConfig?.model !== void 0) appendRequestHeaderIfChanged(childSession, {
+			provider: "kimi-cli",
+			model: requestConfig.model,
+			...requestConfig.reasoningEffort === void 0 ? {} : { reasoningEffort: requestConfig.reasoningEffort },
+			...requestConfig.maxTokens === void 0 ? {} : { maxTokens: requestConfig.maxTokens }
+		});
+		const model = [...unit].reverse().find((line) => line.model !== void 0)?.model;
+		childSession.append("step/start", {
+			turn,
+			step
+		});
+		childSession.append("assistant/message", {
+			turn,
+			step,
+			message: assistantEvent(blocks, model),
+			stream: [],
+			...usage === void 0 ? {} : { usage }
+		}, { surfaceOp: "append" });
+		for (const line of toolLines) {
+			const call = childSession.append("tool/call", {
+				turn,
+				step,
+				callId: line.id,
+				name: line.name,
+				arguments: line.args ?? ""
+			});
+			childSession.append("tool/result", {
+				turn,
+				step,
+				message: createToolResultMessage({
+					callId: line.id,
+					content: [{
+						type: "text",
+						text: line.result ?? "（工具调用被中断，未能记录返回结果）"
+					}],
+					isError: line.result === void 0
+				})
+			}, {
+				surfaceOp: "append",
+				sourceEventSeqs: [call.seq]
+			});
+		}
+		childSession.append("step/end", {
+			turn,
+			step
+		});
 	}
-	return thinkingEffort ?? modelDefaultEffort;
+	await persistChildSession(ctx, childSession);
+	const remainder = addTokenUsage(carryUsage, lastContentUnit === -1 ? unclaimedUsage : void 0);
+	return {
+		total: consumedTotal,
+		texts,
+		...deltaUsage !== void 0 ? { usage: deltaUsage } : {},
+		...deltaUsage !== void 0 && remainder === void 0 ? { usageAttached: true } : {},
+		...remainder !== void 0 ? { usageUnattached: remainder } : {},
+		...observedModel !== void 0 ? { model: observedModel } : {},
+		...toolCalls !== void 0 ? { toolCalls } : {}
+	};
 }
 /**
-* 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.
+* 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.
 */
-async function readKimiAutoApprove(homeDir) {
-	let text;
-	try {
-		text = await readFile(join(homeDir, "config.toml"), "utf8");
-	} catch {
-		return false;
+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 text.includes("pattern = \"Bash(*)");
+	return count === 0 ? void 0 : {
+		count,
+		byName
+	};
 }
-/** 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.
+* Write the fold's request/header when the wire's declared config differs from
+* the child log's last one (the host logs changed snapshots, not per-call
+* duplicates): first write is `initial`, a differing one `change`, an
+* identical one skipped.
 */
-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}`);
+function appendRequestHeaderIfChanged(childSession, config) {
+	const serialized = JSON.stringify(config);
+	let last;
+	for (const event of childSession.snapshotEvents()) if (event.type === "request/header") last = JSON.stringify(event.data.header?.config);
+	if (last === serialized) return;
+	childSession.append("request/header", {
+		header: { config },
+		reason: last === void 0 ? "initial" : "change"
+	});
 }
 /**
-* 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.
+* 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.
 */
-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
-	})]);
+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/live-driver.js
@@ -2241,11 +2788,14 @@ async function kimiLogout(homeDir) {
 * 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.
+* Live output rides the `local-agent/stream` channel: chunk deltas
+* accumulate per streaming item and publish throttled updates at the item's
+* reserved (turn, step) — the member live node renders them as-is — while
+* the item's durable content lands as ONE atomic step/start→…→step/end
+* triple at that step, written by the completing wire line's fold or at
+* settle. Durable steps stay dense and strictly sequential (the released-log
+* reader validates exactly that on every cold open); snapshots never hold a
+* step open across appends.
 *
 * Lifecycle mirrors the dsh/codex live drivers' discipline: lazy spawn with an
 * initialize handshake (loadSession capability required — crash recovery is
@@ -2719,6 +3269,8 @@ var KimiAcpLiveDriver = class {
 			this.ctx.logger.warn(`local-agent-kimi: pinning default_model for the resident runtime failed: ${thrown$1(error).message}`);
 			return false;
 		});
+		const endpoint = this.config.endpoint === void 0 ? void 0 : await this.config.endpoint(spec.homeDir).catch(() => void 0);
+		await ensureKimiEndpointProvider(spec.homeDir, hasEndpointCredential(endpoint) ? endpoint.baseUrl ?? "https://api.kimi.com/coding/v1" : void 0).catch(() => false);
 		const spawnSpec = {
 			argv: [
 				"kimi",
@@ -2732,7 +3284,10 @@ var KimiAcpLiveDriver = class {
 				stderr: "pipe"
 			},
 			graceMs: DEFAULT_DISPOSE_GRACE_MS,
-			env: delegationEnv({ KIMI_CODE_HOME: spec.homeDir })
+			env: delegationEnv({
+				KIMI_CODE_HOME: spec.homeDir,
+				...endpointAuthEnv(endpoint)
+			})
 		};
 		let child;
 		try {
@@ -2800,11 +3355,8 @@ var KimiAcpLiveDriver = class {
 	* never exits: the match runs against the settled error instead). Degrades
 	* silently on a core predating reportAuthFailure.
 	*/
-	reportAuthIfShaped(error, homeDir) {
+	reportAuthIfShaped(error) {
 		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);
 	}
@@ -2928,25 +3480,17 @@ var KimiAcpLiveDriver = class {
 		/** 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.
+		* The step ledger: the steps in-flight reservations currently hold this
+		* round. A reservation's durable content lands at the fold that consumes
+		* it (possibly carrying several reservations' kinds in one message — the
+		* wire step's fold), which RELEASES the other consumed coordinates for
+		* later folds; only a reservation kimi never completes (a plan stream, an
+		* unwired tool notification) stays held until its settle-time finalize.
+		* The file fold skips held 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;
@@ -2974,7 +3518,23 @@ var KimiAcpLiveDriver = class {
 		};
 		/** A stream's synthetic key: kimi's ACP deltas carry no item id, so kind + turn pairs them. */
 		let generation = 0;
+		/**
+		* One step reservation per generation, shared by the think and text
+		* streams of the same response segment: the host's own live shape is
+		* reasoning + text on ONE step, and a per-kind step would leave the
+		* consumed reservation's stream frames pointing at a step that never
+		* materializes (an empty trailing step breaks the host's answer
+		* detection, folding the reply into the collapsed process block).
+		*/
+		const generationSteps = /* @__PURE__ */ new Map();
 		const seenToolCalls = /* @__PURE__ */ new Set();
+		/**
+		* ACP tool_call notifications' chronological reservations (call id →
+		* step, plus the notification's display title). No durable event lands at
+		* notification time: the native lifecycle (advertisement, call, result in
+		* one closed step) is written by the wire line's fold, or at settle with
+		* an interrupted placeholder when kimi never logged the call.
+		*/
 		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. */
@@ -2992,7 +3552,7 @@ var KimiAcpLiveDriver = class {
 			const stream = streams.get(key);
 			if (stream !== void 0) {
 				stream.text += text;
-				appendStreamSnapshot(stream, false, false);
+				publishStreamSnapshot(stream, false);
 			}
 			localAgent?.reportRunProgress(childSession.id, {
 				kind: "delta",
@@ -3018,135 +3578,283 @@ var KimiAcpLiveDriver = class {
 			const stream = streams.get(planKey);
 			if (stream !== void 0 && stream.text !== plan) {
 				stream.text = plan;
-				appendStreamSnapshot(stream, true, false);
+				publishStreamSnapshot(stream, true);
 			}
 		};
 		/**
-		* 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.
+		* The live-output channel. Snapshots are browser-only previews (never
+		* `local-agent/stream` log events) — durable step content lands once per
+		* stream, at finalization, as the fold's atomic triple.
 		*/
 		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;
+		/**
+		* Publish one snapshot of a streaming item at its reserved (turn, step)
+		* through the live channel. Batched per stream on a bounded deadline
+		* unless `force`. Never writes durable content.
+		*/
+		const publishStreamSnapshot = (stream, force) => {
+			if (stream.text.trim() === "" || stream.sealed === true) 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));
+				liveFlush.schedule(stream.step, () => publishStreamSnapshot(stream, true));
 				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?.preview(stream.step, stream.kind, stream.text, {
+				receivedAt,
+				itemId: stream.kind
+			});
+			stream.lastSnapshotLen = stream.text.length;
+		};
+		/**
+		* Write the stream's durable content as ONE atomic
+		* step/start→assistant/message→step/end triple at its reserved step and
+		* seal the reservation (its completing wire line, when one exists, pairs
+		* and drops). `interrupted` marks a non-completed round's partial (a
+		* cancelled turn reads 已停止 legitimately); `withUsage` attaches the
+		* round's uncarried usage.
+		*/
+		/**
+		* Write the durable content of every stream sharing one step as ONE atomic
+		* step/start→assistant/message→step/end triple (a generation's think and
+		* text merge into a single message — the host's own shape) and seal the
+		* reservations. `interrupted` marks a non-completed round's partial (a
+		* cancelled turn reads 已停止 legitimately); `withUsage` attaches the
+		* round's uncarried usage.
+		*/
+		const finalizeStep = (step, entries, interrupted, withUsage) => {
+			liveFlush.cancel(step);
+			pendingStreamArrival.delete(step);
+			const reasoning = entries.filter(([, stream]) => stream.kind === "think").map(([, stream]) => stream.text).join("");
+			const text = entries.filter(([, stream]) => stream.kind === "text").map(([, stream]) => stream.text).join("");
+			const blocks = [];
+			if (reasoning.trim() !== "") blocks.push({
+				type: "reasoning",
+				text: reasoning
+			});
+			if (text.trim() !== "") blocks.push({
+				type: "text",
+				text
+			});
+			if (blocks.length === 0) {
+				streamPublisher?.finish(step);
+				const keys = new Set(entries.map(([key]) => key));
+				if (!new Set([...streams.entries()].filter(([key, stream]) => !keys.has(key) && stream.sealed !== true).map(([, stream]) => stream.step)).has(step)) {
+					const index = reservedSteps.indexOf(step);
+					if (index >= 0) reservedSteps.splice(index, 1);
+				}
+				for (const [key, stream] of entries) {
+					stream.sealed = true;
+					generationSteps.delete(stream.generation);
+					if (activeStream === key) activeStream = void 0;
 				}
-				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;
-			}
+			const durable = nextWrittenKimiStep(childSession, turn);
+			childSession.append("step/start", {
+				turn,
+				step: durable
+			});
 			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),
+				step: durable,
+				message: assistantEvent(blocks, 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;
+			streamPublisher?.finish(step);
+			childSession.append("step/end", {
+				turn,
+				step: durable
+			});
+			for (const [key, stream] of entries) {
+				stream.sealed = true;
+				generationSteps.delete(stream.generation);
+				if (activeStream === key) activeStream = void 0;
+			}
 			persist();
 		};
 		/**
+		* Write the durable step for an ACP tool call kimi never logged to the
+		* wire (a crash between the notification and the wire flush): the
+		* notification's title stands in for the name and the result is the
+		* shared interrupted placeholder — the native lifecycle in one step.
+		*/
+		/** Whether this turn's log already carries the tool call (folded from the wire). */
+		const toolLogged = (id) => childSession.snapshotEvents().some((event) => event.type === "tool/call" && event.data.turn === turn && event.data.callId === id);
+		const finalizeOrphanTool = (id, entry) => {
+			const name = entry.title ?? "tool";
+			const step = nextWrittenKimiStep(childSession, turn);
+			childSession.append("step/start", {
+				turn,
+				step
+			});
+			childSession.append("assistant/message", {
+				turn,
+				step,
+				message: assistantEvent([{
+					type: "tool-call",
+					id,
+					name,
+					arguments: ""
+				}], runtime?.modelConfiguration?.currentModel ?? roundModel),
+				stream: []
+			}, { surfaceOp: "append" });
+			const call = childSession.append("tool/call", {
+				turn,
+				step,
+				callId: id,
+				name,
+				arguments: ""
+			});
+			childSession.append("tool/result", {
+				turn,
+				step,
+				message: createToolResultMessage({
+					callId: id,
+					content: [{
+						type: "text",
+						text: KIMI_INTERRUPTED_TOOL_RESULT
+					}],
+					isError: true
+				})
+			}, {
+				surfaceOp: "append",
+				sourceEventSeqs: [call.seq]
+			});
+			childSession.append("step/end", {
+				turn,
+				step
+			});
+		};
+		/**
+		* The fold's gap fill: a fold about to write at `step` first finalizes
+		* every live stream reserved below it (ascending), so the stored log's
+		* steps land dense and strictly sequential. Only streams can sit in the
+		* gap: an unresulted tool line holds its fold instead (session-mirror).
+		*/
+		const finalizeBefore = (targetTurn, step) => {
+			if (targetTurn !== turn) return;
+			const pending = [...streams.entries()].filter(([, stream]) => stream.sealed !== true && stream.step < step).sort((a, b) => a[1].step - b[1].step);
+			const byStep = /* @__PURE__ */ new Map();
+			for (const entry of pending) {
+				const group = byStep.get(entry[1].step) ?? [];
+				group.push(entry);
+				byStep.set(entry[1].step, group);
+			}
+			for (const [at, entries] of byStep) finalizeStep(at, entries, false, false);
+		};
+		/**
 		* 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.
+		* synchronously) and every earlier reservation. A kind switch publishes
+		* one freshness snapshot of the current stream (skipped when its text has
+		* not grown since the last one); its durable triple still lands at its
+		* own reserved step when the wire line folds or the round settles.
 		*/
 		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);
+				if (previous !== void 0 && previous.text.length !== previous.lastSnapshotLen) publishStreamSnapshot(previous, true);
 				activeStream = void 0;
 			}
 			let stream = streams.get(key);
+			if (stream?.sealed === true) {
+				streams.delete(key);
+				stream = void 0;
+			}
 			if (stream === void 0) {
-				let step = nextKimiSessionStep(childSession, turn);
-				for (const reserved of reservedSteps) step = Math.max(step, reserved + 1);
-				reservedSteps.push(step);
+				let step = key === planKey ? void 0 : generationSteps.get(generation);
+				if (step === void 0) {
+					step = nextKimiSessionStep(childSession, turn);
+					while (reservedSteps.includes(step)) step += 1;
+					reservedSteps.push(step);
+					if (key !== planKey) generationSteps.set(generation, step);
+				}
 				stream = {
 					kind,
 					step,
+					generation: key === planKey ? -1 : generation,
 					text: "",
-					lastSnapshotAt: 0,
-					lastSnapshotLen: 0,
-					opened: false
+					lastSnapshotLen: 0
 				};
 				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.
+		* The fold-pass coordination surface: the file
+		* fold skips reserved steps for sequential folds, pairs one fold with the
+		* round's in-flight streams of the fold's kinds (consuming both — a wire
+		* step's think and text ride ONE durable step), and closes every
+		* reservation below each fold step first (finalizeBefore) — 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;
+			finalizeBefore,
+			releaseTool: (line) => {
+				if (line.turn !== turn) return;
+				const entry = toolSteps.get(line.id);
+				if (entry === void 0) return;
 				toolSteps.delete(line.id);
-				return {
-					step,
-					opened: true
-				};
+				const index = reservedSteps.indexOf(entry.step);
+				if (index >= 0) reservedSteps.splice(index, 1);
 			},
-			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;
+			completeStreams: (t, kinds) => {
+				if (t !== turn) return void 0;
+				const picked = [];
+				for (const kind of kinds) {
+					const entry = [...streams.entries()].find(([key, stream]) => key !== planKey && stream.kind === kind);
+					if (entry !== void 0) picked.push(entry);
+				}
+				if (picked.length === 0) return void 0;
+				const sealed = [];
+				for (const [key, stream] of picked) {
+					streams.delete(key);
+					generationSteps.delete(stream.generation);
+					if (activeStream === key) activeStream = void 0;
+					if (stream.sealed === true) {
+						sealed.push(stream.kind);
+						continue;
+					}
+					liveFlush.cancel(stream.step);
+				}
+				const open = picked.filter(([, stream]) => stream.sealed !== true);
+				if (open.length === 0) return { sealed };
+				const held = new Set([...streams.values()].filter((stream) => stream.sealed !== true).map((stream) => stream.step));
+				for (const [, stream] of open) {
+					if (held.has(stream.step)) continue;
+					const index = reservedSteps.indexOf(stream.step);
+					if (index >= 0) reservedSteps.splice(index, 1);
+				}
+				for (const step of new Set(open.map(([, stream]) => stream.step))) streamPublisher?.finish(step);
+				const written = /* @__PURE__ */ new Set();
+				for (const event of childSession.snapshotEvents()) {
+					const data = event.data;
+					if (event.type === "step/start" && data.turn === turn && typeof data.step === "number") written.add(data.step);
+				}
+				let free = nextKimiSessionStep(childSession, turn);
+				while (reservedSteps.includes(free)) free += 1;
+				const candidates = [...new Set(open.map(([, stream]) => stream.step))].filter((step) => !written.has(step));
 				return {
-					step: stream.step,
-					opened: stream.opened
+					step: Math.min(free, ...candidates),
+					sealed
 				};
 			}
 		};
-		const mirrorOptions = () => ({ streams: mirrorStreams });
+		const mirrorOptions = (settle = false) => ({
+			streams: mirrorStreams,
+			...settle ? { settle: true } : {}
+		});
 		/**
 		* Observation accounting across mirror passes: a pass whose window
 		* attached its usage to a folded message is already carried; anything else
@@ -3155,7 +3863,7 @@ var KimiAcpLiveDriver = class {
 		* the latest.
 		*/
 		const noteMirrorUsage = (delta) => {
-			if (delta.usage !== void 0 && delta.usageAttached !== true) roundUsage = addTokenUsage(roundUsage, delta.usage);
+			if (delta.usageUnattached !== void 0) roundUsage = addTokenUsage(roundUsage, delta.usageUnattached);
 			if (delta.model !== void 0) roundModel = delta.model;
 		};
 		/** Throttled push-triggered mirror pass; the file fold stays the only transcript source. */
@@ -3207,23 +3915,22 @@ var KimiAcpLiveDriver = class {
 					const stream = streams.get(key);
 					if (stream !== void 0) {
 						stream.text += text;
-						appendStreamSnapshot(stream, false, false);
+						publishStreamSnapshot(stream, 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) {
+					if (id !== void 0 && toolLogged(id)) seenToolCalls.add(id);
+					else if (id !== void 0) {
 						seenToolCalls.add(id);
 						let step = nextKimiSessionStep(childSession, turn);
-						for (const reserved of reservedSteps) step = Math.max(step, reserved + 1);
+						while (reservedSteps.includes(step)) step += 1;
 						reservedSteps.push(step);
-						toolSteps.set(id, step);
-						childSession.append("step/start", {
-							turn,
-							step
+						toolSteps.set(id, {
+							step,
+							...typeof update["title"] === "string" ? { title: update["title"] } : {}
 						});
-						persist();
 					}
 					generation++;
 				}
@@ -3293,7 +4000,7 @@ var KimiAcpLiveDriver = class {
 			let stableReads = 0;
 			const deadline = Date.now() + SETTLE_MIRROR_QUIESCE_MS;
 			for (;;) {
-				const delta = await mirrorKimiDelta(this.ctx, childSession, spec.homeDir, sessionId, mirrorOptions());
+				const delta = await mirrorKimiDelta(this.ctx, childSession, spec.homeDir, sessionId, mirrorOptions(true));
 				noteMirrorUsage(delta);
 				localAgent?.reportRunProgress(childSession.id, {
 					kind: "mirror",
@@ -3314,7 +4021,7 @@ var KimiAcpLiveDriver = class {
 				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);
+				this.reportAuthIfShaped(error);
 			},
 			signal: request.signal,
 			onAbort
@@ -3328,25 +4035,28 @@ var KimiAcpLiveDriver = class {
 				} 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
+				const pending = [...[...[...streams.entries()].filter(([, stream]) => stream.sealed !== true).reduce((byStep, entry) => {
+					const group = byStep.get(entry[1].step) ?? [];
+					group.push(entry);
+					byStep.set(entry[1].step, group);
+					return byStep;
+				}, /* @__PURE__ */ new Map()).entries()].map(([step, entries]) => ({
+					step,
+					entries
+				})), ...[...toolSteps.entries()].map(([toolId, tool]) => ({
+					step: tool.step,
+					toolId,
+					tool
+				}))].sort((a, b) => a.step - b.step);
+				const lastStream = pending.map((entry, index) => "entries" in entry ? index : -1).filter((index) => index >= 0).at(-1);
+				pending.forEach((entry, index) => {
+					if ("entries" in entry) finalizeStep(entry.step, entry.entries, settled.stopReason !== "completed", index === lastStream);
+					else if (!toolLogged(entry.toolId)) finalizeOrphanTool(entry.toolId, entry.tool);
 				});
+				streams.clear();
 				toolSteps.clear();
+				activeStream = void 0;
+				if (pending.length > 0) persist();
 				if (settled.stopReason === "completed") childSession.append("turn/end", {
 					turn,
 					reason: { kind: "completed" }
@@ -3386,7 +4096,7 @@ var KimiAcpLiveDriver = class {
 		});
 		await Promise.race([accepted, abortBranch.catch(() => void 0)]);
 		return subprocessRunHandle({
-			id: childSession.id,
+			id: SessionId(randomUUID()),
 			result,
 			signal: request.signal,
 			onAbort,
@@ -3551,6 +4261,7 @@ var KimiCliProvider = class {
 	live;
 	model;
 	memberModels;
+	endpoint;
 	name = "kimi-cli";
 	capabilities = NO_START_CAPABILITIES;
 	inheritsParentContext = false;
@@ -3561,19 +4272,33 @@ var KimiCliProvider = class {
 	*   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.
+	*   reload; it receives the round's scope (a named scope's curated list
+	*   answers first). 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) {
+	constructor(ctx, live, model, memberModels, endpoint) {
 		this.ctx = ctx;
 		this.live = live;
 		this.model = model;
 		this.memberModels = memberModels;
+		this.endpoint = endpoint;
+	}
+	/**
+	* Resolve the scope's endpoint for this round and land its baseUrl on the
+	* managed provider (the surgery writes only on drift), so a hand-edited
+	* endpoint-auth.json applies without a restart.
+	*/
+	async prepareEndpoint(homeDir) {
+		if (this.endpoint === void 0) return void 0;
+		const endpoint = await this.endpoint(homeDir).catch(() => void 0);
+		await ensureKimiEndpointProvider(homeDir, hasEndpointCredential(endpoint) ? endpoint.baseUrl ?? "https://api.kimi.com/coding/v1" : void 0).catch(() => false);
+		return endpoint;
 	}
 	/** Resolve the live driver for one round's member, if live is on for it. */
 	liveDriver(childSessionId) {
@@ -3646,7 +4371,7 @@ var KimiCliProvider = class {
 				...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());
+		const childSessionId = SessionId(intent?.preparedMemberId ?? intent?.childSessionId ?? 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);
@@ -3675,16 +4400,19 @@ var KimiCliProvider = class {
 				delegationDepth: (request.parent.session.header.delegationDepth ?? 0) + 1
 			} });
 			const harness = this.ctx.localAgent.get("kimi");
-			const label = subagentDelegationLabel(harness?.displayName ?? "kimi", request.descriptor.label);
+			const label = subagentDelegationLabel(harness?.displayName ?? "kimi", request.label || void 0);
 			childSession.append("subagent/descriptor", {
-				...request.descriptor,
+				version: SUBAGENT_DESCRIPTOR_VERSION,
+				mode: "one-shot",
+				provider: this.name,
 				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);
+		const endpoint = await this.prepareEndpoint(homeDir);
+		const baseUrl = hasEndpointCredential(endpoint) ? endpoint.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) {
@@ -3717,10 +4445,13 @@ var KimiCliProvider = class {
 		try {
 			const run = await startKimiCliRun(request, {
 				cwd,
-				env: delegationEnv({ KIMI_CODE_HOME: homeDir }),
+				env: delegationEnv({
+					KIMI_CODE_HOME: homeDir,
+					...endpointAuthEnv(endpoint)
+				}),
 				...exec === void 0 ? {} : { exec },
 				endpointLabel: baseUrl,
-				...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(runId) ?? requestedModel, this.model),
+				...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(runId) ?? requestedModel, () => this.model?.(scope)),
 				...configuration === void 0 ? {} : { controlled: true },
 				disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
 				spawn: (spec) => this.ctx.subprocess.spawn(spec),
@@ -3728,9 +4459,6 @@ var KimiCliProvider = class {
 					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: () => {
@@ -3797,16 +4525,20 @@ var KimiCliProvider = class {
 				}
 			}
 			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);
+			const endpoint = await this.prepareEndpoint(homeDir);
+			const baseUrl = hasEndpointCredential(endpoint) ? endpoint.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 }),
+					env: delegationEnv({
+						KIMI_CODE_HOME: homeDir,
+						...endpointAuthEnv(endpoint)
+					}),
 					...exec === void 0 ? {} : { exec },
 					endpointLabel: baseUrl,
-					...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(intent.childSessionId) ?? requestedModel, this.model),
+					...configuration?.resolved ?? resolveRoundModel(this.memberModels?.overrideFor(intent.childSessionId) ?? requestedModel, () => this.model?.(scope)),
 					...configuration === void 0 ? {} : { controlled: true },
 					disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
 					spawn: (spec) => this.ctx.subprocess.spawn(spec),
@@ -3814,9 +4546,6 @@ var KimiCliProvider = class {
 						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: () => {
@@ -3926,7 +4655,10 @@ async function mirrorKimiAfterExit(spec, stderr) {
 	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 });
+		const delta = await mirrorKimiDelta(spec.ctx, spec.childSession, spec.homeDir, kimiSessionId, {
+			turn: spec.resume?.turn ?? 1,
+			settle: true
+		});
 		spec.ctx.get("localAgent")?.reportRunProgress(spec.childSession.id, {
 			kind: "mirror",
 			mirroredLines: delta.total
@@ -4092,29 +4824,6 @@ async function startKimiCliRun(request, spec) {
 		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(() => {
@@ -4123,19 +4832,46 @@ async function startKimiCliRun(request, spec) {
 			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 settled = await result;
+			const mirrored = await mirrorKimiAfterExit(spec, stderr);
+			addRoundUsage(mirrored?.usage);
+			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"
+						}
+					}
+				});
+				if (spec.ctx !== void 0) await persistChildSession(spec.ctx, spec.childSession).catch((error) => {
+					spec.ctx?.logger.warn(`subagent-kimi: turn/end persistence failed: ${thrown(error).message}`);
+				});
+			}
 			const cliVersion = await spec.cliVersion?.();
 			spec.onRoundSettled?.({
-				...settled?.model === void 0 ? {} : { observedModel: settled.model },
+				...mirrored?.model === void 0 ? {} : { observedModel: mirrored.model },
 				...cliVersion === void 0 ? {} : { cliVersion },
 				...roundUsage === void 0 ? {} : { usage: roundUsage },
-				...settled?.toolCalls === void 0 ? {} : { toolCalls: settled.toolCalls }
+				...mirrored?.toolCalls === void 0 ? {} : { toolCalls: mirrored.toolCalls }
 			});
 		});
 	}, () => {});
 	return Promise.resolve(subprocessRunHandle({
-		id: spec.childSession?.id ?? SessionId(randomUUID()),
+		id: SessionId(randomUUID()),
 		result,
 		signal: request.signal,
 		onAbort,
@@ -4161,15 +4897,17 @@ var LiveDriverSwitch = class {
 	ctx;
 	liveIdleMs;
 	model;
+	endpoint;
 	liveOn = false;
 	active;
 	/** Retiring generations still draining their in-flight rounds. */
 	draining = /* @__PURE__ */ new Set();
 	unwatch;
-	constructor(ctx, face, liveIdleMs, model) {
+	constructor(ctx, face, liveIdleMs, model, endpoint) {
 		this.ctx = ctx;
 		this.liveIdleMs = liveIdleMs;
 		this.model = model;
+		this.endpoint = endpoint;
 		this.apply(face.get());
 		this.unwatch = face.watch((next) => {
 			this.apply(next);
@@ -4193,7 +4931,8 @@ var LiveDriverSwitch = class {
 		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 }
+			...this.model === void 0 ? {} : { model: this.model },
+			...this.endpoint === void 0 ? {} : { endpoint: this.endpoint }
 		}) : void 0;
 		if (retiring !== void 0) {
 			this.draining.add(retiring);
@@ -4280,6 +5019,47 @@ function dedupe(candidates) {
 	return out;
 }
 /**
+* Scope the served directory to the surface asking for it (the same helper
+* lives in each provider's broker — fold into the family core when the
+* directory faces next evolve):
+*
+* - memberless (the card's add-model dialog, the invite picker): the
+*   endpoint's served catalog only — the configuration/history extras the
+*   broker's info extension adds for STATUS display (a config-defined model
+*   the endpoint does not serve) must never become add candidates;
+* - a member whose harness has a curated list: the list IS the vocabulary,
+*   in the list's own order (the same rule `choices` already follows) — a
+*   curated value the endpoint no longer serves stays as a bare row (the
+*   card shows it the same way), and the member's current effective model is
+*   kept visible as a bare entry when it sits outside the list, so a pre-list
+*   binding never renders blank;
+* - a member without a curated list: the legacy extended vocabulary.
+*/
+function scopeServedDirectory(directory, opts) {
+	if (opts.member && opts.curated.length === 0) return directory;
+	const served = directory.entries.filter((entry) => entry.source === "native");
+	if (!opts.member) return {
+		...directory,
+		entries: served
+	};
+	const byValue = new Map(served.flatMap((entry) => entry.resolvedModel === void 0 ? [[entry.value, entry]] : [[entry.value, entry], [entry.resolvedModel, entry]]));
+	const entries = opts.curated.map((value) => byValue.get(value) ?? {
+		value,
+		label: value,
+		source: "configuration"
+	});
+	const current = opts.current?.trim();
+	if (current !== void 0 && current !== "" && !entries.some((entry) => entry.value === current || entry.resolvedModel === current)) entries.push({
+		value: current,
+		label: current,
+		source: "configuration"
+	});
+	return {
+		...directory,
+		entries
+	};
+}
+/**
 * 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
@@ -4306,7 +5086,7 @@ var KimiModelBroker = class {
 	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 model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel(home) ?? 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;
@@ -4344,14 +5124,19 @@ var KimiModelBroker = class {
 	}
 	async modelDirectory(childSessionId, refresh = false) {
 		if (refresh) await this.deps.catalog?.refresh(childSessionId);
-		return (await this.modelInfo(childSessionId)).directory ?? {
+		const info = await this.modelInfo(childSessionId);
+		return scopeServedDirectory(info.directory ?? {
 			entries: [],
 			complete: false,
 			customInput: true,
 			status: "unsupported",
 			refreshing: false,
 			revision: 0
-		};
+		}, {
+			member: childSessionId !== void 0,
+			curated: this.deps.modelList?.(this.deps.homeDir(childSessionId)) ?? [],
+			current: info.effective
+		});
 	}
 	async *followModelDirectory(childSessionId, signal) {
 		if (this.deps.catalog === void 0) {
@@ -4383,7 +5168,7 @@ var KimiModelBroker = class {
 	* 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();
+	spawnModel = (childSessionId) => this.overrideFor(childSessionId) ?? this.startModels.get(childSessionId) ?? this.deps.settingsModel(this.deps.homeDir(childSessionId));
 	/**
 	* 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
@@ -4392,11 +5177,12 @@ var KimiModelBroker = class {
 	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 settings = this.deps.settingsModel(homeDir);
 		const native = this.deps.catalog?.read(childSessionId);
 		const [cliDefault, discovered] = await Promise.all([readKimiDefaultModel(homeDir).catch(() => void 0), listKimiConfigModels(homeDir).catch(() => [])]);
-		const choices = dedupe([
+		const curated = this.deps.modelList?.(homeDir) ?? [];
+		const choices = curated.length > 0 ? [...curated] : dedupe([
 			settings,
 			cliDefault,
 			...discovered,
@@ -4417,7 +5203,7 @@ var KimiModelBroker = class {
 				settings,
 				cliDefault,
 				...discovered
-			], this.deps.recentModels()) },
+			], curated.length > 0 ? [] : this.deps.recentModels()) },
 			live: this.deps.isLive(),
 			switchable: !inFlight,
 			...inFlight ? { reason: SWITCH_IN_FLIGHT_REASON } : {}
@@ -4454,42 +5240,6 @@ var KimiModelBroker = class {
 * `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
@@ -4563,8 +5313,10 @@ async function removeLegacyVariants(ctx) {
 /**
 * 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
+* root (`KIMI_CODE_HOME`), endpoint-key authentication (endpoint-auth.ts —
+* the managed provider reads the key from the `api_key_env` environment
+* indirection; no OAuth anywhere), 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.
@@ -4608,6 +5360,8 @@ const Config = z.object({
 		z.const("high"),
 		z.const("max")
 	]),
+	baseUrl: z.string(),
+	apiKey: z.string(),
 	live: volatilize(SETTINGS_FIELDS.live),
 	liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
 	liveMirrorGranularity: volatilize(SETTINGS_FIELDS.liveMirrorGranularity),
@@ -4669,10 +5423,15 @@ function apply(ctx, config) {
 	ctx.effect(() => {
 		const homeDir = ctx.localAgent.homeDir("kimi");
 		const thinkingEffort = config.thinkingEffort ?? "high";
+		const endpointConfig = {
+			...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl },
+			...config.apiKey === void 0 ? {} : { apiKey: config.apiKey }
+		};
+		const resolveEndpoint = (scopeHome) => resolveEndpointAuth(scopeHome, endpointConfig);
 		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) => {
+		provisionKimiConfig(homeDir, vol(config.model) ?? "kimi-code/k3", thinkingEffort, config.baseUrl).then(() => ensureKimiPermissions(homeDir)).catch((error) => {
 			ctx.logger.warn(`local-agent-kimi: config provisioning failed: ${error instanceof Error ? error.message : String(error)}`);
 		});
 		const readSettings = () => {
@@ -4700,12 +5459,14 @@ function apply(ctx, config) {
 			legacyBase,
 			read: readSettings
 		});
-		const resolveModel = () => {
+		const resolveModelKey = () => {
 			const model = face.get().model?.trim();
 			return model === void 0 || model === "" ? void 0 : model;
 		};
+		const resolveModelFor = (homeDir) => firstModelOf(readModelListSync(homeDir)) ?? resolveModelKey();
+		const resolveModel = (scope) => resolveModelFor(ctx.localAgent.homeDir("kimi", scope));
 		let broker;
-		const liveSwitch = new LiveDriverSwitch(ctx, face, config.liveIdleMs, (child) => broker.spawnModel(child));
+		const liveSwitch = new LiveDriverSwitch(ctx, face, config.liveIdleMs, (child) => broker.spawnModel(child), resolveEndpoint);
 		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);
@@ -4714,16 +5475,20 @@ function apply(ctx, config) {
 				...record?.cwd === void 0 ? {} : { cwd: record.cwd },
 				...native === void 0 ? {} : { native }
 			};
+		}, {
+			endpoint: resolveEndpoint,
+			warn: (message) => ctx.logger.warn(message)
 		});
 		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,
+			settingsModel: resolveModelFor,
+			modelList: (homeDir) => readModelListSync(homeDir),
 			recentModels: () => face.get().recentModels ?? [],
 			isLive: () => face.get().live,
 			liveSwitch
 		});
-		const disposeProvider = ctx.subagents.registerProvider(new KimiCliProvider(ctx, liveSwitch.resolve, resolveModel, broker));
+		const disposeProvider = ctx.subagents.registerProvider(new KimiCliProvider(ctx, liveSwitch.resolve, resolveModel, broker, resolveEndpoint));
 		const disposeHarness = ctx.localAgent.register({
 			prepareMember: async ({ binding, childSession, configuration, signal }) => {
 				const driver = liveSwitch.resolve(binding.childSessionId);
@@ -4740,31 +5505,76 @@ function apply(ctx, config) {
 			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 provisionKimiConfig(scopedHome, vol(config.model) ?? "kimi-code/k3", thinkingEffort, config.baseUrl);
 				await ensureKimiPermissions(scopedHome);
 			},
-			isAuthenticated: kimiAuthenticated,
-			credentialStamp: kimiCredentialStamp,
-			logout: kimiLogout,
+			isAuthenticated: async (home) => hasEndpointCredential(await resolveEndpoint(home)),
+			checkEndpoint: (home) => resolveEndpoint(home).then((endpoint) => checkKimiEndpoint(endpoint)),
+			endpointAuth: {
+				read: async (home) => {
+					const endpoint = await resolveEndpoint(home);
+					return {
+						...endpoint.baseUrl === void 0 ? {} : { baseUrl: endpoint.baseUrl },
+						apiKeySet: endpoint.apiKey !== void 0,
+						authTokenSet: false
+					};
+				},
+				write: async (home, fields) => {
+					const next = { ...await readEndpointAuthFile(home) ?? {} };
+					for (const [field, value] of Object.entries(fields)) {
+						if (field !== "baseUrl" && field !== "apiKey") continue;
+						if (value === void 0) continue;
+						const trimmed = typeof value === "string" ? value.trim() : "";
+						if (value === null || trimmed === "") delete next[field];
+						else next[field] = trimmed;
+					}
+					if (Object.keys(next).length === 0) await clearEndpointAuth(home);
+					else await writeEndpointAuth(home, next);
+					const resolved = await resolveEndpoint(home);
+					await ensureKimiEndpointProvider(home, hasEndpointCredential(resolved) ? resolved.baseUrl ?? "https://api.kimi.com/coding/v1" : void 0);
+				}
+			},
+			credentialStamp: endpointAuthStamp,
+			logout: async (home) => {
+				if (await endpointAuthFileExists(home)) {
+					await clearEndpointAuth(home);
+					return;
+				}
+				throw new Error("kimi has no scoped endpoint-auth.json to clear — the credential comes from the settings card or the profile row (baseUrl/apiKey); clear it there instead");
+			},
 			subcommand: handleSubcommand,
 			modelBroker: broker,
+			modelList: {
+				read: (home) => readModelList(home),
+				write: async (home, models) => {
+					const written = await writeModelList(home, models);
+					await ensureKimiModelTables(home, written, (value) => {
+						const entry = modelCatalog.readHome(home).entries.find((candidate) => candidate.value === value);
+						return entry === void 0 ? void 0 : {
+							label: entry.label,
+							...entry.reasoning === void 0 ? {} : {
+								efforts: entry.reasoning.options.map((option) => option.value),
+								...entry.reasoning.default === void 0 ? {} : { defaultEffort: entry.reasoning.default }
+							}
+						};
+					});
+					return written;
+				}
+			},
 			effectiveSettings: async (scopedHome) => {
-				const [reasoningEffort, baseUrl, autoApprove, defaultModel, cliVersion] = await Promise.all([
+				const [reasoningEffort, endpoint, autoApprove, defaultModel, cliVersion] = await Promise.all([
 					readKimiReasoningEffort(scopedHome).catch(() => void 0),
-					readKimiBaseUrl(scopedHome).catch(() => void 0),
+					resolveEndpoint(scopedHome).catch(() => void 0),
 					readKimiAutoApprove(scopedHome).catch(() => false),
 					readKimiDefaultModel(scopedHome).catch(() => void 0),
 					kimiCliVersion(ctx, scopedHome).catch(() => void 0)
 				]);
+				const baseUrl = hasEndpointCredential(endpoint) ? endpoint.baseUrl ?? "https://api.kimi.com/coding/v1" : await readKimiBaseUrl(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;
+				const model = resolveModelFor(scopedHome) ?? defaultModel;
 				return {
 					drive: face.get().live ? "live" : "exec",
 					autoApprove,