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

package/lib/index.js

@@ -0,0 +1,3550 @@
+import z from "@deepseek-ai/schemastery";
+import { LIVE_FLUSH_INTERVAL_MS, LiveFlush, LiveStreamPublisher, ModelDirectoryCache, assertResumeCwdUnchanged, assertResumeScopeUnchanged, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, extendModelDirectory, modelDirectoryContextKey, persistChildSession, probeCliVersion, resolveChildCwd, resolveRoundModel, settingsFace, subagentDelegationLabel, vol } from "@khorsheed/dsh-local-agent";
+import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV, endpointHost } from "@khorsheed/dsh-local-agent/types";
+import { randomUUID } from "node:crypto";
+import { 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 { StringDecoder } from "node:string_decoder";
+import { open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+//#region lib/types/records.js
+/**
+* Codex session records adapter: scans the scoped home's `sessions/`
+* rollout files (one JSONL per session under `sessions/YYYY/MM/DD/`).
+* The LISTING reads only the head of each file — the first `session_meta`
+* line carries the id, cwd, and started-at timestamp it needs. The READ-BACK
+* path ({@link codexRolloutRoundFacts}) instead locates one run's file (by
+* thread id, working directory, or a time window) and reads that round's
+* usage, model, and codex build out of it — the facts the exec `--json` wire
+* either omits entirely (the model) or drops on a non-completed round (the
+* usage). Files are treated as append-only with torn-tail tolerance, and
+* contents are always untrusted input.
+* @module @khorsheed/dsh-local-agent-codex/records
+*/
+/** Rollout files live under this directory inside the scoped home. */
+const SESSIONS_ROOT = "sessions";
+/** Bound on the head prefix read from one rollout file. */
+const HEAD_BYTES = 65536;
+/** Bound on the tail read from one rollout file for the usage scan. */
+const TAIL_BYTES = 65536;
+/** Bound on the full-file fallback read when the tail scan finds no token_count. */
+const FULL_BYTES = 8388608;
+/**
+* How far back a candidate file's start may precede the run's start and
+* still count as "this run" (clock skew + pre-spawn session creation slack).
+*/
+const ROLLOUT_WINDOW_SLACK_MS = 3e5;
+/** Extra future slack for the window end (file timestamps may skew ahead). */
+const ROLLOUT_WINDOW_FUTURE_MS = 6e4;
+/**
+* Whether the scoped home holds usable Codex credentials: the `auth.json`
+* file exists. Absent means the device-code flow has not completed.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns true when credentials are present.
+*/
+async function codexAuthenticated(homeDir) {
+	try {
+		await readFile(join(homeDir, "auth.json"));
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+/**
+* Parse the first line of a rollout file for the listing fields. Unknown or
+* malformed values yield an undefined record rather than failing the list.
+* @param text - the raw rollout file content (only the head is read).
+* @returns the record, or undefined when the head is not a session_meta line.
+*/
+function rolloutRecord(text) {
+	const line = text.split("\n")[0];
+	if (line === void 0) return void 0;
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (event.type !== "session_meta" || typeof event.payload !== "object" || event.payload === null) return;
+	const meta = event.payload;
+	const sessionId = typeof meta.id === "string" && meta.id !== "" ? meta.id : typeof meta.session_id === "string" && meta.session_id !== "" ? meta.session_id : void 0;
+	if (sessionId === void 0) return void 0;
+	if (typeof meta.cwd !== "string") return void 0;
+	const record = {
+		id: sessionId,
+		workDir: meta.cwd
+	};
+	const startedAt = typeof meta.timestamp === "string" ? Date.parse(meta.timestamp) : void 0;
+	if (startedAt !== void 0 && Number.isFinite(startedAt)) record.startedAt = startedAt;
+	return record;
+}
+/**
+* Read the scoped home's rollout files. The listing walks
+* `sessions/YYYY/MM/DD/` and reads each `rollout-*.jsonl` head; a torn or
+* malformed file is skipped rather than failing the whole list.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the parsed records, empty when no sessions exist yet.
+*/
+async function listCodexSessions(homeDir) {
+	const records = [];
+	let years;
+	try {
+		years = await readdir(join(homeDir, SESSIONS_ROOT));
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+	for (const year of years) {
+		if (!/^\d{4}$/.test(year)) continue;
+		let months;
+		try {
+			months = await readdir(join(homeDir, SESSIONS_ROOT, year));
+		} catch {
+			continue;
+		}
+		for (const month of months) {
+			if (!/^\d{2}$/.test(month)) continue;
+			let days;
+			try {
+				days = await readdir(join(homeDir, SESSIONS_ROOT, year, month));
+			} catch {
+				continue;
+			}
+			for (const day of days) {
+				if (!/^\d{2}$/.test(day)) continue;
+				let files;
+				try {
+					files = await readdir(join(homeDir, SESSIONS_ROOT, year, month, day));
+				} catch {
+					continue;
+				}
+				for (const name of files) {
+					if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
+					try {
+						const handle = await open(join(homeDir, SESSIONS_ROOT, year, month, day, 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 = rolloutRecord(text);
+						if (record !== void 0) records.push(record);
+					} catch {
+						continue;
+					}
+				}
+			}
+		}
+	}
+	return records;
+}
+/**
+* Map codex's token-count payload onto the shared usage contract — the
+* SINGLE caliber for both the exec `turn.completed` usage and the rollout
+* `token_count` recovery, so the two sources can never drift. Codex's
+* `input_tokens` is the TOTAL input including cache hits (OpenAI-style
+* accounting, confirmed against `total_tokens` in the rollout token_count),
+* and `cached_input_tokens` is the cache-read subset — so the uncached
+* bucket subtracts the cached portion to avoid double counting. There is no
+* cache-write concept, so that bucket is omitted (the shared four-bucket
+* contract: uncached input, output, cache read, cache write — codex fills
+* the first three).
+* @param usage - the raw codex usage object (`turn.completed`'s `usage` or a
+*   rollout `token_count` `info.last_token_usage`/`total_token_usage`).
+* @returns the shared usage record.
+*/
+function usageFromCodex(usage) {
+	const raw = usage;
+	const input = Number(raw.input_tokens);
+	const cached = Number(raw.cached_input_tokens);
+	const output = Number(raw.output_tokens);
+	const usageRecord = {
+		inputTokens: Number.isFinite(input) && Number.isFinite(cached) ? Math.max(0, input - cached) : Number.isFinite(input) ? input : 0,
+		outputTokens: Number.isFinite(output) ? output : 0
+	};
+	if (Number.isFinite(cached) && cached > 0) usageRecord.cacheReadTokens = cached;
+	return usageRecord;
+}
+/**
+* Scan rollout-file text for the LAST `token_count` event and map its usage
+* onto the shared contract. A token_count entry rides an
+* `{"type":"event_msg","payload":{"type":"token_count","info":{…}}}` line
+* (verified against codex-cli 0.144.0 rollout files); the per-turn
+* `info.last_token_usage` is the same caliber as `turn.completed`'s usage,
+* with the session-wide `total_token_usage` as fallback. Torn or malformed
+* lines are skipped; an absent event yields undefined.
+* @param text - raw rollout file content (the tail scan reads a bounded suffix).
+* @returns the mapped usage of the last token_count event, or undefined.
+*/
+function codexRolloutTokenUsage(text) {
+	let info;
+	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 !== "event_msg" || typeof event.payload !== "object" || event.payload === null) continue;
+		const payload = event.payload;
+		if (payload.type !== "token_count") continue;
+		if (typeof payload.info === "object" && payload.info !== null) info = payload.info;
+	}
+	if (info === void 0) return void 0;
+	const entry = info;
+	const usage = entry.last_token_usage ?? entry.total_token_usage;
+	return usage === void 0 ? void 0 : usageFromCodex(usage);
+}
+/** Parse the ISO timestamp embedded in a `rollout-<ISO>-<uuid>.jsonl` name. */
+function rolloutFilenameTimestamp(name) {
+	const match = /^rollout-(\d{4}-\d{2}-\d{2}T\d{2})-(\d{2})-(\d{2})/.exec(name);
+	if (match === null) return void 0;
+	const parsed = Date.parse(`${match[1]}:${match[2]}:${match[3]}`);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+/**
+* The codex build that wrote one rollout file, from its `session_meta` head
+* (`payload.cli_version`, present since codex 0.14x). This is the AUTHORITY
+* for the version a delegation round actually ran: it is codex's own record of
+* itself, written by the process that served the round, so it cannot drift
+* from the binary the way a later `--version` probe can.
+* @param text - the raw rollout head.
+* @returns the version, or undefined when the head names none.
+*/
+function rolloutCliVersion(text) {
+	const line = text.split("\n")[0];
+	if (line === void 0) return void 0;
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (event.type !== "session_meta" || typeof event.payload !== "object" || event.payload === null) return;
+	const version = event.payload.cli_version;
+	return typeof version === "string" && version !== "" ? version : void 0;
+}
+/**
+* How far before the run's spawn moment a `turn_context` timestamp may sit and
+* still count as THIS run's turn (sub-second ordering between the host's
+* spawn clock and the CLI's own stamps).
+*/
+const ROLLOUT_CONTEXT_SLACK_MS = 2e3;
+/**
+* Locate ONE run's rollout file. Walks the scoped home's `sessions/YYYY/MM/DD/`
+* tree reading each file's head (the same bounded walk as
+* {@link listCodexSessions}), then prefers the file whose session id equals
+* `locator.threadId`; otherwise the file whose start falls in the window
+* around `locator.windowStart`, newest first.
+*
+* **Concurrency**: the window alone cannot separate two runs started seconds
+* apart, so when the locator names a `cwd` the window set is restricted to
+* files whose head records that same directory. A window that holds candidates
+* but none in the run's directory resolves to NOTHING rather than to a
+* neighbour's file — unless the window holds exactly one candidate, where
+* there is no other run to confuse it with and the mismatch is path skew (a
+* symlinked temp root) rather than ambiguity. A misattributed model is a
+* worse answer than an absent one: the evaluation fails a run loud on
+* declared ≠ observed.
+* @param homeDir - the `codex` harness's scoped home.
+* @param locator - the thread id, working directory, and/or start-time window.
+* @returns the located candidate, or undefined when nothing locates.
+*/
+async function locateCodexRollout(homeDir, locator) {
+	const candidates = [];
+	let years;
+	try {
+		years = await readdir(join(homeDir, SESSIONS_ROOT));
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	for (const year of years) {
+		if (!/^\d{4}$/.test(year)) continue;
+		let months;
+		try {
+			months = await readdir(join(homeDir, SESSIONS_ROOT, year));
+		} catch {
+			continue;
+		}
+		for (const month of months) {
+			if (!/^\d{2}$/.test(month)) continue;
+			let days;
+			try {
+				days = await readdir(join(homeDir, SESSIONS_ROOT, year, month));
+			} catch {
+				continue;
+			}
+			for (const day of days) {
+				if (!/^\d{2}$/.test(day)) continue;
+				let files;
+				try {
+					files = await readdir(join(homeDir, SESSIONS_ROOT, year, month, day));
+				} catch {
+					continue;
+				}
+				for (const name of files) {
+					if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
+					const path = join(homeDir, SESSIONS_ROOT, year, month, day, name);
+					try {
+						const handle = await open(path, "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 = rolloutRecord(text);
+						candidates.push({
+							path,
+							id: record?.id,
+							startedAt: record?.startedAt ?? rolloutFilenameTimestamp(name),
+							workDir: record?.workDir,
+							cliVersion: rolloutCliVersion(text)
+						});
+					} catch {
+						continue;
+					}
+				}
+			}
+		}
+	}
+	if (candidates.length === 0) return void 0;
+	const threadMatch = locator.threadId === void 0 ? void 0 : candidates.find((candidate) => candidate.id === locator.threadId);
+	if (threadMatch !== void 0) return threadMatch;
+	if (locator.windowStart === void 0) return void 0;
+	const windowStart = locator.windowStart - ROLLOUT_WINDOW_SLACK_MS;
+	const windowEnd = Date.now() + ROLLOUT_WINDOW_FUTURE_MS;
+	const inWindow = candidates.filter((candidate) => candidate.startedAt !== void 0 && candidate.startedAt >= windowStart && candidate.startedAt <= windowEnd).sort((left, right) => (right.startedAt ?? 0) - (left.startedAt ?? 0));
+	if (locator.cwd === void 0) return inWindow[0];
+	const wanted = resolve(locator.cwd);
+	const sameCwd = inWindow.filter((candidate) => candidate.workDir !== void 0 && resolve(candidate.workDir) === wanted);
+	if (sameCwd.length > 0) return sameCwd[0];
+	return inWindow.length === 1 ? inWindow[0] : void 0;
+}
+/**
+* Scan rollout text for this run's two read-back facts: the LAST `token_count`
+* usage, and the model of the LAST `turn_context` whose top-level `timestamp`
+* falls inside the run's window (`windowStart` onward) — the turn codex
+* actually started for this round, so a resumed thread's earlier rounds are
+* never misread and a round killed mid-turn still observes the model it
+* started with. A torn line is skipped.
+*/
+function scanRolloutText(text, windowStart) {
+	const usage = codexRolloutTokenUsage(text);
+	const scan = usage === void 0 ? {} : { usage };
+	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 !== "turn_context" || typeof event.payload !== "object" || event.payload === null) continue;
+		if (windowStart !== void 0) {
+			const stamped = typeof event.timestamp === "string" ? Date.parse(event.timestamp) : void 0;
+			if (stamped === void 0 || !Number.isFinite(stamped) || stamped < windowStart) continue;
+		}
+		const candidate = event.payload.model;
+		if (typeof candidate === "string" && candidate !== "") scan.model = candidate;
+	}
+	return scan;
+}
+/**
+* Read one located rollout file for the round's usage and model.
+*
+* The tail is read first because it is where `token_count` lives (codex writes
+* one per turn boundary, so the last is at the end). `turn_context` is the
+* opposite: codex writes it when the turn STARTS, so a round that then
+* produces more than {@link TAIL_BYTES} of events pushes it out of the tail
+* entirely — which is exactly how a real evaluation run reported a null model
+* against rollout files that named it plainly, while a short smoke round (a
+* whole file smaller than the tail window) read back fine. So whenever the
+* tail leaves either fact missing, a bounded full read from offset 0 fills it
+* in.
+*/
+async function readRolloutFacts(path, windowStart) {
+	const handle = await open(path, "r");
+	try {
+		const { size } = await handle.stat();
+		if (size === 0) return {};
+		const tailLength = Math.min(TAIL_BYTES, size);
+		const tail = Buffer.alloc(tailLength);
+		const tailRead = await handle.read(tail, 0, tailLength, size - tailLength);
+		const scan = scanRolloutText(tail.subarray(0, tailRead.bytesRead).toString("utf8"), windowStart);
+		if (scan.usage !== void 0 && scan.model !== void 0 || size <= TAIL_BYTES) return scan;
+		const full = Buffer.alloc(Math.min(FULL_BYTES, size));
+		const fullRead = await handle.read(full, 0, full.length, 0);
+		const wide = scanRolloutText(full.subarray(0, fullRead.bytesRead).toString("utf8"), windowStart);
+		const usage = scan.usage ?? wide.usage;
+		const model = scan.model ?? wide.model;
+		return {
+			...usage === void 0 ? {} : { usage },
+			...model === void 0 ? {} : { model }
+		};
+	} finally {
+		await handle.close();
+	}
+}
+/**
+* Read ONE run's facts back from its rollout file: the token usage a
+* non-completed round never streamed, the model the exec `--json` wire does
+* not carry at all (codex 0.144.0), and the codex build that served it. One
+* locate and one file open serve all three.
+*
+* Every field is absent on a miss — no rollout file, an unreadable home, a
+* hard kill before any turn boundary, a window with no turn_context. Absence
+* is recorded, never guessed.
+* @param homeDir - the `codex` harness's scoped home.
+* @param locator - the thread id, working directory, and/or start-time window.
+* @returns the round's read-back facts.
+*/
+async function codexRolloutRoundFacts(homeDir, locator) {
+	let located;
+	try {
+		located = await locateCodexRollout(homeDir, locator);
+	} catch {
+		return {};
+	}
+	if (located === void 0) return {};
+	const windowStart = locator.windowStart === void 0 ? void 0 : locator.windowStart - ROLLOUT_CONTEXT_SLACK_MS;
+	let scan = {};
+	try {
+		scan = await readRolloutFacts(located.path, windowStart);
+	} catch {}
+	return {
+		...scan.usage === void 0 ? {} : { usage: scan.usage },
+		...scan.model === void 0 ? {} : { model: scan.model },
+		...located.cliVersion === void 0 ? {} : { cliVersion: located.cliVersion }
+	};
+}
+//#endregion
+//#region lib/types/live-driver.js
+/**
+* The codex provider's live driver: one resident `codex app-server --stdio`
+* process per member (child session), driven over the vendor's experimental
+* JSON-RPC app-server wire (protocol-probed against codex-cli 0.144.0's
+* `app-server generate-json-schema`; the harness `subagent-codex` package is
+* the reference implementation). A delegation round is a `turn/start` on the
+* member's resident thread instead of a fresh `codex exec` process, which buys
+* what the process boundary could not: runtime-level graceful interrupt
+* (`turn/interrupt`; the process survives and the thread stays continuable)
+* and push-mode mirroring (`item/completed` + delta notifications instead of
+* folding a polled stdout stream).
+*
+* Lifecycle mirrors the dsh live driver's discipline (M1): lazy spawn with an
+* initialize handshake, one in-flight spawn per member, idle-timeout reclaim
+* (stdin EOF → grace → SIGTERM ladder — the app-server wire has no shutdown
+* method), crash re-spawn with `thread/resume` of the recorded thread id, a
+* channel breaker with cooldown, and `disposeAll` on plugin unload. The wire
+* adapter is self-contained (no new dependency): line framing with a
+* StringDecoder for split UTF-8 tails, request correlation, and unattended
+* auto-answers for the server→client approval requests (the proposal's
+* default permission policy: answer exactly as the unattended exec mode does).
+* @module @khorsheed/dsh-local-agent-codex/live-driver
+*/
+/** Default idle lifetime of an unused resident runtime before reclaim. */
+const DEFAULT_LIVE_IDLE_MS = 18e5;
+/** Default timeout for a wire request acknowledgement. */
+const DEFAULT_LIVE_REQUEST_TIMEOUT_MS = 3e4;
+/** Default timeout for the app-server handshake (a cold boot can be slow). */
+const DEFAULT_LIVE_INITIALIZE_TIMEOUT_MS = 6e4;
+/** Bounded wait for an interrupted turn to converge while a run disposes. */
+const DEFAULT_LIVE_DISPOSE_CONVERGE_MS = 5e3;
+/** How long a tripped channel breaker stays on the exec fallback. */
+const DEFAULT_LIVE_CHANNEL_RETRY_MS = 3e5;
+/** Grace between stdin EOF and SIGTERM when reclaiming an app-server. */
+const RECLAIM_EOF_GRACE_MS = 1e3;
+/** Default minimum interval between one streaming item's snapshot messages. */
+const DEFAULT_SNAPSHOT_MIN_INTERVAL_MS = LIVE_FLUSH_INTERVAL_MS;
+/**
+* The app-server channel could not come up (spawn failure or handshake
+* timeout/mismatch). The provider catches exactly this and falls back to the
+* exec one-shot; any other error is a real round failure.
+*/
+var LiveChannelUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LiveChannelUnavailableError";
+	}
+};
+const DEFAULT_TIMEOUTS = {
+	initializeMs: DEFAULT_LIVE_INITIALIZE_TIMEOUT_MS,
+	requestMs: DEFAULT_LIVE_REQUEST_TIMEOUT_MS,
+	convergeMs: DEFAULT_LIVE_DISPOSE_CONVERGE_MS,
+	channelRetryMs: DEFAULT_LIVE_CHANNEL_RETRY_MS
+};
+function thrown$1(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Auth-shaped failure signatures in codex's error output: the endpoint
+* rejected the credential. Mirrors the exec path's detector
+* (CODEX_AUTH_FAILURE in codex-cli-provider.ts); the live path matches
+* against turn-failure messages, which is where a mid-run 401 surfaces when
+* the process does not exit.
+*/
+const CODEX_LIVE_AUTH_FAILURE = /401 unauthorized|unauthorized|authentication failed|not logged in|access token/i;
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Map one app-server `item/completed` ThreadItem onto the shared transcript
+* line shape — the live transport's entry into the SAME fold the exec NDJSON
+* parser owns (`foldCodexStreamLine`); both produce `CodexTranscriptLine`s
+* and append through `appendCodexTranscriptLine`, so the two drivers' final
+* child transcripts cannot drift.
+*/
+function codexAppServerItemToLine(item) {
+	const itemId = typeof item["id"] === "string" ? item["id"] : void 0;
+	switch (item["type"]) {
+		case "reasoning": {
+			const parts = [item["summary"], item["content"]].filter(Array.isArray).flat().filter((entry) => typeof entry === "string" && entry.trim() !== "");
+			return parts.length === 0 ? void 0 : {
+				kind: "think",
+				text: parts.join("\n"),
+				...itemId === void 0 ? {} : { itemId }
+			};
+		}
+		case "agentMessage": return typeof item["text"] === "string" ? {
+			kind: "text",
+			text: item["text"],
+			...itemId === void 0 ? {} : { itemId }
+		} : void 0;
+		case "commandExecution": {
+			const command = typeof item["command"] === "string" ? item.command : void 0;
+			const output = typeof item["aggregatedOutput"] === "string" && item["aggregatedOutput"].trim() !== "" ? item["aggregatedOutput"] : void 0;
+			if (command === void 0 && output === void 0) return void 0;
+			return {
+				kind: "tool",
+				id: itemId ?? `codex-live-${randomUUID()}`,
+				name: "Bash",
+				...command === void 0 ? {} : { args: command },
+				...output === void 0 ? {} : { result: output }
+			};
+		}
+		case "webSearch": return {
+			kind: "tool",
+			id: itemId ?? `codex-live-${randomUUID()}`,
+			name: "WebSearch"
+		};
+		case "fileChange": {
+			const changes = Array.isArray(item["changes"]) ? item["changes"] : [];
+			const args = changes.map((change) => `${typeof change["kind"] === "string" ? change["kind"] : "update"}: ${typeof change["path"] === "string" ? change["path"] : "?"}`).join("\n");
+			const diff = changes.map((change) => change["diff"]).filter((entry) => typeof entry === "string" && entry.trim() !== "").join("\n");
+			return {
+				kind: "tool",
+				id: itemId ?? `codex-live-${randomUUID()}`,
+				name: "ApplyPatch",
+				...args === "" ? {} : { args },
+				...diff === "" ? {} : { result: diff }
+			};
+		}
+		case "dynamicToolCall": {
+			const tool = typeof item["tool"] === "string" ? item.tool : "dynamic";
+			const args = item["arguments"] === void 0 || item["arguments"] === null ? void 0 : typeof item["arguments"] === "string" ? item["arguments"] : JSON.stringify(item["arguments"]);
+			return {
+				kind: "tool",
+				id: itemId ?? `codex-live-${randomUUID()}`,
+				name: tool,
+				...args === void 0 || args === "" ? {} : { args }
+			};
+		}
+		case "collabAgentToolCall": {
+			const tool = typeof item["tool"] === "string" ? item.tool : "collab";
+			return {
+				kind: "tool",
+				id: itemId ?? `codex-live-${randomUUID()}`,
+				name: `collab/${tool}`
+			};
+		}
+		case "mcpToolCall": {
+			const server = typeof item["server"] === "string" ? item.server : void 0;
+			const tool = typeof item["tool"] === "string" ? item.tool : void 0;
+			return {
+				kind: "tool",
+				id: itemId ?? `codex-live-${randomUUID()}`,
+				name: server !== void 0 && tool !== void 0 ? `${server}/${tool}` : tool ?? "mcp"
+			};
+		}
+		case "plan": return typeof item["text"] === "string" && item["text"].trim() !== "" ? {
+			kind: "think",
+			text: item["text"]
+		} : void 0;
+		default: return;
+	}
+}
+/** Map the app-server's per-turn usage breakdown onto the shared usage contract. */
+function usageFromAppServer(breakdown) {
+	const input = Number(breakdown["inputTokens"]);
+	const cached = Number(breakdown["cachedInputTokens"]);
+	const output = Number(breakdown["outputTokens"]);
+	const usage = {
+		inputTokens: Number.isFinite(input) && Number.isFinite(cached) ? Math.max(0, input - cached) : Number.isFinite(input) ? input : 0,
+		outputTokens: Number.isFinite(output) ? output : 0
+	};
+	if (Number.isFinite(cached) && cached > 0) usage.cacheReadTokens = cached;
+	return usage;
+}
+/**
+* The app-server wire peer: newline-delimited JSON-RPC over the child's
+* stdio. Self-contained on purpose (no new package dependency): request
+* correlation, StringDecoder framing, and server→client request answering
+* (the approval surface, auto-declined per the unattended policy).
+*/
+var CodexWirePeer = class {
+	output;
+	warn;
+	onServerRequest;
+	onNotification;
+	requestMs;
+	buffer = "";
+	decoder = new StringDecoder("utf8");
+	nextId = 0;
+	pending = /* @__PURE__ */ new Map();
+	closed = false;
+	constructor(input, output, warn, onServerRequest, onNotification, requestMs) {
+		this.output = output;
+		this.warn = warn;
+		this.onServerRequest = onServerRequest;
+		this.onNotification = onNotification;
+		this.requestMs = requestMs;
+		input?.on("data", (chunk) => {
+			this.feed(this.decoder.write(chunk));
+		});
+	}
+	write(message) {
+		this.output?.write(JSON.stringify(message) + "\n");
+	}
+	request(method, params, timeoutMs) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("subagent-codex live: the wire is closed"));
+		this.nextId += 1;
+		const id = `req_${this.nextId}`;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`subagent-codex live: ${method} timed out`));
+				timer.unref();
+			}, timeoutMs ?? this.requestMs);
+			timer.unref();
+			this.pending.set(id, {
+				resolve: (result) => resolve(result),
+				reject,
+				timer
+			});
+			this.write({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			});
+		});
+	}
+	notify(method, params) {
+		this.write(params === void 0 ? {
+			jsonrpc: "2.0",
+			method
+		} : {
+			jsonrpc: "2.0",
+			method,
+			params
+		});
+	}
+	/** Detach and reject every outstanding request. */
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const request of this.pending.values()) {
+			clearTimeout(request.timer);
+			request.reject(/* @__PURE__ */ new Error("subagent-codex live: the wire closed"));
+		}
+		this.pending.clear();
+	}
+	feed(text) {
+		this.buffer += text;
+		let index = this.buffer.indexOf("\n");
+		while (index >= 0) {
+			const line = this.buffer.slice(0, index);
+			this.buffer = this.buffer.slice(index + 1);
+			index = this.buffer.indexOf("\n");
+			if (line.trim() !== "") this.dispatchLine(line);
+		}
+	}
+	/** Handle one wire line; a malformed or hostile line never escapes this frame. */
+	dispatchLine(line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			this.warn("subagent-codex live: ignored a malformed wire line");
+			return;
+		}
+		try {
+			const hasId = typeof message.id === "string" || typeof message.id === "number";
+			if (hasId && typeof message.method === "string") {
+				const id = message.id;
+				try {
+					const result = this.onServerRequest(message.method, message.params ?? {});
+					this.write({
+						jsonrpc: "2.0",
+						id,
+						result
+					});
+				} catch (error) {
+					this.write({
+						jsonrpc: "2.0",
+						id,
+						error: {
+							code: -32603,
+							message: thrown$1(error).message
+						}
+					});
+				}
+				return;
+			}
+			if (hasId && ("result" in message || "error" in message)) {
+				const request = this.pending.get(String(message.id));
+				if (request === void 0) return;
+				this.pending.delete(String(message.id));
+				clearTimeout(request.timer);
+				const wireError = message.error;
+				if (wireError !== void 0 && wireError !== null) request.reject(/* @__PURE__ */ new Error(`subagent-codex live: ${wireError.message ?? "wire error"}`));
+				else request.resolve(message.result);
+				return;
+			}
+			if (typeof message.method === "string") this.onNotification(message.method, message.params ?? {});
+		} catch (error) {
+			this.warn(`subagent-codex live: wire line handler failed: ${thrown$1(error).message}`);
+		}
+	}
+};
+/** One resident app-server process: the wire peer, the loaded thread's id, and
+* the reclaim ladder (stdin EOF → grace → SIGTERM → grace → SIGKILL).
+*/
+var CodexLiveRuntime = class {
+	child;
+	dead = false;
+	reclaimed = false;
+	peer;
+	/** The member's loaded thread; assigned by the first round's thread/start or thread/resume. */
+	threadId;
+	/**
+	* The model this process bound at spawn (the `-c model=…` override), or
+	* undefined when it spawned with no model flag at all. A round whose start
+	* model differs retires the runtime instead of silently running the old one.
+	*/
+	configurationKey;
+	boundModel;
+	/** Turn ids of settled/interrupted rounds — their late notifications are tagged out. */
+	retiredTurnIds = /* @__PURE__ */ new Set();
+	/** The active round's notification sink; installed per round, cleared at settle. */
+	onWireNotification;
+	onDead;
+	stderrTail = "";
+	stderrDecoder = new StringDecoder("utf8");
+	constructor(child, onServerRequest, warn, requestMs) {
+		this.child = child;
+		this.peer = new CodexWirePeer(child.stdout, child.stdin, warn, onServerRequest, (method, params) => {
+			this.onWireNotification?.(method, params);
+		}, requestMs);
+		child.stderr?.on("data", (chunk) => {
+			this.stderrTail = (this.stderrTail + this.stderrDecoder.write(chunk)).slice(-4096);
+		});
+		child.done.then(() => {
+			this.markDead();
+		}, () => {
+			this.markDead();
+		});
+	}
+	get diagnostics() {
+		return this.stderrTail.trim();
+	}
+	markDead() {
+		if (this.dead) return;
+		this.dead = true;
+		this.peer.close();
+		this.onDead?.();
+	}
+	/** Graceful teardown: close the wire, EOF stdin, grace, then the terminate ladder. */
+	async reclaim() {
+		if (this.reclaimed) return;
+		this.reclaimed = true;
+		this.peer.close();
+		if (!this.dead) {
+			this.child.stdin?.end();
+			await Promise.race([this.child.done.catch(() => {}), delay(RECLAIM_EOF_GRACE_MS)]);
+		}
+		if (!this.dead) {
+			this.child.terminate();
+			await this.child.waitForExit();
+		}
+		await this.child.done.catch(() => {});
+		this.markDead();
+	}
+};
+/** Unattended approval answer: prefer cancel, else decline (harness-proven tables). */
+function unattendedDecision(params) {
+	const available = params["availableDecisions"];
+	if (Array.isArray(available)) {
+		if (available.includes("cancel")) return "cancel";
+		if (available.includes("decline")) return "decline";
+	}
+	return "decline";
+}
+/**
+* The codex live driver owns every resident app-server runtime of this
+* provider generation. Created only when `live: true`; disposed with the
+* plugin.
+*/
+var CodexLiveDriver = class {
+	ctx;
+	config;
+	timeouts;
+	runtimes = /* @__PURE__ */ new Map();
+	/** In-flight spawns by member: concurrent rounds share one, disposeAll waits them out. */
+	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;
+	}
+	clearIdleTimer(key) {
+		const timer = this.idleTimers.get(key);
+		if (timer !== void 0) clearTimeout(timer);
+		this.idleTimers.delete(key);
+	}
+	armIdleTimer(key) {
+		this.clearIdleTimer(key);
+		const idleMs = this.config.liveIdleMs ?? 18e5;
+		const timer = setTimeout(() => {
+			this.reclaim(key);
+		}, idleMs);
+		timer.unref();
+		this.idleTimers.set(key, timer);
+	}
+	async reclaim(key) {
+		const runtime = this.runtimes.get(key);
+		this.clearIdleTimer(key);
+		if (runtime === void 0) return;
+		this.runtimes.delete(key);
+		await runtime.reclaim();
+	}
+	/** Reclaim every runtime (plugin unload); no process survives the profile. */
+	async disposeAll() {
+		this.disposed = true;
+		this.disposeController.abort();
+		await Promise.all([...this.ensuring.values()].map((pending) => pending.catch(() => void 0)));
+		for (const key of [...this.runtimes.keys()]) await this.reclaim(key);
+	}
+	/**
+	* True while the member's runtime exists or is being spawned. The settings
+	* controller gates a new generation on this: a fresh driver must not serve
+	* a member whose retiring generation still hosts the (same) codex thread.
+	*/
+	hasRuntime(key) {
+		return this.runtimes.has(key) || this.ensuring.has(key);
+	}
+	/** @deprecated Compatibility no-op: live output is always incremental. */
+	setLiveMirrorGranularity(_granularity) {}
+	/**
+	* Drain for a settings-driven generation handoff: refuse new rounds (the
+	* provider's catch falls back to exec), let every in-flight round finish on
+	* its runtime, then reclaim. Resolves when no runtime or spawn remains.
+	* Unlike disposeAll, in-flight work is never interrupted.
+	*/
+	async drain() {
+		this.draining = true;
+		const keys = /* @__PURE__ */ new Set([
+			...this.runtimes.keys(),
+			...this.ensuring.keys(),
+			...this.roundChains.keys()
+		]);
+		await Promise.all([...keys].map(async (key) => {
+			await (this.roundChains.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await (this.ensuring.get(key) ?? Promise.resolve()).catch(() => void 0);
+			await this.reclaim(key);
+		}));
+	}
+	/**
+	* The model the member's live runtime bound at spawn: the identifier, or
+	* undefined when the runtime spawned with no model flag. Null when the
+	* member has no live runtime in this generation — the broker's switch check
+	* distinguishes "no runtime to retire" from "runtime bound to no model".
+	*/
+	boundModelOf(key) {
+		const runtime = this.runtimes.get(key);
+		if (runtime === void 0 || runtime.dead) return null;
+		return runtime.boundModel;
+	}
+	/**
+	* Retire the member's resident runtime so the NEXT round respawns (the CLI
+	* session itself carries over via thread/resume). The composer's model
+	* switch calls this after storing the new override; the caller guarantees
+	* no round is in flight for the member.
+	*/
+	async retireRuntime(key) {
+		await this.reclaim(key);
+	}
+	/** The member's runtime, spawning it (once per member at a time) when absent or dead. */
+	async ensureRuntime(spec, signal) {
+		const key = String(spec.childSession.id);
+		const startModel = spec.startModel?.trim();
+		const existing = this.runtimes.get(key);
+		if (existing !== void 0 && !existing.dead) {
+			if (spec.configuration !== void 0 && existing.configurationKey !== JSON.stringify(spec.configuration) || spec.configuration === void 0 && existing.configurationKey !== void 0 || startModel !== void 0 && startModel !== "" && existing.boundModel !== startModel) await this.reclaim(key);
+			else {
+				this.clearIdleTimer(key);
+				return existing;
+			}
+		} else if (existing !== void 0) this.runtimes.delete(key);
+		const pending = this.ensuring.get(key);
+		if (pending !== void 0) return pending;
+		const spawn = this.spawnRuntime(spec, signal).finally(() => {
+			this.ensuring.delete(key);
+		});
+		this.ensuring.set(key, spawn);
+		return spawn;
+	}
+	/**
+	* Spawn the member's resident app-server and prove the wire with a
+	* handshake. Failure trips the channel breaker; a cancellation mid-spawn
+	* reclaims the half-started process without touching the breaker.
+	*/
+	async spawnRuntime(spec, signal) {
+		const key = String(spec.childSession.id);
+		if (this.disposed) throw new LiveChannelUnavailableError("the live driver is disposed");
+		const member = registerCodexMemberRun(this.ctx, String(spec.childSession.id), spec.parentSessionId);
+		const startModel = spec.startModel?.trim();
+		const model = spec.configuration !== void 0 ? spec.configuration.model : startModel !== void 0 && startModel !== "" ? startModel : this.config.model?.(key)?.trim();
+		const spawnSpec = {
+			argv: [
+				"codex",
+				"app-server",
+				...member === void 0 ? [] : ["-c", member.configOverride],
+				...model === void 0 || model === "" ? [] : ["-c", `model=${JSON.stringify(model)}`],
+				...spec.configuration?.effort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(spec.configuration.effort)}`],
+				"--stdio"
+			],
+			cwd: spec.cwd,
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe"
+			},
+			graceMs: DEFAULT_DISPOSE_GRACE_MS,
+			env: delegationEnv({ CODEX_HOME: spec.homeDir })
+		};
+		let child;
+		try {
+			child = this.ctx.subprocess.spawn(spawnSpec);
+		} catch (error) {
+			member?.release();
+			this.markChannelBroken();
+			throw new LiveChannelUnavailableError(`the app-server failed to spawn: ${thrown$1(error).message}`);
+		}
+		const runtime = new CodexLiveRuntime(child, (method, params) => this.answerServerRequest(method, params), (message) => {
+			this.ctx.logger.warn(message);
+		}, this.timeouts.requestMs);
+		runtime.boundModel = model === void 0 || model === "" ? void 0 : 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();
+		};
+		const aborted = new Promise((_, reject) => {
+			const cancel = () => {
+				reject(/* @__PURE__ */ new Error("subagent-codex: run cancelled locally"));
+			};
+			const unload = () => {
+				reject(new LiveChannelUnavailableError("the live driver was disposed during spawn"));
+			};
+			if (signal.aborted) {
+				cancel();
+				return;
+			}
+			if (this.disposeController.signal.aborted) {
+				unload();
+				return;
+			}
+			signal.addEventListener("abort", cancel, { once: true });
+			this.disposeController.signal.addEventListener("abort", unload, { once: true });
+		});
+		aborted.catch(() => {});
+		try {
+			await Promise.race([runtime.peer.request("initialize", {
+				clientInfo: {
+					name: "dsh-local-agent-codex",
+					title: "dsh local-agent codex live driver",
+					version: "0.1.0"
+				},
+				capabilities: {
+					experimentalApi: false,
+					requestAttestation: false
+				}
+			}, this.timeouts.initializeMs), aborted]);
+			runtime.peer.notify("initialized");
+		} catch (error) {
+			await runtime.reclaim();
+			if (signal.aborted) throw thrown$1(error);
+			this.markChannelBroken();
+			throw new LiveChannelUnavailableError(`the app-server handshake failed: ${thrown$1(error).message}`);
+		}
+		if (this.disposed) {
+			await runtime.reclaim();
+			throw new LiveChannelUnavailableError("the live driver was disposed during spawn");
+		}
+		this.channelBrokenAt = void 0;
+		this.runtimes.set(key, runtime);
+		return runtime;
+	}
+	markChannelBroken() {
+		this.channelBrokenAt = Date.now();
+	}
+	/**
+	* Report an auth-shaped round failure to the family registry's auth-failure
+	* mark (the exec path's post-exit 401 detection ported to a process that
+	* never exits: the match runs against the settled error instead). Degrades
+	* silently on a core predating reportAuthFailure.
+	*/
+	reportAuthIfShaped(error) {
+		if (!CODEX_LIVE_AUTH_FAILURE.test(error.message)) return;
+		const registry = this.ctx.localAgent;
+		if (typeof registry.reportAuthFailure === "function") registry.reportAuthFailure("codex", error.message.split("\n").find((line) => line.trim() !== "") ?? error.message);
+	}
+	/**
+	* Auto-answer the app-server's approval/elicitation requests, matching the
+	* unattended exec behavior (and the harness reference implementation's
+	* tables): the live driver never grants interactive approval. This is the
+	* proposal's default permission policy; the relay hook for a human
+	* approval UI is a later increment.
+	*/
+	answerServerRequest(method, params) {
+		switch (method) {
+			case "item/commandExecution/requestApproval":
+			case "item/fileChange/requestApproval": return { decision: unattendedDecision(params) };
+			case "item/permissions/requestApproval": return {
+				permissions: {},
+				scope: "turn"
+			};
+			case "item/tool/requestUserInput": return { answers: {} };
+			case "mcpServer/elicitation/request": return {
+				action: "decline",
+				content: null,
+				_meta: null
+			};
+			default: throw new Error(`subagent-codex live: unsupported app-server request ${method}`);
+		}
+	}
+	/**
+	* Drive one delegation round on the member's resident app-server. Mirrors
+	* the exec run's settlement contract exactly so the facade, the tool, and
+	* the projections cannot tell the difference — except `cancel` is a runtime
+	* interrupt and the process survives. Cancellation is honored in every
+	* window (the M1 acceptance lesson): the abort listener registers before
+	* any await, the spawn/handshake races it, and a pre-accept cancel reclaims
+	* the fresh runtime instead of letting the turn run unwatched.
+	*/
+	/** Create/resume the native thread without starting a model turn. */
+	async prepare(spec, signal) {
+		signal.throwIfAborted();
+		if (this.draining || this.disabled) throw new LiveChannelUnavailableError("the live driver is unavailable for preparation");
+		try {
+			const runtime = await this.ensureRuntime(spec, signal);
+			await this.ensureThread(runtime, spec);
+			signal.throwIfAborted();
+			this.armIdleTimer(String(spec.childSession.id));
+		} catch (error) {
+			await this.reclaim(String(spec.childSession.id));
+			throw error;
+		}
+	}
+	async ensureThread(rt, spec) {
+		if (rt.threadId === void 0) {
+			const permissionParams = {
+				approvalPolicy: "never",
+				sandbox: this.config.sandbox ?? "workspace-write"
+			};
+			if (spec.resume === void 0) {
+				const response = await rt.peer.request("thread/start", {
+					cwd: spec.cwd,
+					ephemeral: false,
+					...permissionParams
+				});
+				if (typeof response?.thread?.id !== "string") throw new Error("subagent-codex live: thread/start returned no thread id");
+				rt.threadId = response.thread.id;
+			} else {
+				const response = await rt.peer.request("thread/resume", {
+					threadId: spec.resume.cliSessionId,
+					cwd: spec.cwd,
+					...permissionParams
+				});
+				if (typeof response?.thread?.id !== "string") throw new Error("subagent-codex live: thread/resume returned no thread");
+				rt.threadId = response.thread.id;
+			}
+		}
+		if (spec.resume === void 0 && rt.threadId !== void 0) spec.onThreadId?.(rt.threadId);
+	}
+	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-codex: 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-codex: the live driver is disposed");
+		const turn = spec.resume?.turn ?? 1;
+		const childSession = spec.childSession;
+		const localAgent = this.ctx.get("localAgent");
+		/** The round's start moment, anchoring the settle read-back's rollout time window. */
+		const startedAtMs = Date.now();
+		const runAbort = new AbortController();
+		let roundSettled = false;
+		let runtime;
+		/** The in-flight turn's server-assigned id; interrupt needs it. */
+		let activeTurnId;
+		/** Pre-ack turn id observed via turn/started (notifications can precede the response). */
+		let pendingTurnId;
+		let turnOpened = false;
+		let lastText = "";
+		/** Final-answer selection per the harness wire: final_answer phase beats unphased. */
+		let lastFinalAnswer;
+		let lastUnphasedAnswer;
+		/** The round's folded transcript (the exec fold's line shape). */
+		const lines = [];
+		let mirrored = 0;
+		let usage;
+		/** 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 items seen this round by item id:
+		* deltas accumulate into throttled snapshot assistant/messages appended
+		* at the item'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 item's completion 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 item deltas currently accumulate into (items stream sequentially). */
+		let activeStream;
+		/** Items/completions that arrived before the turn id was known. */
+		const earlyNotifications = [];
+		let persistQueue = Promise.resolve();
+		const persist = () => {
+			persistQueue = persistQueue.then(() => persistChildSession(this.ctx, childSession)).catch((error) => {
+				this.ctx.logger.warn(`subagent-codex: live persistence failed: ${thrown$1(error).message}`);
+			});
+		};
+		const requestCancel = () => {
+			if (roundSettled || runAbort.signal.aborted) return;
+			runAbort.abort(/* @__PURE__ */ new Error("subagent-codex: run cancelled locally"));
+			const turnId = activeTurnId ?? pendingTurnId;
+			if (turnId !== void 0 && runtime?.threadId !== void 0 && !runtime.dead) runtime.peer.request("turn/interrupt", {
+				threadId: runtime.threadId,
+				turnId
+			}).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-codex: run cancelled locally")), { once: true });
+		});
+		const collectOutput = () => {
+			const partial = activeStream === void 0 ? "" : streams.get(activeStream)?.text ?? "";
+			const selected = lastFinalAnswer ?? lastUnphasedAnswer ?? (lastText !== "" ? lastText : partial === "" ? void 0 : partial);
+			return selected === void 0 || selected.trim() === "" ? [] : [{
+				type: "text",
+				text: selected
+			}];
+		};
+		/**
+		* Append one snapshot of a streaming item at its reserved (turn, step).
+		* Throttled per item by interval and growth 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 attachUsage = withUsage && !usageCarried && usage !== void 0;
+			childSession.append("assistant/message", {
+				turn,
+				step: stream.step,
+				message: codexAssistantEvent([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 (attachUsage) usageCarried = true;
+			stream.lastSnapshotAt = now;
+			stream.lastSnapshotLen = stream.text.length;
+			persist();
+		};
+		/**
+		* Reserve the step one new streaming item will occupy — past every
+		* completed line (folded or held back) and every earlier reservation. A
+		* different item'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 = 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 `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 completion. */
+		const mirrorUpTo = (upto, withUsage) => {
+			let usageIndex = -1;
+			if (withUsage) {
+				for (let index = 0; index < lines.length; index += 1) if (lines[index]?.kind !== "tool") usageIndex = index;
+			}
+			for (let index = mirrored; index < upto; index += 1) {
+				const line = lines[index];
+				if (line === void 0) continue;
+				const lineUsage = withUsage && index === usageIndex ? usage : void 0;
+				if (lineUsage !== void 0) usageCarried = true;
+				const itemId = line.kind === "tool" ? void 0 : line.itemId;
+				const stream = itemId === void 0 ? void 0 : streams.get(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: codexAssistantEvent(blocks),
+						stream: [],
+						...lineUsage === void 0 ? {} : { usage: lineUsage }
+					}, { surfaceOp: "append" });
+					streamPublisher?.finish(stream.step);
+					childSession.append("step/end", {
+						turn,
+						step: stream.step
+					});
+				} else appendCodexTranscriptLine(childSession, turn, foldStep(index), line, lineUsage);
+				mirrored = index + 1;
+				localAgent?.reportRunProgress(childSession.id, {
+					kind: "delta",
+					text: codexLineText(line)
+				});
+			}
+			if (upto > 0) persist();
+		};
+		let resolveCompletion;
+		const completion = new Promise((resolve) => {
+			resolveCompletion = resolve;
+		});
+		const openTurn = () => {
+			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
+			});
+			for (const early of earlyNotifications.splice(0)) dispatchTurnNotification(early.method, early.params);
+		};
+		/** Process one turn-scoped notification for the round's own turn id. */
+		const dispatchTurnNotification = (method, params) => {
+			if (method === "item/completed") {
+				const item = params["item"];
+				const line = codexAppServerItemToLine(item);
+				if (item["type"] === "agentMessage" && typeof item["text"] === "string") {
+					const phase = item["phase"];
+					if (phase === "final_answer") lastFinalAnswer = item["text"];
+					else if (phase === null || phase === void 0) lastUnphasedAnswer = item["text"];
+					lastText = item["text"];
+				}
+				if (line === void 0) return;
+				lines.push(line);
+				mirrorUpTo(lines.length - 1, false);
+				return;
+			}
+			if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta") {
+				if (typeof params["delta"] !== "string") return;
+				const text = params["delta"];
+				if (text === "") return;
+				const reasoning = method === "item/reasoning/textDelta";
+				const itemId = typeof params["itemId"] === "string" ? params["itemId"] : `codex-stream-${reasoning ? "think" : "text"}-${turn}`;
+				reserveStream(itemId, reasoning ? "think" : "text");
+				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 (method === "thread/tokenUsage/updated") {
+				const last = params["tokenUsage"]?.["last"];
+				if (last !== void 0) usage = usageFromAppServer(last);
+				return;
+			}
+			if (method === "turn/completed") {
+				const turnData = params["turn"];
+				mirrorUpTo(lines.length, true);
+				resolveCompletion({
+					status: String(turnData["status"]),
+					...turnData["error"] === null || turnData["error"] === void 0 ? {} : { error: turnData["error"] }
+				});
+			}
+		};
+		/** Route one wire notification: round-scoped, turn-id tagged, early ones buffered. */
+		const dispatchNotification = (method, params) => {
+			const paramThreadId = params["threadId"];
+			if (typeof paramThreadId === "string" && runtime?.threadId !== void 0 && paramThreadId !== runtime.threadId) return;
+			if (method === "turn/started") {
+				const id = params["turn"]?.["id"];
+				if (typeof id === "string" && activeTurnId === void 0 && !runtime?.retiredTurnIds.has(id)) pendingTurnId = id;
+				return;
+			}
+			if (![
+				"item/completed",
+				"item/agentMessage/delta",
+				"item/reasoning/textDelta",
+				"thread/tokenUsage/updated",
+				"turn/completed"
+			].includes(method)) return;
+			const turnId = method === "turn/completed" ? params["turn"]?.["id"] : params["turnId"];
+			if (!(activeTurnId !== void 0 && turnId === activeTurnId) && !(activeTurnId === void 0 && pendingTurnId !== void 0 && turnId === pendingTurnId)) return;
+			if (!turnOpened) {
+				earlyNotifications.push({
+					method,
+					params
+				});
+				return;
+			}
+			dispatchTurnNotification(method, params);
+		};
+		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-codex: run cancelled locally");
+			}
+			rt.onWireNotification = dispatchNotification;
+			try {
+				await this.ensureThread(rt, spec);
+				const response = await rt.peer.request("turn/start", {
+					threadId: rt.threadId,
+					input: [{
+						type: "text",
+						text: task,
+						text_elements: []
+					}],
+					...spec.configuration?.model === void 0 ? {} : { model: spec.configuration.model },
+					...spec.configuration?.effort === void 0 ? {} : { effort: spec.configuration.effort }
+				});
+				if (typeof response?.turn?.id !== "string") throw new Error("subagent-codex live: turn/start returned no turn id");
+				activeTurnId = response.turn.id;
+			} catch (error) {
+				if (!runAbort.signal.aborted) await this.reclaim(String(childSession.id));
+				throw thrown$1(error);
+			}
+			if (runAbort.signal.aborted && runtime !== void 0 && runtime.threadId !== void 0) runtime.peer.request("turn/interrupt", {
+				threadId: runtime.threadId,
+				turnId: activeTurnId
+			}).catch(() => {});
+			openTurn();
+		})();
+		const attempt = accepted.then(async () => {
+			if (runAbort.signal.aborted) throw new Error("subagent-codex: run cancelled locally");
+			const processFailure = runtime.child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-codex: the live runtime exited mid-round (code ${String(outcome.exitCode)}, signal ${String(outcome.signal)})`)), (error) => Promise.reject(thrown$1(error)));
+			processFailure.catch(() => {});
+			const outcome = await Promise.race([completion, processFailure]);
+			if (outcome.status === "interrupted") return {
+				output: collectOutput(),
+				stopReason: "aborted"
+			};
+			if (outcome.status === "failed") {
+				const message = typeof outcome.error?.["message"] === "string" ? outcome.error["message"] : "the codex turn failed";
+				throw new Error(`subagent-codex live: ${message}`);
+			}
+			if (outcome.status !== "completed") throw new Error(`subagent-codex live: the turn ended with unexpected status ${outcome.status}`);
+			const output = collectOutput();
+			if (output.length === 0) throw new Error("subagent-codex 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-codex: live round failed (${stopReason}): ${error.message}${suffix}`);
+				this.reportAuthIfShaped(error);
+			},
+			signal: request.signal,
+			onAbort
+		}).then(async (settled) => {
+			roundSettled = true;
+			liveFlush.dispose();
+			if (turnOpened) {
+				if (mirrored < lines.length) mirrorUpTo(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) {
+				if (activeTurnId !== void 0) runtime.retiredTurnIds.add(activeTurnId);
+				runtime.onWireNotification = 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
+					});
+					const facts = await codexRolloutRoundFacts(spec.homeDir, {
+						threadId: runtime?.threadId,
+						windowStart: startedAtMs,
+						cwd: spec.cwd
+					});
+					const settledUsage = usage ?? facts.usage;
+					const round = {
+						...facts.model === void 0 ? {} : { observedModel: facts.model },
+						...facts.cliVersion === void 0 ? {} : { cliVersion: facts.cliVersion },
+						...settledUsage === void 0 ? {} : { usage: settledUsage }
+					};
+					localAgent?.recordRoundSettled?.(childSession.id, round);
+				}
+			} catch (error) {
+				this.ctx.logger.warn(`subagent-codex: live settle observation failed: ${thrown$1(error).message}`);
+			} finally {
+				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([completion.catch(() => ({ status: "interrupted" })), delay(this.timeouts.convergeMs)]);
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/types/provision.js
+/**
+* Codex scoped-home provisioning: pin file-based credential storage so the
+* device-code login writes `auth.json` inside the scoped home. Codex's
+* `cli_auth_credentials_store` defaults to `auto` — on macOS that resolves
+* to the keychain, which would both leak credentials outside the scoped
+* home and defeat the `auth.json` presence check this package's records
+* adapter uses for authentication. An existing config is respected
+* untouched; sign-out removes the credential file.
+* @module @khorsheed/dsh-local-agent-codex/provision
+*/
+/** Credential file inside the scoped home; its presence marks auth. */
+const AUTH_FILE = "auth.json";
+/** Minimal scoped config: keep credentials in the scoped home. */
+const SCOPED_CONFIG = `# Written by dsh-local-agent-codex: keep the device-code
+# credentials inside the scoped home (auth.json) instead of the OS keychain.
+cli_auth_credentials_store = "file"
+`;
+/**
+* Provision `<homeDir>/config.toml` unless one already exists. A present
+* config is respected untouched (a person may have edited it); otherwise a
+* minimal config pinning file-based credential storage is written so login
+* lands in the scoped home's `auth.json`.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns true when a config was written, false when one already existed.
+*/
+async function provisionCodexConfig(homeDir) {
+	try {
+		await readFile(join(homeDir, "config.toml"));
+		return false;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	await writeFile(join(homeDir, "config.toml"), SCOPED_CONFIG, { flag: "wx" });
+	return true;
+}
+/**
+* Read the scoped config's effective custom endpoint: the base_url of the
+* `model_providers` entry named by `model_provider`, or the first custom
+* provider's base_url when no selection exists (a user manually editing the
+* config to route through a custom endpoint typically sets both). Only used
+* for diagnostics — the config is authoritative and a user-edited value is
+* respected untouched.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the configured custom base URL, or undefined when none is set.
+*/
+async function readCodexBaseUrl(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return;
+	}
+	let section = "";
+	let selected;
+	const providers = /* @__PURE__ */ new Map();
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		const key = /^(\w+)\s*=\s*"([^"]*)"$/.exec(line);
+		if (key === null) continue;
+		if (section === "" && key[1] === "model_provider") selected = key[2];
+		const provider = /^model_providers\.(".*"|[\w-]+)$/.exec(section);
+		if (provider !== null && key[1] === "base_url") providers.set(provider[1].replace(/^"(.*)"$/, "$1"), key[2]);
+	}
+	if (selected !== void 0 && providers.has(selected)) return providers.get(selected);
+	if (providers.size === 1) return [...providers.values()][0];
+}
+/**
+* Read the scoped config's effective reasoning effort: the top-level
+* `model_reasoning_effort` key (codex reads it for reasoning-capable models).
+* A missing or malformed config, or no key, yields undefined — the honest
+* "unknown", never a guessed default. Read-only: the config is authoritative
+* and a user-edited value is reported as-is. The provider passes no effort
+* override on the argv, so this IS the value every round runs with.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the configured effort, or undefined when none is set.
+*/
+async function readCodexReasoningEffort(homeDir) {
+	return readTopLevelConfigString(homeDir, "model_reasoning_effort");
+}
+/**
+* Read the scoped config's configured model: the top-level `model` key — the
+* selection a plain `codex exec` round runs with. A missing or malformed
+* config, or no key, yields undefined — the honest "unknown", never a guessed
+* default. Read-only: the config is authoritative and a user-edited value is
+* reported as-is.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the configured model identifier, or undefined when none is set.
+*/
+async function readCodexModel(homeDir) {
+	return readTopLevelConfigString(homeDir, "model");
+}
+/**
+* One top-level string key from the scoped config.toml: counts only before
+* the first table header — the same rule the model_provider scan applies.
+* Absent file or absent key yields undefined, never a guessed default.
+*/
+async function readTopLevelConfigString(homeDir, key) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return;
+	}
+	let section = "";
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		if (section !== "") continue;
+		const match = /^(\w+)\s*=\s*"([^"]*)"$/.exec(line);
+		if (match !== null && match[1] === key) return match[2];
+	}
+}
+/**
+* Every model identifier the scoped config.toml itself names, deduped in file
+* order: the top-level `model` key plus each `[profiles.<name>]` table's own
+* `model` (a profile is how a codex config names a second model at all).
+* `[model_providers.*]` tables are deliberately NOT collected — their keys
+* name providers (endpoint definitions), not models, so offering one as a
+* model choice would be a wrong suggestion, not a discovered one. Absent file
+* or no model keys yields an empty list, never a hardcoded catalog entry.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the model identifiers the file carries.
+*/
+async function listCodexConfigModels(homeDir) {
+	let text;
+	try {
+		text = await readFile(join(homeDir, "config.toml"), "utf8");
+	} catch {
+		return [];
+	}
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (value) => {
+		if (value === void 0 || value.trim() === "" || seen.has(value)) return;
+		seen.add(value);
+		found.push(value);
+	};
+	let section = "";
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		const header = /^\[+([^\]]+)\]+$/.exec(line);
+		if (header !== null) {
+			section = header[1];
+			continue;
+		}
+		const match = /^(\w+)\s*=\s*"([^"]*)"$/.exec(line);
+		if (match === null || match[1] !== "model") continue;
+		if (section === "" || section.startsWith("profiles.")) collect(match[2]);
+	}
+	return found;
+}
+/**
+* The credential file's modification stamp (epoch ms), undefined when absent.
+* A completed device-code login rewrites `auth.json`, so the stamp
+* distinguishes a fresh login from a leftover (possibly revoked) credential.
+* @param homeDir - the `codex` harness's scoped home.
+* @returns the marker's mtime, or undefined when no credential exists.
+*/
+async function codexCredentialStamp(homeDir) {
+	try {
+		return (await stat(join(homeDir, AUTH_FILE))).mtimeMs;
+	} catch {
+		return;
+	}
+}
+/**
+* Sign out of the scoped account: remove the credential file, so `/<name>
+* status` reports not authenticated and the next login authorizes a fresh
+* account. With `cli_auth_credentials_store = "file"` the credentials live
+* solely in `auth.json`, so removing it is the logout path.
+* @param homeDir - the `codex` harness's scoped home.
+*/
+async function codexLogout(homeDir) {
+	await rm(join(homeDir, AUTH_FILE), { force: true });
+}
+//#endregion
+//#region lib/types/codex-cli-provider.js
+/**
+* One-shot Codex CLI subagent lifecycle: spawn `codex exec "<task>"` through
+* the subprocess seam under the harness's scoped home, capture its printed
+* response as the run output, and dispose to whole-tree quiescence. Mirrors
+* the kimi-cli provider: every accepted run is a fresh process and a fresh
+* codex session; there is no continuation across runs.
+*
+* The provider name `codex-local` avoids colliding with the official
+* `subagent-codex` package's provider name `codex` — 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_codex`
+* 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-codex/codex-cli-provider
+*/
+/** Quote one TOML basic string for the `-c` config override. */
+function tomlString(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/** Default POSIX grace between subprocess termination tiers. */
+const DEFAULT_DISPOSE_GRACE_MS = 3e3;
+/**
+* Auth-shaped failure signatures in codex's stderr or event stream: the
+* endpoint rejected the credential. Narrow on purpose — matched against
+* provider-controlled error output only.
+*/
+const CODEX_AUTH_FAILURE = /401 unauthorized|unauthorized|authentication failed|not logged in|access token/i;
+/** Register one member run with the channel; see {@link CodexMemberRunHandle}. */
+function registerCodexMemberRun(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: "codex-local"
+	});
+	const serverName = `dsh-member-${token.slice(0, 8)}`;
+	const bridge = registry.memberBridgeCommand();
+	const configOverride = `mcp_servers.${serverName}={command=${tomlString(bridge.command)},args=[${bridge.args.map(tomlString).join(",")}],env={${MEMBER_BRIDGE_SOCKET_ENV}=${tomlString(registry.memberBridgeSocketPath())},${MEMBER_BRIDGE_TOKEN_ENV}=${tomlString(token)}},default_tools_approval_mode=${tomlString("approve")}}`;
+	let released = false;
+	return {
+		token,
+		configOverride,
+		release: () => {
+			if (released) return;
+			released = true;
+			registry.unregisterMemberRun(token);
+		}
+	};
+}
+/**
+* One-shot and resumable Codex CLI subagent provider: every accepted FRESH run
+* starts a `codex exec` 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 thread with `codex exec --json resume <thread_id>`
+* inside the SAME dsh child session. With the live driver configured
+* (`live: true`), rounds instead go to the resident app-server 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("codex", scope);
+}
+/**
+* The codex build `codex --version` reports, probed through the shared
+* subprocess seam inside the SCOPED home (never the user's own installation)
+* and cached by the family probe against the executable's identity. Both the
+* effective-settings snapshot and a settled round's read-back use it — the
+* round prefers its own rollout head, which names the build that actually ran.
+* @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 codexCliVersion(ctx, homeDir) {
+	const subprocess = ctx.get("subprocess");
+	if (subprocess === void 0) return Promise.resolve(void 0);
+	return probeCliVersion({
+		argv: ["codex", "--version"],
+		cwd: homeDir,
+		spawn: (spec) => subprocess.spawn(spec),
+		env: delegationEnv({ CODEX_HOME: homeDir })
+	});
+}
+var CodexCliProvider = class {
+	ctx;
+	sandbox;
+	live;
+	model;
+	overrides;
+	name = "codex-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 configured model, read PER ROUND so a
+	*   settings-card write takes effect on the next delegation without a
+	*   reload. Undefined (the resolver absent, or returning undefined) leaves
+	*   the argv exactly as it was before the key existed — the scoped
+	*   config.toml's own `model` then decides, as it always did.
+	* @param overrides - resolver for the member's session-level model override
+	*   (the composer picker, owned by the model broker). It outranks BOTH the
+	*   delegation's recorded model and the configured one: on the exec path it
+	*   re-points the next round's `-m`, and on the live path it is the member's
+	*   start model — a resident runtime bound to a different model is retired
+	*   so the round respawns onto the override.
+	*/
+	constructor(ctx, sandbox = "workspace-write", live, model, overrides) {
+		this.ctx = ctx;
+		this.sandbox = sandbox;
+		this.live = live;
+		this.model = model;
+		this.overrides = overrides;
+	}
+	/** 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;
+	}
+	/** Per-round member-channel registration for the exec path (see {@link registerCodexMemberRun}). */
+	memberRun(childSessionId, parentSessionId) {
+		return registerCodexMemberRun(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("codex", scope);
+		const cwd = resolveChildCwd(request.parent.session.header.cwd, intent?.cwd);
+		if (cwd === void 0) throw new Error("subagent-codex: the parent session has no working directory to run the CLI in");
+		const exec = intent?.exec;
+		if (exec !== void 0) containerScopedHome(exec, "CODEX_HOME", "subagent-codex");
+		if (intent !== void 0 && intent.kind === "resume") {
+			const record = this.ctx.localAgent.getDelegation(intent.childSessionId);
+			assertResumeCwdUnchanged(record, cwd, "subagent-codex");
+			assertResumeScopeUnchanged(record, scope, "subagent-codex");
+			if (typeof this.ctx.localAgent.withMemberConfigurationRound !== "function") return this.startCodexResume(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.startCodexResume(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("Codex effort requires the configuration admission core");
+			return this.startCodexFresh(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.startCodexFresh(request, cwd, homeDir, exec, scope, intent?.model, childSessionId, configuration), request.signal, intent?.onAdmitted);
+	}
+	/** Fresh round: record the child session, spawn `codex exec`, append after settle. */
+	async startCodexFresh(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("codex");
+			const label = subagentDelegationLabel(harness?.displayName ?? "codex", request.descriptor.label);
+			childSession.append("subagent/descriptor", {
+				...request.descriptor,
+				label
+			});
+			establishSubagentCatalogChild(request.parent.session, childSession.header, label);
+		} catch (error) {
+			this.ctx.logger.warn(`subagent-codex: subagent session record failed: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const baseUrl = await readCodexBaseUrl(homeDir).catch(() => void 0);
+		this.ctx.logger.info(`subagent-codex: delegating via ${baseUrl ?? "codex default endpoint"}`);
+		const live = exec === void 0 ? this.liveDriver(runId) : void 0;
+		if (live !== void 0 && childSession !== void 0 && !live.disabled) {
+			const startModel = configuration === void 0 ? this.overrides?.(runId) ?? requestedModel : configuration.resolved.model;
+			try {
+				return await live.startRound(request, {
+					cwd,
+					homeDir,
+					childSession,
+					parentSessionId: request.parent.session.id,
+					...startModel === void 0 ? {} : { startModel },
+					...configuration === void 0 ? {} : { configuration: configuration.resolved },
+					onThreadId: (threadId) => {
+						this.ctx.localAgent.recordDelegation({
+							childSessionId: runId,
+							provider: this.name,
+							parentSessionId: request.parent.session.id,
+							cliSessionId: threadId,
+							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-codex: 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 startCodexCliRun(request, {
+				cwd,
+				env: delegationEnv({ CODEX_HOME: homeDir }),
+				...exec === void 0 ? {} : { exec },
+				endpointLabel: baseUrl,
+				sandbox: this.sandbox,
+				...configuration?.resolved ?? resolveRoundModel(this.overrides?.(runId) ?? requestedModel, this.model),
+				disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+				spawn: (spec) => this.ctx.subprocess.spawn(spec),
+				onError: (error, stopReason) => {
+					this.ctx.logger.warn(`subagent-codex: child run failed (${stopReason}) via ${baseUrl ?? "codex default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+				},
+				onAuthFailure: (detail) => {
+					this.ctx.localAgent.reportAuthFailure("codex", detail, scope);
+				},
+				onAuthSuccess: () => {
+					markCredentialVerified(this.ctx, scope);
+				},
+				cliVersion: () => codexCliVersion(this.ctx, homeDir),
+				...member === void 0 ? {} : { member: { configOverride: member.configOverride } },
+				childSession,
+				ctx: this.ctx,
+				onThreadId: (threadId) => {
+					if (threadId === void 0) return;
+					this.ctx.localAgent.recordDelegation({
+						childSessionId: runId,
+						provider: this.name,
+						parentSessionId: request.parent.session.id,
+						cliSessionId: threadId,
+						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 thread inside the existing child session. */
+	async startCodexResume(request, intent, cwd, homeDir, exec, scope, requestedModel, configuration) {
+		if (!this.ctx.localAgent.acquireResumeLock(intent.childSessionId)) throw new Error(`subagent-codex: 该子会话有进行中的委派，等其完成后再追问 (child session ${intent.childSessionId})`);
+		try {
+			const childSession = this.ctx.get("sessions")?.get(SessionId(intent.childSessionId));
+			if (childSession === void 0) throw new Error(`subagent-codex: 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 baseUrl = await readCodexBaseUrl(homeDir).catch(() => void 0);
+			this.ctx.logger.info(`subagent-codex: resuming via ${baseUrl ?? "codex default endpoint"}`);
+			const live = exec === void 0 ? this.liveDriver(intent.childSessionId) : void 0;
+			if (live !== void 0 && !live.disabled) {
+				const startModel = configuration === void 0 ? this.overrides?.(intent.childSessionId) ?? requestedModel : configuration.resolved.model;
+				try {
+					const liveRun = await live.startRound(request, {
+						cwd,
+						homeDir,
+						childSession,
+						parentSessionId: request.parent.session.id,
+						resume: {
+							cliSessionId: intent.cliSessionId,
+							turn: nextTurn
+						},
+						...startModel === void 0 ? {} : { startModel },
+						...configuration === void 0 ? {} : { configuration: configuration.resolved }
+					});
+					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-codex: live driver unavailable, using the exec one-shot: ${error.message}`);
+				}
+			}
+			const member = exec === void 0 ? this.memberRun(intent.childSessionId, request.parent.session.id) : void 0;
+			let run;
+			try {
+				run = await startCodexCliRun(request, {
+					cwd,
+					env: delegationEnv({ CODEX_HOME: homeDir }),
+					...exec === void 0 ? {} : { exec },
+					endpointLabel: baseUrl,
+					sandbox: this.sandbox,
+					...configuration?.resolved ?? resolveRoundModel(this.overrides?.(intent.childSessionId) ?? requestedModel, this.model),
+					disposeGraceMs: DEFAULT_DISPOSE_GRACE_MS,
+					spawn: (spec) => this.ctx.subprocess.spawn(spec),
+					onError: (error, stopReason) => {
+						this.ctx.logger.warn(`subagent-codex: child run failed (${stopReason}) via ${baseUrl ?? "codex default endpoint"}: ${error instanceof Error ? error.message : String(error)}`);
+					},
+					onAuthFailure: (detail) => {
+						this.ctx.localAgent.reportAuthFailure("codex", detail, scope);
+					},
+					onAuthSuccess: () => {
+						markCredentialVerified(this.ctx, scope);
+					},
+					cliVersion: () => codexCliVersion(this.ctx, homeDir),
+					...member === void 0 ? {} : { member: { configOverride: member.configOverride } },
+					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-codex: the one-shot task must contain only text blocks");
+	const texts = [];
+	for (const block of prompt) {
+		if (block.type !== "text") throw new Error("subagent-codex: 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-codex: the one-shot task must not be empty");
+	return texts.join("\n");
+}
+/** Count one tool call under the CLI's own name for the item. */
+function countToolCall(state, name) {
+	state.toolCalls.set(name, (state.toolCalls.get(name) ?? 0) + 1);
+}
+/**
+* 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
+	};
+}
+/**
+* Fold one NDJSON line into the stream state. Shared by
+* {@link parseCodexJsonStream} (settle-time whole-stream parse) and
+* {@link CodexStreamParser} (live incremental parse) so the two paths cannot
+* drift.
+*/
+function foldCodexStreamLine(state, raw) {
+	const line = raw.trim();
+	if (line === "") return;
+	let event;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (event.type === "thread.started" && typeof event.thread_id === "string") {
+		state.threadId = event.thread_id;
+		if (typeof event.model === "string" && event.model !== "") state.model = event.model;
+		return;
+	}
+	if (event.type === "turn.completed") {
+		state.completed = true;
+		if (event.usage !== void 0) state.usage = usageFromCodex(event.usage);
+		if (typeof event.model === "string" && event.model !== "") state.model = event.model;
+		return;
+	}
+	if (event.type !== "item.completed" || event.item === void 0) return;
+	const item = event.item;
+	if (item.type === "reasoning" && typeof item.text === "string" && item.text.trim() !== "") state.lines.push({
+		kind: "think",
+		text: item.text
+	});
+	else if (item.type === "agent_message" && typeof item.text === "string") {
+		state.lines.push({
+			kind: "text",
+			text: item.text
+		});
+		state.text = item.text;
+	} else if (item.type === "command_execution") {
+		countToolCall(state, "command_execution");
+		const command = typeof item.command === "string" ? item.command : void 0;
+		const output = typeof item.aggregated_output === "string" && item.aggregated_output.trim() !== "" ? item.aggregated_output : void 0;
+		if (command !== void 0 || output !== void 0) state.lines.push({
+			kind: "tool",
+			id: typeof item.id === "string" ? item.id : `codex-tool-${state.lines.length}`,
+			name: "Bash",
+			...command === void 0 ? {} : { args: command },
+			...output === void 0 ? {} : { result: output }
+		});
+	} else if (item.type === "web_search_call") {
+		countToolCall(state, "web_search_call");
+		state.lines.push({
+			kind: "tool",
+			id: typeof item.id === "string" ? item.id : `codex-tool-${state.lines.length}`,
+			name: "WebSearch"
+		});
+	} else if (item.type === "file_change") {
+		countToolCall(state, "file_change");
+		const args = (item.changes ?? []).map((change) => `${change.kind ?? "update"}: ${change.path ?? "?"}`).join("\n");
+		if (args !== "") state.lines.push({
+			kind: "tool",
+			id: typeof item.id === "string" ? item.id : `codex-tool-${state.lines.length}`,
+			name: "ApplyPatch",
+			args
+		});
+	} else if (item.type === "function_call") {
+		countToolCall(state, "function_call");
+		state.lines.push({
+			kind: "tool",
+			id: typeof item.id === "string" ? item.id : `codex-tool-${state.lines.length}`,
+			name: item.name ?? "function",
+			...typeof item.arguments === "string" && item.arguments !== "" ? { args: item.arguments } : {}
+		});
+	} else if (item.type === "function_call_output") {
+		const output = typeof item.output === "string" ? item.output : void 0;
+		if (output !== void 0 && output.trim() !== "") {
+			const last = state.lines[state.lines.length - 1];
+			if (last !== void 0 && last.kind === "tool") state.lines[state.lines.length - 1] = {
+				...last,
+				result: last.result === void 0 ? output : `${last.result}\n${output}`
+			};
+		}
+	}
+}
+/**
+* Incremental `codex exec --json` parser: feed stdout chunks as they arrive
+* and the folded transcript accumulates line by line. The last line is
+* volatile until the terminal `turn.completed` — a `function_call_output`
+* merges into a pending tool line — so live consumers hold it back (see the
+* run's live mirror).
+*/
+var CodexStreamParser = class {
+	buffer = "";
+	lines = [];
+	text;
+	usage;
+	threadId;
+	model;
+	completed = 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) foldCodexStreamLine(this, raw);
+	}
+};
+/**
+* Parse a `codex exec --json` NDJSON event stream into an ordered transcript
+* (thinking, agent text, tool/command activity in event order), plus the final
+* answer text, token usage, the thread id a later resume round continues, and
+* the model identifier the stream named (usually absent — codex 0.144.0 does
+* not put one on the wire; the settle path then reads the rollout's
+* turn_context). Item types covered: `reasoning` (thinking), `agent_message`
+* (reply text), `command_execution` (shell command with aggregated output),
+* `web_search_call`, and `function_call_output`. The last `agent_message`
+* wins as the run output (the final answer), and `turn.completed` carries the
+* turn's usage. Malformed lines are skipped.
+* @param stream - the collected stdout NDJSON text.
+* @returns the ordered transcript, final answer text, usage, thread id, and
+*   any stream-named model.
+*/
+function parseCodexJsonStream(stream) {
+	const state = {
+		lines: [],
+		text: void 0,
+		usage: void 0,
+		threadId: void 0,
+		model: void 0,
+		completed: false,
+		toolCalls: /* @__PURE__ */ new Map()
+	};
+	for (const raw of stream.split("\n")) foldCodexStreamLine(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.threadId === void 0 ? {} : { threadId: state.threadId },
+		...state.model === void 0 ? {} : { model: state.model },
+		...toolCalls === void 0 ? {} : { toolCalls }
+	};
+}
+/**
+* Start the real `codex exec` child and publish its run. The codex
+* reply arrives as an NDJSON event stream on stdout (`--json`): the final
+* `agent_message` item is the run output and the `turn.completed` usage is
+* the token accounting. stderr is piped for diagnostics and never folded
+* into the run output. A resume round spawns `codex exec --json resume
+* <thread_id>` instead, continuing the same thread. 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.
+*/
+function startCodexCliRun(request, spec) {
+	const task = textTask(request.prompt);
+	if (request.signal.aborted) throw new Error("subagent-codex: request was aborted before the CLI started");
+	const turn = spec.resume?.turn ?? 1;
+	const memberArgv = spec.member === void 0 ? [] : ["-c", spec.member.configOverride];
+	const modelArgv = [...spec.model === void 0 ? [] : ["-m", spec.model], ...spec.effort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(spec.effort)}`]];
+	const argv = spec.resume === void 0 ? [
+		"codex",
+		"exec",
+		...memberArgv,
+		...modelArgv,
+		"--sandbox",
+		spec.sandbox,
+		"--skip-git-repo-check",
+		"--json",
+		task
+	] : [
+		"codex",
+		"exec",
+		...memberArgv,
+		...modelArgv,
+		"--sandbox",
+		spec.sandbox,
+		"--skip-git-repo-check",
+		"--json",
+		"resume",
+		spec.resume.cliSessionId,
+		task
+	];
+	const launch = spec.exec === void 0 ? {
+		argv,
+		env: spec.env
+	} : containerExecSpawn(spec.exec, {
+		argv,
+		env: spec.env
+	}, "subagent-codex");
+	const child = spec.spawn({
+		argv: launch.argv,
+		cwd: spec.cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe"
+		},
+		graceMs: spec.disposeGraceMs,
+		env: launch.env
+	});
+	const startedAtMs = Date.now();
+	spec.childSession?.append("turn/start", { turn });
+	const liveMirror = spec.childSession !== void 0 && spec.ctx !== void 0 ? createCodexLiveMirror(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-codex: 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-codex: run cancelled locally")), { once: true });
+	});
+	const processFailure = child.done.then((outcome) => Promise.reject(/* @__PURE__ */ new Error(`subagent-codex: 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 = parseCodexJsonStream(drained !== void 0 && drained !== "" ? drained : output).text?.trim();
+		return text === void 0 || text === "" ? [] : [{
+			type: "text",
+			text
+		}];
+	};
+	let exitCode = null;
+	/** The flattened failure's own message, snapshotted for the diagnostic. */
+	let settleFailure;
+	const result = settleRunResult({
+		attempt: () => Promise.race([
+			child.done.then((outcome) => {
+				if (outcome.exitCode !== 0) {
+					const via = spec.endpointLabel ?? "codex default endpoint";
+					exitCode = outcome.exitCode;
+					throw new Error(`subagent-codex: codex exec exited with code ${String(outcome.exitCode)} via ${via}`);
+				}
+				if (parseCodexJsonStream(output).lines.length === 0) {
+					spec.onError?.(/* @__PURE__ */ new Error("subagent-codex: exited 0 but parsed no codex events — check the codex --json event schema"), "error");
+					throw new Error("subagent-codex: codex exec exited 0 but produced no answer");
+				}
+				const answer = collectOutput();
+				if (answer.length === 0) throw new Error("subagent-codex: codex exec exited 0 but produced no answer");
+				return {
+					output: answer,
+					stopReason: "completed"
+				};
+			}),
+			processFailure,
+			abortBranch
+		]),
+		collectOutput,
+		collectDiagnostic: () => {
+			const detail = [];
+			if (settleFailure !== void 0) detail.push(settleFailure);
+			const stderrTail = (child.collected.stderr?.readFrom(0).text || stderr).trim();
+			if (stderrTail !== "") detail.push(`stderr: ${stderrTail.slice(-500)}`);
+			const homeDir = spec.env["CODEX_HOME"];
+			if (homeDir !== void 0 && homeDir !== "") {
+				const threadId = parseCodexJsonStream(output).threadId;
+				const when = new Date(startedAtMs);
+				const dir = `${homeDir}/sessions/${String(when.getFullYear())}/${String(when.getMonth() + 1).padStart(2, "0")}/${String(when.getDate()).padStart(2, "0")}`;
+				detail.push(threadId === void 0 ? `rollout 目录: ${dir}` : `rollout: ${dir}/rollout-*-${threadId}.jsonl`);
+			}
+			return detail.length === 0 ? void 0 : detail.join("\n");
+		},
+		cancelled: () => runAbort.signal.aborted,
+		onError: (error, stopReason) => {
+			settleFailure = error instanceof Error ? error.message : String(error);
+			spec.onError?.(error instanceof Error ? error : new Error(String(error)), stopReason);
+		},
+		signal: request.signal,
+		onAbort
+	}).then((settled) => {
+		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
+		if (spec.childSession !== void 0) {
+			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
+				turn,
+				reason: { kind: "completed" }
+			});
+			else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "aborted",
+					reason: { kind: "parent" }
+				}
+			});
+			else spec.childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "error",
+					error: {
+						message: `codex exec exited with code ${String(exitCode)}`,
+						code: "UNKNOWN"
+					}
+				}
+			});
+		}
+		return settled;
+	});
+	result.then(() => child.done).then(() => {
+		if (spec.onAuthFailure !== void 0) {
+			const authDetail = `${child.collected.stderr?.readFrom(0).text || stderr}\n${child.collected.stdout?.readFrom(0).text || output}`;
+			if (CODEX_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
+		}
+		return mirrorCodexAfterExit(spec, task, turn, output, liveMirror, startedAtMs);
+	}, () => {});
+	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 codex route. */
+function codexAssistantEvent(blocks) {
+	return createAssistantMessage({
+		content: blocks,
+		source: {
+			provider: "codex-local",
+			model: "codex"
+		}
+	});
+}
+/**
+* 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.
+* @returns whether the line folded (false when the options skipped it).
+*/
+function appendCodexTranscriptLine(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 true;
+	}
+	const blocks = line.kind === "think" ? [{
+		type: "reasoning",
+		text: line.text
+	}] : [{
+		type: "text",
+		text: line.text
+	}];
+	childSession.append("assistant/message", {
+		turn,
+		step,
+		message: codexAssistantEvent(blocks),
+		stream: [],
+		...usage === void 0 ? {} : { usage }
+	}, { surfaceOp: "append" });
+	childSession.append("step/end", {
+		turn,
+		step
+	});
+	return true;
+}
+/** Fold one transcript line into the run's child session as one assistant step. */
+function appendCodexLine(spec, turn, step, line, usage) {
+	if (spec.childSession === void 0) return;
+	appendCodexTranscriptLine(spec.childSession, turn, step, line, usage);
+}
+/** The delta-progress text for one transcript line. */
+function codexLineText(line) {
+	return line.kind === "tool" ? `[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}${line.result !== void 0 ? `\n${line.result}` : ""}` : line.text;
+}
+/** Create the per-run live mirror over the incremental parser. */
+function createCodexLiveMirror(spec, task, turn) {
+	const parser = new CodexStreamParser();
+	const childSession = spec.childSession;
+	const ctx = spec.ctx;
+	let mirrored = 0;
+	let userMirrored = 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);
+			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;
+						appendCodexLine(spec, turn, index + 1, line, usage);
+						mirrored = index + 1;
+						localAgent?.reportRunProgress(childSession.id, {
+							kind: "delta",
+							text: codexLineText(line)
+						});
+					}
+					await persistChildSession(ctx, childSession);
+					localAgent?.reportRunProgress(childSession.id, {
+						kind: "mirror",
+						mirroredLines: mirrored
+					});
+				} catch (error) {
+					ctx.logger.warn(`subagent-codex: live mirror failed: ${thrown(error).message}`);
+				}
+			});
+		}
+	};
+	return mirror;
+}
+/**
+* Mirror the delegation's user prompt and the codex event 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 subagent record degrades to a final-text-only view).
+* The transcript's reasoning folds to `reasoning` blocks, agent text and tool
+* activity to text blocks (tool lines render `[工具 Bash] <command> → output`),
+* and the final assistant message carries the round's usage when codex
+* 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 NDJSON 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 appendCodexResponse(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)) {
+		appendCodexLine(spec, turn, step, line, step - 1 === usageIndex ? parsed.usage : void 0);
+		localAgent?.reportRunProgress(childSession.id, {
+			kind: "delta",
+			text: codexLineText(line)
+		});
+		step += 1;
+	}
+	if (parsed.usage !== void 0 && usageIndex !== -1 && usageIndex < fromLines) spec.ctx?.logger.warn(`subagent-codex: 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 codex NDJSON stream 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 (reasoning, commands,
+* replies, usage) instead of leaving the child blank — the run result settles
+* 'aborted'/'error' at the cancel moment, but codex may have produced content
+* before the kill landed. Also records the thread id (fresh rounds) so a
+* later resume can continue the partial thread.
+*
+* **Usage recovery**: a non-completed terminal state never emits
+* `turn.completed`, so the parsed stream carries no usage even though codex
+* wrote the run's real token spend to its rollout file. When the stream's
+* usage is absent, the mirror falls back to the run's rollout file — located
+* by the thread id (the `session_meta` head id) or by the spawn-time window —
+* and attaches the file's LAST `token_count` entry (same
+* `input − cached` caliber as `turn.completed`, via the shared
+* {@link usageFromCodex}), so a killed or failed run still books its tokens.
+* The fallback is best-effort and silent: no rollout file, an unreadable
+* home, or a hard kill that wrote no token_count leaves the child without
+* usage, exactly as before.
+*
+* **Model observation**: the exec --json wire carries no model field (codex
+* 0.144.0), so the run's model identifier is read from the located rollout
+* file's LAST `turn_context` line whose timestamp falls inside this run's
+* window — the turn codex actually started for this round. When the stream
+* itself names a model (a future CLI), the stream wins. Absent on any miss;
+* the observation rides {@link CodexCliRunSpec.onRoundSettled} along with the
+* round's usage.
+* @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 NDJSON stdout.
+* @param startedAtMs - the spawn moment, anchoring the rollout time window.
+*/
+async function mirrorCodexAfterExit(spec, task, turn, output, live, startedAtMs) {
+	if (spec.childSession === void 0 || spec.ctx === void 0) return;
+	const work = async () => {
+		const parsed = parseCodexJsonStream(output);
+		if (spec.resume === void 0) spec.onThreadId?.(parsed.threadId);
+		const fromLines = live?.mirroredLines ?? 0;
+		const userMirrored = live?.userMirrored ?? false;
+		let usage = parsed.usage;
+		let observedModel = parsed.model;
+		let cliVersion;
+		const homeDir = spec.env["CODEX_HOME"];
+		if (homeDir !== void 0 && homeDir !== "") {
+			const facts = await codexRolloutRoundFacts(homeDir, {
+				threadId: parsed.threadId,
+				windowStart: startedAtMs,
+				cwd: spec.cwd
+			});
+			usage ??= facts.usage;
+			observedModel ??= facts.model;
+			cliVersion = facts.cliVersion;
+		}
+		cliVersion ??= await spec.cliVersion?.();
+		spec.onRoundSettled?.({
+			...observedModel === void 0 ? {} : { observedModel },
+			...cliVersion === void 0 ? {} : { cliVersion },
+			...usage === void 0 ? {} : { usage },
+			...parsed.toolCalls === void 0 ? {} : { toolCalls: parsed.toolCalls }
+		});
+		if (parsed.lines.length === 0 && !userMirrored) return;
+		await appendCodexResponse(spec, task, turn, {
+			lines: parsed.lines,
+			output: collectOutputBlocks(parsed.text),
+			...usage === void 0 ? {} : { usage }
+		}, fromLines, userMirrored);
+	};
+	try {
+		if (live === void 0) await work();
+		else await live.enqueue(work);
+	} catch (error) {
+		spec.onError?.(thrown(error), "error");
+	}
+}
+/** Build the run-output blocks from the final codex answer text. */
+function collectOutputBlocks(text) {
+	const trimmed = text?.trim();
+	return trimmed === void 0 || trimmed === "" ? [] : [{
+		type: "text",
+		text: trimmed
+	}];
+}
+//#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-codex — internal, unit-tested directly.
+*/
+var LiveDriverSwitch = class {
+	ctx;
+	options;
+	liveOn = false;
+	active;
+	/** Retiring generations still draining their in-flight rounds. */
+	draining = /* @__PURE__ */ new Set();
+	unwatch;
+	constructor(ctx, face, options) {
+		this.ctx = ctx;
+		this.options = options;
+		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 codex
+	* thread 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 model the member's live runtime bound at spawn (the broker's switch
+	* check): the identifier, undefined for "bound to no model", null for "no
+	* live runtime". Consults only the ACTIVE generation — a draining one is on
+	* its way out anyway.
+	*/
+	boundModel(childSessionId) {
+		return this.active?.boundModelOf(childSessionId) ?? null;
+	}
+	/**
+	* Retire the member's resident runtime in the active generation so the next
+	* round respawns onto the member's new effective model (the composer's
+	* model switch path; the CLI session itself carries over via thread/resume).
+	*/
+	async retireRuntime(childSessionId) {
+		await this.active?.retireRuntime(childSessionId);
+	}
+	/** 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 CodexLiveDriver(this.ctx, {
+			...this.options.sandbox === void 0 ? {} : { sandbox: this.options.sandbox },
+			...this.options.liveIdleMs === void 0 ? {} : { liveIdleMs: this.options.liveIdleMs },
+			...this.options.model === void 0 ? {} : { model: this.options.model }
+		}) : void 0;
+		if (retiring !== void 0) {
+			this.draining.add(retiring);
+			retiring.drain().then(() => {
+				this.draining.delete(retiring);
+			}, (error) => {
+				this.draining.delete(retiring);
+				this.ctx.logger.warn(`local-agent-codex: 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/model-broker.js
+/**
+* The codex harness's model broker: the member-aware model surface the core
+* gateway routes to (`harnessModel` for the settings card, `memberModel` /
+* `setMemberModel` for the composer picker). It owns the session-level
+* override map — shared with the exec provider (which consults it per round)
+* and the live driver (which binds it at runtime spawn) — and retires a
+* member's resident runtime when a switch leaves it bound to a different
+* model, so the NEXT round respawns onto the new one while the codex thread
+* itself carries over via thread/resume.
+*
+* Resolution order is the family's fixed one (first match wins): override →
+* the delegation's recorded model → the plugin-config `model` (settings) →
+* the scoped config.toml's own `model` (cliDefault) → the account catalog's
+* `isDefault` slug (catalogDefault) → the CLI's built-in default, which names
+* nothing. The catalogDefault layer is the ONE case source `cli-builtin`
+* carries an `effective` model: the app-server probe marks the account's
+* compiled default with `isDefault`, so "follow the CLI default" finally has
+* a name. The `cliDefault` FIELD stays scoped-config-only — the two layers
+* must stay distinguishable (the file is user-editable, the catalog answer is
+* the account's). The pickable vocabulary is what the instance actually
+* knows — settings + cliDefault + the identifiers the scoped config itself
+* carries (profiles) + the app-server `model/list` account catalog (probed,
+* cached, best-effort — see model-catalog.ts) + the card's recent-model
+* memory — never a hardcoded catalog.
+* @module @khorsheed/dsh-local-agent-codex/model-broker
+*/
+/** Dedupe the choice vocabulary, dropping unset layers and blanks. */
+function dedupeChoices(layers) {
+	const seen = /* @__PURE__ */ new Set();
+	const choices = [];
+	for (const layer of layers) {
+		const value = layer?.trim();
+		if (value === void 0 || value === "" || seen.has(value)) continue;
+		seen.add(value);
+		choices.push(value);
+	}
+	return choices;
+}
+var CodexModelBroker = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	configurationAdapter(binding) {
+		const home = this.deps.ctx.localAgent.homeDir("codex", binding.scope);
+		const resolve = async (selection) => {
+			let directory = this.deps.directory?.(home, binding.cwd);
+			if (directory?.status === "loading") {
+				await this.deps.refreshDirectory?.(home, binding.cwd);
+				directory = this.deps.directory?.(home, binding.cwd);
+			}
+			const model = selection.model.mode === "value" ? selection.model.value : (selection.model.mode === "inherit" ? binding.model : void 0) ?? this.deps.settingsModel() ?? await readCodexModel(home) ?? this.deps.catalogDefault(home, binding.cwd);
+			const entry = directory?.entries.find((entry) => entry.value === model);
+			const explicitEffort = selection.effort.mode === "value" ? selection.effort.value : selection.effort.mode === "inherit" ? binding.effort : void 0;
+			const effort = explicitEffort ?? await readCodexReasoningEffort(home) ?? entry?.reasoning?.default;
+			if (explicitEffort !== void 0 && !entry?.reasoning?.options.some((option) => option.value === explicitEffort)) throw new Error("Codex has not advertised this reasoning effort for the selected model; refresh its native directory");
+			return {
+				...model === void 0 ? {} : { model },
+				...effort === void 0 ? {} : { effort }
+			};
+		};
+		return {
+			validate: async (selection) => {
+				await resolve(selection);
+			},
+			prepare: resolve,
+			apply: async (selection) => {
+				const resolved = await resolve(selection);
+				await this.deps.retireRuntime(binding.childSessionId);
+				return resolved;
+			},
+			reconcile: async (state) => {
+				if (this.activeDelegations().includes(binding.childSessionId)) return {
+					active: true,
+					matches: "unknown",
+					resolved: {}
+				};
+				await this.deps.retireRuntime(binding.childSessionId);
+				return {
+					active: false,
+					matches: "current",
+					resolved: await resolve(state.current.selection)
+				};
+			}
+		};
+	}
+	async modelDirectory(childSessionId, refresh = false) {
+		const home = this.deps.homeDir(childSessionId);
+		if (refresh) await this.deps.refreshDirectory?.(home, this.deps.cwd?.(childSessionId));
+		return (await this.modelInfo(childSessionId, childSessionId === void 0 ? void 0 : this.deps.ctx.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(this.deps.homeDir(childSessionId), this.deps.cwd?.(childSessionId), signal)) yield await this.modelDirectory(childSessionId);
+	}
+	/** The member's in-flight rounds (an empty answer on a core that predates the read). */
+	activeDelegations() {
+		const registry = this.deps.ctx.localAgent;
+		return typeof registry.activeDelegations === "function" ? registry.activeDelegations() : [];
+	}
+	/** The model the member's NEXT spawn binds explicitly: override → recorded → settings. */
+	boundLayer(childSessionId) {
+		const override = this.deps.overrides.get(childSessionId);
+		if (override !== void 0) return override;
+		const recorded = this.deps.ctx.localAgent.getDelegation(childSessionId)?.model?.trim();
+		if (recorded !== void 0 && recorded !== "") return recorded;
+		return this.deps.settingsModel();
+	}
+	/**
+	* Read the model surface. The cliDefault and the discovered identifiers come
+	* from the scoped config.toml LIVE (a person-edited file is authoritative);
+	* a read failure degrades that layer to absent, never to a guessed value.
+	* The account catalog comes from the probe cache SYNCHRONOUSLY (a cold
+	* cache reads empty and re-probes in the background — the settings card
+	* re-fetches on open, so it never blocks on a CLI boot).
+	*/
+	async modelInfo(childSessionId, delegationModel) {
+		const settings = this.deps.settingsModel();
+		const homeDir = this.deps.homeDir(childSessionId);
+		const [cliDefault, discovered] = await Promise.all([readCodexModel(homeDir).catch(() => void 0), listCodexConfigModels(homeDir).catch(() => [])]);
+		const override = childSessionId === void 0 ? void 0 : this.deps.overrides.get(childSessionId);
+		const delegation = delegationModel?.trim() === "" ? void 0 : delegationModel;
+		const catalogDefaultRaw = this.deps.catalogDefault(homeDir, this.deps.cwd?.(childSessionId))?.trim();
+		const effective = override ?? delegation ?? settings ?? cliDefault ?? (catalogDefaultRaw === void 0 || catalogDefaultRaw === "" ? void 0 : catalogDefaultRaw);
+		const source = override !== void 0 ? "override" : delegation !== void 0 ? "delegation" : settings !== void 0 ? "settings" : cliDefault !== void 0 ? "cli-config" : "cli-builtin";
+		const inFlight = childSessionId !== void 0 && this.activeDelegations().includes(childSessionId);
+		return {
+			...effective === void 0 ? {} : { effective },
+			source,
+			...override === void 0 ? {} : { override },
+			...delegation === void 0 ? {} : { delegation },
+			...settings === void 0 ? {} : { settings },
+			...cliDefault === void 0 ? {} : { cliDefault },
+			...this.deps.directory === void 0 ? {} : { directory: extendModelDirectory(this.deps.directory(homeDir, this.deps.cwd?.(childSessionId)), [
+				settings,
+				cliDefault,
+				...discovered
+			], this.deps.recentModels()) },
+			choices: dedupeChoices([
+				settings,
+				cliDefault,
+				...discovered,
+				...this.deps.catalog(homeDir, this.deps.cwd?.(childSessionId)),
+				...this.deps.recentModels()
+			]),
+			live: this.deps.live(),
+			switchable: !inFlight,
+			...inFlight ? { reason: "成员有进行中的委派轮次，等其完成后再切换模型" } : {}
+		};
+	}
+	/**
+	* Set (or clear) the member's session-level override. Same-model is a
+	* no-op; a different model with a live runtime bound elsewhere retires the
+	* runtime so the next round respawns (the codex thread resumes). Throws
+	* while a round is in flight — retiring mid-round would kill the run.
+	*/
+	async setMemberModel(childSessionId, model) {
+		if (typeof this.deps.ctx.localAgent.setMemberModel === "function") return this.deps.ctx.localAgent.setMemberModel(childSessionId, model);
+		if (this.activeDelegations().includes(childSessionId)) throw new Error(`subagent-codex: 成员有进行中的委派轮次，等其完成后再切换模型 (child session ${childSessionId})`);
+		const trimmed = model?.trim();
+		const next = trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+		if (this.deps.overrides.get(childSessionId) === next) return;
+		if (next === void 0) this.deps.overrides.delete(childSessionId);
+		else this.deps.overrides.set(childSessionId, next);
+		const bound = this.deps.liveBoundModel(childSessionId);
+		if (bound !== null && bound !== this.boundLayer(childSessionId)) await this.deps.retireRuntime(childSessionId);
+	}
+};
+/** Grace between stdin EOF and terminate when the probe tears the process down. */
+const PROBE_EOF_GRACE_MS = 1e3;
+/** Preserve native metadata, including hidden candidates; reject malformed pages. */
+function catalogEntries(result) {
+	const page = result;
+	if (!Array.isArray(page?.data)) throw new Error("model/list returned no model array");
+	const entries = [];
+	let defaultModel;
+	for (const entry of page.data) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		const raw = typeof record["id"] === "string" ? record["id"] : record["model"];
+		const value = typeof raw === "string" ? raw.trim() : "";
+		if (value === "") continue;
+		if (record["isDefault"] === true && defaultModel === void 0) defaultModel = value;
+		const nativeEfforts = record["supportedReasoningEfforts"];
+		const options = Array.isArray(nativeEfforts) ? nativeEfforts.flatMap((option) => {
+			if (typeof option !== "object" || option === null) return [];
+			const effort = option;
+			const choice = effort["reasoningEffort"];
+			if (typeof choice !== "string" || choice === "") return [];
+			return [{
+				value: choice,
+				label: choice,
+				...typeof effort["description"] === "string" ? { description: effort["description"] } : {}
+			}];
+		}) : void 0;
+		const defaultEffort = record["defaultReasoningEffort"];
+		entries.push({
+			value,
+			label: typeof record["displayName"] === "string" ? record["displayName"] : value,
+			source: "native",
+			hidden: record["hidden"] === true,
+			...typeof record["description"] === "string" ? { description: record["description"] } : {},
+			...options === void 0 ? {} : { reasoning: {
+				options,
+				...typeof defaultEffort === "string" ? { default: defaultEffort } : {}
+			} }
+		});
+	}
+	return {
+		entries,
+		...defaultModel === void 0 ? {} : { defaultModel },
+		...typeof page.nextCursor === "string" && page.nextCursor !== "" ? { nextCursor: page.nextCursor } : {}
+	};
+}
+/** Synchronous compatibility reads plus a rich, subscribable directory. */
+var CodexModelCatalog = class {
+	deps;
+	timeoutMs;
+	cache;
+	constructor(deps) {
+		this.deps = deps;
+		this.timeoutMs = deps.timeoutMs ?? 5e3;
+		this.cache = new ModelDirectoryCache({
+			load: (key, signal) => {
+				const context = JSON.parse(key);
+				return this.probe(context.homeDir, context.cwd, signal);
+			},
+			ttlMs: deps.ttlMs ?? 3e5,
+			...deps.now === void 0 ? {} : { now: deps.now },
+			onError: (error) => deps.warn?.(`local-agent-codex: the model catalog probe degraded: ${error instanceof Error ? error.message : String(error)}`)
+		});
+	}
+	key(homeDir, cwd = homeDir) {
+		const files = [join(homeDir, "config.toml"), join(homeDir, "auth.json")];
+		for (let directory = cwd;; directory = dirname(directory)) {
+			files.push(join(directory, ".codex", "config.toml"));
+			if (dirname(directory) === directory) break;
+		}
+		return modelDirectoryContextKey({
+			provider: "codex",
+			homeDir,
+			cwd,
+			cli: ["codex"],
+			files
+		});
+	}
+	read(homeDir, cwd) {
+		return this.directory(homeDir, cwd).entries.filter((entry) => !entry.hidden).map((entry) => entry.value);
+	}
+	readDefault(homeDir, cwd) {
+		return this.directory(homeDir, cwd).defaultModel;
+	}
+	directory(homeDir, cwd) {
+		return this.cache.read(this.key(homeDir, cwd));
+	}
+	follow(homeDir, signal, cwd) {
+		return this.cache.follow(() => this.key(homeDir, cwd), signal);
+	}
+	invalidate(homeDir, cwd) {
+		this.cache.invalidate(this.key(homeDir, cwd));
+	}
+	dispose() {
+		this.cache.dispose();
+	}
+	async refresh(homeDir, cwd) {
+		return (await this.cache.refresh(this.key(homeDir, cwd))).entries.filter((entry) => !entry.hidden).map((entry) => entry.value);
+	}
+	/**
+	* One bounded probe: spawn the app-server against the scoped home, answer
+	* the initialize handshake exactly as the live driver shapes it, ask
+	* `model/list`, then tear the process down (stdin EOF → grace →
+	* terminate). The overall timeout kills the process on expiry. Failures propagate to the shared cache, which preserves prior data.
+	*/
+	async probe(homeDir, cwd, signal) {
+		const spec = {
+			argv: [
+				"codex",
+				"app-server",
+				"--stdio"
+			],
+			cwd,
+			stdio: {
+				stdin: "pipe",
+				stdout: "pipe",
+				stderr: "pipe"
+			},
+			graceMs: DEFAULT_DISPOSE_GRACE_MS,
+			env: delegationEnv({ CODEX_HOME: homeDir })
+		};
+		const child = this.deps.spawn(spec);
+		const decoder = new StringDecoder("utf8");
+		let buffer = "";
+		const pending = /* @__PURE__ */ new Map();
+		let nextId = 0;
+		let done = false;
+		const finish = () => {
+			if (done) return;
+			done = true;
+			for (const request of pending.values()) request.reject(/* @__PURE__ */ new Error("the model catalog probe closed"));
+			pending.clear();
+		};
+		child.stdout?.on("data", (chunk) => {
+			buffer += decoder.write(chunk);
+			let index = buffer.indexOf("\n");
+			while (index >= 0) {
+				const line = buffer.slice(0, index);
+				buffer = buffer.slice(index + 1);
+				index = buffer.indexOf("\n");
+				if (line.trim() === "") continue;
+				let message;
+				try {
+					message = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				const id = typeof message.id === "number" ? message.id : void 0;
+				if (id !== void 0 && typeof message.method === "string") {
+					child.stdin?.write(JSON.stringify({
+						jsonrpc: "2.0",
+						id,
+						error: {
+							code: -32601,
+							message: "unsupported"
+						}
+					}) + "\n");
+					continue;
+				}
+				if (id === void 0) continue;
+				const request = pending.get(id);
+				if (request === void 0) continue;
+				pending.delete(id);
+				const wireError = message.error;
+				if (wireError !== void 0 && wireError !== null) request.reject(new Error(wireError.message ?? "wire error"));
+				else request.resolve(message.result);
+			}
+		});
+		child.done.then(finish, finish);
+		const abort = () => {
+			finish();
+			child.terminate();
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		if (signal.aborted) abort();
+		const request = (method, params) => {
+			if (done) return Promise.reject(/* @__PURE__ */ new Error("the model catalog probe closed"));
+			nextId += 1;
+			const id = nextId;
+			return new Promise((resolve, reject) => {
+				pending.set(id, {
+					resolve: (result) => resolve(result),
+					reject
+				});
+				child.stdin?.write(JSON.stringify({
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				}) + "\n");
+			});
+		};
+		const teardown = async () => {
+			finish();
+			child.stdin?.end();
+			await Promise.race([child.done.catch(() => {}), new Promise((resolve) => setTimeout(resolve, PROBE_EOF_GRACE_MS))]);
+			child.terminate();
+			await child.waitForExit().catch(() => {});
+		};
+		let timer;
+		try {
+			return await Promise.race([(async () => {
+				await request("initialize", {
+					clientInfo: {
+						name: "dsh-local-agent-codex",
+						title: "dsh local-agent codex model catalog probe",
+						version: "0.1.0"
+					},
+					capabilities: {
+						experimentalApi: false,
+						requestAttestation: false
+					}
+				});
+				child.stdin?.write(JSON.stringify({
+					jsonrpc: "2.0",
+					method: "initialized"
+				}) + "\n");
+				const entries = /* @__PURE__ */ new Map();
+				const cursors = /* @__PURE__ */ new Set();
+				let cursor;
+				let defaultModel;
+				do {
+					const page = catalogEntries(await request("model/list", {
+						includeHidden: true,
+						...cursor === void 0 ? {} : { cursor }
+					}));
+					for (const entry of page.entries) if (!entries.has(entry.value)) entries.set(entry.value, entry);
+					defaultModel ??= page.defaultModel;
+					cursor = page.nextCursor;
+					if (cursor !== void 0) {
+						if (cursors.has(cursor)) throw new Error("model/list repeated a pagination cursor");
+						cursors.add(cursor);
+					}
+				} while (cursor !== void 0);
+				return {
+					entries: [...entries.values()],
+					complete: true,
+					customInput: true,
+					...defaultModel === void 0 ? {} : { defaultModel }
+				};
+			})(), new Promise((_, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("the model catalog probe timed out")), this.timeoutMs);
+				timer.unref();
+			})]);
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+			signal.removeEventListener("abort", abort);
+			await teardown();
+		}
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/**
+* Codex harness instantiation of the local-agent family. Registers the
+* `codex` harness into the core registry: scoped home under the shared homes
+* root (`CODEX_HOME`), device-code login through `codex login --device-auth`
+* (prompt captured from stdout), and rollout-file session records.
+* Delegation mounts through the `codex-local` provider (one-shot
+* `codex exec` under the scoped home); the bundle patch's
+* `tool-subagent-codex-local` row puts the tool on the profile root, so
+* every agent preset can delegate.
+*
+* @module @khorsheed/dsh-local-agent-codex
+*/
+/** Stable Cordis plugin name; the bundle patch row id. */
+const name = "local-agent-codex";
+/**
+* Boot delay before the model catalog's eager warmup probe fires. The probe
+* spawns a `codex app-server` — cheap, but not free — so it waits out the
+* boot storm instead of competing with it, and the FIRST settings-card open
+* usually hits a warm cache. A card opened before the timer fires simply
+* triggers the probe itself (the read path's lazy kick), so the delay never
+* costs correctness. Kept short: a setting visible within seconds of boot.
+*/
+const CATALOG_WARMUP_DELAY_MS = 1500;
+/** 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({
+	sandbox: z.union([
+		z.const("read-only"),
+		z.const("workspace-write"),
+		z.const("danger-full-access")
+	]),
+	model: volatilize(SETTINGS_FIELDS.model),
+	live: volatilize(SETTINGS_FIELDS.live),
+	liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
+	liveMirrorGranularity: volatilize(SETTINGS_FIELDS.liveMirrorGranularity),
+	recentModels: volatilize(SETTINGS_FIELDS.recentModels)
+});
+/** The sandbox policy a fresh delegation defaults to. */
+const DEFAULT_SANDBOX = "workspace-write";
+/**
+* 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 CODEX_SETTINGS_NAMESPACE = "local-agent-codex";
+/**
+* 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 CODEX_SETTINGS_SCHEMA = z.object(SETTINGS_FIELDS);
+/**
+* Register the Codex harness into the local-agent registry.
+* @param ctx - plugin context carrying the registry.
+* @param config - plugin config; `sandbox` selects the `codex exec` policy.
+*/
+function apply(ctx, config) {
+	ctx.effect(() => {
+		const sandbox = config.sandbox ?? "workspace-write";
+		const homeDir = ctx.localAgent.homeDir("codex");
+		provisionCodexConfig(homeDir).catch((error) => {
+			ctx.logger.warn(`local-agent-codex: config.toml 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: CODEX_SETTINGS_NAMESPACE,
+			legacySchema: CODEX_SETTINGS_SCHEMA,
+			legacyBase,
+			read: readSettings
+		});
+		const resolveModel = () => {
+			const model = face.get().model?.trim();
+			return model === void 0 || model === "" ? void 0 : model;
+		};
+		const memberModelOverrides = /* @__PURE__ */ new Map();
+		const modelCatalog = new CodexModelCatalog({
+			spawn: (spec) => ctx.subprocess.spawn(spec),
+			warn: (message) => ctx.logger.warn(message)
+		});
+		const warmup = setTimeout(() => {
+			modelCatalog.read(homeDir);
+		}, CATALOG_WARMUP_DELAY_MS);
+		warmup.unref();
+		const liveSwitch = new LiveDriverSwitch(ctx, face, {
+			sandbox,
+			model: (childSessionId) => memberModelOverrides.get(childSessionId) ?? resolveModel(),
+			...config.liveIdleMs === void 0 ? {} : { liveIdleMs: config.liveIdleMs }
+		});
+		const modelBroker = new CodexModelBroker({
+			ctx,
+			settingsModel: resolveModel,
+			recentModels: () => face.get().recentModels ?? [],
+			homeDir: (childSessionId) => ctx.localAgent.homeDir("codex", childSessionId === void 0 ? void 0 : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.scope),
+			cwd: (childSessionId) => childSessionId === void 0 ? void 0 : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.cwd,
+			directory: (home, cwd) => modelCatalog.directory(home, cwd),
+			refreshDirectory: (home, cwd) => modelCatalog.refresh(home, cwd),
+			followDirectory: (home, cwd, signal) => modelCatalog.follow(home, signal, cwd),
+			live: () => face.get().live,
+			overrides: memberModelOverrides,
+			liveBoundModel: (childSessionId) => liveSwitch.boundModel(childSessionId),
+			retireRuntime: (childSessionId) => liveSwitch.retireRuntime(childSessionId),
+			catalog: (scopedHome, cwd) => modelCatalog.read(scopedHome, cwd),
+			catalogDefault: (scopedHome, cwd) => modelCatalog.readDefault(scopedHome, cwd)
+		});
+		const disposeProvider = ctx.subagents.registerProvider(new CodexCliProvider(ctx, sandbox, liveSwitch.resolve, resolveModel, (childSessionId) => memberModelOverrides.get(childSessionId)));
+		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("codex", binding.scope),
+					childSession,
+					parentSessionId: binding.parentSessionId,
+					configuration: configuration.resolved
+				}, signal);
+			},
+			name: "codex",
+			displayName: "Codex",
+			homeEnvVar: "CODEX_HOME",
+			delegationProvider: "codex-local",
+			modelBroker,
+			login: { pty: {
+				command: "codex",
+				args: ["login"]
+			} },
+			records: { listSessions: (homeDir) => listCodexSessions(homeDir) },
+			provision: (scopedHome) => provisionCodexConfig(scopedHome).then(() => {}),
+			isAuthenticated: codexAuthenticated,
+			credentialStamp: codexCredentialStamp,
+			logout: codexLogout,
+			effectiveSettings: async (scopedHome) => {
+				const [reasoningEffort, baseUrl, scopedModel, cliVersion] = await Promise.all([
+					readCodexReasoningEffort(scopedHome).catch(() => void 0),
+					readCodexBaseUrl(scopedHome).catch(() => void 0),
+					readCodexModel(scopedHome).catch(() => void 0),
+					codexCliVersion(ctx, scopedHome).catch(() => void 0)
+				]);
+				const model = resolveModel() ?? scopedModel;
+				const baseUrlHost = baseUrl !== void 0 ? endpointHost(baseUrl) : void 0;
+				return {
+					drive: face.get().live ? "live" : "exec",
+					sandbox,
+					...reasoningEffort !== void 0 ? { reasoningEffort } : {},
+					baseUrlSet: baseUrl !== 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 listCodexSessions(invocation.agent.ctx.localAgent.homeDir("codex")).then((records) => ({
+					kind: "success",
+					text: records.length === 0 ? "No codex sessions in the scoped home yet." : records.map((r) => `${r.id} ${r.workDir}`).join("\n")
+				}));
+			}
+		});
+		return () => {
+			clearTimeout(warmup);
+			modelCatalog.dispose();
+			disposeProvider();
+			disposeHarness();
+			liveSwitch.dispose();
+		};
+	}, "local-agent-codex: harness");
+}
+//#endregion
+export { CATALOG_WARMUP_DELAY_MS, CODEX_SETTINGS_NAMESPACE, Config, DEFAULT_SANDBOX, apply, inject, name };