tensor-grep 1.63.0__tar.gz → 1.63.2__tar.gz

{tensor_grep-1.63.0 → tensor_grep-1.63.2}/PKG-INFO

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

{tensor_grep-1.63.0 → tensor_grep-1.63.2}/pyproject.toml

@@ -480,12 +480,14 @@ version_variables = [
 
 
 
+
+
 
 
 
 [project]
 name = "tensor-grep"
-version = "1.63.0"
+version = "1.63.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.63.0 → tensor_grep-1.63.2}/rust_core/Cargo.lock

@@ -1579,7 +1579,7 @@ dependencies = [
 
 [[package]]
 name = "tensor_grep_rs"
-version = "1.63.0"
+version = "1.63.2"
 dependencies = [
  "aho-corasick",
  "anyhow",

{tensor_grep-1.63.0 → tensor_grep-1.63.2}/rust_core/Cargo.toml

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

{tensor_grep-1.63.0 → tensor_grep-1.63.2}/src/tensor_grep/cli/main.py

@@ -22,7 +22,9 @@ from uuid import uuid4
 if sys.platform.startswith("win") and not sys.stdout.isatty():
     os.environ.setdefault("TYPER_USE_RICH", "0")
 
+import click
 import typer
+from typer.core import TyperGroup
 
 from tensor_grep.backends.base import BackendExecutionError
 from tensor_grep.cli import ast_workflows
@@ -230,7 +232,46 @@ review_bundle_app = typer.Typer(
     help="Create and verify enterprise review bundles.",
     no_args_is_help=True,
 )
+
+
+class _EvidenceGroup(TyperGroup):
+    """Nudge `tg evidence <path>` toward the `emit` subcommand.
+
+    Dogfood trap (v1.61.2): an agent reaches for `tg evidence <PATH> <query>` by
+    analogy with `tg defs`/`tg orient` (which take a path directly), but `evidence`
+    is a command GROUP whose only action is `emit`. Click's default
+    "No such command 'src/...'" is correct (exit 2) but unhelpful -- when the unknown
+    subcommand looks like a filesystem path, append the concrete fix so the caller
+    does not have to re-read `--help`.
+    """
+
+    def resolve_command(
+        self, ctx: click.Context, args: list[str]
+    ) -> tuple[str | None, click.Command | None, list[str]]:
+        try:
+            return super().resolve_command(ctx, args)
+        except click.exceptions.UsageError as exc:
+            token = args[0] if args else ""
+            if (
+                token
+                and not token.startswith("-")
+                and ("/" in token or "\\" in token or Path(token).exists())
+            ):
+                # Re-raise a NEW UsageError with the hint appended -- `UsageError.message` is a
+                # Final attribute (cannot be reassigned in place); a fresh error carrying the same
+                # `ctx` renders identically (Usage + "Try --help" + Error:) and keeps exit code 2.
+                raise click.exceptions.UsageError(
+                    f"{exc.format_message()}\n"
+                    "Hint: `tg evidence` is a command group; its receipt action is "
+                    f"`emit`. Did you mean `tg evidence emit {token}`? "
+                    "(run `tg evidence emit --help`)",
+                    ctx=exc.ctx,
+                ) from exc
+            raise
+
+
 evidence_app = typer.Typer(
+    cls=_EvidenceGroup,
     help="Emit a versioned EvidenceReceipt aggregating tg's existing outputs.",
     no_args_is_help=True,
 )

{tensor_grep-1.63.0 → tensor_grep-1.63.2}/src/tensor_grep/core/reranker.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import dataclasses
 import os
 import sys
-import time
+import threading
 from collections import defaultdict
 
 from tensor_grep.core.result import SearchResult
@@ -212,26 +212,57 @@ def rerank_hybrid(
         )
         budget_ms = _int_env(_RERANK_BUDGET_MS_ENV, _DEFAULT_RERANK_BUDGET_MS)
         head = fused_order[:pool_k]
-        late_rerank_start = time.perf_counter()
-        try:
-            reranked_head = late_reranker.rerank(query, [chunks[i].text for i in head], head)
-        except LateRerankUnavailableError as exc:
-            # RECOVERABLE (e.g. a malformed embedding shape from the injected encoder): degrade
-            # to the plain RRF order for this pool, never crash. A genuine BackendExecutionError
-            # (a real encode-time fault) is deliberately NOT caught here -- it propagates to the
-            # CLI boundary (cli/main.py ~:6804-6813) per the Backend Fail-Closed Contract.
-            late_rank_fallback_reason = str(exc)
-            sys.stderr.write(f"tg: {late_rank_fallback_reason}\n")
-        else:
-            elapsed_ms = (time.perf_counter() - late_rerank_start) * 1000.0
-            if elapsed_ms > budget_ms:
-                late_rank_fallback_reason = (
-                    "late rerank unavailable: budget exceeded "
-                    f"({elapsed_ms:.0f}ms > {budget_ms}ms at pool_k={pool_k})"
+        # Real wall-clock deadline (A3, external audit 2026-07-11): the previous post-hoc
+        # `elapsed > budget` check could only DISCARD a rerank that had already RETURNED -- a HUNG
+        # encoder (a wedged model, an infinite loop in the injected reranker) never returns, so
+        # `late_reranker.rerank` blocked `tg search --rank` indefinitely with no bound. Run it on a
+        # daemon thread and `join` on the budget: if it overruns, abandon the thread (it dies with
+        # this short-lived CLI process) and degrade. The Backend Fail-Closed Contract is PRESERVED
+        # across the thread boundary -- a LateRerankUnavailableError (recoverable) degrades to the
+        # plain RRF order; ANYTHING ELSE (a genuine BackendExecutionError encode fault, or a
+        # KeyboardInterrupt/SystemExit user-abort) is re-raised on this thread so it still
+        # propagates to the CLI boundary (cli/main.py ~:6804-6813), exactly as the synchronous
+        # version did. Capturing BaseException (not just Exception) is deliberate: it keeps a
+        # user-abort from being silently swallowed into an RRF degrade AND guarantees exactly one
+        # of the two result holders is populated when the worker finishes (so the `else` splice
+        # below can never IndexError on an empty result).
+        rerank_result: list[list[int]] = []
+        rerank_error: list[BaseException] = []
+
+        def _run_late_rerank() -> None:
+            try:
+                rerank_result.append(
+                    late_reranker.rerank(query, [chunks[i].text for i in head], head)
                 )
+            except (
+                BaseException
+            ) as exc:  # classified + re-raised (if non-recoverable) by the caller
+                rerank_error.append(exc)
+
+        worker = threading.Thread(target=_run_late_rerank, name="tg-late-rerank", daemon=True)
+        worker.start()
+        worker.join(timeout=budget_ms / 1000.0)
+
+        if worker.is_alive():
+            # Still running at the deadline (hung or merely too slow): do NOT wait -- abandon the
+            # daemon thread and degrade. This is the only branch that bounds a genuinely HUNG
+            # encoder; the old post-hoc check could never run for one.
+            late_rank_fallback_reason = (
+                f"late rerank unavailable: budget exceeded (>{budget_ms}ms at pool_k={pool_k})"
+            )
+            sys.stderr.write(f"tg: {late_rank_fallback_reason}\n")
+        elif rerank_error:
+            exc = rerank_error[0]
+            if isinstance(exc, LateRerankUnavailableError):
+                # RECOVERABLE (e.g. a malformed embedding shape): degrade, never crash.
+                late_rank_fallback_reason = str(exc)
                 sys.stderr.write(f"tg: {late_rank_fallback_reason}\n")
             else:
-                fused_order = reranked_head + fused_order[pool_k:]
+                # A genuine encode-time fault -> propagate (Backend Fail-Closed Contract): never
+                # silently degrade a real error into a plausible-but-wrong ranking.
+                raise exc
+        else:
+            fused_order = rerank_result[0] + fused_order[pool_k:]
 
     # Position in the fused order is a monotonic proxy for the underlying RRF score: RRF ties are
     # already broken by ascending chunk index before this list is built, so using position