dsh-context 0.43.0 → 0.44.0

package/lib/index.js

@@ -273,7 +273,8 @@ const DEFAULT_BOUNDS = {
 	maxKeptTurns: 300,
 	maxEvents: 400,
 	maxNodes: 2e3,
-	maxArchiveNodes: 400
+	maxArchiveNodes: 400,
+	maxFileOps: 400
 };
 /**
 * The cordis `Config` validator: strict on keys, defaults on the schema fields; tolerates `undefined` (a patch row without a `config:`
@@ -284,74 +285,27 @@ const Config = z.preprocess((v) => v ?? {}, z.object({
 	maxKeptTurns: z.number().int().min(1).default(DEFAULT_BOUNDS.maxKeptTurns),
 	maxEvents: z.number().int().min(1).default(DEFAULT_BOUNDS.maxEvents),
 	maxNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxNodes),
-	maxArchiveNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxArchiveNodes)
+	maxArchiveNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxArchiveNodes),
+	maxFileOps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxFileOps)
 }).strict());
 function resolveBounds(config) {
 	return Config.parse(config ?? {});
 }
 //#endregion
-//#region src/shared/version.ts
-/**
-* The harness-version gate's shared arithmetic — the supported dsh baseline
-* and the version compare behind it. Runtime code shared by BOTH halves (the
-* host probes and gates; the client displays what the wire record carries),
-* so this module must stay dependency-free.
-*
-* The baseline mirrors the support matrix (AGENTS.md "Compatibility" and the
-* package's `dsh.compatibility.dshReleases` declaration): the oldest dsh
-* release this plugin works on. A harness BELOW it gets the fallback units
-* (host/fallback.ts) instead of the real folds.
-*/
-/** The oldest supported dsh release (see the matrix note above). */
-const BASELINE_DSH_VERSION = "0.1.2-rc.1";
-/**
-* Release-channel rank at an equal X.Y.Z: a final release outranks its
-* release candidates, which outrank betas, which outrank alphas
-* (正式版 > RC > Beta > Alpha).
-*/
-function channelRank(channel) {
-	return channel === "rc" ? 3 : channel === "beta" ? 2 : 1;
-}
-const RELEASE_RANK = 4;
-/**
-* Parse `v?[major].[minor].[patch][-(alpha|beta|rc)[.N]][+build]`, or null
-* when the string is not that shape. Channels other than alpha/beta/rc
-* (nightly, dev, …) do not parse — the gate fails open on them.
-*/
-function parseVersion(version) {
-	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta|rc)(?:\.(\d+))?)?(?:\+[0-9a-z.-]+)?$/i.exec(version.trim());
-	if (match === null) return null;
-	const channel = match[4]?.toLowerCase();
-	return {
-		major: Number(match[1]),
-		minor: Number(match[2]),
-		patch: Number(match[3]),
-		rank: channel === void 0 ? RELEASE_RANK : channelRank(channel),
-		serial: match[5] ? Number(match[5]) : 0
-	};
-}
-/**
-* Total order over parsed versions: X.Y.Z numerically first, then the
-* channel rank, then the prerelease serial.
-*/
-function compareParsed(a, b) {
-	if (a.major !== b.major) return a.major - b.major;
-	if (a.minor !== b.minor) return a.minor - b.minor;
-	if (a.patch !== b.patch) return a.patch - b.patch;
-	if (a.rank !== b.rank) return a.rank - b.rank;
-	return a.serial - b.serial;
-}
+//#region src/shared/estimate.ts
 /**
-* Whether `version` satisfies the supported baseline. FAIL OPEN by design: a
-* version that cannot be parsed (a dev/nightly harness build) must not blank
-* a working deployment, so it passes — the gate trips only on a proven
-* below-baseline release.
+* Token heuristics shared by the host fold and the client boundary — the
+* harness token-meter's own fixed-density figure (dsh-token-meter/estimate.ts:
+* ~4 chars ≈ 1 token, +4 role framing). Priced identically on both sides so a
+* legacy value normalized at the client boundary matches what the host view
+* would have served.
 */
