dsh-context 0.37.0 → 0.38.1

package/lib/index.d.ts

@@ -85,12 +85,35 @@ interface TimelineState {
   cost?: SessionCostUsage;
   archiveFloor?: number;
   /**
-   * Tool callId → name, armed by `tool/call` and DELETED when its
-   * `tool/result` folds in (one result per call, in log order) — the map
-   * stays at pending-call size instead of growing for the session's whole
-   * lifetime (it is persisted state, shallow-copied by every fold step).
+   * Whole-session timing totals (see TimingTotals) — running sums over the
+   * COMPLETE session log, like `cost`. Absent until the first step or tool
+   * lifecycle folds in; created once and cloned-on-touch afterwards (the
+   * object is shared with the persisted previous state — see `ensure`).
    */
-  callNames: Record<string, string>;
+  timing?: TimingTotals;
+  /**
+   * The open step's start instant, armed by `step/start` and consumed by the
+   * `assistant/message` (LM-call time) and `step/end` (wall time) that follow
+   * it. 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;
+  };
+  /**
+   * Tool callId → the call's name and start instant, armed by `tool/call` and
+   * DELETED when its `tool/result` folds in (one result per call, in log
+   * order) — the map stays at pending-call size instead of growing for the
+   * session's whole lifetime (it is persisted state, shallow-copied by every
+   * fold step). The start instant prices the call's duration into
+   * `timing.toolsMs` when the result arrives.
+   */
+  callNames: Record<string, {
+    name: string;
+    start: number;
+  }>;
   /**
    * Seq list of the surface nodes the next replacement will shadow, armed by
    * the metering event (`compaction/summary` | `compaction/prune`) and
@@ -187,6 +210,12 @@ interface Snapshot {
    * request reports usage.
    */
   cost?: SessionCostUsage;
+  /**
+   * Whole-session timing totals (see TimingTotals). Absent until the first
+   * step lifecycle completes in the log (older plugin builds never folded
+   * one — clients treat absence as an empty timing card).
+   */
+  timing?: TimingTotals;
   /**
    * The served live surface: the newest `maxNodes` tail PLUS every live inject node older than the tail (injections land first and are
    * few,
@@ -230,6 +259,37 @@ interface CostBucketTotals {
   cacheWrite: number;
   output: number;
 }
+/**
+ * One completed tool name's whole-session call tally behind the timing
+ * card's top-tools ranking (running totals, never trimmed).
+ */
+interface ToolTimingTotals {
+  calls: number;
+  ms: number;
+}
+/**
+ * Whole-session timing totals, host-folded from the durable `step/start` /
+ `step/end` / `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 whole steps, `lmMs` the
+ * step-start → assistant-message slice (the model call), `toolsMs` the sum of
+ * per-call tool durations (parallel calls each count, so it can overlap).
+ * Absent until the first step lifecycle completes in the log.
+ */
+interface TimingTotals {
+  /** Summed wall time of completed steps (the session's active time). */
+  wallMs: number;
+  /** Summed step-start → assistant-message time (model-call time). */
+  lmMs: number;
+  /** Completed model calls (assistant messages folded). */
+  calls: number;
+  /** Summed per-call durations of completed tool calls. */
+  toolsMs: number;
+  /** Completed tool calls (call/result pairs folded). */
+  toolCalls: number;
+  /** Per-tool-name tallies behind the timing card's ranking (bounded). */
+  tools: Record<string, ToolTimingTotals>;
+}
 /** One model family's totals split by DeepSeek's pricing period (Beijing Time). */
 interface CostFamilyUsage {
   peak?: CostBucketTotals;

package/lib/index.js

@@ -786,10 +786,18 @@ function applySurface(st, ev, type, data, message) {
 		}
 	} else if (type === "tool/result") {
 		const srcId = source?.callId;
-		const srcName = typeof srcId === "string" ? st.callNames[srcId] : void 0;
 		const blockId = (message?.content?.[0])?.toolCallId;
-		if (srcName !== void 0) node.tool = srcName;
-		else if (typeof blockId === "string" && Object.hasOwn(st.callNames, blockId)) node.tool = st.callNames[blockId];
+		const srcEntry = typeof srcId === "string" ? st.callNames[srcId] : void 0;
+		const blockEntry = srcEntry === void 0 && typeof blockId === "string" ? st.callNames[blockId] : void 0;
+		const toolEntry = srcEntry ?? blockEntry;
+		if (toolEntry !== void 0) {
+			node.tool = toolEntry.name;
+			const timing = ensureTiming(st);
+			const dur = durOf(toolEntry.start, ev.time);
+			timing.toolsMs += dur;
+			timing.toolCalls += 1;
+			bumpToolTotals(timing, toolEntry.name, dur);
+		}
 		if (typeof srcId === "string" || typeof blockId === "string") {
 			const kept = {};
 			for (const k in st.callNames) if (k !== srcId && k !== blockId) kept[k] = st.callNames[k];
@@ -922,6 +930,60 @@ function accumulateCost(st, time, usage) {
 * `bounds` come from the plugin config (config.ts) — retention only, they
 * never change the state shape.
 */
+/** The timing card's per-tool ranking cap: the busiest 16 names are kept. */
+const TOOL_TIMING_CAP = 16;
+/** Non-negative, NaN-proof duration between two instants (hostile times degrade to 0). */
+function durOf(from, to) {
+	if (!Number.isFinite(from) || !Number.isFinite(to)) return 0;
+	return Math.max(0, to - from);
+}
+/**
+* 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.
+*/
+function ensureTiming(st) {
+	if (st.timing === void 0) st.timing = {
+		wallMs: 0,
+		lmMs: 0,
+		calls: 0,
+		toolsMs: 0,
+		toolCalls: 0,
+		tools: {}
+	};
+	return st.timing;
+}
+/**
+* Tally one completed tool call into the per-name ranking, bounded to
+* TOOL_TIMING_CAP names: repeated names update in place, a new name beyond
+* the cap evicts the smallest tally first (the ranking's tail), so state
+* stays bounded even over a hostile log of unique names.
+*/
+function bumpToolTotals(timing, name, ms) {
+	if (!Object.hasOwn(timing.tools, name)) {
+		if (Object.keys(timing.tools).length >= TOOL_TIMING_CAP) {
+			let minKey = "";
+			let minMs = Infinity;
+			for (const k in timing.tools) if (timing.tools[k].ms < minMs) {
+				minMs = timing.tools[k].ms;
+				minKey = k;
+			}
+			const kept = {};
+			for (const k in timing.tools) if (k !== minKey) kept[k] = timing.tools[k];
+			timing.tools = kept;
+		}
+		timing.tools[name] = {
+			calls: 1,
+			ms
+		};
+		return;
+	}
+	const cur = timing.tools[name];
+	timing.tools[name] = {
+		calls: cur.calls + 1,
+		ms: cur.ms + ms
+	};
+}
 function applyTimeline(state, event, bounds) {
 	let st;
 	const ensure = () => st ??= {
@@ -931,7 +993,11 @@ function applyTimeline(state, event, bounds) {
 		requests: [...state.requests],
 		events: [...state.events],
 		archived: [...state.archived],
-		callNames: { ...state.callNames }
+		callNames: { ...state.callNames },
+		...state.timing !== void 0 ? { timing: {
+			...state.timing,
+			tools: { ...state.timing.tools }
+		} } : {}
 	};
 	const data = event.data;
 	try {
@@ -964,9 +1030,25 @@ function applyTimeline(state, event, bounds) {
 			case "tool/call":
 				if (data && typeof data.callId === "string" && typeof data.name === "string") {
 					const s = ensure();
-					s.callNames[data.callId] = data.name;
+					s.callNames[data.callId] = {
+						name: data.name,
+						start: event.time
+					};
 				}
 				break;
+			case "step/start": {
+				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();
+				ensureTiming(s).wallMs += durOf(start.time, event.time);
+				delete s.stepStart;
+				break;
+			}
 			case "user/message": {
 				const msg = deriveEventMessage(event);
 				const s = ensure();
@@ -1037,6 +1119,10 @@ function applyTimeline(state, event, bounds) {
 					accumulateCost(s, event.time, usage);
 				}
 				s.requests.push(record);
+				const timing = ensureTiming(s);
+				timing.calls += 1;
+				const stepStart = state.stepStart;
+				if (stepStart !== void 0) timing.lmMs += durOf(stepStart.time, event.time);
 				const asstMsg = deriveEventMessage(event);
 				applySurface(s, event, event.type, data, asstMsg);
 				break;
@@ -1120,6 +1206,14 @@ function buildTimelineView(state, bounds) {
 		if (pro !== void 0) cost.pro = pro;
 		result.cost = cost;
 	}
+	if (state.timing !== void 0) {
+		const tools = {};
+		for (const k in state.timing.tools) tools[k] = { ...state.timing.tools[k] };
+		result.timing = {
+			...state.timing,
+			tools
+		};
+	}
 	const overflowCount = Math.max(0, state.surface.length - bounds.maxNodes);
 	const overflow = state.surface.slice(0, overflowCount);
 	const tail = state.surface.slice(overflowCount);
@@ -1249,6 +1343,18 @@ const costFamilySchema = z.object({
 	peak: costBucketsSchema.optional(),
 	off: costBucketsSchema.optional()
 }).strict();
+const toolTimingSchema = z.object({
+	calls: z.number().int().nonnegative(),
+	ms: z.number().nonnegative()
+}).strict();
+const timingTotalsSchema = z.object({
+	wallMs: z.number().nonnegative(),
+	lmMs: z.number().nonnegative(),
+	calls: z.number().int().nonnegative(),
+	toolsMs: z.number().nonnegative(),
+	toolCalls: z.number().int().nonnegative(),
+	tools: z.record(z.string(), toolTimingSchema)
+}).strict();
 const contextTimelineSchema = z.object({
 	ok: z.literal(true),
 	model: z.string().optional(),
@@ -1263,6 +1369,7 @@ const contextTimelineSchema = z.object({
 		flash: costFamilySchema.optional(),
 		pro: costFamilySchema.optional()
 	}).strict().optional(),
+	timing: timingTotalsSchema.optional(),
 	nodes: z.array(surfaceNodeSchema),
 	droppedNodes: z.number().int().nonnegative(),
 	archive: z.array(surfaceNodeSchema),
@@ -1297,7 +1404,12 @@ const timelineStateSchema = z.object({
 		pro: costFamilySchema.optional()
 	}).strict().optional(),
 	archiveFloor: z.number().optional(),
-	callNames: z.record(z.string(), z.string()),
+	timing: timingTotalsSchema.optional(),
+	stepStart: z.object({ time: z.number() }).strict().optional(),
+	callNames: z.record(z.string(), z.object({
+		name: z.string(),
+		start: z.number()
+	}).strict()),
 	pendingShadowedSeqs: z.array(z.number()).optional(),
 	pendingShadowEventSeq: z.number().optional()
 });
@@ -1335,7 +1447,7 @@ function createContextTimelineDefinition(config) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 10
+		stateVersion: 11
 	};
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.37.0",
+  "version": "0.38.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": {
@@ -34,7 +34,7 @@
     "build": "tsdown",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
-    "watch": "tsdown --watch",
+    "watch": "bash scripts/watch.sh",
     "register": "bash scripts/register.sh",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.tests.json",
     "test": "pnpm run typecheck && vitest run --coverage",