@khorsheed/dsh-context-lens 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,3943 @@
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region lib/types/tool-summary.js
+/** Counts calls by exact tool name, retaining first-occurrence order. */
+function countToolCalls(names) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const name of names) counts.set(name, (counts.get(name) ?? 0) + 1);
+	return [...counts].map(([name, count]) => ({
+		name,
+		count
+	}));
+}
+//#endregion
+//#region lib/types/messages.js
+/**
+* User-role producers that ride along every turn rather than start one: a
+* turn with no human message is attributed to its first message from any
+* other producer (a room delivery, a schedule, a plugin trigger).
+*/
+const AMBIENT_SOURCES = /* @__PURE__ */ new Set([
+	"user",
+	"runtime-context",
+	"skill-catalog",
+	"skill-invocation",
+	"repeat-tool-reminder",
+	"compact-checkpoint"
+]);
+/**
+* The trigger preview: injected triggers lead with standing instructions and
+* end with what this turn delivers (a report, a forwarded message), so the
+* last paragraph is the part that differs turn to turn.
+*/
+function lastParagraph(text) {
+	return previewLine(text.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p.length > 0).at(-1) ?? text, 120);
+}
+/** Collapse whitespace for the single-line preview, capped at `max` chars. */
+function previewLine(text, max = 80) {
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 1)}…`;
+}
+/** Model-facing text of non-assistant content: text verbatim, file/image as placeholder lines. */
+function plainText(blocks) {
+	const parts = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			parts.push(block.text ?? "");
+			break;
+		case "file":
+			parts.push(`[file: ${block.ref ?? "attachment"}]`);
+			break;
+		case "image": parts.push(`[image${block.ref === void 0 ? "" : `: ${block.ref}`}]`);
+	}
+	return parts.join("\n");
+}
+/**
+* The verbatim wire form of one message — what `SegmentItem.full` carries.
+* Assistant rows serialize to a JSON string `{reasoning?, text?, calls?}`
+* (calls keep the raw argument JSON), the shape the reference panel renders;
+* every other role is its plain text. The content is pre-projection: the
+* waterfall sees file/image blocks before the adapter rewrites them to handle
+* text, so they appear as bracketed placeholders.
+*/
+function serializeMessage(message) {
+	if (message.role === "assistant") {
+		const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text ?? "").join("");
+		const text = message.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+		const calls = message.content.filter((block) => block.type === "tool-call").map((block) => ({
+			id: block.id ?? "",
+			name: block.name ?? "",
+			arguments: block.arguments ?? ""
+		}));
+		return JSON.stringify({
+			...reasoning.length > 0 ? { reasoning } : {},
+			...text.length > 0 ? { text } : {},
+			...calls.length > 0 ? { calls } : {}
+		});
+	}
+	if (message.role === "developer") return JSON.stringify(message.content);
+	return plainText(message.content);
+}
+/** Tool names one assistant message invoked (the chip on assistant rows). */
+function toolCallNames(message) {
+	return message.content.filter((block) => block.type === "tool-call").map((block) => block.name ?? "").filter((name) => name.length > 0);
+}
+/** Single-line summary of one message for the collapsed row. */
+function previewMessage(message) {
+	if (message.role === "assistant") {
+		const names = toolCallNames(message);
+		if (names.length > 0) return `→ ${names.join(", ")}`;
+		return previewLine(message.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join(""));
+	}
+	if (message.role === "developer") {
+		const changes = message.content.map((block) => block.type === "tool-addition" ? `+${block.toolName ?? ""}` : block.type === "tool-removal" ? `-${block.toolName ?? ""}` : "").filter((part) => part.length > 1);
+		return previewLine(changes.length > 0 ? `tools ${changes.join(" ")}` : serializeMessage(message));
+	}
+	return previewLine(plainText(message.content));
+}
+/**
+* Classify one message into its panel category. Role decides first; user-role
+* rows refine by producer `kind`, with `form: 'snapshot'` as the fallback
+* signal for runtime snapshots from producers the explicit map predates.
+*/
+function classifyMessage(message) {
+	switch (message.role) {
+		case "system": return "system";
+		case "assistant": return "assistant";
+		case "tool": return "tool-result";
+		case "developer": return "tool-change";
+	}
+	switch (message.sourceKind) {
+		case "user": return "user";
+		case "runtime-context": return "runtime-snapshot";
+		case "skill-catalog":
+		case "skill-invocation": return "skill-injection";
+		case "compact-checkpoint": return "compaction";
+		case "repeat-tool-reminder": return "reminder-injection";
+		default: return message.sourceForm === "snapshot" ? "runtime-snapshot" : "plugin-injection";
+	}
+}
+/** The label a row shows as its origin — producer kind, refined where the panel knows more. */
+function messageSourceLabel(message, toolName) {
+	if (message.role === "tool" && toolName !== void 0) return toolName;
+	return message.sourceKind;
+}
+/**
+* Diff identity for one message: the durable id when present, else a content
+* hash. Tool-result pruning preserves ids while changing content; the hash
+* fallback keeps hand-built id-less inputs (aux requests) diffable.
+*/
+function messageKey(message, hash) {
+	return `${message.id === void 0 ? "h" : `id:${message.id}`}:${hash(JSON.stringify({
+		..."turn" in message && typeof message.turn === "number" ? { sourceTurn: message.turn } : {},
+		role: message.role,
+		kind: message.sourceKind,
+		content: message.content,
+		...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId }
+	}))}`;
+}
+/** Normalize one typed waterfall message (loop-built or hand-built). Never mutates the input. */
+function fromRequestMessage(message) {
+	const content = message.content.map(normalizeBlock);
+	const id = "id" in message && typeof message.id === "string" ? message.id : void 0;
+	const source = "source" in message && typeof message.source === "object" ? message.source : void 0;
+	const base = {
+		...id === void 0 ? {} : { id },
+		..."turn" in message && typeof message.turn === "number" ? { sourceTurn: message.turn } : {},
+		role: message.role,
+		...source?.compactionId === void 0 ? {} : { compactionId: source.compactionId },
+		sourceKind: source?.kind ?? "user",
+		...source?.form === void 0 ? {} : { sourceForm: source.form },
+		content
+	};
+	if (message.role === "tool") return {
+		...base,
+		toolCallId: message.toolCallId,
+		...message.isError === void 0 ? {} : { isError: message.isError }
+	};
+	return base;
+}
+/** Flatten one typed content block. Unknown block types keep only their tag. */
+function normalizeBlock(block) {
+	switch (block.type) {
+		case "text":
+		case "reasoning": return {
+			type: block.type,
+			text: block.text
+		};
+		case "tool-call": return {
+			type: "tool-call",
+			id: block.id,
+			name: block.name,
+			arguments: block.arguments
+		};
+		case "tool-addition":
+		case "tool-removal": return {
+			type: block.type,
+			toolName: block.toolName
+		};
+		case "file":
+		case "image": {
+			const ref = attachmentLabel(block.attachment);
+			return ref === void 0 ? { type: block.type } : {
+				type: block.type,
+				ref
+			};
+		}
+		default: return { type: block.type };
+	}
+}
+/** Best-effort display label out of an attachment reference. */
+function attachmentLabel(attachment) {
+	if (typeof attachment !== "object" || attachment === null) return void 0;
+	const name = attachment.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+/** Structural read of one log-lane message (untrusted JSON). Returns undefined for unreadable rows. */
+function fromLogMessage(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const value = raw;
+	const role = value["role"];
+	if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool" && role !== "developer") return;
+	const content = Array.isArray(value["content"]) ? value["content"].map(readBlock).filter(isDefined) : [];
+	const source = typeof value["source"] === "object" && value["source"] !== null ? value["source"] : void 0;
+	const sourceKind = typeof source?.["kind"] === "string" ? source["kind"] : role === "user" ? "user" : role;
+	return {
+		...typeof value["id"] === "string" ? { id: value["id"] } : {},
+		...typeof value["turn"] === "number" ? { sourceTurn: value["turn"] } : {},
+		role,
+		sourceKind,
+		...typeof source?.["compactionId"] === "string" ? { compactionId: source["compactionId"] } : {},
+		...typeof source?.["form"] === "string" ? { sourceForm: source["form"] } : {},
+		content,
+		...typeof value["toolCallId"] === "string" ? { toolCallId: value["toolCallId"] } : {},
+		...value["isError"] === void 0 ? {} : { isError: value["isError"] === true }
+	};
+}
+/** Structural read of one log-lane content block. */
+function readBlock(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const value = raw;
+	const type = value["type"];
+	if (typeof type !== "string") return void 0;
+	return {
+		type,
+		...typeof value["text"] === "string" ? { text: value["text"] } : {},
+		...typeof value["id"] === "string" ? { id: value["id"] } : {},
+		...typeof value["name"] === "string" ? { name: value["name"] } : {},
+		...typeof value["arguments"] === "string" ? { arguments: value["arguments"] } : {},
+		...typeof value["toolName"] === "string" ? { toolName: value["toolName"] } : {}
+	};
+}
+function isDefined(value) {
+	return value !== void 0;
+}
+const VARIABLE_REFERENCE = /\{\{([a-z][a-z0-9_]*)\}\}/g;
+/**
+* Interpolate one section the way the host's renderer does, minus its error
+* paths: a reference whose variable is missing keeps its literal form so the
+* rendered text still lines up with whatever the host produced (or simply
+* fails to match, degrading attribution to a single row).
+*/
+function interpolateSection(text, variables) {
+	return text.replace(VARIABLE_REFERENCE, (raw, name) => variables[name] ?? raw);
+}
+/**
+* Record one post-waterfall assembly into the ring. Adjacent duplicates (a
+* listener-free re-assembly between steps) collapse to one entry.
+*/
+function recordAssembly(ring, assembly, at) {
+	const sections = assembly.sections.map((section) => ({
+		name: section.name,
+		text: section.interpolate === false ? section.text : interpolateSection(section.text, assembly.variables)
+	})).filter((section) => section.text.length > 0);
+	const rendered = sections.map((section) => section.text).join("\n\n");
+	const last = ring[ring.length - 1];
+	if (last !== void 0 && last.rendered === rendered) {
+		last.at = at;
+		return;
+	}
+	ring.push({
+		rendered,
+		sections,
+		at
+	});
+	if (ring.length > 32) ring.splice(0, ring.length - 32);
+}
+/** Split one request's payload into the four segments. Pure: no I/O, no clock. */
+function splitRequest(input) {
+	const { messages, context } = input;
+	const keys = messages.map((message) => messageKey(message, contentHash));
+	const freshnessByIndex = messageFreshness(keys, context.previous);
+	const previousToolNames = new Set(context.previous?.toolNames ?? []);
+	const system = [];
+	if (input.systemSlot !== void 0 && input.systemSlot.length > 0) system.push({
+		index: -1,
+		category: "system",
+		source: "system",
+		preview: previewLine(input.systemSlot),
+		full: input.systemSlot,
+		chars: input.systemSlot.length,
+		freshness: context.previous?.systemSlot === input.systemSlot ? "history" : "new"
+	});
+	const history = [];
+	const added = [];
+	messages.forEach((message, index) => {
+		const freshness = freshnessByIndex[index];
+		if (message.role === "system") {
+			system.push(...attributeSystem(message, index, freshness, context.assemblies));
+			return;
+		}
+		const full = serializeMessage(message);
+		const toolCalls = message.role === "assistant" ? toolCallNames(message) : [];
+		const durationMs = message.role === "assistant" && message.id !== void 0 ? context.durationFor?.(message.id) : void 0;
+		const sourceTurn = message.sourceTurn ?? (message.id === void 0 ? void 0 : context.turnFor?.(message.id));
+		const item = {
+			index,
+			...message.id === void 0 ? {} : { messageId: message.id },
+			...message.compactionId === void 0 ? {} : { compactionId: message.compactionId },
+			...message.pruning === void 0 ? {} : { pruning: message.pruning },
+			category: classifyMessage(message),
+			source: messageSourceLabel(message, message.toolCallId === void 0 ? void 0 : context.resolveToolName?.(message.toolCallId)),
+			...toolCalls.length > 0 ? { toolCalls } : {},
+			preview: previewMessage(message),
+			full,
+			chars: full.length,
+			...durationMs === void 0 ? {} : { durationMs },
+			...message.isError === void 0 ? {} : { isError: message.isError },
+			...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId },
+			...sourceTurn === void 0 ? {} : { sourceTurn },
+			freshness
+		};
+		(freshness === "history" ? history : added).push(item);
+	});
+	const tools = (input.tools ?? []).map((tool) => {
+		const parameters = JSON.stringify(tool.parameters, null, 1);
+		return {
+			name: tool.name,
+			description: tool.description,
+			parameters,
+			chars: tool.name.length + tool.description.length + parameters.length,
+			added: context.previous !== void 0 && !previousToolNames.has(tool.name)
+		};
+	});
+	const totalChars = system.reduce((n, item) => n + item.chars, 0) + tools.reduce((n, item) => n + item.chars, 0) + history.reduce((n, item) => n + item.chars, 0) + added.reduce((n, item) => n + item.chars, 0);
+	return {
+		system,
+		tools,
+		history,
+		added,
+		fingerprint: {
+			messageKeys: keys,
+			toolNames: (input.tools ?? []).map((tool) => tool.name),
+			...input.systemSlot === void 0 ? {} : { systemSlot: input.systemSlot }
+		},
+		totalChars
+	};
+}
+/** Match occurrences, preserving unchanged tails across surface replacements. */
+function messageFreshness(keys, previous) {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const key of previous?.messageKeys ?? []) remaining.set(key, (remaining.get(key) ?? 0) + 1);
+	return keys.map((key) => {
+		const count = remaining.get(key) ?? 0;
+		if (count > 0) remaining.set(key, count - 1);
+		return count > 0 ? "history" : "new";
+	});
+}
+/** A late log backfill can supply the baseline that was missing at capture. */
+function rebaseSegments(segments, current, previous) {
+	const freshness = messageFreshness(current.messageKeys, previous);
+	const refresh = (item) => ({
+		...item,
+		freshness: item.index === -1 ? current.systemSlot === previous.systemSlot ? "history" : "new" : freshness[item.index] ?? item.freshness
+	});
+	const messages = [...segments.history, ...segments.added].sort((a, b) => a.index - b.index).map(refresh);
+	const tools = new Set(previous.toolNames);
+	return {
+		system: segments.system.map(refresh),
+		tools: segments.tools.map((tool) => ({
+			...tool,
+			added: !tools.has(tool.name)
+		})),
+		history: messages.filter((item) => item.freshness === "history"),
+		added: messages.filter((item) => item.freshness === "new")
+	};
+}
+/** Attribute one system message to assembly sections when its text matches a rendered assembly exactly. */
+function attributeSystem(message, index, freshness, assemblies) {
+	const full = serializeMessage(message);
+	for (let i = assemblies.length - 1; i >= 0; i -= 1) {
+		const assembly = assemblies[i];
+		if (assembly === void 0 || assembly.rendered !== full || assembly.sections.length === 0) continue;
+		return assembly.sections.map((section) => ({
+			index,
+			...message.id === void 0 ? {} : { messageId: message.id },
+			...message.compactionId === void 0 ? {} : { compactionId: message.compactionId },
+			...message.pruning === void 0 ? {} : { pruning: message.pruning },
+			category: "system",
+			source: section.name,
+			preview: previewLine(section.text),
+			full: section.text,
+			chars: section.text.length,
+			...message.isError === void 0 ? {} : { isError: message.isError },
+			...message.toolCallId === void 0 ? {} : { toolCallId: message.toolCallId },
+			...message.sourceTurn === void 0 ? {} : { sourceTurn: message.sourceTurn },
+			freshness
+		}));
+	}
+	return [{
+		index,
+		...message.id === void 0 ? {} : { messageId: message.id },
+		category: "system",
+		source: message.sourceKind,
+		preview: previewLine(full),
+		full,
+		chars: full.length,
+		freshness
+	}];
+}
+/** FNV-1a 32-bit — enough to keep id-less messages diffable, no crypto import needed. */
+function contentHash(text) {
+	let hash = 2166136261;
+	for (let i = 0; i < text.length; i += 1) {
+		hash ^= text.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region lib/types/prefix-diff.js
+/** Linear comparison on full text; never infer a change from already-truncated previews. */
+function prefixTextChange(before, after) {
+	const a = Array.from(before), b = Array.from(after);
+	let start = 0, end = 0;
+	while (start < a.length && start < b.length && a[start] === b[start]) start++;
+	while (end < a.length - start && end < b.length - start && a[a.length - end - 1] === b[b.length - end - 1]) end++;
+	return {
+		offset: start,
+		leading: a.slice(Math.max(0, start - 48), start).join(""),
+		trailing: end ? a.slice(a.length - end, a.length - end + 48).join("") : "",
+		leadingOmitted: start > 48,
+		trailingOmitted: end > 48,
+		removed: a.slice(start, Math.min(a.length - end, start + 160)).join(""),
+		added: b.slice(start, Math.min(b.length - end, start + 160)).join(""),
+		removedChars: a.length - start - end,
+		addedChars: b.length - start - end
+	};
+}
+//#endregion
+//#region lib/types/changes.js
+/**
+* The change list between two consecutive requests of one scope. Every entry
+* is a fact the host recorded or an exact comparison — never an inference:
+*
+* - Messages pair by durable id (content hash for id-less ones): ids only in
+*   the previous request were removed, ids only in the current one were added,
+*   a shared id whose text differs was rewritten in place.
+* - A surface replacement event (`surfaceOp: replace`) names the ids it
+*   shadowed and the id it put in their place; that pairing — and its
+*   producer's `kind · op` — comes from the {@link ReplacementFact} registry,
+*   fed by the live `session/event` lane and by log backfill alike. The
+*   metering event the host appends right before a replacement
+*   (`compaction/summary`, `compaction/prune`) types it as a compaction or a
+*   prune. Without a fact the same rows stay an honest remove + add.
+* - System rows group into one entry (the user's question is "did the system
+*   prompt change"), diffed head against head, with a checkable equality when
+*   the new head repeats a removed in-history system update verbatim.
+* - Unexplained additions after the last kept row are the ordinary tail
+*   append, summarized rather than listed.
+*
+* @module @khorsheed/dsh-context-lens/changes
+*/
+/** Read the meter a `compaction/*` row announces for the next replacement. */
+function meterOf(row) {
+	if (row.type === "compaction/prune") return { kind: "prune" };
+	if (row.type !== "compaction/summary") return void 0;
+	const id = record(row.data)?.["compactionId"];
+	return {
+		kind: "compaction",
+		...typeof id === "string" ? { compactionId: id } : {}
+	};
+}
+function record(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+/** The message a surface event carries: `data.message` for step events, `data` itself for user messages. */
+function messageOfRow(row) {
+	const data = record(row.data);
+	if (data === void 0) return void 0;
+	const message = record(data["message"]) ?? data;
+	const id = message["id"];
+	const source = record(message["source"]);
+	return {
+		...typeof id === "string" ? { id } : {},
+		...source === void 0 ? {} : { source }
+	};
+}
+/**
+* The fact one replacement row records, or undefined for appends and rows
+* whose ids cannot be read.
+* @param idAt - resolve a shadowed log seq to its message id.
+* @param meter - the metering row immediately before this one, if any.
+*/
+function replacementFact(row, idAt, meter) {
+	const op = record(row.surfaceOp);
+	if (op === void 0 || op["op"] !== "replace") return void 0;
+	const message = messageOfRow(row);
+	if (message?.id === void 0) return void 0;
+	const seqs = row.sourceEventSeqs !== void 0 && row.sourceEventSeqs.length > 0 ? [...row.sourceEventSeqs] : typeof op["startSeq"] === "number" && typeof op["endSeq"] === "number" && op["endSeq"] >= op["startSeq"] ? Array.from({ length: op["endSeq"] - op["startSeq"] + 1 }, (_, i) => op["startSeq"] + i) : [];
+	const replacedIds = seqs.map(idAt).filter((id) => id !== void 0);
+	const sourceKind = typeof message.source?.["kind"] === "string" ? message.source["kind"] : row.type;
+	const sourceOp = typeof message.source?.["op"] === "string" ? message.source["op"] : void 0;
+	const compactionId = typeof message.source?.["compactionId"] === "string" ? message.source["compactionId"] : meter?.compactionId;
+	const kind = meter?.kind ?? (compactionId !== void 0 ? "compaction" : "replace");
+	return {
+		newId: message.id,
+		replacedIds,
+		kind,
+		sourceKind,
+		...sourceOp === void 0 ? {} : { sourceOp },
+		...row.seq === void 0 ? {} : { eventSeq: row.seq },
+		...seqs.length === 0 ? {} : { replacedSeqs: seqs },
+		...kind === "compaction" && compactionId !== void 0 ? { compactionId } : {}
+	};
+}
+/** Every replacement fact of one whole log (the backfill path). */
+function replacementFactsOf(rows) {
+	const ids = /* @__PURE__ */ new Map();
+	const facts = [];
+	let meter;
+	for (const row of rows) {
+		const fact = replacementFact(row, (seq) => ids.get(seq), meter);
+		if (fact !== void 0) facts.push(fact);
+		const id = messageOfRow(row)?.id;
+		if (row.seq !== void 0 && id !== void 0) ids.set(row.seq, id);
+		meter = meterOf(row);
+	}
+	return facts;
+}
+function messagesOf(rows) {
+	const byIndex = /* @__PURE__ */ new Map();
+	for (const row of rows) byIndex.set(row.index, [...byIndex.get(row.index) ?? [], row]);
+	const seen = /* @__PURE__ */ new Map();
+	return [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([index, parts]) => {
+		const first = parts[0];
+		const sectioned = parts.length > 1;
+		const sections = [];
+		let cursor = 0;
+		for (const part of parts) {
+			sections.push({
+				name: part.source,
+				start: cursor,
+				end: cursor + Array.from(part.full).length
+			});
+			cursor += Array.from(part.full).length + 2;
+		}
+		const text = parts.map((part) => part.full).join("\n\n");
+		const id = parts.find((part) => part.messageId !== void 0)?.messageId;
+		const base = id === void 0 ? `h:${first.category}:${text.length}:${hashText(text)}` : `id:${id}`;
+		const n = seen.get(base) ?? 0;
+		seen.set(base, n + 1);
+		return {
+			index,
+			key: n === 0 ? base : `${base}#${n}`,
+			...id === void 0 ? {} : { id },
+			category: first.category,
+			source: first.category === "system" && sectioned ? "system-prompt" : first.source,
+			text,
+			sections: sectioned ? sections : []
+		};
+	});
+}
+function hashText(text) {
+	let hash = 2166136261;
+	for (let i = 0; i < text.length; i += 1) {
+		hash ^= text.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function rowOf(message) {
+	return {
+		index: message.index,
+		...message.id === void 0 ? {} : { messageId: message.id },
+		category: message.category,
+		source: message.source,
+		preview: message.text.replace(/\s+/g, " ").trim().slice(0, 120),
+		chars: Array.from(message.text).length
+	};
+}
+function sectionAt(message, offset) {
+	return message.sections.find((section) => offset >= section.start && offset <= section.end)?.name;
+}
+/** Contiguous runs (by index) of rows; system and non-system rows never share a run. */
+function runs(messages) {
+	const out = [];
+	for (const message of messages) {
+		const last = out[out.length - 1];
+		const tail = last?.[last.length - 1];
+		if (last !== void 0 && tail !== void 0 && message.index === tail.index + 1 && message.category === "system" === (tail.category === "system")) last.push(message);
+		else out.push([message]);
+	}
+	return out;
+}
+/**
+* Diff two consecutive requests.
+* @param breakIndex - the message index where the exact prefix comparison first differs, if it does.
+*/
+function diffRequests(previous, current, facts, breakIndex) {
+	const prev = messagesOf(previous.rows), cur = messagesOf(current.rows);
+	const prevByKey = new Map(prev.map((m) => [m.key, m])), curByKey = new Map(cur.map((m) => [m.key, m]));
+	const removed = prev.filter((m) => !curByKey.has(m.key));
+	const added = cur.filter((m) => !prevByKey.has(m.key));
+	const rewritten = cur.filter((m) => m.id !== void 0 && prevByKey.has(m.key) && prevByKey.get(m.key).text !== m.text);
+	const resolve = (ids, depth = 0) => ids.flatMap((id) => {
+		if (prev.some((m) => m.id === id) || depth > 8) return [id];
+		const inner = facts.byNewId(id);
+		return inner === void 0 || inner.newId === id ? [id] : resolve(inner.replacedIds, depth + 1);
+	});
+	const explained = /* @__PURE__ */ new Set();
+	const changes = [];
+	const seenFacts = /* @__PURE__ */ new Set();
+	const candidates = [];
+	const want = (fact) => {
+		if (fact === void 0 || seenFacts.has(fact.newId)) return;
+		seenFacts.add(fact.newId);
+		candidates.push(fact);
+	};
+	for (const m of added) if (m.id !== void 0) want(facts.byNewId(m.id));
+	for (const m of rewritten) want(facts.byNewId(m.id));
+	for (const m of removed) if (m.id !== void 0) want(facts.byReplacedId(m.id));
+	for (const fact of candidates) {
+		const shadowed = new Set(resolve(fact.replacedIds));
+		const gone = removed.filter((m) => m.id !== void 0 && shadowed.has(m.id) && !explained.has(m.key));
+		const fresh = cur.filter((m) => m.id === fact.newId);
+		const inPlace = fresh.filter((m) => prevByKey.has(m.key));
+		const freshAdded = fresh.filter((m) => !prevByKey.has(m.key));
+		if (gone.length === 0 && freshAdded.length === 0 && inPlace.length === 0) continue;
+		for (const m of [
+			...gone,
+			...freshAdded,
+			...inPlace
+		]) explained.add(m.key);
+		const before = inPlace.length > 0 ? prevByKey.get(inPlace[0].key) : gone.length === 1 ? gone[0] : void 0;
+		const after = inPlace[0] ?? freshAdded[0];
+		const text = before !== void 0 && after !== void 0 ? prefixTextChange(before.text, after.text) : void 0;
+		changes.push({
+			kind: fact.kind,
+			removed: inPlace.length > 0 ? inPlace.map((m) => rowOf(prevByKey.get(m.key))) : gone.map(rowOf),
+			added: [...inPlace, ...freshAdded].map(rowOf),
+			source: {
+				kind: fact.sourceKind,
+				...fact.sourceOp === void 0 ? {} : { op: fact.sourceOp }
+			},
+			...fact.eventSeq === void 0 ? {} : { eventSeq: fact.eventSeq },
+			...fact.replacedSeqs === void 0 ? {} : { replacedSeqs: fact.replacedSeqs },
+			...fact.compactionId === void 0 ? {} : { compactionId: fact.compactionId },
+			...text === void 0 ? {} : { text }
+		});
+	}
+	for (const m of rewritten) {
+		if (explained.has(m.key)) continue;
+		explained.add(m.key);
+		const before = prevByKey.get(m.key);
+		changes.push({
+			kind: "replace",
+			removed: [rowOf(before)],
+			added: [rowOf(m)],
+			text: prefixTextChange(before.text, m.text)
+		});
+	}
+	const keptPrev = prev.filter((m) => curByKey.has(m.key));
+	const keptCur = cur.filter((m) => prevByKey.has(m.key));
+	const lastKeptPrev = Math.max(-1, ...keptPrev.map((m) => m.index));
+	const anchor = Math.max(-1, ...keptCur.map((m) => m.index), ...cur.filter((m) => explained.has(m.key)).map((m) => m.index));
+	const looseRemoved = removed.filter((m) => !explained.has(m.key));
+	const looseAdded = added.filter((m) => !explained.has(m.key));
+	const tailRows = looseRemoved.some((m) => m.index > lastKeptPrev) ? [] : looseAdded.filter((m) => m.index > anchor && m.category !== "system");
+	const tailKeys = new Set(tailRows.map((m) => m.key));
+	for (const run of runs(looseRemoved)) changes.push({
+		kind: "remove",
+		removed: run.map(rowOf),
+		added: []
+	});
+	for (const run of runs(looseAdded.filter((m) => !tailKeys.has(m.key)))) changes.push({
+		kind: "add",
+		removed: [],
+		added: run.map(rowOf)
+	});
+	const grouped = groupSystem(changes, prev, cur);
+	grouped.sort((a, b) => firstIndex(a) - firstIndex(b));
+	const tools = diffTools(previous.tools, current.tools);
+	const breakAt = breakIndex === void 0 ? void 0 : grouped.find((c) => c.added.some((r) => r.index === breakIndex)) ?? grouped.find((c) => c.removed.some((r) => r.index === breakIndex));
+	if (breakAt !== void 0) breakAt.isBreak = true;
+	else if (breakIndex === void 0 && tools[0] !== void 0) tools[0].isBreak = true;
+	return {
+		changes: grouped,
+		tools,
+		...tailRows.length === 0 ? {} : { tail: {
+			count: tailRows.length,
+			sources: [...new Set(tailRows.map((m) => m.source))]
+		} }
+	};
+}
+function firstIndex(change) {
+	return Math.min(...change.added.map((r) => r.index), ...change.removed.map((r) => r.index));
+}
+/**
+* Fold every all-system change into one entry. The text diff compares the
+* head system message of both requests (the cache prefix); when the new head
+* repeats a removed system message verbatim, that equality is recorded.
+*/
+function groupSystem(changes, prev, cur) {
+	const isSystem = (c) => [...c.removed, ...c.added].length > 0 && [...c.removed, ...c.added].every((r) => r.category === "system");
+	const system = changes.filter(isSystem);
+	if (system.length === 0) return changes;
+	const rest = changes.filter((c) => !isSystem(c));
+	const prevHead = prev.find((m) => m.category === "system"), curHead = cur.find((m) => m.category === "system");
+	let text;
+	let section;
+	if (prevHead !== void 0 && curHead !== void 0 && prevHead.index === curHead.index && prevHead.text !== curHead.text) {
+		text = prefixTextChange(prevHead.text, curHead.text);
+		section = sectionAt(curHead, text.offset);
+	} else {
+		const effective = (list) => list.filter((m) => m.category === "system" && m.text.length > 0).at(-1);
+		const before = effective(prev), after = effective(cur);
+		if (before !== void 0 && after !== void 0 && before.text !== after.text) text = prefixTextChange(before.text, after.text);
+	}
+	const removed = system.flatMap((c) => c.removed);
+	const sameAs = curHead === void 0 ? void 0 : removed.find((r) => r.index !== curHead.index && prev.find((m) => m.index === r.index)?.text === curHead.text);
+	return [{
+		kind: system.some((c) => c.kind !== "add" && c.kind !== "remove") ? "replace" : removed.length > 0 ? "remove" : "add",
+		system: true,
+		removed,
+		added: system.flatMap((c) => c.added),
+		source: { kind: "system-prompt" },
+		parts: system.map((c) => ({
+			kind: c.kind,
+			removed: c.removed,
+			added: c.added,
+			...c.eventSeq === void 0 ? {} : { eventSeq: c.eventSeq },
+			...c.replacedSeqs === void 0 ? {} : { replacedSeqs: c.replacedSeqs }
+		})),
+		...text === void 0 ? {} : { text },
+		...section === void 0 ? {} : { section },
+		...sameAs === void 0 ? {} : { sameAs }
+	}, ...rest];
+}
+/** Tool definitions pair by name; description and parameters diff separately. */
+function diffTools(previous, current) {
+	const before = new Map(previous.map((tool) => [tool.name, tool]));
+	const after = new Set(current.map((tool) => tool.name));
+	const out = [];
+	for (const tool of current) {
+		const old = before.get(tool.name);
+		if (old === void 0) {
+			out.push({
+				name: tool.name,
+				change: "added"
+			});
+			continue;
+		}
+		const description = old.description === tool.description ? void 0 : prefixTextChange(old.description, tool.description);
+		const parameters = old.parameters === tool.parameters ? void 0 : prefixTextChange(old.parameters, tool.parameters);
+		if (description === void 0 && parameters === void 0) continue;
+		out.push({
+			name: tool.name,
+			change: "modified",
+			...description === void 0 ? {} : { description },
+			...parameters === void 0 ? {} : { parameters }
+		});
+	}
+	for (const tool of previous) if (!after.has(tool.name)) out.push({
+		name: tool.name,
+		change: "removed"
+	});
+	return out;
+}
+//#endregion
+//#region lib/types/room.js
+function emptyRoom() {
+	return {
+		members: /* @__PURE__ */ new Map(),
+		dispatches: [],
+		runs: /* @__PURE__ */ new Map(),
+		handoffs: [],
+		decisions: [],
+		seen: /* @__PURE__ */ new Set()
+	};
+}
+const str = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+/**
+* Apply one `room/*` event. Unknown types and malformed payloads are ignored.
+* @returns whether the event was a room event this module reads.
+*/
+function applyRoomEvent(room, type, data, seq, at) {
+	if (!type.startsWith("room/")) return false;
+	if (seq !== void 0) {
+		if (room.seen.has(seq)) return true;
+		room.seen.add(seq);
+	}
+	const d = typeof data === "object" && data !== null ? data : {};
+	switch (type) {
+		case "room/member-added":
+		case "room/member-updated": {
+			const id = str(d["id"]), name = str(d["name"]);
+			if (id !== void 0 && name !== void 0) room.members.set(id, name);
+			return true;
+		}
+		case "room/dispatch": {
+			if (d["origin"] !== "human" || seq === void 0 || at === void 0) return true;
+			const targets = Array.isArray(d["targets"]) ? d["targets"].filter((t) => typeof t === "string") : [];
+			room.dispatches.push({
+				seq,
+				at,
+				text: str(d["text"]) ?? "",
+				targets
+			});
+			return true;
+		}
+		case "room/run-state": {
+			const runId = str(d["runId"]);
+			if (runId === void 0) return true;
+			const [head, ...rest] = runId.split(":");
+			const dispatchSeq = Number(head);
+			if (!Number.isSafeInteger(dispatchSeq)) return true;
+			const run = room.runs.get(runId) ?? {
+				runId,
+				dispatchSeq,
+				memberId: rest.join(":")
+			};
+			const member = str(d["member"]), state = str(d["state"]), child = str(d["childSessionId"]);
+			const startedAt = num(d["startedAt"]), elapsed = num(d["elapsedMs"]), childTurn = num(d["childTurn"]);
+			if (member !== void 0) run.member = member;
+			if (state !== void 0) run.state = state;
+			if (startedAt !== void 0) run.startedAt = startedAt;
+			if (startedAt !== void 0 && elapsed !== void 0) run.endedAt = startedAt + elapsed;
+			else if ((state === "done" || state === "failed") && at !== void 0) run.endedAt ??= at;
+			if (child !== void 0) run.childSessionId = child;
+			if (childTurn !== void 0) run.childTurn = childTurn;
+			room.runs.set(runId, run);
+			return true;
+		}
+		case "room/decision": {
+			const call = typeof d["call"] === "object" && d["call"] !== null ? d["call"] : void 0;
+			const id = str(d["id"]), scenario = str(d["scenario"]), outcome = str(d["outcome"]);
+			if (call === void 0 || id === void 0 || scenario === void 0 || outcome === void 0 || seq === void 0 || at === void 0) return true;
+			const request = typeof call["request"] === "object" && call["request"] !== null ? call["request"] : {};
+			const failure = call["failure"];
+			const about = typeof d["about"] === "object" && d["about"] !== null ? d["about"] : {};
+			room.decisions.push({
+				id,
+				seq,
+				at,
+				scenario,
+				outcome,
+				model: str(call["model"]) ?? "typesafe",
+				about,
+				request: {
+					state: request["state"] ?? null,
+					questions: request["questions"] ?? null
+				},
+				...str(d["rule"]) === void 0 ? {} : { rule: str(d["rule"]) },
+				...num(d["probability"]) === void 0 ? {} : { probability: num(d["probability"]) },
+				...num(call["latencyMs"]) === void 0 ? {} : { latencyMs: num(call["latencyMs"]) },
+				...typeof call["cached"] === "boolean" ? { cached: call["cached"] } : {},
+				...num(call["inputTokens"]) === void 0 ? {} : { inputTokens: num(call["inputTokens"]) },
+				...num(call["outputTokens"]) === void 0 ? {} : { outputTokens: num(call["outputTokens"]) },
+				...call["response"] === void 0 ? {} : { response: call["response"] },
+				...typeof failure?.reason === "string" ? { failure: {
+					reason: failure.reason,
+					...typeof failure.detail === "string" ? { detail: failure.detail } : {}
+				} } : {}
+			});
+			return true;
+		}
+		case "room/coordinator": {
+			const memberId = str(d["memberId"]);
+			if (memberId !== void 0 && seq !== void 0 && at !== void 0) room.handoffs.push({
+				seq,
+				at,
+				memberId
+			});
+			return true;
+		}
+		default: return true;
+	}
+}
+/** The runs a dispatch started, in start order. */
+function runsOf(room, dispatchSeq) {
+	return [...room.runs.values()].filter((run) => run.dispatchSeq === dispatchSeq).sort((a, b) => (a.startedAt ?? 0) - (b.startedAt ?? 0));
+}
+/** A synthetic, stable panel address for a room round (far below any purpose bucket). */
+const ROOM_TURN_BASE = -1e6;
+const roomTurnSeq = (dispatchSeq) => ROOM_TURN_BASE - dispatchSeq;
+//#endregion
+//#region lib/types/store.js
+/**
+* The context-lens capture store: an in-memory ring of sessions → turns →
+* agent scopes → requests, plus the correlation tables the lanes feed.
+*
+* Correlation model:
+* - **Turns** come from `turn/start` / `turn/end` on a root session; a request
+*   whose `sessionId` is the root lands in the turn open at dispatch time.
+* - **Aux requests** (`purpose: compaction | session-title | …`) are not
+*   conversation steps even when one fires mid-turn: they accumulate in a
+*   per-session pseudo-turn keyed by purpose, sorted into the turn list at
+*   first sight.
+* - **Scopes**: `main` is the conversation itself; each `subagent/catalog`
+*   event opens a child scope pinned to the turn that delegated it. A request
+*   whose `sessionId` is a known child joins that scope (in-process drivers);
+*   fresh-process children fill the same scope from the log lane instead.
+* - **Tool timing** pairs `tool/call` → `tool/result` by callId and attributes
+*   the interval to the request whose response issued the call (callId owner
+*   table, fed from tool-call stream blocks).
+*
+* Eviction is turn-granular (never a half turn): per-session turn cap and a
+* global request cap both evict the oldest CLOSED turn; a turn holding a live
+* stream is skipped, so the caps are soft while streams are open.
+*
+* @module @khorsheed/dsh-context-lens/store
+*/
+/** Replacement facts kept per session; older facts only matter for requests long evicted. */
+const REPLACEMENT_CAP = 2048;
+const DEFAULT_MAX_TURNS_PER_SESSION = 30;
+const DEFAULT_MAX_BACKFILL_REQUESTS_PER_SESSION = 500;
+const DEFAULT_MAX_STORED_CHARS_TOTAL = 15e7;
+/**
+* Whether one scope passes a read's allow-list: unfiltered when the filter
+* carries no `scopes`, otherwise membership. Shared by the store's query
+* methods and the service's child-log gate.
+*/
+function scopeAuthorized(scopeId, filter) {
+	return filter?.scopes === void 0 || filter.scopes.includes(scopeId);
+}
+/** The scope's fidelity marker for the wire; absent while it holds no captured content. */
+function scopeOrigin(scope) {
+	if (scope.logFilled) return "log-reconstructed";
+	if (scope.live || scope.requests.length > 0) return "live";
+}
+/** The in-memory capture store. All mutation enters through the `note*`/`observe*` methods. */
+var InspectorStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	childToParent = /* @__PURE__ */ new Map();
+	/** A session opened on its own that its log header names as a child (`parentSession`). */
+	parents = /* @__PURE__ */ new Map();
+	/** callId → the request whose response issued the call (exec attribution). */
+	callOwners = /* @__PURE__ */ new Map();
+	callNames = /* @__PURE__ */ new Map();
+	/** Recently observed rendered assemblies (system-section attribution). */
+	assemblies = [];
+	now;
+	onTurnEvicted;
+	maxTurnsPerSession;
+	maxBackfillRequestsPerSession;
+	maxStoredCharsTotal;
+	/** The instance epoch stamped on every query result (restart invalidation). */
+	generation;
+	seqCounter = 0;
+	/** Stored segment text characters across all sessions (the memory driver). */
+	totalChars = 0;
+	constructor(config = {}, deps = {}) {
+		this.maxTurnsPerSession = config.maxTurnsPerSession ?? DEFAULT_MAX_TURNS_PER_SESSION;
+		this.maxBackfillRequestsPerSession = config.maxBackfillRequestsPerSession ?? DEFAULT_MAX_BACKFILL_REQUESTS_PER_SESSION;
+		this.maxStoredCharsTotal = config.maxStoredCharsTotal ?? DEFAULT_MAX_STORED_CHARS_TOTAL;
+		this.now = deps.now ?? Date.now;
+		this.onTurnEvicted = deps.onTurnEvicted;
+		this.generation = deps.generation ?? `${this.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+	}
+	/** The shared assembly ring (service feeds it from the assemble waterfall). */
+	get assemblyRing() {
+		return this.assemblies;
+	}
+	/** Whether `sessionId` is a known subagent child of some captured session. */
+	isChild(sessionId) {
+		return this.childToParent.has(sessionId);
+	}
+	/** The root session one request/event belongs to (children resolve up). */
+	rootOf(sessionId) {
+		let cursor = sessionId;
+		const seen = /* @__PURE__ */ new Set();
+		while (this.childToParent.has(cursor) && !seen.has(cursor)) {
+			seen.add(cursor);
+			cursor = this.childToParent.get(cursor);
+		}
+		return cursor;
+	}
+	session(id) {
+		let record = this.sessions.get(id);
+		if (record === void 0) {
+			record = {
+				id,
+				turns: [],
+				activeCompactions: /* @__PURE__ */ new Map(),
+				prunings: /* @__PURE__ */ new Map(),
+				replacements: /* @__PURE__ */ new Map(),
+				lastAccess: this.now(),
+				turnSpans: /* @__PURE__ */ new Map(),
+				replacedBy: /* @__PURE__ */ new Map(),
+				openTurn: void 0,
+				buckets: /* @__PURE__ */ new Map(),
+				nextBucketSeq: -1,
+				nextScopeSeq: 1,
+				backfillState: "none",
+				backfillReason: void 0,
+				backfilledRequests: 0,
+				pendingCalls: /* @__PURE__ */ new Map(),
+				messageTurns: /* @__PURE__ */ new Map(),
+				messageDurations: /* @__PURE__ */ new Map(),
+				evictedTurns: 0,
+				nextRequestNumbers: /* @__PURE__ */ new Map()
+			};
+			this.sessions.set(id, record);
+		}
+		return record;
+	}
+	/** Allocate one turn row; the caller sets the address (`turnSeq`) in `init`. */
+	mintTurn(session, at, init) {
+		const turn = {
+			liveContent: false,
+			query: "",
+			startedAt: at,
+			scopes: /* @__PURE__ */ new Map(),
+			...init
+		};
+		session.turns.push(turn);
+		return turn;
+	}
+	mainScope(session, turn, at) {
+		let scope = turn.scopes.get("main");
+		if (scope === void 0) {
+			scope = {
+				scopeId: "main",
+				scopeSeq: session.nextScopeSeq,
+				kind: "main",
+				status: "running",
+				config: {},
+				requests: [],
+				startedAt: at,
+				live: false,
+				logFilled: false
+			};
+			session.nextScopeSeq += 1;
+			turn.scopes.set("main", scope);
+		}
+		return scope;
+	}
+	/** Observe durable compression boundaries without manufacturing model calls. */
+	noteCompaction(sessionId, type, data) {
+		const session = this.session(this.rootOf(sessionId));
+		const id = data["compactionId"];
+		if (typeof id !== "string") return;
+		if (type === "compaction/start") session.activeCompactions.set(sessionId, {
+			id,
+			...typeof data["turn"] === "number" ? { hostTurn: data["turn"] } : {}
+		});
+		if (type === "compaction/end") session.activeCompactions.delete(sessionId);
+		if (type === "compaction/summary" || type === "compaction/applied") for (const turn of session.turns) for (const scope of turn.scopes.values()) for (const request of scope.requests) {
+			if (request.compaction?.id !== id) continue;
+			if (Array.isArray(data["shadowedSeqs"])) request.compaction.replacedCount = data["shadowedSeqs"].length;
+			if (type === "compaction/applied") request.compaction.applied = true;
+		}
+	}
+	/** Preserve pruning metadata across later requests, with bounded observation state. */
+	notePruning(sessionId, messageId, beforeChars, afterChars) {
+		const state = this.session(this.rootOf(sessionId)).prunings;
+		const key = `${sessionId}:${messageId}`;
+		if (afterChars >= beforeChars && !state.has(key)) return;
+		state.set(key, {
+			beforeChars: state.get(key)?.beforeChars ?? beforeChars,
+			afterChars
+		});
+		if (state.size > 512) state.delete(state.keys().next().value);
+	}
+	/** Record one host surface replacement (live event or log backfill) for the change list. */
+	noteReplacement(sessionId, fact) {
+		const session = this.session(this.rootOf(sessionId));
+		session.replacements.set(fact.newId, fact);
+		for (const id of fact.replacedIds) if (id !== fact.newId) session.replacedBy.set(id, fact);
+		while (session.replacements.size > REPLACEMENT_CAP) session.replacements.delete(session.replacements.keys().next().value);
+		while (session.replacedBy.size > REPLACEMENT_CAP * 4) session.replacedBy.delete(session.replacedBy.keys().next().value);
+	}
+	/**
+	* Begin one captured request: correlate session/turn/scope, split the
+	* segments against the scope's previous fingerprint, assign the sequence.
+	*
+	* @returns the stored row, or `undefined` when the request carries no
+	*   session identity the capture can place (a host call with no sessionId
+	*   and no purpose is out of the panel's scope).
+	*/
+	beginRequest(snapshot, startedAt) {
+		if (snapshot.sessionId === void 0) return void 0;
+		const rootId = this.rootOf(snapshot.sessionId);
+		const session = this.session(rootId);
+		const isChild = snapshot.sessionId !== rootId;
+		const compaction = snapshot.purpose === "compaction" ? session.activeCompactions.get(snapshot.sessionId) : void 0;
+		let turn;
+		let scopeId;
+		if (isChild) {
+			const found = this.findScope(session, snapshot.sessionId);
+			if (found === void 0 || found.scope.logFilled) return void 0;
+			turn = found.turn;
+			scopeId = found.scope.scopeId;
+			found.scope.live = true;
+		} else if (snapshot.purpose !== void 0 || session.openTurn === void 0) {
+			const purpose = snapshot.purpose ?? "ad-hoc";
+			const bucketKey = compaction ? `${purpose}:${compaction.id}` : purpose;
+			let bucket = session.buckets.get(bucketKey);
+			if (bucket === void 0) {
+				bucket = this.mintTurn(session, startedAt, {
+					purpose,
+					query: purpose,
+					turnSeq: session.nextBucketSeq
+				});
+				session.nextBucketSeq -= 1;
+				session.buckets.set(bucketKey, bucket);
+			}
+			turn = bucket;
+			scopeId = "main";
+		} else {
+			turn = session.openTurn;
+			scopeId = "main";
+		}
+		const scope = scopeId === "main" ? this.mainScope(session, turn, startedAt) : turn.scopes.get(scopeId);
+		if (scope === void 0) return void 0;
+		const previous = scope.previous ?? (snapshot.purpose === void 0 ? this.previousRequest(session, scopeId, startedAt, this.seqCounter)?.fingerprint : void 0);
+		const segments = splitRequest({
+			messages: snapshot.messages.map((message) => {
+				const pruning = message.id === void 0 ? void 0 : session.prunings.get(`${snapshot.sessionId}:${message.id}`);
+				return pruning === void 0 ? message : {
+					...message,
+					pruning
+				};
+			}),
+			...snapshot.systemSlot === void 0 ? {} : { systemSlot: snapshot.systemSlot },
+			...snapshot.tools === void 0 ? {} : { tools: snapshot.tools },
+			context: {
+				...previous === void 0 || snapshot.purpose === "compaction" ? {} : { previous },
+				assemblies: this.assemblies,
+				resolveToolName: (callId) => this.callNames.get(callId),
+				durationFor: (messageId) => session.messageDurations.get(messageId),
+				turnFor: (messageId) => session.messageTurns.get(messageId)
+			}
+		});
+		if (snapshot.purpose !== "compaction") scope.previous = segments.fingerprint;
+		const request = {
+			seq: this.seqCounter,
+			sessionId: rootId,
+			scopeId: scope.scopeId,
+			turnSeq: turn.turnSeq,
+			...snapshot.purpose === void 0 ? {} : { purpose: snapshot.purpose },
+			...compaction === void 0 ? {} : { compaction: { ...compaction } },
+			startedAt,
+			status: "streaming",
+			config: snapshot.config,
+			responseSummary: { kind: snapshot.purpose === "compaction" ? "compaction" : "none" },
+			segments: {
+				system: segments.system,
+				tools: segments.tools,
+				history: segments.history,
+				added: segments.added
+			},
+			totalChars: segments.totalChars,
+			blocks: [],
+			execs: [],
+			fingerprint: segments.fingerprint,
+			...snapshot.purpose === void 0 && previous === void 0 ? { needsHistoryBaseline: true } : {}
+		};
+		this.seqCounter += 1;
+		const nextNumber = snapshot.purpose === void 0 ? session.nextRequestNumbers.get(scopeId) : void 0;
+		if (nextNumber !== void 0) {
+			request.requestNumber = nextNumber;
+			session.nextRequestNumbers.set(scopeId, nextNumber + 1);
+		}
+		scope.requests.push(request);
+		turn.liveContent = true;
+		this.totalChars += request.totalChars;
+		if (scope.config.provider === void 0 && snapshot.config.provider !== void 0) scope.config = snapshot.config;
+		this.enforceCaps();
+		return request;
+	}
+	/** Attach a purpose-built (log-lane) request row to an existing child scope. */
+	appendLogRequest(rootSessionId, scopeId, built) {
+		const session = this.sessions.get(rootSessionId);
+		if (session === void 0) return void 0;
+		const found = this.findScope(session, scopeId);
+		if (found === void 0 || found.scope.live) return void 0;
+		found.scope.logFilled = true;
+		const request = {
+			...built,
+			seq: this.seqCounter,
+			sessionId: rootSessionId,
+			scopeId,
+			turnSeq: found.turn.turnSeq
+		};
+		this.seqCounter += 1;
+		found.scope.requests.push(request);
+		if (built.purpose === void 0) found.scope.previous = built.fingerprint;
+		this.totalChars += request.totalChars;
+		this.attachResponse(request, built.response);
+		this.accountExecutionResults(request);
+		this.enforceCaps();
+		return request;
+	}
+	findScope(session, scopeId) {
+		for (const turn of session.turns) {
+			const scope = turn.scopes.get(scopeId);
+			if (scope !== void 0) return {
+				turn,
+				scope
+			};
+		}
+	}
+	/** One stream chunk observed on a live request's tee. */
+	observeChunk(request, chunk, at) {
+		if (request.firstChunkAt === void 0) request.firstChunkAt = at;
+		switch (chunk.type) {
+			case "block-start":
+				if (chunk.index === void 0) return;
+				request.blocks.push({
+					kind: chunk.blockType ?? "unknown",
+					index: chunk.index,
+					start: at
+				});
+				return;
+			case "text-delta":
+			case "reasoning-delta": {
+				const span = request.blocks.find((block) => block.index === chunk.index && block.end === void 0);
+				if (span === void 0 || chunk.text === void 0) return;
+				span.text = (span.text ?? "") + chunk.text;
+				return;
+			}
+			case "tool-call-delta": {
+				const span = request.blocks.find((block) => block.index === chunk.index && block.end === void 0);
+				if (span === void 0 || chunk.argumentsDelta === void 0) return;
+				span.args = (span.args ?? "") + chunk.argumentsDelta;
+				return;
+			}
+			case "block-end": {
+				const span = request.blocks.find((block) => block.index === chunk.index && block.end === void 0);
+				if (span === void 0) return;
+				span.end = at;
+				if (chunk.block?.text !== void 0) span.text = chunk.block.text;
+				if (chunk.block?.type === "tool-call") {
+					if (chunk.block.name !== void 0) span.toolName = chunk.block.name;
+					if (chunk.block.id !== void 0) {
+						span.callId = chunk.block.id;
+						this.callOwners.set(chunk.block.id, request);
+						if (chunk.block.name !== void 0) this.callNames.set(chunk.block.id, chunk.block.name);
+					}
+					if (chunk.block.arguments !== void 0) span.args = chunk.block.arguments;
+				}
+				return;
+			}
+			case "usage":
+				if (chunk.usage !== void 0) request.usage = chunk.usage;
+				return;
+			case "finish":
+				if (chunk.reason !== void 0) request.finishKind = chunk.reason.kind;
+				if (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted") request.error = chunk.reason.failure?.message ?? chunk.reason.kind;
+				return;
+		}
+	}
+	/** Settle one request: ok on a clean finish, failed on an error finish or a raised error. */
+	settleRequest(request, at, thrown) {
+		if (request.status !== "streaming") return;
+		request.settledAt = at;
+		if (thrown !== void 0) {
+			request.status = "failed";
+			request.error = thrown instanceof Error ? thrown.message : String(thrown);
+		} else if (request.error !== void 0) request.status = "failed";
+		else if (request.finishKind === void 0) {
+			request.status = "failed";
+			request.error = "stream closed before its finish chunk";
+		} else request.status = "ok";
+		request.responseSummary = request.purpose === "compaction" ? { kind: "compaction" } : summarizeResponse(request);
+		this.attachResponse(request, responseFromSpans(request.blocks));
+		const session = this.sessions.get(request.sessionId);
+		if (session !== void 0 && request.purpose === void 0) session.lastSettledMain = request;
+	}
+	/** Set the request's response and count its chars into the store budget. */
+	attachResponse(request, response) {
+		if (response === void 0) return;
+		request.response = response;
+		const chars = responseSize(response);
+		request.responseChars = chars;
+		this.totalChars += chars;
+	}
+	accountExecutionResults(request) {
+		const chars = executionSize(request);
+		this.totalChars += chars - (request.executionChars ?? 0);
+		request.executionChars = chars;
+	}
+	/** Incremental child folds mutate shared execution spans after insertion. */
+	refreshExecutionResults(sessionId, scopeId) {
+		const session = this.sessions.get(sessionId);
+		const scope = session && this.findScope(session, scopeId)?.scope;
+		for (const request of scope?.requests ?? []) this.accountExecutionResults(request);
+		this.enforceCaps();
+	}
+	/** turn/start on a root session (child sessions route their events to the parent instead). */
+	/** @param seq - the `turn/start` event's log seq (the chat's history-jump target). */
+	turnStart(sessionId, hostTurn, at, seq) {
+		const rootId = this.rootOf(sessionId);
+		const session = this.session(rootId);
+		const scopeId = sessionId === rootId ? "main" : sessionId;
+		if (hostTurn === 1 && !session.nextRequestNumbers.has(scopeId)) session.nextRequestNumbers.set(scopeId, 1);
+		if (this.isChild(sessionId)) return;
+		if (!session.turnSpans.has(hostTurn)) session.turnSpans.set(hostTurn, { start: at });
+		if (session.logDriven) {
+			session.logDirty = true;
+			return;
+		}
+		if (session.openTurn !== void 0) return;
+		const existing = session.turns.find((turn) => turn.hostTurn === hostTurn && turn.purpose === void 0);
+		if (existing !== void 0) {
+			session.openTurn = existing;
+			if (seq !== void 0) existing.startSeq = seq;
+			return;
+		}
+		session.openTurn = this.mintTurn(session, at, {
+			hostTurn,
+			turnSeq: hostTurn,
+			liveContent: true,
+			liveStartObserved: true
+		});
+		if (seq !== void 0) session.openTurn.startSeq = seq;
+	}
+	/** turn/end: close the open turn, resolve its main scope, sweep abandoned streams. */
+	turnEnd(sessionId, hostTurn, reason, at) {
+		if (this.isChild(sessionId)) return;
+		const span = this.sessions.get(sessionId)?.turnSpans.get(hostTurn);
+		if (span !== void 0) span.end = at;
+		const session = this.sessions.get(sessionId);
+		if (session === void 0) return;
+		if (session.logDriven) {
+			session.logDirty = true;
+			return;
+		}
+		let turn = session.openTurn;
+		if (turn === void 0) {
+			const bucket = session.buckets.get("ad-hoc");
+			const drifted = bucket?.scopes.get("main")?.requests.filter((request) => request.purpose === void 0) ?? [];
+			if (drifted.length === 0) return;
+			turn = this.mintTurn(session, at, {
+				hostTurn,
+				turnSeq: hostTurn,
+				liveContent: true
+			});
+			const main = this.mainScope(session, turn, drifted[0]?.startedAt ?? at);
+			for (const request of drifted) {
+				request.turnSeq = turn.turnSeq;
+				main.requests.push(request);
+			}
+			const bucketScope = bucket?.scopes.get("main");
+			if (bucket !== void 0 && bucketScope !== void 0) {
+				bucketScope.requests = bucketScope.requests.filter((request) => !drifted.includes(request));
+				if (bucketScope.requests.length === 0) {
+					bucket.scopes.delete("main");
+					session.buckets.delete("ad-hoc");
+					session.turns = session.turns.filter((candidate) => candidate !== bucket);
+				}
+			}
+		}
+		turn.endedAt = at;
+		session.openTurn = void 0;
+		const main = turn.scopes.get("main");
+		if (main !== void 0) {
+			main.status = reason.kind === "completed" || reason.kind === "max-tokens" ? "ok" : "failed";
+			if (main.status === "failed") main.error = reason.kind === "error" ? reason.error?.message ?? "turn failed" : reason.kind;
+			main.endedAt = at;
+		}
+		for (const scope of turn.scopes.values()) for (const request of scope.requests) if (request.status === "streaming") this.settleRequest(request, at, /* @__PURE__ */ new Error("stream still open at turn end"));
+		this.enforceCaps();
+	}
+	/** A human message entering the turn — the turn list's query preview. */
+	noteUserMessage(sessionId, sourceKind, text) {
+		if (this.isChild(sessionId)) return;
+		const turn = this.sessions.get(sessionId)?.openTurn;
+		if (turn === void 0 || turn.query !== "") return;
+		if (sourceKind !== "user") {
+			if (turn.trigger === void 0 && !AMBIENT_SOURCES.has(sourceKind)) turn.trigger = {
+				source: sourceKind,
+				text: lastParagraph(text)
+			};
+			return;
+		}
+		turn.query = text.replace(/\s+/g, " ").trim().slice(0, 120);
+	}
+	/** The turn's closing assistant message id + generation-time backfill for history rows. */
+	noteAssistantMessage(sessionId, messageId) {
+		const session = this.sessions.get(this.rootOf(sessionId));
+		if (session === void 0) return;
+		if (!this.isChild(sessionId) && session.openTurn !== void 0) session.openTurn.closingMessageId = messageId;
+		const producer = session.lastSettledMain;
+		if (producer !== void 0) {
+			const total = producer.settledAt === void 0 ? void 0 : producer.settledAt - producer.startedAt;
+			if (total !== void 0) session.messageDurations.set(messageId, total);
+		}
+	}
+	/** tool/call: open the exec interval (when the issuing request is known) and queue delegation binding. */
+	toolCall(sessionId, callId, name, args, at) {
+		const rootId = this.rootOf(sessionId);
+		const session = this.session(rootId);
+		this.callNames.set(callId, name);
+		const owner = this.callOwners.get(callId);
+		if (owner !== void 0) owner.execs.push({
+			callId,
+			name,
+			start: at
+		});
+		if (isDelegationTool$1(name)) {
+			const pending = {
+				callId,
+				name,
+				at,
+				...delegationLabel$1(args)
+			};
+			session.pendingCalls.set(callId, pending);
+		}
+	}
+	/** Source turns belong to session events, not the immutable message payload. */
+	noteMessageTurn(sessionId, messageId, turn) {
+		const root = this.childToParent.get(sessionId) ?? sessionId;
+		const session = this.sessions.get(root);
+		const value = turn ?? session?.openTurn?.hostTurn;
+		if (session && value !== void 0) session.messageTurns.set(messageId, value);
+	}
+	/** tool/result: close the exec interval; resolve a delegation scope's outcome. */
+	toolResult(sessionId, callId, isError, result, at) {
+		const rootId = this.rootOf(sessionId);
+		const session = this.sessions.get(rootId);
+		const owner = this.callOwners.get(callId);
+		if (owner !== void 0) {
+			const span = owner.execs.find((exec) => exec.callId === callId && exec.end === void 0);
+			if (span !== void 0) {
+				span.end = at;
+				span.isError = isError;
+				span.result = result;
+				this.accountExecutionResults(owner);
+				this.enforceCaps();
+			}
+		}
+		if (session === void 0) return;
+		const pending = session.pendingCalls.get(callId);
+		if (pending === void 0) return;
+		session.pendingCalls.delete(callId);
+		const scopeId = pending.childId ?? `call:${callId}`;
+		const scope = this.findScope(session, scopeId)?.scope ?? this.openChildScope(session, scopeId, pending.label, at, callId);
+		if (scope === void 0) return;
+		scope.status = isError ? "failed" : "ok";
+		if (isError) scope.error = previewLine(result);
+		scope.endedAt = at;
+	}
+	/** subagent/catalog: open the child scope on the current turn and bind the pending call. */
+	subagentCatalog(sessionId, childId, label, at) {
+		if (this.isChild(sessionId)) return;
+		const session = this.session(sessionId);
+		this.childToParent.set(childId, sessionId);
+		const scope = this.openChildScope(session, childId, label, at);
+		if (scope === void 0) return;
+		for (const pending of session.pendingCalls.values()) if (pending.childId === void 0) {
+			pending.childId = childId;
+			scope.callId = pending.callId;
+			if (pending.label !== void 0 && scope.label === void 0) scope.label = pending.label;
+			break;
+		}
+	}
+	/** Open one child scope on the session's current turn (or latest turn as a fallback). */
+	openChildScope(session, scopeId, label, at, callId) {
+		const existing = this.findScope(session, scopeId);
+		if (existing !== void 0) return existing.scope;
+		const turn = session.openTurn ?? this.holderTurn(session, at);
+		const scope = {
+			scopeId,
+			scopeSeq: session.nextScopeSeq,
+			kind: "subagent",
+			...label === void 0 ? {} : { label },
+			status: "running",
+			config: {},
+			requests: [],
+			startedAt: at,
+			live: false,
+			logFilled: false,
+			...callId === void 0 ? {} : { callId }
+		};
+		session.nextScopeSeq += 1;
+		turn.scopes.set(scopeId, scope);
+		return scope;
+	}
+	/** Every child scope of one session (the log lane iterates these). */
+	childScopes(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session === void 0) return [];
+		const out = [];
+		for (const turn of session.turns) for (const scope of turn.scopes.values()) if (scope.kind === "subagent" && !scope.scopeId.startsWith("call:")) out.push({
+			scopeId: scope.scopeId,
+			live: scope.live,
+			status: scope.status
+		});
+		return out;
+	}
+	/** The session's backfill watermark (retryable until 'complete'). */
+	backfillState(sessionId) {
+		return this.sessions.get(sessionId)?.backfillState ?? "none";
+	}
+	/** A durably unreadable log stops the backfill from retrying it on every query. */
+	markBackfillBroken(sessionId, reason) {
+		const session = this.session(sessionId);
+		session.backfillState = "broken";
+		session.backfillReason = reason;
+	}
+	/**
+	* Insert log-reconstructed turns (the pre-mount history), newest-first within
+	* budget: live-content turns win the budget outright, a host turn with any
+	* record is never merged into (the overlap rule), and one oversized turn is
+	* SKIPPED without aborting the older ones. Scope ordinals are renumbered
+	* afterwards so the chips' `#N` stay chronological across the live/backfill
+	* boundary (scopeSeq is a display anchor, not an address).
+	*
+	* The watermark is honest: 'complete' only when every candidate fit; a
+	* budget-dropped candidate keeps the state 'partial', and the service
+	* re-reads the log on later queries (eviction may have freed room). The
+	* insert itself never evicts a live turn: char pressure evicts the oldest
+	* BACKFILLED turns first.
+	*
+	* @returns the number of turns actually inserted.
+	*/
+	insertLogTurns(sessionId, logTurns) {
+		const session = this.session(sessionId);
+		session.lastAccess = this.now();
+		this.reconcileRequestNumbers(session, logTurns);
+		const hosts = logTurns.filter((turn) => turn.purpose === void 0).map((turn) => turn.hostTurn);
+		if (hosts.length > 0) session.logRange = {
+			first: Math.min(...hosts),
+			last: Math.max(...hosts)
+		};
+		for (const turn of logTurns) if (turn.purpose === void 0) session.turnSpans.set(turn.hostTurn, {
+			start: turn.startedAt,
+			...turn.endedAt === void 0 ? {} : { end: turn.endedAt }
+		});
+		for (const holder of logTurns.filter((turn) => turn.purpose === "room-members")) {
+			const target = this.holderTurn(session, holder.startedAt);
+			for (const delegation of holder.delegations) if (delegation.childId === void 0 || this.findScope(session, delegation.childId) === void 0) this.addDelegationScope(session, target, delegation);
+		}
+		let refreshed = 0;
+		if (session.logDriven && session.backfillState !== "broken") {
+			const materialized = this.windowOf(session, hosts);
+			for (const loaded of session.turns.filter((turn) => turn.purpose === void 0 && turn.hostTurn !== void 0)) {
+				const logged = logTurns.find((turn) => turn.purpose === void 0 && turn.hostTurn === loaded.hostTurn);
+				if (logged === void 0 || !materialized.has(logged.hostTurn)) continue;
+				if ((loaded.scopes.get("main")?.requests.length ?? 0) === logged.requests.length && loaded.endedAt === this.logTurnEnd(session, logged, logTurns)) continue;
+				this.evictTurn(session, loaded, false);
+				this.insertLogTurn(session, logged, logTurns);
+				refreshed += 1;
+			}
+			if (refreshed > 0) this.renumberScopes(session);
+		}
+		const dirty = session.logDirty === true;
+		session.logDirty = false;
+		if (session.backfillState === "broken" || session.backfillState === "complete" && !dirty) return refreshed;
+		const keep = this.windowOf(session, hosts);
+		const window = logTurns.filter((turn) => turn.purpose === void 0 && keep.has(turn.hostTurn));
+		if (window.length === 0) {
+			session.backfillState = "complete";
+			return 0;
+		}
+		const lo = Math.min(...window.map((turn) => turn.hostTurn)), hi = Math.max(...window.map((turn) => turn.hostTurn));
+		const startAt = window.find((turn) => turn.hostTurn === lo).startedAt;
+		const nextAfter = logTurns.filter((turn) => turn.purpose === void 0 && turn.hostTurn > hi).sort((x, y) => x.hostTurn - y.hostTurn)[0]?.startedAt ?? Number.POSITIVE_INFINITY;
+		const inWindow = (turn) => {
+			if (turn.purpose === "room-members") return false;
+			if (turn.purpose === void 0) return turn.hostTurn >= lo && turn.hostTurn <= hi;
+			const host = turn.requests[0]?.compaction?.hostTurn;
+			return host !== void 0 ? host >= lo && host <= hi : turn.startedAt >= startAt && turn.startedAt < nextAfter;
+		};
+		const candidates = logTurns.filter((logTurn) => inWindow(logTurn) && !session.turns.some((turn) => logTurn.purpose === void 0 ? turn.purpose === void 0 && turn.hostTurn === logTurn.hostTurn : [...turn.scopes.values()].some((scope) => scope.requests.some((request) => request.compaction?.id === logTurn.requests[0]?.compaction?.id))));
+		let dropped = 0;
+		let inserted = 0;
+		const stop = (i) => {
+			if (inserted === 0) {
+				dropped += 1;
+				return false;
+			}
+			dropped += i + 1;
+			return true;
+		};
+		for (let i = candidates.length - 1; i >= 0; i -= 1) {
+			const candidate = candidates[i];
+			const candidateChars = candidate.requests.reduce((n, request) => n + request.totalChars + executionSize(request) + responseSize(request.response), 0);
+			if (candidate.requests.length > this.maxBackfillRequestsPerSession - session.backfilledRequests) {
+				if (stop(i)) break;
+				continue;
+			}
+			if (this.totalChars + candidateChars > this.maxStoredCharsTotal) this.freeChars(session, candidateChars);
+			if (this.totalChars + candidateChars > this.maxStoredCharsTotal) {
+				if (stop(i)) break;
+				continue;
+			}
+			this.insertLogTurn(session, candidate, logTurns);
+			inserted += 1;
+		}
+		session.backfillState = dropped > 0 ? "partial" : "complete";
+		if (inserted > 0) this.renumberScopes(session);
+		return inserted;
+	}
+	/**
+	* The backfill window over a log's host turns: the newest
+	* `maxTurnsPerSession` at or before the window's end. At the latest, live
+	* turns the log does not hold yet take window slots too. The log lane
+	* materializes only these turns' requests.
+	*/
+	windowHosts(sessionId, hosts) {
+		return this.windowOf(this.session(sessionId), hosts);
+	}
+	windowOf(session, hosts) {
+		const end = session.windowEnd ?? Number.POSITIVE_INFINITY;
+		const logged = new Set(hosts);
+		const liveAhead = session.windowEnd === void 0 ? session.turns.filter((turn) => turn.liveContent && turn.hostTurn !== void 0 && !logged.has(turn.hostTurn)).length : 0;
+		return new Set([...logged].filter((host) => host <= end).sort((x, y) => y - x).slice(0, Math.max(0, this.maxTurnsPerSession - liveAhead)));
+	}
+	/**
+	* Make room for `needed` chars by evicting other sessions' backfilled
+	* turns, least recently read session first, oldest turn first. Live
+	* content never yields. A session that lost backfill re-reads it when next
+	* read (its state drops back to partial).
+	*/
+	freeChars(current, needed) {
+		const others = [...this.sessions.values()].filter((other) => other !== current).sort((x, y) => x.lastAccess - y.lastAccess);
+		for (const other of others) {
+			const victims = other.turns.filter((turn) => !turn.liveContent && !this.turnIsLive(turn)).sort((x, y) => x.startedAt - y.startedAt);
+			for (const victim of victims) {
+				if (this.totalChars + needed <= this.maxStoredCharsTotal) return;
+				this.evictTurn(other, victim, false);
+				if (other.backfillState === "complete") other.backfillState = "partial";
+			}
+		}
+	}
+	/**
+	* Move a session's backfill window: drop its backfilled turns (live turns
+	* stay) and let the next read refill the window ending at `end` (the
+	* latest turns when absent).
+	*/
+	setWindow(sessionId, end) {
+		const session = this.session(sessionId);
+		if (end === void 0) delete session.windowEnd;
+		else session.windowEnd = end;
+		for (const turn of [...session.turns]) if (!turn.liveContent && !this.turnIsLive(turn)) this.evictTurn(session, turn, false);
+		if (session.backfillState !== "broken") session.backfillState = "none";
+	}
+	/** A complete log can anchor live turns without retaining old request bodies. */
+	reconcileRequestNumbers(session, logTurns) {
+		for (const logged of logTurns) {
+			if (logged.purpose !== void 0) continue;
+			const live = session.turns.find((t) => t.hostTurn === logged.hostTurn && t.purpose === void 0 && t.liveStartObserved);
+			const first = logged.requests[0]?.requestNumber;
+			if (!live || first === void 0) continue;
+			const requests = live.scopes.get("main")?.requests ?? [];
+			for (let i = 0; i < requests.length; i++) requests[i].requestNumber ??= first + i;
+		}
+		const liveRequests = session.turns.filter((t) => t.liveContent && t.purpose === void 0).sort((a, b) => a.startedAt - b.startedAt || a.turnSeq - b.turnSeq).flatMap((t) => t.scopes.get("main")?.requests ?? []);
+		if (liveRequests.length && liveRequests.at(-1)?.requestNumber === void 0) return;
+		let next = session.nextRequestNumbers.get("main");
+		for (const r of [...logTurns.flatMap((t) => t.requests), ...liveRequests]) if (r.requestNumber !== void 0) next = Math.max(next ?? 1, r.requestNumber + 1);
+		if (next !== void 0) session.nextRequestNumbers.set("main", next);
+	}
+	/** Retry numbering after a streaming turn’s first durable response becomes available. */
+	/**
+	* Make a session log-driven: an external agent's session opened on its own
+	* (a CLI in its own process, so no request passes through this host). Its
+	* turns come from its log only; the live turns opened so far held nothing
+	* and give way to the log's.
+	*/
+	markLogDriven(sessionId) {
+		const session = this.session(sessionId);
+		if (session.logDriven) return;
+		session.logDriven = true;
+		session.logDirty = true;
+		for (const turn of [...session.turns]) {
+			if (turn.purpose !== void 0 || !turn.liveContent) continue;
+			if ([...turn.scopes.values()].some((scope) => scope.requests.length > 0)) continue;
+			if (session.openTurn === turn) session.openTurn = void 0;
+			this.evictTurn(session, turn, false);
+		}
+	}
+	/** Any live event of a log-driven session: the next read re-reads its log. */
+	noteLogActivity(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session?.logDriven) session.logDirty = true;
+	}
+	/** Whether a read should re-read a log-driven session's log. */
+	needsLogRead(sessionId) {
+		return this.sessions.get(sessionId)?.logDirty === true;
+	}
+	/** A log turn's end as the store records it: still open when it is a log-driven session's last turn. */
+	logTurnEnd(session, logTurn, logTurns) {
+		if (this.logTurnOpen(session, logTurn, logTurns)) return void 0;
+		const lastSettled = logTurn.requests.reduce((latest, request) => request.settledAt !== void 0 && (latest === void 0 || request.settledAt > latest) ? request.settledAt : latest, void 0);
+		return logTurn.endedAt ?? lastSettled ?? logTurn.startedAt;
+	}
+	logTurnOpen(session, logTurn, logTurns) {
+		if (!session.logDriven || logTurn.endReasonKind !== void 0 || logTurn.purpose !== void 0) return false;
+		return !logTurns.some((turn) => turn.purpose === void 0 && turn.hostTurn > logTurn.hostTurn);
+	}
+	needsRequestNumbers(sessionId) {
+		return this.sessions.get(sessionId)?.turns.some((t) => t.liveStartObserved && (t.scopes.get("main")?.requests.some((r) => r.purpose === void 0 && r.requestNumber === void 0) ?? false)) ?? false;
+	}
+	/** One reconstructed turn → one TurnRecord (main scope + delegation stubs). */
+	insertLogTurn(session, logTurn, logTurns = []) {
+		const turn = this.mintTurn(session, logTurn.startedAt, {
+			...logTurn.purpose === void 0 ? { hostTurn: logTurn.hostTurn } : { purpose: logTurn.purpose },
+			turnSeq: logTurn.purpose === void 0 ? logTurn.hostTurn : session.nextBucketSeq--,
+			query: logTurn.query
+		});
+		if (logTurn.trigger !== void 0) turn.trigger = logTurn.trigger;
+		if (logTurn.startSeq !== void 0) turn.startSeq = logTurn.startSeq;
+		if (logTurn.closingMessageId !== void 0) turn.closingMessageId = logTurn.closingMessageId;
+		const open = this.logTurnOpen(session, logTurn, logTurns);
+		const end = this.logTurnEnd(session, logTurn, logTurns);
+		if (end !== void 0) turn.endedAt = end;
+		const mainStatus = open ? "running" : logTurn.endReasonKind === "completed" || logTurn.endReasonKind === "max-tokens" ? "ok" : "failed";
+		const main = {
+			scopeId: "main",
+			scopeSeq: 0,
+			kind: "main",
+			status: mainStatus,
+			config: logTurn.requests[0]?.config ?? {},
+			requests: [],
+			startedAt: logTurn.startedAt,
+			...turn.endedAt === void 0 ? {} : { endedAt: turn.endedAt },
+			live: false,
+			logFilled: true
+		};
+		if (mainStatus === "failed") main.error = logTurn.endReasonKind === void 0 ? "interrupted (no turn/end in the log)" : logTurn.endError ?? logTurn.endReasonKind;
+		turn.scopes.set("main", main);
+		for (const built of logTurn.requests) {
+			const request = {
+				...built,
+				seq: this.seqCounter,
+				sessionId: session.id,
+				scopeId: "main",
+				turnSeq: turn.turnSeq
+			};
+			this.seqCounter += 1;
+			main.requests.push(request);
+			this.totalChars += request.totalChars;
+			session.backfilledRequests += 1;
+			this.attachResponse(request, built.response);
+			this.accountExecutionResults(request);
+		}
+		for (const delegation of logTurn.delegations) this.addDelegationScope(session, turn, delegation);
+	}
+	/** One reconstructed delegation → its child scope on `turn`. */
+	addDelegationScope(session, turn, delegation) {
+		const scopeId = delegation.childId ?? `call:${delegation.callId}`;
+		if (delegation.childId !== void 0) this.childToParent.set(delegation.childId, session.id);
+		const label = delegation.catalogLabel ?? delegation.label;
+		const scope = {
+			scopeId,
+			scopeSeq: 0,
+			kind: "subagent",
+			...label === void 0 ? {} : { label },
+			status: delegation.callId === "" ? "ok" : delegation.isError === true || delegation.resultAt === void 0 ? "failed" : "ok",
+			...delegation.isError === true && delegation.errorPreview !== void 0 ? { error: delegation.errorPreview } : delegation.resultAt === void 0 && delegation.callId !== "" ? { error: "no tool/result in the log" } : {},
+			config: {},
+			requests: [],
+			startedAt: delegation.at,
+			...delegation.resultAt === void 0 ? {} : { endedAt: delegation.resultAt },
+			live: false,
+			logFilled: false,
+			...delegation.callId === "" ? {} : { callId: delegation.callId }
+		};
+		turn.scopes.set(scopeId, scope);
+	}
+	/** The hidden turn holding children started outside any turn (never listed; room rounds read it). */
+	holderTurn(session, at) {
+		const found = session.turns.find((turn) => turn.purpose === "room-members");
+		if (found !== void 0) return found;
+		const turn = this.mintTurn(session, at, {
+			purpose: "room-members",
+			query: "",
+			turnSeq: session.nextBucketSeq
+		});
+		session.nextBucketSeq -= 1;
+		return turn;
+	}
+	/** Renumber one session's scope ordinals chronologically (turn order, then creation order). */
+	renumberScopes(session) {
+		let next = 1;
+		const ordered = [...session.turns].sort((a, b) => a.startedAt - b.startedAt || a.turnSeq - b.turnSeq);
+		for (const turn of ordered) for (const scope of turn.scopes.values()) {
+			scope.scopeSeq = next;
+			next += 1;
+		}
+	}
+	/**
+	* Light turn list of one session plus its backfill watermark (sorted newest
+	* last). A {@link ScopeFilter} restricts every aggregate to the authorized
+	* scopes; the turn rows themselves (query preview, timestamps) are
+	* session-level metadata and stay listed.
+	*/
+	listTurns(sessionId, filter) {
+		const session = this.sessions.get(sessionId);
+		if (session !== void 0) session.lastAccess = this.now();
+		const backfill = session === void 0 ? { state: "none" } : {
+			state: session.backfillState,
+			...session.backfillReason === void 0 ? {} : { reason: session.backfillReason }
+		};
+		if (session === void 0) return {
+			turns: [],
+			backfill,
+			generation: this.generation,
+			...this.parents.has(sessionId) ? { parent: this.parents.get(sessionId) } : {}
+		};
+		const ordinals = this.ordinals(session);
+		const listed = [...session.turns, ...this.roomTurns(session, filter)].filter((turn) => turn.purpose !== "room-members" && this.attachedTurn(session, turn) === void 0).sort((a, b) => a.startedAt - b.startedAt || a.turnSeq - b.turnSeq);
+		const handoffs = (session.room?.handoffs ?? []).map((h) => ({
+			at: h.at,
+			name: session.room.members.get(h.memberId) ?? h.memberId
+		}));
+		const decisions = scopeAuthorized("main", filter) ? this.decisionsByTurn(session, filter) : /* @__PURE__ */ new Map();
+		return {
+			turns: listed.map((turn) => {
+				const held = decisions.get(turn.turnSeq);
+				const item = {
+					...this.turnItem(sessionId, turn, filter),
+					...held === void 0 ? {} : { roomDecisionIds: held.map((row) => row.id) }
+				};
+				const ordinal = ordinals.get(turn.hostTurn !== void 0 ? `h${turn.hostTurn}` : `t${turn.turnSeq}`);
+				return ordinal === void 0 ? item : {
+					...item,
+					ordinal
+				};
+			}),
+			backfill,
+			total: ordinals.size,
+			unloaded: this.unloadedRuns(session, ordinals),
+			...handoffs.length === 0 ? {} : { handoffs },
+			generation: this.generation,
+			...this.parents.has(sessionId) ? { parent: this.parents.get(sessionId) } : {},
+			...session.logRange === void 0 ? {} : { range: session.logRange },
+			...session.evictedTurns === 0 ? {} : { evictedTurnCount: session.evictedTurns },
+			...filter?.scopes === void 0 ? {} : { authorizedScopes: this.authorizedScopes(session, filter) }
+		};
+	}
+	/** The session's existing scopes that pass the filter (turn order, then creation order). */
+	authorizedScopes(session, filter) {
+		const allowed = new Set(filter.scopes);
+		const out = [];
+		for (const turn of [...session.turns].sort((a, b) => a.startedAt - b.startedAt || a.turnSeq - b.turnSeq)) for (const scope of turn.scopes.values()) if (allowed.has(scope.scopeId) && !out.includes(scope.scopeId)) out.push(scope.scopeId);
+		return out;
+	}
+	turnItem(sessionId, turn, filter) {
+		let requestCount = 0;
+		let scopeCount = 0;
+		let failedScopeCount = 0;
+		let totalInputTokens = 0;
+		let totalOutputTokens = 0;
+		for (const scope of turn.scopes.values()) {
+			if (!scopeAuthorized(scope.scopeId, filter)) continue;
+			scopeCount += 1;
+			requestCount += scope.requests.length;
+			if (scope.status === "failed") failedScopeCount += 1;
+			for (const request of scope.requests) {
+				totalInputTokens += (request.usage?.inputTokens ?? 0) + (request.usage?.cacheReadTokens ?? 0) + (request.usage?.cacheWriteTokens ?? 0);
+				totalOutputTokens += request.usage?.outputTokens ?? 0;
+			}
+		}
+		return {
+			sessionId,
+			turnSeq: turn.turnSeq,
+			...turn.hostTurn === void 0 ? {} : { hostTurn: turn.hostTurn },
+			query: turn.query,
+			...turn.query === "" && turn.trigger !== void 0 ? { trigger: turn.trigger } : {},
+			...turn.room === void 0 ? {} : { room: turn.room },
+			...turn.startSeq === void 0 ? {} : { startSeq: turn.startSeq },
+			startedAt: turn.startedAt,
+			...turn.endedAt === void 0 ? {} : { endedAt: turn.endedAt },
+			requestCount,
+			scopeCount,
+			failedScopeCount,
+			totalInputTokens,
+			totalOutputTokens,
+			origin: turn.liveContent ? "live" : "log-reconstructed",
+			...turn.closingMessageId === void 0 ? {} : { closingMessageId: turn.closingMessageId }
+		};
+	}
+	/** One turn's scope/request overview, without segments. */
+	getTurn(sessionId, turnSeq, filter) {
+		const session = this.sessions.get(sessionId);
+		if (session !== void 0) session.lastAccess = this.now();
+		const turn = session === void 0 ? void 0 : this.findTurn(session, turnSeq, filter);
+		if (session === void 0 || turn === void 0) return void 0;
+		const item = this.turnItem(sessionId, turn, filter);
+		const scopes = [...turn.scopes.values()].filter((scope) => scopeAuthorized(scope.scopeId, filter)).map((scope) => this.scopeOverview(session, turn, scope));
+		if (turn.hostTurn !== void 0 && scopeAuthorized("main", filter)) for (const pseudo of session.turns) {
+			if (this.attachedTurn(session, pseudo) !== turn) continue;
+			for (const scope of pseudo.scopes.values()) scopes.push(this.scopeOverview(session, pseudo, scope));
+		}
+		const roomDecisions = scopeAuthorized("main", filter) ? this.decisionsByTurn(session, filter).get(turn.turnSeq) : void 0;
+		return {
+			turn: item,
+			scopes,
+			...roomDecisions === void 0 ? {} : { roomDecisions },
+			generation: this.generation,
+			...filter?.scopes === void 0 ? {} : { authorizedScopes: scopes.map((scope) => scope.scopeId) }
+		};
+	}
+	/**
+	* The room's decision-model calls by the turn they happened in: each goes to
+	* the latest listed turn (main turn or room round) that started at or
+	* before it.
+	*/
+	decisionsByTurn(session, filter) {
+		const byTurn = /* @__PURE__ */ new Map();
+		const decisions = session.room?.decisions ?? [];
+		if (decisions.length === 0) return byTurn;
+		const listed = [...session.turns, ...this.roomTurns(session, filter)].filter((turn) => turn.purpose !== "room-members" && this.attachedTurn(session, turn) === void 0).sort((a, b) => a.startedAt - b.startedAt || a.turnSeq - b.turnSeq);
+		for (const decision of decisions) {
+			const owner = listed.findLast((turn) => turn.startedAt <= decision.at);
+			if (owner === void 0) continue;
+			const rows = byTurn.get(owner.turnSeq) ?? [];
+			rows.push(decision);
+			byTurn.set(owner.turnSeq, rows);
+		}
+		return byTurn;
+	}
+	/** Record one `room/*` event of a main session (log backfill or live). */
+	noteRoomEvent(sessionId, type, data, seq, at) {
+		if (this.isChild(sessionId) || !type.startsWith("room/")) return;
+		const session = this.session(sessionId);
+		session.room ??= emptyRoom();
+		applyRoomEvent(session.room, type, data, seq, at);
+	}
+	/** A listed turn or a room round, by its panel address. */
+	findTurn(session, turnSeq, filter) {
+		return session.turns.find((candidate) => candidate.turnSeq === turnSeq) ?? (turnSeq < -999999 ? this.roomTurns(session, filter).find((candidate) => candidate.turnSeq === turnSeq) : void 0);
+	}
+	/** Whether a moment falls inside some main turn (loaded or not). */
+	insideMainTurn(session, at) {
+		for (const span of session.turnSpans.values()) if (at >= span.start && at <= (span.end ?? Number.POSITIVE_INFINITY)) return true;
+		return false;
+	}
+	/**
+	* Every human room dispatch made outside a main turn, as a round: the
+	* dispatch's message, and per member run the child session's requests of
+	* that run (its recorded child turn, else the run's time span). Built on
+	* read from the room state and the children's scopes; nothing is stored.
+	*/
+	roomTurns(session, filter) {
+		const room = session.room;
+		if (room === void 0) return [];
+		return room.dispatches.filter((dispatch) => !this.insideMainTurn(session, dispatch.at)).map((dispatch) => {
+			const scopes = /* @__PURE__ */ new Map();
+			const runs = runsOf(room, dispatch.seq);
+			for (const run of runs) {
+				const child = this.childOfRun(session, run);
+				if (child !== void 0 && !scopeAuthorized(child.scopeId, filter)) continue;
+				const scopeId = child?.scopeId ?? `room:${dispatch.seq}:${run.memberId}`;
+				const from = (run.startedAt ?? dispatch.at) - 2e3, to = (run.endedAt ?? this.now()) + 2e3;
+				const requests = (child?.requests ?? []).filter((request) => run.childTurn !== void 0 && request.hostTurn !== void 0 ? request.hostTurn === run.childTurn : request.startedAt >= from && request.startedAt <= to);
+				scopes.set(scopeId, {
+					scopeId,
+					scopeSeq: child?.scopeSeq ?? 0,
+					kind: "subagent",
+					label: run.member ?? room.members.get(run.memberId) ?? child?.label ?? run.memberId,
+					...child?.provider === void 0 ? {} : { provider: child.provider },
+					status: run.state === "failed" ? "failed" : run.state === "done" ? "ok" : "running",
+					config: child?.config ?? {},
+					requests,
+					startedAt: run.startedAt ?? dispatch.at,
+					...run.endedAt === void 0 ? {} : { endedAt: run.endedAt },
+					live: false,
+					logFilled: true
+				});
+			}
+			const ends = runs.map((run) => run.endedAt).filter((end) => end !== void 0);
+			return {
+				turnSeq: roomTurnSeq(dispatch.seq),
+				purpose: "room",
+				query: dispatch.text,
+				room: { targets: dispatch.targets },
+				startedAt: dispatch.at,
+				...ends.length === 0 ? {} : { endedAt: Math.max(...ends) },
+				liveContent: false,
+				scopes
+			};
+		});
+	}
+	/** The child session a run went to: named by the run, else the child catalogued closest to the run's start. */
+	childOfRun(session, run) {
+		if (run.childSessionId !== void 0) {
+			const named = this.findScope(session, run.childSessionId)?.scope;
+			if (named !== void 0) return named;
+		}
+		if (run.startedAt === void 0) return void 0;
+		let best;
+		for (const turn of session.turns) for (const scope of turn.scopes.values()) {
+			if (scope.kind !== "subagent" || Math.abs(scope.startedAt - run.startedAt) > 1e4) continue;
+			if (best === void 0 || Math.abs(scope.startedAt - run.startedAt) < Math.abs(best.startedAt - run.startedAt)) best = scope;
+		}
+		return best;
+	}
+	/**
+	* One numbering for the whole session, by time: every main turn (loaded or
+	* not) and every room round. Keys: `h<hostTurn>` for main turns,
+	* `t<turnSeq>` for room rounds.
+	*/
+	ordinals(session) {
+		const units = [];
+		const hosts = /* @__PURE__ */ new Set();
+		for (const [host, span] of session.turnSpans) {
+			units.push({
+				key: `h${host}`,
+				at: span.start,
+				host
+			});
+			hosts.add(host);
+		}
+		for (const turn of session.turns) if (turn.hostTurn !== void 0 && !hosts.has(turn.hostTurn)) units.push({
+			key: `h${turn.hostTurn}`,
+			at: turn.startedAt,
+			host: turn.hostTurn
+		});
+		for (const round of this.roomTurns(session)) units.push({
+			key: `t${round.turnSeq}`,
+			at: round.startedAt,
+			host: Number.POSITIVE_INFINITY
+		});
+		units.sort((a, b) => a.at - b.at || a.host - b.host);
+		return new Map(units.map((unit, i) => [unit.key, i + 1]));
+	}
+	/** Runs of main turns the log holds but the store has not loaded, in ordinals, with their host-turn ends. */
+	unloadedRuns(session, ordinals) {
+		const loaded = new Set(session.turns.filter((turn) => turn.hostTurn !== void 0).map((turn) => turn.hostTurn));
+		const missing = [...session.turnSpans.keys()].filter((host) => !loaded.has(host)).map((host) => ({
+			host,
+			ordinal: ordinals.get(`h${host}`)
+		})).sort((a, b) => a.ordinal - b.ordinal);
+		const out = [];
+		for (const { host, ordinal } of missing) {
+			const last = out.at(-1);
+			if (last !== void 0 && last.to === ordinal - 1) {
+				last.to = ordinal;
+				last.lastHost = host;
+			} else out.push({
+				from: ordinal,
+				to: ordinal,
+				firstHost: host,
+				lastHost: host
+			});
+		}
+		return out;
+	}
+	/** A compaction pseudo-turn's host turn: the one it started in, else the next turn to begin; undefined for any other turn. */
+	attachedTurn(session, turn) {
+		if (turn.purpose !== "compaction") return void 0;
+		const real = session.turns.filter((t) => t.hostTurn !== void 0).sort((a, b) => a.startedAt - b.startedAt);
+		const hostTurn = [...turn.scopes.values()].flatMap((scope) => scope.requests).find((r) => r.compaction?.hostTurn !== void 0)?.compaction?.hostTurn;
+		return (hostTurn === void 0 ? void 0 : real.find((t) => t.hostTurn === hostTurn)) ?? real.find((t) => t.startedAt >= turn.startedAt) ?? real.at(-1);
+	}
+	/** Where the panel addresses a request: compaction requests live in their host turn's `compaction:` view. */
+	addressOf(session, request) {
+		const pseudo = session.turns.find((t) => t.turnSeq === request.turnSeq);
+		const host = pseudo === void 0 ? void 0 : this.attachedTurn(session, pseudo);
+		return {
+			turnSeq: host?.turnSeq ?? request.turnSeq,
+			scopeId: host === void 0 ? request.scopeId : `compaction:${request.turnSeq}`,
+			seq: request.seq,
+			...request.requestNumber === void 0 ? {} : { requestNumber: request.requestNumber }
+		};
+	}
+	scopeOverview(session, turn, scope) {
+		const origin = scopeOrigin(scope);
+		const host = this.attachedTurn(session, turn);
+		const scopeId = host === void 0 ? scope.scopeId : `compaction:${turn.turnSeq}`;
+		const main = turn.scopes.get("main");
+		const delegator = scope.callId === void 0 ? void 0 : main?.requests.find((r) => r.response?.toolCalls.some((call) => call.callId === scope.callId));
+		const compaction = host === void 0 ? void 0 : scope.requests.find((r) => r.compaction !== void 0)?.compaction;
+		const after = host === void 0 ? void 0 : host.scopes.get("main")?.requests.filter((r) => r.startedAt <= turn.startedAt).sort((a, b) => b.startedAt - a.startedAt)[0];
+		return {
+			scopeId,
+			scopeSeq: scope.scopeSeq,
+			kind: host !== void 0 ? "compaction" : scope.kind,
+			...scope.label === void 0 ? {} : { label: scope.label },
+			...scope.provider === void 0 ? {} : { provider: scope.provider },
+			...delegator === void 0 ? {} : { delegatedBy: this.addressOf(session, delegator) },
+			...compaction === void 0 ? {} : { compaction: {
+				...compaction.replacedCount === void 0 ? {} : { replacedCount: compaction.replacedCount },
+				...after === void 0 ? {} : { after: this.addressOf(session, after) },
+				...compaction.hostTurn === void 0 ? { betweenTurns: true } : {}
+			} },
+			status: scope.status,
+			...scope.error === void 0 ? {} : { error: scope.error },
+			config: scope.config,
+			startedAt: scope.startedAt,
+			...scope.endedAt === void 0 ? {} : { endedAt: scope.endedAt },
+			...origin === void 0 ? {} : { origin },
+			requests: scope.requests.map((request) => ({
+				seq: request.seq,
+				...request.requestNumber === void 0 ? {} : { requestNumber: request.requestNumber },
+				scopeId,
+				status: request.status,
+				config: request.config,
+				responseSummary: request.responseSummary,
+				startedAt: request.startedAt,
+				...request.usage === void 0 ? {} : { usage: request.usage },
+				...request.settledAt === void 0 ? {} : { totalMs: request.settledAt - request.startedAt },
+				...request.compaction?.inputPartial ? { timingApproximate: true } : {},
+				totalChars: request.totalChars,
+				toolErrors: request.execs.filter((exec) => exec.isError).length
+			}))
+		};
+	}
+	/** Record the child's provider from its `subagent/descriptor` (live child events or its log). */
+	noteChildProvider(childId, provider) {
+		const root = this.childToParent.get(childId);
+		const session = root === void 0 ? void 0 : this.sessions.get(root);
+		const found = session === void 0 ? void 0 : this.findScope(session, childId);
+		if (found !== void 0) found.scope.provider = provider;
+	}
+	/** A session opened on its own that is some other session's child. */
+	noteParent(sessionId, parent) {
+		this.parents.set(sessionId, parent);
+	}
+	/** Whether a child's parent link is already known (the service resolves it once). */
+	hasParent(sessionId) {
+		return this.parents.has(sessionId);
+	}
+	/**
+	* One request's full four-segment breakdown. A request whose scope the
+	* filter excludes answers with a {@link ScopedRefusal} — distinguishable
+	* from `undefined` (no such seq on this instance).
+	*/
+	getRequest(sessionId, seq, filter) {
+		const session = this.sessions.get(sessionId);
+		if (session === void 0) return void 0;
+		for (const turn of session.turns) for (const scope of turn.scopes.values()) {
+			const request = scope.requests.find((candidate) => candidate.seq === seq);
+			if (request === void 0) continue;
+			if (!scopeAuthorized(scope.scopeId, filter)) return {
+				refused: "no-authorized-content",
+				generation: this.generation
+			};
+			const previous = session.turns.flatMap((t) => [...t.scopes.values()]).filter((s) => s.scopeId === scope.scopeId).flatMap((s) => s.requests).filter((r) => r.purpose === request.purpose && (r.startedAt < request.startedAt || r.startedAt === request.startedAt && r.seq < request.seq)).sort((a, b) => b.startedAt - a.startedAt || b.seq - a.seq)[0];
+			return {
+				...this.requestView(request),
+				...previous === void 0 || request.compaction?.inputPartial || previous.compaction?.inputPartial ? {} : { prefix: this.withLinks(session, request, previous, comparePrefix(previous, request, factLookup(session))) }
+			};
+		}
+	}
+	/** Resolve change entries to retained requests: the compaction call, and the request that still held un-pruned text. */
+	withLinks(session, request, previous, prefix) {
+		if (prefix.changes === void 0) return prefix;
+		const link = (r) => this.addressOf(session, r);
+		const retained = session.turns.flatMap((turn) => [...turn.scopes.values()]).flatMap((scope) => scope.requests);
+		return {
+			...prefix,
+			changes: prefix.changes.map((change) => {
+				if (change.kind === "compaction" && change.compactionId !== void 0) {
+					const target = retained.find((r) => r.compaction?.id === change.compactionId && r.seq !== request.seq);
+					return target === void 0 ? change : {
+						...change,
+						compactionRequest: link(target)
+					};
+				}
+				return change.kind === "prune" ? {
+					...change,
+					pruneBefore: link(previous)
+				} : change;
+			})
+		};
+	}
+	previousRequest(session, scopeId, at, seq) {
+		return session.turns.flatMap((turn) => turn.scopes.get(scopeId)?.requests ?? []).filter((r) => r.purpose === void 0 && (r.startedAt < at || r.startedAt === at && r.seq < seq)).sort((a, b) => b.startedAt - a.startedAt || b.seq - a.seq)[0];
+	}
+	requestView(request) {
+		const session = this.sessions.get(request.sessionId);
+		const baseline = request.needsHistoryBaseline && session !== void 0 ? this.previousRequest(session, request.scopeId, request.startedAt, request.seq) : void 0;
+		const segments = baseline === void 0 ? request.segments : rebaseSegments(request.segments, request.fingerprint, baseline.fingerprint);
+		const owners = /* @__PURE__ */ new Map();
+		for (const turn of this.sessions.get(request.sessionId)?.turns ?? []) for (const r of turn.scopes.get(request.scopeId)?.requests ?? []) if (r.requestNumber !== void 0) {
+			for (const c of r.response?.toolCalls ?? []) if (c.callId !== void 0) owners.set(c.callId, r.requestNumber);
+		}
+		const retained = (this.sessions.get(request.sessionId)?.turns ?? []).flatMap((turn) => turn.scopes.get(request.scopeId)?.requests ?? []);
+		const link = (r) => session === void 0 ? {
+			turnSeq: r.turnSeq,
+			scopeId: r.scopeId,
+			seq: r.seq
+		} : this.addressOf(session, r);
+		const before = retained.filter((r) => r.purpose === void 0 && r.startedAt < request.startedAt).sort((a, b) => b.startedAt - a.startedAt)[0];
+		const provenance = (items) => items.map((item) => {
+			const number = item.toolCallId === void 0 ? void 0 : owners.get(item.toolCallId);
+			const compression = item.compactionId === void 0 ? void 0 : retained.find((r) => r.compaction?.id === item.compactionId);
+			const original = item.pruning === void 0 ? void 0 : retained.filter((r) => r.startedAt < request.startedAt && [...r.segments.history, ...r.segments.added].some((old) => old.messageId === item.messageId && !old.pruning)).sort((a, b) => b.startedAt - a.startedAt)[0];
+			return {
+				...item,
+				...number === void 0 ? {} : { sourceRequestNumber: number },
+				...compression === void 0 ? {} : { compactionRequest: link(compression) },
+				...item.pruning === void 0 ? {} : { pruning: {
+					...item.pruning,
+					...original === void 0 ? {} : { before: link(original) }
+				} }
+			};
+		});
+		const response = request.response && {
+			...request.response,
+			toolCalls: request.response.toolCalls.map((call) => {
+				const exec = call.callId === void 0 ? void 0 : request.execs.find((e) => e.callId === call.callId);
+				return exec === void 0 ? call : {
+					...call,
+					execution: {
+						status: exec.isError === true ? "failed" : exec.end !== void 0 || exec.isError === false ? "ok" : "running",
+						...exec.result === void 0 ? {} : { result: exec.result }
+					}
+				};
+			})
+		};
+		return {
+			seq: request.seq,
+			...request.requestNumber === void 0 ? {} : { requestNumber: request.requestNumber },
+			scopeId: session === void 0 ? request.scopeId : this.addressOf(session, request).scopeId,
+			sessionId: request.sessionId,
+			...request.purpose === void 0 ? {} : { purpose: request.purpose },
+			...request.compaction === void 0 ? {} : { compaction: {
+				...request.compaction,
+				...before === void 0 ? {} : { before: link(before) }
+			} },
+			startedAt: request.startedAt,
+			status: request.status,
+			...request.error === void 0 ? {} : { error: request.error },
+			config: request.config,
+			...request.usage === void 0 ? {} : { usage: request.usage },
+			timing: requestTiming(request),
+			generation: this.generation,
+			responseSummary: request.responseSummary,
+			...response === void 0 ? {} : { response },
+			segments: {
+				...segments,
+				history: provenance(segments.history),
+				added: provenance(segments.added)
+			}
+		};
+	}
+	/** One turn's whole-turn timing aggregation, filtered to the authorized scopes. */
+	getTurnTiming(sessionId, turnSeq, filter) {
+		const session = this.sessions.get(sessionId);
+		const turn = session === void 0 ? void 0 : this.findTurn(session, turnSeq, filter);
+		if (session === void 0 || turn === void 0) return void 0;
+		const lanes = [];
+		const tools = /* @__PURE__ */ new Map();
+		for (const scope of turn.scopes.values()) {
+			if (!scopeAuthorized(scope.scopeId, filter)) continue;
+			for (const request of scope.requests) {
+				lanes.push(...requestLanes(request));
+				for (const exec of request.execs) {
+					if (exec.end === void 0) continue;
+					lanes.push({
+						kind: "tool-exec",
+						requestSeq: request.seq,
+						scopeId: request.scopeId,
+						startedAt: exec.start,
+						durationMs: exec.end - exec.start,
+						tool: exec.name,
+						callId: exec.callId,
+						...exec.isError === void 0 ? {} : { isError: exec.isError }
+					});
+					const argsMs = request.blocks.filter((block) => block.callId === exec.callId && block.end !== void 0).reduce((n, block) => n + (block.end - block.start), 0);
+					const aggregate = tools.get(exec.name) ?? {
+						tool: exec.name,
+						calls: 0,
+						totalMs: 0,
+						argsMs: 0
+					};
+					aggregate.calls += 1;
+					aggregate.totalMs += exec.end - exec.start;
+					aggregate.argsMs += argsMs;
+					tools.set(exec.name, aggregate);
+				}
+			}
+		}
+		lanes.sort((a, b) => a.startedAt - b.startedAt || a.requestSeq - b.requestSeq);
+		const sum = (kind) => lanes.filter((lane) => lane.kind === kind).reduce((n, lane) => n + lane.durationMs, 0);
+		const endedAt = turn.endedAt ?? this.now();
+		return {
+			turnSeq: turn.turnSeq,
+			startedAt: turn.startedAt,
+			totalMs: Math.max(0, endedAt - turn.startedAt),
+			buckets: {
+				waitMs: sum("wait"),
+				reasoningMs: sum("reasoning"),
+				toolArgsMs: sum("tool-args"),
+				textMs: sum("text"),
+				toolExecMs: sum("tool-exec"),
+				otherMs: sum("other")
+			},
+			lanes,
+			tools: [...tools.values()].sort((a, b) => b.totalMs - a.totalMs),
+			generation: this.generation,
+			...filter?.scopes === void 0 ? {} : { authorizedScopes: [...turn.scopes.values()].filter((scope) => scopeAuthorized(scope.scopeId, filter)).map((scope) => scope.scopeId) }
+		};
+	}
+	/** Session request headers only; excluded scopes contribute no rows or aggregates. */
+	getSessionTrend(sessionId, filter) {
+		const list = this.listTurns(sessionId, filter);
+		return {
+			...list,
+			requests: list.turns.flatMap((turn) => (this.getTurn(sessionId, turn.turnSeq, filter)?.scopes ?? []).flatMap((scope) => scope.requests.map((request) => ({
+				...request,
+				turnSeq: turn.turnSeq
+			}))))
+		};
+	}
+	/** Release every session buffer (plugin dispose). */
+	dispose() {
+		const sessionIds = [...this.sessions.keys()];
+		for (const sessionId of sessionIds) {
+			const session = this.sessions.get(sessionId);
+			if (session === void 0) continue;
+			for (const turn of [...session.turns]) this.evictTurn(session, turn);
+		}
+		this.sessions.clear();
+		this.childToParent.clear();
+		this.callOwners.clear();
+		this.callNames.clear();
+		this.totalChars = 0;
+	}
+	/** @param counted - false for a window move or cross-session room, which the "collected then dropped" signal does not report. */
+	evictTurn(session, turn, counted = true) {
+		session.turns = session.turns.filter((candidate) => candidate !== turn);
+		if (counted) session.evictedTurns += 1;
+		for (const [purpose, bucket] of session.buckets) if (bucket === turn) session.buckets.delete(purpose);
+		if (session.openTurn === turn) session.openTurn = void 0;
+		for (const scope of turn.scopes.values()) {
+			for (const request of scope.requests) {
+				for (const block of request.blocks) if (block.callId !== void 0) {
+					this.callOwners.delete(block.callId);
+					this.callNames.delete(block.callId);
+				}
+				this.totalChars -= request.totalChars + (request.responseChars ?? 0) + (request.executionChars ?? 0);
+			}
+			if (scope.kind === "subagent") session.nextRequestNumbers.delete(scope.scopeId);
+			if (!turn.liveContent && scope.kind === "main") session.backfilledRequests -= scope.requests.length;
+		}
+		const end = turn.endedAt ?? this.now();
+		for (const [callId, pending] of session.pendingCalls) if (pending.at >= turn.startedAt && pending.at <= end) session.pendingCalls.delete(callId);
+		this.onTurnEvicted?.(session.id, turn);
+		if (session.turns.length === 0 && counted) {
+			this.sessions.delete(session.id);
+			for (const [childId, parentId] of this.childToParent) if (parentId === session.id) this.childToParent.delete(childId);
+		}
+	}
+	turnIsLive(turn) {
+		if (turn.endedAt === void 0 && turn.purpose === void 0) return true;
+		for (const scope of turn.scopes.values()) if (scope.requests.some((request) => request.status === "streaming")) return true;
+		return false;
+	}
+	/** The globally oldest closed backfilled turn (char-pressure eviction order). */
+	oldestBackfilledTurn() {
+		let victim;
+		for (const session of this.sessions.values()) for (const turn of session.turns) {
+			if (turn.liveContent || this.turnIsLive(turn)) continue;
+			if (victim === void 0 || turn.startedAt < victim.turn.startedAt) victim = {
+				session,
+				turn
+			};
+		}
+		return victim;
+	}
+	enforceCaps() {
+		for (const session of this.sessions.values()) {
+			const real = (live) => session.turns.filter((turn) => turn.hostTurn !== void 0 && turn.liveContent === live);
+			while (real(true).length > this.maxTurnsPerSession) {
+				const victim = real(true).sort((x, y) => x.startedAt - y.startedAt).find((turn) => !this.turnIsLive(turn));
+				if (victim === void 0) break;
+				this.evictTurn(session, victim);
+			}
+			while (real(false).length > this.maxTurnsPerSession) {
+				const victim = real(false).sort((x, y) => x.startedAt - y.startedAt)[0];
+				if (victim === void 0) break;
+				this.evictTurn(session, victim);
+			}
+		}
+		while (this.totalChars > this.maxStoredCharsTotal) {
+			const victim = this.oldestBackfilledTurn();
+			if (victim === void 0) return;
+			this.evictTurn(victim.session, victim.turn);
+			if (victim.session.backfillState === "complete") victim.session.backfillState = "partial";
+		}
+		for (const session of [...this.sessions.values()]) if (session.turns.length === 0 && session.openTurn === void 0) {
+			this.sessions.delete(session.id);
+			for (const [childId, parentId] of this.childToParent) if (parentId === session.id) this.childToParent.delete(childId);
+		}
+	}
+};
+/** The six-way timing split of one request, computed from its recorded spans. */
+function requestTiming(request) {
+	const closed = request.blocks.filter((block) => block.end !== void 0);
+	const sum = (kind) => closed.filter((block) => block.kind === kind).reduce((n, block) => n + (block.end - block.start), 0);
+	const closedExecs = request.execs.filter((exec) => exec.end !== void 0);
+	const toolExecMs = closedExecs.reduce((n, exec) => n + (exec.end - exec.start), 0);
+	return {
+		...request.firstChunkAt === void 0 ? {} : { waitMs: request.firstChunkAt - request.startedAt },
+		...closed.some((block) => block.kind === "reasoning") ? { reasoningMs: sum("reasoning") } : {},
+		...closed.some((block) => block.kind === "tool-call") ? { toolArgsMs: sum("tool-call") } : {},
+		...closed.some((block) => block.kind === "text") ? { textMs: sum("text") } : {},
+		...closedExecs.length > 0 ? { toolExecMs } : {},
+		...request.settledAt === void 0 ? {} : { totalMs: request.settledAt - request.startedAt }
+	};
+}
+const LANE_KIND = {
+	reasoning: "reasoning",
+	"tool-call": "tool-args",
+	text: "text"
+};
+/**
+* One request's lane partition of [startedAt, settledAt]: wait, then blocks in
+* time order, with the gaps between known activity as `other` lanes. Overlaps
+* clamp to the running cursor, so the lanes never double-count wall time.
+*/
+function requestLanes(request) {
+	if (request.settledAt === void 0) return [];
+	const lanes = [];
+	const base = {
+		requestSeq: request.seq,
+		scopeId: request.scopeId
+	};
+	let cursor = request.startedAt;
+	const push = (kind, start, end, tool) => {
+		if (end <= start) return;
+		lanes.push({
+			kind,
+			...base,
+			startedAt: start,
+			durationMs: end - start,
+			...tool === void 0 ? {} : { tool }
+		});
+	};
+	if (request.firstChunkAt !== void 0 && request.firstChunkAt > cursor) {
+		push("wait", cursor, request.firstChunkAt);
+		cursor = request.firstChunkAt;
+	}
+	const closed = request.blocks.filter((block) => block.end !== void 0).sort((a, b) => a.start - b.start);
+	for (const block of closed) {
+		const start = Math.max(block.start, cursor);
+		if (start > cursor) push("other", cursor, start);
+		push(LANE_KIND[block.kind] ?? "other", start, Math.max(start, block.end), block.toolName);
+		cursor = Math.max(cursor, block.end);
+	}
+	if (request.settledAt > cursor) push("other", cursor, request.settledAt);
+	return lanes;
+}
+/**
+* Assemble a request's own response from its recorded block spans: the
+* authoritative block-end content, falling back to delta-accumulated text for
+* blocks a cancelled stream never closed. `undefined` when nothing was
+* produced (a failure before any block — the `error` field covers that).
+*/
+function responseFromSpans(blocks) {
+	const reasoning = blocks.filter((block) => block.kind === "reasoning").map((block) => block.text ?? "").join("");
+	const text = blocks.filter((block) => block.kind === "text").map((block) => block.text ?? "").join("");
+	const toolCalls = blocks.filter((block) => block.kind === "tool-call" && block.toolName !== void 0).map((block) => ({
+		...block.callId === void 0 ? {} : { callId: block.callId },
+		name: block.toolName,
+		arguments: block.args ?? ""
+	}));
+	if (reasoning === "" && text === "" && toolCalls.length === 0) return void 0;
+	return {
+		...reasoning === "" ? {} : { reasoning },
+		...text === "" ? {} : { text },
+		toolCalls
+	};
+}
+/** 明细头锚点（结构化）：响应流里的工具调用 → `{kind:'tool', name, hint?, more?}`；纯文本 → `{kind:'text'}`；纯思考 → `{kind:'reasoning'}`；空响应 → `{kind:'none'}`。 */
+function summarizeResponse(request) {
+	const calls = request.blocks.filter((block) => block.kind === "tool-call" && block.toolName !== void 0);
+	if (calls.length > 0) {
+		const first = calls[0];
+		const hint = toolHint(first.args);
+		return {
+			kind: "tool",
+			name: first.toolName,
+			...hint === void 0 ? {} : { hint },
+			...calls.length > 1 ? {
+				more: calls.length - 1,
+				toolCounts: countToolCalls(calls.map((call) => call.toolName))
+			} : {}
+		};
+	}
+	if (request.blocks.some((block) => block.kind === "text")) return { kind: "text" };
+	return request.blocks.some((block) => block.kind === "reasoning") ? { kind: "reasoning" } : { kind: "none" };
+}
+/**
+* The one-line argument hint behind `tool:name` — the reference
+* reconstruction's key order (what → file basename → for → description),
+* truncated so the summary stays one line.
+*/
+function toolHint(args) {
+	if (args === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(args);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const value = parsed;
+	const pick = (...keys) => {
+		for (const key of keys) {
+			const candidate = value[key];
+			if (typeof candidate === "string" && candidate.length > 0) return candidate;
+		}
+	};
+	const what = pick("what");
+	if (what !== void 0) return clip(what);
+	const file = pick("file_path", "path", "filePath");
+	if (file !== void 0) return clip(file.split("/").pop() ?? file);
+	const purpose = pick("for");
+	if (purpose !== void 0) return clip(purpose);
+	const description = pick("description");
+	return description === void 0 ? void 0 : clip(description);
+}
+/** One-line clip for hint values. */
+function clip(text) {
+	const collapsed = text.replace(/\s+/g, " ").trim();
+	return collapsed.length <= 40 ? collapsed : `${collapsed.slice(0, 39)}…`;
+}
+/** The delegation tool family whose calls pair with `subagent/catalog` events. */
+function isDelegationTool$1(name) {
+	return /^subagent[_-]/.test(name);
+}
+/** The delegation label out of the call arguments (`description` is the subagent_dsh convention). */
+function delegationLabel$1(args) {
+	try {
+		const parsed = JSON.parse(args);
+		if (typeof parsed === "object" && parsed !== null) {
+			const description = parsed.description;
+			if (typeof description === "string" && description.length > 0) return { label: description };
+		}
+	} catch {}
+	return {};
+}
+/** Content comparison is independent of durable message identity and provider cache behavior. */
+/** `provider/model`, or '' when the capture recorded neither. */
+function configKey(config) {
+	return config.provider === void 0 && config.model === void 0 ? "" : `${config.provider ?? "?"}/${config.model ?? "?"}`;
+}
+function factLookup(session) {
+	return {
+		byNewId: (id) => session.replacements.get(id),
+		byReplacedId: (id) => session.replacedBy.get(id)
+	};
+}
+function comparePrefix(previous, current, facts) {
+	const rows = (request) => [
+		...request.segments.system,
+		...request.segments.history,
+		...request.segments.added
+	].sort((a, b) => a.index - b.index);
+	const a = rows(previous), b = rows(current);
+	let i = 0;
+	while (i < a.length && i < b.length && a[i]?.full === b[i]?.full && a[i]?.category === b[i]?.category) i++;
+	const text = i < a.length ? prefixTextChange(a[i]?.full ?? "", b[i]?.full ?? "") : void 0;
+	const changed = text === void 0 ? void 0 : {
+		index: b[i]?.index ?? a[i]?.index ?? 0,
+		before: `${text.leadingOmitted ? "…" : ""}${text.leading}${text.removed}${text.removedChars > 160 ? "…" : ""}${text.trailing}${text.trailingOmitted ? "…" : ""}`,
+		after: `${text.leadingOmitted ? "…" : ""}${text.leading}${text.added}${text.addedChars > 160 ? "…" : ""}${text.trailing}${text.trailingOmitted ? "…" : ""}`,
+		...a[i] === void 0 ? {} : { beforeCategory: a[i].category },
+		...b[i] === void 0 ? {} : { afterCategory: b[i].category },
+		text
+	};
+	const listed = diffRequests({
+		rows: a,
+		tools: previous.segments.tools
+	}, {
+		rows: b,
+		tools: current.segments.tools
+	}, facts, changed === void 0 ? void 0 : changed.index);
+	return {
+		previousSeq: previous.seq,
+		...previous.requestNumber === void 0 ? {} : { previousRequestNumber: previous.requestNumber },
+		gapMs: Math.max(0, current.startedAt - (previous.settledAt ?? previous.startedAt)),
+		changes: listed.changes,
+		toolChanges: listed.tools,
+		...listed.tail === void 0 ? {} : { tail: listed.tail },
+		...configKey(previous.config) === configKey(current.config) || configKey(previous.config) === "" || configKey(current.config) === "" ? {} : { configChanged: {
+			from: configKey(previous.config),
+			to: configKey(current.config)
+		} },
+		toolsChanged: JSON.stringify(previous.segments.tools.map(({ added, ...tool }) => tool)) !== JSON.stringify(current.segments.tools.map(({ added, ...tool }) => tool)),
+		...changed === void 0 ? {} : { changed }
+	};
+}
+/** Extra captured bodies consume retention budget, never input character totals. */
+function executionSize(request) {
+	return request.execs.reduce((n, exec) => n + (exec.result?.length ?? 0), 0);
+}
+function responseSize(response) {
+	return (response?.reasoning?.length ?? 0) + (response?.text?.length ?? 0) + (response?.toolCalls.reduce((n, call) => n + call.name.length + call.arguments.length, 0) ?? 0);
+}
+//#endregion
+//#region lib/types/log-lane.js
+/**
+* The log lane: reconstructs requests from an on-disk session log, read through
+* the host's `sessionPersistence` service (which owns the root layout, the
+* zstd framing, and the format-version chain). Two drivers share one fold:
+*
+* - **Child scopes** — a `subagent_dsh` one-shot child runs in a NEW process,
+*   so the parent's `llm/stream` never sees its requests; the scope fills from
+*   the child's own log, incrementally (the cursor resumes at the consumed
+*   offset across panel queries).
+* - **Main-session backfill** — the panel otherwise shows only turns captured
+*   live since mount; the session's own log reconstructs the pre-mount history
+*   at log fidelity ({@link reconstructSession}), once per session.
+*
+* Honesty contract (one-shot child logs lack two things by design): no
+* `request/header` events means `config` stays `{}` until a header says
+* otherwise, and a missing system prompt never lands in the log, so the system
+* segment stays empty. Main-session logs carry both (`request/header` →
+* config + tools; `system/message` → the rendered prompt as ONE block — the
+* assemble-section attribution is the live lane's upgrade, the log keeps no
+* section names). The lane never invents either.
+*
+* Each `assistant/message` (a settled, usage-carrying response) or
+* `assistant/attempt` (a settled failure) completes one request row.
+*
+* @module @khorsheed/dsh-context-lens/log-lane
+*/
+/** Structural check for the probed `sessionPersistence` service. */
+function isSessionLogReader(value) {
+	return typeof value === "object" && value !== null && typeof value.open === "function";
+}
+/**
+* Subagent providers that run inside this host, so their requests pass
+* through the live capture. Every other provider (claude-local, codex-local,
+* kimi-cli, dsh-cli, …) is its own process, mirrored into its log after the
+* fact.
+*/
+const IN_PROCESS_PROVIDERS = /* @__PURE__ */ new Set(["spawn", "fork"]);
+/** A step/start this close to its answer was written after the call, not when it began. */
+const MIRROR_LAG_MS = 50;
+/** A fresh cursor for one log. */
+function openCursor() {
+	return {
+		consumed: 0,
+		numberedFromStart: false,
+		messages: [],
+		compactions: /* @__PURE__ */ new Map(),
+		stepStartAt: void 0,
+		config: void 0,
+		tools: void 0,
+		callAt: /* @__PURE__ */ new Map(),
+		callNames: /* @__PURE__ */ new Map(),
+		callOwners: /* @__PURE__ */ new Map(),
+		messageDurations: /* @__PURE__ */ new Map(),
+		previous: void 0,
+		requests: [],
+		turnHost: void 0,
+		turnQuerySeen: false,
+		turnTriggerSeen: false,
+		pendingDelegations: /* @__PURE__ */ new Map(),
+		broken: void 0
+	};
+}
+/**
+* Fold new log rows into the cursor. Returns the requests completed by THIS
+* batch (the child-scope driver's whole output); the sink receives those plus
+* the turn/delegation structure (the backfill driver). Tool exec spans can
+* open and close in later batches, so pairing data lives on the cursor.
+*/
+function foldLogRows(cursor, rows, sink = {}) {
+	const built = [];
+	for (const row of rows) {
+		if (cursor.consumed === 0) cursor.numberedFromStart = row.type === "session" || row.seq === 0;
+		cursor.consumed += 1;
+		if (row.ignorable) continue;
+		const data = typeof row.data === "object" && row.data !== null ? row.data : {};
+		switch (row.type) {
+			case "turn/start": {
+				const hostTurn = typeof data["turn"] === "number" ? data["turn"] : void 0;
+				cursor.turnHost = hostTurn;
+				cursor.turnQuerySeen = false;
+				cursor.turnTriggerSeen = false;
+				if (hostTurn !== void 0) sink.turnStart?.(hostTurn, row.time, row.seq);
+				break;
+			}
+			case "turn/end": {
+				flushDeferred(cursor, built, sink);
+				const hostTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+				const reason = typeof data["reason"] === "object" && data["reason"] !== null ? data["reason"] : { kind: "unknown" };
+				if (hostTurn !== void 0) sink.turnEnd?.(hostTurn, reason, row.time);
+				cursor.turnHost = void 0;
+				break;
+			}
+			case "step/start":
+				cursor.stepStartAt = row.time;
+				if (cursor.lastEventAt === void 0) delete cursor.stepPrevAt;
+				else cursor.stepPrevAt = cursor.lastEventAt;
+				break;
+			case "subagent/descriptor": {
+				const provider = data["provider"];
+				if (typeof provider === "string" && !IN_PROCESS_PROVIDERS.has(provider)) cursor.external = true;
+				break;
+			}
+			case "request/header": {
+				const header = data["header"];
+				const config = header?.config;
+				if (config !== void 0) cursor.config = {
+					...typeof config["provider"] === "string" ? { provider: config["provider"] } : {},
+					...typeof config["model"] === "string" ? { model: config["model"] } : {},
+					...typeof config["reasoningEffort"] === "string" ? { reasoningEffort: config["reasoningEffort"] } : {},
+					...typeof config["temperature"] === "number" ? { temperature: config["temperature"] } : {},
+					...typeof config["maxTokens"] === "number" ? { maxTokens: config["maxTokens"] } : {}
+				};
+				if (Array.isArray(header?.tools)) cursor.tools = header.tools.filter((tool) => typeof tool === "object" && tool !== null && typeof tool.name === "string" && typeof tool.description === "string" && typeof tool.parameters === "object");
+				break;
+			}
+			case "system/message":
+			case "developer/message": {
+				const message = fromLogMessage(data["message"]);
+				if (message !== void 0) message.sourceTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+				if (message !== void 0) placeMessage(cursor, row, message);
+				break;
+			}
+			case "user/message": {
+				const message = fromLogMessage(data);
+				if (message !== void 0) message.sourceTurn = cursor.turnHost;
+				if (message !== void 0) {
+					placeMessage(cursor, row, message);
+					if (!cursor.turnQuerySeen && message.sourceKind === "user") {
+						cursor.turnQuerySeen = true;
+						sink.queryText?.(cursor.turnHost, collapseQuery(serializeMessage(message)), row.time);
+					} else if (!cursor.turnTriggerSeen && (row.surfaceOp === void 0 || row.surfaceOp === "append") && !AMBIENT_SOURCES.has(message.sourceKind)) {
+						cursor.turnTriggerSeen = true;
+						sink.triggerText?.(cursor.turnHost, message.sourceKind, lastParagraph(serializeMessage(message)));
+					}
+				}
+				break;
+			}
+			case "assistant/message": {
+				const hostTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+				if (cursor.deferred !== void 0 && cursor.deferred.hostTurn !== hostTurn) flushDeferred(cursor, built, sink);
+				const own = buildRequest(cursor, row, data, false);
+				const message = fromLogMessage(data["message"]);
+				let request = own;
+				if (cursor.deferred !== void 0) {
+					request = cursor.deferred.request;
+					const blocks = [...cursor.deferred.blocks, ...message?.content ?? []];
+					cursor.deferred.blocks = blocks;
+					joinCall(request, own, blocks);
+				}
+				if (cursor.external === true && own.usage === void 0 && own.status !== "failed") cursor.deferred ??= {
+					request,
+					hostTurn,
+					blocks: [...message?.content ?? []]
+				};
+				else {
+					delete cursor.deferred;
+					built.push(request);
+					cursor.requests.push(request);
+					sink.request?.(hostTurn, request);
+				}
+				if (message !== void 0) message.sourceTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+				if (message !== void 0) {
+					placeMessage(cursor, row, message);
+					if (message.id !== void 0) {
+						if (request.settledAt !== void 0) cursor.messageDurations.set(message.id, request.settledAt - request.startedAt);
+						sink.closingMessage?.(hostTurn, message.id);
+					}
+					for (const block of message.content) if (block.type === "tool-call" && block.id !== void 0) cursor.callOwners.set(block.id, request);
+				}
+				break;
+			}
+			case "assistant/attempt": {
+				const request = buildRequest(cursor, row, data, true);
+				built.push(request);
+				cursor.requests.push(request);
+				sink.request?.(typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost, request);
+				break;
+			}
+			case "tool/call": {
+				const callId = typeof data["callId"] === "string" ? data["callId"] : void 0;
+				const name = typeof data["name"] === "string" ? data["name"] : void 0;
+				if (callId !== void 0) {
+					cursor.callAt.set(callId, row.time ?? 0);
+					if (name !== void 0) cursor.callNames.set(callId, name);
+					const owner = cursor.callOwners.get(callId);
+					if (owner !== void 0 && name !== void 0) owner.execs.push({
+						callId,
+						name,
+						start: row.time ?? owner.settledAt ?? owner.startedAt
+					});
+					if (name !== void 0 && isDelegationTool(name)) {
+						const delegation = {
+							...typeof data["turn"] === "number" ? { hostTurn: data["turn"] } : {},
+							callId,
+							name,
+							at: row.time ?? 0,
+							...delegationLabel(typeof data["arguments"] === "string" ? data["arguments"] : "")
+						};
+						cursor.pendingDelegations.set(callId, delegation);
+					}
+				}
+				break;
+			}
+			case "subagent/catalog": {
+				const childId = typeof data["childId"] === "string" ? data["childId"] : void 0;
+				if (childId !== void 0 && childId.length > 0) {
+					let bound = false;
+					for (const pending of cursor.pendingDelegations.values()) if (pending.childId === void 0) {
+						pending.childId = childId;
+						if (typeof data["label"] === "string" && data["label"].length > 0) pending.catalogLabel = data["label"];
+						bound = true;
+						break;
+					}
+					if (!bound) sink.delegation?.({
+						...cursor.turnHost === void 0 ? {} : { hostTurn: cursor.turnHost },
+						callId: "",
+						name: "subagent/catalog",
+						at: row.time ?? 0,
+						childId,
+						...typeof data["label"] === "string" && data["label"].length > 0 ? { catalogLabel: data["label"] } : {}
+					});
+				}
+				break;
+			}
+			case "compaction/start": {
+				const id = data["compactionId"];
+				if (typeof id === "string") cursor.compactions.set(id, {
+					startedAt: row.time ?? 0,
+					...typeof data["turn"] === "number" ? { hostTurn: data["turn"] } : {}
+				});
+				break;
+			}
+			case "compaction/summary": {
+				const request = buildCompaction(cursor, row, data);
+				if (request) {
+					const id = request.compaction.id;
+					cursor.compactions.set(id, {
+						...cursor.compactions.get(id),
+						startedAt: request.startedAt,
+						request
+					});
+					built.push(request);
+					sink.request?.(cursor.turnHost, request);
+				}
+				break;
+			}
+			case "compaction/end":
+				if (typeof data["compactionId"] === "string") cursor.compactions.delete(data["compactionId"]);
+				break;
+			case "tool/result": {
+				const message = fromLogMessage(data["message"]);
+				if (message !== void 0) message.sourceTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+				if (message !== void 0) placeMessage(cursor, row, message);
+				if (row.surfaceOp && row.surfaceOp !== "append") break;
+				const callId = message?.toolCallId ?? (typeof data["toolCallId"] === "string" ? data["toolCallId"] : void 0);
+				if (callId !== void 0) {
+					const span = cursor.callOwners.get(callId)?.execs.find((exec) => exec.callId === callId && exec.end === void 0);
+					if (span !== void 0) {
+						if (row.time !== void 0) span.end = row.time;
+						span.isError = message?.isError === true;
+						if (message !== void 0) span.result = serializeMessage(message);
+					}
+					const delegation = cursor.pendingDelegations.get(callId);
+					if (delegation !== void 0) {
+						cursor.pendingDelegations.delete(callId);
+						if (row.time !== void 0) delegation.resultAt = row.time;
+						delegation.isError = message?.isError === true;
+						if (delegation.isError && message !== void 0) delegation.errorPreview = previewLine(serializeMessage(message));
+						sink.delegation?.(delegation);
+					}
+				}
+				break;
+			}
+		}
+		if (row.time !== void 0 && row.type !== "local-agent/stream") cursor.lastEventAt = row.time;
+	}
+	return built;
+}
+/** Apply inclusive endpoints in CURRENT surface order (seq order may differ). */
+function placeMessage(cursor, row, message) {
+	const node = {
+		seq: row.seq ?? cursor.consumed,
+		message
+	};
+	const op = row.surfaceOp;
+	if (op === void 0 || op === "append") {
+		cursor.messages.push(node);
+		return;
+	}
+	const start = cursor.messages.findIndex((item) => item.seq === op.startSeq);
+	const end = cursor.messages.findIndex((item) => item.seq === op.endSeq);
+	if (op.op !== "replace" || start < 0 || end < start) throw new Error(`Invalid context surface replacement at event ${row.seq}`);
+	if (row.type === "tool/result") {
+		const original = cursor.messages[start].message;
+		const beforeChars = original.pruning?.beforeChars ?? serializeMessage(original).length;
+		const afterChars = serializeMessage(message).length;
+		if (afterChars < beforeChars) message.pruning = {
+			beforeChars,
+			afterChars
+		};
+	}
+	cursor.messages.splice(start, end - start + 1, node);
+	const compression = message.compactionId === void 0 ? void 0 : cursor.compactions.get(message.compactionId)?.request?.compaction;
+	if (compression) compression.applied = true;
+}
+/** Recover recorded model-backed summaries without inventing the missing instruction. */
+function buildCompaction(cursor, row, data) {
+	const id = data["compactionId"];
+	if (typeof id !== "string" || data["llmStreamCall"] !== true && data["usage"] === void 0) return void 0;
+	const start = cursor.compactions.get(id);
+	const seqs = Array.isArray(data["shadowedSeqs"]) ? data["shadowedSeqs"] : [];
+	const selected = new Set(seqs);
+	const region = cursor.messages.filter((item) => selected.has(item.seq));
+	if (!fromLogMessage({
+		role: "assistant",
+		content: data["summary"]
+	})) return void 0;
+	const temp = openCursor();
+	if (cursor.materialize !== void 0) temp.materialize = cursor.materialize;
+	temp.turnHost = start?.hostTurn;
+	const head = cursor.messages[0];
+	temp.messages = head !== void 0 && head.message.role === "system" && !selected.has(head.seq) ? [head, ...region] : region;
+	if (cursor.tools !== void 0) temp.tools = cursor.tools;
+	temp.stepStartAt = start?.startedAt ?? row.time;
+	temp.config = {
+		...typeof data["provider"] === "string" ? { provider: data["provider"] } : {},
+		...typeof data["model"] === "string" ? { model: data["model"] } : {},
+		...typeof data["maxTokens"] === "number" ? { maxTokens: data["maxTokens"] } : {}
+	};
+	return {
+		...buildRequest(temp, row, {
+			message: {
+				role: "assistant",
+				content: data["summary"]
+			},
+			usage: data["usage"]
+		}, false),
+		responseSummary: { kind: "compaction" },
+		purpose: "compaction",
+		compaction: {
+			id,
+			applied: false,
+			...start?.hostTurn === void 0 ? {} : { hostTurn: start.hostTurn },
+			...Array.isArray(data["shadowedSeqs"]) && region.length === seqs.length ? {
+				replacedCount: region.length,
+				replacedChars: region.reduce((n, item) => n + serializeMessage(item.message).length, 0)
+			} : {},
+			inputPartial: true
+		}
+	};
+}
+/**
+* One-shot reconstruction of a whole session log into turns (the main-session
+* backfill). Requests group by their host turn number (step-scoped events
+* carry it; a torn bracket falls back to the fold's open-turn state). Turns
+* never closed by a turn/end (a crash) come out with `endReasonKind` unset.
+*/
+function reconstructSession(rows, materialize) {
+	const cursor = openCursor();
+	if (materialize !== void 0) cursor.materialize = materialize;
+	const turns = [];
+	const byHostTurn = /* @__PURE__ */ new Map();
+	const orphans = [];
+	const place = (delegation) => {
+		const turn = turnFor(delegation.hostTurn, delegation.at);
+		if (turn !== void 0) turn.delegations.push(delegation);
+		else if (delegation.childId !== void 0) orphans.push(delegation);
+	};
+	const turnFor = (hostTurn, at) => {
+		if (hostTurn === void 0) return void 0;
+		let turn = byHostTurn.get(hostTurn);
+		if (turn === void 0) {
+			turn = {
+				hostTurn,
+				query: "",
+				...at === void 0 ? { startedAt: 0 } : { startedAt: at },
+				requests: [],
+				delegations: []
+			};
+			byHostTurn.set(hostTurn, turn);
+			turns.push(turn);
+		} else if (turn.startedAt === 0 && at !== void 0) turn.startedAt = at;
+		return turn;
+	};
+	const sink = {
+		turnStart: (hostTurn, at, seq) => {
+			const turn = turnFor(hostTurn, at);
+			if (turn !== void 0 && seq !== void 0 && turn.startSeq === void 0) turn.startSeq = seq;
+		},
+		turnEnd: (hostTurn, reason, at) => {
+			const turn = turnFor(hostTurn, at);
+			if (turn === void 0) return;
+			if (at !== void 0) turn.endedAt = at;
+			turn.endReasonKind = reason.kind;
+			if (reason.kind === "error" && reason.error?.message !== void 0) turn.endError = reason.error.message;
+		},
+		queryText: (hostTurn, text, at) => {
+			const turn = turnFor(hostTurn, at);
+			if (turn !== void 0 && turn.query === "") turn.query = text;
+		},
+		triggerText: (hostTurn, source, text) => {
+			const turn = turnFor(hostTurn, void 0);
+			if (turn !== void 0 && turn.trigger === void 0) turn.trigger = {
+				source,
+				text
+			};
+		},
+		closingMessage: (hostTurn, messageId) => {
+			const turn = turnFor(hostTurn, void 0);
+			if (turn !== void 0) turn.closingMessageId = messageId;
+		},
+		request: (hostTurn, request) => {
+			if (request.compaction) turns.push({
+				hostTurn: -turns.length - 1,
+				purpose: "compaction",
+				query: "compaction",
+				startedAt: request.startedAt,
+				endedAt: request.settledAt ?? request.startedAt,
+				endReasonKind: "completed",
+				requests: [request],
+				delegations: []
+			});
+			else turnFor(hostTurn, request.startedAt)?.requests.push(request);
+		},
+		delegation: (delegation) => {
+			place(delegation);
+		}
+	};
+	foldLogRows(cursor, rows, sink);
+	flushDeferred(cursor, [], sink);
+	for (const pending of cursor.pendingDelegations.values()) place(pending);
+	if (orphans.length > 0) turns.push({
+		hostTurn: -1,
+		purpose: "room-members",
+		query: "",
+		startedAt: orphans[0].at,
+		endedAt: orphans.at(-1).at,
+		endReasonKind: "completed",
+		requests: [],
+		delegations: orphans
+	});
+	return turns;
+}
+/** The delegation tool family whose calls pair with `subagent/catalog` events. */
+function isDelegationTool(name) {
+	return /^subagent[_-]/.test(name);
+}
+/** The delegation label out of the call arguments (`description` is the subagent_dsh convention). */
+function delegationLabel(args) {
+	try {
+		const parsed = JSON.parse(args);
+		if (typeof parsed === "object" && parsed !== null) {
+			const description = parsed.description;
+			if (typeof description === "string" && description.length > 0) return { label: description };
+		}
+	} catch {}
+	return {};
+}
+/** The turn-list query preview: one collapsed line, capped. */
+function collapseQuery(text) {
+	return text.replace(/\s+/g, " ").trim().slice(0, 120);
+}
+/**
+* A log without request headers (an external agent's child: its CLI owns the
+* request) still names who answered on the assistant message's source; the
+* rest of the request config was never recorded and stays absent.
+*/
+function configFromSource(raw) {
+	const source = typeof raw === "object" && raw !== null ? raw["source"] : void 0;
+	return {
+		...typeof source?.["provider"] === "string" ? { provider: source["provider"] } : {},
+		...typeof source?.["model"] === "string" ? { model: source["model"] } : {}
+	};
+}
+/** One settled request out of its assistant event: stream timing, usage, and the segment split. */
+function buildRequest(cursor, row, data, failed) {
+	const written = cursor.stepStartAt ?? row.time ?? 0;
+	const startedAt = cursor.external === true && row.time !== void 0 && row.time - written < MIRROR_LAG_MS && cursor.stepPrevAt !== void 0 ? cursor.stepPrevAt : written;
+	const settledAt = row.time ?? startedAt;
+	const streamFacts = readStream(Array.isArray(data["stream"]) ? data["stream"] : []);
+	const usage = readUsage(data["usage"]);
+	const hostTurn = typeof data["turn"] === "number" ? data["turn"] : cursor.turnHost;
+	const messages = cursor.messages.map((folded) => folded.message);
+	let segments;
+	if (cursor.materialize?.(hostTurn) === false) {
+		cursor.previousMessages = messages;
+		cursor.previousToolNames = (cursor.tools ?? []).map((tool) => tool.name);
+		cursor.previous = void 0;
+		segments = {
+			system: [],
+			tools: [],
+			history: [],
+			added: [],
+			totalChars: 0,
+			fingerprint: {
+				messageKeys: [],
+				toolNames: []
+			}
+		};
+	} else {
+		if (cursor.previous === void 0 && cursor.previousMessages !== void 0) cursor.previous = {
+			messageKeys: cursor.previousMessages.map((message) => messageKey(message, contentHash)),
+			toolNames: cursor.previousToolNames ?? []
+		};
+		delete cursor.previousMessages;
+		segments = splitRequest({
+			messages,
+			...cursor.tools === void 0 ? {} : { tools: cursor.tools },
+			context: {
+				...cursor.previous === void 0 ? {} : { previous: cursor.previous },
+				assemblies: [],
+				resolveToolName: (callId) => cursor.callNames.get(callId),
+				durationFor: (messageId) => cursor.messageDurations.get(messageId)
+			}
+		});
+		cursor.previous = segments.fingerprint;
+	}
+	const message = failed ? void 0 : fromLogMessage(data["message"]);
+	const blocks = message !== void 0 ? spansFromMessage(message, streamFacts, startedAt) : streamFacts.blocks;
+	const response = message !== void 0 ? responseFromMessage(message) : responseFromSpans(streamFacts.blocks);
+	const finish = streamFacts.finish;
+	const error = failed ? finish?.failure ?? "attempt settled without a committed message" : void 0;
+	const finishKind = finish?.kind;
+	return {
+		...cursor.numberedFromStart ? { requestNumber: cursor.requests.length + 1 } : {},
+		...hostTurn === void 0 ? {} : { hostTurn },
+		startedAt,
+		status: failed ? "failed" : "ok",
+		...error === void 0 ? {} : { error },
+		config: cursor.config ?? configFromSource(data["message"]),
+		...usage === void 0 ? {} : { usage },
+		responseSummary: message !== void 0 ? summarizeMessage(message) : summarizeBlocks(streamFacts.blocks),
+		...response === void 0 ? {} : { response },
+		segments: {
+			system: segments.system,
+			tools: segments.tools,
+			history: segments.history,
+			added: segments.added
+		},
+		totalChars: segments.totalChars,
+		...streamFacts.firstChunkAt === void 0 ? {} : { firstChunkAt: streamFacts.firstChunkAt },
+		settledAt,
+		...finishKind === void 0 ? {} : { finishKind },
+		blocks,
+		execs: [],
+		fingerprint: segments.fingerprint
+	};
+}
+/** Block spans for a committed response: stream timing with the message's tool-call identity. */
+function spansFromMessage(message, facts, fallbackStart) {
+	const calls = message.content.filter((block) => block.type === "tool-call");
+	const spans = facts.blocks.map((span) => ({ ...span }));
+	for (const span of spans) {
+		if (span.kind !== "tool-call") continue;
+		if (span.callId !== void 0) continue;
+		const call = calls.find((block) => block.id !== void 0 && !spans.some((other) => other !== span && other.callId === block.id));
+		if (call?.id !== void 0) {
+			span.callId = call.id;
+			if (call.name !== void 0) span.toolName = call.name;
+			if (call.arguments !== void 0) span.args = call.arguments;
+		}
+	}
+	if (spans.length === 0 && message.content.length > 0) return [{
+		kind: "text",
+		index: 0,
+		start: facts.firstChunkAt ?? fallbackStart
+	}];
+	return spans;
+}
+/** A deferred call's step that never got its usage step still counts as a request. */
+function flushDeferred(cursor, built, sink) {
+	const deferred = cursor.deferred;
+	if (deferred === void 0) return;
+	delete cursor.deferred;
+	built.push(deferred.request);
+	cursor.requests.push(deferred.request);
+	sink.request?.(deferred.hostTurn, deferred.request);
+}
+/** Fold one more step of a call into the request the call began (its input stays the first step's). */
+function joinCall(request, step, blocks) {
+	const message = {
+		role: "assistant",
+		content: blocks
+	};
+	const response = responseFromMessage(message);
+	if (response !== void 0) request.response = response;
+	request.responseSummary = summarizeMessage(message);
+	request.status = step.status;
+	if (step.error !== void 0) request.error = step.error;
+	if (step.usage !== void 0) request.usage = step.usage;
+	if (step.settledAt !== void 0) request.settledAt = step.settledAt;
+	if (step.finishKind !== void 0) request.finishKind = step.finishKind;
+	request.blocks.push(...step.blocks);
+	request.execs.push(...step.execs);
+}
+/** The response's own content from a committed assistant message (authoritative). */
+function responseFromMessage(message) {
+	const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text ?? "").join("");
+	const text = message.content.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+	const toolCalls = message.content.filter((block) => block.type === "tool-call" && block.name !== void 0).map((block) => ({
+		...block.id === void 0 ? {} : { callId: block.id },
+		name: block.name,
+		arguments: block.arguments ?? ""
+	}));
+	if (reasoning === "" && text === "" && toolCalls.length === 0) return void 0;
+	return {
+		...reasoning === "" ? {} : { reasoning },
+		...text === "" ? {} : { text },
+		toolCalls
+	};
+}
+/** The response hint from a committed message's blocks (structured 明细头锚点). */
+function summarizeMessage(message) {
+	const calls = message.content.filter((block) => block.type === "tool-call" && block.name !== void 0);
+	if (calls.length > 0) {
+		const first = calls[0];
+		const hint = hintFromArgs(first.arguments);
+		return {
+			kind: "tool",
+			name: first.name,
+			...hint === void 0 ? {} : { hint },
+			...calls.length > 1 ? {
+				more: calls.length - 1,
+				toolCounts: countToolCalls(calls.map((call) => call.name))
+			} : {}
+		};
+	}
+	if (message.content.some((block) => block.type === "text" && (block.text ?? "").trim().length > 0)) return { kind: "text" };
+	return message.content.some((block) => block.type === "reasoning" && (block.text ?? "").trim().length > 0) ? { kind: "reasoning" } : { kind: "none" };
+}
+/** The response summary when only stream spans survived (an attempt). */
+function summarizeBlocks(blocks) {
+	const calls = blocks.filter((block) => block.kind === "tool-call" && block.toolName !== void 0);
+	if (calls.length === 0) {
+		if (blocks.some((block) => block.kind === "text")) return { kind: "text" };
+		return blocks.some((block) => block.kind === "reasoning") ? { kind: "reasoning" } : { kind: "none" };
+	}
+	const first = calls[0];
+	const hint = hintFromArgs(first.args);
+	return {
+		kind: "tool",
+		name: first.toolName,
+		...hint === void 0 ? {} : { hint },
+		...calls.length > 1 ? {
+			more: calls.length - 1,
+			toolCounts: countToolCalls(calls.map((call) => call.toolName))
+		} : {}
+	};
+}
+/** The one-line argument hint — the reference reconstruction's key order. */
+function hintFromArgs(args) {
+	if (args === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(args);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const value = parsed;
+	const what = value["what"];
+	if (typeof what === "string" && what.length > 0) return previewLine(what, 40);
+	const file = value["file_path"] ?? value["path"] ?? value["filePath"];
+	if (typeof file === "string" && file.length > 0) return previewLine(file.split("/").pop() ?? file, 40);
+	const purpose = value["for"];
+	if (typeof purpose === "string" && purpose.length > 0) return previewLine(purpose, 40);
+	const description = value["description"];
+	if (typeof description === "string" && description.length > 0) return previewLine(description, 40);
+}
+/**
+* Block timing out of one compact stream record list (`AssistantStreamRecord`):
+* block-start/block-end ride as raw `chunk` records, deltas pack into runs
+* whose `time0` still counts toward the first-chunk time.
+*/
+function readStream(records) {
+	const blocks = [];
+	let firstChunkAt;
+	let finish;
+	const note = (time) => {
+		if (typeof time !== "number") return;
+		if (firstChunkAt === void 0 || time < firstChunkAt) firstChunkAt = time;
+	};
+	for (const raw of records) {
+		if (typeof raw !== "object" || raw === null) continue;
+		const record = raw;
+		if (record["type"] === "chunk") {
+			const time = record["time"];
+			const chunk = record["chunk"];
+			if (typeof time !== "number" || chunk === void 0) continue;
+			note(time);
+			switch (chunk["type"]) {
+				case "block-start":
+					blocks.push({
+						kind: typeof chunk["blockType"] === "string" ? chunk["blockType"] : "unknown",
+						index: typeof chunk["index"] === "number" ? chunk["index"] : blocks.length,
+						start: time
+					});
+					break;
+				case "block-end": {
+					const index = chunk["index"];
+					const span = blocks.find((block) => block.index === index && block.end === void 0);
+					if (span !== void 0) {
+						span.end = time;
+						const block = chunk["block"];
+						if (typeof block?.["text"] === "string") span.text = block["text"];
+						if (block?.["type"] === "tool-call") {
+							if (typeof block["id"] === "string") span.callId = block["id"];
+							if (typeof block["name"] === "string") span.toolName = block["name"];
+							if (typeof block["arguments"] === "string") span.args = block["arguments"];
+						}
+					}
+					break;
+				}
+				case "finish": {
+					const reason = chunk["reason"];
+					const kind = typeof reason?.["kind"] === "string" ? reason["kind"] : void 0;
+					const failure = reason?.["failure"];
+					finish = {
+						kind: kind ?? "unknown",
+						...typeof failure?.["message"] === "string" ? { failure: failure["message"] } : {}
+					};
+					break;
+				}
+			}
+		} else {
+			note(record["time0"]);
+			const span = blocks.find((block) => block.index === record["index"] && block.end === void 0);
+			if (span !== void 0) {
+				if (Array.isArray(record["texts"])) span.text = (span.text ?? "") + record["texts"].join("");
+				else if (Array.isArray(record["args"])) span.args = (span.args ?? "") + record["args"].join("");
+			}
+		}
+	}
+	return {
+		...firstChunkAt === void 0 ? {} : { firstChunkAt },
+		blocks,
+		...finish === void 0 ? {} : { finish }
+	};
+}
+/** Structural read of one usage object (provider figures, cache fields optional). */
+function readUsage(raw) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const value = raw;
+	if (typeof value["inputTokens"] !== "number" || typeof value["outputTokens"] !== "number") return void 0;
+	return {
+		inputTokens: value["inputTokens"],
+		outputTokens: value["outputTokens"],
+		...typeof value["totalTokens"] === "number" ? { totalTokens: value["totalTokens"] } : {},
+		...typeof value["cacheReadTokens"] === "number" ? { cacheReadTokens: value["cacheReadTokens"] } : {},
+		...typeof value["cacheWriteTokens"] === "number" ? { cacheWriteTokens: value["cacheWriteTokens"] } : {}
+	};
+}
+//#endregion
+//#region lib/types/service.js
+/** The capture store's query face (Remote delegates here). */
+var InspectorService = class {
+	ctx;
+	config;
+	store;
+	disposers;
+	/** childId → open read handle (persistent: reads are offset-incremental). */
+	handles = /* @__PURE__ */ new Map();
+	cursors = /* @__PURE__ */ new Map();
+	/** In-flight refresh per childId — concurrent panel queries share one read. */
+	refreshing = /* @__PURE__ */ new Map();
+	/** sessionId → the metering event (`compaction/summary` | `compaction/prune`) just seen; the host appends its replacement next. */
+	meters = /* @__PURE__ */ new Map();
+	now;
+	logWarn;
+	persistenceOverride;
+	constructor(ctx, config = {}, deps = {}) {
+		this.ctx = ctx;
+		this.config = config;
+		this.now = deps.now ?? Date.now;
+		this.logWarn = deps.logger?.warn.bind(deps.logger) ?? ((message) => ctx.logger.warn(message));
+		this.persistenceOverride = deps.persistence;
+		const storeConfig = {
+			...config.maxTurnsPerSession === void 0 ? {} : { maxTurnsPerSession: config.maxTurnsPerSession },
+			...config.maxBackfillRequestsPerSession === void 0 ? {} : { maxBackfillRequestsPerSession: config.maxBackfillRequestsPerSession },
+			...config.maxStoredCharsTotal === void 0 ? {} : { maxStoredCharsTotal: config.maxStoredCharsTotal }
+		};
+		this.store = new InspectorStore(storeConfig, {
+			now: this.now,
+			onTurnEvicted: (_sessionId, turn) => this.dropEvictedChildState(turn),
+			...deps.generation === void 0 ? {} : { generation: deps.generation }
+		});
+		this.disposers = [
+			ctx.on("llm/stream", (options, next) => this.onStream(options, next)),
+			ctx.on("system-prompt/assemble", (_assembly, _context, next) => this.onAssemble(next)),
+			ctx.on("session/event", (session, event) => this.onSessionEvent(session, event))
+		];
+	}
+	/**
+	* The waterfall tee: snapshot the (possibly deep-frozen) request at dispatch,
+	* then forward every chunk unchanged while observing. A capture-side failure
+	* at setup degrades to the bare downstream stream; mid-stream failures only
+	* lose the remaining observations.
+	*/
+	onStream(options, next) {
+		let request;
+		try {
+			request = this.store.beginRequest(snapshotOptions(options), this.now());
+		} catch (error) {
+			this.logWarn(`context-lens: capture setup failed, forwarding uncaptured (${String(error)})`);
+			return next();
+		}
+		if (request === void 0) return next();
+		return this.tee(request, next);
+	}
+	tee(request, next) {
+		const { store, now } = this;
+		const warn = this.logWarn;
+		return (async function* () {
+			let thrown;
+			try {
+				for await (const chunk of next()) {
+					try {
+						store.observeChunk(request, chunk, now());
+					} catch (error) {
+						warn(`context-lens: chunk observation dropped (${String(error)})`);
+					}
+					yield chunk;
+				}
+			} catch (error) {
+				thrown = error;
+				throw error;
+			} finally {
+				try {
+					store.settleRequest(request, now(), thrown);
+				} catch (error) {
+					warn(`context-lens: request settlement dropped (${String(error)})`);
+				}
+			}
+		})();
+	}
+	/**
+	* Record the post-waterfall assembly for section attribution. The returned
+	* value passes through unchanged — this listener observes, it never rewrites
+	* a prompt.
+	*/
+	async onAssemble(next) {
+		const result = await next();
+		try {
+			recordAssembly(this.store.assemblyRing, result, this.now());
+		} catch (error) {
+			this.logWarn(`context-lens: assembly record dropped (${String(error)})`);
+		}
+		return result;
+	}
+	onSessionEvent(session, event) {
+		try {
+			this.dispatchSessionEvent(session, event);
+		} catch (error) {
+			this.logWarn(`context-lens: session event "${String(event.type)}" dropped (${String(error)})`);
+		}
+	}
+	dispatchSessionEvent(session, event) {
+		const sessionId = session.id;
+		const at = event.time;
+		const eventType = event.type;
+		this.noteReplacement(session, event);
+		this.store.noteLogActivity(sessionId);
+		if (eventType.startsWith("compaction/")) this.store.noteCompaction(sessionId, eventType, event.data);
+		if (eventType.startsWith("room/")) {
+			this.store.noteRoomEvent(sessionId, eventType, event.data, event.seq, at);
+			return;
+		}
+		if (event.type === "tool/result" && event.surfaceOp !== "append") {
+			const original = session.eventAt(event.surfaceOp.startSeq);
+			if (original?.type === "tool/result") this.store.notePruning(sessionId, event.data.message.id, serializeMessage(fromRequestMessage(original.data.message)).length, serializeMessage(fromRequestMessage(event.data.message)).length);
+			return;
+		}
+		switch (event.type) {
+			case "turn/start":
+				this.store.turnStart(sessionId, event.data.turn, at, event.seq);
+				return;
+			case "turn/end":
+				this.store.turnEnd(sessionId, event.data.turn, event.data.reason, at);
+				return;
+			case "user/message": {
+				const message = fromRequestMessage(event.data);
+				if (message.compactionId !== void 0 && event.surfaceOp !== "append") this.store.noteCompaction(sessionId, "compaction/applied", { compactionId: message.compactionId });
+				if (message.id) this.store.noteMessageTurn(sessionId, message.id);
+				this.store.noteUserMessage(sessionId, message.sourceKind, serializeMessage(message));
+				return;
+			}
+			case "assistant/message":
+				this.store.noteMessageTurn(sessionId, event.data.message.id, event.data.turn);
+				this.store.noteAssistantMessage(sessionId, event.data.message.id);
+				return;
+			case "tool/call":
+				this.store.toolCall(sessionId, event.data.callId, event.data.name, event.data.arguments, at);
+				return;
+			case "tool/result": {
+				this.store.noteMessageTurn(sessionId, event.data.message.id, event.data.turn);
+				const message = fromRequestMessage(event.data.message);
+				this.store.toolResult(sessionId, event.data.message.toolCallId, event.data.message.isError === true, serializeMessage(message), at);
+				return;
+			}
+		}
+		const type = event.type;
+		if (type === "subagent/descriptor") {
+			const provider = event.data["provider"];
+			if (typeof provider === "string") {
+				this.store.noteChildProvider(sessionId, provider);
+				if (!IN_PROCESS_PROVIDERS.has(provider)) this.store.markLogDriven(sessionId);
+			}
+			return;
+		}
+		if (type === "subagent/catalog") {
+			const data = event.data;
+			const childId = data["childId"];
+			if (typeof childId === "string" && childId.length > 0) {
+				const label = data["label"];
+				this.store.subagentCatalog(sessionId, childId, typeof label === "string" && label.length > 0 ? label : void 0, at);
+			}
+		}
+	}
+	/** The probed `sessionPersistence` service, when the composition mounts one. */
+	reader() {
+		if (this.persistenceOverride !== void 0) return this.persistenceOverride;
+		try {
+			const candidate = this.ctx.get("sessionPersistence");
+			return isSessionLogReader(candidate) ? candidate : void 0;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Refresh the log-sourced child scopes of one session (query-time,
+	* incremental). A scope the query's {@link ScopeFilter} excludes is skipped
+	* outright — its log is not opened on an unauthorized query's behalf.
+	*/
+	async refreshChildren(rootSessionId, filter) {
+		const reader = this.reader();
+		if (reader === void 0) return;
+		const scopes = this.store.childScopes(rootSessionId);
+		await Promise.all(scopes.map((scope) => scopeAuthorized(scope.scopeId, filter) ? this.refreshChild(rootSessionId, scope.scopeId, reader, scope.live) : Promise.resolve()));
+	}
+	refreshChild(rootSessionId, childId, reader, live) {
+		if (live) return Promise.resolve();
+		const pending = this.refreshing.get(childId);
+		if (pending !== void 0) return pending;
+		const job = this.doRefreshChild(rootSessionId, childId, reader).finally(() => {
+			this.refreshing.delete(childId);
+		});
+		this.refreshing.set(childId, job);
+		return job;
+	}
+	async doRefreshChild(rootSessionId, childId, reader) {
+		let cursor = this.cursors.get(childId);
+		if (cursor?.broken !== void 0) return;
+		if (cursor === void 0) {
+			cursor = openCursor();
+			this.cursors.set(childId, cursor);
+		}
+		try {
+			let handle = this.handles.get(childId);
+			if (handle === void 0) {
+				handle = await reader.open(childId, "read");
+				this.handles.set(childId, handle);
+			}
+			const { events } = await handle.read(cursor.consumed);
+			const provider = events.find((row) => row.type === "subagent/descriptor")?.data?.["provider"];
+			if (typeof provider === "string") this.store.noteChildProvider(childId, provider);
+			for (const request of foldLogRows(cursor, events)) this.store.appendLogRequest(rootSessionId, childId, request);
+			this.store.refreshExecutionResults(rootSessionId, childId);
+		} catch (error) {
+			if (error instanceof Error && error.name === "SessionPersistenceNotFoundError") return;
+			cursor.broken = error instanceof Error ? error.message : String(error);
+			this.logWarn(`context-lens: child log "${childId}" unreadable (${cursor.broken})`);
+		}
+	}
+	/** Turn eviction drops the child cursors/handles whose scopes lived on it. */
+	dropEvictedChildState(turn) {
+		for (const scopeId of turn.scopes.keys()) {
+			if (scopeId === "main") continue;
+			this.cursors.delete(scopeId);
+			const handle = this.handles.get(scopeId);
+			if (handle !== void 0) {
+				this.handles.delete(scopeId);
+				handle.close().catch(() => void 0);
+			}
+		}
+	}
+	/**
+	* Reconstruct the session's pre-mount history from its own log, once per
+	* session (the store's watermark holds). The read is one full pass at first
+	* query; the store keeps the newest turns that fit the budget behind the
+	* live ones. A not-yet-materialized log is transient (retry next query); any
+	* other read failure marks the session broken and stops hammering it.
+	*/
+	/** Pair a surface replacement with what it shadowed, typed by the metering event right before it. */
+	noteReplacement(session, row) {
+		const meter = this.meters.get(session.id);
+		this.meters.delete(session.id);
+		const next = meterOf(row);
+		if (next !== void 0) this.meters.set(session.id, next);
+		const fact = replacementFact(row, (seq) => {
+			const shadowed = session.eventAt(seq);
+			return shadowed === void 0 ? void 0 : messageOfRow(shadowed)?.id;
+		}, meter);
+		if (fact !== void 0) this.store.noteReplacement(session.id, fact);
+	}
+	async backfillMainSession(sessionId) {
+		const reader = this.reader();
+		if (reader === void 0) return;
+		const state = this.store.backfillState(sessionId);
+		if (state === "broken" || state === "complete" && !this.store.needsRequestNumbers(sessionId) && !this.store.needsLogRead(sessionId)) return;
+		const jobKey = `main:${sessionId}`;
+		const pending = this.refreshing.get(jobKey);
+		if (pending !== void 0) return pending;
+		const job = this.doBackfillMainSession(sessionId, reader).finally(() => {
+			this.refreshing.delete(jobKey);
+		});
+		this.refreshing.set(jobKey, job);
+		return job;
+	}
+	async doBackfillMainSession(sessionId, reader) {
+		try {
+			const handle = await reader.open(sessionId, "read");
+			try {
+				const { events } = await handle.read(0);
+				const hosts = events.filter((row) => row.type === "turn/start").map((row) => row.data?.turn).filter((turn) => typeof turn === "number");
+				const provider = events.find((row) => row.type === "subagent/descriptor")?.data?.["provider"];
+				if (typeof provider === "string" && !IN_PROCESS_PROVIDERS.has(provider)) this.store.markLogDriven(sessionId);
+				const keep = this.store.windowHosts(sessionId, hosts);
+				this.store.insertLogTurns(sessionId, reconstructSession(events, (host) => host === void 0 || keep.has(host)));
+				for (const fact of replacementFactsOf(events)) this.store.noteReplacement(sessionId, fact);
+				for (const row of events) if (row.type.startsWith("room/")) this.store.noteRoomEvent(sessionId, row.type, row.data, row.seq, row.time);
+				await this.resolveParent(sessionId, events, reader);
+			} finally {
+				handle.close().catch(() => void 0);
+			}
+		} catch (error) {
+			if (error instanceof Error && error.name === "SessionPersistenceNotFoundError") return;
+			const reason = error instanceof Error ? error.message : String(error);
+			this.store.markBackfillBroken(sessionId, reason);
+			this.logWarn(`context-lens: session "${sessionId}" log unreadable, history backfill skipped (${reason})`);
+		}
+	}
+	/**
+	* A session opened on its own whose log header names a `parentSession`:
+	* read the parent's log once for its title, the turn whose catalog row
+	* started this child, and that row's label. Best effort — an unreadable
+	* parent leaves just its id.
+	*/
+	async resolveParent(sessionId, events, reader) {
+		const header = events[0];
+		const parentId = header?.type === "session" ? header.parentSession : void 0;
+		if (typeof parentId !== "string" || parentId.length === 0 || this.store.hasParent(sessionId)) return;
+		const parent = { sessionId: parentId };
+		try {
+			const handle = await reader.open(parentId, "read");
+			try {
+				const { events: rows } = await handle.read(0);
+				let turn;
+				for (const row of rows) {
+					const data = row.data ?? {};
+					if (row.type === "turn/start" && typeof data["turn"] === "number") turn = data["turn"];
+					if (row.type === "session/title" && typeof data["title"] === "string") parent.title = data["title"];
+					if (row.type === "subagent/catalog" && data["childId"] === sessionId) {
+						if (turn !== void 0) parent.hostTurn = turn;
+						if (typeof data["label"] === "string") parent.label = data["label"];
+					}
+				}
+			} finally {
+				handle.close().catch(() => void 0);
+			}
+		} catch {}
+		this.store.noteParent(sessionId, parent);
+	}
+	/**
+	* Light turn list of one session plus its backfill watermark. The optional
+	* {@link ScopeFilter} restricts rows and aggregates to the authorized
+	* scopes; absent is the unfiltered local semantics.
+	*/
+	async listTurns(sessionId, filter) {
+		await this.backfillMainSession(sessionId);
+		await this.refreshChildren(sessionId, filter);
+		return this.store.listTurns(sessionId, filter);
+	}
+	/**
+	* Move the session's backfill window to the turns ending at `end` (the
+	* latest turns when null) and answer the refreshed turn list. Live turns
+	* stay; the window refills from the log in the same call.
+	*/
+	async loadTurns(sessionId, end, filter) {
+		const pending = this.refreshing.get(`main:${sessionId}`);
+		if (pending !== void 0) await pending;
+		this.store.setWindow(sessionId, end ?? void 0);
+		return this.listTurns(sessionId, filter);
+	}
+	/** One turn's scope/request overview, without segments. */
+	async getTurn(sessionId, turnSeq, filter) {
+		await this.backfillMainSession(sessionId);
+		await this.refreshChildren(sessionId, filter);
+		return this.store.getTurn(sessionId, turnSeq, filter);
+	}
+	/** One request's full four-segment breakdown (a {@link ScopedRefusal} when the filter excludes its scope). */
+	async getRequest(sessionId, seq, filter) {
+		await this.backfillMainSession(sessionId);
+		await this.refreshChildren(sessionId, filter);
+		const request = this.store.getRequest(sessionId, seq, filter);
+		const tools = request !== void 0 && "prefix" in request ? request.prefix?.toolChanges : void 0;
+		if (tools === void 0 || tools.length === 0) return request;
+		return {
+			...request,
+			prefix: {
+				...request.prefix,
+				toolChanges: tools.map((tool) => {
+					const owner = this.toolOwner(tool.name);
+					return owner === void 0 ? tool : {
+						...tool,
+						owner
+					};
+				})
+			}
+		};
+	}
+	/** The declaring package from a registered tool's host-side origin tag (capability-catalog convention); absent when untagged. */
+	toolOwner(name) {
+		try {
+			const definition = this.ctx.get("tools")?.get?.(name);
+			if (typeof definition !== "object" || definition === null) return void 0;
+			const origin = definition[Symbol.for("dsh.tool.origin")];
+			return typeof origin?.owner === "string" ? origin.owner : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** Read the session map through the same backfill and scope-filtered path. */
+	async getSessionTrend(sessionId, filter) {
+		await this.listTurns(sessionId, filter);
+		return this.store.getSessionTrend(sessionId, filter);
+	}
+	/** One turn's whole-turn timing aggregation. */
+	async getTurnTiming(sessionId, turnSeq, filter) {
+		await this.backfillMainSession(sessionId);
+		await this.refreshChildren(sessionId, filter);
+		return this.store.getTurnTiming(sessionId, turnSeq, filter);
+	}
+	/** Release every session buffer, listener, and open child-log handle (plugin dispose). */
+	dispose() {
+		for (const dispose of this.disposers.splice(0)) dispose();
+		this.store.dispose();
+		for (const handle of this.handles.values()) handle.close().catch(() => void 0);
+		this.handles.clear();
+		this.cursors.clear();
+	}
+};
+/** The dispatch-time snapshot of one GenerateOptions (never mutates the frozen input). */
+function snapshotOptions(options) {
+	return {
+		...options.sessionId === void 0 ? {} : { sessionId: options.sessionId },
+		...options.purpose === void 0 ? {} : { purpose: options.purpose },
+		config: {
+			provider: options.provider,
+			model: options.model,
+			...options.reasoningEffort === void 0 ? {} : { reasoningEffort: options.reasoningEffort },
+			...options.temperature === void 0 ? {} : { temperature: options.temperature },
+			...options.maxTokens === void 0 ? {} : { maxTokens: options.maxTokens }
+		},
+		messages: options.messages.map(fromRequestMessage),
+		...options.system === void 0 ? {} : { systemSlot: options.system },
+		...options.tools === void 0 ? {} : { tools: options.tools }
+	};
+}
+//#endregion
+//#region lib/types/remote.js
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** The wire namespace is `requestInspector`. */
+let RequestInspectorRemoteService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _listTurns_decorators;
+	let _loadTurns_decorators;
+	let _getTurn_decorators;
+	let _getRequest_decorators;
+	let _getSessionTrend_decorators;
+	let _getTurnTiming_decorators;
+	return class RequestInspectorRemoteService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_listTurns_decorators = [Remote("listTurns")];
+			_loadTurns_decorators = [Remote("loadTurns")];
+			_getTurn_decorators = [Remote("getTurn")];
+			_getRequest_decorators = [Remote("getRequest")];
+			_getSessionTrend_decorators = [Remote("getSessionTrend")];
+			_getTurnTiming_decorators = [Remote("getTurnTiming")];
+			__esDecorate(this, null, _listTurns_decorators, {
+				kind: "method",
+				name: "listTurns",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listTurns" in obj,
+					get: (obj) => obj.listTurns
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _loadTurns_decorators, {
+				kind: "method",
+				name: "loadTurns",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "loadTurns" in obj,
+					get: (obj) => obj.loadTurns
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getTurn_decorators, {
+				kind: "method",
+				name: "getTurn",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getTurn" in obj,
+					get: (obj) => obj.getTurn
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getRequest_decorators, {
+				kind: "method",
+				name: "getRequest",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getRequest" in obj,
+					get: (obj) => obj.getRequest
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getSessionTrend_decorators, {
+				kind: "method",
+				name: "getSessionTrend",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getSessionTrend" in obj,
+					get: (obj) => obj.getSessionTrend
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getTurnTiming_decorators, {
+				kind: "method",
+				name: "getTurnTiming",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getTurnTiming" in obj,
+					get: (obj) => obj.getTurnTiming
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["requestInspector"];
+		constructor(ctx, _config = {}) {
+			super(ctx, "requestInspectorRemote", { namespace: "requestInspector" });
+			__runInitializers(this, _instanceExtraInitializers);
+		}
+		/** The service core this face delegates to. */
+		get core() {
+			return this.ctx.requestInspector;
+		}
+		/** Light turn list of one session plus its backfill watermark, newest last. */
+		listTurns(sessionId, filter) {
+			return this.core.listTurns(sessionId, filter);
+		}
+		/** Move the backfill window to the turns ending at `end` (latest when null); answers the new turn list. */
+		loadTurns(sessionId, end, filter) {
+			return this.core.loadTurns(sessionId, end, filter);
+		}
+		/** One turn's scope/request overview — the left column, no segments. */
+		getTurn(sessionId, turnSeq, filter) {
+			return this.core.getTurn(sessionId, turnSeq, filter);
+		}
+		/** One request's full four-segment breakdown — the right column. */
+		getRequest(sessionId, seq, filter) {
+			return this.core.getRequest(sessionId, seq, filter);
+		}
+		/** Lightweight session map, with no message bodies. */
+		getSessionTrend(sessionId, filter) {
+			return this.core.getSessionTrend(sessionId, filter);
+		}
+		/** One turn's whole-turn timing aggregation — the 耗时分布 tab. */
+		getTurnTiming(sessionId, turnSeq, filter) {
+			return this.core.getTurnTiming(sessionId, turnSeq, filter);
+		}
+	};
+})();
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name used by loader diagnostics. */
+const name = "context-lens";
+/**
+* Plugin body: provide the service core, then mount the Remote data face.
+*
+* No `static inject`: every seam the capture touches is an event name or a
+* probed service, so a composition missing one (no persistence backend, a host
+* without these events) simply yields an empty panel instead of a failed boot.
+*
+* @param ctx - owning Cordis context.
+* @param config - optional plugin config.
+*/
+function apply(ctx, config = {}) {
+	const service = new InspectorService(ctx, config);
+	ctx.provide("requestInspector", service);
+	ctx.plugin(RequestInspectorRemoteService, {});
+	ctx.effect(() => () => {
+		service.dispose();
+	}, "context-lens: capture shutdown");
+}
+//#endregion
+export { InspectorService, RequestInspectorRemoteService, apply, name };