@khorsheed/dsh-local-agent-claude-code 0.2.0-rc.3 → 0.2.1

package/lib/index.js

@@ -192,6 +192,20 @@ function servedEfforts(effort) {
 	return levels.length === 0 ? void 0 : levels;
 }
 /**
+* The effort block's home in a served-model entry. Anthropic's current
+* /v1/models shape nests it under `capabilities.effort` (verified against the
+* openproxy relay 2026-10-22: `capabilities.effort.<level>.supported`); the
+* flat top-level `effort` the parser was written against still wins when
+* present, so either shape answers.
+*/
+function servedEffortsOf(record) {
+	const direct = servedEfforts(record["effort"]);
+	if (direct !== void 0) return direct;
+	const capabilities = record["capabilities"];
+	if (typeof capabilities !== "object" || capabilities === null) return void 0;
+	return servedEfforts(capabilities["effort"]);
+}
+/**
 * `GET <baseUrl>/v1/models` with the resolved credential's auth header(s) —
 * the token-free endpoint probe shared by the `/claude-code check` verdict
 * and the model catalog. Anthropic's own API serves this route with
@@ -237,7 +251,7 @@ async function fetchEndpointModels(endpoint, fetchImpl, signal) {
 		if (typeof entry !== "object" || entry === null) continue;
 		const record = entry;
 		if (typeof record.id !== "string" || record.id === "") continue;
-		const efforts = servedEfforts(record.effort);
+		const efforts = servedEffortsOf(record);
 		models.push({
 			id: record.id,
 			...typeof record.display_name === "string" && record.display_name !== "" ? { displayName: record.display_name } : {},
@@ -528,8 +542,9 @@ var ClaudeControlRequests = class {
 * Fold: the resident stream speaks the exec path's exact event vocabulary
 * (`system`/`assistant`/`user`/`result`), so each turn folds through the
 * shared `ClaudeStreamParser` with the exec live mirror's hold-back rule (the
-* volatile last line waits for `result`, which carries the round's usage).
-* Every line folds 1:1. The always-enabled
+* volatile last line waits for `result`, which carries the round's usage, and
+* an unresulted tool line holds the fold until its result merges in place —
+* the native lifecycle folds as one closed step). Every line folds 1:1. The always-enabled
 * `--include-partial-messages` adds incremental output on top: each `stream_event` partial accumulates into its kind's
 * stream (native message id + block index, with ordered legacy fallback),
 * which reserves a (turn, step) at its first delta and
@@ -570,11 +585,6 @@ const DEFAULT_LIVE_CHANNEL_RETRY_MS = 3e5;
 const RECLAIM_EOF_GRACE_MS = 1e3;
 /** Default minimum interval between one streaming kind's snapshot messages. */
 const DEFAULT_SNAPSHOT_MIN_INTERVAL_MS = LIVE_FLUSH_INTERVAL_MS;
