@event4u/agent-config 5.10.1 → 6.0.0

package/scripts/inventory_frontmatter.py

@@ -1,164 +0,0 @@
-#!/usr/bin/env python3
-"""
-Inventory frontmatter keys across all agent artefacts.
-
-Reads .agent-src.uncondensed/{skills,rules,commands,personas}, parses the
-YAML frontmatter of every file, and prints per-type:
-
-- total file count
-- every key observed, with count and percentage
-- sample values (up to 3) per key
-
-Output is Markdown on stdout, intended to be captured into
-`agents/reference/docs/frontmatter-contract.md` as raw material for Phase 1 of the
-frontmatter-schema roadmap.
-
-Stdlib-only. No PyYAML — we do a simple line-based parse sufficient for
-our frontmatter shapes (flat keys, inline lists, block lists, one nested
-`execution:` block).
-"""
-
-from __future__ import annotations
-
-import re
-import sys
-from collections import Counter, defaultdict
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-SRC = ROOT / ".agent-src.uncondensed"
-
-FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
-
-
-def extract_frontmatter(text: str) -> str | None:
-    match = FRONTMATTER_RE.search(text)
-    return match.group(1) if match else None
-
-
-def parse_frontmatter_keys(fm: str) -> dict[str, str]:
-    """Return a flat {key: raw_value_string} for a frontmatter block.
-
-    For nested blocks (e.g. `execution:`), the nested keys are flattened
-    with a dot notation: `execution.type`, `execution.handler`, etc.
-    Inline lists (`personas: [a, b]`) and block lists (`- a\n- b`) are
-    rendered as their raw value.
-    """
-    result: dict[str, str] = {}
-    lines = fm.splitlines()
-    i = 0
-    current_nested: str | None = None
-    current_list_key: str | None = None
-    list_buffer: list[str] = []
-
-    def flush_list() -> None:
-        nonlocal current_list_key, list_buffer
-        if current_list_key is not None:
-            result[current_list_key] = "[" + ", ".join(list_buffer) + "]"
-        current_list_key = None
-        list_buffer = []
-
-    while i < len(lines):
-        line = lines[i]
-        stripped = line.strip()
-
-        if not stripped or stripped.startswith("#"):
-            i += 1
-            continue
-
-        # Top-level key (no leading whitespace)
-        if line and not line[0].isspace():
-            flush_list()
-            current_nested = None
-            m = re.match(r"^([\w-]+):\s*(.*?)\s*$", line)
-            if m:
-                key, value = m.group(1), m.group(2)
-                if value == "" or value == "|":
-                    # Could start a nested block OR a list. Look ahead.
-                    nxt = lines[i + 1].strip() if i + 1 < len(lines) else ""
-                    if nxt.startswith("- "):
-                        current_list_key = key
-                    else:
-                        current_nested = key
-                        result[key] = "{nested}"
-                else:
-                    result[key] = value
-        # Nested (indented) key
-        elif current_nested is not None:
-            m = re.match(r"^\s+([\w-]+):\s*(.*?)\s*$", line)
-            if m:
-                key, value = m.group(1), m.group(2)
-                result[f"{current_nested}.{key}"] = value or "{nested}"
-        # Block list item
-        elif current_list_key is not None and stripped.startswith("- "):
-            list_buffer.append(stripped[2:].strip())
-
-        i += 1
-
-    flush_list()
-    return result
-
-
-def gather_files(artefact_dir: Path, pattern: str) -> list[Path]:
-    if not artefact_dir.exists():
-        return []
-    files = [f for f in artefact_dir.rglob(pattern) if not f.is_symlink()]
-    return sorted(files)
-
-
-def inventory_type(name: str, files: list[Path]) -> None:
-    total = len(files)
-    print(f"### {name} — {total} files\n")
-    if total == 0:
-        print("_(no files)_\n")
-        return
-
-    key_counts: Counter[str] = Counter()
-    key_value_counts: dict[str, Counter[str]] = defaultdict(Counter)
-
-    for f in files:
-        text = f.read_text(encoding="utf-8")
-        fm = extract_frontmatter(text)
-        if fm is None:
-            continue
-        parsed = parse_frontmatter_keys(fm)
-        for k, v in parsed.items():
-            key_counts[k] += 1
-            # Record distinct values for enum detection; truncate to keep
-            # the table readable and strip surrounding quotes.
-            normalized = v.strip('"').strip("'")[:80] if v else "{empty}"
-            key_value_counts[k][normalized] += 1
-
-    print("| key | count | % | status | distinct values (count) |")
-    print("|---|---:|---:|---|---|")
-    for key, count in sorted(key_counts.items(), key=lambda kv: (-kv[1], kv[0])):
-        pct = count * 100 // total
-        status = "required" if pct >= 95 else "optional"
-        values = key_value_counts[key]
-        if len(values) <= 8:
-            rendered = " · ".join(f"`{val}` ({n})" for val, n in values.most_common())
-        else:
-            top = values.most_common(5)
-            rendered = " · ".join(f"`{val}` ({n})" for val, n in top)
-            rendered += f" · … +{len(values) - 5} more"
-        print(f"| `{key}` | {count} | {pct}% | {status} | {rendered} |")
-    print()
-
-
-def main() -> int:
-    print("# Frontmatter inventory (generated)\n")
-    print("Generated by `scripts/inventory_frontmatter.py`. Raw material for")
-    print("Phase 1 of the frontmatter-schema roadmap. Do not edit by hand.\n")
-
-    inventory_type("skills", gather_files(SRC / "skills", "SKILL.md"))
-    inventory_type("rules", gather_files(SRC / "rules", "*.md"))
-    inventory_type("commands", gather_files(SRC / "commands", "*.md"))
-    inventory_type("personas", [
-        f for f in gather_files(SRC / "personas", "*.md")
-        if f.name.lower() != "readme.md"
-    ])
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/inventory_meta_layers.py

