@khorsheed/dsh-local-agent-claude-code 0.1.0-rc.6

package/lib/index.js

@@ -0,0 +1,3771 @@
+import z from "@deepseek-ai/schemastery";
+import { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, modelDirectoryContextKey, persistChildSession, probeCliVersion, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol } from "@khorsheed/dsh-local-agent";
+import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV, endpointHost } from "@khorsheed/dsh-local-agent/types";
+import { createHash, randomUUID } from "node:crypto";
+import { createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { NO_START_CAPABILITIES, settleRunResult, subprocessRunHandle } from "@deepseek-ai/dsh-subagent";
+import { dirname, join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { execFile } from "node:child_process";
+import { mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+//#region lib/types/control-requests.js
+/** Bounded, correlated Claude stream-json controls, shared by discovery and live sessions. */
+var ClaudeControlRequests = class {
+	send;
+	timeoutMs;
+	sequence = 0;
+	closed = false;
+	pending = /* @__PURE__ */ new Map();
+	constructor(send, timeoutMs = 5e3) {
+		this.send = send;
+		this.timeoutMs = timeoutMs;
+	}
+	accept(event) {
+		if (event["type"] !== "control_response") return false;
+		const response = event["response"];
+		const id = response?.["request_id"];
+		if (typeof id !== "string") return true;
+		const pending = this.pending.get(id);
+		if (pending === void 0) return true;
+		if (response?.["subtype"] !== "success") pending.reject(new Error(typeof response?.["error"] === "string" ? response["error"] : "Claude rejected the control request"));
+		else {
+			const result = response["response"];
+			pending.resolve(typeof result === "object" && result !== null ? result : {});
+		}
+		return true;
+	}
+	request(request, signal) {
+		if (this.closed || signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Claude control channel is closed"));
+		const id = `dsh-control-${++this.sequence}`;
+		return new Promise((resolve, reject) => {
+			const finish = () => {
+				this.pending.delete(id);
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", abort);
+			};
+			const fail = (error) => {
+				finish();
+				reject(error);
+			};
+			const abort = () => {
+				fail(/* @__PURE__ */ new Error("Claude control request cancelled"));
+			};
+			const timer = setTimeout(() => fail(/* @__PURE__ */ new Error(`Claude ${String(request["subtype"])} control timed out`)), this.timeoutMs);
+			timer.unref();
+			this.pending.set(id, {
+				resolve: (value) => {
+					finish();
+					resolve(value);
+				},
+				reject: fail
+			});
+			signal?.addEventListener("abort", abort, { once: true });
+			try {
+				this.send({
+					type: "control_request",
+					request_id: id,
+					request
+				});
+			} catch (error) {
+				fail(error instanceof Error ? error : /* @__PURE__ */ new Error("Claude control write failed"));
+			}
+		});
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const request of [...this.pending.values()]) request.reject(/* @__PURE__ */ new Error("Claude control channel closed before acknowledgement"));
+	}
+};
+//#endregion
+//#region lib/types/model-catalog.js
+/** Initialize's native picker vocabulary, not an account entitlement claim. */
+function claudeDirectory(result) {
+	const models = result["models"];
+	if (models === void 0) return {
+		entries: [],
+		complete: false,
+		customInput: true,
+		unsupported: true,
+		reason: "This Claude CLI does not expose a native model directory"
+	};
+	if (!Array.isArray(models)) throw new Error("Claude initialize returned an invalid model directory");
+	const entries = /* @__PURE__ */ new Map();
+	for (const candidate of models) {
+		if (typeof candidate !== "object" || candidate === null) continue;
+		const model = candidate;
+		const value = typeof model["value"] === "string" ? model["value"].trim() : "";
+		if (value === "" || entries.has(value)) continue;
+		const levels = model["supportedEffortLevels"];
+		const options = Array.isArray(levels) ? levels.flatMap((level) => typeof level === "string" && level !== "" ? [{
+			value: level,
+			label: level
+		}] : []) : void 0;
+		entries.set(value, {
+			value,
+			label: typeof model["displayName"] === "string" ? model["displayName"] : value,
+			source: "native",
+			...typeof model["resolvedModel"] === "string" ? { resolvedModel: model["resolvedModel"] } : {},
+			...typeof model["description"] === "string" ? { description: model["description"] } : {},
+			...options === void 0 ? {} : { reasoning: { options } }
+		});
+	}
+	return {
+		entries: [...entries.values()],
+		complete: true,
+		customInput: true,
+		...entries.has("default") ? { defaultModel: "default" } : {}
+	};
+}
+/** Scoped native control probe. Never syncs credentials, writes settings or submits a user turn. */
+var ClaudeModelCatalog = class {
+	deps;
+	cache;
+	constructor(deps) {
+		this.deps = deps;
+		this.cache = new ModelDirectoryCache({
+			load: (key, signal) => {
+				const context = JSON.parse(key);
+				return this.probe(context.homeDir, context.cwd, signal);
+			},
+			...deps.ttlMs === void 0 ? {} : { ttlMs: deps.ttlMs },
+			onError: (error) => deps.warn?.(`Claude model discovery failed: ${error instanceof Error ? error.message : String(error)}`)
+		});
+	}
+	key(homeDir, cwd = homeDir) {
+		const files = [
+			join(homeDir, "settings.json"),
+			join(homeDir, ".credentials.json"),
+			join(homeDir, ".claude.json")
+		];
+		for (let directory = cwd;; directory = dirname(directory)) {
+			files.push(join(directory, ".claude", "settings.json"), join(directory, ".claude", "settings.local.json"));
+			if (dirname(directory) === directory) break;
+		}
+		return modelDirectoryContextKey({
+			provider: "claude-code",
+			homeDir,
+			cwd,
+			cli: [this.deps.cli ?? "claude"],
+			files,
+			...this.deps.baseUrl === void 0 ? {} : { endpoint: this.deps.baseUrl }
+		});
+	}
+	read(homeDir, cwd) {
+		return this.cache.read(this.key(homeDir, cwd));
+	}
+	refresh(homeDir, cwd) {
+		return this.cache.refresh(this.key(homeDir, cwd));
+	}
+	follow(homeDir, cwd, signal) {
+		return this.cache.follow(() => this.key(homeDir, cwd), signal);
+	}
+	invalidate(homeDir, cwd) {
+		this.cache.invalidate(this.key(homeDir, cwd));
+	}
+	dispose() {
+		this.cache.dispose();
+	}
+	async probe(homeDir, cwd, signal) {
+		const child = this.deps.spawn({
+			argv: [
+				this.deps.cli ?? "claude",
+				"-p",
+				"--verbose",
+				"--input-format",
+				"stream-json",
+				"--output-format",
+				"stream-json",
+				"--no-session-persistence",
+				"--settings",
+				"{\"disableAllHooks\":true}",
+				"--strict-mcp-config",
+				"--mcp-config",
+				"{\"mcpServers\":{}}",
+				"--"
+			],
+			cwd,
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe"
+			},
+			graceMs: 2e3,
+			env: delegationEnv({
+				CLAUDE_CONFIG_DIR: homeDir,
+				...this.deps.baseUrl === void 0 ? {} : { ANTHROPIC_BASE_URL: this.deps.baseUrl }
+			})
+		});
+		const controls = new ClaudeControlRequests((frame) => {
+			if (child.stdin === void 0) throw new Error("Claude discovery stdin is unavailable");
+			child.stdin.write(JSON.stringify(frame) + "\n");
+		}, this.deps.timeoutMs ?? 5e3);
+		const decoder = new StringDecoder("utf8");
+		let buffer = "";
+		child.stdout?.on("data", (chunk) => {
+			buffer += decoder.write(chunk);
+			if (buffer.length > 1048576) {
+				controls.close();
+				child.terminate();
+				return;
+			}
+			let index;
+			while ((index = buffer.indexOf("\n")) >= 0) {
+				const line = buffer.slice(0, index);
+				buffer = buffer.slice(index + 1);
+				let event;
+				try {
+					event = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				if (controls.accept(event)) continue;
+				if (event["type"] === "control_request" && typeof event["request_id"] === "string") child.stdin?.write(JSON.stringify({
+					type: "control_response",
+					response: {
+						subtype: "error",
+						request_id: event["request_id"],
+						error: "Model discovery does not execute tools"
+					}
+				}) + "\n");
+			}
+		});
+		child.stderr?.on("data", () => {});
+		child.done.then(() => controls.close(), () => controls.close());
+		let cleanupTimer;
+		try {
+			return claudeDirectory(await controls.request({
+				subtype: "initialize",
+				hooks: {}
+			}, signal));
+		} finally {
+			controls.close();
+			child.stdin?.end();
+			await Promise.race([child.done.catch(() => {}), new Promise((resolve) => {
+				cleanupTimer = setTimeout(resolve, 1e3);
+				cleanupTimer.unref();
+			})]);
+			if (cleanupTimer !== void 0) clearTimeout(cleanupTimer);
+			child.terminate();
+			await child.waitForExit().catch(() => {});
+		}
+	}
+};
+//#endregion
+//#region lib/types/records.js
+/**
+* Claude Code session records adapter: scans the scoped home's `projects/`
+* session files (one JSONL per session under `projects/<cwd-slug>/`, the
+* slug being the workspace path with separators replaced by dashes), plus
+* the transcript model read-back ({@link readClaudeTranscriptModel}) the
+* model broker's `lastObserved` backstop runs on. The
+* slug is a LOSSY encoding of the cwd — different paths can collide on the
+* same slug — so the listed cwd always comes from the file CONTENT (the
+* first `user` event's `cwd` field), never from the directory name. Only the
+* head of each file is read — the first user event carries the id, cwd, and
+* timestamp the listing needs; the rest of the file (conversation) is not
+* parsed. Files are append-only with torn-tail tolerance, and contents are
+* always untrusted input.
+* @module @khorsheed/dsh-local-agent-claude-code/records
+*/
+/** Session files live under this directory inside the scoped home. */
+const PROJECTS_ROOT = "projects";
+/** Bound on the head prefix read from one session file. */
+const HEAD_BYTES = 65536;
+/**
+* Bound on the tail read when extracting a transcript's model. Assistant
+* lines are frequent, so the last window almost always names one; a bigger
+* conversation is never read whole.
+*/
+const TRANSCRIPT_TAIL_BYTES = 262144;
+/** Cap on project directories the transcript reads scan. */
+const TRANSCRIPT_SCAN_DIRS = 200;
+/** Cap on transcript files the harness-level newest-scan stats. */
+const TRANSCRIPT_SCAN_FILES = 500;
+/** Cap on sidechain (`agent-*.jsonl`) candidates inspected for one session id. */
+const TRANSCRIPT_SIDECHAIN_FILES = 100;
+/** How many newest transcripts the harness-level read tries before giving up. */
+const TRANSCRIPT_NEWEST_TRIES = 3;
+/** Test-swappable process exec (the keychain read goes through `security`). */
+const internals = { exec: promisify(execFile) };
+/**
+* The scoped `.claude.json`'s modification stamp (epoch ms), undefined when
+* absent. A completed login rewrites this file, so the stamp distinguishes a
+* fresh login from a leftover marker (a revoked token's record lingers).
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the marker's mtime, or undefined when no scoped config exists.
+*/
+async function claudeCredentialStamp(homeDir) {
+	try {
+		return (await stat(join(homeDir, ".claude.json"))).mtimeMs;
+	} catch {
+		return;
+	}
+}
+/**
+* The keychain entry name current claude uses for a non-default config dir:
+* the bare name belongs to `~/.claude`, other dirs get a path-hash suffix.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the macOS keychain service name holding the OAuth credential.
+*/
+function keychainService(homeDir) {
+	return `Claude Code-credentials-${createHash("sha256").update(homeDir).digest("hex").slice(0, 8)}`;
+}
+/**
+* Whether a credential blob is USABLE: the token record nests under
+* `claudeAiOauth`, and a blob whose access AND refresh tokens are both empty
+* is a shell. macOS keeps historical items under the same service (an early
+* claude wrote an `acct=unknown` placeholder with blank tokens and
+* `expiresAt: 0`), and mirroring one into the credentials file makes every
+* delegation report "OAuth session expired and could not be refreshed" —
+* indistinguishable from a real expiry while login looks successful. A
+* non-empty token is the bar for mirroring a blob or keeping a file.
+* @param text - the raw credential JSON.
+* @returns true when the blob carries a non-empty token.
+*/
+function credentialUsable(text) {
+	try {
+		const oauth = JSON.parse(text).claudeAiOauth;
+		return typeof oauth?.accessToken === "string" && oauth.accessToken !== "" || typeof oauth?.refreshToken === "string" && oauth.refreshToken !== "";
+	} catch {
+		return false;
+	}
+}
+/**
+* A `security dump-keychain` timedate as epoch ms; undefined when the shape is
+* not recognized (the item then sorts as oldest).
+*
+* The shape that matters is the COMPACT Zulu stamp `20260916040855Z`, because
+* that is what the tool actually prints — with the attribute's trailing NUL
+* rendered as a literal `\000` after the closing digit, so the match must not
+* anchor at the end. Only the spaced `2026-09-01 02:03:04 +0000` form was
+* parsed before, which no `security` build was observed to emit: every item
+* fell to the `?? 0` default, the newest-first sort over all-equal keys
+* degenerated to the dump's own order (a stable sort), and
+* `readKeychainCredential` returned whichever usable item the dump happened to
+* list first. A scoped home that had been logged in twice then kept serving the
+* SUPERSEDED credential — the fresh login sat unread in the keychain while the
+* runtime ran on a generation whose refresh token was already spent. The
+* spaced form is still accepted in case some build does emit it.
+* @param text - the quoted timedate string from the dump.
+* @returns the epoch milliseconds, or undefined.
+*/
+function keychainTimestamp(text) {
+	const trimmed = text.trim();
+	const compact = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z/.exec(trimmed);
+	if (compact !== null) {
+		const at = (index) => Number(compact[index]);
+		const ms = Date.UTC(at(1), at(2) - 1, at(3), at(4), at(5), at(6));
+		return Number.isFinite(ms) ? ms : void 0;
+	}
+	const spaced = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$/.exec(trimmed);
+	if (spaced === null) return void 0;
+	const part = (index) => Number(spaced[index]);
+	const offsetMinutes = (part(8) * 60 + part(9)) * (spaced[7] === "+" ? 1 : -1);
+	const ms = Date.UTC(part(1), part(2) - 1, part(3), part(4), part(5), part(6)) - offsetMinutes * 6e4;
+	return Number.isFinite(ms) ? ms : void 0;
+}
+/**
+* Every account holding an item under the service, newest write first. macOS
+* allows SEVERAL items per service, and an unscoped `find-generic-password
+* -w` returns the FIRST match — which can be a historical empty shell (see
+* `credentialUsable`) — so the sync enumerates instead of trusting the first
+* hit. The dump prints metadata only (no secrets); a failing dump or a parse
+* miss yields an empty list, and the caller then falls back to the unscoped
+* read.
+* @param service - the keychain service name.
+* @returns the accounts, newest modification first.
+*/
+async function keychainItems(service) {
+	let stdout;
+	try {
+		({stdout} = await internals.exec("security", ["dump-keychain"]));
+	} catch {
+		return [];
+	}
+	const items = [];
+	let svce;
+	let acct;
+	let mdat = 0;
+	const flush = () => {
+		if (svce === service && acct !== void 0) items.push({
+			acct,
+			mdat
+		});
+		svce = void 0;
+		acct = void 0;
+		mdat = 0;
+	};
+	for (const line of stdout.split("\n")) {
+		if (line.startsWith("keychain:")) {
+			flush();
+			continue;
+		}
+		const trimmed = line.trim();
+		const svceMatch = /^"svce"<blob>="(.*)"$/.exec(trimmed);
+		if (svceMatch !== null) {
+			svce = svceMatch[1];
+			continue;
+		}
+		const acctMatch = /^"acct"<blob>="(.*)"$/.exec(trimmed);
+		if (acctMatch !== null) {
+			acct = acctMatch[1];
+			continue;
+		}
+		const mdatMatch = /^"mdat"<timedate>=0x[0-9a-fA-F]+\s+"(.*)"$/.exec(trimmed);
+		if (mdatMatch !== null) mdat = keychainTimestamp(mdatMatch[1] ?? "") ?? 0;
+	}
+	flush();
+	return items.sort((a, b) => b.mdat - a.mdat);
+}
+/**
+* One keychain read: the item for `acct` when given, else the first match.
+* Returns the raw blob only when it is USABLE (non-empty token); anything
+* else — missing item, unreadable payload, an empty shell — is undefined.
+* @param service - the keychain service name.
+* @param acct - the account to read, or undefined for the unscoped first match.
+* @returns the credential blob, or undefined.
+*/
+async function readKeychainEntry(service, acct) {
+	try {
+		const args = [
+			"find-generic-password",
+			"-s",
+			service
+		];
+		if (acct !== void 0) args.push("-a", acct);
+		args.push("-w");
+		const { stdout } = await internals.exec("security", args);
+		const blob = stdout.trim();
+		return credentialUsable(blob) ? blob : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The usable credential blob for this scoped home, or undefined. Every
+* account under the service is tried newest-write-first and the first
+* non-empty token wins; when enumeration itself is unavailable (not macOS, a
+* failing dump) the legacy unscoped read still runs, held to the same
+* non-empty-token bar.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the credential blob, or undefined when nothing usable is stored.
+*/
+async function readKeychainCredential(homeDir) {
+	const service = keychainService(homeDir);
+	const items = await keychainItems(service);
+	for (const item of items) {
+		const blob = await readKeychainEntry(service, item.acct);
+		if (blob !== void 0) return blob;
+	}
+	return items.length > 0 ? void 0 : readKeychainEntry(service, void 0);
+}
+/**
+* The stored credential's expiry (epoch ms), read from the USABLE macOS
+* keychain item for this scoped home (see `readKeychainCredential`);
+* undefined when no usable item exists or it carries no expiry (presence
+* alone then decides, as before). The READ side takes the LATER of the
+* access-token and refresh-token expiries: the CLI refreshes on use, so a
+* live refresh token means the credential still works.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the expiry, or undefined when unknown.
+*/
+async function readCredentialExpiry(homeDir) {
+	const blob = await readKeychainCredential(homeDir);
+	return blob === void 0 ? void 0 : credentialFileExpiry(blob);
+}
+/**
+* The ACCESS-token expiry (epoch ms) of a credential blob — the freshness key
+* the sync compares the two stores on. Deliberately not
+* {@link credentialFileExpiry}: that one answers "is this credential still
+* usable" and takes the LATER of the two expiries, so two generations of one
+* grant share a refresh expiry and compare equal. A refresh always mints a
+* later ACCESS expiry, which is exactly what tells the generations apart.
+* @param text - the raw credential JSON.
+* @returns the access-token expiry, or undefined when absent or unparseable.
+*/
+function credentialAccessExpiry(text) {
+	try {
+		const access = JSON.parse(text).claudeAiOauth?.expiresAt;
+		return typeof access === "number" ? access : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Reconcile the keychain credential with `<homeDir>/.credentials.json`,
+* NEWER WINS. Claude 2.1.236 on macOS WRITES the scoped login to the hashed
+* keychain entry but READS the credentials file at runtime (the same
+* write/read split as the Linux #47661 bug) — a login that lands only in the
+* keychain still answers "Not logged in", so the file has to be kept current.
+*
+* The file is not this process's private mirror, though: a containerized
+* round bind-mounts this very directory read-write (the unit has no keychain,
+* so the CLI inside it reads and writes the file), and the pre-spawn sync runs
+* against the HOST path moments before the unit reads it through the mount.
+* An unconditional mirror therefore makes this function the one participant
+* that can move the credential chain BACKWARD: it hands the next run a refresh
+* token the other writer already spent, the endpoint rejects it, and the CLI
+* answers by CLEARING the file — which logs the instance out, because that
+* file is the instance's credential. So the keychain blob is written only when
+* it is not older than the file's. Undefined expiry on either side keeps the
+* pre-newer-wins behavior (the keychain writes), and a file that is not USABLE
+* never wins.
+*
+* Only a USABLE blob (non-empty token, see `readKeychainCredential`) is
+* mirrored; with none in the keychain, a file holding an empty-token shell —
+* debris from an earlier first-match read, or a cleared credential — is
+* REMOVED, so the runtime says "Not logged in" instead of the misleading
+* "OAuth session expired". Idempotent and content-compare before write.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @param log - warn channel for the two decisions that used to be silent.
+* @returns true when a usable credential is in the file after the call.
+*/
+async function syncClaudeCredentialFile(homeDir, log) {
+	const file = join(homeDir, ".credentials.json");
+	let existing;
+	try {
+		existing = await readFile(file, "utf8");
+	} catch {}
+	const fileUsable = existing !== void 0 && credentialUsable(existing);
+	const blob = await readKeychainCredential(homeDir);
+	if (blob === void 0) {
+		if (existing !== void 0 && !fileUsable) await rm(file, { force: true });
+		return fileUsable;
+	}
+	if (existing !== void 0 && existing.trim() === blob) return true;
+	if (fileUsable) {
+		const fileExpiry = credentialAccessExpiry(existing);
+		const blobExpiry = credentialAccessExpiry(blob);
+		if (fileExpiry !== void 0 && blobExpiry !== void 0 && fileExpiry > blobExpiry) {
+			log?.(`local-agent-claude-code: ${homeDir}/.credentials.json is AHEAD of the keychain (file access expiry ${new Date(fileExpiry).toISOString()}, keychain ${new Date(blobExpiry).toISOString()}) — keeping the file; something else refreshed this grant (a containerized round mounts this directory read-write)`);
+			return true;
+		}
+	}
+	if (existing !== void 0 && !fileUsable) log?.(`local-agent-claude-code: ${homeDir}/.credentials.json held a cleared credential (both tokens empty) and is being restored from the keychain (access expiry ${new Date(credentialAccessExpiry(blob) ?? 0).toISOString()}); if the next round fails to authenticate, this grant was already spent and the scope needs a fresh login`);
+	await writeFile(file, blob, { mode: 384 });
+	return true;
+}
+/**
+* The expiry (epoch ms) from a `.credentials.json` payload; the token record
+* nests under `claudeAiOauth`. Returns the LATER of the access-token and
+* refresh-token expiries — the CLI refreshes on use, so a live refresh token
+* keeps the credential usable past the access expiry. Undefined when
+* absent/unparseable.
+* @param text - the file contents.
+* @returns the expiry, or undefined.
+*/
+function credentialFileExpiry(text) {
+	try {
+		const parsed = JSON.parse(text);
+		const access = parsed.claudeAiOauth?.expiresAt;
+		const refresh = parsed.claudeAiOauth?.refreshTokenExpiresAt;
+		const accessMs = typeof access === "number" ? access : void 0;
+		const refreshMs = typeof refresh === "number" ? refresh : void 0;
+		if (accessMs === void 0 && refreshMs === void 0) return void 0;
+		return Math.max(accessMs ?? 0, refreshMs ?? 0);
+	} catch {
+		return;
+	}
+}
+/**
+* Whether the scoped home holds usable Claude Code credentials: the scoped
+* `.claude.json` carries an `oauthAccount` record once a device-code login
+* has completed, AND the keychain credential is not past its stored expiry
+* (when the expiry is readable — a server-side REVOCATION is not visible
+* locally; providers report those through `localAgent.reportAuthFailure`).
+* The real credential lives in the macOS keychain under a hashed entry
+* (`Claude Code-credentials-<sha256(path)[:8]>`, hashed from the config-dir
+* path) or in the default `~/.claude/.credentials.json` on Linux (upstream
+* bug #47661: `CLAUDE_CONFIG_DIR` does not isolate the credentials file
+* there — it writes the scoped dir but READS the default home, so Linux
+* credentials may exist even when the scoped home has none). Spawning the
+* CLI to probe auth is avoided; the platform differences are documented in
+* the README.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @param log - warn channel handed to the credential reconcile below.
+* @returns true when a completed login is recorded and not locally expired.
+*/
+async function claudeAuthenticated(homeDir, log) {
+	await syncClaudeCredentialFile(homeDir, log);
+	let fileExpiry;
+	let filePresent = false;
+	try {
+		fileExpiry = credentialFileExpiry(await readFile(join(homeDir, ".credentials.json"), "utf8"));
+		filePresent = true;
+	} catch {}
+	if (filePresent) return fileExpiry === void 0 || fileExpiry > Date.now();
+	let text;
+	try {
+		text = await readFile(join(homeDir, ".claude.json"), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+	let config;
+	try {
+		config = JSON.parse(text);
+	} catch {
+		return false;
+	}
+	if (config.oauthAccount === void 0 || config.oauthAccount === null) return false;
+	const expiry = await readCredentialExpiry(homeDir);
+	return expiry === void 0 || expiry > Date.now();
+}
+/**
+* Parse the head of a session file for the listing fields. The first `user`
+* event carries `sessionId`, `cwd`, and `timestamp`; its `cwd` is the only
+* trustworthy workspace source (the directory slug is lossy). Unknown or
+* malformed values yield an undefined record rather than failing the list.
+* @param text - the raw session file head (only the head is read).
+* @returns the record, or undefined when no user event is found.
+*/
+function projectRecord(text) {
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "") continue;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (event.type !== "user") continue;
+		if (typeof event.sessionId !== "string" || event.sessionId === "") return void 0;
+		if (typeof event.cwd !== "string") return void 0;
+		const record = {
+			id: event.sessionId,
+			workDir: event.cwd
+		};
+		const startedAt = typeof event.timestamp === "string" ? Date.parse(event.timestamp) : void 0;
+		if (startedAt !== void 0 && Number.isFinite(startedAt)) record.startedAt = startedAt;
+		return record;
+	}
+}
+/**
+* Read the scoped home's session files. The listing walks the projects
+* directory and reads each jsonl head; a torn or malformed file is skipped
+* rather than failing the whole list.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the parsed records, empty when no sessions exist yet.
+*/
+async function listClaudeSessions(homeDir) {
+	const records = [];
+	let projectDirs;
+	try {
+		projectDirs = await readdir(join(homeDir, PROJECTS_ROOT));
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	for (const projectDir of projectDirs) {
+		let files;
+		try {
+			files = await readdir(join(homeDir, PROJECTS_ROOT, projectDir));
+		} catch {
+			continue;
+		}
+		for (const name of files) {
+			if (!name.endsWith(".jsonl")) continue;
+			try {
+				const handle = await open(join(homeDir, PROJECTS_ROOT, projectDir, name), "r");
+				let text;
+				try {
+					const buffer = Buffer.alloc(HEAD_BYTES);
+					const { bytesRead } = await handle.read(buffer, 0, HEAD_BYTES, 0);
+					text = buffer.subarray(0, bytesRead).toString("utf8");
+				} finally {
+					await handle.close();
+				}
+				const record = projectRecord(text);
+				if (record !== void 0) records.push(record);
+			} catch {
+				continue;
+			}
+		}
+	}
+	return records;
+}
+/**
+* Extract the model one transcript names, reading its TAIL (bounded, never
+* the whole conversation) from the newest line backward: the first line
+* carrying a model wins — the top-level `model` of the stream-json init
+* event's shape, or the nested `message.model` of an assistant line. Newest
+* first because a session's later rounds may run a different model than its
+* first, and "what ran last" is the question the caller asks. A torn final
+* line is skipped, never failed on.
+* @param path - the transcript file.
+* @returns the model identifier, or undefined when the window names none.
+*/
+async function transcriptFileModel(path) {
+	let text;
+	try {
+		const handle = await open(path, "r");
+		try {
+			const { size } = await handle.stat();
+			const length = Math.min(size, TRANSCRIPT_TAIL_BYTES);
+			const buffer = Buffer.alloc(length);
+			const { bytesRead } = await handle.read(buffer, 0, length, Math.max(0, size - length));
+			text = buffer.subarray(0, bytesRead).toString("utf8");
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return;
+	}
+	const lines = text.split("\n");
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
+		const line = lines[index].trim();
+		if (line === "") continue;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (typeof event.model === "string" && event.model !== "") return event.model;
+		if (typeof event.message?.model === "string" && event.message.model !== "") return event.message.model;
+	}
+}
+/** The project directories under one scoped home, capped; empty on any failure. */
+async function projectDirs(homeDir) {
+	try {
+		return (await readdir(join(homeDir, PROJECTS_ROOT))).slice(0, TRANSCRIPT_SCAN_DIRS);
+	} catch {
+		return [];
+	}
+}
+/** The jsonl file names inside one project directory; empty on any failure. */
+async function projectFiles(homeDir, projectDir) {
+	try {
+		return (await readdir(join(homeDir, PROJECTS_ROOT, projectDir))).filter((name) => name.endsWith(".jsonl"));
+	} catch {
+		return [];
+	}
+}
+/**
+* Whether a sidechain (`agent-*.jsonl`) transcript belongs to one session:
+* its head lines carry the PARENT session's id (`isSidechain: true`). Only
+* the bounded head is read.
+*/
+async function sidechainSessionMatches(path, cliSessionId) {
+	let text;
+	try {
+		const handle = await open(path, "r");
+		try {
+			const buffer = Buffer.alloc(HEAD_BYTES);
+			const { bytesRead } = await handle.read(buffer, 0, HEAD_BYTES, 0);
+			text = buffer.subarray(0, bytesRead).toString("utf8");
+		} finally {
+			await handle.close();
+		}
+	} catch {
+		return false;
+	}
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (line === "") continue;
+		try {
+			if (JSON.parse(line).sessionId === cliSessionId) return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
+}
+/**
+* The model a member's OWN CLI transcript names — the history backstop for
+* the broker's `lastObserved` when no delegation record observed one (every
+* member whose rounds predate the live-settle report). The live-settle
+* channel remains primary (the record's `observedModel` wins when present);
+* this reader only answers "what did this session last run" from the CLI's
+* own files, read-only — nothing is backfilled into `delegations.jsonl`.
+*
+* Location rule: with `cliSessionId`, the main transcript
+* `projects/<cwd-slug>/<cliSessionId>.jsonl` (found by NAME across the
+* project dirs — the slug is lossy, so it is never computed); when it is
+* absent, a sidechain `agent-*.jsonl` whose head names the session id
+* (bounded candidate count) answers instead. Without `cliSessionId` (the
+* settings card's memberless read), the NEWEST transcript across the
+* projects tree (mtime, bounded dir/file scan) answers; a newest file that
+* names no model yields to the next, up to a few tries. Every failure —
+* missing tree, unreadable file, no model in the read window — is
+* `undefined`, never a throw.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @param cliSessionId - the delegation record's CLI session id, when the
+*   member's own transcript is wanted.
+* @returns the model identifier, or undefined.
+*/
+async function readClaudeTranscriptModel(homeDir, cliSessionId) {
+	if (cliSessionId !== void 0) {
+		let main;
+		const sidechains = [];
+		for (const projectDir of await projectDirs(homeDir)) for (const name of await projectFiles(homeDir, projectDir)) {
+			if (name === `${cliSessionId}.jsonl` && main === void 0) {
+				main = join(homeDir, PROJECTS_ROOT, projectDir, name);
+				continue;
+			}
+			if (name.startsWith("agent-") && sidechains.length < TRANSCRIPT_SIDECHAIN_FILES) sidechains.push(join(homeDir, PROJECTS_ROOT, projectDir, name));
+		}
+		if (main !== void 0) {
+			const model = await transcriptFileModel(main);
+			if (model !== void 0) return model;
+		}
+		for (const path of sidechains) if (await sidechainSessionMatches(path, cliSessionId)) {
+			const model = await transcriptFileModel(path);
+			if (model !== void 0) return model;
+		}
+		return;
+	}
+	const candidates = [];
+	let scanned = 0;
+	for (const projectDir of await projectDirs(homeDir)) for (const name of await projectFiles(homeDir, projectDir)) {
+		if (scanned >= TRANSCRIPT_SCAN_FILES) break;
+		scanned += 1;
+		const path = join(homeDir, PROJECTS_ROOT, projectDir, name);
+		try {
+			candidates.push({
+				path,
+				mtimeMs: (await stat(path)).mtimeMs
+			});
+		} catch {
+			continue;
+		}
+	}
+	candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+	for (const candidate of candidates.slice(0, TRANSCRIPT_NEWEST_TRIES)) {
+		const model = await transcriptFileModel(candidate.path);
+		if (model !== void 0) return model;
+	}
+}
+//#endregion
+//#region lib/types/live-driver.js
+/**
+* The claude provider's live driver: one resident Claude Code stream-json
+* process per member (child session), driven over the vendor's
+* `--input-format stream-json --output-format stream-json` realtime mode
+* (protocol-probed against claude 2.1.236; the Agent SDK's streaming-input
+* mode is this same channel, driven here directly so no SDK dependency
+* lands). A delegation round is one `user` message on the resident process's
+* stdin instead of a fresh `claude -p` — which buys what the process boundary
+* could not: runtime-level graceful interrupt (`control_request
+* {subtype:'interrupt'}`; the process survives and the session stays
+* continuable) and the same-shape push stream folded live per turn.
+*
+* Auth discipline (a hard requirement): the resident process runs under the
+* family's scoped `CLAUDE_CONFIG_DIR` and nothing else — the OAuth marker in
+* the scoped `.claude.json` and the keychain entry hashed to that path are
+* exactly what the exec mode's one-shot processes already use. The driver
+* never touches the user's global `~/.claude`, never runs any `auth` verb,
+* and only adds `ANTHROPIC_BASE_URL` when the plugin config supplies it (the
+* exec path's exact env rule).
+*
+* Protocol facts (all probed): the first stdin `user` message triggers
+* `system/init` carrying the server-assigned session id (EVERY turn emits a
+* fresh init — the delegation records the first one); each turn closes with
+* a `result` event (`is_error`, usage, session id); the interrupt control
+* request answers with a `control_response` success; a new process with
+* `--resume <session_id>` reattaches the on-disk session in the same mode
+* (crash recovery); stdin EOF quiesces the process (the reclaim ladder).
+*
+* Fold: the resident stream speaks the exec path's exact event vocabulary
+* (`system`/`assistant`/`user`/`result`), so each turn folds through the
+* shared `ClaudeStreamParser` with the exec live mirror's hold-back rule (the
+* volatile last line waits for `result`, which carries the round's usage).
+* Every line folds 1:1. The always-enabled
+* `--include-partial-messages` adds incremental output on top: each `stream_event` partial accumulates into its kind's
+* stream (native message id + block index, with ordered legacy fallback),
+* which reserves a (turn, step) at its first delta and
+* appends throttled snapshot `assistant/message`s there — the host folds
+* repeated settles at one coordinate into one live-updating chat node, the
+* only streaming channel left after 0.1.5 retired the durable per-chunk
+* event. A streamed line's completion folds at its stream's reserved step and
+* finalizes it (no duplicated content); a stream whose completion never
+* arrives is force-finalized at settle (interrupted on a non-completed round,
+* so a cancelled turn reads 已停止 legitimately), the last one carrying the
+* round's usage when no folded line did.
+*
+* Lifecycle mirrors M1–M3's discipline: lazy spawn, one in-flight spawn per
+* member, idle-timeout reclaim (stdin EOF → grace → SIGTERM ladder), crash
+* re-spawn with `--resume`, a channel breaker with cooldown, `disposeAll` on
+* unload, and cancellation honored in every window (abort listener before
+* any await; the init wait races the abort signal).
+*
+* Two member-aware additions on top: the spawn binds the member's EFFECTIVE
+* model (session-level override, then the round's delegation model, then the
+* settings key — resolved by the config callback per spawn, scratched into
+* the scoped settings.json because a `--resume` respawn honors the file over
+* the flag), and a runtime whose bound model no longer matches is retired so
+* the round respawns onto the right one; and server→client control requests
+* (a `permissionMode: 'normal'` spawn's `can_use_tool` approval surface) are
+* auto-answered so an unattended runtime never hangs on a permission prompt.
+* @module @khorsheed/dsh-local-agent-claude-code/live-driver
+*/
+/** Default idle lifetime of an unused resident runtime before reclaim. */
+const DEFAULT_LIVE_IDLE_MS = 18e5;
+/** Default timeout for the turn's system/init ack (a cold boot can be slow). */
+const DEFAULT_LIVE_INIT_TIMEOUT_MS = 6e4;
+/** Bounded wait for an interrupted turn to converge while a run disposes. */
+const DEFAULT_LIVE_DISPOSE_CONVERGE_MS = 5e3;
+/** How long a tripped channel breaker stays on the exec fallback. */
+const DEFAULT_LIVE_CHANNEL_RETRY_MS = 3e5;
+/** Grace between stdin EOF and SIGTERM when reclaiming a stream-json process. */
+const RECLAIM_EOF_GRACE_MS = 1e3;
+/** Default minimum interval between one streaming kind's snapshot messages. */
+const DEFAULT_SNAPSHOT_MIN_INTERVAL_MS = LIVE_FLUSH_INTERVAL_MS;
+/**
+* The stream-json channel could not come up (spawn failure or the first
+* turn's init never arrived). The provider catches exactly this and falls
+* back to the exec one-shot; any other error is a real round failure.
+*/
+var LiveChannelUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LiveChannelUnavailableError";
+	}
+};
+const DEFAULT_TIMEOUTS = {
+	initMs: DEFAULT_LIVE_INIT_TIMEOUT_MS,
+	convergeMs: DEFAULT_LIVE_DISPOSE_CONVERGE_MS,
+	channelRetryMs: DEFAULT_LIVE_CHANNEL_RETRY_MS
+};
+function thrown$1(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* One resident stream-json process: the NDJSON frame pump, the session id it
+* carries, the per-session turn chain (one turn at a time — claude queues
+* stdin user messages, but the cancelled turn's result must land before the
+* next turn's message goes out, keeping the stop-then-rephrase gesture's
+* streams unambiguous), and the reclaim ladder (stdin EOF → grace → SIGTERM).
+*/
+var ClaudeLiveRuntime = class {
+	child;
+	warn;
+	dead = false;
+	reclaimed = false;
+	/** The member's claude session id (first turn's system/init). */
+	sessionId;
+	/** The model this runtime's process was spawned with (undefined = no flag). */
+	configurationKey;
+	model;
+	/** Serializes turns per member (converge-before-next-message). */
+	turnChain = Promise.resolve();
+	/** The active round's event sink; installed per round, cleared at settle. */
+	onEvent;
+	controls = new ClaudeControlRequests((message) => this.send(message));
+	onDead;
+	buffer = "";
+	decoder = new StringDecoder("utf8");
+	stderrTail = "";
+	stderrDecoder = new StringDecoder("utf8");
+	constructor(child, warn) {
+		this.child = child;
+		this.warn = warn;
+		child.stdout?.on("data", (chunk) => {
+			this.feed(this.decoder.write(chunk));
+		});
+		child.stderr?.on("data", (chunk) => {
+			this.stderrTail = (this.stderrTail + this.stderrDecoder.write(chunk)).slice(-4096);
+		});
+		child.done.then(() => {
+			this.markDead();
+		}, () => {
+			this.markDead();
+		});
+	}
+	get diagnostics() {
+		return this.stderrTail.trim();
+	}
+	feed(text) {
+		this.buffer += text;
+		let index = this.buffer.indexOf("\n");
+		while (index >= 0) {
+			const line = this.buffer.slice(0, index);
+			this.buffer = this.buffer.slice(index + 1);
+			index = this.buffer.indexOf("\n");
+			if (line.trim() === "") continue;
+			let event;
+			try {
+				event = JSON.parse(line);
+			} catch {
+				this.warn("subagent-claude live: ignored a malformed stream line");
+				continue;
+			}
+			try {
+				this.dispatchEvent(event);
+			} catch (error) {
+				this.warn(`subagent-claude live: stream handler failed: ${thrown$1(error).message}`);
+			}
+		}
+	}
+	dispatchEvent(event) {
+		if (this.controls.accept(event)) return;
+		if (event["type"] === "control_request") {
+			this.answerControlRequest(event);
+			return;
+		}
+		this.onEvent?.(event);
+	}
+	/**
+	* Answer a server→client control request so the runtime never hangs on
+	* one. A `permissionMode: 'normal'` spawn omits
+	* `--dangerously-skip-permissions`, so the CLI routes its approval surface
+	* (`can_use_tool`) here — and a subagent has no human to approve. The
+	* auto-allow mirrors the exec path's effective behavior (its one-shot
+	* spawns pre-allow the member bridge tool and otherwise run the same
+	* unattended policy) and the kimi live driver's auto-allow of
+	* `session/request_permission`. Any other subtype answers with an error so
+	* the CLI's own fallback path runs instead of waiting forever.
+	*/
+	answerControlRequest(event) {
+		const requestId = event["request_id"];
+		if (typeof requestId !== "string") return;
+		const request = event["request"];
+		const subtype = request?.["subtype"];
+		if (subtype === "can_use_tool") {
+			const input = request?.["input"];
+			this.send({
+				type: "control_response",
+				response: {
+					subtype: "success",
+					request_id: requestId,
+					response: {
+						behavior: "allow",
+						updatedInput: typeof input === "object" && input !== null ? input : {}
+					}
+				}
+			});
+			return;
+		}
+		this.send({
+			type: "control_response",
+			response: {
+				subtype: "error",
+				request_id: requestId,
+				error: `subagent-claude live: unsupported control request ${String(subtype)}`
+			}
+		});
+	}
+	/** Write one stdin frame. */
+	send(message) {
+		this.child.stdin?.write(JSON.stringify(message) + "\n");
+	}
+	/** Native initialization and model binding precede any user prompt. */
+	async configure(configuration, signal) {
+		const entry = claudeDirectory(await this.controls.request({
+			subtype: "initialize",
+			hooks: {}
+		}, signal)).entries.find((entry) => entry.value === configuration.model || entry.resolvedModel === configuration.model);
+		if (configuration.effort !== void 0 && !entry?.reasoning?.options.some((option) => option.value === configuration.effort)) throw new Error("The running Claude CLI does not advertise the requested model/effort combination");
+		if (configuration.model !== void 0) await this.controls.request({
+			subtype: "set_model",
+			model: configuration.model
+		}, signal);
+	}
+	/** The graceful runtime interrupt, bounded and checked for an actual success ack. */
+	async interrupt() {
+		if (this.dead) return;
+		await this.controls.request({ subtype: "interrupt" });
+	}
+	markDead() {
+		if (this.dead) return;
+		this.dead = true;
+		this.controls.close();
+		this.onDead?.();
+	}
+	/** Graceful teardown: EOF stdin, grace, then the terminate ladder. */
+	async reclaim() {
+		if (this.reclaimed) return;
+		this.reclaimed = true;
+		if (!this.dead) {
+			this.child.stdin?.end();
+			await Promise.race([this.child.done.catch(() => {}), delay(RECLAIM_EOF_GRACE_MS)]);
+		}
+		if (!this.dead) {
+			this.child.terminate();
+			await this.child.waitForExit();
+		}
+		await this.child.done.catch(() => {});
+		this.markDead();
+	}
+};
+/**
+* The claude live driver owns every resident stream-json runtime of this
+* provider generation. Created only when `live: true`; disposed with the
+* plugin.
+*/
+var ClaudeLiveDriver = class {
+	ctx;
+	config;
+	timeouts;
+	runtimes = /* @__PURE__ */ new Map();
+	ensuring = /* @__PURE__ */ new Map();
+	idleTimers = /* @__PURE__ */ new Map();
+	/** Per-member round serialization (the resume lock covers resume-vs-resume only). */
+	roundChains = /* @__PURE__ */ new Map();
+	channelBrokenAt;
+	disposed = false;
+	/**
+	* Set by drain() (a settings-driven generation handoff): new rounds are
+	* refused so the provider falls back to exec, while in-flight rounds finish
+	* on their runtime undisturbed. Unlike `disposed`, the driver still serves
+	* what it already accepted.
+	*/
+	draining = false;
+	disposeController = new AbortController();
+	constructor(ctx, config, timeouts = DEFAULT_TIMEOUTS) {
+		this.ctx = ctx;
+		this.config = config;
+		this.timeouts = timeouts;
+	}
+	/** Whether the channel is in its post-failure cooldown (rounds fall back to exec). */
+	get disabled() {
+		return this.channelBrokenAt !== void 0 && Date.now() - this.channelBrokenAt < (this.timeouts.channelRetryMs ?? 3e5);
+	}
+	/** Count of resident runtimes currently registered (zombie accounting in tests). */
+	get liveCount() {
+		return this.runtimes.size;
+	}
+	/**
+	* True while the member's runtime exists or is being spawned. The settings
+	* controller gates a new generation on this: a fresh driver must not serve
+	* a member whose retiring generation still hosts the (same) claude session.
+	*/
+	hasRuntime(key) {
+		return this.runtimes.has(key) || this.ensuring.has(key);
+	}
+	/** @deprecated Compatibility no-op: live output is always incremental. */
+	setLiveMirrorGranularity(_granularity) {}
+	/**
+	* Drain for a settings-driven generation handoff: refuse new rounds (the
+	* provider's catch falls back to exec), let every in-flight round finish on
+	* its runtime, then reclaim. Resolves when no runtime or spawn remains.
+	* Unlike disposeAll, in-flight work is never interrupted.
+	*/
+	async drain() {
+		this.draining = true;
+		const keys = /* @__PURE__ */ new Set([
+			...this.runtimes.keys(),
+			...this.ensuring.keys(),
+			...this.roundChains.keys()
+		]);
+		await Promise.all([...keys].map(async (key) => {
+			await (this.roundChains.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await (this.ensuring.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await this.reclaim(key);
+		}));
+	}
+	clearIdleTimer(key) {
+		const timer = this.idleTimers.get(key);
+		if (timer !== void 0) clearTimeout(timer);
+		this.idleTimers.delete(key);
+	}
+	armIdleTimer(key) {
+		this.clearIdleTimer(key);
+		const idleMs = this.config.liveIdleMs ?? 18e5;
+		const timer = setTimeout(() => {
+			this.reclaim(key);
+		}, idleMs);
+		timer.unref();
+		this.idleTimers.set(key, timer);
+	}
+	async reclaim(key) {
+		const runtime = this.runtimes.get(key);
+		this.clearIdleTimer(key);
+		if (runtime === void 0) return;
+		this.runtimes.delete(key);
+		await runtime.reclaim();
+	}
+	/** Reclaim every runtime (plugin unload); no process survives the profile. */
+	async disposeAll() {
+		this.disposed = true;
+		this.disposeController.abort();
+		await Promise.all([...this.ensuring.values()].map((pending) => pending.catch(() => void 0)));
+		for (const key of [...this.runtimes.keys()]) await this.reclaim(key);
+	}
+	ensureRuntime(spec, signal) {
+		const key = String(spec.childSession.id);
+		const existing = this.runtimes.get(key);
+		if (existing !== void 0 && !existing.dead && existing.model === this.spawnModel(key, spec) && existing.configurationKey === (spec.configuration === void 0 ? void 0 : JSON.stringify(spec.configuration))) {
+			this.clearIdleTimer(key);
+			return Promise.resolve(existing);
+		}
+		if (existing !== void 0) this.runtimes.delete(key);
+		const pending = this.ensuring.get(key);
+		if (pending !== void 0) return pending;
+		const spawn = (existing !== void 0 && !existing.dead ? existing.reclaim() : Promise.resolve()).then(() => this.spawnRuntime(spec, signal)).finally(() => {
+			this.ensuring.delete(key);
+		});
+		this.ensuring.set(key, spawn);
+		return spawn;
+	}
+	/** The model a spawn for this round would bind (the argv `--model` value). */
+	spawnModel(key, spec) {
+		if (spec.configuration !== void 0) return spec.configuration.model;
+		const model = this.config.model?.(key, spec.model)?.trim();
+		return model === void 0 || model === "" ? void 0 : model;
+	}
+	/**
+	* The model the member's resident runtime was spawned with, or undefined
+	* when the member has no live runtime (or it binds none). The model broker
+	* compares this against a switch's new effective model.
+	*/
+	runtimeModel(childSessionId) {
+		return this.runtimes.get(childSessionId)?.model;
+	}
+	/**
+	* Retire the member's resident runtime so the next round respawns with its
+	* new effective model (the model broker's switch path). The caller refuses
+	* switches while a round is in flight, so the reclaim never kills a run;
+	* the CLI session survives on disk and the respawn resumes it.
+	*/
+	async retireRuntime(childSessionId) {
+		await (this.ensuring.get(childSessionId) ?? Promise.resolve()).catch(() => void 0);
+		await this.reclaim(childSessionId);
+	}
+	/**
+	* Spawn the member's resident stream-json process. There is no handshake
+	* message — the channel proves itself with the first turn's system/init —
+	* so spawn failure is the only breaker trip here; the init wait lives in
+	* the round's accept window.
+	*/
+	async spawnRuntime(spec, signal) {
+		const key = String(spec.childSession.id);
+		if (this.disposed) throw new LiveChannelUnavailableError("the live driver is disposed");
+		await syncClaudeCredentialFile(spec.homeDir, (message) => {
+			this.ctx.logger.warn(message);
+		}).catch(() => false);
+		const member = registerClaudeMemberRun(this.ctx, String(spec.childSession.id), spec.parentSessionId);
+		const model = this.spawnModel(key, spec);
+		if (spec.configuration === void 0 && this.config.provisionModel !== void 0) await this.config.provisionModel(spec.homeDir, model).catch(() => void 0);
+		const spawnSpec = {
+			argv: [
+				"claude",
+				"-p",
+				"--verbose",
+				...model === void 0 ? [] : ["--model", model],
+				"--input-format",
+				"stream-json",
+				"--output-format",
+				"stream-json",
+				"--include-partial-messages",
+				...(this.config.permissionMode ?? "skip") === "skip" ? ["--dangerously-skip-permissions"] : [],
+				...spec.resume === void 0 ? [] : ["--resume", spec.resume.cliSessionId],
+				...member === void 0 ? [] : [
+					"--mcp-config",
+					member.mcpConfig,
+					"--allowedTools",
+					member.allowedTool,
+					"--"
+				]
+			],
+			cwd: spec.cwd,
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe"
+			},
+			graceMs: DEFAULT_DISPOSE_GRACE_MS,
+			env: delegationEnv({
+				CLAUDE_CONFIG_DIR: spec.homeDir,
+				...spec.configuration === void 0 ? {} : { CLAUDE_CODE_EFFORT_LEVEL: spec.configuration.effort ?? "auto" },
+				...this.config.baseUrl === void 0 ? {} : { ANTHROPIC_BASE_URL: this.config.baseUrl }
+			})
+		};
+		let child;
+		try {
+			child = this.ctx.subprocess.spawn(spawnSpec);
+		} catch (error) {
+			member?.release();
+			this.markChannelBroken();
+			throw new LiveChannelUnavailableError(`the stream-json process failed to spawn: ${thrown$1(error).message}`);
+		}
+		const runtime = new ClaudeLiveRuntime(child, (message) => {
+			this.ctx.logger.warn(message);
+		});
+		runtime.model = model;
+		runtime.configurationKey = spec.configuration === void 0 ? void 0 : JSON.stringify(spec.configuration);
+		runtime.onDead = () => {
+			if (this.runtimes.get(key) === runtime) this.runtimes.delete(key);
+			this.clearIdleTimer(key);
+			member?.release();
+		};
+		if (signal.aborted || this.disposeController.signal.aborted) {
+			await runtime.reclaim();
+			if (signal.aborted) throw new Error("subagent-claude: run cancelled locally");
+			throw new LiveChannelUnavailableError("the live driver was disposed during spawn");
+		}
+		if (spec.configuration !== void 0) try {
+			await runtime.configure(spec.configuration, signal);
+		} catch (error) {
+			await runtime.reclaim();
+			throw error;
+		}
+		this.channelBrokenAt = void 0;
+		this.runtimes.set(key, runtime);
+		return runtime;
+	}
+	markChannelBroken() {
+		this.channelBrokenAt = Date.now();
+	}
+	/**
+	* Drive one delegation round on the member's resident stream-json process.
+	* Mirrors the exec run's settlement contract exactly (settleRunResult +
+	* turn/end bookkeeping); cancel is the interrupt control request and the
+	* process survives.
+	*/
+	/** Initialize native controls without sending a user prompt. Native history starts on its first real turn. */
+	async prepare(spec, signal) {
+		signal.throwIfAborted();
+		if (this.draining || this.disabled) throw new LiveChannelUnavailableError("the live driver is unavailable for preparation");
+		try {
+			await this.ensureRuntime(spec, signal);
+			signal.throwIfAborted();
+			this.armIdleTimer(String(spec.childSession.id));
+		} catch (error) {
+			await this.reclaim(String(spec.childSession.id));
+			throw error;
+		}
+	}
+	async startRound(request, spec) {
+		if (this.draining) throw new LiveChannelUnavailableError("the live driver is draining (a settings change retired this generation)");
+		const key = String(spec.childSession.id);
+		const round = (this.roundChains.get(key) ?? Promise.resolve()).catch(() => {}).then(() => this.startRoundLocked(request, spec));
+		this.roundChains.set(key, round.then((handle) => handle.result.catch(() => ({})), () => ({})));
+		return round;
+	}
+	/** The serialized round body. */
+	async startRoundLocked(request, spec) {
+		const task = textTask(request.prompt);
+		if (request.signal.aborted) throw new Error("subagent-claude: request was aborted before the run started");
+		if (this.draining) throw new LiveChannelUnavailableError("the live driver is draining (a settings change retired this generation)");
+		if (this.disposed) throw new Error("subagent-claude: the live driver is disposed");
+		const turn = spec.resume?.turn ?? 1;
+		const childSession = spec.childSession;
+		const localAgent = this.ctx.get("localAgent");
+		const runAbort = new AbortController();
+		let roundSettled = false;
+		let runtime;
+		/** True while this round's turn is in flight (interrupt targets it). */
+		let turnInFlight = false;
+		/** True from the message going out until its result lands — the sink must
+		*  survive settlement in that window so the chain can converge. */
+		let awaitingResult = false;
+		let turnOpened = false;
+		/** This turn's fold (the exec live mirror's exact parser). */
+		const parser = new ClaudeStreamParser();
+		let mirrored = 0;
+		/**
+		* The model and CLI build this turn's system/init named — the live
+		* drive's half of the exec settle parse's read-back, reported as the
+		* round's settled observation. EVERY turn re-emits its init, so a round
+		* always observes its own.
+		*/
+		let roundModel;
+		let roundCliVersion;
+		/** Whether a folded line already carries the round's usage (no backfill event exists). */
+		let usageCarried = false;
+		/**
+		* The step ledger: `reservedSteps` holds every step a stream reservation
+		* consumed (in increasing order — permanently, whether the stream later
+		* completes or stays an orphan snapshot), and a sequential line folds at
+		* its index shifted past every reservation before it. A tool completed
+		* mid-stream therefore folds ABOVE the stream's step and the projection
+		* renders the round's chronological order.
+		*/
+		const reservedSteps = [];
+		/**
+		* The streaming kinds seen this round by stream key:
+		* deltas accumulate into throttled snapshot assistant/messages appended
+		* at the kind's reserved (turn, step) — the host folds repeated settles
+		* at one coordinate into one live-updating chat node, which is the only
+		* streaming channel left after 0.1.5 retired the durable per-chunk event.
+		* The kind's completed line folds at the same step and finalizes it; an
+		* entry whose completion never arrives is force-finalized at settle.
+		*/
+		const streams = /* @__PURE__ */ new Map();
+		/** The stream deltas currently accumulate into (kinds stream sequentially). */
+		let activeStream;
+		let persistQueue = Promise.resolve();
+		const persist = () => {
+			persistQueue = persistQueue.then(() => persistChildSession(this.ctx, childSession)).catch((error) => {
+				this.ctx.logger.warn(`subagent-claude: live persistence failed: ${thrown$1(error).message}`);
+			});
+		};
+		const requestCancel = () => {
+			if (roundSettled || runAbort.signal.aborted) return;
+			runAbort.abort(/* @__PURE__ */ new Error("subagent-claude: run cancelled locally"));
+			if (turnInFlight && runtime !== void 0 && !runtime.dead) runtime.interrupt().catch(() => {});
+		};
+		const onAbort = () => {
+			requestCancel();
+		};
+		request.signal.addEventListener("abort", onAbort, { once: true });
+		const abortBranch = new Promise((_, reject) => {
+			runAbort.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("subagent-claude: run cancelled locally")), { once: true });
+		});
+		const collectOutput = () => {
+			const text = parser.text?.trim();
+			return text === void 0 || text === "" ? [] : [{
+				type: "text",
+				text: parser.text
+			}];
+		};
+		let messageKey;
+		let legacyMessage = 0;
+		const streamKey = (kind, index) => `${messageKey ?? `legacy-${turn}-${legacyMessage}`}:${typeof index === "number" ? index : kind}`;
+		/**
+		* Append one snapshot of a streaming kind 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` and no folded line carried it, the
+		* round's usage.
+		*/
+		const streamPublisher = localAgent?.liveStreams === void 0 ? void 0 : new LiveStreamPublisher(localAgent.liveStreams, childSession, turn, persist, (error) => this.ctx.logger.warn(`live checkpoint failed: ${String(error)}`));
+		const liveFlush = new LiveFlush((error) => this.ctx.logger.warn(`live mirror flush failed: ${String(error)}`), this.config.snapshotMinIntervalMs ?? DEFAULT_SNAPSHOT_MIN_INTERVAL_MS);
+		const pendingStreamArrival = /* @__PURE__ */ new Map();
+		const appendStreamSnapshot = (stream, force, interrupted, withUsage = false, final = false) => {
+			if (stream.text.trim() === "") return;
+			const now = Date.now();
+			if (!force) {
+				if (!pendingStreamArrival.has(stream.step)) pendingStreamArrival.set(stream.step, now);
+				liveFlush.schedule(stream.step, () => appendStreamSnapshot(stream, true, interrupted, withUsage));
+				return;
+			}
+			liveFlush.cancel(stream.step);
+			const receivedAt = pendingStreamArrival.get(stream.step) ?? now;
+			pendingStreamArrival.delete(stream.step);
+			if (streamPublisher !== void 0 && !final) {
+				if (!stream.opened) {
+					childSession.append("step/start", {
+						turn,
+						step: stream.step
+					});
+					stream.opened = true;
+				}
+				streamPublisher.update(stream.step, stream.kind, stream.text, { receivedAt });
+				stream.lastSnapshotAt = now;
+				stream.lastSnapshotLen = stream.text.length;
+				return;
+			}
+			if (!stream.opened) {
+				childSession.append("step/start", {
+					turn,
+					step: stream.step
+				});
+				stream.opened = true;
+			}
+			const usage = parser.usage;
+			childSession.append("assistant/message", {
+				turn,
+				step: stream.step,
+				message: assistantEvent([stream.kind === "think" ? {
+					type: "reasoning",
+					text: stream.text
+				} : {
+					type: "text",
+					text: stream.text
+				}]),
+				stream: [],
+				...withUsage && !usageCarried && usage !== void 0 ? { usage } : {},
+				...interrupted ? { interrupted: true } : {}
+			}, { surfaceOp: "append" });
+			if (withUsage && !usageCarried && usage !== void 0) usageCarried = true;
+			stream.lastSnapshotAt = now;
+			stream.lastSnapshotLen = stream.text.length;
+			persist();
+		};
+		/**
+		* Reserve the step one streaming kind will occupy — past every completed
+		* line (folded or held back) and every earlier reservation. A different
+		* kind's deltas force one final snapshot of the current stream (its
+		* completion still folds at its own reserved step when it lands).
+		*/
+		const reserveStream = (itemId, kind) => {
+			if (activeStream !== void 0 && activeStream !== itemId) {
+				const previous = streams.get(activeStream);
+				if (previous !== void 0 && previous.text.length !== previous.lastSnapshotLen) appendStreamSnapshot(previous, true, false);
+				activeStream = void 0;
+			}
+			let stream = streams.get(itemId);
+			if (stream === void 0) {
+				const step = parser.lines.length + reservedSteps.length + 1;
+				reservedSteps.push(step);
+				stream = {
+					itemId,
+					kind,
+					step,
+					text: "",
+					lastSnapshotAt: 0,
+					lastSnapshotLen: 0,
+					opened: false
+				};
+				streams.set(itemId, stream);
+			}
+			activeStream = itemId;
+		};
+		/** The sequential fold step for `parser.lines[index]`: its position shifted past every reservation before it. */
+		const foldStep = (index) => {
+			let step = index + 1;
+			for (const reserved of reservedSteps) if (reserved <= step) step += 1;
+			else break;
+			return step;
+		};
+		/** Mirror folded lines [mirrored, upto); the last line is held back until `result`. */
+		const mirrorUpTo = (upto, withUsage) => {
+			let usageIndex = -1;
+			if (withUsage) {
+				for (let index = 0; index < parser.lines.length; index += 1) if (parser.lines[index]?.kind !== "tool") usageIndex = index;
+			}
+			for (let index = mirrored; index < upto; index += 1) {
+				const line = parser.lines[index];
+				if (line === void 0) continue;
+				const lineUsage = withUsage && index === usageIndex ? parser.usage : void 0;
+				if (lineUsage !== void 0) usageCarried = true;
+				const stream = line.kind === "tool" ? void 0 : (line.streamId === void 0 ? void 0 : streams.get(line.streamId)) ?? [...streams.values()].find((candidate) => candidate.kind === line.kind && (line.streamId === void 0 || candidate.itemId.startsWith("legacy-")));
+				const itemId = stream?.itemId;
+				if (itemId !== void 0 && stream !== void 0) {
+					liveFlush.cancel(stream.step);
+					streams.delete(itemId);
+					if (activeStream === itemId) activeStream = void 0;
+					if (!stream.opened) childSession.append("step/start", {
+						turn,
+						step: stream.step
+					});
+					const blocks = stream.kind === "think" ? [{
+						type: "reasoning",
+						text: line.kind === "tool" ? "" : line.text
+					}] : [{
+						type: "text",
+						text: line.kind === "tool" ? "" : line.text
+					}];
+					childSession.append("assistant/message", {
+						turn,
+						step: stream.step,
+						message: assistantEvent(blocks),
+						stream: [],
+						...lineUsage === void 0 ? {} : { usage: lineUsage }
+					}, { surfaceOp: "append" });
+					streamPublisher?.finish(stream.step);
+					childSession.append("step/end", {
+						turn,
+						step: stream.step
+					});
+				} else appendClaudeTranscriptLine(childSession, turn, foldStep(index), line, lineUsage);
+				mirrored = index + 1;
+				localAgent?.reportRunProgress(childSession.id, {
+					kind: "delta",
+					text: claudeLineText(line)
+				});
+			}
+			if (upto > 0) persist();
+		};
+		let resolveResult;
+		const resultEvent = new Promise((resolve) => {
+			resolveResult = resolve;
+		});
+		let resolveInit;
+		let rejectInit;
+		const initArrived = new Promise((resolve, reject) => {
+			resolveInit = resolve;
+			rejectInit = reject;
+		});
+		/** The round's event sink (installed on the runtime while it runs). */
+		const onEvent = (event) => {
+			const type = event["type"];
+			if (type === "system" && typeof event["session_id"] === "string") {
+				if (runtime !== void 0 && runtime.sessionId === void 0) {
+					runtime.sessionId = event["session_id"];
+					resolveInit(runtime.sessionId);
+				}
+				if (typeof event["model"] === "string" && event["model"] !== "") roundModel = event["model"];
+				roundCliVersion = claudeVersionFromInit(event["claude_code_version"]) ?? roundCliVersion;
+				return;
+			}
+			if (type === "result") {
+				awaitingResult = false;
+				parser.push(JSON.stringify(event) + "\n");
+				mirrorUpTo(parser.lines.length, true);
+				resolveResult(event);
+				return;
+			}
+			if (type === "stream_event") {
+				const inner = event["event"];
+				if (inner?.["type"] === "message_start") {
+					const message = inner["message"];
+					messageKey = typeof message?.["id"] === "string" ? message["id"] : `legacy-${turn}-${++legacyMessage}`;
+					return;
+				}
+				const delta = inner?.["delta"];
+				const deltaType = delta?.["type"];
+				const text = delta?.["text"] ?? delta?.["thinking"];
+				if ((deltaType === "text_delta" || deltaType === "thinking_delta") && typeof text === "string" && text !== "") {
+					const kind = deltaType === "thinking_delta" ? "think" : "text";
+					reserveStream(streamKey(kind, inner?.["index"]), kind);
+					const stream = activeStream === void 0 ? void 0 : streams.get(activeStream);
+					if (stream !== void 0) {
+						stream.text += text;
+						appendStreamSnapshot(stream, false, false);
+					}
+					localAgent?.reportRunProgress(childSession.id, {
+						kind: "delta",
+						text
+					});
+				}
+				return;
+			}
+			if (type !== "assistant" && type !== "user") return;
+			parser.push(JSON.stringify(event) + "\n");
+			mirrorUpTo(parser.lines.length - 1, false);
+			if (type === "assistant") {
+				messageKey = void 0;
+				legacyMessage++;
+			}
+		};
+		const sendAndInit = async () => {
+			if (runAbort.signal.aborted) throw new Error("subagent-claude: run cancelled locally");
+			const rt = runtime;
+			rt.onEvent = onEvent;
+			turnInFlight = true;
+			awaitingResult = true;
+			rt.send({
+				type: "user",
+				message: {
+					role: "user",
+					content: [{
+						type: "text",
+						text: task
+					}]
+				}
+			});
+			if (rt.sessionId === void 0) {
+				const initWatchdog = setTimeout(() => {
+					(async () => {
+						this.markChannelBroken();
+						await this.reclaim(String(childSession.id));
+						rejectInit(new LiveChannelUnavailableError("the stream-json init never arrived"));
+					})();
+				}, this.timeouts.initMs);
+				initWatchdog.unref();
+				try {
+					const cancelled = new Promise((_, reject) => {
+						runAbort.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("subagent-claude: run cancelled locally")), { once: true });
+					});
+					const sessionId = await Promise.race([initArrived, cancelled]).catch(async (error) => {
+						if (runAbort.signal.aborted && !(error instanceof LiveChannelUnavailableError)) await this.reclaim(String(childSession.id));
+						throw error;
+					});
+					spec.onSessionId?.(sessionId);
+				} finally {
+					clearTimeout(initWatchdog);
+				}
+			}
+		};
+		const accepted = (async () => {
+			const rt = await this.ensureRuntime(spec, request.signal);
+			runtime = rt;
+			if (runAbort.signal.aborted) {
+				await this.reclaim(String(childSession.id));
+				throw new Error("subagent-claude: run cancelled locally");
+			}
+			childSession.append("turn/start", { turn });
+			childSession.append("user/message", createUserMessage({
+				content: [{
+					type: "text",
+					text: task
+				}],
+				source: { kind: "user" }
+			}), { surfaceOp: "append" });
+			turnOpened = true;
+			persist();
+			localAgent?.reportRunProgress(childSession.id, {
+				kind: "delta",
+				text: task
+			});
+			rt.turnChain = rt.turnChain.catch(() => {}).then(sendAndInit);
+			await rt.turnChain;
+		})();
+		const attempt = accepted.then(async () => {
+			if (runAbort.signal.aborted) throw new Error("subagent-claude: run cancelled locally");
+			const rt = runtime;
+			const processFailure = rt.child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-claude: the live runtime exited mid-round (code ${String(outcome.exitCode)}, signal ${String(outcome.signal)})`)), (error) => Promise.reject(thrown$1(error)));
+			processFailure.catch(() => {});
+			const resultPromise = Promise.race([resultEvent, processFailure]);
+			rt.turnChain = resultPromise;
+			const event = await resultPromise;
+			if (event["is_error"] === true) {
+				const message = typeof event["error"] === "string" ? event["error"] : "claude reported an error";
+				throw new Error(`subagent-claude live: ${message}`);
+			}
+			const output = collectOutput();
+			if (output.length === 0) throw new Error("subagent-claude live: the turn completed but produced no answer");
+			return {
+				output,
+				stopReason: "completed"
+			};
+		});
+		const result = settleRunResult({
+			attempt: () => Promise.race([attempt, abortBranch]),
+			collectOutput,
+			cancelled: () => runAbort.signal.aborted,
+			onError: (error, stopReason) => {
+				const diagnostics = runtime?.diagnostics ?? "";
+				const suffix = diagnostics === "" ? "" : `; ${diagnostics}`;
+				this.ctx.logger.warn(`subagent-claude: live round failed (${stopReason}): ${error.message}${suffix}`);
+			},
+			signal: request.signal,
+			onAbort
+		}).then(async (settled) => {
+			roundSettled = true;
+			liveFlush.dispose();
+			turnInFlight = false;
+			if (turnOpened) {
+				if (mirrored < parser.lines.length) mirrorUpTo(parser.lines.length, true);
+				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;
+				}
+				if (settled.stopReason === "completed") childSession.append("turn/end", {
+					turn,
+					reason: { kind: "completed" }
+				});
+				else if (settled.stopReason === "aborted") childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "aborted",
+						reason: { kind: "parent" }
+					}
+				});
+				else childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "error",
+						error: {
+							message: "the live round did not complete",
+							code: "UNKNOWN"
+						}
+					}
+				});
+			}
+			if (runtime !== void 0 && runtime.onEvent === onEvent && !awaitingResult) runtime.onEvent = void 0;
+			streamPublisher?.dispose();
+			if (turnOpened) {
+				persist();
+				await persistQueue;
+			}
+			return settled;
+		});
+		result.then(async () => {
+			try {
+				if (turnOpened) {
+					await persistQueue.catch(() => {});
+					localAgent?.reportRunProgress(childSession.id, {
+						kind: "mirror",
+						mirroredLines: mirrored
+					});
+				}
+			} finally {
+				if (turnOpened) {
+					const toolCalls = toolCallsOf(parser.toolCalls);
+					const round = {
+						...roundModel === void 0 ? {} : { observedModel: roundModel },
+						...roundCliVersion === void 0 ? {} : { cliVersion: roundCliVersion },
+						...parser.usage === void 0 ? {} : { usage: parser.usage },
+						...toolCalls === void 0 ? {} : { toolCalls }
+					};
+					localAgent?.recordRoundSettled?.(childSession.id, round);
+				}
+				this.armIdleTimer(String(childSession.id));
+			}
+		});
+		await Promise.race([accepted, abortBranch.catch(() => void 0)]);
+		return subprocessRunHandle({
+			id: childSession.id,
+			result,
+			signal: request.signal,
+			onAbort,
+			requestCancel,
+			teardown: async () => {
+				if (roundSettled) return;
+				await Promise.race([resultEvent.catch(() => ({})), delay(this.timeouts.convergeMs)]);
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/types/claude-cli-provider.js
+/**
+* One-shot Claude Code CLI subagent lifecycle: spawn `claude -p "<task>"`
+* through the subprocess seam under the harness's scoped home, capture its
+* JSON result as the run output, and dispose to whole-tree quiescence.
+* Mirrors the kimi/codex providers: every accepted run is a fresh process
+* and a fresh claude session; there is no continuation across runs.
+*
+* The provider name `claude-local` avoids colliding with the official
+* `subagent-claude-code` package's provider name `claude-code` — a
+* composition that mounts both would fail loud with DUPLICATE_PROVIDER. The
+* tool row in this bundle's patch takes the official model-facing name
+* `subagent_claude_code` instead: the official preset row ships disabled,
+* and the patch disables it too (a deliberate user re-enable conflicts
+* loud, by design).
+* @module @khorsheed/dsh-local-agent-claude-code/claude-cli-provider
+*/
+/** Default POSIX grace between subprocess termination tiers. */
+const DEFAULT_DISPOSE_GRACE_MS = 3e3;
+/**
+* Auth-shaped failure signatures in claude's result error or stderr: the
+* endpoint rejected the credential (401/403, revoked token). Narrow on
+* purpose — matched against provider-controlled error strings only.
+*/
+const CLAUDE_AUTH_FAILURE = /failed to authenticate|authentication_failed|oauth access token/i;
+/** Register one member run with the channel; see {@link ClaudeMemberRunHandle}. */
+function registerClaudeMemberRun(ctx, childSessionId, parentSessionId) {
+	const registry = ctx.localAgent;
+	if (typeof registry.registerMemberRun !== "function" || typeof registry.memberBridgeSocketPath !== "function" || typeof registry.memberBridgeCommand !== "function") return void 0;
+	const token = registry.registerMemberRun({
+		childSessionId,
+		parentSessionId,
+		provider: "claude-local"
+	});
+	const serverName = `dsh-member-${token.slice(0, 8)}`;
+	const bridge = registry.memberBridgeCommand();
+	const mcpConfig = JSON.stringify({ mcpServers: { [serverName]: {
+		command: bridge.command,
+		args: bridge.args,
+		env: {
+			[MEMBER_BRIDGE_SOCKET_ENV]: registry.memberBridgeSocketPath(),
+			[MEMBER_BRIDGE_TOKEN_ENV]: token
+		}
+	} } });
+	let released = false;
+	return {
+		token,
+		mcpConfig,
+		allowedTool: `mcp__${serverName}__member_message`,
+		release: () => {
+			if (released) return;
+			released = true;
+			registry.unregisterMemberRun(token);
+		}
+	};
+}
+/**
+* One-shot and resumable Claude Code CLI subagent provider: every accepted
+* FRESH run starts a `claude -p` process in the delegating Session's
+* workspace, under the harness scoped home; a resume round (the family tool's
+* staged resume intent) continues the SAME session with `claude -p --resume
+* <session_id>` inside the SAME dsh child session. With the live driver
+* configured (`live: true`), rounds instead go to the resident stream-json
+* process (see live-driver.ts); the exec path below stays the fallback.
+*/
+/**
+* Mark the harness credential verified after a completed round, degrading
+* silently on a core that predates the mark (the family's companion-pair
+* rule: a provider paired with an older core loses the grade, never the run).
+* @param ctx - host context carrying the family registry.
+*/
+function markCredentialVerified(ctx, scope) {
+	const registry = ctx.get("localAgent");
+	if (registry === void 0 || typeof registry.reportAuthSuccess !== "function") return;
+	registry.reportAuthSuccess("claude-code", scope);
+}
+/**
+* The version `claude --version` reports, probed through the shared subprocess
+* seam against the SCOPED config directory (never the user's own
+* installation) and cached by the family probe against the executable's
+* identity. The effective-settings snapshot uses it; a settled round prefers
+* the version its own stream named.
+* @param ctx - host context carrying the subprocess seam.
+* @param homeDir - the harness's scoped home.
+* @returns the version, or undefined when the CLI cannot be asked.
+*/
+function claudeCliVersion(ctx, homeDir) {
+	const subprocess = ctx.get("subprocess");
+	if (subprocess === void 0) return Promise.resolve(void 0);
+	return probeCliVersion({
+		argv: ["claude", "--version"],
+		cwd: homeDir,
+		spawn: (spec) => subprocess.spawn(spec),
+		env: delegationEnv({ CLAUDE_CONFIG_DIR: homeDir })
+	});
+}
+var ClaudeCliProvider = class {
+	ctx;
+	permissionMode;
+	baseUrl;
+	live;
+	model;
+	name = "claude-local";
+	capabilities = NO_START_CAPABILITIES;
+	inheritsParentContext = false;
+	/**
+	* @param live - the live driver, or a resolver returning the current
+	*   generation's driver per member (the settings toggle swaps generations;
+	*   a resolver may return undefined to steer one member's round to exec
+	*   while a retiring generation still hosts it).
+	* @param model - resolver for the member's effective model, read PER ROUND
+	*   so a settings-card write or a composer switch takes effect on the next
+	*   delegation without a reload. Receives the member (the child session id)
+	*   and the round's delegation-layer model, and answers in the family's
+	*   order — session-level override, delegation, settings. Absent (the
+	*   resolver not passed), the delegation's own model still rides, exactly
+	*   as before the key existed.
+	*/
+	constructor(ctx, permissionMode = "skip", baseUrl, live, model) {
+		this.ctx = ctx;
+		this.permissionMode = permissionMode;
+		this.baseUrl = baseUrl;
+		this.live = live;
+		this.model = model;
+	}
+	/** Resolve the live driver for one round's member, if live is on for it. */
+	liveDriver(childSessionId) {
+		const live = this.live;
+		if (live === void 0) return void 0;
+		return typeof live === "function" ? live(childSessionId) : live;
+	}
+	/** The round's model fragment for the exec spawn spec (see {@link resolveRoundModel}). */
+	roundModel(childSessionId, requestedModel) {
+		return resolveRoundModel(this.model === void 0 ? requestedModel : this.model(childSessionId, requestedModel));
+	}
+	/** Per-round member-channel registration for the exec path (see {@link registerClaudeMemberRun}). */
+	memberRun(childSessionId, parentSessionId) {
+		return registerClaudeMemberRun(this.ctx, childSessionId, parentSessionId);
+	}
+	async start(request) {
+		const intent = this.ctx.localAgent.takeDelegationIntent(request.parent.session.id, this.name);
+		const scope = intent?.scope;
+		const homeDir = this.ctx.localAgent.homeDir("claude-code", scope);
+		const cwd = resolveChildCwd(request.parent.session.header.cwd, intent?.cwd);
+		if (cwd === void 0) throw new Error("subagent-claude: the parent session has no working directory to run the CLI in");
+		const exec = intent?.exec;
+		if (exec !== void 0) containerScopedHome(exec, "CLAUDE_CONFIG_DIR", "subagent-claude");
+		if (intent !== void 0 && intent.kind === "resume") {
+			const record = this.ctx.localAgent.getDelegation(intent.childSessionId);
+			assertResumeCwdUnchanged(record, cwd, "subagent-claude");
+			assertResumeScopeUnchanged(record, scope, "subagent-claude");
+			if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") return this.startClaudeResume(request, intent, cwd, homeDir, exec, scope, record?.model);
+			return this.ctx.localAgent.withMemberConfigurationRound({
+				childSessionId: intent.childSessionId,
+				provider: this.name,
+				parentSessionId: request.parent.session.id,
+				cwd,
+				...scope === void 0 ? {} : { scope },
+				...record?.model === void 0 ? {} : { model: record.model },
+				...record?.effort === void 0 ? {} : { effort: record.effort },
+				...record?.configurationLock === void 0 ? {} : { configurationLock: record.configurationLock }
+			}, (configuration) => this.startClaudeResume(request, intent, cwd, homeDir, exec, scope, record?.model, configuration), request.signal, intent?.onAdmitted);
+		}
+		const childSessionId = SessionId(intent?.preparedMemberId ?? randomUUID());
+		if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") {
+			if (intent?.effort !== void 0) throw new Error("Claude effort requires the configuration admission core");
+			return this.startClaudeFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId);
+		}
+		return this.ctx.localAgent.withMemberConfigurationRound({
+			childSessionId,
+			provider: this.name,
+			parentSessionId: request.parent.session.id,
+			cwd,
+			...scope === void 0 ? {} : { scope },
+			...intent?.model === void 0 ? {} : { model: intent.model },
+			...intent?.effort === void 0 ? {} : { effort: intent.effort },
+			...intent?.configurationLock === void 0 ? {} : { configurationLock: intent.configurationLock }
+		}, (configuration) => this.startClaudeFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId, configuration), request.signal, intent?.onAdmitted);
+	}
+	/** Fresh round: record the child session, spawn `claude -p`, append after settle. */
+	async startClaudeFresh(request, cwd, homeDir, exec, scope, requestedModel, runId, configuration) {
+		let childSession;
+		try {
+			const sessions = this.ctx.get("sessions");
+			if (sessions === void 0) throw new Error("the sessions service is not mounted");
+			childSession = sessions.get(runId) ?? sessions.create(runId, { meta: {
+				cwd,
+				parentSession: request.parent.session.id,
+				origin: "subagent",
+				delegationDepth: (request.parent.session.header.delegationDepth ?? 0) + 1
+			} });
+			const harness = this.ctx.localAgent.get("claude-code");
+			const label = subagentDelegationLabel(harness?.displayName ?? "Claude Code", request.descriptor.label);
+			childSession.append("subagent/descriptor", {
+				...request.descriptor,
+				label
+			});
+			establishSubagentCatalogChild(request.parent.session, childSession.header, label);
+		} catch (error) {
+			this.ctx.logger.warn(`subagent-claude: subagent session record failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const effectiveBaseUrl = this.baseUrl ?? process.env.ANTHROPIC_BASE_URL;
+		this.ctx.logger.info(`subagent-claude: delegating via ${effectiveBaseUrl ?? "claude default endpoint"}`);
+		const live = exec === void 0 ? this.liveDriver(runId) : void 0;
+		if (live !== void 0 && childSession !== void 0 && !live.disabled) try {
+			return await live.startRound(request, {
+				cwd,
+				homeDir,
+				childSession,
+				...configuration === void 0 ? {} : { configuration: configuration.resolved },
+				parentSessionId: request.parent.session.id,
+				...requestedModel === void 0 ? {} : { model: requestedModel },
+				onSessionId: (sessionId) => {
+					this.ctx.localAgent.recordDelegation({
+						childSessionId: runId,
+						provider: this.name,
+						parentSessionId: request.parent.session.id,
+						cliSessionId: sessionId,
+						cwd,
+						...scope === void 0 ? {} : { scope },
+						...requestedModel === void 0 ? {} : { model: requestedModel }
+					});
+				}
+			});
+		} catch (error) {
+			if (!(error instanceof LiveChannelUnavailableError) || request.signal.aborted) throw error;
+			this.ctx.logger.warn(`subagent-claude: live driver unavailable, using the exec one-shot: ${error.message}`);
+		}
+		const member = exec === void 0 ? this.memberRun(runId, request.parent.session.id) : void 0;
+		try {
+			const run = await startClaudeCliRun(request, {
+				cwd,
+				env: delegationEnv({
+					CLAUDE_CONFIG_DIR: homeDir,
+					...this.baseUrl === void 0 ? {} : { ANTHROPIC_BASE_URL: this.baseUrl }
+				}),
+				...exec === void 0 ? {} : { exec },
+				endpointLabel: effectiveBaseUrl,
+				permissionMode: this.permissionMode,
+				...configuration?.resolved ?? this.roundModel(runId, requestedModel),
+				...configuration === void 0 ? {} : { controlled: true },
+				disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+				spawn: (spec) => this.ctx.subprocess.spawn(spec),
+				onError: (error, stopReason) => {
+					this.ctx.logger.warn(`subagent-claude: child run failed (${stopReason}) via ${effectiveBaseUrl ?? "claude default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+				},
+				onAuthFailure: (detail) => {
+					this.ctx.localAgent.reportAuthFailure("claude-code", detail, scope);
+				},
+				onAuthSuccess: () => {
+					markCredentialVerified(this.ctx, scope);
+				},
+				cliVersion: () => claudeCliVersion(this.ctx, homeDir),
+				...member === void 0 ? {} : { member: {
+					mcpConfig: member.mcpConfig,
+					allowedTool: member.allowedTool
+				} },
+				childSession,
+				ctx: this.ctx,
+				onSessionId: (sessionId) => {
+					if (sessionId === void 0) return;
+					this.ctx.localAgent.recordDelegation({
+						childSessionId: runId,
+						provider: this.name,
+						parentSessionId: request.parent.session.id,
+						cliSessionId: sessionId,
+						cwd,
+						...scope === void 0 ? {} : { scope },
+						...requestedModel === void 0 ? {} : { model: requestedModel }
+					});
+				},
+				onRoundSettled: (round) => {
+					this.ctx.localAgent.recordRoundSettled(runId, round);
+				}
+			});
+			if (member !== void 0) run.result.then(member.release, member.release);
+			return run;
+		} catch (error) {
+			member?.release();
+			throw error;
+		}
+	}
+	/** Resume round: continue the recorded claude session inside the existing child session. */
+	async startClaudeResume(request, intent, cwd, homeDir, exec, scope, requestedModel, configuration) {
+		if (!this.ctx.localAgent.acquireResumeLock(intent.childSessionId)) throw new Error(`subagent-claude: 该子会话有进行中的委派，等其完成后再追问 (child session ${intent.childSessionId})`);
+		try {
+			const childSession = this.ctx.get("sessions")?.get(SessionId(intent.childSessionId));
+			if (childSession === void 0) throw new Error(`subagent-claude: resume target child session ${intent.childSessionId} is not live — start a fresh delegation instead`);
+			const nextTurn = childSession.snapshotEvents().filter((event) => event.type === "turn/start").length + 1;
+			const live = exec === void 0 ? this.liveDriver(intent.childSessionId) : void 0;
+			if (live !== void 0 && !live.disabled) try {
+				const liveRun = await live.startRound(request, {
+					cwd,
+					homeDir,
+					childSession,
+					...configuration === void 0 ? {} : { configuration: configuration.resolved },
+					parentSessionId: request.parent.session.id,
+					resume: {
+						cliSessionId: intent.cliSessionId,
+						turn: nextTurn
+					},
+					...requestedModel === void 0 ? {} : { model: requestedModel }
+				});
+				liveRun.result.then(() => {
+					this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				}, () => {
+					this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				});
+				return liveRun;
+			} catch (error) {
+				if (!(error instanceof LiveChannelUnavailableError) || request.signal.aborted) throw error;
+				this.ctx.logger.warn(`subagent-claude: live driver unavailable, using the exec one-shot: ${error.message}`);
+			}
+			const effectiveBaseUrl = this.baseUrl ?? process.env.ANTHROPIC_BASE_URL;
+			this.ctx.logger.info(`subagent-claude: resuming via ${effectiveBaseUrl ?? "claude default endpoint"}`);
+			const member = exec === void 0 ? this.memberRun(intent.childSessionId, request.parent.session.id) : void 0;
+			let run;
+			try {
+				run = await startClaudeCliRun(request, {
+					cwd,
+					env: delegationEnv({
+						CLAUDE_CONFIG_DIR: homeDir,
+						...this.baseUrl === void 0 ? {} : { ANTHROPIC_BASE_URL: this.baseUrl }
+					}),
+					...exec === void 0 ? {} : { exec },
+					endpointLabel: effectiveBaseUrl,
+					permissionMode: this.permissionMode,
+					...configuration?.resolved ?? this.roundModel(intent.childSessionId, requestedModel),
+					...configuration === void 0 ? {} : { controlled: true },
+					disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+					spawn: (spec) => this.ctx.subprocess.spawn(spec),
+					onError: (error, stopReason) => {
+						this.ctx.logger.warn(`subagent-claude: child run failed (${stopReason}) via ${effectiveBaseUrl ?? "claude default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+					},
+					onAuthFailure: (detail) => {
+						this.ctx.localAgent.reportAuthFailure("claude-code", detail, scope);
+					},
+					onAuthSuccess: () => {
+						markCredentialVerified(this.ctx, scope);
+					},
+					cliVersion: () => claudeCliVersion(this.ctx, homeDir),
+					...member === void 0 ? {} : { member: {
+						mcpConfig: member.mcpConfig,
+						allowedTool: member.allowedTool
+					} },
+					childSession,
+					ctx: this.ctx,
+					resume: {
+						cliSessionId: intent.cliSessionId,
+						turn: nextTurn
+					},
+					onRoundSettled: (round) => {
+						this.ctx.localAgent.recordRoundSettled(intent.childSessionId, round);
+					}
+				});
+			} catch (error) {
+				member?.release();
+				throw error;
+			}
+			run.result.then(() => {
+				this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				member?.release();
+			}, () => {
+				this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+				member?.release();
+			});
+			return run;
+		} catch (error) {
+			this.ctx.localAgent.releaseResumeLock(intent.childSessionId);
+			throw error;
+		}
+	}
+};
+function thrown(value) {
+	/* v8 ignore next -- typed subprocess failures reject with Error. */
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Validate and join the one-shot task before crossing the process boundary.
+* @param prompt - task content accepted from the shared subagent service.
+* @returns the joined non-empty text.
+*/
+function textTask(prompt) {
+	if (prompt.length === 0) throw new Error("subagent-claude: the one-shot task must contain only text blocks");
+	const texts = [];
+	for (const block of prompt) {
+		if (block.type !== "text") throw new Error("subagent-claude: the one-shot task must contain only text blocks");
+		texts.push(block.text);
+	}
+	if (texts.every((text) => text.trim().length === 0)) throw new Error("subagent-claude: the one-shot task must not be empty");
+	return texts.join("\n");
+}
+/**
+* Fold a tool-call counter into the settled shape: `{count, byName}` with the
+* per-name values summing to `count`. An empty map yields undefined — a
+* stream that named no tool call reports nothing rather than a zero it did
+* not observe.
+* @param counts - the fold's per-name tally.
+* @returns the settled accounting, or undefined when nothing was counted.
+*/
+function toolCallsOf(counts) {
+	if (counts.size === 0) return void 0;
+	let count = 0;
+	const byName = {};
+	for (const [name, value] of counts) {
+		count += value;
+		byName[name] = value;
+	}
+	return {
+		count,
+		byName
+	};
+}
+/**
+* Translate one TodoWrite tool input into the dsh whole-list snapshot.
+* Claude's documented schema is `{todos: [{content, status, activeForm}]}`
+* with status `pending | in_progress | completed` — dsh's TodoItem vocabulary
+* minus `activeForm` (display-only). Unknown statuses map to `pending`; a
+* shape-skewed input returns undefined and the caller degrades to the plain
+* text fold — shape skew must never throw into the mirror.
+* @param input - the tool_use block's `input` payload.
+* @returns the dsh todo list, or undefined on shape skew.
+*/
+function todosFromTodoWrite(input) {
+	if (typeof input !== "object" || input === null) return void 0;
+	const todos = input.todos;
+	if (!Array.isArray(todos)) return void 0;
+	const out = [];
+	for (const item of todos) {
+		if (typeof item !== "object" || item === null) return void 0;
+		const content = item.content;
+		if (typeof content !== "string" || content.trim() === "") return void 0;
+		const status = item.status;
+		out.push({
+			content,
+			status: status === "in_progress" || status === "completed" ? status : "pending"
+		});
+	}
+	return out;
+}
+/**
+* Append the todo/write snapshot unless the child session's last snapshot is
+* identical — the M2 dsh mirror's JSON-comparison idempotency: repeated passes
+* over the same state never duplicate it. The comparison base is the whole
+* log, not the current round: a standing whole-list snapshot has no round
+* scope, so a resume round with an unchanged list re-appends nothing and the
+* earlier round's list keeps standing.
+* @param childSession - the parent-side dsh subagent session.
+* @param todos - the translated whole list.
+* @returns whether a snapshot was appended.
+*/
+function appendTodosIfChanged(childSession, todos) {
+	const last = childSession.snapshotEvents().filter((event) => event.type === "todo/write").at(-1);
+	if (last !== void 0 && JSON.stringify(last.data) === JSON.stringify({ todos })) return false;
+	childSession.append("todo/write", { todos });
+	return true;
+}
+/**
+* The CLI version named by a `system` init event's `claude_code_version`.
+* claude 2.1.x serializes its whole build-info module there
+* (`{ VERSION, BUILD_TIME, GIT_SHA, … }`), so the version is a field of it; a
+* future release that emits a bare string is accepted unchanged. Anything
+* else yields undefined and the probe answers instead.
+* @param value - the event's `claude_code_version` field.
+* @returns the version string, or undefined.
+*/
+function claudeVersionFromInit(value) {
+	if (typeof value === "string" && value !== "") return value;
+	if (typeof value !== "object" || value === null) return void 0;
+	const version = value.VERSION;
+	return typeof version === "string" && version !== "" ? version : void 0;
+}
+/**
+* Fold one NDJSON line into the stream state. Shared by
+* {@link parseClaudeStreamJson} (settle-time whole-stream parse) and
+* {@link ClaudeStreamParser} (live incremental parse) so the two paths cannot
+* drift.
+*/
+function foldClaudeStreamLine(state, raw) {
+	const line = raw.trim();
+	if (line === "") return;
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (event.type === "system" && typeof event.session_id === "string") {
+		state.sessionId = event.session_id;
+		if (typeof event.model === "string" && event.model !== "") state.model = event.model;
+		const version = claudeVersionFromInit(event.claude_code_version);
+		if (version !== void 0) state.cliVersion = version;
+		return;
+	}
+	if (event.type === "result") {
+		state.completed = true;
+		if (event.is_error === true) state.error = typeof event.result === "string" ? event.result : typeof event.error === "string" ? event.error : "claude -p reported an error";
+		if (typeof event.session_id === "string") state.sessionId = event.session_id;
+		if (typeof event.model === "string" && event.model !== "") state.model = event.model;
+		if (event.usage !== void 0) state.usage = usageFromClaude(event.usage);
+		return;
+	}
+	if (event.type !== "assistant" && event.type !== "user") return;
+	const blocks = event.message?.content ?? [];
+	for (const [blockIndex, block] of blocks.entries()) {
+		if (typeof block !== "object" || block === null) continue;
+		const record = block;
+		const identity = event.type === "assistant" && typeof event.message?.id === "string" ? { streamId: `${event.message.id}:${blockIndex}` } : {};
+		const kind = record["type"];
+		if (kind === "text" && typeof record["text"] === "string" && record["text"].trim() !== "") {
+			state.lines.push({
+				kind: "text",
+				text: record["text"],
+				...identity
+			});
+			if (event.type === "assistant") state.text = record["text"];
+		} else if (kind === "thinking" && typeof record["thinking"] === "string" && record["thinking"].trim() !== "") state.lines.push({
+			kind: "think",
+			text: record["thinking"],
+			...identity
+		});
+		else if (kind === "redacted_thinking") state.lines.push({
+			kind: "think",
+			text: REDACTED_THINKING_TEXT,
+			...identity
+		});
+		else if (kind === "tool_use" || kind === "server_tool_use") {
+			const name = typeof record["name"] === "string" ? record["name"] : "tool";
+			state.toolCalls.set(name, (state.toolCalls.get(name) ?? 0) + 1);
+			if (name === "TodoWrite") {
+				const todos = todosFromTodoWrite(record["input"]);
+				if (todos !== void 0) {
+					state.todos = todos;
+					continue;
+				}
+				state.todoSkew = true;
+			}
+			const id = typeof record["id"] === "string" ? record["id"] : void 0;
+			if (id !== void 0) state.callsById.set(id, state.lines.length);
+			const edit = kind === "tool_use" ? editToolDetail(name, record["input"]) : void 0;
+			if (edit !== void 0) state.lines.push({
+				kind: "tool",
+				id: id ?? `claude-tool-${state.lines.length}`,
+				name: "ApplyPatch",
+				args: edit.args,
+				...edit.patch === void 0 ? {} : { result: edit.patch }
+			});
+			else {
+				const detail = inputDetail(record["input"]);
+				state.lines.push({
+					kind: "tool",
+					id: id ?? `claude-tool-${state.lines.length}`,
+					name: kind === "server_tool_use" ? SERVER_TOOL_CARD_NAMES[name] ?? name : name,
+					...detail === void 0 ? {} : { args: detail }
+				});
+			}
+		} else if (kind === "tool_result") {
+			const resultText = toolResultText(record["content"]);
+			if (resultText !== void 0 && resultText.trim() !== "") attachToolResult(state, record["tool_use_id"], resultText, record["is_error"] === true);
+		} else if (kind === "web_search_tool_result" || kind === "web_fetch_tool_result") {
+			const resultText = serverToolResultText(record);
+			if (resultText !== void 0 && resultText.trim() !== "") attachToolResult(state, record["tool_use_id"], resultText, false);
+		}
+	}
+}
+/**
+* Merge a tool result into its call line: pair by tool_use_id when the stream
+* carries it, else the most recent tool line so an id-less stream still lands
+* the result on its call. A line already carrying a body (an edit tool's
+* patch) keeps it — the status text adds nothing to a successful edit — but
+* an error result always appends, since a failed edit's message is the point.
+*/
+function attachToolResult(state, useId, resultText, isError) {
+	let target = typeof useId !== "string" ? void 0 : state.callsById.get(useId);
+	if (target === void 0) {
+		for (let index = state.lines.length - 1; index >= 0; index -= 1) if (state.lines[index]?.kind === "tool") {
+			target = index;
+			break;
+		}
+	}
+	if (target === void 0) return;
+	const last = state.lines[target];
+	if (last === void 0 || last.kind !== "tool") return;
+	if (last.result === void 0) state.lines[target] = {
+		...last,
+		result: resultText
+	};
+	else if (isError) state.lines[target] = {
+		...last,
+		result: `${last.result}\n${resultText}`
+	};
+}
+/**
+* Incremental `claude --output-format stream-json` parser: feed stdout chunks
+* as they arrive and the folded transcript accumulates line by line. The last
+* line is volatile until the terminal `result` event — a `tool_result` merges
+* into a pending tool line — so live consumers hold it back (see the run's
+* live mirror).
+*/
+var ClaudeStreamParser = class {
+	buffer = "";
+	lines = [];
+	callsById = /* @__PURE__ */ new Map();
+	text;
+	usage;
+	sessionId;
+	model;
+	cliVersion;
+	error;
+	completed = false;
+	todos;
+	todoSkew = false;
+	toolCalls = /* @__PURE__ */ new Map();
+	/** Fold every complete NDJSON line in the chunk; the tail stays buffered. */
+	push(chunk) {
+		this.buffer += chunk;
+		const parts = this.buffer.split("\n");
+		this.buffer = parts.pop() ?? "";
+		for (const raw of parts) foldClaudeStreamLine(this, raw);
+	}
+};
+/**
+* Parse a `claude -p --verbose --output-format stream-json` NDJSON stream.
+* Each line is one event: `system` init (carries the session id and the
+* model), `assistant` (content blocks: `text`, `tool_use`, `thinking`), `user`
+* (a `tool_result` block), and a terminal `result` (final usage, error flag,
+* session id). Content blocks fold into an ordered transcript (thinking,
+* reply text, tool calls with results), the last assistant `text` becomes the
+* run output, and the `result` event's usage/session id ride the parse. The
+* model identifier comes from the init (or result) event's `model` field. A
+* malformed stream or an `is_error` result yields the error instead.
+* @param output - the collected stdout NDJSON text.
+* @returns the ordered transcript, final answer text, usage, session id, the
+*   observed model, and the error when the run reported one.
+*/
+function parseClaudeStreamJson(output) {
+	const state = {
+		lines: [],
+		callsById: /* @__PURE__ */ new Map(),
+		toolCalls: /* @__PURE__ */ new Map(),
+		text: void 0,
+		usage: void 0,
+		sessionId: void 0,
+		model: void 0,
+		cliVersion: void 0,
+		error: void 0,
+		completed: false,
+		todos: void 0,
+		todoSkew: false
+	};
+	for (const raw of output.split("\n")) foldClaudeStreamLine(state, raw);
+	const toolCalls = toolCallsOf(state.toolCalls);
+	return {
+		lines: state.lines,
+		...state.text === void 0 ? {} : { text: state.text },
+		...state.usage === void 0 ? {} : { usage: state.usage },
+		...state.error === void 0 ? {} : { error: state.error },
+		...state.sessionId === void 0 ? {} : { sessionId: state.sessionId },
+		...state.cliVersion === void 0 ? {} : { cliVersion: state.cliVersion },
+		...state.model === void 0 ? {} : { model: state.model },
+		...state.todos === void 0 ? {} : { todos: state.todos },
+		...state.todoSkew === false ? {} : { todoSkew: true },
+		...toolCalls === void 0 ? {} : { toolCalls }
+	};
+}
+/** The placeholder think line for a `redacted_thinking` block (content is server-encrypted by design). */
+const REDACTED_THINKING_TEXT = "（思考内容已由服务端隐藏：redacted_thinking，内容按设计不可见，此行仅标示它存在）";
+/** Server-side tool_use names map to the card names of their local-tool twins. */
+const SERVER_TOOL_CARD_NAMES = {
+	web_search: "WebSearch",
+	web_fetch: "WebFetch"
+};
+/** Render a tool_use input payload as a compact command/query line. */
+function inputDetail(input) {
+	if (input === void 0) return void 0;
+	if (typeof input === "string") return input.trim() === "" ? void 0 : input.trim();
+	if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+	const record = input;
+	for (const key of [
+		"command",
+		"query",
+		"url",
+		"path"
+	]) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim() !== "") return value.trim();
+	}
+	const json = JSON.stringify(record);
+	if (json === "{}") return void 0;
+	return json.length <= 160 ? json : `${json.slice(0, 160)}…`;
+}
+/**
+* The actual edit behind an Edit/Write/MultiEdit/NotebookEdit tool_use, for
+* the apply-patch-style card (codex's fileChange idiom: `kind: path` args,
+* the patch as the body). Edit and MultiEdit synthesize `-`-/`+`-prefixed
+* old/new lines; Write and NotebookEdit carry the whole new body verbatim.
+* Undefined for any other tool or a shape-skewed input (the caller then
+* keeps the one-scalar summary).
+* @param name - the tool_use block's `name`.
+* @param input - the tool_use block's `input` payload.
+* @returns the card args and patch body, or undefined.
+*/
+function editToolDetail(name, input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+	const record = input;
+	const pathOf = (key) => {
+		const value = record[key];
+		return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+	};
+	const hunk = (oldString, newString) => {
+		if (typeof oldString !== "string" || typeof newString !== "string") return void 0;
+		return [...oldString.split("\n").map((line) => `- ${line}`), ...newString.split("\n").map((line) => `+ ${line}`)].join("\n");
+	};
+	if (name === "Edit") {
+		const path = pathOf("file_path");
+		if (path === void 0) return void 0;
+		const patch = hunk(record["old_string"], record["new_string"]);
+		return {
+			args: `update: ${path}`,
+			...patch === void 0 ? {} : { patch }
+		};
+	}
+	if (name === "MultiEdit") {
+		const path = pathOf("file_path");
+		if (path === void 0) return void 0;
+		const patch = (Array.isArray(record["edits"]) ? record["edits"] : []).map((edit) => hunk(edit["old_string"], edit["new_string"])).filter((entry) => entry !== void 0).join("\n\n");
+		return {
+			args: `update: ${path}`,
+			...patch === "" ? {} : { patch }
+		};
+	}
+	if (name === "Write") {
+		const path = pathOf("file_path");
+		if (path === void 0) return void 0;
+		const content = record["content"];
+		return {
+			args: `update: ${path}`,
+			...typeof content === "string" && content !== "" ? { patch: content } : {}
+		};
+	}
+	if (name === "NotebookEdit") {
+		const path = pathOf("notebook_path");
+		if (path === void 0) return void 0;
+		const source = record["new_source"];
+		return {
+			args: `update: ${path}`,
+			...typeof source === "string" && source !== "" ? { patch: source } : {}
+		};
+	}
+}
+/** Cap for a fetched page's text on a WebFetch card — the log stays a log. */
+const WEB_FETCH_TEXT_LIMIT = 4e3;
+/**
+* Flatten a server-side web tool result block to card text. A search folds
+* its hits as `title — url` lines (an error block as `error: <code>`); a
+* fetch folds the page text capped at {@link WEB_FETCH_TEXT_LIMIT}. Undefined
+* when the block carries nothing readable — the pending call line then simply
+* stays result-less, never dropped.
+* @param record - the `web_search_tool_result` / `web_fetch_tool_result` block.
+* @returns the card text, or undefined.
+*/
+function serverToolResultText(record) {
+	const content = record["content"];
+	if (Array.isArray(content)) {
+		const lines = content.map((item) => {
+			if (typeof item !== "object" || item === null) return void 0;
+			const entry = item;
+			if (entry["type"] === "web_search_tool_result_error") return `error: ${typeof entry["error_code"] === "string" ? entry["error_code"] : "unknown"}`;
+			if (entry["type"] === "web_search_result") {
+				const title = typeof entry["title"] === "string" ? entry["title"] : "";
+				const url = typeof entry["url"] === "string" ? entry["url"] : "";
+				if (title === "" && url === "") return void 0;
+				return title === "" ? url : `${title} — ${url}`;
+			}
+		}).filter((line) => line !== void 0);
+		return lines.length === 0 ? void 0 : lines.join("\n");
+	}
+	if (typeof content === "object" && content !== null) {
+		const entry = content;
+		if (entry["type"] === "web_fetch_tool_result_error") return `error: ${typeof entry["error_code"] === "string" ? entry["error_code"] : "unknown"}`;
+		const url = typeof entry["url"] === "string" ? entry["url"] : void 0;
+		const body = typeof entry["content"] === "string" ? entry["content"] : void 0;
+		return [url, body === void 0 ? void 0 : body.length <= WEB_FETCH_TEXT_LIMIT ? body : `${body.slice(0, WEB_FETCH_TEXT_LIMIT)}\n…`].filter((part) => part !== void 0 && part !== "").join("\n") || void 0;
+	}
+}
+/** Flatten a tool_result content payload (string or block array) to text. */
+function toolResultText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return void 0;
+	return content.filter((block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join("\n");
+}
+/**
+* Map claude's usage payload onto the shared usage contract. Claude's
+* `input_tokens` is the uncached input; cache reads and cache creation are
+* reported separately, so each maps to its own bucket with no subtraction.
+* @param usage - the raw claude usage object.
+* @returns the shared usage record.
+*/
+function usageFromClaude(usage) {
+	const raw = usage;
+	if (raw === void 0 || typeof raw !== "object") return {
+		inputTokens: 0,
+		outputTokens: 0
+	};
+	const num = (value) => {
+		const n = Number(value);
+		return Number.isFinite(n) ? n : void 0;
+	};
+	const input = num(raw.input_tokens);
+	const output = num(raw.output_tokens);
+	const cacheRead = num(raw.cache_read_input_tokens);
+	const cacheWrite = num(raw.cache_creation_input_tokens);
+	const usageRecord = {
+		inputTokens: input ?? 0,
+		outputTokens: output ?? 0
+	};
+	if (cacheRead !== void 0 && cacheRead > 0) usageRecord.cacheReadTokens = cacheRead;
+	if (cacheWrite !== void 0 && cacheWrite > 0) usageRecord.cacheWriteTokens = cacheWrite;
+	return usageRecord;
+}
+/**
+* Start the real `claude -p` child and publish its run. The claude
+* result arrives as an NDJSON event stream on stdout (`--verbose
+* --output-format stream-json`): assistant content blocks (text, tool_use,
+* thinking), user tool_result blocks, and a terminal result event carrying
+* usage and session id. stderr is piped for diagnostics and never folded
+* into the run output. A resume round spawns `claude -p --resume
+* <session_id>` instead, continuing the same session. The run id is the
+* child session id for a session-backed run.
+* @param request - resolved shared subagent request.
+* @param spec - workspace, environment, process service, and diagnostic policy.
+* @returns the published run after the child starts.
+*/
+async function startClaudeCliRun(request, spec) {
+	const task = textTask(request.prompt);
+	if (request.signal.aborted) throw new Error("subagent-claude: request was aborted before the CLI started");
+	const configDir = spec.env["CLAUDE_CONFIG_DIR"];
+	if (configDir !== void 0) await syncClaudeCredentialFile(configDir, (message) => {
+		spec.ctx?.logger.warn(message);
+	}).catch(() => false);
+	const turn = spec.resume?.turn ?? 1;
+	const memberArgv = spec.member === void 0 ? [] : [
+		"--mcp-config",
+		spec.member.mcpConfig,
+		"--allowedTools",
+		spec.member.allowedTool,
+		"--"
+	];
+	const modelArgv = spec.model === void 0 ? [] : ["--model", spec.model];
+	const argv = spec.resume === void 0 ? spec.permissionMode === "skip" ? [
+		"claude",
+		"-p",
+		"--dangerously-skip-permissions",
+		"--verbose",
+		...modelArgv,
+		"--output-format",
+		"stream-json",
+		...memberArgv,
+		task
+	] : [
+		"claude",
+		"-p",
+		"--verbose",
+		...modelArgv,
+		"--output-format",
+		"stream-json",
+		...memberArgv,
+		task
+	] : spec.permissionMode === "skip" ? [
+		"claude",
+		"-p",
+		"--dangerously-skip-permissions",
+		"--verbose",
+		...modelArgv,
+		"--resume",
+		spec.resume.cliSessionId,
+		"--output-format",
+		"stream-json",
+		...memberArgv,
+		task
+	] : [
+		"claude",
+		"-p",
+		"--verbose",
+		...modelArgv,
+		"--resume",
+		spec.resume.cliSessionId,
+		"--output-format",
+		"stream-json",
+		...memberArgv,
+		task
+	];
+	const env = spec.controlled ? {
+		...spec.env,
+		CLAUDE_CODE_EFFORT_LEVEL: spec.effort ?? "auto"
+	} : spec.env;
+	const launch = spec.exec === void 0 ? {
+		argv,
+		env
+	} : containerExecSpawn(spec.exec, {
+		argv,
+		env
+	}, "subagent-claude");
+	const child = spec.spawn({
+		argv: launch.argv,
+		cwd: spec.cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe"
+		},
+		graceMs: spec.disposeGraceMs,
+		env: launch.env
+	});
+	spec.childSession?.append("turn/start", { turn });
+	const liveMirror = spec.childSession !== void 0 && spec.ctx !== void 0 ? createClaudeLiveMirror(spec, task, turn) : void 0;
+	let output = "";
+	child.stdout?.on("data", (chunk) => {
+		const text = chunk.toString();
+		output += text;
+		liveMirror?.push(text);
+	});
+	let stderr = "";
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+	});
+	const disposeProcess = async () => {
+		child.terminate();
+		await child.waitForExit().catch(() => false);
+		await child.done.catch(() => {});
+	};
+	const runAbort = new AbortController();
+	const requestCancel = () => {
+		if (runAbort.signal.aborted) return;
+		runAbort.abort(/* @__PURE__ */ new Error("subagent-claude: run cancelled locally"));
+	};
+	const onAbort = () => {
+		requestCancel();
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	const abortBranch = new Promise((_, reject) => {
+		runAbort.signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("subagent-claude: run cancelled locally")), { once: true });
+	});
+	const processFailure = child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-claude: CLI exited before the run settled (code ${String(outcome.exitCode)}, signal ${String(outcome.signal)})`)), (error) => Promise.reject(thrown(error)));
+	processFailure.catch(() => {});
+	const collectOutput = () => {
+		const drained = child.collected.stdout?.readFrom(0).text;
+		const text = parseClaudeStreamJson(drained !== void 0 && drained !== "" ? drained : output).text?.trim();
+		return text === void 0 || text === "" ? [] : [{
+			type: "text",
+			text
+		}];
+	};
+	let exitCode = null;
+	const result = settleRunResult({
+		attempt: () => Promise.race([
+			child.done.then((outcome) => {
+				if (outcome.exitCode !== 0) {
+					const via = spec.endpointLabel ?? "claude default endpoint";
+					exitCode = outcome.exitCode;
+					throw new Error(`subagent-claude: claude -p exited with code ${String(outcome.exitCode)} via ${via}`);
+				}
+				const output = collectOutput();
+				if (output.length === 0) throw new Error("subagent-claude: claude -p exited 0 but produced no answer");
+				return {
+					output,
+					stopReason: "completed"
+				};
+			}),
+			processFailure,
+			abortBranch
+		]),
+		collectOutput,
+		cancelled: () => runAbort.signal.aborted,
+		onError: spec.onError,
+		signal: request.signal,
+		onAbort
+	}).then((settled) => {
+		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
+		if (spec.childSession !== void 0) {
+			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
+				turn,
+				reason: { kind: "completed" }
+			});
+			else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "aborted",
+					reason: { kind: "parent" }
+				}
+			});
+			else {
+				const parsed = parseClaudeStreamJson(output);
+				spec.childSession.append("turn/end", {
+					turn,
+					reason: {
+						kind: "error",
+						error: {
+							message: parsed.error ?? `claude -p exited with code ${String(exitCode)}`,
+							code: "UNKNOWN"
+						}
+					}
+				});
+			}
+		}
+		return settled;
+	});
+	result.then(() => child.done).then(() => {
+		if (spec.onAuthFailure !== void 0) {
+			const drainedStderr = child.collected.stderr?.readFrom(0).text || stderr;
+			const authDetail = `${parseClaudeStreamJson(child.collected.stdout?.readFrom(0).text || output).error ?? ""}\n${drainedStderr}`;
+			if (CLAUDE_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
+		}
+		return mirrorClaudeAfterExit(spec, task, turn, output, liveMirror);
+	}, () => {});
+	return Promise.resolve(subprocessRunHandle({
+		id: spec.childSession?.id ?? SessionId(randomUUID()),
+		result,
+		signal: request.signal,
+		onAbort,
+		requestCancel,
+		teardown: disposeProcess
+	}));
+}
+/** One assistant-role message event, attributed to the claude route. */
+function assistantEvent(blocks) {
+	return createAssistantMessage({
+		content: blocks,
+		source: {
+			provider: "claude-local",
+			model: "claude"
+		}
+	});
+}
+/**
+* Fold one transcript line into the child session as one assistant step,
+* 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 line's 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). Tool cards escape that
+* fate only because their definition does not consult the step location.
+*/
+function appendClaudeTranscriptLine(childSession, turn, step, line, usage) {
+	childSession.append("step/start", {
+		turn,
+		step
+	});
+	if (line.kind === "tool") {
+		const call = childSession.append("tool/call", {
+			turn,
+			step,
+			callId: line.id,
+			name: line.name,
+			arguments: line.args ?? ""
+		});
+		if (line.result !== void 0) childSession.append("tool/result", {
+			turn,
+			step,
+			message: createToolResultMessage({
+				callId: line.id,
+				content: [{
+					type: "text",
+					text: line.result
+				}],
+				isError: false
+			})
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: [call.seq]
+		});
+		childSession.append("step/end", {
+			turn,
+			step
+		});
+		return;
+	}
+	const blocks = line.kind === "think" ? [{
+		type: "reasoning",
+		text: line.text
+	}] : [{
+		type: "text",
+		text: line.text
+	}];
+	childSession.append("assistant/message", {
+		turn,
+		step,
+		message: assistantEvent(blocks),
+		stream: [],
+		...usage === void 0 ? {} : { usage }
+	}, { surfaceOp: "append" });
+	childSession.append("step/end", {
+		turn,
+		step
+	});
+}
+/**
+* Fold one transcript line into the run's child session as one assistant step.
+*/
+function appendClaudeLine(spec, turn, step, line, usage) {
+	if (spec.childSession === void 0) return;
+	appendClaudeTranscriptLine(spec.childSession, turn, step, line, usage);
+}
+/** The delta-progress text for one transcript line. */
+function claudeLineText(line) {
+	return line.kind === "tool" ? `[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}${line.result !== void 0 ? ` → ${line.result}` : ""}` : line.text;
+}
+/** Create the per-run live mirror over the incremental parser. */
+function createClaudeLiveMirror(spec, task, turn) {
+	const parser = new ClaudeStreamParser();
+	const childSession = spec.childSession;
+	const ctx = spec.ctx;
+	let mirrored = 0;
+	let userMirrored = false;
+	let lastTodos;
+	let todoSkewWarned = false;
+	let queue = Promise.resolve();
+	const mirror = {
+		get mirroredLines() {
+			return mirrored;
+		},
+		get userMirrored() {
+			return userMirrored;
+		},
+		enqueue(task) {
+			queue = queue.then(task);
+			return queue;
+		},
+		push(chunk) {
+			parser.push(chunk);
+			if (parser.todos !== void 0 && parser.todos !== lastTodos) {
+				lastTodos = parser.todos;
+				appendTodosIfChanged(childSession, parser.todos);
+			}
+			if (parser.todoSkew && !todoSkewWarned) {
+				todoSkewWarned = true;
+				ctx.logger.warn("subagent-claude: a TodoWrite call missed the documented input shape; folded as a plain tool line");
+			}
+			const upto = parser.completed ? parser.lines.length : parser.lines.length - 1;
+			if (upto <= mirrored) return;
+			mirror.enqueue(async () => {
+				try {
+					const localAgent = ctx.get("localAgent");
+					if (!userMirrored) {
+						userMirrored = true;
+						childSession.append("user/message", createUserMessage({
+							content: [{
+								type: "text",
+								text: task
+							}],
+							source: { kind: "user" }
+						}), { surfaceOp: "append" });
+						localAgent?.reportRunProgress(childSession.id, {
+							kind: "delta",
+							text: task
+						});
+					}
+					let carrier = -1;
+					if (parser.completed && parser.usage !== void 0) {
+						for (let scan = 0; scan < parser.lines.length; scan += 1) if (parser.lines[scan]?.kind !== "tool") carrier = scan;
+					}
+					for (let index = mirrored; index < upto; index += 1) {
+						const line = parser.lines[index];
+						if (line === void 0) continue;
+						const usage = index === carrier ? parser.usage : void 0;
+						appendClaudeLine(spec, turn, index + 1, line, usage);
+						mirrored = index + 1;
+						localAgent?.reportRunProgress(childSession.id, {
+							kind: "delta",
+							text: claudeLineText(line)
+						});
+					}
+					await persistChildSession(ctx, childSession);
+					localAgent?.reportRunProgress(childSession.id, {
+						kind: "mirror",
+						mirroredLines: mirrored
+					});
+				} catch (error) {
+					ctx.logger.warn(`subagent-claude: live mirror failed: ${thrown(error).message}`);
+				}
+			});
+		}
+	};
+	return mirror;
+}
+/**
+* Mirror the delegation's user prompt and the claude stream transcript into
+* the dsh subagent session, then persist. Runs detached from the settle race —
+* the run result settles with the child exit, and a failure here is
+* diagnostic-only. The transcript's thinking folds to `reasoning` blocks,
+* reply text and tool activity (call with command plus result) to text
+* blocks, and the final assistant message carries the round's usage when
+* claude reported it, so the tokenUsage projection counts the delegation.
+* @param spec - the run spec carrying the child session and host context.
+* @param task - the one-shot task text (the user prompt).
+* @param turn - the round's turn number (1 for a fresh round, incremented on resume).
+* @param parsed - the parsed stream transcript, final output, and usage.
+* @param fromLines - transcript lines the live mirror already appended.
+* @param userMirrored - whether the live mirror already appended the prompt.
+*/
+async function appendClaudeResponse(spec, task, turn, parsed, fromLines = 0, userMirrored = false) {
+	if (spec.childSession === void 0 || spec.ctx === void 0) return;
+	const childSession = spec.childSession;
+	const localAgent = spec.ctx.get("localAgent");
+	if (!userMirrored) {
+		childSession.append("user/message", createUserMessage({
+			content: [{
+				type: "text",
+				text: task
+			}],
+			source: { kind: "user" }
+		}), { surfaceOp: "append" });
+		localAgent?.reportRunProgress(childSession.id, {
+			kind: "delta",
+			text: task
+		});
+	}
+	let usageIndex = -1;
+	for (let index = 0; index < parsed.lines.length; index += 1) if (parsed.lines[index]?.kind !== "tool") usageIndex = index;
+	let step = fromLines + 1;
+	for (const line of parsed.lines.slice(fromLines)) {
+		appendClaudeLine(spec, turn, step, line, step - 1 === usageIndex ? parsed.usage : void 0);
+		localAgent?.reportRunProgress(childSession.id, {
+			kind: "delta",
+			text: claudeLineText(line)
+		});
+		step += 1;
+	}
+	if (parsed.usage !== void 0 && usageIndex !== -1 && usageIndex < fromLines) spec.ctx.logger.warn(`subagent-claude: round ${turn} usage arrived after its carrier line was mirrored; the accounting is dropped`);
+	await persistChildSession(spec.ctx, childSession);
+	localAgent?.reportRunProgress(childSession.id, {
+		kind: "mirror",
+		mirroredLines: parsed.lines.length
+	});
+}
+/**
+* Mirror the claude stream-json into the child session AFTER the CLI process
+* has exited, whatever its stop reason. A cancelled or failed round still
+* preserves the events the stream already emitted (thinking, tool calls with
+* results, replies, usage) instead of leaving the child blank — the run result
+* settles 'aborted'/'error' at the cancel moment, but claude may have produced
+* content before the kill landed. Also records the session id (fresh rounds)
+* so a later resume can continue the partial session.
+* @param spec - the run spec carrying the child session and host context.
+* @param task - the one-shot task text (the user prompt).
+* @param turn - the round's turn number.
+* @param output - the collected stream-json stdout.
+*/
+async function mirrorClaudeAfterExit(spec, task, turn, output, live) {
+	if (spec.childSession === void 0 || spec.ctx === void 0) return;
+	const childSession = spec.childSession;
+	const work = async () => {
+		const parsed = parseClaudeStreamJson(output);
+		if (spec.resume === void 0) spec.onSessionId?.(parsed.sessionId);
+		if (parsed.todoSkew === true) spec.ctx?.logger.warn("subagent-claude: a TodoWrite call missed the documented input shape; folded as a plain tool line");
+		if (parsed.todos !== void 0) appendTodosIfChanged(childSession, parsed.todos);
+		const fromLines = live?.mirroredLines ?? 0;
+		const userMirrored = live?.userMirrored ?? false;
+		const cliVersion = parsed.cliVersion ?? await spec.cliVersion?.();
+		spec.onRoundSettled?.({
+			...parsed.model === void 0 ? {} : { observedModel: parsed.model },
+			...cliVersion === void 0 ? {} : { cliVersion },
+			...parsed.usage === void 0 ? {} : { usage: parsed.usage },
+			...parsed.toolCalls === void 0 ? {} : { toolCalls: parsed.toolCalls }
+		});
+		if (parsed.lines.length === 0 && !userMirrored) return;
+		const trimmed = parsed.text?.trim();
+		await appendClaudeResponse(spec, task, turn, {
+			lines: parsed.lines,
+			output: trimmed === void 0 || trimmed === "" ? [] : [{
+				type: "text",
+				text: trimmed
+			}],
+			...parsed.usage === void 0 ? {} : { usage: parsed.usage }
+		}, fromLines, userMirrored);
+	};
+	try {
+		if (live === void 0) await work();
+		else await live.enqueue(work);
+	} catch (error) {
+		spec.onError?.(thrown(error), "error");
+	}
+}
+//#endregion
+//#region lib/types/live-switch.js
+/**
+* The settings-driven live-driver switch: owns the active driver generation
+* and retires old ones on a settings change, without a plugin reload.
+*
+* Toggle OFF (or unload): the retiring generation is DRAINED, not killed —
+* new rounds are refused (the provider's catch falls back to exec), in-flight
+* rounds finish on their runtime, idle runtimes are reclaimed at once.
+* Toggling ON builds the next generation lazily (no process until the first
+* round). Legacy granularity settings are ignored.
+*
+* @module @khorsheed/dsh-local-agent-claude-code — internal, unit-tested directly.
+*/
+var LiveDriverSwitch = class {
+	ctx;
+	driverBase;
+	liveOn = false;
+	active;
+	/** Retiring generations still draining their in-flight rounds. */
+	draining = /* @__PURE__ */ new Set();
+	unwatch;
+	constructor(ctx, face, driverBase) {
+		this.ctx = ctx;
+		this.driverBase = driverBase;
+		this.apply(face.get());
+		this.unwatch = face.watch((next) => {
+			this.apply(next);
+		});
+	}
+	/**
+	* Resolve the live driver for one round's member (the provider's call
+	* site). A retiring generation still hosting the member gates the new one —
+	* the round falls back to exec rather than double-loading the same claude
+	* session into two processes.
+	*/
+	resolve = (childSessionId) => {
+		if (this.active === void 0) return void 0;
+		for (const retiring of this.draining) if (retiring.hasRuntime(childSessionId)) return void 0;
+		return this.active;
+	};
+	/**
+	* The generation currently hosting the member's runtime — the active one,
+	* or a retiring generation still draining it (the model broker retires the
+	* member's runtime through whichever generation owns it on a model switch).
+	*/
+	hostingDriver(childSessionId) {
+		if (this.active?.hasRuntime(childSessionId) === true) return this.active;
+		for (const retiring of this.draining) if (retiring.hasRuntime(childSessionId)) return retiring;
+	}
+	/** Mirror the resolved settings into the driver generation. */
+	apply(next) {
+		if (next.live === this.liveOn) return;
+		this.liveOn = next.live;
+		const retiring = this.active;
+		this.active = next.live ? new ClaudeLiveDriver(this.ctx, { ...this.driverBase }) : void 0;
+		if (retiring !== void 0) {
+			this.draining.add(retiring);
+			retiring.drain().then(() => {
+				this.draining.delete(retiring);
+			}, (error) => {
+				this.draining.delete(retiring);
+				this.ctx.logger.warn(`local-agent-claude-code: live driver drain failed: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		}
+	}
+	/** Plugin unload: interrupt whatever survives (disposeAll, not drain). */
+	dispose() {
+		this.unwatch();
+		this.active?.disposeAll();
+		for (const retiring of this.draining) retiring.disposeAll();
+		this.draining.clear();
+	}
+};
+//#endregion
+//#region lib/types/provision.js
+/**
+* Claude Code scoped-home provisioning. Unlike codex (whose credential store
+* must be pinned to a file) and kimi (which needs a provider config),
+* claude's `CLAUDE_CONFIG_DIR` scoped home needs nothing beyond the
+* directory itself: login via `claude auth login` writes `.claude.json`
+* (with the `oauthAccount` record) into it, and the real credential lands in
+* the macOS keychain under a hashed entry or — on Linux, despite upstream
+* bug #47661 — in the default `~/.claude/.credentials.json` while the config
+* stays scoped. Sign-out removes the scoped config so `status` reports not
+* authenticated; the keychain entry on macOS persists until the CLI removes
+* it, which the framework's file-based logout cannot reach.
+* @module @khorsheed/dsh-local-agent-claude-code/provision
+*/
+/** The scoped config file holding the oauthAccount auth marker. */
+const SCOPED_CONFIG = ".claude.json";
+/** The scoped settings file carrying the CLI's env block. */
+const SCOPED_SETTINGS = "settings.json";
+/**
+* Provision the scoped home directory. Claude creates it lazily on first
+* use, but creating it eagerly keeps the harness's homeDir contract uniform
+* with the other harnesses. When `proxyUrl` is configured, the scoped
+* `settings.json` gains an env block pointing the CLI's own traffic at it —
+* claude reads proxy settings from this file, so the child works even when
+* the host process environment carries no proxy (a supervisor-spawned
+* instance's env is not the user's shell env). An existing settings file is
+* merged, not overwritten; only the two proxy keys are managed.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @param proxyUrl - optional HTTP proxy URL for the child CLI's traffic.
+*/
+async function provisionClaudeHome(homeDir, proxyUrl) {
+	await mkdir(homeDir, { recursive: true });
+	if (proxyUrl === void 0) return;
+	const path = join(homeDir, SCOPED_SETTINGS);
+	let settings = {};
+	try {
+		settings = JSON.parse(await readFile(path, "utf8"));
+	} catch {}
+	const env = settings.env ?? {};
+	if (env.https_proxy === proxyUrl && env.http_proxy === proxyUrl) return;
+	env.https_proxy = proxyUrl;
+	env.http_proxy = proxyUrl;
+	settings.env = env;
+	await writeFile(path, JSON.stringify(settings, void 0, 2) + "\n");
+}
+/**
+* Read the scoped settings' configured model: the `model` key of
+* `<homeDir>/settings.json` — the model a delegation round pins when the
+* scoped settings name one at all. Claude's own default model is decided by
+* the CLI and is deliberately NOT guessed here. Only the scoped file is
+* consulted (never the host's `~/.claude`); absent or malformed content
+* yields undefined.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @returns the configured model identifier, or undefined when none is set.
+*/
+async function readClaudeConfiguredModel(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, SCOPED_SETTINGS), "utf8");
+	} catch {
+		return;
+	}
+	try {
+		const settings = JSON.parse(text);
+		return typeof settings.model === "string" && settings.model !== "" ? settings.model : void 0;
+	} catch {
+		return;
+	}
+}
+/** Read the scoped native effort setting without changing the settings file. */
+async function readClaudeConfiguredEffort(homeDir) {
+	try {
+		const settings = JSON.parse(await readFile(join(homeDir, SCOPED_SETTINGS), "utf8"));
+		return typeof settings.effortLevel === "string" && settings.effortLevel.trim() !== "" ? settings.effortLevel.trim() : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Write (or, with undefined, remove) the scoped settings.json `model` key,
+* merging the rest of the file exactly as {@link provisionClaudeHome} merges
+* its env block. Only the live driver calls this: a resident runtime needs
+* its member's effective model IN THE FILE, because a `--resume` respawn
+* restores the session's own stored model over the `--model` flag. The exec
+* path never calls it — its `--model` flag always applies, and the file
+* stays exactly as the person edited it.
+* @param homeDir - the `claude-code` harness's scoped home.
+* @param model - the model to scratch in, or undefined to remove the key.
+*/
+async function writeClaudeScopedModel(homeDir, model) {
+	const path = join(homeDir, SCOPED_SETTINGS);
+	let settings = {};
+	try {
+		settings = JSON.parse(await readFile(path, "utf8"));
+	} catch {}
+	if (model === void 0) {
+		if (!("model" in settings)) return;
+		delete settings["model"];
+	} else {
+		if (settings["model"] === model) return;
+		settings["model"] = model;
+	}
+	await writeFile(path, JSON.stringify(settings, void 0, 2) + "\n");
+}
+/**
+* Sign out of the scoped account: remove the scoped config file, so
+* `/<name> status` reports not authenticated and the next login authorizes
+* a fresh account. The macOS keychain entry (a hashed
+* `Claude Code-credentials-<sha256(path)[:8]>` record keyed to the scoped
+* home path) is NOT removed — the CLI's `claude auth logout` owns that, and
+* the harness logout contract is file-based; the stale entry is harmless
+* because a fresh login rewrites the same hashed slot.
+* @param homeDir - the `claude-code` harness's scoped home.
+*/
+async function claudeLogout(homeDir) {
+	await rm(join(homeDir, SCOPED_CONFIG), { force: true });
+}
+//#endregion
+//#region lib/types/model-broker.js
+/**
+* The claude-code harness's model broker: the family gateway routes
+* `harnessModel` / `memberModel` / `setMemberModel` here, and the broker
+* answers the family's fixed resolution order — the session-level override
+* (the composer's picker), the delegation's recorded model, the plugin-config
+* `model` key (the settings card), the scoped settings.json's own `model`,
+* and last the CLI's built-in default, which names nothing.
+*
+* The override map is IN-MEMORY by design (it deliberately does not survive a
+* host restart) and SHARED: index.ts hands the same map to the provider's and
+* the live driver's model resolvers, so a composer switch reaches the next
+* round through every drive. With the live driver on, switching to a
+* DIFFERENT model retires the member's resident runtime so the next round
+* respawns onto the new model — the CLI session itself resumes on disk, so
+* the conversation carries over. A switch while a round is in flight is
+* refused: retiring a runtime mid-round would kill the run.
+*
+* `lastObserved` (the cli-builtin layer's display hint): the delegation
+* record's `observedModel` answers when the live-settle channel reported
+* one; the member's own CLI transcript (`transcriptModel`, a bounded read of
+* the projects tree) is the history backstop for rounds that predate that
+* channel — read-only, TTL-cached, never a write into `delegations.jsonl`.
+*
+* @module @khorsheed/dsh-local-agent-claude-code/model-broker — internal, unit-tested directly.
+*/
+/**
+* The scoped settings.json `model` key across live-spawn scratch writes. The
+* live driver writes a member's effective model into the file before a
+* resident spawn (a `--resume` respawn restores the session's stored model
+* over the `--model` flag), and this memory keeps the person's own configured
+* value straight across those writes: what the file held before our first
+* write is the `cli-config` layer, and a spawn with NO effective model
+* restores that value instead of leaking the previous member's model into
+* the next runtime. In-memory on purpose: a restart re-reads the file as it
+* stands. Writes serialize on an internal queue so concurrent member spawns
+* cannot lose each other's read-modify-write.
+*/
+var ClaudeScopedModelMemory = class {
+	/** The value we last scratched in and believe the file still holds. */
+	written;
+	/** What the file held before our first write; null = it named no model. */
+	previous = null;
+	queue = Promise.resolve();
+	/**
+	* Bring the scoped settings.json's `model` key to the effective model a
+	* spawn is about to bind — writing it, or restoring the person's value when
+	* the spawn binds none and the file still holds our earlier scratch.
+	* @param homeDir - the scoped home the spawn runs against.
+	* @param model - the spawn's effective model, or undefined for none.
+	*/
+	provision(homeDir, model) {
+		const run = this.queue.then(() => this.provisionLocked(homeDir, model));
+		this.queue = run.catch(() => void 0);
+		return run;
+	}
+	/**
+	* The person's configured model — the `cli-config` layer. A file value we
+	* did not write reports as read; our own scratch value reports what the
+	* file held before we wrote it.
+	* @param homeDir - the scoped home to read.
+	* @returns the person's configured model, or undefined when none.
+	*/
+	async cliDefault(homeDir) {
+		const file = await readClaudeConfiguredModel(homeDir);
+		if (file !== this.written) {
+			this.previous = file ?? null;
+			this.written = void 0;
+			return file;
+		}
+		return this.previous ?? void 0;
+	}
+	async provisionLocked(homeDir, model) {
+		const file = await readClaudeConfiguredModel(homeDir);
+		if (file !== this.written) {
+			this.previous = file ?? null;
+			this.written = void 0;
+		}
+		if (model === void 0) {
+			if (this.written === void 0) return;
+			await writeClaudeScopedModel(homeDir, this.previous ?? void 0);
+			this.written = void 0;
+			return;
+		}
+		if (file === model) return;
+		await writeClaudeScopedModel(homeDir, model);
+		this.written = model;
+	}
+};
+var ClaudeModelBroker = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	configurationAdapter(binding) {
+		const context = this.deps.configurationContext?.(binding);
+		if (context === void 0) throw new Error("Claude member configuration context is unavailable");
+		const resolve = async (selection) => {
+			let directory = await context.directory();
+			if (directory.status === "loading") directory = await context.directory(true);
+			const model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel() ?? await readClaudeConfiguredModel(context.home) ?? directory.defaultModel;
+			const entry = directory.entries.find((entry) => entry.value === model || entry.resolvedModel === model);
+			const effort = (selection.effort.mode === "value" ? selection.effort.value : selection.effort.mode === "inherit" ? binding.effort : void 0) ?? await readClaudeConfiguredEffort(context.home) ?? entry?.reasoning?.default;
+			if (effort !== void 0 && !entry?.reasoning?.options.some((option) => option.value === effort)) throw new Error("Claude has not advertised this reasoning effort for the selected model");
+			return {
+				...model === void 0 ? {} : { model },
+				...effort === void 0 ? {} : { effort }
+			};
+		};
+		const retire = async () => {
+			await this.deps.liveSwitch.hostingDriver(binding.childSessionId)?.retireRuntime(binding.childSessionId);
+		};
+		return {
+			validate: async (selection) => {
+				await resolve(selection);
+			},
+			prepare: resolve,
+			apply: async (selection) => {
+				const resolved = await resolve(selection);
+				await retire();
+				return resolved;
+			},
+			reconcile: async (state) => {
+				if (this.deps.localAgent.isDelegationActive(binding.childSessionId)) return {
+					active: true,
+					matches: "unknown",
+					resolved: {}
+				};
+				await retire();
+				return {
+					active: false,
+					matches: "current",
+					resolved: await resolve(state.current.selection)
+				};
+			}
+		};
+	}
+	async modelDirectory(childSessionId, refresh = false) {
+		if (refresh) await this.deps.directory?.(childSessionId, true);
+		return (await this.modelInfo(childSessionId, childSessionId === void 0 ? void 0 : this.deps.localAgent.getDelegation(childSessionId)?.model)).directory ?? {
+			entries: [],
+			complete: false,
+			customInput: true,
+			status: "unsupported",
+			refreshing: false,
+			revision: 0
+		};
+	}
+	async *followModelDirectory(childSessionId, signal) {
+		if (this.deps.followDirectory === void 0) {
+			yield await this.modelDirectory(childSessionId);
+			return;
+		}
+		for await (const _snapshot of this.deps.followDirectory(childSessionId, signal)) yield await this.modelDirectory(childSessionId);
+	}
+	/**
+	* The `lastObserved` cache: childSessionId (empty key = the memberless
+	* harness read) → the answer and when it was read. A miss is cached too —
+	* a member with no transcript yet should not pay a rescan per card open.
+	*/
+	observedCache = /* @__PURE__ */ new Map();
+	/**
+	* The last model the member (or the harness) was observed running. The
+	* live-settle channel is primary — a record whose latest round reported
+	* `observedModel` answers without touching disk; the CLI's own transcripts
+	* are the history backstop for every round that predates it.
+	*/
+	async lastObserved(childSessionId) {
+		const record = childSessionId === void 0 ? void 0 : this.deps.localAgent.getDelegation(childSessionId);
+		if (childSessionId !== void 0 && record === void 0) return void 0;
+		if (record?.observedModel !== void 0 && record.observedModel.trim() !== "") return record.observedModel;
+		const key = childSessionId ?? "";
+		const hit = this.observedCache.get(key);
+		if (hit !== void 0 && Date.now() - hit.at < 6e4) return hit.model;
+		const model = await this.deps.transcriptModel(record?.cliSessionId, childSessionId).catch(() => void 0);
+		this.observedCache.set(key, {
+			at: Date.now(),
+			model
+		});
+		return model;
+	}
+	/**
+	* Read the model surface in the family's fixed order. Without a member the
+	* override and delegation layers stay absent — the settings card's "what
+	* would a round run with" read.
+	*/
+	async modelInfo(childSessionId, delegationModel) {
+		const override = childSessionId === void 0 ? void 0 : this.deps.overrides.get(childSessionId);
+		const delegation = delegationModel?.trim() === "" ? void 0 : delegationModel?.trim();
+		const settings = this.deps.settingsModel();
+		const cliDefault = await this.deps.cliDefault(childSessionId);
+		const native = await this.deps.directory?.(childSessionId);
+		const [effective, source] = override !== void 0 ? [override, "override"] : delegation !== void 0 ? [delegation, "delegation"] : settings !== void 0 ? [settings, "settings"] : cliDefault !== void 0 ? [cliDefault, "cli-config"] : [native?.defaultModel, "cli-builtin"];
+		const choices = [...new Set([
+			settings,
+			cliDefault,
+			...native?.entries.filter((entry) => !entry.hidden).map((entry) => entry.value) ?? [],
+			...this.deps.recentModels()
+		].filter((value) => value !== void 0))];
+		const lastObserved = await this.lastObserved(childSessionId);
+		const active = childSessionId !== void 0 && this.deps.localAgent.isDelegationActive(childSessionId);
+		return {
+			...effective === void 0 ? {} : { effective },
+			source,
+			...override === void 0 ? {} : { override },
+			...delegation === void 0 ? {} : { delegation },
+			...settings === void 0 ? {} : { settings },
+			...cliDefault === void 0 ? {} : { cliDefault },
+			...lastObserved === void 0 ? {} : { lastObserved },
+			choices,
+			...native === void 0 ? {} : { directory: extendModelDirectory(native, [settings, cliDefault], [...this.deps.recentModels(), lastObserved]) },
+			live: this.deps.live(),
+			switchable: !active,
+			...active ? { reason: "该成员有进行中的委派轮次，等其完成后再切换模型 (a delegation round is in flight)" } : {}
+		};
+	}
+	/**
+	* Set or clear a member's session-level override. Throws while a round is
+	* in flight for the member; a same-model set is a no-op; a real change
+	* retires the member's resident runtime when its bound model is no longer
+	* what the next round would spawn with (the CLI session resumes on the
+	* respawn, so the conversation carries over).
+	*/
+	async setMemberModel(childSessionId, model) {
+		if (this.deps.localAgent.setMemberModel !== void 0) return this.deps.localAgent.setMemberModel(childSessionId, model);
+		if (this.deps.localAgent.isDelegationActive(childSessionId)) throw new Error(`subagent-claude: 成员 ${childSessionId} 有进行中的委派轮次，等其完成后再切换模型 (a delegation round is in flight for this member)`);
+		const trimmed = model?.trim();
+		const next = trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+		if (next === this.deps.overrides.get(childSessionId)) return;
+		if (next === void 0) this.deps.overrides.delete(childSessionId);
+		else this.deps.overrides.set(childSessionId, next);
+		const delegation = this.deps.localAgent.getDelegation(childSessionId)?.model?.trim();
+		const spawnModel = next ?? (delegation === void 0 || delegation === "" ? void 0 : delegation) ?? this.deps.settingsModel();
+		const host = this.deps.liveSwitch.hostingDriver(childSessionId);
+		if (host !== void 0 && host.runtimeModel(childSessionId) !== spawnModel) await host.retireRuntime(childSessionId);
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* Claude Code harness instantiation of the local-agent family. Registers the
+* `claude-code` harness into the core registry: scoped home under the shared
+* homes root (`CLAUDE_CONFIG_DIR`), login as a manual handoff (claude ≥2.1
+* prints no OAuth URL off a TTY, so `/login` replies with the exact terminal
+* command and the registry watches for the credential), and project-file
+* session records. Delegation mounts through the `claude-local` provider
+* (one-shot `claude -p --output-format json` under the scoped home); the
+* bundle patch's `tool-subagent-claude-code-local` row puts the tool on the
+* profile root, so every agent preset can delegate.
+*
+* @module @khorsheed/dsh-local-agent-claude-code
+*/
+/** Stable Cordis plugin name; the bundle patch row id. */
+const name = "local-agent-claude-code";
+/** Services required before the harness can register. */
+const inject = [
+	"localAgent",
+	"subagents",
+	"subprocess",
+	"settings"
+];
+/**
+* The settings fields (`live`, `liveMirrorGranularity`, `model`,
+* `recentModels`) ride the plugin Config, marked `.volatile()` where the
+* host's schemastery has it (3.18.4+, the rc.1 line — probed, never sniffed):
+* there the SettingsForms writes hot-track the running fiber's Volatile
+* references without a remount, and the official one-shot import moves an old
+* settings.yaml section into this row's config. On 0.1.5 the call is absent,
+* the fields stay plain config keys (a semantic superset — the profile row
+* can now preset them too), and the legacy settings namespace below carries
+* the user layer exactly as before. `model` deliberately carries NO default:
+* an unset key must resolve to undefined, which is what keeps the pre-key
+* behavior byte-identical.
+*/
+const SETTINGS_FIELDS = {
+	live: z.boolean().default(false),
+	liveMirrorGranularity: z.union([z.const("event"), z.const("token")]).default("token"),
+	model: z.string(),
+	recentModels: z.array(z.string()).default([])
+};
+/** Mark one schema field volatile when the host's schemastery has the method (rc.1), pass it through plain when not (0.1.5). */
+function volatilize(field) {
+	return typeof field.volatile === "function" ? field.volatile() : field;
+}
+const Config = z.object({
+	permissionMode: z.union([z.const("skip"), z.const("normal")]),
+	model: volatilize(SETTINGS_FIELDS.model),
+	baseUrl: z.string(),
+	proxyUrl: z.string(),
+	live: volatilize(SETTINGS_FIELDS.live),
+	liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
+	liveMirrorGranularity: volatilize(SETTINGS_FIELDS.liveMirrorGranularity),
+	recentModels: volatilize(SETTINGS_FIELDS.recentModels)
+});
+/** The permission mode a fresh delegation defaults to. */
+const DEFAULT_PERMISSION_MODE = "skip";
+/**
+* Settings namespace for the settings-page card. The Cordis config feeds the
+* composition `base` layer, so a field absent from the user layer inherits the
+* YAML value — the card only ever stores deliberate overrides.
+*/
+const CLAUDE_SETTINGS_NAMESPACE = "local-agent-claude-code";
+/**
+* The card's 0.1.5 schema; field defaults are the innermost layer below
+* `base`. Shared with the Config schema's settings fields above.
+*/
+const CLAUDE_SETTINGS_SCHEMA = z.object(SETTINGS_FIELDS);
+/**
+* Register the Claude Code harness into the local-agent registry.
+* @param ctx - plugin context carrying the registry.
+* @param config - plugin config; `permissionMode` selects the `claude -p` policy.
+*/
+function apply(ctx, config) {
+	ctx.effect(() => {
+		const permissionMode = config.permissionMode ?? "skip";
+		const baseUrl = config.baseUrl;
+		const homeDir = ctx.localAgent.homeDir("claude-code");
+		provisionClaudeHome(homeDir, config.proxyUrl).catch((error) => {
+			ctx.logger.warn(`local-agent-claude-code: scoped home provisioning failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+		const readSettings = () => {
+			const model = vol(config.model);
+			const recentModels = vol(config.recentModels);
+			return {
+				live: vol(config.live) ?? false,
+				liveMirrorGranularity: vol(config.liveMirrorGranularity) ?? "token",
+				...model === void 0 ? {} : { model },
+				...recentModels === void 0 ? {} : { recentModels }
+			};
+		};
+		const legacyBase = {};
+		for (const field of [
+			"live",
+			"liveMirrorGranularity",
+			"model"
+		]) {
+			const value = vol(config[field]);
+			if (value !== void 0) legacyBase[field] = value;
+		}
+		const face = settingsFace(ctx, {
+			namespace: CLAUDE_SETTINGS_NAMESPACE,
+			legacySchema: CLAUDE_SETTINGS_SCHEMA,
+			legacyBase,
+			read: readSettings
+		});
+		const resolveModel = () => {
+			const model = face.get().model?.trim();
+			return model === void 0 || model === "" ? void 0 : model;
+		};
+		const overrides = /* @__PURE__ */ new Map();
+		const scopedModelMemory = new ClaudeScopedModelMemory();
+		const effectiveModel = (childSessionId, delegationModel) => {
+			const own = overrides.get(childSessionId)?.trim();
+			if (own !== void 0 && own !== "") return own;
+			const named = delegationModel?.trim();
+			if (named !== void 0 && named !== "") return named;
+			return resolveModel();
+		};
+		const liveSwitch = new LiveDriverSwitch(ctx, face, {
+			...config.permissionMode === void 0 ? {} : { permissionMode: config.permissionMode },
+			...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl },
+			...config.liveIdleMs === void 0 ? {} : { liveIdleMs: config.liveIdleMs },
+			model: effectiveModel,
+			provisionModel: (home, model) => scopedModelMemory.provision(home, model)
+		});
+		const modelCatalog = new ClaudeModelCatalog({
+			spawn: (spec) => ctx.subprocess.spawn(spec),
+			...config.baseUrl === void 0 ? {} : { baseUrl: config.baseUrl },
+			warn: (message) => ctx.logger.warn(message)
+		});
+		const modelContext = (childSessionId) => {
+			const record = childSessionId === void 0 ? void 0 : ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId);
+			return {
+				home: ctx.localAgent.homeDir("claude-code", record?.scope),
+				cwd: record?.cwd
+			};
+		};
+		const modelBroker = new ClaudeModelBroker({
+			localAgent: ctx.localAgent,
+			configurationContext: (binding) => {
+				const home = ctx.localAgent.homeDir("claude-code", binding.scope);
+				return {
+					home,
+					directory: (refresh) => refresh ? modelCatalog.refresh(home, binding.cwd) : modelCatalog.read(home, binding.cwd)
+				};
+			},
+			settingsModel: resolveModel,
+			cliDefault: (childSessionId) => {
+				const context = modelContext(childSessionId);
+				return context.home === homeDir ? scopedModelMemory.cliDefault(homeDir) : readClaudeConfiguredModel(context.home);
+			},
+			directory: (childSessionId, refresh) => {
+				const context = modelContext(childSessionId);
+				return refresh ? modelCatalog.refresh(context.home, context.cwd) : modelCatalog.read(context.home, context.cwd);
+			},
+			followDirectory: (childSessionId, signal) => {
+				const context = modelContext(childSessionId);
+				return modelCatalog.follow(context.home, context.cwd, signal);
+			},
+			recentModels: () => face.get().recentModels ?? [],
+			live: () => face.get().live,
+			overrides,
+			liveSwitch,
+			transcriptModel: (cliSessionId, childSessionId) => readClaudeTranscriptModel(modelContext(childSessionId).home, cliSessionId)
+		});
+		const disposeProvider = ctx.subagents.registerProvider(new ClaudeCliProvider(ctx, permissionMode, baseUrl, liveSwitch.resolve, effectiveModel));
+		const disposeHarness = ctx.localAgent.register({
+			prepareMember: async ({ binding, childSession, configuration, signal }) => {
+				const driver = liveSwitch.resolve(binding.childSessionId);
+				if (driver === void 0 || driver.disabled) throw new Error("Enable the native live harness before preparing a coordinator");
+				await driver.prepare({
+					cwd: binding.cwd,
+					homeDir: ctx.localAgent.homeDir("claude-code", binding.scope),
+					childSession,
+					parentSessionId: binding.parentSessionId,
+					configuration: configuration.resolved
+				}, signal);
+			},
+			name: "claude-code",
+			displayName: "Claude Code",
+			homeEnvVar: "CLAUDE_CONFIG_DIR",
+			delegationProvider: "claude-local",
+			login: {
+				pty: {
+					command: "env",
+					args: (scopedHome) => [
+						"-u",
+						"ANTHROPIC_API_KEY",
+						"-u",
+						"ANTHROPIC_BASE_URL",
+						`CLAUDE_CONFIG_DIR=${scopedHome}`,
+						"claude",
+						"auth",
+						"login"
+					]
+				},
+				watch: async (home) => {
+					await syncClaudeCredentialFile(home, (message) => {
+						ctx.logger.warn(message);
+					});
+					return claudeAuthenticated(home, (message) => {
+						ctx.logger.warn(message);
+					});
+				}
+			},
+			records: { listSessions: (homeDir) => listClaudeSessions(homeDir) },
+			provision: (scopedHome) => provisionClaudeHome(scopedHome, config.proxyUrl).then(() => {}),
+			isAuthenticated: (home) => claudeAuthenticated(home, (message) => {
+				ctx.logger.warn(message);
+			}),
+			credentialStamp: claudeCredentialStamp,
+			logout: claudeLogout,
+			modelBroker,
+			effectiveSettings: async (scopedHome) => {
+				const effectiveBaseUrl = baseUrl ?? process.env.ANTHROPIC_BASE_URL;
+				const baseUrlHost = effectiveBaseUrl !== void 0 ? endpointHost(effectiveBaseUrl) : void 0;
+				const [scopedModel, cliVersion] = await Promise.all([readClaudeConfiguredModel(scopedHome).catch(() => void 0), claudeCliVersion(ctx, scopedHome).catch(() => void 0)]);
+				const model = resolveModel() ?? scopedModel;
+				return {
+					drive: face.get().live ? "live" : "exec",
+					permissionMode,
+					baseUrlSet: effectiveBaseUrl !== void 0,
+					...baseUrlHost !== void 0 ? { baseUrlHost } : {},
+					...model !== void 0 ? { model } : {},
+					...cliVersion !== void 0 ? { cliVersion } : {}
+				};
+			},
+			subcommand: (input, invocation) => {
+				const [verb] = input.split(/\s+/);
+				if (verb === "sessions") return listClaudeSessions(invocation.agent.ctx.localAgent.homeDir("claude-code")).then((records) => ({
+					kind: "success",
+					text: records.length === 0 ? "No claude sessions in the scoped home yet." : records.map((r) => `${r.id} ${r.workDir}`).join("\n")
+				}));
+			}
+		});
+		return () => {
+			modelCatalog.dispose();
+			disposeProvider();
+			disposeHarness();
+			liveSwitch.dispose();
+		};
+	}, "local-agent-claude-code: harness");
+}
+//#endregion
+export { CLAUDE_SETTINGS_NAMESPACE, Config, DEFAULT_PERMISSION_MODE, apply, inject, name };