ltcai 2.2.2 → 3.0.1

package/static/v3/js/views/home.js

@@ -0,0 +1,119 @@
+/* ============================================================================
+ * View: Home — the workspace command center.
+ * Leads with the product identity (the retrieval lattice: Knowledge Graph +
+ * Vector Index + Hybrid Search) and routes into every primary area.
+ *
+ * View contract (shared by all views):
+ *   export async function render(ctx) -> single DOM node
+ *   ctx = { h, icon, api, store, c, route, params, navigate, toast }
+ * ========================================================================== */
+
+export async function render(ctx) {
+  const { h, icon, api, store, c, navigate } = ctx;
+  const ws = store.activeWorkspace();
+
+  const root = h("div.lt3-stack-6",
+    c.viewHeader({
+      eyebrow: "Local-first AI workspace",
+      title: `Welcome to ${ws.name}`,
+      sub: "Everything you index stays on this machine. Ask questions, explore the graph, and fuse structure with semantics — no data leaves your computer.",
+      actions: [
+        h("button.lt3-btn.lt3-btn--ghost", { on: { click: () => navigate("hybrid-search") } }, icon("arrows-join"), "Hybrid search"),
+        h("button.lt3-btn.lt3-btn--primary", { on: { click: () => navigate("chat", { new: "1" }) } }, icon("message-plus"), "New chat"),
+      ],
+    }),
+    buildHero(ctx),
+    h("section",
+      c.sectionHead("Retrieval lattice", h("span", { id: "home-idx-src" }, c.sourceBadge("pending"))),
+      h("div", { id: "home-pillars" }, c.loading({ lines: 2, block: true })),
+    ),
+    h("section",
+      c.sectionHead("Jump back in"),
+      buildQuickGrid(ctx),
+    ),
+    h("div.lt3-grid-2",
+      c.panel({ eyebrow: "Index", title: "Connected sources", children: h("div", { id: "home-sources" }, c.loading({ lines: 3 })) }),
+      c.panel({ eyebrow: "Workspace", title: "At a glance", children: h("div", { id: "home-stats" }, c.loading({ lines: 3 })) }),
+    ),
+  );
+
+  hydrate(ctx, root);
+  return root;
+}
+
+function buildHero({ h, icon, navigate }) {
+  return h("div.lt3-hero",
+    h("div.lt3-eyebrow.lt3-hero__eyebrow", icon("sparkles"), "Knowledge Graph · Vector Index · Hybrid Search"),
+    h("h2.lt3-hero__title", "One workspace. Three ways to recall everything."),
+    h("p.lt3-hero__sub", "Lattice builds a knowledge graph and a vector field from your files, then fuses them so every answer is grounded in both structure and meaning."),
+    h("div.lt3-hero__actions",
+      h("button.lt3-btn.lt3-btn--primary.lt3-btn--lg", { on: { click: () => navigate("knowledge-graph") } }, icon("chart-dots-3"), "Explore the graph"),
+      h("button.lt3-btn.lt3-btn--ghost.lt3-btn--lg", { on: { click: () => navigate("files") } }, icon("folder-plus"), "Connect files"),
+    ),
+  );
+}
+
+const QUICK = [
+  { key: "knowledge-graph", icon: "chart-dots-3", title: "Knowledge Graph", desc: "Browse entities and relations." },
+  { key: "hybrid-search", icon: "arrows-join", title: "Hybrid Search", desc: "Fuse graph + vector recall." },
+  { key: "chat", icon: "message-2", title: "Chat", desc: "Grounded conversation." },
+  { key: "files", icon: "folders", title: "Files", desc: "Sources and indexing." },
+  { key: "pipeline", icon: "git-branch", title: "Pipeline", desc: "Ingest and embed flows." },
+  { key: "models", icon: "cpu", title: "Models", desc: "Local MLX runtime." },
+];
+
+function buildQuickGrid({ h, icon, navigate }) {
+  return h("div.lt3-quickgrid",
+    QUICK.map((q) => h("button.lt3-quick", { style: { "text-align": "left" }, on: { click: () => navigate(q.key) } },
+      h("div.lt3-quick__icon", icon(q.icon)),
+      h("div.lt3-quick__title", q.title),
+      h("div.lt3-quick__desc", q.desc),
+    )),
+  );
+}
+
+async function hydrate(ctx, root) {
+  const { h, icon, api, store, c } = ctx;
+  const numFmt = c.fmtNum;
+
+  // Index status → pillars + sources + topbar chip.
+  const idx = store.get().indexStatus
+    ? { data: store.get().indexStatus, source: "live" }
+    : await api.indexStatus().then((r) => { store.setIndexStatus(r.data); return r; });
+
+  root.querySelector("#home-idx-src")?.replaceChildren(c.sourceBadge(idx.source));
+  root.querySelector("#home-pillars")?.replaceChildren(c.pillars(idx.data));
+
+  const sources = (idx.data && idx.data.sources) || [];
+  const srcHost = root.querySelector("#home-sources");
+  if (srcHost) {
+    srcHost.replaceChildren(
+      sources.length
+        ? h("div.lt3-stack-3", sources.map((s) => h("div.lt3-stack-2",
+            h("div.lt3-row", { style: { "justify-content": "space-between" } },
+              h("div.lt3-row-2", icon("database"), h("b", { style: { "font-size": "var(--lt3-text-sm)" } }, s.label)),
+              c.statePill(s.state),
+            ),
+            c.meter(s.progress ?? (s.state === "indexed" ? 1 : 0.5), s.state === "indexing" ? "warn" : "vector"),
+            h("div.lt3-faint", { style: { "font-size": "var(--lt3-text-2xs)" } }, `${numFmt(s.files)} files`),
+          )))
+        : c.emptyState({ icon: "database-off", title: "No sources connected", body: "Connect a folder to start indexing." }),
+    );
+  }
+
+  // Workspace counts.
+  const os = await api.workspaceOs();
+  const counts = (os.data && os.data.counts) || {};
+  const statHost = root.querySelector("#home-stats");
+  if (statHost) {
+    statHost.replaceChildren(
+      h("div.lt3-statrow",
+        c.stat({ label: "Memories", value: numFmt(counts.memories), icon: "brain" }),
+        c.stat({ label: "Traces", value: numFmt(counts.traces), icon: "route" }),
+        c.stat({ label: "Workflows", value: numFmt(counts.workflows), icon: "git-branch" }),
+        c.stat({ label: "Skills", value: numFmt(counts.skills), icon: "puzzle" }),
+      ),
+      h("div", { style: { "margin-top": "var(--lt3-space-3)" } }, c.sourceBadge(os.source)),
+    );
+  }
+}

