dsh-context 0.55.0 → 0.56.0

package/lib/index.d.ts

@@ -35,17 +35,6 @@ interface HeadersState {
   headers: StoredHeaderRecord[];
 }
 //#endregion
-//#region src/host/logShapes.d.ts
-/**
- * The decode bucket a stream's `block-start.blockType` names: the model's
- * thinking, the answer text, or the tool-call arguments. Undefined for an
- * unknown/hostile marker, whose interval then stays unattributed rather than
- * poisoning a bucket.
- */
-type DecodeKind = 'reasoning' | 'text' | 'toolarg';
-/** Per-kind count of opened decode blocks (see {@link decodeTallyOfStream}). */
-type DecodeCounts = Record<DecodeKind, number>;
-//#endregion
 //#region src/host/fold.d.ts
 /**
  * History retention bounds (configurable since 0.11 — see config.ts; these
@@ -63,9 +52,8 @@ interface TimelineState {
   sums: Record<Category, number>;
   systemTokens: number;
   /**
-   * The live system-prompt nodes, oldest first — a V3 log's `system/message`
-   * surface nodes, or the single entry a V0/V2 `request/header.header.system`
-   * envelope defines. `systemTokens` is the LAST entry with tokens > 0 (the
+   * The live system-prompt nodes, oldest first — a log's `system/message`
+   * surface nodes. `systemTokens` is the LAST entry with tokens > 0 (the
    * harness's own "last nonempty surviving system" rule), so an empty dormant
    * node keeps its position without clearing the prompt. Bounded by
    * SYSTEM_NODES_MAX. ABSENT on rows folded before this field existed — the
@@ -73,16 +61,6 @@ interface TimelineState {
    * epoch's own envelope figure.
    */
   systems?: SystemPromptNode[];
-  /**
-   * Whether `systems` was built from the V0/V2 request ENVELOPE
-   * (`header.system`) rather than from V3 `system/message` events. Only then
-   * may a system-less header CLEAR the list: its canonical V0 meaning is
-   * "this request has no system prompt", while a V3 header never carries one
-   * (its prompt lives in the message history). Absent = log-sourced, and
-   * never materialized as an `undefined`-valued property (plain-JSON
-   * precondition — see the note above `model`).
-   */
-  systemsFromHeader?: true;
   toolsTokens: number;
   /**
    * The projection-cache precondition is plain JSON: a property whose value
@@ -162,31 +140,16 @@ interface TimelineState {
   /**
    * The open step's start instant, armed by `step/start` and consumed by the
    * `assistant/message` (TTFT/generation split) and `step/end` (wall time)
-   * that follow it; `assistant/chunk` stamps `firstToken` on the step's first
-   * token delta — absent when the stream carried none (legacy or aborted
-   * steps), which leaves that call's model time unattributed. One slot, not a
-   * map: steps are sequential in the log, so the newest `step/start` is the
-   * one those events close — a hostile interleaved log degrades to skipped
-   * durations, never to unbounded state. Same arm/remove lifecycle as
-   * `pendingShadowedSeqs`.
-   *
-   * `decode`, `blocks` and `block` carry the generation split (reasoning /
-   * answer text / tool arguments — see TimingTotals): a V0 log's
-   * `assistant/chunk` `block-start` markers open `block`, close the previous
-   * one into `decode`, and count the opened bucket into `blocks` (the card's
-   * per-slice tally); a V2+ log carries no such events, so `decode` stays
-   * absent and `assistant/message` reads the spans and counts off its embedded
-   * stream instead.
+   * that follow it; the message's embedded stream stamps `firstToken` —
+   * absent when the stream carried none (an aborted step), which leaves that
+   * call's model time unattributed. One slot, not a map: steps are sequential
+   * in the log, so the newest `step/start` is the one those events close — a
+   * hostile interleaved log degrades to skipped durations, never to
+   * unbounded state. Same arm/remove lifecycle as `pendingShadowedSeqs`.
    */
   stepStart?: {
     time: number;
     firstToken?: number;
-    decode?: Record<DecodeKind, number>;
-    blocks?: DecodeCounts;
-    block?: {
-      kind: DecodeKind;
-      since: number;
-    };
   };
   /**
    * Tool callId → the call's name, start instant, and raw arguments, armed by
@@ -292,8 +255,7 @@ type Category = 'user' | 'inject' | 'skill' | 'assistant' | 'tool';
 /**
  * One live system-prompt node (Snapshot.systems) — the harness models the
  * system prompt as a surface node, so its TEXT is fetched on demand from the
- * event at `seq`: a V3 `system/message` event, or the V0/V2 `request/header`
- * whose envelope carried `header.system`. `tokens` is the node's heuristic
+ * `system/message` event at `seq`. `tokens` is the node's heuristic
  * price (0 for a dormant empty node, which the harness reads as "no system
  * prompt"); the effective figure is the LAST node with `tokens > 0`.
  */
