diff --git a/graphify/__main__.py b/graphify/__main__.py
index 924ae986d..4ba382521 100644
--- a/graphify/__main__.py
+++ b/graphify/__main__.py
@@ -539,6 +539,7 @@ def _run_cli() -> None:
         print("    --force                 overwrite graph.json even if the rebuild has fewer nodes")
         print("                            (also: GRAPHIFY_FORCE=1 env var; use after refactors that delete code)")
         print("    --no-cluster            skip clustering, write raw extraction only")
+        print("    --one-file-system       don't cross mount points (find -xdev); auto-on for a / or $HOME root")
         print("  cluster-only <path>     rerun clustering on an existing graph.json and regenerate report")
         print("    --no-viz                skip graph.html generation (useful for >5000 node graphs / CI)")
         print("    --graph <path>          path to graph.json (default <path>/graphify-out/graph.json)")
@@ -585,6 +586,10 @@ def _run_cli() -> None:
         print("    --half-life-days N      signal weight halves every N days (default 30)")
         print("    --min-corroboration N   distinct useful results to prefer a node (default 2)")
         print("  check-update <path>     check needs_update flag and notify if semantic re-extraction is pending (cron-safe)")
+        print("  serve-html              serve graphify-out/ over HTTP and print the graph.html URL (headless hosts)")
+        print("    --host H                interface to bind (default 127.0.0.1; --host 0.0.0.0 exposes it on the network)")
+        print("    --port N                port to listen on (default 8899)")
+        print("    --dir DIR               directory to serve (default graphify-out)")
         print("  tree                    emit a D3 v7 collapsible-tree HTML for graph.json")
         print("    --graph PATH            path to graph.json (default graphify-out/graph.json)")
         print("    --output HTML           output path (default graphify-out/GRAPH_TREE.html)")
@@ -610,6 +615,8 @@ def _run_cli() -> None:
         print("    --out DIR, --output DIR output dir (default: <path>); writes <DIR>/graphify-out/")
         print("    --google-workspace      export .gdoc/.gsheet/.gslides shortcuts via gws before extraction")
         print("    --no-gitignore         ignore .gitignore and .git/info/exclude (prioritizes .graphifyignore)")
+        print("    --one-file-system       don't cross mount points (find -xdev); auto-on for a / or $HOME root")
+        print("    --exclude PATTERN       gitignore-style exclude, anchored at the scan root (repeatable)")
         print("    --no-cluster            skip clustering, write raw extraction only")
         print("    --code-only             index code (local AST, no API key) and skip doc/paper/image files")
         print("    --postgres DSN          extract schema from a live PostgreSQL database")
