symgrep-codesearch 0.6.2__tar.gz → 0.6.4__tar.gz

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.6.2
+Version: 0.6.4
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/pyproject.toml

@@ -7,6 +7,15 @@ build-backend = "setuptools.build_meta"
 # Semgrep team. The IMPORT name is unchanged — `import symgrep` — so consumers (honestreview, spendguard,
 # 7thsense, warden) are unaffected by the distribution rename. The package dir stays src/symgrep.
 name = "symgrep-codesearch"
+# 0.6.4: grammar fix — C# (.cs) now parses. The tree-sitter-language-pack migration left C# pointing at the
+# legacy grammar name "c_sharp"; the maintained pack's manifest calls it "csharp", so `get_parser("c_sharp")`
+# raised TreeSitterUnavailable and every .cs file silently degraded to nearest_decl. enclosing._TS_PACK_NAME now
+# maps c_sharp→csharp (same mechanism as embedded_template→embeddedtemplate). Patch: a pip-installed user on
+# 0.6.3 gets real C# treesitter spans again. (Also lands this release's dev-only work: the one-shot nudge-cost
+# fix and a CI import fix — neither ships in the wheel.)
+# 0.6.3: MCP surface completeness — TOOL_DESCRIPTION now documents structural=/lang= (the last undescribed
+# params), and a new `symgrep install-mcp` subcommand self-registers the server via `claude mcp add`. No API
+# change; keeps PyPI current with the capability descriptions pip-installed MCP clients see.
 # 0.6.2: ripgrep is a system binary and cannot be a normal pip dependency, but the new `[rg]` extra pulls
 # `ripgrep-bin` (a wheel bundling the rg binary) for a self-contained install; rg_binary() now also finds an
 # rg next to the interpreter (venv bin), so the pip-only path works even under `.venv/bin/python -m …`.
@@ -17,7 +26,7 @@ name = "symgrep-codesearch"
 # semantic search. Minor bump (dependency surface changed; no breaking import/CLI/MCP change).
 # 0.5.0: added the public `file_structure` library API (+ its MCP tool and `symgrep structure` CLI), import
 # module-name normalization, and the FileStructure `connects` list (structure schema v2).
-version = "0.6.2"
+version = "0.6.4"
 description = "Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning"
 readme = "README.md"
 # 3.11+ : the maintained grammar pack (tree-sitter-language-pack, a CORE dep below) ships abi3 wheels for

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/src/symgrep/cli.py

@@ -409,10 +409,70 @@ def _cmd_structure(rest) -> int:
     return 0
 
 
