swarph-cli 0.69.9__tar.gz → 0.71.0__tar.gz

{swarph_cli-0.69.9/src/swarph_cli.egg-info → swarph_cli-0.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.69.9
+Version: 0.71.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

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.69.9"
+version = "0.71.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" }
@@ -130,6 +130,9 @@ service = [
 
 [project.scripts]
 swarph = "swarph_cli.main:main"
+# #660: operator surface — separate entrypoint so identity cannot inherit
+# $SWARPH_SELF from the cell CLI helpers (see swarph_cli.operator + its tests).
+swarph-me = "swarph_cli.operator:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/__init__.py

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

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/bench/backends.py

@@ -475,6 +475,15 @@ class RuleBackend:
         )
 
 
+class SignalBackend(RuleBackend):
+    """Deterministic signal arm (#213). ``model_id`` is ``module:callable``.
+
+    Same call as :class:`RuleBackend`: no credentials, no network, the
+    callable's return value is the categorical label. The runner scores a
+    ``signal:`` arm with the robust date-grouped scorer, not mean distance.
+    """
+
+
 class TypedHttpBackend:
     KIND = "typed"
     """POST a bench item to a Jev-compatible ``/v1/systemone`` server.

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/bench/runner.py

@@ -21,6 +21,7 @@ from .backends import Backend, BackendResult, _redact
 from .prices import cost_usd, is_known, lookup
 from .providers import egress_of_url
 from .quality import score
+from .signal_score import robust_report
 
 
 @dataclass
@@ -55,7 +56,10 @@ def parse_models(arg: str) -> list[ModelSpec]:
                 id=name, backend="provider", provider=name,
                 label=label or f"provider:{name}"))
             continue
-        for prefix, backend in (("typed-http:", "typed-http"), ("rule:", "rule")):
+        # signal:<module:callable> is the deterministic signal-backtest arm
+        # (#213). It carries colons in the payload, same as rule:.
+        for prefix, backend in (
+                ("typed-http:", "typed-http"), ("rule:", "rule"), ("signal:", "signal")):
             if tok.startswith(prefix):
                 specs.append(ModelSpec(id=tok[len(prefix):], backend=backend, label=tok))
                 break
@@ -120,6 +124,7 @@ class ModelBoardRow:
     base_url: str = ""
     path: str = ""
     kind: str = ""
+    robust: Optional[dict] = None
 
 
 def _dispatch(backend: Backend, model_id: str, prompt: str, system: str) -> BackendResult:
@@ -319,6 +324,7 @@ def run_pack(
                 resumed[item["task_id"]] = _taskrow_from_ledger(item)
 
         rows: list[TaskRow] = []
+        signal_obs: list[dict] = []
         arm_spent = 0.0
         arm_stopped = False
         for task in tasks:
@@ -389,6 +395,17 @@ def run_pack(
                 estimated=result.estimated or unknown,
                 text=result.text,
             ))
+            if spec.backend == "signal":
+                meta = task.get("meta") or {}
+                fwd = meta.get("fwd")
+                predicted = sc.get("parsed")
+                signal_obs.append({
+                    "cls": class_of(task),
+                    "date": str(meta.get("date") or ""),
+                    "fwd": float(fwd) if isinstance(fwd, (int, float)) and not isinstance(fwd, bool) else None,
+                    "expected": str(task.get("expected") or ""),
+                    "predicted": str(predicted).strip().upper() if predicted is not None else "",
+                })
         detail[spec.label] = rows
 
         done = [r for r in rows if r.error is None and not r.not_run]
@@ -429,6 +446,7 @@ def run_pack(
             base_url=getattr(backend, "base_url", ""),
             path=getattr(backend, "path", ""),
             kind=getattr(backend, "KIND", ""),
+            robust=robust_report(signal_obs) if spec.backend == "signal" else None,
         ))
 
     board.sort(key=lambda b: (b.mean_distance, b.cost_usd))
@@ -439,7 +457,10 @@ def run_pack(
         "aborted": partial == "aborted",
         "exit_code": 1 if partial else 0,
         "egress_overrides": overrides,
-        "board": [vars(b) for b in board],
+        "board": [
+            {k: v for k, v in vars(b).items() if k != "robust" or v is not None}
+            for b in board
+        ],
         "detail": {label: [vars(r) for r in rows] for label, rows in detail.items()},
     }
     text = _redact(json.dumps(payload), secrets)

swarph_cli-0.71.0/src/swarph_cli/bench/signal_score.py

@@ -0,0 +1,110 @@
+"""Robust scorer for a signal pack (#213).
+
+Mean distance is the wrong lens for a categorical UP/FLAT/DOWN call: an arm
+that always says FLAT can look precise while never separating the tails.
+This scorer reports, per cell and only then pooled:
+
+- n
+- balanced accuracy (mean recall over the outcome labels present in the cell)
+- the median forward return of the rows the arm called UP, and of the rows
+  it called DOWN (the separation)
+- a bootstrap confidence interval of that separation, resampling whole
+  decision dates so rows that share a date stay together
+"""
+from __future__ import annotations
+
+import random
+
+LABELS = ("UP", "FLAT", "DOWN")
+N_BOOT = 1000
+SEED = 20260927
+
+
+def _median(xs: list[float]) -> float | None:
+    if not xs:
+        return None
+    s = sorted(xs)
+    n = len(s)
+    mid = n // 2
+    if n % 2:
+        return s[mid]
+    return (s[mid - 1] + s[mid]) / 2.0
+
+
+def balanced_accuracy(expected: list[str], predicted: list[str]) -> float | None:
+    recalls = []
+    for lab in LABELS:
+        idx = [i for i, e in enumerate(expected) if e == lab]
+        if not idx:
+            continue
+        recalls.append(sum(1 for i in idx if predicted[i] == lab) / len(idx))
+    if not recalls:
+        return None
+    return round(sum(recalls) / len(recalls), 4)
+
+
+def cell_block(rows: list[dict]) -> dict:
+    expected = [str(r.get("expected") or "") for r in rows]
+    predicted = [str(r.get("predicted") or "") for r in rows]
+    up = [float(r["fwd"]) for r in rows if r.get("predicted") == "UP" and isinstance(r.get("fwd"), (int, float))]
+    down = [float(r["fwd"]) for r in rows if r.get("predicted") == "DOWN" and isinstance(r.get("fwd"), (int, float))]
+    med_up = _median(up)
+    med_down = _median(down)
+    sep = None if med_up is None or med_down is None else round(med_up - med_down, 6)
+    return {
+        "n": len(rows),
+        "balanced_accuracy": balanced_accuracy(expected, predicted),
+        "n_called_up": len(up),
+        "n_called_down": len(down),
+        "median_fwd_called_up": None if med_up is None else round(med_up, 6),
+        "median_fwd_called_down": None if med_down is None else round(med_down, 6),
+        "separation": sep,
+    }
+
+
+def bootstrap_ci(rows: list[dict], *, n_boot: int = N_BOOT, seed: int = SEED) -> dict:
+    """95% interval of separation, resampling decision dates with replacement."""
+    by_date: dict[str, list[dict]] = {}
+    for row in rows:
+        by_date.setdefault(str(row.get("date") or ""), []).append(row)
+    dates = sorted(by_date)
+    out = {
+        "stat": "separation",
+        "n_dates": len(dates),
+        "n_boot": n_boot,
+        "seed": seed,
+        "lo": None,
+        "hi": None,
+    }
+    if len(dates) < 2:
+        return out
+    rng = random.Random(seed)
+    stats: list[float] = []
+    n_dates = len(dates)
+    for _ in range(n_boot):
+        drawn: list[dict] = []
+        for _i in range(n_dates):
+            drawn.extend(by_date[dates[rng.randrange(n_dates)]])
+        sep = cell_block(drawn)["separation"]
+        if sep is not None:
+            stats.append(sep)
+    if not stats:
+        return out
+    stats.sort()
+    last = len(stats) - 1
+    out["lo"] = round(stats[int(0.025 * last)], 6)
+    out["hi"] = round(stats[int(0.975 * last)], 6)
+    return out
+
+
+def robust_report(obs: list[dict]) -> dict:
+    """Per-cell table first. Pooled is present only as a sibling of that table."""
+    per_cell: dict[str, dict] = {}
+    for cls in sorted({str(o.get("cls") or "") for o in obs}):
+        rows = [o for o in obs if str(o.get("cls") or "") == cls]
+        block = cell_block(rows)
+        block["bootstrap_ci"] = bootstrap_ci(rows)
+        per_cell[cls] = block
+    pooled = cell_block(obs)
+    pooled["bootstrap_ci"] = bootstrap_ci(obs)
+    return {"per_cell": per_cell, "pooled": pooled}

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/bench/validate.py

@@ -16,6 +16,9 @@ from __future__ import annotations
 import re
 from typing import Optional
 
+import hashlib
+import json
+
 from .backends import Backend
 from .pack import validate_schema
 from .quality import d_text
@@ -280,4 +283,64 @@ def validate_pack(
         report.warnings.extend(disc_warnings)
 
     report.warnings.extend(gate_calibration(pack, backends))
+    report.errors.extend(gate_signal_pack(pack))
     return report
+
+
+def tasks_sha256(tasks: list) -> str:
+    """sha256 of the task list. Frozen canon: json.dumps with sort_keys and
+    compact separators, UTF-8. The pack builder must use this exact canon."""
+    blob = json.dumps(tasks, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    return hashlib.sha256(blob).hexdigest()
+
+
+def gate_signal_pack(pack: dict) -> list[str]:
+    """A signal pack is valid only with a matching task-list sha256, a frozen
+    5-bar outcome rule, and cardinality > 1 on both conditioning axes
+    (regime and sector). A constant axis passes a schema check and still
+    measures nothing."""
+    header = pack.get("header")
+    if not isinstance(header, dict) or header.get("pack_kind") != "signal":
+        return []
+    errors: list[str] = []
+    tasks = pack.get("tasks") or []
+    digest = tasks_sha256(tasks)
+    if header.get("sha256_tasks") != digest:
+        errors.append(
+            f"header.sha256_tasks does not match the task list (computed {digest})"
+        )
+    if header.get("row_count") != len(tasks):
+        errors.append(
+            f"header.row_count={header.get('row_count')!r} does not match len(tasks)={len(tasks)}"
+        )
+    outcome = header.get("outcome") if isinstance(header.get("outcome"), dict) else {}
+    if outcome.get("horizon_bars") != 5 or outcome.get("up_gt") is None or outcome.get("down_lt") is None:
+        errors.append("header.outcome must freeze horizon_bars=5, up_gt, and down_lt")
+    for key in ("data_window", "universe_source_query", "price_history_snapshot_date"):
+        if not header.get(key):
+            errors.append(f"header.{key} is required on a signal pack")
+    regimes: set[str] = set()
+    sectors: set[str] = set()
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        cls = str((task.get("meta") or {}).get("class") or "")
+        if "|" not in cls:
+            errors.append(f"task {task.get('id')!r} meta.class must be '<regime>|<sector>'")
+            continue
+        regime, sector = cls.split("|", 1)
+        if regime:
+            regimes.add(regime)
+        if sector:
+            sectors.add(sector)
+    if len(regimes) < 2:
+        errors.append(
+            f"conditioning axis regime has cardinality {len(regimes)}; "
+            "a constant axis is not a valid pack"
+        )
+    if len(sectors) < 2:
+        errors.append(
+            f"conditioning axis sector has cardinality {len(sectors)}; "
+            "a constant axis is not a valid pack"
+        )
+    return errors

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/capture/paths.py

@@ -77,3 +77,14 @@ def manifest_path(role: str) -> Path:
     validate_role(role)
     base = captures_dir()
     return _assert_contained(base / f"{role}.json", base)
+
+
+def card_preimage_path() -> Path:
+    """Append-only log of card text REPLACED by ``board cards edit`` on this box.
+
+    Not role-scoped (no ``validate_role``): the writer is the CLI itself, not a
+    capture role, and the file is one per machine on purpose — it answers "what
+    did an edit issued FROM HERE destroy", which is the only question a local
+    file can honestly answer. See ``_write_card_preimage`` in commands/board.py.
+    """
+    return _swarph_state() / "board-card-preimages.jsonl"

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/commands/bench.py

@@ -28,6 +28,7 @@ from swarph_cli.bench.backends import (
     MeteredGeminiBackend,
     MeteredMistralBackend,
     RuleBackend,
+    SignalBackend,
     SubscriptionBackend,
     TypedHttpBackend,
     HttpBackend,
@@ -65,6 +66,7 @@ def _default_backends() -> dict[str, Backend]:
         "mistral": MeteredMistralBackend(),
         "subscription": subscription,
         "rule": RuleBackend(),
+        "signal": SignalBackend(),
         "typed-http": TypedHttpBackend(),
         # Selectable class for the wiring lock. A real call is provider:<name>,
         # which replaces this with the registry arm. An unresolved name is
@@ -108,6 +110,34 @@ def _format_run_table(result: dict) -> str:
                 f"    {_s(cls):20} n={c['n']:<4} hits={c['hits']:<4} "
                 f"hit_rate={c['hit_rate']:<6} mean_distance={c['mean_distance']}"
             )
+        robust = row.get("robust")
+        if robust:
+            lines.append("  per-cell (robust):")
+            per_cell = robust.get("per_cell") or {}
+            for cls, c in sorted(per_cell.items()):
+                ci = c.get("bootstrap_ci") or {}
+                lines.append(
+                    f"    {_s(cls):24} n={c['n']:<5} "
+                    f"bal_acc={c['balanced_accuracy']} "
+                    f"med_up={c['median_fwd_called_up']} "
+                    f"med_down={c['median_fwd_called_down']} "
+                    f"sep={c['separation']} "
+                    f"ci=[{ci.get('lo')}, {ci.get('hi')}]"
+                )
+            # Pooled sits beside the per-cell table. It is not printed when
+            # the table is empty — a pooled-only line is the failure mode
+            # this scorer exists to prevent.
+            if per_cell and robust.get("pooled"):
+                p = robust["pooled"]
+                ci = p.get("bootstrap_ci") or {}
+                lines.append(
+                    "  pooled (beside the per-cell table): "
+                    f"n={p['n']} bal_acc={p['balanced_accuracy']} "
+                    f"med_up={p['median_fwd_called_up']} "
+                    f"med_down={p['median_fwd_called_down']} "
+                    f"sep={p['separation']} "
+                    f"ci=[{ci.get('lo')}, {ci.get('hi')}]"
+                )
     return "\n".join(lines)
 
 

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/commands/board.py

@@ -12,11 +12,14 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import re
 import sys
 import urllib.error
 import urllib.parse
 import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # #532 — negative-branch marker detection. THREE COPIES exist and no single
@@ -30,6 +33,7 @@ from typing import Optional
 # substring test can know a falsifier exists.
 _FAIL_MARKER_RE = re.compile(r"(?<![\w-])fail(?:s|ed|ing|ures?)?(?![\w-])", re.IGNORECASE)
 
+from swarph_cli.capture.paths import card_preimage_path
 from swarph_cli.commands._content import ContentError, add_content_args, resolve_content
 from swarph_cli.commands._display import sanitize_terminal as _s
 from swarph_cli.commands.mesh import (
@@ -178,6 +182,49 @@ def _card_edit_payload(actor, title, body, *, due_at=_SENTINEL, project_id=None,
     return patch
 
 
+def _write_card_preimage(actor, gateway, card_id, card, patch) -> Path:
+    """Append the card's CURRENT title and body to a local log BEFORE an edit
+    replaces them. Returns the path written.
+
+    >>> WHY THE CLIENT AND NOT THE SERVER. <<< #596 is fixed for TITLE only: the
+    gateway retains the replaced title in ``body_history`` (mesh-gateway 989c83d,
+    live since 2026-09-17 13:22Z) and for a BODY edit appends {by, at, chars} —
+    who, when, and the length of the NEW text. The replaced body is gone, and
+    #596's side table (the system-wide fix) is a gateway change behind a deploy
+    gate. This is the footprint the EDITING MACHINE can keep on its own.
+
+    ponytail: one file, one box. It covers edits issued FROM HERE and nothing
+    else — a body replaced from another cell is still unrecoverable, and
+    "a transcript is a copy of the board nobody indexes" (drop-on-meta-edge,
+    #596) applies to this file too. The side table remains the real fix; this
+    only makes the window survivable.
+    """
+    rec = {
+        "at": datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z"),
+        "by": actor,
+        "gateway": gateway,
+        "card": card_id,
+        "body_version": card.get("body_version"),
+        "prev_title": card.get("title"),
+        "prev_body": card.get("body"),
+        "new_title": patch.get("title"),
+        "new_body": patch.get("body"),
+    }
+    path = card_preimage_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # A previous line with no trailing newline would MERGE with this one and
+    # destroy both records; the reader is json-per-line.
+    prefix = ""
+    if path.exists() and path.stat().st_size:
+        with path.open("rb") as fh:
+            fh.seek(-1, os.SEEK_END)
+            if fh.read(1) != b"\n":
+                prefix = "\n"
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(prefix + json.dumps(rec, ensure_ascii=False) + "\n")
+    return path
+
+
 def _apply_label(current: list, action: str, label: str) -> list:
     """Compute the NEW label set. Pure, so the read-modify-write is testable
     without a gateway.
@@ -1241,12 +1288,32 @@ def run_board(argv: list[str]) -> int:
             except ValueError as exc:
                 print(f"swarph board cards edit: {exc}", file=sys.stderr)
                 return 2
+            # READ BEFORE WRITE, and REFUSE if either the read or the capture
+            # fails. This mirrors `label`'s read-modify-write guard for a
+            # different reason: there the failed read would clobber the other
+            # labels; here it would destroy text nothing can recover (#596).
+            st_cur, cur = _http_get_json(f"{gw}/board/cards/{args.id}", token)
+            if st_cur != 200 or not isinstance(cur, dict):
+                print(f"swarph board cards edit: cannot read card #{args.id} "
+                      f"before editing (HTTP {st_cur}) — refusing to write. The "
+                      f"gateway keeps NO recoverable copy of a replaced body "
+                      f"(#596), so an edit whose pre-image was not captured is "
+                      f"an unrecoverable one", file=sys.stderr)
+                return 1
+            try:
+                pre = _write_card_preimage(self_name, gw, args.id, cur, patch)
+            except OSError as exc:
+                print(f"swarph board cards edit: cannot write the pre-image log "
+                      f"({exc}) — refusing to write, for the same reason: the "
+                      f"replaced text would exist nowhere (#596)", file=sys.stderr)
+                return 1
             st, d = _patch_json(f"{gw}/board/cards/{args.id}", patch, token)
             # Surface body_version: it is the latch every verdict stamp keys on
             # (#199), so an edit that re-opens reviewed work is visible in the
             # success line, not only in a later audit.
             return _out(st, d, lambda x: f"card #{x.get('id')} edited "
-                                         f"(body_version={x.get('body_version')})", aj)
+                                         f"(body_version={x.get('body_version')}; "
+                                         f"pre-image {pre})", aj)
         if args.command == "thread":
             st, d = _http_get_json(_thread_url(gw, args.id, limit=args.limit), token)
             # NO special-casing of 403/409. `_out` already returns 1 and prints the

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/commands/codegraph_hook.py

@@ -476,8 +476,19 @@ def supported_hook_events() -> frozenset:
 
 
 def run_codegraph_hook(argv: Optional[list] = None) -> int:
-    """ALWAYS exits 0 — must never fail a turn."""
+    """ALWAYS exits 0 on hook stdin — must never fail a turn.
+
+    ``--supported-events`` is the out-of-process advertise path for
+    ``swarph hooks add`` (#830): prints one event name per line and exits 0
+    without reading stdin. Installers MUST invoke this via PATH ``swarph``,
+    not an in-process import — same late binding as the generated hook script.
+    """
     argv = list(argv or [])
+    if "--supported-events" in argv:
+        for name in sorted(supported_hook_events()):
+            print(name)
+        return 0
+
     self_name = identity.declared(env=identity.SELF_ONLY)[0] or ""
     gateway = env_gateway()
     for i, a in enumerate(argv):

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/commands/hooks.py

@@ -42,6 +42,7 @@ import json
 import os
 import re
 import shutil
+import subprocess
 import sys
 import tempfile
 from dataclasses import dataclass
@@ -618,16 +619,50 @@ def _read_script_bundle_version(script_path: Path) -> str | None:
     return m.group(1) if m else None
 
 
-def _handler_missing_events(required: tuple) -> tuple[frozenset, frozenset]:
-    """Return (advertised, missing) for the late-bound codegraph handler (#830).
+def _probe_path_handler_events() -> frozenset | None:
+    """Ask PATH's ``swarph codegraph-hook --supported-events`` (#830).
+
+    Same late-bound name the generated script ``exec``s. An in-process import
+    cannot see install-vs-PATH skew — measured on lab-ovh after #408. Returns
+    ``None`` when the probe cannot run; empty frozenset when the handler
+    answers with no lines (old binary that ignores the flag and prints nothing).
 
-    Bundles with empty ``handler_events`` skip this gate. Today only
-    ``codegraph-on-grep`` advertises; the import is the running package on
-    PATH's peer — i.e. the same interpreter that will execute the hook.
+    Empty is NOT "handler was asked and supports nothing" as distinct evidence:
+    an old handler silently ignores the unknown flag, reads stdin, finds no
+    tool_input, and exits 0 with blank stdout — #830's own silent-success defect
+    answering this probe. That empty, a genuine empty advertise, and a failed
+    probe (``None`` → treated as empty below) all fail the gate closed; the
+    operator message names the likely cause. Do not read empty as a successful
+    negotiation.
     """
-    from swarph_cli.commands.codegraph_hook import supported_hook_events
+    try:
+        proc = subprocess.run(
+            ["swarph", "codegraph-hook", "--supported-events"],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=30,
+            stdin=subprocess.DEVNULL,
+        )
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    return frozenset(
+        ln.strip() for ln in (proc.stdout or "").splitlines() if ln.strip()
+    )
+
 
-    advertised = supported_hook_events()
+def _handler_missing_events(required: tuple) -> tuple[frozenset, frozenset]:
+    """Return (advertised, missing) via PATH probe — not an in-process import.
+
+    Bundles with empty ``handler_events`` skip this gate. A failed probe is
+    treated as advertising nothing so install fails closed.
+    """
+    advertised = _probe_path_handler_events()
+    if advertised is None:
+        return frozenset(), frozenset(required)
     return advertised, frozenset(required) - advertised
 
 
@@ -685,16 +720,18 @@ def install_hook(
         out("  Install Git for Windows, then re-run — nothing was written.")
         return 1
 
-    # #830: refuse bindings the RUNNING handler cannot advertise. Code must
-    # land before or with bindings — never after.
+    # #830: refuse bindings PATH's handler cannot advertise. Probe out of
+    # process (same ``swarph`` name the script will exec) — an in-process
+    # import is inert against install/PATH skew. Code must land before or
+    # with bindings, never after.
     if bundle.handler_events:
         advertised, missing = _handler_missing_events(bundle.handler_events)
         if missing:
-            out(f"cannot install {bundle.name}: running handler does not "
-                f"advertise events {sorted(missing)}.")
+            out(f"cannot install {bundle.name}: PATH's swarph codegraph-hook "
+                f"does not advertise events {sorted(missing)}.")
             out(f"  handler advertises: {sorted(advertised) or '(none)'}")
-            out("  Upgrade swarph-cli so the handler supports these events, "
-                "then re-run — nothing was written (#830).")
+            out("  Upgrade the swarph on PATH so the handler supports these "
+                "events, then re-run — nothing was written (#830).")
             return 1
 
     command = _hook_command_path(script_dst)

{swarph_cli-0.69.9 → swarph_cli-0.71.0}/src/swarph_cli/commands/install_wake_hook.py

@@ -7,9 +7,9 @@ design), not by which harness happens to be detected:
 * ``claude`` / ``codex`` → ARM-INSTRUCTION: the session-start hook emits
   the watch pipeline (``tail -F inbox.log | dm_notify_filter``) as session
   context so the agent arms it as a background watch.
-* ``cursor`` → VERIFY-AND-REPORT: the wake already lives in swarph (the
-  monitor's push sink); the hook verifies it at every session start and
-  says loudly when the cell has no wake path.
+* ``cursor`` → ARM-INSTRUCTION, same tail pipeline as claude/codex, written
+  to ``~/.cursor/hooks.json``. The wake is the session-armed tail. A
+  missing or stale sidecar inbox.log is said loudly in the session context.
 * unknown / undetectable harness → LOUD REFUSAL: nonzero exit, nothing
   written. A silent no-op here would manufacture exactly the
   armed-looking-but-deaf cell this card exists to eliminate.
@@ -271,9 +271,10 @@ Usage:
 
 
 Installs the silent-wake session-start hook (board card #482). The product
-depends on where the wake lives: claude/codex get an arm-instruction (the
-tail -F inbox.log | dm_notify_filter watch), cursor gets verify-and-report
-of the swarph monitor's push sink. Unknown harnesses are refused loudly.
+depends on where the wake lives: claude, codex, and cursor get an
+arm-instruction (the tail -F inbox.log | dm_notify_filter watch). Cursor
+emits that pipeline as session context and says loudly when the sidecar
+inbox.log is missing or stale. Unknown harnesses are refused loudly.
 --cell is refused with --scope user (card #527): a baked cell name in a
 box-global file arms one cell's wake for every session on the box and
 silently evicts the last installed cell's. Omit --cell and the hook
@@ -444,7 +445,7 @@ def run_install_wake_hook(argv: Optional[list[str]] = None) -> int:
         product = (
             "arm-instruction (the session-start hook emits the "
             "tail -F inbox.log | dm_notify_filter watch as session context)"
-            if harness in ("claude", "codex", "muse")
+            if harness in ("claude", "codex", "muse", "cursor")
             else "verify-and-report (the session-start hook checks the "
             "swarph monitor's push sink and says loudly if none exists)"
         )