dsh-context 0.64.0 → 0.66.0

package/lib/index.js

@@ -1,21 +1,24 @@
+/**
+ * dsh-context v0.66.0
+ * A DeepSeek Harness plugin for context insight and management, with context dashboard and context command, for understanding how the context is made of, and how it evolves.
+ * @author bowenliang123
+ * @license Apache-2.0
+ * @homepage https://github.com/bowenliang123/dsh-context
+ * @built 2026-10-08T17:44:49+00:00
+ * @commit f60e1a56439b
+ * @commit-date 2026-10-09T01:41:58+08:00
+ */
+
 import { createRequire } from "node:module";
 import { z } from "zod";
-import { SessionLogOffset, deriveEventMessage, interruptedTurnClosers } from "@deepseek-ai/dsh-session";
+import { deriveEventMessage, interruptedTurnClosers } from "@deepseek-ai/dsh-session";
+import z$1 from "@deepseek-ai/schemastery";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, normalize, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import z$1 from "@deepseek-ai/schemastery";
+import { getHeapStatistics } from "node:v8";
 import { randomUUID } from "node:crypto";
 //#region src/shared/providers.ts
-/**
-* The provider-id seam between dsh request envelopes and the models.dev
-* registry: client/cost.ts resolves price-book branches through it, and
-* host/fold.ts uses the DeepSeek resolution to split the session-cost totals
-* into peak/off-peak periods. Only the renames live here — a dsh route key
-* that is not a registry id (user-declared gateways, `claude`/`codex`
-* subscriptions, org-prefixed catalogs) passes through and prices through
-* the model-side resolution index instead (client/cost.ts).
-*/
 const MODELS_DEV_PROVIDER_IDS = {
 	"deepseek-official": "deepseek",
 	"deepseek-account": "deepseek",
@@ -23,38 +26,20 @@ const MODELS_DEV_PROVIDER_IDS = {
 	"minimax-cn": "minimax",
 	"zai-coding-cn": "zhipuai"
 };
-/** The models.dev provider id that prices a dsh provider (identity for unmapped ids). */
 function modelsDevProviderOf(dshProviderId) {
 	return MODELS_DEV_PROVIDER_IDS[dshProviderId] ?? dshProviderId;
 }
-/** Whether a dsh provider prices through DeepSeek's period-based list (peak / half-price off-peak). */
 function isDeepSeekProvider(dshProviderId) {
 	return modelsDevProviderOf(dshProviderId) === "deepseek";
 }
 //#endregion
 //#region src/shared/estimate.ts
-/**
-* 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.
-*/
 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;
 }