-/**
-* The stream-json channel could not come up (spawn failure or the first
-* turn's init never arrived). The provider catches exactly this and falls
-* back to the exec one-shot; any other error is a real round failure.
-*/
 var LiveChannelUnavailableError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -927,6 +937,7 @@ var ClaudeLiveDriver = class {
 			graceMs: DEFAULT_DISPOSE_GRACE_MS,
 			env: delegationEnv({
 				CLAUDE_CONFIG_DIR: spec.homeDir,
+				...member === void 0 ? {} : { MCP_TOOL_TIMEOUT: MEMBER_TOOL_TIMEOUT_MS },
 				...spec.configuration === void 0 ? {} : { CLAUDE_CODE_EFFORT_LEVEL: spec.configuration.effort ?? "auto" },
 				...endpointAuthEnv(endpoint)
 			})
@@ -1022,27 +1033,22 @@ var ClaudeLiveDriver = class {
 		*/
 		let roundModel;
 		let roundCliVersion;
-		/** Whether a folded line already carries the round's usage (no backfill event exists). */
+		/** Whether a folded line already carried usage (per-call inline, or the round's total as the fallback — no backfill event exists). */
 		let usageCarried = false;
 		/**
-		* The step ledger: `reservedSteps` holds every step a stream reservation
-		* consumed (in increasing order — permanently, whether the stream later
-		* completes or stays an orphan snapshot), and a sequential line folds at
-		* its index shifted past every reservation before it. A tool completed
-		* mid-stream therefore folds ABOVE the stream's step and the projection
-		* renders the round's chronological order.
-		*/
-		const reservedSteps = [];
-		/**
-		* The streaming kinds seen this round by stream key:
-		* deltas accumulate into throttled snapshot assistant/messages appended
-		* at the kind's reserved (turn, step) — the host folds repeated settles
-		* at one coordinate into one live-updating chat node, which is the only
-		* streaming channel left after 0.1.5 retired the durable per-chunk event.
-		* The kind's completed line folds at the same step and finalizes it; an
-		* entry whose completion never arrives is force-finalized at settle.
+		* The streaming blocks seen this round by stream key: deltas accumulate
+		* into throttled snapshots at the block'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 block's completed
+		* line 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 (chronological order).
 		*/
 		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 one it chronologically precedes). */
+		const folded = /* @__PURE__ */ new Set();
 		/** The stream deltas currently accumulate into (kinds stream sequentially). */
 		let activeStream;
 		let persistQueue = Promise.resolve();
@@ -1072,6 +1078,34 @@ var ClaudeLiveDriver = class {
 		};
 		let messageKey;
 		let legacyMessage = 0;
+		const callUsage = /* @__PURE__ */ new Map();
+		const openCalls = /* @__PURE__ */ new Set();
+		let currentCall;
+		const endCall = (usage) => {
+			if (currentCall === void 0) return;
+			if (typeof usage === "object" && usage !== null) {
+				const merged = { ...callUsage.get(currentCall) };
+				for (const [key, value] of Object.entries(usage)) if (value !== null && value !== void 0) merged[key] = value;
+				callUsage.set(currentCall, merged);
+			}
+			openCalls.delete(currentCall);
+		};
+		/**
+		* A line's usage when its call is known: `skip` on every line but the
+		* call's last, the call's final usage (or, without stream events, the
+		* line's own report) on the last; `null` for an id-less line.
+		*/
+		const callLineUsage = (index) => {
+			const id = parser.lines[index]?.messageId;
+			if (id === void 0) return null;
+			let last = -1;
+			parser.lines.forEach((line, position) => {
+				if (line.messageId === id) last = position;
+			});
+			if (index !== last) return { skip: true };
+			const raw = callUsage.get(id);
+			return { usage: raw !== void 0 ? usageFromClaude(raw) : parser.lines[index].usage };
+		};
 		const streamKey = (kind, index) => `${messageKey ?? `legacy-${turn}-${legacyMessage}`}:${typeof index === "number" ? index : kind}`;
 		/**
 		* Append one snapshot of a streaming kind at its reserved (turn, step).
@@ -1082,6 +1116,27 @@ var ClaudeLiveDriver = 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;
@@ -1094,30 +1149,30 @@ var ClaudeLiveDriver = 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 usage = parser.usage;
+			const totalFallback = withUsage && !usageCarried && usage !== void 0 && !parser.lines.some((line) => line.usage !== void 0);
 			childSession.append("assistant/message", {
 				turn,
-				step: stream.step,
+				step: stream.durable,
 				message: assistantEvent([stream.kind === "think" ? {
 					type: "reasoning",
 					text: stream.text
@@ -1126,19 +1181,26 @@ var ClaudeLiveDriver = class {
 					text: stream.text
 				}]),
 				stream: [],
-				...withUsage && !usageCarried && usage !== void 0 ? { usage } : {},
+				...totalFallback ? { usage } : {},
 				...interrupted ? { interrupted: true } : {}
 			}, { surfaceOp: "append" });
-			if (withUsage && !usageCarried && usage !== void 0) usageCarried = true;
+			if (totalFallback) usageCarried = true;
 			stream.lastSnapshotAt = now;
 			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 streaming kind will occupy — past every completed
-		* line (folded or held back) and every earlier reservation. A different
-		* kind's deltas force one final snapshot of the current stream (its
-		* completion still folds at its own reserved step when it lands).
+		* Track one new streaming block: its provisional key and how many lines
+		* had completed when it began. A different block's deltas force one
+		* freshness snapshot of the current stream.
 		*/
 		const reserveStream = (itemId, kind) => {
 			if (activeStream !== void 0 && activeStream !== itemId) {
@@ -1148,12 +1210,12 @@ var ClaudeLiveDriver = class {
 			}
 			let stream = streams.get(itemId);
 			if (stream === void 0) {
-				const step = parser.lines.length + reservedSteps.length + 1;
-				reservedSteps.push(step);
+				streamKeys += 1;
 				stream = {
 					itemId,
 					kind,
-					step,
+					step: streamKeys,
+					after: parser.lines.length,
 					text: "",
 					lastSnapshotAt: 0,
 					lastSnapshotLen: 0,
@@ -1163,60 +1225,90 @@ var ClaudeLiveDriver = class {
 			}
 			activeStream = itemId;
 		};
-		/** The sequential fold step for `parser.lines[index]`: its position shifted past every reservation before it. */
-		const foldStep = (index) => {
-			let step = index + 1;
-			for (const reserved of reservedSteps) if (reserved <= step) step += 1;
-			else break;
-			return step;
+		/** The stream a completed line finalizes, if it was streamed. */
+		const streamOfLine = (line) => line === void 0 || line.kind === "tool" ? void 0 : (line.streamId === void 0 ? void 0 : streams.get(line.streamId)) ?? [...streams.values()].find((candidate) => candidate.kind === line.kind && (line.streamId === void 0 || candidate.itemId.startsWith("legacy-")));
+		/** Write parser.lines[index] at the next step(s). */
+		const foldLine = (index, lineUsage) => {
+			const line = parser.lines[index];
+			const perCall = callLineUsage(index);
+			const effectiveUsage = perCall === null ? line.usage ?? lineUsage : "skip" in perCall ? void 0 : perCall.usage ?? lineUsage;
+			if (effectiveUsage !== void 0) usageCarried = true;
+			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: assistantEvent(blocks),
+					stream: [],
+					...effectiveUsage === void 0 ? {} : { usage: effectiveUsage }
+				}, { surfaceOp: "append" });
+				finishStream(stream);
+				closeOpenStep();
+			} else {
+				closeOpenStep();
+				lastStep += 1;
+				const { usage: _snapshot, ...bare } = line;
+				appendClaudeTranscriptLine(childSession, turn, lastStep, bare, effectiveUsage);
+			}
+			folded.add(index);
+			localAgent?.reportRunProgress(childSession.id, {
+				kind: "delta",
+				text: claudeLineText(line)
+			});
 		};
-		/** Mirror folded lines [mirrored, upto); the last line is held back until `result`. */
-		const mirrorUpTo = (upto, withUsage) => {
+		/**
+		* Mirror the completed lines before `upto` in chronological order; the
+		* last line is held back until `result`. A line waits behind every stream
+		* that began before it completed (that stream's line folds first, or the
+		* mirror stops while it still streams). A tool line whose result the
+		* stream has not recorded yet HOLDS the fold mid-round: the fold writes
+		* the native lifecycle as one closed step (the released-log reader
+		* resolves every advertised call before step/end), and the result merges
+		* into the call's line in place, so a later pass retries from here. The
+		* settle flushes (`settle: true` — the turn's result event, or the final
+		* flush after a cancel/failure) never hold: a result that will never
+		* arrive folds as the interrupted placeholder.
+		*/
+		const mirrorUpTo = (upto, withUsage, settle = false) => {
 			let usageIndex = -1;
-			if (withUsage) {
+			if (withUsage && !parser.lines.some((line) => line.usage !== void 0)) {
 				for (let index = 0; index < parser.lines.length; index += 1) if (parser.lines[index]?.kind !== "tool") usageIndex = index;
 			}
-			for (let index = mirrored; index < upto; index += 1) {
-				const line = parser.lines[index];
-				if (line === void 0) continue;
+			const usageFor = (index) => {
 				const lineUsage = withUsage && index === usageIndex ? parser.usage : void 0;
 				if (lineUsage !== void 0) usageCarried = true;
-				const stream = line.kind === "tool" ? void 0 : (line.streamId === void 0 ? void 0 : streams.get(line.streamId)) ?? [...streams.values()].find((candidate) => candidate.kind === line.kind && (line.streamId === void 0 || candidate.itemId.startsWith("legacy-")));
-				const itemId = stream?.itemId;
-				if (itemId !== void 0 && stream !== void 0) {
-					liveFlush.cancel(stream.step);
-					streams.delete(itemId);
-					if (activeStream === itemId) activeStream = void 0;
-					if (!stream.opened) childSession.append("step/start", {
-						turn,
-						step: stream.step
-					});
-					const blocks = stream.kind === "think" ? [{
-						type: "reasoning",
-						text: line.kind === "tool" ? "" : line.text
-					}] : [{
-						type: "text",
-						text: line.kind === "tool" ? "" : line.text
-					}];
-					childSession.append("assistant/message", {
-						turn,
-						step: stream.step,
-						message: assistantEvent(blocks),
-						stream: [],
-						...lineUsage === void 0 ? {} : { usage: lineUsage }
-					}, { surfaceOp: "append" });
-					streamPublisher?.finish(stream.step);
-					childSession.append("step/end", {
-						turn,
-						step: stream.step
-					});
-				} else appendClaudeTranscriptLine(childSession, turn, foldStep(index), line, lineUsage);
-				mirrored = index + 1;
-				localAgent?.reportRunProgress(childSession.id, {
-					kind: "delta",
-					text: claudeLineText(line)
-				});
+				return lineUsage;
+			};
+			outer: for (let index = mirrored; index < upto; index += 1) {
+				if (folded.has(index)) continue;
+				const line = parser.lines[index];
+				if (line === void 0) continue;
+				if (!settle && line.kind === "tool" && line.result === void 0) break;
+				if (!settle && line.messageId !== void 0 && openCalls.has(line.messageId)) break;
+				const own = streamOfLine(line);
+				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 = parser.lines.findIndex((candidate, position) => position > index && position < upto && !folded.has(position) && streamOfLine(candidate) === earlier);
+					if (at < 0) break outer;
+					const atCall = parser.lines[at]?.messageId;
+					if (!settle && atCall !== void 0 && openCalls.has(atCall)) break outer;
+					foldLine(at, usageFor(at));
+				}
+				foldLine(index, usageFor(index));
 			}
+			while (folded.has(mirrored)) mirrored += 1;
 			if (upto > 0) persist();
 		};
 		let resolveResult;
@@ -1232,6 +1324,13 @@ var ClaudeLiveDriver = class {
 		/** The round's event sink (installed on the runtime while it runs). */
 		const onEvent = (event) => {
 			const type = event["type"];
+			if (roundSettled) {
+				if (type === "result") {
+					awaitingResult = false;
+					resolveResult(event);
+				}
+				return;
+			}
 			if (type === "system" && typeof event["session_id"] === "string") {
 				if (runtime !== void 0 && runtime.sessionId === void 0) {
 					runtime.sessionId = event["session_id"];
@@ -1244,7 +1343,7 @@ var ClaudeLiveDriver = class {
 			if (type === "result") {
 				awaitingResult = false;
 				parser.push(JSON.stringify(event) + "\n");
-				mirrorUpTo(parser.lines.length, true);
+				mirrorUpTo(parser.lines.length, true, true);
 				resolveResult(event);
 				return;
 			}
@@ -1253,6 +1352,17 @@ var ClaudeLiveDriver = class {
 				if (inner?.["type"] === "message_start") {
 					const message = inner["message"];
 					messageKey = typeof message?.["id"] === "string" ? message["id"] : `legacy-${turn}-${++legacyMessage}`;
+					currentCall = typeof message?.["id"] === "string" ? message["id"] : void 0;
+					if (currentCall !== void 0) {
+						openCalls.add(currentCall);
+						const usage = message?.["usage"];
+						if (typeof usage === "object" && usage !== null) callUsage.set(currentCall, { ...usage });
+					}
+					return;
+				}
+				if (inner?.["type"] === "message_delta" || inner?.["type"] === "message_stop") {
+					endCall(inner["usage"]);
+					mirrorUpTo(parser.lines.length - 1, false);
 					return;
 				}
 				const delta = inner?.["delta"];
@@ -1328,6 +1438,11 @@ var ClaudeLiveDriver = class {
 				throw new Error("subagent-claude: run cancelled locally");
 			}
 			childSession.append("turn/start", { turn });
+			if (spec.configuration?.model !== void 0) appendClaudeRequestHeader(childSession, {
+				provider: "claude-local",
+				model: spec.configuration.model,
+				reasoningEffort: spec.configuration.effort ?? "auto"
+			});
 			childSession.append("user/message", createUserMessage({
 				content: [{
 					type: "text",
@@ -1379,16 +1494,20 @@ var ClaudeLiveDriver = class {
 			liveFlush.dispose();
 			turnInFlight = false;
 			if (turnOpened) {
-				if (mirrored < parser.lines.length) mirrorUpTo(parser.lines.length, true);
+				if (mirrored < parser.lines.length) mirrorUpTo(parser.lines.length, true, true);
+				while (mirrored < parser.lines.length && streams.size > 0) {
+					const oldest = streams.values().next().value;
+					appendStreamSnapshot(oldest, true, settled.stopReason !== "completed", false, true);
+					finishStream(oldest);
+					closeOpenStep();
+					mirrorUpTo(parser.lines.length, true, 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;
@@ -1460,24 +1579,6 @@ var ClaudeLiveDriver = class {
 		});
 	}
 };
-//#endregion
-//#region lib/types/claude-cli-provider.js
-/**
-* One-shot Claude Code CLI subagent lifecycle: spawn `claude -p "<task>"`
-* through the subprocess seam under the harness's scoped home, capture its
-* JSON result as the run output, and dispose to whole-tree quiescence.
-* Mirrors the kimi/codex providers: every accepted run is a fresh process
-* and a fresh claude session; there is no continuation across runs.
-*
-* The provider name `claude-local` avoids colliding with the official
-* `subagent-claude-code` package's provider name `claude-code` — a
-* composition that mounts both would fail loud with DUPLICATE_PROVIDER. The
-* tool row in this bundle's patch takes the official model-facing name
-* `subagent_claude_code` instead: the official preset row ships disabled,
-* and the patch disables it too (a deliberate user re-enable conflicts
-* loud, by design).
-* @module @khorsheed/dsh-local-agent-claude-code/claude-cli-provider
-*/
 /** Default POSIX grace between subprocess termination tiers. */
 const DEFAULT_DISPOSE_GRACE_MS = 3e3;
 /**
@@ -1489,6 +1590,11 @@ const DEFAULT_DISPOSE_GRACE_MS = 3e3;
 * provider-controlled error strings only.
 */
 const CLAUDE_AUTH_FAILURE = /failed to authenticate|authentication_failed|oauth access token|invalid (x-api-key|api key|authentication token)|api error: 40[13]/i;
+/**
+* The MCP tool-call bound for a member's claude process (`MCP_TOOL_TIMEOUT`,
+* ms): a bridge call may wait up to 30 minutes for the human's answer.
+*/
+const MEMBER_TOOL_TIMEOUT_MS = String(18e5);
 /** Register one member run with the channel; see {@link ClaudeMemberRunHandle}. */
 function registerClaudeMemberRun(ctx, childSessionId, parentSessionId) {
 	const registry = ctx.localAgent;
@@ -1707,6 +1813,7 @@ var ClaudeCliProvider = class {
 				cwd,
 				env: delegationEnv({
 					CLAUDE_CONFIG_DIR: homeDir,
+					...member === void 0 ? {} : { MCP_TOOL_TIMEOUT: MEMBER_TOOL_TIMEOUT_MS },
 					...endpointAuthEnv(endpoint)
 				}),
 				...exec === void 0 ? {} : { exec },
@@ -1796,6 +1903,7 @@ var ClaudeCliProvider = class {
 					cwd,
 					env: delegationEnv({
 						CLAUDE_CONFIG_DIR: homeDir,
+						...member === void 0 ? {} : { MCP_TOOL_TIMEOUT: MEMBER_TOOL_TIMEOUT_MS },
 						...endpointAuthEnv(endpoint)
 					}),
 					...exec === void 0 ? {} : { exec },
@@ -1866,6 +1974,17 @@ function textTask(prompt) {
 	if (texts.every((text) => text.trim().length === 0)) throw new Error("subagent-claude: the one-shot task must not be empty");
 	return texts.join("\n");
 }
+/** Group the lines of one API call (consecutive lines sharing a message id).
+* Lines without an id stay singleton units (the pre-grouping shape). */
+function groupClaudeTranscriptLines(lines) {
+	const groups = [];
+	for (const line of lines) {
+		const last = groups[groups.length - 1];
+		if (line.messageId !== void 0 && last !== void 0 && last[0]?.messageId === line.messageId) last.push(line);
+		else groups.push([line]);
+	}
+	return groups;
+}
 /**
 * 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
@@ -1978,11 +2097,17 @@ function foldClaudeStreamLine(state, raw) {
 	}
 	if (event.type !== "assistant" && event.type !== "user") return;
 	const blocks = event.message?.content ?? [];
+	const linesBefore = state.lines.length;
+	const messageId = event.type === "assistant" && typeof event.message?.id === "string" ? event.message.id : void 0;
 	for (const [blockIndex, block] of blocks.entries()) {
 		if (typeof block !== "object" || block === null) continue;
 		const record = block;
-		const identity = event.type === "assistant" && typeof event.message?.id === "string" ? { streamId: `${event.message.id}:${blockIndex}` } : {};
+		const identity = messageId !== void 0 ? {
+			streamId: `${messageId}:${blockIndex}`,
+			messageId
+		} : {};
 		const kind = record["type"];
+		if (kind === "text" && event.type === "user") continue;
 		if (kind === "text" && typeof record["text"] === "string" && record["text"].trim() !== "") {
 			state.lines.push({
 				kind: "text",
@@ -2019,6 +2144,7 @@ function foldClaudeStreamLine(state, raw) {
 				id: id ?? `claude-tool-${state.lines.length}`,
 				name: "ApplyPatch",
 				args: edit.args,
+				...messageId === void 0 ? {} : { messageId },
 				...edit.patch === void 0 ? {} : { result: edit.patch }
 			});
 			else {
@@ -2027,6 +2153,7 @@ function foldClaudeStreamLine(state, raw) {
 					kind: "tool",
 					id: id ?? `claude-tool-${state.lines.length}`,
 					name: kind === "server_tool_use" ? SERVER_TOOL_CARD_NAMES[name] ?? name : name,
+					...messageId === void 0 ? {} : { messageId },
 					...detail === void 0 ? {} : { args: detail }
 				});
 			}
@@ -2038,6 +2165,22 @@ function foldClaudeStreamLine(state, raw) {
 			if (resultText !== void 0 && resultText.trim() !== "") attachToolResult(state, record["tool_use_id"], resultText, false);
 		}
 	}
+	if (event.type === "assistant" && event.message?.usage !== void 0 && state.lines.length > linesBefore) {
+		const lastIndex = state.lines.length - 1;
+		const last = state.lines[lastIndex];
+		if (messageId !== void 0) {
+			const previous = state.usageStamped.get(messageId);
+			if (previous !== void 0 && previous !== lastIndex) {
+				const { usage: _cleared, ...rest } = state.lines[previous];
+				state.lines[previous] = rest;
+			}
+		}
+		state.lines[lastIndex] = {
+			...last,
+			usage: usageFromClaude(event.message.usage)
+		};
+		if (messageId !== void 0) state.usageStamped.set(messageId, lastIndex);
+	}
 }
 /**
 * Merge a tool result into its call line: pair by tool_use_id when the stream
@@ -2077,6 +2220,7 @@ var ClaudeStreamParser = class {
 	buffer = "";
 	lines = [];
 	callsById = /* @__PURE__ */ new Map();
+	usageStamped = /* @__PURE__ */ new Map();
 	text;
 	usage;
 	sessionId;
@@ -2113,6 +2257,7 @@ function parseClaudeStreamJson(output) {
 	const state = {
 		lines: [],
 		callsById: /* @__PURE__ */ new Map(),
+		usageStamped: /* @__PURE__ */ new Map(),
 		toolCalls: /* @__PURE__ */ new Map(),
 		text: void 0,
 		usage: void 0,
@@ -2259,16 +2404,30 @@ function serverToolResultText(record) {
 		return [url, body === void 0 ? void 0 : body.length <= WEB_FETCH_TEXT_LIMIT ? body : `${body.slice(0, WEB_FETCH_TEXT_LIMIT)}\n…`].filter((part) => part !== void 0 && part !== "").join("\n") || void 0;
 	}
 }
-/** Flatten a tool_result content payload (string or block array) to text. */
+/**
+* Flatten a tool_result content payload (string or block array) to text.
+* Beyond `text` blocks, ToolSearch answers with `tool_reference` blocks — one
+* per discovered tool — which list as the found tool names; dropping them
+* stranded the call (no result recorded) and it settled as a phantom
+* interrupted failure.
+*/
 function toolResultText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return void 0;
-	return content.filter((block) => typeof block === "object" && block !== null && block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join("\n");
+	return content.map((block) => {
+		if (typeof block !== "object" || block === null) return void 0;
+		const record = block;
+		if (record.type === "text" && typeof record.text === "string") return record.text;
+		if (record.type === "tool_reference" && typeof record.tool_name === "string") return record.tool_name;
+	}).filter((text) => text !== void 0).join("\n");
 }
 /**
 * Map claude's usage payload onto the shared usage contract. Claude's
 * `input_tokens` is the uncached input; cache reads and cache creation are
 * reported separately, so each maps to its own bucket with no subtraction.
+* When the payload carries ANY cache field, `cacheReadTokens` is always
+* written (0 when the read counter is absent or zero) — a reader can then
+* tell "no hits" from "not reported".
 * @param usage - the raw claude usage object.
 * @returns the shared usage record.
 */
@@ -2290,7 +2449,7 @@ function usageFromClaude(usage) {
 		inputTokens: input ?? 0,
 		outputTokens: output ?? 0
 	};
-	if (cacheRead !== void 0 && cacheRead > 0) usageRecord.cacheReadTokens = cacheRead;
+	if (cacheRead !== void 0 || cacheWrite !== void 0) usageRecord.cacheReadTokens = cacheRead ?? 0;
 	if (cacheWrite !== void 0 && cacheWrite > 0) usageRecord.cacheWriteTokens = cacheWrite;
 	return usageRecord;
 }
@@ -2449,41 +2608,47 @@ async function startClaudeCliRun(request, spec) {
 		onAbort
 	}).then((settled) => {
 		if (settled.stopReason === "completed") spec.onAuthSuccess?.();
-		if (spec.childSession !== void 0) {
-			if (settled.stopReason === "completed") spec.childSession.append("turn/end", {
+		return settled;
+	});
+	result.then(() => child.done).then(async () => {
+		const drainedStdout = child.collected.stdout?.readFrom(0).text || output;
+		if (spec.onAuthFailure !== void 0) {
+			const drainedStderr = child.collected.stderr?.readFrom(0).text || stderr;
+			const authDetail = `${parseClaudeStreamJson(drainedStdout).error ?? ""}\n${drainedStderr}`;
+			if (CLAUDE_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
+		}
+		await mirrorClaudeAfterExit(spec, task, turn, drainedStdout, liveMirror);
+		const closeTurn = async () => {
+			if (spec.childSession === void 0) return;
+			const childSession = spec.childSession;
+			const settled = await result;
+			if (settled.stopReason === "completed") childSession.append("turn/end", {
 				turn,
 				reason: { kind: "completed" }
 			});
-			else if (settled.stopReason === "aborted") spec.childSession.append("turn/end", {
+			else if (settled.stopReason === "aborted") childSession.append("turn/end", {
 				turn,
 				reason: {
 					kind: "aborted",
 					reason: { kind: "parent" }
 				}
 			});
-			else {
-				const parsed = parseClaudeStreamJson(output);
-				spec.childSession.append("turn/end", {
-					turn,
-					reason: {
-						kind: "error",
-						error: {
-							message: parsed.error ?? `claude -p exited with code ${String(exitCode)}`,
-							code: "UNKNOWN"
-						}
+			else childSession.append("turn/end", {
+				turn,
+				reason: {
+					kind: "error",
+					error: {
+						message: parseClaudeStreamJson(drainedStdout).error ?? `claude -p exited with code ${String(exitCode)}`,
+						code: "UNKNOWN"
 					}
-				});
-			}
-		}
-		return settled;
-	});
-	result.then(() => child.done).then(() => {
-		if (spec.onAuthFailure !== void 0) {
-			const drainedStderr = child.collected.stderr?.readFrom(0).text || stderr;
-			const authDetail = `${parseClaudeStreamJson(child.collected.stdout?.readFrom(0).text || output).error ?? ""}\n${drainedStderr}`;
-			if (CLAUDE_AUTH_FAILURE.test(authDetail)) spec.onAuthFailure(authDetail.split("\n").find((line) => line.trim() !== "") ?? "auth failure");
-		}
-		return mirrorClaudeAfterExit(spec, task, turn, output, liveMirror);
+				}
+			});
+			if (spec.ctx !== void 0) await persistChildSession(spec.ctx, childSession).catch((error) => {
+				spec.ctx?.logger.warn(`subagent-claude: turn/end persistence failed: ${thrown(error).message}`);
+			});
+		};
+		if (liveMirror === void 0) await closeTurn();
+		else await liveMirror.enqueue(closeTurn);
 	}, () => {});
 	return Promise.resolve(subprocessRunHandle({
 		id: SessionId(randomUUID()),
@@ -2495,6 +2660,22 @@ async function startClaudeCliRun(request, spec) {
 	}));
 }
 /** One assistant-role message event, attributed to the claude route. */
+/**
+* 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 appendClaudeRequestHeader(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"
+	});
+}
 function assistantEvent(blocks) {
 	return createAssistantMessage({
 		content: blocks,
@@ -2512,30 +2693,53 @@ function assistantEvent(blocks) {
 * 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.
+*
+* A tool line folds the native lifecycle inside its one step: an assistant
+* message advertising the tool-call block, the `tool/call`, and its
+* `tool/result` — the released-log reader pairs call and result against the
+* advertisement and resolves every advertised call before the step closes, so
+* a line whose result the stream has not recorded yet must NOT reach this
+* fold mid-round (the callers hold there; the result merges into the call's
+* line in place, so a later pass sees it). A line still unresulted at settle
+* folds with the interrupted placeholder ({@link CLAUDE_INTERRUPTED_TOOL_RESULT}).
 */
 function appendClaudeTranscriptLine(childSession, turn, step, line, usage) {
+	const lineUsage = line.usage ?? usage;
 	childSession.append("step/start", {
 		turn,
 		step
 	});
 	if (line.kind === "tool") {
+		const args = line.args ?? "";
+		childSession.append("assistant/message", {
+			turn,
+			step,
+			message: assistantEvent([{
+				type: "tool-call",
+				id: line.id,
+				name: line.name,
+				arguments: args
+			}]),
+			stream: [],
+			...lineUsage === void 0 ? {} : { usage: lineUsage }
+		}, { 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",
@@ -2559,24 +2763,82 @@ function appendClaudeTranscriptLine(childSession, turn, step, line, usage) {
 		step,
 		message: assistantEvent(blocks),
 		stream: [],
-		...usage === void 0 ? {} : { usage }
+		...lineUsage === void 0 ? {} : { usage: lineUsage }
 	}, { surfaceOp: "append" });
 	childSession.append("step/end", {
 		turn,
 		step
 	});
 }
-/**
-* Fold one transcript line into the run's child session as one assistant step.
-*/
-function appendClaudeLine(spec, turn, step, line, usage) {
-	if (spec.childSession === void 0) return;
-	appendClaudeTranscriptLine(spec.childSession, turn, step, line, usage);
-}
 /** The delta-progress text for one transcript line. */
 function claudeLineText(line) {
 	return line.kind === "tool" ? `[工具 ${line.name}]${line.args !== void 0 ? ` ${line.args}` : ""}${line.result !== void 0 ? ` → ${line.result}` : ""}` : line.text;
 }
+/**
+* Fold one API call (a message-id group) into the child session as ONE
+* assistant step: a single assistant/message carrying the call's reasoning,
+* text and tool-call blocks (the host's own mixed-content shape), then each
+* call's native lifecycle, then step/end. The call's usage rides the message
+* once — the group's own per-call stamp wins over the round-total fallback.
+*/
+function appendClaudeTranscriptGroup(childSession, turn, step, group, usage) {
+	const lineUsage = group.map((line) => line.usage).find((value) => value !== void 0) ?? usage;
+	const blocks = [];
+	for (const line of group) if (line.kind === "think") blocks.push({
+		type: "reasoning",
+		text: line.text
+	});
+	else if (line.kind === "text") blocks.push({
+		type: "text",
+		text: line.text
+	});
+	else blocks.push({
+		type: "tool-call",
+		id: line.id,
+		name: line.name,
+		arguments: line.args ?? ""
+	});
+	childSession.append("step/start", {
+		turn,
+		step
+	});
+	childSession.append("assistant/message", {
+		turn,
+		step,
+		message: assistantEvent(blocks),
+		stream: [],
+		...lineUsage === void 0 ? {} : { usage: lineUsage }
+	}, { surfaceOp: "append" });
+	for (const line of group) {
+		if (line.kind !== "tool") continue;
+		const call = childSession.append("tool/call", {
+			turn,
+			step,
+			callId: line.id,
+			name: line.name,
+			arguments: line.args ?? ""
+		});
+		childSession.append("tool/result", {
+			turn,
+			step,
+			message: createToolResultMessage({
+				callId: line.id,
+				content: [{
+					type: "text",
+					text: line.result ?? "（工具调用被中断，未能记录返回结果）"
+				}],
+				isError: line.result === void 0
+			})
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: [call.seq]
+		});
+	}
+	childSession.append("step/end", {
+		turn,
+		step
+	});
+}
 /** Create the per-run live mirror over the incremental parser. */
 function createClaudeLiveMirror(spec, task, turn) {
 	const parser = new ClaudeStreamParser();
@@ -2584,6 +2846,7 @@ function createClaudeLiveMirror(spec, task, turn) {
 	const ctx = spec.ctx;
 	let mirrored = 0;
 	let userMirrored = false;
+	let headerWritten = false;
 	let lastTodos;
 	let todoSkewWarned = false;
 	let queue = Promise.resolve();
@@ -2595,7 +2858,7 @@ function createClaudeLiveMirror(spec, task, turn) {
 			return userMirrored;
 		},
 		enqueue(task) {
-			queue = queue.then(task);
+			queue = queue.catch(() => {}).then(task);
 			return queue;
 		},
 		push(chunk) {
@@ -2608,8 +2871,22 @@ function createClaudeLiveMirror(spec, task, turn) {
 				todoSkewWarned = true;
 				ctx.logger.warn("subagent-claude: a TodoWrite call missed the documented input shape; folded as a plain tool line");
 			}
-			const upto = parser.completed ? parser.lines.length : parser.lines.length - 1;
-			if (upto <= mirrored) return;
+			const groups = groupClaudeTranscriptLines(parser.lines);
+			const groupStarts = [];
+			let totalLines = 0;
+			for (const group of groups) {
+				groupStarts.push(totalLines);
+				totalLines += group.length;
+			}
+			let uptoGroups = parser.completed ? groups.length : groups.length - 1;
+			if (!parser.completed) for (let scan = 0; scan < uptoGroups; scan += 1) {
+				if (groupStarts[scan] < mirrored) continue;
+				if (groups[scan].some((line) => line.kind === "tool" && line.result === void 0)) {
+					uptoGroups = scan;
+					break;
+				}
+			}
+			if ((groupStarts[uptoGroups] ?? totalLines) <= mirrored && userMirrored) return;
 			mirror.enqueue(async () => {
 				try {
 					const localAgent = ctx.get("localAgent");
@@ -2627,17 +2904,27 @@ function createClaudeLiveMirror(spec, task, turn) {
 							text: task
 						});
 					}
+					if (!headerWritten) {
+						const observedModel = parser.model ?? spec.model;
+						if (observedModel !== void 0) {
+							headerWritten = true;
+							appendClaudeRequestHeader(childSession, {
+								provider: "claude-local",
+								model: observedModel,
+								...spec.controlled ? { reasoningEffort: spec.effort ?? "auto" } : {}
+							});
+						}
+					}
 					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;
+					if (parser.completed && parser.usage !== void 0 && !parser.lines.some((line) => line.usage !== void 0)) {
+						for (let scan = 0; scan < groups.length; scan += 1) if (groups[scan].some((line) => line.kind !== "tool")) carrier = scan;
 					}
-					for (let index = mirrored; index < upto; index += 1) {
-						const line = parser.lines[index];
-						if (line === void 0) continue;
-						const usage = index === carrier ? parser.usage : void 0;
-						appendClaudeLine(spec, turn, index + 1, line, usage);
-						mirrored = index + 1;
-						localAgent?.reportRunProgress(childSession.id, {
+					for (let scan = 0; scan < uptoGroups; scan += 1) {
+						if (groupStarts[scan] < mirrored) continue;
+						const group = groups[scan];
+						appendClaudeTranscriptGroup(childSession, turn, scan + 1, group, scan === carrier ? parser.usage : void 0);
+						mirrored = groupStarts[scan] + group.length;
+						for (const line of group) localAgent?.reportRunProgress(childSession.id, {
 							kind: "delta",
 							text: claudeLineText(line)
 						});
@@ -2687,18 +2974,28 @@ async function appendClaudeResponse(spec, task, turn, parsed, fromLines = 0, use
 			text: task
 		});
 	}
-	let usageIndex = -1;
-	for (let index = 0; index < parsed.lines.length; index += 1) if (parsed.lines[index]?.kind !== "tool") usageIndex = index;
-	let step = fromLines + 1;
-	for (const line of parsed.lines.slice(fromLines)) {
-		appendClaudeLine(spec, turn, step, line, step - 1 === usageIndex ? parsed.usage : void 0);
-		localAgent?.reportRunProgress(childSession.id, {
+	const groups = groupClaudeTranscriptLines(parsed.lines);
+	const groupStarts = [];
+	let totalLines = 0;
+	for (const group of groups) {
+		groupStarts.push(totalLines);
+		totalLines += group.length;
+	}
+	let carrier = -1;
+	if (!parsed.lines.some((line) => line.usage !== void 0)) {
+		for (let scan = 0; scan < groups.length; scan += 1) if (groups[scan].some((line) => line.kind !== "tool")) carrier = scan;
+	}
+	for (let scan = 0; scan < groups.length; scan += 1) {
+		if (groupStarts[scan] < fromLines) continue;
+		const group = groups[scan];
+		appendClaudeTranscriptGroup(childSession, turn, scan + 1, group, scan === carrier ? parsed.usage : void 0);
+		for (const line of group) localAgent?.reportRunProgress(childSession.id, {
 			kind: "delta",
 			text: claudeLineText(line)
 		});
-		step += 1;
 	}
-	if (parsed.usage !== void 0 && usageIndex !== -1 && usageIndex < fromLines) spec.ctx.logger.warn(`subagent-claude: round ${turn} usage arrived after its carrier line was mirrored; the accounting is dropped`);
+	const carrierLine = carrier === -1 ? -1 : groupStarts[carrier] ?? -1;
+	if (parsed.usage !== void 0 && carrierLine !== -1 && carrierLine < fromLines) spec.ctx.logger.warn(`subagent-claude: round ${turn} usage arrived after its carrier line was mirrored; the accounting is dropped`);
 	await persistChildSession(spec.ctx, childSession);
 	localAgent?.reportRunProgress(childSession.id, {
 		kind: "mirror",
@@ -3051,6 +3348,47 @@ var ClaudeScopedModelMemory = class {
 		this.written = model;
 	}
 };
+/**
+* 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 ClaudeModelBroker = class {
 	deps;
 	constructor(deps) {
@@ -3101,14 +3439,20 @@ var ClaudeModelBroker = class {
 	}
 	async modelDirectory(childSessionId, refresh = false) {
 		if (refresh) await this.deps.directory?.(childSessionId, true);
-		return (await this.modelInfo(childSessionId, childSessionId === void 0 ? void 0 : this.deps.localAgent.getDelegation(childSessionId)?.model)).directory ?? {
+		const record = childSessionId === void 0 ? void 0 : this.deps.localAgent.getDelegation(childSessionId);
+		const info = await this.modelInfo(childSessionId, record?.model);
+		return scopeServedDirectory(info.directory ?? {
 			entries: [],
 			complete: false,
 			customInput: true,
 			status: "unsupported",
 			refreshing: false,
 			revision: 0
-		};
+		}, {
+			member: childSessionId !== void 0,
+			curated: this.deps.modelList?.(record?.scope) ?? [],
+			current: info.effective
+		});
 	}
 	async *followModelDirectory(childSessionId, signal) {
 		if (this.deps.followDirectory === void 0) {
@@ -3506,7 +3850,7 @@ const inject = [
 * behavior byte-identical.
 */
 const SETTINGS_FIELDS = {
-	live: z.boolean().default(false),
+	live: z.boolean().default(true),
 	liveMirrorGranularity: z.union([z.const("event"), z.const("token")]).default("token"),
 	model: z.string(),
 	recentModels: z.array(z.string()).default([])
@@ -3556,7 +3900,7 @@ function apply(ctx, config) {
 			const model = vol(config.model);
 			const recentModels = vol(config.recentModels);
 			return {
-				live: vol(config.live) ?? false,
+				live: vol(config.live) ?? true,
 				liveMirrorGranularity: vol(config.liveMirrorGranularity) ?? "token",
 				...model === void 0 ? {} : { model },
 				...recentModels === void 0 ? {} : { recentModels }
@@ -3573,6 +3917,7 @@ function apply(ctx, config) {
 		}
 		const face = settingsFace(ctx, {
 			namespace: CLAUDE_SETTINGS_NAMESPACE,
+			harness: "claude-code",
 			legacySchema: CLAUDE_SETTINGS_SCHEMA,
 			legacyBase,
 			read: readSettings