@@ -452,9 +414,9 @@ interface Snapshot {
   timing?: TimingTotals;
   /**
    * The live system-prompt nodes, oldest first — the browser's per-step source
-   * for the System section. Absent when the log carried no system prompt, and
-   * on older plugin builds (the client then falls back to the header epoch's
-   * own `systemTokens`, the pre-V3 shape).
+   * for the System section. Absent on rows folded before this field existed
+   * (older plugin builds; the client then falls back to the header epoch's
+   * own `systemTokens`, the legacy wire shape those builds served).
    */
   systems?: SystemPromptNode[];
   /**
@@ -536,7 +498,7 @@ interface ContextTimelineDetail {
  * One executed file operation (a settled file-tool call with a resolved
  * target), folded host-side from the durable tool lifecycle: the call's
  * name+arguments (`tool/call`), the result's presentation meta and error
- * (`tool/result`), or a nested Code-Mode settle (`tool/code-dispatch`,
+ * (`tool/result`), or a nested Code-Mode settle (`tool/ptc-dispatch`,
  * located on its parent run_code result via `parent` + `program`).
  *
  * `gone` is NOT host-stamped: the client joins it from the detail's archive
@@ -604,10 +566,9 @@ interface ToolTimingTotals {
  * Whole-session timing totals, host-folded from the durable `step/start` /
  * `step/end` / `tool/call` / `tool/result` lifecycle plus the model call's
  * first token (running totals over the COMPLETE session log — the same
- * never-trimmed framing as `cost`). The first token comes from a V0
- * `assistant/chunk` delta or from the call's own embedded stream
- * (`assistant/message.data.stream` / `assistant/attempt.data.stream`, the
- * V2+ settlement) — whichever the log carries, matching the harness's own
+ * never-trimmed framing as `cost`). The first token comes from the call's
+ * own embedded stream (`assistant/message.data.stream` /
+ * `assistant/attempt.data.stream`), matching the harness's own
  * session-stats fold. Durations are wall-clock milliseconds: `wallMs` sums
  * whole steps, `ttftMs` the step-start → first-token slice (the model wait)
  * and `genMs` the first-token → assistant-message slice (the generation) —
@@ -878,7 +839,33 @@ export interface Config {
   insightsEntry?: InsightsEntry;
 }
 /** The cordis `Config` validator and the Config-form generation's served schema. */
-export declare const Config: z$1<Config>;
+export declare const Config: z$1<Schemastery.ObjectS<NoInfer<{
+  maxRequestSteps: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxKeptTurns: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxEvents: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxNodes: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxArchiveNodes: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxFileOps: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  defaultPlacement: z$1<"all" | "sidebar" | "tab", "all" | "sidebar" | "tab", Mode>;
+  defaultGranularity: z$1<"step" | "turn", "step" | "turn", Mode>;
+  defaultTrendMode: z$1<"delta" | "total", "delta" | "total", Mode>;
+  defaultToolSort: z$1<"count" | "name" | "size", "count" | "name" | "size", Mode>;
+  defaultFileSort: z$1<"count" | "latest" | "path", "count" | "latest" | "path", Mode>;
+  insightsEntry: z$1<"hide" | "show", "hide" | "show", Mode>;
+}>>, Schemastery.ObjectT<NoInfer<{
+  maxRequestSteps: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxKeptTurns: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxEvents: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxNodes: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxArchiveNodes: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  maxFileOps: z$1<number, number, Mode extends "volatile" | "volatile-defined" ? "volatile-defined" : "defined">;
+  defaultPlacement: z$1<"all" | "sidebar" | "tab", "all" | "sidebar" | "tab", Mode>;
+  defaultGranularity: z$1<"step" | "turn", "step" | "turn", Mode>;
+  defaultTrendMode: z$1<"delta" | "total", "delta" | "total", Mode>;
+  defaultToolSort: z$1<"count" | "name" | "size", "count" | "name" | "size", Mode>;
+  defaultFileSort: z$1<"count" | "latest" | "path", "count" | "latest" | "path", Mode>;
+  insightsEntry: z$1<"hide" | "show", "hide" | "show", Mode>;
+}>>, "plain">;
 //#endregion
 //#region src/host/index.d.ts
 export declare const name = "dsh-context";

package/lib/index.js

@@ -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;
@@ -375,9 +373,7 @@ function decodeKindOfBlock(blockType) {
 * 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
+* 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.
@@ -441,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) {
@@ -463,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 {
@@ -903,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;
@@ -1257,20 +1252,6 @@ function applyTimeline(state, event, bounds) {
 				const tools = Array.isArray(header.tools) ? header.tools : [];
 				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) {
@@ -1301,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,
@@ -1327,7 +1307,6 @@ function applyTimeline(state, event, bounds) {
 					};
 				}
 				break;
-			case "tool/code-dispatch":
 			case "tool/ptc-dispatch": {
 				const rootCallId = data?.rootCallId;
 				const name = data?.name;
@@ -1344,47 +1323,6 @@ function applyTimeline(state, event, bounds) {
 				}
 				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);
-					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
-						} } : {}
-					};
-					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;
@@ -1426,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") {
@@ -1565,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], stepStart.blocks?.[kind] ?? 0);
-						} else {
-							const tally = decodeTallyOfStream(data?.stream, event.time);
-							for (const kind of DECODE_KINDS) addDecode(timing, kind, tally.spans[kind], tally.blocks[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);
@@ -2345,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;
@@ -2693,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
@@ -2815,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) => {
@@ -2832,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
@@ -3115,7 +3064,6 @@ 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(),
@@ -3132,25 +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(),
-		blocks: z.object({
-			reasoning: z.number().int(),
-			text: z.number().int(),
-			toolarg: z.number().int()
-		}).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(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.55.0",
+  "version": "0.56.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",
@@ -68,10 +68,8 @@
     },
     "compatibility": {
       "dshReleases": {
-        "0.1.2-rc.1": "compatible",
-        "0.1.3-alpha.2": "compatible",
         "0.1.5-rc.1": "compatible",
-        "0.1.7-alpha.2": "compatible"
+        "0.1.7-rc.2": "compatible"
       }
     }
   },
@@ -90,9 +88,9 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.2-rc.1",
-    "@deepseek-ai/dsh-session": ">=0.1.2-rc.1",
-    "@deepseek-ai/dsh-settings": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.5-rc.1",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.1",
+    "@deepseek-ai/dsh-settings": ">=0.1.5-rc.1",
     "@deepseek-ai/schemastery": "^3.18.2",
     "react": "^18.3.1"
   },
