dsh-context 0.52.1 → 0.52.2

package/lib/client.js

@@ -1905,10 +1905,10 @@ window.__ModuleLoader__.load({
 		* - INLINE (older hosts, channel-less deployments, the baseline-gate
 		*   fallback): the wire value carries the collections in place. It passes
 		*   through untouched — no fetch ever happens.
-		* - SPLIT (current host with the detail channel live): the wire value is the
+		* - SPLIT (current host with the detail route live): the wire value is the
 		*   slim head (~1KB — every session.list row, control baseline, and push
-		*   frame carries it whole). The collections arrive from the host's
-		*   `/dsh-context` `detail` endpoint (host/detail.ts): one targeted read
+		*   frame carries it whole). The collections arrive from the plugin's
+		*   `/api/dsh-context/detail` fetch route (host/detail.ts): one targeted read
 		*   when the tab/modal first opens, then a debounced refetch whenever the
 		*   pushed `detailRev` outruns the served detail. Closed tabs fetch nothing.
 		*
@@ -1923,8 +1923,7 @@ window.__ModuleLoader__.load({
 		* failure surfaces as a retryable note on the detail cards instead of an
 		* empty chart.
 		*/
-		const DETAIL_CHANNEL = "/dsh-context";
-		const DETAIL_ENDPOINT = "detail";
+		const DETAIL_ROUTE = "/api/dsh-context/detail";
 		/**
 		* Narrow the detail endpoint's payload to a render-safe value (the same
 		* boundary rigor as `timelineOf`): collections re-proved per item, scalars
@@ -1935,8 +1934,10 @@ window.__ModuleLoader__.load({
 			const data = asRecord(value);
 			if (data === null) return null;
 			if (typeof data.rev !== "number" || !Number.isFinite(data.rev) || data.rev < 0) return null;
+			const head = timelineOf(data.head);
 			return {
 				rev: data.rev,
+				...head !== null ? { head } : {},
 				requests: objectsOf(data.requests),
 				events: objectsOf(data.events),
 				nodes: objectsOf(data.nodes),
@@ -1949,24 +1950,26 @@ window.__ModuleLoader__.load({
 			};
 		}
 		/**
-		* The detail reader over the harness's generic Connection RPC
-		* (`ctx.connection.rpc.call`) — resolved through the shared `rpcCallOf`
-		* reflect read (the same seam openPathVia/canOpenPathsOf use), so a hostile
-		* or absent connection service degrades to `undefined` instead of throwing.
-		* The returned thunk resolves the session's current detail, `null` when the
-		* session is not live anymore, and rejects on transport failure or a
-		* malformed payload (the store turns the two into the retryable state).
+		* The detail reader over the plugin's own `/api` fetch route (host/detail.ts).
+		* Same-origin POST through the harness's authenticated fence; the returned
+		* thunk resolves the session's current detail, `null` when the session is not
+		* live anymore, and rejects on transport failure or a malformed payload (the
+		* store turns the two into the retryable state).
 		*/
 		function makeDetailFetcher(ctx, sessionId) {
 			if (sessionId === "") return void 0;
-			const call = rpcCallOf(ctx);
-			if (call === void 0) return void 0;
 			return async () => {
-				const r = asRecord(await call(DETAIL_CHANNEL, DETAIL_ENDPOINT, { sessionId }));
-				if (r === null || r.ok !== true) throw new Error("dsh-context: detail rpc failed");
+				const response = await fetch(DETAIL_ROUTE, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({ sessionId })
+				});
+				if (!response.ok) throw new Error(`dsh-context: detail route HTTP ${response.status}`);
+				const r = asRecord(await response.json());
+				if (r === null || r.ok !== true) throw new Error("dsh-context: detail read failed");
 				if (r.value === null) return null;
 				const detail = detailOf(r.value);
-				if (detail === null) throw new Error("dsh-context: detail rpc malformed");
+				if (detail === null) throw new Error("dsh-context: detail read malformed");
 				return detail;
 			};
 		}
@@ -6371,8 +6374,15 @@ window.__ModuleLoader__.load({
 		* no current session, or a snapshot without a `byId` table (older harness).
 		* The current session synthesizes a row when the list has not delivered it
 		* yet, so the card can still show its live self stats.
-		*/
-		function agentForestOf(snapshot, currentId, self) {
+		* @param fetched - detail-channel heads for COLD rows, keyed by session id.
+		*   The host's list block serves projection values only from the projection
+		*   cache, so a relative that never attached since the timeline unit last
+		*   changed lists pressure-only (no composition row) and its ring would
+		*   degrade to the occupancy arc; the card fetches those heads on demand.
+		*   A row's own value always wins — the injection lands only on rows whose
+		*   `contextTimeline` is absent.
+		*/
+		function agentForestOf(snapshot, currentId, self, fetched) {
 			const byId = asRecord(asRecord(snapshot)?.byId);
 			if (byId === null || currentId === void 0 || currentId === "") return null;
 			const rows = /* @__PURE__ */ new Map();
@@ -6427,7 +6437,12 @@ window.__ModuleLoader__.load({
 			const visit = (id, row, parentId, depth, seen, family) => {
 				if (seen.has(id) || nodes.length >= 25) return;
 				seen.add(id);
-				const stats = agentStatsOf(row.projections);
+				const values = row.projections;
+				const fetchedHead = fetched !== void 0 ? fetched.get(id) : void 0;
+				const stats = agentStatsOf(fetchedHead !== void 0 && values?.contextTimeline === void 0 ? {
+					...values,
+					contextTimeline: fetchedHead
+				} : values);
 				const identity = stats.identity;
 				const node = {
 					...stats,
@@ -6686,9 +6701,13 @@ window.__ModuleLoader__.load({
 		*
 		* Data rides the harness's existing planes end to end — the session-list
 		* snapshot (`ctx.sessions.list`: lineage rows + per-session projection
-		* values) and the tab's own projections for the current node — so the card
-		* adds no RPC of its own beyond one direct-child catalog refresh per
-		* session. A harness without the outward sessions service hides the card.
+		* values) and the tab's own projections for the current node. The list block
+		* serves projection values only from the host's projection cache, so a
+		* relative that never attached since the timeline unit last changed lists
+		* pressure-only (occupancy without composition); those nodes fetch their slim
+		* head from the plugin's `/api` detail route (the one call below) and
+		* re-render composed. A harness without the outward sessions service hides
+		* the card.
 		*/
 		/** Caption box height under a node (3 wrapped label lines + the tokens line). */
 		const CAPTION_H = 60;
@@ -6701,6 +6720,7 @@ window.__ModuleLoader__.load({
 		}
 		function makeAgentGraph(ctx, kit) {
 			const { t, fmt, catLabel } = kit;
+			const heads = /* @__PURE__ */ new Map();
 			function AgentGraph(props) {
 				const face = (0, react.useMemo)(() => sessionsFaceOf(ctx), []);
 				const subscribe = (0, react.useCallback)((fn) => {
@@ -6746,8 +6766,9 @@ window.__ModuleLoader__.load({
 					if (typeof face.refreshSubagents !== "function") return;
 					face.refreshSubagents(sessionId).catch(() => {});
 				}, [face, sessionId]);
+				const [landed, setLanded] = (0, react.useState)(/* @__PURE__ */ new Map());
 				const built = (0, react.useMemo)(() => {
-					const forest = agentForestOf(snapshot, sessionId, props.self);
+					const forest = agentForestOf(snapshot, sessionId, props.self, landed);
 					return forest !== null ? {
 						forest,
 						layout: layoutForest(forest, stageWidth)
@@ -6756,8 +6777,29 @@ window.__ModuleLoader__.load({
 					snapshot,
 					sessionId,
 					props.self,
-					stageWidth
+					stageWidth,
+					landed
 				]);
+				(0, react.useEffect)(() => {
+					if (built === null) return;
+					const attach = (pending, id) => {
+						pending.then((head) => {
+							if (head !== null) setLanded((prev) => prev.get(id) === head ? prev : new Map(prev).set(id, head));
+						}).catch(() => {});
+					};
+					for (const n of built.forest.nodes) {
+						if (n.isCurrent || n.head !== null && n.head.parts.length > 0) continue;
+						const cached = heads.get(n.id);
+						if (cached !== void 0) {
+							attach(cached, n.id);
+							continue;
+						}
+						const fetcher = makeDetailFetcher(ctx, n.id);
+						const pending = fetcher !== void 0 ? fetcher().then((d) => d?.head ?? null) : Promise.resolve(null);
+						heads.set(n.id, pending);
+						attach(pending, n.id);
+					}
+				}, [built]);
 				if (built === null) return null;
 				const { forest, layout } = built;
 				const byId = new Map(forest.nodes.map((n) => [n.id, n]));
@@ -7599,7 +7641,7 @@ window.__ModuleLoader__.load({
 			return function PluginInfo() {
 				const [latest, setLatest] = (0, react.useState)(null);
 				(0, react.useEffect)(() => {
-					if ("0.52.1".includes("-dev")) return;
+					if ("0.52.2".includes("-dev")) return;
 					let on = true;
 					fetchLatestVersion().then((v) => {
 						if (on && v) setLatest(v);
@@ -7608,8 +7650,8 @@ window.__ModuleLoader__.load({
 						on = false;
 					};
 				}, []);
-				const update = latest !== null && isNewerVersion(latest, "0.52.1") ? latest : null;
-				const nameText = "dsh-context (v0.52.1)";
+				const update = latest !== null && isNewerVersion(latest, "0.52.2") ? latest : null;
+				const nameText = "dsh-context (v0.52.2)";
 				const nameValue = [nameText];
 				if (update) nameValue.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 					className: "lc-pi-update",

package/lib/index.d.ts

@@ -446,6 +446,17 @@ interface Snapshot {
  */
 interface ContextTimelineDetail {
   rev: number;
+  /**
+   * The slim wire head at the SAME fold cut as the collections: the
+   * composition scalars (`current`), the window/model envelope, and the
+   * precomputed counts. Sessions listed cold (never attached since the
+   * requesting unit last changed) carry no `contextTimeline` projection row
+   * for the browser's list reads, so the Agent network card fetches this
+   * head per node to render their composition rings. The host always serves
+   * it; optional so a payload missing it still serves the collections (the
+   * detail cards) and only the ring composition degrades.
+   */
+  head?: ContextTimeline;
   requests: RequestRecord[];
   events: ContextEventRecord[];
   nodes: SurfaceNode[];

package/lib/index.js

@@ -1933,11 +1933,14 @@ function buildTimelineHead(state) {
 }
 /**
 * The on-demand detail payload (host/detail.ts serves it off the live fold
-* state): the heavy collections plus the revision marker the head carries.
+* state): the heavy collections, the slim head at the SAME cut (the Agent
+* network's cold-node ring fetch renders composition off it), and the
+* revision marker the head carries.
 */
 function buildTimelineDetail(state, bounds) {
 	return {
 		rev: state.detailRev ?? 0,
+		head: buildTimelineHead(state),
 		...detailCollectionsOf(state, bounds)
 	};
 }
@@ -1956,63 +1959,71 @@ function buildTimelineView(state, bounds) {
 }
 //#endregion
 //#region src/host/detail.ts
-/** The plugin's generic Connection RPC channel (the pre-v0.9 name, kept). */
-const DETAIL_CHANNEL = "/dsh-context";
-/** The RPC failure envelope the transport expects (ConnectionRpcFailure). */
+/** The plugin's detail route, under the authenticated `/api` fence. */
+const DETAIL_ROUTE = "/api/dsh-context/detail";
+/** One JSON reply of the detail route. */
+function reply(value) {
+	return Response.json(value, { headers: { "cache-control": "no-store" } });
+}
+/** The typed failure envelope (the same shape the Connection RPC carried). */
 function failure(code, message) {
-	return {
+	return reply({
 		ok: false,
 		error: {
 			code,
-			message,
-			details: {}
+			message
 		}
-	};
+	});
 }
 /**
-* Arm the detail endpoint whenever the connection and sessions services are
+* Serve the detail route whenever the connection and sessions services are
 * both composed (see the module header for the load-order contract). The
 * registration rides the injected fiber: either service unloading withdraws
-* the channel and closes the gate.
+* the route and closes the gate.
 */
 function watchDetailChannel(ctx, bounds) {
 	const gate = { live: false };
 	ctx.inject(["connection", "sessions"], (c) => {
 		const connection = c.get("connection");
 		const sessions = c.get("sessions");
-		const handle = typeof connection?.rpc?.handle === "function" ? connection.rpc.handle.bind(connection.rpc) : void 0;
+		const register = typeof connection?.fetch?.register === "function" ? connection.fetch.register.bind(connection.fetch) : void 0;
 		const getSession = typeof sessions?.get === "function" ? sessions.get.bind(sessions) : void 0;
-		if (handle === void 0 || getSession === void 0) return;
+		if (register === void 0 || getSession === void 0) return;
 		const projections = ctx.sessionProjections;
-		const handler = async (endpoint, payload) => {
-			if (endpoint !== "detail") return failure("dsh-context/unknown-endpoint", `unknown endpoint: ${endpoint}`);
-			const sessionId = payload !== null && typeof payload === "object" ? payload.sessionId : void 0;
+		const handler = async (request) => {
+			let sessionId;
+			try {
+				const body = await request.json();
+				sessionId = body !== null && typeof body === "object" ? body.sessionId : void 0;
+			} catch {
+				return failure("dsh-context/bad-request", "body is not JSON");
+			}
 			if (typeof sessionId !== "string" || sessionId === "") return failure("dsh-context/bad-request", "missing sessionId");
 			try {
 				const session = getSession(sessionId);
 				if (session !== void 0 && session !== null) {
 					const state = projections.stateOf(session, "contextTimeline");
-					if (state === void 0) return {
+					if (state === void 0) return reply({
 						ok: true,
 						value: null
-					};
-					return {
+					});
+					return reply({
 						ok: true,
 						value: buildTimelineDetail(state, bounds)
-					};
+					});
 				}
 				const query = ctx.get("sessionQuery");
 				const observe = typeof query?.observeSession === "function" ? query.observeSession.bind(query) : void 0;
-				if (observe === void 0) return {
+				if (observe === void 0) return reply({
 					ok: true,
 					value: null
-				};
+				});
 				const observation = await observe(sessionId, { projectionMode: "none" });
 				const events = observation?.events;
-				if (!Array.isArray(events)) return {
+				if (!Array.isArray(events)) return reply({
 					ok: true,
 					value: null
-				};
+				});
 				let state = createTimelineState();
 				try {
 					for (const ev of events) state = applyTimeline(state, ev, bounds);
@@ -2020,21 +2031,21 @@ function watchDetailChannel(ctx, bounds) {
 					const dispose = observation?.[Symbol.dispose];
 					if (typeof dispose === "function") dispose.call(observation);
 				}
-				return {
+				return reply({
 					ok: true,
 					value: buildTimelineDetail(state, bounds)
-				};
+				});
 			} catch (err) {
 				return failure("gateway/internal", err instanceof Error ? err.message : String(err));
 			}
 		};
 		try {
-			c.effect(() => {
-				const unregister = handle(DETAIL_CHANNEL, handler);
-				return () => {
-					unregister();
-				};
-			}, "dsh-context: detail channel");
+			c.effect(() => register({
+				path: DETAIL_ROUTE,
+				methods: ["POST"],
+				requestBody: "buffered",
+				fetch: handler
+			}), "dsh-context: detail route");
 		} catch {
 			return;
 		}

package/package.json

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