package/static/v3/js/views/hybrid-search.js

@@ -0,0 +1,195 @@
+/* ============================================================================
+ * View: Hybrid Search — the fused-retrieval surface (headline capability).
+ * Runs api.hybridSearch(query, {weights}) and shows, per result, how keyword,
+ * local vector and graph signals combine into the fused score. Missing
+ * endpoints degrade to clearly-badged sample data.
+ * ========================================================================== */
+
+const MODES = [
+  { key: "hybrid", label: "Hybrid" },
+  { key: "vector", label: "Vector" },
+  { key: "graph", label: "Graph" },
+  { key: "keyword", label: "Keyword" },
+];
+
+const MODE_WEIGHTS = {
+  hybrid: { keyword: 0.35, vector: 0.40, graph: 0.25 },
+  vector: { keyword: 0, vector: 1, graph: 0 },
+  graph: { keyword: 0, vector: 0, graph: 1 },
+  keyword: { keyword: 1, vector: 0, graph: 0 },
+};
+
+const EXAMPLES = ["retrieval design", "vector index config", "rank fusion", "graph adjacency"];
+
+const SIGNALS = [
+  { key: "vector", label: "Vector", variant: "vector", icon: "grid-dots", desc: "Local vector similarity from the configured embedding index." },
+  { key: "keyword", label: "Keyword", variant: "", icon: "abc", desc: "Lexical overlap — exact terms and phrases." },
+  { key: "graph", label: "Graph", variant: "graph", icon: "chart-dots-3", desc: "Structural proximity in the knowledge graph." },
+];
+
+export async function render(ctx) {
+  const { h, icon, api, store, c } = ctx;
+
+  const state = { query: "", mode: "hybrid", source: "pending" };
+
+  let activeWeights = MODE_WEIGHTS.hybrid;
+  api.indexStatus().then((r) => { if (r.data) store.setIndexStatus(r.data); });
+
+  const input = h("input", {
+    type: "text", placeholder: "Search your workspace…", "aria-label": "Search query",
+    on: { keydown: (e) => { if (e.key === "Enter") run(input.value); } },
+  });
+  const weightPill = h("span", c.pill(weightLabel(activeWeights), "info"));
+  const srcSlot = h("span", c.sourceBadge("pending"));
+  const resultsHost = h("div.lt3-stack-6", introBlock());
+
+  const seg = h("div.lt3-fusion", { role: "tablist", "aria-label": "Fusion mode" },
+    MODES.map((m) => h("button", {
+      type: "button", role: "tab",
+      dataset: { active: String(m.key === state.mode) },
+      "aria-selected": String(m.key === state.mode),
+      on: { click: () => { state.mode = m.key; syncSeg(); if (state.query) run(state.query); } },
+    }, m.label)),
+  );
+  function syncSeg() {
+    seg.querySelectorAll("button").forEach((b, i) => {
+      const on = MODES[i].key === state.mode;
+      b.dataset.active = String(on); b.setAttribute("aria-selected", String(on));
+    });
+  }
+
+  const root = h("div.lt3-stack-6",
+    c.viewHeader({
+      eyebrow: "Retrieval · fusion",
+      title: "Hybrid Search",
+      sub: "Fuse keyword recall, local vector similarity, and knowledge-graph structure. Each result shows the contributing signals behind its rank.",
+      actions: [srcSlot],
+    }),
+    h("section.lt3-search-hero",
+      h("div.lt3-row-2", { style: { "align-items": "stretch" } },
+        h("div.lt3-search", { style: { flex: "1", height: "46px" } }, icon("search"), input),
+        h("button.lt3-btn.lt3-btn--primary.lt3-btn--lg", { on: { click: () => run(input.value) } }, icon("arrows-join"), "Search"),
+      ),
+      h("div.lt3-row", { style: { "justify-content": "space-between", "flex-wrap": "wrap", gap: "var(--lt3-space-3)" } },
+        seg,
+        h("div.lt3-row-2", h("span.lt3-faint", { style: { "font-size": "var(--lt3-text-2xs)" } }, "Weights"), weightPill),
+      ),
+      h("div.lt3-cluster",
+        h("span.lt3-faint", { style: { "font-size": "var(--lt3-text-2xs)" } }, "Try"),
+        EXAMPLES.map((q) => h("button.lt3-chip", { type: "button", on: { click: () => run(q) } }, icon("search"), q)),
+      ),
+    ),
+    resultsHost,
+  );
+
+  /* ── search flow ───────────────────────────────────────────────────────── */
+  async function run(rawQuery) {
+    const q = String(rawQuery || "").trim();
+    if (!q) { input.focus(); return; }
+    state.query = q;
+    if (input.value !== q) input.value = q;
+    resultsHost.replaceChildren(
+      c.sectionHead(`Results for “${q}”`, srcSlot.cloneNode(true)),
+      c.loading({ lines: 4 }),
+    );
+    activeWeights = MODE_WEIGHTS[state.mode] || MODE_WEIGHTS.hybrid;
+    weightPill.replaceChildren(c.pill(weightLabel(activeWeights), "info"));
+    const res = await api.hybridSearch(q, { weights: activeWeights });
+    if (res.weights) {
+      activeWeights = res.weights;
+      weightPill.replaceChildren(c.pill(weightLabel(activeWeights), "info"));
+    }
+    state.source = res.source;
+    srcSlot.replaceChildren(c.sourceBadge(res.source));
+    renderResults(res);
+  }
+
+  function renderResults(res) {
+    if (!res.ok) {
+      resultsHost.replaceChildren(c.errorState(res.error || "Search failed", () => run(state.query)));
+      return;
+    }
+    const rows = Array.isArray(res.data) ? res.data : [];
+    if (!rows.length) {
+      resultsHost.replaceChildren(
+        c.sectionHead(`No results for “${state.query}”`, c.sourceBadge(res.source)),
+        c.emptyState({ icon: "search-off", title: "Nothing matched", body: "Try broader terms, or switch the fusion mode above." }),
+      );
+      return;
+    }
+    resultsHost.replaceChildren(
+      c.sectionHead(
+        `${rows.length} ${rows.length === 1 ? "result" : "results"}`,
+        c.pill(MODES.find((m) => m.key === state.mode).label, "info"),
+        c.sourceBadge(res.source),
+      ),
+      h("div.lt3-stack-3", rows.map((r) => resultCard(r))),
+    );
+  }
+
+  function resultCard(r) {
+    const score = typeof r.score === "number" ? r.score : (0.5 * (r.vector || 0) + 0.2 * (r.lexical || 0) + 0.3 * (r.graph || 0));
+    return h("article.lt3-result",
+      h("div.lt3-result__top",
+        h("div.lt3-result__title", { style: { flex: "1", "min-width": "0" } }, String(r.title || "Untitled")),
+        c.pill(`${(score).toFixed(2)} score`, "info", { dot: true }),
+      ),
+      h("div.lt3-faint.lt3-mono", { style: { "font-size": "var(--lt3-text-2xs)" } }, String(r.path || "")),
+      r.snippet && h("p.lt3-result__snippet", String(r.snippet)),
+      h("div.lt3-result__scores",
+        scoreBlock("Vector", r.vector, "vector"),
+        scoreBlock("Keyword", r.lexical, ""),
+        scoreBlock("Graph", r.graph, "graph"),
+      ),
+    );
+  }
+
+  function scoreBlock(label, value, variant) {
+    const v = Number(value) || 0;
+    return h("div.lt3-score",
+      h("div.lt3-score__row", h("span", label), h("b", v.toFixed(2))),
+      c.meter(v, variant),
+    );
+  }
+
+  /* ── pre-search intro ──────────────────────────────────────────────────── */
+  function introBlock() {
+    return h("div.lt3-stack-6",
+      c.emptyState({
+        icon: "arrows-join",
+        title: "Search across structure and vector signals",
+        body: "Enter a query above. Results show keyword, local vector, and graph scores before fusion.",
+      }),
+      h("section",
+        c.sectionHead("How fusion scores a match"),
+        h("div.lt3-grid-3",
+          SIGNALS.map((s) => signalCard(s)),
+        ),
+      ),
+    );
+  }
+
+  function signalCard(s) {
+    const tint = s.variant === "vector" ? "var(--lt3-pillar-vector)"
+      : s.variant === "graph" ? "var(--lt3-pillar-graph)"
+      : "var(--accent-3)";
+    return c.card(
+      h("div.lt3-stack-3",
+        h("div.lt3-row-2",
+          h("span.lt3-result__title", { style: { display: "grid", "place-items": "center", width: "32px", height: "32px", "border-radius": "var(--lt3-radius-sm)", background: `color-mix(in srgb, ${tint} 16%, transparent)`, color: tint } }, icon(s.icon)),
+          h("b", s.label),
+        ),
+        h("p.lt3-muted", { style: { "font-size": "var(--lt3-text-sm)" } }, s.desc),
+        c.meter(s.key === "graph" ? 0.85 : s.key === "vector" ? 0.7 : 0.55, s.variant),
+      ),
+      { flat: true },
+    );
+  }
+
+  return root;
+}
+
+function weightLabel(weights) {
+  const w = { ...MODE_WEIGHTS.hybrid, ...(weights || {}) };
+  return `K ${Number(w.keyword || 0).toFixed(2)} · V ${Number(w.vector || 0).toFixed(2)} · G ${Number(w.graph || 0).toFixed(2)}`;
+}

