dsh-context 0.60.0 → 0.62.0

package/lib/index.d.ts

@@ -157,6 +157,28 @@ interface TimelineState {
     time: number;
     firstToken?: number;
   };
+  /**
+   * The timing strip's painted spans (shared/types.ts TimingSpan): every
+   * completed step's time slices in log order, stamped with their REAL
+   * instants — the TTFT wait, the decode blocks in stream order, the tool-run
+   * windows, and the in-step residue. The client packs them gapless, each
+   * band's width its share of the cumulative active time (idle time BETWEEN
+   * steps carries no span and takes no track). Bounded by TIMING_SPANS_MAX
+   * (newest tail kept). Flushed per step at `step/end` from the `stepSpans`
+   * accumulator.
+   */
+  spans: TimingSpan[];
+  /**
+   * The open step's accumulated painted spans: the assistant message pushes
+   * the model slices (TTFT + the decode blocks), each paired tool result its
+   * run window; `step/end` clamps them into the step window, de-overlaps
+   * first-wins (parallel runs paint their union), fills the holes with the
+   * residue kind, and flushes the tiling into `spans`. Absent until the first
+   * in-step span; DELETED at the flush (the plain-JSON precondition). Same
+   * arm/remove lifecycle as `stepStart` — never written in place, always
+   * replaced, so no CloneKey covers it.
+   */
+  stepSpans?: TimingSpan[];
   /**
    * Tool callId → the call's name, start instant, and raw arguments, armed by
    * `tool/call` and DELETED when its `tool/result` folds in (one result per
@@ -469,6 +491,13 @@ interface Snapshot {
    */
   fileOps?: FileOpRecord[];
   fileOpsFloor?: number;
+  /**
+   * The timing strip's painted spans (see TimingSpan) — present on the INLINE
+   * wire value and on the detail payload, absent from the slim head (they ride
+   * the detail channel there) and from rows folded before the collection
+   * existed (older hosts; the client then shows no strip).
+   */
+  spans?: TimingSpan[];
 }
 /**
  * The on-demand DETAIL payload of the split `contextTimeline` generation —
@@ -509,6 +538,13 @@ interface ContextTimelineDetail {
   fileOps?: FileOpRecord[];
   /** The newest dropped op's seq when the op log trimmed (coverage honesty, same family as archiveFloor). */
   fileOpsFloor?: number;
+  /**
+   * The timing strip's painted spans (see TimingSpan): the completed steps'
+   * time slices in log order, positioned by their real instants. Additive-
+   * optional: a payload folded before the collection existed (older hosts)
+   * serves without it, and the timing card shows no strip then.
+   */
+  spans?: TimingSpan[];
 }
 /**
  * One executed file operation (a settled file-tool call with a resolved
@@ -559,6 +595,22 @@ interface FileOpRecord {
  * delivered projection is by definition available); kept for wire compatibility with the snapshot shape.
  */
 type ContextTimeline = Snapshot;
