dsh-xray 0.7.2 → 0.8.1

package/lib/collect/attribution.js

@@ -0,0 +1,239 @@
+// Registry attribution: attribute named entries (prompt sections, tools) to
+// the plugin that registered them. Purely observational — nothing here
+// mutates the registries.
+//
+// Both dsh-system-prompt and dsh-tools follow the same ScopedLayers pattern:
+// `register()`/`section()` runs `layers.effect(CALLER ctx, ...)` with a fixed
+// label ("systemPrompt.section()" / "tools.register()"), and every
+// registration/disposal emits a change event ("system-prompt/change" /
+// "tools/change"). The effect meta carries only the label, not the entry
+// name (cordis EffectMeta is {label, children}), so the name->plugin join is
+// reconstructed diff-wise: between two change events, the only fibers whose
+// labeled-effect count grew are the registrants of the names that appeared.
+// Verified against dsh-system-prompt + cordis in /tmp probes (2026-08-25).
+//
+// Baseline rule: entries present before observation starts are attributed by
+// a one-shot scan only when exactly one already-mounted fiber carries the
+// label — otherwise they stay null (`unattributed`) rather than guessing.
+
+/** Count effects with the given label in one fiber's live effect tree. */
+function labeledEffectCount(fiber, label) {
+  let count = 0;
+  const walk = (effect, depth) => {
+    if (!effect || depth > 4) return;
+    if (effect.label === label) count += 1;
+    for (const child of effect.children ?? []) walk(child, depth + 1);
+  };
+  try {
+    for (const effect of fiber.getEffects?.() ?? []) walk(effect, 0);
+  } catch {
+    /* disposed fiber mid-walk: count what we saw */
+  }
+  return count;
+}
+
+/** Best-effort plugin name for a fiber (entry name first, runtime name second). */
+function fiberPluginName(fiber) {
+  try {
+    return fiber.entry?.options?.name ?? fiber.name ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Normalize an identifier to comparable word stems: "tool-fs-search" ->
+ * ["tool","fs","search"], "tool:glob" -> ["tool","glob"], "get_goal" ->
+ * ["get","goal"]. Scope prefixes like @deepseek-ai/dsh- are shed first. */
+function stems(identifier) {
+  return String(identifier)
+    .replace(/^@[^/]+\//, '')
+    .replace(/^dsh-/, '')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+/** Does the name plausibly belong to the fiber? True when they share any
+ * non-generic stem ("tool"/"get"/"list" alone prove nothing). */
+const GENERIC_STEMS = new Set(['tool', 'tools', 'get', 'set', 'list', 'run', 'app', 'dsh']);
+function affine(name, fiberName) {
+  const ns = stems(name);
+  const fibers = new Set(stems(fiberName));
+  return ns.some((s) => !GENERIC_STEMS.has(s) && fibers.has(s));
+}
+
+/**
+ * Attribute pre-existing names to carrier fibers by stem affinity, accepting
+ * a fiber's assignment only when its matched-name count reconciles exactly
+ * with its labeled-effect count (so a partial or over-broad match assigns
+ * nothing rather than something wrong).
+ * @returns Map<name, pluginName> for the names that reconciled.
+ */
+function baselineByAffinity(names, carriers, counts) {
+  const assigned = new Map();
+  const claims = new Map(); // fiber -> names it matches
+  for (const fiber of carriers) {
+    const fname = fiberPluginName(fiber);
+    if (!fname) continue;
+    const mine = [...names].filter((n) => !assigned.has(n) && affine(n, fname));
+    claims.set(fiber, mine);
+  }
+  // A name claimed by two fibers is ambiguous everywhere it appears: drop it.
+  const claimCount = new Map();
+  for (const mine of claims.values())
+    for (const n of mine) claimCount.set(n, (claimCount.get(n) ?? 0) + 1);
+  for (const [fiber, mine] of claims) {
+    const unambiguous = mine.filter((n) => claimCount.get(n) === 1);
+    if (unambiguous.length > 0 && unambiguous.length === (counts.get(fiber) ?? 0)) {
+      const fname = fiberPluginName(fiber);
+      for (const n of unambiguous) assigned.set(n, fname);
+    }
+  }
+  return assigned;
+}
+
+/**
+ * Install one diff-based attribution observer.
+ * @param ctx - the mounted plugin's context (reaches registry + events).
+ * @param spec - { event, effectLabel, names } where `names(ctx)` reads the
+ * registry's current global-layer name set.
+ * @returns { table, dispose } — `table` is a live Map<name, pluginName|null>.
+ */
+function installAttribution(ctx, spec) {
+  const table = new Map();
+  const fibers = new Set();
+  const counts = new Map(); // fiber -> last seen labeled-effect count
+
+  try {
+    for (const runtime of ctx.registry.values()) {
+      for (const fiber of runtime.fibers) fibers.add(fiber);
+    }
+  } catch {
+    /* registry unreadable: event stream alone still works */
+  }
+  const disposePlugin = ctx.on('internal/plugin', (fiber) => {
+    try {
+      fibers.add(fiber);
+    } catch {
+      /* never break the host */
+    }
+  });
+
+  // Baseline: entries registered before observation started. The diff trick
+  // cannot see the past, but the effect COUNTS per fiber survive: a fiber
+  // carrying N labeled effects registered exactly N of the pre-existing
+  // names. Names follow strong conventions (fiber "tool-goal" registers
+  // section "tool:goal" and tools "get_goal"/"create_goal"/...), so match
+  // names to fibers by normalized-stem affinity — and accept a fiber's
+  // matches ONLY when their count equals that fiber's effect count exactly
+  // (per-fiber bookkeeping must reconcile). Anything left over stays null
+  // (`unattributed`) rather than guessed.
+  let prevNames = spec.names(ctx);
+  const carriers = [];
+  for (const fiber of fibers) {
+    const count = labeledEffectCount(fiber, spec.effectLabel);
+    counts.set(fiber, count);
+    if (count > 0) carriers.push(fiber);
+  }
+  if (carriers.length === 1) {
+    for (const name of prevNames) table.set(name, fiberPluginName(carriers[0]));
+  } else {
+    const assigned = baselineByAffinity(prevNames, carriers, counts);
+    for (const name of prevNames) table.set(name, assigned.get(name) ?? null);
+  }
+
+  const disposeChange = ctx.on(spec.event, () => {
+    try {
+      const names = spec.names(ctx);
+      const added = [...names].filter((n) => !prevNames.has(n));
+      const removed = [...prevNames].filter((n) => !names.has(n));
+      const registrants = [];
+      for (const fiber of fibers) {
+        const now = labeledEffectCount(fiber, spec.effectLabel);
+        const before = counts.get(fiber) ?? 0;
+        if (now > before) registrants.push(fiber);
+        counts.set(fiber, now);
+      }
+      // One grown fiber owns every added name in this tick (change fires per
+      // registration); multiple grown fibers between coalesced ticks would
+      // be ambiguous — attribute only the unambiguous case.
+      for (const name of added) {
+        table.set(name, registrants.length === 1 ? fiberPluginName(registrants[0]) : null);
+      }
+      for (const name of removed) table.delete(name);
+      prevNames = names;
+    } catch {
+      /* diagnostics must never break the host path */
+    }
+  });
+
+  return {
+    table,
+    dispose: () => {
+      disposePlugin();
+      disposeChange();
+    },
+  };
+}
+
+/** All names across the global layer plus every scoped overlay. Tool plugins
+ * mount under each agent's scope (agent-presets refuses unscoped mounts), so
+ * the global layer alone misses every per-agent registration. */
+function allLayerNames(layers, pick) {
+  const names = new Set();
+  if (!layers) return names;
+  try {
+    for (const key of pick(layers.global)?.keys() ?? []) names.add(key);
+    for (const layer of layers.scoped?.values() ?? []) {
+      for (const key of pick(layer)?.keys() ?? []) names.add(key);
+    }
+  } catch {
+    /* layer shape drifted: return what we saw */
+  }
+  return names;
+}
+
+/** Prompt section names (global + every agent scope). */
+function sectionNames(ctx) {
+  try {
+    return allLayerNames(ctx.get?.('systemPrompt')?.layers, (layer) => layer?.sections);
+  } catch {
+    return new Set();
+  }
+}
+
+/** Tool names (global + every agent scope). */
+function toolNames(ctx) {
+  try {
+    return allLayerNames(ctx.get?.('tools')?.layers, (layer) => layer?.tools);
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * Install both attribution observers (sections + tools).
+ * @returns { sections, tools, dispose } — two live Map<name, plugin|null>.
+ */
+function installSectionAttribution(ctx) {
+  const sections = installAttribution(ctx, {
+    event: 'system-prompt/change',
+    effectLabel: 'systemPrompt.section()',
+    names: sectionNames,
+  });
+  const tools = installAttribution(ctx, {
+    event: 'tools/change',
+    effectLabel: 'tools.register()',
+    names: toolNames,
+  });
+  return {
+    table: sections.table,
+    toolTable: tools.table,
+    dispose: () => {
+      sections.dispose();
+      tools.dispose();
+    },
+  };
+}
+
+module.exports = { installSectionAttribution, installAttribution, labeledEffectCount };

package/lib/collect/runtime.js

@@ -60,11 +60,36 @@ function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 
-/** Capture the model-facing tool schemas (name/description/parameters). */
+/** Capture the model-facing tool schemas (name/description/parameters).
+ * Tool plugins mount under each agent's scope (agent-presets refuses
+ * unscoped mounts), so `schemas()` on the global view alone misses them:
+ * walk the global layer plus every scoped overlay and dedupe by name. */
 function snapshotTools(ctx) {
   try {
     const tools = ctx.get?.('tools') ?? ctx.root?.tools;
-    const schemas = tools?.schemas?.();
+    if (!tools) return [];
+    const byName = new Map();
+    const harvest = (definitions) => {
+      for (const [name, definition] of definitions?.entries() ?? []) {
+        if (byName.has(name)) continue;
+        byName.set(name, {
+          name,
+          description: definition.description ?? '',
+          tokens: estimateTokens(
+            JSON.stringify({
+              name,
+              description: definition.description ?? '',
+              parameters: definition.parameters ?? {},
+            }),
+          ),
+        });
+      }
+    };
+    harvest(tools.layers?.global?.tools);
+    for (const layer of tools.layers?.scoped?.values() ?? []) harvest(layer.tools);
+    if (byName.size > 0) return [...byName.values()];
+    // Layer shape drifted: fall back to the public global-view projection.
+    const schemas = tools.schemas?.();
     if (!Array.isArray(schemas)) return [];
     return schemas.map((s) => ({
       name: s.name,
@@ -125,9 +150,67 @@ function snapshotRegistry(ctx) {
   };
 }
 
+/**
+ * Read ONE entry's live text on demand (never persisted): the answer to
+ * "what exactly is this ~N tokens?". Sections resolve their text (static
+ * string or provider function called with an empty context); tools return
+ * the full model-facing schema. Reads the same layers attribution reads.
+ * @returns { kind, name, text, chars, tokens, estimator } or null when absent.
+ */
+function snapshotEntry(ctx, kind, name) {
+  const found = (text) => ({
+    kind,
+    name,
+    text,
+    chars: text.length,
+    tokens: estimateTokens(text),
+    estimator: '~4 chars/token',
+  });
+  const firstAcrossLayers = (layers, pick) => {
+    let value = pick(layers.global);
+    if (value !== undefined) return value;
+    for (const layer of layers.scoped?.values() ?? []) {
+      value = pick(layer);
+      if (value !== undefined) return value;
+    }
+    return undefined;
+  };
+  try {
+    if (kind === 'section') {
+      const layers = ctx.get?.('systemPrompt')?.layers;
+      if (!layers) return null;
+      const section = firstAcrossLayers(layers, (layer) => layer?.sections?.get?.(name));
+      if (!section) return null;
+      const text = typeof section.text === 'function' ? section.text({}) : section.text;
+      return found(String(text ?? ''));
+    }
+    if (kind === 'tool') {
+      const layers = ctx.get?.('tools')?.layers;
+      if (!layers) return null;
+      const definition = firstAcrossLayers(layers, (layer) => layer?.tools?.get?.(name));
+      if (!definition) return null;
+      return found(
+        JSON.stringify(
+          {
+            name: definition.name,
+            description: definition.description ?? '',
+            parameters: definition.parameters ?? {},
+          },
+          null,
+          2,
+        ),
+      );
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 module.exports = {
   snapshotRegistry,
   snapshotTools,
+  snapshotEntry,
   injectNames,
   provideNames,
   stateName,

package/lib/index.js

@@ -1,7 +1,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
-const { snapshotRegistry, stateName, estimateTokens } = require('./collect/runtime.js');
+const {
+  snapshotRegistry,
+  snapshotEntry,
+  stateName,
+  estimateTokens,
+} = require('./collect/runtime.js');
+const { installSectionAttribution } = require('./collect/attribution.js');
 const { serviceGraph, health, shadowing, contextCost } = require('./model.js');
 
 const name = 'dsh-xray';
@@ -27,6 +33,7 @@ function apply(ctx) {
   const file = path.join(dir, 'runtime.json');
   const transitions = new Map(); // plugin name -> [{state, at}] ring buffer
   let lastAssembly = null; // latest system-prompt assembly observation
+  let attribution = null; // section name -> plugin name (live table)
 
   let timer = null;
   const writeSnapshot = () => {
@@ -35,6 +42,8 @@ function apply(ctx) {
       const snap = snapshotRegistry(ctx);
       snap.transitions = Object.fromEntries(transitions);
       snap.promptAssembly = lastAssembly;
+      snap.sectionOwners = attribution ? Object.fromEntries(attribution.table) : {};
+      snap.toolOwners = attribution ? Object.fromEntries(attribution.toolTable) : {};
       fs.mkdirSync(dir, { recursive: true });
       const tmp = `${file}.tmp`;
       fs.writeFileSync(tmp, JSON.stringify(snap, null, 2));
@@ -81,9 +90,16 @@ function apply(ctx) {
       return result;
     });
     schedule(); // initial snapshot
+    // Section attribution: diff-based name->plugin table over
+    // system-prompt/change (see collect/attribution.js for the strategy).
+    attribution = installSectionAttribution(ctx);
     return [
       disposeStatus,
       disposeAssemble,
+      () => {
+        attribution.dispose();
+        attribution = null;
+      },
       () => {
         clearTimeout(timer);
         writeSnapshot(); // final state on unload
@@ -102,26 +118,34 @@ function apply(ctx) {
         const snap = snapshotRegistry(ctx);
         snap.transitions = Object.fromEntries(transitions);
         snap.promptAssembly = lastAssembly;
+        snap.sectionOwners = attribution ? Object.fromEntries(attribution.table) : {};
+        snap.toolOwners = attribution ? Object.fromEntries(attribution.toolTable) : {};
         return snap;
       };
       wctx.effect(
         () =>
-          mountPanel(wctx.webServer, {
-            summary: () => {
-              const snap = freshSnap();
-              return {
-                plugins: snap.plugins.length,
-                unhealthy: health(snap).unhealthy.length,
-                services: Object.keys(serviceGraph(snap).services).length,
-                toolSchemaTokens: contextCost(snap).totalTokens,
-                capturedAt: snap.capturedAt,
-              };
+          mountPanel(
+            wctx.webServer,
+            {
+              summary: () => {
+                const snap = freshSnap();
+                return {
+                  plugins: snap.plugins.length,
+                  unhealthy: health(snap).unhealthy.length,
+                  services: Object.keys(serviceGraph(snap).services).length,
+                  toolSchemaTokens: contextCost(snap).totalTokens,
+                  capturedAt: snap.capturedAt,
+                };
+              },
+              deps: () => serviceGraph(freshSnap()),
+              health: () => health(freshSnap()),
+              cost: () => contextCost(freshSnap()),
+              shadow: () => shadowing(freshSnap()),
             },
-            deps: () => serviceGraph(freshSnap()),
-            health: () => health(freshSnap()),
-            cost: () => contextCost(freshSnap()),
-            shadow: () => shadowing(freshSnap()),
-          }),
+            // Entry text is computed per request from the live registries and
+            // never persisted — the audit answer to "what exactly is ~N tokens?".
+            (kind, entryName) => snapshotEntry(ctx, kind, entryName),
+          ),
         'xray-panel-routes',
       );
       logger.info('xray panel mounted at /xray');
@@ -172,6 +196,8 @@ function apply(ctx) {
             const snap = snapshotRegistry(ctx);
             snap.transitions = Object.fromEntries(transitions);
             snap.promptAssembly = lastAssembly;
+            snap.sectionOwners = attribution ? Object.fromEntries(attribution.table) : {};
+            snap.toolOwners = attribution ? Object.fromEntries(attribution.toolTable) : {};
             if (args.view === 'deps') return serviceGraph(snap);
             if (args.view === 'health') return health(snap);
             if (args.view === 'cost') return contextCost(snap);

package/lib/model.js

@@ -277,8 +277,13 @@ function shadowing(snap) {
   return out;
 }
 
-/** F8: estimated context cost — tool schemas plus prompt sections. */
+/** F8: estimated context cost — tool schemas plus prompt sections, each
+ * attributed to the plugin that registered it (F9: owner join + per-plugin
+ * rollup). Owners come from the snapshot's diff-based attribution tables;
+ * a missing entry renders as null (`unattributed`), never a guess. */
 function contextCost(snap) {
+  const sectionOwners = snap.sectionOwners ?? {};
+  const toolOwners = snap.toolOwners ?? {};
   const tools = (snap.tools ?? []).slice().sort((a, b) => b.tokens - a.tokens);
   const toolTokens = tools.reduce((sum, t) => sum + t.tokens, 0);
   const sections = (snap.promptAssembly?.sections ?? [])
@@ -287,14 +292,49 @@ function contextCost(snap) {
   const sectionTokens = sections.reduce((sum, s) => sum + s.tokens, 0);
   const total = toolTokens + sectionTokens;
   const share = (n) => (total ? Math.round((n / total) * 1000) / 10 : 0);
+
+  // Per-plugin rollup: what does each plugin cost per request, and through
+  // which entries? This is the context-budget view: sort by tokens, and the
+  // top rows are the plugins silently taxing every request.
+  const byOwner = new Map();
+  const add = (owner, kind, name, tokens) => {
+    const key = owner ?? 'unattributed';
+    if (!byOwner.has(key))
+      byOwner.set(key, { plugin: key, tokens: 0, sections: 0, tools: 0, entries: [] });
+    const row = byOwner.get(key);
+    row.tokens += tokens;
+    row[kind] += 1;
+    row.entries.push({ kind: kind === 'sections' ? 'section' : 'tool', name, tokens });
+  };
+  for (const s of sections) add(sectionOwners[s.name], 'sections', s.name, s.tokens);
+  for (const t of tools) add(toolOwners[t.name], 'tools', t.name, t.tokens);
+  const owners = [...byOwner.values()]
+    .sort((a, b) => b.tokens - a.tokens)
+    .map((row) => ({
+      ...row,
+      share: share(row.tokens),
+      entries: row.entries.sort((a, b) => b.tokens - a.tokens),
+    }));
+
   return {
     totalTokens: total,
     toolTokens,
     sectionTokens,
     toolCount: tools.length,
     sectionCount: sections.length,
-    tools: tools.map((t) => ({ name: t.name, tokens: t.tokens, share: share(t.tokens) })),
-    sections: sections.map((s) => ({ name: s.name, tokens: s.tokens, share: share(s.tokens) })),
+    tools: tools.map((t) => ({
+      name: t.name,
+      tokens: t.tokens,
+      share: share(t.tokens),
+      owner: toolOwners[t.name] ?? null,
+    })),
+    sections: sections.map((s) => ({
+      name: s.name,
+      tokens: s.tokens,
+      share: share(s.tokens),
+      owner: sectionOwners[s.name] ?? null,
+    })),
+    owners,
     promptObservedAt: snap.promptAssembly?.at ?? null,
     capturedAt: snap.capturedAt,
   };

package/lib/panel.js

@@ -40,6 +40,34 @@ const PAGE = `<!doctype html>
 <script>
 const views = ['summary', 'health', 'deps', 'cost', 'shadow'];
 const esc = (s) => String(s ?? '').replace(/[&<>]/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
+const escAttr = (s) => esc(s).replace(/"/g, '&quot;');
+
+// One question per view: what am I looking at, and what does trouble look like?
+const INTRO = {
+  summary: 'Composition at a glance. A non-zero "unhealthy" count means some plugin failed to start — see the health view.',
+  health: 'Plugin lifecycle. "Waiting" plugins declared a dependency that no active plugin provides yet; "unhealthy" fibers failed to start and their features are absent.',
+  deps: 'Who provides and consumes each service. The disable-cascade table answers: if I disable this plugin, which dependents stop working with it?',
+  cost: 'What every LLM request carries before your message: prompt sections + tool schemas, attributed to the plugin that registered each. "By plugin" is each plugin\\'s per-request context tax.',
+  shadow: 'Same-name registrations. A service provided by two plugins means one silently wins — usually intended (an override), occasionally a conflict.',
+};
+
+// Hover glossary: term -> plain-language meaning (native title tooltips).
+const TIPS = {
+  share: 'Percentage of the total estimated context (sections + tool schemas) this row costs on every request',
+  tokens: 'Rough estimate: ~4 characters per token',
+  owner: 'The plugin whose registration put this entry into the context',
+  unattributed: 'Registered before dsh-xray mounted and not reconcilable to a single plugin — mount dsh-xray earlier in the profile to shrink this row',
+  wants: 'Services this plugin declared via inject that are not (yet) provided by any active plugin',
+  fiber: 'One mounted instance of the plugin (a Cordis fiber uid)',
+  state: 'Cordis lifecycle state: ACTIVE is healthy; FAILED means apply() threw',
+  affects: 'Transitive consumers: disabling the provider takes these down with it',
+  providers: 'Every plugin claiming this service name; the last one to load wins silently',
+  registrations: 'How many tools/commands this plugin registered on the shared registries',
+  sections: 'Prompt sections this plugin contributes to the system prompt',
+  tools: 'Tool schemas this plugin registers (each costs context on every request)',
+};
+const th = (h) => '<th' + (TIPS[h] ? ' title="' + escAttr(TIPS[h]) + '"' : '') + '>' + esc(h) + '</th>';
+const intro = (v) => '<p class="muted" style="margin:0 0 10px">' + INTRO[v] + '</p>';
 const nav = document.getElementById('nav');
 const content = document.getElementById('content');
 const status = document.getElementById('status');
@@ -54,7 +82,7 @@ for (const v of views) {
 }
 
 function table(headers, rows) {
-  return '<table><tr>' + headers.map((h) => '<th>' + esc(h) + '</th>').join('') + '</tr>'
+  return '<table><tr>' + headers.map(th).join('') + '</tr>'
     + rows.join('') + '</table>';
 }
 function bar(share) {
@@ -98,24 +126,31 @@ const renderers = {
         + '<h3 style="margin:16px 0 8px">services</h3>' + html;
     }
     if (d.unsatisfied.length) {
-      html = '<p class="warn">' + d.unsatisfied.length + ' unsatisfied inject(s)</p>' + html;
+      html = '<p class="warn" title="' + escAttr(TIPS.wants) + '">' + d.unsatisfied.length + ' unsatisfied inject(s) — these plugins wait forever unless a provider is added</p>' + html;
     }
     return html;
   },
   cost(d) {
     let html = '<p>~' + d.totalTokens + ' tokens: ' + d.toolCount + ' tool schema(s) ~' + d.toolTokens
       + ' + ' + d.sectionCount + ' prompt section(s) ~' + d.sectionTokens + '</p>';
+    if (d.owners && d.owners.length) {
+      html += '<h3 style="margin:12px 0 4px">by plugin</h3>'
+        + table(['plugin', 'sections', 'tools', 'tokens', 'share', ''], d.owners.map((o) =>
+          '<tr><td>' + (o.plugin === 'unattributed' ? '<span class="muted" title="' + escAttr(TIPS.unattributed) + '">unattributed</span>' : esc(o.plugin))
+          + '</td><td class="num">' + o.sections + '</td><td class="num">' + o.tools
+          + '</td><td class="num">~' + o.tokens + '</td><td class="num">' + o.share + '%</td><td>' + bar(o.share) + '</td></tr>'));
+    }
     if (d.sections.length) {
       html += '<h3 style="margin:12px 0 4px">prompt sections</h3>'
-        + table(['section', 'tokens', 'share', ''], d.sections.map((s) =>
-          '<tr><td>' + esc(s.name) + '</td><td class="num">~' + s.tokens + '</td><td class="num">'
+        + table(['section', 'owner', 'tokens', 'share', ''], d.sections.map((s) =>
+          '<tr><td>' + esc(s.name) + '</td><td class="muted">' + esc(s.owner ?? '—') + '</td><td class="num">~' + s.tokens + '</td><td class="num">'
           + s.share + '%</td><td>' + bar(s.share) + '</td></tr>'));
     } else {
       html += '<p class="muted">no prompt assembly observed yet — send one agent message first</p>';
     }
     html += '<h3 style="margin:12px 0 4px">tool schemas</h3>'
-      + table(['tool', 'tokens', 'share', ''], d.tools.map((t) =>
-        '<tr><td>' + esc(t.name) + '</td><td class="num">~' + t.tokens + '</td><td class="num">'
+      + table(['tool', 'owner', 'tokens', 'share', ''], d.tools.map((t) =>
+        '<tr><td>' + esc(t.name) + '</td><td class="muted">' + esc(t.owner ?? '—') + '</td><td class="num">~' + t.tokens + '</td><td class="num">'
         + t.share + '%</td><td>' + bar(t.share) + '</td></tr>'));
     return html;
   },
@@ -140,7 +175,7 @@ async function render() {
     const res = await fetch('/xray/api/' + active);
     if (!res.ok) throw new Error(await res.text());
     const data = await res.json();
-    content.innerHTML = renderers[active](data);
+    content.innerHTML = intro(active) + renderers[active](data);
     status.textContent = '';
   } catch (err) {
     status.innerHTML = '<span class="warn">' + esc(err.message) + '</span>';
@@ -165,9 +200,11 @@ function sendJson(response, code, value) {
 /**
  * Mount the panel routes. `views` supplies fresh data per request:
  * { summary, deps, health, cost, shadow } — each a () => object.
+ * `entry`, when supplied, answers /xray/api/entry?kind=section|tool&name=…
+ * with one entry's live text (computed per request, never persisted).
  * Returns the disposers webServer.register produced.
  */
-function mountPanel(webServer, views) {
+function mountPanel(webServer, views, entry) {
   const disposers = [];
   disposers.push(
     webServer.register({
@@ -207,6 +244,36 @@ function mountPanel(webServer, views) {
       }),
     );
   }
+  if (entry) {
+    disposers.push(
+      webServer.register({
+        kind: 'exact',
+        path: '/xray/api/entry',
+        handler: (request, response) => {
+          if (request.method !== 'GET') {
+            response.writeHead(405, { allow: 'GET' });
+            response.end();
+            return;
+          }
+          const params = new URL(request.url ?? '/', 'http://x').searchParams;
+          const kind = params.get('kind');
+          const name = params.get('name');
+          if ((kind !== 'section' && kind !== 'tool') || !name) {
+            sendJson(response, 400, { error: 'expected ?kind=section|tool&name=<entry name>' });
+            return;
+          }
+          try {
+            const value = entry(kind, name);
+            if (value === null)
+              sendJson(response, 404, { error: `no live ${kind} named "${name}"` });
+            else sendJson(response, 200, value);
+          } catch (err) {
+            sendJson(response, 500, { error: err.message });
+          }
+        },
+      }),
+    );
+  }
   return disposers;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-xray",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "X-ray for your DeepSeek Harness — see what's actually loaded, why, and what it costs you.",
   "repository": {
     "type": "git",
@@ -62,6 +62,7 @@
       "platform": "web",
       "inject": [
         "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-slots",
         "@deepseek-ai/dsh-client-ui-conversation"
       ]