tensor-grep 1.45.0__tar.gz → 1.45.2__tar.gz

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensor-grep
-Version: 1.45.0
+Version: 1.45.2
 Requires-Dist: typer>=0.12,<0.26
 Requires-Dist: rich>=13.0
 Requires-Dist: mcp>=1.2.0

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/pyproject.toml

@@ -397,12 +397,14 @@ version_variables = [
 
 
 
+
+
 
 
 
 [project]
 name = "tensor-grep"
-version = "1.45.0"
+version = "1.45.2"
 description = "High-performance grep-compatible CLI with Rust, GPU, and AST/NLP routing"
 readme = { file = "rust_core/README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/rust_core/Cargo.lock

@@ -1541,7 +1541,7 @@ dependencies = [
 
 [[package]]
 name = "tensor_grep_rs"
-version = "1.45.0"
+version = "1.45.2"
 dependencies = [
  "aho-corasick",
  "anyhow",

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/rust_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tensor_grep_rs"
-version = "1.45.0"
+version = "1.45.2"
 edition = "2021"
 description = "Rust core engine for tensor-grep"
 license = "Apache-2.0"
@@ -304,6 +304,8 @@ path = "src/bin/tg_search_fast.rs"
 
 
 
+
+
 
 
 

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/src/tensor_grep/cli/lang_go.py

@@ -124,7 +124,15 @@ _GO_DEF_NODE_KINDS = (
 
 
 def _go_receiver_type_name(method_node: Any, source_bytes: bytes) -> str | None:
-    """Return the (possibly pointer) receiver type name for a ``method_declaration`` node."""
+    """Return the (possibly pointer, possibly generic) receiver type name for a
+    ``method_declaration`` node.
+
+    F8 fix: a GENERIC receiver (``func (r *MyType[T]) M()`` / ``func (r MyType[T]) N()``) parses
+    the receiver's type as a ``generic_type`` node whose own text is ``"MyType[T]"`` -- that never
+    matches the plain ``"MyType"`` name a ``type_spec`` declares, so method<->type association
+    silently broke for every generic Go receiver. Descending to ``generic_type``'s ``type`` field
+    (the base ``type_identifier``) restores the plain base name.
+    """
     receiver = method_node.child_by_field_name("receiver")
     if receiver is None:
         return None
@@ -144,9 +152,43 @@ def _go_receiver_type_name(method_node: Any, source_bytes: bytes) -> str | None:
         )
         if inner is not None:
             type_node = inner
+    if type_node.type == "generic_type":
+        base_type_node = type_node.child_by_field_name("type")
+        if base_type_node is not None:
+            type_node = base_type_node
     return _tree_sitter_node_text(source_bytes, type_node)
 
 
+def _go_import_spec_path_text(path_field: Any, source_bytes: bytes) -> str | None:
+    """Return an ``import_spec``'s string-literal import path (quotes stripped), or ``None``.
+
+    F11 fix: the primary route reads the ``interpreted_string_literal_content`` child that recent
+    ``tree_sitter_go`` grammar versions expose. An older/differently-built grammar package can
+    omit that child (there is no dedicated content node at all, or it is named differently) --
+    when that happens this used to silently return no path for EVERY import in the file, which
+    then silently degrades all cross-package import resolution with no error and no
+    ``resolution_gaps`` entry (the parser loaded fine, so nothing marks a gap). Falling back to
+    quote-stripping the string literal's own raw text keeps import extraction working even
+    against a grammar shape this module wasn't written against.
+    """
+    if path_field is None:
+        return None
+    content_node = next(
+        (
+            child
+            for child in path_field.children
+            if child.type == "interpreted_string_literal_content"
+        ),
+        None,
+    )
+    if content_node is not None:
+        return _tree_sitter_node_text(source_bytes, content_node)
+    raw_text = _tree_sitter_node_text(source_bytes, path_field).strip()
+    if len(raw_text) >= 2 and raw_text[0] in {'"', "`"} and raw_text[-1] == raw_text[0]:
+        return raw_text[1:-1]
+    return None
+
+
 def go_imports_and_symbols(path: Path) -> tuple[list[str], list[dict[str, Any]]]:
     """Extract import paths + top-level definitions from a Go source file, one AST pass.
 
@@ -184,20 +226,9 @@ def go_imports_and_symbols(path: Path) -> tuple[list[str], list[dict[str, Any]]]
         node_type = node.type
         if node_type == "import_spec":
             path_field = node.child_by_field_name("path")
-            content_node = (
-                next(
-                    (
-                        child
-                        for child in path_field.children
-                        if child.type == "interpreted_string_literal_content"
-                    ),
-                    None,
-                )
-                if path_field is not None
-                else None
-            )
-            if content_node is not None:
-                imports.append(_node_text(content_node))
+            import_path_text = _go_import_spec_path_text(path_field, source_bytes)
+            if import_path_text is not None:
+                imports.append(import_path_text)
         elif node_type == "function_declaration":
             name_node = node.child_by_field_name("name")
             if name_node is not None:
@@ -437,7 +468,16 @@ def _go_repo_context(repo_root: Path | str | None) -> dict[str, Any]:
 def _go_import_path_to_dir(import_path: str, context: dict[str, Any]) -> Path | None:
     """Resolve an import path (e.g. ``"example.com/mod/bar"``) to an absolute directory via the
     longest matching ``module_dirs`` prefix (longest-prefix-wins handles a workspace where one
-    module's path is itself a prefix of another's)."""
+    module's path is itself a prefix of another's).
+
+    F24 fix: stop at an intervening ``go.mod`` boundary. A nested module (its own ``go.mod`` that
+    is NOT listed as a ``go.work`` ``use`` entry -- e.g. simply forgotten) is a SEPARATE module
+    even when the enclosing module's path prefix happens to textually match its subdirectory --
+    walking past that boundary used to silently resolve a cross-package reference into the wrong
+    module's directory. Any ``go.mod`` strictly under the matched prefix's own root (which is
+    expected and ignored -- that root's ``go.mod`` is exactly what got this prefix primed) now
+    aborts resolution (returns ``None``) instead of fabricating a cross-module match.
+    """
     module_dirs = context.get("module_dirs", {})
     if not isinstance(module_dirs, dict):
         return None
@@ -448,9 +488,16 @@ def _go_import_path_to_dir(import_path: str, context: dict[str, Any]) -> Path |
                 best_prefix = prefix
     if best_prefix is None:
         return None
-    base_dir = Path(str(module_dirs[best_prefix]))
+    base_dir = Path(str(module_dirs[best_prefix])).resolve()
     remainder = import_path[len(best_prefix) :].lstrip("/")
-    return (base_dir / remainder).resolve() if remainder else base_dir.resolve()
+    if not remainder:
+        return base_dir
+    current = base_dir
+    for part in remainder.split("/"):
+        current = current / part
+        if (current / "go.mod").is_file():
+            return None
+    return current
 
 
 def _go_import_bindings(source_bytes: bytes, tree: Any) -> list[dict[str, Any]]:
@@ -461,19 +508,8 @@ def _go_import_bindings(source_bytes: bytes, tree: Any) -> list[dict[str, Any]]:
         if node.type == "import_spec":
             path_field = node.child_by_field_name("path")
             name_field = node.child_by_field_name("name")
-            content_node = (
-                next(
-                    (
-                        child
-                        for child in path_field.children
-                        if child.type == "interpreted_string_literal_content"
-                    ),
-                    None,
-                )
-                if path_field is not None
-                else None
-            )
-            if content_node is not None:
+            import_path_text = _go_import_spec_path_text(path_field, source_bytes)
+            if import_path_text is not None:
                 alias: str | None = None
                 dot = False
                 blank = False
@@ -485,7 +521,7 @@ def _go_import_bindings(source_bytes: bytes, tree: Any) -> list[dict[str, Any]]:
                     elif name_field.type == "blank_identifier":
                         blank = True
                 bindings.append({
-                    "path": _tree_sitter_node_text(source_bytes, content_node),
+                    "path": import_path_text,
                     "alias": alias,
                     "dot": dot,
                     "blank": blank,
@@ -571,10 +607,38 @@ _GO_NAME_DEFINING_PARENT_TYPES = {
 }
 
 
+def _go_package_defines_function(target_dir: str, name: str) -> bool:
+    """F10 fallback confirmation: True iff *target_dir* (a resolved package directory) contains a
+    top-level ``function``/``method`` declaration named *name*.
+
+    Used only when ``go_references_and_calls`` is not given ``definition_dirs`` (the stronger,
+    definition-aware check used by repo_map.py's refs/callers scan -- see F25 in that function's
+    docstring). Deliberately un-cached: this module never caches anything that reads file content
+    without an mtime guard (see the module-level caches above, which are keyed on repo ROOT
+    priming, not file content), and a Go package directory is small enough that a plain per-call
+    scan is cheap.
+    """
+    directory = Path(target_dir)
+    if not directory.is_dir():
+        return False
+    try:
+        entries = sorted(directory.glob("*.go"))
+    except OSError:
+        return False
+    for entry in entries:
+        _, symbols = go_imports_and_symbols(entry)
+        for record in symbols:
+            if record.get("name") == name and record.get("kind") in {"function", "method"}:
+                return True
+    return False
+
+
 def go_references_and_calls(
     path: Path,
     symbol: str,
     repo_root: Path | str | None = None,
+    *,
+    definition_dirs: frozenset[str] | None = None,
 ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
     """Reference/call rows for *symbol* in *path*.
 
@@ -585,15 +649,30 @@ def go_references_and_calls(
     *field*/method-selector mention is ``field_identifier``.
 
     Package-qualified access (``pkg.Symbol``) resolves through this file's import bindings +
-    the primed repo context: if the qualifying identifier is a recognized import alias whose
-    resolved directory matches *definition_path*'s directory, the row carries
-    ``resolution_provenance=["go-import-resolution"]`` at ``resolution_confidence=0.95``. A
-    selector call whose left-hand operand is NOT a recognized package alias (e.g. ``w.Write(x)``
-    where ``w`` is an arbitrary receiver variable of unknown static type) is equifinal -- ANY
-    type with a same-named method would match textually -- so it is still emitted (never
-    silently dropped) but capped at ``resolution_confidence<=0.7`` with
-    ``resolution_provenance=["receiver-heuristic"]``, per the Stage 1 no-fabricated-precision
-    trap.
+    the primed repo context. Two shapes:
+
+    - **Non-call selector** (e.g. ``config.DefaultTimeout``): F9 fix -- classified ``ref_kind``
+      "value" (a package-qualified const/var read), not "field", whenever the operand resolves as
+      a recognized import alias; an unresolved operand (e.g. a genuine struct field access) still
+      classifies "field" as before.
+    - **Call** (e.g. ``pkg.Helper(...)`` / ``w.Write(...)``): a resolved package alias only earns
+      ``resolution_provenance=["go-import-resolution"]`` at ``resolution_confidence=0.95`` if the
+      resolved package is CONFIRMED to actually own *symbol* -- F25 fix: when *definition_dirs* is
+      supplied (repo_map.py always supplies it, built from the symbol's own known definitions),
+      confirmation means the resolved directory is one of those definition dirs, which also fixes
+      a same-named-export collision (two unrelated packages each exporting a symbol with the same
+      name used to both get 0.95 turn just because the alias itself resolved); when
+      *definition_dirs* is omitted (e.g. a standalone caller), F10 fallback confirmation checks
+      whether the resolved package directory itself defines a top-level function/method named
+      *symbol* -- this is what prevents a LOCAL VARIABLE that happens to share its name with an
+      unrelated import alias (``w := SomeStruct{}`` shadowing `import w "pkg/w"`) from fabricating
+      high confidence for ``w.Method()`` when ``pkg/w`` does not actually define ``Method``.
+      Either way, an unconfirmed resolution is never dropped -- it demotes to the same
+      ``resolution_confidence<=0.7`` / ``resolution_provenance=["receiver-heuristic"]`` band as a
+      selector call whose left-hand operand is not a recognized package alias at all (e.g.
+      ``w.Write(x)`` where ``w`` is an arbitrary receiver variable of unknown static type) --
+      equifinal in both cases (ANY type with a same-named method could match textually), per the
+      Stage 1 no-fabricated-precision trap.
     """
     if path.suffix != ".go":
         return [], []
@@ -643,6 +722,21 @@ def go_references_and_calls(
             return None
         return {"provenance": ["go-import-resolution"], "confidence": 0.95, "dir": target_dir}
 
+    def _confident_call_resolution(package_resolution: dict[str, Any] | None) -> dict[str, Any]:
+        """F10/F25 fix: only trust ``package_resolution`` (0.95) for a CALL when the resolved
+        package is confirmed to actually own *symbol* -- see the ``go_references_and_calls``
+        docstring for the two confirmation routes. Anything unconfirmed demotes to the same
+        equifinal receiver-heuristic band a non-package selector call already gets, never drops.
+        """
+        if package_resolution is not None:
+            target_dir = str(package_resolution.get("dir", ""))
+            if definition_dirs is not None:
+                if target_dir in definition_dirs:
+                    return package_resolution
+            elif _go_package_defines_function(target_dir, symbol):
+                return package_resolution
+        return {"provenance": ["receiver-heuristic"], "confidence": 0.7}
+
     def _emit(
         bucket: list[dict[str, Any]],
         node: Any,
@@ -715,10 +809,7 @@ def go_references_and_calls(
                         and grandparent.child_by_field_name("function") == parent
                     )
                     if is_call:
-                        resolution = package_resolution or {
-                            "provenance": ["receiver-heuristic"],
-                            "confidence": 0.7,
-                        }
+                        resolution = _confident_call_resolution(package_resolution)
                         _emit(
                             references,
                             node,
@@ -728,11 +819,14 @@ def go_references_and_calls(
                         )
                         _emit(calls, node, kind="call", ref_kind="call", resolution=resolution)
                     else:
+                        # F9 fix: a package-qualified non-call selector (`config.DefaultTimeout`)
+                        # is a VALUE read (const/var), not a struct FIELD access -- only a
+                        # genuinely unresolved operand (a real struct field access) stays "field".
                         _emit(
                             references,
                             node,
                             kind="reference",
-                            ref_kind="field",
+                            ref_kind="value" if package_resolution is not None else "field",
                             resolution=package_resolution,
                         )
         for child in node.children:

{tensor_grep-1.45.0 → tensor_grep-1.45.2}/src/tensor_grep/cli/main.py

@@ -44,6 +44,7 @@ from tensor_grep.cli.runtime_paths import (
 from tensor_grep.cli.scan_guardrails import BroadScanRefusedError, ensure_scan_not_broad
 from tensor_grep.core.observability import nvtx_range
 from tensor_grep.core.result import MatchLine
+from tensor_grep.core.retrieval_chunker import MAX_CHUNKS
 from tensor_grep.io.directory_scanner import UNBOUNDED_VENDORED_ROOT_DIR_NAMES
 from tensor_grep.sidecar import DEFAULT_CLASSIFY_MAX_LINES
 
@@ -3503,18 +3504,47 @@ def _search_with_cpu_fallback(
     return CPUBackend().search(current_file, pattern, config=config)
 
 
+# F5 (Fable audit MED): retrieval_chunker.MAX_CHUNKS bounds a single chunk_file() call (per FILE).
+# A matched-file set of many small files can still blow past a sane CORPUS-wide total even though
+# no single file trips the per-file guard, so DenseIndex.__init__'s single-batch encode would face
+# unbounded memory. Cap the CORPUS total here too, sharing the same threshold as the per-file guard
+# (no separate magic number to keep in sync).
+_SEMANTIC_CORPUS_CHUNK_CAP = MAX_CHUNKS
+
+
+def _set_semantic_rank_fallback_reason(all_results: "SearchResult") -> None:
+    """Probe dense-leg availability and set ``rank_fallback_reason`` (F16, Fable audit LOW).
+
+    Used for the 0-match `--semantic` case: with no matches there is nothing to rerank, so the
+    full :func:`_apply_semantic_rerank` path (chunking, model load) is skipped entirely -- but the
+    availability probe must still run so the JSON envelope stays honest (a dense-unavailable
+    search must report that even when it happens to find zero matches, not silently omit
+    ``rank_fallback_reason``).
+    """
+    from tensor_grep.core.retrieval_dense import dense_available
+
+    available, unavailable_reason = dense_available()
+    if not available:
+        all_results.rank_fallback_reason = unavailable_reason
+        sys.stderr.write(f"tg: {unavailable_reason}\n")
+
+
 def _apply_semantic_rerank(all_results: "SearchResult", pattern: str) -> "SearchResult":
     """Apply the `--semantic` hybrid (BM25 + dense RRF) rerank, fail-closed to BM25-only.
 
     The dense leg is best-effort: when the `semantic` extra is absent, the model has not been
-    fetched, or the model produces a malformed/mismatched embedding, this degrades VISIBLY to a
-    BM25-only rerank (stderr warning + ``rank_fallback_reason`` set) -- it never silently returns
-    unranked output and never mislabels BM25-only output as "semantic". A genuine backend fault
-    (e.g. a corrupt model directory) raises ``BackendExecutionError`` instead of degrading, per
-    the Backend Fail-Closed Contract -- that is NOT caught here.
+    fetched, the model produces a malformed/mismatched embedding, or a query-time dense fault
+    occurs (F1: e.g. a dim mismatch raised from inside `rerank_hybrid`'s call to
+    `DenseIndex.query`), this degrades VISIBLY to a BM25-only rerank (stderr warning +
+    ``rank_fallback_reason`` set) -- it never silently returns unranked output and never mislabels
+    BM25-only output as "semantic". A genuine backend fault (e.g. a corrupt model directory)
+    raises ``BackendExecutionError`` instead of degrading, per the Backend Fail-Closed Contract --
+    that is NOT caught here; the caller (the `search` command) must catch it and exit cleanly
+    (F4).
     """
     from tensor_grep.core.reranker import rerank_hybrid
-    from tensor_grep.core.retrieval_chunker import chunk_file
+    from tensor_grep.core.retrieval_bm25 import Bm25Index
+    from tensor_grep.core.retrieval_chunker import Chunk, chunk_file
     from tensor_grep.core.retrieval_dense import (
         DenseIndex,
         DenseUnavailableError,
@@ -3528,23 +3558,73 @@ def _apply_semantic_rerank(all_results: "SearchResult", pattern: str) -> "Search
     if not available:
         all_results.rank_fallback_reason = unavailable_reason
         sys.stderr.write(f"tg: {unavailable_reason}\n")
-    else:
+
+    # F3 (Fable audit MED): build the chunk corpus ONCE and share it between the BM25 and dense
+    # legs. Previously the dense leg's corpus was built here while the BM25 leg rebuilt its own
+    # corpus from scratch inside `rerank_hybrid` (bm25_index=None) -- a second full file-I/O pass,
+    # and a silent RRF-misalignment risk if the two passes' chunk_size/overlap defaults ever
+    # diverge.
+    chunks: list[Chunk] = []
+    for path in all_results.matched_file_paths:
+        try:
+            file_chunks = chunk_file(path)
+        except RuntimeError as exc:
+            # F5: retrieval_chunker's own MAX_CHUNKS guard is PER FILE; a single pathological file
+            # can still trip it on its own even before the corpus-wide cap below is reached. Either
+            # way, degrade to BM25-only (using whatever we already have -- discard the corpus, let
+            # rerank_hybrid rebuild its own BM25-only chunks) rather than crash the whole search.
+            all_results.rank_fallback_reason = str(exc)
+            sys.stderr.write(f"tg: {exc}\n")
+            return rerank_hybrid(
+                all_results, pattern, all_results.matched_file_paths, dense_index=None
+            )
+        chunks.extend(file_chunks)
+        if len(chunks) > _SEMANTIC_CORPUS_CHUNK_CAP:
+            reason = (
+                "semantic ranking unavailable: corpus chunk cap "
+                f"({_SEMANTIC_CORPUS_CHUNK_CAP}) exceeded across the matched file set -- narrow "
+                "the search to fewer files for a semantic rerank"
+            )
+            all_results.rank_fallback_reason = reason
+            sys.stderr.write(f"tg: {reason}\n")
+            return rerank_hybrid(
+                all_results, pattern, all_results.matched_file_paths, dense_index=None
+            )
+
+    bm25_index = Bm25Index(chunks)
+
+    if available:
         try:
             model = load_dense_model(default_model_dir())
-            chunks = []
-            for path in all_results.matched_file_paths:
-                chunks.extend(chunk_file(path))
             dense_index = DenseIndex(chunks, model)
         except DenseUnavailableError as exc:
             all_results.rank_fallback_reason = str(exc)
             sys.stderr.write(f"tg: {exc}\n")
+        # BackendExecutionError (e.g. a corrupt model directory) deliberately propagates: that is
+        # an unrecoverable fault the CLI boundary must catch and exit on (F4), not degrade here.
 
-    return rerank_hybrid(
-        all_results,
-        pattern,
-        all_results.matched_file_paths,
-        dense_index=dense_index,
-    )
+    try:
+        return rerank_hybrid(
+            all_results,
+            pattern,
+            all_results.matched_file_paths,
+            bm25_index=bm25_index,
+            dense_index=dense_index,
+        )
+    except DenseUnavailableError as exc:
+        # F1: a query-time dense fault (e.g. a dim mismatch) is raised from INSIDE rerank_hybrid's
+        # call to `DenseIndex.query`, outside the try/except above (which only guards index
+        # construction). Degrade to BM25-only here too -- reuse the SAME bm25_index (no second
+        # chunk pass) rather than let it traceback.
+        all_results.rank_fallback_reason = str(exc)
+        sys.stderr.write(f"tg: {exc}\n")
+        return rerank_hybrid(
+            all_results,
+            pattern,
+            all_results.matched_file_paths,
+            bm25_index=bm25_index,
+            dense_index=None,
+        )
 
 
 def _search_error_payload(error: str, detail: str) -> dict[str, object]:
@@ -6661,8 +6741,25 @@ def search_command(
             all_results.match_counts_by_file[match.file] = (
                 all_results.match_counts_by_file.get(match.file, 0) + 1
             )
-    if config.semantic_rank and all_results.matches:
-        all_results = _apply_semantic_rerank(all_results, pattern)
+    if config.semantic_rank:
+        if all_results.matches:
+            try:
+                all_results = _apply_semantic_rerank(all_results, pattern)
+            except BackendExecutionError as exc:
+                # F4 (Fable audit MED): a genuine dense-backend fault (e.g. a corrupt model
+                # directory) must exit cleanly with a `tg:` message, never a raw traceback --
+                # `_apply_semantic_rerank` deliberately does NOT catch this (see its docstring);
+                # this is the CLI boundary the Backend Fail-Closed Contract requires.
+                if json:
+                    _emit_search_error_json("semantic_backend_error", str(exc))
+                else:
+                    typer.echo(f"tg: {exc}", err=True)
+                sys.exit(2)
+        else:
+            # F16 (Fable audit LOW): probe dense-leg availability even on a 0-match search so
+            # `rank_fallback_reason` is set whenever the leg is unavailable, regardless of match
+            # count -- skipping the probe here silently made the JSON envelope dishonest.
+            _set_semantic_rank_fallback_reason(all_results)
     elif config.rank_bm25 and all_results.matches:
         from tensor_grep.core.reranker import rerank_by_bm25
 
@@ -9013,10 +9110,7 @@ def blast_radius_plan(
 
     Like `blast-radius --json` but shaped as an edit/action plan (no source snippets).
     """
-    from tensor_grep.cli.repo_map import (
-        build_symbol_blast_radius_plan,
-        build_symbol_blast_radius_plan_json,
-    )
+    from tensor_grep.cli.repo_map import build_symbol_blast_radius_plan
 
     try:
         resolved_path, resolved_symbol = _resolve_path_and_symbol(
@@ -9025,20 +9119,6 @@ def blast_radius_plan(
             symbol_option=symbol,
             command_name="blast-radius-plan",
         )
-        if json_output:
-            typer.echo(
-                build_symbol_blast_radius_plan_json(
-                    resolved_symbol,
-                    resolved_path,
-                    max_depth=max_depth,
-                    max_files=max_files,
-                    max_symbols=max_symbols,
-                    semantic_provider=provider,
-                    max_repo_files=max_repo_files,
-                )
-            )
-            return
-
         payload = build_symbol_blast_radius_plan(
             resolved_symbol,
             resolved_path,
@@ -9052,10 +9132,21 @@ def blast_radius_plan(
         typer.echo(str(exc), err=True)
         raise typer.Exit(1) from exc
 
-    typer.echo(f"Blast radius plan for {payload['symbol']} in {payload['path']}")
-    typer.echo(
-        f"files={len(payload['files'])} tests={len(payload['tests'])} symbols={len(payload['symbols'])}"
-    )
+    # F14 (Fable audit MED): output the payload FIRST, then gate on the shared _scan_incomplete
+    # contract -- mirrors blast-radius/map/context-render/edit-plan/blast-radius-render (Cluster B,
+    # 2026-07-06). This payload is built from build_symbol_blast_radius_from_map and carries the
+    # exact scan_limit/caller_scan_truncated markers the gate checks; without this, a scan-truncated
+    # plan exited 0 while the sibling `blast-radius` command exits 2 on identical truncation.
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2))
+    else:
+        typer.echo(f"Blast radius plan for {payload['symbol']} in {payload['path']}")
+        typer.echo(
+            f"files={len(payload['files'])} tests={len(payload['tests'])} symbols={len(payload['symbols'])}"
+        )
+
+    if _scan_incomplete(payload):
+        raise typer.Exit(2)
 
 
 @session_app.command("open")