diff --git a/graphify/cli.py b/graphify/cli.py
index 441e4ca36..abfc201c1 100644
--- a/graphify/cli.py
+++ b/graphify/cli.py
@@ -6,6 +6,7 @@
 import of main to avoid a cli<->__main__ import cycle.
 """
 from __future__ import annotations
+import functools
 import json
 import os
 import re
@@ -802,6 +803,70 @@ def _reenter_main() -> None:
     main()
 
 
+def _is_high_scan_root(root: Path) -> str | None:
+    """Return a human label when *root* is a dangerously high scan root, else None.
+
+    A whole-machine scan of a filesystem root (`/`, or a drive root on Windows)
+    or the user's `$HOME` walks vendored caches, virtual filesystems and other
+    machines' mounts — the root cause of a 2-hour `/` scan that ingested 1.18M
+    refs from the Go module cache. The extract/update paths use this to auto-arm
+    protections and warn (FIX 2/FIX 3).
+    """
+    try:
+        resolved = root.resolve()
+    except (OSError, RuntimeError):
+        resolved = root
+    if resolved == Path(resolved.anchor) and resolved.anchor:
+        return "filesystem root"
+    home = Path(os.path.expanduser("~"))
+    try:
+        if home and resolved == home.resolve():
+            return "home directory ($HOME)"
+    except (OSError, RuntimeError):
+        pass
+    return None
+
+
+def _warn_high_root_scan(root: Path, label: str, cli_excludes: list[str], one_file_system: bool) -> None:
+    """Print a loud, unmissable warning before a whole-machine scan (FIX 3).
+
+    Only fired when the user passed no ``--exclude`` and there is no
+    ``.graphifyignore`` at the root, i.e. nothing scoping the scan. Never blocks
+    (kept scriptable) — it just makes the active protections visible.
+    """
+    if cli_excludes:
+        return
+    try:
+        if (root / ".graphifyignore").is_file():
+            return
+    except OSError:
+        return
+    print(
+        f"[graphify] WARNING: starting a whole-machine scan of {root} ({label}).",
+        file=sys.stderr,
+    )
+    print(
+        "[graphify]   This can take hours and ingest vendored caches / other "
+        "mounts. Active protections:",
+        file=sys.stderr,
+    )
+    print(
+        "[graphify]     - default excludes: /proc /sys /dev /run + Go/.cargo/"
+        ".rustup/.m2/.gradle/.pnpm-store caches (disable: GRAPHIFY_NO_DEFAULT_EXCLUDES=1)",
+        file=sys.stderr,
+    )
+    print(
+        f"[graphify]     - one-file-system: {'ON' if one_file_system else 'OFF'} "
+        "(mount points not crossed when ON)",
+        file=sys.stderr,
+    )
+    print(
+        "[graphify]   Scope it with --exclude PATTERN or a .graphifyignore file "
+        "to scan faster.",
+        file=sys.stderr,
+    )
+
+
 def dispatch_command(cmd: str) -> None:
     if cmd == "provider":
         from graphify.llm import _custom_providers_path, BACKENDS
@@ -2077,6 +2142,10 @@ def dispatch_command(cmd: str) -> None:
     elif cmd == "update":
         force = os.environ.get("GRAPHIFY_FORCE", "").lower() in ("1", "true", "yes")
         no_cluster = False
+        # --one-file-system (find -xdev). update re-runs detect() via watch's
+        # _rebuild_code, which has no kwarg for this, so it is plumbed through the
+        # GRAPHIFY_ONE_FILE_SYSTEM env var that detect() already honours (FIX 2).
+        one_file_system: bool | None = None
         args = sys.argv[2:]
         watch_arg: str | None = None
         for a in args:
@@ -2086,6 +2155,9 @@ def dispatch_command(cmd: str) -> None:
             if a == "--no-cluster":
                 no_cluster = True
                 continue
+            if a in ("--one-file-system", "--xdev"):
+                one_file_system = True
+                continue
             if a.startswith("-"):
                 print(f"error: unknown update option: {a}", file=sys.stderr)
                 sys.exit(2)
@@ -2106,6 +2178,24 @@ def dispatch_command(cmd: str) -> None:
         if not watch_path.exists():
             print(f"error: path not found: {watch_path}", file=sys.stderr)
             sys.exit(1)
+
+        # FIX 2/FIX 3: high-root guardrails (see the extract path). Auto-enable
+        # --one-file-system for a `/` or $HOME scan root, then warn loudly if
+        # nothing scopes a whole-machine scan.
+        _high_root_label = _is_high_scan_root(watch_path)
+        if _high_root_label is not None:
+            if one_file_system is None:
+                one_file_system = True
+                print(
+                    f"[graphify update] {_high_root_label} scan root: "
+                    f"auto-enabling --one-file-system (won't cross mount points)"
+                )
+            _warn_high_root_scan(
+                watch_path.resolve(), _high_root_label, [], bool(one_file_system)
+            )
+        if one_file_system:
+            os.environ["GRAPHIFY_ONE_FILE_SYSTEM"] = "1"
+
         from graphify.watch import _rebuild_code
 
         print(f"Re-extracting code files in {watch_path} (no LLM needed)...")
@@ -2155,6 +2245,87 @@ def dispatch_command(cmd: str) -> None:
 
         check_update(Path(sys.argv[2]).resolve())
         sys.exit(0)
+    elif cmd == "serve-html":
+        # Serve graphify-out/ over HTTP so headless hosts (no browser, remote
+        # boxes) can open graph.html in a local browser (#headless). Uses only
+        # the stdlib http.server — no extra deps.
+        import http.server
+
+        host = "127.0.0.1"
+        port = 8899
+        serve_dir = Path(_GRAPHIFY_OUT)
+        args = sys.argv[2:]
+        i_arg = 0
+        while i_arg < len(args):
+            a = args[i_arg]
+            if a == "--host" and i_arg + 1 < len(args):
+                host = args[i_arg + 1]; i_arg += 2
+            elif a.startswith("--host="):
+                host = a.split("=", 1)[1]; i_arg += 1
+            elif a == "--port" and i_arg + 1 < len(args):
+                port = int(args[i_arg + 1]); i_arg += 2
+            elif a.startswith("--port="):
+                port = int(a.split("=", 1)[1]); i_arg += 1
+            elif a == "--dir" and i_arg + 1 < len(args):
+                serve_dir = Path(args[i_arg + 1]); i_arg += 2
+            elif a.startswith("--dir="):
+                serve_dir = Path(a.split("=", 1)[1]); i_arg += 1
+            elif a in ("-h", "--help"):
+                print("Usage: graphify serve-html [--host H] [--port N] [--dir DIR]")
+                print("  --host H    interface to bind (default 127.0.0.1; use 0.0.0.0 to expose on the network)")
+                print("  --port N    port to listen on (default 8899)")
+                print("  --dir DIR   directory to serve (default graphify-out)")
+                return
+            else:
+                print(f"error: unknown serve-html option: {a}", file=sys.stderr)
+                sys.exit(2)
+
+        serve_dir = serve_dir.resolve()
+        if not serve_dir.is_dir():
+            print(f"error: directory not found: {serve_dir}", file=sys.stderr)
+            print("Run `graphify extract <path>` first to generate graphify-out/.", file=sys.stderr)
+            sys.exit(1)
+
+        # Serve serve_dir as the document root regardless of CWD (Python 3.7+
+        # SimpleHTTPRequestHandler honours the `directory` kwarg).
+        handler = functools.partial(
+            http.server.SimpleHTTPRequestHandler, directory=str(serve_dir)
+        )
+
+        # ThreadingHTTPServer keeps the browser responsive when it opens several
+        # requests (HTML + JSON + assets) at once.
+        http.server.ThreadingHTTPServer.allow_reuse_address = True
+        try:
+            httpd = http.server.ThreadingHTTPServer((host, port), handler)
+        except OSError as exc:
+            print(f"error: could not bind {host}:{port} ({exc})", file=sys.stderr)
+            sys.exit(1)
+
+        # 0.0.0.0/:: binds every interface — surface that it is reachable off-box.
+        display_host = "localhost" if host in ("127.0.0.1", "0.0.0.0", "::") else host
+        graph_html = serve_dir / "graph.html"
+        print(f"Serving {serve_dir} at http://{display_host}:{port}/")
+        if graph_html.is_file():
+            print(f"Open the graph: http://{display_host}:{port}/graph.html")
+        else:
+            print(
+                f"note: graph.html not found in {serve_dir} "
+                "(run `graphify extract <path>` to generate it)"
+            )
+        if host in ("0.0.0.0", "::"):
+            print(
+                f"warning: bound to {host} — this exposes the server to your "
+                "network, not just this machine.",
+                file=sys.stderr,
+            )
+        print("Press Ctrl+C to stop.")
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            print("\nStopping server.")
+        finally:
+            httpd.server_close()
+        return
     elif cmd == "tree":
         # Emit a D3 v7 collapsible-tree HTML view of graph.json:
         # expand-all / collapse-all / reset-view buttons, multi-line
@@ -2854,6 +3025,9 @@ def _to_simple(g: "_nx.Graph") -> "_nx.Graph":
         cli_exclude_hubs: float | None = None
         cli_excludes: list[str] = []
         cli_timing: bool = False
+        # --one-file-system (find -xdev): prune child dirs on a different mount.
+        # Auto-enabled below for a `/` or $HOME scan root. None -> library default.
+        cli_one_file_system: bool | None = None
         # --force parity with `graphify update`: the flag or GRAPHIFY_FORCE=1
         # disables the incremental gate and skips semantic-cache reads (#1894).
         force = os.environ.get("GRAPHIFY_FORCE", "").lower() in ("1", "true", "yes")
@@ -2945,6 +3119,8 @@ def _parse_float(name: str, raw: str) -> float:
                 cli_excludes.append(args[i + 1]); i += 2
             elif a.startswith("--exclude="):
                 cli_excludes.append(a.split("=", 1)[1]); i += 1
+            elif a in ("--one-file-system", "--xdev"):
+                cli_one_file_system = True; i += 1
             elif a == "--postgres" and i + 1 < len(args):
                 cli_postgres_dsn = args[i + 1]; i += 2
             elif a.startswith("--postgres="):
@@ -2977,6 +3153,22 @@ def _parse_float(name: str, raw: str) -> float:
         if deep_mode:
             print("[graphify extract] deep mode enabled: richer semantic extraction")
 
+        # FIX 2/FIX 3: high-root guardrails. Auto-enable --one-file-system for a
+        # `/` or $HOME scan root (with a notice), then warn loudly if nothing is
+        # scoping a whole-machine scan.
+        if has_path:
+            _high_root_label = _is_high_scan_root(target)
+            if _high_root_label is not None:
+                if cli_one_file_system is None:
+                    cli_one_file_system = True
+                    print(
+                        f"[graphify extract] {_high_root_label} scan root: "
+                        f"auto-enabling --one-file-system (won't cross mount points)"
+                    )
+                _warn_high_root_scan(
+                    target, _high_root_label, cli_excludes, bool(cli_one_file_system)
+                )
+
         # CLI flag wins over env var. Setting GRAPHIFY_API_TIMEOUT here so
         # _call_openai_compat picks it up without needing a new kwarg path.
         if cli_api_timeout is not None:
@@ -3062,6 +3254,7 @@ def _parse_float(name: str, raw: str) -> float:
                 google_workspace=google_workspace or None,
                 extra_excludes=_effective_excludes or None,
                 gitignore=_effective_gitignore,
+                one_file_system=cli_one_file_system,
             )
             files_by_type = detection.get("files", {})
             new_by_type = detection.get("new_files", {})
@@ -3108,6 +3301,7 @@ def _parse_float(name: str, raw: str) -> float:
                 extra_excludes=_effective_excludes or None,
                 cache_root=out_root,
                 gitignore=_effective_gitignore,
+                one_file_system=cli_one_file_system,
             )
             files_by_type = detection.get("files", {})
             code_files = [Path(p) for p in files_by_type.get("code", [])]
diff --git a/graphify/detect.py b/graphify/detect.py
index 23e9198bf..3b72af0ba 100644
--- a/graphify/detect.py
+++ b/graphify/detect.py
@@ -812,6 +812,56 @@ def count_words(path: Path) -> int:
     ".worktrees",  # git worktree convention (#947) — sibling checkouts, always redundant
 }
 
+# Absolute paths never worth descending: kernel virtual filesystems. A high-root
+# scan (e.g. `graphify extract /`) that walks /proc alone ingests a per-PID tree
+# that changes under the scanner and is architecturally meaningless; /sys, /dev
+# and /run are the same class. Matched by the directory's resolved absolute path,
+# not its basename, so an unrelated project dir named "proc" is never pruned.
+# Disable with GRAPHIFY_NO_DEFAULT_EXCLUDES=1 (mirrors the vendored-cache gate).
+_SKIP_ABS_PATHS = frozenset({
+    "/proc", "/sys", "/dev", "/run",
+})
+
+# Well-known vendored dependency caches. These hold thousands-to-millions of
+# extracted upstream sources that are never this project's code — the Go module
+# cache under `go/pkg/mod` alone ingested 1.18M refs on a `/` scan (#root-cause).
+# Basenames like `.cargo`/`.m2` are unambiguous enough to prune by name, but
+# `pkg`/`mod` are common real directory names, so the Go cache is gated on the
+# `.../go/pkg/mod` path shape below in `_is_vendored_cache_dir` rather than a
+# bare basename. Disable all of these with GRAPHIFY_NO_DEFAULT_EXCLUDES=1.
+_SKIP_VENDORED_CACHE_DIRS = frozenset({
+    ".cargo", ".rustup", ".m2", ".gradle", ".pnpm-store",
+})
+
+
+def _default_excludes_enabled() -> bool:
+    """False when the user opted out of the built-in high-root protections.
+
+    GRAPHIFY_NO_DEFAULT_EXCLUDES=1 disables the virtual-filesystem and
+    vendored-cache pruning added for whole-machine scans, for the rare case a
+    user really does want to index one of those trees. Explicit ``--exclude`` /
+    ``.graphifyignore`` ``!`` negations still take precedence regardless.
+    """
+    return os.environ.get("GRAPHIFY_NO_DEFAULT_EXCLUDES", "").lower() not in ("1", "true", "yes")
+
+
+def _is_vendored_cache_dir(name: str, parent: "Path | None") -> bool:
+    """True when *name* under *parent* is a well-known vendored dependency cache.
+
+    Basename caches (`.cargo`, `.rustup`, `.m2`, `.gradle`, `.pnpm-store`) match
+    directly. The Go module cache is gated on the `.../go/pkg/mod` path structure
+    — pruning a bare `mod`/`pkg` by name would drop legitimate source — so it
+    matches only when the directory is `mod` whose parent is `pkg` whose parent
+    is `go`.
+    """
+    if name in _SKIP_VENDORED_CACHE_DIRS:
+        return True
+    # Go module cache: <GOPATH>/pkg/mod  (parent basename "pkg", grandparent "go").
+    if name == "mod" and parent is not None and parent.name == "pkg" and parent.parent.name == "go":
+        return True
+    return False
+
+
 # Large generated files that are never useful to extract
 _SKIP_FILES = {
     "package-lock.json", "yarn.lock", "pnpm-lock.yaml",
@@ -1216,6 +1266,43 @@ def _matches(rel: str, p: str, path_relative: bool) -> bool:
     return _eval(path)
 
 
+def _explicitly_reincluded(path: Path, patterns: list[tuple[Path, str]]) -> bool:
+    """True when a user ``!`` negation pattern explicitly matches *path*.
+
+    Lets an explicit ``--exclude '!go/pkg/mod'`` / ``.graphifyignore`` negation
+    re-include a directory the built-in default excludes (virtual filesystems,
+    vendored caches) would otherwise prune (#root-cause). Only negation patterns
+    are considered — a plain include has no bearing on default-exclude pruning.
+    """
+    for anchor, pattern in patterns:
+        if not pattern.startswith("!"):
+            continue
+        raw = pattern[1:]
+        directory_only = raw.endswith("/")
+        path_relative = "/" in raw.rstrip("/")
+        p = raw.strip("/")
+        if not p:
+            continue
+        try:
+            rel = _nfc(str(path.relative_to(anchor)).replace(os.sep, "/"))
+        except ValueError:
+            continue
+        if rel == ".":
+            continue
+        if directory_only and not path.is_dir():
+            continue
+        if path_relative:
+            if _match_anchored_ignore_pattern(rel, p):
+                return True
+        else:
+            if fnmatch.fnmatch(_nfc(path.name), p) or fnmatch.fnmatch(rel, p):
+                return True
+            for part in rel.split("/"):
+                if fnmatch.fnmatch(part, p):
+                    return True
+    return False
+
+
 def ignored_predicate(
     root: Path,
     *,
@@ -1304,8 +1391,23 @@ def _resolves_under_root(path: Path, root: Path) -> bool:
     return True
 
 
-def detect(root: Path, *, follow_symlinks: bool | None = None, google_workspace: bool | None = None, extra_excludes: list[str] | None = None, cache_root: Path | None = None, gitignore: bool = True) -> dict:
+def detect(root: Path, *, follow_symlinks: bool | None = None, google_workspace: bool | None = None, extra_excludes: list[str] | None = None, cache_root: Path | None = None, gitignore: bool = True, one_file_system: bool | None = None) -> dict:
     root = root.resolve()
+    # --one-file-system / GRAPHIFY_ONE_FILE_SYSTEM=1 (find -xdev): capture the
+    # root's device now and prune any child dir on a different filesystem so a
+    # high-root scan never crosses a mount point (network shares, bind mounts,
+    # /proc, external disks). Auto-enabled by the CLI for `/` and $HOME (#root).
+    if one_file_system is None:
+        one_file_system = os.environ.get("GRAPHIFY_ONE_FILE_SYSTEM", "").lower() in ("1", "true", "yes")
+    root_dev: int | None = None
+    if one_file_system:
+        try:
+            root_dev = os.stat(_os_path(root)).st_dev
+        except OSError:
+            root_dev = None
+    # Built-in high-root protections: virtual filesystems + vendored dep caches.
+    # Escapable via GRAPHIFY_NO_DEFAULT_EXCLUDES=1 (#root-cause).
+    default_excludes = _default_excludes_enabled()
     configured_out_dir = root / GRAPHIFY_OUT
     configured_out_names = {configured_out_dir.name}
     try:
@@ -1436,6 +1538,29 @@ def _on_walk_error(err: OSError) -> None:
                     if is_configured_out:
                         pruned_noise.append(str(child) + os.sep)
                         continue
+                    # Built-in high-root protections (#root-cause). An explicit
+                    # user `!` negation re-includes and takes precedence, so a
+                    # user who really wants to index /proc or the Go cache can.
+                    if default_excludes and not _explicitly_reincluded(child, ignore_patterns):
+                        try:
+                            child_abs = os.path.realpath(_os_path(child))
+                        except OSError:
+                            child_abs = str(child)
+                        if child_abs in _SKIP_ABS_PATHS:
+                            pruned_noise.append(str(child) + os.sep + " [virtual filesystem]")
+                            continue
+                        if _is_vendored_cache_dir(d, dp):
+                            pruned_noise.append(str(child) + os.sep + " [vendored dependency cache]")
+                            continue
+                    # --one-file-system: never cross a mount point (#root).
+                    if root_dev is not None and not _explicitly_reincluded(child, ignore_patterns):
+                        try:
+                            child_dev = os.stat(_os_path(child)).st_dev
+                        except OSError:
+                            child_dev = root_dev
+                        if child_dev != root_dev:
+                            pruned_noise.append(str(child) + os.sep + " [different filesystem (--one-file-system)]")
+                            continue
                     if _is_noise_dir(d, dp):
                         # Record pruned-as-noise dirs so a wrongly-pruned real
                         # source dir is at least traceable in the output rather
@@ -1916,6 +2041,7 @@ def detect_incremental(
     kind: str = "semantic",
     extra_excludes: list[str] | None = None,
     gitignore: bool = True,
+    one_file_system: bool | None = None,
 ) -> dict:
     """Like detect(), but returns only new or modified files since the last run.
 
@@ -1945,6 +2071,7 @@ def detect_incremental(
         google_workspace=google_workspace,
         extra_excludes=extra_excludes,
         gitignore=gitignore,
+        one_file_system=one_file_system,
     )
     # Pass ``root`` so a manifest written with relative keys (post-#777) is
     # re-anchored to the absolute form the rest of this function compares
diff --git a/graphify/export.py b/graphify/export.py
index 0a1a0bb65..708828289 100644
--- a/graphify/export.py
+++ b/graphify/export.py
@@ -315,8 +315,23 @@ def _json_sort_key(item: dict) -> str:
         if true_src is not None and true_tgt is not None:
             link["source"] = true_src
             link["target"] = true_tgt
-    data["nodes"].sort(key=_json_sort_key)
-    data["links"].sort(key=_json_sort_key)
+    # Deterministic ordering keyed on stable identity fields only. Avoid a full
+    # json.dumps of every element (#: at ~844k edges that re-serializes the whole
+    # graph an extra time). Nodes are keyed by id; links by their endpoint +
+    # relation identity. Total and stable across runs — need not byte-match the
+    # old json-dump ordering.
+    def _node_sort_key(node: dict):
+        return str(node.get("id"))
+
+    def _link_sort_key(link: dict):
+        return (
+            str(link.get("source")),
+            str(link.get("target")),
+            str(link.get("relation") or link.get("key") or ""),
+        )
+
+    data["nodes"].sort(key=_node_sort_key)
+    data["links"].sort(key=_link_sort_key)
     if "hyperedges" not in getattr(G, "graph", {}):
         # Hardening (#2485): a graph with NO hyperedges key at all was built by
         # a path that never engaged hyperedge metadata — distinct from an
diff --git a/graphify/exporters/html.py b/graphify/exporters/html.py
index 372dd397f..9486e76cf 100644
--- a/graphify/exporters/html.py
+++ b/graphify/exporters/html.py
@@ -27,6 +27,62 @@ def _viz_node_limit() -> int:
     except ValueError:
         return MAX_NODES_FOR_VIZ
 
+_VIS_NETWORK_CDN = "https://unpkg.com/vis-network@9.1.6/standalone/umd/vis-network.min.js"
+_VIS_NETWORK_SRI = "sha384-Ux6phic9PEHJ38YtrijhkzyJ8yQlH8i/+buBR8s3mAZOJrP1gwyvAcIYl3GWtpX1"
+_VIS_NETWORK_VENDOR_NAME = "vis-network.min.js"
+
+
+def _vis_network_script_tag(output_path: str) -> str:
+    """Return the <script> tag that loads vis-network.
+
+    Default: the SRI-pinned CDN tag (integrity + crossorigin), so a tampered
+    unpkg payload is rejected by the browser.
+
+    Offline/air-gapped: when GRAPHIFY_VIZ_OFFLINE=1, reference a locally-vendored
+    ``vis-network.min.js`` written next to graph.html instead of the CDN. The
+    vendored file must already exist beside the output (e.g. copied in by the
+    packager, or from a prior online run) or be resolvable from a bundled copy —
+    this environment has no network access to fetch it on demand. If the local
+    asset can't be produced, degrade gracefully: fall back to the SRI-pinned CDN
+    tag and print a note so the "offline" intent is not silently violated.
+
+    NOTE (deferred): fully self-vendoring the JS by downloading + hashing at
+    export time, and externalizing the graph payload into a separate fetch()'d
+    file / WebGL renderer, are larger changes left to a later pass.
+    """
+    import os
+    import shutil
+
+    cdn_tag = (
+        f'<script src="{_VIS_NETWORK_CDN}"\n'
+        f'        integrity="{_VIS_NETWORK_SRI}"\n'
+        f'        crossorigin="anonymous"></script>'
+    )
+    if os.environ.get("GRAPHIFY_VIZ_OFFLINE") != "1":
+        return cdn_tag
+
+    out = Path(output_path)
+    vendored = out.parent / _VIS_NETWORK_VENDOR_NAME
+    try:
+        if not vendored.exists():
+            # Try a copy bundled inside the package (vendored offline asset).
+            bundled = Path(__file__).resolve().parent / _VIS_NETWORK_VENDOR_NAME
+            if bundled.exists():
+                out.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(bundled, vendored)
+        if vendored.exists():
+            # Local reference — relative so the report stays portable.
+            return f'<script src="{_VIS_NETWORK_VENDOR_NAME}"></script>'
+    except OSError:
+        pass
+    print(
+        "[graphify] GRAPHIFY_VIZ_OFFLINE=1 but no local "
+        f"{_VIS_NETWORK_VENDOR_NAME} could be produced next to {out.name}; "
+        "falling back to the SRI-pinned CDN (requires network to view).",
+    )
+    return cdn_tag
+
+
 def _html_styles() -> str:
     return """<style>
   * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -437,13 +493,23 @@ def to_html(
                 meta.graph["hyperedges"] = remapped
             to_html(meta, meta_communities, output_path,
                     community_labels=community_labels, member_counts=mc)
+            # Make the aggregation explicit so users don't mistake the meta-graph
+            # for a full node-level render.
+            print(
+                f"NOTE: graph.html shows an AGGREGATED view — "
+                f"{meta.number_of_nodes()} communities shown instead of "
+                f"{G.number_of_nodes()} nodes (not every node is displayed)."
+            )
             print(f"graph.html written (aggregated: {meta.number_of_nodes()} community nodes, {meta.number_of_edges()} cross-community edges)")
             print("Tip: run with --obsidian for full node-level detail.")
             return
         raise ValueError(
             f"Graph has {G.number_of_nodes()} nodes - too large for HTML viz "
-            f"(limit: {limit}). Use --no-viz, raise GRAPHIFY_VIZ_NODE_LIMIT, "
-            f"or reduce input size."
+            f"(limit: {limit}). Options: pass --no-viz to skip the interactive "
+            f"HTML; raise the limit via GRAPHIFY_VIZ_NODE_LIMIT (e.g. "
+            f"GRAPHIFY_VIZ_NODE_LIMIT={G.number_of_nodes()}); or use the "
+            f"aggregated community meta-graph (node_limit=), which renders one "
+            f"node per community instead of every node."
         )
 
     node_community = _node_community_map(communities)
@@ -565,15 +631,14 @@ def _js_safe(obj) -> str:
     hyperedges_json = _js_safe(getattr(G, "graph", {}).get("hyperedges", []))
     title = _html.escape(sanitize_label(_html_document_title(output_path)))
     stats = f"{G.number_of_nodes()} nodes &middot; {G.number_of_edges()} edges &middot; {len(communities)} communities"
+    vis_script_tag = _vis_network_script_tag(output_path)
 
     html = f"""<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
 <title>graphify - {title}</title>
-<script src="https://unpkg.com/vis-network@9.1.6/standalone/umd/vis-network.min.js"
-        integrity="sha384-Ux6phic9PEHJ38YtrijhkzyJ8yQlH8i/+buBR8s3mAZOJrP1gwyvAcIYl3GWtpX1"
-        crossorigin="anonymous"></script>
+{vis_script_tag}
 {_html_styles()}
 </head>
 <body>
diff --git a/graphify/extract.py b/graphify/extract.py
index 03db99454..28e46e451 100644
--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -1,6 +1,7 @@
 """Deterministic structural extraction from source code using tree-sitter. Outputs nodes+edges dicts."""
 from __future__ import annotations
 
+import functools
 import hashlib
 import importlib
 import json
@@ -8,6 +9,7 @@
 import re
 import sys
 import textwrap
+import time
 from collections import Counter
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -1968,11 +1970,16 @@ def _canonicalize_csharp_namespace_nodes(all_nodes: list[dict], all_edges: list[
 })
 
 
+@functools.lru_cache(maxsize=None)
+def _lang_is_case_insensitive_str(source_file: str) -> bool:
+    return Path(source_file).suffix.lower() in _CASE_INSENSITIVE_EXTS
+
+
 def _lang_is_case_insensitive(source_file: object) -> bool:
     """True when the file's language resolves identifiers case-insensitively (#1581)."""
     if not source_file:
         return False
-    return Path(str(source_file)).suffix.lower() in _CASE_INSENSITIVE_EXTS
+    return _lang_is_case_insensitive_str(str(source_file))
 
 
 # Language interop families for cross-file call resolution. A call in one language
@@ -2014,11 +2021,16 @@ def _lang_is_case_insensitive(source_file: object) -> bool:
 }
 
 
