pi-weave 0.3.7 → 0.3.9

package/src/web/client/trail/trail.ts

@@ -0,0 +1,45 @@
+/** Polling `GET /api/trail`, alongside (not inside) the graph poll in `../workspace.ts`. */
+
+import type { TrailPayload } from "../../shared/wire";
+import type { FetchLike } from "../api";
+import { fetchTrail } from "../api";
+import { POLL_MS } from "../workspace";
+
+export interface TrailPollOptions {
+  fetch: FetchLike;
+  onTrail: (trail: TrailPayload) => void;
+  repeat?: (fn: () => void, ms: number) => () => void;
+}
+
+/**
+ * Poll the trail every {@link POLL_MS}, revalidating on its stamp, and report
+ * only fresh payloads. A failed poll keeps what was there: the trail is an
+ * extra, and a blip must not blank it. Returns `stop`.
+ */
+export function startTrailPoll(opts: TrailPollOptions): () => void {
+  let previous: TrailPayload | null = null;
+  let stopped = false;
+  let polling = false;
+  const poll = async (): Promise<void> => {
+    if (stopped || polling) return;
+    polling = true;
+    try {
+      const result = await fetchTrail(opts.fetch, previous);
+      if (stopped || !result.ok || result.cached) return;
+      previous = result.data;
+      opts.onTrail(result.data);
+    } finally {
+      polling = false;
+    }
+  };
+  const repeat = opts.repeat ?? ((fn, ms) => {
+    const timer = setInterval(fn, ms);
+    return () => clearInterval(timer);
+  });
+  const cancel = repeat(() => void poll(), POLL_MS);
+  void poll();
+  return () => {
+    stopped = true;
+    cancel();
+  };
+}

package/src/web/client/tree/Tree.tsx

@@ -1,5 +1,7 @@
 /** The vault and repository tree column. */
 
+import type { TrailMark } from "../trail/trail.model";
+import { trailRowClass } from "../trail/trail.model";
 import { NOTE_DRAG_TYPE } from "../shell/shell.model";
 import { useLayoutEffect, useRef, useState } from "preact/hooks";
 import { createFolder, deleteFolder, deleteNote, moveNote, renameFolder, renameNote } from "../api";