-function meetsBaseline(version, baseline = BASELINE_DSH_VERSION) {
-	const v = parseVersion(version);
-	const b = parseVersion(baseline);
-	if (v === null || b === null) return true;
-	return compareParsed(v, b) >= 0;
+const CHARS_PER_TOKEN$1 = 4;
+const ROLE_OVERHEAD$1 = 4;
+/** Price rendered system-prompt text; 0 for absent/empty/non-string input. */
+function estimateSystemTokens(text) {
+	if (typeof text !== "string" || text.length === 0) return 0;
+	return Math.ceil(text.length / CHARS_PER_TOKEN$1) + ROLE_OVERHEAD$1;
 }
 //#endregion
 //#region src/shared/imageTokens.ts
@@ -499,11 +453,11 @@ function estimateImageTokens(width, height) {
 * (shared/imageTokens.ts), falling back to the meter's JSON price when the
 * attachment's dimensions are unknown.
 */
-const CHARS_PER_TOKEN$1 = 4;
+const CHARS_PER_TOKEN = 4;
 const BLOCK_OVERHEAD = 4;
-const ROLE_OVERHEAD$1 = 4;
+const ROLE_OVERHEAD = 4;
 function estimateToolsTotal(tools) {
-	return tools.length > 0 ? Math.ceil(JSON.stringify(tools).length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD : 0;
+	return tools.length > 0 ? Math.ceil(JSON.stringify(tools).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD : 0;
 }
 /** The `ContentBlock` walkers take `unknown`: block arrays ride the untrusted
 * log, so their element shapes (null and primitives included) are re-proved
@@ -520,10 +474,10 @@ function estimateBlocks(blocks) {
 		switch (block.type) {
 			case "text":
 			case "reasoning":
-				tokens += Math.ceil((block.text || "").length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
+				tokens += Math.ceil((block.text || "").length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
 				break;
 			case "tool-call":
-				tokens += Math.ceil((block.name || "").length / CHARS_PER_TOKEN$1) + Math.ceil((block.arguments || "").length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
+				tokens += Math.ceil((block.name || "").length / CHARS_PER_TOKEN) + Math.ceil((block.arguments || "").length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
 				break;
 			case "tool-result":
 				tokens += estimateBlocks(block.content) + BLOCK_OVERHEAD;
@@ -531,10 +485,10 @@ function estimateBlocks(blocks) {
 			case "image": {
 				const ref = block.attachment;
 				const priced = ref !== null && typeof ref === "object" && typeof ref.width === "number" && typeof ref.height === "number" ? estimateImageTokens(ref.width, ref.height) : null;
-				tokens += (priced ?? Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN$1)) + BLOCK_OVERHEAD;
+				tokens += (priced ?? Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN)) + BLOCK_OVERHEAD;
 				break;
 			}
-			default: tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN$1);
+			default: tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN);
 		}
 	}
 	return tokens;
@@ -546,12 +500,12 @@ function estimateBlocks(blocks) {
 */
 function estimateMessage(message, emptyIsZero = false) {
 	if (emptyIsZero && (message === null || message === void 0 || !Array.isArray(message.content) || message.content.length === 0)) return 0;
-	return estimateBlocks(message?.content) + ROLE_OVERHEAD$1;
+	return estimateBlocks(message?.content) + ROLE_OVERHEAD;
 }
 /** The shared meter heuristic over rendered system-prompt text (shared/estimate.ts). */
 /** Per-tool price for the top-tools display (the total uses dsh's whole-array price). */
 function estimateToolSchema(tool) {
-	return Math.ceil(JSON.stringify(tool).length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
+	return Math.ceil(JSON.stringify(tool).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
 }
 /**
 * Count image blocks in a message payload, recursing into nested content (tool-result blocks carry their inner blocks) — seeds each node's
@@ -610,157 +564,231 @@ function isInjection(source) {
 	return source !== null && source !== void 0 && (typeof source.kind === "string" && source.kind !== "" && source.kind !== "user" || typeof source.form === "string");
 }
 //#endregion
-//#region src/shared/estimate.ts
+//#region src/shared/fileOps.ts
+/** Parse a call's raw JSON arguments; non-string/malformed/non-record inputs yield null. */
+function parseCallArgs(raw) {
+	if (typeof raw !== "string" || raw === "") return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const KIND_BY_TOOL = {
+	read: "read",
+	read_image: "read",
+	write: "write",
+	edit: "write",
+	grep: "search",
+	glob: "search"
+};
+/** The file purpose of a tool, or null for non-file tools (bash, web_search…). */
+function kindOfTool(tool) {
+	if (tool === void 0) return null;
+	return KIND_BY_TOOL[tool] ?? null;
+}
 /**
-* Token heuristics shared by the host fold and the client boundary — the
-* harness token-meter's own fixed-density figure (dsh-token-meter/estimate.ts:
-* ~4 chars ≈ 1 token, +4 role framing). Priced identically on both sides so a
-* legacy value normalized at the client boundary matches what the host view
-* would have served.
+* The file purpose of one executed call. Like {@link kindOfTool} except for
+* the one file tool whose purpose follows its arguments: `str_replace_editor`
+* reads on `view` and writes on every other command (create / str_replace /
+* insert — an unknown command writes too; the call failed and the row keeps
+* its error flag).
 */
-const CHARS_PER_TOKEN = 4;
-const ROLE_OVERHEAD = 4;
-/** Price rendered system-prompt text; 0 for absent/empty/non-string input. */
-function estimateSystemTokens(text) {
-	if (typeof text !== "string" || text.length === 0) return 0;
-	return Math.ceil(text.length / CHARS_PER_TOKEN) + ROLE_OVERHEAD;
+function kindOfCall(tool, args) {
+	if (tool === "str_replace_editor") return args !== null && args.command === "view" ? "read" : "write";
+	return kindOfTool(tool);
 }
-//#endregion
-//#region src/host/headers.ts
 /**
-* The `contextHeaders` session projection unit — the request-header EPOCH
-* METADATA behind the timeline's envelope figures.
-*
-* The hot `contextTimeline` unit carries only token prices of the system
-* prompt and tool schemas; this companion unit keeps the per-epoch METADATA
-* (epoch seq/time boundaries, per-tool token prices and plugin attribution)
-* so the Context browser can pick the header epoch in force at any step and
-* size its sections immediately. The epoch CONTENT (full system prompt text,
-* full tool JSON schemas) deliberately does NOT ride the projection VALUE:
-* session projections are served whole in every `session.list` row, control
-* baseline, push frame, and change notification, so carrying content here
-* multiplied it by sessions × epochs across every channel. The client
-* fetches one epoch's `request/header` event on demand — a seq-anchored
-* history read off the epoch's `seq`, the same targeted read the browser
-* already uses for message content — and caches it per session (history is
-* immutable).
-*
-* Read-compat over the persisted state (the pinned decision behind keeping
-* `stateVersion` at 1): the harness serves a cold session's projections from
-* its CACHED checkpoint rows and has no refresh channel for an idle session
-* — a version bump invalidates every row and orphans the key until the
-* session goes live again (the #37 regression). The state therefore still
-* ACCEPTS the v1 content-bearing record shape, current folds append
-* metadata-only records alongside any seeded legacy ones, and the view
-* normalizes BOTH to the metadata-only wire shape (pricing the legacy system
-* text at read time). Cached v1 rows keep working, new checkpoint writes
-* shrink as legacy epochs age out of the capped list, and the wire — the
-* part every delivery channel carries — is metadata-only from day one.
-*
-* Same projection contract as the timeline unit: pure init/apply/view,
-* `Object.is` reference stability for uninteresting events, plain-JSON
-* bounded state (epoch list capped — see HEADERS_MAX).
+* The operation's target path: the path-ish argument of read/write tools;
+* for searches the narrowing `path`, else the pattern itself (a pathless
+* grep/glob's target IS the pattern — the workspace-wide search text).
 */
-/** Retention cap on header epochs (metadata only; changes are rare; 50 is generous). */
-const HEADERS_MAX = 50;
+function pathOfArgs(tool, args) {
+	if (args === null) return null;
+	if (tool === "grep" || tool === "glob") {
+		const p = args.path;
+		if (typeof p === "string" && p !== "") return p;
+		const pattern = args.pattern;
+		return typeof pattern === "string" && pattern !== "" ? pattern : null;
+	}
+	for (const k of [
+		"file_path",
+		"filePath",
+		"path"
+	]) {
+		const v = args[k];
+		if (typeof v === "string" && v !== "") return v;
+	}
+	return null;
+}
+/** Rendered line count: '' is 0, a trailing newline closes its own line. */
+function linesOf(s) {
+	if (s === "") return 0;
+	let n = 0;
+	for (let i = 0; i < s.length; i++) if (s[i] === "\n") n++;
+	return s.endsWith("\n") ? n : n + 1;
+}
+/** The added/removed pair of one content-bearing argument set, or zeros. */
+function pairOf(added, removed) {
+	return {
+		added: typeof added === "string" ? linesOf(added) : 0,
+		removed: typeof removed === "string" ? linesOf(removed) : 0
+	};
+}
 /**
-* The persisted-state schema: the SUPERSET of both record generations, so a
-* cached v1 row (content-bearing) seeds the fold instead of being discarded.
+* The signed line footprint of one call: an edit removes its old string and
+* adds its new one; a write adds its content (the pre-existing body, if any,
+* is unknowable from the arguments — the estimate stays honest about that);
+* `str_replace_editor` splits the same shapes across its commands. Callers
+* reach here only with parsed args (a null parse yields no path).
 */
-const storedToolSchema = z.object({
-	name: z.string(),
-	tokens: z.number().int().nonnegative(),
-	description: z.string().optional(),
-	plugin: z.string().optional(),
-	schema: z.unknown().optional()
-}).strict();
-const storedEpochSchema = z.object({
-	seq: z.number(),
-	time: z.number(),
-	system: z.string().optional(),
-	systemTokens: z.number().int().nonnegative().optional(),
-	tools: z.array(storedToolSchema)
-}).strict();
-const contextHeadersStateSchema = z.object({ headers: z.array(storedEpochSchema) }).strict();
-/** The wire schema: strict metadata — the shape every delivery channel carries. */
-const headerToolWireSchema = z.object({
-	name: z.string(),
-	tokens: z.number().int().nonnegative(),
-	plugin: z.string().optional()
-}).strict();
-/** Exported for the fallback unit (fallback.ts): one wire contract, one schema. */
-const contextHeadersSchema = z.object({ headers: z.array(z.object({
-	seq: z.number(),
-	time: z.number(),
-	systemTokens: z.number().int().nonnegative().optional(),
-	tools: z.array(headerToolWireSchema)
-}).strict()) }).strict();
-function recordOf(event) {
-	if (event.type !== "request/header") return null;
-	const rawHeader = event.data.header;
-	if (rawHeader === null || rawHeader === void 0 || typeof rawHeader !== "object") return null;
-	const header = rawHeader;
-	const tools = Array.isArray(header.tools) ? header.tools : [];
-	const record = {
-		seq: event.seq,
-		time: event.time,
-		tools: tools.map((t) => {
-			const tool = t !== null && typeof t === "object" ? t : {};
-			const entry = {
-				name: typeof tool.name === "string" ? tool.name : "?",
-				tokens: estimateToolSchema(t)
-			};
-			if (typeof tool.plugin === "string" && tool.plugin !== "") entry.plugin = tool.plugin;
-			return entry;
-		})
+function deltaOf(tool, args) {
+	if (tool === "edit") return pairOf(args.new_string, args.old_string);
+	if (tool === "write") return pairOf(args.content, void 0);
+	if (tool === "str_replace_editor") {
+		if (args.command === "str_replace") return pairOf(args.new_str, args.old_str);
+		if (args.command === "insert") return pairOf(args.new_str, void 0);
+		if (args.command === "create") return pairOf(args.file_text, void 0);
+	}
+	return {
+		added: 0,
+		removed: 0
 	};
-	if (typeof header.system === "string" && header.system.length > 0) record.systemTokens = estimateSystemTokens(header.system);
-	return record;
+}
+/** The exact window a read's result meta reports: `offset` plus the retained
+* `lines` array (the same bounded payload the read card renders from). Null
+* for a foreign or malformed meta. */
+function readWindowOf(meta) {
+	if (meta === null || typeof meta !== "object") return null;
+	const m = meta;
+	if (typeof m.path !== "string" || m.path === "") return null;
+	if (typeof m.offset !== "number" || !Number.isFinite(m.offset) || m.offset < 1) return null;
+	if (!Array.isArray(m.lines) || m.lines.length === 0) return null;
+	return {
+		start: m.offset,
+		count: m.lines.length
+	};
+}
+/** The limit estimate: the tool reads up to `limit` lines from `offset`;
+* absent when the call reads unbounded. */
+function readEstimateOf(args) {
+	const limit = args.limit;
+	return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? {
+		count: Math.floor(limit),
+		est: true
+	} : void 0;
+}
+/** What a read op shows: the exact window off the result meta, else the
+* limit estimate, else nothing (an unbounded read names no footprint). */
+function readOf(meta, args) {
+	const win = readWindowOf(meta);
+	if (win !== null) return {
+		start: win.start,
+		count: win.count
+	};
+	return readEstimateOf(args);
 }
 /**
-* The context-headers projection unit; registered alongside the timeline unit (host/index.ts); clients read it through
-* `useProjection('contextHeaders')` and fetch an epoch's full content on demand via the session history (historyPage.ts).
-* Contract mirror with a REQUIRED `wire` block (see compat.ts).
-* @param resolve - best-effort tool-to-plugin attribution (see toolSources.ts); fills a missing `plugin` at view time so
-* epochs folded without attribution still render a tag when the source is known.
+* A search op's detail: the pattern, with the include filter appended when
+* one narrowed the call. A patternless (malformed) search has no detail.
 */
-function createContextHeadersDefinition(resolve) {
-	const view = (state) => ({ headers: state.headers.map((h) => {
-		const record = {
-			seq: h.seq,
-			time: h.time,
-			tools: h.tools.map((t) => {
-				const entry = {
-					name: t.name,
-					tokens: t.tokens
-				};
-				const plugin = t.plugin ?? (resolve !== void 0 ? resolve(t.name) : void 0);
-				if (plugin !== void 0) entry.plugin = plugin;
-				return entry;
-			})
-		};
-		const systemTokens = h.systemTokens ?? (typeof h.system === "string" && h.system !== "" ? estimateSystemTokens(h.system) : void 0);
-		if (systemTokens !== void 0) record.systemTokens = systemTokens;
-		return record;
-	}) });
-	return {
-		key: "contextHeaders",
-		stateSchema: contextHeadersStateSchema,
-		wire: {
-			viewSchema: contextHeadersSchema,
-			view
-		},
-		init: () => ({ headers: [] }),
-		apply: (state, event) => {
-			const record = recordOf(event);
-			if (record === null) return state;
-			const last = state.headers.at(-1);
-			if (last !== void 0 && last.seq === record.seq) return state;
-			const headers = [...state.headers, record];
-			return { headers: headers.length > HEADERS_MAX ? headers.slice(-50) : headers };
-		},
-		stateVersion: 1
+function searchDetailOf(args) {
+	const pattern = args?.pattern;
+	if (typeof pattern !== "string" || pattern === "") return void 0;
+	const include = args?.include;
+	return typeof include === "string" && include !== "" ? `${pattern} (${include})` : pattern;
+}
+/**
+* The files a search demonstrably reached, read off the result's bounded
+* presentation meta (grep groups matched lines by file; glob lists paths).
+* Only the COMPLETE list attributes: a capped search (`truncated`) names a
+* partial file set, and a malformed meta names none — both fall back to the
+* call's own target. Each entry carries the reported match count.
+*/
+function searchFilesOf(meta) {
+	if (meta === null || typeof meta !== "object") return null;
+	const m = meta;
+	if (m.truncated !== false) return null;
+	const files = [];
+	if (m.shape === "matches" && Array.isArray(m.files)) for (const f of m.files) {
+		if (f === null || typeof f !== "object") continue;
+		const group = f;
+		if (typeof group.path === "string" && group.path !== "" && Array.isArray(group.matches)) files.push({
+			path: group.path,
+			hits: group.matches.length
+		});
+	}
+	else if (m.shape === "paths" && Array.isArray(m.paths)) {
+		for (const p of m.paths) if (typeof p === "string" && p !== "") files.push({
+			path: p,
+			hits: 0
+		});
+	}
+	return files.length > 0 ? files : null;
+}
+/**
+* The one-shot per-call op assembly, uniform across every producer: the
+* host's call/result pairing (args off the armed call, meta off the
+* result), the nested Code-Mode settle (no meta exists on a dispatch — the
+* read window and per-file search attribution degrade to the argument-only
+* forms), and the client's inline-generation join fallback. Returns zero to
+* N records: a search with the complete matched-file meta rows per file;
+* any other file call rows once; a non-file tool (or a call whose arguments
+* resolve no target) rows nothing.
+*/
+function opsOfCall(input) {
+	const args = parseCallArgs(input.argsRaw);
+	const kind = kindOfCall(input.tool, args);
+	if (kind === null) return [];
+	const stamp = {
+		seq: input.seq,
+		kind,
+		tool: input.tool,
+		err: input.err === true,
+		added: 0,
+		removed: 0,
+		path: "",
+		...input.time !== void 0 ? { time: input.time } : {},
+		...input.gone !== void 0 ? { gone: input.gone } : {},
+		...input.parent !== void 0 ? { parent: input.parent } : {},
+		...input.program !== void 0 ? { program: input.program } : {}
 	};
+	if (kind === "search") {
+		const files = searchFilesOf(input.meta);
+		if (files !== null) {
+			const detail = searchDetailOf(args);
+			const target = args !== null ? pathOfArgs(input.tool, args) : null;
+			const narrowed = args !== null && typeof args.path === "string" && args.path !== "";
+			return [...target !== null && !files.some((f) => f.path === target) ? [{
+				...stamp,
+				path: target,
+				...narrowed && detail !== void 0 ? { detail } : {},
+				...narrowed ? {} : { pattern: true }
+			}] : [], ...files.map((f) => ({
+				...stamp,
+				path: f.path,
+				...detail !== void 0 ? { detail } : {},
+				...f.hits > 0 ? { hits: f.hits } : {}
+			}))];
+		}
+	}
+	if (args === null) return [];
+	const path = pathOfArgs(input.tool, args);
+	if (path === null) return [];
+	const { added, removed } = deltaOf(input.tool, args);
+	const narrowed = typeof args.path === "string" && args.path !== "";
+	const detail = kind === "search" && narrowed ? searchDetailOf(args) : void 0;
+	const read = kind === "read" ? readOf(input.meta, args) : void 0;
+	return [{
+		...stamp,
+		path,
+		added,
+		removed,
+		...detail !== void 0 ? { detail } : {},
+		...read !== void 0 ? { read } : {},
+		...kind === "search" && !narrowed ? { pattern: true } : {}
+	}];
 }
 //#endregion
 //#region src/host/fold.ts
@@ -792,6 +820,11 @@ function trimState(st, bounds) {
 	if (countTurnRuns(st.requests) > bounds.maxKeptTurns) st.requests = trimToLastTurns(st.requests, bounds.maxKeptTurns);
 	if (st.requests.length > bounds.maxRequestSteps) st.requests = st.requests.slice(-bounds.maxRequestSteps);
 	if (st.events.length > bounds.maxEvents) st.events = st.events.slice(-bounds.maxEvents);
+	if (st.fileOps.length > bounds.maxFileOps) {
+		const drop = st.fileOps.length - bounds.maxFileOps;
+		st.fileOpsFloor = Math.max(st.fileOpsFloor ?? 0, st.fileOps[drop - 1].seq);
+		st.fileOps = st.fileOps.slice(drop);
+	}
 	if (st.archived.length > 0) {
 		let drop = 0;
 		const oldestReq = st.requests.length > 0 ? st.requests[0].seq : void 0;
@@ -818,7 +851,8 @@ function createTimelineState() {
 		requests: [],
 		events: [],
 		archived: [],
-		callNames: {}
+		callNames: {},
+		fileOps: []
 	};
 }
 function categoryOf(type, message) {
@@ -828,13 +862,58 @@ function categoryOf(type, message) {
 	return "user";
 }
 /**
-* Archive removed surface nodes as stamped COPIES — the objects leaving
-* `st.surface` are shared with the persisted previous state, so `gone` must
-* never be written onto them directly.
+* Mark the detail collections dirty (TimelineState.detailRev). Every caller
+* is a fold branch that just mutated the requests/events/surface/archive;
+* branches that touch only the working slots (stepStart, callNames, the
+* shadow claim) or the envelope scalars do NOT bump — the served detail is
+* unchanged, and an open tab has nothing to refetch.
 */
-function archiveRemoved(st, removed, goneSeq) {
-	for (const n of removed) st.archived.push({
-		...n,
+function bumpDetailRev(st) {
+	st.detailRev = (st.detailRev ?? 0) + 1;
+}
+/**
+* Bound on the buffered nested Code-Mode ops (TimelineState.pendingCodeOps)
+* — a hostile log that dispatches without settling the parent run_code
+* cannot grow the persisted state past this.
+*/
+const PENDING_CODE_OPS_MAX = 200;
+/** JSON-stringify an unknown argument payload; a hostile (cyclic) value yields no args. */
+function argsRawOf(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0 || value === null) return void 0;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+/** Append op records to the fold-derived log (the trim lives in trimState, with the other collections). */
+function pushFileOps(st, ops) {
+	for (const op of ops) st.fileOps.push(op);
+}
+/**
+* Buffer nested Code-Mode ops under their top run_code call id (they flush
+* when the parent's result folds — the ops' locate target). A full buffer
+* drops new arrivals wholesale (defensive logs only).
+*/
+function bufferCodeOps(st, rootCallId, ops) {
+	const pending = st.pendingCodeOps ?? {};
+	let total = 0;
+	for (const k in pending) total += pending[k].length;
+	if (total + ops.length > PENDING_CODE_OPS_MAX) return;
+	st.pendingCodeOps = {
+		...pending,
+		[rootCallId]: [...pending[rootCallId] ?? [], ...ops]
+	};
+}
+/**
+* Archive removed surface nodes as stamped COPIES — the objects leaving
+* `st.surface` are shared with the persisted previous state, so `gone` must
+* never be written onto them directly.
+*/
+function archiveRemoved(st, removed, goneSeq) {
+	for (const n of removed) st.archived.push({
+		...n,
 		gone: goneSeq
 	});
 }
@@ -1130,6 +1209,8 @@ function applyTimeline(state, event, bounds) {
 		events: [...state.events],
 		archived: [...state.archived],
 		callNames: { ...state.callNames },
+		fileOps: [...state.fileOps],
+		...state.pendingCodeOps !== void 0 ? { pendingCodeOps: { ...state.pendingCodeOps } } : {},
 		...state.timing !== void 0 ? { timing: {
 			...state.timing,
 			tools: { ...state.timing.tools }
@@ -1146,13 +1227,16 @@ function applyTimeline(state, event, bounds) {
 				s.systemTokens = estimateSystemTokens(header.system);
 				if (header.config && typeof header.config.model === "string") s.model = header.config.model;
 				if (header.config && typeof header.config.provider === "string") s.provider = header.config.provider;
-				if ((data?.reason === "change" || data?.reason === "resume") && s.model && s.lastModel && s.model !== s.lastModel) s.events.push({
-					seq: event.seq,
-					time: event.time,
-					kind: "model",
-					from: s.lastModel,
-					to: s.model
-				});
+				if ((data?.reason === "change" || data?.reason === "resume") && s.model && s.lastModel && s.model !== s.lastModel) {
+					s.events.push({
+						seq: event.seq,
+						time: event.time,
+						kind: "model",
+						from: s.lastModel,
+						to: s.model
+					});
+					bumpDetailRev(s);
+				}
 				if (s.model) s.lastModel = s.model;
 				break;
 			}
@@ -1166,12 +1250,29 @@ function applyTimeline(state, event, bounds) {
 			case "tool/call":
 				if (data && typeof data.callId === "string" && typeof data.name === "string") {
 					const s = ensure();
+					const argsRaw = argsRawOf(data.arguments);
 					s.callNames[data.callId] = {
 						name: data.name,
-						start: event.time
+						start: event.time,
+						...argsRaw !== void 0 ? { argsRaw } : {}
 					};
 				}
 				break;
+			case "tool/code-dispatch": {
+				const rootCallId = data?.rootCallId;
+				const name = data?.name;
+				if (typeof rootCallId === "string" && typeof name === "string") {
+					const ops = opsOfCall({
+						seq: event.seq,
+						time: event.time,
+						tool: name,
+						argsRaw: argsRawOf(data?.arguments),
+						err: data?.isError === true
+					});
+					if (ops.length > 0) bufferCodeOps(ensure(), rootCallId, ops);
+				}
+				break;
+			}
 			case "assistant/chunk": {
 				const start = state.stepStart;
 				if (start === void 0 || start.firstToken !== void 0) return state;
@@ -1199,6 +1300,7 @@ function applyTimeline(state, event, bounds) {
 			case "user/message": {
 				const msg = deriveEventMessage(event);
 				const s = ensure();
+				bumpDetailRev(s);
 				const node = applySurface(s, event, event.type, data, msg);
 				const source = msg?.source;
 				if (isInjection(source)) {
@@ -1223,8 +1325,34 @@ function applyTimeline(state, event, bounds) {
 			}
 			case "tool/result": {
 				const toolMsg = deriveEventMessage(event);
+				const srcId = (toolMsg?.source)?.callId;
+				const firstBlock = toolMsg?.content?.[0];
+				const blockId = firstBlock?.toolCallId;
+				const pendingEntry = (typeof srcId === "string" ? state.callNames[srcId] : void 0) ?? (typeof blockId === "string" ? state.callNames[blockId] : void 0);
+				const buffered = (typeof srcId === "string" ? state.pendingCodeOps?.[srcId] : void 0) ?? (typeof blockId === "string" ? state.pendingCodeOps?.[blockId] : void 0);
 				const s = ensure();
+				bumpDetailRev(s);
 				const node = applySurface(s, event, event.type, data, toolMsg);
+				if (pendingEntry !== void 0) pushFileOps(s, opsOfCall({
+					seq: event.seq,
+					time: event.time,
+					tool: pendingEntry.name,
+					argsRaw: pendingEntry.argsRaw,
+					meta: data?.meta,
+					err: Boolean(data?.error) || firstBlock?.isError === true
+				}));
+				if (buffered !== void 0 && buffered.length > 0) {
+					const program = parseCallArgs(pendingEntry?.argsRaw)?.description;
+					pushFileOps(s, buffered.map((op) => ({
+						...op,
+						parent: event.seq,
+						...typeof program === "string" && program !== "" ? { program } : {}
+					})));
+					const kept = {};
+					for (const k in s.pendingCodeOps) if (k !== srcId && k !== blockId) kept[k] = s.pendingCodeOps[k];
+					if (Object.keys(kept).length > 0) s.pendingCodeOps = kept;
+					else delete s.pendingCodeOps;
+				}
 				if (node.tool === "skill" || node.tool === void 0) {
 					const name = skillNameOf(toolMsg);
 					if (name !== "") {
@@ -1245,6 +1373,7 @@ function applyTimeline(state, event, bounds) {
 			case "assistant/message": {
 				const usage = data?.usage;
 				const s = ensure();
+				bumpDetailRev(s);
 				const total = s.systemTokens + s.toolsTokens + s.sums.user + s.sums.inject + s.sums.assistant + s.sums.tool;
 				const record = {
 					time: event.time,
@@ -1289,16 +1418,21 @@ function applyTimeline(state, event, bounds) {
 				break;
 			}
 			case "plan/mode":
-				if (data && typeof data.active === "boolean") ensure().events.push({
-					seq: event.seq,
-					time: event.time,
-					kind: "mode",
-					name: data.active ? "plan.on" : "plan.off"
-				});
+				if (data && typeof data.active === "boolean") {
+					const s = ensure();
+					s.events.push({
+						seq: event.seq,
+						time: event.time,
+						kind: "mode",
+						name: data.active ? "plan.on" : "plan.off"
+					});
+					bumpDetailRev(s);
+				}
 				break;
 			case "compaction/summary":
 			case "compaction/prune": {
 				const s = ensure();
+				bumpDetailRev(s);
 				if (data && Array.isArray(data.shadowedSeqs)) {
 					s.pendingShadowedSeqs = data.shadowedSeqs.filter((x) => typeof x === "number");
 					s.pendingShadowEventSeq = event.seq;
@@ -1324,11 +1458,15 @@ function applyTimeline(state, event, bounds) {
 	return state;
 }
 /**
-* Serve the projection's wire view: bound the surface nodes to the newest tail and attach each event to the request around it; stamp
-* COPIES
-* — the persisted state objects are never mutated.
+* The envelope scalars both wire generations share: current composition, the
+* live-surface counters, and the copied cost/timing totals. Served value
+* fields are COPIES — the served value must never alias persisted state.
+* Optional scalars use conditional spread: an unknown value must not
+* materialize an `undefined`-valued property (the lossless-JSON pipeline —
+* a single such property can fail the whole push, the failure mode behind
+* issue #29).
 */
-function buildTimelineView(state, bounds) {
+function headFieldsOf(state) {
 	const surfaceTotal = state.sums.user + state.sums.inject + state.sums.assistant + state.sums.tool;
 	const result = {
 		ok: true,
@@ -1346,11 +1484,11 @@ function buildTimelineView(state, bounds) {
 		},
 		images: state.surface.reduce((n, node) => n + (node.imgs ?? 0), 0),
 		toolCalls: state.surface.reduce((n, node) => node.cat === "tool" ? n + 1 : n, 0),
-		requests: state.requests.map((r) => ({ ...r })),
-		events: state.events.map((e) => ({ ...e })),
+		requests: [],
+		events: [],
 		nodes: [],
 		droppedNodes: 0,
-		archive: state.archived.map((n) => ({ ...n }))
+		archive: []
 	};
 	if (state.cost !== void 0) {
 		const copyFam = (f) => {
@@ -1375,6 +1513,25 @@ function buildTimelineView(state, bounds) {
 			tools
 		};
 	}
+	return result;
+}
+/**
+* The heavy collections: copies of the retained request records and context
+* events (each event attached to the requests around it — the chart's ✂
+* anchoring), the bounded served surface window, and the removed-node
+* archive. Shared verbatim by the inline wire view (channel-less hosts) and
+* the on-demand detail payload (host/detail.ts).
+*/
+function detailCollectionsOf(state, bounds) {
+	const result = {
+		requests: state.requests.map((r) => ({ ...r })),
+		events: state.events.map((e) => ({ ...e })),
+		nodes: [],
+		droppedNodes: 0,
+		archive: state.archived.map((n) => ({ ...n })),
+		fileOps: state.fileOps.map((o) => ({ ...o })),
+		...state.fileOpsFloor !== void 0 ? { fileOpsFloor: state.fileOpsFloor } : {}
+	};
 	const overflowCount = Math.max(0, state.surface.length - bounds.maxNodes);
 	const overflow = state.surface.slice(0, overflowCount);
 	const tail = state.surface.slice(overflowCount);
@@ -1405,6 +1562,354 @@ function buildTimelineView(state, bounds) {
 	}
 	return result;
 }
+/**
+* The split generation's SLIM wire head: the envelope scalars plus the
+* precomputed count figures, the newest request's billing summary (the
+* headline's derived anchor), and the detail revision marker. Small enough
+* to ride every delivery channel whole (~1KB) — the heavy collections moved
+* to the on-demand detail channel (host/detail.ts).
+*/
+function buildTimelineHead(state) {
+	const result = headFieldsOf(state);
+	const turns = /* @__PURE__ */ new Set();
+	for (const r of state.requests) turns.add(r.turn ?? 0);
+	let injects = 0;
+	let compactions = 0;
+	let prunes = 0;
+	for (const e of state.events) if (e.kind === "inject") injects++;
+	else if (e.kind === "compaction") compactions++;
+	else if (e.kind === "prune") prunes++;
+	result.counts = {
+		turns: turns.size,
+		steps: state.requests.length,
+		injects,
+		compactions,
+		prunes
+	};
+	const last = state.requests.at(-1);
+	if (last !== void 0) result.last = {
+		seq: last.seq,
+		total: last.total,
+		...typeof last.prompt === "number" ? { prompt: last.prompt } : {}
+	};
+	result.detailRev = state.detailRev ?? 0;
+	return result;
+}
+/**
+* The on-demand detail payload (host/detail.ts serves it off the live fold
+* state): the heavy collections plus the revision marker the head carries.
+*/
+function buildTimelineDetail(state, bounds) {
+	return {
+		rev: state.detailRev ?? 0,
+		...detailCollectionsOf(state, bounds)
+	};
+}
+/**
+* Serve the INLINE projection wire view (channel-less hosts): the head
+* scalars with the detail collections in place — the shape every delivery
+* channel carried before the split generation. Bound the surface nodes to
+* the newest tail and attach each event to the request around it; stamp
+* COPIES — the persisted state objects are never mutated.
+*/
+function buildTimelineView(state, bounds) {
+	return {
+		...headFieldsOf(state),
+		...detailCollectionsOf(state, bounds)
+	};
+}
+//#endregion
+//#region src/host/detail.ts
+/** The plugin's generic Connection RPC channel (the pre-v0.9 name, kept). */
+const DETAIL_CHANNEL = "/dsh-context";
+/** The RPC failure envelope the transport expects (ConnectionRpcFailure). */
+function failure(code, message) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			details: {}
+		}
+	};
+}
+/**
+* Arm the detail endpoint whenever the connection and sessions services are
+* both composed (see the module header for the load-order contract). The
+* registration rides the injected fiber: either service unloading withdraws
+* the channel and closes the gate.
+*/
+function watchDetailChannel(ctx, bounds) {
+	const gate = { live: false };
+	ctx.inject(["connection", "sessions"], (c) => {
+		const connection = c.get("connection");
+		const sessions = c.get("sessions");
+		const handle = typeof connection?.rpc?.handle === "function" ? connection.rpc.handle.bind(connection.rpc) : void 0;
+		const getSession = typeof sessions?.get === "function" ? sessions.get.bind(sessions) : void 0;
+		if (handle === void 0 || getSession === void 0) return;
+		const projections = ctx.sessionProjections;
+		const handler = async (endpoint, payload) => {
+			if (endpoint !== "detail") return failure("dsh-context/unknown-endpoint", `unknown endpoint: ${endpoint}`);
+			const sessionId = payload !== null && typeof payload === "object" ? payload.sessionId : void 0;
+			if (typeof sessionId !== "string" || sessionId === "") return failure("dsh-context/bad-request", "missing sessionId");
+			try {
+				const session = getSession(sessionId);
+				if (session !== void 0 && session !== null) {
+					const state = projections.stateOf(session, "contextTimeline");
+					if (state === void 0) return {
+						ok: true,
+						value: null
+					};
+					return {
+						ok: true,
+						value: buildTimelineDetail(state, bounds)
+					};
+				}
+				const query = ctx.get("sessionQuery");
+				const observe = typeof query?.observeSession === "function" ? query.observeSession.bind(query) : void 0;
+				if (observe === void 0) return {
+					ok: true,
+					value: null
+				};
+				const observation = await observe(sessionId, { projectionMode: "none" });
+				const events = observation?.events;
+				if (!Array.isArray(events)) return {
+					ok: true,
+					value: null
+				};
+				let state = createTimelineState();
+				try {
+					for (const ev of events) state = applyTimeline(state, ev, bounds);
+				} finally {
+					const dispose = observation?.[Symbol.dispose];
+					if (typeof dispose === "function") dispose.call(observation);
+				}
+				return {
+					ok: true,
+					value: buildTimelineDetail(state, bounds)
+				};
+			} catch (err) {
+				return failure("gateway/internal", err instanceof Error ? err.message : String(err));
+			}
+		};
+		try {
+			c.effect(() => {
+				const unregister = handle(DETAIL_CHANNEL, handler);
+				return () => {
+					unregister();
+				};
+			}, "dsh-context: detail channel");
+		} catch {
+			return;
+		}
+		gate.live = true;
+		return () => {
+			gate.live = false;
+		};
+	});
+	return gate;
+}
+//#endregion
+//#region src/shared/version.ts
+/**
+* The harness-version gate's shared arithmetic — the supported dsh baseline
+* and the version compare behind it. Runtime code shared by BOTH halves (the
+* host probes and gates; the client displays what the wire record carries),
+* so this module must stay dependency-free.
+*
+* The baseline mirrors the support matrix (AGENTS.md "Compatibility" and the
+* package's `dsh.compatibility.dshReleases` declaration): the oldest dsh
+* release this plugin works on. A harness BELOW it gets the fallback units
+* (host/fallback.ts) instead of the real folds.
+*/
+/** The oldest supported dsh release (see the matrix note above). */
+const BASELINE_DSH_VERSION = "0.1.2-rc.1";
+/**
+* Release-channel rank at an equal X.Y.Z: a final release outranks its
+* release candidates, which outrank betas, which outrank alphas
+* (正式版 > RC > Beta > Alpha).
+*/
+function channelRank(channel) {
+	return channel === "rc" ? 3 : channel === "beta" ? 2 : 1;
+}
+const RELEASE_RANK = 4;
+/**
+* Parse `v?[major].[minor].[patch][-(alpha|beta|rc)[.N]][+build]`, or null
+* when the string is not that shape. Channels other than alpha/beta/rc
+* (nightly, dev, …) do not parse — the gate fails open on them.
+*/
+function parseVersion(version) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta|rc)(?:\.(\d+))?)?(?:\+[0-9a-z.-]+)?$/i.exec(version.trim());
+	if (match === null) return null;
+	const channel = match[4]?.toLowerCase();
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		rank: channel === void 0 ? RELEASE_RANK : channelRank(channel),
+		serial: match[5] ? Number(match[5]) : 0
+	};
+}
+/**
+* Total order over parsed versions: X.Y.Z numerically first, then the
+* channel rank, then the prerelease serial.
+*/
+function compareParsed(a, b) {
+	if (a.major !== b.major) return a.major - b.major;
+	if (a.minor !== b.minor) return a.minor - b.minor;
+	if (a.patch !== b.patch) return a.patch - b.patch;
+	if (a.rank !== b.rank) return a.rank - b.rank;
+	return a.serial - b.serial;
+}
+/**
+* Whether `version` satisfies the supported baseline. FAIL OPEN by design: a
+* version that cannot be parsed (a dev/nightly harness build) must not blank
+* a working deployment, so it passes — the gate trips only on a proven
+* below-baseline release.
+*/
+function meetsBaseline(version, baseline = BASELINE_DSH_VERSION) {
+	const v = parseVersion(version);
+	const b = parseVersion(baseline);
+	if (v === null || b === null) return true;
+	return compareParsed(v, b) >= 0;
+}
+//#endregion
+//#region src/host/headers.ts
+/**
+* The `contextHeaders` session projection unit — the request-header EPOCH
+* METADATA behind the timeline's envelope figures.
+*
+* The hot `contextTimeline` unit carries only token prices of the system
+* prompt and tool schemas; this companion unit keeps the per-epoch METADATA
+* (epoch seq/time boundaries, per-tool token prices and plugin attribution)
+* so the Context browser can pick the header epoch in force at any step and
+* size its sections immediately. The epoch CONTENT (full system prompt text,
+* full tool JSON schemas) deliberately does NOT ride the projection VALUE:
+* session projections are served whole in every `session.list` row, control
+* baseline, push frame, and change notification, so carrying content here
+* multiplied it by sessions × epochs across every channel. The client
+* fetches one epoch's `request/header` event on demand — a seq-anchored
+* history read off the epoch's `seq`, the same targeted read the browser
+* already uses for message content — and caches it per session (history is
+* immutable).
+*
+* Read-compat over the persisted state (the pinned decision behind keeping
+* `stateVersion` at 1): the harness serves a cold session's projections from
+* its CACHED checkpoint rows and has no refresh channel for an idle session
+* — a version bump invalidates every row and orphans the key until the
+* session goes live again (the #37 regression). The state therefore still
+* ACCEPTS the v1 content-bearing record shape, current folds append
+* metadata-only records alongside any seeded legacy ones, and the view
+* normalizes BOTH to the metadata-only wire shape (pricing the legacy system
+* text at read time). Cached v1 rows keep working, new checkpoint writes
+* shrink as legacy epochs age out of the capped list, and the wire — the
+* part every delivery channel carries — is metadata-only from day one.
+*
+* Same projection contract as the timeline unit: pure init/apply/view,
+* `Object.is` reference stability for uninteresting events, plain-JSON
+* bounded state (epoch list capped — see HEADERS_MAX).
+*/
+/** Retention cap on header epochs (metadata only; changes are rare; 50 is generous). */
+const HEADERS_MAX = 50;
+/**
+* The persisted-state schema: the SUPERSET of both record generations, so a
+* cached v1 row (content-bearing) seeds the fold instead of being discarded.
+*/
+const storedToolSchema = z.object({
+	name: z.string(),
+	tokens: z.number().int().nonnegative(),
+	description: z.string().optional(),
+	plugin: z.string().optional(),
+	schema: z.unknown().optional()
+}).strict();
+const storedEpochSchema = z.object({
+	seq: z.number(),
+	time: z.number(),
+	system: z.string().optional(),
+	systemTokens: z.number().int().nonnegative().optional(),
+	tools: z.array(storedToolSchema)
+}).strict();
+const contextHeadersStateSchema = z.object({ headers: z.array(storedEpochSchema) }).strict();
+/** The wire schema: strict metadata — the shape every delivery channel carries. */
+const headerToolWireSchema = z.object({
+	name: z.string(),
+	tokens: z.number().int().nonnegative(),
+	plugin: z.string().optional()
+}).strict();
+/** Exported for the fallback unit (fallback.ts): one wire contract, one schema. */
+const contextHeadersSchema = z.object({ headers: z.array(z.object({
+	seq: z.number(),
+	time: z.number(),
+	systemTokens: z.number().int().nonnegative().optional(),
+	tools: z.array(headerToolWireSchema)
+}).strict()) }).strict();
+function recordOf(event) {
+	if (event.type !== "request/header") return null;
+	const rawHeader = event.data.header;
+	if (rawHeader === null || rawHeader === void 0 || typeof rawHeader !== "object") return null;
+	const header = rawHeader;
+	const tools = Array.isArray(header.tools) ? header.tools : [];
+	const record = {
+		seq: event.seq,
+		time: event.time,
+		tools: tools.map((t) => {
+			const tool = t !== null && typeof t === "object" ? t : {};
+			const entry = {
+				name: typeof tool.name === "string" ? tool.name : "?",
+				tokens: estimateToolSchema(t)
+			};
+			if (typeof tool.plugin === "string" && tool.plugin !== "") entry.plugin = tool.plugin;
+			return entry;
+		})
+	};
+	if (typeof header.system === "string" && header.system.length > 0) record.systemTokens = estimateSystemTokens(header.system);
+	return record;
+}
+/**
+* The context-headers projection unit; registered alongside the timeline unit (host/index.ts); clients read it through
+* `useProjection('contextHeaders')` and fetch an epoch's full content on demand via the session history (historyPage.ts).
+* Contract mirror with a REQUIRED `wire` block (see compat.ts).
+* @param resolve - best-effort tool-to-plugin attribution (see toolSources.ts); fills a missing `plugin` at view time so
+* epochs folded without attribution still render a tag when the source is known.
+*/
+function createContextHeadersDefinition(resolve) {
+	const view = (state) => ({ headers: state.headers.map((h) => {
+		const record = {
+			seq: h.seq,
+			time: h.time,
+			tools: h.tools.map((t) => {
+				const entry = {
+					name: t.name,
+					tokens: t.tokens
+				};
+				const plugin = t.plugin ?? (resolve !== void 0 ? resolve(t.name) : void 0);
+				if (plugin !== void 0) entry.plugin = plugin;
+				return entry;
+			})
+		};
+		const systemTokens = h.systemTokens ?? (typeof h.system === "string" && h.system !== "" ? estimateSystemTokens(h.system) : void 0);
+		if (systemTokens !== void 0) record.systemTokens = systemTokens;
+		return record;
+	}) });
+	return {
+		key: "contextHeaders",
+		stateSchema: contextHeadersStateSchema,
+		wire: {
+			viewSchema: contextHeadersSchema,
+			view
+		},
+		init: () => ({ headers: [] }),
+		apply: (state, event) => {
+			const record = recordOf(event);
+			if (record === null) return state;
+			const last = state.headers.at(-1);
+			if (last !== void 0 && last.seq === record.seq) return state;
+			const headers = [...state.headers, record];
+			return { headers: headers.length > HEADERS_MAX ? headers.slice(-50) : headers };
+		},
+		stateVersion: 1
+	};
+}
 //#endregion
 //#region src/host/timeline.ts
 /**
@@ -1485,6 +1990,34 @@ const contextEventSchema = z.object({
 	turn: z.number().optional(),
 	step: z.number().optional()
 }).strict();
+/** The fold-derived file-operation record (shared/types.ts FileOpRecord). */
+const fileOpSchema = z.object({
+	seq: z.number().int().nonnegative(),
+	path: z.string(),
+	kind: z.enum([
+		"read",
+		"write",
+		"search"
+	]),
+	tool: z.string(),
+	time: z.number().optional(),
+	err: z.boolean(),
+	added: z.number().int().nonnegative(),
+	removed: z.number().int().nonnegative(),
+	detail: z.string().optional(),
+	hits: z.number().int().positive().optional(),
+	read: z.union([z.object({
+		start: z.number().int().positive(),
+		count: z.number().int().nonnegative()
+	}).strict(), z.object({
+		count: z.number().int().positive(),
+		est: z.literal(true)
+	}).strict()]).optional(),
+	parent: z.number().int().nonnegative().optional(),
+	program: z.string().optional(),
+	pattern: z.literal(true).optional(),
+	gone: z.number().int().nonnegative().optional()
+}).strict();
 const currentSchema = z.object({
 	system: z.number().int().nonnegative(),
 	tools: z.number().int().nonnegative(),
@@ -1522,7 +2055,28 @@ const unsupportedSchema = z.object({
 	current: z.string(),
 	minimum: z.string()
 }).strict();
-/** Exported for the fallback unit (fallback.ts): one wire contract, one schema. */
+/** The stats board's precomputed count figures (the split head — see Snapshot.counts). */
+const countsSchema = z.object({
+	turns: z.number().int().nonnegative(),
+	steps: z.number().int().nonnegative(),
+	injects: z.number().int().nonnegative(),
+	compactions: z.number().int().nonnegative(),
+	prunes: z.number().int().nonnegative()
+}).strict();
+/** The newest retained request's billing summary (the split head's headline anchor). */
+const lastSchema = z.object({
+	seq: z.number(),
+	total: z.number().int().nonnegative(),
+	prompt: z.number().int().nonnegative().optional()
+}).strict();
+/**
+* One wire contract for both generations: the SPLIT head (envelope scalars +
+* counts/last/detailRev; the heavy collections stay absent — they ride the
+* on-demand detail channel, host/detail.ts) and the INLINE value
+* (channel-less hosts and the fallback unit carry the collections in place).
+* The collections are therefore optional on the schema; the split marker is
+* `detailRev` (present ⟺ split).
+*/
 const contextTimelineSchema = z.object({
 	ok: z.literal(true),
 	unsupported: unsupportedSchema.optional(),
@@ -1532,18 +2086,23 @@ const contextTimelineSchema = z.object({
 	current: currentSchema,
 	images: z.number().int().nonnegative().optional(),
 	toolCalls: z.number().int().nonnegative().optional(),
-	requests: z.array(requestRecordSchema),
-	events: z.array(contextEventSchema),
+	counts: countsSchema.optional(),
+	last: lastSchema.optional(),
+	detailRev: z.number().int().nonnegative().optional(),
+	requests: z.array(requestRecordSchema).optional(),
+	events: z.array(contextEventSchema).optional(),
 	cost: z.object({
 		flash: costFamilySchema.optional(),
 		pro: costFamilySchema.optional()
 	}).strict().optional(),
 	timing: timingTotalsSchema.optional(),
-	nodes: z.array(surfaceNodeSchema),
-	droppedNodes: z.number().int().nonnegative(),
-	archive: z.array(surfaceNodeSchema),
+	nodes: z.array(surfaceNodeSchema).optional(),
+	droppedNodes: z.number().int().nonnegative().optional(),
+	archive: z.array(surfaceNodeSchema).optional(),
 	surfaceFloor: z.number().int().nonnegative().optional(),
-	archiveFloor: z.number().int().nonnegative().optional()
+	archiveFloor: z.number().int().nonnegative().optional(),
+	fileOps: z.array(fileOpSchema).optional(),
+	fileOpsFloor: z.number().int().nonnegative().optional()
 }).strict();
 /**
 * The persisted fold-state schema (the registry's `stateSchema`
@@ -1580,10 +2139,15 @@ const timelineStateSchema = z.object({
 	}).strict().optional(),
 	callNames: z.record(z.string(), z.object({
 		name: z.string(),
-		start: z.number()
+		start: z.number(),
+		argsRaw: z.string().optional()
 	}).strict()),
 	pendingShadowedSeqs: z.array(z.number()).optional(),
-	pendingShadowEventSeq: z.number().optional()
+	pendingShadowEventSeq: z.number().optional(),
+	detailRev: z.number().int().nonnegative().optional(),
+	fileOps: z.array(fileOpSchema),
+	fileOpsFloor: z.number().int().nonnegative().optional(),
+	pendingCodeOps: z.record(z.string(), z.array(fileOpSchema)).optional()
 });
 /**
 * The context-timeline projection unit, created per plugin instance with its
@@ -1603,10 +2167,24 @@ const timelineStateSchema = z.object({
 * `wire` block the registry treats the unit as host-only and never delivers
 * `contextTimeline` to the browser (the Context tab would stay on its
 * loading screen forever).
+*
+* `slim` selects the wire generation PER SERVE (a liveness probe, not a
+* fixed flag): while the on-demand detail channel is live (host/detail.ts),
+* the wire value is the SLIM head (buildTimelineHead) — the heavy
+* collections no longer ride every session.list row, control baseline,
+* follow snapshot, and push frame. Before the channel arms (the connection
+* service may activate after this plugin) or on a deployment whose
+* connection/sessions services never compose, the unit serves the INLINE
+* value so the tab keeps working end to end. Both generations validate
+* against the same schema (the collections are optional on it), and both
+* fold the SAME state — the split is view-only, so no `stateVersion` bump
+* and no cached-row invalidation comes with it (the `detailRev` state field
+* is additive-optional: older rows restore without it and read as revision
+* 0).
 */
-function createContextTimelineDefinition(config) {
+function createContextTimelineDefinition(config, slim) {
 	const bounds = resolveBounds(config);
-	const view = (state) => buildTimelineView(state, bounds);
+	const view = (state) => slim() ? buildTimelineHead(state) : buildTimelineView(state, bounds);
 	return {
 		key: "contextTimeline",
 		stateSchema: timelineStateSchema,
@@ -1616,7 +2194,7 @@ function createContextTimelineDefinition(config) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 13
+		stateVersion: 15
 	};
 }
 //#endregion
@@ -1844,7 +2422,8 @@ function apply(ctx, config) {
 		return;
 	}
 	const attribution = createToolAttribution(ctx);
-	ctx.sessionProjections.register(createContextTimelineDefinition(config));
+	const gate = watchDetailChannel(ctx, resolveBounds(config));
+	ctx.sessionProjections.register(createContextTimelineDefinition(config, () => gate.live));
 	ctx.sessionProjections.register(createContextHeadersDefinition((name) => attribution.ownerOf(name)));
 	installSettings(ctx);
 }