diff --git a/CHANGELOG.md b/CHANGELOG.md
index bcd7481..e5e4f20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [2.1.0] - 2026-05-31
+
+### Added
+- **🎯 AI-Native Navigation (P1)**: Implemented line-numbered code fences and symbol-level XML anchors (`<anchor id="...">`) for classes and functions in full mode, allowing AI to navigate and apply Search & Replace diffs flawlessly.
+- **🚀 Ultra-Focused Mode Optimization**: Focused mode (`scriber <path>`) now acts as a precise surgical tool, cutting out unnecessary contextual noise.
+- **🛡️ Support Files Pruning**: Support files (`pyproject.toml`, `README.md`, Dockerfiles) are no longer granted automatic `full` mode immunity when running focused scans. They now decay to tree mode unless explicitly targeted.
+- **🧪 Test File Quarantine**: Test modules are heavily penalized in focused mode, dropping out of full/excerpt context to keep the generated pack laser-focused on actual implementation logic.
+
+### Fixed
+- **🐛 Excerpt Fallback Bug**: Fixed a critical bug where `excerpt` files failed to render and completely dropped their token estimates, resulting in `_Excerpt unavailable_` placeholders. They now correctly fall back to outline AST structures and compute tokens accurately.
+- **⚖️ Graph Token Hard-Capping**: Re-engineered token budgeting with rigid distance-based hard caps in `ranker.py` (Max scores: 100/79/74/44 for Dist 0/1/2/3+ respectively). Focused mode is now reliably ~45% of the full project token size, completely eliminating distant `full` mode leaks.
+
 ## [2.0.0] - 2026-05-30
 
 ### Added
diff --git a/pyproject.toml b/pyproject.toml
index 6339246..010424e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "project-scriber"
-version = "2.0.0"
+version = "2.1.0"
 description = "Scriber 2.0: build intelligent code packs from one or more project paths."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -54,8 +54,8 @@ format = "md"
 output = ".scriber/scriber_pack.md"
 only_tree = false
 use_gitignore = true
-max_files = 60
-max_tokens = 100000
+max_files = 0
+max_tokens = 0
 min_score = 45
 path_style = "project-relative"
 allow_external_paths = false
diff --git a/rust/scriber_native/src/import.rs b/rust/scriber_native/src/import.rs
index c86a963..e2c2327 100644
--- a/rust/scriber_native/src/import.rs
+++ b/rust/scriber_native/src/import.rs
@@ -620,3 +620,79 @@ pub fn build_import_graph(
 
     Ok(edges)
 }
