dsh-context 0.62.1 → 0.62.3

package/lib/client.js

@@ -11404,7 +11404,7 @@ window.__ModuleLoader__.load({
 			return function PluginInfo() {
 				const [latest, setLatest] = (0, react.useState)(null);
 				(0, react.useEffect)(() => {
-					if ("0.62.1".includes("-dev")) return;
+					if ("0.62.3".includes("-dev")) return;
 					let on = true;
 					fetchLatestVersion().then((v) => {
 						if (on && v) setLatest(v);
@@ -11413,8 +11413,8 @@ window.__ModuleLoader__.load({
 						on = false;
 					};
 				}, []);
-				const update = latest !== null && isNewerVersion(latest, "0.62.1") ? latest : null;
-				const nameText = "dsh-context (v0.62.1)";
+				const update = latest !== null && isNewerVersion(latest, "0.62.3") ? latest : null;
+				const nameText = "dsh-context (v0.62.3)";
 				const nameValue = [nameText];
 				if (update) nameValue.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 					className: "lc-pi-update",

package/lib/index.d.ts

@@ -638,20 +638,26 @@ interface ToolTimingTotals {
  * own embedded stream (`assistant/message.data.stream` /
  * `assistant/attempt.data.stream`), 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) —
+ * whole steps, `ttftMs` the step-start → decode-start slice (the model wait)
+ * and `genMs` the decode-start → 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 decode window opens at the first OBSERVABLE instant — the first token,
+ * or an earlier `block-start` marker the token packing could not stamp (a
+ * redacted reasoning block leaves no chunk behind): anchoring at the token
+ * would charge the marker-tiled window to the wait as well, double-counting
+ * it past 100% in the legend. 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
+ * up to the assistant message), so the three tile the marker span — exactly
+ * `genMs` when the first marker leads the first token (the window opens
+ * there); when the first marker sits marginally PAST the token the lead-in
+ * gap stays inside `genMs` unattributed, so the buckets never exceed it.
+ * 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).
@@ -659,9 +665,9 @@ interface ToolTimingTotals {
 interface TimingTotals {
   /** Summed wall time of completed steps (the session's active time). */
   wallMs: number;
-  /** Summed step-start → first-token time (the model wait, TTFT). */
+  /** Summed step-start → decode-start time (the model wait, TTFT). */
   ttftMs: number;
-  /** Summed first-token → assistant-message time (the generation). */
+  /** Summed decode-start → assistant-message time (the generation). */
   genMs: number;
   /** Reasoning-decode slice of `genMs` (the model's thinking). */
   reasoningMs?: number;
@@ -687,7 +693,9 @@ interface TimingTotals {
    * output tokens and `speedMs` the first-token → assistant-message
    * windows, over the calls that carried BOTH a first-token stamp and a
    * usage report — a subset of `genMs`, which counts every token-stamped
-   * call regardless of usage. Additive-optional: cached rows written before
+   * call regardless of usage. `speedMs` KEEPS the first-token anchor (not
+   * the marker-aware decode start): it is the harness-parity figure.
+   * Additive-optional: cached rows written before
    * the seat existed lack them, and the card falls back to no chip.
    */
   speedTokens?: number;

package/lib/index.js

@@ -1592,11 +1592,11 @@ function applyTimeline(state, event, bounds) {
 				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 decodeBlocks = decodeSpansOfStream(data?.stream, event.time);
 						let decodeStart = firstToken;
 						for (const block of decodeBlocks) decodeStart = Math.min(decodeStart, block.start);
+						timing.ttftMs += durOf(stepStart.time, decodeStart);
+						timing.genMs += durOf(decodeStart, event.time);
 						const modelSpans = [{
 							kind: "ttft",
 							start: stepStart.time,
@@ -2155,12 +2155,15 @@ const FIRST_PARTY_SOURCES = Object.freeze({
 * first argument, so `reader.fiber.name` identifies the plugin that is about
 * to call `register()`.
 *
-* - The `internal/get` handler records who last read the `tools` service and
-*   wraps that instance's `register` (once — an earlier wrapper of a previous
-*   hook incarnation is peeled back to the original, so a plugin reload
-*   re-wraps without stacking) to capture the reader at registration time
-*   into a live map. Every wrapper is undone when the plugin unloads: the
-*   original `register` goes back on the instance, unless a newer hook
+* - The `internal/get` handler records the reading fiber's NAME — a scalar,
+*   never the reader context, which would pin the caller's whole agent — and
+*   wraps the tools service's `register` (once per underlying instance —
+*   cordis hands out a fresh traced proxy per read of a tracked service, so
+*   the proxy is peeled to the stable instance first; an earlier wrapper of a
+*   previous hook incarnation is peeled back to the original, so a plugin
+*   reload re-wraps without stacking) to capture the reader at registration
+*   time into a live map. Every wrapper is undone when the plugin unloads:
+*   the original `register` goes back on the instance, unless a newer hook
 *   incarnation re-wrapped it first (that incarnation's own cleanup then
 *   owns the restore).
 * - When the reader slot is missing, root-named, or this plugin's own (e.g.
@@ -2221,6 +2224,20 @@ function packageNameFrom(file) {
 	}
 }
 const FRAME_POSITION = /:\d+:\d+$/;
+/** Symbol cordis registers (`Symbol.for`) on its traced proxies: reading it
+* yields the wrapped target — the stable underlying service instance. */
+const CORDIS_ORIGINAL = Symbol.for("cordis.original");
+/**
+* Peel cordis's per-read traced proxy of a tracked service (dsh's ToolRuntime
+* is one — every `ctx.tools` read returns a fresh proxy closing over the
+* reader's context) down to the instance it wraps, so identity-keyed
+* bookkeeping sees one stable object. Plain service objects pass through
+* unchanged.
+* @param tools - the value as handed out by a context read.
+*/
+function rawInstanceOf(tools) {
+	return tools?.[CORDIS_ORIGINAL] ?? tools;
+}
 /** Package name of this module's own package (self-fallbacks are filtered). */
 const selfPackage = packageNameFrom(selfUrl);
 /**
@@ -2279,7 +2296,7 @@ function createToolAttribution(ctx) {
 		const instance = tools;
 		const wrappedRegister = function(definition) {
 			const toolName = definition?.name;
-			let owner = lastReader?.fiber.name;
+			let owner = lastReader;
 			if (!owner || owner === "root" || owner === self) owner = callerPackageFrom((/* @__PURE__ */ new Error()).stack);
 			const dispose = original.call(this, definition);
 			if (typeof toolName === "string" && owner && owner !== "root" && owner !== self && owner !== selfPackage) {
@@ -2303,14 +2320,14 @@ function createToolAttribution(ctx) {
 	ctx.on("internal/get", (reader, name, _error, next) => {
 		if (name !== "tools") return next();
 		const tools = next();
-		lastReader = reader;
-		wrapInstance(tools);
+		lastReader = reader.fiber.name;
+		wrapInstance(rawInstanceOf(tools));
 		return tools;
 	});
 	ctx.effect(() => () => {
 		for (const restore of patched.splice(0)) restore();
 	}, "tools.register attribution");
-	const toolsService = ctx.get("tools", false);
+	const toolsService = rawInstanceOf(ctx.get("tools", false));
 	wrapInstance(toolsService);
 	const boot = /* @__PURE__ */ new Set();
 	try {
@@ -3415,7 +3432,7 @@ function createContextTimelineDefinition(config, slim) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 23
+		stateVersion: 24
 	};
 }
 //#endregion

package/package.json

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