@@ -106,15 +104,16 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-invariants": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-scope": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-session": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-session-projection": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-settings": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-invariants": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-scope": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-session-projection": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-settings": "0.1.5-rc.1",
     "@deepseek-ai/dsh-util-workspace-path": "0.1.5-rc.1",
     "@deepseek-ai/schemastery": "^3.18.4",
     "@opencode-ai/models": "^0.0.72",
+    "@shikijs/langs": "^4.3.1",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@tailwindcss/node": "4.3.3",
     "@tailwindcss/oxide": "4.3.3",
@@ -122,15 +121,30 @@
     "@types/react": "^18.3.31",
     "@types/react-dom": "^18.3.7",
     "@vitest/coverage-v8": "^4.1.11",
+    "anser": "^2.3.5",
+    "clsx": "^2.0.0",
     "eslint-plugin-sonarjs": "^4.2.0",
     "husky": "^9.1.7",
     "jsdom": "^30.0.1",
+    "katex": "^0.16.47",
     "lightningcss": "1.32.0",
+    "mdast-util-from-markdown": "^2.0.3",
+    "mdast-util-gfm": "^3.1.0",
+    "mdast-util-math": "^3.0.0",
+    "micromark-core-commonmark": "^2.0.3",
+    "micromark-extension-gfm": "^3.0.0",
+    "micromark-extension-math": "^3.1.0",
+    "micromark-factory-space": "^2.0.1",
+    "micromark-util-character": "^2.1.1",
+    "micromark-util-classify-character": "^2.0.1",
+    "micromark-util-sanitize-uri": "^2.0.1",
+    "micromark-util-symbol": "^2.0.1",
     "oxlint": "1.82.0",
     "oxlint-tsgolint": "7.0.2001",
     "playwright-core": "^1.62.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
+    "shiki": "^4.3.1",
     "simple-icons": "16.31.0",
     "tailwindcss": "4.3.3",
     "tsdown": "^0.23.0",