dsh-context 0.46.0 → 0.47.0

package/lib/index.d.ts

@@ -72,6 +72,27 @@ interface TimelineState {
   surface: SurfaceNode[];
   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
+   * 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
+   * wire then serves no `systems` and the client falls back to the header
+   * 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
@@ -221,6 +242,19 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
   }
 }
 type Category = 'user' | 'inject' | '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
+ * 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`.
+ */
+interface SystemPromptNode {
+  seq: number;
+  time: number;
+  tokens: number;
+}
 /**
  * The stats board's count figures, precomputed host-side over the RETAINED
  * request/event records (the same set the detail payload serves). Carried by
@@ -316,6 +350,13 @@ interface Snapshot {
    * one — clients treat absence as an empty timing card).
    */
   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).
+   */
+  systems?: SystemPromptNode[];
   /**
    * The served live surface: the newest `maxNodes` tail PLUS every live inject node older than the tail (injections land first and are
    * few,
@@ -450,9 +491,13 @@ interface ToolTimingTotals {
 }
 /**
  * Whole-session timing totals, host-folded from the durable `step/start` /
- `step/end` / `assistant/chunk` / `tool/call` / `tool/result` lifecycle
- * (running totals over the COMPLETE session log — the same never-trimmed
- * framing as `cost`). Durations are wall-clock milliseconds: `wallMs` sums
+ * `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
+ * 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) —
  * both only over calls whose stream carried a token delta, `toolsMs` the sum

package/lib/index.js