+def _resolve_mcp_entrypoint() -> "Optional[str]":
+    """Absolute path to symgrep's MCP stdio entrypoint for THIS install, resolved — never hardcoded. The
+    `symgrep-mcp` console script sits next to the interpreter (venv bin) for a pip OR editable install; a bare
+    checkout with no install falls back to the repo's bin/symgrep-mcp wrapper. None if neither is found."""
+    import shutil
+    exe_dir = os.path.dirname(sys.executable or "")
+    cand = os.path.join(exe_dir, "symgrep-mcp")
+    if os.path.isfile(cand) and os.access(cand, os.X_OK):
+        return cand
+    on_path = shutil.which("symgrep-mcp")
+    if on_path:
+        return on_path
+    repo_bin = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+                            "bin", "symgrep-mcp")
+    if os.path.isfile(repo_bin) and os.access(repo_bin, os.X_OK):
+        return repo_bin
+    return None
+
+
+def _cmd_install_mcp(rest) -> int:
+    """`symgrep install-mcp [--scope user|local|project] [--name NAME] [--dry-run]` — register symgrep's own
+    MCP server with Claude Code, so a fresh install advertises itself as a tool. It does NOT write
+    ~/.claude.json itself (one shared file must have ONE writer); it shells to `claude mcp add`, the safe
+    single writer that ships with the client — so this command carries no config-mutation logic to drift."""
+    import shutil
+    import subprocess
+    sp = argparse.ArgumentParser(prog="symgrep install-mcp")
+    sp.add_argument("--scope", default="user", choices=["local", "user", "project"],
+                    help="Claude Code config scope to register in (default: user)")
+    sp.add_argument("--name", default="symgrep", help="server name to register under (default: symgrep)")
+    sp.add_argument("--dry-run", action="store_true", help="print the exact `claude mcp add` command, write nothing")
+    a = sp.parse_args(rest)
+    claude = shutil.which("claude")
+    if not claude:
+        print("install-mcp: the `claude` CLI is not on PATH. symgrep delegates registration to it rather than "
+              "writing ~/.claude.json itself — install Claude Code, then re-run.", file=sys.stderr)
+        return 2
+    entry = _resolve_mcp_entrypoint()
+    if not entry:
+        print("install-mcp: could not locate symgrep's MCP entrypoint (`symgrep-mcp` console script or "
+              "bin/symgrep-mcp). Install symgrep in this interpreter (`pip install symgrep-codesearch`) first.",
+              file=sys.stderr)
+        return 2
+    cmd = [claude, "mcp", "add", "--scope", a.scope, a.name, "--", entry]
+    if a.dry_run:
+        print("DRY RUN — would run:\n  " + " ".join(cmd))
+        return 0
+    print("registering symgrep's MCP server:\n  " + " ".join(cmd))
+    rc = subprocess.run(cmd).returncode
+    if rc == 0:
+        # MCP servers are read at client START: a just-registered server is callable in the NEXT session, not
+        # this one — say so rather than imply a live pickup this cannot deliver.
+        print(f"registered '{a.name}' at scope '{a.scope}'. It becomes callable in the NEXT Claude session "
+              "(MCP servers load at client start). `claude mcp add` leaves an existing entry intact, so this "
+              "is safe to re-run.")
+    return rc
+
+
 def main(argv=None) -> int:
     _argv = list(sys.argv[1:] if argv is None else argv)
     if _argv and _argv[0] == "structure":       # `symgrep structure <path>` — a subcommand over the flag CLI
         return _cmd_structure(_argv[1:])
+    if _argv and _argv[0] == "install-mcp":      # `symgrep install-mcp` — self-register as an MCP server
+        return _cmd_install_mcp(_argv[1:])
     ap = argparse.ArgumentParser(prog="symgrep", description=__doc__)
     ap.add_argument("pattern", nargs="?", default=None,
                     help="regex to search (omit with --index: then every positional is a ROOT)")

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/src/symgrep/enclosing.py

@@ -213,10 +213,13 @@ _TS_UNAVAILABLE_ANNOUNCED: List[bool] = [False]
 
 
 # symgrep's internal grammar name -> the MAINTAINED pack's (tree-sitter-language-pack) name, ONLY where they
-# differ. The 15 code languages (TS_LANG_BY_EXT) and "html" resolve identically in both packs; the embedded
-# ERB/EJS grammar is "embedded_template" in the legacy pack but "embeddedtemplate" in the maintained one. A
-# name absent here passes through unchanged. This is a fixed spelling map (parsing, not a judgement).
-_TS_PACK_NAME = {"embedded_template": "embeddedtemplate"}
+# differ. Most code languages (TS_LANG_BY_EXT) and "html" resolve identically in both packs; the two that
+# differ: the embedded ERB/EJS grammar is "embedded_template" in the legacy pack but "embeddedtemplate" in the
+# maintained one, and C# is "c_sharp" in the legacy pack but "csharp" in the maintained pack's manifest
+# (requesting "c_sharp" there routes to a download manifest that lacks it → DownloadError, which is why every CI
+# run went red on C# after the pack migration). A name absent here passes through unchanged. This is a fixed
+# spelling map (parsing, not a judgement).
+_TS_PACK_NAME = {"embedded_template": "embeddedtemplate", "c_sharp": "csharp"}
 
 
 def _ts_parser(lang: str):

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/src/symgrep/mcp_server.py