+/**
+ * One painted span of the timing card's session-time strip (the card's bottom
+ * band): a completed step's time slice — the TTFT wait, one decode block (in
+ * stream order), one tool-run window, or an in-step residue gap — folded
+ * host-side at `step/end`. The instants are the slice's REAL occurrence times
+ * (the hover tip reads them); the strip packs the spans gapless in log order,
+ * each band's width its share of the session's cumulative active time (idle
+ * time BETWEEN steps carries no span and takes no track). `end` > `start`
+ * always (the fold drops zero/negative slices).
+ */
+interface TimingSpan {
+  /** The slice kind — the timing card's own slice vocabulary (same keys, same colors). */
+  kind: 'ttft' | 'reasoning' | 'text' | 'toolarg' | 'tools' | 'other';
+  start: number;
+  end: number;
+}
 /**
  * Cumulative billed-token totals for one pricing bucket of the session-cost
  * estimate (host-folded, never trimmed — running totals over the COMPLETE

package/lib/index.js

@@ -414,6 +414,43 @@ function decodeTallyOfStream(stream, endTime) {
 	return tally;
 }
 /**
+* The ORDERED decode spans of one embedded assistant stream — the same
+* ownership rule as {@link decodeTallyOfStream} (each `block-start` marker
+* owns the interval up to the next one, the last one up to `endTime`), but
+* keeping the sequence: the timing strip paints the decode window in stream
+* order. Total over untrusted input, mirroring the tally: a malformed record
+* is skipped whole, an unknown `blockType` leaves its interval unspanned
+* (the caller's residue fill owns it), a zero/negative-length span drops
+* out, and a stream with no marker (or not an array) yields none.
+*/
+function decodeSpansOfStream(stream, endTime) {
+	const spans = [];
+	if (!Array.isArray(stream) || !Number.isFinite(endTime)) return spans;
+	let kind;
+	let since = 0;
+	const close = (to) => {
+		if (kind !== void 0 && to > since) spans.push({
+			kind,
+			start: since,
+			end: to
+		});
+	};
+	for (const record of stream) {
+		if (record === null || typeof record !== "object") continue;
+		const r = record;
+		if (r.type !== "chunk" || r.chunk === null || typeof r.chunk !== "object") continue;
+		const chunk = r.chunk;
+		if (chunk.type !== "block-start") continue;
+		const time = r.time;
+		if (typeof time !== "number" || !Number.isFinite(time)) continue;
+		close(time);
+		kind = decodeKindOfBlock(chunk.blockType);
+		since = time;
+	}
+	close(endTime);
+	return spans;
+}
+/**
 * 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 —
@@ -758,6 +795,7 @@ function trimState(st, bounds) {
 		st.turnRuns = countTurnRuns(st.requests);
 	}
 	if (st.events.length > bounds.maxEvents) st.events = st.events.slice(-bounds.maxEvents);
+	if (st.spans.length > TIMING_SPANS_MAX) st.spans = st.spans.slice(-TIMING_SPANS_MAX);
 	if (st.fileOps.length > bounds.maxFileOps) {
 		const drop = st.fileOps.length - bounds.maxFileOps;
 		st.fileOpsFloor = Math.max(st.fileOpsFloor ?? 0, st.fileOps[drop - 1].seq);
@@ -775,6 +813,13 @@ function trimState(st, bounds) {
 		}
 	}
 }
+/**
+* Bound on the timing strip's painted spans (TimelineState.spans): a count
+* cap, newest tail kept — the same hardcoded-cap family as SYSTEM_NODES_MAX.
+* At ~6–8 spans per step the cap covers a few hundred recent steps, far past
+* the strip's pixel resolution on any real pane.
+*/
+const TIMING_SPANS_MAX = 2e3;
 function createTimelineState() {
 	return {
 		surface: [],
@@ -792,7 +837,8 @@ function createTimelineState() {
 		events: [],
 		archived: [],
 		callNames: {},
-		fileOps: []
+		fileOps: [],
+		spans: []
 	};
 }
 function categoryOf(type, message) {
@@ -969,6 +1015,11 @@ function applySurface(st, ev, type, data, message) {
 			timing.toolsMs += dur;
 			timing.toolCalls += 1;
 			bumpToolTotals(timing, toolEntry.name, dur);
+			if (st.stepStart !== void 0) st.stepSpans = [...st.stepSpans ?? [], {
+				kind: "tools",
+				start: toolEntry.start,
+				end: ev.time
+			}];
 		}
 		if (typeof srcId === "string" || typeof blockId === "string") {
 			const kept = {};
@@ -1345,6 +1396,7 @@ function applyTimeline(state, event, bounds) {
 			case "step/start": {
 				const s = ensure([]);
 				s.stepStart = { time: event.time };
+				delete s.stepSpans;
 				break;
 			}
 			case "step/end": {
@@ -1352,7 +1404,43 @@ function applyTimeline(state, event, bounds) {
 				if (start === void 0) return state;
 				const s = ensure(["timing"]);
 				ensureTiming(s).wallMs += durOf(start.time, event.time);
+				const painted = [];
+				for (const span of state.stepSpans ?? []) {
+					const from = Math.max(start.time, span.start);
+					const to = Math.min(event.time, span.end);
+					if (to > from) painted.push({
+						kind: span.kind,
+						start: from,
+						end: to
+					});
+				}
+				painted.sort((a, b) => a.start - b.start || a.end - b.end);
+				const flushed = [];
+				let cursor = start.time;
+				for (const span of painted) {
+					const from = Math.max(cursor, span.start);
+					if (span.end <= from) continue;
+					if (from > cursor) flushed.push({
+						kind: "other",
+						start: cursor,
+						end: from
+					});
+					flushed.push({
+						kind: span.kind,
+						start: from,
+						end: span.end
+					});
+					cursor = span.end;
+				}
+				if (event.time > cursor) flushed.push({
+					kind: "other",
+					start: cursor,
+					end: event.time
+				});
+				s.spans = [...state.spans, ...flushed];
 				delete s.stepStart;
+				delete s.stepSpans;
+				bumpDetailRev(s);
 				break;
 			}
 			case "user/message": {
@@ -1506,6 +1594,24 @@ function applyTimeline(state, event, bounds) {
 					if (firstToken !== void 0) {
 						timing.ttftMs += durOf(stepStart.time, firstToken);
 						timing.genMs += durOf(firstToken, event.time);
+						const decodeBlocks = decodeSpansOfStream(data?.stream, event.time);
+						let decodeStart = firstToken;
+						for (const block of decodeBlocks) decodeStart = Math.min(decodeStart, block.start);
+						const modelSpans = [{
+							kind: "ttft",
+							start: stepStart.time,
+							end: decodeStart
+						}];
+						for (const block of decodeBlocks) {
+							const to = Math.min(event.time, block.end);
+							if (to <= block.start) continue;
+							modelSpans.push({
+								kind: block.kind,
+								start: modelSpans.length === 1 ? decodeStart : block.start,
+								end: to
+							});
+						}
+						s.stepSpans = [...s.stepSpans ?? [], ...modelSpans];
 						if (output !== null) {
 							timing.speedMs = (timing.speedMs ?? 0) + durOf(firstToken, event.time);
 							timing.speedTokens = (timing.speedTokens ?? 0) + output;
@@ -1641,7 +1747,8 @@ function detailCollectionsOf(state, bounds) {
 		droppedNodes: 0,
 		archive: state.archived.map((n) => ({ ...n })),
 		fileOps: state.fileOps.map((o) => ({ ...o })),
-		...state.fileOpsFloor !== void 0 ? { fileOpsFloor: state.fileOpsFloor } : {}
+		...state.fileOpsFloor !== void 0 ? { fileOpsFloor: state.fileOpsFloor } : {},
+		spans: state.spans.map((s) => ({ ...s }))
 	};
 	const overflowCount = Math.max(0, state.surface.length - bounds.maxNodes);
 	const overflow = state.surface.slice(0, overflowCount);
@@ -3103,6 +3210,19 @@ const fileOpSchema = z.object({
 	pattern: z.literal(true).optional(),
 	gone: z.number().int().nonnegative().optional()
 }).strict();
+/** One painted span of the timing strip (shared/types.ts TimingSpan). */
+const timingSpanSchema = z.object({
+	kind: z.enum([
+		"ttft",
+		"reasoning",
+		"text",
+		"toolarg",
+		"tools",
+		"other"
+	]),
+	start: z.number(),
+	end: z.number()
+}).strict();
 const currentSchema = z.object({
 	system: z.number().int().nonnegative(),
 	tools: z.number().int().nonnegative(),
@@ -3198,7 +3318,8 @@ const contextTimelineSchema = z.object({
 	surfaceFloor: z.number().int().nonnegative().optional(),
 	archiveFloor: z.number().int().nonnegative().optional(),
 	fileOps: z.array(fileOpSchema).optional(),
-	fileOpsFloor: z.number().int().nonnegative().optional()
+	fileOpsFloor: z.number().int().nonnegative().optional(),
+	spans: z.array(timingSpanSchema).optional()
 }).strict();
 /**
 * The persisted fold-state schema (the registry's `stateSchema`
@@ -3245,6 +3366,8 @@ const timelineStateSchema = z.object({
 	detailRev: z.number().int().nonnegative().optional(),
 	fileOps: z.array(fileOpSchema),
 	fileOpsFloor: z.number().int().nonnegative().optional(),
+	spans: z.array(timingSpanSchema),
+	stepSpans: z.array(timingSpanSchema).optional(),
 	pendingCodeOps: z.record(z.string(), z.array(fileOpSchema)).optional()
 });
 /**
@@ -3292,7 +3415,7 @@ function createContextTimelineDefinition(config, slim) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 22
+		stateVersion: 23
 	};
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.60.0",
+  "version": "0.62.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",
@@ -69,7 +69,8 @@
     "compatibility": {
       "dshReleases": {
         "0.1.5-rc.1": "compatible",
-        "0.1.7-rc.2": "compatible"
+        "0.1.7-rc.2": "compatible",
+        "0.2.0-rc.2": "compatible"
       }
     }
   },