@@ -308,6 +308,30 @@ 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;
+	for (const block of blocks) {
+		const text = block !== null && typeof block === "object" && block.type === "text" ? block.text : void 0;
+		if (typeof text === "string") {
+			characters += text.length;
+			continue;
+		}
+		try {
+			const json = JSON.stringify(block);
+			if (typeof json === "string") characters += json.length;
+		} catch {}
+	}
+	return Math.ceil(characters / CHARS_PER_TOKEN$1) + ROLE_OVERHEAD$1;
+}
 //#endregion
 //#region src/shared/imageTokens.ts
 /**
@@ -565,6 +589,111 @@ function isInjection(source) {
 	return source !== null && source !== void 0 && (typeof source.kind === "string" && source.kind !== "" && source.kind !== "user" || typeof source.form === "string");
 }
 //#endregion
+//#region src/host/logShapes.ts
+/**
+* Shape-driven readers over the durable session-event vocabulary — the ONE
+* place the plugin reconciles the two supported log generations:
+*
+*   - 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.1+): `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).
+*
+* @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.
+*/
+function isTokenChunk(chunk) {
+	if (chunk === null || typeof chunk !== "object") return false;
+	const c = chunk;
+	switch (c.type) {
+		case "text-delta":
+		case "reasoning-delta": return typeof c.text === "string" && c.text !== "";
+		case "tool-call-delta": return typeof c.argumentsDelta === "string" && c.argumentsDelta !== "" || c.name !== void 0;
+		default: return false;
+	}
+}
+/**
+* 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;
+	if (record.type === "tool-call-chunks" && record.name !== void 0) return time0;
+	const fragments = record.type === "tool-call-chunks" ? record.args : record.texts;
+	if (!Array.isArray(fragments)) return void 0;
+	const dt = Array.isArray(record.dt) ? record.dt : [];
+	let time = time0;
+	for (const [index, fragment] of fragments.entries()) {
+		if (index > 0) {
+			const step = dt[index - 1];
+			if (typeof step !== "number" || !Number.isFinite(step)) return void 0;
+			time += step;
+		}
+		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` — the V2+
+* settlement that replaced the V0 `assistant/chunk` events), 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) {
+		if (record === null || typeof record !== "object") continue;
+		const r = record;
+		if (r.type === "chunk") {
+			const time = r.time;
+			if (typeof time === "number" && Number.isFinite(time) && isTokenChunk(r.chunk)) return time;
+			continue;
+		}
+		const time = runFirstTokenTime(r);
+		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).
+* 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.
+*/
+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;
+	if (typeof start !== "number" || !Number.isFinite(start)) return null;
+	if (typeof end !== "number" || !Number.isFinite(end)) return null;
+	return {
+		start,
+		end
+	};
+}
+//#endregion
 //#region src/shared/fileOps.ts
 /** Parse a call's raw JSON arguments; non-string/malformed/non-record inputs yield null. */
 function parseCallArgs(raw) {
@@ -873,6 +1002,24 @@ 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.
@@ -919,6 +1066,35 @@ function archiveRemoved(st, removed, 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 = [];
+	const removed = [];
+	for (const n of st.surface) if (claimed.has(n.seq)) {
+		st.sums[n.cat] -= n.tokens;
+		removed.push(n);
+	} else kept.push(n);
+	archiveRemoved(st, removed, goneSeq);
+	st.surface = kept;
+	return removed;
+}
+/**
+* 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.
+*/
+function messageOf(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
@@ -1002,18 +1178,10 @@ function applySurface(st, ev, type, data, message) {
 	const shadowEventSeq = st.pendingShadowEventSeq;
 	delete st.pendingShadowedSeqs;
 	delete st.pendingShadowEventSeq;
-	const op = ev.surfaceOp;
-	if (op !== null && typeof op === "object" && op.op === "replace") {
+	const op = replaceRangeOf(ev.surfaceOp);
+	if (op !== null) {
 		if (Array.isArray(shadowedSeqs) && shadowedSeqs.length > 0) {
-			const shadowed = new Set(shadowedSeqs);
-			const kept = [];
-			const removed = [];
-			for (const n of st.surface) if (shadowed.has(n.seq)) {
-				st.sums[n.cat] -= n.tokens;
-				removed.push(n);
-			} else kept.push(n);
-			archiveRemoved(st, removed, ev.seq);
-			st.surface = kept;
+			const removed = removeSurfaceSeqs(st, new Set(shadowedSeqs), ev.seq);
 			st.sums[cat] += node.tokens;
 			st.surface.push(node);
 			if (shadowEventSeq !== void 0) {
@@ -1138,21 +1306,6 @@ function durOf(from, to) {
 	return Math.max(0, to - from);
 }
 /**
-* Whether a stream chunk carries a non-empty token delta — the first-token
-* marker the TTFT fold waits for (the same rule as the harness's own
-* session-stats fold). Shape-guarded: a malformed chunk is just not a token.
-*/
-function isTokenDelta(chunk) {
-	if (chunk === null || typeof chunk !== "object") return false;
-	const c = chunk;
-	switch (c.type) {
-		case "text-delta":
-		case "reasoning-delta": return typeof c.text === "string" && c.text !== "";
-		case "tool-call-delta": return typeof c.argumentsDelta === "string" && c.argumentsDelta !== "" || c.name !== void 0;
-		default: return false;
-	}
-}
-/**
 * 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.
@@ -1225,7 +1378,20 @@ function applyTimeline(state, event, bounds) {
 				const tools = Array.isArray(header.tools) ? header.tools : [];
 				const s = ensure();
 				s.toolsTokens = estimateToolsTotal(tools);
-				s.systemTokens = estimateSystemTokens(header.system);
+				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) {
@@ -1241,6 +1407,25 @@ function applyTimeline(state, event, bounds) {
 				if (s.model) s.lastModel = s.model;
 				break;
 			}
+			case "system/message": {
+				const s = ensure();
+				delete s.pendingShadowedSeqs;
+				delete s.pendingShadowEventSeq;
+				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();
+					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,
+					tokens: estimateSystemContent(messageOf(data)?.content)
+				});
+				break;
+			}
 			case "request/context": {
 				const s = ensure();
 				if (data && typeof data.contextWindow === "number") s.contextWindow = data.contextWindow;
@@ -1259,7 +1444,8 @@ function applyTimeline(state, event, bounds) {
 					};
 				}
 				break;
-			case "tool/code-dispatch": {
+			case "tool/code-dispatch":
+			case "tool/ptc-dispatch": {
 				const rootCallId = data?.rootCallId;
 				const name = data?.name;
 				if (typeof rootCallId === "string" && typeof name === "string") {
@@ -1277,7 +1463,7 @@ function applyTimeline(state, event, bounds) {
 			case "assistant/chunk": {
 				const start = state.stepStart;
 				if (start === void 0 || start.firstToken !== void 0) return state;
-				if (!isTokenDelta(data?.chunk)) return state;
+				if (!isTokenChunk(data?.chunk)) return state;
 				const s = ensure();
 				s.stepStart = {
 					time: start.time,
@@ -1285,6 +1471,18 @@ function applyTimeline(state, event, bounds) {
 				};
 				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();
+				s.stepStart = {
+					time: start.time,
+					firstToken: first
+				};
+				break;
+			}
 			case "step/start": {
 				const s = ensure();
 				s.stepStart = { time: event.time };
@@ -1410,9 +1608,12 @@ function applyTimeline(state, event, bounds) {
 				const timing = ensureTiming(s);
 				timing.calls += 1;
 				const stepStart = state.stepStart;
-				if (stepStart !== void 0 && stepStart.firstToken !== void 0) {
-					timing.ttftMs += durOf(stepStart.time, stepStart.firstToken);
-					timing.genMs += durOf(stepStart.firstToken, event.time);
+				if (stepStart !== void 0) {
+					const firstToken = stepStart.firstToken ?? firstTokenTimeOfStream(data?.stream);
+					if (firstToken !== void 0) {
+						timing.ttftMs += durOf(stepStart.time, firstToken);
+						timing.genMs += durOf(firstToken, event.time);
+					}
 				}
 				const asstMsg = deriveEventMessage(event);
 				applySurface(s, event, event.type, data, asstMsg);
@@ -1514,6 +1715,7 @@ function headFieldsOf(state) {
 			tools
 		};
 	}
+	if (state.systems !== void 0 && state.systems.length > 0) result.systems = state.systems.map((n) => ({ ...n }));
 	return result;
 }
 /**
@@ -1951,6 +2153,12 @@ const surfaceNodeSchema = z.object({
 	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(),
@@ -2097,6 +2305,7 @@ const contextTimelineSchema = z.object({
 		pro: costFamilySchema.optional()
 	}).strict().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(),
@@ -2120,6 +2329,8 @@ const timelineStateSchema = z.object({
 		tool: z.number().int().nonnegative()
 	}).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(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.46.0",
+  "version": "0.47.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.",
   "author": "bowenliang123",
   "repository": {
@@ -57,13 +57,16 @@
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-conversation",
-        "@deepseek-ai/dsh-client-ui-settings"
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
       ],
       "platform": "web"
     },
     "compatibility": {
       "dshReleases": {
-        "0.1.2-rc.1": "compatible"
+        "0.1.2-rc.1": "compatible",
+        "0.1.3-alpha.2": "compatible",
+        "0.1.5-alpha.1": "compatible"
       }
     }
   },