fix(graph): populate Calls_* / Imports_* rel tables via AP resolve pass

The workflow-graph viz filter for ``calls`` and ``imports`` showed zero
nodes because Cortex's auto-indexer only invoked AP's ``index_codebase``
tool, which persists Defines_* / HasMethod_* / HasField_* but NEVER
Calls_* / Imports_* / Extends_* / Implements_*. Those require AP's
separate ``resolve_graph`` pass.

Changes

1. ``http_standalone.py::_bg_index`` — switched ``b.index_codebase(...)``
   to ``b.analyze_codebase(...)`` (AP's all-in-one: index + resolve +
   cluster). New project graphs now land fully populated.

2. ``http_standalone.py::_bg_index`` — for EXISTING graphs (already
   indexed pre-Gap-10 with only ``index_codebase``), run the idempotent
   ``resolve_graph`` tool as a backfill so every project's Calls_* /
   Imports_* / Implements_* rel tables get populated retroactively,
   without paying the cost of a full re-parse.

3. ``http_launcher.py::_index`` — same switch from ``index_codebase``
   to ``analyze_codebase`` for the launcher-side indexer (kicked off
   when the user opens the viz from a project with no prior graph).

Debugging path required two upstream fixes that are NOT in this commit
but are prerequisites for the fix to render end-to-end:

  * AP (sibling repo ``automatised-pipeline``): the resolver crashed on
    the first unknown rel-table pair (e.g. ``Calls_Method_Struct``) via
    a ``?`` in ``EdgeBuffer::flush`` — one unknown name aborted the
    whole flush and dropped every resolved edge. Patched locally to
    skip-with-warning; AP rebuilt from source.

  * Cortex's AST disk cache at ``~/.claude/methodology/ast_cache/``
    serialised per-project edges BEFORE the resolver ran and its
    ``_graph_signature`` didn't detect LadybugDB internal file changes.
    Purging the 25 cache files + an HTTP respawn is needed once after
    the AP fix lands.

Verified live: bulk ``resolve_graph`` across all 25 project graphs
yielded 50,160 calls + 937 imports + 6,492 implements. After cache
purge and HTTP respawn, the ``calls — symbol ↔ symbol`` and
``imports — file ↔ symbol`` filters populate as the phase-builder
streams L6 per-project batches.

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

Author: cdeust

mcp_server/server/http_launcher.py

@@ -178,7 +178,11 @@ def _ensure_ap_graph(dev_src: Path | None, env: dict) -> None:
         async def _index():
             b = APBridge()
             try:
-                await b.index_codebase(
+                # analyze_codebase = index + resolve + cluster. Using
+                # the composed tool so Calls_* / Imports_* / Extends_*
+                # rel tables land populated; index_codebase alone
+                # leaves them empty (matched to the viz filter bug).
+                await b.analyze_codebase(
                     target,
                     output_dir=str(cache_dir),
                     language="auto",

mcp_server/server/http_standalone.py

@@ -328,14 +328,29 @@ async def _run():
                     for proj in projects:
                         outdir = roster_root / proj.name
                         graph_file = outdir / "graph"
-                        # Skip projects already indexed — cheap recovery
-                        # on a re-launch and avoids paying the cost of a
-                        # 5 000-file codebase every visualize call.
+                        # Graph already indexed. We still attempt a
+                        # resolve_graph pass because older Cortex
+                        # versions only ran index_codebase — their
+                        # graphs have zero Calls_* / Imports_* rows.
+                        # resolve_graph is idempotent: when edges are
+                        # already present it no-ops quickly.
                         if graph_file.exists() and graph_file.stat().st_size > 10000:
+                            try:
+                                await b.call(
+                                    "resolve_graph",
+                                    {"graph_path": str(graph_file)},
+                                )
+                            except Exception:
+                                pass
                             continue
                         outdir.mkdir(parents=True, exist_ok=True)
                         try:
-                            await b.index_codebase(
+                            # analyze_codebase runs index + resolve + cluster
+                            # in one pass so Calls_* / Imports_* / Extends_*
+                            # / Implements_* rel tables get populated. Using
+                            # index_codebase alone leaves those tables empty
+                            # and the viz filter has nothing to match.
+                            await b.analyze_codebase(
                                 str(proj),
                                 output_dir=str(outdir),
                                 language="auto",