dsh-context 0.39.0 → 0.40.1

package/lib/index.d.ts

@@ -30,8 +30,27 @@ declare const Config: z.ZodPreprocess<z.ZodObject<{
 }, z.core.$strict>>;
 //#endregion
 //#region src/host/headers.d.ts
+/**
+ * One stored tool: the v1 row shape carried the producer description and the
+ * raw schema; folds since the #37 slim-down append metadata-only entries.
+ */
+interface StoredHeaderTool {
+  name: string;
+  tokens: number;
+  description?: string;
+  plugin?: string;
+  schema?: unknown;
+}
+/** One stored epoch: v1 rows carried `system`; folds since carry `systemTokens`. */
+interface StoredHeaderRecord {
+  seq: number;
+  time: number;
+  system?: string;
+  systemTokens?: number;
+  tools: StoredHeaderTool[];
+}
 interface HeadersState {
-  headers: HeaderRecord[];
+  headers: StoredHeaderRecord[];
 }
 //#endregion
 //#region src/host/fold.d.ts
@@ -382,12 +401,10 @@ interface ContextEventRecord {
   turn?: number;
   step?: number;
 }
-/** One tool schema as assembled into a request header, with its display price. */
+/** One tool of a request-header epoch, with its display price. */
 interface HeaderTool {
   name: string;
   tokens: number;
-  /** Producer-declared description (may be long; the browser truncates). */
-  description?: string;
   /**
    * The registering plugin's label, when attribution is known: either a
    * `plugin` field carried by the raw header entry (harness-provided) or the
@@ -397,16 +414,21 @@ interface HeaderTool {
    * the browser shows no tag.
    */
   plugin?: string;
-  /** The raw JSON schema object the model received (plain JSON). */
-  schema?: unknown;
 }
 /**
- * One request-header epoch: the full system prompt and tool schemas in force from this event's seq until the next epoch.
+ * One request-header epoch's METADATA: the epoch boundaries and token prices
+ * in force from this event's seq until the next epoch. The epoch CONTENT
+ * (full system prompt text, tool descriptions/schemas) is not projected —
+ * every session.list row, control baseline, push frame, and projection-cache
+ * checkpoint would otherwise carry it per session × epoch. The client
+ * fetches one epoch's content on demand (a seq-anchored history read off
+ * `seq`) as a {@link HeaderEpochContent}.
  */
 interface HeaderRecord {
   seq: number;
   time: number;
-  system?: string;
+  /** The epoch's estimated system-prompt tokens; absent when it logged no system prompt. */
+  systemTokens?: number;
   tools: HeaderTool[];
 }
 /** The `contextHeaders` projection value: the bounded epoch list (newest last). */

package/lib/index.js