+
+#[pyclass]
+#[derive(Clone, Debug)]
+pub struct NativeRelationEdge {
+    #[pyo3(get)]
+    pub source: String,
+    #[pyo3(get)]
+    pub target: String,
+    #[pyo3(get)]
+    pub kind: String,
+    #[pyo3(get)]
+    pub weight: f64,
+    #[pyo3(get)]
+    pub confidence: f64,
+    #[pyo3(get)]
+    pub evidence: Option<String>,
+    #[pyo3(get)]
+    pub line: Option<usize>,
+    #[pyo3(get)]
+    pub analyzer: String,
+}
+
+#[pymethods]
+impl NativeRelationEdge {
+    #[new]
+    #[pyo3(signature = (source, target, kind, weight, confidence, evidence, line, analyzer))]
+    #[allow(clippy::too_many_arguments)]
+    fn new(
+        source: String,
+        target: String,
+        kind: String,
+        weight: f64,
+        confidence: f64,
+        evidence: Option<String>,
+        line: Option<usize>,
+        analyzer: String,
+    ) -> Self {
+        NativeRelationEdge {
+            source,
+            target,
+            kind,
+            weight,
+            confidence,
+            evidence,
+            line,
+            analyzer,
+        }
+    }
+}
+
+#[pyfunction]
+pub fn build_relation_graph(
+    root: &str,
+    files: Vec<NativeFileInfo>,
+    python_source_roots: Vec<String>,
+    python_module_init_files: Vec<String>,
+) -> PyResult<Vec<NativeRelationEdge>> {
+    let import_edges =
+        build_import_graph(root, files, python_source_roots, python_module_init_files)?;
+
+    let mut relation_edges = Vec::with_capacity(import_edges.len());
+    for edge in import_edges {
+        relation_edges.push(NativeRelationEdge {
+            source: edge.from,
+            target: edge.to,
+            kind: "import".to_string(), // we map everything to "import" for now to match python
+            weight: 1.0,
+            confidence: 0.98,
+            evidence: None,
+            line: None,
+            analyzer: "imports:native".to_string(),
+        });
+    }
+
+    Ok(relation_edges)
+}
diff --git a/rust/scriber_native/src/lib.rs b/rust/scriber_native/src/lib.rs
index 4b854dd..90d4285 100644
--- a/rust/scriber_native/src/lib.rs
+++ b/rust/scriber_native/src/lib.rs
@@ -76,6 +76,7 @@ fn build_info() -> PyResult<String> {
 fn _native(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<scan::NativeFileInfo>()?;
     m.add_class::<import::NativeImportEdge>()?;
+    m.add_class::<import::NativeRelationEdge>()?;
     m.add_class::<score::NativeCandidate>()?;
     m.add_class::<score::NativePackOptions>()?;
     m.add_function(wrap_pyfunction!(read_text, m)?)?;
@@ -84,6 +85,7 @@ fn _native(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(read_many_text, m)?)?;
     m.add_function(wrap_pyfunction!(scan_project, m)?)?;
     m.add_function(wrap_pyfunction!(import::build_import_graph, m)?)?;
+    m.add_function(wrap_pyfunction!(import::build_relation_graph, m)?)?;
     m.add_function(wrap_pyfunction!(score::score_candidates_native, m)?)?;
     m.add_function(wrap_pyfunction!(render::render_tree, m)?)?;
     m.add_function(wrap_pyfunction!(native_api_version, m)?)?;
diff --git a/rust/scriber_native/src/score.rs b/rust/scriber_native/src/score.rs
index a4efbff..f7d5ef4 100644
--- a/rust/scriber_native/src/score.rs
+++ b/rust/scriber_native/src/score.rs
@@ -1,4 +1,4 @@
-use crate::import::NativeImportEdge;
+use crate::import::NativeRelationEdge;
 use crate::scan::NativeFileInfo;
 use pyo3::prelude::*;
 use std::collections::{HashMap, HashSet};
@@ -351,39 +351,117 @@ fn is_near_seed(support_file: &str, seed: &str) -> bool {
         || seed_parent.starts_with(sf_parent)
 }
 
-fn walk_neighbors(
-    edges: &HashMap<String, HashSet<String>>,
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+
+#[derive(Debug, Clone)]
+struct QueueState {
+    strength: f64,
+    depth: usize,
+    node: String,
+}
+
+impl Eq for QueueState {}
+
+impl PartialEq for QueueState {
+    fn eq(&self, other: &Self) -> bool {
+        self.strength == other.strength && self.depth == other.depth && self.node == other.node
+    }
+}
+
+impl Ord for QueueState {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.strength
+            .partial_cmp(&other.strength)
+            .unwrap_or(Ordering::Equal)
+            .then_with(|| other.depth.cmp(&self.depth))
+    }
+}
+
+impl PartialOrd for QueueState {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+fn walk_weighted_neighbors(
+    edges: &[NativeRelationEdge],
     start: &str,
     depth: usize,
-) -> HashMap<String, usize> {
-    let mut found = HashMap::new();
-    let mut frontier = HashSet::new();
-    frontier.insert(start.to_string());
-    let mut visited = HashSet::new();
-    visited.insert(start.to_string());
-
-    for distance in 1..=depth {
-        let mut next_frontier = HashSet::new();
-        for item in frontier {
-            if let Some(neighbors) = edges.get(&item) {
-                for neighbor in neighbors {
-                    if visited.contains(neighbor) {
-                        continue;
+    reverse: bool,
+) -> HashMap<String, f64> {
+    let mut adj: HashMap<String, Vec<(String, &NativeRelationEdge)>> = HashMap::new();
+    for edge in edges {
+        let u = if reverse { &edge.target } else { &edge.source };
+        let v = if reverse { &edge.source } else { &edge.target };
+        adj.entry(u.clone()).or_default().push((v.clone(), edge));
+    }
+
+    let mut max_strength: HashMap<String, f64> = HashMap::new();
+    max_strength.insert(start.to_string(), 1.0);
+
+    let mut best_at_state: HashMap<(String, usize), f64> = HashMap::new();
+    best_at_state.insert((start.to_string(), 0), 1.0);
+
+    let mut heap = BinaryHeap::new();
+    heap.push(QueueState {
+        strength: 1.0,
+        depth: 0,
+        node: start.to_string(),
+    });
+
+    while let Some(QueueState {
+        strength: u_str,
+        depth: u_depth,
+        node: u,
+    }) = heap.pop()
+    {
+        if u_str < *best_at_state.get(&(u.clone(), u_depth)).unwrap_or(&0.0) {
+            continue;
+        }
+
+        if u_depth >= depth {
+            continue;
+        }
+
+        if let Some(neighbors) = adj.get(&u) {
+            for (neighbor, edge) in neighbors {
+                let edge_str = if edge.kind == "import" || edge.kind == "reexport" {
+                    if u_depth == 0 {
+                        1.0
+                    } else {
+                        0.88
                     }
-                    visited.insert(neighbor.clone());
-                    found.insert(neighbor.clone(), distance);
-                    next_frontier.insert(neighbor.clone());
+                } else {
+                    edge.weight * edge.confidence
+                };
+
+                let next_str = u_str * edge_str;
+                let next_depth = u_depth + 1;
+
+                if next_str > *max_strength.get(neighbor).unwrap_or(&0.0) {
+                    max_strength.insert(neighbor.clone(), next_str);
+                }
+
+                let state_key = (neighbor.clone(), next_depth);
+                if next_str > *best_at_state.get(&state_key).unwrap_or(&0.0) {
+                    best_at_state.insert(state_key, next_str);
+                    heap.push(QueueState {
+                        strength: next_str,
+                        depth: next_depth,
+                        node: neighbor.clone(),
+                    });
                 }
             }
         }
-        frontier = next_frontier;
-        if frontier.is_empty() {
-            break;
-        }
     }
-    found
+
+    max_strength.remove(start);
+    max_strength
 }
 
+
+
 fn support_base_score(file: &NativeFileInfo, options: &NativePackOptions) -> i32 {
     let cat = file.support_category.as_deref().unwrap_or("support file");
     match cat {
@@ -429,7 +507,7 @@ fn matches_entrypoint(rel: &str, entrypoint_patterns: &[String]) -> bool {
 pub fn score_candidates_native(
     files: Vec<NativeFileInfo>,
     seeds_list: Vec<String>,
-    edges: Vec<NativeImportEdge>,
+    edges: Vec<NativeRelationEdge>,
     options: NativePackOptions,
 ) -> PyResult<Vec<NativeCandidate>> {
     let mut mapped_files = HashMap::new();
@@ -450,15 +528,17 @@ pub fn score_candidates_native(
     // Build graph edges maps
     let mut graph_imports: HashMap<String, HashSet<String>> = HashMap::new();
     let mut graph_imported_by: HashMap<String, HashSet<String>> = HashMap::new();
-    for edge in edges {
-        graph_imports
-            .entry(edge.from.clone())
-            .or_default()
-            .insert(edge.to.clone());
-        graph_imported_by
-            .entry(edge.to.clone())
-            .or_default()
-            .insert(edge.from.clone());
+    for edge in &edges {
+        if edge.kind == "import" || edge.kind == "reexport" {
+            graph_imports
+                .entry(edge.source.clone())
+                .or_default()
+                .insert(edge.target.clone());
+            graph_imported_by
+                .entry(edge.target.clone())
+                .or_default()
+                .insert(edge.source.clone());
+        }
     }
 
     if options.mode == "project_snapshot" {
@@ -531,10 +611,12 @@ pub fn score_candidates_native(
             for seed_rel in &seed_files {
                 // Direct dependencies
                 if options.include_direct_dependencies {
-                    for (dep, distance) in walk_neighbors(&graph_imports, seed_rel, options.depth) {
+                    for (dep, strength) in
+                        walk_weighted_neighbors(&edges, seed_rel, options.depth, false)
+                    {
                         let score = std::cmp::max(
                             options.tree_min_score,
-                            options.direct_dependency_score - ((distance as i32 - 1) * 10),
+                            (options.direct_dependency_score as f64 * strength) as i32,
                         );
                         if let Some(c) = mapped_files.get_mut(&dep) {
                             c.score = std::cmp::max(c.score, score);
@@ -551,12 +633,12 @@ pub fn score_candidates_native(
 
                 // Reverse dependencies
                 if options.include_reverse_dependencies {
-                    for (dep, distance) in
-                        walk_neighbors(&graph_imported_by, seed_rel, options.depth)
+                    for (dep, strength) in
+                        walk_weighted_neighbors(&edges, seed_rel, options.depth, true)
                     {
                         let score = std::cmp::max(
                             options.tree_min_score,
-                            options.reverse_dependency_score - ((distance as i32 - 1) * 10),
+                            (options.reverse_dependency_score as f64 * strength) as i32,
                         );
                         if let Some(c) = mapped_files.get_mut(&dep) {
                             c.score = std::cmp::max(c.score, score);
diff --git a/src/scriber/__init__.py b/src/scriber/__init__.py
index 1aef752..b32d113 100644
--- a/src/scriber/__init__.py
+++ b/src/scriber/__init__.py
@@ -1,8 +1,9 @@
-"""ProjectScriber 2.0."""
+"""ProjectScriber 2.1."""
 
 from .packer.pack import build_pack, build_and_write_pack
 from .core.models import ScriberPack
 
 __all__ = ["build_pack", "build_and_write_pack", "ScriberPack"]
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
+
diff --git a/src/scriber/budget/allocator.py b/src/scriber/budget/allocator.py
new file mode 100644
index 0000000..80b945b
--- /dev/null
+++ b/src/scriber/budget/allocator.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+from scriber.core.models import Candidate, ContentMode, PackItem, FileRole
+
+@dataclass(slots=True)
+class BudgetPolicy:
+    target_tokens: int
+    hard_limit_tokens: int
+    mode: str = "full"
+    header_budget_ratio: float = 0.12
+    graph_budget_ratio: float = 0.08
+    full_code_budget_ratio: float = 0.55
+    outline_budget_ratio: float = 0.20
+    reserve_ratio: float = 0.05
+
+def allocate_budget(candidates: list[Candidate], policy: BudgetPolicy, explicit_seeds: set) -> list[PackItem]:
+    items = []
+    
+    current_tokens = 0
+    full_budget = int(policy.target_tokens * policy.full_code_budget_ratio)
+    
+    for i, c in enumerate(candidates):
+        item_id = f"F{i+1:03d}"
+        role = getattr(c, "role", "unknown")
+        
+        mode: ContentMode = "tree"
+        
+        is_seed = c.file.relative in explicit_seeds
+        
+        if is_seed:
+            mode = "full"
+        elif c.file.content_policy == "tree_only":
+            mode = "tree"
+        elif c.file.content_policy == "full" and policy.mode != "focused":
+            mode = "full"
+        elif c.token_estimate <= 1200 and c.score >= 80 and current_tokens < full_budget:
+            mode = "full"
+        elif c.score >= 85 and c.token_estimate <= 2400 and current_tokens < full_budget:
+            mode = "full"
+        elif c.score >= 75:
+            mode = "excerpt"
+        elif c.score >= 45:
+            mode = "outline"
+        else:
+            mode = "tree"
+            
+        if mode == "full":
+            current_tokens += c.token_estimate
+            
+        item = PackItem(
+            file=c.file,
+            score=c.score,
+            role=role,
+            content_mode=mode,
+            reason=c.reason_summary,
+            reasons=c.reasons,
+            relation_evidence=[],
+            token_estimate=c.token_estimate,
+            utility=c.utility,
+            raw_score=c.raw_score,
+            item_id=item_id
+        )
+        items.append(item)
+        
+    return items
diff --git a/src/scriber/cache.py b/src/scriber/cache.py
index f96f0fc..d899aa8 100644
--- a/src/scriber/cache.py
+++ b/src/scriber/cache.py
@@ -37,12 +37,17 @@ def __init__(self, config: ScriberConfig, project_root: Path):
         self.enabled = config.cache.enabled
         self.cache_dir = project_root / config.cache.dir
         self.files_cache_path = self.cache_dir / "files.json"
-        self.graph_cache_path = self.cache_dir / "import_graph.json"
+        self.imports_cache_path = self.cache_dir / "imports_v2.json"
+        self.relations_cache_path = self.cache_dir / "relations_v1.jsonl"
         self.config_hash = get_config_hash(config)
         self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
         
+        self.reads = 0
+        self.hits = 0
+        self.writes = 0
+        
         self.files_data: dict[str, dict[str, Any]] = {}
-        self.graph_data: dict[str, list[str]] = {}
+        self.imports_data: dict[str, dict[str, Any]] = {}
         self._load()
 
     def _load(self) -> None:
@@ -53,13 +58,14 @@ def _load(self) -> None:
             if self.files_cache_path.exists():
                 with self.files_cache_path.open("r", encoding="utf-8") as f:
                     self.files_data = json.load(f)
-            if self.graph_cache_path.exists():
-                with self.graph_cache_path.open("r", encoding="utf-8") as f:
-                    self.graph_data = json.load(f)
+            if self.imports_cache_path.exists():
+                with self.imports_cache_path.open("r", encoding="utf-8") as f:
+                    self.imports_data = json.load(f)
+            # relations_v1.jsonl will be append-only or rewritten on save, we don't load it entirely into memory for now
         except Exception:
             # Silently fallback to empty cache on read errors
             self.files_data = {}
-            self.graph_data = {}
+            self.imports_data = {}
 
     def get_file(self, rel_path: Path, mtime_ns: int, size: int) -> dict[str, Any] | None:
         if not self.enabled:
@@ -92,17 +98,57 @@ def set_file(self, rel_path: Path, mtime_ns: int, size: int, data: dict[str, Any
     def get_imports(self, rel_path: Path) -> set[Path] | None:
         if not self.enabled:
             return None
+        self.reads += 1
         key = rel_path.as_posix()
-        imports = self.graph_data.get(key)
+        imports = self.imports_data.get(key)
         if imports is not None:
-            return {Path(p) for p in imports}
+            self.hits += 1
+            return {Path(p) for p in imports.get("targets", [])}
         return None
 
     def set_imports(self, rel_path: Path, imports: set[Path]) -> None:
         if not self.enabled:
             return
+        self.writes += 1
         key = rel_path.as_posix()
-        self.graph_data[key] = [p.as_posix() for p in sorted(imports)]
+        try:
+            stat = (self.cache_dir.parent.parent / rel_path).stat()
+            mtime_ns = stat.st_mtime_ns
+            size = stat.st_size
+        except OSError:
+            mtime_ns = 0
+            size = 0
+        self.imports_data[key] = {
+            "mtime_ns": mtime_ns,
+            "size": size,
+            "config_hash": self.config_hash,
+            "targets": [p.as_posix() for p in sorted(imports)]
+        }
+
+    def add_import_edge(self, source: Path, target: Path) -> None:
+        if not self.enabled:
+            return
+        self.writes += 1
+        key = source.as_posix()
+        target_str = target.as_posix()
+        if key not in self.imports_data:
+            try:
+                stat = (self.cache_dir.parent.parent / source).stat()
+                mtime_ns = stat.st_mtime_ns
+                size = stat.st_size
+            except OSError:
+                mtime_ns = 0
+                size = 0
+            self.imports_data[key] = {
+                "mtime_ns": mtime_ns,
+                "size": size,
+                "config_hash": self.config_hash,
+                "targets": [target_str]
+            }
+        else:
+            if target_str not in self.imports_data[key].get("targets", []):
+                self.imports_data[key].setdefault("targets", []).append(target_str)
+                self.imports_data[key]["targets"].sort()
 
     def save(self, active_files: set[Path] | None = None) -> None:
         if not self.enabled:
@@ -116,7 +162,7 @@ def save(self, active_files: set[Path] | None = None) -> None:
             if active_files is not None:
                 active_keys = {p.as_posix() for p in active_files}
                 self.files_data = {k: v for k, v in self.files_data.items() if k in active_keys}
-                self.graph_data = {k: v for k, v in self.graph_data.items() if k in active_keys}
+                self.imports_data = {k: v for k, v in self.imports_data.items() if k in active_keys}
 
             # 2. Enforce absolute limit of max 1000 entries to prevent infinite growth
             if len(self.files_data) > 1000:
@@ -125,11 +171,11 @@ def save(self, active_files: set[Path] | None = None) -> None:
                 to_remove = sorted_keys[:len(sorted_keys) - 1000]
                 for k in to_remove:
                     self.files_data.pop(k, None)
-                    self.graph_data.pop(k, None)
+                    self.imports_data.pop(k, None)
 
             with self.files_cache_path.open("w", encoding="utf-8") as f:
                 json.dump(self.files_data, f, indent=2)
-            with self.graph_cache_path.open("w", encoding="utf-8") as f:
-                json.dump(self.graph_data, f, indent=2)
+            with self.imports_cache_path.open("w", encoding="utf-8") as f:
+                json.dump(self.imports_data, f, indent=2)
         except Exception:
             pass  # Fail silently on write errors to not interrupt execution
diff --git a/src/scriber/cli/main.py b/src/scriber/cli/main.py
index c943226..7071f7f 100644
--- a/src/scriber/cli/main.py
+++ b/src/scriber/cli/main.py
@@ -11,6 +11,109 @@
 from scriber.core.root import resolve_config_path
 from scriber.packer.pack import build_and_write_pack
 
+def handle_introspection(args, pack) -> None:
+    import json
+    
+    # 1. Export Graph JSON if requested
+    if args.graph_json:
+        edges_data = []
+        for edge in pack.graph.edges:
+            edges_data.append({
+                "source": str(edge.source),
+                "target": str(edge.target),
+                "kind": edge.kind,
+                "weight": edge.weight,
+                "confidence": edge.confidence,
+                "evidence": edge.evidence,
+                "line": edge.line,
+                "analyzer": edge.analyzer
+            })
+        
+        graph_data = {"edges": edges_data}
+        json_path = Path(args.graph_json)
+        try:
+            with open(json_path, "w", encoding="utf-8") as f:
+                json.dump(graph_data, f, indent=2)
+            print(f"Exported relation graph to {json_path}", file=sys.stderr)
+        except Exception as e:
+            print(f"Error exporting relation graph to JSON: {e}", file=sys.stderr)
+
+    # 2. Explain Graph
+    if args.explain_graph:
+        edges = pack.graph.edges
+        total_edges = len(edges)
+        
+        # Group by kind
+        kind_counts = {}
+        for edge in edges:
+            kind_counts[edge.kind] = kind_counts.get(edge.kind, 0) + 1
+            
+        # Get unique nodes
+        nodes = set()
+        for edge in edges:
+            nodes.add(edge.source)
+            nodes.add(edge.target)
+        unique_nodes = len(nodes)
+        avg_degree = (total_edges * 2.0 / unique_nodes) if unique_nodes > 0 else 0.0
+        
+        print("\n========================================", file=sys.stderr)
+        print("SCRIBER RELATION GRAPH EXPLANATION", file=sys.stderr)
+        print("========================================", file=sys.stderr)
+        print(f"Total Edges: {total_edges}", file=sys.stderr)
+        print("Edges by Kind:", file=sys.stderr)
+        for kind, count in sorted(kind_counts.items(), key=lambda x: x[1], reverse=True):
+            print(f" - {kind.ljust(20)}: {count}", file=sys.stderr)
+        print(f"Unique Nodes: {unique_nodes}", file=sys.stderr)
+        print(f"Average Degree: {avg_degree:.2f}", file=sys.stderr)
+        print("========================================\n", file=sys.stderr)
+
+    # 3. Why <file>
+    if args.why:
+        why_target = args.why.replace("\\", "/").lower()
+        target_c = None
+        
+        candidates_or_items = getattr(pack, "candidates", getattr(pack, "items", []))
+        for c in candidates_or_items:
+            rel_str = c.file.relative.as_posix().lower()
+            abs_str = c.file.absolute.as_posix().lower()
+            if why_target in rel_str or why_target in abs_str:
+                target_c = c
+                break
+                
+        if not target_c:
+            print(f"\nCould not find file matching '{args.why}' in the analyzed candidates.", file=sys.stderr)
+            return
+
+        print("\n========================================", file=sys.stderr)
+        print(f"WHY WAS '{target_c.file.relative}' INCLUDED?", file=sys.stderr)
+        print("========================================", file=sys.stderr)
+        print(f"Score: {target_c.score}", file=sys.stderr)
+        if hasattr(target_c, "role"):
+            print(f"Role: {target_c.role}", file=sys.stderr)
+            
+        reasons = getattr(target_c, "reasons", [])
+        if reasons:
+            print("Selection Reasons:", file=sys.stderr)
+            for r in reasons:
+                print(f" - {r}", file=sys.stderr)
+        else:
+            reason_summary = getattr(target_c, "reason_summary", getattr(target_c, "reason", "None"))
+            print(f"Selection Reasons: {reason_summary}", file=sys.stderr)
+            
+        incoming = []
+        for edge in pack.graph.edges:
+            if edge.target == target_c.file.relative:
+                incoming.append(edge)
+                
+        if incoming:
+            print("\nIncoming Relation Edges:", file=sys.stderr)
+            for edge in sorted(incoming, key=lambda e: (e.kind, str(e.source))):
+                ev = f" ({edge.evidence})" if edge.evidence else ""
+                print(f" - {edge.source} -> [this file] (kind: {edge.kind}, weight: {edge.weight}, confidence: {edge.confidence}){ev}", file=sys.stderr)
+        else:
+            print("\nNo incoming relation edges found in graph.", file=sys.stderr)
+        print("========================================\n", file=sys.stderr)
+
 
 
 
@@ -27,6 +130,7 @@ def build_parser() -> argparse.ArgumentParser:
         description="Scriber 2.0: build an intelligent code pack from one or more project paths.",
     )
     parser.add_argument("paths", nargs="*", help="Project file/folder paths used as seeds. Defaults to current directory.")
+    parser.add_argument("--profile", choices=["gpt", "focused-gpt", "full"], default="gpt", help="Preset configuration profile (gpt, focused-gpt, full).")
     parser.add_argument("--config", help="Path to pyproject.toml. Its parent directory becomes the project root.")
     parser.add_argument("--path-base", choices=["project", "cwd"], default="project", help="Base directory for relative paths when --config is used.")
     parser.add_argument("--format", choices=["md", "txt"], dest="output_format", help="Output format.")
@@ -46,6 +150,9 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--force", action="store_true", help="Allow --init to append even if [tool.scriber] already exists.")
     parser.add_argument("--project", action="store_true", help="Force project snapshot mode.")
     parser.add_argument("--explain-selection", action="store_true", help="Explain reason for file selection in detail.")
+    parser.add_argument("--explain-graph", action="store_true", help="Print relation graph statistics and relations.")
+    parser.add_argument("--why", help="Print exactly which rules/edges pulled the specified file into the pack.")
+    parser.add_argument("--graph-json", help="Export the RelationGraph as a JSON file to the specified path.")
     parser.add_argument("--validate-config", action="store_true", help="Validate pyproject.toml scriber config.")
     parser.add_argument("--dry-run", action="store_true", help="Perform a dry run without saving the pack file.")
     parser.add_argument("--open", action="store_true", help="Open the output file automatically after creation.")
@@ -113,6 +220,7 @@ def main(argv: Sequence[str] | None = None) -> int:
             pack = build_pack(
                 args.paths or ["."],
                 config_path=args.config,
+                profile=args.profile,
                 output=args.output,
                 output_format=args.output_format,
                 only_tree=True if args.only_tree else None,
@@ -129,9 +237,16 @@ def main(argv: Sequence[str] | None = None) -> int:
             sys.stderr.write("\r".ljust(80) + "\r")
             sys.stderr.flush()
 
-            code_count = len([c for c in pack.candidates if c.file.kind == "code" and c.include_content])
-            support_count = len([c for c in pack.candidates if c.file.kind == "support" and c.include_content])
-            total_count = len(pack.candidates)
+            is_llm_pack = hasattr(pack, "items")
+            items = getattr(pack, "items", getattr(pack, "candidates", []))
+            if is_llm_pack:
+                code_count = len([c for c in items if c.file.kind == "code" and c.content_mode != "tree"])
+                support_count = len([c for c in items if c.file.kind == "support" and c.content_mode != "tree"])
+                total_count = len([c for c in items if c.content_mode != "tree"])
+            else:
+                code_count = len([c for c in items if c.file.kind == "code" and c.include_content])
+                support_count = len([c for c in items if c.file.kind == "support" and c.include_content])
+                total_count = len([c for c in items if c.include_content])
 
             print("Scriber dry-run completed.", file=sys.stderr)
             print("----------------------------------------", file=sys.stderr)
@@ -139,13 +254,24 @@ def main(argv: Sequence[str] | None = None) -> int:
             print(f" Code files selected:    {code_count}", file=sys.stderr)
             print(f" Support files selected: {support_count}", file=sys.stderr)
             print(f" Total files in pack:    {total_count}", file=sys.stderr)
-            print(f" Estimated tokens:       {pack.total_tokens}", file=sys.stderr)
-            if args.timings and pack.timings:
-                print("----------------------------------------", file=sys.stderr)
-                print("Timings:", file=sys.stderr)
-                for phase, duration in pack.timings.items():
-                    print(f"  {phase.replace('_', ' ').ljust(15)}: {duration:.4f}s", file=sys.stderr)
-                print(f"  total:           {sum(pack.timings.values()):.4f}s", file=sys.stderr)
+            total_tokens = getattr(pack, "budget_actual", getattr(pack, "total_tokens", 0))
+            print(f" Estimated tokens:       {total_tokens}", file=sys.stderr)
+            if args.timings:
+                if pack.stats:
+                    print("----------------------------------------", file=sys.stderr)
+                    print("Stats:", file=sys.stderr)
+                    if "graph_edges_built" in pack.stats:
+                        print(f"  Graph edges built:  {pack.stats['graph_edges_built']}", file=sys.stderr)
+                        print(f"  Graph cache reads:  {pack.stats['graph_cache_reads']}", file=sys.stderr)
+                        print(f"  Graph cache hits:   {pack.stats['graph_cache_hits']}", file=sys.stderr)
+                        print(f"  Graph cache writes: {pack.stats['graph_cache_writes']}", file=sys.stderr)
+                        print(f"  Graph source:       {pack.stats['graph_source']}", file=sys.stderr)
+                if pack.timings:
+                    print("----------------------------------------", file=sys.stderr)
+                    print("Timings:", file=sys.stderr)
+                    for phase, duration in pack.timings.items():
+                        print(f"  {phase.replace('_', ' ').ljust(15)}: {duration:.4f}s", file=sys.stderr)
+                    print(f"  total:           {sum(pack.timings.values()):.4f}s", file=sys.stderr)
 
             config = load_config(pack.config_path)
             config = apply_overrides(config, output=args.output)
@@ -154,11 +280,14 @@ def main(argv: Sequence[str] | None = None) -> int:
                 output_path = pack.project_root / output_path
             print(f" Proposed output path:   {output_path}", file=sys.stderr)
             print("----------------------------------------", file=sys.stderr)
+            if args.explain_graph or args.why or args.graph_json:
+                handle_introspection(args, pack)
             return 0
 
         output, pack = build_and_write_pack(
             args.paths or ["."],
             config_path=args.config,
+            profile=args.profile,
             output=args.output,
             output_format=args.output_format,
             only_tree=True if args.only_tree else None,
@@ -177,31 +306,58 @@ def main(argv: Sequence[str] | None = None) -> int:
         sys.stderr.write("\r".ljust(80) + "\r")
         sys.stderr.flush()
 
+        is_llm_pack = hasattr(pack, "items")
+        items = getattr(pack, "items", getattr(pack, "candidates", []))
+        
         code_count = 0
         support_count = 0
         omitted_count = 0
-        for cand in pack.candidates:
-            if cand.include_content:
-                if cand.file.kind == "code":
-                    code_count += 1
-                elif cand.file.kind == "support":
-                    support_count += 1
+        
+        for cand in items:
+            if is_llm_pack:
+                if cand.content_mode != "tree":
+                    if cand.file.kind == "code":
+                        code_count += 1
+                    elif cand.file.kind == "support":
+                        support_count += 1
+                else:
+                    omitted_count += 1
             else:
-                omitted_count += 1
+                if cand.include_content:
+                    if cand.file.kind == "code":
+                        code_count += 1
+                    elif cand.file.kind == "support":
+                        support_count += 1
+                else:
+                    omitted_count += 1
 
         sys.stderr.write("Scriber build completed.\n")
         sys.stderr.write("----------------------------------------\n")
         sys.stderr.write(f" Code files included:    {code_count}\n")
         sys.stderr.write(f" Support files included: {support_count}\n")
         sys.stderr.write(f" Files omitted/skipped:  {omitted_count}\n")
-        sys.stderr.write(f" Estimated tokens:       {pack.total_tokens}\n")
+        total_tokens = getattr(pack, "budget_actual", getattr(pack, "total_tokens", 0))
+        sys.stderr.write(f" Estimated tokens:       {total_tokens}\n")
         sys.stderr.write("----------------------------------------\n")
-        if args.timings and pack.timings:
-            sys.stderr.write("Timings:\n")
-            for phase, duration in pack.timings.items():
-                sys.stderr.write(f" - {phase.replace('_', ' ').ljust(15)}: {duration:.4f}s\n")
-            sys.stderr.write(f" - total:           {sum(pack.timings.values()):.4f}s\n")
-            sys.stderr.write("----------------------------------------\n")
+        if args.timings:
+            if pack.stats:
+                sys.stderr.write("Stats:\n")
+                if "graph_edges_built" in pack.stats:
+                    sys.stderr.write(f" - Graph edges built:  {pack.stats['graph_edges_built']}\n")
+                    sys.stderr.write(f" - Graph cache reads:  {pack.stats['graph_cache_reads']}\n")
+                    sys.stderr.write(f" - Graph cache hits:   {pack.stats['graph_cache_hits']}\n")
+                    sys.stderr.write(f" - Graph cache writes: {pack.stats['graph_cache_writes']}\n")
+                    sys.stderr.write(f" - Graph source:       {pack.stats['graph_source']}\n")
+                sys.stderr.write("----------------------------------------\n")
+            if pack.timings:
+                sys.stderr.write("Timings:\n")
+                for phase, duration in pack.timings.items():
+                    sys.stderr.write(f" - {phase.replace('_', ' ').ljust(15)}: {duration:.4f}s\n")
+                sys.stderr.write(f" - total:           {sum(pack.timings.values()):.4f}s\n")
+                sys.stderr.write("----------------------------------------\n")
+
+        if args.explain_graph or args.why or args.graph_json:
+            handle_introspection(args, pack)
 
         if output is not None:
             print(f"Scriber pack written to: {output}")
diff --git a/src/scriber/core/config.py b/src/scriber/core/config.py
index fed0545..73895fc 100644
--- a/src/scriber/core/config.py
+++ b/src/scriber/core/config.py
@@ -147,8 +147,8 @@
 output = ".scriber/scriber_pack.md"
 only_tree = false
 use_gitignore = true
-max_files = 60
-max_tokens = 100000
+max_files = 0
+max_tokens = 0
 min_score = 45
 path_style = "project-relative"
 allow_external_paths = false
diff --git a/src/scriber/core/models.py b/src/scriber/core/models.py
index c521c49..c093382 100644
--- a/src/scriber/core/models.py
+++ b/src/scriber/core/models.py
@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal
+from typing import Any, Literal
 
 FileKind = Literal["code", "support", "other"]
 ContentPolicy = Literal["full", "auto", "tree_only"]
@@ -113,8 +113,16 @@ class FileNode:
     def read_text(self) -> str:
         if self._cached_text is not None:
             return self._cached_text
-        from scriber.native import require_native
-        text = require_native().read_text(str(self.absolute))
+
+        try:
+            from scriber.native import is_native_available, require_native
+            if is_native_available():
+                text = require_native().read_text(str(self.absolute))
+            else:
+                text = self.absolute.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            text = self.absolute.read_text(encoding="utf-8", errors="replace")
+
         object.__setattr__(self, "_cached_text", text)
         return text
 
@@ -141,12 +149,12 @@ class Candidate:
     reason_counts: dict[str, int] = field(default_factory=dict)
     reason_examples: dict[str, list[Path]] = field(default_factory=dict)
     reason_summary: str = ""
+    utility: float = 0.0
+    raw_score: float = 0.0
+    role: str = "unknown"
 
 
-@dataclass(slots=True)
-class ModuleGraph:
-    imports: dict[Path, set[Path]] = field(default_factory=dict)
-    imported_by: dict[Path, set[Path]] = field(default_factory=dict)
+from scriber.graph.model import RelationKind, RelationEdge, RelationGraph, ModuleGraph
 
 
 @dataclass(slots=True)
@@ -160,8 +168,84 @@ class ScriberPack:
     output_format: OutputFormat
     mode: PackMode
     total_tokens: int = 0
+    stats: dict[str, Any] = field(default_factory=dict)
     timings: dict[str, float] = field(default_factory=dict)
 
     @property
     def included_paths(self) -> list[Path]:
         return [candidate.file.relative for candidate in self.candidates]
+
+
+ContentMode = Literal["full", "excerpt", "outline", "tree", "omit"]
+
+FileRole = Literal[
+    "entrypoint",
+    "orchestrator",
+    "model",
+    "config",
+    "graph",
+    "ranker",
+    "renderer",
+    "scanner",
+    "language_adapter",
+    "native_adapter",
+    "test",
+    "support",
+    "docs",
+    "generated",
+    "unknown",
+]
+
+@dataclass(frozen=True, slots=True)
+class FileRef:
+    path: Path
+    kind: FileKind
+    language: str
+    size_bytes: int
+    token_estimate: int
+    role: FileRole = "unknown"
+
+@dataclass(frozen=True, slots=True)
+class FileOutline:
+    path: Path
+    language: str
+    purpose: str | None
+    imports: list[str]
+    exports: list[str]
+    classes: list[str]
+    functions: list[str]
+    constants: list[str]
+    notes: list[str]
+    token_estimate: int
+
+@dataclass(slots=True)
+class PackItem:
+    file: FileNode
+    score: int
+    role: FileRole
+    content_mode: ContentMode
+    reason: str
+    reasons: list[str]
+    relation_evidence: list[RelationEdge]
+    outline: FileOutline | None = None
+    content: str | None = None
+    excerpts: list[str] = field(default_factory=list)
+    token_estimate: int = 0
+    item_id: str = ""
+    utility: float = 0.0
+    raw_score: float = 0.0
+
+@dataclass(slots=True)
+class LlmPack:
+    project_root: Path
+    config_path: Path
+    profile: str
+    mode: PackMode
+    goal: str | None
+    budget_target: int
+    budget_actual: int
+    items: list[PackItem]
+    graph: RelationGraph
+    stats: dict[str, Any]
+    warnings: list[str]
+    timings: dict[str, float] = field(default_factory=dict)
diff --git a/src/scriber/core/symbols.py b/src/scriber/core/symbols.py
new file mode 100644
index 0000000..fa127b0
--- /dev/null
+++ b/src/scriber/core/symbols.py
@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+
+@dataclass(slots=True)
+class SymbolNode:
+    name: str
+    kind: str  # "class" or "function"
+    line_start: int
+    line_end: int
+    parent_name: str | None = None
+
+
+@dataclass(slots=True)
+class SymbolIndex:
+    symbols_by_file: dict[Path, list[SymbolNode]] = field(default_factory=dict)
+
+    def add_symbol(self, file_path: Path, symbol: SymbolNode) -> None:
+        self.symbols_by_file.setdefault(file_path, []).append(symbol)
+
+    def get_symbols(self, file_path: Path) -> list[SymbolNode]:
+        return self.symbols_by_file.get(file_path, [])
diff --git a/src/scriber/engine/ranker.py b/src/scriber/engine/ranker.py
new file mode 100644
index 0000000..cdc8474
--- /dev/null
+++ b/src/scriber/engine/ranker.py
@@ -0,0 +1,134 @@
+from __future__ import annotations
+from pathlib import Path
+import math
+from collections import deque, defaultdict
+from scriber.core.models import FileNode, RelationGraph, ScriberConfig, Candidate
+from scriber.engine.roles import classify_file_role, ROLE_SCORE
+
+RELATION_WEIGHT = {
+    "import": 90,
+    "reexport": 80,
+    "test_of": 78,
+    "entrypoint_to_module": 75,
+    "config_refs_code": 58,
+    "env_key": 52,
+    "doc_mentions_code": 42,
+    "git_cochange": 40,
+    "same_package": 28,
+    "same_dir": 20,
+    "name_similarity": 18,
+    "semantic_similarity": 15,
+}
+
+def rank_context(files: dict[Path, FileNode], graph: RelationGraph, seeds: list[Path], config: ScriberConfig, mode: str) -> list[Candidate]:
+    candidates = []
+    
+    explicit_seeds = {s for s in seeds}
+
+    distances = {}
+    if mode == "focused":
+        adj_out = defaultdict(list)
+        adj_in = defaultdict(list)
+        for edge in graph.edges:
+            adj_out[edge.source].append(edge.target)
+            adj_in[edge.target].append(edge.source)
+            
+        q_out = deque()
+        q_in = deque()
+        dist_out = {}
+        dist_in = {}
+        
+        for s in explicit_seeds:
+            if s in files:
+                dist_out[s] = 0
+                dist_in[s] = 0
+                q_out.append(s)
+                q_in.append(s)
+                
+        while q_out:
+            curr = q_out.popleft()
+            d = dist_out[curr]
+            for nbr in adj_out[curr]:
+                if nbr not in dist_out:
+                    dist_out[nbr] = d + 1
+                    q_out.append(nbr)
+                    
+        while q_in:
+            curr = q_in.popleft()
+            d = dist_in[curr]
+            for nbr in adj_in[curr]:
+                if nbr not in dist_in:
+                    dist_in[nbr] = d + 1
+                    q_in.append(nbr)
+                    
+        for rel in files.keys():
+            d_out = dist_out.get(rel, 999)
+            d_in = dist_in.get(rel, 999)
+            distances[rel] = min(d_out, d_in)
+
+    for rel, node in files.items():
+        role = classify_file_role(node, graph)
+        role_score = ROLE_SCORE.get(role, 20)
+        
+        relation_score = 0.0
+        incoming = graph.incoming.get(rel, [])
+        for edge in incoming:
+            weight = RELATION_WEIGHT.get(edge.kind, 10) * edge.weight * edge.confidence
+            relation_score += weight
+            
+        centrality_bonus = 0
+        evidence_bonus = len(incoming) * 2
+        noise_penalty = 0
+        
+        if node.language in {"json", "lock", "svg"}:
+            noise_penalty += 50
+
+        if mode == "focused":
+            dist = distances.get(rel, 999)
+            if dist == 0:
+                decay = 1.0
+                seed_bonus = 100
+                max_score = 100
+            elif dist == 1:
+                decay = 1.0
+                seed_bonus = 0
+                max_score = 79
+            elif dist == 2:
+                decay = 0.5
+                seed_bonus = 0
+                max_score = 74
+            else:
+                decay = 0.1
+                seed_bonus = 0
+                max_score = 44
+        else:
+            decay = 1.0
+            seed_bonus = 100 if rel in explicit_seeds else 0
+            max_score = 100
+            
+        if mode == "focused" and role == "test" and rel not in explicit_seeds:
+            noise_penalty += 80
+            max_score = min(max_score, 44) # Force test files to tree mode unless specifically targeted
+            
+        raw_score = (role_score + relation_score + seed_bonus + centrality_bonus + evidence_bonus - noise_penalty) * decay
+        
+        token_estimate = node.size_bytes // 4
+        utility = raw_score / math.sqrt(token_estimate + 200)
+        
+        c = Candidate(
+            file=node,
+            score=int(min(max_score, max(0, raw_score))), # clamp to distance-based max_score
+            reasons=[f"Role {role}: {role_score}", f"Relations: {relation_score:.1f}"],
+            include_content=False,
+            token_estimate=token_estimate
+        )
+        
+        object.__setattr__(c, "utility", utility)
+        object.__setattr__(c, "raw_score", raw_score)
+        object.__setattr__(c, "role", role)
+        
+        candidates.append(c)
+        
+    # Primary sort by utility, then score
+    candidates.sort(key=lambda c: (getattr(c, "utility", 0), c.score), reverse=True)
+    return candidates
diff --git a/src/scriber/engine/roles.py b/src/scriber/engine/roles.py
new file mode 100644
index 0000000..2f319c8
--- /dev/null
+++ b/src/scriber/engine/roles.py
@@ -0,0 +1,53 @@
+from __future__ import annotations
+from pathlib import Path
+from scriber.core.models import FileNode, FileRole, RelationGraph
+
+ROLE_SCORE: dict[FileRole, int] = {
+    "entrypoint": 95,
+    "orchestrator": 95,
+    "graph": 90,
+    "ranker": 90,
+    "renderer": 90,
+    "model": 88,
+    "config": 82,
+    "scanner": 75,
+    "native_adapter": 65,
+    "language_adapter": 65,
+    "test": 55,
+    "support": 45,
+    "docs": 35,
+    "generated": 5,
+    "unknown": 20,
+}
+
+def classify_file_role(file: FileNode, graph: RelationGraph) -> FileRole:
+    rel = file.relative.as_posix().lower()
+    
+    if rel in {"cli/main.py", "src/scriber/cli/main.py", "src/main.py", "main.py"}:
+        return "entrypoint"
+    if "orchestrator" in rel or "pack.py" in rel or "build.py" in rel:
+        return "orchestrator"
+    if "core/models.py" in rel or "model.py" in rel:
+        return "model"
+    if "core/config.py" in rel or "config.py" in rel:
+        return "config"
+    if "test" in rel and file.kind == "code":
+        return "test"
+    if "languages/" in rel:
+        return "language_adapter"
+    if "graph/" in rel:
+        return "graph"
+    if "ranker.py" in rel or "scorer.py" in rel:
+        return "ranker"
+    if "renderer" in rel or "llm_report" in rel:
+        return "renderer"
+    if "scanner/" in rel:
+        return "scanner"
+    if rel.endswith("native.py") or "rust/scriber_native/" in rel or ("native" in rel and file.language == "rust"):
+        return "native_adapter"
+    if "readme" in rel or rel.startswith("docs"):
+        return "docs"
+    if rel in {"pyproject.toml", "package.json", "cargo.toml"} or file.kind == "support":
+        return "support"
+        
+    return "unknown"
diff --git a/src/scriber/engine/scorer.py b/src/scriber/engine/scorer.py
index 0dbfb24..dee0cca 100644
--- a/src/scriber/engine/scorer.py
+++ b/src/scriber/engine/scorer.py
@@ -3,7 +3,7 @@
 from pathlib import Path
 
 from scriber.core.matchers import match_pattern
-from scriber.core.models import Candidate, FileNode, ModuleGraph, ScriberConfig, SeedPath
+from scriber.core.models import Candidate, FileNode, ModuleGraph, ScriberConfig, SeedPath, RelationEdge
 
 
 def _score(config: ScriberConfig, key: str) -> int:
@@ -111,6 +111,56 @@ def _name_related(a: Path, b: Path) -> bool:
     return a_stem in b_stem or b_stem in a_stem
 
 
+def _walk_weighted_neighbors(
+    edges: list[RelationEdge],
+    start: Path,
+    depth_limit: int,
+    reverse: bool = False
+) -> dict[Path, float]:
+    import heapq
+    
+    adj: dict[Path, list[tuple[Path, RelationEdge]]] = {}
+    for edge in edges:
+        u = edge.target if reverse else edge.source
+        v = edge.source if reverse else edge.target
+        adj.setdefault(u, []).append((v, edge))
+        
+    queue = [(-1.0, 0, start)]
+    max_strength: dict[Path, float] = {start: 1.0}
+    best_at_state: dict[tuple[Path, int], float] = {(start, 0): 1.0}
+    
+    while queue:
+        neg_str, depth, u = heapq.heappop(queue)
+        u_str = -neg_str
+        
+        if u_str < best_at_state.get((u, depth), 0.0):
+            continue
+            
+        if depth >= depth_limit:
+            continue
+            
+        for neighbor, edge in adj.get(u, []):
+            if edge.kind in {"import", "reexport"}:
+                edge_str = 1.0 if depth == 0 else 0.88
+            else:
+                edge_str = edge.weight * edge.confidence
+                
+            next_str = u_str * edge_str
+            next_depth = depth + 1
+            
+            if next_str > max_strength.get(neighbor, 0.0):
+                max_strength[neighbor] = next_str
+                
+            if next_str > best_at_state.get((neighbor, next_depth), 0.0):
+                best_at_state[(neighbor, next_depth)] = next_str
+                heapq.heappush(queue, (-next_str, next_depth, neighbor))
+                
+    if start in max_strength:
+        del max_strength[start]
+        
+    return max_strength
+
+
 def _walk_neighbors(edges: dict[Path, set[Path]], start: Path, depth: int) -> dict[Path, int]:
     found: dict[Path, int] = {}
     frontier = {start}
@@ -222,13 +272,13 @@ def score_candidates(
     if config.modules and scoring.enabled:
         for seed_rel in seed_files:
             if scoring.include_direct_dependencies:
-                for dep, distance in _walk_neighbors(graph.imports, seed_rel, scoring.depth).items():
-                    score = max(scoring.tree_min_score, _score(config, "direct_dependency") - ((distance - 1) * 10))
+                for dep, strength in _walk_weighted_neighbors(graph.edges, seed_rel, scoring.depth, reverse=False).items():
+                    score = max(scoring.tree_min_score, int(_score(config, "direct_dependency") * strength))
                     _add(candidates, files, dep, score, "direct_dependency", f"direct dependency of `{seed_rel.as_posix()}`", seed=seed_rel)
 
             if scoring.include_reverse_dependencies:
-                for dep, distance in _walk_neighbors(graph.imported_by, seed_rel, scoring.depth).items():
-                    score = max(scoring.tree_min_score, _score(config, "reverse_dependency") - ((distance - 1) * 10))
+                for dep, strength in _walk_weighted_neighbors(graph.edges, seed_rel, scoring.depth, reverse=True).items():
+                    score = max(scoring.tree_min_score, int(_score(config, "reverse_dependency") * strength))
                     _add(candidates, files, dep, score, "reverse_dependency", f"imports seed `{seed_rel.as_posix()}`", seed=seed_rel)
 
             if scoring.include_same_package:
diff --git a/src/scriber/graph/analyzers/__init__.py b/src/scriber/graph/analyzers/__init__.py
new file mode 100644
index 0000000..129c757
--- /dev/null
+++ b/src/scriber/graph/analyzers/__init__.py
@@ -0,0 +1,26 @@
+from pathlib import Path
+from typing import Any
+from scriber.graph.indexes import GraphIndexes
+from scriber.graph.analyzers.tests import TestsAnalyzer
+from scriber.graph.analyzers.package import PackageAnalyzer
+from scriber.graph.analyzers.env import EnvAnalyzer
+from scriber.graph.analyzers.config_refs import ConfigRefsAnalyzer
+from scriber.graph.analyzers.docs import DocsAnalyzer
+
+def generate_cheap_relations(files: dict[Path, Any], edge_cls: Any, is_native: bool = False) -> list[Any]:
+    indexes = GraphIndexes.build(files)
+    config = None # Passed as None for these simple analyzers
+    
+    analyzers = [
+        TestsAnalyzer(),
+        PackageAnalyzer(),
+        EnvAnalyzer(),
+        ConfigRefsAnalyzer(),
+        DocsAnalyzer(),
+    ]
+    
+    edges = []
+    for analyzer in analyzers:
+        edges.extend(analyzer.analyze(files, indexes, config, edge_cls, is_native))
+        
+    return edges
diff --git a/src/scriber/graph/analyzers/base.py b/src/scriber/graph/analyzers/base.py
new file mode 100644
index 0000000..9abe43f
--- /dev/null
+++ b/src/scriber/graph/analyzers/base.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Iterable, Protocol
+from pathlib import Path
+
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+from scriber.graph.model import RelationEdge
+
+
+class RelationAnalyzer(Protocol):
+    name: str
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig) -> Iterable[RelationEdge]:
+        ...
diff --git a/src/scriber/graph/analyzers/config_refs.py b/src/scriber/graph/analyzers/config_refs.py
new file mode 100644
index 0000000..481b213
--- /dev/null
+++ b/src/scriber/graph/analyzers/config_refs.py
@@ -0,0 +1,35 @@
+from __future__ import annotations
+from typing import Iterable, Any
+from pathlib import Path
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+
+def is_config_file(f: FileNode) -> bool:
+    name = f.relative.name.lower()
+    return name in {"pyproject.toml", "setup.py", "package.json", "dockerfile"} or f.relative.suffix.lower() in {".toml", ".yaml", ".yml", ".json"}
+
+class ConfigRefsAnalyzer:
+    name = "config_refs"
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig | None, edge_cls: Any, is_native: bool) -> Iterable:
+        edges = []
+        for rel, node in files.items():
+            if is_config_file(node):
+                try:
+                    content = node.absolute.read_text(encoding="utf-8", errors="ignore")
+                    for crel, cnode in files.items():
+                        if cnode.kind == "code":
+                            if crel.as_posix() in content or (len(crel.name) > 4 and crel.name != "__init__.py" and crel.name in content):
+                                edges.append(edge_cls(
+                                    source=str(rel) if is_native else rel,
+                                    target=str(crel) if is_native else crel,
+                                    kind="config_refs_code",
+                                    weight=0.6,
+                                    confidence=0.8,
+                                    evidence=f"Config {rel.name} references {crel.name}",
+                                    line=None,
+                                    analyzer="config_refs:indexed"
+                                ))
+                except Exception:
+                    pass
+        return edges
diff --git a/src/scriber/graph/analyzers/docs.py b/src/scriber/graph/analyzers/docs.py
new file mode 100644
index 0000000..6afc72e
--- /dev/null
+++ b/src/scriber/graph/analyzers/docs.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+from typing import Iterable, Any
+from pathlib import Path
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+
+class DocsAnalyzer:
+    name = "docs"
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig | None, edge_cls: Any, is_native: bool) -> Iterable:
+        edges = []
+        for rel, node in files.items():
+            name_lower = node.relative.name.lower()
+            if name_lower in {"readme.md", "readme.txt", "readme"} or "doc" in name_lower:
+                try:
+                    content = node.absolute.read_text(encoding="utf-8", errors="ignore")
+                    for crel, cnode in files.items():
+                        if cnode.kind == "code":
+                            if crel.as_posix() in content or (len(crel.name) > 4 and crel.name != "__init__.py" and crel.name in content):
+                                edges.append(edge_cls(
+                                    source=str(rel) if is_native else rel,
+                                    target=str(crel) if is_native else crel,
+                                    kind="doc_mentions_code",
+                                    weight=0.42,
+                                    confidence=0.8,
+                                    evidence=f"{node.relative.name} mentions {crel.name}",
+                                    line=None,
+                                    analyzer="docs:indexed"
+                                ))
+                except Exception:
+                    pass
+        return edges
diff --git a/src/scriber/graph/analyzers/env.py b/src/scriber/graph/analyzers/env.py
new file mode 100644
index 0000000..f4eb938
--- /dev/null
+++ b/src/scriber/graph/analyzers/env.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+from typing import Iterable, Any
+from pathlib import Path
+import re
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+
+class EnvAnalyzer:
+    name = "env"
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig | None, edge_cls: Any, is_native: bool) -> Iterable:
+        edges = []
+        file_envs = {}
+        for rel, node in files.items():
+            if node.kind != "code": continue
+            try:
+                content = node.absolute.read_text(encoding="utf-8", errors="ignore")
+                keys = self.extract_env_keys(content)
+                if keys:
+                    file_envs[rel] = keys
+                    for k in keys:
+                        indexes.env_key_to_files.setdefault(k, []).append(node)
+            except Exception:
+                pass
+                
+        for key, nodes in indexes.env_key_to_files.items():
+            for i, n1 in enumerate(nodes):
+                for j, n2 in enumerate(nodes):
+                    if i == j: continue
+                    edges.append(edge_cls(
+                        source=str(n1.relative) if is_native else n1.relative,
+                        target=str(n2.relative) if is_native else n2.relative,
+                        kind="env_key",
+                        weight=0.4,
+                        confidence=0.9,
+                        evidence=f"Shared env key: {key}",
+                        line=None,
+                        analyzer="env:indexed"
+                    ))
+        return edges
+
+    def extract_env_keys(self, content: str) -> set[str]:
+        keys = set()
+        for match in re.finditer(r'os\.environ(?:\[|\.get\()[\'"]([A-Za-z0-9_]+)[\'"]', content):
+            keys.add(match.group(1))
+        for match in re.finditer(r'os\.getenv\([\'"]([A-Za-z0-9_]+)[\'"]\)', content):
+            keys.add(match.group(1))
+        for match in re.finditer(r'process\.env(?:\[[\'"]([A-Za-z0-9_]+)[\'"]\]|\.([A-Za-z0-9_]+))', content):
+            keys.add(match.group(1) or match.group(2))
+        return keys
diff --git a/src/scriber/graph/analyzers/package.py b/src/scriber/graph/analyzers/package.py
new file mode 100644
index 0000000..7626b6e
--- /dev/null
+++ b/src/scriber/graph/analyzers/package.py
@@ -0,0 +1,30 @@
+from __future__ import annotations
+from typing import Iterable, Any
+from pathlib import Path
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+
+class PackageAnalyzer:
+    name = "package"
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig | None, edge_cls: Any, is_native: bool) -> Iterable:
+        edges = []
+        for d, siblings in indexes.by_dir.items():
+            code_siblings = [s for s in siblings if s.kind == "code"]
+            for s1 in code_siblings:
+                count = 0
+                for s2 in code_siblings:
+                    if s1 == s2: continue
+                    count += 1
+                    if count > 8: break
+                    edges.append(edge_cls(
+                        source=str(s1.relative) if is_native else s1.relative,
+                        target=str(s2.relative) if is_native else s2.relative,
+                        kind="same_package",
+                        weight=0.5,
+                        confidence=1.0,
+                        evidence=None,
+                        line=None,
+                        analyzer="package:indexed"
+                    ))
+        return edges
diff --git a/src/scriber/graph/analyzers/tests.py b/src/scriber/graph/analyzers/tests.py
new file mode 100644
index 0000000..409f63f
--- /dev/null
+++ b/src/scriber/graph/analyzers/tests.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+from typing import Iterable, Any
+from pathlib import Path
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.indexes import GraphIndexes
+
+class TestsAnalyzer:
+    name = "tests"
+
+    def analyze(self, files: dict[Path, FileNode], indexes: GraphIndexes, config: ScriberConfig | None, edge_cls: Any, is_native: bool) -> Iterable:
+        edges = []
+        for rel, node in files.items():
+            if node.kind != "code": continue
+            stem = rel.stem.lower()
+            name = rel.name.lower()
+            clean_stem = stem.replace("test_", "").replace("_test", "").replace(".test", "")
+            is_test = name.startswith("test_") or name.endswith("_test.py") or ".test." in name
+            
+            if is_test and clean_stem:
+                targets = indexes.by_clean_stem.get(clean_stem, [])
+                for target_node in targets:
+                    if target_node.relative == rel: continue
+                    target_name = target_node.relative.name.lower()
+                    target_is_test = target_name.startswith("test_") or target_name.endswith("_test.py") or ".test." in target_name
+                    if not target_is_test:
+                        edges.append(edge_cls(
+                            source=str(rel) if is_native else rel,
+                            target=str(target_node.relative) if is_native else target_node.relative,
+                            kind="test_of",
+                            weight=0.85,
+                            confidence=0.9,
+                            evidence=f"test filename {rel.name} matches {target_node.relative.name}",
+                            line=None,
+                            analyzer="tests:indexed"
+                        ))
+        return edges
diff --git a/src/scriber/graph/builder.py b/src/scriber/graph/builder.py
index a181441..17afd2a 100644
--- a/src/scriber/graph/builder.py
+++ b/src/scriber/graph/builder.py
@@ -2,12 +2,13 @@
 
 from pathlib import Path
 
-from scriber.core.models import FileNode, ModuleGraph, ScriberConfig
+from scriber.core.models import FileNode, ScriberConfig
+from scriber.graph.model import ModuleGraph, RelationEdge
 from scriber.graph.languages.python import build_module_map, parse_python_imports, resolve_import_record
 from scriber.scanner.files import read_text_lossy
 
 
-def build_graph(files: dict[Path, FileNode], config: ScriberConfig) -> ModuleGraph:
+def build_graph(files: dict[Path, FileNode], config: ScriberConfig, cache: ScriberCache | None = None) -> ModuleGraph:
     graph = ModuleGraph()
     if not files:
         return graph
@@ -24,8 +25,9 @@ def build_graph(files: dict[Path, FileNode], config: ScriberConfig) -> ModuleGra
     sample = next(iter(files.values()))
     root = Path(sample.absolute.as_posix()[:len(sample.absolute.as_posix()) - len(sample.relative.as_posix())]).resolve()
 
-    from scriber.cache import ScriberCache
-    cache = ScriberCache(config, root)
+    if cache is None:
+        from scriber.cache import ScriberCache
+        cache = ScriberCache(config, root)
 
     module_to_path, path_to_module = build_module_map(files, config.python)
 
@@ -124,9 +126,17 @@ def build_graph(files: dict[Path, FileNode], config: ScriberConfig) -> ModuleGra
                     resolved_set.add(target)
 
 
+        from scriber.core.models import RelationEdge
+
         for target in resolved_set:
-            graph.imports.setdefault(rel, set()).add(target)
-            graph.imported_by.setdefault(target, set()).add(rel)
+            graph.add_edge(RelationEdge(
+                source=rel,
+                target=target,
+                kind="import",
+                weight=1.0,
+                confidence=0.98,
+                analyzer=f"imports:{file.language}",
+            ))
 
         cache.set_imports(rel, resolved_set)
 
diff --git a/src/scriber/graph/indexes.py b/src/scriber/graph/indexes.py
new file mode 100644
index 0000000..aa61518
--- /dev/null
+++ b/src/scriber/graph/indexes.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from scriber.core.models import FileNode
+
+
+@dataclass(slots=True)
+class GraphIndexes:
+    by_dir: dict[Path, list[FileNode]] = field(default_factory=dict)
+    by_stem: dict[str, list[FileNode]] = field(default_factory=dict)
+    by_clean_stem: dict[str, list[FileNode]] = field(default_factory=dict)
+    by_language: dict[str, list[FileNode]] = field(default_factory=dict)
+    env_key_to_files: dict[str, list[FileNode]] = field(default_factory=dict)
+    config_tokens: dict[Path, set[str]] = field(default_factory=dict)
+    doc_tokens: dict[Path, set[str]] = field(default_factory=dict)
+
+    @classmethod
+    def build(cls, files: dict[Path, FileNode]) -> GraphIndexes:
+        indexes = cls()
+        
+        for rel, node in files.items():
+            indexes.by_dir.setdefault(rel.parent, []).append(node)
+            indexes.by_stem.setdefault(rel.stem, []).append(node)
+            
+            clean_stem = re.sub(r'[^a-zA-Z0-9]', '', rel.stem).lower()
+            if clean_stem:
+                indexes.by_clean_stem.setdefault(clean_stem, []).append(node)
+                
+            indexes.by_language.setdefault(node.language, []).append(node)
+            
+            # Simple indexing for .env and docs is done per analyzer as needed, 
+            # but we can initialize the dicts here.
+            
+        return indexes
diff --git a/src/scriber/graph/languages/extractor.py b/src/scriber/graph/languages/extractor.py
new file mode 100644
index 0000000..333e74e
--- /dev/null
+++ b/src/scriber/graph/languages/extractor.py
@@ -0,0 +1,74 @@
+import ast
+from pathlib import Path
+from typing import Any
+from scriber.core.symbols import SymbolNode, SymbolIndex
+
+class PythonSymbolVisitor(ast.NodeVisitor):
+    def __init__(self, file_path: Path, index: SymbolIndex):
+        self.file_path = file_path
+        self.index = index
+        self.current_parent: str | None = None
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> Any:
+        start = node.lineno
+        end = getattr(node, "end_lineno", start)
+        
+        symbol = SymbolNode(
+            name=node.name,
+            kind="class",
+            line_start=start,
+            line_end=end,
+            parent_name=self.current_parent
+        )
+        self.index.add_symbol(self.file_path, symbol)
+        
+        old_parent = self.current_parent
+        self.current_parent = node.name
+        self.generic_visit(node)
+        self.current_parent = old_parent
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
+        start = node.lineno
+        end = getattr(node, "end_lineno", start)
+        
+        symbol = SymbolNode(
+            name=node.name,
+            kind="function",
+            line_start=start,
+            line_end=end,
+            parent_name=self.current_parent
+        )
+        self.index.add_symbol(self.file_path, symbol)
+        
+        old_parent = self.current_parent
+        self.current_parent = node.name
+        self.generic_visit(node)
+        self.current_parent = old_parent
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
+        start = node.lineno
+        end = getattr(node, "end_lineno", start)
+        
+        symbol = SymbolNode(
+            name=node.name,
+            kind="function",
+            line_start=start,
+            line_end=end,
+            parent_name=self.current_parent
+        )
+        self.index.add_symbol(self.file_path, symbol)
+        
+        old_parent = self.current_parent
+        self.current_parent = node.name
+        self.generic_visit(node)
+        self.current_parent = old_parent
+
+
+def extract_python_symbols(file_path: Path, source_code: str, index: SymbolIndex) -> None:
+    try:
+        tree = ast.parse(source_code, filename=str(file_path))
+        visitor = PythonSymbolVisitor(file_path, index)
+        visitor.visit(tree)
+    except Exception:
+        # Gracefully handle syntactically invalid or unparseable files
+        pass
diff --git a/src/scriber/graph/model.py b/src/scriber/graph/model.py
new file mode 100644
index 0000000..d87376c
--- /dev/null
+++ b/src/scriber/graph/model.py
@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+RelationKind = Literal[
+    "import",
+    "reexport",
+    "call",
+    "type_reference",
+    "inherits",
+    "implements",
+    "test_of",
+    "fixture_for",
+    "config_refs_code",
+    "env_key",
+    "doc_mentions_symbol",
+    "doc_mentions_code",
+    "same_package",
+    "same_dir",
+    "name_similarity",
+    "git_cochange",
+    "semantic_similarity",
+    "entrypoint_to_module",
+]
+
+@dataclass(frozen=True, slots=True)
+class RelationEdge:
+    source: Path
+    target: Path
+    kind: RelationKind
+    weight: float = 1.0
+    confidence: float = 1.0
+    evidence: str | None = None
+    line: int | None = None
+    analyzer: str = "unknown"
+
+@dataclass(slots=True)
+class RelationGraph:
+    edges: list[RelationEdge] = field(default_factory=list)
+    outgoing: dict[Path, list[RelationEdge]] = field(default_factory=dict)
+    incoming: dict[Path, list[RelationEdge]] = field(default_factory=dict)
+    imports: dict[Path, set[Path]] = field(default_factory=dict)
+    imported_by: dict[Path, set[Path]] = field(default_factory=dict)
+
+    def add_edge(self, edge: RelationEdge) -> None:
+        self.edges.append(edge)
+        self.outgoing.setdefault(edge.source, []).append(edge)
+        self.incoming.setdefault(edge.target, []).append(edge)
+
+        if edge.kind in {"import", "reexport"}:
+            self.imports.setdefault(edge.source, set()).add(edge.target)
+            self.imported_by.setdefault(edge.target, set()).add(edge.source)
+
+@dataclass(slots=True)
+class ModuleGraph(RelationGraph):
+    pass
diff --git a/src/scriber/outline/__init__.py b/src/scriber/outline/__init__.py
new file mode 100644
index 0000000..2e72db9
--- /dev/null
+++ b/src/scriber/outline/__init__.py
@@ -0,0 +1,13 @@
+from scriber.core.models import FileNode, FileOutline
+from scriber.outline.base import Outliner
+from scriber.outline.generic import GenericOutliner
+from scriber.outline.python import PythonOutliner
+
+_outliners: dict[str, Outliner] = {
+    "python": PythonOutliner(),
+}
+_generic = GenericOutliner()
+
+def generate_outline(file: FileNode, content: str) -> FileOutline:
+    outliner = _outliners.get(file.language, _generic)
+    return outliner.outline(file, content)
diff --git a/src/scriber/outline/base.py b/src/scriber/outline/base.py
new file mode 100644
index 0000000..a79c6c0
--- /dev/null
+++ b/src/scriber/outline/base.py
@@ -0,0 +1,7 @@
+from __future__ import annotations
+from typing import Protocol
+from scriber.core.models import FileNode, FileOutline
+
+class Outliner(Protocol):
+    def outline(self, file: FileNode, content: str) -> FileOutline:
+        ...
diff --git a/src/scriber/outline/generic.py b/src/scriber/outline/generic.py
new file mode 100644
index 0000000..f0aac16
--- /dev/null
+++ b/src/scriber/outline/generic.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+from scriber.core.models import FileNode, FileOutline
+from scriber.outline.base import Outliner
+
+class GenericOutliner(Outliner):
+    def outline(self, file: FileNode, content: str) -> FileOutline:
+        return FileOutline(
+            path=file.relative,
+            language=file.language,
+            purpose=None,
+            imports=[],
+            exports=[],
+            classes=[],
+            functions=[],
+            constants=[],
+            notes=["Static outline not implemented for this language. Showing generic info."],
+            token_estimate=20
+        )
diff --git a/src/scriber/outline/python.py b/src/scriber/outline/python.py
new file mode 100644
index 0000000..bd9c9c7
--- /dev/null
+++ b/src/scriber/outline/python.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+import ast
+from scriber.core.models import FileNode, FileOutline
+from scriber.outline.base import Outliner
+
+class PythonOutliner(Outliner):
+    def outline(self, file: FileNode, content: str) -> FileOutline:
+        classes = []
+        functions = []
+        imports = []
+        try:
+            tree = ast.parse(content)
+            for node in tree.body:
+                if isinstance(node, ast.ClassDef):
+                    classes.append(node.name)
+                elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    functions.append(node.name)
+                elif isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.append(alias.name)
+                elif isinstance(node, ast.ImportFrom):
+                    module = node.module or ""
+                    for alias in node.names:
+                        imports.append(f"{module}.{alias.name}")
+        except SyntaxError:
+            pass
+            
+        return FileOutline(
+            path=file.relative,
+            language="python",
+            purpose=None,
+            imports=imports[:20],
+            exports=[],
+            classes=classes,
+            functions=functions,
+            constants=[],
+            notes=[],
+            token_estimate=len(classes)*5 + len(functions)*3 + len(imports)*2
+        )
diff --git a/src/scriber/packer/pack.py b/src/scriber/packer/pack.py
index 2e7011c..801f93f 100644
--- a/src/scriber/packer/pack.py
+++ b/src/scriber/packer/pack.py
@@ -13,6 +13,7 @@
 from scriber.scanner.files import classify_file, is_text_readable, read_text_lossy
 from scriber.tokens import estimate_tokens
 from scriber.scanner.scan import scan_project
+from scriber.core.models import LlmPack
 
 
 def _resolve_input(path_value: str, root: Path, allow_external: bool, path_base: str = "cwd") -> Path:
@@ -151,28 +152,7 @@ def _apply_content_policy(pack: ScriberPack, config) -> None:
     pack.total_tokens = total
 
 
-def build_pack(
-    paths: list[str] | None = None,
-    *,
-    config_path: str | None = None,
-    output: str | None = None,
-    output_format: str | None = None,
-    only_tree: bool | None = None,
-    modules: bool | None = None,
-    support: bool | None = None,
-    max_files: int | None = None,
-    max_tokens: int | None = None,
-    min_score: int | None = None,
-    support_content: str | None = None,
-    progress_callback: Callable[[str], None] | None = None,
-    project: bool | None = None,
-    path_base: str = "project",
-) -> ScriberPack:
-    from time import perf_counter
-    timings = {}
-    
-    t_start = perf_counter()
-    paths = paths or ["."]
+def _load_and_apply_config(paths, config_path, output, output_format, only_tree, modules, support, max_files, max_tokens, min_score, support_content):
     resolved_config = resolve_config_path(paths, config_path)
     root = project_root_from_config(resolved_config)
     config = load_config(resolved_config)
@@ -188,11 +168,11 @@ def build_pack(
         min_score=min_score,
         support_content=support_content,
     )
-    timings["config_load"] = perf_counter() - t_start
+    return resolved_config, root, config
 
-    t_scan = perf_counter()
+def _scan_files(paths, root, config, path_base, progress_callback):
     if progress_callback: progress_callback("Skanowanie plikow...")
-    from scriber.native import require_native, is_native_available
+    from scriber.native import is_native_available
     native_files = None
     if is_native_available():
         from scriber.scanner.scan import scan_project_with_native
@@ -201,21 +181,23 @@ def build_pack(
         files = scan_project(root, config)
     resolved_inputs = [_resolve_input(item, root, config.allow_external_paths, path_base) for item in paths]
     seeds = [_expand_seed(path, root, files, config) for path in resolved_inputs]
-    timings["scan"] = perf_counter() - t_scan
-
-    # Detect mode
+    
     is_project_snapshot = False
-    if project:
-        is_project_snapshot = True
-    else:
-        for path in resolved_inputs:
-            if path == root:
-                is_project_snapshot = True
-                break
-    mode = "project_snapshot" if is_project_snapshot else "focused"
+    for path in resolved_inputs:
+        if path == root:
+            is_project_snapshot = True
+            break
+    
+    return files, native_files, seeds, is_project_snapshot
 
-    # Use native code pack builder if available
+
+def _build_graph_and_score(mode, files, seeds, native_files, root, config, progress_callback):
+    from time import perf_counter
+    timings = {}
+    stats = {}
+    from scriber.native import is_native_available
     if is_native_available():
+        from scriber.native import require_native
         native = require_native()
         
         t_graph = perf_counter()
@@ -223,20 +205,45 @@ def build_pack(
         
         assert native_files is not None
         
-        edges = native.build_import_graph(
+        edges = native.build_relation_graph(
             str(root),
             native_files,
             config.python.source_roots,
             config.python.module_init_files
         )
         
-        from scriber.core.models import ModuleGraph
+        from scriber.graph.analyzers import generate_cheap_relations
+        edges.extend(generate_cheap_relations(files, native.NativeRelationEdge, is_native=True))
+        
+        from scriber.cache import ScriberCache
+        cache = ScriberCache(config, root)
+
+        from scriber.core.models import ModuleGraph, RelationEdge
         graph = ModuleGraph()
         for edge in edges:
-            from_path = Path(getattr(edge, "from"))
-            to_path = Path(edge.to)
-            graph.imports.setdefault(from_path, set()).add(to_path)
-            graph.imported_by.setdefault(to_path, set()).add(from_path)
+            from_path = Path(getattr(edge, "source"))
+            to_path = Path(edge.target)
+            py_edge = RelationEdge(
+                source=from_path,
+                target=to_path,
+                kind=edge.kind,
+                weight=edge.weight,
+                confidence=edge.confidence,
+                evidence=edge.evidence,
+                line=edge.line,
+                analyzer=edge.analyzer
+            )
+            graph.add_edge(py_edge)
+            if py_edge.kind in {"import", "reexport"}:
+                cache.add_import_edge(from_path, to_path)
+            
+        cache.save(set(files.keys()))
+        
+        stats["graph_edges_built"] = len(edges)
+        stats["graph_source"] = "native"
+        stats["graph_cache_reads"] = cache.reads
+        stats["graph_cache_hits"] = cache.hits
+        stats["graph_cache_writes"] = cache.writes
             
         timings["graph_build"] = perf_counter() - t_graph
         
@@ -300,7 +307,23 @@ def build_pack(
     else:
         t_graph = perf_counter()
         if progress_callback: progress_callback("Budowanie grafu modulow...")
-        graph = build_graph(files, config)
+        from scriber.cache import ScriberCache
+        cache = ScriberCache(config, root)
+        from scriber.graph.builder import build_graph
+        graph = build_graph(files, config, cache)
+        
+        from scriber.graph.analyzers import generate_cheap_relations
+        from scriber.core.models import RelationEdge
+        cheap_edges = generate_cheap_relations(files, RelationEdge, is_native=False)
+        for edge in cheap_edges:
+            graph.add_edge(edge)
+            
+        stats["graph_edges_built"] = len(graph.edges)
+        stats["graph_source"] = "python"
+        stats["graph_cache_reads"] = cache.reads
+        stats["graph_cache_hits"] = cache.hits
+        stats["graph_cache_writes"] = cache.writes
+        
         timings["graph_build"] = perf_counter() - t_graph
         
         t_score = perf_counter()
@@ -308,6 +331,119 @@ def build_pack(
         candidates = score_candidates(files=files, seeds=seeds, graph=graph, config=config, mode=mode)
         timings["scoring"] = perf_counter() - t_score
 
+    return candidates, graph, timings, stats
+
+def build_pack(
+    paths: list[str] | None = None,
+    *,
+    config_path: str | None = None,
+    profile: str | None = None,
+    output: str | None = None,
+    output_format: str | None = None,
+    only_tree: bool | None = None,
+    modules: bool | None = None,
+    support: bool | None = None,
+    max_files: int | None = None,
+    max_tokens: int | None = None,
+    min_score: int | None = None,
+    support_content: str | None = None,
+    progress_callback: Callable[[str], None] | None = None,
+    project: bool | None = None,
+    path_base: str = "project",
+) -> ScriberPack | LlmPack:
+    from time import perf_counter
+    
+    t_start = perf_counter()
+    paths = paths or ["."]
+    resolved_config, root, config = _load_and_apply_config(
+        paths, config_path, output, output_format, only_tree, modules, support, max_files, max_tokens, min_score, support_content
+    )
+    t_config_load = perf_counter() - t_start
+
+    t_scan = perf_counter()
+    files, native_files, seeds, is_project_snapshot = _scan_files(paths, root, config, path_base, progress_callback)
+    t_scan_time = perf_counter() - t_scan
+
+    mode = "project_snapshot" if (project or is_project_snapshot) else "focused"
+
+    if profile == "full":
+        mode = "project_snapshot"
+    elif profile == "focused-gpt":
+        mode = "focused"
+
+    candidates, graph, sub_timings, stats = _build_graph_and_score(
+        mode, files, seeds, native_files, root, config, progress_callback
+    )
+
+    if profile in {"gpt", "focused-gpt", "full"}:
+        from scriber.engine.ranker import rank_context
+        from scriber.budget.allocator import allocate_budget, BudgetPolicy
+        from time import perf_counter
+        
+        t_rank = perf_counter()
+        if progress_callback: progress_callback("Rankowanie kontekstu...")
+        seed_paths = [seed for p in seeds for seed in p.expanded_files]
+        new_candidates = rank_context(files, graph, seed_paths, config, mode)
+        sub_timings["rank_context"] = perf_counter() - t_rank
+        
+        t_budget = perf_counter()
+        if progress_callback: progress_callback("Alokacja budzetu...")
+        policy = BudgetPolicy(
+            target_tokens=config.max_tokens if config.max_tokens > 0 else 30000,
+            hard_limit_tokens=config.max_tokens if config.max_tokens > 0 else 100000,
+            mode=mode
+        )
+        if mode == "focused":
+            explicit_seeds = {seed for p in seeds for seed in p.expanded_files}
+        else:
+            explicit_seeds = {seed for p in seeds if not p.is_dir for seed in p.expanded_files}
+            
+        items = allocate_budget(new_candidates, policy, explicit_seeds)
+        sub_timings["budget_allocation"] = perf_counter() - t_budget
+        
+        t_content = perf_counter()
+        if progress_callback: progress_callback("Czytanie i outline...")
+        from scriber.outline import generate_outline
+        
+        actual_tokens = 0
+        for item in items:
+            if item.content_mode == "full":
+                try:
+                    item.content = item.file.read_text()
+                    actual_tokens += item.token_estimate
+                except Exception:
+                    item.content_mode = "tree"
+            elif item.content_mode in ("outline", "excerpt"):
+                try:
+                    content = item.file.read_text()
+                    item.outline = generate_outline(item.file, content)
+                    actual_tokens += item.outline.token_estimate
+                except Exception:
+                    item.content_mode = "tree"
+                    
+        sub_timings["content_read"] = perf_counter() - t_content
+        
+        stats["input_paths"] = paths
+        pack = LlmPack(
+            project_root=root,
+            config_path=resolved_config,
+            profile=profile,
+            mode=mode,
+            goal=None,
+            budget_target=policy.target_tokens,
+            budget_actual=actual_tokens,
+            items=items,
+            graph=graph,
+            stats=stats,
+            warnings=[]
+        )
+        pack.timings = {
+            "config_load": t_config_load,
+            "scan": t_scan_time,
+            **sub_timings
+        }
+        return pack
+
     pack = ScriberPack(
         project_root=root,
         config_path=resolved_config,
@@ -317,18 +453,24 @@ def build_pack(
         only_tree=config.only_tree,
         output_format=config.format,
         mode=mode,
+        stats=stats,
     )
     
     t_content = perf_counter()
     if progress_callback: progress_callback("Aplikowanie regul zawartosci...")
     _apply_content_policy(pack, config)
-    timings["content_read"] = perf_counter() - t_content
+    t_content_time = perf_counter() - t_content
     
-    pack.timings = timings
+    pack.timings = {
+        "config_load": t_config_load,
+        "scan": t_scan_time,
+        "content_read": t_content_time,
+        **sub_timings
+    }
     return pack
 
 
-def build_and_write_pack(paths: list[str] | None = None, **kwargs) -> tuple[Path | None, ScriberPack]:
+def build_and_write_pack(paths: list[str] | None = None, **kwargs) -> tuple[Path | None, ScriberPack | LlmPack]:
     explain_selection = kwargs.pop("explain_selection", False)
     pack = build_pack(paths, **kwargs)
     config_path = resolve_config_path(paths or ["."], kwargs.get("config_path"))
@@ -347,7 +489,16 @@ def build_and_write_pack(paths: list[str] | None = None, **kwargs) -> tuple[Path
     )
     progress = kwargs.get("progress_callback")
     if progress: progress("Renderowanie Markdown...")
-    rendered = render_pack(pack, explain_selection=explain_selection)
+    
+    if isinstance(pack, LlmPack):
+        from scriber.renderer.llm_report import render_llm_report
+        import io
+        buf = io.StringIO()
+        render_llm_report(pack, buf)
+        rendered = buf.getvalue()
+    else:
+        rendered = render_pack(pack, explain_selection=explain_selection)
+        
     output = config.output
     if str(output) == "-":
         import sys
@@ -360,6 +511,13 @@ def build_and_write_pack(paths: list[str] | None = None, **kwargs) -> tuple[Path
     if not output.is_absolute():
         output = pack.project_root / output
     output.parent.mkdir(parents=True, exist_ok=True)
-    from scriber.native import require_native
-    require_native().write_text(str(output), rendered)
+    try:
+        from scriber.native import is_native_available, require_native
+        if is_native_available():
+            require_native().write_text(str(output), rendered)
+        else:
+            output.write_text(rendered, encoding="utf-8")
+    except Exception:
+        output.write_text(rendered, encoding="utf-8")
+        
     return output, pack
diff --git a/src/scriber/renderer/llm_report.py b/src/scriber/renderer/llm_report.py
new file mode 100644
index 0000000..027b182
--- /dev/null
+++ b/src/scriber/renderer/llm_report.py
@@ -0,0 +1,216 @@
+from __future__ import annotations
+from typing import TextIO
+from pathlib import Path
+from collections import defaultdict
+import json
+
+from scriber.core.models import LlmPack, PackItem, FileOutline
+from scriber.graph.model import RelationEdge
+
+def render_llm_report(pack: LlmPack, out: TextIO) -> None:
+    out.write("# Scriber Pack v3\n\n")
+    
+    out.write("<scriber_instructions>\n")
+    out.write("You are reading a generated codebase context pack.\n")
+    out.write("Prefer facts from <manifest>, <relations>, and <file> blocks.\n")
+    out.write("If a file is tree_only or omitted, do not infer its contents.\n")
+    out.write("When proposing patches, cite file IDs and line ranges.\n")
+    out.write("</scriber_instructions>\n\n")
+    
+    out.write("<manifest format=\"yaml\">\n")
+    out.write("project:\n")
+    out.write(f"  mode: {pack.mode}\n")
+    out.write(f"  goal: {pack.goal or 'null'}\n")
+    out.write(f"  target_tokens: {pack.budget_target}\n")
+    out.write(f"  actual_tokens: {pack.budget_actual}\n")
+    
+    input_paths = pack.stats.get("input_paths", [])
+    if input_paths:
+        out.write("  analyzed_targets:\n")
+        for p in input_paths:
+            out.write(f"    - {p}\n")
+    out.write("\n")
+    
+    out.write("read_order:\n")
+    for item in pack.items:
+        if item.content_mode not in ("tree", "omit"):
+            out.write(f"  - {item.item_id}  # {item.file.relative.as_posix()}\n")
+            
+    out.write("\nfiles:\n")
+    for item in pack.items:
+        if item.content_mode in ("omit",):
+            continue
+        out.write(f"  {item.item_id}:\n")
+        out.write(f"    path: {item.file.relative.as_posix()}\n")
+        out.write(f"    role: {item.role}\n")
+        out.write(f"    mode: {item.content_mode}\n")
+        out.write(f"    score: {item.score}\n")
+        out.write(f"    utility: {item.utility:.2f}\n")
+        out.write(f"    tokens: {item.token_estimate}\n")
+        if item.outline and item.outline.purpose:
+            out.write(f"    purpose: {item.outline.purpose}\n")
+    out.write("</manifest>\n\n")
+
+    out.write("## Architecture map\n")
+    out.write("```\n")
+    _render_tree(pack.items, out)
+    out.write("```\n\n")
+
+    out.write("<relations>\n")
+    _render_graph(pack, out)
+    out.write("</relations>\n\n")
+    
+    warnings = _generate_warnings(pack)
+    if warnings:
+        out.write("## Pack quality warnings\n\n")
+        for w in warnings:
+            out.write(f"- {w}\n")
+        out.write("\n")
+
+    out.write("## Files Content\n\n")
+    
+    for item in pack.items:
+        if item.content_mode in ("tree", "omit"):
+            continue
+            
+        out.write(f'<file id="{item.item_id}" path="{item.file.relative.as_posix()}" role="{item.role}" mode="{item.content_mode}">\n')
+        
+        if item.outline and item.outline.purpose:
+            out.write("<purpose>\n")
+            out.write(f"{item.outline.purpose}\n")
+            out.write("</purpose>\n\n")
+            
+        if item.outline:
+            _render_symbols_manifest(item.outline, out)
+
+        if item.content_mode == "full" and item.content:
+            out.write(f"```{item.file.language} linenums=\"1\"\n")
+            out.write(_add_line_numbers(item.content, item.file.relative.as_posix(), item.file.language))
+            if not item.content.endswith("\n"):
+                out.write("\n")
+            out.write("```\n")
+            
+        elif item.content_mode == "excerpt":
+            if item.excerpts:
+                for excerpt in item.excerpts:
+                    out.write(f"```{item.file.language}\n")
+                    out.write(excerpt)
+                    out.write("\n```\n\n")
+            elif item.outline:
+                _render_outline_fallback(item, out)
+            else:
+                out.write("_Excerpt unavailable; falling back to metadata only._\n\n")
+                
+        elif item.content_mode == "outline" and item.outline:
+            _render_outline_fallback(item, out)
+            
+        out.write("</file>\n\n")
+
+import re
+
+def _add_line_numbers(content: str, path: str, language: str) -> str:
+    lines = content.splitlines()
+    out = []
+    out.append(f"# file: {path}")
+    out.append(f"# lines: 1-{len(lines)}")
+    for i, line in enumerate(lines, 1):
+        if language in ("python", "py"):
+            m = re.match(r'^(\s*)(class|def|async def)\s+([a-zA-Z0-9_]+)', line)
+            if m:
+                indent, _, name = m.groups()
+                out.append(f"{i:04d} {indent}# <anchor id=\"{name}\">")
+        out.append(f"{i:04d} {line}")
+    return "\n".join(out)
+
+def _render_symbols_manifest(outline: FileOutline, out: TextIO) -> None:
+    symbols = []
+    if outline.classes:
+        symbols.extend(outline.classes)
+    if outline.functions:
+        symbols.extend(outline.functions)
+    if not symbols:
+        return
+        
+    out.write("<symbols>\n")
+    for sym in symbols:
+        out.write(f"- {sym}\n")
+    out.write("</symbols>\n\n")
+
+def _render_outline_fallback(item: PackItem, out: TextIO) -> None:
+    out.write("```python\n") 
+    out.write(f"# Outline for {item.file.relative.name}\n")
+    if item.outline.classes:
+        out.write("Classes: " + ", ".join(item.outline.classes) + "\n")
+    if item.outline.functions:
+        out.write("Functions: " + ", ".join(item.outline.functions) + "\n")
+    if item.outline.imports:
+        out.write("Imports: " + ", ".join(item.outline.imports) + "\n")
+    out.write("```\n\n")
+
+def _generate_warnings(pack: LlmPack) -> list[str]:
+    warnings = []
+    empty_excerpts = sum(1 for i in pack.items if i.content_mode == "excerpt" and not i.excerpts)
+    if empty_excerpts > 0:
+        warnings.append(f"{empty_excerpts} files are marked excerpt but have no excerpts (falling back to outline).")
+    
+    unknown_roles = sum(1 for i in pack.items if i.role == "unknown")
+    if unknown_roles > 0:
+        warnings.append(f"{unknown_roles} files have role=unknown.")
+        
+    return warnings
+
+def _render_tree(items: list[PackItem], out: TextIO) -> None:
+    tree = {}
+    item_map = {item.file.relative.as_posix(): item for item in items}
+    
+    for item in items:
+        parts = item.file.relative.parts
+        curr = tree
+        for part in parts:
+            if part not in curr:
+                curr[part] = {}
+            curr = curr[part]
+            
+    def print_node(path_parts, current_dict, prefix=""):
+        keys = sorted(current_dict.keys())
+        for i, k in enumerate(keys):
+            is_last = i == len(keys) - 1
+            child_prefix = prefix + ("    " if is_last else "│   ")
+            connector = "└── " if is_last else "├── "
+            
+            full_path = "/".join(path_parts + (k,))
+            item = item_map.get(full_path)
+            
+            if item:
+                badge = f"[{item.item_id} {item.role} {item.content_mode} score={item.score}]"
+                name_str = f"{prefix}{connector}{k}"
+                out.write(f"{name_str:<50} {badge}\n")
+            else:
+                out.write(f"{prefix}{connector}{k}/\n")
+                print_node(path_parts + (k,), current_dict[k], child_prefix)
+                
+    out.write(".\n")
+    print_node((), tree, "")
+
+def _render_graph(pack: LlmPack, out: TextIO) -> None:
+    included_paths = {item.file.relative for item in pack.items}
+    item_id_map = {item.file.relative: item.item_id for item in pack.items}
+    
+    groups = defaultdict(list)
+    for edge in pack.graph.edges:
+        if edge.source in included_paths and edge.target in included_paths:
+            key = (edge.source, edge.target, edge.kind)
+            groups[key].append(edge)
+            
+    sorted_groups = sorted(groups.items(), key=lambda x: (x[0][0].as_posix(), x[0][1].as_posix()))
+    
+    for (source, target, kind), edges in sorted_groups:
+        count = len(edges)
+        max_conf = max(e.confidence for e in edges)
+        analyzers = sorted({e.analyzer for e in edges})
+        
+        s_id = item_id_map[source]
+        t_id = item_id_map[target]
+        
+        analyzer_str = ",".join(analyzers)
+        out.write(f"{s_id} -> {t_id} [{kind}] x{count} (analyzers=[{analyzer_str}], conf={max_conf:.2f})\n")
diff --git a/src/scriber/scanner/files.py b/src/scriber/scanner/files.py
index f203dde..d4e8c20 100644
--- a/src/scriber/scanner/files.py
+++ b/src/scriber/scanner/files.py
@@ -42,7 +42,11 @@ def is_probably_binary(path: Path) -> bool:
     try:
         return require_native().is_probably_binary(str(path))
     except Exception:
-        return True
+        try:
+            chunk = path.read_bytes()[:4096]
+            return b"\0" in chunk
+        except OSError:
+            return True
 
 
 def language_for(path: Path) -> str:
diff --git a/src/scriber/scanner/scan.py b/src/scriber/scanner/scan.py
index e2fa8a4..922c44a 100644
--- a/src/scriber/scanner/scan.py
+++ b/src/scriber/scanner/scan.py
@@ -6,8 +6,16 @@
 
 
 def scan_project(root: Path, config: ScriberConfig) -> dict[Path, FileNode]:
-    files, _ = scan_project_with_native(root, config)
-    return files
+    try:
+        from scriber.native import is_native_available
+        if is_native_available():
+            files, _ = scan_project_with_native(root, config)
+            return files
+    except Exception:
+        pass
+
+    from scriber.scanner.scan_py import scan_project as scan_project_py
+    return scan_project_py(root, config)
 
 
 def scan_project_with_native(root: Path, config: ScriberConfig) -> tuple[dict[Path, FileNode], list]:
diff --git a/tests/test_cache.py b/tests/test_cache.py
index 5c141bf..94dc68e 100644
--- a/tests/test_cache.py
+++ b/tests/test_cache.py
@@ -35,7 +35,7 @@ def test_cache_functionality(tmp_path: Path) -> None:
     
     # Check that cache files were created
     assert (tmp_path / ".scriber/cache/files.json").exists()
-    assert (tmp_path / ".scriber/cache/import_graph.json").exists()
+    assert (tmp_path / ".scriber/cache/imports_v2.json").exists()
     
     # Reload cache and check if retrieved properly
     new_cache = ScriberCache(config, tmp_path)
diff --git a/tests/test_native.py b/tests/test_native.py
index 643d795..77c3341 100644
--- a/tests/test_native.py
+++ b/tests/test_native.py
@@ -193,7 +193,7 @@ def test_native_graph_matches_python_graph_mixed_project(tmp_path: Path) -> None
         config.support_content.default,
         config.support
     )
-    edges = native.build_import_graph(
+    edges = native.build_relation_graph(
         str(tmp_path),
         native_files,
         config.python.source_roots,
@@ -202,7 +202,8 @@ def test_native_graph_matches_python_graph_mixed_project(tmp_path: Path) -> None
 
     rs_imports = {}
     for edge in edges:
-        rs_imports.setdefault(Path(getattr(edge, "from")), set()).add(Path(edge.to))
+        if edge.kind == "import" or edge.kind == "mod" or edge.kind == "use" or edge.kind == "include":
+            rs_imports.setdefault(Path(getattr(edge, "source")), set()).add(Path(edge.target))
     
     for path, targets in py_graph.imports.items():
         file = python_files[path]
@@ -242,7 +243,7 @@ def test_native_scoring_matches_python_for_focused_pack(tmp_path: Path) -> None:
         config.support_content.default,
         config.support
     )
-    edges = native.build_import_graph(
+    edges = native.build_relation_graph(
         str(tmp_path),
         native_files,
         config.python.source_roots,
@@ -397,16 +398,17 @@ def test_native_import_complex_python(tmp_path: Path) -> None:
         config.support_content.default,
         config.support
     )
-    edges = native.build_import_graph(
+    edges = native.build_relation_graph(
         str(tmp_path),
         native_files,
         config.python.source_roots,
         config.python.module_init_files
     )
 
-    imports = {Path(getattr(edge, "from")): set() for edge in edges}
+    imports = {Path(getattr(edge, "source")): set() for edge in edges}
     for edge in edges:
-        imports[Path(getattr(edge, "from"))].add(Path(edge.to))
+        if edge.kind == "import":
+            imports[Path(getattr(edge, "source"))].add(Path(edge.target))
         
     main_path = Path("src/main.py")
     assert main_path in imports
diff --git a/tests/test_symbols.py b/tests/test_symbols.py
new file mode 100644
index 0000000..fd4a5e1
--- /dev/null
+++ b/tests/test_symbols.py
@@ -0,0 +1,43 @@
+from pathlib import Path
+from scriber.core.symbols import SymbolIndex, SymbolNode
+from scriber.graph.languages.extractor import extract_python_symbols
+
+def test_extract_python_symbols() -> None:
+    code = """
+class MyClass:
+    def __init__(self):
+        pass
+
+    async def my_method(self):
+        pass
+
+def global_function():
+    pass
+"""
+    index = SymbolIndex()
+    file_path = Path("src/dummy.py")
+    
+    extract_python_symbols(file_path, code, index)
+    
+    symbols = index.get_symbols(file_path)
+    assert len(symbols) == 4
+    
+    # Check Class
+    class_sym = next(s for s in symbols if s.name == "MyClass")
+    assert class_sym.kind == "class"
+    assert class_sym.parent_name is None
+    
+    # Check Constructor
+    init_sym = next(s for s in symbols if s.name == "__init__")
+    assert init_sym.kind == "function"
+    assert init_sym.parent_name == "MyClass"
+    
+    # Check Async Method
+    method_sym = next(s for s in symbols if s.name == "my_method")
+    assert method_sym.kind == "function"
+    assert method_sym.parent_name == "MyClass"
+    
+    # Check Global Function
+    func_sym = next(s for s in symbols if s.name == "global_function")
+    assert func_sym.kind == "function"
+    assert func_sym.parent_name is None