dsh-context 0.52.2 → 0.53.1

package/lib/index.js

@@ -1,381 +1,94 @@
 import { createRequire } from "node:module";
+import { z } from "zod";
+import { SessionLogOffset, deriveEventMessage, interruptedTurnClosers } from "@deepseek-ai/dsh-session";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, normalize, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { z } from "zod";
-import { deriveEventMessage } from "@deepseek-ai/dsh-session";
 import z$1 from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
+//#region src/shared/providers.ts
 /**
-* Recover the MCP server display label from a proxied tool name, or undefined
-* for non-MCP names. `dsh-mcp-client` names tools `mcp__<server>__<rawName>`
-* (normalized, and hash-appended when overlong/invalid — the label then shows
-* whatever of the server survived the truncation). The separating `__` is the
-* LAST one in the name, and it must sit AFTER the `mcp__` prefix: the prefix's
-* own separator (or an empty server right after it) is not a server.
+* The provider-id seam between dsh request envelopes and the models.dev
+* registry: client/cost.ts resolves price-book branches through it, and
+* host/fold.ts uses the DeepSeek resolution to split the session-cost totals
+* into peak/off-peak periods. Only the renames live here — an id absent
+* from the table passes through verbatim.
 */
-function mcpServerOf(name) {
-	if (!name.startsWith("mcp__")) return void 0;
-	const cut = name.lastIndexOf("__");
-	if (cut < 5) return void 0;
-	const server = name.slice(5, cut);
-	return server.length > 0 ? server : void 0;
-}
-/** The `mcp:<server>` display label of a proxied tool name, or undefined. */
-function mcpSourceOf(name) {
-	const server = mcpServerOf(name);
-	return server !== void 0 ? `mcp:${server}` : void 0;
+const MODELS_DEV_PROVIDER_IDS = {
+	"deepseek-official": "deepseek",
+	"kimi-coding": "moonshotai",
+	"minimax-cn": "minimax",
+	"zai-coding-cn": "zhipuai"
+};
+/** The models.dev provider id that prices a dsh provider (identity for unmapped ids). */
+function modelsDevProviderOf(dshProviderId) {
+	return MODELS_DEV_PROVIDER_IDS[dshProviderId] ?? dshProviderId;
 }
-/** The pinned package of a first-party tool name, or undefined. */
-function pinnedSourceOf(name) {
-	return FIRST_PARTY_SOURCES[name];
+/** Whether a dsh provider prices through DeepSeek's period-based list (peak / half-price off-peak). */
+function isDeepSeekProvider(dshProviderId) {
+	return modelsDevProviderOf(dshProviderId) === "deepseek";
 }
-/**
-* Pinned first-party tool → plugin package map (see header comment). One entry
-* per model-facing name of the shipped tool packages in the official
-* tool-schema catalog of the supported dsh baseline; names are verified
-* stable across the supported harness range. Packages that mount under
-* distinct names per composition (bash/pwsh persistent variants, the
-* `subagent_fork` fixed-route alias) map to their primary package.
-*/
-const FIRST_PARTY_SOURCES = Object.freeze({
-	read: "@deepseek-ai/dsh-tool-fs",
-	write: "@deepseek-ai/dsh-tool-fs",
-	edit: "@deepseek-ai/dsh-tool-fs",
-	read_image: "@deepseek-ai/dsh-tool-fs",
-	glob: "@deepseek-ai/dsh-tool-fs-search",
-	grep: "@deepseek-ai/dsh-tool-fs-search",
-	str_replace_editor: "@deepseek-ai/dsh-tool-str-replace-editor",
-	bash: "@deepseek-ai/dsh-tool-bash",
-	pwsh: "@deepseek-ai/dsh-tool-pwsh",
-	web_search: "@deepseek-ai/dsh-tool-web",
-	web_fetch: "@deepseek-ai/dsh-tool-web",
-	job_output: "@deepseek-ai/dsh-tool-jobs",
-	job_list: "@deepseek-ai/dsh-tool-jobs",
-	job_kill: "@deepseek-ai/dsh-tool-jobs",
-	ask_user_question: "@deepseek-ai/dsh-tool-ask-user",
-	plan: "@deepseek-ai/dsh-plan-mode",
-	exit_plan_mode: "@deepseek-ai/dsh-plan-mode",
-	skill: "@deepseek-ai/dsh-tool-skill",
-	todo_write: "@deepseek-ai/dsh-tool-todo",
-	subagent: "@deepseek-ai/dsh-tool-subagent",
-	subagent_fork: "@deepseek-ai/dsh-tool-subagent",
-	send_message: "@deepseek-ai/dsh-tool-subagent-control",
-	interrupt_agent: "@deepseek-ai/dsh-tool-subagent-control",
-	list_agents: "@deepseek-ai/dsh-tool-subagent-control",
-	ralph: "@deepseek-ai/dsh-tool-ralph",
-	workflow: "@deepseek-ai/dsh-tool-workflow",
-	run_code: "@deepseek-ai/dsh-tools",
-	schedule_create: "@deepseek-ai/dsh-schedule",
-	schedule_list: "@deepseek-ai/dsh-schedule",
-	schedule_delete: "@deepseek-ai/dsh-schedule",
-	create_goal: "@deepseek-ai/dsh-tool-goal",
-	get_goal: "@deepseek-ai/dsh-tool-goal",
-	update_goal: "@deepseek-ai/dsh-tool-goal",
-	lsp: "@deepseek-ai/dsh-tool-lsp"
-});
 //#endregion
-//#region src/host/attribution.ts
-/**
-* Live tool→plugin attribution layered on the static recovery in
-* toolSources.ts.
-*
-* The session log records tools as plain `ToolSchema` entries (name /
-* description / parameters) — the registering plugin is not in there.
-* toolSources.ts derives the deterministic sources (harness-logged field,
-* `mcp:<server>` naming, pinned first-party map). This module additionally
-* watches RUNTIME registrations: cordis fires the `internal/get` waterfall on
-* every context read of a service property, passing the READING context as the
-* 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
-*   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.
-*   LOCAL-LINK plugins — dev installs via `dsh plugin add <path>` or
-*   npm/pnpm link — whose anonymous entrypoints make cordis fall back to the
-*   root name), the wrapped `register` falls back to the call stack: the first
-*   frame outside this package is resolved to its nearest `package.json`
-*   `name`. That covers both npm installs (`node_modules/<pkg>`) and local
-*   links (any directory carrying a package.json), which never pass through
-*   node_modules. Frames that resolve back to this package are skipped.
-* - `ownerOf(name)` prefers the name-derived `mcp:<server>` label (it names
-*   the actual provider, where the live record would only ever name the MCP
-*   proxy client), then the LIVE record — for a post-boot registration it is
-*   the truth, even when the name collides with a pinned first-party tool —
-*   then the pinned map (the boot-time guess for tools registered before the
-*   hook), and finally tags tools that were ALREADY registered when the hook
-*   installed (the boot snapshot — third-party bundles, e.g. local links like
-*   dsh-file-claim, that applied before dsh-context) with the
-*   `UNKNOWN_TOOL_SOURCE` sentinel: their registering plugin is unknowable,
-*   and a bare gap would read as "no plugin" instead of "unknown plugin".
-*
-* Best-effort by design: a read separated from `register()` by an `await` can
-* be overwritten by another plugin's read (misattribution) and the stack
-* fallback needs a resolvable package.json — both degrade to the name/pinned
-* chain; registrations that predate the hook degrade to the unknown tag. The
-* hook costs roughly +1.4us per service-property read and is negligible on
-* the rare register path (the stack walk only runs when the reader slot is
-* unusable, and its package lookups are cached per directory).
-*/
-/** This module's own file URL — the stack walk skips its own frames. */
-const selfUrl = normalize(fileURLToPath(import.meta.url));
-/** Directory → package-name cache for the synchronous walk below. */
-const packageCache = /* @__PURE__ */ new Map();
+//#region src/shared/estimate.ts
 /**
-* Best-effort package name for a module file: walk up to the nearest
-* `package.json` carrying a `name`. Works for dependencies installed under
-* `node_modules` as well as local links whose package root is any on-disk
-* directory. The per-directory results are cached.
-* @param file - absolute path of a module file.
+* Token heuristics shared by the host fold and the client boundary — the
+* harness token-meter's own fixed-density figure (dsh-token-meter/estimate.ts:
+* ~4 chars ≈ 1 token, +4 role framing). Priced identically on both sides so a
+* legacy value normalized at the client boundary matches what the host view
+* would have served.
 */
-function packageNameFrom(file) {
-	let dir = dirname(file);
-	for (let depth = 0; depth < 12; depth++) {
-		const cached = packageCache.get(dir);
-		if (cached !== void 0) return cached;
-		const packageFile = join(dir, "package.json");
-		if (existsSync(packageFile)) try {
-			const name = JSON.parse(readFileSync(packageFile, "utf8")).name;
-			if (typeof name === "string" && name) {
-				packageCache.set(dir, name);
-				return name;
-			}
-		} catch {}
-		const parent = dirname(dir);
-		packageCache.set(dir, void 0);
-		if (parent === dir) return void 0;
-		dir = parent;
-	}
+const CHARS_PER_TOKEN$1 = 4;
+const ROLE_OVERHEAD$1 = 4;
+/** Price rendered system-prompt text; 0 for absent/empty/non-string input. */
+function estimateSystemTokens(text) {
+	if (typeof text !== "string" || text.length === 0) return 0;
+	return Math.ceil(text.length / CHARS_PER_TOKEN$1) + ROLE_OVERHEAD$1;
 }
-const FRAME_POSITION = /:\d+:\d+$/;
-/** Package name of this module's own package (self-fallbacks are filtered). */
-const selfPackage = packageNameFrom(selfUrl);
 /**
-* Resolve the registering package from a stack trace: walk frames from the
-* innermost out, skipping this module's own frames and frames that resolve to
-* this package, and return the package name of the first frame that resolves
-* elsewhere. Works with both `file://` URLs and bare absolute paths
-* (transpiled modules render without a scheme), with optional `fn (...)` and
-* `async` wrappers.
-* @param stack - `Error().stack`, or undefined when no fallback is desired.
+* 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 callerPackageFrom(stack) {
-	if (!stack) return void 0;
-	for (const raw of stack.split("\n").slice(1)) {
-		let line = raw.trim();
-		if (!line.startsWith("at ")) continue;
-		line = line.slice(3);
-		if (line.startsWith("async ")) line = line.slice(6);
-		line = line.replace(/\)\s*$/, "");
-		const position = FRAME_POSITION.exec(line);
-		if (!position) continue;
-		let target = line.slice(0, -position[0].length);
-		if (target.includes("(")) target = target.slice(target.lastIndexOf("(") + 1);
-		if (target.startsWith("file://")) try {
-			target = normalize(fileURLToPath(target));
-		} catch {
+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;
 		}
-		else if (!/^[A-Za-z]:[\\/]/.test(target) && !target.startsWith("/") && !target.startsWith("\\\\")) continue;
-		else target = normalize(target);
-		if (target === selfUrl) continue;
-		const name = packageNameFrom(target);
-		if (name !== void 0 && name !== selfPackage) return name;
+		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
 /**
-* Install the runtime-attribution hook on a cordis app context. The hook
-* rides the calling fiber's lifetime (`ctx.on`, and an effect that restores
-* every patched `register`), so it is disposed with the plugin.
-* @param ctx - the context the dsh-context plugin runs in; its fiber name is
-* excluded from attributions.
-*/
-function createToolAttribution(ctx) {
-	const live = /* @__PURE__ */ new Map();
-	const wrapped = /* @__PURE__ */ new WeakSet();
-	const self = ctx.fiber.name;
-	let lastReader;
-	const patched = [];
-	const wrapInstance = (tools) => {
-		if (!tools || typeof tools !== "object" || wrapped.has(tools)) return;
-		const register = tools.register;
-		if (typeof register !== "function") return;
-		wrapped.add(tools);
-		const original = register.attributedOriginal ?? register;
-		if (typeof original !== "function") return;
-		const instance = tools;
-		const wrappedRegister = function(definition) {
-			const toolName = definition?.name;
-			let owner = lastReader?.fiber.name;
-			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) {
-				live.set(toolName, owner);
-				if (typeof dispose === "function") return () => {
-					try {
-						return dispose();
-					} finally {
-						live.delete(toolName);
-					}
-				};
-			}
-			return dispose;
-		};
-		wrappedRegister.attributedOriginal = original;
-		instance.register = wrappedRegister;
-		patched.push(() => {
-			if (instance.register === wrappedRegister) instance.register = original;
-		});
-	};
-	ctx.on("internal/get", (reader, name, _error, next) => {
-		if (name !== "tools") return next();
-		const tools = next();
-		lastReader = reader;
-		wrapInstance(tools);
-		return tools;
-	});
-	ctx.effect(() => () => {
-		for (const restore of patched.splice(0)) restore();
-	}, "tools.register attribution");
-	const toolsService = ctx.get("tools", false);
-	wrapInstance(toolsService);
-	const boot = /* @__PURE__ */ new Set();
-	try {
-		const toolEntries = toolsService?.layers?.global?.tools;
-		if (toolEntries !== void 0 && typeof toolEntries.entries === "function") for (const [name] of toolEntries.entries()) boot.add(name);
-	} catch {}
-	return { ownerOf: (name) => mcpSourceOf(name) ?? live.get(name) ?? pinnedSourceOf(name) ?? (boot.has(name) ? "<unknown-plugin>" : void 0) };
-}
-//#endregion
-//#region src/host/config.ts
-/**
-* dsh-context host configuration — the `config:` block of the `dsh-context`
-* loader row in cordis.yml.
-*
-* Cordis validates the entry config against this exported `Config` schema
-* (any Standard Schema v1 validator — zod is ours) before `apply` runs, fills
-* per-field defaults, and fails the load loudly on invalid or unknown keys
-* (`.strict()`). The official plugin-config principle this answers: "anything
-* that two deployments may want to set differently is a configuration field".
-*
-* The persisted projection state shape is independent of these bounds — they
-* only tune the fold's retention / presentation slice, so changing them never
-* requires a projection `stateVersion` bump.
-*/
-const DEFAULT_BOUNDS = {
-	maxRequestSteps: 1500,
-	maxKeptTurns: 300,
-	maxEvents: 400,
-	maxNodes: 2e3,
-	maxArchiveNodes: 400,
-	maxFileOps: 400
-};
-/**
-* The cordis `Config` validator: strict on keys, defaults on the schema fields; tolerates `undefined` (a patch row without a `config:`
-* block — defaults win).
-*/
-const Config = z.preprocess((v) => v ?? {}, z.object({
-	maxRequestSteps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxRequestSteps),
-	maxKeptTurns: z.number().int().min(1).default(DEFAULT_BOUNDS.maxKeptTurns),
-	maxEvents: z.number().int().min(1).default(DEFAULT_BOUNDS.maxEvents),
-	maxNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxNodes),
-	maxArchiveNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxArchiveNodes),
-	maxFileOps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxFileOps)
-}).strict());
-function resolveBounds(config) {
-	return Config.parse(config ?? {});
-}
-//#endregion
-//#region src/shared/providers.ts
-/**
-* The provider-id seam between dsh request envelopes and the models.dev
-* registry: client/cost.ts resolves price-book branches through it, and
-* host/fold.ts uses the DeepSeek resolution to split the session-cost totals
-* into peak/off-peak periods. Only the renames live here — an id absent
-* from the table passes through verbatim.
-*/
-const MODELS_DEV_PROVIDER_IDS = {
-	"deepseek-official": "deepseek",
-	"kimi-coding": "moonshotai",
-	"minimax-cn": "minimax",
-	"zai-coding-cn": "zhipuai"
-};
-/** The models.dev provider id that prices a dsh provider (identity for unmapped ids). */
-function modelsDevProviderOf(dshProviderId) {
-	return MODELS_DEV_PROVIDER_IDS[dshProviderId] ?? dshProviderId;
-}
-/** Whether a dsh provider prices through DeepSeek's period-based list (peak / half-price off-peak). */
-function isDeepSeekProvider(dshProviderId) {
-	return modelsDevProviderOf(dshProviderId) === "deepseek";
-}
-//#endregion
-//#region src/shared/estimate.ts
-/**
-* Token heuristics shared by the host fold and the client boundary — the
-* harness token-meter's own fixed-density figure (dsh-token-meter/estimate.ts:
-* ~4 chars ≈ 1 token, +4 role framing). Priced identically on both sides so a
-* legacy value normalized at the client boundary matches what the host view
-* would have served.
-*/
-const CHARS_PER_TOKEN$1 = 4;
-const ROLE_OVERHEAD$1 = 4;
-/** Price rendered system-prompt text; 0 for absent/empty/non-string input. */
-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
-/**
-* Per-image token estimate for DeepSeek's vision model — a faithful port of
-* the official "图片 Token 计算器" (Image Token Calculator) shipped on the
-* DeepSeek API docs (https://api-docs.deepseek.com/zh-cn/quick_start/token_usage),
-* which implements the provider's own image→token conversion:
-*
-*   - every image is aspect-preserved rescaled before entering the model:
-*     below ~384×384 total pixels it is enlarged, above it is shrunk;
-*   - tokens follow the patch grid (patch 14px, downsample 3), so every
-*     image costs at least 117 and at most ~384 tokens (the documented cap).
-*
-* Verified against the docs calculator itself: 2048×1365→313, 800×600→341,
-* 2048×2048→349, 512×512→201, 100×100→117, 1920×1080→369, 400×900→249.
-* The DSH request pipeline's own 640k-pixel pre-resize does not change the
-* result (the provider formula rescales to the same patch grid), so the
-* durable attachment dimensions can be fed in directly.
-*
-* Pure math shared by the Host fold (message pricing) and the Client
-* (attachment card token badges) — no dependencies, never mutates.
+* Per-image token estimate for DeepSeek's vision model — a faithful port of
+* the official "图片 Token 计算器" (Image Token Calculator) shipped on the
+* DeepSeek API docs (https://api-docs.deepseek.com/zh-cn/quick_start/token_usage),
+* which implements the provider's own image→token conversion:
+*
+*   - every image is aspect-preserved rescaled before entering the model:
+*     below ~384×384 total pixels it is enlarged, above it is shrunk;
+*   - tokens follow the patch grid (patch 14px, downsample 3), so every
+*     image costs at least 117 and at most ~384 tokens (the documented cap).
+*
+* Verified against the docs calculator itself: 2048×1365→313, 800×600→341,
+* 2048×2048→349, 512×512→201, 100×100→117, 1920×1080→369, 400×900→249.
+* The DSH request pipeline's own 640k-pixel pre-resize does not change the
+* result (the provider formula rescales to the same patch grid), so the
+* durable attachment dimensions can be fed in directly.
+*
+* Pure math shared by the Host fold (message pricing) and the Client
+* (attachment card token badges) — no dependencies, never mutates.
 */
 const PATCH_SIZE = 14;
 const DOWNSAMPLE_RATIO = 3;