@@ -1,288 +0,0 @@
-"""Meta-layer / concept-surface inventory — read-only discovery pass.
-
-Drives Phase 1 of `agents/roadmaps/road-to-leaner-core-and-discovery.md`.
-Sibling to `scripts/inventory_abstraction_budget.py`: that tool counts
-per-artefact references + frontmatter bloat; this one inventories the
-*concept surface* the post-5.x feedback names as meta-complexity.
-
-For each concept it emits one row:
-    concept · surfaces it lives in · line cost · last-touched · overlap candidates
-
-Concept = a normalized token shared by ≥ 2 stable artefacts (a rule, a
-contract, a guideline, or a context) — i.e. a single idea defined in
-more than one surface. Plus the curated meta-layer families the
-feedback names explicitly (iron-laws, value, roadmap, linked-projects,
-marketplace, governance). Also tabulates always-loaded rule families
-(kernel) + Iron-Law count per rule.
-
-Output: agents/evidence/analysis/meta-layer-inventory.md (+ .csv)
-Read-only. Touches no abstraction file.
-
-Usage:
-    python3 scripts/inventory_meta_layers.py [--quiet]
-"""
-from __future__ import annotations
-
-import argparse
-import csv
-import json
-import re
-import subprocess
-from collections import defaultdict
-from dataclasses import dataclass, field
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = REPO_ROOT / ".agent-src" / "rules"
-CONTRACTS_DIR = REPO_ROOT / "docs" / "contracts"
-GUIDELINES_DIR = REPO_ROOT / "docs" / "guidelines"
-CONTEXTS_DIR = REPO_ROOT / ".agent-src" / "contexts"
-ROUTER = REPO_ROOT / "dist" / "router.json"
-EVIDENCE_DIR = REPO_ROOT / "agents" / "evidence" / "analysis"
-
-IRON_LAW_RE = re.compile(r"^#{1,3}\s+(?:The\s+)?Iron\s+Laws?\b", re.IGNORECASE | re.MULTILINE)
-
-# Generic filename tokens that carry no concept identity — dropped before grouping.
-STOPWORDS = {
-    "rule", "rules", "contract", "contracts", "mechanics", "policy", "schema",
-    "config", "v1", "v2", "and", "the", "of", "for", "to", "in", "on", "a",
-    "adr", "model", "spec", "format", "default", "defaults", "system", "examples",
-    "demos", "writing", "patterns", "auto", "core", "base",
-}
-
-# Curated meta-layer families the feedback names (always emitted as rows).
-SEED_FAMILIES = ["iron", "value", "roadmap", "linked", "marketplace", "governance", "council"]
-
-
-@dataclass
-class Surface:
-    path: Path
-    kind: str  # rule | contract | guideline | context
-    lines: int
-    tokens: set[str] = field(default_factory=set)
-
-    @property
-    def rel(self) -> str:
-        return str(self.path.relative_to(REPO_ROOT))
-
-
-def _last_touched(path: Path) -> str:
-    try:
-        out = subprocess.run(
-            ["git", "log", "-1", "--format=%ad", "--date=short", "--", str(path)],
-            cwd=REPO_ROOT, capture_output=True, text=True, check=False, timeout=10,
-        )
-        return out.stdout.strip() or "untracked"
-    except Exception:
-        return "unknown"
-
-
-def _tokens(stem: str) -> set[str]:
-    return {t for t in re.split(r"[-_]", stem.lower()) if t and t not in STOPWORDS and len(t) > 2}
-
-
-def _collect(directory: Path, kind: str) -> list[Surface]:
-    out: list[Surface] = []
-    if not directory.exists():
-        return out
-    for p in sorted(directory.rglob("*.md")):
-        if p.name == "README.md":
-            continue
-        text = p.read_text(encoding="utf-8", errors="replace")
-        out.append(Surface(p, kind, text.count("\n") + 1, _tokens(p.stem)))
-    return out
-
-
-def _kernel_and_tiers() -> dict[str, int | list[str]]:
-    if not ROUTER.exists():
-        return {"kernel": [], "tier_1": 0, "tier_2": 0}
-    d = json.loads(ROUTER.read_text(encoding="utf-8"))
-    return {
-        "kernel": d.get("kernel", []),
-        "tier_1": d.get("tier_1", 0) if isinstance(d.get("tier_1"), int) else len(d.get("tier_1", [])),
-        "tier_2": d.get("tier_2", 0) if isinstance(d.get("tier_2"), int) else len(d.get("tier_2", [])),
-    }
-
-
-def _iron_law_counts() -> dict[str, int]:
-    counts: dict[str, int] = {}
-    for p in sorted(RULES_DIR.glob("*.md")):
-        text = p.read_text(encoding="utf-8", errors="replace")
-        n = len(IRON_LAW_RE.findall(text))
-        if n:
-            counts[p.stem] = n
-    return counts
-
-
-def _stack(s: Surface) -> str:
-    """Concern stack a surface belongs to. PHP coding guidelines are a
-    different domain from agent-behaviour rules/contracts — a shared topic
-    word (`git`, `security`) between them is coincidence, not duplication.
-    """
-    return "php" if "/guidelines/php/" in s.rel.replace("\\", "/") else "agent"
-
-
-def _same_concept(a: Surface, b: Surface) -> bool:
-    """Genuine concept duplication, not topic adjacency.
-
-    True when one stem is a prefix of the other (the rule→mechanics/examples
-    split — `language-and-tone` ⊂ `language-and-tone-examples`), OR the two
-    stems share ≥ 2 significant tokens (a tight family like `domain-safety-*`).
-    Single shared topic token (`skill`, `command`, `agent`) is NOT enough.
-
-    Cross-stack guard (Phase-1 council namespace-hygiene, 2026-05-30): a PHP
-    coding guideline and an agent rule/contract that merely share one topic
-    word (`git`, `security`) are distinct concerns — only group them on a
-    near-identical stem (prefix containment), never on a lone shared token.
-    """
-    sa, sb = a.path.stem.lower(), b.path.stem.lower()
-    short, long = (sa, sb) if len(sa) <= len(sb) else (sb, sa)
-    # Containment only counts when the prefix is itself a multi-token concept
-    # (`language-and-tone` ⊂ `…-examples`), never a generic single word
-    # (`git` ⊂ `git-history-discipline` is coincidence, not duplication).
-    if short != long and long.startswith(short + "-") and len(_tokens(short)) >= 2:
-        return True
-    if _stack(a) != _stack(b):
-        return False
-    return len(a.tokens & b.tokens) >= 2
-
-
-def _concept_rows(surfaces: list[Surface]) -> list[dict]:
-    # Union-find over the genuine-duplication adjacency.
-    parent = list(range(len(surfaces)))
-
-    def find(i: int) -> int:
-        while parent[i] != i:
-            parent[i] = parent[parent[i]]
-            i = parent[i]
-        return i
-
-    def union(i: int, j: int) -> None:
-        parent[find(i)] = find(j)
-
-    for i in range(len(surfaces)):
-        for j in range(i + 1, len(surfaces)):
-            if _same_concept(surfaces[i], surfaces[j]):
-                union(i, j)
-
-    comps: dict[int, list[Surface]] = defaultdict(list)
-    for idx, s in enumerate(surfaces):
-        comps[find(idx)].append(s)
-
-    rows: list[dict] = []
-    for group in comps.values():
-        if len(group) < 2:
-            continue
-        kinds = {s.kind for s in group}
-        # Concept label = the most-common significant token shared across the group.
-        tok_freq: dict[str, int] = defaultdict(int)
-        for s in group:
-            for t in s.tokens:
-                tok_freq[t] += 1
-        shared = [t for t, n in tok_freq.items() if n == len(group)] or [max(tok_freq, key=tok_freq.get)]
-        label = "-".join(sorted(shared)[:2])
-        seeded = any(any(t.startswith(f) or f.startswith(t) for f in SEED_FAMILIES) for t in shared)
-        cross_kind = len(kinds) >= 2
-        contract_dup = sum(1 for s in group if s.kind == "contract") >= 2
-        line_cost = sum(s.lines for s in group)
-        touched = max((_last_touched(s.path) for s in group), default="unknown")
-        rows.append({
-            "concept": label,
-            "surfaces": "; ".join(s.rel for s in sorted(group, key=lambda x: x.rel)),
-            "surface_count": len(group),
-            "kinds": ",".join(sorted(kinds)),
-            "line_cost": line_cost,
-            "last_touched": touched,
-            "overlap": "Y" if (cross_kind or contract_dup) else "family",
-            "seeded": "Y" if seeded else "",
-        })
-    rows.sort(key=lambda r: (-r["surface_count"], -r["line_cost"]))
-    return rows
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description="Meta-layer / concept-surface inventory (read-only).")
-    ap.add_argument("--quiet", action="store_true")
-    args = ap.parse_args(argv)
-
-    surfaces = (
-        _collect(RULES_DIR, "rule")
-        + _collect(CONTRACTS_DIR, "contract")
-        + _collect(GUIDELINES_DIR, "guideline")
-        + _collect(CONTEXTS_DIR, "context")
-    )
-    tiers = _kernel_and_tiers()
-    iron = _iron_law_counts()
-    rows = _concept_rows(surfaces)
-
-    EVIDENCE_DIR.mkdir(parents=True, exist_ok=True)
-    md = EVIDENCE_DIR / "meta-layer-inventory.md"
-    csv_path = EVIDENCE_DIR / "meta-layer-inventory.csv"
-
-    kernel = tiers["kernel"]
-    overlap_count = sum(1 for r in rows if r["overlap"] == "Y")
-    iron_total = sum(iron.values())
-
-    lines = [
-        "# Meta-Layer / Concept-Surface Inventory",
-        "",
-        "> Read-only discovery output for `agents/roadmaps/road-to-leaner-core-and-discovery.md` Phase 1.",
-        "> Counts are grep/git-backed via `scripts/inventory_meta_layers.py`. A row is an *overlap candidate*",
-        "> when one concept (a shared filename token) is defined across ≥ 2 stable surfaces.",
-        "",
-        "## Summary",
-        "",
-        "| Metric | Value |",
-        "|---|---:|",
-        f"| Always-loaded kernel rule families | {len(kernel)} |",
-        f"| tier_1 (balanced) rules | {tiers['tier_1']} |",
-        f"| tier_2 (full) rules | {tiers['tier_2']} |",
-        f"| Rules carrying Iron-Law headings | {len(iron)} |",
-        f"| Total Iron-Law headings across rules | {iron_total} |",
-        f"| Concept surfaces scanned (rule/contract/guideline/context) | {len(surfaces)} |",
-        f"| Concept overlap candidates (≥ 2 surfaces, cross-kind/contract-dup) | {overlap_count} |",
-        "",
-        f"Kernel: {', '.join(kernel)}",
-        "",
-        "## Iron-Law density per rule (top 15)",
-        "",
-        "| Rule | Iron Laws |",
-        "|---|---:|",
-    ]
-    for stem, n in sorted(iron.items(), key=lambda kv: -kv[1])[:15]:
-        lines.append(f"| `{stem}` | {n} |")
-
-    lines += [
-        "",
-        "## Concept-overlap ledger",
-        "",
-        "> One row per concept defined in ≥ 2 surfaces. `overlap=Y` = cross-kind or duplicate-contract",
-        "> (genuine merge/delete candidate). `seeded` = a feedback-named meta-layer family.",
-        "> Classification (merge / delete / keep-with-reason) is filled in Step 2 — left blank here.",
-        "",
-        "| Concept | Surfaces | # | Kinds | Lines | Last touched | Overlap | Class |",
-        "|---|---|---:|---|---:|---|---|---|",
-    ]
-    for r in rows:
-        lines.append(
-            f"| `{r['concept']}` | {r['surfaces']} | {r['surface_count']} | {r['kinds']} | "
-            f"{r['line_cost']} | {r['last_touched']} | {r['overlap']} | _unclassified_ |"
-        )
-    lines.append("")
-    md.write_text("\n".join(lines), encoding="utf-8")
-
-    with csv_path.open("w", newline="", encoding="utf-8") as fh:
-        w = csv.DictWriter(fh, fieldnames=["concept", "surface_count", "kinds", "line_cost", "last_touched", "overlap", "seeded", "surfaces"])
-        w.writeheader()
-        for r in rows:
-            w.writerow(r)
-
-    if not args.quiet:
-        print(f"meta-layer inventory: {len(surfaces)} surfaces, {len(rows)} concept rows, {overlap_count} overlap candidates")
-        print(f"  → {md.relative_to(REPO_ROOT)}")
-        print(f"  → {csv_path.relative_to(REPO_ROOT)}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/scripts/iron_law_sha.py

@@ -1,107 +0,0 @@
-#!/usr/bin/env python3
-"""SHA-256 of every triple-fence block in a rule file (Iron Law preservation).
-
-Usage:
-  python3 scripts/iron_law_sha.py <rule-id> [<rule-id> ...]
-  python3 scripts/iron_law_sha.py --all-kernel
-  python3 scripts/iron_law_sha.py --diff <rule-id> --against <baseline-sha>
-
-The Iron-Law block is delimited by triple-backtick fences. Every line
-inside any fence in the file is concatenated, whitespace-normalised
-(runs of spaces collapsed; leading / trailing whitespace stripped per
-line), case-folded, then SHA-256-hashed. Empty fences hash to
-SHA-256(''), which is `e3b0c442…` (the well-known empty-string hash).
-
-Acceptance per `road-to-kernel-and-router.md` P2.2: re-runnable,
-deterministic, stdlib-only, no network. Condensation of a kernel rule
-must preserve this SHA (or surface a deliberate ADR-tracked diff).
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import re
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(REPO_ROOT / "scripts"))
-from _lib.agent_src import artefact_roots  # noqa: E402
-
-# Pre-monorepo this was REPO_ROOT/.agent-src.uncondensed/rules. Post-move
-# (ADR-017) the source rules live under packages/*/.agent-src.uncondensed/rules.
-# Resolve the same way measure_rule_budget does (multi-root aware) so the
-# Iron-Law SHA gate keeps working against the current layout.
-def _rules_dirs() -> list[Path]:
-    return [root / "rules" for root in artefact_roots() if (root / "rules").is_dir()]
-
-# Locked kernel set — kept in sync with measure_rule_budget.KERNEL_RULES.
-KERNEL_RULES = (
-    "agent-authority",
-    "ask-when-uncertain",
-    "commit-policy",
-    "direct-answers",
-    "language-and-tone",
-    "no-cheap-questions",
-    "non-destructive-by-default",
-    "scope-control",
-    "verify-before-complete",
-)
-
-_FENCE_RE = re.compile(r"```(?:[^\n]*\n)([\s\S]*?)```")
-_WS_RE = re.compile(r"\s+")
-
-
-def iron_law_sha(text: str) -> str:
-    """SHA-256 of all triple-fence content, whitespace-collapsed, upper-cased.
-
-    Algorithm matches `scripts/_pilot_measure.py` exactly so the SHAs
-    recorded in `docs/contracts/kernel-membership.md` § 2 stay
-    reproducible across pre / post condensation.
-    """
-    blocks = _FENCE_RE.findall(text)
-    norm = "".join(_WS_RE.sub(" ", b).strip().upper() for b in blocks)
-    return hashlib.sha256(norm.encode("utf-8")).hexdigest()
-
-
-def rule_sha(rule_id: str) -> str:
-    for rules_dir in _rules_dirs():
-        path = rules_dir / f"{rule_id}.md"
-        if path.exists():
-            return iron_law_sha(path.read_text(encoding="utf-8"))
-    raise FileNotFoundError(f"{rule_id}.md not found under any artefact root's rules/")
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("rules", nargs="*", help="rule ids (omit if --all-kernel)")
-    parser.add_argument("--all-kernel", action="store_true", help="hash all 9 kernel rules")
-    parser.add_argument(
-        "--diff", metavar="RULE", help="hash one rule and compare to --against"
-    )
-    parser.add_argument("--against", metavar="SHA", help="expected SHA (for --diff)")
-    args = parser.parse_args(argv)
-
-    if args.diff:
-        if not args.against:
-            parser.error("--diff requires --against")
-        actual = rule_sha(args.diff)
-        match = actual == args.against
-        symbol = "✅" if match else "❌"
-        print(f"{symbol}  {args.diff}: {actual}  (expected {args.against})")
-        return 0 if match else 1
-
-    targets = list(KERNEL_RULES) if args.all_kernel else args.rules
-    if not targets:
-        parser.error("provide rule ids, or use --all-kernel")
-
-    width = max(len(t) for t in targets)
-    for rid in targets:
-        sha = rule_sha(rid)
-        print(f"{rid:<{width}}  {sha}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/linked_projects_list.py

@@ -1,91 +0,0 @@
-"""`agent-config linked-projects:list` — list opted-in IDE-attached siblings.
-
-Phase 4 of `road-to-leaner-core-and-discovery`; closes the ADR-032 follow-up
-"expose the detector as a CLI subcommand for consumer reach". Pure wrapper over
-`scripts/_lib/linked_projects.detect_linked_projects` + the
-`agents/settings/.agent-settings.local.yml` → `linked_projects[]` opt-in
-cascade. No detection logic is duplicated here.
-
-Prints opted-in siblings (`path · detected_via · large`). `--all` shows every
-detected sibling with its opt-in status; `--format json` is machine-readable.
-Read-only, no network.
-
-Usage:
-    python3 scripts/linked_projects_list.py [--all] [--format text|json] [--root PATH]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-import yaml
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(REPO_ROOT / "scripts"))
-from _lib.linked_projects import detect_linked_projects  # type: ignore  # noqa: E402
-
-LOCAL_SETTINGS = Path("agents") / "settings" / ".agent-settings.local.yml"
-
-
-def _opt_in_map(root: Path) -> dict[str, bool]:
-    """Map resolved sibling path → include flag from the local settings cascade."""
-    f = root / LOCAL_SETTINGS
-    if not f.is_file():
-        return {}
-    try:
-        data = yaml.safe_load(f.read_text(encoding="utf-8", errors="replace")) or {}
-    except yaml.YAMLError:
-        return {}
-    out: dict[str, bool] = {}
-    for entry in (data.get("linked_projects") or []):
-        if isinstance(entry, dict) and entry.get("path"):
-            try:
-                out[str(Path(entry["path"]).expanduser().resolve())] = bool(entry.get("include"))
-            except OSError:
-                out[str(entry["path"])] = bool(entry.get("include"))
-    return out
-
-
-def collect(root: Path, show_all: bool) -> list[dict]:
-    detected = detect_linked_projects(root)
-    opt_in = _opt_in_map(root)
-    rows: list[dict] = []
-    for d in detected:
-        include = opt_in.get(d["path"])  # None = undecided
-        if not show_all and include is not True:
-            continue
-        rows.append({**d, "include": include})
-    return rows
-
-
-def render_text(rows: list[dict], show_all: bool) -> str:
-    if not rows:
-        scope = "detected" if show_all else "opted-in"
-        return f"No {scope} linked-project siblings. (Attach a sibling repo in your IDE and opt in.)"
-    lines = ["| path | detected via | large | opted in |", "|---|---|---|---|"]
-    for r in rows:
-        inc = {True: "yes", False: "no", None: "undecided"}[r.get("include")]
-        lines.append(f"| {r['path']} | {r['detected_via']} | {'yes' if r['large'] else 'no'} | {inc} |")
-    return "\n".join(lines)
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description="List opted-in IDE-attached sibling projects (read-only).")
-    ap.add_argument("--all", action="store_true", help="Show every detected sibling, not only opted-in.")
-    ap.add_argument("--format", choices=("text", "json"), default="text")
-    ap.add_argument("--root", default=".", help="Project root (default: cwd).")
-    args = ap.parse_args(argv)
-
-    root = Path(args.root).resolve()
-    rows = collect(root, args.all)
-    if args.format == "json":
-        print(json.dumps({"root": str(root), "siblings": rows}, indent=2))
-    else:
-        print(render_text(rows, args.all))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())