@@ -55,7 +55,30 @@ TOOL_DESCRIPTION = (
     "nothing is CALLED that, never that nothing DOES it. That gap is how duplicate implementations get "
     "written — measured in one codebase: `share.scrub` beside `share._scrub_text`, `adapters.call_complete` "
     "beside `adapters.call`, `_save_state` in three files. Requires an index (symgrep --index <root>); if "
-    "there is none it says so rather than returning an empty result."
+    "there is none it says so rather than returning an empty result.\n\n"
+    "THREE MORE MODES, each a different question:\n"
+    "  usage=true    — is this name DEFINED, REFERENCED, both, or neither? Returns a verdict in\n"
+    "                  {defined_referenced, defined_unused, undefined_referenced, absent}. LEXICAL,\n"
+    "                  by name: 'defined_unused' is a possibly-unused HINT, never proof of dead code.\n"
+    "  resolve=true  — cross-file candidate resolution: {resolved_unique, ambiguous, external, absent}.\n"
+    "                  When >1 definition shares a name it reports AMBIGUOUS with candidates rather\n"
+    "                  than picking a winner. Use this before trusting any single definition of a\n"
+    "                  name that occurs more than once — import order decides it at runtime.\n"
+    "  structured=true — machine-readable JSON with a mechanical `status` (ok | no_index | unavailable)\n"
+    "                  instead of prose. Use whenever a program, not a human, reads the result.\n\n"
+    "unit= sets --semantic GRANULARITY: 'symbol' (default, a whole function) | 'block' (a sub-function\n"
+    "AST block — Type-4 clone retrieval, finds copy-pasted fragments whole-function search misses) |\n"
+    "'data' (a schema/config/proto/sql definition) | 'both'/'all'. block and data hits need\n"
+    "structured=true to read their span. kind= filters within a unit, e.g. 'data_schema', 'sql_table',\n"
+    "'proto_message'.\n\n"
+    "structural=true SWITCHES FROM REGEX TO AST-PATTERN MATCH — `pattern` becomes a code snippet with\n"
+    "metavariables ($NAME matches one node, $$$ is variadic), matched by syntactic SHAPE, so it finds forms a\n"
+    "regex cannot express (e.g. `$A == $A` for self-comparisons) without tripping on whitespace or naming. It\n"
+    "REQUIRES lang= to pick the grammar the pattern is parsed in (lang= one of the tree-sitter languages:\n"
+    "'python' | 'go' | 'javascript' | 'typescript' | 'tsx' | 'rust' | 'java' | 'c' | 'cpp' | 'ruby' | 'php' |\n"
+    "'c_sharp' | 'kotlin' | 'scala' | 'bash'); with no usable grammar it reports UNAVAILABLE rather than\n"
+    "silently falling back to text. Use it for structural queries a name/regex search cannot express; use\n"
+    "plain regex or semantic=true for everything else."
 )
 
 
@@ -131,6 +154,11 @@ def _run_fastmcp(http=None) -> bool:
         definitions, references, resolution_basis:"candidate-name"}. verdict ∈ resolved_unique | ambiguous |
         external | absent. When >1 definition shares the name it is AMBIGUOUS (candidates, not one winner).
 
+        structural=True: match by AST SHAPE, not regex — `pattern` is a code snippet with metavariables
+        ($NAME matches one node, $$$ is variadic). Requires lang= (the tree-sitter grammar the pattern parses
+        in, e.g. "python"/"go"/"rust"); reports UNAVAILABLE when no grammar is usable rather than falling back
+        to text. lang is used ONLY by structural search.
+
         unit: --semantic granularity — "symbol" (default; a whole function/method, the only pre-v6 behaviour,
         byte-stable) | "block" (a sub-function AST block, Type-4 clone retrieval) | "data" (a schema/data/config
         symbol — a data_schema file unit or a proto/sql definition) | "both"/"all". block/data hits need

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/src/symgrep_codesearch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.6.2
+Version: 0.6.4
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/src/symgrep_codesearch.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ tests/test_index_scope.py
 tests/test_index_worker.py
 tests/test_mcp_structured.py
 tests/test_name_uniqueness.py
