diff --git a/dashboard/src/ui/StateChip.tsx b/dashboard/src/ui/StateChip.tsx
index 782e64fcde..a9ce48ddfc 100644
--- a/dashboard/src/ui/StateChip.tsx
+++ b/dashboard/src/ui/StateChip.tsx
@@ -121,13 +121,6 @@ export const STATE_LAMP: Record<DomainStateKind, string> = {
   unsupported_schema: 'bg-state-unsupported-schema',
 };
 
-/** The lamp utility for a state, for registers that print the state's word
- * beside a swatch without the chip's full chrome. One table, so a register
- * and the chips beneath it cannot disagree about a hue. */
-export function stateLampClass(kind: DomainStateKind): string {
-  return STATE_LAMP[kind] ?? 'bg-state-unsupported-schema';
-}
-
 export function StateChip({
   kind,
   detail,
diff --git a/dashboard/src/ui/archetypes/ExplorerSplit.tsx b/dashboard/src/ui/archetypes/ExplorerSplit.tsx
index e01477bb32..47652bd2c4 100644
--- a/dashboard/src/ui/archetypes/ExplorerSplit.tsx
+++ b/dashboard/src/ui/archetypes/ExplorerSplit.tsx
@@ -197,6 +197,7 @@ export function DataRow({
   selected,
   onSelect,
   onInspect,
+  rowId,
   children,
   className,
   height,
@@ -205,7 +206,22 @@ export function DataRow({
 }: {
   selected?: boolean;
   onSelect?: () => void;
+  /**
+   * Hover inspects; click selects. A workspace whose inspector previews the
+   * row under the pointer (or under keyboard focus) wires it here, and the row
+   * fires it for both pointer movement over it and focus arriving so the
+   * keyboard path reaches exactly what the pointer does.
+   *
+   * Movement, not entry: a list that scrolls under a parked pointer — which is
+   * what the roving arrow keys do — synthesises enter events for whichever row
+   * slides beneath it, and those would steal inspection from the row the
+   * keyboard just focused. The browser fires no move for a scroll.
+   */
   onInspect?: () => void;
+  /** The row's stable identity, stamped as `data-row-id` so a list can find
+   * the row a selection made elsewhere (a scene, the address) refers to and
+   * bring it into view. */
+  rowId?: string;
   children: ReactNode;
   className?: string;
   /**
@@ -224,8 +240,9 @@ export function DataRow({
     <button
       type="button"
       onClick={onSelect}
-      onPointerEnter={onInspect}
+      onPointerMove={onInspect}
       onFocus={onInspect}
+      data-row-id={rowId}
       aria-pressed={selected ?? false}
       style={{ height: height != null ? `${height}px` : 'var(--row-height-data)' }}
       className={cn(
diff --git a/dashboard/src/workspaces/knowledge/FactConstellation.tsx b/dashboard/src/workspaces/knowledge/FactConstellation.tsx
index 2d91111c86..3ca3ebd258 100644
--- a/dashboard/src/workspaces/knowledge/FactConstellation.tsx
+++ b/dashboard/src/workspaces/knowledge/FactConstellation.tsx
@@ -75,7 +75,6 @@ export function FactConstellation({
   onInspect,
   onSelect,
   graphRead,
-  className,
 }: {
   model: ConstellationModel;
   /** The fact the reader is inspecting (hover or focus, sticky until Escape). */
@@ -86,7 +85,6 @@ export function FactConstellation({
   onSelect: (factId: string) => void;
   /** The daemon's own reading of the graph sub-read, printed beside coverage. */
   graphRead: MemoryReadStatusV1 | undefined;
-  className?: string;
 }) {
   const haloId = useId();
   // A satellite under the pointer dims the field to its wiring but has no fact
@@ -98,7 +96,12 @@ export function FactConstellation({
     inspectedFactId == null ? null : (model.nodeIdByFact.get(inspectedFactId) ?? null);
   const selectedNodeId =
     selectedFactId == null ? null : (model.nodeIdByFact.get(selectedFactId) ?? null);
-  const focusNodeId = hoveredNodeId ?? inspectedNodeId;
+  // Inspection dims what it is not wired to; selection does not. A selected
+  // fact is marked by its ring and stays legible in a field drawn at full
+  // strength, so a reader who has chosen one is not left looking at a dimmed
+  // store until they press Escape.
+  const focusNodeId =
+    hoveredNodeId ?? (inspectedNodeId !== selectedNodeId ? inspectedNodeId : null);
   const focusSet = useMemo(() => {
     if (focusNodeId == null) return null;
     const set = new Set<string>([focusNodeId]);
@@ -113,7 +116,7 @@ export function FactConstellation({
 
   return (
     <figure
-      className={cn('td-optic td-grain td-scanlines relative flex min-h-0 flex-col', className)}
+      className="td-optic td-grain td-scanlines relative flex flex-col"
       data-testid="fact-constellation"
     >
       <Corners tone="signal" />
@@ -131,7 +134,7 @@ export function FactConstellation({
         </span>
       </figcaption>
       {empty ? (
-        <div className="relative z-10 flex flex-1 items-center justify-center p-6">
+        <div className="relative z-10 flex min-h-[220px] items-center justify-center p-6">
           <p className="max-w-md text-center text-xs leading-relaxed text-text-muted">
             The memory graph returned no roots to draw
             {model.coverage.completeness === 'complete'
@@ -140,12 +143,17 @@ export function FactConstellation({
           </p>
         </div>
       ) : (
+        // The key sits beside the field from `lg`, in the width the 5:3 drawing
+        // leaves free at the sides of a wider aperture, and beneath it below.
+        // The field is one of two readings of the same rows, and the ledger
+        // under it must stay in view at 1440x900 rather than below the fold.
+        <div className="relative z-10 flex flex-col lg:flex-row lg:items-stretch">
         <svg
           role="img"
           aria-label={description}
           viewBox={`0 0 ${CONSTELLATION_WORLD.width} ${CONSTELLATION_WORLD.height}`}
           preserveAspectRatio="xMidYMid meet"
-          className="relative z-10 block min-h-[240px] w-full flex-1 select-none"
+          className="block h-[clamp(180px,30vh,360px)] w-full select-none lg:min-w-0 lg:flex-1"
           data-testid="fact-constellation-svg"
           onPointerLeave={() => setHoveredNodeId(null)}
         >
@@ -171,6 +179,10 @@ export function FactConstellation({
                 inspected={node.id === focusNodeId}
                 selected={node.id === selectedNodeId}
                 onEnter={() => {
+                  // Movement, not entry, for the same reason the ledger rows
+                  // inspect on move: a field scrolling under a parked pointer
+                  // must not steal inspection from the keyboard.
+                  if (hoveredNodeId === node.id) return;
                   setHoveredNodeId(node.id);
                   if (node.factId != null) onInspect(node.factId);
                 }}
@@ -201,11 +213,12 @@ export function FactConstellation({
               ))}
           </g>
         </svg>
+        <div className="flex flex-wrap items-start justify-between gap-x-6 gap-y-1.5 px-3 pb-2 pt-1 lg:w-44 lg:shrink-0 lg:flex-col lg:justify-start lg:gap-y-3 lg:pt-2">
+          <TrustLegend model={model} />
+          <RelationLegend model={model} />
+        </div>
+        </div>
       )}
-      <div className="relative z-10 flex flex-wrap items-end justify-between gap-x-4 gap-y-2 px-3 pb-2 pt-1">
-        <TrustLegend model={model} />
-        <RelationLegend model={model} />
-      </div>
       <CoverageFooter model={model} graphRead={graphRead} />
     </figure>
   );
@@ -353,7 +366,7 @@ function Body({
       data-fact-id={node.factId ?? undefined}
       data-inspected={inspected || undefined}
       data-selected={selected || undefined}
-      onPointerEnter={onEnter}
+      onPointerMove={onEnter}
       onPointerLeave={onLeave}
       onClick={onClick}
       className={cn(
@@ -454,12 +467,15 @@ function Glyph({
   }
 }
 
+/** The legends run as ruled rows rather than stacked lists: the field is one
+ * of two readings of the same rows and the ledger beneath it has to stay in
+ * view, so the key spends width, of which there is plenty, not height. */
 function TrustLegend({ model }: { model: ConstellationModel }) {
   return (
-    <dl aria-label="Trust bands" className="flex flex-col gap-0.5">
+    <dl aria-label="Trust bands" className="flex flex-wrap items-center gap-x-3 gap-y-1">
       <dt className="td-legend">trust</dt>
       {model.bands.map((band) => (
-        <dd key={band.id} className="flex items-center gap-2 text-3xs text-text-muted">
+        <dd key={band.id} className="flex items-center gap-1.5 text-3xs text-text-muted">
           <span
             aria-hidden
             className={cn(
@@ -493,12 +509,12 @@ function RelationLegend({ model }: { model: ConstellationModel }) {
     );
   }
   return (
-    <dl aria-label="Relations and bodies" className="flex flex-col gap-0.5">
+    <dl aria-label="Relations and bodies" className="flex flex-wrap items-center gap-x-3 gap-y-1">
       <dt className="td-legend">relations · bodies</dt>
       {model.relationKinds.map((kind) => {
         const style = relationStyle(kind);
         return (
-          <dd key={kind} className="flex items-center gap-2 text-3xs text-text-muted">
+          <dd key={kind} className="flex items-center gap-1.5 text-3xs text-text-muted">
             <svg aria-hidden width="22" height="6" viewBox="0 0 22 6" className="shrink-0">
               <line
                 x1="1"
@@ -519,7 +535,7 @@ function RelationLegend({ model }: { model: ConstellationModel }) {
       {satelliteKinds.map((kind) => {
         const glyph = nodeGlyph(kind);
         return (
-          <dd key={kind} className="flex items-center gap-2 text-3xs text-text-muted">
+          <dd key={kind} className="flex items-center gap-1.5 text-3xs text-text-muted">
             <svg aria-hidden width="22" height="10" viewBox="0 0 22 10" className="shrink-0">
               <Glyph
                 shape={glyph.shape}
@@ -569,7 +585,7 @@ function CoverageFooter({
     </span>,
     <span key="relations">
       {coverage.drawnRelations.toLocaleString()} of {coverage.relationCount.toLocaleString()}{' '}
-      relations drawn under a limit of {coverage.relationLimit.toLocaleString()}
+      relations drawn, limit {coverage.relationLimit.toLocaleString()}
     </span>,
   ];
   if (coverage.unavailableFactCandidates > 0) {
diff --git a/dashboard/src/workspaces/knowledge/FactInspector.tsx b/dashboard/src/workspaces/knowledge/FactInspector.tsx
index 2baf6b0d72..ba89366784 100644
--- a/dashboard/src/workspaces/knowledge/FactInspector.tsx
+++ b/dashboard/src/workspaces/knowledge/FactInspector.tsx
@@ -365,7 +365,7 @@ function Provenance({
     typeof metadata === 'object' &&
     Object.keys(metadata as Record<string, unknown>).length > 0;
   return (
-    <dl className="grid grid-cols-[minmax(6rem,8rem)_1fr] gap-x-3 gap-y-1 text-2xs">
+    <dl className="grid grid-cols-[minmax(7rem,9.5rem)_1fr] gap-x-3 gap-y-1 text-2xs">
       <Term label="source label">
         {subject.source_label ?? <span className="text-text-muted">none recorded</span>}
       </Term>
@@ -407,9 +407,14 @@ function Provenance({
       <Term label="updated">{stamp(subject.updated_at)}</Term>
       <Term label="last recalled">{formatMicrosUtc(subject.last_recalled_at, { nullAs: 'never recalled' })}</Term>
       <Term label="projected as of">{stamp(subject.projected_as_of)}</Term>
-      <Term label="retrievals · accesses">
+      <Term label="retrievals">
         <span className="td-value" data-cell="numeric">
-          {subject.retrieval_count?.toLocaleString() ?? '—'} · {subject.access_count?.toLocaleString() ?? '—'}
+          {subject.retrieval_count?.toLocaleString() ?? '—'}
+        </span>
+      </Term>
+      <Term label="accesses">
+        <span className="td-value" data-cell="numeric">
+          {subject.access_count?.toLocaleString() ?? '—'}
         </span>
       </Term>
       <Term label="metadata">
@@ -439,7 +444,9 @@ function stamp(micros: number | null | undefined): ReactNode {
 function Term({ label, children }: { label: string; children: ReactNode }) {
   return (
     <>
-      <dt className="td-legend pt-px">{label}</dt>
+      {/* Legends are nowrap by default; a two-word term in a 24rem inspector
+        * has to be allowed to break rather than run under its value. */}
+      <dt className="td-legend whitespace-normal pt-px leading-snug">{label}</dt>
       <dd className="min-w-0 break-words text-text-secondary">{children}</dd>
     </>
   );
diff --git a/dashboard/src/workspaces/knowledge/FactLedger.tsx b/dashboard/src/workspaces/knowledge/FactLedger.tsx
index 55775091f9..b0c376c1ec 100644
--- a/dashboard/src/workspaces/knowledge/FactLedger.tsx
+++ b/dashboard/src/workspaces/knowledge/FactLedger.tsx
@@ -13,6 +13,7 @@
  * reorders what arrived and the header says what the slice cannot reach.
  */
 import {
+  useEffect,
   useLayoutEffect,
   useMemo,
   useRef,
@@ -52,8 +53,6 @@ export function FactLedger({
   loaded,
   distribution,
   query,
-  sort,
-  onSort,
   storeFactCount,
   factsCoverage,
   selectedFactId,
@@ -61,14 +60,13 @@ export function FactLedger({
   onInspect,
   onSelect,
 }: {
-  /** Already ordered by `sort`. */
+  /** Already ordered by the caller's sort; the sort control sits on the bay's
+   * title bar so the header here spends its height on the slice statement. */
   facts: MemoryFactRowV1[];
   coverageNotice: ReactNode;
   loaded: LoadedTrust | null;
   distribution: TrustDistribution;
   query: string;
-  sort: FactSort;
-  onSort: (sort: FactSort) => void;
   /** The store's own fact total from the overview summary, when it reported one. */
   storeFactCount: number | null;
   factsCoverage: MemoryFactsCoverageV1;
@@ -85,6 +83,30 @@ export function FactLedger({
     summaryProbeRef,
     characterProbeRef,
   );
+  // A selection made on the field or carried in by the address brings its
+  // exact row into view, so the two readings of the same fact stay in step.
+  // The loaded slice is bounded well under the virtualisation threshold, so
+  // the row is in the DOM to be found; a windowed list would need the
+  // virtualizer's own scroll-to-index instead.
+  useEffect(() => {
+    if (selectedFactId == null) return;
+    const root = listRootRef.current;
+    const scroller = root?.parentElement;
+    if (!root || !scroller) return;
+    const row = [...root.querySelectorAll<HTMLElement>('[data-row-id]')].find(
+      (candidate) => candidate.dataset['rowId'] === selectedFactId,
+    );
+    if (!row) return;
+    // Only the ledger's own scroller moves. `scrollIntoView` would also walk
+    // the page scroller and pull the workspace header off the top for a row
+    // that was merely below the ledger's fold.
+    const top = row.offsetTop;
+    const bottom = top + row.offsetHeight;
+    if (top < scroller.scrollTop) scroller.scrollTop = top;
+    else if (bottom > scroller.scrollTop + scroller.clientHeight) {
+      scroller.scrollTop = bottom - scroller.clientHeight;
+    }
+  }, [selectedFactId]);
   // Recall counts have no absolute ceiling, so the rail is scaled to the
   // busiest fact actually on screen. That makes the column a ranking of what
   // is loaded — which is what it is — rather than an implied fraction of some
@@ -123,8 +145,6 @@ export function FactLedger({
                 loaded={loaded}
                 distribution={distribution}
                 query={query}
-                sort={sort}
-                onSort={onSort}
                 storeFactCount={storeFactCount}
                 factsCoverage={factsCoverage}
               />
@@ -161,23 +181,18 @@ export function FactLedger({
  * has no low-trust facts; the store in fact holds twenty-one below 0.75 that
  * this slice never reaches. That is not a detail — it is the difference
  * between "feedback never moves a score" and "you are looking at the top of
- * the list". The same header owns the sort control, because a sort is a
- * reordering of exactly this slice and nothing more.
+ * the list".
  */
 function LedgerHeader({
   loaded,
   distribution,
   query,
-  sort,
-  onSort,
   storeFactCount,
   factsCoverage,
 }: {
   loaded: LoadedTrust;
   distribution: TrustDistribution;
   query: string;
-  sort: FactSort;
-  onSort: (sort: FactSort) => void;
   storeFactCount: number | null;
   factsCoverage: MemoryFactsCoverageV1;
 }) {
@@ -189,30 +204,12 @@ function LedgerHeader({
   const beyond =
     eligible != null && eligible > loaded.total ? eligible - loaded.total : null;
   return (
-    <div className="flex flex-col gap-1 border-b border-edge-subtle px-3 py-2">
-      <div className="flex flex-wrap items-center gap-x-3 gap-y-1">
-        <p className="td-legend">
-          {loaded.total.toLocaleString()} facts loaded · {loaded.measured.toLocaleString()} with
-          trust · {loaded.unavailable.toLocaleString()} unavailable
-          {query ? ` · matching “${query}”` : ''}
-        </p>
-        <span aria-hidden className="td-rule" />
-        <label className="flex items-center gap-2 text-3xs text-text-muted">
-          <span className="td-legend">sort</span>
-          <select
-            aria-label="Sort loaded facts"
-            value={sort}
-            onChange={(event) => onSort(event.target.value as FactSort)}
-            className="min-h-[var(--touch-target-min)] border border-edge-subtle bg-surface-0 px-2 text-2xs text-text-secondary"
-          >
-            {FACT_SORTS.map((option) => (
-              <option key={option} value={option}>
-                {factSortLabel(option)}
-              </option>
-            ))}
-          </select>
-        </label>
-      </div>
+    <div className="flex flex-col gap-0.5 border-b border-edge-subtle px-3 py-1.5">
+      <p className="td-legend">
+        {loaded.total.toLocaleString()} facts loaded · {loaded.measured.toLocaleString()} with
+        trust · {loaded.unavailable.toLocaleString()} unavailable
+        {query ? ` · matching “${query}”` : ''}
+      </p>
       <p className="text-2xs leading-relaxed text-text-muted">
         {measuredRange == null
           ? 'No loaded fact exposes a trust measurement.'
@@ -221,28 +218,53 @@ function LedgerHeader({
             : `Trust ${measuredRange.min.toFixed(2)}–${measuredRange.max.toFixed(2)}, with ${loaded.atMax.toLocaleString()} at exactly ${measuredRange.max.toFixed(2)}.`}
         {measuredRange && unreached != null && unreached > 0
           ? ` The store holds ${unreached.toLocaleString()} further facts below ${measuredRange.min.toFixed(2)} that this slice does not reach.`
-          : ''}
-      </p>
-      {/* Paging is a typed absence, not a control drawn disabled: the route
-        * serves one bounded, trust-ranked slice and no cursor, so the ledger
-        * states the bound and how much of the store lies past it. */}
-      <p
-        className="text-3xs leading-relaxed text-text-muted"
-        data-testid="fact-ledger-bound"
-      >
-        Sorted within this slice only. The read is bounded to the top{' '}
-        {factsCoverage.limit.toLocaleString()} by trust
-        {beyond != null
-          ? ` — ${beyond.toLocaleString()} more ${beyond === 1 ? 'fact lies' : 'facts lie'} beyond it`
-          : eligible == null
-            ? ' — the store did not report how many facts lie beyond it'
-            : ''}
-        ; the memory route serves no page cursor, so paging is unavailable rather than hidden.
+          : ''}{' '}
+        {/* Paging is a typed absence, not a control drawn disabled: the route
+          * serves one bounded, trust-ranked slice and no cursor, so the ledger
+          * states the bound and how much of the store lies past it. */}
+        <span data-testid="fact-ledger-bound">
+          Sorted within this slice only. The read is bounded to the top{' '}
+          {factsCoverage.limit.toLocaleString()} by trust
+          {beyond != null
+            ? ` — ${beyond.toLocaleString()} more ${beyond === 1 ? 'fact lies' : 'facts lie'} beyond it`
+            : eligible == null
+              ? ' — the store did not report how many facts lie beyond it'
+              : ''}
+          ; the memory route serves no page cursor, so paging is unavailable rather than hidden.
+        </span>
       </p>
     </div>
   );
 }
 
+/** The sort control, drawn on the bay's title bar. A sort is a reordering of
+ * exactly the loaded slice, and the header beneath says so. */
+export function FactSortControl({
+  sort,
+  onSort,
+}: {
+  sort: FactSort;
+  onSort: (sort: FactSort) => void;
+}) {
+  return (
+    <label className="flex items-center gap-2 text-3xs text-text-muted">
+      <span className="td-legend">sort</span>
+      <select
+        aria-label="Sort loaded facts"
+        value={sort}
+        onChange={(event) => onSort(event.target.value as FactSort)}
+        className="min-h-[var(--touch-target-min)] max-w-[14rem] border border-edge-subtle bg-surface-0 px-2 text-2xs text-text-secondary"
+      >
+        {FACT_SORTS.map((option) => (
+          <option key={option} value={option}>
+            {factSortLabel(option)}
+          </option>
+        ))}
+      </select>
+    </label>
+  );
+}
+
 /** The column legend, aligned to the row grid below it. Columns that a
  * viewport gives up are withdrawn here at the same breakpoints. */
 function ColumnLegend() {
@@ -303,6 +325,7 @@ function FactRow({
       selected={selected}
       onSelect={onSelect}
       onInspect={onInspect}
+      rowId={fact.fact_id}
       height={FACT_ROW_HEIGHT}
       align="start"
       className={cn(inspected && !selected && 'bg-surface-1')}
diff --git a/dashboard/src/workspaces/knowledge/KnowledgeFacts.dom.test.tsx b/dashboard/src/workspaces/knowledge/KnowledgeFacts.dom.test.tsx
index a5e1571226..47a7d27cca 100644
--- a/dashboard/src/workspaces/knowledge/KnowledgeFacts.dom.test.tsx
+++ b/dashboard/src/workspaces/knowledge/KnowledgeFacts.dom.test.tsx
@@ -20,6 +20,7 @@ import type {
   MemoryHolographicPayloadV1,
 } from '../../contracts/generated.ts';
 import { useScope } from '../../data/scope/store.ts';
+import { useStatusRegistersStore } from '../../data/shell/statusRegisters.ts';
 import { fixtureEnvelope } from '../../test/fixtureEnvelope.ts';
 import { KnowledgePage } from './KnowledgePage.tsx';
 
@@ -33,6 +34,9 @@ vi.mock('../../viz/chart/echarts.ts', async (importOriginal) => ({
 afterEach(() => {
   vi.unstubAllGlobals();
   useScope.getState().selectAllProjects();
+  // Registers are withdrawn on unmount; cleanup runs after this hook in the
+  // setup file, so the store is reset here as well to keep cases independent.
+  useStatusRegistersStore.setState({ owners: new Map() });
 });
 
 function fact(over: Partial<MemoryFactRowV1> & { fact_id: string }): MemoryFactRowV1 {
@@ -264,13 +268,28 @@ function rungState(panel: HTMLElement, rung: string): string | null | undefined
   return panel.querySelector(`[data-ladder-rung="${rung}"]`)?.getAttribute('data-ladder-state');
 }
 
+/** The registers the workspace has posted to the shell strip, keyed by their id tail. */
+function publishedRegisters(): Record<string, { value: string; state: string; detail?: string | undefined }> {
+  const out: Record<string, { value: string; state: string; detail?: string | undefined }> = {};
+  for (const registers of useStatusRegistersStore.getState().owners.values()) {
+    for (const register of registers) {
+      out[register.id.split(':').at(-1) ?? register.id] = {
+        value: register.value,
+        state: register.state,
+        detail: register.detail,
+      };
+    }
+  }
+  return out;
+}
+
 describe('Facts camera: inspect, select, and the address', () => {
   it('previews the bounded row on hover without fetching, and reads the canonical detail on select', async () => {
     const requested = stub();
     renderPage();
     const row = await ledgerRow(/alpha fact content/);
 
-    fireEvent.pointerEnter(row);
+    fireEvent.pointerMove(row);
     expect(inspector().getAttribute('data-fact-id')).toBe('fact-alpha');
     expect(within(inspector()).getByText(/inspecting · hover or focus/)).toBeTruthy();
     expect(within(inspector()).getByText('alpha fact content')).toBeTruthy();
@@ -296,7 +315,7 @@ describe('Facts camera: inspect, select, and the address', () => {
     const body = container.querySelector('[data-node="fact:fact-beta"]');
     expect(body).not.toBeNull();
 
-    fireEvent.pointerEnter(body!);
+    fireEvent.pointerMove(body!);
     expect(inspector().getAttribute('data-fact-id')).toBe('fact-beta');
     expect(body!.getAttribute('data-inspected')).toBe('true');
     // Hover dims the material the body is not wired to: gamma is not drawn
@@ -317,7 +336,7 @@ describe('Facts camera: inspect, select, and the address', () => {
     await userEvent.click(await ledgerRow(/alpha fact content/));
     expect(await within(inspector()).findByText('selected fact')).toBeTruthy();
 
-    fireEvent.pointerEnter(await ledgerRow(/beta fact content/));
+    fireEvent.pointerMove(await ledgerRow(/beta fact content/));
     expect(inspector().getAttribute('data-fact-id')).toBe('fact-beta');
 
     await userEvent.keyboard('{Escape}');
@@ -444,9 +463,9 @@ describe('Facts camera: typed absences', () => {
     const aperture = screen.getByTestId('knowledge-aperture');
     expect(aperture.querySelector('[data-state="error"]')).not.toBeNull();
     expect(aperture.textContent).toMatch(/no constellation is drawn/);
-    const register = screen.getByTestId('knowledge-register');
-    expect(register.querySelector('[data-register="graph"]')?.getAttribute('data-register-state')).toBe('error');
-    expect(register.querySelector('[data-register="facts"]')?.getAttribute('data-register-state')).toBe('ready');
+    await waitFor(() => expect(publishedRegisters()['graph']?.state).toBe('error'));
+    expect(publishedRegisters()['graph']?.detail).toBe('the graph schema changed');
+    expect(publishedRegisters()['memory']?.state).toBe('ready');
   });
 
   it('prints the daemon coverage under the constellation and the sub-read states on the register', async () => {
@@ -456,14 +475,18 @@ describe('Facts camera: typed absences', () => {
     const coverage = screen.getByTestId('fact-constellation-coverage');
     expect(coverage.textContent).toMatch(/graph coverage unknown: fact_universe_bounded/);
     expect(coverage.textContent).toMatch(/2 of 4,128 facts in the store drawn/);
-    expect(coverage.textContent).toMatch(/2 of 2 relations drawn under a limit of 100/);
+    expect(coverage.textContent).toMatch(/2 of 2 relations drawn, limit 100/);
     const svg = screen.getByTestId('fact-constellation-svg');
     expect(svg.getAttribute('aria-label')).toMatch(/2 fact roots/);
     expect(svg.getAttribute('aria-label')).toMatch(/fact ledger beside this field is the exact accessible equivalent/);
-    const register = screen.getByTestId('knowledge-register');
-    expect(register.querySelector('[data-register="graph"]')?.getAttribute('data-register-state')).toBe('partial');
-    expect(register.querySelector('[data-register="status"]')?.getAttribute('data-register-state')).toBe('ready');
-    expect(register.querySelector('[data-register="camera"]')?.textContent).toBe('Facts');
+    await waitFor(() => expect(publishedRegisters()['memory']?.state).toBe('ready'));
+    const registers = publishedRegisters();
+    expect(registers['memory']).toMatchObject({ state: 'ready', detail: '4,128 facts' });
+    expect(registers['graph']).toMatchObject({ state: 'partial', detail: '2 roots · 2 relations' });
+    expect(registers['camera']).toMatchObject({ state: 'identity', value: 'Facts' });
+    expect(Object.keys(registers).sort()).toEqual(['camera', 'graph', 'memory']);
+    // The canonical envelope truth header (coverage, freshness, refresh) is drawn.
+    expect(screen.getByLabelText('Evidence').textContent).toMatch(/coverage/);
   });
 
   it('switches to the Geometry camera from the inspector and keeps the selected fact in the address', async () => {
diff --git a/dashboard/src/workspaces/knowledge/KnowledgePage.tsx b/dashboard/src/workspaces/knowledge/KnowledgePage.tsx
index 09e58a7b3e..7ef0f23653 100644
--- a/dashboard/src/workspaces/knowledge/KnowledgePage.tsx
+++ b/dashboard/src/workspaces/knowledge/KnowledgePage.tsx
@@ -18,6 +18,7 @@ import { formatCount, splitCount } from '../../ui/format.ts';
 import { cn } from '../../ui/cn';
 import { envelopePayload, useEnvelope } from '../../data/query/useEnvelope.ts';
 import { scopeKey, useScope } from '../../data/scope/store.ts';
+import { usePublishStatusRegisters } from '../../data/shell/statusRegisters.ts';
 import {
   type MemoryCategoryCountV1,
   MemoryFactDetailPayloadV1Schema,
@@ -31,15 +32,11 @@ import { MemoryGeometry } from './MemoryGeometry.tsx';
 import { MemoryOplog } from './MemoryOplog.tsx';
 import { FactConstellation } from './FactConstellation.tsx';
 import { FactInspector } from './FactInspector.tsx';
-import { FactLedger, MemoryCoverageNotices } from './FactLedger.tsx';
+import { FactLedger, FactSortControl, MemoryCoverageNotices } from './FactLedger.tsx';
 import { composeConstellation } from './constellation.ts';
 import { useFactsAddress } from './factsAddress.ts';
 import { sortFacts } from './ledger.ts';
-import {
-  KnowledgeRegister,
-  envelopeReading,
-  subReadReading,
-} from './KnowledgeRegister.tsx';
+import { cameraRegister, graphRegister, memoryRegister } from './knowledgeRegisters.ts';
 import {
   KNOWLEDGE_PANEL_ID,
   KnowledgeViewSwitcher,
@@ -76,8 +73,17 @@ const BASE = '/api/plugins/holographic';
  */
 export function KnowledgePage() {
   const [view, selectView] = useKnowledgeView();
+  // The camera position rides the shell's status strip beside the transport
+  // facts, so a linked position can be read off the screen from any camera.
+  usePublishStatusRegisters('knowledge', [cameraRegister(view)]);
   return (
-    <div className="flex h-full min-h-0 flex-col">
+    // Below `lg` the Facts camera is a vertical stack and the column has to be
+    // allowed its natural height: pinned to the viewport it squeezed the
+    // aperture and the ledger to nothing and painted them through the summary
+    // bay beneath. The shell's `main` is the scroll container, so giving the
+    // stack its real height simply makes the page scroll; from `lg` the panes
+    // split the viewport and each owns its overflow again.
+    <div className="flex min-h-full flex-col lg:h-full lg:min-h-0">
       {/* `flex-wrap`, because the note under the camera is prose and the
        * switcher is four 44px targets: held on one row they laid the note
        * past the right edge at 320 CSS px and at 400% zoom. */}
@@ -218,8 +224,17 @@ function KnowledgeFacts({ onOpenGeometry }: { onOpenGeometry: () => void }) {
     unknown: 'memory overview has not answered',
   });
 
+  // The two authorities the plate names on the strip, posted in their own
+  // words: the memory overview envelope and its graph sub-read. The facts and
+  // status sub-reads print their states on the ledger and the store summary,
+  // where the width for a reason exists; the strip has room for a word.
+  usePublishStatusRegisters('knowledge:facts', [
+    memoryRegister(overview.isPending, overview.data),
+    graphRegister(overview.isPending, overview.data),
+  ]);
+
   return (
-    <div className="flex h-full min-h-0 flex-col" data-testid="knowledge-facts">
+    <div className="flex flex-col lg:h-full lg:min-h-0" data-testid="knowledge-facts">
       {overviewEnvelope ? (
         <EnvelopeTruth
           envelope={overviewEnvelope}
@@ -227,16 +242,11 @@ function KnowledgeFacts({ onOpenGeometry }: { onOpenGeometry: () => void }) {
           onRefresh={() => void overview.refetch()}
         />
       ) : null}
-      <KnowledgeRegister
-        memory={envelopeReading(overview.isPending, overview.data)}
-        facts={holographic ? subReadReading(reads?.facts) : envelopeReading(overview.isPending, overview.data)}
-        entities={holographic ? subReadReading(reads?.entities) : envelopeReading(overview.isPending, overview.data)}
-        graph={holographic ? subReadReading(reads?.graph) : envelopeReading(overview.isPending, overview.data)}
-        status={envelopeReading(status.isPending, status.data)}
-        camera="facts"
-      />
-      <div className="flex min-h-0 flex-1 flex-col lg:flex-row">
-        <section aria-label="Facts camera" className="flex min-h-0 min-w-0 flex-1 flex-col">
+      <div className="flex flex-col lg:min-h-0 lg:flex-1 lg:flex-row">
+        <section
+          aria-label="Facts camera"
+          className="flex min-w-0 flex-col lg:min-h-0 lg:flex-1"
+        >
           <ReadSection title="Memory" state={overviewState} chrome="centered">
             {(envelope) => {
               const data = envelope.payload.holographic;
@@ -299,6 +309,7 @@ function KnowledgeFacts({ onOpenGeometry }: { onOpenGeometry: () => void }) {
         <aside
           aria-label="Inspector"
           className="flex w-full shrink-0 flex-col border-t border-edge-subtle bg-surface-1 lg:min-h-0 lg:w-[24rem] lg:overflow-auto lg:border-l lg:border-t-0 xl:w-[26rem]"
+          data-testid="knowledge-inspector-bay"
         >
           {shownFactId ? (
             <FactInspector
@@ -365,7 +376,6 @@ function Aperture({
           onInspect={onInspect}
           onSelect={onSelect}
           graphRead={graphRead}
-          className="min-h-[300px] lg:min-h-[360px]"
         />
       ) : (
         <div className="td-optic relative flex min-h-[200px] flex-col items-center justify-center gap-3 p-6 text-center">
@@ -461,8 +471,6 @@ function LedgerBay({
         loaded={summarizeLoadedTrust(sorted)}
         distribution={trust}
         query={applied}
-        sort={sort}
-        onSort={onSort}
         storeFactCount={data.overview?.facts ?? null}
         factsCoverage={data.facts_coverage}
         selectedFactId={selectedFactId}
@@ -473,15 +481,22 @@ function LedgerBay({
     );
   }
   return (
+    // From `lg` the ledger takes whatever the aperture leaves and scrolls its
+    // rows inside; below `lg` the page scrolls, so the ledger takes a fixed,
+    // readable height of its own rather than a share of a viewport it is no
+    // longer pinned to.
     <section
       aria-label="Fact ledger"
-      className="flex min-h-[var(--pane-min-height)] min-w-0 flex-1 flex-col overflow-hidden"
+      className="flex min-w-0 flex-col overflow-hidden max-lg:h-[30rem] lg:min-h-[var(--pane-min-height)] lg:flex-1"
       onKeyDown={onLedgerKeyDown}
     >
-      <div className="flex h-8 shrink-0 items-center gap-2.5 border-b border-edge-subtle px-3">
+      <div className="flex min-h-[var(--touch-target-min)] shrink-0 flex-wrap items-center gap-x-2.5 gap-y-1 border-b border-edge-subtle px-3">
         <span className="td-title">Fact ledger</span>
         <span aria-hidden className="td-rule" />
-        <span className="text-3xs text-text-muted">exact rows · hover inspects · click or Enter selects</span>
+        <span className="text-3xs text-text-muted max-md:hidden">
+          exact rows · hover inspects · click or Enter selects
+        </span>
+        <FactSortControl sort={sort} onSort={onSort} />
       </div>
       {/* Named, because internal scrolling is licensed for LABELLED regions
         * only, and this is the element that actually scrolls. Empty and refused
@@ -549,7 +564,7 @@ function StoreReadouts({
     <div className="flex flex-wrap items-end gap-4 border-l border-edge-subtle pl-4">
       <Readout
         label="facts"
-        size="lg"
+        size="md"
         value={factCount.value}
         unit={factCount.unit}
         note={summary?.facts != null ? `${summary.facts.toLocaleString()} recorded` : 'not reported'}
diff --git a/dashboard/src/workspaces/knowledge/KnowledgeRegister.tsx b/dashboard/src/workspaces/knowledge/KnowledgeRegister.tsx
deleted file mode 100644
index ac3b6e15ec..0000000000
--- a/dashboard/src/workspaces/knowledge/KnowledgeRegister.tsx
+++ /dev/null
@@ -1,128 +0,0 @@
-/**
- * The Knowledge workspace's own status word: one numbered register per
- * authority the Facts camera reads, each carrying that authority's state and
- * nothing else's.
- *
- * The shell's bottom strip reports the transport (link, feed, source, query).
- * It says nothing about whether the memory store answered, whether the fact
- * rows were bounded, or whether the graph came back partial — and those are
- * independent facts that a reader of this workspace needs side by side. So
- * the workspace carries its own register, in the same grammar as the strip,
- * and the camera position is the last cell so a linked position can be read
- * off the screen.
- */
-import type { ReactNode } from 'react';
-
-import type {
-  DashboardEnvelopeV1,
-  MemoryReadStatusV1,
-} from '../../contracts/generated.ts';
-import type { EnvelopeResult } from '../../data/query/envelope.ts';
-import { cn } from '../../ui/cn';
-import { stateLampClass, type DomainStateKind } from '../../ui/StateChip.tsx';
-import { knowledgeViewLabel, type KnowledgeViewKind } from './KnowledgeViews.tsx';
-
-export interface RegisterReading {
-  state: DomainStateKind;
-  /** The one reason a reader needs that the word cannot hold. */
-  detail?: string | undefined;
-}
-
-/** An envelope read as one register reading: pending, transport, or the
- * daemon's own domain state. */
-export function envelopeReading(
-  pending: boolean,
-  result: EnvelopeResult<unknown> | undefined,
-): RegisterReading {
-  if (pending) return { state: 'loading' };
-  if (!result) return { state: 'unknown', detail: 'has not answered' };
-  if (result.outcome === 'transport') return { state: result.state, detail: result.detail };
-  return { state: result.envelope.domain_state };
-}
-
-/** A memory sub-read (`holographic.reads[...]`) as one register reading. */
-export function subReadReading(read: MemoryReadStatusV1 | undefined): RegisterReading {
-  if (!read) return { state: 'unknown', detail: 'not reported' };
-  return { state: read.state, detail: read.error ?? read.code ?? undefined };
-}
-
-export function KnowledgeRegister({
-  memory,
-  facts,
-  entities,
-  graph,
-  status,
-  camera,
-}: {
-  memory: RegisterReading;
-  facts: RegisterReading;
-  entities: RegisterReading;
-  graph: RegisterReading;
-  status: RegisterReading;
-  camera: KnowledgeViewKind;
-}) {
-  return (
-    <div
-      role="group"
-      aria-label="Knowledge authorities"
-      className="flex min-h-8 shrink-0 flex-wrap items-stretch border-b border-edge-subtle bg-surface-1"
-      data-testid="knowledge-register"
-    >
-      <Cell code="01" label="Memory" reading={memory} />
-      <Cell code="02" label="Facts" reading={facts} />
-      <Cell code="03" label="Entities" reading={entities} />
-      <Cell code="04" label="Graph" reading={graph} />
-      <Cell code="05" label="Status" reading={status} />
-      <div className="flex min-w-0 shrink-0 items-center gap-2 border-r border-edge-subtle px-3">
-        <span aria-hidden className="td-value text-3xs text-text-muted" data-cell="numeric">
-          06
-        </span>
-        <span className="td-legend">Camera</span>
-        <span className="td-value text-2xs uppercase text-accent" data-register="camera">
-          {knowledgeViewLabel(camera)}
-        </span>
-      </div>
-      <span aria-hidden className="flex-1" />
-    </div>
-  );
-}
-
-function Cell({
-  code,
-  label,
-  reading,
-}: {
-  code: string;
-  label: string;
-  reading: RegisterReading;
-}) {
-  const word = reading.state.replaceAll('_', ' ');
-  return (
-    <div
-      className="flex min-w-0 shrink-0 items-center gap-2 border-r border-edge-subtle px-3"
-      data-register={label.toLowerCase()}
-      data-register-state={reading.state}
-    >
-      <span aria-hidden className="td-value text-3xs text-text-muted" data-cell="numeric">
-        {code}
-      </span>
-      <span className="td-legend">{label}</span>
-      <span className="flex min-w-0 items-center gap-1.5">
-        <span aria-hidden className={cn('size-2 shrink-0', stateLampClass(reading.state))} />
-        <Word>{word}</Word>
-        {reading.detail ? (
-          <span
-            className="td-value max-w-48 truncate text-3xs normal-case text-text-muted"
-            title={reading.detail}
-          >
-            {reading.detail}
-          </span>
-        ) : null}
-      </span>
-    </div>
-  );
-}
-
-function Word({ children }: { children: ReactNode }) {
-  return <span className="td-value text-2xs uppercase">{children}</span>;
-}
diff --git a/dashboard/src/workspaces/knowledge/constellation.test.ts b/dashboard/src/workspaces/knowledge/constellation.test.ts
index 123accf663..cd8e996f23 100644
--- a/dashboard/src/workspaces/knowledge/constellation.test.ts
+++ b/dashboard/src/workspaces/knowledge/constellation.test.ts
@@ -208,6 +208,33 @@ describe('composeConstellation', () => {
     );
   });
 
+  it('yields a label whose text would overprint an accepted label to the next candidate', () => {
+    // Forty equally trusted facts in one category sit on one ring, thirteen
+    // world units apart, all wired to one hub: every candidate collides with
+    // its neighbours, so the greedy pass has to space the seven it prints.
+    const nodes: MemoryGraphNodeV1[] = [];
+    const edges: MemoryGraphPayloadV1['edges'] = [];
+    nodes.push({ id: 'entity:hub', kind: 'entity', entity_id: 'hub', label: 'hub' });
+    for (let index = 0; index < 40; index += 1) {
+      nodes.push(factNode(`f${index.toString().padStart(2, '0')}`, { trust_score: 0.9 }));
+      edges.push({ kind: 'mentions', source: `fact:f${index.toString().padStart(2, '0')}`, target: 'entity:hub' });
+    }
+    const model = composeConstellation(graph(nodes, edges));
+    const labelled = model.nodes.filter((node) => node.labelled);
+    expect(labelled.length).toBeGreaterThan(0);
+    expect(labelled.length).toBeLessThanOrEqual(7);
+    for (const a of labelled) {
+      for (const b of labelled) {
+        if (a === b) continue;
+        const sameRow = Math.abs(a.y - b.y) < 13;
+        const sameSideOverlap = a.labelSide === b.labelSide && Math.abs(a.x - b.x) < 200;
+        expect(sameRow && sameSideOverlap).toBe(false);
+      }
+    }
+    // Determinism holds for the label pass as well as the coordinates.
+    expect(composeConstellation(graph(nodes, edges)).nodes.filter((node) => node.labelled)).toEqual(labelled);
+  });
+
   it('counts every trust band, zeroes included, and carries the daemon coverage verbatim', () => {
     const model = composeConstellation(
       graph(
diff --git a/dashboard/src/workspaces/knowledge/constellation.ts b/dashboard/src/workspaces/knowledge/constellation.ts
index 203ec2f61d..b9cb5dd8c6 100644
--- a/dashboard/src/workspaces/knowledge/constellation.ts
+++ b/dashboard/src/workspaces/knowledge/constellation.ts
@@ -161,6 +161,11 @@ export interface ConstellationModel {
 
 /** How many facts carry a printed label. */
 const LABEL_BUDGET = 7;
+/** The footprint one printed label claims, in world units: a 30-character
+ * line of 10.5px mono and a row of it. Two labels closer than this on the
+ * same side would overprint. */
+const LABEL_TEXT_WIDTH = 200;
+const LABEL_ROW_HEIGHT = 13;
 
 /** The trust bands the legend prints, highest first. Edges are inclusive at
  * the lower bound so `0.80` reads in the top band. */
@@ -355,17 +360,36 @@ export function composeConstellation(graph: MemoryGraphPayloadV1): Constellation
     positioned.set(satellite.id, { ...polar(angle, radius), angle, radius });
   }
 
-  // Labels: the budget goes to the most wired facts, ties to the most trusted.
-  const labelOrder = [...factSeeds]
-    .sort(
-      (a, b) =>
-        (degree.get(b.node.id) ?? 0) - (degree.get(a.node.id) ?? 0) ||
-        (b.trust ?? -1) - (a.trust ?? -1) ||
-        a.node.fact_id.localeCompare(b.node.fact_id),
-    )
-    .slice(0, LABEL_BUDGET)
-    .map((seed) => seed.node.id);
-  const labelled = new Set(labelOrder);
+  // Labels: the budget goes to the most wired facts, ties to the most trusted,
+  // and a candidate whose text would sit on top of an accepted label's text
+  // yields its place to the next one down. Greedy and deterministic: the
+  // same graph labels the same bodies.
+  const labelCandidates = [...factSeeds].sort(
+    (a, b) =>
+      (degree.get(b.node.id) ?? 0) - (degree.get(a.node.id) ?? 0) ||
+      (b.trust ?? -1) - (a.trust ?? -1) ||
+      a.node.fact_id.localeCompare(b.node.fact_id),
+  );
+  const accepted: { x: number; y: number; side: 'left' | 'right' }[] = [];
+  const labelled = new Set<string>();
+  for (const seed of labelCandidates) {
+    if (labelled.size >= LABEL_BUDGET) break;
+    const point = positioned.get(seed.node.id);
+    if (!point) continue;
+    const side: 'left' | 'right' = Math.cos(point.angle) >= 0 ? 'right' : 'left';
+    const collides = accepted.some(
+      (other) =>
+        Math.abs(other.y - point.y) < LABEL_ROW_HEIGHT &&
+        (other.side === side
+          ? Math.abs(other.x - point.x) < LABEL_TEXT_WIDTH
+          : side === 'right'
+            ? point.x < other.x && other.x - point.x < LABEL_TEXT_WIDTH
+            : point.x > other.x && point.x - other.x < LABEL_TEXT_WIDTH),
+    );
+    if (collides) continue;
+    accepted.push({ x: point.x, y: point.y, side });
+    labelled.add(seed.node.id);
+  }
 
   const bandCounts = new Map<TrustBandId, number>();
   const nodes: ConstellationNode[] = [];
diff --git a/dashboard/src/workspaces/knowledge/knowledgeRegisters.test.ts b/dashboard/src/workspaces/knowledge/knowledgeRegisters.test.ts
new file mode 100644
index 0000000000..60a544ce6e
--- /dev/null
+++ b/dashboard/src/workspaces/knowledge/knowledgeRegisters.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+
+import type { DashboardEnvelopeV1, MemoryOverviewPayloadV1 } from '../../contracts/generated.ts';
+import { cameraRegister, graphRegister, memoryRegister } from './knowledgeRegisters.ts';
+
+function envelope<T>(payload: T, domainState: DashboardEnvelopeV1<T>['domain_state'] = 'ready'): DashboardEnvelopeV1<T> {
+  return {
+    schema_revision: 1,
+    scope: { project_id: 'p', storage_mode: 'profile_sharded', store_root: '/data' },
+    version: { entity_version: null, graph_version: null },
+    time: { valid_time_micros: null, observation_time_micros: 1 },
+    source_watermark: null,
+    authorization: { outcome: 'authorized' },
+    coverage: {
+      completeness: 'complete',
+      eligible: 1,
+      examined: 1,
+      matched: 1,
+      excluded: 0,
+      omitted: 0,
+      unknown: 0,
+      denominator: 1,
+      unit: 'facts',
+      omission_reasons: [],
+    },
+    freshness: { state: 'fresh', observed_at_micros: 1, watermark: null },
+    domain_state: domainState,
+    legal_actions: [],
+    payload,
+  } as DashboardEnvelopeV1<T>;
+}
+
+function overview(over: Partial<MemoryOverviewPayloadV1['holographic']> = {}): MemoryOverviewPayloadV1 {
+  return {
+    query: '',
+    limit: 100,
+    providers: {},
+    holographic: {
+      path: '/tmp/memory.db',
+      exists: true,
+      error: '',
+      overview: { facts: 4128, entities: 612, categories: [], trust_histogram: [], growth: [] },
+      facts: [],
+      entities: [],
+      graph: {
+        nodes: [],
+        edges: [],
+        coverage: {
+          completeness: 'unknown',
+          eligible: null,
+          examined: null,
+          matched: null,
+          excluded: null,
+          omitted: null,
+          unknown: null,
+          denominator: null,
+          unit: null,
+          omission_reasons: ['fact_universe_bounded'],
+        },
+        fact_universe_count: 4128,
+        fact_candidates_examined: 0,
+        unavailable_fact_candidates: 0,
+        root_count: 28,
+        relation_count: 41,
+        relation_limit: 100,
+      },
+      reads: {
+        facts: { state: 'ready' },
+        entities: { state: 'ready' },
+        graph: { state: 'partial', code: 'graph_coverage_incomplete' },
+      },
+      facts_coverage: { completeness: 'partial', limit: 100 },
+      ...over,
+    },
+  };
+}
+
+describe('knowledge registers', () => {
+  it('reports the overview envelope in its own state with the store total as the qualifier', () => {
+    expect(memoryRegister(true, undefined)).toMatchObject({ label: 'Memory', state: 'loading' });
+    expect(memoryRegister(false, undefined)).toMatchObject({ state: 'unknown' });
+    expect(memoryRegister(false, { outcome: 'transport', state: 'offline' })).toMatchObject({
+      value: 'offline',
+      state: 'offline',
+    });
+    expect(memoryRegister(false, { outcome: 'envelope', envelope: envelope(overview()) })).toMatchObject({
+      value: 'ready',
+      state: 'ready',
+      detail: '4,128 facts',
+    });
+    expect(
+      memoryRegister(false, { outcome: 'envelope', envelope: envelope(overview({ error: 'store locked' }), 'partial') }),
+    ).toMatchObject({ state: 'partial', detail: 'store locked' });
+  });
+
+  it('reports each sub-read in the daemon state and code, never above the envelope that carries it', () => {
+    const served = { outcome: 'envelope', envelope: envelope(overview()) } as const;
+    expect(graphRegister(false, served)).toMatchObject({
+      label: 'Graph',
+      state: 'partial',
+      detail: '28 roots · 41 relations',
+    });
+    const complete = {
+      outcome: 'envelope',
+      envelope: envelope(
+        overview({ reads: { facts: { state: 'ready' }, entities: { state: 'ready' }, graph: { state: 'ready' } } }),
+      ),
+    } as const;
+    expect(graphRegister(false, complete)).toMatchObject({
+      state: 'ready',
+      detail: '28 roots · 41 relations',
+    });
+    expect(graphRegister(false, { outcome: 'transport', state: 'denied' })).toMatchObject({ state: 'denied' });
+    expect(graphRegister(true, undefined)).toMatchObject({ state: 'loading' });
+    const unreported = {
+      outcome: 'envelope',
+      envelope: envelope(overview({ reads: {} })),
+    } as const;
+    expect(graphRegister(false, unreported)).toMatchObject({ state: 'unknown', detail: 'sub-read not reported' });
+  });
+
+  it('reports the camera as an identity, not a source state', () => {
+    expect(cameraRegister('geometry')).toEqual({
+      id: 'knowledge:camera',
+      label: 'Camera',
+      value: 'Geometry',
+      state: 'identity',
+    });
+  });
+});
diff --git a/dashboard/src/workspaces/knowledge/knowledgeRegisters.ts b/dashboard/src/workspaces/knowledge/knowledgeRegisters.ts
new file mode 100644
index 0000000000..d522d51bc0
--- /dev/null
+++ b/dashboard/src/workspaces/knowledge/knowledgeRegisters.ts
@@ -0,0 +1,122 @@
+/**
+ * The registers the Knowledge workspace posts to the shell's status strip:
+ * the memory overview read, its graph sub-read, and the camera position —
+ * the three the plate names beside the transport cells. Each is the
+ * authority's own word plus one qualifier; none is inferred from another,
+ * and one camera's answer never stands in for another's. Pure, so the strip's
+ * wording can be pinned by a test without mounting the page.
+ */
+import type {
+  DashboardEnvelopeV1,
+  MemoryOverviewPayloadV1,
+  MemoryReadStatusV1,
+} from '../../contracts/generated.ts';
+import type { EnvelopeResult } from '../../data/query/envelope.ts';
+import type { StatusRegister } from '../../data/shell/statusRegisters.ts';
+import { knowledgeViewLabel, type KnowledgeViewKind } from './KnowledgeViews.tsx';
+
+const OWNER = 'knowledge';
+
+/** An envelope read as one register: pending, transport, or the daemon's own
+ * domain state with the qualifier the payload supplies. A null payload —
+ * which the envelope ladder reports as a transport outcome — never reaches
+ * `ready`. */
+function envelopeRegister<T>(
+  id: string,
+  label: string,
+  pending: boolean,
+  result: EnvelopeResult<T> | undefined,
+  ready: (envelope: DashboardEnvelopeV1<T>) => string | undefined,
+): StatusRegister {
+  if (pending) return { id, label, value: 'loading', state: 'loading' };
+  if (result === undefined) {
+    return { id, label, value: 'unknown', state: 'unknown', detail: 'no response recorded' };
+  }
+  if (result.outcome === 'transport') {
+    return { id, label, value: result.state, state: result.state, detail: result.detail };
+  }
+  return {
+    id,
+    label,
+    value: result.envelope.domain_state,
+    state: result.envelope.domain_state,
+    detail: ready(result.envelope),
+  };
+}
+
+/** The memory overview envelope: the read every other Facts register hangs off. */
+export function memoryRegister(
+  pending: boolean,
+  result: EnvelopeResult<MemoryOverviewPayloadV1> | undefined,
+): StatusRegister {
+  return envelopeRegister(`${OWNER}:memory`, 'Memory', pending, result, (envelope) => {
+    const holographic = envelope.payload.holographic;
+    if (holographic.error) return holographic.error;
+    const facts = holographic.overview?.facts;
+    return facts == null ? undefined : `${facts.toLocaleString()} facts`;
+  });
+}
+
+/** One of the overview's sub-reads, in the daemon's own state and code. The
+ * sub-read cannot be more available than the envelope that carries it, so a
+ * pending or refused overview is reported here in the same words. */
+function subReadRegister(
+  id: string,
+  label: string,
+  pending: boolean,
+  overview: EnvelopeResult<MemoryOverviewPayloadV1> | undefined,
+  pick: (payload: MemoryOverviewPayloadV1) => MemoryReadStatusV1 | undefined,
+  qualify: (payload: MemoryOverviewPayloadV1) => string,
+): StatusRegister {
+  if (pending || overview === undefined || overview.outcome === 'transport') {
+    return envelopeRegister(id, label, pending, overview, () => undefined);
+  }
+  const payload = overview.envelope.payload;
+  return readRegister(id, label, pick(payload), qualify(payload));
+}
+
+function readRegister(
+  id: string,
+  label: string,
+  read: MemoryReadStatusV1 | undefined,
+  qualifier: string,
+): StatusRegister {
+  if (!read) return { id, label, value: 'unknown', state: 'unknown', detail: 'sub-read not reported' };
+  // The daemon's error sentence outranks the measured qualifier; its code
+  // does not — the aperture's coverage footer prints the code beside the
+  // reasons, and the strip has room for a word and a count.
+  return {
+    id,
+    label,
+    value: read.state,
+    state: read.state,
+    detail: read.error ?? qualifier,
+  };
+}
+
+export function graphRegister(
+  pending: boolean,
+  overview: EnvelopeResult<MemoryOverviewPayloadV1> | undefined,
+): StatusRegister {
+  return subReadRegister(
+    `${OWNER}:graph`,
+    'Graph',
+    pending,
+    overview,
+    (payload) => payload.holographic.reads['graph'],
+    (payload) => {
+      const graph = payload.holographic.graph;
+      return `${graph.root_count.toLocaleString()} roots · ${graph.relation_count.toLocaleString()} relations`;
+    },
+  );
+}
+
+/** The camera position: an identity, not a source state. */
+export function cameraRegister(view: KnowledgeViewKind): StatusRegister {
+  return {
+    id: `${OWNER}:camera`,
+    label: 'Camera',
+    value: knowledgeViewLabel(view),
+    state: 'identity',
+  };
+}
diff --git a/docs/lookbook-prove/knowledge/knowledge_1440_facts_camera_overview.png b/docs/lookbook-prove/knowledge/knowledge_1440_facts_camera_overview.png
new file mode 100644
index 0000000000..6f6d036dd8
Binary files /dev/null and b/docs/lookbook-prove/knowledge/knowledge_1440_facts_camera_overview.png differ
diff --git a/docs/lookbook-prove/knowledge/knowledge_1440_hover_inspects_bounded_row.png b/docs/lookbook-prove/knowledge/knowledge_1440_hover_inspects_bounded_row.png
new file mode 100644
index 0000000000..d00d2dff70
Binary files /dev/null and b/docs/lookbook-prove/knowledge/knowledge_1440_hover_inspects_bounded_row.png differ
diff --git a/docs/lookbook-prove/knowledge/knowledge_real_daemon_1440_selected_fact.png b/docs/lookbook-prove/knowledge/knowledge_real_daemon_1440_selected_fact.png
new file mode 100644
index 0000000000..3f2b577bf6
Binary files /dev/null and b/docs/lookbook-prove/knowledge/knowledge_real_daemon_1440_selected_fact.png differ
diff --git a/docs/lookbook-prove/knowledge/knowledge_real_daemon_trust_audit_inspector.png b/docs/lookbook-prove/knowledge/knowledge_real_daemon_trust_audit_inspector.png
new file mode 100644
index 0000000000..35fd2030a9
Binary files /dev/null and b/docs/lookbook-prove/knowledge/knowledge_real_daemon_trust_audit_inspector.png differ