interlinked-mapper 0.3.9__tar.gz → 0.3.11__tar.gz

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.3.9
+Version: 0.3.11
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked/analyzer/graph.py

@@ -15,6 +15,7 @@ from interlinked.models import (
 # Method names so common on builtins (dict, list, set, str, etc.) that resolving
 # them to project symbols by bare-name matching is almost always a false positive.
 # e.g. `op_dict.items()` should NOT resolve to `ActionCost.items`.
+# Checked against the LAST component of dotted targets (e.g. "effect.get" → "get").
 _BUILTIN_METHOD_NAMES: frozenset[str] = frozenset({
     # dict
     "items", "keys", "values", "get", "pop", "update", "setdefault",
@@ -28,8 +29,9 @@ _BUILTIN_METHOD_NAMES: frozenset[str] = frozenset({
     # str
     "strip", "split", "join", "replace", "startswith", "endswith",
     "lower", "upper", "format", "encode", "decode",
-    # general
+    # general / logging
     "close", "read", "write", "flush", "seek", "tell",
+    "warning", "error", "info", "debug", "exception", "critical",
 })
 
 
@@ -236,36 +238,48 @@ class CodeGraph:
                 source = next(iter(candidates))
 
         if target not in node_ids:
-            # Never resolve bare builtin method names — they match too
-            # broadly (e.g. "items" matching ActionCost.items when the
-            # actual call is dict.items()).
-            if target in _BUILTIN_METHOD_NAMES:
+            # Check the last dotted component against builtin method names.
+            # Catches both bare "items" and dotted "effect.get", "args.items".
+            leaf = target.rsplit(".", 1)[-1]
+            if leaf in _BUILTIN_METHOD_NAMES:
                 return edge
 
+            # Dotted targets like "effect.get" or "logger.warning" where the
+            # root is NOT a known node are local-variable method calls —
+            # resolving them through the name index produces false positives.
+            if "." in target:
+                root = target.split(".", 1)[0]
+                # If the root isn't itself a project node, it's a local var
+                if root not in node_ids and root not in name_index:
+                    return edge
+
             candidates = name_index.get(target, set())
             if len(candidates) == 1:
                 target = next(iter(candidates))
             elif len(candidates) > 1:
-                # For CALLS edges, a bare name like `process()` in Python
-                # NEVER resolves to the same class — you need `self.process()`
-                # for that.  Exclude the source itself to prevent self-call
-                # artifacts, and prefer module-level over class-level.
+                # Exclude self-calls (bare `process()` != `self.process()`)
                 filtered = candidates - {source}
                 if not filtered:
                     filtered = candidates
 
-                # Extract the top-level module from the source
+                # Prefer candidates sharing the longest common prefix with
+                # the source.  This ensures a call from engine.rules.resolver
+                # to _resolve_entity_ref picks resolver's own definition
+                # over engine.rules.field_paths._resolve_entity_ref.
                 src_parts = source.split(".")
-                src_module = src_parts[0] if src_parts else source
-
-                # Score candidates: prefer same module, then shorter paths
-                # (module-level functions are shorter than class methods)
-                best = None
-                for c in filtered:
-                    if c.startswith(src_module + "."):
-                        if best is None or c.count(".") < best.count("."):
-                            best = c
-                target = best or next(iter(filtered))
+
+                def _common_prefix_len(c: str) -> int:
+                    c_parts = c.split(".")
+                    n = 0
+                    for a, b in zip(src_parts, c_parts):
+                        if a == b:
+                            n += 1
+                        else:
+                            break
+                    return n
+
+                best = max(filtered, key=lambda c: (_common_prefix_len(c), -c.count(".")))
+                target = best
 
         if source == edge.source and target == edge.target:
             return edge

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked/analyzer/parser.py

@@ -34,6 +34,7 @@ import warnings
 from pathlib import Path
 from typing import Any
 
+from interlinked.analyzer.graph import _BUILTIN_METHOD_NAMES
 from interlinked.models import NodeData, EdgeData, SymbolType, EdgeType
 
 # Python builtins we should never create nodes/edges for
@@ -323,7 +324,17 @@ def parse_project(root: str | Path) -> tuple[list[NodeData], list[EdgeData]]:
                     metadata=e.metadata,
                 ))
             else:
-                # Keep the raw call target — external library calls visible to auditors
+                # Keep the raw call target — external library calls visible
+                # to auditors.  BUT filter out localvar.builtin_method()
+                # patterns: if the inferencer couldn't resolve the target
+                # and the leaf is a common builtin method name, it's almost
+                # certainly a dict/list/str/logging method on a local var
+                # (e.g. effect.get(), args.items(), logger.warning()).
+                # Real project method calls resolve through the type system.
+                if "." in raw_target:
+                    leaf = raw_target.rsplit(".", 1)[-1]
+                    if leaf in _BUILTIN_METHOD_NAMES:
+                        continue
                 resolved_edges.append(e)
             continue
 

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked/analyzer/similarity.py

@@ -254,8 +254,8 @@ def get_rich_context(graph: CodeGraph, node: NodeData) -> dict:
     # Connections
     callers = graph.callers_of(node.id)
     callees = graph.callees_of(node.id)
-    context["callers"] = [{"id": n.id, "name": n.name} for n in callers[:20]]
-    context["callees"] = [{"id": n.id, "name": n.name} for n in callees[:20]]
+    context["callers"] = [{"id": n.id, "name": n.name} for n in callers]
+    context["callees"] = [{"id": n.id, "name": n.name} for n in callees]
 
     # Fingerprint — slim version (drop ast_tree, minhash, ast_node_counts)
     fp = node.metadata.get("fingerprint")

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked/mcp_server.py

@@ -563,10 +563,7 @@ def _dispatch_via_server(name: str, args: dict[str, Any], server_url: str) -> st
                 return json.dumps(result, indent=2)
             return str(result)
         if "results" in data:
-            results = data["results"]
-            if len(results) > 20:
-                return f"Found {len(results)} results. Showing first 20:\n" + json.dumps(results[:20], indent=2)
-            return json.dumps(results, indent=2)
+            return json.dumps(data["results"], indent=2)
         if "error" in data:
             return f"Error: {data['error']}"
         return json.dumps(data, indent=2)
@@ -654,10 +651,7 @@ async def _async_dispatch_via_server(name: str, args: dict[str, Any], server_url
                 return json.dumps(result, indent=2)
             return str(result)
         if "results" in data:
-            results = data["results"]
-            if len(results) > 20:
-                return f"Found {len(results)} results. Showing first 20:\n" + json.dumps(results[:20], indent=2)
-            return json.dumps(results, indent=2)
+            return json.dumps(data["results"], indent=2)
         if "error" in data:
             return f"Error: {data['error']}"
         return json.dumps(data, indent=2)
@@ -692,9 +686,6 @@ def _dispatch_tool(
 
     elif name == "interlinked_query":
         results = engine.query(args["expression"])
-        if len(results) > 20:
-            summary = f"Found {len(results)} results. Showing first 20:\n"
-            return summary + json.dumps(results[:20], indent=2)
         return json.dumps(results, indent=2)
 
     elif name == "interlinked_trace_variable":

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked_mapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.3.9
+Version: 0.3.11
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/interlinked_mapper.egg-info/SOURCES.txt

@@ -41,4 +41,5 @@ interlinked_mapper.egg-info/dependency_links.txt
 interlinked_mapper.egg-info/entry_points.txt
 interlinked_mapper.egg-info/requires.txt
 interlinked_mapper.egg-info/top_level.txt
-tests/test_accuracy.py
+tests/test_accuracy.py
+tests/test_query_completeness.py

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlinked-mapper"
-version = "0.3.9"
+version = "0.3.11"
 description = "A Python program topology explorer — visualize the shape of your codebase"
 readme = "README.md"
 license = {text = "MIT"}

{interlinked_mapper-0.3.9 → interlinked_mapper-0.3.11}/tests/test_accuracy.py

@@ -917,6 +917,91 @@ class TestParserSkipDirs:
 # ══════════════════════════════════════════════════════════════════════
 
 
+class TestFalsePositiveEdges:
+    """Regression tests for false positive edge resolution.
+
+    These patterns caused incorrect edges in production:
+    - effect.get(), args.items() — dotted builtin methods not caught
+    - logger.warning() — logging method resolving to project symbols
+    - _resolve_entity_ref — same-name function in sibling module
+    """
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.graph, self.engine, _, _ = _build(FIXTURES)
+
+    def _edge_targets_from(self, source_partial: str, edge_type: EdgeType | None = None) -> set[str]:
+        """All edge targets from a source matching partial name."""
+        src = _find(self.graph, source_partial)
+        return {
+            e.target for e in self.graph.all_edges()
+            if e.source == src
+            and (edge_type is None or e.edge_type == edge_type)
+        }
+
+    def test_dict_get_not_resolved(self):
+        """effect.get('value') must NOT create a call to any project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        # "effect.get" should not resolve to anything with ".get" in it
+        assert not any(t.endswith(".get") for t in targets), \
+            f"dict.get() false positive: {[t for t in targets if '.get' in t]}"
+
+    def test_dict_items_not_resolved(self):
+        """args.items() must NOT create a call to any project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".items") for t in targets), \
+            f"dict.items() false positive: {[t for t in targets if '.items' in t]}"
+
+    def test_list_extend_not_resolved(self):
+        """ops.extend() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".extend") for t in targets), \
+            f"list.extend() false positive: {[t for t in targets if '.extend' in t]}"
+
+    def test_list_append_not_resolved(self):
+        """collected.append() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".append") and "." in t.rsplit(".append", 1)[0] for t in targets), \
+            f"list.append() false positive: {[t for t in targets if '.append' in t]}"
+
+    def test_str_startswith_not_resolved(self):
+        """ref.startswith() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".startswith") for t in targets), \
+            f"str.startswith() false positive: {[t for t in targets if '.startswith' in t]}"
+
+    def test_str_split_not_resolved(self):
+        """ref.split() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".split") for t in targets), \
+            f"str.split() false positive: {[t for t in targets if '.split' in t]}"
+
+    def test_logger_warning_not_resolved(self):
+        """logger.warning() must NOT create edges to project symbols."""
+        targets = self._edge_targets_from("logging_calls", EdgeType.CALLS)
+        # Should not resolve to any project node
+        node_ids = _node_ids(self.graph)
+        resolved_to_project = targets & node_ids
+        bad = {t for t in resolved_to_project if "warning" in t or "error" in t or "info" in t or "debug" in t}
+        assert not bad, \
+            f"logging calls resolved to project symbols: {bad}"
+
+    def test_same_name_helper_resolves_locally(self):
+        """calls_shared_helper() should call THIS module's _shared_helper."""
+        caller = _find(self.graph, "calls_shared_helper")
+        targets = {
+            e.target for e in self.graph.all_edges()
+            if e.source == caller and e.edge_type == EdgeType.CALLS
+        }
+        # Should resolve to false_positive_edges._shared_helper, not another module's
+        local_match = [t for t in targets if "false_positive_edges._shared_helper" in t]
+        foreign_match = [t for t in targets if "_shared_helper" in t and "false_positive_edges" not in t]
+        assert local_match, \
+            f"calls_shared_helper should call local _shared_helper, got: {targets}"
+        assert not foreign_match, \
+            f"calls_shared_helper resolved to foreign _shared_helper: {foreign_match}"
+
+
 class TestMCPFidelity:
     """Verify MCP dispatch produces the same results as direct engine calls."""
 