@@ -1292,6 +1005,10 @@ function applySurface(st, ev, type, data, message) {
 * schemas' `.int().nonnegative()` gates on EVERY later delivery, permanently
 * freezing the projection feed for the session (issue #44). NaN, infinities,
 * and non-numeric values read as absent.
+*
+* Exported for the activity unit (host/activity.ts): the daily ledger re-proves
+* the same durable usage buckets with the same sanitizer, so one raw figure
+* can never enter either fold's state.
 */
 function tokenCountOf(value) {
 	if (typeof value === "number") return Number.isFinite(value) ? Math.max(0, Math.round(value)) : null;
@@ -1636,7 +1353,10 @@ function applyTimeline(state, event, bounds) {
 						if (source.form === "notice" && typeof source.summary === "string" && source.summary !== "") rec.detail = source.summary;
 					}
 					s.events.push(rec);
-				} else s.humanInputs = (s.humanInputs ?? 0) + 1;
+				} else {
+					s.humanInputs = (s.humanInputs ?? 0) + 1;
+					if (node.text !== void 0 && node.text !== "") s.lastUser = node.text;
+				}
 				break;
 			}
 			case "tool/result": {
@@ -1819,6 +1539,7 @@ function headFieldsOf(state) {
 		images: state.surface.reduce((n, node) => n + (node.imgs ?? 0), 0),
 		toolCalls: state.surface.reduce((n, node) => node.cat === "tool" || node.cat === "skill" && node.tool !== void 0 ? n + 1 : n, 0),
 		humanInputs: state.humanInputs ?? 0,
+		...state.lastUser !== void 0 ? { lastUser: state.lastUser } : {},
 		requests: [],
 		events: [],
 		nodes: [],
@@ -1848,114 +1569,640 @@ function headFieldsOf(state) {
 			tools
 		};
 	}
-	if (state.systems !== void 0 && state.systems.length > 0) result.systems = state.systems.map((n) => ({ ...n }));
-	return result;
+	if (state.systems !== void 0 && state.systems.length > 0) result.systems = state.systems.map((n) => ({ ...n }));
+	return result;
+}
+/**
+* The heavy collections: copies of the retained request records and context
+* events (each event attached to the requests around it — the chart's ✂
+* anchoring), the bounded served surface window, and the removed-node
+* archive. Shared verbatim by the inline wire view (channel-less hosts) and
+* the on-demand detail payload (host/detail.ts).
+*/
+function detailCollectionsOf(state, bounds) {
+	const result = {
+		requests: state.requests.map((r) => ({ ...r })),
+		events: state.events.map((e) => ({ ...e })),
+		nodes: [],
+		droppedNodes: 0,
+		archive: state.archived.map((n) => ({ ...n })),
+		fileOps: state.fileOps.map((o) => ({ ...o })),
+		...state.fileOpsFloor !== void 0 ? { fileOpsFloor: state.fileOpsFloor } : {}
+	};
+	const overflowCount = Math.max(0, state.surface.length - bounds.maxNodes);
+	const overflow = state.surface.slice(0, overflowCount);
+	const tail = state.surface.slice(overflowCount);
+	const pinned = overflow.filter((n) => n.cat === "inject" || n.cat === "skill");
+	result.nodes = pinned.length > 0 ? [...pinned, ...tail] : tail;
+	result.droppedNodes = overflowCount - pinned.length;
+	if (result.droppedNodes > 0) {
+		let floor = 0;
+		for (const n of overflow) if (n.cat !== "inject" && n.cat !== "skill") floor = Math.max(floor, n.seq);
+		result.surfaceFloor = floor;
+	}
+	if (state.archiveFloor !== void 0) result.archiveFloor = state.archiveFloor;
+	const requests = result.requests;
+	const events = result.events;
+	let ri = 0;
+	for (const ev of events) {
+		while (ri < requests.length && requests[ri].seq <= ev.seq) ri++;
+		const next = requests.at(ri);
+		const prev = ri > 0 ? requests.at(ri - 1) : void 0;
+		if (next !== void 0 && typeof next.turn === "number" && typeof next.step === "number") {
+			ev.turn = next.turn;
+			ev.step = next.step;
+		}
+		if (prev !== void 0 && typeof prev.turn === "number" && typeof prev.step === "number") {
+			ev.fromTurn = prev.turn;
+			ev.fromStep = prev.step;
+		}
+	}
+	return result;
+}
+/**
+* The split generation's SLIM wire head: the envelope scalars plus the
+* precomputed count figures, the newest request's billing summary (the
+* headline's derived anchor), and the detail revision marker. Small enough
+* to ride every delivery channel whole (~1KB) — the heavy collections moved
+* to the on-demand detail channel (host/detail.ts).
+*/
+function buildTimelineHead(state) {
+	const result = headFieldsOf(state);
+	const turns = /* @__PURE__ */ new Set();
+	for (const r of state.requests) turns.add(r.turn ?? 0);
+	let injects = 0;
+	let compactions = 0;
+	let prunes = 0;
+	for (const e of state.events) if (e.kind === "inject") injects++;
+	else if (e.kind === "compaction") compactions++;
+	else if (e.kind === "prune") prunes++;
+	result.counts = {
+		turns: turns.size,
+		steps: state.requests.length,
+		injects,
+		compactions,
+		prunes
+	};
+	const last = state.requests.at(-1);
+	if (last !== void 0) result.last = {
+		seq: last.seq,
+		total: last.total,
+		...typeof last.prompt === "number" ? { prompt: last.prompt } : {}
+	};
+	result.detailRev = state.detailRev ?? 0;
+	return result;
+}
+/**
+* The on-demand detail payload (host/detail.ts serves it off the live fold
+* 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)
+	};
+}
+/**
+* Serve the INLINE projection wire view (channel-less hosts): the head
+* scalars with the detail collections in place — the shape every delivery
+* channel carried before the split generation. Bound the surface nodes to
+* the newest tail and attach each event to the request around it; stamp
+* COPIES — the persisted state objects are never mutated.
+*/
+function buildTimelineView(state, bounds) {
+	return {
+		...headFieldsOf(state),
+		...detailCollectionsOf(state, bounds)
+	};
+}
+//#endregion
+//#region src/shared/days.ts
+/** Zero-pad to two digits (no Intl allocation on the hot path). */
+function pad2(n) {
+	return n < 10 ? "0" + String(n) : String(n);
+}
+/**
+* The local calendar-day key of an epoch-ms instant, or null when the time
+* is not a finite number or falls outside the representable date range —
+* untrusted log data can never produce a garbage key.
+*/
+function dayKeyOf(time) {
+	if (!Number.isFinite(time)) return null;
+	const d = new Date(time);
+	const y = d.getFullYear();
+	if (!Number.isFinite(y) || y < 1970 || y > 9999) return null;
+	return `${String(y).padStart(4, "0")}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+//#endregion
+//#region src/host/activity.ts
+/**
+* The `contextActivity` session projection unit — the per-day activity
+* ledger behind the Context Dashboard's heatmap.
+*
+* The timeline unit (fold.ts) is a "current snapshot" fold: it prices the
+* context as it stands NOW, which cannot draw a per-day chart. This unit
+* folds the same committed event stream into a ledger keyed by local
+* calendar day (shared/days.ts): every assistant settlement adds one
+* completed request to its day and, when the provider reported a usage
+* object, the day's billed-token figure grows by the disjoint buckets
+* (uncached input + cache read + cache write + output — the same semantics
+* the timeline's request records and the official token meter use). The
+* overview merges every listed session's ledger off the session list's
+* projection column (no per-session open needed) and colors its heatmap.
+*
+* One wire contract, one small state: a day entry is two integers and the
+* retention cap keeps at most {@link MAX_KEPT_DAYS} keys, so the value
+* riding every session-list row stays trivial next to the timeline head.
+* Same projection contract as the sibling units: pure init/apply/view,
+* unknown or malformed events return the state unchanged, and no
+* `undefined`-valued property ever materializes (the plain-JSON persisted-
+* state precondition).
+*/
+/**
+* Retention cap on ledger days. A little over a year of daily-active
+* sessions; the oldest keys drop first (key order IS chronological order).
+*/
+const MAX_KEPT_DAYS = 400;
+const activityDaySchema = z.object({
+	tokens: z.number().int().nonnegative(),
+	requests: z.number().int().nonnegative()
+}).strict();
+/** Validate the wire payload before it leaves the host (strict: no drift). */
+const contextActivitySchema = z.object({ days: z.record(z.string(), activityDaySchema) }).strict();
+/** The persisted fold-state schema — identical shape, validated before a checkpoint row seeds a fold. */
+const activityStateSchema = z.object({ days: z.record(z.string(), activityDaySchema) });
+/**
+* The day's billed increment from one durable usage object: the four
+* disjoint buckets summed after the shared per-bucket sanitizer
+* ({@link tokenCountOf} — fractions round, negatives clamp, garbage reads
+* absent). A usage object with NO readable bucket contributes nothing, so a
+* settlement that carried no usage still counts its request without
+* fabricating tokens.
+*/
+function billedOfUsage(value) {
+	if (value === null || typeof value !== "object") return 0;
+	const usage = value;
+	let any = false;
+	let total = 0;
+	for (const bucket of [
+		usage.inputTokens,
+		usage.cacheReadTokens,
+		usage.cacheWriteTokens,
+		usage.outputTokens
+	]) {
+		const count = tokenCountOf(bucket);
+		if (count !== null) {
+			total += count;
+			any = true;
+		}
+	}
+	return any ? total : 0;
+}
+/**
+* Fold one committed event into the ledger. Only `assistant/message` (the
+* step settlement — both supported log generations) advances a day; every
+* other type returns the state reference unchanged, as does a settlement
+* with an unreadable time. The next state is a copy along the mutated path
+* only — the persisted previous state is never mutated in place.
+*/
+function applyActivity(state, event) {
+	if (event.type !== "assistant/message") return state;
+	const key = dayKeyOf(event.time);
+	if (key === null) return state;
+	const data = event.data;
+	const tokens = billedOfUsage(data?.usage);
+	const prev = state.days[key];
+	const entry = {
+		tokens: prev === void 0 ? tokens : prev.tokens + tokens,
+		requests: prev === void 0 ? 1 : prev.requests + 1
+	};
+	let days = {
+		...state.days,
+		[key]: entry
+	};
+	const keys = Object.keys(days);
+	if (keys.length > MAX_KEPT_DAYS) {
+		keys.sort();
+		const drop = new Set(keys.slice(0, keys.length - MAX_KEPT_DAYS));
+		days = Object.fromEntries(Object.entries(days).filter(([k]) => !drop.has(k)));
+	}
+	return { days };
+}
+/**
+* The daily-activity projection unit, registered alongside the timeline and
+* headers units (host/index.ts); the overview reads it through the session
+* list's projection column. `stateVersion` 1: the ledger's first shape.
+*/
+function createContextActivityDefinition() {
+	return {
+		key: "contextActivity",
+		stateSchema: activityStateSchema,
+		init: () => ({ days: {} }),
+		apply: (state, event) => applyActivity(state, event),
+		wire: {
+			viewSchema: contextActivitySchema,
+			view: (state) => ({ days: Object.fromEntries(Object.entries(state.days).map(([k, v]) => [k, { ...v }])) })
+		},
+		stateVersion: 1
+	};
+}
+/**
+* Recover the MCP server display label from a proxied tool name, or undefined
+* for non-MCP names. `dsh-mcp-client` names tools `mcp__<server>__<rawName>`
+* (normalized, and hash-appended when overlong/invalid — the label then shows
+* whatever of the server survived the truncation). The separating `__` is the
+* LAST one in the name, and it must sit AFTER the `mcp__` prefix: the prefix's
+* own separator (or an empty server right after it) is not a server.
+*/
+function mcpServerOf(name) {
+	if (!name.startsWith("mcp__")) return void 0;
+	const cut = name.lastIndexOf("__");
+	if (cut < 5) return void 0;
+	const server = name.slice(5, cut);
+	return server.length > 0 ? server : void 0;
+}
+/** The `mcp:<server>` display label of a proxied tool name, or undefined. */
+function mcpSourceOf(name) {
+	const server = mcpServerOf(name);
+	return server !== void 0 ? `mcp:${server}` : void 0;
+}
+/** The pinned package of a first-party tool name, or undefined. */
+function pinnedSourceOf(name) {
+	return FIRST_PARTY_SOURCES[name];
+}
+/**
+* Pinned first-party tool → plugin package map (see header comment). One entry
+* per model-facing name of the shipped tool packages in the official
+* tool-schema catalog of the supported dsh baseline; names are verified
+* stable across the supported harness range. Packages that mount under
+* distinct names per composition (bash/pwsh persistent variants, the
+* `subagent_fork` fixed-route alias) map to their primary package.
+*/
+const FIRST_PARTY_SOURCES = Object.freeze({
+	read: "@deepseek-ai/dsh-tool-fs",
+	write: "@deepseek-ai/dsh-tool-fs",
+	edit: "@deepseek-ai/dsh-tool-fs",
+	read_image: "@deepseek-ai/dsh-tool-fs",
+	glob: "@deepseek-ai/dsh-tool-fs-search",
+	grep: "@deepseek-ai/dsh-tool-fs-search",
+	str_replace_editor: "@deepseek-ai/dsh-tool-str-replace-editor",
+	bash: "@deepseek-ai/dsh-tool-bash",
+	pwsh: "@deepseek-ai/dsh-tool-pwsh",
+	web_search: "@deepseek-ai/dsh-tool-web",
+	web_fetch: "@deepseek-ai/dsh-tool-web",
+	job_output: "@deepseek-ai/dsh-tool-jobs",
+	job_list: "@deepseek-ai/dsh-tool-jobs",
+	job_kill: "@deepseek-ai/dsh-tool-jobs",
+	ask_user_question: "@deepseek-ai/dsh-tool-ask-user",
+	plan: "@deepseek-ai/dsh-plan-mode",
+	exit_plan_mode: "@deepseek-ai/dsh-plan-mode",
+	skill: "@deepseek-ai/dsh-tool-skill",
+	todo_write: "@deepseek-ai/dsh-tool-todo",
+	subagent: "@deepseek-ai/dsh-tool-subagent",
+	subagent_fork: "@deepseek-ai/dsh-tool-subagent",
+	send_message: "@deepseek-ai/dsh-tool-subagent-control",
+	interrupt_agent: "@deepseek-ai/dsh-tool-subagent-control",
+	list_agents: "@deepseek-ai/dsh-tool-subagent-control",
+	ralph: "@deepseek-ai/dsh-tool-ralph",
+	workflow: "@deepseek-ai/dsh-tool-workflow",
+	run_code: "@deepseek-ai/dsh-tools",
+	schedule_create: "@deepseek-ai/dsh-schedule",
+	schedule_list: "@deepseek-ai/dsh-schedule",
+	schedule_delete: "@deepseek-ai/dsh-schedule",
+	create_goal: "@deepseek-ai/dsh-tool-goal",
+	get_goal: "@deepseek-ai/dsh-tool-goal",
+	update_goal: "@deepseek-ai/dsh-tool-goal",
+	lsp: "@deepseek-ai/dsh-tool-lsp"
+});
+//#endregion
+//#region src/host/attribution.ts
+/**
+* Live tool→plugin attribution layered on the static recovery in
+* toolSources.ts.
+*
+* The session log records tools as plain `ToolSchema` entries (name /
+* description / parameters) — the registering plugin is not in there.
+* toolSources.ts derives the deterministic sources (harness-logged field,
+* `mcp:<server>` naming, pinned first-party map). This module additionally
+* watches RUNTIME registrations: cordis fires the `internal/get` waterfall on
+* every context read of a service property, passing the READING context as the
+* 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
+*   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.
+*   LOCAL-LINK plugins — dev installs via `dsh plugin add <path>` or
+*   npm/pnpm link — whose anonymous entrypoints make cordis fall back to the
+*   root name), the wrapped `register` falls back to the call stack: the first
+*   frame outside this package is resolved to its nearest `package.json`
+*   `name`. That covers both npm installs (`node_modules/<pkg>`) and local
+*   links (any directory carrying a package.json), which never pass through
+*   node_modules. Frames that resolve back to this package are skipped.
+* - `ownerOf(name)` prefers the name-derived `mcp:<server>` label (it names
+*   the actual provider, where the live record would only ever name the MCP
+*   proxy client), then the LIVE record — for a post-boot registration it is
+*   the truth, even when the name collides with a pinned first-party tool —
+*   then the pinned map (the boot-time guess for tools registered before the
+*   hook), and finally tags tools that were ALREADY registered when the hook
+*   installed (the boot snapshot — third-party bundles, e.g. local links like
+*   dsh-file-claim, that applied before dsh-context) with the
+*   `UNKNOWN_TOOL_SOURCE` sentinel: their registering plugin is unknowable,
+*   and a bare gap would read as "no plugin" instead of "unknown plugin".
+*
+* Best-effort by design: a read separated from `register()` by an `await` can
+* be overwritten by another plugin's read (misattribution) and the stack
+* fallback needs a resolvable package.json — both degrade to the name/pinned
+* chain; registrations that predate the hook degrade to the unknown tag. The
+* hook costs roughly +1.4us per service-property read and is negligible on
+* the rare register path (the stack walk only runs when the reader slot is
+* unusable, and its package lookups are cached per directory).
+*/
+/** This module's own file URL — the stack walk skips its own frames. */
+const selfUrl = normalize(fileURLToPath(import.meta.url));
+/** Directory → package-name cache for the synchronous walk below. */
+const packageCache = /* @__PURE__ */ new Map();
+/**
+* Best-effort package name for a module file: walk up to the nearest
+* `package.json` carrying a `name`. Works for dependencies installed under
+* `node_modules` as well as local links whose package root is any on-disk
+* directory. The per-directory results are cached.
+* @param file - absolute path of a module file.
+*/
+function packageNameFrom(file) {
+	let dir = dirname(file);
+	for (let depth = 0; depth < 12; depth++) {
+		const cached = packageCache.get(dir);
+		if (cached !== void 0) return cached;
+		const packageFile = join(dir, "package.json");
+		if (existsSync(packageFile)) try {
+			const name = JSON.parse(readFileSync(packageFile, "utf8")).name;
+			if (typeof name === "string" && name) {
+				packageCache.set(dir, name);
+				return name;
+			}
+		} catch {}
+		const parent = dirname(dir);
+		packageCache.set(dir, void 0);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
 }
+const FRAME_POSITION = /:\d+:\d+$/;
+/** Package name of this module's own package (self-fallbacks are filtered). */
+const selfPackage = packageNameFrom(selfUrl);
 /**
-* The heavy collections: copies of the retained request records and context
-* events (each event attached to the requests around it — the chart's ✂
-* anchoring), the bounded served surface window, and the removed-node
-* archive. Shared verbatim by the inline wire view (channel-less hosts) and
-* the on-demand detail payload (host/detail.ts).
+* Resolve the registering package from a stack trace: walk frames from the
+* innermost out, skipping this module's own frames and frames that resolve to
+* this package, and return the package name of the first frame that resolves
+* elsewhere. Works with both `file://` URLs and bare absolute paths
+* (transpiled modules render without a scheme), with optional `fn (...)` and
+* `async` wrappers.
+* @param stack - `Error().stack`, or undefined when no fallback is desired.
 */
-function detailCollectionsOf(state, bounds) {
-	const result = {
-		requests: state.requests.map((r) => ({ ...r })),
-		events: state.events.map((e) => ({ ...e })),
-		nodes: [],
-		droppedNodes: 0,
-		archive: state.archived.map((n) => ({ ...n })),
-		fileOps: state.fileOps.map((o) => ({ ...o })),
-		...state.fileOpsFloor !== void 0 ? { fileOpsFloor: state.fileOpsFloor } : {}
-	};
-	const overflowCount = Math.max(0, state.surface.length - bounds.maxNodes);
-	const overflow = state.surface.slice(0, overflowCount);
-	const tail = state.surface.slice(overflowCount);
-	const pinned = overflow.filter((n) => n.cat === "inject" || n.cat === "skill");
-	result.nodes = pinned.length > 0 ? [...pinned, ...tail] : tail;
-	result.droppedNodes = overflowCount - pinned.length;
-	if (result.droppedNodes > 0) {
-		let floor = 0;
-		for (const n of overflow) if (n.cat !== "inject" && n.cat !== "skill") floor = Math.max(floor, n.seq);
-		result.surfaceFloor = floor;
-	}
-	if (state.archiveFloor !== void 0) result.archiveFloor = state.archiveFloor;
-	const requests = result.requests;
-	const events = result.events;
-	let ri = 0;
-	for (const ev of events) {
-		while (ri < requests.length && requests[ri].seq <= ev.seq) ri++;
-		const next = requests.at(ri);
-		const prev = ri > 0 ? requests.at(ri - 1) : void 0;
-		if (next !== void 0 && typeof next.turn === "number" && typeof next.step === "number") {
-			ev.turn = next.turn;
-			ev.step = next.step;
-		}
-		if (prev !== void 0 && typeof prev.turn === "number" && typeof prev.step === "number") {
-			ev.fromTurn = prev.turn;
-			ev.fromStep = prev.step;
+function callerPackageFrom(stack) {
+	if (!stack) return void 0;
+	for (const raw of stack.split("\n").slice(1)) {
+		let line = raw.trim();
+		if (!line.startsWith("at ")) continue;
+		line = line.slice(3);
+		if (line.startsWith("async ")) line = line.slice(6);
+		line = line.replace(/\)\s*$/, "");
+		const position = FRAME_POSITION.exec(line);
+		if (!position) continue;
+		let target = line.slice(0, -position[0].length);
+		if (target.includes("(")) target = target.slice(target.lastIndexOf("(") + 1);
+		if (target.startsWith("file://")) try {
+			target = normalize(fileURLToPath(target));
+		} catch {
+			continue;
 		}
+		else if (!/^[A-Za-z]:[\\/]/.test(target) && !target.startsWith("/") && !target.startsWith("\\\\")) continue;
+		else target = normalize(target);
+		if (target === selfUrl) continue;
+		const name = packageNameFrom(target);
+		if (name !== void 0 && name !== selfPackage) return name;
 	}
-	return result;
 }
 /**
-* The split generation's SLIM wire head: the envelope scalars plus the
-* precomputed count figures, the newest request's billing summary (the
-* headline's derived anchor), and the detail revision marker. Small enough
-* to ride every delivery channel whole (~1KB) — the heavy collections moved
-* to the on-demand detail channel (host/detail.ts).
+* Install the runtime-attribution hook on a cordis app context. The hook
+* rides the calling fiber's lifetime (`ctx.on`, and an effect that restores
+* every patched `register`), so it is disposed with the plugin.
+* @param ctx - the context the dsh-context plugin runs in; its fiber name is
+* excluded from attributions.
 */
-function buildTimelineHead(state) {
-	const result = headFieldsOf(state);
-	const turns = /* @__PURE__ */ new Set();
-	for (const r of state.requests) turns.add(r.turn ?? 0);
-	let injects = 0;
-	let compactions = 0;
-	let prunes = 0;
-	for (const e of state.events) if (e.kind === "inject") injects++;
-	else if (e.kind === "compaction") compactions++;
-	else if (e.kind === "prune") prunes++;
-	result.counts = {
-		turns: turns.size,
-		steps: state.requests.length,
-		injects,
-		compactions,
-		prunes
+function createToolAttribution(ctx) {
+	const live = /* @__PURE__ */ new Map();
+	const wrapped = /* @__PURE__ */ new WeakSet();
+	const self = ctx.fiber.name;
+	let lastReader;
+	const patched = [];
+	const wrapInstance = (tools) => {
+		if (!tools || typeof tools !== "object" || wrapped.has(tools)) return;
+		const register = tools.register;
+		if (typeof register !== "function") return;
+		wrapped.add(tools);
+		const original = register.attributedOriginal ?? register;
+		if (typeof original !== "function") return;
+		const instance = tools;
+		const wrappedRegister = function(definition) {
+			const toolName = definition?.name;
+			let owner = lastReader?.fiber.name;
+			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) {
+				live.set(toolName, owner);
+				if (typeof dispose === "function") return () => {
+					try {
+						return dispose();
+					} finally {
+						live.delete(toolName);
+					}
+				};
+			}
+			return dispose;
+		};
+		wrappedRegister.attributedOriginal = original;
+		instance.register = wrappedRegister;
+		patched.push(() => {
+			if (instance.register === wrappedRegister) instance.register = original;
+		});
 	};
-	const last = state.requests.at(-1);
-	if (last !== void 0) result.last = {
-		seq: last.seq,
-		total: last.total,
-		...typeof last.prompt === "number" ? { prompt: last.prompt } : {}
+	ctx.on("internal/get", (reader, name, _error, next) => {
+		if (name !== "tools") return next();
+		const tools = next();
+		lastReader = reader;
+		wrapInstance(tools);
+		return tools;
+	});
+	ctx.effect(() => () => {
+		for (const restore of patched.splice(0)) restore();
+	}, "tools.register attribution");
+	const toolsService = ctx.get("tools", false);
+	wrapInstance(toolsService);
+	const boot = /* @__PURE__ */ new Set();
+	try {
+		const toolEntries = toolsService?.layers?.global?.tools;
+		if (toolEntries !== void 0 && typeof toolEntries.entries === "function") for (const [name] of toolEntries.entries()) boot.add(name);
+	} catch {}
+	return { ownerOf: (name) => mcpSourceOf(name) ?? live.get(name) ?? pinnedSourceOf(name) ?? (boot.has(name) ? "<unknown-plugin>" : void 0) };
+}
+//#endregion
+//#region src/host/backfill.ts
+/** Inter-session pacing so a multi-hundred-session backfill never starve the host. */
+const YIELD_MS = 10;
+function asRecord(value) {
+	return value !== null && typeof value === "object" ? value : null;
+}
+/** One listed record's header, re-proved: id and cwd are the two fields the run relies on. */
+function headerOf(record) {
+	const header = asRecord(asRecord(record)?.header);
+	if (header === null) return null;
+	if (typeof header.id !== "string" || header.id === "") return null;
+	return header;
+}
+/** Whether the cache already serves BOTH projection rows for this header (nothing to backfill). */
+function servesRows(cache, header) {
+	try {
+		const values = asRecord(asRecord(cache.cachedSnapshot(header, SessionLogOffset(0), ["contextActivity", "contextTimeline"]))?.values);
+		return values !== null && values.contextActivity !== void 0 && values.contextTimeline !== void 0;
+	} catch {
+		return false;
+	}
+}
+/** Read one stored log through a read handle, mirroring dsh-session-query's readColdSessionLog. */
+async function readColdLog(persistence, id, signal) {
+	const handle = await persistence.open(id, "read", { signal });
+	let events;
+	try {
+		const result = asRecord(await handle.read(0, void 0, { signal }))?.events;
+		events = Array.isArray(result) ? result : [];
+	} catch (error) {
+		try {
+			await handle.close();
+		} catch {}
+		throw error;
+	}
+	await handle.close();
+	return {
+		header: handle.header,
+		inheritedEventCount: handle.inheritedEventCount,
+		events: [...events, ...interruptedTurnClosers(events)]
 	};
-	result.detailRev = state.detailRev ?? 0;
-	return result;
 }
 /**
-* The on-demand detail payload (host/detail.ts serves it off the live fold
-* 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.
+* Whether one session is live (folds for itself — a cold write would only
+* race its own checkpoints). A throwing registry read conservatively skips
+* the session too: better to leave a row unfolded than to write over a
+* possibly-live one.
 */
-function buildTimelineDetail(state, bounds) {
-	return {
-		rev: state.detailRev ?? 0,
-		head: buildTimelineHead(state),
-		...detailCollectionsOf(state, bounds)
+function isLive(sessions, id) {
+	if (sessions === null || typeof sessions.get !== "function") return false;
+	try {
+		return sessions.get(id) !== void 0;
+	} catch {
+		return true;
+	}
+}
+/**
+* Arm the warm-up on whichever deployment composes the four cold-path
+* services; returns the deferred inject's disposer (abort on unload).
+*/
+function watchActivityBackfill(ctx) {
+	const handle = ctx.inject([
+		"sessionQuery",
+		"sessionProjectionCache",
+		"sessionPersistence",
+		"sessions"
+	], (raw) => {
+		const injected = raw;
+		const query = asRecord(injected.sessionQuery);
+		const cache = asRecord(injected.sessionProjectionCache);
+		const persistence = asRecord(injected.sessionPersistence);
+		if (query === null || typeof query.listSessions !== "function") return;
+		if (cache === null || typeof cache.cachedSnapshot !== "function" || typeof cache.coldSnapshot !== "function") return;
+		if (persistence === null || typeof persistence.open !== "function") return;
+		const sessions = asRecord(injected.sessions);
+		const abort = new AbortController();
+		const run = async () => {
+			const listed = await query.listSessions(abort.signal);
+			if (!Array.isArray(listed)) return;
+			let folded = 0;
+			for (const record of listed) {
+				if (abort.signal.aborted) return;
+				const header = headerOf(record);
+				if (header === null || typeof header.cwd !== "string") continue;
+				if (isLive(sessions, header.id)) continue;
+				if (servesRows(cache, header)) continue;
+				try {
+					const log = await readColdLog(persistence, header.id, abort.signal);
+					cache.coldSnapshot(log.header, log.inheritedEventCount, log.events);
+					folded++;
+				} catch (error) {
+					ctx.logger.warn(`dsh-context: projection backfill skipped "${header.id}" (${String(error)})`);
+				}
+				await new Promise((resolve) => setTimeout(resolve, YIELD_MS));
+			}
+			if (folded > 0) ctx.logger.info(`dsh-context: projection rows backfilled for ${folded} session(s)`);
+		};
+		run().catch((error) => {
+			if (!abort.signal.aborted) ctx.logger.warn(`dsh-context: projection backfill stopped early (${String(error)})`);
+		});
+		return () => {
+			abort.abort();
+		};
+	});
+	return () => {
+		handle?.dispose?.();
 	};
 }
+//#endregion
+//#region src/host/config.ts
 /**
-* Serve the INLINE projection wire view (channel-less hosts): the head
-* scalars with the detail collections in place — the shape every delivery
-* channel carried before the split generation. Bound the surface nodes to
-* the newest tail and attach each event to the request around it; stamp
-* COPIES — the persisted state objects are never mutated.
+* dsh-context host configuration — the `config:` block of the `dsh-context`
+* loader row in cordis.yml.
+*
+* Cordis validates the entry config against this exported `Config` schema
+* (any Standard Schema v1 validator — zod is ours) before `apply` runs, fills
+* per-field defaults, and fails the load loudly on invalid or unknown keys
+* (`.strict()`). The official plugin-config principle this answers: "anything
+* that two deployments may want to set differently is a configuration field".
+*
+* The persisted projection state shape is independent of these bounds — they
+* only tune the fold's retention / presentation slice, so changing them never
+* requires a projection `stateVersion` bump.
 */
-function buildTimelineView(state, bounds) {
-	return {
-		...headFieldsOf(state),
-		...detailCollectionsOf(state, bounds)
-	};
+const DEFAULT_BOUNDS = {
+	maxRequestSteps: 1500,
+	maxKeptTurns: 300,
+	maxEvents: 400,
+	maxNodes: 2e3,
+	maxArchiveNodes: 400,
+	maxFileOps: 400
+};
+/**
+* The cordis `Config` validator: strict on keys, defaults on the schema fields; tolerates `undefined` (a patch row without a `config:`
+* block — defaults win).
+*/
+const Config = z.preprocess((v) => v ?? {}, z.object({
+	maxRequestSteps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxRequestSteps),
+	maxKeptTurns: z.number().int().min(1).default(DEFAULT_BOUNDS.maxKeptTurns),
+	maxEvents: z.number().int().min(1).default(DEFAULT_BOUNDS.maxEvents),
+	maxNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxNodes),
+	maxArchiveNodes: z.number().int().min(1).default(DEFAULT_BOUNDS.maxArchiveNodes),
+	maxFileOps: z.number().int().min(1).default(DEFAULT_BOUNDS.maxFileOps)
+}).strict());
+function resolveBounds(config) {
+	return Config.parse(config ?? {});
 }
 //#endregion
 //#region src/host/detail.ts
@@ -2453,6 +2700,7 @@ const contextTimelineSchema = z.object({
 	images: z.number().int().nonnegative().optional(),
 	toolCalls: z.number().int().nonnegative().optional(),
 	humanInputs: z.number().int().nonnegative().optional(),
+	lastUser: z.string().optional(),
 	counts: countsSchema.optional(),
 	last: lastSchema.optional(),
 	detailRev: z.number().int().nonnegative().optional(),
@@ -2499,6 +2747,7 @@ const timelineStateSchema = z.object({
 	archiveFloor: z.number().optional(),
 	timing: timingTotalsSchema.optional(),
 	humanInputs: z.number().int().nonnegative().optional(),
+	lastUser: z.string().optional(),
 	stepStart: z.object({
 		time: z.number(),
 		firstToken: z.number().optional(),
@@ -2573,7 +2822,7 @@ function createContextTimelineDefinition(config, slim) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 19
+		stateVersion: 20
 	};
 }
 //#endregion
@@ -2664,6 +2913,14 @@ function createFallbackTimelineDefinition(current) {
 function createFallbackHeadersDefinition() {
 	return fallbackDefinition("contextHeaders", contextHeadersSchema, { headers: [] });
 }
+/**
+* The fallback `contextActivity` unit: an empty ledger — the overview's
+* heatmap renders its empty note instead of waiting on a key that the gate
+* would never deliver.
+*/
+function createFallbackActivityDefinition() {
+	return fallbackDefinition("contextActivity", contextActivitySchema, { days: {} });
+}
 //#endregion
 //#region src/host/settings.ts
 /** The namespace is the join key between the Host registration and the browser card. */
@@ -2686,7 +2943,8 @@ const SettingsSchema = z$1.object({
 		"count",
 		"latest",
 		"path"
-	]).default("count").loose()
+	]).default("count").loose(),
+	insightsEntry: z$1.union(["show", "hide"]).default("show").loose()
 });
 /** Serve the namespace while a settings provider is composed; inert otherwise. */
 function installSettings(ctx) {
@@ -2958,6 +3216,7 @@ function apply(ctx, config) {
 	if (harnessVersion !== void 0 && !meetsBaseline(harnessVersion)) {
 		ctx.sessionProjections.register(createFallbackTimelineDefinition(harnessVersion));
 		ctx.sessionProjections.register(createFallbackHeadersDefinition());
+		ctx.sessionProjections.register(createFallbackActivityDefinition());
 		return;
 	}
 	const attribution = createToolAttribution(ctx);
@@ -2965,6 +3224,8 @@ function apply(ctx, config) {
 	const gate = watchDetailChannel(ctx, resolveBounds(config));
 	ctx.sessionProjections.register(createContextTimelineDefinition(config, () => gate.live));
 	ctx.sessionProjections.register(createContextHeadersDefinition((name) => attribution.ownerOf(name)));
+	ctx.sessionProjections.register(createContextActivityDefinition());
+	watchActivityBackfill(ctx);
 	installSettings(ctx);
 }
 //#endregion