feat(viz): surface AP all-file edges — doc References + File→File imports

AP 0.2.0 indexes every file (File nodes for .js/.md/.json/.pdf/...) and adds
direct File→File edges: Imports_File_File (.js import/require) and the new
References_File_File (Markdown [text](path) links). Query both in
_impact_for_graph and fold them into the file-level direction rollups so the
impact panel shows real edges for non-AST and frontend files:
- references / referenced_by (doc links)
- imports folded into depends_on / depended_on_by
Richest-graph selection + empty-state check updated to count them.
Frontend impact diagram renders the References groups.

Verified against the freshly all-file-indexed Cortex graph (1160 files):
References_File_File resolves (CONTRIBUTING.md→README.md, README.md→
docs/papers/science.md). py compile + ruff clean; trace.js parses.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: cdeust

mcp_server/server/http_standalone_trace.py

@@ -344,6 +344,30 @@ async def q(cypher):
                 "p.depth AS depth, p.symbol_count AS n "
                 "ORDER BY p.symbol_count DESC LIMIT 40" % esc
             )
+            # All-file indexing (AP >= 0.2.0): direct File→File edges for files
+            # the AST parsers don't cover. Imports_File_File = .js import/require;
+            # References_File_File = Markdown/doc links. These make non-code and
+            # frontend files show real direction in the impact panel.
+            file_imports = await q(
+                "MATCH (f:File)-[r:Imports_File_File]->(d:File) "
+                "WHERE f.id = '%s' "
+                "RETURN DISTINCT d.id AS name, r.confidence AS conf LIMIT 200" % esc
+            )
+            file_imported_by = await q(
+                "MATCH (s:File)-[r:Imports_File_File]->(f:File) "
+                "WHERE f.id = '%s' "
+                "RETURN DISTINCT s.id AS name, r.confidence AS conf LIMIT 200" % esc
+            )
+            doc_refs = await q(
+                "MATCH (f:File)-[r:References_File_File]->(d:File) "
+                "WHERE f.id = '%s' "
+                "RETURN DISTINCT d.id AS name, r.confidence AS conf LIMIT 200" % esc
+            )
+            doc_referenced_by = await q(
+                "MATCH (s:File)-[r:References_File_File]->(f:File) "
+                "WHERE f.id = '%s' "
+                "RETURN DISTINCT s.id AS name, r.confidence AS conf LIMIT 200" % esc
+            )
 
             def _file_of(qn):
                 return str(qn or "").partition("::")[0]
@@ -437,13 +461,40 @@ def _rollup(items):
                 out.sort(key=lambda x: x["edges"], reverse=True)
                 return out
 
+            def _file_edges(rows, kind):
+                out = []
+                for r in rows:
+                    nm = r.get("name")
+                    if not nm or nm == rel_path:
+                        continue
+                    out.append(
+                        {
+                            "file": nm,
+                            "label": _basename(nm),
+                            "kind": kind,
+                            "confidence": _conf(r),
+                        }
+                    )
+                return out
+
+            # Direct File→File edges (AP all-file indexing): code imports for
+            # non-AST files (.js) and doc references (Markdown). Folded into the
+            # file-level direction so the panel shows them even when a file has
+            # no AST symbols at all.
+            imports_files = _file_edges(file_imports, "imports")
+            imported_by_files = _file_edges(file_imported_by, "imports")
+            references = _file_edges(doc_refs, "references")
+            referenced_by = _file_edges(doc_referenced_by, "references")
+
             return {
                 "downstream": downstream,
                 "upstream": upstream,
                 "members": members,
                 "processes": processes,
-                "depends_on": _rollup(downstream),
-                "depended_on_by": _rollup(upstream),
+                "references": references,
+                "referenced_by": referenced_by,
+                "depends_on": _rollup(downstream + imports_files),
+                "depended_on_by": _rollup(upstream + imported_by_files),
             }
 
     return loop_run(_run())
@@ -491,6 +542,10 @@ def serve_trace_impact(handler) -> None:
                 + len(r.get("upstream", []))
                 + len(r.get("members", []))
                 + len(r.get("processes", []))
+                + len(r.get("references", []))
+                + len(r.get("referenced_by", []))
+                + len(r.get("depends_on", []))
+                + len(r.get("depended_on_by", []))
             )
             if n > best_edges:
                 best_edges = n

ui/unified/js/trace.js

@@ -268,6 +268,9 @@
     // Lead with the file-level direction (developer blast-radius at a glance).
     h += _impactFiles('Depends on (files)', d.depends_on, 'down');
     h += _impactFiles('Depended on by (files)', d.depended_on_by, 'up');
+    // Doc references (Markdown links → files) — all-file indexing.
+    h += _impactGroup('References (docs → files)', d.references, 'down');
+    h += _impactGroup('Referenced by (docs)', d.referenced_by, 'up');
     // Causal chains this file launches.
     h += _impactProcesses(d.processes);
     // Then the detailed symbol-level edges.
@@ -276,7 +279,9 @@
     h += _impactGroup('Defines', d.members, 'flat');
     h += _impactVersions(d.versions);
     if (!(d.downstream || []).length && !(d.upstream || []).length
-        && !(d.members || []).length && !(d.processes || []).length) {
+        && !(d.members || []).length && !(d.processes || []).length
+        && !(d.references || []).length && !(d.referenced_by || []).length
+        && !(d.depends_on || []).length && !(d.depended_on_by || []).length) {
       h += '<div class="impact-loading">No dependencies found in the code-graph.</div>';
     }
     return h;