+tests/test_nudge_classify.py
 tests/test_nudge_runaway.py
 tests/test_report_filters.py
 tests/test_resolve.py

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/tests/test_blocks_extraction.py

@@ -11,8 +11,9 @@ import tempfile
 import pathlib
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # tests dir on path: checklib imports when run directly (python tests/<file>.py), as CI does
 from symgrep import blocks, structural            # noqa: E402
-from tests.checklib import Checks                  # noqa: E402
+from checklib import Checks                  # noqa: E402
 
 c = Checks("test_blocks_extraction")
 

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/tests/test_blocks_retrieval.py

@@ -15,7 +15,8 @@ import tempfile
 import pathlib
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
-from tests.checklib import Checks                  # noqa: E402
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # tests dir on path: checklib imports when run directly (python tests/<file>.py), as CI does
+from checklib import Checks                  # noqa: E402
 
 c = Checks("test_blocks_retrieval")
 

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/tests/test_data_symbols.py

@@ -12,8 +12,9 @@ import tempfile
 import pathlib
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # tests dir on path: checklib imports when run directly (python tests/<file>.py), as CI does
 from symgrep import data_symbols as ds        # noqa: E402
-from tests.checklib import Checks             # noqa: E402
+from checklib import Checks             # noqa: E402
 
 c = Checks("test_data_symbols")
 _SEM_LINE = re.compile(r"^\s+(\d\.\d+)\s+(\S+)\s+(~?\S+):(\d+)\s*$")   # honestreview's exact parse

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/tests/test_file_structure.py

@@ -16,8 +16,9 @@ import pathlib
 import contextlib
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # tests dir on path: checklib imports when run directly (python tests/<file>.py), as CI does
 from symgrep.structure import file_structure, STRUCTURE_SCHEMA_VERSION   # noqa: E402
-from tests.checklib import Checks                                        # noqa: E402
+from checklib import Checks                                        # noqa: E402
 
 c = Checks("test_file_structure")
 
@@ -121,7 +122,7 @@ c.check("CLI == library API (no drift)", rc == 0 and cli_out == s.to_dict())
 # 6. a tree-sitter language (Go). tree-sitter is an OPTIONAL dependency: assert the contract that actually
 # holds here — extraction when the grammar is present, LANGUAGE-NAMED honest degradation when it is not
 # (never a silent basis downgrade dressed as a clean result). Both are real contracts, so neither branch skips.
-from tests.checklib import ts_available
+from checklib import ts_available
 HAVE_TS = ts_available("go")           # symgrep's own loader (either grammar pack), not one pack's import name
 
 GO = pathlib.Path(d) / "m.go"

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.4}/tests/test_index_reconstruct.py

@@ -12,8 +12,9 @@ import sys
 import tempfile
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # tests dir on path: checklib imports when run directly (python tests/<file>.py), as CI does
 from symgrep import semantic                    # noqa: E402
-from tests.checklib import Checks               # noqa: E402
+from checklib import Checks               # noqa: E402
 
 c = Checks("test_index_reconstruct")
 

symgrep_codesearch-0.6.4/tests/test_nudge_classify.py

