@khorsheed/dsh-local-agent-codex 0.2.0-rc.3 → 0.2.0

package/lib/index.js

@@ -135,10 +135,12 @@ async function listCodexSessions(homeDir) {
 * `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).
+* bucket subtracts the cached portion to avoid double counting.
+* `cached_input_tokens` rides every payload (zero included), so
+* `cacheReadTokens` is written whenever the field is present — a reader can
+* tell "no hits" from "not reported". Codex also reports cache creation
+* (`cache_write_input_tokens`), mapped to `cacheWriteTokens` (the shared
+* four-bucket contract: uncached input, output, cache read, cache write).
 * @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.
@@ -147,12 +149,14 @@ function usageFromCodex(usage) {
 	const raw = usage;
 	const input = Number(raw.input_tokens);
 	const cached = Number(raw.cached_input_tokens);
+	const cacheWrite = Number(raw.cache_write_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,
+		inputTokens: Number.isFinite(input) && Number.isFinite(cached) ? Math.max(0, input - cached - (Number.isFinite(cacheWrite) ? cacheWrite : 0)) : Number.isFinite(input) ? input : 0,
 		outputTokens: Number.isFinite(output) ? output : 0
 	};
-	if (Number.isFinite(cached) && cached > 0) usageRecord.cacheReadTokens = cached;
+	if (Number.isFinite(cached)) usageRecord.cacheReadTokens = cached;
+	if (Number.isFinite(cacheWrite) && cacheWrite > 0) usageRecord.cacheWriteTokens = cacheWrite;
 	return usageRecord;
 }
 /**
@@ -740,11 +744,6 @@ const DEFAULT_LIVE_CHANNEL_RETRY_MS = 3e5;
 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);
@@ -826,11 +825,14 @@ function codexAppServerItemToLine(item) {
 		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"]);
+			const content = item["contentItems"];
+			const result = Array.isArray(content) ? content.filter((block) => typeof block === "object" && block !== null).map((block) => typeof block["text"] === "string" ? block["text"] : void 0).filter((text) => text !== void 0 && text !== "").join("\n") : void 0;
 			return {
 				kind: "tool",
 				id: itemId ?? `codex-live-${randomUUID()}`,
 				name: tool,
-				...args === void 0 || args === "" ? {} : { args }
+				...args === void 0 || args === "" ? {} : { args },
+				...result === void 0 || result === "" ? {} : { result }
 			};
 		}
 		case "collabAgentToolCall": {
@@ -861,12 +863,14 @@ function codexAppServerItemToLine(item) {
 function usageFromAppServer(breakdown) {
 	const input = Number(breakdown["inputTokens"]);
 	const cached = Number(breakdown["cachedInputTokens"]);
+	const cacheWrite = Number(breakdown["cacheWriteInputTokens"]);
 	const output = Number(breakdown["outputTokens"]);
 	const usage = {
-		inputTokens: Number.isFinite(input) && Number.isFinite(cached) ? Math.max(0, input - cached) : Number.isFinite(input) ? input : 0,
+		inputTokens: Number.isFinite(input) && Number.isFinite(cached) ? Math.max(0, input - cached - (Number.isFinite(cacheWrite) ? cacheWrite : 0)) : Number.isFinite(input) ? input : 0,
 		outputTokens: Number.isFinite(output) ? output : 0
 	};
-	if (Number.isFinite(cached) && cached > 0) usage.cacheReadTokens = cached;
+	if (Number.isFinite(cached)) usage.cacheReadTokens = cached;
+	if (Number.isFinite(cacheWrite) && cacheWrite > 0) usage.cacheWriteTokens = cacheWrite;
 	return usage;
 }
 /**
@@ -1428,27 +1432,31 @@ var CodexLiveDriver = class {
 		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 cumulative turn total the wire's `tokenUsage.total` names, for the settled report. */
+		let totalUsage;
 		/**
-		* 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.
+		* Per-call usage by transcript line: each `thread/tokenUsage/updated`
+		* notification closes one API call (its items have all completed), and
+		* the call's LAST line carries its `tokenUsage.last`. The map is
+		* authoritative per line, independent of the flush's withUsage flag.
 		*/
-		const reservedSteps = [];
+		const usageByLine = /* @__PURE__ */ new Map();
+		/** Whether a folded line already carries usage (per-call, or the round's fallback — no backfill event exists). */
+		let usageCarried = false;
 		/**
-		* 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.
+		* The streaming items seen this round by item id: deltas accumulate into
+		* throttled snapshots at the item's step once it may open in the log
+		* (previewed live before that) — the host folds repeated settles at one
+		* coordinate into one live-updating chat node. The item's completion
+		* folds at the same step and finalizes it; an entry whose completion
+		* never arrives is force-finalized at settle. A tool that completes
+		* mid-stream folds after the stream, keeping the round's chronology.
 		*/
 		const streams = /* @__PURE__ */ new Map();
+		/** Provisional stream keys (live flush and preview identity), never log steps. */
+		let streamKeys = 0;
+		/** Line indexes already written (a line may fold ahead of an earlier one it chronologically precedes). */
+		const folded = /* @__PURE__ */ new Set();
 		/** The item deltas currently accumulate into (items stream sequentially). */
 		let activeStream;
 		/** Items/completions that arrived before the turn id was known. */
@@ -1492,6 +1500,27 @@ var CodexLiveDriver = class {
 		*/
 		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);
+		let lastStep = 0;
+		let openStep;
+		const openStreamStep = (stream) => {
+			lastStep += 1;
+			childSession.append("step/start", {
+				turn,
+				step: lastStep
+			});
+			stream.durable = lastStep;
+			stream.opened = true;
+			openStep = lastStep;
+		};
+		const closeOpenStep = () => {
+			if (openStep === void 0) return;
+			childSession.append("step/end", {
+				turn,
+				step: openStep
+			});
+			openStep = void 0;
+		};
+		const canOpenStream = (stream) => openStep === void 0 && mirrored >= stream.after && streams.keys().next().value === stream.itemId;
 		const pendingStreamArrival = /* @__PURE__ */ new Map();
 		const appendStreamSnapshot = (stream, force, interrupted, withUsage = false, final = false) => {
 			if (stream.text.trim() === "") return;
@@ -1504,30 +1533,29 @@ var CodexLiveDriver = class {
 			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
+			if (!stream.opened) {
+				if (canOpenStream(stream)) openStreamStep(stream);
+				else if (!final) {
+					streamPublisher?.preview(stream.step, stream.kind, stream.text, {
+						itemId: stream.itemId,
+						receivedAt
 					});
-					stream.opened = true;
+					return;
+				} else {
+					closeOpenStep();
+					openStreamStep(stream);
 				}
-				streamPublisher.update(stream.step, stream.kind, stream.text, { receivedAt });
+			}
+			if (streamPublisher !== void 0 && !final) {
+				streamPublisher.update(stream.durable, 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;
+			const attachUsage = withUsage && !usageCarried && usageByLine.size === 0 && usage !== void 0;
 			childSession.append("assistant/message", {
 				turn,
-				step: stream.step,
+				step: stream.durable,
 				message: codexAssistantEvent([stream.kind === "think" ? {
 					type: "reasoning",
 					text: stream.text
@@ -1536,7 +1564,7 @@ var CodexLiveDriver = class {
 					text: stream.text
 				}]),
 				stream: [],
-				...withUsage && !usageCarried && usage !== void 0 ? { usage } : {},
+				...withUsage && !usageCarried && usageByLine.size === 0 && usage !== void 0 ? { usage } : {},
 				...interrupted ? { interrupted: true } : {}
 			}, { surfaceOp: "append" });
 			if (attachUsage) usageCarried = true;
@@ -1544,11 +1572,19 @@ var CodexLiveDriver = class {
 			stream.lastSnapshotLen = stream.text.length;
 			persist();
 		};
+		/** Close a stream's live presentation once its final text is in the log. */
+		const finishStream = (stream) => {
+			liveFlush.cancel(stream.step);
+			streams.delete(stream.itemId);
+			if (activeStream === stream.itemId) activeStream = void 0;
+			streamPublisher?.finish(stream.step);
+			if (stream.durable !== void 0) streamPublisher?.finish(stream.durable);
+		};
 		/**
-		* 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).
+		* Track one new streaming item: its provisional key (live flush and
+		* preview identity) and how many lines had completed when it began. A
+		* different item's deltas force one freshness snapshot of the current
+		* stream.
 		*/
 		const reserveStream = (itemId, kind) => {
 			if (activeStream !== void 0 && activeStream !== itemId) {
@@ -1558,12 +1594,12 @@ var CodexLiveDriver = class {
 			}
 			let stream = streams.get(itemId);
 			if (stream === void 0) {
-				const step = lines.length + reservedSteps.length + 1;
-				reservedSteps.push(step);
+				streamKeys += 1;
 				stream = {
 					itemId,
 					kind,
-					step,
+					step: streamKeys,
+					after: lines.length,
 					text: "",
 					lastSnapshotAt: 0,
 					lastSnapshotLen: 0,
@@ -1573,60 +1609,78 @@ var CodexLiveDriver = class {
 			}
 			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;
+		/** The stream a completed line finalizes, if it was streamed. */
+		const streamOfLine = (line) => line === void 0 || line.kind === "tool" ? void 0 : streams.get(line.itemId ?? "");
+		/** Write lines[index] at the next step(s). */
+		const foldLine = (index, lineUsage) => {
+			const line = lines[index];
+			const stream = streamOfLine(line);
+			if (stream !== void 0) {
+				if (!stream.opened) {
+					closeOpenStep();
+					openStreamStep(stream);
+				}
+				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.durable,
+					message: codexAssistantEvent(blocks),
+					stream: [],
+					...lineUsage === void 0 ? {} : { usage: lineUsage }
+				}, { surfaceOp: "append" });
+				finishStream(stream);
+				closeOpenStep();
+			} else {
+				closeOpenStep();
+				lastStep += 1;
+				appendCodexTranscriptLine(childSession, turn, lastStep, line, lineUsage);
+			}
+			folded.add(index);
+			localAgent?.reportRunProgress(childSession.id, {
+				kind: "delta",
+				text: codexLineText(line)
+			});
 		};
-		/** Mirror folded lines [mirrored, upto); the last line is held back until completion. */
+		/**
+		* Mirror the completed lines before `upto` in chronological order; the
+		* last line is held back until completion. A line waits behind every
+		* stream that began before it completed: that stream's line folds first,
+		* or — while it is still streaming — the mirror stops until it lands.
+		*/
 		const mirrorUpTo = (upto, withUsage) => {
 			let usageIndex = -1;
-			if (withUsage) {
+			if (withUsage && usageByLine.size === 0) {
 				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 usageFor = (index) => {
+				const own = usageByLine.get(index);
+				if (own !== void 0) {
+					usageCarried = true;
+					return own;
+				}
 				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)
-				});
+				return lineUsage;
+			};
+			outer: for (let index = mirrored; index < upto; index += 1) {
+				if (folded.has(index)) continue;
+				const own = streamOfLine(lines[index]);
+				const all = [...streams.values()];
+				const before = own === void 0 ? all.filter((stream) => stream.after <= index) : all.slice(0, all.indexOf(own));
+				for (const earlier of before) {
+					const at = lines.findIndex((line, position) => position > index && position < upto && !folded.has(position) && streamOfLine(line) === earlier);
+					if (at < 0) break outer;
+					foldLine(at, usageFor(at));
+				}
+				foldLine(index, usageFor(index));
 			}
+			while (folded.has(mirrored)) mirrored += 1;
 			if (upto > 0) persist();
 		};
 		let resolveCompletion;
@@ -1635,6 +1689,11 @@ var CodexLiveDriver = class {
 		});
 		const openTurn = () => {
 			childSession.append("turn/start", { turn });
+			if (spec.configuration?.model !== void 0) appendCodexRequestHeader(childSession, {
+				provider: "codex-local",
+				model: spec.configuration.model,
+				...spec.configuration.effort === void 0 ? {} : { reasoningEffort: spec.configuration.effort }
+			});
 			childSession.append("user/message", createUserMessage({
 				content: [{
 					type: "text",
@@ -1685,17 +1744,29 @@ var CodexLiveDriver = class {
 				return;
 			}
 			if (method === "thread/tokenUsage/updated") {
-				const last = params["tokenUsage"]?.["last"];
-				if (last !== void 0) usage = usageFromAppServer(last);
+				const tokenUsage = params["tokenUsage"];
+				const last = tokenUsage?.["last"];
+				const total = tokenUsage?.["total"];
+				if (total !== void 0 && (Number.isFinite(Number(total["inputTokens"])) || Number.isFinite(Number(total["outputTokens"])))) totalUsage = usageFromAppServer(total);
+				if (last !== void 0) {
+					usage = usageFromAppServer(last);
+					if (lines.length > 0) {
+						usageByLine.set(lines.length - 1, usage);
+						mirrorUpTo(lines.length - 1, true);
+					}
+				}
 				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"] }
-				});
+				try {
+					mirrorUpTo(lines.length, true);
+				} finally {
+					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. */
@@ -1795,15 +1866,19 @@ var CodexLiveDriver = class {
 			liveFlush.dispose();
 			if (turnOpened) {
 				if (mirrored < lines.length) mirrorUpTo(lines.length, true);
+				while (mirrored < lines.length && streams.size > 0) {
+					const oldest = streams.values().next().value;
+					appendStreamSnapshot(oldest, true, settled.stopReason !== "completed", false, true);
+					finishStream(oldest);
+					closeOpenStep();
+					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
-						});
+						finishStream(stream);
+						closeOpenStep();
 					}
 					streams.clear();
 					activeStream = void 0;
@@ -1854,7 +1929,7 @@ var CodexLiveDriver = class {
 						windowStart: startedAtMs,
 						cwd: spec.cwd
 					});
-					const settledUsage = usage ?? facts.usage;
+					const settledUsage = totalUsage ?? usage ?? facts.usage;
 					const round = {
 						...facts.model === void 0 ? {} : { observedModel: facts.model },
 						...facts.cliVersion === void 0 ? {} : { cliVersion: facts.cliVersion },
@@ -2046,23 +2121,6 @@ async function listCodexConfigModels(homeDir) {
 	}
 	return found;
 }
-//#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, "\\\"")}"`;
@@ -2086,7 +2144,7 @@ function registerCodexMemberRun(ctx, childSessionId, parentSessionId) {
 	});
 	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")}}`;