@@ -433,11 +433,11 @@ function estimateImageTokens(width, height) {
 * (shared/imageTokens.ts), falling back to the meter's JSON price when the
 * attachment's dimensions are unknown.
 */
-const CHARS_PER_TOKEN = 4;
+const CHARS_PER_TOKEN$1 = 4;
 const BLOCK_OVERHEAD = 4;
-const ROLE_OVERHEAD = 4;
+const ROLE_OVERHEAD$1 = 4;
 function estimateToolsTotal(tools) {
-	return tools.length > 0 ? Math.ceil(JSON.stringify(tools).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD : 0;
+	return tools.length > 0 ? Math.ceil(JSON.stringify(tools).length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD : 0;
 }
 /** The `ContentBlock` walkers take `unknown`: block arrays ride the untrusted
 * log, so their element shapes (null and primitives included) are re-proved
@@ -454,10 +454,10 @@ function estimateBlocks(blocks) {
 		switch (block.type) {
 			case "text":
 			case "reasoning":
-				tokens += Math.ceil((block.text || "").length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+				tokens += Math.ceil((block.text || "").length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
 				break;
 			case "tool-call":
-				tokens += Math.ceil((block.name || "").length / CHARS_PER_TOKEN) + Math.ceil((block.arguments || "").length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+				tokens += Math.ceil((block.name || "").length / CHARS_PER_TOKEN$1) + Math.ceil((block.arguments || "").length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
 				break;
 			case "tool-result":
 				tokens += estimateBlocks(block.content) + BLOCK_OVERHEAD;
@@ -465,10 +465,10 @@ function estimateBlocks(blocks) {
 			case "image": {
 				const ref = block.attachment;
 				const priced = ref !== null && typeof ref === "object" && typeof ref.width === "number" && typeof ref.height === "number" ? estimateImageTokens(ref.width, ref.height) : null;
-				tokens += (priced ?? Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN)) + BLOCK_OVERHEAD;
+				tokens += (priced ?? Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN$1)) + BLOCK_OVERHEAD;
 				break;
 			}
-			default: tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN);
+			default: tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN$1);
 		}
 	}
 	return tokens;
@@ -480,15 +480,12 @@ function estimateBlocks(blocks) {
 */
 function estimateMessage(message, emptyIsZero = false) {
 	if (emptyIsZero && (message === null || message === void 0 || !Array.isArray(message.content) || message.content.length === 0)) return 0;
-	return estimateBlocks(message?.content) + ROLE_OVERHEAD;
-}
-function estimateSystem(text) {
-	if (typeof text !== "string" || text.length === 0) return 0;
-	return Math.ceil(text.length / CHARS_PER_TOKEN) + ROLE_OVERHEAD;
+	return estimateBlocks(message?.content) + ROLE_OVERHEAD$1;
 }
+/** The shared meter heuristic over rendered system-prompt text (shared/estimate.ts). */
 /** Per-tool price for the top-tools display (the total uses dsh's whole-array price). */
 function estimateToolSchema(tool) {
-	return Math.ceil(JSON.stringify(tool).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+	return Math.ceil(JSON.stringify(tool).length / CHARS_PER_TOKEN$1) + BLOCK_OVERHEAD;
 }
 /**
 * Count image blocks in a message payload, recursing into nested content (tool-result blocks carry their inner blocks) — seeds each node's
@@ -547,44 +544,90 @@ 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/shared/estimate.ts
+/**
+* Token heuristics shared by the host fold and the client boundary — the
+* harness token-meter's own fixed-density figure (dsh-token-meter/estimate.ts:
+* ~4 chars ≈ 1 token, +4 role framing). Priced identically on both sides so a
+* legacy value normalized at the client boundary matches what the host view
+* would have served.
+*/
+const CHARS_PER_TOKEN = 4;
+const ROLE_OVERHEAD = 4;
+/** Price rendered system-prompt text; 0 for absent/empty/non-string input. */
+function estimateSystemTokens(text) {
+	if (typeof text !== "string" || text.length === 0) return 0;
+	return Math.ceil(text.length / CHARS_PER_TOKEN) + ROLE_OVERHEAD;
+}
+//#endregion
 //#region src/host/headers.ts
 /**
-* The `contextHeaders` session projection unit — the request-header CONTENT
-* epochs behind the timeline's envelope figures.
+* The `contextHeaders` session projection unit — the request-header EPOCH
+* METADATA behind the timeline's envelope figures.
 *
 * The hot `contextTimeline` unit carries only token prices of the system
-* prompt and tool schemas; this companion unit keeps the CONTENT (full
-* system prompt text, full tool JSON schemas) so the Context browser card
-* can show what a picked step's request was actually assembled from. It is
-* a separate unit on purpose: the agent loop logs `request/header` only
-* when the header changes, so this state (and its pushes to the browser)
-* moves rarely — carrying full content costs nothing on the per-event hot
-* path.
+* prompt and tool schemas; this companion unit keeps the per-epoch METADATA
+* (epoch seq/time boundaries, per-tool token prices and plugin attribution)
+* so the Context browser can pick the header epoch in force at any step and
+* size its sections immediately. The epoch CONTENT (full system prompt text,
+* full tool JSON schemas) deliberately does NOT ride the projection VALUE:
+* session projections are served whole in every `session.list` row, control
+* baseline, push frame, and change notification, so carrying content here
+* multiplied it by sessions × epochs across every channel. The client
+* fetches one epoch's `request/header` event on demand — a seq-anchored
+* history read off the epoch's `seq`, the same targeted read the browser
+* already uses for message content — and caches it per session (history is
+* immutable).
+*
+* Read-compat over the persisted state (the pinned decision behind keeping
+* `stateVersion` at 1): the harness serves a cold session's projections from
+* its CACHED checkpoint rows and has no refresh channel for an idle session
+* — a version bump invalidates every row and orphans the key until the
+* session goes live again (the #37 regression). The state therefore still
+* ACCEPTS the v1 content-bearing record shape, current folds append
+* metadata-only records alongside any seeded legacy ones, and the view
+* normalizes BOTH to the metadata-only wire shape (pricing the legacy system
+* text at read time). Cached v1 rows keep working, new checkpoint writes
+* shrink as legacy epochs age out of the capped list, and the wire — the
+* part every delivery channel carries — is metadata-only from day one.
 *
 * Same projection contract as the timeline unit: pure init/apply/view,
 * `Object.is` reference stability for uninteresting events, plain-JSON
 * bounded state (epoch list capped — see HEADERS_MAX).
 */
-/** Retention cap on header epochs (changes are rare; 50 is generous). */
+/** Retention cap on header epochs (metadata only; changes are rare; 50 is generous). */
 const HEADERS_MAX = 50;
-const headerToolSchema = z.object({
+/**
+* The persisted-state schema: the SUPERSET of both record generations, so a
+* cached v1 row (content-bearing) seeds the fold instead of being discarded.
+*/
+const storedToolSchema = z.object({
 	name: z.string(),
 	tokens: z.number().int().nonnegative(),
 	description: z.string().optional(),
 	plugin: z.string().optional(),
 	schema: z.unknown().optional()
 }).strict();
-const contextHeadersSchema = z.object({ headers: z.array(z.object({
+const storedEpochSchema = z.object({
 	seq: z.number(),
 	time: z.number(),
 	system: z.string().optional(),
-	tools: z.array(headerToolSchema)
+	systemTokens: z.number().int().nonnegative().optional(),
+	tools: z.array(storedToolSchema)
+}).strict();
+const contextHeadersStateSchema = z.object({ headers: z.array(storedEpochSchema) }).strict();
+/** The wire schema: strict metadata — the shape every delivery channel carries. */
+const headerToolWireSchema = z.object({
+	name: z.string(),
+	tokens: z.number().int().nonnegative(),
+	plugin: z.string().optional()
+}).strict();
+const contextHeadersSchema = z.object({ headers: z.array(z.object({
+	seq: z.number(),
+	time: z.number(),
+	systemTokens: z.number().int().nonnegative().optional(),
+	tools: z.array(headerToolWireSchema)
 }).strict()) }).strict();
-/**
-* State and wire are the same shape (the view only shallow-copies each record), so one schema validates both under the dsh 0.1.1-rc.1+
-* `stateSchema`/`wire` contract.
-*/
-const contextHeadersStateSchema = contextHeadersSchema;
 function recordOf(event) {
 	if (event.type !== "request/header") return null;
 	const rawHeader = event.data.header;
@@ -598,36 +641,41 @@ function recordOf(event) {
 			const tool = t !== null && typeof t === "object" ? t : {};
 			const entry = {
 				name: typeof tool.name === "string" ? tool.name : "?",
-				tokens: estimateToolSchema(t),
-				schema: t
+				tokens: estimateToolSchema(t)
 			};
-			if (typeof tool.description === "string" && tool.description !== "") entry.description = tool.description;
 			if (typeof tool.plugin === "string" && tool.plugin !== "") entry.plugin = tool.plugin;
 			return entry;
 		})
 	};
-	if (typeof header.system === "string" && header.system.length > 0) record.system = header.system;
+	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
-* `useProjection('contextHeaders')` and degrade to tokens-only header sections when the key is absent. Contract mirror
-* with a REQUIRED `wire` block (see compat.ts).
+* `useProjection('contextHeaders')` and fetch an epoch's full content on demand via the session history (historyPage.ts).
+* Contract mirror with a REQUIRED `wire` block (see compat.ts).
 * @param resolve - best-effort tool-to-plugin attribution (see toolSources.ts); fills a missing `plugin` at view time so
 * epochs folded without attribution still render a tag when the source is known.
 */
 function createContextHeadersDefinition(resolve) {
-	const view = (state) => ({ headers: state.headers.map((h) => ({
-		...h,
-		tools: h.tools.map((t) => {
-			if (resolve === void 0 || t.plugin !== void 0) return { ...t };
-			const plugin = resolve(t.name);
-			return plugin === void 0 ? { ...t } : {
-				...t,
-				plugin
-			};
-		})
-	})) });
+	const view = (state) => ({ headers: state.headers.map((h) => {
+		const record = {
+			seq: h.seq,
+			time: h.time,
+			tools: h.tools.map((t) => {
+				const entry = {
+					name: t.name,
+					tokens: t.tokens
+				};
+				const plugin = t.plugin ?? (resolve !== void 0 ? resolve(t.name) : void 0);
+				if (plugin !== void 0) entry.plugin = plugin;
+				return entry;
+			})
+		};
+		const systemTokens = h.systemTokens ?? (typeof h.system === "string" && h.system !== "" ? estimateSystemTokens(h.system) : void 0);
+		if (systemTokens !== void 0) record.systemTokens = systemTokens;
+		return record;
+	}) });
 	return {
 		key: "contextHeaders",
 		stateSchema: contextHeadersStateSchema,
@@ -1014,7 +1062,7 @@ function applyTimeline(state, event, bounds) {
 				const tools = Array.isArray(header.tools) ? header.tools : [];
 				const s = ensure();
 				s.toolsTokens = estimateToolsTotal(tools);
-				s.systemTokens = estimateSystem(header.system);
+				s.systemTokens = estimateSystemTokens(header.system);
 				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) s.events.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "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": {