@@ -46,6 +48,8 @@ export interface TreeProps {
   graph: GraphPayload | null;
   selectedId: string | null;
   recentIds: ReadonlySet<string>;
+  /** Recall-trail glows by row id (`trail/trail.model.ts`). */
+  trail?: ReadonlyMap<string, TrailMark>;
   onSelect: (id: string, newTab?: boolean, keepSidebar?: boolean) => void;
   /**
    * Ask before a mutation that would invalidate an open draft. `false` means
@@ -76,13 +80,13 @@ export function Icon({ name, class: className }: { name: IconName; class?: strin
   );
 }
 
-function Row({ view, recentIds, edit, onEdit, onRename, onSelect, onToggle, onMenu, onDrop }: { view: ReturnType<typeof rowViews>[number]; recentIds: ReadonlySet<string>; edit: string | null; onEdit: (value: string) => void; onRename: (value: string | null) => void; onSelect: (newTab: boolean) => void; onToggle: () => void; onMenu: (x: number, y: number) => void; onDrop: (id: string) => void }) {
+function Row({ view, recentIds, trail, edit, onEdit, onRename, onSelect, onToggle, onMenu, onDrop }: { view: ReturnType<typeof rowViews>[number]; recentIds: ReadonlySet<string>; trail: TrailMark | undefined; edit: string | null; onEdit: (value: string) => void; onRename: (value: string | null) => void; onSelect: (newTab: boolean) => void; onToggle: () => void; onMenu: (x: number, y: number) => void; onDrop: (id: string) => void }) {
   const folder = dropFolder(view.id);
   return (
     <li
       id={view.domId}
       data-row-id={view.id}
-      class={`weave-row weave-row-${view.kind}${view.selected ? " weave-row-on" : ""}${recentIds.has(view.id) ? " weave-row-new" : ""}`}
+      class={`weave-row weave-row-${view.kind}${view.selected ? " weave-row-on" : ""}${recentIds.has(view.id) ? " weave-row-new" : ""}${trailRowClass(trail)}`}
       role="treeitem"
       aria-level={view.level}
       aria-posinset={view.posinset}
@@ -297,7 +301,7 @@ export function Tree(props: TreeProps) {
             setMenu({ id: "vault", label: "Vault", x: event.clientX, y: event.clientY });
           }}
         >
-          {rowViews(rows, props.selectedId, props.now).map((view) => <Row key={view.id} view={view} recentIds={props.recentIds} edit={editing?.id === view.id ? editing.value : null} onEdit={(value) => setEditing((current) => current === null ? null : { ...current, value })} onRename={commitEdit} onSelect={(newTab) => { props.onSelect(view.id, newTab); if (view.hasKids) setState((current) => toggleExpanded(current, view.id)); }} onToggle={() => setState(toggleExpanded(state, view.id))} onMenu={(x, y) => setMenu({ id: view.id, label: view.label, x, y })} onDrop={(dragged) => { const folder = dropFolder(view.id); if (dragged.startsWith("note:") && folder !== undefined) { const target = mutableTreeRow(dragged); if (target !== null && !props.onMutate(affectedNoteSlugs(props.graph, target))) return; void run(moveNote(fetchJson, dragged.slice("note:".length), folder)); } }} />)}
+          {rowViews(rows, props.selectedId, props.now).map((view) => <Row key={view.id} view={view} recentIds={props.recentIds} trail={props.trail?.get(view.id)} edit={editing?.id === view.id ? editing.value : null} onEdit={(value) => setEditing((current) => current === null ? null : { ...current, value })} onRename={commitEdit} onSelect={(newTab) => { props.onSelect(view.id, newTab); if (view.hasKids) setState((current) => toggleExpanded(current, view.id)); }} onToggle={() => setState(toggleExpanded(state, view.id))} onMenu={(x, y) => setMenu({ id: view.id, label: view.label, x, y })} onDrop={(dragged) => { const folder = dropFolder(view.id); if (dragged.startsWith("note:") && folder !== undefined) { const target = mutableTreeRow(dragged); if (target !== null && !props.onMutate(affectedNoteSlugs(props.graph, target))) return; void run(moveNote(fetchJson, dragged.slice("note:".length), folder)); } }} />)}
         </ul>
       ) : <p class="weave-tree-empty">{empty}</p>}
       <p class="weave-tree-count">{rowCountLabel(rows)}</p>

package/src/web/client/tree/tree.model.ts

@@ -49,11 +49,8 @@ export type TreeViewState = TreeState;
 /**
  * The provenance filter cycle: all → human → agent → generated → all.
  *
- * The same order as the TUI's `p` key (`src/pi/viewer/tui/theme.ts`), and
- * declared again here because the client tier may not import `src/pi` and the
- * order is not part of `src/core/view`. That is a real, if small, duplication
- * — so it is one array with a test asserting its contents, rather than an
- * `if/else` chain in two places. If a fourth provenance is ever added, the
+ * The order is not part of `src/core/view`, so it is one array with a test
+ * asserting its contents, rather than an `if/else` chain in two places. If a fourth provenance is ever added, the
  * honest fix is to promote this into `src/core/view` and take it through the
  * door; today it is four literals and a promotion would be ceremony.
  */

package/src/web/server/page.ts

@@ -243,7 +243,7 @@ export function renderPage(opts: RenderPageOptions): RenderedPage {
     "</head>",
     "<body>",
     `<div id="app" data-cwd="${escapeAttr(opts.bootstrap.cwd)}">`,
-    "<noscript>pi-weave needs JavaScript. Use <code>/weave-view tui</code> instead.</noscript>",
+    "<noscript>pi-weave needs JavaScript to show the workspace.</noscript>",
     "</div>",
     `<script type="application/json" id="${escapeAttr(BOOTSTRAP_ELEMENT_ID)}" nonce="${escapeAttr(nonce)}">`,
     jsonScriptBody(opts.bootstrap),

package/src/web/server/routes.ts

@@ -6,6 +6,7 @@
  * | GET    | `/`                      | the HTML shell, with its per-response nonce  |
  * | GET    | `/app.js`                | the committed bundle, `Cache-Control: no-store` |
  * | GET    | `/api/graph`             | {@link GraphPayload}, ETag'd on `stamp`      |
+ * | GET    | `/api/trail`             | {@link TrailPayload}, ETag'd on `stamp`      |
  * | GET    | `/api/note/:slug`        | {@link NotePayload}                          |
  * | POST   | `/api/note/:slug`        | save a note's Markdown body                  |
  * | POST   | `/api/notes`            | create an empty human-authored vault note    |
@@ -15,6 +16,9 @@
  * | POST   | `/api/folder/:path`        | create a vault folder                      |
  * | POST   | `/api/folder/:path/rename` | rename a vault folder                      |
  * | DELETE | `/api/folder/:path`      | delete a vault folder                        |
+ * | GET    | `/api/history/:slug`     | {@link HistoryWirePayload}                   |
+ * | GET    | `/api/history-settings`  | {@link HistorySettingsPayload}               |
+ * | POST   | `/api/history-settings`  | turn note history on or off                  |
  * | GET    | `/api/okf/:rel`          | {@link OkfFilePayload}                       |
  * | GET    | `/api/artifact/:rel`     | sandboxed HTML artifact                     |
  * | GET    | `/api/search?q=`         | {@link SearchPayload}                        |
@@ -49,22 +53,28 @@ import { createReadStream } from "node:fs";
 import { pipeline } from "node:stream/promises";
 import { createVaultBackup } from "./backup";
 import { readFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { WorkspaceSnapshot } from "../../core/cache/workspace";
 import { WorkspaceCache } from "../../core/cache/workspace";
 import { readOkfFileForView } from "../../core/graph/current";
 import type { GraphModel as CoreGraphModel } from "../../core/graph/model";
+import { encodeRevisions, historyEnabled, historyTrimmed, setHistoryEnabled } from "../../core/history";
 import { openNoteInEditor } from "../../core/openInEditor";
+import { recallTrail, type RecallTrail } from "../../core/trail";
 import type { Note } from "../../core/types";
 import type { VaultMutationResult } from "../../core/vault";
-import { addNote, createFolder, deleteFolder, deleteNote, getNote, moveNote, renameFolder, renameNote, resolveHtmlPath, searchNotes, setNoteBody } from "../../core/vault";
+import { addNote, createFolder, deleteFolder, deleteNote, getNote, moveNote, renameFolder, readNoteHistory, renameNote, resolveHtmlPath, searchNotes, setNoteBody } from "../../core/vault";
 import { deriveTagIndex, type TaggedNote } from "../../core/view/links";
 import type {
   GraphPayload,
+  HistoryWirePayload,
+  HistorySettingsPayload,
   NotePayload,
   OkfFilePayload,
   OpenResult,
   SearchPayload,
+  TrailPayload,
   ViewNote,
 } from "../shared/wire";
 import { WIRE_MODEL_OMITTED_KEYS } from "../shared/wire";
@@ -85,6 +95,8 @@ export interface RouteDeps {
   /** Test seam for `POST /api/open`; defaults to the real editor shell-out. */
   openNote?: ((slug: string) => Promise<boolean>) | undefined;
   workspaceState: WorkspaceStateStore;
+  /** The recall trail to serve. Defaults to the process-wide one the tools write. */
+  trail?: RecallTrail | undefined;
 }
 
 const JSON_TYPE = "application/json; charset=utf-8";
@@ -383,6 +395,7 @@ async function route(
   if (method === "GET" && path === "/") return sendShell(deps, res);
   if (method === "GET" && path === "/app.js") return sendBundle(deps, res);
   if (method === "GET" && path === "/api/graph") return sendGraph(deps, req, res);
+  if (method === "GET" && path === "/api/trail") return sendTrail(deps, req, res);
   if (method === "GET" && path === "/api/backup") {
     const backup = await createVaultBackup(deps.vaultRoot);
     try {
@@ -413,6 +426,8 @@ async function route(
     const handled = await routeNote(deps, method, path.slice("/api/note/".length), req, res);
     if (handled) return;
   }
+  if (method === "GET" && path.startsWith("/api/history/")) return sendHistory(deps, path.slice("/api/history/".length), res);
+  if (path === "/api/history-settings" && (method === "GET" || method === "POST")) return historySettings(deps, method, req, res);
   if (method === "GET" && path.startsWith("/api/okf/")) {
     return sendOkf(deps, path.slice("/api/okf/".length), res);
   }
@@ -558,6 +573,29 @@ async function sendGraph(deps: RouteDeps, req: IncomingMessage, res: ServerRespo
   res.end(body);
 }
 
+/**
+ * `GET /api/trail`. The trail is process-wide, so it is filtered to this
+ * server's vault; the stamp is the buffer's own, which moves on every record.
+ */
+function sendTrail(deps: RouteDeps, req: IncomingMessage, res: ServerResponse): void {
+  const snapshot = (deps.trail ?? recallTrail).snapshot();
+  const etag = `"${snapshot.stamp}"`;
+  const conditional = req.headers["if-none-match"];
+  if (matchesEtag(etag, typeof conditional === "string" ? conditional : undefined)) {
+    res.writeHead(304, { ...baseHeaders(), etag, "cache-control": "no-cache" });
+    res.end();
+    return;
+  }
+  const payload: TrailPayload = {
+    stamp: snapshot.stamp,
+    turn: snapshot.turn,
+    events: snapshot.events
+      .filter((event) => resolvePath(event.vault) === resolvePath(deps.vaultRoot))
+      .map(({ vault: _vault, ...event }) => event),
+  };
+  sendJson(res, 200, payload, { etag, "cache-control": "no-cache" });
+}
+
 /**
  * `If-None-Match` matching, weak-comparison style.
  *
@@ -615,11 +653,17 @@ async function routeNote(
       sendJson(res, 400, { error: "expected JSON object" });
       return true;
     }
-    const fields = body as { body?: unknown; name?: unknown; folder?: unknown };
+    const fields = body as { body?: unknown; raw?: unknown; name?: unknown; folder?: unknown };
     // The payload decides, not the suffix: slugs nest, so `archive/rename` is
     // a real note and only `{name}`/`{folder}` mean the action.
     if (typeof fields.body === "string") {
-      sendMutation(res, await setNoteBody(deps.vaultRoot, target, fields.body));
+      // `raw: true` is the editor saying the person changed their own Raw
+      // words; without it the on-disk tail is kept, whatever the body says.
+      if (fields.raw !== undefined && typeof fields.raw !== "boolean") {
+        sendJson(res, 400, { error: "expected raw: boolean" });
+        return true;
+      }
+      sendMutation(res, await setNoteBody(deps.vaultRoot, target, fields.body, new Date(), "human", fields.raw === true ? "replace" : "keep"));
       return true;
     }
     if (action === null) {
@@ -700,6 +744,42 @@ function notePayload(note: Note): NotePayload {
   return { note: view };
 }
 
+/**
+ * Every saved revision of a note. The note's current body is passed in so an
+ * edit made outside pi-weave since the last write shows as the final step.
+ */
+async function sendHistory(deps: RouteDeps, slug: string, res: ServerResponse): Promise<void> {
+  const revisions = await readNoteHistory(deps.vaultRoot, slug);
+  if (revisions === null) {
+    sendJson(res, 404, { error: "no such note" });
+    return;
+  }
+  // Deltas, as on disk: full bodies for every revision would grow with the
+  // square of the note's length.
+  const trimmed = await historyTrimmed(deps.vaultRoot, slug);
+  const payload: HistoryWirePayload = {
+    slug,
+    enabled: await historyEnabled(deps.vaultRoot),
+    trimmed,
+    revisions: encodeRevisions(revisions, trimmed),
+  };
+  sendJson(res, 200, payload, { "cache-control": "no-store" });
+}
+
+async function historySettings(deps: RouteDeps, method: string, req: IncomingMessage, res: ServerResponse): Promise<void> {
+  if (method === "POST") {
+    const body = await readJsonBody(req);
+    const enabled = typeof body === "object" && body !== null ? (body as { enabled?: unknown }).enabled : undefined;
+    if (typeof enabled !== "boolean") {
+      sendJson(res, 400, { error: "expected { enabled: boolean }" });
+      return;
+    }
+    await setHistoryEnabled(deps.vaultRoot, enabled);
+  }
+  const payload: HistorySettingsPayload = { enabled: await historyEnabled(deps.vaultRoot) };
+  sendJson(res, 200, payload, { "cache-control": "no-store" });
+}
+
 async function sendOkf(deps: RouteDeps, rel: string, res: ServerResponse): Promise<void> {
   // Anchored under `<cwd>/.okf` by `readOkfFileForView`, which resolves and
   // then re-checks the prefix — the only correct order.

package/src/web/shared/logo.ts

@@ -4,7 +4,7 @@
  * The web viewer is a single committed bundle behind a strict CSP
  * (img-src 'self' data:), so the brand mark is an inlined 48×48 PNG —
  * the transparent-background spider derived from docs/pi-weave-logo.png —
- * rather than a new static route. Same pattern as the TUI's branding.ts.
+ * rather than a new static route.
  */
 export const LOGO_MARK_MIME = "image/png";
 /** 48×48 transparent PNG, base64 — crisp at 2× for the 18px header mark. */

package/src/web/shared/view.ts

@@ -61,10 +61,9 @@
  * ## Why this is a small list
  *
  * Deliberately not `export * from "../../core/view"`. The barrel pulls in
- * `health.ts` (a TUI surface) and `links.ts`'s tag index (derived server-side
- * into `GraphPayload.tags`), neither of which any browser column consumes
- * today — and each one it pulled in would be a module the purity guard then
- * has to defend forever.
+ * `links.ts`'s tag index (derived server-side into `GraphPayload.tags`),
+ * which no browser column consumes today — and each module it pulled in
+ * would be one the purity guard then has to defend forever.
  *
  * So this is an allowlist, on the same principle as the `npm` column in
  * `tests/web/tiers.test.ts`: the surface the columns actually use, and nothing
@@ -131,6 +130,13 @@ export type { TreeRow, TreeState } from "../../core/view/tree";
  */
 export { formatTreeMeta, relTime } from "../../core/view/time";
 
+/**
+ * The note editor holds only the head of a body; the `## Raw` tail is shown
+ * read-only beneath it and rejoined on save. The vault splits with the same
+ * function, so the editor can never hide text the server would overwrite.
+ */
+export { joinRawOpening, joinRawTail, splitRawOpening, splitRawTail } from "../../core/view/rawTail";
+
 // --- context rail (§1.2, P2) --------------------------------------------------
 
 /** Links, backlinks and the ordered meta block for the selected node. */

package/src/web/shared/wire.ts

@@ -40,7 +40,7 @@
  * contract.
  */
 
-import type { WireGraphModel, WireNoteSearchHit, WireNoteSource, WireViewNote } from "./graph";
+import type { WireGraphModel, WireNoteSearchHit, WireViewNote } from "./graph";
 import type { Point } from "./metrics";
 
 /**
@@ -140,10 +140,83 @@ export interface GraphPayload {
 }
 
 /** `GET /api/note/:slug`. */
+/** How the agent touched a note — see `src/core/trail.ts`. */
+export type WireTrailKind = "searched" | "read" | "wrote";
+
+/** One recall-trail step. `at` is ISO; `slugs` may be empty for a search with no hits. */
+export interface WireTrailEvent {
+  seq: number;
+  turn: number;
+  at: string;
+  kind: WireTrailKind;
+  action: string;
+  slugs: string[];
+  query?: string;
+}
+
+/**
+ * `GET /api/trail` — the notes the agent searched, read and wrote this
+ * session, oldest first, filtered to this workspace's vault. ETag'd on
+ * `stamp`, like the graph, so polling it is a `304` while the agent is idle.
+ */
+export interface TrailPayload {
+  stamp: string;
+  turn: number;
+  events: WireTrailEvent[];
+}
+
 export interface NotePayload {
   note: ViewNote;
 }
 
+/** One saved revision of a note, body included. */
+export interface HistoryRevision {
+  /** ISO-8601 time of the change. */
+  at: string;
+  /** Who made it: `outside` is any editor other than pi-weave. */
+  by: "human" | "agent" | "outside" | "system";
+  /** What kind of change: create, edit, append, raw, finalize, generate, repair, outside, baseline. */
+  op: string;
+  body: string;
+}
+
+/** A history payload as the client works with it: every body rebuilt. */
+export interface HistoryPayload {
+  slug: string;
+  /** Whether new revisions are being recorded. */
+  enabled: boolean;
+  /** Older revisions were dropped to keep the note's history file small. */
+  trimmed: boolean;
+  revisions: HistoryRevision[];
+}
+
+/**
+ * One revision on the wire: a full body, or a delta against the one before
+ * (keep `keep[0]` characters from the start and `keep[1]` from the end, and
+ * put `text` between them). The first revision is always full.
+ */
+export interface HistoryWireRevision {
+  at: string;
+  by: HistoryRevision["by"];
+  op: string;
+  full?: string;
+  keep?: [number, number];
+  text?: string;
+}
+
+/** `GET /api/history/:slug`. Oldest first; the last revision is the note as it is now. */
+export interface HistoryWirePayload {
+  slug: string;
+  enabled: boolean;
+  trimmed: boolean;
+  revisions: HistoryWireRevision[];
+}
+
+/** `GET` and `POST /api/history-settings`. */
+export interface HistorySettingsPayload {
+  enabled: boolean;
+}
+
 /** `GET /api/okf/:rel`. */
 export interface OkfFilePayload {
   /** The requested path, relative to `<cwd>/.okf`. Echoed, never resolved. */

package/src/core/view/health.ts

@@ -1,160 +0,0 @@
-/**
- * healthModel — staleness + link health, derived exclusively from the
- * GraphModel (weave-workspace §3).
- *
- * Zero new server/core fields: everything here is a projection of nodes,
- * edges, and `model.staleness`.
- */
-
-import type { GraphModel, GraphNode } from "../graph/model";
-import { deriveBacklinks } from "./links";
-import { listLabel } from "./tree";
-import type { SelectableRow } from "./types";
-
-export interface HealthRow extends SelectableRow {
-  text: string;
-}
-
-export interface HealthSection {
-  heading: string;
-  rows: HealthRow[];
-}
-
-export interface HealthModel {
-  sections: HealthSection[];
-}
-
-const HEALTH_LIST_CAP = 10;
-
-export function healthModel(model: GraphModel): HealthModel {
-  const byId = new Map<string, GraphNode>();
-  for (const n of model.nodes) byId.set(n.id, n);
-  const sections: HealthSection[] = [];
-
-  // Repository section
-  const repo = byId.get("repository");
-  if (repo) {
-    const rows: HealthRow[] = [];
-    const staleness = model.staleness;
-    if (staleness) {
-      rows.push({ id: "health:repo:state", text: `state: ${staleness.state}` });
-      for (let i = 0; i < staleness.reasons.length; i++) {
-        rows.push({ id: `health:repo:reason:${i}`, text: `  ${staleness.reasons[i]}` });
-      }
-    }
-    if (repo.detail.files) rows.push({ id: "health:repo:files", text: `files: ${repo.detail.files}` });
-    if (repo.detail.languages) rows.push({ id: "health:repo:langs", text: `languages: ${repo.detail.languages}` });
-    let summarized = 0;
-    for (const n of model.nodes) {
-      if (n.kind !== "module") continue;
-      const count = n.detail["summarized files"];
-      if (count) summarized += Number(count);
-    }
-    if (summarized > 0) {
-      rows.push({ id: "health:repo:summarized", text: `summarized files: ${summarized} (run /weave-scan deep)` });
-    }
-    sections.push({ heading: "Repository", rows });
-  }
-
-  // Vault section
-  const vault = byId.get("vault");
-  if (vault) {
-    const rows: HealthRow[] = [];
-    const noteCount = Number(vault.detail.notes ?? "0");
-    rows.push({ id: "health:vault:notes", text: `notes: ${noteCount}` });
-    const prov = countProvenance(model.nodes);
-    rows.push({
-      id: "health:vault:provenance",
-      text: `provenance: ● human ${prov.human} · ◐ agent ${prov.agent} · ○ generated ${prov.generated}`,
-    });
-    if (vault.detail.warning) {
-      rows.push({ id: "health:vault:warning", text: vault.detail.warning });
-    }
-    sections.push({ heading: "Vault", rows });
-  }
-
-  // Link health
-  const backlinks = deriveBacklinks(model.edges);
-  const orphans: GraphNode[] = [];
-  const dangling: { node: GraphNode; count: number }[] = [];
-  for (const n of model.nodes) {
-    if (n.kind !== "note") continue;
-    if (!backlinks.has(n.id)) orphans.push(n);
-    const dl = n.detail["dangling links"];
-    if (dl && Number(dl) > 0) dangling.push({ node: n, count: Number(dl) });
-  }
-  const degree = new Map<string, number>();
-  for (const e of model.edges) {
-    degree.set(e.source, (degree.get(e.source) ?? 0) + 1);
-    degree.set(e.target, (degree.get(e.target) ?? 0) + 1);
-  }
-  const hubs = [...model.nodes]
-    .map((n) => ({ n, d: degree.get(n.id) ?? 0 }))
-    .filter((x) => x.d > 0)
-    .sort((a, b) => b.d - a.d)
-    .slice(0, HEALTH_LIST_CAP);
-
-  const linkRows: HealthRow[] = [];
-  if (orphans.length > 0) {
-    linkRows.push({ id: "health:link:orphans-h", text: `orphans (${orphans.length}):` });
-    const shown = orphans.slice(0, HEALTH_LIST_CAP);
-    for (let i = 0; i < shown.length; i++) {
-      linkRows.push({ id: `health:link:orphan:${shown[i]!.id}`, text: `  ${listLabel(shown[i]!)}`, target: shown[i]!.id });
-    }
-    if (orphans.length > HEALTH_LIST_CAP) {
-      linkRows.push({ id: "health:link:orphan:more", text: `  … and ${orphans.length - HEALTH_LIST_CAP} more` });
-    }
-  } else {
-    linkRows.push({ id: "health:link:orphans-h", text: "orphans: none" });
-  }
-  if (dangling.length > 0) {
-    linkRows.push({ id: "health:link:dangling-h", text: `dangling links (${dangling.length}):` });
-    const shown = dangling.slice(0, HEALTH_LIST_CAP);
-    for (let i = 0; i < shown.length; i++) {
-      linkRows.push({
-        id: `health:link:dangling:${shown[i]!.node.id}`,
-        text: `  ${listLabel(shown[i]!.node)} (${shown[i]!.count})`,
-        target: shown[i]!.node.id,
-      });
-    }
-    if (dangling.length > HEALTH_LIST_CAP) {
-      linkRows.push({ id: "health:link:dangling:more", text: `  … and ${dangling.length - HEALTH_LIST_CAP} more` });
-    }
-    // How many are *repairable* is not knowable from the graph: resolution
-    // needs note bodies and titles, which the model flattens away. Point at
-    // the tool that does know rather than re-deriving a worse answer here.
-    linkRows.push({ id: "health:link:dangling:repair", text: "  repair: weave_note action=links (fix: true to apply)" });
-  }
-  if (hubs.length > 0) {
-    linkRows.push({ id: "health:link:hubs-h", text: `top hubs (by degree):` });
-    for (let i = 0; i < hubs.length; i++) {
-      linkRows.push({
-        id: `health:link:hub:${hubs[i]!.n.id}`,
-        text: `  ${listLabel(hubs[i]!.n)} (${hubs[i]!.d})`,
-        target: hubs[i]!.n.id,
-      });
-    }
-  }
-  sections.push({ heading: "Link health", rows: linkRows });
-
-  return { sections };
-}
-
-export interface ProvenanceCounts {
-  total: number;
-  human: number;
-  agent: number;
-  generated: number;
-  structural: number;
-}
-
-export function countProvenance(nodes: readonly GraphNode[]): ProvenanceCounts {
-  const c: ProvenanceCounts = { total: nodes.length, human: 0, agent: 0, generated: 0, structural: 0 };
-  for (const n of nodes) {
-    if (n.provenance === "human") c.human++;
-    else if (n.provenance === "agent") c.agent++;
-    else if (n.provenance === "generated") c.generated++;
-    else c.structural++;
-  }
-  return c;
-}

package/src/pi/viewer/tui/bodyStore.ts

@@ -1,95 +0,0 @@
-/**
- * BodyStore — shared note/.okf body cache (weave-view-tui-v2 §6, §9.1).
- *
- * Every pane (e.g. two Detail panes reading the same note) shares one fetch
- * per node id. A body load is kicked off once per id, in-flight loads are
- * deduped, and a refresh busts the cache so the next read re-fetches.
- *
- * The store is harness-free (takes injected loaders + an optional
- * onChange callback).
- */
-
-import type { ViewNote } from "../../../core/graph/current";
-
-/** The body loaders a BodyStore is bound to (bound to vault/cwd by run.ts). */
-export interface BodyLoaders {
-  loadNote: (slug: string) => Promise<ViewNote | null>;
-  loadOkf: (rel: string) => Promise<{ path: string; body: string } | null>;
-}
-
-export interface BodyStoreOptions {
-  loaders: BodyLoaders;
-  /** Invoked (no args) when an async load resolves so the owner can re-render. */
-  onChange?: () => void;
-}
-
-/**
- * A cache+dedup keyed by node id. `get` never throws and never double-loads.
- *
- * - `null` body = the node exists but has no loadable body (or it loaded to
- *   null); the pane renders nothing for it.
- * - `undefined` = not yet requested (the pane shows a placeholder and asks the
- *   store to load, mirroring v1's `bodyLinesFor`).
- * - `isLoading(id)` = an in-flight request is outstanding (pane shows "loading").
- */
-export class BodyStore {
-  private readonly loaders: BodyLoaders;
-  private readonly onChange: (() => void) | undefined;
-  private cache = new Map<string, string | null>();
-  private loading = new Set<string>();
-
-  constructor(opts: BodyStoreOptions) {
-    this.loaders = opts.loaders;
-    this.onChange = opts.onChange;
-  }
-
-  /** True when the id is mid-load. */
-  isLoading(id: string): boolean {
-    return this.loading.has(id);
-  }
-
-  /** Cached body for the id, or undefined when not yet requested. */
-  get(id: string): string | null | undefined {
-    return this.cache.get(id);
-  }
-
-  /** True once a body has been requested for the id (cached or failed). */
-  has(id: string): boolean {
-    return this.cache.has(id);
-  }
-
-  /**
-   * Kick off a load for `id` if not already requested/in-flight. Returns true
-   * when a load was started (so the caller can show a placeholder). The load
-   * uses `kind` (note/file) to pick the loader and `ref` (slug/rel path).
-   */
-  load(id: string, kind: "note" | "file", ref: string | undefined): boolean {
-    if (ref === undefined) return false;
-    if (this.cache.has(id) || this.loading.has(id)) return false;
-    this.loading.add(id);
-    if (kind === "note") {
-      void this.loaders
-        .loadNote(ref)
-        .then((note) => this.finish(id, note?.body ?? null))
-        .catch(() => this.finish(id, null));
-    } else {
-      void this.loaders
-        .loadOkf(ref)
-        .then((file) => this.finish(id, file?.body ?? null))
-        .catch(() => this.finish(id, null));
-    }
-    return true;
-  }
-
-  /** Drop all cached bodies and in-flight markers (the `r` refresh). */
-  clear(): void {
-    this.cache.clear();
-    this.loading.clear();
-  }
-
-  private finish(id: string, body: string | null): void {
-    this.cache.set(id, body);
-    this.loading.delete(id);
-    this.onChange?.();
-  }
-}