+	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")},tool_timeout_sec=1800}`;
 	let released = false;
 	return {
 		token,
@@ -2557,6 +2615,23 @@ function foldCodexStreamLine(state, raw) {
 				result: last.result === void 0 ? output : `${last.result}\n${output}`
 			};
 		}
+	} else if (item.type === "custom_tool_call") {
+		countToolCall(state, "custom_tool_call");
+		state.lines.push({
+			kind: "tool",
+			id: typeof item.id === "string" ? item.id : `codex-tool-${state.lines.length}`,
+			name: item.name ?? "custom",
+			...typeof item.input === "string" && item.input !== "" ? { args: item.input } : {}
+		});
+	} else if (item.type === "custom_tool_call_output") {
+		const output = typeof item.output === "string" ? item.output : Array.isArray(item.output) ? item.output.filter((block) => typeof block === "object" && block !== null && typeof block.text === "string").map((block) => block.text).join("\n") : 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}`
+			};
+		}
 	}
 }
 /**
@@ -2591,7 +2666,8 @@ var CodexStreamParser = class {
 * 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`
+* `web_search_call`, `custom_tool_call`/`custom_tool_call_output` (deferred
+* and dynamic tools), 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.
@@ -2683,6 +2759,11 @@ function startCodexCliRun(request, spec) {
 	});
 	const startedAtMs = Date.now();
 	spec.childSession?.append("turn/start", { turn });
