@event4u/agent-config 6.1.0 → 7.0.1

package/src/scripts/project_thin_rules.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""Thin-projection of the rule layer (lean-initial-context build-out, Phase 3.1).
-
-The dominant always-on cost is rule BODIES (~58k GPT tok; kernel only ~6.5k).
-0B.6 verdict: demote every non-kernel rule body to a progressive-disclosure
-pointer the agent resolves on trigger-match (the one mechanism 0B.5 confirmed
-works for the primary tool — like skills). The kernel stays full-bodied.
-
-A **thin** rule entry keeps the matching signal (frontmatter `description` +
-`triggers`) so the router still selects it, and replaces the body with a
-one-line pointer to the full text. The agent loads the body on match.
-
-This module is the mechanism + a measurement harness. It writes to a target
-dir of your choosing — it never overwrites the live `.claude/` / `.augment/`
-projections. condense.py reads `lean_projection.mode` (default `eager-all`)
-to decide whether the real generate-tools path calls in here; until that flag
-is flipped + live-A/B-validated, the default projection is unchanged.
-
-Usage:
-    python3 scripts/project_thin_rules.py --measure          # measure delta, no write
-    python3 scripts/project_thin_rules.py --out <dir>        # write thin rules to <dir>
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent.parent
-sys.path.insert(0, str(REPO_ROOT / "src" / "scripts"))
-from _lib import token_count  # noqa: E402
-
-RULES_SOURCE = REPO_ROOT / "dist/agent-src" / "rules"
-ROUTER = REPO_ROOT / "dist" / "router.json"
-
-
-def kernel_ids() -> set[str]:
-    """The always-full-bodied set — authoritative kernel list from the router."""
-    return set(json.loads(ROUTER.read_text(encoding="utf-8")).get("kernel", []))
-
-
-def split_frontmatter(text: str) -> tuple[str, str]:
-    """Return (frontmatter_including_fences, body). Empty fm if none."""
-    if text.startswith("---\n"):
-        end = text.find("\n---\n", 4)
-        if end != -1:
-            return text[: end + 5], text[end + 5 :]
-    return "", text
-
-
-def _description(fm: str) -> str:
-    m = re.search(r'^description:\s*"?(.+?)"?\s*$', fm, re.MULTILINE)
-    return m.group(1).strip() if m else ""
-
-
-# How many trigger keywords/phrases to surface as the always-on match hint.
-# The full trigger set lives in dist/router.json (compiled from source) — the
-# projected entry only needs enough signal for the agent to recognise a match
-# and load the body. The router, not this list, drives actual selection.
-_TRIGGER_HINT_LIMIT = 6
-
-
-def _trigger_hint(fm: str) -> str:
-    """A short, comma-joined sample of the rule's trigger keywords/phrases."""
-    hits: list[str] = []
-    for m in re.finditer(r'^\s*-\s*(?:keyword|phrase|intent):\s*"?(.+?)"?\s*$', fm, re.MULTILINE):
-        hits.append(m.group(1).strip())
-        if len(hits) >= _TRIGGER_HINT_LIMIT:
-            break
-    return ", ".join(hits)
-
-
-def thin_entry(rule_id: str, text: str) -> str:
-    """Build the minimal progressive-disclosure pointer for a non-kernel rule.
-
-    The always-on layer keeps only the match signal (description + a short
-    trigger hint) and a pointer to the full body — NOT the full frontmatter.
-    The router (dist/router.json, compiled from source) holds the complete
-    `triggers:` / `routes_to:`; selection is unchanged. Dropping the inlined
-    frontmatter is where the bulk of the token saving comes from.
-    """
-    fm, _body = split_frontmatter(text)
-    desc = _description(fm)
-    hint = _trigger_hint(fm)
-    title = rule_id.replace("-", " ").title()
-    fires = f" Fires on: {hint}." if hint else ""
-    return (
-        f"## {title}\n"
-        f"> Routed rule — load the body on trigger-match.{fires} {desc} "
-        f"Body: [`{rule_id}`](../../.agent-src.uncondensed/rules/{rule_id}.md)\n"
-    )
-
-
-def build_thin(rules_dir: Path = RULES_SOURCE) -> dict[str, str]:
-    """Map {filename: thin_or_full_text} for every rule. Kernel stays full."""
-    kernel = kernel_ids()
-    out: dict[str, str] = {}
-    for p in sorted(rules_dir.glob("*.md")):
-        text = p.read_text(encoding="utf-8")
-        out[p.name] = text if p.stem in kernel else thin_entry(p.stem, text)
-    return out
-
-
-def measure(rules_dir: Path = RULES_SOURCE) -> dict:
-    """Eager vs thin token footprint for the rule layer."""
-    kernel = kernel_ids()
-    eager_blob = "".join(
-        p.read_text(encoding="utf-8") for p in sorted(rules_dir.glob("*.md"))
-    )
-    thin_blob = "".join(build_thin(rules_dir).values())
-    eager = token_count.measure(eager_blob)
-    thin = token_count.measure(thin_blob)
-    n = len(list(rules_dir.glob("*.md")))
-    return {
-        "rules_total": n,
-        "kernel_full": len(kernel & {p.stem for p in rules_dir.glob("*.md")}),
-        "non_kernel_thinned": n - len(kernel & {p.stem for p in rules_dir.glob("*.md")}),
-        "eager_gpt": eager["tokens_gpt"],
-        "thin_gpt": thin["tokens_gpt"],
-        "saved_gpt": eager["tokens_gpt"] - thin["tokens_gpt"],
-        "saved_pct": round(
-            100 * (eager["tokens_gpt"] - thin["tokens_gpt"]) / eager["tokens_gpt"], 1
-        )
-        if eager["tokens_gpt"]
-        else 0.0,
-        "eager_chars": eager["chars"],
-        "thin_chars": thin["chars"],
-        "token_method": token_count.method_note(),
-    }
-
-
-def write_thin(out_dir: Path, rules_dir: Path = RULES_SOURCE) -> int:
-    out_dir.mkdir(parents=True, exist_ok=True)
-    files = build_thin(rules_dir)
-    for name, text in files.items():
-        (out_dir / name).write_text(text, encoding="utf-8")
-    return len(files)
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    ap.add_argument("--measure", action="store_true", help="print the eager-vs-thin token delta")
-    ap.add_argument("--out", type=Path, help="write thin rule files to this dir")
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args(argv)
-
-    if args.out:
-        n = write_thin(args.out)
-        print(f"wrote {n} thin rule files → {args.out}")
-        return 0
-
-    m = measure()
-    if args.json:
-        print(json.dumps(m, indent=2, sort_keys=True))
-    else:
-        print(f"Rule-layer thin projection (kernel full-bodied + {m['non_kernel_thinned']} non-kernel pointers):")
-        print(f"  eager: {m['eager_gpt']:>6} GPT tok ({m['eager_chars']:,} chars)")
-        print(f"  thin:  {m['thin_gpt']:>6} GPT tok ({m['thin_chars']:,} chars)")
-        print(f"  saved: {m['saved_gpt']:>6} GPT tok  ({m['saved_pct']}% of the rule layer)")
-        print(f"  method: {m['token_method']}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/propose_modules_config.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""Propose a ``modules:`` block for ``.agent-project-settings.yml``.
-
-Phase B Step 2 of road-to-configurable-modules. Wraps the pure
-:mod:`scripts._lib.module_detection` helper in a CLI surface that the
-installer, the GUI wizard, and the ``/agents init`` command can all call
-without re-implementing the detection table.
-
-Usage:
-    python3 scripts/propose_modules_config.py                  # interactive
-    python3 scripts/propose_modules_config.py --json           # machine-readable
-    python3 scripts/propose_modules_config.py --project <path> # custom root
-
-Exit codes:
-    0 — candidates surfaced (or none found, with ``modules.enabled: false``)
-    2 — invalid arguments / unreachable path
-
-The CLI never writes files. Callers consume the JSON / TTY output and
-patch ``.agent-project-settings.yml`` themselves (preserves comments +
-ordering per the layered-settings contract).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-# Re-export so consumers can import either path.
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from scripts._lib.module_detection import (  # noqa: E402
-    ModuleCandidate,
-    detect_module_roots,
-)
-
-
-def _candidate_to_dict(cand: ModuleCandidate) -> dict[str, str]:
-    return {
-        "path": cand.path,
-        "stack": cand.stack,
-        "namespace_template_guess": cand.namespace_template_guess,
-        "confidence": cand.confidence,
-    }
-
-
-def _render_interactive(candidates: list[ModuleCandidate]) -> None:
-    """Print a numbered-options block — the same shape ``/agents init`` shows."""
-    if not candidates:
-        print("⚠️  No module roots detected.")
-        print()
-        print(
-            "Skipping `modules:` config. Re-run after adding a module "
-            "directory (app/Modules/, src/Module/, packages/, internal/, ...)."
-        )
-        return
-    print("📦 Detected module-root candidates:")
-    print()
-    print("  #  Path              Stack            Confidence  Namespace template")
-    print("  ─  ────────────────  ───────────────  ──────────  ────────────────────")
-    for idx, cand in enumerate(candidates, start=1):
-        ns = cand.namespace_template_guess or "—"
-        print(
-            f"  {idx:>1}  {cand.path:<16}  {cand.stack:<15}"
-            f"  {cand.confidence:<10}  {ns}"
-        )
-    print()
-    print("Suggested `modules:` block (paste into .agent-project-settings.yml):")
-    print()
-    print("modules:")
-    print("  enabled: true")
-    print(f"  root_paths: [{', '.join(c.path for c in candidates)}]")
-    primary_ns = next(
-        (c.namespace_template_guess for c in candidates
-         if c.namespace_template_guess),
-        "",
-    )
-    if primary_ns:
-        print(f"  namespace_template: '{primary_ns}'")
-    else:
-        print("  # namespace_template: ''  # stack has no PHP-style namespace")
-    print("  agent_folder: agents")
-    print("  skip_dirs: [.module-template, .example]")
-
-
-def _resolve_project_root(arg: str | None) -> Path:
-    if arg:
-        root = Path(arg).expanduser().resolve()
-    else:
-        root = Path.cwd().resolve()
-    if not root.is_dir():
-        print(
-            f"error: project root is not a directory: {root}",
-            file=sys.stderr,
-        )
-        sys.exit(2)
-    return root
-
-
-def main(argv: list[str]) -> int:
-    parser = argparse.ArgumentParser(
-        prog="propose_modules_config.py",
-        description=(
-            "Detect module-root candidates and propose a `modules:` block "
-            "for .agent-project-settings.yml. Pure read-only scan."
-        ),
-    )
-    parser.add_argument(
-        "--project",
-        default=None,
-        help="project root (default: cwd)",
-    )
-    parser.add_argument(
-        "--json",
-        action="store_true",
-        help="emit machine-readable JSON instead of the TTY table",
-    )
-    args = parser.parse_args(argv)
-    root = _resolve_project_root(args.project)
-    candidates = detect_module_roots(root)
-    if args.json:
-        payload = {
-            "project_root": str(root),
-            "candidates": [_candidate_to_dict(c) for c in candidates],
-            "proposed_block": {
-                "enabled": bool(candidates),
-                "root_paths": [c.path for c in candidates],
-                "namespace_template": next(
-                    (c.namespace_template_guess for c in candidates
-                     if c.namespace_template_guess),
-                    "",
-                ),
-                "agent_folder": "agents",
-                "skip_dirs": [".module-template", ".example"],
-            },
-        }
-        json.dump(payload, sys.stdout, indent=2)
-        sys.stdout.write("\n")
-        return 0
-    _render_interactive(candidates)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/src/scripts/prototype_lint_contradictions.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-"""
-Prototype contradiction linter (P1.1 of road-to-package-optimization).
-
-Hard acceptance: must flag >=3 real cross-artifact contradictions in this
-repo within 5 s wall-clock and < $0.01 cost (deterministic, no LLM calls).
-On failure, the roadmap closes with the null result documented; no
-Phase 2 work begins.
-
-Heuristic family — three deterministic checks across rules, skills,
-commands, and contexts:
-
-1. Routing mismatch: rule frontmatter `routes_to: [skill:foo]` but the
-   target artifact does not exist or has no matching trigger.
-2. Trigger collision with imperative conflict: two artifacts share a
-   trigger keyword AND one body contains an `ALWAYS X` Iron Law while
-   the other contains `NEVER X` (or `MUST` vs `MUST NOT`) on the same
-   verb-object.
-3. Catalog drift: a token-optimizer-style catalog row cites a path that
-   does not exist (subset of #1, broader scope than the freshness gate).
-
-Stdlib only. JSON to stdout. Exit 0 = clean / Exit 1 = contradictions found.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sys
-import time
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parent.parent.parent
-SRC = REPO / ".agent-src.uncondensed"
-
-ARTIFACT_DIRS = {
-    "rule": SRC / "rules",
-    "skill": SRC / "skills",
-    "command": SRC / "commands",
-    "context": SRC / "contexts",
-}
-
-FM_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
-ALWAYS_RE = re.compile(r"^\s*(ALWAYS|MUST)\s+([A-Z][^.\n]{2,80})", re.MULTILINE)
-NEVER_RE = re.compile(r"^\s*(NEVER|MUST NOT|DO NOT)\s+([A-Z][^.\n]{2,80})", re.MULTILINE)
-
-
-def parse_artifact(path: Path, kind: str) -> dict:
-    text = path.read_text(encoding="utf-8", errors="replace")
-    fm: dict = {}
-    m = FM_RE.match(text)
-    body = text
-    if m:
-        body = text[m.end():]
-        for line in m.group(1).splitlines():
-            if ":" in line and not line.startswith(" "):
-                k, _, v = line.partition(":")
-                fm[k.strip()] = v.strip()
-    triggers = re.findall(r"`([a-z][a-z0-9_-]+)`", fm.get("description", ""))
-    routes = re.findall(r"(skill|rule|command):([a-z0-9_-]+)", fm.get("routes_to", ""))
-    always = [m.group(2).strip() for m in ALWAYS_RE.finditer(body)]
-    never = [m.group(2).strip() for m in NEVER_RE.finditer(body)]
-    return {
-        "kind": kind,
-        "path": str(path.relative_to(REPO)),
-        "id": path.stem if path.name != "SKILL.md" else path.parent.name,
-        "triggers": set(triggers),
-        "routes": routes,
-        "always": always,
-        "never": never,
-    }
-
-
-def collect() -> list[dict]:
-    out: list[dict] = []
-    for kind, root in ARTIFACT_DIRS.items():
-        if not root.exists():
-            continue
-        for p in root.rglob("*.md"):
-            if p.name in {"README.md", "INDEX.md"}:
-                continue
-            out.append(parse_artifact(p, kind))
-    return out
-
-
-def check_routing(arts: list[dict]) -> list[dict]:
-    by_id = {(a["kind"], a["id"]): a for a in arts}
-    flags: list[dict] = []
-    for a in arts:
-        for tgt_kind, tgt_id in a["routes"]:
-            if (tgt_kind, tgt_id) not in by_id:
-                flags.append({
-                    "type": "routing_mismatch",
-                    "artifact_a": a["path"],
-                    "artifact_b": f"{tgt_kind}:{tgt_id} (missing)",
-                    "evidence": f"{a['id']} routes_to {tgt_kind}:{tgt_id}, target not found",
-                })
-    return flags
-
-
-def normalize_verb(s: str) -> str:
-    return re.sub(r"[^a-z ]+", "", s.lower()).split(" ", 1)[0] if s else ""
-
-
-def check_imperative_conflict(arts: list[dict]) -> list[dict]:
-    flags: list[dict] = []
-    by_trigger: dict[str, list[dict]] = {}
-    for a in arts:
-        for t in a["triggers"]:
-            by_trigger.setdefault(t, []).append(a)
-    for trigger, group in by_trigger.items():
-        if len(group) < 2:
-            continue
-        for i, a in enumerate(group):
-            for b in group[i + 1:]:
-                a_verbs = {normalize_verb(s) for s in a["always"]}
-                b_verbs = {normalize_verb(s) for s in b["never"]}
-                conflict = a_verbs & b_verbs - {""}
-                if conflict:
-                    flags.append({
-                        "type": "imperative_conflict",
-                        "artifact_a": a["path"],
-                        "artifact_b": b["path"],
-                        "evidence": f"shared trigger '{trigger}', a says ALWAYS {sorted(conflict)}, b says NEVER {sorted(conflict)}",
-                    })
-    return flags
-
-
-def main() -> int:
-    t0 = time.monotonic()
-    arts = collect()
-    flags = check_routing(arts) + check_imperative_conflict(arts)
-    elapsed = time.monotonic() - t0
-    report = {
-        "artifacts_scanned": len(arts),
-        "elapsed_seconds": round(elapsed, 3),
-        "flags": flags,
-        "acceptance": {
-            "min_flags": 3,
-            "max_seconds": 5.0,
-            "passed": len(flags) >= 3 and elapsed < 5.0,
-        },
-    }
-    json.dump(report, sys.stdout, indent=2)
-    sys.stdout.write("\n")
-    return 0 if not flags else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/prove_pack_extractable.py

@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-"""Prove a pack + its declared dependency closure is self-contained.
-
-road-to-6.0.0-D Phase 1 Step 6 — the *extraction proof*. It de-risks the
-monorepo collapse (Phase 3) by proving that a pack moved into the flat
-``src/`` library can still be lifted back out into a standalone package:
-every artefact the pack references must live inside the pack's own
-``requires`` closure (plus the always-available foundation packs). A
-reference that points OUTSIDE the closure is a dangling edge — the slice
-would not build standalone, so re-split is no longer possible.
-
-What "its own tests pass" means for a markdown artefact library: the
-isolated slice has (1) zero dangling skill/rule references in frontmatter,
-(2) zero dangling markdown links into the artefact library, and (3) a
-``pack.yaml`` whose ``requires`` graph stays acyclic within the closure.
-Those are the structural invariants the per-pack CI gates assert; proving
-them on the isolated closure is the standalone-build proof.
-
-Usage:
-  python3 scripts/prove_pack_extractable.py <pack-id> [--json]
-
-Exit codes: 0 = extractable · 1 = dangling reference(s) · 3 = unknown pack.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-import yaml
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _lib import agent_src  # noqa: E402
-
-ROOT = Path(__file__).resolve().parents[2]
-PACKS_VOCAB = ROOT / "src" / "config" / "discovery" / "packs.yml"
-# Always-available foundation packs: every pack may reference these without
-# declaring them in `requires` (the 6.0.0-D council's resolution of the
-# ambiguous "core" in the boundary rule — engineering-base + meta are the
-# implicit foundation, alongside the legacy physical `core`).
-FOUNDATION = {"core", "engineering-base", "meta"}
-_LINK_RE = re.compile(r"\]\(([^)#?]+\.md)(?:[#?][^)]*)?\)")
-
-
-def _frontmatter(path: Path) -> dict:
-    text = path.read_text("utf-8", errors="replace")
-    if not text.startswith("---"):
-        return {}
-    end = text.find("\n---", 4)
-    if end == -1:
-        return {}
-    try:
-        data = yaml.safe_load(text[4:end])
-    except yaml.YAMLError:
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def _pack_requires() -> dict[str, set[str]]:
-    """Map pack id -> direct `requires` set, from the discovery vocab."""
-    graph: dict[str, set[str]] = {}
-    vocab = yaml.safe_load(PACKS_VOCAB.read_text("utf-8")) or []
-    for entry in vocab:
-        if isinstance(entry, dict) and isinstance(entry.get("id"), str):
-            graph[entry["id"]] = set(entry.get("requires") or [])
-    return graph
-
-
-def _closure(pack: str, graph: dict[str, set[str]]) -> set[str]:
-    """Transitive `requires` closure of ``pack`` (inclusive) + foundation."""
-    seen: set[str] = set()
-    stack = [pack]
-    while stack:
-        p = stack.pop()
-        if p in seen:
-            continue
-        seen.add(p)
-        stack.extend(graph.get(p, set()) - seen)
-    return seen | FOUNDATION
-
-
-def _library_index() -> tuple[dict[str, set[str]], dict[str, set[str]]]:
-    """Build (slug_to_packs, logicalpath_to_packs) over the flat library."""
-    slug_packs: dict[str, set[str]] = {}
-    path_packs: dict[str, set[str]] = {}
-    for phys, logical in agent_src.iter_all_sources():
-        if not logical.endswith(".md"):
-            continue
-        fm = _frontmatter(phys)
-        packs = set(p for p in (fm.get("packs") or []) if isinstance(p, str))
-        if not packs:
-            continue
-        path_packs[logical] = packs
-        if logical.startswith("skills/") and logical.endswith("/SKILL.md"):
-            slug_packs[logical.split("/")[1]] = packs
-        elif logical.startswith("rules/"):
-            slug_packs[logical[len("rules/"):-len(".md")]] = packs
-    return slug_packs, path_packs
-
-
-def prove(pack: str) -> tuple[bool, list[str], list[str], set[str]]:
-    """Return (extractable, hard_dangling, advisory_warnings, closure).
-
-    The dependency axis is frontmatter (6.0.0-D council convergence): a
-    HARD edge is a ``skills:`` / ``rules:`` include — it must resolve inside
-    the closure or the standalone slice fails to build. A markdown link into
-    another pack is an ADVISORY cross-reference (a "route to" / "see also")
-    — it is reported as a warning but does NOT block extraction, because the
-    skill still functions when the linked alternative is simply not installed.
-    """
-    graph = _pack_requires()
-    if pack not in graph:
-        return False, [f"unknown pack id '{pack}' (not in {PACKS_VOCAB})"], [], set()
-    closure = _closure(pack, graph)
-    slug_packs, path_packs = _library_index()
-
-    def in_closure(packs: set[str]) -> bool:
-        return bool(packs & closure)
-
-    hard: list[str] = []
-    advisory: list[str] = []
-    members = [(logical, phys) for phys, logical in agent_src.iter_all_sources()
-               if logical.endswith(".md") and pack in path_packs.get(logical, set())]
-    for logical, phys in members:
-        fm = _frontmatter(phys)
-        # (1) HARD: frontmatter skill/rule includes — the build-dependency axis
-        for slug in (fm.get("skills") or []) + (fm.get("rules") or []):
-            if not isinstance(slug, str):
-                continue
-            target = slug_packs.get(slug)
-            if target is None:
-                continue  # command-routing target / non-library slug — not a pack edge
-            if not in_closure(target):
-                hard.append(
-                    f"{logical}: include '{slug}' lives in {sorted(target)} — outside closure")
-        # (2) ADVISORY: markdown links into the artefact library
-        for raw in _LINK_RE.findall(phys.read_text("utf-8", errors="replace")):
-            tgt = agent_src.strip_source_prefix(raw) or _resolve_rel(phys, raw)
-            if tgt is None or tgt not in path_packs:
-                continue
-            if not in_closure(path_packs[tgt]):
-                advisory.append(
-                    f"{logical}: advisory link → {tgt} ({sorted(path_packs[tgt])}) — "
-                    f"not installed when '{pack}' is extracted alone")
-    return (not hard), hard, advisory, closure
-
-
-def _resolve_rel(source: Path, raw: str) -> str | None:
-    try:
-        resolved = (source.parent / raw).resolve()
-        rel = resolved.relative_to(ROOT).as_posix()
-    except (OSError, ValueError):
-        return None
-    return agent_src.strip_source_prefix(rel)
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("pack", help="pack id (e.g. laravel)")
-    ap.add_argument("--json", action="store_true")
-    args = ap.parse_args()
-    ok, hard, advisory, closure = prove(args.pack)
-    if not closure:
-        print(f"❌  {hard[0]}", file=sys.stderr)
-        return 3
-    if args.json:
-        json.dump({"pack": args.pack, "extractable": ok,
-                   "closure": sorted(closure), "hard_dangling": hard,
-                   "advisory": advisory}, sys.stdout, indent=2)
-        sys.stdout.write("\n")
-    elif ok:
-        print(f"✅  '{args.pack}' is extractable — closure {sorted(closure)}, "
-              f"0 hard dangling references.")
-        for a in advisory:
-            print(f"   ⚠️  {a}")
-    else:
-        for d in hard:
-            print(f"❌  {d}", file=sys.stderr)
-        print(f"\n{len(hard)} hard dangling reference(s) — '{args.pack}' is NOT "
-              f"standalone-extractable.", file=sys.stderr)
-    return 0 if ok else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())