dsh-context 0.54.4 → 0.56.0

package/lib/index.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { z } from "zod";
 import { SessionLogOffset, deriveEventMessage, interruptedTurnClosers } from "@deepseek-ai/dsh-session";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, normalize, relative } from "node:path";
+import { dirname, isAbsolute, join, normalize, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import z$1 from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
@@ -330,30 +330,28 @@ function isInjection(source) {
 //#region src/host/logShapes.ts
 /**
 * Shape-driven readers over the durable session-event vocabulary — the ONE
-* place the plugin reconciles the two supported log generations:
+* 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`.
 *
-*   - V0 (dsh 0.1.2-rc.1): `request/header.header.system`, `assistant/chunk`
-*     stream events, `SurfaceOp { start, end }`, `tool/code-dispatch`.
-*   - V3 (dsh 0.1.5-alpha.x+): `system/message` surface nodes,
-*     `assistant/message.data.stream` / `assistant/attempt.data.stream`,
-*     `SurfaceOp { startSeq, endSeq }`, `tool/ptc-dispatch`.
-*
-* The fold reads SHAPES, never a detected harness version: a session log is
-* written by exactly one generation, the two spellings are mutually
-* exclusive within it, and a deployment's version probe can be wrong (a
-* healed profile mirror may name a different release than the running
-* harness). 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).
+* 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
-* both generations share. Mirrors 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.
+* 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;
@@ -372,21 +370,28 @@ function decodeKindOfBlock(blockType) {
 	if (blockType === "tool-call") return "toolarg";
 }
 /**
-* Per-kind decode spans 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`. This is the V2+ shape, whose
-* timed stream rides the settlement (`assistant/message.data.stream`) instead
-* of separate `assistant/chunk` events. Total over untrusted input — a
-* malformed record is skipped, a non-finite boundary yields zero, and a stream
-* with no marker (or not an array) yields all zeros.
-*/
-function decodeSpansOfStream(stream, endTime) {
-	const spans = {
-		reasoning: 0,
-		text: 0,
-		toolarg: 0
+* 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: {
+			reasoning: 0,
+			text: 0,
+			toolarg: 0
+		},
+		blocks: {
+			reasoning: 0,
+			text: 0,
+			toolarg: 0
+		}
 	};
-	if (!Array.isArray(stream) || !Number.isFinite(endTime)) return spans;
+	if (!Array.isArray(stream) || !Number.isFinite(endTime)) return tally;
 	let kind;
 	let since = 0;
 	for (const record of stream) {
@@ -397,12 +402,13 @@ function decodeSpansOfStream(stream, endTime) {
 		if (chunk.type !== "block-start") continue;
 		const time = r.time;
 		if (typeof time !== "number" || !Number.isFinite(time)) continue;
-		if (kind !== void 0) spans[kind] += Math.max(0, time - since);
+		if (kind !== void 0) tally.spans[kind] += Math.max(0, time - since);
 		kind = decodeKindOfBlock(chunk.blockType);
+		if (kind !== void 0) tally.blocks[kind] += 1;
 		since = time;
 	}
-	if (kind !== void 0) spans[kind] += Math.max(0, endTime - since);
-	return spans;
+	if (kind !== void 0) tally.spans[kind] += Math.max(0, endTime - since);
+	return tally;
 }
 /**
 * The first token's instant inside one PACKED delta run (`text-chunks` /
@@ -431,9 +437,8 @@ function runFirstTokenTime(record) {
 }
 /**
 * The first token's instant inside an embedded assistant stream
-* (`assistant/message.data.stream`, `assistant/attempt.data.stream` — the V2+
-* settlement that replaced the V0 `assistant/chunk` events), or undefined
-* when the stream carries no token. Mirrors dsh-llm's
+* (`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) {
@@ -453,16 +458,14 @@ function firstTokenTimeOfStream(stream) {
 /**
 * 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).
-* Reads BOTH endpoint spellings: V3's `startSeq`/`endSeq` first, then V0's
-* `start`/`end` — each accepted only as a finite number, so a hostile op
-* with one good and one malformed endpoint degrades to 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;
 	if (op.op !== "replace") return null;
-	const start = typeof op.startSeq === "number" ? op.startSeq : op.start;
-	const end = typeof op.endSeq === "number" ? op.endSeq : op.end;
+	const { startSeq: start, endSeq: end } = op;
 	if (typeof start !== "number" || !Number.isFinite(start)) return null;
 	if (typeof end !== "number" || !Number.isFinite(end)) return null;
 	return {
@@ -507,6 +510,24 @@ function kindOfCall(tool, args) {
 	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).
@@ -645,7 +666,7 @@ function searchFilesOf(meta) {
 * resolve no target) rows nothing.
 */
 function opsOfCall(input) {
-	const args = parseCallArgs(input.argsRaw);
+	const args = opBearingTool(input.tool) ? parseCallArgs(input.argsRaw) : null;
 	const kind = kindOfCall(input.tool, args);
 	if (kind === null) return [];
 	const stamp = {
@@ -724,8 +745,15 @@ function countTurnRuns(requests) {
 	return runs;
 }
 function trimState(st, bounds) {
-	if (countTurnRuns(st.requests) > bounds.maxKeptTurns) st.requests = trimToLastTurns(st.requests, bounds.maxKeptTurns);
-	if (st.requests.length > bounds.maxRequestSteps) st.requests = st.requests.slice(-bounds.maxRequestSteps);
+	st.turnRuns = st.turnRuns ?? countTurnRuns(st.requests);
+	if (st.turnRuns > bounds.maxKeptTurns) {
+		st.requests = trimToLastTurns(st.requests, bounds.maxKeptTurns);
+		st.turnRuns = countTurnRuns(st.requests);
+	}
+	if (st.requests.length > bounds.maxRequestSteps) {
+		st.requests = st.requests.slice(-bounds.maxRequestSteps);
+		st.turnRuns = countTurnRuns(st.requests);
+	}
 	if (st.events.length > bounds.maxEvents) st.events = st.events.slice(-bounds.maxEvents);
 	if (st.fileOps.length > bounds.maxFileOps) {
 		const drop = st.fileOps.length - bounds.maxFileOps;
@@ -757,6 +785,7 @@ function createTimelineState() {
 		systemTokens: 0,
 		toolsTokens: 0,
 		requests: [],
+		turnRuns: 0,
 		events: [],
 		archived: [],
 		callNames: {},
@@ -867,8 +896,10 @@ function removeSurfaceSeqs(st, claimed, goneSeq) {
 /**
 * The message nested under an event payload's `message` field
 * (`system/message`, `assistant/message`, `tool/result`) — read structurally
-* rather than through `deriveEventMessage`, whose 0.1.2-rc.1 generation knows
-* nothing of the V3 `system/message` variant. A malformed payload reads null.
+* because the fold needs a TOTAL read over untrusted payloads: a malformed
+* message reads null here, never throws or guesses a shape. Purely a type
+* cast: `deriveEventMessage` returns `event.data` for a user/message (no
+* `data.message` indirection), so its result feeds every other case.
 */
 function messageOf$1(data) {
 	const message = data?.message;
@@ -1118,17 +1149,32 @@ function ensureTiming(st) {
 	};
 	return st.timing;
 }
+/** The TimingTotals fields each decode bucket's span and count land in. */
+const DECODE_FIELDS = {
+	reasoning: {
+		ms: "reasoningMs",
+		n: "reasoningBlocks"
+	},
+	text: {
+		ms: "textMs",
+		n: "textBlocks"
+	},
+	toolarg: {
+		ms: "toolArgMs",
+		n: "toolArgBlocks"
+	}
+};
 /**
-* Fold one block's decode span into the totals' generation split (see
-* TimingTotals). A zero span stays ABSENT — the field then carries the
-* "no time was decoded in this bucket" fact without adding dead properties to
-* every pre-split-shaped state, and the card reads absence as 0.
+* 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) {
-	if (!(ms > 0)) return;
-	if (kind === "reasoning") timing.reasoningMs = (timing.reasoningMs ?? 0) + ms;
-	else if (kind === "text") timing.textMs = (timing.textMs ?? 0) + ms;
-	else timing.toolArgMs = (timing.toolArgMs ?? 0) + ms;
+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
@@ -1161,22 +1207,42 @@ function bumpToolTotals(timing, name, ms) {
 		ms: cur.ms + ms
 	};
 }
+const CLONE_ALL = [
+	"surface",
+	"sums",
+	"requests",
+	"events",
+	"archived",
+	"callNames",
+	"fileOps",
+	"timing"
+];
 function applyTimeline(state, event, bounds) {
 	let st;
-	const ensure = () => st ??= {
-		...state,
-		surface: [...state.surface],
-		sums: { ...state.sums },
-		requests: [...state.requests],
-		events: [...state.events],
-		archived: [...state.archived],
-		callNames: { ...state.callNames },
-		fileOps: [...state.fileOps],
-		...state.pendingCodeOps !== void 0 ? { pendingCodeOps: { ...state.pendingCodeOps } } : {},
-		...state.timing !== void 0 ? { timing: {
+	/**
+	* 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];
+		else if (key === "sums") st.sums = { ...state.sums };
+		else if (key === "requests") st.requests = [...state.requests];
+		else if (key === "events") st.events = [...state.events];
+		else if (key === "archived") st.archived = [...state.archived];
+		else if (key === "callNames") st.callNames = { ...state.callNames };
+		else if (key === "fileOps") st.fileOps = [...state.fileOps];
+		else if (state.timing !== void 0) st.timing = {
 			...state.timing,
 			tools: { ...state.timing.tools }
-		} } : {}
+		};
+		return st;
 	};
 	const data = event.data;
 	try {
@@ -1184,22 +1250,8 @@ function applyTimeline(state, event, bounds) {
 			case "request/header": {
 				const header = data?.header ?? {};
 				const tools = Array.isArray(header.tools) ? header.tools : [];
-				const s = ensure();
+				const s = ensure(["events"]);
 				s.toolsTokens = estimateToolsTotal(tools);
-				const systemText = header.system;
-				if (typeof systemText === "string" && systemText !== "") {
-					s.systems = [{
-						seq: event.seq,
-						time: event.time,
-						tokens: estimateSystemTokens(systemText)
-					}];
-					s.systemsFromHeader = true;
-					s.systemTokens = systemTokensOf(s.systems);
-				} else if (s.systemsFromHeader === true) {
-					s.systems = [];
-					delete s.systemsFromHeader;
-					s.systemTokens = 0;
-				}
 				if (header.config && typeof header.config.model === "string") s.model = header.config.model;
 				if (header.config && typeof header.config.provider === "string") s.provider = header.config.provider;
 				if ((data?.reason === "change" || data?.reason === "resume") && s.model && s.lastModel && s.model !== s.lastModel) {
@@ -1216,7 +1268,11 @@ function applyTimeline(state, event, bounds) {
 				break;
 			}
 			case "system/message": {
-				const s = ensure();
+				const s = ensure([
+					"surface",
+					"sums",
+					"archived"
+				]);
 				delete s.pendingShadowedSeqs;
 				delete s.pendingShadowEventSeq;
 				const op = replaceRangeOf(event.surfaceOp);
@@ -1226,7 +1282,6 @@ function applyTimeline(state, event, bounds) {
 					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);
 				}
-				delete s.systemsFromHeader;
 				pushSystem(s, {
 					seq: event.seq,
 					time: event.time,
@@ -1235,7 +1290,7 @@ function applyTimeline(state, event, bounds) {
 				break;
 			}
 			case "request/context": {
-				const s = ensure();
+				const s = ensure([]);
 				if (data && typeof data.contextWindow === "number") s.contextWindow = data.contextWindow;
 				if (data && typeof data.model === "string") s.model = data.model;
 				if (data && typeof data.provider === "string") s.provider = data.provider;
@@ -1243,8 +1298,8 @@ function applyTimeline(state, event, bounds) {
 			}
 			case "tool/call":
 				if (data && typeof data.callId === "string" && typeof data.name === "string") {
-					const s = ensure();
-					const argsRaw = argsRawOf(data.arguments);
+					const s = ensure(["callNames"]);
+					const argsRaw = rawArgsNeeded(data.name) ? argsRawOf(data.arguments) : void 0;
 					s.callNames[data.callId] = {
 						name: data.name,
 						start: event.time,
@@ -1252,62 +1307,28 @@ function applyTimeline(state, event, bounds) {
 					};
 				}
 				break;
-			case "tool/code-dispatch":
 			case "tool/ptc-dispatch": {
 				const rootCallId = data?.rootCallId;
 				const name = data?.name;
 				if (typeof rootCallId === "string" && typeof name === "string") {
+					const argsRaw = opBearingTool(name) ? argsRawOf(data?.arguments) : void 0;
 					const ops = opsOfCall({
 						seq: event.seq,
 						time: event.time,
 						tool: name,
-						argsRaw: argsRawOf(data?.arguments),
+						argsRaw,
 						err: data?.isError === true
 					});
-					if (ops.length > 0) bufferCodeOps(ensure(), rootCallId, ops);
+					if (ops.length > 0) bufferCodeOps(ensure([]), rootCallId, ops);
 				}
 				break;
 			}
-			case "assistant/chunk": {
-				const start = state.stepStart;
-				if (start === void 0) return state;
-				const chunk = data?.chunk;
-				if (chunk !== null && typeof chunk === "object" && chunk.type === "block-start") {
-					const kind = decodeKindOfBlock(chunk.blockType);
-					if (start.block === void 0 && kind === void 0) return state;
-					const s = ensure();
-					const decode = { ...start.decode ?? {
-						reasoning: 0,
-						text: 0,
-						toolarg: 0
-					} };
-					if (start.block !== void 0) decode[start.block.kind] += durOf(start.block.since, event.time);
-					s.stepStart = {
-						time: start.time,
-						...start.firstToken !== void 0 ? { firstToken: start.firstToken } : {},
-						decode,
-						...kind !== void 0 ? { block: {
-							kind,
-							since: event.time
-						} } : {}
-					};
-					break;
-				}
-				if (start.firstToken !== void 0) return state;
-				if (!isTokenChunk(data?.chunk)) return state;
-				const s = ensure();
-				s.stepStart = {
-					...start,
-					firstToken: event.time
-				};
-				break;
-			}
 			case "assistant/attempt": {
 				const start = state.stepStart;
 				if (start === void 0 || start.firstToken !== void 0) return state;
 				const first = firstTokenTimeOfStream(data?.stream);
 				if (first === void 0) return state;
-				const s = ensure();
+				const s = ensure([]);
 				s.stepStart = {
 					time: start.time,
 					firstToken: first
@@ -1315,21 +1336,26 @@ function applyTimeline(state, event, bounds) {
 				break;
 			}
 			case "step/start": {
-				const s = ensure();
+				const s = ensure([]);
 				s.stepStart = { time: event.time };
 				break;
 			}
 			case "step/end": {
 				const start = state.stepStart;
 				if (start === void 0) return state;
-				const s = ensure();
+				const s = ensure(["timing"]);
 				ensureTiming(s).wallMs += durOf(start.time, event.time);
 				delete s.stepStart;
 				break;
 			}
 			case "user/message": {
 				const msg = deriveEventMessage(event);
-				const s = ensure();
+				const s = ensure([
+					"surface",
+					"sums",
+					"archived",
+					"events"
+				]);
 				bumpDetailRev(s);
 				const node = applySurface(s, event, event.type, data, msg);
 				const source = msg?.source;
@@ -1338,7 +1364,7 @@ function applyTimeline(state, event, bounds) {
 						seq: event.seq,
 						time: event.time,
 						kind: "inject",
-						form: source.form || "context",
+						form: typeof source.form === "string" && source.form !== "" ? source.form : "context",
 						tokens: node.tokens
 					};
 					if (source.kind === "skill-invocation") {
@@ -1366,7 +1392,14 @@ function applyTimeline(state, event, bounds) {
 				const blockId = firstBlock?.toolCallId;
 				const pendingEntry = (typeof srcId === "string" ? state.callNames[srcId] : void 0) ?? (typeof blockId === "string" ? state.callNames[blockId] : void 0);
 				const buffered = (typeof srcId === "string" ? state.pendingCodeOps?.[srcId] : void 0) ?? (typeof blockId === "string" ? state.pendingCodeOps?.[blockId] : void 0);
-				const s = ensure();
+				const s = ensure([
+					"surface",
+					"sums",
+					"archived",
+					"events",
+					"fileOps",
+					"timing"
+				]);
 				bumpDetailRev(s);
 				const node = applySurface(s, event, event.type, data, toolMsg);
 				if (node.tool === ASK_USER_TOOL) s.humanInputs = (s.humanInputs ?? 0) + 1;
@@ -1413,7 +1446,14 @@ function applyTimeline(state, event, bounds) {
 			}
 			case "assistant/message": {
 				const usage = data?.usage;
-				const s = ensure();
+				const s = ensure([
+					"surface",
+					"sums",
+					"archived",
+					"events",
+					"requests",
+					"timing"
+				]);
 				bumpDetailRev(s);
 				const total = s.systemTokens + s.toolsTokens + s.sums.user + s.sums.inject + s.sums.skill + s.sums.assistant + s.sums.tool;
 				const record = {
@@ -1449,6 +1489,8 @@ function applyTimeline(state, event, bounds) {
 					}
 				}
 				s.requests.push(record);
+				const prevLast = state.requests.at(-1);
+				s.turnRuns = (state.turnRuns ?? countTurnRuns(state.requests)) + (prevLast === void 0 ? record.turn !== void 0 ? 1 : 0 : record.turn === prevLast.turn ? 0 : 1);
 				const timing = ensureTiming(s);
 				timing.calls += 1;
 				const stepStart = state.stepStart;
@@ -1461,14 +1503,8 @@ function applyTimeline(state, event, bounds) {
 							timing.speedMs = (timing.speedMs ?? 0) + durOf(firstToken, event.time);
 							timing.speedTokens = (timing.speedTokens ?? 0) + output;
 						}
-						if (stepStart.decode !== void 0) {
-							const decode = { ...stepStart.decode };
-							if (stepStart.block !== void 0) decode[stepStart.block.kind] += durOf(stepStart.block.since, event.time);
-							for (const kind of DECODE_KINDS) addDecode(timing, kind, decode[kind]);
-						} else {
-							const spans = decodeSpansOfStream(data?.stream, event.time);
-							for (const kind of DECODE_KINDS) addDecode(timing, kind, spans[kind]);
-						}
+						const tally = decodeTallyOfStream(data?.stream, event.time);
+						for (const kind of DECODE_KINDS) addDecode(timing, kind, tally.spans[kind], tally.blocks[kind]);
 					}
 				}
 				const asstMsg = deriveEventMessage(event);
@@ -1477,7 +1513,7 @@ function applyTimeline(state, event, bounds) {
 			}
 			case "plan/mode":
 				if (data && typeof data.active === "boolean") {
-					const s = ensure();
+					const s = ensure(["events"]);
 					s.events.push({
 						seq: event.seq,
 						time: event.time,
@@ -1489,7 +1525,7 @@ function applyTimeline(state, event, bounds) {
 				break;
 			case "compaction/summary":
 			case "compaction/prune": {
-				const s = ensure();
+				const s = ensure(["events"]);
 				bumpDetailRev(s);
 				if (data && Array.isArray(data.shadowedSeqs)) {
 					s.pendingShadowedSeqs = data.shadowedSeqs.filter((x) => typeof x === "number");
@@ -2241,10 +2277,29 @@ function headerOf(record) {
 	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(cache.cachedSnapshot(header, SessionLogOffset(0), ["contextActivity", "contextTimeline"]))?.values);
+		const values = asRecord(asRecord(cachedSnapshotOf(cache, header))?.values);
 		return values !== null && values.contextActivity !== void 0 && values.contextTimeline !== void 0;
 	} catch {
 		return false;
@@ -2399,18 +2454,21 @@ function watchActivityBackfill(ctx) {
 //#endregion
 //#region src/host/config.ts
 /**
-* dsh-context host configuration — the `config:` block of the `dsh-context`
-* loader row in cordis.yml.
-*
-* Cordis validates the entry config against this exported `Config` schema
-* (any Standard Schema v1 validator — zod is ours) before `apply` runs, fills
-* per-field defaults, and fails the load loudly on invalid or unknown keys
-* (`.strict()`). The official plugin-config principle this answers: "anything
-* that two deployments may want to set differently is a configuration field".
+* dsh-context entry configuration — the `config:` block of the `dsh-context`
+* loader row in cordis.yml, plus the per-user display preferences.
 *
-* The persisted projection state shape is independent of these bounds — they
-* only tune the fold's retention / presentation slice, so changing them never
-* requires a projection `stateVersion` bump.
+* 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,
@@ -2421,19 +2479,57 @@ const DEFAULT_BOUNDS = {
 	maxFileOps: 400
 };
 /**
-* The cordis `Config` validator: strict on keys, defaults on the schema fields; tolerates `undefined` (a patch row without a `config:`
-* block — defaults win).
-*/
-const Config = z.preprocess((v) => v ?? {}, z.object({
-	maxRequestSteps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxRequestSteps),
-	maxKeptTurns: z.number().int().min(1).default(DEFAULT_BOUNDS.maxKeptTurns),
-	maxEvents: z.number().int().min(1).default(DEFAULT_BOUNDS.maxEvents),
-	maxNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxNodes),
-	maxArchiveNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxArchiveNodes),
-	maxFileOps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxFileOps)
-}).strict());
+* 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);
+}
+/** 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()),
+	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())
+});
+/** Resolve the fold's retention bounds (the schema fills every default). */
 function resolveBounds(config) {
-	return Config.parse(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
@@ -2548,7 +2644,7 @@ function watchDetailChannel(ctx, bounds) {
 * (host/fallback.ts) instead of the real folds.
 */
 /** The oldest supported dsh release (see the matrix note above). */
-const BASELINE_DSH_VERSION = "0.1.2-rc.1";
+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
@@ -2670,11 +2766,11 @@ const contextHeadersSchema = z.object({ headers: z.array(z.object({
 }).strict()) }).strict();
 function recordOf(event) {
 	if (event.type !== "request/header") return null;
-	const rawHeader = event.data.header;
+	const rawHeader = event.data?.header;
 	if (rawHeader === null || rawHeader === void 0 || typeof rawHeader !== "object") return null;
 	const header = rawHeader;
 	const tools = Array.isArray(header.tools) ? header.tools : [];
-	const record = {
+	return {
 		seq: event.seq,
 		time: event.time,
 		tools: tools.map((t) => {
@@ -2687,8 +2783,6 @@ function recordOf(event) {
 			return entry;
 		})
 	};
-	if (typeof header.system === "string" && header.system.length > 0) record.systemTokens = estimateSystemTokens(header.system);
-	return record;
 }
 /**
 * The context-headers projection unit; registered alongside the timeline unit (host/index.ts); clients read it through
@@ -2887,8 +2981,11 @@ const timingTotalsSchema = z.object({
 	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(),
@@ -2967,13 +3064,13 @@ const timelineStateSchema = z.object({
 	}).strict(),
 	systemTokens: z.number().int().nonnegative(),
 	systems: z.array(systemPromptNodeSchema).optional(),
-	systemsFromHeader: z.literal(true).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(),
@@ -2983,20 +3080,7 @@ const timelineStateSchema = z.object({
 	lastUser: z.string().optional(),
 	stepStart: z.object({
 		time: z.number(),
-		firstToken: z.number().optional(),
-		decode: z.object({
-			reasoning: z.number(),
-			text: z.number(),
-			toolarg: z.number()
-		}).strict().optional(),
-		block: z.object({
-			kind: z.enum([
-				"reasoning",
-				"text",
-				"toolarg"
-			]),
-			since: z.number()
-		}).strict().optional()
+		firstToken: z.number().optional()
 	}).strict().optional(),
 	callNames: z.record(z.string(), z.object({
 		name: z.string(),
@@ -3390,11 +3474,15 @@ function probeAnchor(resolve, packageNames) {
 /**
 * 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. A pathological child literally named `..foo`
-* would degrade to the home anchor, which is the safe direction.
+* 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) {
-	return !relative(root, candidate).startsWith("..");
+	const rel = relative(root, candidate);
+	return !rel.startsWith("..") && !isAbsolute(rel);
 }
 /**
 * The running module tree's answer, or undefined when it cannot be trusted.