interlinked_mapper-0.3.11/tests/test_query_completeness.py

@@ -0,0 +1,506 @@
+"""Tests that every query type returns FULL untruncated results.
+
+No result set should ever be silently capped or truncated.
+Every query path in QueryEngine.query() and every MCP dispatch path
+must return all matching results.
+
+Run: pytest tests/test_query_completeness.py -v
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from interlinked.analyzer.parser import parse_project
+from interlinked.analyzer.graph import CodeGraph
+from interlinked.analyzer.dead_code import detect_dead_code
+from interlinked.commander.query import QueryEngine, _slim_node_dict
+from interlinked.models import SymbolType, EdgeType, NodeData
+
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def _build() -> tuple[CodeGraph, QueryEngine]:
+    nodes, edges = parse_project(str(FIXTURES))
+    graph = CodeGraph()
+    graph.build_from(nodes, edges)
+    detect_dead_code(graph)
+    engine = QueryEngine(graph)
+    return graph, engine
+
+
+# ══════════════════════════════════════════════════════════════════════
+# 1. QUERY COMPLETENESS — every query type returns all results
+# ══════════════════════════════════════════════════════════════════════
+
+
+class TestQueryCompleteness:
+    """Every query type must return the full result set, never truncated."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.graph, self.engine = _build()
+
+    def _count_by_type(self, sym_type: SymbolType) -> int:
+        return len(self.graph.nodes_by_type(sym_type))
+
+    def _count_dead(self, type_filter: set[SymbolType] | None = None) -> int:
+        return len([
+            n for n in self.graph.all_nodes()
+            if n.is_dead
+            and (type_filter is None or n.symbol_type in type_filter)
+        ])
+
+    # ── "functions" / "methods" ──────────────────────────────────
+
+    def test_functions_query_returns_all(self):
+        results = self.engine.query("functions")
+        expected = (
+            self._count_by_type(SymbolType.FUNCTION)
+            + self._count_by_type(SymbolType.METHOD)
+        )
+        assert len(results) == expected, \
+            f"'functions' query returned {len(results)}, expected {expected}"
+
+    def test_methods_query_returns_all(self):
+        results = self.engine.query("methods")
+        expected = (
+            self._count_by_type(SymbolType.FUNCTION)
+            + self._count_by_type(SymbolType.METHOD)
+        )
+        assert len(results) == expected, \
+            f"'methods' query returned {len(results)}, expected {expected}"
+
+    # ── "classes" ────────────────────────────────────────────────
+
+    def test_classes_query_returns_all(self):
+        results = self.engine.query("classes")
+        expected = self._count_by_type(SymbolType.CLASS)
+        assert len(results) == expected, \
+            f"'classes' query returned {len(results)}, expected {expected}"
+
+    # ── "modules" ────────────────────────────────────────────────
+
+    def test_modules_query_returns_all(self):
+        results = self.engine.query("modules")
+        expected = self._count_by_type(SymbolType.MODULE)
+        assert len(results) == expected, \
+            f"'modules' query returned {len(results)}, expected {expected}"
+
+    # ── "variables" ──────────────────────────────────────────────
+
+    def test_variables_query_returns_all(self):
+        results = self.engine.query("variables")
+        expected = len([
+            n for n in self.graph.all_nodes()
+            if n.symbol_type == SymbolType.VARIABLE
+        ])
+        assert len(results) == expected, \
+            f"'variables' query returned {len(results)}, expected {expected}"
+
+    # ── "parameters" ─────────────────────────────────────────────
+
+    def test_parameters_query_returns_all(self):
+        results = self.engine.query("parameters")
+        expected = len([
+            n for n in self.graph.all_nodes()
+            if n.symbol_type == SymbolType.PARAMETER
+        ])
+        assert len(results) == expected, \
+            f"'parameters' query returned {len(results)}, expected {expected}"
+
+    # ── "dead functions" ─────────────────────────────────────────
+
+    def test_dead_functions_returns_all(self):
+        results = self.engine.query("dead functions")
+        expected = self._count_dead({SymbolType.FUNCTION, SymbolType.METHOD})
+        assert len(results) == expected, \
+            f"'dead functions' returned {len(results)}, expected {expected}"
+
+    def test_dead_returns_all(self):
+        results = self.engine.query("dead")
+        expected = self._count_dead()
+        assert len(results) == expected, \
+            f"'dead' returned {len(results)}, expected {expected}"
+
+    # ── "callers of X" ───────────────────────────────────────────
+
+    def test_callers_of_returns_all(self):
+        # Pick a node that has callers
+        for node in self.graph.all_nodes():
+            callers = self.graph.callers_of(node.id)
+            if len(callers) >= 2:
+                results = self.engine.query(f"callers of {node.qualified_name}")
+                assert len(results) == len(callers), \
+                    f"'callers of {node.name}' returned {len(results)}, expected {len(callers)}"
+                return
+        pytest.skip("No node with >=2 callers found in fixtures")
+
+    # ── "callees of X" ───────────────────────────────────────────
+
+    def test_callees_of_returns_all(self):
+        for node in self.graph.all_nodes():
+            callees = self.graph.callees_of(node.id)
+            if len(callees) >= 2:
+                results = self.engine.query(f"callees of {node.qualified_name}")
+                assert len(results) == len(callees), \
+                    f"'callees of {node.name}' returned {len(results)}, expected {len(callees)}"
+                return
+        pytest.skip("No node with >=2 callees found in fixtures")
+
+    # ── "parameters of X" ────────────────────────────────────────
+
+    def test_parameters_of_returns_all(self):
+        for node in self.graph.all_nodes():
+            if node.symbol_type not in (SymbolType.FUNCTION, SymbolType.METHOD):
+                continue
+            G = self.graph._g
+            if node.id not in G:
+                continue
+            param_ids = [
+                v for _, v, d in G.out_edges(node.id, data=True)
+                if d.get("edge_type") == "contains"
+                and self.graph.get_node(v)
+                and self.graph.get_node(v).symbol_type == SymbolType.PARAMETER
+            ]
+            if len(param_ids) >= 2:
+                results = self.engine.query(f"parameters of {node.qualified_name}")
+                assert len(results) == len(param_ids), \
+                    f"'parameters of {node.name}' returned {len(results)}, expected {len(param_ids)}"
+                return
+        pytest.skip("No function with >=2 params found in fixtures")
+
+    # ── "returns of X" ───────────────────────────────────────────
+
+    def test_returns_of_returns_all(self):
+        for node in self.graph.all_nodes():
+            edges = self.graph.edges_from(node.id, EdgeType.RETURNS)
+            ret_nodes = [self.graph.get_node(e.target) for e in edges if self.graph.get_node(e.target)]
+            if len(ret_nodes) >= 1:
+                results = self.engine.query(f"returns of {node.qualified_name}")
+                assert len(results) == len(ret_nodes), \
+                    f"'returns of {node.name}' returned {len(results)}, expected {len(ret_nodes)}"
+                return
+        pytest.skip("No function with return edges found in fixtures")
+
+    # ── "imports of X" ───────────────────────────────────────────
+
+    def test_imports_of_returns_all(self):
+        for node in self.graph.all_nodes():
+            if node.symbol_type != SymbolType.MODULE:
+                continue
+            edges = self.graph.edges_from(node.id, EdgeType.IMPORTS)
+            if len(edges) >= 1:
+                results = self.engine.query(f"imports of {node.qualified_name}")
+                assert len(results) == len(edges), \
+                    f"'imports of {node.name}' returned {len(results)}, expected {len(edges)}"
+                return
+        pytest.skip("No module with imports found in fixtures")
+
+    # ── "external calls" ─────────────────────────────────────────
+
+    def test_external_calls_returns_all(self):
+        node_ids = {n.id for n in self.graph.all_nodes()}
+        expected = [
+            e for e in self.graph.all_edges()
+            if e.edge_type == EdgeType.CALLS and e.target not in node_ids
+        ]
+        results = self.engine.query("external calls")
+        assert len(results) == len(expected), \
+            f"'external calls' returned {len(results)}, expected {len(expected)}"
+
+    # ── scoped queries ───────────────────────────────────────────
+
+    def test_scoped_functions_returns_all(self):
+        # Find a module with multiple functions
+        modules = self.graph.nodes_by_type(SymbolType.MODULE)
+        for mod in modules:
+            scope = mod.qualified_name
+            expected = [
+                n for n in self.graph.all_nodes()
+                if n.symbol_type in (SymbolType.FUNCTION, SymbolType.METHOD)
+                and n.qualified_name.startswith(scope)
+            ]
+            if len(expected) >= 3:
+                results = self.engine.query(f"functions in {scope}")
+                assert len(results) == len(expected), \
+                    f"'functions in {scope}' returned {len(results)}, expected {len(expected)}"
+                return
+        pytest.skip("No module with >=3 functions found")
+
+    def test_scoped_classes_returns_all(self):
+        modules = self.graph.nodes_by_type(SymbolType.MODULE)
+        for mod in modules:
+            scope = mod.qualified_name
+            expected = [
+                n for n in self.graph.nodes_by_type(SymbolType.CLASS)
+                if n.qualified_name.startswith(scope)
+            ]
+            if len(expected) >= 2:
+                results = self.engine.query(f"classes in {scope}")
+                assert len(results) == len(expected), \
+                    f"'classes in {scope}' returned {len(results)}, expected {len(expected)}"
+                return
+        pytest.skip("No module with >=2 classes found")
+
+    # ── fuzzy name search ────────────────────────────────────────
+
+    def test_fuzzy_search_returns_all(self):
+        # Search for a common substring
+        term = "process"
+        expected = [
+            n for n in self.graph.all_nodes()
+            if term in n.qualified_name.lower() or term in n.name.lower()
+        ]
+        results = self.engine.query(term)
+        assert len(results) == len(expected), \
+            f"fuzzy search '{term}' returned {len(results)}, expected {len(expected)}"
+
+
+# ══════════════════════════════════════════════════════════════════════
+# 2. MCP DISPATCH — no truncation in the MCP layer
+# ══════════════════════════════════════════════════════════════════════
+
+
+class TestMCPNoTruncation:
+    """MCP _dispatch_tool must never truncate query results."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.graph, self.engine = _build()
+
+    def _mcp_query(self, expression: str) -> list:
+        from interlinked.mcp_server import _dispatch_tool
+        self.engine.reset_filter()
+        raw = _dispatch_tool(
+            "interlinked_query",
+            {"expression": expression},
+            self.engine, self.graph, ""
+        )
+        return json.loads(raw)
+
+    def test_mcp_functions_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("functions")
+        mcp_results = self._mcp_query("functions")
+        assert len(mcp_results) == len(engine_results), \
+            f"MCP truncated: {len(mcp_results)} vs engine {len(engine_results)}"
+
+    def test_mcp_classes_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("classes")
+        mcp_results = self._mcp_query("classes")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_modules_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("modules")
+        mcp_results = self._mcp_query("modules")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_dead_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("dead")
+        mcp_results = self._mcp_query("dead")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_variables_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("variables")
+        mcp_results = self._mcp_query("variables")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_parameters_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("parameters")
+        mcp_results = self._mcp_query("parameters")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_external_calls_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("external calls")
+        mcp_results = self._mcp_query("external calls")
+        assert len(mcp_results) == len(engine_results)
+
+    def test_mcp_callers_not_truncated(self):
+        # Find a node with callers
+        for node in self.graph.all_nodes():
+            callers = self.graph.callers_of(node.id)
+            if len(callers) >= 2:
+                self.engine.reset_filter()
+                engine_results = self.engine.query(f"callers of {node.qualified_name}")
+                mcp_results = self._mcp_query(f"callers of {node.qualified_name}")
+                assert len(mcp_results) == len(engine_results), \
+                    f"MCP truncated callers: {len(mcp_results)} vs {len(engine_results)}"
+                return
+        pytest.skip("No node with >=2 callers")
+
+    def test_mcp_callees_not_truncated(self):
+        for node in self.graph.all_nodes():
+            callees = self.graph.callees_of(node.id)
+            if len(callees) >= 2:
+                self.engine.reset_filter()
+                engine_results = self.engine.query(f"callees of {node.qualified_name}")
+                mcp_results = self._mcp_query(f"callees of {node.qualified_name}")
+                assert len(mcp_results) == len(engine_results), \
+                    f"MCP truncated callees: {len(mcp_results)} vs {len(engine_results)}"
+                return
+        pytest.skip("No node with >=2 callees")
+
+    def test_mcp_fuzzy_search_not_truncated(self):
+        self.engine.reset_filter()
+        engine_results = self.engine.query("process")
+        mcp_results = self._mcp_query("process")
+        assert len(mcp_results) == len(engine_results)
+
+
+# ══════════════════════════════════════════════════════════════════════
+# 3. SLIM NODE — fingerprint stripping doesn't lose essential fields
+# ══════════════════════════════════════════════════════════════════════
+
+
+class TestSlimNode:
+    """_slim_node_dict strips heavy fields but preserves everything else."""
+
+    def test_no_fingerprint_passthrough(self):
+        d = {"id": "a.b", "metadata": {}}
+        assert _slim_node_dict(d) == d
+
+    def test_strips_heavy_keys(self):
+        d = {
+            "id": "a.b",
+            "metadata": {
+                "fingerprint": {
+                    "arg_count": 3,
+                    "has_loops": True,
+                    "ast_tree": ("FunctionDef", (("Return", ()),)),
+                    "minhash": tuple(range(100)),
+                    "ast_node_counts": {"FunctionDef": 1, "Return": 1},
+                    "source_snippet": "def foo(): return 1",
+                    "callees": ["bar"],
+                    "callers": ["baz"],
+                },
+            },
+        }
+        result = _slim_node_dict(d)
+        fp = result["metadata"]["fingerprint"]
+        assert "ast_tree" not in fp
+        assert "minhash" not in fp
+        assert "ast_node_counts" not in fp
+        assert "source_snippet" not in fp
+        # Preserved fields
+        assert fp["arg_count"] == 3
+        assert fp["has_loops"] is True
+        assert fp["callees"] == ["bar"]
+        assert fp["callers"] == ["baz"]
+
+    def test_does_not_mutate_original(self):
+        d = {
+            "id": "a.b",
+            "metadata": {
+                "fingerprint": {
+                    "arg_count": 3,
+                    "minhash": (1, 2, 3),
+                },
+            },
+        }
+        _slim_node_dict(d)
+        assert "minhash" in d["metadata"]["fingerprint"], \
+            "_slim_node_dict must not mutate the original dict"
+
+    def test_snapshot_nodes_are_slim(self):
+        """engine.snapshot() nodes must not contain heavy fingerprint fields."""
+        graph, engine = _build()
+        # Run similarity to populate fingerprints
+        try:
+            from interlinked.analyzer.similarity import analyze_similarity
+            analyze_similarity(graph)
+        except Exception:
+            pytest.skip("similarity module not available")
+
+        snap = engine.snapshot()
+        heavy_keys = {"ast_tree", "minhash", "ast_node_counts", "source_snippet"}
+        for node in snap["nodes"]:
+            fp = node.get("metadata", {}).get("fingerprint")
+            if fp:
+                found = heavy_keys & set(fp.keys())
+                assert not found, \
+                    f"Node {node['id']} snapshot contains heavy keys: {found}"
+
+    def test_query_results_are_slim(self):
+        """engine.query() results must not contain heavy fingerprint fields."""
+        graph, engine = _build()
+        try:
+            from interlinked.analyzer.similarity import analyze_similarity
+            analyze_similarity(graph)
+        except Exception:
+            pytest.skip("similarity module not available")
+
+        results = engine.query("functions")
+        heavy_keys = {"ast_tree", "minhash", "ast_node_counts", "source_snippet"}
+        for node in results:
+            fp = node.get("metadata", {}).get("fingerprint")
+            if fp:
+                found = heavy_keys & set(fp.keys())
+                assert not found, \
+                    f"Query result {node['id']} contains heavy keys: {found}"
+
+
+# ══════════════════════════════════════════════════════════════════════
+# 4. GET_CONTEXT — callers/callees not truncated
+# ══════════════════════════════════════════════════════════════════════
+
+
+class TestGetContextCompleteness:
+    """get_context must return full callers/callees lists."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.graph, self.engine = _build()
+
+    def test_callers_not_capped(self):
+        for node in self.graph.all_nodes():
+            callers = self.graph.callers_of(node.id)
+            if len(callers) >= 2:
+                ctx = self.engine.get_context(node.qualified_name)
+                ctx_data = json.loads(ctx) if isinstance(ctx, str) else ctx
+                assert len(ctx_data["callers"]) == len(callers), \
+                    f"get_context callers capped: {len(ctx_data['callers'])} vs {len(callers)}"
+                return
+        pytest.skip("No node with >=2 callers")
+
+    def test_callees_not_capped(self):
+        for node in self.graph.all_nodes():
+            callees = self.graph.callees_of(node.id)
+            if len(callees) >= 2:
+                ctx = self.engine.get_context(node.qualified_name)
+                ctx_data = json.loads(ctx) if isinstance(ctx, str) else ctx
+                assert len(ctx_data["callees"]) == len(callees), \
+                    f"get_context callees capped: {len(ctx_data['callees'])} vs {len(callees)}"
+                return
+        pytest.skip("No node with >=2 callees")
+
+    def test_fingerprint_slim_in_context(self):
+        """get_context fingerprint must not include heavy fields."""
+        try:
+            from interlinked.analyzer.similarity import analyze_similarity
+            analyze_similarity(self.graph)
+        except Exception:
+            pytest.skip("similarity module not available")
+
+        for node in self.graph.all_nodes():
+            if node.metadata.get("fingerprint"):
+                ctx = self.engine.get_context(node.qualified_name)
+                ctx_data = json.loads(ctx) if isinstance(ctx, str) else ctx
+                fp = ctx_data.get("fingerprint")
+                if fp:
+                    heavy = {"ast_tree", "minhash", "ast_node_counts", "source_snippet"}
+                    found = heavy & set(fp.keys())
+                    assert not found, \
+                        f"get_context fingerprint has heavy keys: {found}"
+                return
+        pytest.skip("No node with fingerprint")