swarph-cli 0.63.0__tar.gz → 0.64.0__tar.gz

{swarph_cli-0.63.0/src/swarph_cli.egg-info → swarph_cli-0.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.63.0
+Version: 0.64.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -292,9 +292,12 @@ Between-sessions memory pass: **VERIFY · ORGANIZE · ENRICH** against a **CLONE
 ```
 $ swarph dreaming run --corpus ~/.claude/projects/.../memory --out /tmp/dreaming-out
 $ swarph dreaming run --corpus <dir> --out <dir> --verify-only
-$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing
+$ swarph dreaming run --corpus <dir> --out <dir> --notify <cell>
+$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing | 4 notify send failed
 ```
 
+`--notify <cell>` (#937) sends one mesh DM to `<cell>` **only when the finding set changes** (new and cleared findings named, with counts); an unchanged set sends nothing. State lives in `.last-findings.json` beside the `--out` dir and advances only after a successful send, so a failed send (exit 4) retries on the next run.
+
 **Scope is single-cell:** your corpus and your local transcripts. This is not the cross-agent multi-transcript dreaming from the Anthropic talk — that needs a shared transcript surface this release does not claim.
 
 #### The AI Router (why a tool, not a hook)

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/README.md

@@ -244,9 +244,12 @@ Between-sessions memory pass: **VERIFY · ORGANIZE · ENRICH** against a **CLONE
 ```
 $ swarph dreaming run --corpus ~/.claude/projects/.../memory --out /tmp/dreaming-out
 $ swarph dreaming run --corpus <dir> --out <dir> --verify-only
-$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing
+$ swarph dreaming run --corpus <dir> --out <dir> --notify <cell>
+$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing | 4 notify send failed
 ```
 
+`--notify <cell>` (#937) sends one mesh DM to `<cell>` **only when the finding set changes** (new and cleared findings named, with counts); an unchanged set sends nothing. State lives in `.last-findings.json` beside the `--out` dir and advances only after a successful send, so a failed send (exit 4) retries on the next run.
+
 **Scope is single-cell:** your corpus and your local transcripts. This is not the cross-agent multi-transcript dreaming from the Anthropic talk — that needs a shared transcript surface this release does not claim.
 
 #### The AI Router (why a tool, not a hook)

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.63.0"
+version = "0.64.0"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.63.0"
+__version__ = "0.64.0"
 
 __all__ = ["__version__"]

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli/commands/codegraph_hook.py

@@ -37,6 +37,10 @@ from swarph_cli.gateway_default import env_gateway
 
 TIMEOUT_S = 6
 MAX_ROWS = 6
+# Probe one past the display cap so audit can tell "exactly 6" from "hit the
+# clamp" (#825 / lab 48145: 90.5% of rows sat on match_count==6 because the
+# query limit WAS the count).
+_PROBE_LIMIT = MAX_ROWS + 1
 
 # Identifier token — used for prompt terms and for the Bash shred skip (no
 # useful symbol-shaped token left after cleaning).
@@ -89,6 +93,12 @@ def extract_raw_and_cleaned(cmd: str) -> Optional[tuple[str, str]]:
         if tok.startswith("-"):
             continue
         raw = tok.strip("'\"")
+        # Prefer the longest identifier STILL VISIBLE in the raw pattern
+        # before the shredding re.sub (#825). `foo_bar.*[0-9]+` must yield
+        # `foo_bar`, not skip-as-shredded or query regex debris.
+        idents = [t for t in _IDENT_TOKEN.findall(raw) if len(t) >= 3]
+        if idents:
+            return (raw, max(idents, key=len))
         cleaned = re.sub(r"[^\w\s.]", " ", raw).strip()
         if not cleaned:
             return None
@@ -308,7 +318,8 @@ def resolve_pending_outcome(self_name: str, subsequent: str,
 
 # ── gateway query ─────────────────────────────────────────────────────────
 
-def query_gateway(term: str, gateway: str, token: str, limit: int = MAX_ROWS) -> dict:
+def query_gateway(term: str, gateway: str, token: str,
+                   limit: int = _PROBE_LIMIT) -> dict:
     if not (gateway or "").strip():
         return {"error": "MESH_GATEWAY_URL is not set and swarph ships no default "
                          "gateway host (#578) — the graph was never asked"}
@@ -411,6 +422,9 @@ def _query_and_emit(self_name: str, gateway: str, term: str, *,
         return
     env = query_gateway(term, gateway, token)
     rows = env.get("results") or [] if "error" not in env else []
+    capped = len(rows) > MAX_ROWS
+    # Audit sees the probe length (MAX_ROWS+1 ⇒ at-least / capped). Display
+    # still truncates via render()'s rows[:MAX_ROWS].
     name_hit = any_symbol_name_contains_term(term, rows) if rows else False
     fid = firing_id or str(uuid.uuid4())
     write_audit(self_name, {
@@ -424,13 +438,22 @@ def _query_and_emit(self_name: str, gateway: str, term: str, *,
         "raw_term": raw_term or term,
         "skipped": False,
         "match_count": len(rows),
+        "match_count_capped": capped,
         "any_name_contains_term": name_hit,
         "error": env.get("error"),
     })
     if trigger == "prompt":
         register_pending_firing(self_name, fid, session_id)
+    # Render only the display window so the prompt is not flooded.
+    if capped and "error" not in env:
+        env = {**env, "results": rows[:MAX_ROWS], "match_count_capped": True}
     text = render(term, env)
     if text:
+        if capped:
+            text = text.rstrip() + (
+                f"\n  (display capped at {MAX_ROWS}; audit match_count="
+                f"{len(rows)} match_count_capped=true)"
+            )
         _emit(text, event_name)
 
 

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli/commands/dreaming.py

@@ -67,6 +67,12 @@ def _build_parser() -> argparse.ArgumentParser:
         help="require enrich; refuse (rc=2) if SLM client unavailable (#734)",
     )
     run.add_argument("--verify-only", action="store_true", help="verify only; skip organize/enrich")
+    run.add_argument(
+        "--notify",
+        default=None,
+        metavar="CELL",
+        help="DM CELL when the finding set changes; no DM when it is unchanged (#937)",
+    )
     return p
 
 
@@ -95,4 +101,6 @@ def run_dreaming(argv: list[str] | None = None) -> int:
         forwarded.append("--enrich")
     if args.verify_only:
         forwarded.append("--verify-only")
+    if getattr(args, "notify", None):
+        forwarded.extend(["--notify", args.notify])
     return dreaming_run.main(forwarded)

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli/commands/hooks.py

@@ -1005,36 +1005,47 @@ def uninstall_hook(
     return 0
 
 
-def _is_installed(settings: dict, command: str, bundle: HookBundle) -> bool:
-    """True when ALL of ``bundle``'s bindings' commands are present in settings."""
+def _event_binding_present(
+    settings: dict, command: str, binding: HookBinding,
+) -> bool:
+    """True when one specific event/matcher carries our command."""
     hooks = settings.get("hooks")
     if not isinstance(hooks, dict):
         return False
+    event_list = hooks.get(binding.event)
+    if not isinstance(event_list, list):
+        return False
+    _known = _command_variants_for(command)
+    for entry in event_list:
+        if entry.get("matcher", "") != binding.matcher:
+            continue
+        return any(a.get("command") in _known for a in entry.get("hooks", []))
+    return False
+
+
+def binding_coverage(
+    settings: dict, command: str, bundle: HookBundle,
+) -> tuple[list[str], list[str]]:
+    """Return (present_events, missing_events) for ``bundle``'s bindings (#825).
+
+    A PostToolUse-only install of codegraph-on-grep used to report as plain
+    ``available`` (not installed) while still firing 400 times — the steering
+    half unbound and invisible. Coverage makes PARTIAL legible.
+    """
+    present, missing = [], []
     for b in bundle.bindings:
-        event_list = hooks.get(b.event)
-        if not isinstance(event_list, list):
-            return False
-        found = False
-        for entry in event_list:
-            if entry.get("matcher", "") == b.matcher:
-                # #216 review (Copilot, 2nd pass): THE THIRD SITE. Exact
-                # matching here makes a LEGACY backslash binding read as NOT
-                # INSTALLED, so a Windows cell's real, working hooks list as
-                # "unavailable" — the operator is told nothing is installed
-                # while the bindings sit right there in settings.json.
-                # The previous commit said "one helper, BOTH callers". There
-                # were THREE. A rule applied at N-1 sites is the defect this
-                # class keeps producing, and it produced it again inside the
-                # fix for it.
-                _known = _command_variants_for(command)
-                if any(
-                    a.get("command") in _known for a in entry.get("hooks", [])
-                ):
-                    found = True
-                break
-        if not found:
-            return False
-    return True
+        label = b.event if not b.matcher else f"{b.event}:{b.matcher}"
+        if _event_binding_present(settings, command, b):
+            present.append(label)
+        else:
+            missing.append(label)
+    return present, missing
+
+
+def _is_installed(settings: dict, command: str, bundle: HookBundle) -> bool:
+    """True when ALL of ``bundle``'s bindings' commands are present in settings."""
+    present, missing = binding_coverage(settings, command, bundle)
+    return bool(present) and not missing
 
 
 def list_hooks(
@@ -1045,8 +1056,10 @@ def list_hooks(
 ) -> int:
     """List builtin hooks with install status. One greppable line per builtin::
 
-        name  [installed|available]  trust=builtin  — description
+        name  [installed|partial|available]  trust=builtin  — description
 
+    ``partial`` (#825): at least one binding present but not the full set —
+    the lab-ovh codegraph case (PostToolUse only, UserPromptSubmit/Stop absent).
     When installed and the script carries a ``swarph-cli-bundle-version`` stamp
     (#830), a second line reports match / mismatch vs the running package.
     """
@@ -1054,14 +1067,26 @@ def list_hooks(
     hooks_home_p = Path(hooks_home).expanduser()
     for name in sorted(BUILTIN_HOOKS):
         bundle = BUILTIN_HOOKS[name]
-        command = _installed_command(bundle, hooks_home)
-        # Read side of the same ladder: a legacy install reported as "available"
-        # invites the reinstall that produces a DUPLICATE binding.
-        status = ("installed"
-                  if any(_is_installed(settings, c, bundle)
-                         for c in _installed_command_variants(bundle, hooks_home))
-                  else "available")
+        variants = _installed_command_variants(bundle, hooks_home)
+        # Pick the first variant that has ANY binding coverage for reporting.
+        present: list[str] = []
+        missing: list[str] = [b.event for b in bundle.bindings]
+        for c in variants:
+            p, m = binding_coverage(settings, c, bundle)
+            if len(p) > len(present):
+                present, missing = p, m
+        if present and not missing:
+            status = "installed"
+        elif present and missing:
+            status = "partial"
+        else:
+            status = "available"
         out(f"{name}  [{status}]  trust=builtin  — {bundle.description}")
+        if status == "partial":
+            out(f"  bindings present: {', '.join(present) or '(none)'}")
+            out(f"  bindings MISSING: {', '.join(missing)}  "
+                f"— re-run: swarph hooks add {name}  (#825 fleet bind)")
+            continue
         if status != "installed":
             continue
         script = (hooks_home_p / bundle.script_name).expanduser()

swarph_cli-0.64.0/src/swarph_cli/dreaming/notify.py

@@ -0,0 +1,96 @@
+"""Notify the owning cell when the dreaming finding set changes (#937).
+
+The finding set is disagree + surface_disagreement, keyed file:line:kind, plus
+each non-empty organize finding keyed organize:<text>. State lives at
+<out-parent>/.last-findings.json and is written only after a successful send.
+An unchanged set sends nothing. A missing state file is a first run: send the
+full set once.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class NotifySendError(Exception):
+    """The mesh send failed. Distinct from a findings exit."""
+
+
+def finding_keys(verdicts, organized) -> list[str]:
+    keys: set[str] = set()
+    for v in verdicts or []:
+        if v.get("verdict") in ("disagree", "surface_disagreement"):
+            keys.add(f"{v.get('file')}:{v.get('line')}:{v.get('kind')}")
+    for line in (organized or {}).get("findings") or []:
+        text = str(line).strip()
+        if text:
+            keys.add(f"organize:{text}")
+    return sorted(keys)
+
+
+def _load_previous(path: Path) -> list[str] | None:
+    if not path.exists():
+        return None
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return list(data.get("keys") or [])
+
+
+def _body(keys: list[str], previous: list[str] | None) -> str:
+    if previous is None:
+        lines = ["dreaming findings first run", f"counts: {len(keys)}"]
+        lines.extend(keys)
+        return "\n".join(lines)
+    prev = set(previous)
+    cur = set(keys)
+    new = sorted(cur - prev)
+    cleared = sorted(prev - cur)
+    lines = [
+        "dreaming findings changed",
+        "new: " + (", ".join(new) if new else "(none)"),
+        "cleared: " + (", ".join(cleared) if cleared else "(none)"),
+        f"counts: {len(keys)} was {len(previous)}",
+    ]
+    return "\n".join(lines)
+
+
+def apply(out: Path, verdicts, organized, cell: str, sender) -> bool:
+    """Send one DM when the set changes. Return True if a DM was sent.
+
+    ``sender(cell, body)`` raises on failure. State is not written then.
+    """
+    out = Path(out)
+    keys = finding_keys(verdicts, organized)
+    state = out.parent / ".last-findings.json"
+    previous = _load_previous(state)
+    if previous is not None and sorted(previous) == keys:
+        return False
+    body = _body(keys, previous)
+    try:
+        sender(cell, body)
+    except NotifySendError:
+        raise
+    except Exception as exc:
+        raise NotifySendError(str(exc)) from exc
+    state.write_text(json.dumps({"keys": keys}, indent=2) + "\n", encoding="utf-8")
+    return True
+
+
+def mesh_sender(cell: str, content: str) -> None:
+    """Same path as ``swarph mesh send``: one status DM, no second transport."""
+    import argparse
+
+    from swarph_cli.commands.mesh import _run_send
+    from swarph_cli.gateway_default import env_gateway
+
+    ns = argparse.Namespace(
+        to=cell,
+        kind="status",
+        content=content,
+        content_file=None,
+        self_name=None,
+        token_file=None,
+        gateway=env_gateway(),
+    )
+    rc = _run_send(ns)
+    if rc != 0:
+        raise NotifySendError(f"mesh send exited {rc}")

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli/dreaming/run.py

@@ -18,6 +18,12 @@ def main(argv=None) -> int:
         help="require enrich; refuse (rc=2) if SLM client is unavailable (#734)",
     )
     ap.add_argument("--verify-only", action="store_true")
+    ap.add_argument(
+        "--notify",
+        default=None,
+        metavar="CELL",
+        help="DM CELL when the finding set changes; unchanged set sends nothing (#937)",
+    )
     a = ap.parse_args(argv)
     if a.enrich and a.no_enrich:
         print("dreaming: refusing to run -- --enrich and --no-enrich conflict",
@@ -83,10 +89,18 @@ def main(argv=None) -> int:
     #   1  disagreements or surface_disagreements found — findings to read
     #   2  refused to run (dirty destination)
     #   3  RAN BUT ADJUDICATED NOTHING                  — not clean, not findings
+    #   4  notify send failed                          — instrument failure, not findings
     # `mention` is adjudicated (the artifact WAS compared to the world) but never
     # `bad`: the memory asserted nothing, so there is no finding to read.
     adjudicated = sum(1 for v in verdicts if v["verdict"] in ("agree", "disagree", "mention"))
     bad = [v for v in verdicts if v["verdict"] in ("disagree", "surface_disagreement")]
+    if getattr(a, "notify", None):
+        from swarph_cli.dreaming.notify import NotifySendError, apply, mesh_sender
+        try:
+            apply(out, verdicts, organized, a.notify, mesh_sender)
+        except NotifySendError as exc:
+            print("dreaming: notify failed -- %s" % exc, file=sys.stderr)
+            return 4
     if bad:
         return 1
     if adjudicated == 0:

{swarph_cli-0.63.0 → swarph_cli-0.64.0/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.63.0
+Version: 0.64.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -292,9 +292,12 @@ Between-sessions memory pass: **VERIFY · ORGANIZE · ENRICH** against a **CLONE
 ```
 $ swarph dreaming run --corpus ~/.claude/projects/.../memory --out /tmp/dreaming-out
 $ swarph dreaming run --corpus <dir> --out <dir> --verify-only
-$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing
+$ swarph dreaming run --corpus <dir> --out <dir> --notify <cell>
+$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing | 4 notify send failed
 ```
 
+`--notify <cell>` (#937) sends one mesh DM to `<cell>` **only when the finding set changes** (new and cleared findings named, with counts); an unchanged set sends nothing. State lives in `.last-findings.json` beside the `--out` dir and advances only after a successful send, so a failed send (exit 4) retries on the next run.
+
 **Scope is single-cell:** your corpus and your local transcripts. This is not the cross-agent multi-transcript dreaming from the Anthropic talk — that needs a shared transcript surface this release does not claim.
 
 #### The AI Router (why a tool, not a hook)

{swarph_cli-0.63.0 → swarph_cli-0.64.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -117,6 +117,7 @@ src/swarph_cli/dreaming/candidates.py
 src/swarph_cli/dreaming/clone.py
 src/swarph_cli/dreaming/enrich.py
 src/swarph_cli/dreaming/index_check.py
+src/swarph_cli/dreaming/notify.py
 src/swarph_cli/dreaming/organize.py
 src/swarph_cli/dreaming/probes.py
 src/swarph_cli/dreaming/report.py
@@ -213,6 +214,7 @@ tests/test_762_cards_edit_priority.py
 tests/test_801_confirm_flow_cli.py
 tests/test_802_stage_history.py
 tests/test_825_codegraph_hook_noise.py
+tests/test_825_remaining_cap_shred_bind.py
 tests/test_829_counterfactual_column.py
 tests/test_830_hook_binding_version.py
 tests/test_84_cli_labels.py
@@ -220,6 +222,7 @@ tests/test_866_doctrine_guide.py
 tests/test_872_identity_refuses_not_warns.py
 tests/test_874_source_text.py
 tests/test_888_opencode_data_dir_can_fail.py
+tests/test_937_dreaming_notify.py
 tests/test_add_security_gate.py
 tests/test_artifact_add.py
 tests/test_artifact_hash.py

swarph_cli-0.64.0/tests/test_825_remaining_cap_shred_bind.py

@@ -0,0 +1,165 @@
+"""#825 remaining — match_count cap honesty + recoverable-symbol extract + partial bind.
+
+Can-fail traps: a 7-row probe must set match_count_capped; a raw pattern that
+contains an identifier but used to shred must yield that identifier.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from swarph_cli.commands import codegraph_hook as ch
+from swarph_cli.commands import hooks
+
+
+class _Stdin:
+    def __init__(self, s):
+        self._s = s
+
+    def read(self):
+        return self._s
+
+
+def _home(monkeypatch, tmp_path, with_token=True):
+    home = tmp_path / "home"
+    if with_token:
+        (home / ".config" / "swarph").mkdir(parents=True)
+        (home / ".config" / "swarph" / "cursor-win.peer_token").write_text(
+            "tok", encoding="utf-8")
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setenv("USERPROFILE", str(home))
+    monkeypatch.setenv("SWARPH_SELF", "cursor-win")
+    return home
+
+
+def _seven_rows():
+    return {
+        "results": [
+            {"repo": "r", "file_path": f"a{i}.py", "start_line": i,
+             "kind": "function", "name": f"_firejail_argv_{i}", "callers": i}
+            for i in range(7)
+        ],
+        "freshness": [{"index_age_hours": 1.0}],
+    }
+
+
+def test_825_match_count_capped_when_probe_exceeds_display(
+        monkeypatch, capsys, tmp_path):
+    """Can-fail: today's code asked limit=MAX_ROWS so match_count could never
+    exceed 6 and 90.5% of live rows sat exactly on the clamp with no flag."""
+    home = _home(monkeypatch, tmp_path)
+    seen = {}
+
+    def _qg(term, gateway, token, limit=None):
+        seen["limit"] = limit if limit is not None else ch._PROBE_LIMIT
+        return _seven_rows()
+
+    monkeypatch.setattr(ch, "query_gateway", _qg)
+    monkeypatch.setattr("sys.stdin", _Stdin(json.dumps({
+        "hook_event_name": "PostToolUse",
+        "tool_input": {"command": r'grep -n "_firejail_argv" src/x.py'},
+    })))
+    assert ch.run_codegraph_hook([]) == 0
+    assert seen["limit"] == ch.MAX_ROWS + 1
+    audit = Path(home) / "swarph_state" / "cursor-win" / "codegraph-hook-audit.jsonl"
+    row = json.loads(audit.read_text(encoding="utf-8").splitlines()[0])
+    assert row["match_count"] == 7
+    assert row["match_count_capped"] is True
+    out = capsys.readouterr().out
+    assert "match_count_capped=true" in out
+
+
+def test_825_match_count_uncapped_when_under_display(monkeypatch, tmp_path):
+    home = _home(monkeypatch, tmp_path)
+    env = {
+        "results": [
+            {"repo": "r", "file_path": "a.py", "start_line": 1,
+             "kind": "function", "name": "_firejail_argv", "callers": 9},
+        ],
+        "freshness": [{"index_age_hours": 1.0}],
+    }
+    monkeypatch.setattr(ch, "query_gateway", lambda *a, **k: env)
+    monkeypatch.setattr("sys.stdin", _Stdin(json.dumps({
+        "hook_event_name": "PostToolUse",
+        "tool_input": {"command": r'grep -n "_firejail_argv" src/x.py'},
+    })))
+    assert ch.run_codegraph_hook([]) == 0
+    audit = Path(home) / "swarph_state" / "cursor-win" / "codegraph-hook-audit.jsonl"
+    row = json.loads(audit.read_text(encoding="utf-8").splitlines()[0])
+    assert row["match_count"] == 1
+    assert row["match_count_capped"] is False
+
+
+def test_825_recoverable_symbol_inside_regex_is_not_shredded():
+    """Live-shaped specimen: identifier still present inside a regex pattern.
+
+    OLD extract ran re.sub first and lost the symbol (or skip_reason=shredded).
+    NEW prefers the longest ident token in the raw pattern.
+    """
+    cmd = r"""grep -rn --include='*.py' '_firejail_argv\|legacy_name' src/"""
+    pair = ch.extract_raw_and_cleaned(cmd)
+    assert pair is not None
+    raw, cleaned = pair
+    assert cleaned == "_firejail_argv"
+    assert not ch.term_is_shredded(raw, cleaned)
+
+
+def test_825_pure_regex_debris_still_shredded():
+    """Can-fail companion: no identifier ≥3 → still shredded (skip path)."""
+    cmd = r'grep -n "^\s*[0-9]+[-:]\s*[a-z_]+\s*:" src/x.py'
+    pair = ch.extract_raw_and_cleaned(cmd)
+    assert pair is not None
+    raw, cleaned = pair
+    # May recover 'a' from [a-z_] only as len<3 junk — must still shred.
+    assert ch.term_is_shredded(raw, cleaned) or len(cleaned) < 3 or cleaned in {
+        "a", "z_", "s",
+    }
+    # Stronger: if we only got short debris, shredded; if extract returned a
+    # long false ident from character class, that would be a NEW defect.
+    idents = [t for t in ch._IDENT_TOKEN.findall(raw) if len(t) >= 3]
+    if not idents:
+        assert ch.term_is_shredded(raw, cleaned)
+
+
+def test_825_old_extract_would_miss_recoverable_symbol():
+    """Can-fail: verbatim OLD expression fails the fixture the NEW one passes."""
+    raw = r"_firejail_argv\|legacy_name"
+    old_cleaned = __import__("re").sub(r"[^\w\s.]", " ", raw).strip()
+    # Old shred leaves tokens but the chosen 'term' was the whole cleaned
+    # string — and term_is_shredded looked for idents in cleaned. Reconstruct
+    # the failure mode lab named: debris asked of the index.
+    assert "firejail" in old_cleaned or "_firejail_argv" in old_cleaned.split()
+    # NEW picks the symbol directly:
+    assert ch.extract_raw_and_cleaned(
+        f"grep -n '{raw}' src/x.py"
+    )[1] == "_firejail_argv"
+
+
+def test_825_partial_bind_is_legible(tmp_path):
+    """PostToolUse-only install must list as partial, not available/installed."""
+    settings_path = tmp_path / "settings.json"
+    hooks_home = tmp_path / "hooks"
+    hooks_home.mkdir()
+    bundle = hooks.resolve_builtin("codegraph-on-grep")
+    script = hooks_home / bundle.script_name
+    script.write_text(bundle.script_body, encoding="utf-8")
+    cmd = hooks._installed_command(bundle, hooks_home)
+    settings = {
+        "hooks": {
+            "PostToolUse": [{
+                "matcher": "Bash",
+                "hooks": [{"type": "command", "command": cmd}],
+            }],
+        }
+    }
+    settings_path.write_text(json.dumps(settings), encoding="utf-8")
+    lines = []
+    hooks.list_hooks(
+        settings_path=settings_path, hooks_home=hooks_home, out=lines.append,
+    )
+    blob = "\n".join(lines)
+    assert "codegraph-on-grep  [partial]" in blob
+    assert "UserPromptSubmit" in blob
+    assert "MISSING" in blob