@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/lint_value_dashboard.py

@@ -1,218 +0,0 @@
-#!/usr/bin/env python3
-"""Lint `docs/value.md` for structural invariants.
-
-Phase 5 Step 3 of `agents/roadmaps/road-to-readable-value-dashboard.md`.
-
-Invariants enforced (any violation → exit 1):
-
-1. Required sections present (intro / Reference scale / Panel A / Panel B
-   / Glossary / NET line).
-2. Every cost-ladder rung row cites a `source_report` (or `n/a` for the
-   baseline rung) — no rung sneaks in without traceability.
-3. No `measured` rung renders a `pending` source — internal consistency
-   of confidence ↔ source state.
-4. No negative-saving label: the literal string "Ersparnis" must not
-   appear in a row where the displayed Δ-token value is positive (the
-   load + terse rungs are *costs*, not savings; mislabelling either is
-   a credibility failure the page explicitly forbids).
-5. The `latest.json` exists and its `cost_ladder` rung ids match the
-   five canonical rungs — the renderer cannot silently drop a rung.
-
-The linter loads `internal/bench/reports/value/latest.json` directly
-(not just the rendered `.md`) for items (3) and (5) — the rendered
-text alone is too lossy.
-
-Output: one violation per line in non-quiet mode; one-line summary in
-quiet mode. Exit 0 on clean, 1 on any violation.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-DASHBOARD = REPO_ROOT / "docs" / "value.md"
-LATEST = REPO_ROOT / "internal" / "bench" / "reports" / "value" / "latest.json"
-
-REQUIRED_SECTIONS = (
-    "# Value Dashboard",
-    "## Reference scale",
-    "## Panel A",
-    "## Panel B",
-    "## Glossary",
-    "**NET",
-)
-
-CANONICAL_RUNG_IDS = ("baseline", "load", "thin", "condense", "rtk", "terse")
-
-
-def _log(msg: str, quiet: bool, *, err: bool = False) -> None:
-    if err:
-        print(msg, file=sys.stderr)
-    elif not quiet:
-        print(msg)
-
-
-def check_required_sections(text: str) -> List[str]:
-    return [
-        f"missing required section: '{section}'"
-        for section in REQUIRED_SECTIONS
-        if section not in text
-    ]
-
-
-def check_source_citations(report: Dict[str, Any]) -> List[str]:
-    violations = []
-    for rung in report.get("cost_ladder", []) or []:
-        source = rung.get("source_report")
-        if not source:
-            violations.append(
-                f"rung '{rung.get('id')}' has no source_report field"
-            )
-            continue
-        if not isinstance(source, str) or not source.strip():
-            violations.append(
-                f"rung '{rung.get('id')}' has empty source_report"
-            )
-    return violations
-
-
-def check_confidence_vs_source(report: Dict[str, Any]) -> List[str]:
-    """A `measured` rung's source_report must exist on disk."""
-    violations = []
-    for rung in report.get("cost_ladder", []) or []:
-        if rung.get("confidence") != "measured":
-            continue
-        source = rung.get("source_report") or ""
-        if source in ("", "n/a"):
-            continue  # baseline rung
-        path = REPO_ROOT / source
-        if not path.exists():
-            violations.append(
-                f"rung '{rung.get('id')}' is 'measured' but its "
-                f"source_report does not exist: {source}"
-            )
-    return violations
-
-
-def check_no_negative_savings(text: str) -> List[str]:
-    """A rung whose Δ-token value is positive must not be labelled a saving.
-
-    Heuristic: scan Panel A's rows; flag any row that contains the
-    German word "Ersparnis" with a positive token-delta in the same row.
-    """
-    violations = []
-    # Panel A rows are pipe-delimited; we read every line starting with "|"
-    # inside the cost ladder section.
-    in_panel_a = False
-    for line in text.splitlines():
-        if line.startswith("## Panel A"):
-            in_panel_a = True
-            continue
-        if in_panel_a and line.startswith("## "):
-            break
-        if not in_panel_a or not line.startswith("|"):
-            continue
-        if "Ersparnis" not in line:
-            continue
-        # Look for a "+" sign at the start of an integer-shaped delta.
-        # The format renders deltas as "+4 843" / "-186".
-        m = re.search(r"\|\s*([+-][0-9 ]+)\s*\|", line)
-        if m and m.group(1).strip().startswith("+"):
-            token_value = m.group(1).strip()
-            violations.append(
-                "row labelled 'Ersparnis' has a positive Δ-token value: "
-                f"{token_value!r} — positive deltas are costs, not savings."
-            )
-    return violations
-
-
-def check_canonical_rung_set(report: Dict[str, Any]) -> List[str]:
-    rungs = report.get("cost_ladder", []) or []
-    ids = [r.get("id") for r in rungs]
-    if list(ids) != list(CANONICAL_RUNG_IDS):
-        return [
-            f"cost_ladder rung ids must be {CANONICAL_RUNG_IDS}, "
-            f"got {tuple(ids)}"
-        ]
-    return []
-
-
-def lint(quiet: bool = False) -> int:
-    violations: List[str] = []
-
-    if not DASHBOARD.exists():
-        _log(
-            f"FAIL: dashboard not found: {DASHBOARD.relative_to(REPO_ROOT)}",
-            quiet,
-            err=True,
-        )
-        return 1
-    text = DASHBOARD.read_text()
-    violations.extend(check_required_sections(text))
-    violations.extend(check_no_negative_savings(text))
-
-    if not LATEST.exists():
-        # No JSON to deep-check — that's a placeholder dashboard.
-        # Required-sections check still applies; we degrade gracefully.
-        if violations:
-            for v in violations:
-                _log(f"FAIL: {v}", quiet, err=True)
-            return 1
-        _log(
-            "lint_value_dashboard: dashboard is a placeholder "
-            "(no value-v1.json yet) — structural checks pass.",
-            quiet=False,
-        )
-        return 0
-
-    try:
-        report = json.loads(LATEST.read_text())
-    except json.JSONDecodeError as exc:
-        _log(f"FAIL: {LATEST.name} is not valid JSON: {exc}", quiet, err=True)
-        return 1
-
-    violations.extend(check_source_citations(report))
-    violations.extend(check_confidence_vs_source(report))
-    violations.extend(check_canonical_rung_set(report))
-
-    if violations:
-        for v in violations:
-            _log(f"FAIL: {v}", quiet, err=True)
-        return 1
-    _log(
-        (
-            "lint_value_dashboard: OK — "
-            f"{len(report.get('cost_ladder', []))} rungs, "
-            f"{len(report.get('behaviour', []))} behaviour metrics, all "
-            "sections present, all sources cited."
-        ),
-        quiet=False,
-    )
-    return 0
-
-
-def parse_args(argv: List[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Lint docs/value.md for structural invariants."
-    )
-    parser.add_argument(
-        "--quiet",
-        action="store_true",
-        help="Suppress non-error output.",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: List[str] | None = None) -> int:
-    args = parse_args(argv if argv is not None else sys.argv[1:])
-    return lint(quiet=args.quiet)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_workspace_boundary.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""Workspace-boundary drift check — import-edge enforcement.
-
-Governed by `docs/contracts/workspace-boundary.md` + ADR-095. Fails when a
-workspace module (`src/cli/python/workspace_*.py`) imports an owner-module of
-a domain the workspace does NOT own: skill design, profile/pack semantics,
-video-provider logic, MCP-registry policy, analytics product strategy.
-
-Scope (read this before trusting a green run): this enforces **import edges
-only**. Semantic drift — a workspace module that encodes profile-semantics or
-analytics-product-strategy judgement without importing anything forbidden — is
-NOT catchable here and stays doc-governance, enforced in review against the
-contract. A green run is a supplement to boundary thinking, not a substitute.
-
-Allowed: stdlib, third-party deps, intra-workspace imports (`workspace_*`),
-and any import line carrying a `# boundary-exception: <reason>` pragma.
-
-Usage:  python3 src/scripts/lint_workspace_boundary.py [--quiet]
-Exit:   0 = boundary holds · 1 = a forbidden import was found · 2 = internal.
-"""
-from __future__ import annotations
-
-import ast
-import re
-import sys
-from pathlib import Path
-
-WORKSPACE_GLOB = "src/cli/python/workspace_*.py"
-PRAGMA = "boundary-exception:"
-
-# Owner-modules of the NOT-owned domains. Matched against each dotted segment
-# of an imported module name with segment boundaries, so `packaging` does not
-# trip `pack` and `workspace_skills` is handled by the intra-workspace allow.
-FORBIDDEN: list[tuple[re.Pattern, str]] = [
-    (re.compile(r"(?:^|[._-])condense(?:$|[._-])"), "skill design / condensation"),
-    (re.compile(r"(?:^|[._-])skill_linter(?:$|[._-])"), "skill design"),
-    (re.compile(r"(?:^|[._-])skill_management(?:$|[._-])"), "skill design"),
-    (re.compile(r"(?:^|[._-])skill_writing(?:$|[._-])"), "skill design"),
-    (re.compile(r"(?:^|[._-])discovery_manifest(?:$|[._-])"), "profile/pack semantics"),
-    (re.compile(r"(?:^|[._-])(?:profiles?|packs?)(?:$|[._-])"), "profile/pack semantics"),
-    (re.compile(r"ai[_-]?video"), "video-provider logic"),
-    (re.compile(r"(?:^|[._-])mcp(?:$|[._-])"), "MCP-registry policy"),
-    (re.compile(r"(?:^|[._-])router(?:$|[._-])"), "router / projection policy"),
-    (re.compile(r"(?:^|[._-])persona"), "persona / skill design"),
-]
-
-
-def _is_intra_workspace(module: str) -> bool:
-    head = module.split(".", 1)[0]
-    return head == "workspace" or head.startswith("workspace_")
-
-
-def _forbidden_reason(module: str) -> "str | None":
-    if _is_intra_workspace(module):
-        return None
-    for pat, reason in FORBIDDEN:
-        if pat.search(module):
-            return reason
-    return None
-
-
-def _imported_modules(tree: ast.AST):
-    """Yield (module_name, lineno) for every import in the tree."""
-    for node in ast.walk(tree):
-        if isinstance(node, ast.ImportFrom) and node.module:
-            yield node.module, node.lineno
-        elif isinstance(node, ast.Import):
-            for alias in node.names:
-                yield alias.name, node.lineno
-
-
-def check_file(path: Path) -> list[str]:
-    """Return human-readable violation strings for one workspace module."""
-    src = path.read_text(encoding="utf-8")
-    lines = src.splitlines()
-    try:
-        tree = ast.parse(src, filename=str(path))
-    except SyntaxError as exc:  # pragma: no cover
-        return [f"{path}: unparseable ({exc})"]
-    out: list[str] = []
-    for module, lineno in _imported_modules(tree):
-        reason = _forbidden_reason(module)
-        if reason is None:
-            continue
-        line = lines[lineno - 1] if 0 < lineno <= len(lines) else ""
-        if PRAGMA in line:
-            continue  # reviewed, deliberate exception
-        out.append(
-            f"{path.name}:{lineno}: imports `{module}` "
-            f"(not-owned domain: {reason})"
-        )
-    return out
-
-
-def main(argv: list[str]) -> int:
-    quiet = "--quiet" in argv
-    repo = Path(__file__).resolve().parent.parent.parent
-    files = sorted(repo.glob(WORKSPACE_GLOB))
-    if not files:
-        print(f"⚠️  lint-workspace-boundary: no files match {WORKSPACE_GLOB}")
-        return 0
-    violations: list[str] = []
-    for f in files:
-        violations.extend(check_file(f))
-    if violations:
-        print("❌  Workspace-boundary violation(s) — a workspace module imports "
-              "an owner-module of a domain the workspace does NOT own "
-              "(docs/contracts/workspace-boundary.md):")
-        for v in violations:
-            print(f"  🔴 {v}")
-        print("\nFix: move the logic to the owning surface and consume its "
-              "output, or add `# boundary-exception: <reason>` if the import is "
-              "genuinely justified (reviewed like any boundary change).")
-        return 1
-    if not quiet:
-        print(f"✅  Workspace boundary holds — {len(files)} module(s), "
-              "no forbidden imports.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

package/src/scripts/mcp_parity_smoke.py

@@ -1,316 +0,0 @@
-"""Live-replay parity smoke — local stdio kernel vs deployed Worker URL.
-
-Replays a fixed set of JSON-RPC calls against:
-
-1. The local Python loaders (`prompts.py` / `resources.py`) — the
-   source-of-truth wire surface.
-2. An HTTP target (typically `wrangler dev` locally, or the deployed
-   Cloudflare Worker URL in CI / post-deploy).
-
-Diffs the two on a normalised view (signature + release_key + content
-hashes stripped). Exit 0 = parity, 1 = drift.
-
-Usage:
-    python scripts/mcp_parity_smoke.py --target http://127.0.0.1:8787
-    python scripts/mcp_parity_smoke.py --target https://mcp.example.com
-
-Phase 5.1 of `road-to-cloudflare-mcp-hosting.md`. Governed by
-`docs/contracts/mcp-cloud-scope.md` §A0-cloud.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-import urllib.request
-from pathlib import Path
-from typing import Any
-
-_SCRIPTS = Path(__file__).resolve().parent
-sys.path.insert(0, str(_SCRIPTS))
-_REPO_ROOT = _SCRIPTS.parents[1]
-DEFAULT_NODE_CLI = _REPO_ROOT / "dist" / "cli" / "agent-config.js"
-# Kinds the turnkey local stdio-lite surface serves (ADR-085 subset — no
-# contexts, no execution). The parity leg compares this subset only.
-_NODE_RESOURCE_KINDS = {"rule", "guideline"}
-
-from mcp_server.catalog import load_catalog  # noqa: E402
-from mcp_server.prompts import load_all_prompts, to_mcp_prompt_meta  # noqa: E402
-from mcp_server.resources import load_all_resources, to_mcp_resource_meta  # noqa: E402
-from mcp_server.tools import ALLOWLIST  # noqa: E402
-
-PAGE_SIZE = 50
-
-
-def _local_prompts_list() -> dict[str, Any]:
-    prompts, _ = load_all_prompts()
-    metas = [to_mcp_prompt_meta(p) for p in prompts]
-    page = metas[:PAGE_SIZE]
-    out: dict[str, Any] = {"prompts": page}
-    if len(metas) > PAGE_SIZE:
-        out["nextCursor"] = page[-1]["name"]
-    return out
-
-
-def _local_resources_list() -> dict[str, Any]:
-    resources, _ = load_all_resources()
-    metas = [to_mcp_resource_meta(r) for r in resources]
-    page = metas[:PAGE_SIZE]
-    out: dict[str, Any] = {"resources": page}
-    if len(metas) > PAGE_SIZE:
-        out["nextCursor"] = page[-1]["uri"]
-    return out
-
-
-def _rpc(target: str, method: str, params: dict[str, Any] | None = None) -> Any:
-    body = json.dumps(
-        {"jsonrpc": "2.0", "id": 1, "method": method, "params": params or {}}
-    ).encode("utf-8")
-    req = urllib.request.Request(
-        target,
-        data=body,
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    with urllib.request.urlopen(req, timeout=10) as r:  # noqa: S310
-        resp = json.loads(r.read().decode("utf-8"))
-    if "error" in resp:
-        raise RuntimeError(f"{method}: {resp['error']}")
-    return resp["result"]
-
-
-def _normalize_prompts(payload: dict[str, Any]) -> list[dict[str, Any]]:
-    out = []
-    for p in payload.get("prompts", []):
-        out.append({
-            "name": p["name"],
-            "description": p["description"],
-            "kind": p.get("_meta", {}).get("kind"),
-        })
-    return sorted(out, key=lambda x: x["name"])
-
-
-def _normalize_resources(payload: dict[str, Any]) -> list[dict[str, Any]]:
-    out = []
-    for r in payload.get("resources", []):
-        out.append({
-            "uri": r["uri"],
-            "name": r["name"],
-            "description": r["description"],
-            "mimeType": r["mimeType"],
-            "kind": r.get("_meta", {}).get("kind"),
-        })
-    return sorted(out, key=lambda x: x["uri"])
-
-
-def _local_tools_list() -> dict[str, Any]:
-    """Tools catalog + allowlist as the stdio server publishes them."""
-    catalog_names = [c.name for c in load_catalog()]
-    allowlist_names = list(ALLOWLIST.keys())
-    return {"tools": [{"name": n} for n in sorted(set(catalog_names + allowlist_names))]}
-
-
-def _normalize_tools(payload: dict[str, Any]) -> list[dict[str, Any]]:
-    """Compare on `name` only — descriptions / schemas drift acceptably."""
-    return sorted(
-        [{"name": t["name"]} for t in payload.get("tools", [])],
-        key=lambda x: x["name"],
-    )
-
-
-class _NodeSession:
-    """Interactive stdio session with `node <cli> mcp-server` — write a request
-    line, read one JSON-RPC response line. Enables cursor pagination (we can't
-    know cursors ahead of a batch). stdout is JSON-RPC; stderr (the readiness
-    note) is drained separately. Asserts stdout purity: every line is JSON-RPC.
-    """
-
-    def __init__(self, cli: Path) -> None:
-        self._proc = subprocess.Popen(  # noqa: S603
-            ["node", str(cli), "mcp-server"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            text=True,
-        )
-        self._id = 0
-
-    def call(self, method: str, params: dict[str, Any] | None = None) -> Any:
-        self._id += 1
-        assert self._proc.stdin and self._proc.stdout
-        self._proc.stdin.write(
-            json.dumps({"jsonrpc": "2.0", "id": self._id, "method": method, "params": params or {}}) + "\n"
-        )
-        self._proc.stdin.flush()
-        line = self._proc.stdout.readline().strip()
-        resp = json.loads(line)  # stdout purity: a non-JSON line throws here
-        if "error" in resp and not method.startswith("tools/"):
-            raise RuntimeError(f"{method}: {resp['error']}")
-        return resp.get("result", resp.get("error"))
-
-    def list_all(self, method: str, items_key: str, cursor_field: str) -> list[dict[str, Any]]:
-        """Follow `nextCursor` until exhausted — returns the FULL list."""
-        items: list[dict[str, Any]] = []
-        cursor: str | None = None
-        while True:
-            result = self.call(method, {"cursor": cursor} if cursor else {})
-            items.extend(result.get(items_key, []))
-            cursor = result.get("nextCursor")
-            if not cursor:
-                return items
-
-    def close(self) -> None:
-        assert self._proc.stdin
-        self._proc.stdin.close()
-        self._proc.wait(timeout=15)
-
-
-def _subset_prompts(metas: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Key on name + kind only — robust to condensed-vs-uncondensed
-    description telegraphing across surfaces."""
-    return sorted(
-        ({"name": p["name"], "kind": p["kind"]} for p in metas),
-        key=lambda x: x["name"],
-    )
-
-
-def _subset_resources(metas: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Filter to the kinds the turnkey surface serves; key on uri + kind +
-    mimeType (drop description for the same robustness reason)."""
-    return sorted(
-        (
-            {"uri": r["uri"], "kind": r["kind"], "mimeType": r["mimeType"]}
-            for r in metas
-            if r["kind"] in _NODE_RESOURCE_KINDS
-        ),
-        key=lambda x: x["uri"],
-    )
-
-
-def _diff(label: str, local: list[Any], remote: list[Any]) -> int:
-    if local == remote:
-        print(f"✅  {label}: {len(local)} entries match")
-        return 0
-    print(f"❌  {label}: drift ({len(local)} local vs {len(remote)} remote)")
-    local_set = {json.dumps(x, sort_keys=True) for x in local}
-    remote_set = {json.dumps(x, sort_keys=True) for x in remote}
-    only_local = local_set - remote_set
-    only_remote = remote_set - local_set
-    for s in sorted(only_local)[:5]:
-        print(f"    local-only: {s}")
-    for s in sorted(only_remote)[:5]:
-        print(f"    remote-only: {s}")
-    if len(only_local) > 5 or len(only_remote) > 5:
-        print(f"    (+{len(only_local) - 5} local, +{len(only_remote) - 5} remote more)")
-    return 1
-
-
-def _run_http_leg(target: str) -> int:
-    """Local Python kernel vs deployed Worker (HTTP). Full normalized diff."""
-    failed = 0
-    failed += _diff(
-        "prompts/list",
-        _normalize_prompts(_local_prompts_list()),
-        _normalize_prompts(_rpc(target, "prompts/list")),
-    )
-    failed += _diff(
-        "resources/list",
-        _normalize_resources(_local_resources_list()),
-        _normalize_resources(_rpc(target, "resources/list")),
-    )
-    try:
-        failed += _diff(
-            "tools/list",
-            _normalize_tools(_local_tools_list()),
-            _normalize_tools(_rpc(target, "tools/list")),
-        )
-    except Exception as e:
-        print(f"❌  tools/list: {e}")
-        failed += 1
-    print(f"{'' if failed else 'parity OK '}against {target}".strip())
-    return failed
-
-
-def _local_prompts_all() -> list[dict[str, Any]]:
-    """ALL skill+command prompt metas (uncapped — for full-set parity)."""
-    prompts, _ = load_all_prompts()
-    return [to_mcp_prompt_meta(p) for p in prompts]
-
-
-def _local_resources_all() -> list[dict[str, Any]]:
-    """ALL resource metas (uncapped — for full-set parity)."""
-    resources, _ = load_all_resources()
-    return [to_mcp_resource_meta(r) for r in resources]
-
-
-def _run_node_leg(cli: Path) -> int:
-    """Local Python kernel vs the turnkey Node stdio-lite binary (ADR-085).
-
-    Compares the FULL SUBSET the turnkey surface serves (skill/command prompts,
-    rule/guideline resources — contexts excluded by design) via cursor
-    pagination, on name/kind/uri keys, and asserts the read-only boundary
-    (`tools/list` empty). Skips with a note if the binary isn't built.
-    """
-    if not cli.exists():
-        print(f"⏭️  node-stdio: {cli} not built — run `npm run build:cli` (skipped)")
-        return 0
-    session = _NodeSession(cli)
-    try:
-        node_prompts = session.list_all("prompts/list", "prompts", "name")
-        node_resources = session.list_all("resources/list", "resources", "uri")
-        node_tools = session.call("tools/list").get("tools", [])
-    finally:
-        session.close()
-
-    failed = 0
-    failed += _diff(
-        "node prompts/list (full subset)",
-        _subset_prompts(_normalize_prompts({"prompts": _local_prompts_all()})),
-        _subset_prompts(_normalize_prompts({"prompts": node_prompts})),
-    )
-    failed += _diff(
-        "node resources/list (full subset)",
-        _subset_resources(_normalize_resources({"resources": _local_resources_all()})),
-        _subset_resources(_normalize_resources({"resources": node_resources})),
-    )
-    if node_tools:
-        print(f"❌  node tools/list: expected empty (read-only), got {len(node_tools)}")
-        failed += 1
-    else:
-        print("✅  node tools/list: empty (read-only, ADR-085)")
-    print(f"{'' if failed else 'node-stdio parity OK '}({cli.name})".strip())
-    return failed
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--target", help="HTTP URL of the Worker (HTTP-parity leg).")
-    ap.add_argument(
-        "--node-stdio",
-        nargs="?",
-        const=str(DEFAULT_NODE_CLI),
-        help=(
-            "Run the turnkey-launch parity leg against the Node stdio-lite "
-            f"binary (default: {DEFAULT_NODE_CLI.relative_to(_REPO_ROOT)})."
-        ),
-    )
-    args = ap.parse_args()
-    if not args.target and not args.node_stdio:
-        ap.error("at least one of --target or --node-stdio is required")
-
-    failed = 0
-    if args.target:
-        failed += _run_http_leg(args.target)
-    if args.node_stdio:
-        failed += _run_node_leg(Path(args.node_stdio))
-
-    if failed:
-        print(f"\n{failed} surface(s) drifted")
-        return 1
-    print("\nparity OK")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())