pi-weave 0.1.7 → 0.1.8

package/src/core/view/cluster.ts

@@ -0,0 +1,262 @@
+/**
+ * clusterAggregate — collapse containment subtrees into their parent node
+ * (weave-workspace §3, §7.4).
+ *
+ * A repository graph is mostly containment: a handful of roots, then modules,
+ * then hundreds or thousands of files. Drawn flat that is a hairball, and
+ * scrolled flat it is a wall. The fix is *graph reduction*, not rendering:
+ * given the model and the set of ids the user has expanded, produce a smaller
+ * graph where every collapsed subtree is represented by the node that contains
+ * it, with the edges that crossed the boundary retargeted onto that node.
+ *
+ * Because it is reduction, it lives in core and is shared: the sigma graph
+ * panel (§7.4) consumes `nodes`/`edges` directly, and the TUI tree can consume
+ * the same `clusters` map for its child counts and provenance rollups. One
+ * implementation, so the two surfaces cannot disagree about what "collapsed"
+ * means.
+ *
+ * ## Relationship to the retired viewer
+ *
+ * The retired `page.ts` had a function of the same name. It computed a
+ * *visibility mask* — every node stayed in the graph and hidden ones were
+ * given `display: none` — and it never rewrote a single edge, so a link from a
+ * hidden file to a visible note simply vanished. Two deliberate changes:
+ *
+ * 1. **Reduction, not masking.** We return the reduced node and edge arrays.
+ *    A renderer should never be handed nodes it is expected to hide, and
+ *    sigma in particular wants a graph it can consume verbatim (§7.1).
+ * 2. **Strict collapse.** The retired `reveal` recursed into *every* child
+ *    cluster regardless of the expand set, gating only leaves — so collapsing
+ *    `src/core` still drew all of its sub-clusters. That contradicts both the
+ *    word "collapse" and {@link treeRows}, which recurses only into expanded
+ *    nodes. Here a collapsed cluster hides its entire subtree, so the TUI tree
+ *    and the web graph answer "what is visible?" identically.
+ *
+ * Retained from the original: containment means `contains` **or**
+ * `anchored-at`; clusters are real model nodes rather than synthetic ones (so
+ * ids stay stable and selection keeps working); and the per-cluster provenance
+ * rollup over all descendants.
+ *
+ * The original's `expandChildren` / `collapseChildren` set builders are *not*
+ * ported. They only existed to walk the model a second time, which
+ * {@link ClusterInfo.descendants} already did, and each is now one expression
+ * on the caller's side:
+ *
+ * ```ts
+ * const under = agg.clusters.get(id)!.descendants.filter((d) => agg.clusters.has(d));
+ * const expandAll = new Set([...expanded, id, ...under]);
+ * const collapse = new Set([...expanded].filter((e) => e !== id && !under.includes(e)));
+ * ```
+ */
+
+import type { EdgeKind, GraphEdge, GraphModel, GraphNode } from "../graph/model";
+import type { NoteSource } from "../types";
+import { graphRoots } from "./tree";
+
+/** The edge kinds that form the nesting hierarchy. Matches `treeRows`. */
+const CONTAINMENT: readonly EdgeKind[] = ["contains", "anchored-at"];
+
+function isContainment(kind: EdgeKind): boolean {
+  return CONTAINMENT.includes(kind);
+}
+
+/** Provenance rollup over a cluster's descendants (the ring / mini-bar source). */
+export interface ProvenanceSplit {
+  human: number;
+  agent: number;
+  generated: number;
+  /** Descendants with no provenance — modules, files, git state, packages. */
+  none: number;
+}
+
+/** What is known about one cluster: any node with at least one containment child. */
+export interface ClusterInfo {
+  /** Direct containment children, de-duplicated, in model edge order. */
+  readonly children: readonly string[];
+  /** Every transitive containment descendant, de-duplicated, depth-first. */
+  readonly descendants: readonly string[];
+  /**
+   * The hidden descendants this cluster is currently standing in for — the
+   * cluster → members direction of the mapping, and what a "12 files" badge
+   * counts.
+   *
+   * Empty unless the cluster is *both* visible and collapsed: an expanded
+   * cluster hides nothing, and a cluster that is itself hidden is already
+   * represented by an ancestor. So `members` partitions {@link
+   * ClusterAggregate.hidden} across the visible clusters, whereas
+   * {@link descendants} overlaps freely between a cluster and its ancestors.
+   */
+  readonly members: readonly string[];
+  /** Provenance counts over {@link descendants} (the cluster itself excluded). */
+  readonly provenance: ProvenanceSplit;
+  /** Whether `expanded` contained this id. */
+  readonly expanded: boolean;
+}
+
+export interface ClusterAggregate {
+  /** The visible nodes, in model order. A subset of `model.nodes`. */
+  nodes: GraphNode[];
+  /**
+   * Edges between visible nodes, in model order. Endpoints inside a collapsed
+   * cluster are retargeted onto that cluster; the resulting duplicates and
+   * self-loops are dropped.
+   */
+  edges: GraphEdge[];
+  /**
+   * Every node with at least one containment child, whether or not it is
+   * visible or expanded — a caller implementing "expand all" filters
+   * `descendants` through this map.
+   */
+  clusters: Map<string, ClusterInfo>;
+  /** Ids not present in {@link nodes}. */
+  hidden: Set<string>;
+  /**
+   * Hidden id → the visible cluster representing it. The member → cluster
+   * direction of the mapping; the inverse of {@link ClusterInfo.members}.
+   */
+  representative: Map<string, string>;
+  /** Containment roots, in model order (always visible). */
+  roots: string[];
+}
+
+/**
+ * Reduce `model` to the subgraph implied by `expanded`.
+ *
+ * A node is visible when every containment ancestor between it and a root is
+ * expanded. Roots are always visible, so an empty `expanded` set yields the
+ * roots alone — the maximally collapsed view.
+ *
+ * Deterministic for a deterministic model: every output is ordered by the
+ * model's own node and edge order, and a node reachable through more than one
+ * parent is attributed to the first one encountered.
+ *
+ * Defensive on malformed input, which core cannot rule out for a hand-written
+ * or partially-rebuilt `.okf` index: containment cycles terminate, and an edge
+ * naming an id that is not in the node set is dropped rather than emitted (a
+ * renderer given an edge to a non-existent node throws).
+ */
+export function clusterAggregate(model: GraphModel, expanded: ReadonlySet<string>): ClusterAggregate {
+  const byId = new Map<string, GraphNode>();
+  for (const n of model.nodes) byId.set(n.id, n);
+
+  const children = indexChildren(model, byId);
+  const roots = graphRoots(model);
+
+  // Visible = reachable from a root without passing through a collapsed node.
+  const visible = new Set<string>();
+  const reveal = (id: string): void => {
+    if (visible.has(id)) return; // also the cycle guard
+    visible.add(id);
+    if (!expanded.has(id)) return;
+    for (const child of children.get(id) ?? []) reveal(child);
+  };
+  for (const r of roots) reveal(r);
+
+  // Descendants, computed once per cluster and reused for members + provenance.
+  const descendantsOf = new Map<string, string[]>();
+  for (const id of children.keys()) descendantsOf.set(id, descendants(id, children));
+
+  // Hidden id → nearest visible ancestor. Visible collapsed clusters are the
+  // only things that can represent anything; walking them in model order and
+  // never overwriting makes multi-parent attribution deterministic.
+  const representative = new Map<string, string>();
+  for (const n of model.nodes) {
+    if (!visible.has(n.id) || expanded.has(n.id)) continue;
+    for (const d of descendantsOf.get(n.id) ?? []) {
+      if (!visible.has(d) && !representative.has(d)) representative.set(d, n.id);
+    }
+  }
+
+  // A containment cycle with no root above it is reachable from nowhere, so it
+  // is neither visible nor represented. Show it: dropping it silently would
+  // lose data the caller has no other way to see.
+  for (const n of model.nodes) {
+    if (!visible.has(n.id) && !representative.has(n.id)) visible.add(n.id);
+  }
+
+  const clusters = new Map<string, ClusterInfo>();
+  for (const [id, kids] of children) {
+    // Populated from `children.keys()` immediately above, so this is total.
+    const desc = descendantsOf.get(id)!;
+    clusters.set(id, {
+      children: kids,
+      descendants: desc,
+      members: desc.filter((d) => representative.get(d) === id),
+      provenance: splitOf(desc, byId),
+      expanded: expanded.has(id),
+    });
+  }
+
+  const hidden = new Set<string>();
+  const nodes: GraphNode[] = [];
+  for (const n of model.nodes) {
+    if (visible.has(n.id)) nodes.push(n);
+    else hidden.add(n.id);
+  }
+
+  return { nodes, edges: rewrite(model.edges, visible, representative), clusters, hidden, representative, roots };
+}
+
+/** Direct containment children per parent, de-duplicated, in model edge order. */
+function indexChildren(model: GraphModel, byId: Map<string, GraphNode>): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  for (const e of model.edges) {
+    if (!isContainment(e.kind)) continue;
+    // An edge to an id that is not a node cannot be collapsed into anything.
+    if (!byId.has(e.source) || !byId.has(e.target)) continue;
+    const list = out.get(e.source);
+    if (list === undefined) out.set(e.source, [e.target]);
+    else if (!list.includes(e.target)) list.push(e.target);
+  }
+  return out;
+}
+
+/** Transitive containment descendants of `id`, depth-first, cycle-safe. */
+function descendants(id: string, children: Map<string, string[]>): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>([id]);
+  const walk = (at: string): void => {
+    for (const child of children.get(at) ?? []) {
+      if (seen.has(child)) continue;
+      seen.add(child);
+      out.push(child);
+      walk(child);
+    }
+  };
+  walk(id);
+  return out;
+}
+
+function splitOf(ids: readonly string[], byId: Map<string, GraphNode>): ProvenanceSplit {
+  const split: ProvenanceSplit = { human: 0, agent: 0, generated: 0, none: 0 };
+  for (const id of ids) {
+    const provenance: NoteSource | null = byId.get(id)?.provenance ?? null;
+    if (provenance === null) split.none++;
+    else split[provenance]++;
+  }
+  return split;
+}
+
+/**
+ * Retarget each edge onto visible endpoints, then drop the self-loops (both
+ * ends fell into the same cluster) and the duplicates (many crossings of the
+ * same boundary collapse to one). Kind is preserved and participates in the
+ * de-duplication, so a `contains` and a `links-to` between the same pair both
+ * survive.
+ */
+function rewrite(edges: readonly GraphEdge[], visible: ReadonlySet<string>, representative: ReadonlyMap<string, string>): GraphEdge[] {
+  const resolve = (id: string): string | undefined => (visible.has(id) ? id : representative.get(id));
+  const out: GraphEdge[] = [];
+  const seen = new Set<string>();
+  for (const e of edges) {
+    const source = resolve(e.source);
+    const target = resolve(e.target);
+    if (source === undefined || target === undefined) continue;
+    if (source === target) continue;
+    const key = `${source}\u0000${target}\u0000${e.kind}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ source, target, kind: e.kind });
+  }
+  return out;
+}

package/src/core/view/detail.ts

@@ -0,0 +1,118 @@
+/**
+ * detailModel — a selected node's meta + links + backlinks (weave-workspace §3).
+ *
+ * The note body is *not* part of this model: it is loaded async by whichever
+ * renderer needs it (`readNoteForView` / `readOkfFileForView`).
+ */
+
+import type { GraphModel, GraphNode, NodeKind } from "../graph/model";
+import type { NoteSource } from "../types";
+import { listLabel } from "./tree";
+import type { SelectableRow } from "./types";
+
+export interface DetailMetaRow extends SelectableRow {
+  label: string;
+  value: string;
+}
+
+export interface DetailLinkRow extends SelectableRow {
+  label: string;
+  kind: NodeKind;
+  provenance: NoteSource | null;
+  /** "link" (outgoing) or "backlink" (incoming). */
+  direction: "link" | "backlink";
+}
+
+export interface DetailModel {
+  id: string;
+  label: string;
+  kind: NodeKind;
+  provenance: NoteSource | null;
+  meta: DetailMetaRow[];
+  links: DetailLinkRow[];
+  backlinks: DetailLinkRow[];
+}
+
+/** Ordered meta keys shown in the detail header (weave-view-tui-design §5.2). */
+const META_ORDER = [
+  "path",
+  "slug",
+  "source",
+  "updated",
+  "created",
+  "tags",
+  "files",
+  "languages",
+  "branch",
+  "commit",
+  "uncommitted changes",
+  "captured",
+  "manifest",
+  "kind",
+  "url",
+  "summarized files",
+  "summarized by",
+  "summarized at",
+  "summary",
+  "dangling links",
+  "warning",
+  "stale",
+  "preview",
+  "root",
+  "notes",
+  "state",
+] as const;
+
+export function detailModel(model: GraphModel, id: string): DetailModel | null {
+  const byId = new Map<string, GraphNode>();
+  for (const n of model.nodes) byId.set(n.id, n);
+  const node = byId.get(id);
+  if (!node) return null;
+
+  const meta: DetailMetaRow[] = [];
+  for (const key of META_ORDER) {
+    const v = node.detail[key];
+    if (v === undefined || v === "") continue;
+    meta.push({ id: `meta:${key}`, label: key, value: v });
+  }
+
+  const links: DetailLinkRow[] = [];
+  for (const e of model.edges) {
+    if (e.source !== id) continue;
+    const t = byId.get(e.target);
+    if (!t) continue;
+    links.push({
+      id: `link:${e.kind}:${e.target}`,
+      target: e.target,
+      label: `${e.kind} → ${listLabel(t)}`,
+      kind: t.kind,
+      provenance: t.provenance,
+      direction: "link",
+    });
+  }
+
+  const backlinks: DetailLinkRow[] = [];
+  for (const e of model.edges) {
+    if (e.kind !== "links-to" || e.target !== id) continue;
+    const s = byId.get(e.source);
+    if (!s) continue;
+    backlinks.push({
+      id: `backlink:${e.source}`,
+      target: e.source,
+      label: `← ${listLabel(s)}`,
+      kind: s.kind,
+      provenance: s.provenance,
+      direction: "backlink",
+    });
+  }
+
+  return {
+    id,
+    label: listLabel(node),
+    kind: node.kind,
+    provenance: node.provenance,
+    meta,
+    links,
+    backlinks,
+  };
+}

package/src/core/view/focus.ts

@@ -0,0 +1,109 @@
+/**
+ * focusModel — the 1-hop neighborhood of a node, grouped (weave-workspace §3).
+ *
+ * The TUI renders this as the Focus surface; the browser workspace uses
+ * `focusNeighborhood` for the graph's neighborhood highlight.
+ */
+
+import type { GraphEdge, GraphModel, GraphNode, NodeKind } from "../graph/model";
+import type { NoteSource } from "../types";
+import { listLabel } from "./tree";
+import type { SelectableRow } from "./types";
+
+/** 1-hop neighborhood of `id` (the node itself + direct neighbors). 2-hop excluded. */
+export function focusNeighborhood(id: string, edges: readonly GraphEdge[]): Set<string> {
+  const out = new Set<string>([id]);
+  for (const e of edges) {
+    if (e.source === id) out.add(e.target);
+    if (e.target === id) out.add(e.source);
+  }
+  return out;
+}
+
+/** Incident-edge degree (both directions, all kinds). */
+export function degreeOf(id: string, edges: readonly GraphEdge[]): number {
+  let d = 0;
+  for (const e of edges) if (e.source === id || e.target === id) d++;
+  return d;
+}
+
+export interface FocusRow extends SelectableRow {
+  label: string;
+  kind: NodeKind;
+  provenance: NoteSource | null;
+}
+
+export interface FocusGroup {
+  /** Heading label, e.g. "links to →", "← linked from", "contains", "contained by". */
+  heading: string;
+  rows: FocusRow[];
+}
+
+export interface FocusModel {
+  center: FocusRow;
+  groups: FocusGroup[];
+}
+
+/** The outgoing edge kinds that get their own group, in display order. */
+const OUTGOING_KINDS = ["links-to", "contains", "anchored-at"] as const;
+
+const OUTGOING_HEADINGS: Record<(typeof OUTGOING_KINDS)[number], string> = {
+  "links-to": "links to →",
+  contains: "contains",
+  "anchored-at": "anchored at",
+};
+
+/** Group the 1-hop neighborhood of `id` (outgoing by kind, then incoming). */
+export function focusModel(model: GraphModel, id: string): FocusModel {
+  const byId = new Map<string, GraphNode>();
+  for (const n of model.nodes) byId.set(n.id, n);
+
+  const centerNode = byId.get(id);
+  const center: FocusRow = centerNode
+    ? rowFromNode(centerNode)
+    : { id, label: id, kind: "note", provenance: null };
+
+  const outByKind = new Map<string, string[]>();
+  const incomingContains = new Map<string, string[]>();
+  const backlinks = new Map<string, string[]>();
+  for (const e of model.edges) {
+    if (e.source === id) {
+      const list = outByKind.get(e.kind);
+      if (list) list.push(e.target);
+      else outByKind.set(e.kind, [e.target]);
+    } else if (e.target === id) {
+      if (e.kind === "links-to") {
+        const list = backlinks.get(e.kind);
+        if (list) list.push(e.source);
+        else backlinks.set(e.kind, [e.source]);
+      } else if (e.kind === "contains" || e.kind === "anchored-at") {
+        const list = incomingContains.get(e.kind);
+        if (list) list.push(e.source);
+        else incomingContains.set(e.kind, [e.source]);
+      }
+    }
+  }
+
+  const toRows = (ids: string[]): FocusRow[] =>
+    ids
+      .map((x) => byId.get(x))
+      .filter((n): n is GraphNode => n !== undefined)
+      .map(rowFromNode);
+
+  const groups: FocusGroup[] = [];
+  for (const kind of OUTGOING_KINDS) {
+    const ids = outByKind.get(kind) ?? [];
+    if (ids.length === 0) continue;
+    groups.push({ heading: OUTGOING_HEADINGS[kind], rows: toRows(ids) });
+  }
+  const bl = backlinks.get("links-to") ?? [];
+  if (bl.length > 0) groups.push({ heading: "← linked from", rows: toRows(bl) });
+  const containedBy = incomingContains.get("contains") ?? incomingContains.get("anchored-at") ?? [];
+  if (containedBy.length > 0) groups.push({ heading: "contained by", rows: toRows(containedBy) });
+
+  return { center, groups };
+}
+
+function rowFromNode(n: GraphNode): FocusRow {
+  return { id: n.id, target: n.id, label: listLabel(n), kind: n.kind, provenance: n.provenance };
+}

package/src/core/view/health.ts

@@ -0,0 +1,156 @@
+/**
+ * healthModel — staleness + link health, derived exclusively from the
+ * GraphModel (weave-view-tui-design §5.4 / 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` });
+    }
+  }
+  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/core/view/index.ts

@@ -0,0 +1,15 @@
+/**
+ * src/core/view — portable, renderer-agnostic view-models (weave-workspace §3).
+ *
+ * One implementation of the tree, detail, focus, and health projections, shared
+ * by the pi TUI and the browser workspace so they can never drift. Pure
+ * functions over `GraphModel`; no harness, no DOM, no terminal concepts.
+ */
+export * from "./types";
+export * from "./time";
+export * from "./tree";
+export * from "./detail";
+export * from "./focus";
+export * from "./links";
+export * from "./health";
+export * from "./cluster";