+	if (spec.model !== void 0 && spec.childSession !== void 0) appendCodexRequestHeader(spec.childSession, {
+		provider: "codex-local",
+		model: spec.model,
+		...spec.effort === void 0 ? {} : { reasoningEffort: spec.effort }
+	});
 	const liveMirror = spec.childSession !== void 0 && spec.ctx !== void 0 ? createCodexLiveMirror(spec, task, turn) : void 0;
 	let output = "";
 	child.stdout?.on("data", (chunk) => {
@@ -2770,7 +2851,16 @@ function startCodexCliRun(request, spec) {
 		onAbort
 	}).then((settled) => {
 		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
+		return settled;
+	});
+	result.then(() => child.done).then(async () => {
+		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");
+		}
+		await mirrorCodexAfterExit(spec, task, turn, output, liveMirror, startedAtMs);
 		if (spec.childSession !== void 0) {
+			const settled = await result;
 			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
 				turn,
 				reason: { kind: "completed" }
@@ -2792,15 +2882,10 @@ function startCodexCliRun(request, spec) {
 					}
 				}
 			});
+			if (spec.ctx !== void 0) await persistChildSession(spec.ctx, spec.childSession).catch((error) => {
+				spec.ctx?.logger.warn(`subagent-codex: turn/end persistence failed: ${thrown(error).message}`);
+			});
 		}