package/static/v3/js/views/knowledge-graph.js

@@ -0,0 +1,238 @@
+/* ============================================================================
+ * View: Knowledge Graph — entity/relation explorer.
+ * Renders the graph as an SVG mesh (integration-ready against /api/graph) with
+ * a live inspector. Falls back to clearly-badged sample data when the backend
+ * graph endpoint isn't available yet.
+ * ========================================================================== */
+
+import { escapeHtml } from "../core/dom.js";
+
+const TYPE_COLOR = {
+  Topic: "var(--lt3-pillar-graph)",
+  Concept: "var(--lt3-pillar-vector)",
+  Method: "var(--lt3-pillar-hybrid)",
+  Model: "var(--accent-3)",
+  File: "var(--faint)",
+  Decision: "var(--accent-3)",
+  Task: "var(--accent-2)",
+  Person: "var(--accent-pink)",
+  default: "var(--accent)",
+};
+const colorFor = (t) => TYPE_COLOR[t] || TYPE_COLOR.default;
+
+export async function render(ctx) {
+  const { h, icon, api, store, c } = ctx;
+
+  const state = { selected: null, query: "", data: { nodes: [], edges: [] }, source: "pending" };
+
+  const canvasHost = h("div", c.loading({ lines: 0, block: true }));
+  const inspectorHost = h("div", c.loading({ lines: 4 }));
+  const statHost = h("div.lt3-statrow", c.loading({ lines: 1 }));
+  const srcSlot = h("span", c.sourceBadge("pending"));
+
+  const root = h("div.lt3-stack-6",
+    c.viewHeader({
+      eyebrow: "Retrieval · structure",
+      title: "Knowledge Graph",
+      sub: "Entities and the relations the workspace extracted between them. Click a node to trace its neighborhood.",
+      actions: [
+        srcSlot,
+        h("button.lt3-btn.lt3-btn--ghost", { on: { click: () => load() } }, icon("refresh"), "Rebuild view"),
+        h("button.lt3-btn.lt3-btn--primary", { on: { click: () => ctx.navigate("hybrid-search") } }, icon("arrows-join"), "Search graph"),
+      ],
+    }),
+    statHost,
+    h("div.lt3-split",
+      h("div.lt3-stack-3",
+        c.card(canvasHost, { attrs: { style: "padding:0;overflow:hidden" } }),
+        buildLegend(ctx),
+      ),
+      h("aside.lt3-panel",
+        h("div.lt3-panel__head", h("div", h("div.lt3-eyebrow", "Inspector"), h("h3.lt3-panel__title", "Entities"))),
+        h("div.lt3-search", { style: { "margin-bottom": "var(--lt3-space-4)" } },
+          icon("search"),
+          h("input", { type: "text", placeholder: "Filter entities…", "aria-label": "Filter entities",
+            on: { input: (e) => { state.query = e.target.value.toLowerCase(); renderInspector(); } } }),
+        ),
+        inspectorHost,
+      ),
+    ),
+  );
+
+  async function load() {
+    canvasHost.replaceChildren(c.loading({ lines: 0, block: true }));
+    const [g, stats] = await Promise.all([api.graph(), api.graphStats()]);
+    state.data = normalize(g.data);
+    state.source = g.source;
+    srcSlot.replaceChildren(c.sourceBadge(g.source));
+    renderStats(stats.data, g.data);
+    renderCanvas();
+    renderInspector();
+  }
+
+  function renderStats(stats, graphData) {
+    const nodes = state.data.nodes.length;
+    const edges = state.data.edges.length;
+    const types = stats && stats.nodes ? Object.keys(stats.nodes).length : new Set(state.data.nodes.map((n) => n.type)).size;
+    const density = nodes > 1 ? (edges / (nodes * (nodes - 1) / 2)) : 0;
+    statHost.replaceChildren(
+      c.stat({ label: "Entities", value: c.fmtNum(nodes), icon: "circles" }),
+      c.stat({ label: "Relations", value: c.fmtNum(edges), icon: "vector-triangle" }),
+      c.stat({ label: "Entity types", value: types, icon: "category" }),
+      c.stat({ label: "Density", value: density.toFixed(2), icon: "chart-dots" }),
+    );
+  }
+
+  function renderCanvas() {
+    const { nodes, edges } = state.data;
+    if (!nodes.length) { canvasHost.replaceChildren(c.emptyState({ icon: "chart-dots-3", title: "No entities yet", body: "Index a source to populate the graph." })); return; }
+    const laidOut = layout(nodes);
+    const pos = Object.fromEntries(laidOut.map((n) => [n.id, n]));
+    const W = 1000, H = 600;
+    const edgeSvg = edges.map((e) => {
+      const a = pos[e.from], b = pos[e.to];
+      if (!a || !b) return "";
+      return `<line class="lt3-gedge" x1="${a.px}" y1="${a.py}" x2="${b.px}" y2="${b.py}" stroke-width="${1 + (e.weight || 1) * 0.6}"></line>`;
+    }).join("");
+    const nodeSvg = laidOut.map((n) => {
+      const r = 10 + (n.weight || 0.5) * 16;
+      const sel = state.selected === n.id;
+      return `<g class="lt3-gnode" data-id="${escapeHtml(n.id)}" opacity="${state.selected && !sel && !isNeighbor(n.id) ? 0.35 : 1}">
+        <circle cx="${n.px}" cy="${n.py}" r="${sel ? r + 3 : r}" fill="${colorFor(n.type)}" stroke-width="${sel ? 3 : 2}"></circle>
+        <text x="${n.px}" y="${n.py + r + 13}" text-anchor="middle">${escapeHtml(truncate(n.label, 18))}</text>
+      </g>`;
+    }).join("");
+    canvasHost.replaceChildren(
+      h("div.lt3-graph-canvas", {
+        html: `<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Knowledge graph">${edgeSvg}${nodeSvg}</svg>`,
+        on: { click: onCanvasClick },
+      }),
+    );
+  }
+
+  function onCanvasClick(e) {
+    const g = e.target.closest(".lt3-gnode");
+    if (!g) return;
+    state.selected = g.dataset.id === state.selected ? null : g.dataset.id;
+    renderCanvas();
+    renderInspector();
+  }
+
+  function isNeighbor(id) {
+    if (!state.selected) return false;
+    return state.data.edges.some((e) =>
+      (e.from === state.selected && e.to === id) || (e.to === state.selected && e.from === id));
+  }
+
+  function renderInspector() {
+    if (state.selected) { inspectorHost.replaceChildren(detailView()); return; }
+    const q = state.query;
+    const list = state.data.nodes
+      .filter((n) => !q || (n.label || "").toLowerCase().includes(q) || (n.type || "").toLowerCase().includes(q))
+      .sort((a, b) => (b.weight || 0) - (a.weight || 0));
+    inspectorHost.replaceChildren(
+      list.length
+        ? h("div.lt3-stack-2", list.slice(0, 60).map((n) => entityRow(n)))
+        : c.emptyState({ icon: "search-off", title: "No matches", body: "Try a different entity name." }),
+    );
+  }
+
+  function entityRow(n) {
+    return h("button.lt3-entity", { on: { click: () => { state.selected = n.id; renderCanvas(); renderInspector(); } } },
+      h("div.lt3-entity__type", { style: { background: `color-mix(in srgb, ${colorFor(n.type)} 18%, transparent)`, color: colorFor(n.type) } }, icon(iconForType(n.type))),
+      h("div.lt3-entity__body",
+        h("div.lt3-entity__name", n.label),
+        h("div.lt3-entity__meta", `${n.type || "Entity"} · weight ${(n.weight || 0).toFixed(2)}`),
+      ),
+    );
+  }
+
+  function detailView() {
+    const n = state.data.nodes.find((x) => x.id === state.selected);
+    if (!n) { state.selected = null; return c.emptyState({ title: "Not found" }); }
+    const rels = state.data.edges
+      .filter((e) => e.from === n.id || e.to === n.id)
+      .map((e) => {
+        const otherId = e.from === n.id ? e.to : e.from;
+        const other = state.data.nodes.find((x) => x.id === otherId);
+        return { type: e.type, dir: e.from === n.id ? "→" : "←", other };
+      })
+      .filter((r) => r.other);
+    return h("div.lt3-stack-4",
+      h("button.lt3-btn.lt3-btn--subtle.lt3-btn--sm", { on: { click: () => { state.selected = null; renderCanvas(); renderInspector(); } } }, icon("arrow-left"), "All entities"),
+      h("div.lt3-card.lt3-card--flat",
+        h("div.lt3-row-2", { style: { "margin-bottom": "var(--lt3-space-2)" } },
+          h("span.lt3-pill", { style: { color: colorFor(n.type) } }, n.type || "Entity"),
+        ),
+        h("div", { style: { "font-size": "var(--lt3-text-lg)", "font-weight": 700 } }, n.label),
+        n.summary && h("p.lt3-muted", { style: { "font-size": "var(--lt3-text-sm)", "margin-top": "var(--lt3-space-2)" } }, n.summary),
+      ),
+      h("div",
+        h("div.lt3-eyebrow", { style: { "margin-bottom": "var(--lt3-space-2)" } }, `Relations (${rels.length})`),
+        rels.length
+          ? h("div.lt3-stack-2", rels.map((r) => h("button.lt3-entity", { on: { click: () => { state.selected = r.other.id; renderCanvas(); renderInspector(); } } },
+              h("div.lt3-entity__type", { style: { background: "var(--surface-3)" } }, h("span.lt3-mono", { style: { "font-size": "var(--lt3-text-sm)" } }, r.dir)),
+              h("div.lt3-entity__body",
+                h("div.lt3-entity__name", r.other.label),
+                h("div.lt3-entity__meta", r.type),
+              ),
+            )))
+          : c.emptyState({ icon: "unlink", title: "No relations", body: "This entity is currently isolated." }),
+      ),
+    );
+  }
+
+  load();
+  return root;
+}
+
+/* ── helpers ─────────────────────────────────────────────────────────────── */
+function normalize(data) {
+  const nodes = (data.nodes || []).map((n) => ({
+    id: n.id,
+    label: n.label || n.title || n.id,
+    type: n.type || "Entity",
+    weight: n.weight ?? n.importance_norm ?? (n.metadata && n.metadata.graph_metrics && n.metadata.graph_metrics.importance_norm) ?? 0.5,
+    summary: n.summary || "",
+    x: n.x, y: n.y,
+  }));
+  const ids = new Set(nodes.map((n) => n.id));
+  const edges = (data.edges || []).filter((e) => ids.has(e.from) && ids.has(e.to))
+    .map((e) => ({ from: e.from, to: e.to, type: e.type || "related", weight: e.weight || 1 }));
+  return { nodes, edges };
+}
+
+function layout(nodes) {
+  const W = 1000, H = 600, cx = W / 2, cy = H / 2;
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const hasCoords = nodes.length && nodes.every((n) => typeof n.x === "number" && typeof n.y === "number");
+  if (hasCoords) {
+    return nodes.map((n) => ({ ...n, px: Math.round(60 + n.x * (W - 120)), py: Math.round(50 + n.y * (H - 100)) }));
+  }
+  // Sunflower (Vogel) spread — even spacing, highest-weight entity centered.
+  const order = nodes.map((n, i) => ({ n, i })).sort((a, b) => (b.n.weight || 0) - (a.n.weight || 0));
+  const maxR = Math.min(W, H) * 0.42;
+  const placed = {};
+  order.forEach((o, rank) => {
+    const radius = rank === 0 ? 0 : maxR * Math.sqrt(rank / Math.max(1, nodes.length - 1));
+    const angle = rank * golden;
+    placed[o.i] = {
+      px: Math.round(cx + Math.cos(angle) * radius),
+      py: Math.round(cy + Math.sin(angle) * radius * 0.66),
+    };
+  });
+  return nodes.map((n, i) => ({ ...n, ...placed[i] }));
+}
+
+function truncate(s, n) { s = String(s || ""); return s.length > n ? s.slice(0, n - 1) + "…" : s; }
+
+function iconForType(t) {
+  return ({ Topic: "bulb", Concept: "atom", Method: "function", Model: "cpu", File: "file", Decision: "gavel", Task: "checkbox", Person: "user" })[t] || "point";
+}
+
+function buildLegend({ h }) {
+  const types = ["Topic", "Concept", "Method", "Model", "File"];
+  return h("div.lt3-graph-legend",
+    types.map((t) => h("span", h("i", { style: { background: colorFor(t) } }), t)),
+  );
+}