dsh-context 0.54.4 → 0.55.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";
@@ -372,21 +372,30 @@ 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`.
+* 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 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 +406,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` /
@@ -507,6 +517,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 +673,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 +752,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 +792,7 @@ function createTimelineState() {
 		systemTokens: 0,
 		toolsTokens: 0,
 		requests: [],
+		turnRuns: 0,
 		events: [],
 		archived: [],
 		callNames: {},
@@ -1118,17 +1154,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 +1212,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,7 +1255,7 @@ 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 !== "") {
@@ -1216,7 +1287,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);
@@ -1235,7 +1310,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 +1318,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,
@@ -1257,14 +1332,15 @@ function applyTimeline(state, event, bounds) {
 				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;
 			}
@@ -1275,17 +1351,24 @@ function applyTimeline(state, event, bounds) {
 				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 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);
+					const blocks = { ...start.blocks ?? {
+						reasoning: 0,
+						text: 0,
+						toolarg: 0
+					} };
+					if (kind !== void 0) blocks[kind] += 1;
 					s.stepStart = {
 						time: start.time,
 						...start.firstToken !== void 0 ? { firstToken: start.firstToken } : {},
 						decode,
+						blocks,
 						...kind !== void 0 ? { block: {
 							kind,
 							since: event.time
@@ -1295,7 +1378,7 @@ function applyTimeline(state, event, bounds) {
 				}
 				if (start.firstToken !== void 0) return state;
 				if (!isTokenChunk(data?.chunk)) return state;
-				const s = ensure();
+				const s = ensure([]);
 				s.stepStart = {
 					...start,
 					firstToken: event.time
@@ -1307,7 +1390,7 @@ function applyTimeline(state, event, bounds) {
 				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 +1398,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;
@@ -1366,7 +1454,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 +1508,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 +1551,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;
@@ -1464,10 +1568,10 @@ function applyTimeline(state, event, bounds) {
 						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]);
+							for (const kind of DECODE_KINDS) addDecode(timing, kind, decode[kind], stepStart.blocks?.[kind] ?? 0);
 						} 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]);
 						}
 					}
 				}
@@ -1477,7 +1581,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 +1593,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");
@@ -2399,18 +2503,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 +2528,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
@@ -2887,8 +3032,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(),
@@ -2974,6 +3122,7 @@ const timelineStateSchema = z.object({
 	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(),
@@ -2989,6 +3138,11 @@ const timelineStateSchema = z.object({
 			text: z.number(),
 			toolarg: z.number()
 		}).strict().optional(),
+		blocks: z.object({
+			reasoning: z.number().int(),
+			text: z.number().int(),
+			toolarg: z.number().int()
+		}).strict().optional(),
 		block: z.object({
 			kind: z.enum([
 				"reasoning",
@@ -3390,11 +3544,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.

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Context (dsh-context)",
+    "description": "Context insights and management, with dashboard, browser, dynamics and commands, for understanding how the context composites, and how it evolves."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "上下文 (dsh-context)",
+    "description": "上下文洞察与管理插件：提供跨会话的上下文仪表盘、上下文浏览器、上下文动态、/context 命令，看清上下文的构成与演变。"
+  }
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "dsh-context",
-  "version": "0.54.4",
+  "version": "0.55.0",
   "description": "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.",
+  "icon": "icon.svg",
   "author": "bowenliang123",
   "repository": {
     "type": "git",
@@ -23,9 +24,12 @@
       "default": "./lib/index.js"
     },
     "./client": "./lib/client.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
+    "icon.svg",
+    "locale/*.json",
     "lib/client.js",
     "lib/index.js",
     "lib/index.d.ts",
@@ -67,7 +71,7 @@
         "0.1.2-rc.1": "compatible",
         "0.1.3-alpha.2": "compatible",
         "0.1.5-rc.1": "compatible",
-        "0.1.7-alpha.1": "compatible"
+        "0.1.7-alpha.2": "compatible"
       }
     }
   },
@@ -109,7 +113,7 @@
     "@deepseek-ai/dsh-session-projection": "0.1.2-rc.1",
     "@deepseek-ai/dsh-settings": "0.1.2-rc.1",
     "@deepseek-ai/dsh-util-workspace-path": "0.1.5-rc.1",
-    "@deepseek-ai/schemastery": "^3.18.2",
+    "@deepseek-ai/schemastery": "^3.18.4",
     "@opencode-ai/models": "^0.0.72",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tailwindcss/node": "4.3.3",