-/**
-* Price a `system/message` payload's content exactly like the harness's
-* token-meter (`estimateSystemMessage`): text density over EVERY text block
-* plus role framing, with no per-block overhead — an adapter serializes the
-* prompt as plain text, so a text block costs its characters alone. Any other
-* block (or a hostile element) falls back to its JSON length. 0 for empty
-* content, which the harness reads as "no system prompt".
-*/
 function estimateSystemContent(blocks) {
 	if (!Array.isArray(blocks) || blocks.length === 0) return 0;
 	let characters = 0;
@@ -73,30 +58,9 @@ function estimateSystemContent(blocks) {
 }
 //#endregion
 //#region src/shared/imageTokens.ts
-/**
-* Per-image token estimate for DeepSeek's vision model — a faithful port of
-* the official "图片 Token 计算器" (Image Token Calculator) shipped on the
-* DeepSeek API docs (https://api-docs.deepseek.com/zh-cn/quick_start/token_usage),
-* which implements the provider's own image→token conversion:
-*
-*   - every image is aspect-preserved rescaled before entering the model:
-*     below ~384×384 total pixels it is enlarged, above it is shrunk;
-*   - tokens follow the patch grid (patch 14px, downsample 3), so every
-*     image costs at least 117 and at most ~384 tokens (the documented cap).
-*
-* Verified against the docs calculator itself: 2048×1365→313, 800×600→341,
-* 2048×2048→349, 512×512→201, 100×100→117, 1920×1080→369, 400×900→249.
-* The DSH request pipeline's own 640k-pixel pre-resize does not change the
-* result (the provider formula rescales to the same patch grid), so the
-* durable attachment dimensions can be fed in directly.
-*
-* Pure math shared by the Host fold (message pricing) and the Client
-* (attachment card token badges) — no dependencies, never mutates.
-*/
 const PATCH_SIZE = 14;
 const DOWNSAMPLE_RATIO = 3;
 const MAX_WH_RATIO = 8;
-/** ~384×384 total pixels: smaller images are enlarged before patching. */
 const MIN_PIXELS = 147456;
 const floorDiv = (a, b) => Math.floor(a / b);
 const ceilDiv = (a, b) => Math.floor((a + b - 1) / b);
@@ -106,7 +70,6 @@ function gridTokens(rows, cols) {
 	n += ceilDiv(rows, 2) * (cols + 1) % 2 * 2;
 	return n;
 }
-/** Solve the largest in-grid resize whose token count fits `budget`. */
 function solveResizeRatio(height, width, budget) {
 	const ratio = height / width;
 	const gridW = Math.sqrt((budget - 2) / ratio + .25) - .5;
@@ -116,8 +79,6 @@ function solveResizeRatio(height, width, budget) {
 	let bestWidth;
 	if (gridW < 1) {
 		let rows = floorDiv(budget - 2, 2);
-		/* v8 ignore else -- budget enters at 381 and the tall solve always fits
-		(never decrements), so rows is always odd here; parity-defensive. */
 		if (rows % 2 === 1) rows -= 1;
 		bestWidth = unit;
 		bestHeight = rows * unit;
@@ -144,7 +105,6 @@ function solveResizeRatio(height, width, budget) {
 		numTokens: gridTokens(nLlmH, nLlmW)
 	};
 }
-/** Resize so the patch grid fits the cap, then re-add the pad reserve. */
 function safeResize(height, width, paddedHeight, paddedWidth) {
 	const nLlmH = ceilDiv(floorDiv(paddedHeight, PATCH_SIZE), DOWNSAMPLE_RATIO);
 	const nLlmW = ceilDiv(floorDiv(paddedWidth, PATCH_SIZE), DOWNSAMPLE_RATIO);
@@ -182,10 +142,6 @@ function calcResizeInner(width, height) {
 	const paddedHeight = ceilDiv(h, PATCH_SIZE) * PATCH_SIZE;
 	return safeResize(h, w, paddedHeight, paddedWidth);
 }
-/**
-* Estimate the tokens one image consumes in a DeepSeek vision request from its pixel dimensions. Returns null for non-positive/non-finite
-* dimensions or when the official iteration fails to converge — callers fall back to the generic structural price.
-*/
 function estimateImageTokens(width, height) {
 	if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return null;
 	try {
@@ -197,35 +153,17 @@ function estimateImageTokens(width, height) {
 		}
 		return null;
 	} catch {
-		/* v8 ignore next -- the only throw site is the clamped-away budget guard
-		above; the catch keeps a hostile dimension from ever breaking the fold. */
 		return null;
 	}
 }
 //#endregion
 //#region src/host/pricing.ts
-/**
-* Token pricing — the same fixed-density heuristic as the harness's own
-* token-meter (`dsh-token-meter/estimate.ts`): ~4 chars ≈ 1 token, +4 per
-* content block, +4 role framing. Pure functions over message payloads.
-*
-* One deliberate refinement over the meter: `image` blocks. The meter prices
-* them through its generic JSON branch (~40 tokens for the durable ref),
-* while DeepSeek's vision model actually bills 117-384 tokens per image by
-* pixel dimensions (https://api-docs.deepseek.com/zh-cn/guides/vision/).
-* Image blocks therefore price through the official docs calculator port
-* (shared/imageTokens.ts), falling back to the meter's JSON price when the
-* attachment's dimensions are unknown.
-*/
 const CHARS_PER_TOKEN = 4;
 const BLOCK_OVERHEAD = 4;
 const ROLE_OVERHEAD = 4;
 function estimateToolsTotal(tools) {
 	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
-* here, not trusted from the declared message types. */
 function estimateBlocks(blocks) {
 	let tokens = 0;
 	if (!Array.isArray(blocks)) return 0;
@@ -243,9 +181,6 @@ function estimateBlocks(blocks) {
 			case "tool-call":
 				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;
-				break;
 			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;
@@ -257,24 +192,13 @@ function estimateBlocks(blocks) {
 	}
 	return tokens;
 }
-/**
-* Price one surface message exactly like dsh's token-meter estimate:
-* an empty-content assistant/developer event projects to NO message, so it
-* prices 0; every other message pays content + role framing.
-*/
 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;
 }
-/** 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) + BLOCK_OVERHEAD;
 }
-/**
-* Count image blocks in a message payload, recursing into nested content (tool-result blocks carry their inner blocks) — seeds each node's
-* `imgs`, which the stats board's image cell sums over the LIVE surface (compacted/pruned messages stop counting).
-*/
 function imageCountOf(blocks) {
 	let count = 0;
 	if (!Array.isArray(blocks)) return 0;
@@ -305,13 +229,6 @@ function toolCallNames(blocks) {
 	}
 	return names;
 }
-/**
-* Producer label for an injection event, mirroring the dsh transcript's
-* context provenance (client-runtime context-provenance.ts): workspace
-* instructions name the files they were reconciled from, a plugin source its
-* plugin id, and any other producer its own durable kind. Returns '' when
-* the source is missing or carries no readable identity at all.
-*/
 function injectionSourceName(source) {
 	if (source?.kind === "agent-instructions" && Array.isArray(source.changes)) {
 		const paths = [];
@@ -331,31 +248,6 @@ function isInjection(source) {
 }
 //#endregion
 //#region src/host/logShapes.ts
-/**
-* Shape-driven readers over the durable session-event vocabulary — the ONE
-* place the plugin's log spellings meet. The supported range (dsh
-* 0.1.5-rc.1+, session formats V3/V4) speaks ONE dialect:
-* `system/message` surface nodes, `assistant/message.data.stream` /
-* `assistant/attempt.data.stream` (packed delta runs plus raw chunk
-* records), `SurfaceOp { startSeq, endSeq }`, `tool/ptc-dispatch`.
-*
-* The fold still reads SHAPES, never a detected harness version: the raw log
-* is untrusted input at every layer, and the supported harness refuses —
-* never rewrites — a legacy-format log, so anything that reaches these
-* readers is current-dialect or hostile. Every reader is total over
-* untrusted input — a malformed record yields "nothing here", never a throw
-* (the projection registry drives the fold without an error boundary; one
-* throw stalls the unit's push feed and the browser waits on "loading"
-* forever).
-*
-* @module dsh-context/host/log-shapes
-*/
-/**
-* Whether one raw stream chunk carries a token delta — the first-token
-* marker, mirroring dsh-llm's `isTokenDelta` (a non-empty text or reasoning
-* fragment, or any Tool-call delta carrying arguments or a name); a
-* malformed chunk is simply not a token.
-*/
 function isTokenChunk(chunk) {
 	if (chunk === null || typeof chunk !== "object") return false;
 	const c = chunk;
@@ -366,21 +258,11 @@ function isTokenChunk(chunk) {
 		default: return false;
 	}
 }
-/** Map one `blockType` to its timing bucket (see {@link DecodeKind}). */
 function decodeKindOfBlock(blockType) {
 	if (blockType === "reasoning") return "reasoning";
 	if (blockType === "text") return "text";
 	if (blockType === "tool-call") return "toolarg";
 }
-/**
-* Per-kind decode spans AND counted `block-start` markers inside one embedded
-* assistant stream, tiling [first block-start, endTime]: each `block-start`
-* record owns the interval up to the next one, the last one up to `endTime`.
-* Total over untrusted input — a malformed record is skipped whole (a
-* marker with an unusable time anchors no span and counts nothing), a
-* non-finite boundary yields zero, and a stream with no marker (or not an
-* array) yields all zeros.
-*/
 function decodeTallyOfStream(stream, endTime) {
 	const tally = {
 		spans: {
@@ -413,16 +295,6 @@ function decodeTallyOfStream(stream, endTime) {
 	if (kind !== void 0) tally.spans[kind] += Math.max(0, endTime - since);
 	return tally;
 }
-/**
-* The ORDERED decode spans of one embedded assistant stream — the same
-* ownership rule as {@link decodeTallyOfStream} (each `block-start` marker
-* owns the interval up to the next one, the last one up to `endTime`), but
-* keeping the sequence: the timing strip paints the decode window in stream
-* order. Total over untrusted input, mirroring the tally: a malformed record
-* is skipped whole, an unknown `blockType` leaves its interval unspanned
-* (the caller's residue fill owns it), a zero/negative-length span drops
-* out, and a stream with no marker (or not an array) yields none.
-*/
 function decodeSpansOfStream(stream, endTime) {
 	const spans = [];
 	if (!Array.isArray(stream) || !Number.isFinite(endTime)) return spans;
@@ -450,14 +322,6 @@ function decodeSpansOfStream(stream, endTime) {
 	close(endTime);
 	return spans;
 }
-/**
-* The first token's instant inside one PACKED delta run (`text-chunks` /
-* `reasoning-chunks` / `tool-call-chunks`): the run's base time plus the
-* accumulated inter-member deltas, taken at the first qualifying member —
-* a name-bearing Tool-call run starts at its first member. Mirrors dsh-llm's
-* `runFirstTokenTime`; a non-finite base or delta yields undefined rather
-* than a NaN instant.
-*/
 function runFirstTokenTime(record) {
 	const time0 = record.time0;
 	if (typeof time0 !== "number" || !Number.isFinite(time0)) return void 0;
@@ -475,12 +339,6 @@ function runFirstTokenTime(record) {
 		if (typeof fragment === "string" && fragment !== "") return time;
 	}
 }
-/**
-* The first token's instant inside an embedded assistant stream
-* (`assistant/message.data.stream`, `assistant/attempt.data.stream`), or
-* undefined when the stream carries no token. Mirrors dsh-llm's
-* `assistantStreamFirstTokenTime` over the compact record union.
-*/
 function firstTokenTimeOfStream(stream) {
 	if (!Array.isArray(stream)) return void 0;
 	for (const record of stream) {
@@ -495,12 +353,6 @@ function firstTokenTimeOfStream(stream) {
 		if (time !== void 0) return time;
 	}
 }
-/**
-* The inclusive surface range a replacement op covers, or null for `append`
-* and for any unrecognized/hostile op (which the fold treats as an append).
-* The `startSeq`/`endSeq` endpoints are each accepted only as a finite
-* number, so a hostile op with one malformed endpoint degrades to append.
-*/
 function replaceRangeOf(surfaceOp) {
 	if (surfaceOp === null || typeof surfaceOp !== "object") return null;
 	const op = surfaceOp;
@@ -515,7 +367,6 @@ function replaceRangeOf(surfaceOp) {
 }
 //#endregion
 //#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 {
@@ -533,45 +384,20 @@ const KIND_BY_TOOL = {
 	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;
 }
-/**
-* 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).
-*/
 function kindOfCall(tool, args) {
 	if (tool === "str_replace_editor") return args !== null && args.command === "view" ? "read" : "write";
 	return kindOfTool(tool);
 }
-/**
-* Whether a settled call's arguments can yield an op at all: the file tools
-* plus `str_replace_editor`, whose purpose follows its `command`. The public
-* face of the gate {@link opsOfCall} short-circuits on — callers that decide
-* whether to parse or to KEEP a call's raw arguments ask here instead of
-* restating the tool list.
-*/
 function opBearingTool(tool) {
 	return tool === "str_replace_editor" || kindOfTool(tool) !== null;
 }
-/**
-* Whether a call's raw arguments must ride the fold state
-* (TimelineState.callNames): every op-bearing tool, plus `run_code`, whose
-* `description` labels the ops its nested dispatches book at flush time.
-*/
 function rawArgsNeeded(tool) {
 	return opBearingTool(tool) || tool === "run_code";
 }
-/**
-* 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).
-*/
 function pathOfArgs(tool, args) {
 	if (args === null) return null;
 	if (tool === "grep" || tool === "glob") {
@@ -590,27 +416,18 @@ function pathOfArgs(tool, args) {
 	}
 	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 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).
-*/
 function deltaOf(tool, args) {
 	if (tool === "edit") return pairOf(args.new_string, args.old_string);
 	if (tool === "write") return pairOf(args.content, void 0);
@@ -624,9 +441,6 @@ function deltaOf(tool, args) {
 		removed: 0
 	};
 }
-/** 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;
@@ -638,8 +452,6 @@ function readWindowOf(meta) {
 		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 ? {
@@ -647,8 +459,6 @@ function readEstimateOf(args) {
 		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 {
@@ -657,23 +467,12 @@ function readOf(meta, args) {
 	};
 	return readEstimateOf(args);
 }
-/**
-* 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 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;
@@ -695,16 +494,6 @@ function searchFilesOf(meta) {
 	}
 	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 = opBearingTool(input.tool) ? parseCallArgs(input.argsRaw) : null;
 	const kind = kindOfCall(input.tool, args);
@@ -813,12 +602,6 @@ function trimState(st, bounds) {
 		}
 	}
 }
-/**
-* Bound on the timing strip's painted spans (TimelineState.spans): a count
-* cap, newest tail kept — the same hardcoded-cap family as SYSTEM_NODES_MAX.
-* At ~6–8 spans per step the cap covers a few hundred recent steps, far past
-* the strip's pixel resolution on any real pane.
-*/
 const TIMING_SPANS_MAX = 2e3;
 function createTimelineState() {
 	return {
@@ -850,41 +633,20 @@ function categoryOf(type, message) {
 	if (isInjection(message?.source)) return "inject";
 	return "user";
 }
-/**
-* 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 bumpDetailRev(st) {
 	st.detailRev = (st.detailRev ?? 0) + 1;
 }
-/**
-* Bound on the live system-prompt nodes (TimelineState.systems). The
-* effective figure is the LAST nonempty node, so dropping the oldest can only
-* under-report a pathological log whose newest SYSTEM_NODES_MAX nodes are all
-* empty while an older one still carried text.
-*/
 const SYSTEM_NODES_MAX = 8;
-/** The effective system-prompt price: the last nonempty node, else 0 (the harness's own rule). */
 function systemTokensOf(systems) {
 	for (let i = systems.length - 1; i >= 0; i--) if (systems[i].tokens > 0) return systems[i].tokens;
 	return 0;
 }
-/** Append one system-prompt node, bounding the list (see SYSTEM_NODES_MAX). */
 function pushSystem(st, node) {
 	const systems = [...st.systems ?? [], node];
 	st.systems = systems.length > SYSTEM_NODES_MAX ? systems.slice(-8) : systems;
 	st.systemTokens = systemTokensOf(st.systems);
 }
-/**
-* 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;
@@ -894,15 +656,9 @@ function argsRawOf(value) {
 		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;
@@ -913,24 +669,12 @@ function bufferCodeOps(st, rootCallId, ops) {
 		[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
 	});
 }
-/**
-* Remove every live surface node whose seq the replacement claims, keeping the
-* per-category sums equal to the surviving nodes and archiving the removals.
-* Removal follows the SEQ list, not the declared range: pruned replacement
-* nodes keep their own seqs beyond the range end, so a range-based removal
-* would leave them behind and overcount. Returns the removed nodes.
-*/
 function removeSurfaceSeqs(st, claimed, goneSeq) {
 	if (claimed.size === 0) return [];
 	const kept = [];
@@ -943,44 +687,24 @@ function removeSurfaceSeqs(st, claimed, goneSeq) {
 	st.surface = kept;
 	return removed;
 }
-/**
-* A message nested under data.message. A structural read keeps malformed
-* payloads total and handles developer messages absent from the V3
-* dependency's deriveEventMessage. User messages instead live in data itself.
-*/
 function messageOf$1(data) {
 	const message = data?.message;
 	return message !== null && typeof message === "object" ? message : null;
 }
-/**
-* The first full text block, recursing through nested content blocks (a tool
-* result wraps its text in a `tool-result` block). Unlike `firstText` this
-* must NOT truncate/normalize: the skill name is matched off the raw
-* `<skill_content name="…">` wrapper.
-*/
-function nestedText(blocks) {
+function firstFullText(blocks) {
 	if (!Array.isArray(blocks)) return "";
 	for (const item of blocks) {
 		if (item === null || typeof item !== "object") continue;
 		const block = item;
 		if (block.type === "text" && typeof block.text === "string" && block.text !== "") return block.text;
-		if (block.content !== void 0) {
-			const nested = nestedText(block.content);
-			if (nested !== "") return nested;
-		}
 	}
 	return "";
 }
-/**
-* The skill name a `skill`-tool result carries. Loaded skills are rendered as
-* `<skill_content name="…">…</skill_content>` in the result's text, so the name
-* is recovered from the content rather than trusted from the call envelope.
-*/
 function skillNameOf(msg) {
-	const match = nestedText(msg?.content).match(/<skill_content\s+name="([^"]+)"/);
+	const match = firstFullText(msg !== null && typeof msg === "object" ? msg.content : void 0).match(/<skill_content\s+name="([^"]+)"/);
 	return match === null ? "" : match[1];
 }
-function applySurface(st, ev, type, data, message) {
+function applySurface(st, ev, type, message) {
 	const cat = categoryOf(type, message ?? void 0);
 	const node = {
 		seq: ev.seq,
@@ -1002,10 +726,7 @@ function applySurface(st, ev, type, data, message) {
 		}
 	} else if (type === "tool/result") {
 		const srcId = source?.callId;
-		const blockId = (message?.content?.[0])?.toolCallId;
-		const srcEntry = typeof srcId === "string" ? st.callNames[srcId] : void 0;
-		const blockEntry = srcEntry === void 0 && typeof blockId === "string" ? st.callNames[blockId] : void 0;
-		const toolEntry = srcEntry ?? blockEntry;
+		const toolEntry = typeof srcId === "string" ? st.callNames[srcId] : void 0;
 		if (toolEntry !== void 0) {
 			node.tool = toolEntry.name;
 			const timing = ensureTiming(st);
@@ -1019,12 +740,12 @@ function applySurface(st, ev, type, data, message) {
 				end: ev.time
 			}];
 		}
-		if (typeof srcId === "string" || typeof blockId === "string") {
+		if (typeof srcId === "string") {
 			const kept = {};
-			for (const k in st.callNames) if (k !== srcId && k !== blockId) kept[k] = st.callNames[k];
+			for (const k in st.callNames) if (k !== srcId) kept[k] = st.callNames[k];
 			st.callNames = kept;
 		}
-		if (data?.error || message?.isError === true) node.err = true;
+		if (message?.isError === true) node.err = true;
 	} else if (source?.kind === "skill-invocation") node.skill = typeof source.name === "string" ? source.name : "?";
 	else if (source?.kind === "plugin") {
 		if (source.form === "notice" && typeof source.summary === "string") node.text = source.summary;
@@ -1078,21 +799,6 @@ function applySurface(st, ev, type, data, message) {
 	st.sums[cat] += node.tokens;
 	return node;
 }
-/**
-* One provider-reported usage bucket as a billed count, or null when the
-* field carries no readable number. Accepts finite numbers and numeric
-* strings; fractions round (some gateways report fractional counts) and
-* negatives clamp to 0 — a mis-accounting gateway that reports
-* `cached_tokens > prompt_tokens` drives the disjoint uncached-input figure
-* below zero, and one raw figure in the state would fail the wire and state
-* schemas' `.int().nonnegative()` gates on EVERY later delivery, permanently
-* freezing the projection feed for the session (issue #44). NaN, infinities,
-* and non-numeric values read as absent.
-*
-* Exported for the activity unit (host/activity.ts): the daily ledger re-proves
-* the same durable usage buckets with the same sanitizer, so one raw figure
-* can never enter either fold's state.
-*/
 function tokenCountOf(value) {
 	if (typeof value === "number") return Number.isFinite(value) ? Math.max(0, Math.round(value)) : null;
 	if (typeof value === "string" && value.trim() !== "") {
@@ -1101,15 +807,6 @@ function tokenCountOf(value) {
 	}
 	return null;
 }
-/**
-* DeepSeek's peak windows (the official list: UTC 01:00–04:00 and 06:00–10:00,
-* Monday through Friday — Beijing Time 09:00–12:00 and 14:00–18:00). All other
-* hours, plus entire weekends, bill at the half-price off-peak rate.
-*
-* Exported for the activity unit (host/activity.ts): the daily ledger prices
-* each day's buckets with the same split, so its per-day fees sum to the
-* session-cost totals the timeline fold books.
-*/
 function isPeakUtc(time) {
 	const at = new Date(time);
 	const day = at.getUTCDay();
@@ -1117,26 +814,9 @@ function isPeakUtc(time) {
 	const h = at.getUTCHours();
 	return h >= 1 && h < 4 || h >= 6 && h < 10;
 }
-/**
-* Fold one billed request into the session-cost totals, cloning along the
-* mutated path only (the untouched branch stays shared with the persisted
-* previous state — the apply contract never mutates it in place). The
-* buckets arrive sanitized ({@link BilledUsage}), so the totals stay at the
-* schemas' non-negative safe integers no matter what the provider reported.
-* The key is the request envelope's (provider, model) face — the exact
-* lookup the Client's model-price book resolves (models.dev). A request
-* without a provider still accumulates (under the '' key) and the Client
-* prices it when the model id is unambiguous; without a model there is
-* nothing to price. DeepSeek's period-based list splits the buckets
-* (peak windows at list price, all other hours half price); every other
-* provider books everything under the list-price period.
-*/
-function accumulateCost(st, time, usage) {
-	const model = st.model;
-	if (model === void 0) return;
-	const provider = st.provider ?? "";
+function addBilledUsage(prev, provider, model, time, usage) {
 	const period = isDeepSeekProvider(provider) && !isPeakUtc(time) ? "off" : "peak";
-	const models = st.cost?.[provider] ?? {};
+	const models = prev?.[provider] ?? {};
 	const periods = models[model] ?? {};
 	const b = periods[period] ?? {
 		uncached: 0,
@@ -1155,44 +835,27 @@ function accumulateCost(st, time, usage) {
 		...models,
 		[model]: nextPeriods
 	};
-	st.cost = {
-		...st.cost ?? {},
+	return {
+		...prev ?? {},
 		[provider]: nextModels
 	};
 }
-/**
-* Advance the fold over ONE committed session event under the projection
-* contract. Uninteresting events return the same reference (`Object.is` gates
-* the change feed); any change returns a new reference over a lazy shallow
-* clone, so the persisted state is never mutated in place by the caller.
-* `bounds` come from the plugin config (config.ts) — retention only, they
-* never change the state shape.
-*/
-/** The timing card's per-tool ranking cap: the busiest 16 names are kept. */
+function accumulateCost(st, time, usage) {
+	const model = st.model;
+	if (model === void 0) return;
+	st.cost = addBilledUsage(st.cost, st.provider ?? "", model, time, usage);
+}
 const TOOL_TIMING_CAP = 16;
-/**
-* The interactive Q&A tool (`dsh-tool-ask-user`): its settled result IS the
-* user's answer, so it folds into the human-input tally alongside the user's
-* own messages. One result = one answer submission, however many questions
-* the prompt carried.
-*/
 const ASK_USER_TOOL = "ask_user_question";
-/** The decode buckets of the generation split, in card order (see TimingTotals). */
 const DECODE_KINDS = [
 	"reasoning",
 	"text",
 	"toolarg"
 ];
-/** Non-negative, NaN-proof duration between two instants (hostile times degrade to 0). */
 function durOf(from, to) {
 	if (!Number.isFinite(from) || !Number.isFinite(to)) return 0;
 	return Math.max(0, to - from);
 }
-/**
-* The fold's private timing accumulator: created on first use, and CLONED on
-* every later ensure() (see `applyTimeline`) — the object left in the
-* persisted previous state is never written into in place.
-*/
 function ensureTiming(st) {
 	if (st.timing === void 0) st.timing = {
 		wallMs: 0,
@@ -1205,7 +868,6 @@ function ensureTiming(st) {
 	};
 	return st.timing;
 }
-/** The TimingTotals fields each decode bucket's span and count land in. */
 const DECODE_FIELDS = {
 	reasoning: {
 		ms: "reasoningMs",
@@ -1220,24 +882,11 @@ const DECODE_FIELDS = {
 		n: "toolArgBlocks"
 	}
 };
-/**
-* Fold one block's decode span and count into the totals' generation split
-* (see TimingTotals). A zero span or count stays ABSENT — the field then
-* carries the "nothing was decoded/counted in this bucket" fact without adding
-* dead properties to every pre-split-shaped state, and the card reads absence
-* as 0.
-*/
 function addDecode(timing, kind, ms, blocks) {
 	const field = DECODE_FIELDS[kind];
 	if (ms > 0) timing[field.ms] = (timing[field.ms] ?? 0) + ms;
 	if (blocks > 0) timing[field.n] = (timing[field.n] ?? 0) + blocks;
 }
-/**
-* Tally one completed tool call into the per-name ranking, bounded to
-* TOOL_TIMING_CAP names: repeated names update in place, a new name beyond
-* the cap evicts the smallest tally first (the ranking's tail), so state
-* stays bounded even over a hostile log of unique names.
-*/
 function bumpToolTotals(timing, name, ms) {
 	if (!Object.hasOwn(timing.tools, name)) {
 		if (Object.keys(timing.tools).length >= TOOL_TIMING_CAP) {
@@ -1275,16 +924,6 @@ const CLONE_ALL = [
 ];
 function applyTimeline(state, event, bounds) {
 	let st;
-	/**
-	* The event's private working state: a shallow object clone up front, with
-	* only the named collections cloned into private copies. Everything else
-	* stays shared with the persisted previous state — the apply contract is
-	* "never mutate the previous state in place". Called EXACTLY ONCE per event
-	* (each case names the collections its own path may write into; helpers
-	* never call it), so building afresh per call is safe. The default is the
-	* full clone — a future branch that omits its list degrades to the old
-	* behavior instead of sharing a collection it mutates.
-	*/
 	const ensure = (keys = CLONE_ALL) => {
 		st = { ...state };
 		for (const key of keys) if (key === "surface") st.surface = [...state.surface];
@@ -1334,7 +973,7 @@ function applyTimeline(state, event, bounds) {
 				const op = replaceRangeOf(event.surfaceOp);
 				if (op !== null) {
 					s.systems = (s.systems ?? []).filter((n) => n.seq < op.start || n.seq > op.end);
-					const claimed = /* @__PURE__ */ new Set();
+					const claimed = new Set();
 					for (const n of s.surface) if (n.seq >= op.start && n.seq <= op.end) claimed.add(n.seq);
 					if (removeSurfaceSeqs(s, claimed, event.seq).length > 0) bumpDetailRev(s);
 				}
@@ -1507,7 +1146,7 @@ function applyTimeline(state, event, bounds) {
 					"events"
 				]);
 				bumpDetailRev(s);
-				const node = applySurface(s, event, event.type, data, msg);
+				const node = applySurface(s, event, event.type, msg);
 				const source = msg?.source;
 				if (developer || isInjection(source)) {
 					const rec = {
@@ -1538,10 +1177,8 @@ 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 pendingEntry = typeof srcId === "string" ? state.callNames[srcId] : void 0;
+				const buffered = typeof srcId === "string" ? state.pendingCodeOps?.[srcId] : void 0;
 				const s = ensure([
 					"surface",
 					"sums",
@@ -1551,7 +1188,7 @@ function applyTimeline(state, event, bounds) {
 					"timing"
 				]);
 				bumpDetailRev(s);
-				const node = applySurface(s, event, event.type, data, toolMsg);
+				const node = applySurface(s, event, event.type, toolMsg);
 				if (node.tool === ASK_USER_TOOL) s.humanInputs = (s.humanInputs ?? 0) + 1;
 				if (pendingEntry !== void 0 && pendingEntry.name === ASK_USER_TOOL && state.stepStart !== void 0) s.stepWaits = [...state.stepWaits ?? [], {
 					start: pendingEntry.start,
@@ -1563,7 +1200,7 @@ function applyTimeline(state, event, bounds) {
 					tool: pendingEntry.name,
 					argsRaw: pendingEntry.argsRaw,
 					meta: data?.meta,
-					err: Boolean(data?.error) || toolMsg?.isError === true || firstBlock?.isError === true
+					err: toolMsg?.isError === true
 				}));
 				if (buffered !== void 0 && buffered.length > 0) {
 					const program = parseCallArgs(pendingEntry?.argsRaw)?.description;
@@ -1573,7 +1210,7 @@ function applyTimeline(state, event, bounds) {
 						...typeof program === "string" && program !== "" ? { program } : {}
 					})));
 					const kept = {};
-					for (const k in s.pendingCodeOps) if (k !== srcId && k !== blockId) kept[k] = s.pendingCodeOps[k];
+					for (const k in s.pendingCodeOps) if (k !== srcId) kept[k] = s.pendingCodeOps[k];
 					if (Object.keys(kept).length > 0) s.pendingCodeOps = kept;
 					else delete s.pendingCodeOps;
 				}
@@ -1681,7 +1318,7 @@ function applyTimeline(state, event, bounds) {
 					}
 				}
 				const asstMsg = deriveEventMessage(event);
-				applySurface(s, event, event.type, data, asstMsg);
+				if (applySurface(s, event, event.type, asstMsg).text !== void 0) s.answers = (s.answers ?? 0) + 1;
 				break;
 			}
 			case "session/end-seed": {
@@ -1730,15 +1367,6 @@ function applyTimeline(state, event, bounds) {
 	}
 	return state;
 }
-/**
-* 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 headFieldsOf(state) {
 	const surfaceTotal = state.sums.user + state.sums.inject + state.sums.skill + state.sums.assistant + state.sums.tool;
 	const result = {
@@ -1759,6 +1387,7 @@ function headFieldsOf(state) {
 		images: state.surface.reduce((n, node) => n + (node.imgs ?? 0), 0),
 		toolCalls: state.surface.reduce((n, node) => node.cat === "tool" || node.cat === "skill" && node.tool !== void 0 ? n + 1 : n, 0),
 		humanInputs: state.humanInputs ?? 0,
+		answers: state.answers ?? 0,
 		...state.lastUser !== void 0 ? { lastUser: state.lastUser } : {},
 		requests: [],
 		events: [],
@@ -1792,13 +1421,6 @@ function headFieldsOf(state) {
 	if (state.systems !== void 0 && state.systems.length > 0) result.systems = state.systems.map((n) => ({ ...n }));
 	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 })),
@@ -1840,29 +1462,27 @@ function detailCollectionsOf(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();
+	const turns = 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++;
+	const skills = new Set();
+	for (const e of state.events) {
+		if (e.kind === "inject") injects++;
+		else if (e.kind === "compaction") compactions++;
+		else if (e.kind === "prune") prunes++;
+		if (e.sub === "skill" && typeof e.name === "string" && e.name !== "") skills.add(e.name);
+	}
 	result.counts = {
 		turns: turns.size,
 		steps: state.requests.length,
 		injects,
 		compactions,
-		prunes
+		prunes,
+		skills: skills.size
 	};
 	const last = state.requests.at(-1);
 	if (last !== void 0) result.last = {
@@ -1873,12 +1493,6 @@ function buildTimelineHead(state) {
 	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, the slim head at the SAME cut (the Agent
-* network's cold-node ring fetch renders composition off it), and the
-* revision marker the head carries.
-*/
 function buildTimelineDetail(state, bounds) {
 	return {
 		rev: state.detailRev ?? 0,
@@ -1886,13 +1500,6 @@ function buildTimelineDetail(state, bounds) {
 		...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),
@@ -1900,94 +1507,355 @@ function buildTimelineView(state, bounds) {
 	};
 }
 //#endregion
-//#region src/shared/days.ts
-/** Zero-pad to two digits (no Intl allocation on the hot path). */
-function pad2(n) {
-	return n < 10 ? "0" + String(n) : String(n);
+//#region src/host/config.ts
+const DEFAULT_BOUNDS = {
+	maxRequestSteps: 1500,
+	maxKeptTurns: 300,
+	maxEvents: 400,
+	maxNodes: 2e3,
+	maxArchiveNodes: 400,
+	maxFileOps: 400
+};
+function volatileField(field) {
+	const volatile = field.volatile;
+	return typeof volatile === "function" ? volatile.call(field) : field;
 }
-/**
-* The local calendar-day key of an epoch-ms instant, or null when the time
-* is not a finite number or falls outside the representable date range —
-* untrusted log data can never produce a garbage key.
-*/
-function dayKeyOf(time) {
-	if (!Number.isFinite(time)) return null;
-	const d = new Date(time);
-	const y = d.getFullYear();
-	if (!Number.isFinite(y) || y < 1970 || y > 9999) return null;
-	return `${String(y).padStart(4, "0")}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+function count(defaultValue) {
+	return z$1.number().min(1).step(1).default(defaultValue);
+}
+const Config = z$1.object({
+	maxRequestSteps: count(DEFAULT_BOUNDS.maxRequestSteps),
+	maxKeptTurns: count(DEFAULT_BOUNDS.maxKeptTurns),
+	maxEvents: count(DEFAULT_BOUNDS.maxEvents),
+	maxNodes: count(DEFAULT_BOUNDS.maxNodes),
+	maxArchiveNodes: count(DEFAULT_BOUNDS.maxArchiveNodes),
+	maxFileOps: count(DEFAULT_BOUNDS.maxFileOps),
+	defaultPlacement: volatileField(z$1.union([
+		"all",
+		"tab",
+		"sidebar"
+	]).default("all").loose()),
+	defaultGranularity: volatileField(z$1.union(["step", "turn"]).default("step").loose()),
+	defaultTrendMode: volatileField(z$1.union(["total", "delta"]).default("total").loose()),
+	defaultDeltaBase: volatileField(z$1.union(["step", "turn"]).default("step").loose()),
+	defaultToolSort: volatileField(z$1.union([
+		"size",
+		"count",
+		"name"
+	]).default("count").loose()),
+	defaultFileSort: volatileField(z$1.union([
+		"count",
+		"latest",
+		"path"
+	]).default("count").loose()),
+	insightsEntry: volatileField(z$1.union(["show", "hide"]).default("show").loose()),
+	defaultDurationCurve: volatileField(z$1.union(["show", "hide"]).default("show").loose())
+});
+function resolveBounds(config) {
+	const resolved = Config(config ?? {});
+	return {
+		maxRequestSteps: resolved.maxRequestSteps,
+		maxKeptTurns: resolved.maxKeptTurns,
+		maxEvents: resolved.maxEvents,
+		maxNodes: resolved.maxNodes,
+		maxArchiveNodes: resolved.maxArchiveNodes,
+		maxFileOps: resolved.maxFileOps
+	};
 }
 //#endregion
-//#region src/host/activity.ts
-/**
-* The `contextActivity` session projection unit — the per-day activity
-* ledger behind the Context Dashboard's heatmap and its last-7-days usage
-* chart.
-*
-* The timeline unit (fold.ts) is a "current snapshot" fold: it prices the
-* context as it stands NOW, which cannot draw a per-day chart. This unit
-* folds the same committed event stream into a ledger keyed by local
-* calendar day (shared/days.ts): every assistant settlement adds one
-* completed request to its day and, when the provider reported a usage
-* object, the day's billed-token figure grows by the disjoint buckets
-* (uncached input + cache read + cache write + output — the same semantics
-* the timeline's request records and the official token meter use). Each
-* metered settlement also books its buckets into the day's per-(provider,
-* model, period) pricing record — the same raw material the timeline's
-* session-cost totals carry (SessionCostUsage), so the client prices every
-* day off the SAME model-price book and estimator it prices the KPI band
-* with. Buckets attribute to the day the open STEP STARTED (the turn's
-* initiation, armed by `step/start` and cleared by `step/end` — the
-* timeline fold's own pending-slot protocol), falling back to the
-* settlement instant when no stamp is armed; the peak/off split prices the
-* same instant, so a fee always lands on one day at one rate.
-*
-* One wire contract, one small state: a day entry is two integers plus the
-* optional pricing record, the route in force rides the state (last
-* `request/header` wins), and the retention cap keeps at most
-* {@link MAX_KEPT_DAYS} keys, so the value riding every session-list row
-* stays trivial next to the timeline head. Same projection contract as the
-* sibling units: pure init/apply/view, unknown or malformed events return
-* the state unchanged, and no `undefined`-valued property ever materializes
-* (the plain-JSON persisted-state precondition).
-*/
-/**
-* Retention cap on ledger days. A little over a year of daily-active
-* sessions; the oldest keys drop first (key order IS chronological order).
-*/
-const MAX_KEPT_DAYS = 400;
-const costBucketSchema = z.object({
+//#region src/host/timeline.ts
+const surfaceNodeSchema = z.object({
+	seq: z.number().int().nonnegative(),
+	time: z.number().optional(),
+	cat: z.enum([
+		"user",
+		"inject",
+		"skill",
+		"assistant",
+		"tool"
+	]),
+	tokens: z.number().int().nonnegative(),
+	imgs: z.number().int().nonnegative().optional(),
+	gone: z.number().int().nonnegative().optional(),
+	form: z.string().optional(),
+	name: z.string().optional(),
+	text: z.string().optional(),
+	tool: z.string().optional(),
+	err: z.boolean().optional(),
+	skill: z.string().optional(),
+	calls: z.array(z.string()).optional()
+}).strict();
+const systemPromptNodeSchema = z.object({
+	seq: z.number().int().nonnegative(),
+	time: z.number(),
+	tokens: z.number().int().nonnegative()
+}).strict();
+const requestRecordSchema = z.object({
+	turn: z.number().optional(),
+	step: z.number().optional(),
+	time: z.number(),
+	seq: z.number(),
+	system: z.number().int().nonnegative(),
+	tools: z.number().int().nonnegative(),
+	user: z.number().int().nonnegative(),
+	inject: z.number().int().nonnegative(),
+	assistant: z.number().int().nonnegative(),
+	tool: z.number().int().nonnegative(),
+	total: z.number().int().nonnegative(),
+	prompt: z.number().int().nonnegative().optional(),
+	skill: z.number().int().nonnegative().optional(),
+	cacheRead: z.number().int().nonnegative().optional(),
+	output: z.number().int().nonnegative().optional(),
+	activeMs: z.number().nonnegative().optional(),
+	stepCount: z.number().int().positive().optional()
+}).strict();
+const contextEventSchema = z.object({
+	seq: z.number(),
+	time: z.number(),
+	kind: z.enum([
+		"compaction",
+		"prune",
+		"inject",
+		"model",
+		"mode"
+	]),
+	form: z.string().optional(),
+	tokens: z.number().optional(),
+	count: z.number().optional(),
+	sub: z.string().optional(),
+	name: z.string().optional(),
+	detail: z.string().optional(),
+	from: z.string().optional(),
+	to: z.string().optional(),
+	fromTurn: z.number().optional(),
+	fromStep: z.number().optional(),
+	turn: z.number().optional(),
+	step: z.number().optional()
+}).strict();
+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 timingSpanSchema = z.object({
+	kind: z.enum([
+		"ttft",
+		"reasoning",
+		"text",
+		"toolarg",
+		"tools",
+		"other"
+	]),
+	start: z.number(),
+	end: z.number()
+}).strict();
+const currentSchema = z.object({
+	system: z.number().int().nonnegative(),
+	tools: z.number().int().nonnegative(),
+	user: z.number().int().nonnegative(),
+	inject: z.number().int().nonnegative(),
+	skill: z.number().int().nonnegative(),
+	assistant: z.number().int().nonnegative(),
+	tool: z.number().int().nonnegative(),
+	total: z.number().int().nonnegative()
+}).strict();
+const costBucketsSchema = z.object({
 	uncached: z.number().int().nonnegative(),
 	cacheRead: z.number().int().nonnegative(),
 	cacheWrite: z.number().int().nonnegative(),
 	output: z.number().int().nonnegative()
 }).strict();
-const costModelSchema$1 = z.object({
-	peak: costBucketSchema.optional(),
-	off: costBucketSchema.optional()
+const costModelSchema = z.object({
+	peak: costBucketsSchema.optional(),
+	off: costBucketsSchema.optional()
 }).strict();
-const costUsageSchema$1 = z.record(z.string(), z.record(z.string(), costModelSchema$1));
-const activityDaySchema = z.object({
-	tokens: z.number().int().nonnegative(),
-	requests: z.number().int().nonnegative(),
-	cost: costUsageSchema$1.optional()
+const costModelsSchema = z.record(z.string(), costModelSchema);
+const costUsageSchema = z.record(z.string(), costModelsSchema);
+const toolTimingSchema = z.object({
+	calls: z.number().int().nonnegative(),
+	ms: z.number().nonnegative()
+}).strict();
+const timingTotalsSchema = z.object({
+	wallMs: z.number().nonnegative(),
+	ttftMs: z.number().nonnegative(),
+	genMs: z.number().nonnegative(),
+	reasoningMs: z.number().nonnegative().optional(),
+	reasoningBlocks: z.number().int().nonnegative().optional(),
+	textMs: z.number().nonnegative().optional(),
+	textBlocks: z.number().int().nonnegative().optional(),
+	toolArgMs: z.number().nonnegative().optional(),
+	toolArgBlocks: z.number().int().nonnegative().optional(),
+	speedTokens: z.number().nonnegative().optional(),
+	speedMs: z.number().nonnegative().optional(),
+	calls: z.number().int().nonnegative(),
+	toolsMs: z.number().nonnegative(),
+	toolCalls: z.number().int().nonnegative(),
+	tools: z.record(z.string(), toolTimingSchema)
+}).strict();
+const unsupportedSchema = z.object({
+	current: z.string(),
+	minimum: z.string()
+}).strict();
+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(),
+	skills: z.number().int().nonnegative().optional()
+}).strict();
+const lastSchema = z.object({
+	seq: z.number(),
+	total: z.number().int().nonnegative(),
+	prompt: z.number().int().nonnegative().optional()
+}).strict();
+const contextTimelineSchema = z.object({
+	ok: z.literal(true),
+	unsupported: unsupportedSchema.optional(),
+	model: z.string().optional(),
+	provider: z.string().optional(),
+	contextWindow: z.number().optional(),
+	current: currentSchema,
+	images: z.number().int().nonnegative().optional(),
+	toolCalls: z.number().int().nonnegative().optional(),
+	humanInputs: z.number().int().nonnegative().optional(),
+	answers: z.number().int().nonnegative().optional(),
+	lastUser: z.string().optional(),
+	counts: countsSchema.optional(),
+	last: lastSchema.optional(),
+	detailRev: z.number().int().nonnegative().optional(),
+	requests: z.array(requestRecordSchema).optional(),
+	events: z.array(contextEventSchema).optional(),
+	cost: costUsageSchema.optional(),
+	timing: timingTotalsSchema.optional(),
+	systems: z.array(systemPromptNodeSchema).optional(),
+	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(),
+	fileOps: z.array(fileOpSchema).optional(),
+	fileOpsFloor: z.number().int().nonnegative().optional(),
+	spans: z.array(timingSpanSchema).optional()
+}).strict();
+const timelineStateSchema = z.object({
+	surface: z.array(surfaceNodeSchema),
+	sums: z.object({
+		user: z.number().int().nonnegative(),
+		inject: z.number().int().nonnegative(),
+		skill: z.number().int().nonnegative(),
+		assistant: z.number().int().nonnegative(),
+		tool: z.number().int().nonnegative()
+	}).strict(),
+	systemTokens: z.number().int().nonnegative(),
+	systems: z.array(systemPromptNodeSchema).optional(),
+	toolsTokens: z.number().int().nonnegative(),
+	model: z.string().optional(),
+	provider: z.string().optional(),
+	lastModel: z.string().optional(),
+	contextWindow: z.number().optional(),
+	requests: z.array(requestRecordSchema),
+	turnRuns: z.number().int().nonnegative().optional(),
+	events: z.array(contextEventSchema),
+	archived: z.array(surfaceNodeSchema),
+	cost: costUsageSchema.optional(),
+	archiveFloor: z.number().optional(),
+	timing: timingTotalsSchema.optional(),
+	humanInputs: z.number().int().nonnegative().optional(),
+	answers: z.number().int().nonnegative().optional(),
+	lastUser: z.string().optional(),
+	stepStart: z.object({
+		time: z.number(),
+		firstToken: z.number().optional()
+	}).strict().optional(),
+	stepWaits: z.array(z.object({
+		start: z.number(),
+		end: z.number()
+	}).strict()).optional(),
+	stepApprovals: z.record(z.string(), z.number()).optional(),
+	stepRequestSeq: z.number().optional(),
+	callNames: z.record(z.string(), z.object({
+		name: z.string(),
+		start: z.number(),
+		argsRaw: z.string().optional()
+	}).strict()),
+	pendingShadowedSeqs: z.array(z.number()).optional(),
+	pendingShadowEventSeq: z.number().optional(),
+	detailRev: z.number().int().nonnegative().optional(),
+	fileOps: z.array(fileOpSchema),
+	fileOpsFloor: z.number().int().nonnegative().optional(),
+	spans: z.array(timingSpanSchema),
+	stepSpans: z.array(timingSpanSchema).optional(),
+	pendingCodeOps: z.record(z.string(), z.array(fileOpSchema)).optional()
+});
+function createContextTimelineDefinition(config, slim) {
+	const bounds = resolveBounds(config);
+	const view = (state) => slim() ? buildTimelineHead(state) : buildTimelineView(state, bounds);
+	return {
+		key: "contextTimeline",
+		stateSchema: timelineStateSchema,
+		wire: {
+			viewSchema: contextTimelineSchema,
+			view
+		},
+		init: () => createTimelineState(),
+		apply: (state, event) => applyTimeline(state, event, bounds),
+		stateVersion: 27
+	};
+}
+//#endregion
+//#region src/shared/days.ts
+function dayKeyOf(time) {
+	if (!Number.isFinite(time)) return null;
+	const d = new Date(time);
+	const y = d.getFullYear();
+	if (!Number.isFinite(y) || y < 1970 || y > 9999) return null;
+	return `${String(y).padStart(4, "0")}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+//#endregion
+//#region src/host/activity.ts
+const MAX_KEPT_DAYS = 400;
+const MAX_SKILLS_PER_DAY = 100;
+const activitySkillSchema = z.object({
+	n: z.number().int().nonnegative(),
+	last: z.number()
+}).strict();
+const activityDaySchema = z.object({
+	tokens: z.number().int().nonnegative(),
+	requests: z.number().int().nonnegative(),
+	cost: costUsageSchema.optional(),
+	skills: z.record(z.string(), activitySkillSchema).optional()
 }).strict();
-/** Validate the wire payload before it leaves the host (strict: no drift). */
 const contextActivitySchema = z.object({ days: z.record(z.string(), activityDaySchema) }).strict();
-/** The persisted fold-state schema — validated before a checkpoint row seeds a fold. */
 const activityStateSchema = z.object({
 	days: z.record(z.string(), activityDaySchema),
 	model: z.string().optional(),
 	provider: z.string().optional(),
-	stepStart: z.number().optional()
+	stepStart: z.number().optional(),
+	skillCalls: z.array(z.string()).optional()
 });
-/**
-* One durable usage object's billed buckets, or null when NO bucket is
-* readable (the same rule the timeline fold bills by: a settlement that
-* carried no usage still counts its request without fabricating tokens).
-* Every bucket passes the shared per-bucket sanitizer ({@link tokenCountOf}
-* — fractions round, negatives clamp, garbage reads absent).
-*/
 function billedBucketsOf(value) {
 	if (value === null || typeof value !== "object") return null;
 	const usage = value;
@@ -2003,48 +1871,59 @@ function billedBucketsOf(value) {
 		output: output ?? 0
 	};
 }
-/**
-* Add one settlement's billed buckets to a day's pricing record — the same
-* clone-along-the-mutated-path walk the timeline fold's accumulateCost
-* prices by, so the two folds' records share one shape and one semantics.
-* The pricing period splits off the SAME instant the day bucket does: a fee
-* can never land on one day at the neighbouring window's rate.
-*/
-function pricedDayOf(prev, provider, model, period, usage) {
-	const models = prev?.[provider] ?? {};
-	const periods = models[model] ?? {};
-	const b = periods[period] ?? {
-		uncached: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		output: 0
+function withDayEntry(state, key, entry) {
+	let days = {
+		...state.days,
+		[key]: entry
 	};
+	const keys = Object.keys(days);
+	if (keys.length > MAX_KEPT_DAYS) {
+		keys.sort();
+		const drop = new Set(keys.slice(0, keys.length - MAX_KEPT_DAYS));
+		days = Object.fromEntries(Object.entries(days).filter(([k]) => !drop.has(k)));
+	}
 	return {
-		...prev,
-		[provider]: {
-			...models,
-			[model]: {
-				...periods,
-				[period]: {
-					uncached: b.uncached + usage.input,
-					cacheRead: b.cacheRead + usage.cacheRead,
-					cacheWrite: b.cacheWrite + usage.cacheWrite,
-					output: b.output + usage.output
-				}
-			}
+		...state,
+		days
+	};
+}
+function bookSkillLoad(state, name, time) {
+	const key = dayKeyOf(time);
+	if (key === null) return state;
+	const prev = state.days[key];
+	const existing = prev?.skills?.[name];
+	if (existing === void 0 && prev?.skills !== void 0 && Object.keys(prev.skills).length >= MAX_SKILLS_PER_DAY) return state;
+	const skills = {
+		...prev?.skills,
+		[name]: {
+			n: (existing?.n ?? 0) + 1,
+			last: existing === void 0 ? time : Math.max(existing.last, time)
 		}
 	};
+	return withDayEntry(state, key, {
+		tokens: prev?.tokens ?? 0,
+		requests: prev?.requests ?? 0,
+		...prev?.cost !== void 0 ? { cost: prev.cost } : {},
+		skills
+	});
+}
+function invokedSkillOf(event) {
+	const data = event.data;
+	const carrier = event.type === "developer/message" ? data?.message : data;
+	const source = carrier !== null && typeof carrier === "object" ? carrier.source : void 0;
+	if (source === null || typeof source !== "object") return "";
+	const rec = source;
+	return rec.kind === "skill-invocation" && typeof rec.name === "string" ? rec.name : "";
+}
+function toolResultCallIdOf(message) {
+	if (message === null || typeof message !== "object") return null;
+	const rec = message;
+	if (typeof rec.toolCallId === "string" && rec.toolCallId !== "") return rec.toolCallId;
+	const source = rec.source;
+	if (source === null || typeof source !== "object") return null;
+	const callId = source.callId;
+	return typeof callId === "string" && callId !== "" ? callId : null;
 }
-/**
-* Fold one committed event into the ledger. Four event types advance it:
-* `request/header` tracks the route in force (the timeline fold's rule —
-* last header wins), `step/start`/`step/end` maintain the initiation stamp,
-* and `assistant/message` (the step settlement — both supported log
-* generations) books the day. Everything else returns the state reference
-* unchanged, as does a settlement with no attributable instant. The next
-* state is a copy along the mutated path only — the persisted previous
-* state is never mutated in place.
-*/
 function applyActivity(state, event) {
 	if (event.type === "request/header") {
 		const config = event.data?.header?.config;
@@ -2077,6 +1956,33 @@ function applyActivity(state, event) {
 		if (event.data?.inherited !== true) return state;
 		return { days: {} };
 	}
+	if (event.type === "user/message" || event.type === "developer/message") {
+		const name = invokedSkillOf(event);
+		return name === "" ? state : bookSkillLoad(state, name, event.time);
+	}
+	if (event.type === "tool/call") {
+		const data = event.data;
+		const callId = data?.callId;
+		if (data?.name !== "skill" || typeof callId !== "string" || callId === "") return state;
+		const pending = state.skillCalls ?? [];
+		if (pending.includes(callId)) return state;
+		return {
+			...state,
+			skillCalls: [...pending, callId].slice(-100)
+		};
+	}
+	if (event.type === "tool/result") {
+		const message = event.data?.message;
+		const callId = toolResultCallIdOf(message);
+		const pending = state.skillCalls;
+		if (callId === null || pending === void 0 || !pending.includes(callId)) return state;
+		const skillCalls = pending.filter((id) => id !== callId);
+		const next = { ...state };
+		if (skillCalls.length > 0) next.skillCalls = skillCalls;
+		else delete next.skillCalls;
+		const name = skillNameOf(message);
+		return name === "" ? next : bookSkillLoad(next, name, event.time);
+	}
 	if (event.type !== "assistant/message") return state;
 	const initiated = state.stepStart !== void 0 ? state.stepStart : event.time;
 	const key = dayKeyOf(initiated);
@@ -2085,40 +1991,14 @@ function applyActivity(state, event) {
 	const buckets = billedBucketsOf(data?.usage);
 	const prev = state.days[key];
 	let cost = prev?.cost;
-	if (buckets !== null && state.model !== void 0) {
-		const provider = state.provider ?? "";
-		const period = isDeepSeekProvider(provider) && !isPeakUtc(initiated) ? "off" : "peak";
-		cost = pricedDayOf(cost, provider, state.model, period, buckets);
-	}
-	const entry = {
+	if (buckets !== null && state.model !== void 0) cost = addBilledUsage(cost, state.provider ?? "", state.model, initiated, buckets);
+	return withDayEntry(state, key, {
 		tokens: (prev === void 0 ? 0 : prev.tokens) + (buckets === null ? 0 : buckets.input + buckets.cacheRead + buckets.cacheWrite + buckets.output),
 		requests: (prev === void 0 ? 0 : prev.requests) + 1,
-		...cost !== void 0 ? { cost } : {}
-	};
-	let days = {
-		...state.days,
-		[key]: entry
-	};
-	const keys = Object.keys(days);
-	if (keys.length > MAX_KEPT_DAYS) {
-		keys.sort();
-		const drop = new Set(keys.slice(0, keys.length - MAX_KEPT_DAYS));
-		days = Object.fromEntries(Object.entries(days).filter(([k]) => !drop.has(k)));
-	}
-	return {
-		...state,
-		days
-	};
+		...cost !== void 0 ? { cost } : {},
+		...prev?.skills !== void 0 ? { skills: prev.skills } : {}
+	});
 }
-/**
-* The daily-activity projection unit, registered alongside the timeline and
-* headers units (host/index.ts); the overview reads it through the session
-* list's projection column. `stateVersion` 3: the fold resets the ledger at
-* the tagged fork/seed boundary, so a seeded session's days count post-seed
-* activity only (issue #94) — cached rows for seeded forks read
-* version-stale on upgrade and the dashboard's warm-up cold-refolds them
-* from the durable log, which drops the inherited prefix they booked.
-*/
 function createContextActivityDefinition() {
 	return {
 		key: "contextActivity",
@@ -2129,17 +2009,9 @@ function createContextActivityDefinition() {
 			viewSchema: contextActivitySchema,
 			view: (state) => ({ days: Object.fromEntries(Object.entries(state.days).map(([k, v]) => [k, { ...v }])) })
 		},
-		stateVersion: 3
+		stateVersion: 4
 	};
 }
-/**
-* Recover the MCP server display label from a proxied tool name, or undefined
-* for non-MCP names. `dsh-mcp-client` names tools `mcp__<server>__<rawName>`
-* (normalized, and hash-appended when overlong/invalid — the label then shows
-* whatever of the server survived the truncation). The separating `__` is the
-* LAST one in the name, and it must sit AFTER the `mcp__` prefix: the prefix's
-* own separator (or an empty server right after it) is not a server.
-*/
 function mcpServerOf(name) {
 	if (!name.startsWith("mcp__")) return void 0;
 	const cut = name.lastIndexOf("__");
@@ -2147,23 +2019,13 @@ function mcpServerOf(name) {
 	const server = name.slice(5, cut);
 	return server.length > 0 ? server : void 0;
 }
-/** The `mcp:<server>` display label of a proxied tool name, or undefined. */
 function mcpSourceOf(name) {
 	const server = mcpServerOf(name);
 	return server !== void 0 ? `mcp:${server}` : void 0;
 }
-/** The pinned package of a first-party tool name, or undefined. */
 function pinnedSourceOf(name) {
 	return FIRST_PARTY_SOURCES[name];
 }
-/**
-* Pinned first-party tool → plugin package map (see header comment). One entry
-* per model-facing name of the shipped tool packages in the official
-* tool-schema catalog of the supported dsh baseline; names are verified
-* stable across the supported harness range. Packages that mount under
-* distinct names per composition (bash/pwsh persistent variants, the
-* `subagent_fork` fixed-route alias) map to their primary package.
-*/
 const FIRST_PARTY_SOURCES = Object.freeze({
 	read: "@deepseek-ai/dsh-tool-fs",
 	write: "@deepseek-ai/dsh-tool-fs",
@@ -2202,68 +2064,8 @@ const FIRST_PARTY_SOURCES = Object.freeze({
 });
 //#endregion
 //#region src/host/attribution.ts
-/**
-* Live tool→plugin attribution layered on the static recovery in
-* toolSources.ts.
-*
-* The session log records tools as plain `ToolSchema` entries (name /
-* description / parameters) — the registering plugin is not in there.
-* toolSources.ts derives the deterministic sources (harness-logged field,
-* `mcp:<server>` naming, pinned first-party map). This module additionally
-* watches RUNTIME registrations: cordis fires the `internal/get` waterfall on
-* every context read of a service property, passing the READING context as the
-* first argument, so `reader.fiber.name` identifies the plugin that is about
-* to call `register()`.
-*
-* - The `internal/get` handler records the reading fiber's NAME — a scalar,
-*   never the reader context, which would pin the caller's whole agent — and
-*   wraps the tools service's `register` (once per underlying instance —
-*   cordis hands out a fresh traced proxy per read of a tracked service, so
-*   the proxy is peeled to the stable instance first; an earlier wrapper of a
-*   previous hook incarnation is peeled back to the original, so a plugin
-*   reload re-wraps without stacking) to capture the reader at registration
-*   time into a live map. Every wrapper is undone when the plugin unloads:
-*   the original `register` goes back on the instance, unless a newer hook
-*   incarnation re-wrapped it first (that incarnation's own cleanup then
-*   owns the restore).
-* - When the reader slot is missing, root-named, or this plugin's own (e.g.
-*   LOCAL-LINK plugins — dev installs via `dsh plugin add <path>` or
-*   npm/pnpm link — whose anonymous entrypoints make cordis fall back to the
-*   root name), the wrapped `register` falls back to the call stack: the first
-*   frame outside this package is resolved to its nearest `package.json`
-*   `name`. That covers both npm installs (`node_modules/<pkg>`) and local
-*   links (any directory carrying a package.json), which never pass through
-*   node_modules. Frames that resolve back to this package are skipped.
-* - `ownerOf(name)` prefers the name-derived `mcp:<server>` label (it names
-*   the actual provider, where the live record would only ever name the MCP
-*   proxy client), then the LIVE record — for a post-boot registration it is
-*   the truth, even when the name collides with a pinned first-party tool —
-*   then the pinned map (the boot-time guess for tools registered before the
-*   hook), and finally tags tools that were ALREADY registered when the hook
-*   installed (the boot snapshot — third-party bundles, e.g. local links like
-*   dsh-file-claim, that applied before dsh-context) with the
-*   `UNKNOWN_TOOL_SOURCE` sentinel: their registering plugin is unknowable,
-*   and a bare gap would read as "no plugin" instead of "unknown plugin".
-*
-* Best-effort by design: a read separated from `register()` by an `await` can
-* be overwritten by another plugin's read (misattribution) and the stack
-* fallback needs a resolvable package.json — both degrade to the name/pinned
-* chain; registrations that predate the hook degrade to the unknown tag. The
-* hook costs roughly +1.4us per service-property read and is negligible on
-* the rare register path (the stack walk only runs when the reader slot is
-* unusable, and its package lookups are cached per directory).
-*/
-/** This module's own file URL — the stack walk skips its own frames. */
 const selfUrl = normalize(fileURLToPath(import.meta.url));
-/** Directory → package-name cache for the synchronous walk below. */
-const packageCache = /* @__PURE__ */ new Map();
-/**
-* Best-effort package name for a module file: walk up to the nearest
-* `package.json` carrying a `name`. Works for dependencies installed under
-* `node_modules` as well as local links whose package root is any on-disk
-* directory. The per-directory results are cached.
-* @param file - absolute path of a module file.
-*/
+const packageCache = new Map();
 function packageNameFrom(file) {
 	let dir = dirname(file);
 	for (let depth = 0; depth < 12; depth++) {
@@ -2284,31 +2086,11 @@ function packageNameFrom(file) {
 	}
 }
 const FRAME_POSITION = /:\d+:\d+$/;
-/** Symbol cordis registers (`Symbol.for`) on its traced proxies: reading it
-* yields the wrapped target — the stable underlying service instance. */
 const CORDIS_ORIGINAL = Symbol.for("cordis.original");
-/**
-* Peel cordis's per-read traced proxy of a tracked service (dsh's ToolRuntime
-* is one — every `ctx.tools` read returns a fresh proxy closing over the
-* reader's context) down to the instance it wraps, so identity-keyed
-* bookkeeping sees one stable object. Plain service objects pass through
-* unchanged.
-* @param tools - the value as handed out by a context read.
-*/
 function rawInstanceOf(tools) {
 	return tools?.[CORDIS_ORIGINAL] ?? tools;
 }
-/** Package name of this module's own package (self-fallbacks are filtered). */
 const selfPackage = packageNameFrom(selfUrl);
-/**
-* Resolve the registering package from a stack trace: walk frames from the
-* innermost out, skipping this module's own frames and frames that resolve to
-* this package, and return the package name of the first frame that resolves
-* elsewhere. Works with both `file://` URLs and bare absolute paths
-* (transpiled modules render without a scheme), with optional `fn (...)` and
-* `async` wrappers.
-* @param stack - `Error().stack`, or undefined when no fallback is desired.
-*/
 function callerPackageFrom(stack) {
 	if (!stack) return void 0;
 	for (const raw of stack.split("\n").slice(1)) {
@@ -2333,16 +2115,9 @@ function callerPackageFrom(stack) {
 		if (name !== void 0 && name !== selfPackage) return name;
 	}
 }
-/**
-* Install the runtime-attribution hook on a cordis app context. The hook
-* rides the calling fiber's lifetime (`ctx.on`, and an effect that restores
-* every patched `register`), so it is disposed with the plugin.
-* @param ctx - the context the dsh-context plugin runs in; its fiber name is
-* excluded from attributions.
-*/
 function createToolAttribution(ctx) {
-	const live = /* @__PURE__ */ new Map();
-	const wrapped = /* @__PURE__ */ new WeakSet();
+	const live = new Map();
+	const wrapped = new WeakSet();
 	const self = ctx.fiber.name;
 	let lastReader;
 	const patched = [];
@@ -2357,7 +2132,7 @@ function createToolAttribution(ctx) {
 		const wrappedRegister = function(definition) {
 			const toolName = definition?.name;
 			let owner = lastReader;
-			if (!owner || owner === "root" || owner === self) owner = callerPackageFrom((/* @__PURE__ */ new Error()).stack);
+			if (!owner || owner === "root" || owner === self) owner = callerPackageFrom(new Error().stack);
 			const dispose = original.call(this, definition);
 			if (typeof toolName === "string" && owner && owner !== "root" && owner !== self && owner !== selfPackage) {
 				live.set(toolName, owner);
@@ -2389,7 +2164,7 @@ function createToolAttribution(ctx) {
 	}, "tools.register attribution");
 	const toolsService = rawInstanceOf(ctx.get("tools", false));
 	wrapInstance(toolsService);
-	const boot = /* @__PURE__ */ new Set();
+	const boot = new Set();
 	try {
 		const toolEntries = toolsService?.layers?.global?.tools;
 		if (toolEntries !== void 0 && typeof toolEntries.entries === "function") for (const [name] of toolEntries.entries()) boot.add(name);
@@ -2397,53 +2172,34 @@ function createToolAttribution(ctx) {
 	return { ownerOf: (name) => mcpSourceOf(name) ?? live.get(name) ?? pinnedSourceOf(name) ?? (boot.has(name) ? "<unknown-plugin>" : void 0) };
 }
 //#endregion
+//#region src/host/connection.ts
+function fetchRouteRegistrar(connection) {
+	return typeof connection?.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
+}
+//#endregion
 //#region src/host/balance.ts
-/** The plugin's balance route, under the authenticated `/api` fence. */
 const BALANCE_ROUTE = "/api/dsh-context/balance";
-/** The settings id the DeepSeek API-key provider has served its connection
-* section under: the V3 registered namespace, kept as the entry id on V4+
-* product profiles. */
 const DEEPSEEK_SETTINGS_NS = "llm-deepseek";
-/** llm-deepseek's default credential ref (the env-var name its section resolves). */
-const DEFAULT_API_KEY_ENV = "DEEPSEEK_API_KEY";
-/** The platform's public API root (llm-deepseek's PUBLIC_BASE_URL default). */
 const PUBLIC_BASE_URL = "https://api.deepseek.com";
-/** One platform read's whole budget — never worth blocking the route longer. */
 const FETCH_TIMEOUT_MS = 1e4;
-/** Narrow an unknown value to a string-keyed record, or null. */
-function asRecord$1(value) {
+function asRecord$2(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-/** One platform amount ('110.00', or an already-numeric producer variant), or null. */
 function amountOf(value) {
 	const n = typeof value === "string" ? Number(value) : value;
 	return typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : null;
 }
-/**
-* The DeepSeek API-key provider's settings section, read through whichever
-* face the running line serves. V3's `get` reads the registered
-* `llm-deepseek` section directly; V4+ retired that face, so its `describe()`
-* projection is folded instead — the provider's row is the one whose served
-* value declares the top-level `apiKeyEnv` credential ref (the volatile shape
-* only that provider declares at the section root), preferred under the entry
-* ids the generations have served it as (`llm-deepseek` on product profiles,
-* `llm-deepseek-api-key` elsewhere). Rows fold in isolation — a hostile row
-* drops whole, valid siblings keep serving — and a describe that throws is no
-* section at all.
-*/
 function deepseekSectionOf(ctx) {
 	const settings = ctx.get("settings");
-	const section = typeof settings?.get === "function" ? asRecord$1(settings.get(DEEPSEEK_SETTINGS_NS)) : null;
-	if (section !== null) return section;
 	if (typeof settings?.describe !== "function") return null;
 	try {
 		const rows = settings.describe();
 		if (!Array.isArray(rows)) return null;
 		let shaped = null;
 		for (const row of rows) try {
-			const record = asRecord$1(row);
+			const record = asRecord$2(row);
 			if (record === null) continue;
-			const value = asRecord$1(record.value);
+			const value = asRecord$2(record.value);
 			if (value === null || typeof value.apiKeyEnv !== "string" || value.apiKeyEnv === "") continue;
 			if (record.ns === DEEPSEEK_SETTINGS_NS || record.ns === "llm-deepseek-api-key") return value;
 			shaped ??= value;
@@ -2455,16 +2211,10 @@ function deepseekSectionOf(ctx) {
 		return null;
 	}
 }
-/**
-* Resolve the DeepSeek connection facts exactly as llm-deepseek serves its
-* requests: its settings row for the credential ref and endpoint, the
-* credentials service for the key. `null` whenever any fact is missing —
-* the platform is simply not configured for this deployment.
-*/
 async function resolveFacts(ctx) {
 	const section = deepseekSectionOf(ctx);
 	if (section === null) return null;
-	const apiKeyEnv = typeof section.apiKeyEnv === "string" && section.apiKeyEnv !== "" ? section.apiKeyEnv : DEFAULT_API_KEY_ENV;
+	const apiKeyEnv = section.apiKeyEnv;
 	const baseUrl = typeof section.baseURL === "string" && section.baseURL !== "" ? section.baseURL : PUBLIC_BASE_URL;
 	const credentials = ctx.get("credentials");
 	const resolve = typeof credentials?.resolve === "function" ? credentials.resolve.bind(credentials) : void 0;
@@ -2481,22 +2231,13 @@ async function resolveFacts(ctx) {
 		apiKey
 	};
 }
-/**
-* Narrow the platform's payload to the wire value (the boundary rigor every
-* parser owes untrusted input): each entry's currency and parts are re-proved
-* and the total is the two summed — the platform's own `total_balance` rounds
-* independently of them, so it can land a cent away from what the breakdown
-* beside it adds up to, and the viewer's arithmetic is the authority. An entry
-* failing the shape drops whole, and a payload with no valid entry is no
-* balance at all.
-*/
 function balanceOfPayload(value) {
-	const data = asRecord$1(value);
+	const data = asRecord$2(value);
 	if (data === null) return null;
 	const infos = Array.isArray(data.balance_infos) ? data.balance_infos : [];
 	const balances = [];
 	for (const info of infos) try {
-		const entry = asRecord$1(info);
+		const entry = asRecord$2(info);
 		if (entry === null) continue;
 		const currency = entry.currency;
 		const granted = amountOf(entry.granted_balance);
@@ -2516,19 +2257,9 @@ function balanceOfPayload(value) {
 		balances
 	} : null;
 }
-/** The outbound platform fetch through the real global fetch. */
 const defaultFetcher = (url, init) => fetch(url, init);
 let fetcher = defaultFetcher;
 let inFlight = null;
-/**
-* One platform read for these facts, shared by the identical reads already in
-* flight. Each read that finds none goes to the platform: the account's
-* balance moves with every request the harness bills, so a remembered figure
-* would disagree with the console page the capsule links to. The client's own
-* open-time read is the rate limit. Every failure path — transport, timeout,
-* non-ok status, malformed payload — resolves `null`; the route never throws
-* into the transport.
-*/
 async function readBalance(facts) {
 	if (inFlight !== null) return inFlight;
 	inFlight = (async () => {
@@ -2552,16 +2283,9 @@ async function readBalance(facts) {
 		inFlight = null;
 	}
 }
-/**
-* Serve the balance route whenever the connection service composes (see
-* host/detail.ts for the load-order contract). The registration rides the
-* injected fiber: the service unloading withdraws the route. A rejecting
-* registry only closes the capsule — never the plugin.
-*/
 function watchBalanceChannel(ctx) {
 	ctx.inject(["connection"], (c) => {
-		const connection = c.get("connection");
-		const register = typeof connection?.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
+		const register = fetchRouteRegistrar(c.get("connection"));
 		if (register === void 0) return;
 		const handler = async () => {
 			const facts = await resolveFacts(ctx);
@@ -2584,69 +2308,61 @@ function watchBalanceChannel(ctx) {
 	});
 }
 //#endregion
+//#region src/host/coldRead.ts
+const HIGH_WATER = 2 / 3;
+function v8Reading() {
+	const stats = getHeapStatistics();
+	return {
+		used: stats.used_heap_size,
+		limit: stats.heap_size_limit
+	};
+}
+const noop = () => {};
+function makeColdReadGate(reading = v8Reading) {
+	const clear = () => {
+		try {
+			const { used, limit } = reading();
+			if (!Number.isFinite(used) || !Number.isFinite(limit) || limit <= 0) return true;
+			return used < limit * HIGH_WATER;
+		} catch {
+			return true;
+		}
+	};
+	let tail = Promise.resolve();
+	return { admit(read) {
+		const run = tail.then(() => clear() ? read() : void 0);
+		tail = run.then(noop, noop);
+		return run;
+	} };
+}
+//#endregion
 //#region src/host/backfill.ts
-/** The plugin's warm-up trigger route, under the authenticated `/api` fence. */
 const BACKFILL_ROUTE = "/api/dsh-context/backfill";
-/**
-* Inter-session pacing so a multi-hundred-session backfill never starve the
-* host: each cold read is a full durable-log decode, and a boot-time host
-* under sustained read pressure stalls its own client handshake (the
-* workspace sidebar rides it), so the pass breathes between sessions.
-*/
 const YIELD_MS = 100;
-/**
-* The `name` family dsh raises for a durable log it cannot interpret. The
-* format edge throws `SessionFormatUnsupportedMigrationError`, but the
-* persistence seam translates it — together with every other "intact yet not
-* interpretable" refusal — into `SessionFormatUnsupportedError` before the
-* error escapes (issue #75): classify by the family prefix, since either
-* exact name may be the one that arrives.
-*/
 const UNSUPPORTED_FORMAT = "SessionFormatUnsupported";
-function asRecord(value) {
+function asRecord$1(value) {
 	return value !== null && typeof value === "object" ? value : null;
 }
-/** One listed record's header, re-proved: id and cwd are the two fields the run relies on. */
 function headerOf(record) {
-	const header = asRecord(asRecord(record)?.header);
+	const header = asRecord$1(asRecord$1(record)?.header);
 	if (header === null) return null;
 	if (typeof header.id !== "string" || header.id === "") return null;
 	return header;
 }
-/** The probe keys: the projection keys the cache must already serve. */
 const PROBE_KEYS = ["contextActivity", "contextTimeline"];
-/**
-* Probe the cache through the face the running generation serves. The older
-* spelling is tried first and the newer one answers the fallback: on a
-* 0.1.7-rc.2 cache the 3-arg call binds the branded offset onto `keys`,
-* where `new Set(0)` throws as soon as a served record is reached — while a
-* record-less session returns `undefined` without throwing, which is the
-* correct "not served" either way. On 0.1.5-rc.1 the 3-arg face answers
-* directly; if it ever throws there, the 2-arg retry degrades to the same
-* "not served" verdict through the caller's catch.
-*/
-function cachedSnapshotOf(cache, header) {
-	try {
-		return cache.cachedSnapshot(header, SessionLogOffset(0), PROBE_KEYS);
-	} catch {
-		return cache.cachedSnapshot(header, PROBE_KEYS);
-	}
-}
-/** Whether the cache already serves BOTH projection rows for this header (nothing to backfill). */
 function servesRows(cache, header) {
 	try {
-		const values = asRecord(asRecord(cachedSnapshotOf(cache, header))?.values);
+		const values = asRecord$1(asRecord$1(cache.cachedSnapshot(header, PROBE_KEYS))?.values);
 		return values !== null && values.contextActivity !== void 0 && values.contextTimeline !== void 0;
 	} catch {
 		return false;
 	}
 }
-/** Read one stored log through a read handle, mirroring dsh-session-query's readColdSessionLog. */
 async function readColdLog(persistence, id, signal) {
 	const handle = await persistence.open(id, "read", { signal });
 	let events;
 	try {
-		const result = asRecord(await handle.read(0, void 0, { signal }))?.events;
+		const result = asRecord$1(await handle.read(0, void 0, { signal }))?.events;
 		events = Array.isArray(result) ? result : [];
 	} catch (error) {
 		try {
@@ -2661,12 +2377,6 @@ async function readColdLog(persistence, id, signal) {
 		events: [...events, ...interruptedTurnClosers(events)]
 	};
 }
-/**
-* Whether one session is live (folds for itself — a cold write would only
-* race its own checkpoints). A throwing registry read conservatively skips
-* the session too: better to leave a row unfolded than to write over a
-* possibly-live one.
-*/
 function isLive(sessions, id) {
 	if (sessions === null || typeof sessions.get !== "function") return false;
 	try {
@@ -2675,21 +2385,13 @@ function isLive(sessions, id) {
 		return true;
 	}
 }
-/**
-* Whether the cold read failed because the running harness refuses this log's
-* format — a permanent, source-side refusal (the artifact is left unchanged,
-* so retrying cannot succeed). Matched by the error's documented `name`, so no
-* dsh symbol needs importing and every supported baseline classifies alike: an
-* unknown error shape just falls to the warn path.
-*/
 function isUnsupportedFormat(error) {
 	try {
-		return String(asRecord(error)?.name).startsWith(UNSUPPORTED_FORMAT);
+		return String(asRecord$1(error)?.name).startsWith(UNSUPPORTED_FORMAT);
 	} catch {
 		return false;
 	}
 }
-/** The error's printable form — a hostile error may throw on its own toString. */
 function messageOf(error) {
 	try {
 		return String(error);
@@ -2697,14 +2399,7 @@ function messageOf(error) {
 		return "unprintable error";
 	}
 }
-/**
-* Arm the warm-up behind its trigger route. The route flips `requested`
-* when the dashboard first opens; the cold-path faces compose `launch`.
-* Either half may land first; the first request after both launches the one
-* pass, and every later request is a no-op. Returns the deferred injects'
-* disposer (abort on unload).
-*/
-function watchActivityBackfill(ctx) {
+function watchActivityBackfill(ctx, coldReads = makeColdReadGate()) {
 	let requested = false;
 	let started = false;
 	let launch = null;
@@ -2714,8 +2409,7 @@ function watchActivityBackfill(ctx) {
 		launch();
 	};
 	const routeFiber = ctx.inject(["connection"], (c) => {
-		const connection = c.get("connection");
-		const register = typeof connection?.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
+		const register = fetchRouteRegistrar(c.get("connection"));
 		if (register === void 0) return;
 		try {
 			c.effect(() => register({
@@ -2739,19 +2433,20 @@ function watchActivityBackfill(ctx) {
 		"sessions"
 	], (raw) => {
 		const injected = raw;
-		const query = asRecord(injected.sessionQuery);
-		const cache = asRecord(injected.sessionProjectionCache);
-		const persistence = asRecord(injected.sessionPersistence);
+		const query = asRecord$1(injected.sessionQuery);
+		const cache = asRecord$1(injected.sessionProjectionCache);
+		const persistence = asRecord$1(injected.sessionPersistence);
 		if (query === null || typeof query.listSessions !== "function") return;
 		if (cache === null || typeof cache.cachedSnapshot !== "function" || typeof cache.coldSnapshot !== "function") return;
 		if (persistence === null || typeof persistence.open !== "function") return;
-		const sessions = asRecord(injected.sessions);
+		const sessions = asRecord$1(injected.sessions);
 		const abort = new AbortController();
 		const run = async () => {
 			const listed = await query.listSessions(abort.signal);
 			if (!Array.isArray(listed)) return;
 			let folded = 0;
 			let refused = 0;
+			let paused = false;
 			for (const record of listed) {
 				if (abort.signal.aborted) return;
 				const header = headerOf(record);
@@ -2759,8 +2454,14 @@ function watchActivityBackfill(ctx) {
 				if (isLive(sessions, header.id)) continue;
 				if (servesRows(cache, header)) continue;
 				try {
-					const log = await readColdLog(persistence, header.id, abort.signal);
-					cache.coldSnapshot(log.header, log.inheritedEventCount, log.events);
+					if (await coldReads.admit(async () => {
+						const log = await readColdLog(persistence, header.id, abort.signal);
+						cache.coldSnapshot(log.header, log.inheritedEventCount, log.events);
+						return true;
+					}) === void 0) {
+						paused = true;
+						break;
+					}
 					folded++;
 				} catch (error) {
 					if (isUnsupportedFormat(error)) {
@@ -2771,6 +2472,7 @@ function watchActivityBackfill(ctx) {
 				await new Promise((resolve) => setTimeout(resolve, YIELD_MS));
 			}
 			if (folded > 0) ctx.logger.info(`dsh-context: projection rows backfilled for ${folded} session(s)`);
+			if (paused) ctx.logger.info("dsh-context: projection backfill stopped early under heap pressure (remaining sessions refold on their next live activity)");
 			if (refused > 0) ctx.logger.info(`dsh-context: projection backfill skipped ${refused} session(s) (legacy log format is not migratable; sources left unchanged)`);
 		};
 		launch = () => {
@@ -2788,96 +2490,11 @@ function watchActivityBackfill(ctx) {
 	};
 }
 //#endregion
-//#region src/host/config.ts
-/**
-* dsh-context entry configuration — the `config:` block of the `dsh-context`
-* loader row in cordis.yml, plus the per-user display preferences.
-*
-* The schema is schemastery so both consumers it must serve accept it: cordis
-* validates the entry config through the schema's Standard Schema face before
-* `apply` runs (defaults per field, unknown keys merged through), and the
-* harness's Config-form generation (dsh 0.1.7+) derives the Plugins page's
-* live form from this same schema — there the namespace is the entry id
-* (`dsh-context`) and only the `.volatile()` preference fields are served and
-* editable. Bounds edits remount the entry (the folds read them at apply);
-* preference edits commit volatile-only and never remount. On the older lines
-* the preferences are inert here — their surface is the registered settings
-* namespace (settings.ts). The `Config` type describes the RESOLVED shape
-* cordis hands to `apply`; the raw patch values are partial and the schema
-* fills every default.
-*/
-const DEFAULT_BOUNDS = {
-	maxRequestSteps: 1500,
-	maxKeptTurns: 300,
-	maxEvents: 400,
-	maxNodes: 2e3,
-	maxArchiveNodes: 400,
-	maxFileOps: 400
-};
-/**
-* Mark a field live-editable where the harness's schemastery ships the
-* `.volatile()` modifier (the Config-form generation reads the mark to serve
-* the field on the Plugins page); a plain field on the older lines whose
-* schemastery predates the modifier.
-*/
-function volatileField(field) {
-	const volatile = field.volatile;
-	return typeof volatile === "function" ? volatile.call(field) : field;
-}
-/** One bounded positive-integer count. */
-function count(defaultValue) {
-	return z$1.number().min(1).step(1).default(defaultValue);
+//#region src/host/detail.ts
+const DETAIL_ROUTE = "/api/dsh-context/detail";
+function reply(value) {
+	return Response.json(value, { headers: { "cache-control": "no-store" } });
 }
-/** The cordis `Config` validator and the Config-form generation's served schema. */
-const Config = z$1.object({
-	maxRequestSteps: count(DEFAULT_BOUNDS.maxRequestSteps),
-	maxKeptTurns: count(DEFAULT_BOUNDS.maxKeptTurns),
-	maxEvents: count(DEFAULT_BOUNDS.maxEvents),
-	maxNodes: count(DEFAULT_BOUNDS.maxNodes),
-	maxArchiveNodes: count(DEFAULT_BOUNDS.maxArchiveNodes),
-	maxFileOps: count(DEFAULT_BOUNDS.maxFileOps),
-	defaultPlacement: volatileField(z$1.union([
-		"all",
-		"tab",
-		"sidebar"
-	]).default("all").loose()),
-	defaultGranularity: volatileField(z$1.union(["step", "turn"]).default("step").loose()),
-	defaultTrendMode: volatileField(z$1.union(["total", "delta"]).default("total").loose()),
-	defaultDeltaBase: volatileField(z$1.union(["step", "turn"]).default("step").loose()),
-	defaultToolSort: volatileField(z$1.union([
-		"size",
-		"count",
-		"name"
-	]).default("count").loose()),
-	defaultFileSort: volatileField(z$1.union([
-		"count",
-		"latest",
-		"path"
-	]).default("count").loose()),
-	insightsEntry: volatileField(z$1.union(["show", "hide"]).default("show").loose()),
-	defaultDurationCurve: volatileField(z$1.union(["show", "hide"]).default("show").loose())
-});
-/** Resolve the fold's retention bounds (the schema fills every default). */
-function resolveBounds(config) {
-	const resolved = Config(config ?? {});
-	return {
-		maxRequestSteps: resolved.maxRequestSteps,
-		maxKeptTurns: resolved.maxKeptTurns,
-		maxEvents: resolved.maxEvents,
-		maxNodes: resolved.maxNodes,
-		maxArchiveNodes: resolved.maxArchiveNodes,
-		maxFileOps: resolved.maxFileOps
-	};
-}
-//#endregion
-//#region src/host/detail.ts
-/** The plugin's detail route, under the authenticated `/api` fence. */
-const DETAIL_ROUTE = "/api/dsh-context/detail";
-/** One JSON reply of the detail route. */
-function reply(value) {
-	return Response.json(value, { headers: { "cache-control": "no-store" } });
-}
-/** The typed failure envelope (the same shape the Connection RPC carried). */
 function failure(code, message) {
 	return reply({
 		ok: false,
@@ -2887,18 +2504,11 @@ function failure(code, message) {
 		}
 	});
 }
-/**
-* Serve the detail route 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 route and closes the gate.
-*/
-function watchDetailChannel(ctx, bounds) {
+function watchDetailChannel(ctx, bounds, coldReads = makeColdReadGate()) {
 	const gate = { live: false };
 	ctx.inject(["connection", "sessions"], (c) => {
-		const connection = c.get("connection");
 		const sessions = c.get("sessions");
-		const register = typeof connection?.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
+		const register = fetchRouteRegistrar(c.get("connection"));
 		const getSession = typeof sessions?.get === "function" ? sessions.get.bind(sessions) : void 0;
 		if (register === void 0 || getSession === void 0) return;
 		const projections = ctx.sessionProjections;
@@ -2930,22 +2540,21 @@ function watchDetailChannel(ctx, bounds) {
 					ok: true,
 					value: null
 				});
-				const observation = await observe(sessionId, { projectionMode: "none" });
-				const events = observation?.events;
-				if (!Array.isArray(events)) return reply({
-					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 reply({
 					ok: true,
-					value: buildTimelineDetail(state, bounds)
+					value: await coldReads.admit(async () => {
+						const observation = await observe(sessionId, { projectionMode: "none" });
+						const events = observation?.events;
+						if (!Array.isArray(events)) return 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 buildTimelineDetail(state, bounds);
+					}) ?? null
 				});
 			} catch (err) {
 				return failure("gateway/internal", err instanceof Error ? err.message : String(err));
@@ -2970,33 +2579,11 @@ function watchDetailChannel(ctx, bounds) {
 }
 //#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 (docs/compatibility.md 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.5-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).
-*/
+const BASELINE_DSH_VERSION = "0.1.7-rc.2";
 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;
@@ -3009,10 +2596,6 @@ function parseVersion(version) {
 		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;
@@ -3020,12 +2603,6 @@ function compareParsed(a, b) {
 	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);
@@ -3034,46 +2611,7 @@ function meetsBaseline(version, baseline = BASELINE_DSH_VERSION) {
 }
 //#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(),
@@ -3089,13 +2627,11 @@ const storedEpochSchema = z.object({
 	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(),
@@ -3122,13 +2658,6 @@ function recordOf(event) {
 		})
 	};
 }
-/**
-* 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 = {
@@ -3168,382 +2697,8 @@ function createContextHeadersDefinition(resolve) {
 	};
 }
 //#endregion
-//#region src/host/timeline.ts
-/**
-* The `contextTimeline` session projection unit — the plugin's data plane.
-*
-* This is the whole Host half after the v0.9 data-path migration: instead of
-* serving snapshots over a custom `/dsh-context` RPC channel, the plugin
-* registers one pure projection unit on the harness's
-* `ctx.sessionProjections` registry. The framework then:
-*   - drives the fold per committed `session/event` (eager, incremental),
-*   - persists the unit state through `ctx.sessionProjectionCache`
-*     (checkpointed rows, cold-read ladder, resume-safe),
-*   - delivers finished values to the browser as a `session/projection` push
-*     frame plus a tail-page baseline, where the Client reads them through
-*     the framework-standard `useProjection('contextTimeline')` seat.
-*
-* The unit is pure mathematics (init/apply/view) — it holds no subscriptions
-* and never touches the client. The wire value is the same Snapshot the UI
-* has always rendered (shared/types.ts), so the Client renders unchanged.
-*/
-/** Validate the wire payload before it leaves the host (strict: no drift). */
-const surfaceNodeSchema = z.object({
-	seq: z.number().int().nonnegative(),
-	time: z.number().optional(),
-	cat: z.enum([
-		"user",
-		"inject",
-		"skill",
-		"assistant",
-		"tool"
-	]),
-	tokens: z.number().int().nonnegative(),
-	imgs: z.number().int().nonnegative().optional(),
-	gone: z.number().int().nonnegative().optional(),
-	form: z.string().optional(),
-	name: z.string().optional(),
-	text: z.string().optional(),
-	tool: z.string().optional(),
-	err: z.boolean().optional(),
-	skill: z.string().optional(),
-	calls: z.array(z.string()).optional()
-}).strict();
-/** One live system-prompt node (shared/types.ts SystemPromptNode). */
-const systemPromptNodeSchema = z.object({
-	seq: z.number().int().nonnegative(),
-	time: z.number(),
-	tokens: z.number().int().nonnegative()
-}).strict();
-const requestRecordSchema = z.object({
-	turn: z.number().optional(),
-	step: z.number().optional(),
-	time: z.number(),
-	seq: z.number(),
-	system: z.number().int().nonnegative(),
-	tools: z.number().int().nonnegative(),
-	user: z.number().int().nonnegative(),
-	inject: z.number().int().nonnegative(),
-	assistant: z.number().int().nonnegative(),
-	tool: z.number().int().nonnegative(),
-	total: z.number().int().nonnegative(),
-	prompt: z.number().int().nonnegative().optional(),
-	/**
-	* Skill-machinery tokens (issue #66). The fold writes it on every record;
-	* optional so rows folded before the category existed still parse.
-	*/
-	skill: z.number().int().nonnegative().optional(),
-	cacheRead: z.number().int().nonnegative().optional(),
-	output: z.number().int().nonnegative().optional(),
-	/**
-	* The request's step active milliseconds (see RequestRecord.activeMs).
-	* Optional so a record whose step never closed (the live tail) still parses.
-	*/
-	activeMs: z.number().nonnegative().optional(),
-	stepCount: z.number().int().positive().optional()
-}).strict();
-const contextEventSchema = z.object({
-	seq: z.number(),
-	time: z.number(),
-	kind: z.enum([
-		"compaction",
-		"prune",
-		"inject",
-		"model",
-		"mode"
-	]),
-	form: z.string().optional(),
-	tokens: z.number().optional(),
-	count: z.number().optional(),
-	sub: z.string().optional(),
-	name: z.string().optional(),
-	detail: z.string().optional(),
-	from: z.string().optional(),
-	to: z.string().optional(),
-	fromTurn: z.number().optional(),
-	fromStep: z.number().optional(),
-	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();
-/** One painted span of the timing strip (shared/types.ts TimingSpan). */
-const timingSpanSchema = z.object({
-	kind: z.enum([
-		"ttft",
-		"reasoning",
-		"text",
-		"toolarg",
-		"tools",
-		"other"
-	]),
-	start: z.number(),
-	end: z.number()
-}).strict();
-const currentSchema = z.object({
-	system: z.number().int().nonnegative(),
-	tools: z.number().int().nonnegative(),
-	user: z.number().int().nonnegative(),
-	inject: z.number().int().nonnegative(),
-	skill: z.number().int().nonnegative(),
-	assistant: z.number().int().nonnegative(),
-	tool: z.number().int().nonnegative(),
-	total: z.number().int().nonnegative()
-}).strict();
-const costBucketsSchema = z.object({
-	uncached: z.number().int().nonnegative(),
-	cacheRead: z.number().int().nonnegative(),
-	cacheWrite: z.number().int().nonnegative(),
-	output: z.number().int().nonnegative()
-}).strict();
-const costModelSchema = z.object({
-	peak: costBucketsSchema.optional(),
-	off: costBucketsSchema.optional()
-}).strict();
-const costModelsSchema = z.record(z.string(), costModelSchema);
-const costUsageSchema = z.record(z.string(), costModelsSchema);
-const toolTimingSchema = z.object({
-	calls: z.number().int().nonnegative(),
-	ms: z.number().nonnegative()
-}).strict();
-const timingTotalsSchema = z.object({
-	wallMs: z.number().nonnegative(),
-	ttftMs: z.number().nonnegative(),
-	genMs: z.number().nonnegative(),
-	reasoningMs: z.number().nonnegative().optional(),
-	reasoningBlocks: z.number().int().nonnegative().optional(),
-	textMs: z.number().nonnegative().optional(),
-	textBlocks: z.number().int().nonnegative().optional(),
-	toolArgMs: z.number().nonnegative().optional(),
-	toolArgBlocks: z.number().int().nonnegative().optional(),
-	speedTokens: z.number().nonnegative().optional(),
-	speedMs: z.number().nonnegative().optional(),
-	calls: z.number().int().nonnegative(),
-	toolsMs: z.number().nonnegative(),
-	toolCalls: z.number().int().nonnegative(),
-	tools: z.record(z.string(), toolTimingSchema)
-}).strict();
-/** The baseline-gate record the fallback unit serves (see fallback.ts). */
-const unsupportedSchema = z.object({
-	current: z.string(),
-	minimum: z.string()
-}).strict();
-/** 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(),
-	model: z.string().optional(),
-	provider: z.string().optional(),
-	contextWindow: z.number().optional(),
-	current: currentSchema,
-	images: z.number().int().nonnegative().optional(),
-	toolCalls: z.number().int().nonnegative().optional(),
-	humanInputs: z.number().int().nonnegative().optional(),
-	lastUser: z.string().optional(),
-	counts: countsSchema.optional(),
-	last: lastSchema.optional(),
-	detailRev: z.number().int().nonnegative().optional(),
-	requests: z.array(requestRecordSchema).optional(),
-	events: z.array(contextEventSchema).optional(),
-	cost: costUsageSchema.optional(),
-	timing: timingTotalsSchema.optional(),
-	systems: z.array(systemPromptNodeSchema).optional(),
-	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(),
-	fileOps: z.array(fileOpSchema).optional(),
-	fileOpsFloor: z.number().int().nonnegative().optional(),
-	spans: z.array(timingSpanSchema).optional()
-}).strict();
-/**
-* The persisted fold-state schema (the registry's `stateSchema`
-* contract). Validates the plain-JSON `TimelineState` before a checkpoint
-* row seeds a fold — the same shape guarantee the projection cache's
-* plain-JSON precondition already enforces at write time.
-*/
-const timelineStateSchema = z.object({
-	surface: z.array(surfaceNodeSchema),
-	sums: z.object({
-		user: z.number().int().nonnegative(),
-		inject: z.number().int().nonnegative(),
-		skill: z.number().int().nonnegative(),
-		assistant: z.number().int().nonnegative(),
-		tool: z.number().int().nonnegative()
-	}).strict(),
-	systemTokens: z.number().int().nonnegative(),
-	systems: z.array(systemPromptNodeSchema).optional(),
-	toolsTokens: z.number().int().nonnegative(),
-	model: z.string().optional(),
-	provider: z.string().optional(),
-	lastModel: z.string().optional(),
-	contextWindow: z.number().optional(),
-	requests: z.array(requestRecordSchema),
-	turnRuns: z.number().int().nonnegative().optional(),
-	events: z.array(contextEventSchema),
-	archived: z.array(surfaceNodeSchema),
-	cost: costUsageSchema.optional(),
-	archiveFloor: z.number().optional(),
-	timing: timingTotalsSchema.optional(),
-	humanInputs: z.number().int().nonnegative().optional(),
-	lastUser: z.string().optional(),
-	stepStart: z.object({
-		time: z.number(),
-		firstToken: z.number().optional()
-	}).strict().optional(),
-	stepWaits: z.array(z.object({
-		start: z.number(),
-		end: z.number()
-	}).strict()).optional(),
-	stepApprovals: z.record(z.string(), z.number()).optional(),
-	stepRequestSeq: z.number().optional(),
-	callNames: z.record(z.string(), z.object({
-		name: z.string(),
-		start: z.number(),
-		argsRaw: z.string().optional()
-	}).strict()),
-	pendingShadowedSeqs: z.array(z.number()).optional(),
-	pendingShadowEventSeq: z.number().optional(),
-	detailRev: z.number().int().nonnegative().optional(),
-	fileOps: z.array(fileOpSchema),
-	fileOpsFloor: z.number().int().nonnegative().optional(),
-	spans: z.array(timingSpanSchema),
-	stepSpans: z.array(timingSpanSchema).optional(),
-	pendingCodeOps: z.record(z.string(), z.array(fileOpSchema)).optional()
-});
-/**
-* The context-timeline projection unit, created per plugin instance with its
-* config-resolved retention bounds (config.ts), and registered on
-* `ctx.sessionProjections`. Registry lifecycle notes (mirrored from the
-* harness contract): registration is an effect on the caller's fiber — an
-* unloaded Host half removes the key, and clients read it as capability
-* absence. `stateVersion` must be bumped whenever the persisted state shape
-* or fold semantics change (invalidation of cached rows); config-only
-* changes never require it (bounds tune retention, not state shape).
-*
-* The definition carries the session-projection contract served by every
-* supported harness (see compat.ts): `stateSchema` + a REQUIRED `wire` block.
-* (The return type is the mirrored contract, not the installed dts
-* `ProjectionDefinition`: the registry's wired-register overload demands
-* `wire` PRESENT, which the dts's optional `wire?` fails.) Without the
-* `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, slim) {
-	const bounds = resolveBounds(config);
-	const view = (state) => slim() ? buildTimelineHead(state) : buildTimelineView(state, bounds);
-	return {
-		key: "contextTimeline",
-		stateSchema: timelineStateSchema,
-		wire: {
-			viewSchema: contextTimelineSchema,
-			view
-		},
-		init: () => createTimelineState(),
-		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 26
-	};
-}
-//#endregion
 //#region src/host/fallback.ts
-/**
-* The baseline gate's fallback projection units (see host/index.ts).
-*
-* On a harness below the supported baseline (shared/version.ts) the plugin
-* registers these INSTEAD of the real folds: the log's event shapes on such
-* a harness are outside the compat matrix, so nothing is parsed at all —
-* `apply` is the identity over an opaque empty state, and `view` serves a
-* fixed value whose timeline snapshot carries the gate record (`unsupported`:
-* the detected harness version and the baseline). The client's cards render
-* the blank data and its gate modal urges the upgrade; the registry pipeline
-* (fold, cache, push feed) keeps working end to end, so nothing hangs on a
-* loading screen.
-*
-* The definition carries BOTH registry contract generations: the modern
-* `stateSchema` + `wire` block (dsh 0.1.1-rc.1+, the realistic below-baseline
-* case) and the pre-0.1.1 top-level `schema` + `view` aliases that line's
-* registry reads instead. Each registry ignores the other generation's
-* fields, so one definition serves the gate on every harness that can
-* deliver projections to clients at all.
-*
-* `stateVersion` is pinned at 1. Downgrade/upgrade cache choreography: a
-* downgrade to a gated harness refolds the timeline key from scratch (no
-* ver-1 rows exist for it) and seeds the headers key from the real unit's
-* ver-1 rows — stripped to the empty state, which the gate never reads. An
-* upgrade back discards the fallback's ver-1 timeline rows and REJECTS its
-* ver-1 headers rows at the real unit's stricter state schema, refolding
-* both from the log. Nothing stale survives in either direction.
-*/
-/**
-* The opaque fold state: the gate folds nothing, so any cached row seeds it
-* (strip-mode object — never a discard, never a throw), and the plain-JSON
-* cache-write gate trivially holds.
-*/
 const fallbackStateSchema = z.object({});
-/** One gate unit: identity fold over the opaque state, constant view, both contract generations. */
 function fallbackDefinition(key, wireSchema, value) {
 	const view = () => value;
 	return {
@@ -3560,10 +2715,6 @@ function fallbackDefinition(key, wireSchema, value) {
 		stateVersion: 1
 	};
 }
-/**
-* The fallback `contextTimeline` unit: serves the fixed zeroed snapshot
-* naming the detected harness `current` version against the baseline.
-*/
 function createFallbackTimelineDefinition(current) {
 	return fallbackDefinition("contextTimeline", contextTimelineSchema, {
 		ok: true,
@@ -3588,103 +2739,20 @@ function createFallbackTimelineDefinition(current) {
 		archive: []
 	});
 }
-/**
-* The fallback `contextHeaders` unit: an empty epoch list — the browser's
-* header sections degrade to their metadata-free rendering.
-*/
 function createFallbackHeadersDefinition() {
 	return fallbackDefinition("contextHeaders", contextHeadersSchema, { headers: [] });
 }
-/**
-* The fallback `contextActivity` unit: an empty ledger — the overview's
-* heatmap renders its empty note instead of waiting on a key that the gate
-* would never deliver.
-*/
 function createFallbackActivityDefinition() {
 	return fallbackDefinition("contextActivity", contextActivitySchema, { days: {} });
 }
 //#endregion
-//#region src/host/settings.ts
-/** The namespace is the join key between the Host registration and the browser card. */
-const SETTINGS_NAMESPACE = "dsh-context";
-/** Section schema: also the wire envelope the browser scope validates against. */
-const SettingsSchema = z$1.object({
-	defaultPlacement: z$1.union([
-		"all",
-		"tab",
-		"sidebar"
-	]).default("all").loose(),
-	defaultGranularity: z$1.union(["step", "turn"]).default("step"),
-	defaultTrendMode: z$1.union(["total", "delta"]).default("total").loose(),
-	defaultDeltaBase: z$1.union(["step", "turn"]).default("step").loose(),
-	defaultToolSort: z$1.union([
-		"size",
-		"count",
-		"name"
-	]).default("count").loose(),
-	defaultFileSort: z$1.union([
-		"count",
-		"latest",
-		"path"
-	]).default("count").loose(),
-	insightsEntry: z$1.union(["show", "hide"]).default("show").loose(),
-	defaultDurationCurve: z$1.union(["show", "hide"]).default("show").loose()
-});
-/** Serve the namespace while a settings provider with the register face is composed; inert otherwise. */
-function installSettings(ctx) {
-	ctx.inject(["settings"], (sctx) => {
-		const service = sctx.settings;
-		if (typeof service.register !== "function") return;
-		service.register(SETTINGS_NAMESPACE, SettingsSchema);
-	});
-}
-//#endregion
 //#region src/host/stepIdentity.ts
-/**
-* Step-boundary message identity guard (issue #51 compatibility).
-*
-* The harness refuses to LOAD any session whose durable log carries a
-* `user/message` event whose message lacks a non-empty string `id`
-* (`assertMessageEventShape`) — while the runtime append path runs no such
-* check. One unidentified message therefore persists silently and permanently
-* bricks the session at its next load (`... failed validation: session event
-* at seq N lacks an identified message`). The observed archive held a wrap-up
-* notice whose `id` (and `summary`) had been stripped upstream of the append —
-* a shape no shipped harness producer emits, i.e. a delivery-boundary rebuild
-* outside the audited paths of both this plugin and the harness.
-*
-* This guard hardens the durability boundary from the plugin side. The agent
-* loop appends every step-boundary `user/message` from the `agent/pre-step`
-* decision's `messages` — the one seam all claimed inbox input (prompts,
-* steering, tool-deferred context) flows through before it persists. A
-* prepended listener sits OUTERMOST in that waterfall, so after `next()`
-* resolves it sees the final message list: any message that would persist
-* unidentified gets a fresh id; everything else passes by reference, and the
-* decision object is copied only when a mint happened.
-*
-* Fail-open by contract: a hostile entry (one that throws on property access),
-* a missing list, or any unexpected shape leaves the decision verbatim — a
-* guard must never break the turn it protects. Minted ids carry the `dshctx-`
-* prefix so a backfilled message stays identifiable in the wild.
-*/
-/** Prefix marking an id this guard minted (forensically distinguishable). */
 const MINTED_ID_PREFIX = "dshctx-";
-/**
-* Whether the message fails the harness's restore-time identity check (a
-* non-empty string id). Non-object entries are unfixable (an id needs a
-* container) and stay verbatim.
-*/
 function lacksId(message) {
 	if (typeof message !== "object" || message === null) return false;
 	const id = message.id;
 	return typeof id !== "string" || id === "";
 }
-/**
-* Mint ids for the messages that would persist unidentified.
-* @param messages - the decision's message list, in append order.
-* @returns the rewritten list (untouched entries by reference), or undefined
-*   when every entry already carries an identity.
-*/
 function identifiedMessages(messages) {
 	let copy;
 	for (const [index, message] of messages.entries()) {
@@ -3700,7 +2768,6 @@ function identifiedMessages(messages) {
 	}
 	return copy;
 }
-/** Arm the prepended `agent/pre-step` guard on the plugin's context. */
 function watchStepIdentity(ctx) {
 	ctx.on("agent/pre-step", async (_input, next) => {
 		const decision = await next();
@@ -3717,80 +2784,155 @@ function watchStepIdentity(ctx) {
 	}, { prepend: true });
 }
 //#endregion
+//#region src/host/skills.ts
+const SKILLS_ROUTE = "/api/dsh-context/skills";
+const MAX_SKILLS = 500;
+function asRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringOf(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+async function disposeOf(resource) {
+	if (resource === null || typeof resource !== "object" && typeof resource !== "function") return;
+	try {
+		const asyncDispose = resource[Symbol.asyncDispose];
+		if (typeof asyncDispose === "function") {
+			await asyncDispose.call(resource);
+			return;
+		}
+		const syncDispose = resource[Symbol.dispose];
+		if (typeof syncDispose === "function") syncDispose.call(resource);
+	} catch {}
+}
+function skillInfoOf(value) {
+	const record = asRecord(value);
+	if (record === null || typeof record.name !== "string" || record.name === "") return null;
+	return {
+		name: record.name,
+		description: typeof record.description === "string" ? record.description : "",
+		...typeof record.path === "string" && record.path !== "" ? { path: record.path } : {},
+		...typeof record.source === "string" && record.source !== "" ? { source: record.source } : {}
+	};
+}
+async function sessionViewOf(ctx, sessionId) {
+	if (sessionId === void 0) return {};
+	const query = asRecord(ctx.get("sessionQuery"));
+	if (typeof query?.observeSession !== "function") return {};
+	let observation;
+	try {
+		observation = await query.observeSession.call(query, sessionId);
+	} catch {
+		return {};
+	}
+	try {
+		const obs = asRecord(observation);
+		const cwd = stringOf(asRecord(obs?.header)?.cwd);
+		const agentPreset = stringOf(asRecord(asRecord(obs?.projections)?.values)?.agentPreset);
+		return {
+			...cwd === void 0 ? {} : { cwd },
+			...agentPreset === void 0 ? {} : { agentPreset }
+		};
+	} finally {
+		await disposeOf(observation);
+	}
+}
+async function resolveRegistry(ctx, sessionId, agentPreset) {
+	const presets = asRecord(ctx.get("agentPresets"));
+	let live;
+	if (sessionId !== void 0) {
+		const agents = asRecord(ctx.get("agents"));
+		if (typeof agents?.get === "function") try {
+			live = agents.get.call(agents, sessionId);
+		} catch {
+			live = void 0;
+		}
+	}
+	if (live !== void 0 && live !== null && typeof presets?.serviceFor === "function") {
+		const scoped = asRecord(presets.serviceFor.call(presets, live, "skills"));
+		if (scoped !== null && typeof scoped.list === "function") return {
+			registry: scoped,
+			scope: live,
+			lease: void 0
+		};
+	}
+	const registry = asRecord(ctx.get("skills"));
+	if (registry === null || typeof registry.list !== "function") return null;
+	let scope;
+	let lease;
+	if (typeof presets?.acquireScope === "function") try {
+		lease = await presets.acquireScope.call(presets, agentPreset);
+		scope = asRecord(lease)?.key;
+	} catch {
+		lease = void 0;
+	}
+	return {
+		registry,
+		scope,
+		lease
+	};
+}
+function watchSkillCatalog(ctx) {
+	ctx.inject(["connection"], (c) => {
+		const register = fetchRouteRegistrar(c.get("connection"));
+		if (register === void 0) return;
+		const handler = async (request) => {
+			let value = null;
+			let lease;
+			try {
+				const body = asRecord(await request.json());
+				const sessionId = stringOf(body?.sessionId);
+				const view = await sessionViewOf(ctx, sessionId);
+				const cwd = view.cwd ?? stringOf(body?.cwd);
+				const resolved = await resolveRegistry(ctx, sessionId, view.agentPreset);
+				if (resolved !== null) {
+					lease = resolved.lease;
+					const listed = await resolved.registry.list({
+						...cwd === void 0 ? {} : { cwd },
+						...resolved.scope === void 0 ? {} : { scope: resolved.scope }
+					});
+					const rows = Array.isArray(listed) ? listed : [];
+					const skills = [];
+					for (const row of rows) {
+						const info = skillInfoOf(row);
+						if (info !== null) skills.push(info);
+						if (skills.length >= MAX_SKILLS) break;
+					}
+					value = { skills };
+				}
+			} catch {} finally {
+				await disposeOf(lease);
+			}
+			return Response.json({
+				ok: true,
+				value
+			}, { headers: { "cache-control": "no-store" } });
+		};
+		try {
+			c.effect(() => register({
+				path: SKILLS_ROUTE,
+				methods: ["POST"],
+				requestBody: "buffered",
+				fetch: handler
+			}), "dsh-context: skills route");
+		} catch {
+			return;
+		}
+	});
+}
+//#endregion
 //#region src/host/version.ts
-/**
-* Runtime harness-version probe behind the baseline gate (host/index.ts).
-*
-* The probe never imports a harness package for its version; it reads
-* manifests through Node resolution from two anchors, in order:
-*
-*  1. This module's own ESM resolution of the library packages the Host half
-*     imports at runtime. That is the very pipeline the process resolves those
-*     imports through, so an embedding shell that redirects plugin imports —
-*     the packaged Desktop's ASAR resolver bridge does exactly this — redirects
-*     the probe identically, and the answer names the module instances the
-*     harness is actually running. A witness that lands inside this package's
-*     own tree is the plugin's dependency closure (a `link:`-installed dev
-*     checkout's pinned devDependencies), never the harness, so it is discarded
-*     for the home anchor.
-*  2. The harness home's healed `profiles/node_modules` mirror (located via
-*     the app-boot `dshHomePath` service). It names the installation that last
-*     healed it: authoritative for a dev checkout, whose own tree holds pinned
-*     devDependencies, but only as fresh as the last CLI profile boot. A
-*     packaged Desktop never heals it, so a stale global-CLI mirror can outlive
-*     the CLI and misname the running harness — that is why it answers only
-*     when the running anchor has nothing it can trust.
-*
-* The `@deepseek-ai/dsh` CLI package is probed ONLY through the home anchor:
-* the plugin never imports it, so a hit from the running anchor can only be an
-* ambient install above the plugin's tree (e.g. a global copy under
-* ~/node_modules) — not necessarily the RUNNING harness.
-*
-* Every step is guarded: any failure (absent service, unresolvable package,
-* non-file URL, unreadable/invalid manifest, non-string version) degrades to
-* `undefined`, and the gate treats an unknown version as SATISFIED — a probe
-* misfire must never blank a working deployment.
-*/
-/**
-* Library packages whose manifest version IS the harness release version (the
-* dsh monorepo versions every package in lockstep). The home anchor probes
-* them after the CLI package; the running anchor probes the two first- and
-* second-ordered.
-*/
 const LIBRARY_PROBE_PACKAGES = ["@deepseek-ai/dsh-session-projection", "@deepseek-ai/dsh-session"];
-/**
-* Running-anchor probe order: the package the Host half genuinely imports at
-* runtime first (host/fold.ts imports it, so it MUST resolve whenever this
-* plugin runs), then its co-versioned sibling.
-*/
 const RUNNING_PROBE_PACKAGES = ["@deepseek-ai/dsh-session", "@deepseek-ai/dsh-session-projection"];
-/** Home-anchor probe order: the user-facing CLI version first, then the libraries. */
 const HOME_PROBE_PACKAGES = ["@deepseek-ai/dsh", ...LIBRARY_PROBE_PACKAGES];
-/**
-* This package's root. A running-anchor witness under it belongs to the
-* plugin's own dependency closure, not to the harness.
-*
-* Located through the package's own `./package.json` self-reference: Node
-* resolves that against the nearest package.json, so the answer is the package
-* root in the source tree and in the bundled profile install alike — a fixed
-* number of `..` steps cannot be, since `src/host/` and `lib/` differ by a
-* level. A loader that cannot self-resolve (an exotic loader, or a fork renamed
-* without a matching `exports`) falls back to this module's own directory: the
-* guard then covers less of the package, but it still can never mistake the
-* plugin's own `node_modules` for the harness.
-*/
 function ownPackageRoot() {
 	try {
 		return dirname(fileURLToPath(import.meta.resolve("dsh-context/package.json")));
 	} catch {
-		/* v8 ignore next -- a loader that cannot resolve one of its own package's
-		published subpaths is out of the suite's reach; the fallback keeps one
-		probe path (an unanswered probe fails open either way). */
 		return dirname(fileURLToPath(import.meta.url));
 	}
 }
 const PLUGIN_ROOT = ownPackageRoot();
-/** One manifest's `version`, or undefined on any read/shape failure. */
 function versionOfManifest(manifestPath, expectedName) {
 	try {
 		const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
@@ -3802,7 +2944,6 @@ function versionOfManifest(manifestPath, expectedName) {
 		return;
 	}
 }
-/** Probe the package's published `./package.json` subpath. */
 function versionViaManifest(resolve, packageName) {
 	try {
 		return versionOfManifest(resolve(packageName + "/package.json"));
@@ -3810,12 +2951,6 @@ function versionViaManifest(resolve, packageName) {
 		return;
 	}
 }
-/**
-* Probe via the package's entry point, ascending to its owning manifest.
-* Covers the packaged-executable module proxies: their generated manifests
-* carry the real version but export only entry stubs, and Node's exports
-* gate refuses the direct `./package.json` subpath.
-*/
 function versionViaEntry(resolve, packageName) {
 	let dir;
 	try {
@@ -3831,33 +2966,16 @@ function versionViaEntry(resolve, packageName) {
 		dir = parent;
 	}
 }
-/** One anchor's answer: the first probe package that yields a version. */
 function probeAnchor(resolve, packageNames) {
 	for (const packageName of packageNames) {
 		const version = versionViaManifest(resolve, packageName) ?? versionViaEntry(resolve, packageName);
 		if (version !== void 0) return version;
 	}
 }
-/**
-* Whether `candidate` lies inside `root`'s tree. A `..`-prefixed relative path
-* escapes it; a sibling such as `dsh-context-extra` is reached through `..` too,
-* so it never counts as a child. On Windows, a cross-drive `relative()` returns
-* the candidate's ABSOLUTE path (no `..` prefix) — a different drive is never
-* inside this tree, so the absolute answer is rejected the same way. A
-* pathological child literally named `..foo` would degrade to the home anchor,
-* which is the safe direction.
-*/
 function isInside(root, candidate) {
 	const rel = relative(root, candidate);
 	return !rel.startsWith("..") && !isAbsolute(rel);
 }
-/**
-* The running module tree's answer, or undefined when it cannot be trusted.
-* Each probe package is checked on its own: a witness inside the plugin's own
-* closure is the plugin's dependency, not the harness, and a trusted witness
-* whose manifest cannot be read is no answer either — the next package may
-* still resolve to one.
-*/
 function probeRunningTree(resolve, pluginRoot) {
 	for (const packageName of RUNNING_PROBE_PACKAGES) {
 		let witness;
@@ -3871,16 +2989,9 @@ function probeRunningTree(resolve, pluginRoot) {
 		if (version !== void 0) return version;
 	}
 }
-/** The default running anchor: this module's own ESM resolution. */
 function resolveRunningModule(specifier) {
 	return import.meta.resolve(specifier);
 }
-/**
-* The running harness's version string, or undefined when nothing answers
-* (the gate fails open on it — see the header note).
-* @param resolveUrl - the running anchor's URL resolver (injectable for hermetic tests).
-* @param pluginRoot - this package's root for the own-closure check (injectable for hermetic tests).
-*/
 function detectHarnessVersion(ctx, resolveUrl = resolveRunningModule, pluginRoot = PLUGIN_ROOT) {
 	const running = probeRunningTree((specifier) => {
 		const url = resolveUrl(specifier);
@@ -3903,6 +3014,7 @@ const name = "dsh-context";
 const inject = ["sessionProjections"];
 function apply(ctx, config) {
 	watchBalanceChannel(ctx);
+	watchSkillCatalog(ctx);
 	const harnessVersion = detectHarnessVersion(ctx);
 	if (harnessVersion !== void 0 && !meetsBaseline(harnessVersion)) {
 		ctx.sessionProjections.register(createFallbackTimelineDefinition(harnessVersion));
@@ -3912,12 +3024,12 @@ function apply(ctx, config) {
 	}
 	const attribution = createToolAttribution(ctx);
 	watchStepIdentity(ctx);
-	const gate = watchDetailChannel(ctx, resolveBounds(config));
+	const coldReads = makeColdReadGate();
+	const gate = watchDetailChannel(ctx, resolveBounds(config), coldReads);
 	ctx.sessionProjections.register(createContextTimelineDefinition(config, () => gate.live));
 	ctx.sessionProjections.register(createContextHeadersDefinition((name) => attribution.ownerOf(name)));
 	ctx.sessionProjections.register(createContextActivityDefinition());
-	watchActivityBackfill(ctx);
-	installSettings(ctx);
+	watchActivityBackfill(ctx, coldReads);
 }
 //#endregion
 export { Config, apply, inject, name };