@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/lint_skill_frontmatter_safety.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""P1.4 — dangerous-frontmatter linter (road-to-security-pillar.md).
-
-Enforces the execution-safety contract from the ``runtime-safety`` rule at the
-frontmatter layer, and flags the consumer-format consent-bypass headers
-(``permissionMode: bypassPermissions``, wildcard ``allowed-tools``) that the
-"skill supply-chain" attack class abuses.
-
-Checks (skill / command / persona / agent frontmatter under src/):
-
-- HIGH: ``execution.type: automated`` but the runtime-safety floor is not met —
-  ``handler`` is ``none``/missing, ``safety_mode`` is not ``strict``, or no
-  ``allowed_tools`` key is declared.
-- HIGH: ``allowed_tools`` (or consumer ``allowed-tools``) grants a wildcard —
-  ``*``, ``Bash(*)``, or bare ``Bash`` — an over-broad tool grant.
-- HIGH: ``permissionMode: bypassPermissions`` (consent bypass).
-
-Reconciles with ``validate_frontmatter.py`` (schema fill) by checking only
-*safety semantics*, never re-reporting shape/required-key errors.
-
-Usage: python3 src/scripts/lint_skill_frontmatter_safety.py [--json]
-"""
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _lib import security_lint as sl  # noqa: E402
-
-CHECK = "dangerous-frontmatter"
-
-# Always over-broad: a star or Bash(*) wildcard grant.
-_WILDCARD_TOOL = re.compile(r"(^|[\s,\[\"'])(\*|Bash\(\*\))(\s|,|\]|\"|'|$)")
-# Bare `Bash` (full shell) — over-broad only on a NON-execution skill.
-_BARE_BASH = re.compile(r"(^|[\s,\[\"'])Bash(\s|,|\]|\"|'|$)")
-
-
-def _frontmatter(sf: sl.ScannedFile) -> tuple[list[tuple[int, str]], int] | None:
-    """Return [(lineno, text)] of the frontmatter body + its end line, or None."""
-    if not sf.lines or sf.lines[0].strip() != "---":
-        return None
-    body = []
-    for i in range(1, len(sf.lines)):
-        if sf.lines[i].strip() == "---":
-            return body, i + 1
-        body.append((i + 1, sf.lines[i]))
-    return None
-
-
-def _exec_block(body: list[tuple[int, str]]) -> dict[str, tuple[int, str]]:
-    """Extract execution.* sub-keys as {key: (lineno, value)} (one-level block)."""
-    out: dict[str, tuple[int, str]] = {}
-    in_exec = False
-    base_indent = 0
-    for lineno, text in body:
-        if re.match(r"^execution:\s*$", text):
-            in_exec = True
-            base_indent = len(text) - len(text.lstrip())
-            continue
-        if in_exec:
-            indent = len(text) - len(text.lstrip())
-            if text.strip() and indent <= base_indent:
-                in_exec = False
-                continue
-            m = re.match(r"^\s+([\w-]+):\s*(.*)$", text)
-            if m:
-                out[m.group(1)] = (lineno, m.group(2).strip())
-    return out
-
-
-def _scan(sf: sl.ScannedFile) -> list[sl.Finding]:
-    if sf.pragma_allows(CHECK):
-        return []
-    fm = _frontmatter(sf)
-    if not fm:
-        return []
-    body, _end = fm
-    out: list[sl.Finding] = []
-
-    ex = _exec_block(body)
-    handler = ex.get("handler", (0, ""))[1].strip("'\"")
-    is_execution_skill = bool(ex) and handler not in ("", "none")
-
-    # consumer consent-bypass header + wildcard `allowed-tools` (hyphen = Claude
-    # format; the underscore source key is covered by the execution block below).
-    for lineno, text in body:
-        if re.match(r"\s*permissionMode:\s*['\"]?bypassPermissions", text):
-            out.append(sl.Finding(sf.rel, lineno, CHECK, "HIGH",
-                                  "permissionMode: bypassPermissions (consent bypass)", sf.weight))
-        m = re.match(r"\s*allowed-tools:\s*(.+)$", text)
-        if m and (_WILDCARD_TOOL.search(m.group(1))
-                  or (_BARE_BASH.search(m.group(1)) and not is_execution_skill)):
-            out.append(sl.Finding(sf.rel, lineno, CHECK, "HIGH",
-                                  "wildcard / bare-Bash tool grant (over-broad)", sf.weight))
-
-    if not ex:
-        return out
-    etype = ex.get("type", (0, ""))[1].strip("'\"")
-    safety = ex.get("safety_mode", (0, ""))[1].strip("'\"")
-    exec_line = ex.get("type", ex.get("handler", (0, "")))[0]
-
-    if etype == "automated":
-        if handler in ("", "none"):
-            out.append(sl.Finding(sf.rel, exec_line, CHECK, "HIGH",
-                                  "automated execution with handler none/missing (runtime-safety)", sf.weight))
-        if safety != "strict":
-            out.append(sl.Finding(sf.rel, exec_line, CHECK, "HIGH",
-                                  "automated execution without safety_mode: strict (runtime-safety)", sf.weight))
-        if "allowed_tools" not in ex:
-            out.append(sl.Finding(sf.rel, exec_line, CHECK, "HIGH",
-                                  "automated execution without an explicit allowed_tools declaration", sf.weight))
-
-    at_line, at_val = ex.get("allowed_tools", (0, ""))
-    if at_val and _WILDCARD_TOOL.search(at_val):
-        out.append(sl.Finding(sf.rel, at_line, CHECK, "HIGH",
-                              "execution.allowed_tools wildcard (* / Bash(*)) grant", sf.weight))
-    elif at_val and _BARE_BASH.search(at_val) and not is_execution_skill:
-        out.append(sl.Finding(sf.rel, at_line, CHECK, "HIGH",
-                              "bare Bash grant on a non-execution skill (handler none/missing)", sf.weight))
-    return out
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__, epilog=sl.GUIDELINE_EPILOG)
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-
-    findings: list[sl.Finding] = []
-    roots = ("src/skills", "src/agent-src", "src/domains")
-    for sf in sl.iter_corpus(roots=roots, exts=(".md",)):
-        findings.extend(_scan(sf))
-
-    if args.json:
-        import json
-        print(json.dumps([f.__dict__ for f in findings], indent=2))
-        return 1 if any(f.is_fail for f in findings) else 0
-    return sl.report(findings, check_label="dangerous-frontmatter")
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_skill_tools.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""Block D · D1 — meta-linter for ``scripts/skill_tools/*.py``.
-
-Enforces the four pilot-tool invariants locked by the Block D council
-verdict (`agents/runtime/council/responses/block-d-python-tools-pilot-verdict.md`): <!-- council-ref-allowed: pilot-verdict provenance -->
-
-  1. **stdlib-only** — no third-party imports. Internal package imports
-     (``scripts.*``) are allowed.
-  2. **--help and --json flags** — every tool must register both via
-     ``argparse`` so callers can introspect and machine-read.
-  3. **naming** — ``snake_case_verb_noun.py`` (≥ 1 underscore, lowercase).
-  4. **embedded sample data** — module must define a ``_SAMPLE`` constant
-     OR contain ``if __name__ == "__main__"`` with sample-mode handling
-     (so the tool can run without external fixtures).
-  5. **size cap** — file ≤ 200 LOC (per roadmap D1, applies to D1 itself
-     and to D2/D3/D4 with their own caps validated externally).
-
-Tool discovery is glob-based (``scripts/skill_tools/*.py`` excluding
-``__init__.py``) per anthropic round-2 critique — never a hardcoded list.
-
-Run:
-  python3 scripts/lint_skill_tools.py            # human-readable
-  python3 scripts/lint_skill_tools.py --json     # machine-readable
-
-Exit codes: 0 clean · 1 violations found · 2 usage error.
-"""
-from __future__ import annotations
-
-import argparse
-import ast
-import json
-import re
-import sys
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-ROOT = Path(__file__).resolve().parents[2]
-TOOLS_DIR = ROOT / "src" / "scripts" / "skill_tools"
-NAME_RE = re.compile(r"^[a-z][a-z0-9]*(?:_[a-z0-9]+)+\.py$")
-SIZE_CAP = 200
-
-# Python 3.9-compatible stdlib list. Kept conservative — additions are cheap,
-# false negatives are not. Mirrors `sys.stdlib_module_names` from 3.10+.
-STDLIB = frozenset({
-    "__future__", "abc", "argparse", "ast", "base64", "collections", "configparser",
-    "contextlib", "copy", "csv", "dataclasses", "datetime", "decimal", "difflib",
-    "enum", "errno", "fnmatch", "functools", "glob", "gzip", "hashlib", "heapq",
-    "html", "http", "importlib", "inspect", "io", "ipaddress", "itertools", "json",
-    "logging", "math", "mimetypes", "os", "pathlib", "pickle", "platform", "posixpath",
-    "pprint", "queue", "random", "re", "shlex", "shutil", "signal", "socket",
-    "sqlite3", "ssl", "stat", "string", "struct", "subprocess", "sys", "tempfile",
-    "textwrap", "threading", "time", "tomllib", "traceback", "types", "typing",
-    "unicodedata", "unittest", "urllib", "uuid", "venv", "warnings", "weakref",
-    "xml", "zipfile", "zlib",
-})
-PROJECT_PACKAGES = frozenset({"scripts", "skill_tools"})  # internal imports are fine.
-
-
-def _violations_for(path: Path) -> List[str]:
-    """Return a list of violation strings for one tool (empty = clean)."""
-    out: List[str] = []
-    name = path.name
-    if not NAME_RE.match(name):
-        out.append(f"naming: `{name}` is not snake_case_verb_noun.py")
-
-    text = path.read_text(encoding="utf-8")
-    loc = sum(1 for ln in text.splitlines() if ln.strip() and not ln.lstrip().startswith("#"))
-    if loc > SIZE_CAP:
-        out.append(f"size: {loc} LOC > {SIZE_CAP} cap")
-
-    try:
-        tree = ast.parse(text, filename=str(path))
-    except SyntaxError as exc:
-        out.append(f"syntax: {exc.msg} at line {exc.lineno}")
-        return out
-
-    # Imports — flag any non-stdlib, non-project top-level module + record argparse use.
-    imported: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Import):
-            for alias in node.names:
-                root = alias.name.split(".")[0]
-                imported.add(root)
-                if root not in STDLIB and root not in PROJECT_PACKAGES:
-                    out.append(f"stdlib-only: imports `{alias.name}` (third-party)")
-        elif isinstance(node, ast.ImportFrom):
-            if node.module is None or node.level > 0:
-                continue  # relative imports — package-internal
-            root = node.module.split(".")[0]
-            imported.add(root)
-            if root not in STDLIB and root not in PROJECT_PACKAGES:
-                out.append(f"stdlib-only: imports from `{node.module}` (third-party)")
-
-    # CLI flags — confirm argparse is imported and `--json` is registered.
-    has_argparse = "argparse" in imported
-    has_json_flag = re.search(r"['\"]--json['\"]", text) is not None
-    if not has_argparse:
-        out.append("cli: no `argparse` import detected")
-    if not has_json_flag:
-        out.append("cli: missing `--json` flag")
-    # `--help` is auto-registered by argparse; we sanity-check that
-    # add_help isn't disabled.
-    if re.search(r"add_help\s*=\s*False", text):
-        out.append("cli: `add_help=False` disables --help")
-
-    # Embedded sample data — accept either a module-level _SAMPLE constant
-    # or a __main__ block (the tool can self-demo).
-    has_sample = bool(re.search(r"^_SAMPLE\s*[:=]", text, re.MULTILINE))
-    has_main = '__name__ == "__main__"' in text or "__name__ == '__main__'" in text
-    if not (has_sample or has_main):
-        out.append("sample: no `_SAMPLE` constant or `__main__` block")
-
-    return out
-
-
-def lint(tools_dir: Path) -> Tuple[int, Dict[str, List[str]]]:
-    tools_dir = tools_dir.resolve()
-    if not tools_dir.is_dir():
-        return 2, {"_error": [f"tools dir missing: {tools_dir}"]}
-    findings: Dict[str, List[str]] = {}
-    for path in sorted(tools_dir.glob("*.py")):
-        if path.name == "__init__.py":
-            continue
-        viols = _violations_for(path)
-        if viols:
-            try:
-                key = str(path.relative_to(ROOT))
-            except ValueError:
-                key = str(path)
-            findings[key] = viols
-    return (1 if findings else 0), findings
-
-
-def _print_human(findings: Dict[str, List[str]]) -> None:
-    if not findings:
-        print(f"✅  scripts/skill_tools/ — all tools clean.")
-        return
-    print(f"❌  scripts/skill_tools/ — {len(findings)} tool(s) with violations:")
-    for fp, viols in findings.items():
-        print(f"  {fp}:")
-        for v in viols:
-            print(f"    - {v}")
-
-
-def main(argv: List[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(
-        description="Lint scripts/skill_tools/*.py against Block D pilot invariants.",
-    )
-    parser.add_argument("--json", action="store_true", help="emit JSON instead of text")
-    parser.add_argument("--quiet", action="store_true",
-                        help="suppress the clean-pass success line (errors still print)")
-    parser.add_argument("--tools-dir", default=str(TOOLS_DIR),
-                        help="directory to lint (default: scripts/skill_tools)")
-    args = parser.parse_args(argv)
-
-    code, findings = lint(Path(args.tools_dir))
-    if args.json:
-        json.dump({"exit_code": code, "findings": findings}, sys.stdout, indent=2)
-        sys.stdout.write("\n")
-    elif findings or not args.quiet:
-        _print_human(findings)
-    return code
-
-
-_SAMPLE = {"violations": ["stdlib-only: imports `requests` (third-party)"]}
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_topics_yaml.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python3
-"""Linter for `.github/topics.yml`.
-
-Asserts:
-  * file exists and parses as YAML
-  * `topics:` is a non-empty list
-  * every topic matches `^[a-z0-9][a-z0-9-]*$` and is \u2264 50 chars
-  * no duplicates
-  * `notes:` key exists (may be empty mapping/string), so the
-    rationale slot is never silently dropped
-  * `equivalents:` (if present) is a mapping whose keys are all
-    listed in `topics:`
-
-Roadmap: agents/roadmaps/strategic-visibility-mcp-topics-positioning.md Phase 1.3.
-"""
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-import yaml
-
-ROOT = Path(__file__).resolve().parents[2]
-TOPICS_FILE = ROOT / ".github" / "topics.yml"
-SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]*$")
-QUIET = "--quiet" in sys.argv
-
-
-def _fail(msg: str) -> None:
-    print(f"\u274c  topics.yml: {msg}", file=sys.stderr)
-
-
-def main() -> int:
-    if not TOPICS_FILE.exists():
-        _fail(f"missing file: {TOPICS_FILE.relative_to(ROOT)}")
-        return 1
-    try:
-        doc = yaml.safe_load(TOPICS_FILE.read_text(encoding="utf-8")) or {}
-    except yaml.YAMLError as e:
-        _fail(f"YAML parse error: {e}")
-        return 1
-
-    errors: list[str] = []
-
-    topics = doc.get("topics")
-    if not isinstance(topics, list) or not topics:
-        errors.append("`topics:` must be a non-empty list")
-        topics = []
-
-    seen: set[str] = set()
-    for t in topics:
-        if not isinstance(t, str):
-            errors.append(f"non-string topic entry: {t!r}")
-            continue
-        if len(t) > 50:
-            errors.append(f"topic too long (>50 chars): {t!r}")
-        if not SLUG_RE.match(t):
-            errors.append(f"invalid slug (expect ^[a-z0-9][a-z0-9-]*$): {t!r}")
-        if t in seen:
-            errors.append(f"duplicate topic: {t!r}")
-        seen.add(t)
-
-    if "notes" not in doc:
-        errors.append("`notes:` key missing (may be empty, but must be present)")
-
-    equivalents = doc.get("equivalents")
-    if equivalents is not None:
-        if not isinstance(equivalents, dict):
-            errors.append("`equivalents:` must be a mapping")
-        else:
-            for key, val in equivalents.items():
-                if key not in seen:
-                    errors.append(f"`equivalents:` key {key!r} not in `topics:`")
-                if not isinstance(val, list) or not all(isinstance(v, str) for v in val):
-                    errors.append(f"`equivalents.{key}` must be a list of strings")
-
-    if errors:
-        for e in errors:
-            _fail(e)
-        return 1
-
-    if not QUIET:
-        print(f"\u2705  topics.yml: {len(topics)} topic(s), all valid")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_trust_coherence.py

@@ -1,212 +0,0 @@
-#!/usr/bin/env python3
-"""Lint trust/safety coherence across the discovery manifest.
-
-Phase 5.4 of the monorepo trust-and-safety layer. Walks the freshly
-built `dist/discovery/discovery-manifest.json` and asserts three
-invariants:
-
-  1. Every pack whose ``trust_summary`` declares ``advisory`` or
-     ``restricted`` artefacts ships at least one ``*safety-floor*``
-     rule in the same pack.
-  2. Every artefact with ``trust.human_review_required: true`` carries
-     the ``_HRR_BANNER_MARKER`` in its compiled output under
-     ``dist/agent-src/<logical>``.
-  3. Every rule listed in ``router.json`` ``kernel[]`` declares
-     ``trust.level: core`` (no escalation to advisory/restricted,
-     no demotion to experimental).
-
-Exits 0 clean, 1 on any violation. Stdlib + pyyaml. Cap: ≤ 200 LOC.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-from typing import Any
-
-ROOT = Path(__file__).resolve().parents[2]
-MANIFEST = ROOT / "dist" / "discovery" / "discovery-manifest.json"
-ROUTER = ROOT / "dist" / "router.json"
-COMPILED_SRC = ROOT / "dist/agent-src"
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _lib.agent_src import strip_source_prefix  # noqa: E402
-
-# Imported lazily inside _banner_marker() to keep the cap loose if condense.py
-# grows additional top-level side effects.
-_BANNER_MARKER = "<!-- agent-config:human-review-banner -->"
-
-# Trust levels that demand a domain-safety floor in the same pack.
-_FLAGGED_LEVELS = ("advisory", "restricted")
-_SAFETY_FLOOR_FRAGMENT = "safety-floor"
-
-
-def _load_manifest(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        raise SystemExit(
-            f"ERROR: manifest not found: {path}\n"
-            "  Run `task build-discovery` first."
-        )
-    return json.loads(path.read_text("utf-8"))
-
-
-def _load_kernel(path: Path) -> set[str]:
-    if not path.exists():
-        raise SystemExit(f"ERROR: router.json not found: {path}")
-    data = json.loads(path.read_text("utf-8"))
-    kernel = data.get("kernel") or []
-    if not isinstance(kernel, list):
-        raise SystemExit("ERROR: router.json `kernel` must be a list")
-    return {str(name) for name in kernel}
-
-
-def _check_pack_safety_floors(manifest: dict[str, Any]) -> list[str]:
-    """Check 1: advisory/restricted packs ship a *safety-floor* rule."""
-    errs: list[str] = []
-    # Build pack -> [artefact path] index from the artefact list so we can
-    # spot the safety-floor regardless of how trust_summary was computed.
-    pack_paths: dict[str, list[str]] = {}
-    for art in manifest.get("artefacts", []):
-        for pack in art.get("packs", []) or []:
-            pack_paths.setdefault(pack, []).append(art["path"])
-
-    for pack in manifest.get("packs", []):
-        summary = pack.get("trust_summary", {}) or {}
-        flagged_total = sum(int(summary.get(lvl, 0)) for lvl in _FLAGGED_LEVELS)
-        if flagged_total == 0:
-            continue
-        paths = pack_paths.get(pack["id"], [])
-        has_floor = any(_SAFETY_FLOOR_FRAGMENT in p for p in paths)
-        if not has_floor:
-            counts = ", ".join(
-                f"{lvl}={int(summary.get(lvl, 0))}" for lvl in _FLAGGED_LEVELS
-            )
-            errs.append(
-                f"pack `{pack['id']}` declares flagged artefacts ({counts})"
-                f" but ships no `*{_SAFETY_FLOOR_FRAGMENT}*` rule"
-            )
-    return errs
-
-
-def _check_human_review_banners(
-    manifest: dict[str, Any], compiled_src: Path
-) -> list[str]:
-    """Check 2: every human_review_required artefact has the banner."""
-    errs: list[str] = []
-    for art in manifest.get("artefacts", []):
-        trust = art.get("trust", {}) or {}
-        if not trust.get("human_review_required"):
-            continue
-        rel = art["path"]
-        logical = strip_source_prefix(rel)
-        if logical is None:
-            errs.append(
-                f"{rel}: human_review_required=true but path is not under"
-                " any known source root"
-            )
-            continue
-        compiled = compiled_src / logical
-        if not compiled.exists():
-            errs.append(
-                f"{rel}: human_review_required=true but compiled output"
-                f" missing at `{compiled.relative_to(ROOT)}`"
-            )
-            continue
-        body = compiled.read_text("utf-8", errors="replace")
-        if _BANNER_MARKER not in body:
-            errs.append(
-                f"{rel}: human_review_required=true but compiled output"
-                f" `{compiled.relative_to(ROOT)}` is missing the HRR banner"
-                f" (`{_BANNER_MARKER}`) — re-run `task condense`."
-            )
-    return errs
-
-
-def _check_kernel_trust(
-    manifest: dict[str, Any], kernel: set[str]
-) -> list[str]:
-    """Check 3: every kernel rule declares trust.level=core."""
-    errs: list[str] = []
-    # name -> artefact for category=rule entries. Manifest does not always
-    # populate `name` for rules, so fall back to the logical filename stem.
-    rule_by_name: dict[str, dict[str, Any]] = {}
-    for art in manifest.get("artefacts", []):
-        if art.get("category") != "rule":
-            continue
-        name = art.get("name")
-        if not name:
-            logical = strip_source_prefix(art.get("path", ""))
-            if logical is None:
-                continue
-            stem = Path(logical).stem
-            name = stem
-        rule_by_name[name] = art
-
-    for kname in sorted(kernel):
-        art = rule_by_name.get(kname)
-        if art is None:
-            errs.append(
-                f"kernel rule `{kname}` listed in router.json but no"
-                " matching artefact in manifest"
-            )
-            continue
-        level = (art.get("trust", {}) or {}).get("level")
-        if level != "core":
-            errs.append(
-                f"kernel rule `{kname}` has trust.level=`{level}`"
-                " — must be `core` (router.json kernel guarantees Iron-Law"
-                " floor)"
-            )
-    return errs
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--quiet", action="store_true")
-    parser.add_argument(
-        "--manifest", type=Path, default=MANIFEST, help="discovery manifest"
-    )
-    parser.add_argument(
-        "--router", type=Path, default=ROUTER, help="router.json with kernel[]"
-    )
-    parser.add_argument(
-        "--compiled-src",
-        type=Path,
-        default=COMPILED_SRC,
-        help="compiled output root (dist/agent-src/)",
-    )
-    args = parser.parse_args(argv)
-
-    manifest = _load_manifest(args.manifest)
-    kernel = _load_kernel(args.router)
-
-    errs: list[str] = []
-    errs.extend(_check_pack_safety_floors(manifest))
-    errs.extend(_check_human_review_banners(manifest, args.compiled_src))
-    errs.extend(_check_kernel_trust(manifest, kernel))
-
-    if errs:
-        for e in errs:
-            print(f"ERROR: {e}", file=sys.stderr)
-        print(
-            f"\n{len(errs)} trust-coherence violation(s) across"
-            f" {len(manifest.get('packs', []))} pack(s) and"
-            f" {len(manifest.get('artefacts', []))} artefact(s).",
-            file=sys.stderr,
-        )
-        return 1
-
-    if not args.quiet:
-        print(
-            "✅  lint-trust-coherence:"
-            f" {len(manifest.get('packs', []))} pack(s),"
-            f" {len(kernel)} kernel rule(s),"
-            f" {sum(1 for a in manifest.get('artefacts', []) if (a.get('trust') or {}).get('human_review_required'))}"
-            " HRR artefact(s) clean."
-        )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())