+@functools.lru_cache(maxsize=None)
+def _lang_family_str(source_file: str) -> str | None:
+    return _LANG_FAMILY_BY_EXT.get(Path(source_file).suffix.lower())
+
+
 def _lang_family(source_file: object) -> str | None:
     """Interop family of the file's language, or None when unknown/not code."""
     if not source_file:
         return None
-    return _LANG_FAMILY_BY_EXT.get(Path(str(source_file)).suffix.lower())
+    return _lang_family_str(str(source_file))
 
 
 def _node_label_key(node: dict, fold: bool = False) -> str:
@@ -5522,7 +5534,9 @@ def extract(
     # still carry the raw file-stem prefix; the per-file prefix remap then diverges
     # them (foo_h vs foo_cpp), so the collapse must happen first. Collapsing here
     # also means disambiguation sees one source_file per id and won't split them.
+    _t0 = time.perf_counter()
     _merge_decl_def_classes(all_nodes, all_edges)
+    print(f"  resolving merge_decl_def_classes: done ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Remap file node IDs from absolute-path-derived to the canonical
     # {parent_dir}_{stem} spec form so (a) graph.json edge endpoints are stable
@@ -5943,6 +5957,7 @@ def _learn(e: dict) -> None:
         if p.suffix.lower() in _php_exts and not p.name.lower().endswith(".blade.php")
     ]
     if _php_sel:
+        _t0 = time.perf_counter()
         try:
             _resolve_php_type_references(
                 [r for r, _ in _php_sel], [p for _, p in _php_sel], all_nodes, all_edges
@@ -5950,6 +5965,7 @@ def _learn(e: dict) -> None:
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("PHP type-reference resolution failed, skipping: %s", exc)
+        print(f"  resolving php_type_references: {len(_php_sel)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
     # Java package/import disambiguation must likewise run BEFORE the rewire
     # (#2504): an EXTERNAL import (`org.springframework.stereotype.Component`)
     # leaves a bare `Component` stub that the rewire would collapse onto the only
@@ -5958,6 +5974,7 @@ def _learn(e: dict) -> None:
     # import-exact resolution of internal references (#1318/#1744) still applies.
     _java_sel = [(r, p) for r, p in zip(per_file, paths) if p.suffix == ".java"]
     if _java_sel:
+        _t0 = time.perf_counter()
         try:
             _resolve_java_type_references(
                 [r for r, _ in _java_sel], [p for _, p in _java_sel], all_nodes, all_edges
@@ -5965,10 +5982,12 @@ def _learn(e: dict) -> None:
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("Java type-reference resolution failed, skipping: %s", exc)
+        print(f"  resolving java_type_references: {len(_java_sel)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
     # Resolve internal Go pkg.Type references exactly and park external ones
     # before the generic bare-label stub rewire can manufacture a collision.
     _go_sel = [(r, p) for r, p in zip(per_file, paths) if p.suffix == ".go"]
     if _go_sel:
+        _t0 = time.perf_counter()
         try:
             _resolve_go_type_references(
                 [r for r, _ in _go_sel], [p for _, p in _go_sel],
@@ -5980,11 +5999,15 @@ def _learn(e: dict) -> None:
             logging.getLogger(__name__).warning(
                 "Go type-reference resolution failed, skipping: %s", exc
             )
+        print(f"  resolving go_type_references: {len(_go_sel)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
+    _t0 = time.perf_counter()
     _rewire_unique_stub_nodes(all_nodes, all_edges)
+    print(f"  resolving rewire_unique_stub_nodes: done ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Add cross-file class-level edges (Python only - uses Python parser internally)
     py_paths = [p for p in paths if p.suffix == ".py"]
     if py_paths:
+        _t0 = time.perf_counter()
         py_results = [r for r, p in zip(per_file, paths) if p.suffix == ".py"]
         try:
             cross_file_edges = _resolve_cross_file_imports(py_results, py_paths)
@@ -5992,16 +6015,19 @@ def _learn(e: dict) -> None:
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("Cross-file import resolution failed, skipping: %s", exc)
+        print(f"  resolving cross_file_imports (python): {len(py_paths)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Cross-file Java import resolution
     java_paths = [p for p in paths if p.suffix == ".java"]
     if java_paths:
+        _t0 = time.perf_counter()
         java_results = [r for r, p in zip(per_file, paths) if p.suffix == ".java"]
         try:
             all_edges.extend(_resolve_cross_file_java_imports(java_results, java_paths))
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("Java cross-file import resolution failed, skipping: %s", exc)
+        print(f"  resolving cross_file_java_imports: {len(java_paths)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Cross-file C# type-reference resolution: re-point dangling inherits/implements/
     # references edges left on shadow stubs, disambiguating same-named types by the
@@ -6009,16 +6035,20 @@ def _learn(e: dict) -> None:
     cs_paths = [p for p in paths if p.suffix == ".cs"]
     if cs_paths:
         cs_results = [r for r, p in zip(per_file, paths) if p.suffix == ".cs"]
+        _t0 = time.perf_counter()
         try:
             _resolve_csharp_type_references(cs_results, cs_paths, all_nodes, all_edges)
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("C# type-reference resolution failed, skipping: %s", exc)
+        print(f"  resolving csharp_type_references: {len(cs_paths)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
+        _t0 = time.perf_counter()
         try:
             _resolve_cross_file_csharp_imports(cs_results, cs_paths, all_nodes, all_edges)
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("C# cross-file import resolution failed, skipping: %s", exc)
+        print(f"  resolving cross_file_csharp_imports: {len(cs_paths)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Cross-file Bash source-backed call resolution: a call to a function defined
     # in a file this one `source`s is left unresolved by the per-file extractor
@@ -6054,6 +6084,7 @@ def _looks_like_bash(result: object) -> bool:
         if p.suffix in (".sh", ".bash") or _looks_like_bash(r)
     ]
     if sh_pairs:
+        _t0 = time.perf_counter()
         sh_results = [r for r, _ in sh_pairs]
         sh_paths = [p for _, p in sh_pairs]
         try:
@@ -6063,6 +6094,7 @@ def _looks_like_bash(result: object) -> bool:
         except Exception as exc:
             import logging
             logging.getLogger(__name__).warning("Bash cross-file call resolution failed, skipping: %s", exc)
+        print(f"  resolving bash_source_edges: {len(sh_pairs)} files ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Cross-file call resolution for all languages
     # Each extractor saved unresolved calls in raw_calls. Now that we have all
@@ -6198,7 +6230,20 @@ def _looks_like_bash(result: object) -> bool:
     # of these files with no import evidence is gated below (#1659).
     _JS_TS_CALL_SUFFIXES = (".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs")
     _go_module_cache: dict[Path, str | None] = {}
-    for rc in all_raw_calls:
+    _RAW_CALL_PROGRESS_INTERVAL = 5000
+    _raw_call_total = len(all_raw_calls)
+    _raw_call_t0 = time.perf_counter()
+    for _rc_idx, rc in enumerate(all_raw_calls):
+        if (
+            _raw_call_total >= _RAW_CALL_PROGRESS_INTERVAL
+            and _rc_idx % _RAW_CALL_PROGRESS_INTERVAL == 0
+            and _rc_idx > 0
+        ):
+            print(
+                f"  resolving cross-file calls: {_rc_idx}/{_raw_call_total} raw calls "
+                f"({_rc_idx * 100 // _raw_call_total}%, {time.perf_counter() - _raw_call_t0:.1f}s)",
+                flush=True,
+            )
         callee = rc.get("callee", "")
         if not callee:
             continue
@@ -6390,6 +6435,12 @@ def _has_import_evidence(candidate_id: str) -> bool:
                 "source_location": rc.get("source_location"),
                 "weight": 1.0,
             })
+    if _raw_call_total >= _RAW_CALL_PROGRESS_INTERVAL:
+        print(
+            f"  resolving cross-file calls: {_raw_call_total}/{_raw_call_total} raw calls "
+            f"(100%, {time.perf_counter() - _raw_call_t0:.1f}s)",
+            flush=True,
+        )
 
     # Cross-file, language-specific member-call resolution. Runs after the shared
     # call pass so node ids/caller_nids are final; each pass is additive (only the
@@ -6405,6 +6456,7 @@ def _has_import_evidence(candidate_id: str) -> bool:
     # results: raw_calls come solely from `paths`, so nothing sourced by an
     # unchanged file is ever emitted, and the ambiguity guards count the same
     # candidates a full build would (the context is the whole unchanged corpus).
+    _t0 = time.perf_counter()
     if resolution_context_nodes or resolution_context_edges:
         _rl_nodes = list(resolution_nodes)
         _rl_edges = all_edges + list(resolution_context_edges or [])
@@ -6414,6 +6466,7 @@ def _has_import_evidence(candidate_id: str) -> bool:
         all_edges.extend(_rl_edges[_e0:])
     else:
         run_language_resolvers(paths, per_file, all_nodes, all_edges)
+    print(f"  resolving language_resolvers (member calls): done ({time.perf_counter() - _t0:.1f}s)", flush=True)
 
     # Relativize source_file fields so paths are portable across machines (#555).
     # When the node's id was itself minted from the absolute path, remap it to a
diff --git a/graphify/extractors/csharp.py b/graphify/extractors/csharp.py
index 3aa34e0ed..33bb6c7ad 100644
--- a/graphify/extractors/csharp.py
+++ b/graphify/extractors/csharp.py
@@ -366,19 +366,24 @@ def _label_for_type_ref_target(target_node: dict, source_file: str) -> str | Non
                 return alias
         return stem or None
 
+    # Index placeholder nodes by label once (was a full all_nodes scan per edge on
+    # the common unresolved path, giving O(cs_edges * all_nodes)). Keeps the first
+    # placeholder seen per label, matching the prior first-match-wins order; stubs
+    # created below are registered so later edges reuse them.
+    placeholder_stub_by_label: dict[str, str] = {}
+    for node in all_nodes:
+        nid = node.get("id")
+        if isinstance(nid, str) and _is_placeholder(node):
+            placeholder_stub_by_label.setdefault(node.get("label"), nid)
+
     def _dangling_stub_id(label: str, current_target: object) -> str:
         current = node_by_id.get(current_target)
         if _is_placeholder(current) and current.get("label") == label:
             return str(current_target)
 
-        for node in all_nodes:
-            nid = node.get("id")
-            if (
-                isinstance(nid, str)
-                and node.get("label") == label
-                and _is_placeholder(node)
-            ):
-                return nid
+        existing = placeholder_stub_by_label.get(label)
+        if existing is not None:
+            return existing
 
         stem = _make_id(label)
         stub_id = stem
@@ -397,6 +402,7 @@ def _dangling_stub_id(label: str, current_target: object) -> str:
         }
         all_nodes.append(node)
         node_by_id[stub_id] = node
+        placeholder_stub_by_label.setdefault(label, stub_id)
         return stub_id
 
     REPOINT_RELATIONS = {"implements", "inherits", "references"}
diff --git a/graphify/llm.py b/graphify/llm.py
index 2640429cb..5aff3ca88 100644
--- a/graphify/llm.py
+++ b/graphify/llm.py
@@ -1153,6 +1153,106 @@ def _backend_pkg_hint(pkg: str, extra: str) -> str:
     )
 
 
+class BackendConfigError(Exception):
+    """A backend cannot run because of missing config or a missing SDK.
+
+    Distinct from the recoverable network/API/JSON-parse failures that the
+    labeling and extraction paths retry or degrade past: a config/dependency
+    error will fail *every* call identically, so it is surfaced loudly (even
+    when quiet) and never swallowed into placeholder labels (F-002 addendum).
+    """
+
+
+# Which optional SDK each backend imports at call time, as (pkg, extra) for
+# _backend_pkg_hint. Ollama/OpenAI/Kimi/Gemini/DeepSeek/Azure go through the
+# OpenAI-compatible client, so they all need `openai`; claude needs `anthropic`;
+# bedrock needs `boto3`. Backends with no importable SDK (claude-cli) map to None.
+_BACKEND_SDK: dict[str, tuple[str, str]] = {
+    "claude": ("anthropic", "anthropic"),
+    "kimi": ("openai", "kimi"),
+    "ollama": ("openai", "ollama"),
+    "gemini": ("openai", "gemini"),
+    "openai": ("openai", "openai"),
+    "deepseek": ("openai", "openai"),
+    "azure": ("openai", "openai"),
+    "bedrock": ("boto3", "bedrock"),
+}
+
+# Local/self-hosted backends whose traffic never leaves the user's machine (or
+# their own configured host). Everything else in BACKENDS is treated as a cloud
+# backend for the privacy notice in detect_backend().
+_LOCAL_BACKENDS = frozenset({"ollama", "claude-cli"})
+
+
+def _backend_sdk_requirement(backend: str) -> tuple[str, str] | None:
+    """Return (pkg, extra) for the SDK ``backend`` imports, or None if it needs none.
+
+    Custom providers (not in the built-in map) route through the
+    OpenAI-compatible client, so they require `openai` too.
+    """
+    if backend in _BACKEND_SDK:
+        return _BACKEND_SDK[backend]
+    if backend in BACKENDS and backend != "claude-cli":
+        return ("openai", "openai")
+    return None
+
+
+def _call_path_is_real() -> bool:
+    """True unless a caller (tests, an embedder) has replaced the LLM transport.
+
+    The SDK import in :func:`preflight_backend` is a fast-fail optimization; it
+    must not fire when the real ``_call_llm`` / ``_call_openai_compat`` has been
+    monkeypatched, since then the vendored SDK is never imported. Originals are
+    captured once the functions are defined (``_capture_original_call_path``);
+    before that (import-time), assume the real path.
+    """
+    orig_llm = globals().get("_ORIG_CALL_LLM")
+    if orig_llm is not None and globals().get("_call_llm") is not orig_llm:
+        return False
+    orig_compat = globals().get("_ORIG_CALL_OPENAI_COMPAT")
+    if orig_compat is not None and globals().get("_call_openai_compat") is not orig_compat:
+        return False
+    return True
+
+
+def preflight_backend(backend: str, *, api_key: str | None = None) -> None:
+    """Fail fast if ``backend``'s SDK is missing or its key/config is absent.
+
+    Called at the start of the labeling/extraction entry points so a
+    missing-dependency or missing-key error is raised *before* any work is done,
+    with the actionable install/config message rather than after processing.
+    Raises :class:`BackendConfigError`; never returns a value.
+    """
+    if backend not in BACKENDS:
+        raise BackendConfigError(f"Unknown backend {backend!r}. Available: {sorted(BACKENDS)}")
+    # The SDK + key checks only apply when the real LLM transport is in use. If a
+    # caller has swapped out `_call_llm`/`_call_openai_compat` (tests, or an
+    # embedder that supplies its own transport), neither the vendored SDK nor the
+    # env key is actually needed — and a real missing SDK/key still surfaces
+    # loudly via the call path (caught as a config/dependency error in
+    # generate_community_labels). Skipping here just avoids a false fast-fail.
+    if not _call_path_is_real():
+        return
+    req = _backend_sdk_requirement(backend)
+    if req is not None:
+        pkg, extra = req
+        try:
+            __import__(pkg)
+        except ImportError as exc:
+            raise BackendConfigError(
+                f"labeling disabled: {_backend_pkg_hint(pkg, extra)}"
+            ) from exc
+    # Key/config presence. Ollama authenticates with a placeholder; bedrock and
+    # claude-cli use ambient credentials/subscription rather than an env key.
+    if backend in ("ollama", "bedrock", "claude-cli"):
+        return
+    if not (api_key or _get_backend_api_key(backend)):
+        raise BackendConfigError(
+            f"labeling disabled: no API key for backend '{backend}'. "
+            f"Set {_format_backend_env_keys(backend)} or pass api_key=."
+        )
+
+
 def _call_openai_compat(
     base_url: str,
     api_key: str,
@@ -2766,6 +2866,12 @@ def _ollama_host_is_link_local_or_metadata(host: str) -> bool:
     return False
 
 
+# Capture the real LLM transport once both are defined, so preflight_backend can
+# tell whether a caller has monkeypatched it (see _call_path_is_real).
+_ORIG_CALL_LLM = _call_llm
+_ORIG_CALL_OPENAI_COMPAT = _call_openai_compat
+
+
 def _validate_ollama_base_url(url: str, *, warn: bool = True) -> None:
     """Warn if OLLAMA_BASE_URL looks unsafe; hard-block link-local/metadata (F3).
 
@@ -2813,6 +2919,46 @@ def _validate_ollama_base_url(url: str, *, warn: bool = True) -> None:
         )
 
 
+# Set once a cloud-backend privacy notice has been printed, so the "identifiers
+# will be sent to <backend>" line appears at most once per run no matter how many
+# times detect_backend() is called (labeling + extraction both call it).
+_cloud_backend_notified = False
+
+
+def _resolve_backend_base_url(backend: str) -> str:
+    """Best-effort base_url for a backend, for the privacy notice. Never raises."""
+    cfg = BACKENDS.get(backend, {})
+    url = str(cfg.get("base_url", "") or "")
+    if not url and backend == "azure":
+        url = str(os.environ.get("AZURE_OPENAI_ENDPOINT", "") or "")
+    if not url and backend == "bedrock":
+        url = f"AWS ({os.environ.get('AWS_REGION') or os.environ.get('AWS_DEFAULT_REGION') or 'default region'})"
+    return url or "the provider's API"
+
+
+def _notify_cloud_backend_selected(backend: str, *, auto: bool) -> None:
+    """Print a one-time, always-visible privacy notice when a CLOUD backend is
+    selected — labeling ships code identifiers and extraction ships file contents
+    to it, so a stray key silently routing private symbols to the cloud (e.g. an
+    incidental GEMINI_API_KEY) is made visible. Never printed for ollama/local
+    (traffic stays on the user's own host). Mirrors the Ollama corpus warning.
+    """
+    global _cloud_backend_notified
+    if backend in _LOCAL_BACKENDS or _cloud_backend_notified:
+        return
+    _cloud_backend_notified = True
+    model = _default_model_for_backend(backend)
+    url = _resolve_backend_base_url(backend)
+    if auto:
+        print(
+            f"graphify: using {backend} ({model}) at {url} — "
+            "code identifiers/content will be sent there.",
+            file=sys.stderr,
+        )
+    else:
+        print(f"graphify: using {backend} ({model}) at {url}.", file=sys.stderr)
+
+
 def detect_backend() -> str | None:
     """Return the name of whichever backend has an API key set, or None.
 
@@ -2826,10 +2972,13 @@ def detect_backend() -> str | None:
     """
     for backend in ("gemini", "kimi", "claude", "openai", "deepseek"):
         if _get_backend_api_key(backend):
+            _notify_cloud_backend_selected(backend, auto=True)
             return backend
     if _get_backend_api_key("azure") and os.environ.get("AZURE_OPENAI_ENDPOINT"):
+        _notify_cloud_backend_selected("azure", auto=True)
         return "azure"
     if os.environ.get("AWS_PROFILE") or os.environ.get("AWS_REGION") or os.environ.get("AWS_DEFAULT_REGION"):
+        _notify_cloud_backend_selected("bedrock", auto=True)
         return "bedrock"
     # Honor Ollama's own OLLAMA_HOST here too, not just OLLAMA_BASE_URL (#1940) —
     # otherwise a user who set the standard Ollama var but no --backend still
@@ -2842,6 +2991,7 @@ def detect_backend() -> str | None:
     for name in BACKENDS:
         if name not in ("gemini", "kimi", "claude", "openai", "deepseek", "azure", "bedrock", "ollama", "claude-cli"):
             if _get_backend_api_key(name):
+                _notify_cloud_backend_selected(name, auto=True)
                 return name
     return None
 
@@ -3132,8 +3282,11 @@ def generate_community_labels(
 ) -> tuple[dict[int, str], str]:
     """CLI entry point: resolve a backend, name communities, and degrade to
     ``Community N`` placeholders on any failure (no backend, API error, malformed
-    reply). Returns ``(labels, source)`` where source is ``"llm"`` or
-    ``"placeholder"``. Never raises."""
+    reply). Returns ``(labels, source)`` where source is ``"llm"``,
+    ``"placeholder"`` (recoverable failure — a few batches degraded), or
+    ``"disabled"`` (a CONFIG/DEPENDENCY error: the backend's SDK is missing or its
+    key/config is absent; reported loudly even when ``quiet=True``, since it would
+    fail every call identically). Never raises."""
     if backend is None:
         try:
             backend = detect_backend()
@@ -3147,14 +3300,28 @@ def generate_community_labels(
                 file=sys.stderr,
             )
         return _placeholder_community_labels(communities), "placeholder"
+    # Preflight the SDK + key BEFORE labeling any community, so a missing
+    # dependency / missing key fails fast with the actionable message instead of
+    # after processing (FIX 2). A config/dependency error is not recoverable and
+    # would fail every batch identically, so it is surfaced loudly even when
+    # quiet — never swallowed into placeholders like a transient API failure.
     try:
+        preflight_backend(backend)
         labels = label_communities(
             G, communities, backend=backend, model=model, gods=gods,
             max_concurrency=max_concurrency, batch_size=batch_size,
             usage_out=usage_out,
         )
         return labels, "llm"
-    except Exception as exc:
+    except (BackendConfigError, ImportError) as exc:
+        # CONFIG/DEPENDENCY error: always visible (even with quiet=True) and
+        # tagged as "disabled" so the caller can distinguish it from a
+        # partially-labeled run that degraded on a few transient failures.
+        print(f"[graphify label] {exc}", file=sys.stderr)
+        return _placeholder_community_labels(communities), "disabled"
+    except (json.JSONDecodeError, ValueError, OSError, RuntimeError) as exc:
+        # Recoverable network / API / JSON-parse failure only — degrade to
+        # placeholders. Programming/config errors are handled above or propagate.
         if not quiet:
             print(
                 f"[graphify label] warning: community labeling failed ({exc}); "
diff --git a/graphify/resolver_registry.py b/graphify/resolver_registry.py
index b17478a78..190750ffa 100644
--- a/graphify/resolver_registry.py
+++ b/graphify/resolver_registry.py
@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import logging
+import time
 from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -79,7 +80,12 @@ def run_language_resolvers(
     for resolver in active:
         if not (resolver.suffixes & suffixes_present):
             continue
+        start = time.perf_counter()
         try:
             resolver.resolve(per_file, all_nodes, all_edges)
         except Exception as exc:
             _LOG.warning("%s resolution failed, skipping: %s", resolver.name, exc)
+        print(
+            f"  resolving {resolver.name}: done ({time.perf_counter() - start:.1f}s)",
+            flush=True,
+        )