dsh-context 0.46.1 → 0.48.0

package/lib/index.d.ts

@@ -56,6 +56,15 @@ 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';
+//#endregion
 //#region src/host/fold.d.ts
 /**
  * History retention bounds (configurable since 0.11 — see config.ts; these
@@ -72,6 +81,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
@@ -132,10 +162,21 @@ interface TimelineState {
    * one those events close — a hostile interleaved log degrades to skipped
    * durations, never to unbounded state. Same arm/remove lifecycle as
    * `pendingShadowedSeqs`.
+   *
+   * `decode` and `block` carry the generation split (reasoning / answer text /
+   * tool arguments — see TimingTotals): a V0 log's `assistant/chunk`
+   * `block-start` markers open `block` and close the previous one into
+   * `decode`; a V2+ log carries no such events, so `decode` stays absent and
+   * `assistant/message` reads the spans off its embedded stream instead.
    */
   stepStart?: {
     time: number;
     firstToken?: number;
+    decode?: Record<DecodeKind, number>;
+    block?: {
+      kind: DecodeKind;
+      since: number;
+    };
   };
   /**
    * Tool callId → the call's name, start instant, and raw arguments, armed by
@@ -221,6 +262,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 +370,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,14 +511,30 @@ 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
  * of per-call tool durations (parallel calls each count, so it can overlap).
  * Absent until the first step lifecycle completes in the log.
+ *
+ * The generation window itself splits by WHAT was being decoded, off the
+ * stream's `block-start` framing (`blockType`): `reasoningMs` (the model's
+ * thinking), `textMs` (the answer text), and `toolArgMs` (the tool-call
+ * arguments). Each marker owns the interval up to the next one (the last one
+ * up to the assistant message), so the three tile the marker span and together
+ * account for essentially all of `genMs` — the span opens at the first marker,
+ * which can sit marginally before the first token, so it is not an exact
+ * partition. They are ADDITIVE-OPTIONAL: cached projection rows written before
+ * the split carry `genMs` without them, so the card falls back to the
+ * un-split shape instead of the cache row being discarded (the
+ * stateVersion-15 rationale in host/timeline.ts).
  */
 interface TimingTotals {
   /** Summed wall time of completed steps (the session's active time). */
@@ -466,6 +543,12 @@ interface TimingTotals {
   ttftMs: number;
   /** Summed first-token → assistant-message time (the generation). */
   genMs: number;
+  /** Reasoning-decode slice of `genMs` (the model's thinking). */
+  reasoningMs?: number;
+  /** Answer-text decode slice of `genMs`. */
+  textMs?: number;
+  /** Tool-call-argument decode slice of `genMs`. */
+  toolArgMs?: number;
   /** Completed model calls (assistant messages folded). */
   calls: number;
   /** Summed per-call durations of completed tool calls. */
@@ -485,7 +568,7 @@ interface CostFamilyUsage {
  * token totals per DeepSeek V4 model family (matched on the model NAME,
  * provider-agnostic) and pricing period. The Client prices these with its
  * hardcoded list-price table in the locale's currency. Absent until a
- * deepseek-v4-flash / deepseek-v4-pro request reports usage.
+ * deepseek-v4.1-flash / deepseek-v4-pro request reports usage.
  */
 interface SessionCostUsage {
   flash?: CostFamilyUsage;

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,150 @@ 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.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).
+*
+* @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;
+	}
+}
+/** Map one `blockType` to its timing bucket (see {@link DecodeKind}). */
+function decodeKindOfBlock(blockType) {
+	if (blockType === "reasoning") return "reasoning";
+	if (blockType === "text") return "text";
+	if (blockType === "tool-call") return "toolarg";
+}
+/**
+* Per-kind decode spans 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, a non-finite boundary yields zero, and a stream
+* with no marker (or not an array) yields all zeros.
+*/
+function decodeSpansOfStream(stream, endTime) {
+	const spans = {
+		reasoning: 0,
+		text: 0,
+		toolarg: 0
+	};
+	if (!Array.isArray(stream) || !Number.isFinite(endTime)) return spans;
+	let kind;
+	let since = 0;
+	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;
+		if (kind !== void 0) spans[kind] += Math.max(0, time - since);
+		kind = decodeKindOfBlock(chunk.blockType);
+		since = time;
+	}
+	if (kind !== void 0) spans[kind] += Math.max(0, endTime - since);
+	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 —
+* 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 +1041,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 +1105,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 +1217,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) {
@@ -1069,7 +1276,7 @@ function tokenCountOf(value) {
 /**
 * The DeepSeek V4 model family a model name prices as — matched on the NAME
 * alone (provider-agnostic: official API, proxies, OpenRouter spellings like
-* `deepseek/deepseek-v4-flash` all land here). Null for any other model:
+* `deepseek/deepseek-v4.1-flash` all land here). Null for any other model:
 * non-V4 usage is simply not priced.
 */
 function costFamilyOf(model) {
@@ -1132,27 +1339,18 @@ function accumulateCost(st, time, usage) {
 */
 /** The timing card's per-tool ranking cap: the busiest 16 names are kept. */
 const TOOL_TIMING_CAP = 16;
+/** The decode buckets of the generation split, in card order (see TimingTotals). */
+const DECODE_KINDS = [
+	"reasoning",
+	"text",
+	"toolarg"
+];
 /** 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);
 }
 /**
-* 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.
@@ -1170,6 +1368,18 @@ function ensureTiming(st) {
 	return st.timing;
 }
 /**
+* Fold one block's decode span into the totals' generation split (see
+* TimingTotals). A zero span stays ABSENT — the field then carries the
+* "no time was decoded in this bucket" fact without adding dead properties to
+* every pre-split-shaped state, and the card reads absence as 0.
+*/
+function addDecode(timing, kind, ms) {
+	if (!(ms > 0)) return;
+	if (kind === "reasoning") timing.reasoningMs = (timing.reasoningMs ?? 0) + ms;
+	else if (kind === "text") timing.textMs = (timing.textMs ?? 0) + ms;
+	else timing.toolArgMs = (timing.toolArgMs ?? 0) + ms;
+}
+/**
 * 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
@@ -1225,7 +1435,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 +1464,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 +1501,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") {
@@ -1275,13 +1518,48 @@ 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);
+					s.stepStart = {
+						time: start.time,
+						...start.firstToken !== void 0 ? { firstToken: start.firstToken } : {},
+						decode,
+						...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;
-				if (!isTokenDelta(data?.chunk)) return state;
+				const first = firstTokenTimeOfStream(data?.stream);
+				if (first === void 0) return state;
 				const s = ensure();
 				s.stepStart = {
 					time: start.time,
-					firstToken: event.time
+					firstToken: first
 				};
 				break;
 			}
@@ -1410,9 +1688,20 @@ 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);
+						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]);
+						} else {
+							const spans = decodeSpansOfStream(data?.stream, event.time);
+							for (const kind of DECODE_KINDS) addDecode(timing, kind, spans[kind]);
+						}
+					}
 				}
 				const asstMsg = deriveEventMessage(event);
 				applySurface(s, event, event.type, data, asstMsg);
@@ -1514,6 +1803,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 +2241,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(),
@@ -2046,6 +2342,9 @@ const timingTotalsSchema = z.object({
 	wallMs: z.number().nonnegative(),
 	ttftMs: z.number().nonnegative(),
 	genMs: z.number().nonnegative(),
+	reasoningMs: z.number().nonnegative().optional(),
+	textMs: z.number().nonnegative().optional(),
+	toolArgMs: z.number().nonnegative().optional(),
 	calls: z.number().int().nonnegative(),
 	toolsMs: z.number().nonnegative(),
 	toolCalls: z.number().int().nonnegative(),
@@ -2097,6 +2396,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 +2420,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(),
@@ -2136,7 +2438,20 @@ const timelineStateSchema = z.object({
 	timing: timingTotalsSchema.optional(),
 	stepStart: z.object({
 		time: z.number(),
-		firstToken: z.number().optional()
+		firstToken: z.number().optional(),
+		decode: z.object({
+			reasoning: z.number(),
+			text: z.number(),
+			toolarg: z.number()
+		}).strict().optional(),
+		block: z.object({
+			kind: z.enum([
+				"reasoning",
+				"text",
+				"toolarg"
+			]),
+			since: z.number()
+		}).strict().optional()
 	}).strict().optional(),
 	callNames: z.record(z.string(), z.object({
 		name: z.string(),