-		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: SessionId(randomUUID()),
@@ -2811,6 +2896,22 @@ function startCodexCliRun(request, spec) {
 		teardown: disposeProcess
 	}));
 }
+/**
+* Write the round's request/header when the config differs from the child
+* log's last one (the host logs changed snapshots, not per-call duplicates):
+* the first write is `initial`, a differing one `change`, an identical one
+* skipped. Context Lens reads the child log's config from these headers.
+*/
+function appendCodexRequestHeader(childSession, config) {
+	const serialized = JSON.stringify(config);
+	let last;
+	for (const event of childSession.snapshotEvents()) if (event.type === "request/header") last = JSON.stringify(event.data.header?.config);
+	if (last === serialized) return;
+	childSession.append("request/header", {
+		header: { config },
+		reason: last === void 0 ? "initial" : "change"
+	});
+}
 /** One assistant-role message event, attributed to the codex route. */
 function codexAssistantEvent(blocks) {
 	return createAssistantMessage({
@@ -2827,8 +2928,17 @@ function codexAssistantEvent(blocks) {
 * 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.
+* drafts from the explicit coordinates, recovers it).
+*
+* A tool line folds the NATIVE lifecycle inside its one step: an assistant
+* message advertising the tool-call block, the `tool/call`, then its
+* `tool/result` — the released-log reader pairs call and result against the
+* advertisement and resolves every advertised call before the step closes.
+* Every fold sees a COMPLETED item (the exec live mirror holds the volatile
+* last line; the live driver folds at item/completed), so a result the
+* stream has not recorded by fold time will never arrive — the call folds
+* with the synthesized interrupted result instead of leaving the step
+* unresolvable.
 * @returns whether the line folded (false when the options skipped it).
 */
 function appendCodexTranscriptLine(childSession, turn, step, line, usage) {
@@ -2837,23 +2947,36 @@ function appendCodexTranscriptLine(childSession, turn, step, line, usage) {
 		step
 	});
 	if (line.kind === "tool") {
+		const args = line.args ?? "";
+		childSession.append("assistant/message", {
+			turn,
+			step,
+			message: codexAssistantEvent([{
+				type: "tool-call",
+				id: line.id,
+				name: line.name,
+				arguments: args
+			}]),
+			stream: [],
+			...usage === void 0 ? {} : { usage }
+		}, { surfaceOp: "append" });
 		const call = childSession.append("tool/call", {
 			turn,
 			step,
 			callId: line.id,
 			name: line.name,
-			arguments: line.args ?? ""
+			arguments: args
 		});
-		if (line.result !== void 0) childSession.append("tool/result", {
+		childSession.append("tool/result", {
 			turn,
 			step,
 			message: createToolResultMessage({
 				callId: line.id,
 				content: [{
 					type: "text",
-					text: line.result
+					text: line.result ?? "（工具调用被中断，未能记录返回结果）"
 				}],
-				isError: false
+				isError: line.result === void 0
 			})
 		}, {
 			surfaceOp: "append",
@@ -3224,6 +3347,47 @@ function dedupeChoices(layers) {
 	}
 	return choices;
 }
+/**
+* Scope the served directory to the surface asking for it (the same helper
+* lives in each provider's broker — fold into the family core when the
+* directory faces next evolve):
+*
+* - memberless (the card's add-model dialog, the invite picker): the
+*   endpoint's served catalog only — the configuration/history extras the
+*   broker's info extension adds for STATUS display must never become add
+*   candidates;
+* - a member whose harness has a curated list: the list IS the vocabulary,
+*   in the list's own order (the same rule `choices` already follows) — a
+*   curated value the endpoint no longer serves stays as a bare row (the
+*   card shows it the same way), and the member's current effective model is
+*   kept visible as a bare entry when it sits outside the list, so a pre-list
+*   binding never renders blank;
+* - a member without a curated list: the legacy extended vocabulary.
+*/
+function scopeServedDirectory(directory, opts) {
+	if (opts.member && opts.curated.length === 0) return directory;
+	const served = directory.entries.filter((entry) => entry.source === "native");
+	if (!opts.member) return {
+		...directory,
+		entries: served
+	};
+	const byValue = new Map(served.flatMap((entry) => entry.resolvedModel === void 0 ? [[entry.value, entry]] : [[entry.value, entry], [entry.resolvedModel, entry]]));
+	const entries = opts.curated.map((value) => byValue.get(value) ?? {
+		value,
+		label: value,
+		source: "configuration"
+	});
+	const current = opts.current?.trim();
+	if (current !== void 0 && current !== "" && !entries.some((entry) => entry.value === current || entry.resolvedModel === current)) entries.push({
+		value: current,
+		label: current,
+		source: "configuration"
+	});
+	return {
+		...directory,
+		entries
+	};
+}
 var CodexModelBroker = class {
 	deps;
 	constructor(deps) {
@@ -3275,14 +3439,19 @@ var CodexModelBroker = class {
 	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 ?? {
+		const info = await this.modelInfo(childSessionId, childSessionId === void 0 ? void 0 : this.deps.ctx.localAgent.getDelegation(childSessionId)?.model);
+		return scopeServedDirectory(info.directory ?? {
 			entries: [],
 			complete: false,
 			customInput: true,
 			status: "unsupported",
 			refreshing: false,
 			revision: 0
-		};
+		}, {
+			member: childSessionId !== void 0,
+			curated: this.deps.modelList?.(home) ?? [],
+			current: info.effective
+		});
 	}
 	async *followModelDirectory(childSessionId, signal) {
 		if (this.deps.followDirectory === void 0) {