@@ -0,0 +1,147 @@
+"""Guards for the nudge's COST DELIVERY — the fix for the measured $70/day defect (2026-10-07).
+
+The classification itself is correct and must stay agentic; what these pin is HOW the verdict is fetched, so
+the expensive path can never come back silently:
+
+  1. NEVER a Claude Code session / the capped Anthropic plan. The old hook shelled `spendguard ask … --budget 0`,
+     which routed to the claude-code subscription lane — a full `claude -p` session (~80K cold tokens, Opus).
+     Tests: the hook's miss-path shells the one-shot CLASSIFIER (not `spendguard ask`/`--budget 0`); the model is
+     non-anthropic (cannot reach the claude-code lane); and the classifier REFUSES a claude-code executor outright.
+  2. STAYS AGENTIC. With no gated LLM path available the verdict is None (fail open) — there is NO mechanical
+     string/regex classifier that decides true/false. The WHOLE command is the evidence (never sliced).
+  3. CACHE IN FRONT. A repeat command returns from cache without spawning anything.
+
+Run: python tests/test_nudge_classify.py   (command is `python …`, so the LIVE hook sees no grep)
+"""
+import json
+import os
+import sys
+import types
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+sys.path.insert(0, os.path.join(os.path.dirname(HERE), "hooks"))
+from checklib import Checks                                                             # noqa: E402
+_t = Checks("test_nudge_classify")
+check = _t.check
+
+import symgrep_nudge as h                                                              # noqa: E402
+
+
+# ---- 1a. NON-ANTHROPIC model: the classifier can never reach the claude-code lane / the capped plan ----------
+import symgrep_nudge_classify as clf                                                   # noqa: E402
+check("classifier default model is NON-anthropic (cannot route to the claude-code session / capped plan)",
+      not clf.NUDGE_VENDOR_DEFAULT.lower().startswith("anthropic"),
+      f"NUDGE_VENDOR_DEFAULT={clf.NUDGE_VENDOR_DEFAULT!r}")
+
+
+# ---- 1b. The hook's miss-path shells the CLASSIFIER, never `spendguard ask … --budget 0` (the session path) --
+_captured = {}
+
+
+def _fake_run(argv, **kw):
+    _captured["argv"] = list(argv)
+    _captured["input"] = kw.get("input")
+    out = types.SimpleNamespace()
+    out.stdout = json.dumps({"code_search": True, "why": "test", "executor": "api", "cost": 1e-5})
+    out.stderr = ""
+    out.returncode = 0
+    return out
+
+
+def _with(tmp_cache, py_exists=True):
+    """Point the cache at a throwaway sqlite and the classifier python at a real (any) existing file."""
+    os.environ["SYMGREP_NUDGE_CACHE"] = tmp_cache
+    os.environ["SYMGREP_NUDGE_PYTHON"] = sys.executable if py_exists else os.path.join(tmp_cache, "nope")
+
+
+import tempfile                                                                        # noqa: E402
+_tmp = tempfile.mkdtemp(prefix="nudge-test-")
+_cache = os.path.join(_tmp, "verdicts.sqlite")
+
+_orig_run = h.subprocess.run
+h.subprocess.run = _fake_run
+try:
+    _with(_cache)
+    v = h.judge_is_code_search("rg -n uniquepattern_abc123 src/")
+    argv = _captured.get("argv", [])
+    check("miss-path verdict is the classifier's JSON (True here)", v is True, f"v={v!r}")
+    check("miss-path shells a PYTHON interpreter, not the spendguard binary",
+          bool(argv) and "python" in os.path.basename(argv[0]).lower(), f"argv0={argv[:1]}")
+    check("miss-path runs symgrep_nudge_classify.py (the one-shot), not `ask`",
+          len(argv) >= 2 and argv[1].endswith("symgrep_nudge_classify.py"), f"argv1={argv[1:2]}")
+    check("miss-path argv contains NEITHER 'ask' NOR '--budget' (the old session path is gone)",
+          "ask" not in argv and "--budget" not in argv, f"argv={argv}")
+    check("the WHOLE command is sent to the classifier on stdin (no slice)",
+          _captured.get("input") == "rg -n uniquepattern_abc123 src/", f"input={_captured.get('input')!r}")
+
+    # ---- 3. CACHE IN FRONT: a repeat returns from cache WITHOUT spawning the classifier -----------------------
+    _captured.clear()
+
+    def _boom(*a, **k):
+        raise AssertionError("cache HIT must not spawn the classifier subprocess")
+
+    h.subprocess.run = _boom
+    v2 = h.judge_is_code_search("rg -n uniquepattern_abc123 src/")
+    check("a repeat command is served from the content cache (no subprocess)", v2 is True, f"v2={v2!r}")
+finally:
+    h.subprocess.run = _orig_run
+
+
+# ---- 2a. STAYS AGENTIC: with no gated LLM path, there is NO mechanical verdict (fail open = None) -------------
+for k in ("SYMGREP_SPENDGUARD",):
+    os.environ.pop(k, None)
+os.environ["SYMGREP_NUDGE_PYTHON"] = os.path.join(_tmp, "does-not-exist")
+os.environ["SYMGREP_NUDGE_CACHE"] = os.path.join(_tmp, "empty.sqlite")
+# A clearly-code-search command: a regex/keyword classifier WOULD answer True here. The honest answer with no
+# LLM reachable is None (fail open) — proving no mechanical path decides the meaning.
+check("no LLM path reachable → judge returns None (no regex/keyword fallback decides it)",
+      h.judge_is_code_search("rg -n 'def handler' src/") is None,
+      "a non-None verdict would mean a mechanical classifier exists")
+
+
+# ---- 1c. The classifier REFUSES a claude-code executor (the session) even if routing ever drifted there -------
+# Inject a fake spendguard so classify() runs with no network/spend: its adapters.call returns a claude-code hit.
+_fake_sg = types.ModuleType("spendguard")
+_fake_adapters = types.ModuleType("spendguard.adapters")
+_prompt_seen = {}
+
+
+def _fake_call(model, prompt, **kw):
+    _prompt_seen["model"] = model
+    _prompt_seen["prompt"] = prompt
+    _prompt_seen["kw"] = kw
+    return {"executor": "claude-code", "text": '{"code_search": true, "why": "x"}', "cost": 0.0, "error": None}
+
+
+_fake_adapters.call = _fake_call
+_fake_sg.adapters = _fake_adapters
+_fake_sg.require = lambda *a, **k: None
+sys.modules["spendguard"] = _fake_sg
+sys.modules["spendguard.adapters"] = _fake_adapters
+
+res = clf.classify("rg -n foo src/")
+check("classifier REFUSES a claude-code executor (the ~80K Opus session this fix removes)",
+      res["code_search"] is None and "claude-code" in (res["error"] or ""),
+      f"res={res}")
+check("the refused (session) verdict carries executor='claude-code' for the guard to see",
+      res["executor"] == "claude-code", f"executor={res['executor']!r}")
+
+# ---- 2b. WHOLE command is the evidence — classify() sends the command verbatim, never a slice ----------------
+long_cmd = "rg -n '" + ("x" * 5000) + "' src/ --glob '*.py'"
+
+
+def _fake_call_ok(model, prompt, **kw):
+    _prompt_seen["prompt"] = prompt
+    return {"executor": "api", "text": '{"code_search": true, "why": "x"}', "cost": 1e-5, "error": None}
+
+
+_fake_adapters.call = _fake_call_ok
+res2 = clf.classify(long_cmd)
+check("classify() sends the ENTIRE command to the model (no truncation of the evidence)",
+      _prompt_seen.get("prompt") == long_cmd, "prompt was sliced")
+check("classify() does not pass a strict schema= (so the $0 lane stays reachable)",
+      "schema" not in _prompt_seen.get("kw", {}) or _prompt_seen["kw"].get("schema") is None,
+      f"kw keys={list(_prompt_seen.get('kw', {}))}")
+
+_t.finish()