@event4u/agent-config 6.1.0 → 7.0.1

package/src/scripts/lint_no_new_atomic_commands.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""
-Atomic-command linter for the command-collapse policy.
-
-Reads the locked verb clusters from `docs/contracts/command-clusters.md`,
-finds every command file under `.agent-src.uncondensed/commands/` that
-was **added** since `--baseline` (default: `main`), and requires each
-new file to declare either:
-
-  - `cluster: <locked-name>`   (file is a cluster entry or sub-command), or
-  - `superseded_by: <slug>`    (file is a deprecation shim).
-
-Modifications to pre-existing files are NOT flagged — only additions.
-This stops the atomic surface from growing without forcing every existing
-command into a Phase 1 cluster (most aren't in Phase 1).
-
-Exit codes: 0 = clean, 1 = violations found, 3 = internal error.
-
-Usage:
-    python3 scripts/lint_no_new_atomic_commands.py
-    python3 scripts/lint_no_new_atomic_commands.py --baseline origin/main
-    python3 scripts/lint_no_new_atomic_commands.py --all       # ignore baseline
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import subprocess
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent.parent
-COMMANDS_DIR = Path(".agent-src.uncondensed/commands")
-CLUSTER_CONTRACT = Path("docs/contracts/command-clusters.md")
-
-
-@dataclass
-class Violation:
-    file: str
-    reason: str
-
-
-def load_locked_clusters() -> set[str]:
-    """Parse the locked cluster table from the contract."""
-    text = (ROOT / CLUSTER_CONTRACT).read_text(encoding="utf-8")
-    # Locate the locked-clusters table; cluster names sit in backticks in column 1.
-    in_table = False
-    clusters: set[str] = set()
-    for line in text.splitlines():
-        if line.startswith("## Locked clusters"):
-            in_table = True
-            continue
-        if in_table and line.startswith("## "):
-            break
-        if in_table:
-            m = re.match(r"\|\s*`([a-z][a-z0-9-]*)`\s*\|", line)
-            if m:
-                clusters.add(m.group(1))
-    if not clusters:
-        print(
-            f"❌  Could not parse locked-clusters table from {CLUSTER_CONTRACT}",
-            file=sys.stderr,
-        )
-        sys.exit(3)
-    return clusters
-
-
-def added_command_files(baseline: str) -> list[Path]:
-    """Files under commands/ added (status A) since baseline."""
-    try:
-        result = subprocess.run(
-            ["git", "diff", "--name-only", "--diff-filter=A",
-             f"{baseline}...HEAD", "--", str(COMMANDS_DIR)],
-            capture_output=True, text=True, cwd=ROOT, timeout=15,
-        )
-    except (FileNotFoundError, subprocess.TimeoutExpired) as exc:
-        print(f"❌  git diff failed: {exc}", file=sys.stderr)
-        sys.exit(3)
-    if result.returncode != 0:
-        print(f"❌  git diff exit {result.returncode}: {result.stderr}",
-              file=sys.stderr)
-        sys.exit(3)
-    files = [Path(p) for p in result.stdout.splitlines()
-             if p.endswith(".md") and p != "" and Path(p).name != "AGENTS.md"]
-    # Also include untracked (newly added, uncommitted) files.
-    try:
-        wt = subprocess.run(
-            ["git", "status", "--porcelain", "--", str(COMMANDS_DIR)],
-            capture_output=True, text=True, cwd=ROOT, timeout=10,
-        )
-        for line in wt.stdout.splitlines():
-            if len(line) < 4:
-                continue
-            status = line[:2]
-            if status.strip() not in ("A", "??", "AM"):
-                continue
-            path = line[3:].strip().split(" -> ")[-1]
-            if path.endswith(".md") and Path(path).name != "AGENTS.md":
-                p = Path(path)
-                if p not in files:
-                    files.append(p)
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        pass
-    return files
-
-
-def all_command_files() -> list[Path]:
-    return sorted(p for p in (ROOT / COMMANDS_DIR).rglob("*.md")
-                  if p.name != "AGENTS.md")
-
-
-def parse_frontmatter(path: Path) -> dict[str, str]:
-    text = path.read_text(encoding="utf-8")
-    if not text.startswith("---"):
-        return {}
-    end = text.find("\n---", 3)
-    if end == -1:
-        return {}
-    fm: dict[str, str] = {}
-    for line in text[3:end].splitlines():
-        if ":" in line:
-            k, _, v = line.partition(":")
-            fm[k.strip()] = v.strip()
-    return fm
-
-
-def check_file(path: Path, clusters: set[str]) -> Violation | None:
-    abs_path = path if path.is_absolute() else ROOT / path
-    if not abs_path.exists():
-        return None  # deleted file, nothing to check
-    fm = parse_frontmatter(abs_path)
-    if "superseded_by" in fm:
-        return None  # shim — exempt
-    cluster = fm.get("cluster")
-    if not cluster:
-        return Violation(str(path),
-                         "missing `cluster:` frontmatter "
-                         f"(allowed: {sorted(clusters)})")
-    if cluster not in clusters:
-        return Violation(str(path),
-                         f"`cluster: {cluster}` is not a locked cluster "
-                         f"(allowed: {sorted(clusters)})")
-    return None
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("--baseline", default="main",
-                    help="git ref to diff against (default: main)")
-    ap.add_argument("--all", action="store_true",
-                    help="check every command file, not just changed ones")
-    args = ap.parse_args()
-
-    clusters = load_locked_clusters()
-    targets = (all_command_files() if args.all
-               else added_command_files(args.baseline))
-    if not targets:
-        print(f"✅  No new commands added under {COMMANDS_DIR} "
-              f"(baseline: {args.baseline}).")
-        return 0
-
-    violations = [v for v in (check_file(p, clusters) for p in targets)
-                  if v is not None]
-    if violations:
-        print(f"❌  {len(violations)} newly-added atomic command(s) violate "
-              f"the command-cluster policy:")
-        for v in violations:
-            print(f"  • {v.file} — {v.reason}")
-        print(f"\nSee docs/contracts/command-clusters.md for the locked "
-              f"cluster names and frontmatter contract.")
-        return 1
-    print(f"✅  {len(targets)} newly-added command(s) all declare a valid "
-          f"`cluster:` (or `superseded_by:`).")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/lint_one_off_age.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""One-off-script age linter.
-
-Scans `scripts/_one_off/<YYYY-MM>/_one_off_*.py` and enforces the
-TTL policy from `docs/contracts/one-off-script-lifecycle.md`:
-
-  * Age ≤ 60 days   → active, silent.
-  * 60 < Age ≤ 90   → warning, exit 0.
-  * Age > 90        → hard fail, exit 1 (purge candidate).
-
-Scripts MAY extend their TTL exactly once via a frontmatter block:
-
-    \"\"\"
-    ---
-    ttl_extended_until: YYYY-MM-DD
-    ttl_reason: <free text>
-    ---
-    \"\"\"
-
-The extended date is honoured up to 180 days past the month-directory
-date. Anything beyond hard-fails with no second extension.
-
-Exit codes: 0 = clean (incl. warnings), 1 = hard fail, 3 = internal error.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from dataclasses import asdict, dataclass
-from datetime import date, datetime, timezone
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent.parent
-ONE_OFF_DIR = ROOT / "src" / "scripts" / "_one_off"
-
-NAME_RE = re.compile(r"^_one_off_[a-z0-9-]+\.py$")
-MONTH_RE = re.compile(r"^\d{4}-\d{2}$")
-TTL_RE = re.compile(
-    r"---\s*\n\s*ttl_extended_until:\s*(\d{4}-\d{2}-\d{2})\s*\n",
-    re.MULTILINE,
-)
-
-WARN_DAYS = 60
-HARD_DAYS = 90
-EXTEND_CAP_DAYS = 180
-
-
-@dataclass
-class Finding:
-    path: str
-    age_days: int
-    severity: str  # "warn" | "fail"
-    reason: str
-
-
-def _today_utc() -> date:
-    return datetime.now(timezone.utc).date()
-
-
-def _month_anchor(month_dir: str) -> date | None:
-    if not MONTH_RE.match(month_dir):
-        return None
-    y, m = map(int, month_dir.split("-"))
-    try:
-        return date(y, m, 1)
-    except ValueError:
-        return None
-
-
-def _read_extension(path: Path) -> date | None:
-    try:
-        head = path.read_text(encoding="utf-8")[:1024]
-    except OSError:
-        return None
-    m = TTL_RE.search(head)
-    if not m:
-        return None
-    try:
-        return datetime.strptime(m.group(1), "%Y-%m-%d").date()
-    except ValueError:
-        return None
-
-
-def scan(root: Path, today: date | None = None) -> list[Finding]:
-    today = today or _today_utc()
-    base = root / "scripts" / "_one_off"
-    if not base.exists():
-        return []
-    out: list[Finding] = []
-    for month_dir in sorted(base.iterdir()):
-        if not month_dir.is_dir():
-            continue
-        anchor = _month_anchor(month_dir.name)
-        if anchor is None:
-            out.append(Finding(
-                path=str(month_dir.relative_to(root)),
-                age_days=-1,
-                severity="fail",
-                reason="invalid month directory name (expect YYYY-MM)",
-            ))
-            continue
-        for f in sorted(month_dir.iterdir()):
-            if f.name == "README.md" or f.is_dir():
-                continue
-            if not NAME_RE.match(f.name):
-                out.append(Finding(
-                    path=str(f.relative_to(root)),
-                    age_days=-1,
-                    severity="fail",
-                    reason="filename does not match _one_off_<slug>.py",
-                ))
-                continue
-            age = (today - anchor).days
-            extension = _read_extension(f)
-            if extension is not None:
-                cap = (extension - anchor).days
-                if cap > EXTEND_CAP_DAYS:
-                    out.append(Finding(
-                        path=str(f.relative_to(root)),
-                        age_days=age,
-                        severity="fail",
-                        reason=f"ttl_extended_until exceeds 180-day cap ({cap}d)",
-                    ))
-                    continue
-                if age <= cap:
-                    continue  # extension still valid, silent
-            if age > HARD_DAYS:
-                out.append(Finding(
-                    path=str(f.relative_to(root)),
-                    age_days=age,
-                    severity="fail",
-                    reason=f"age {age}d exceeds {HARD_DAYS}-day hard limit",
-                ))
-            elif age > WARN_DAYS:
-                out.append(Finding(
-                    path=str(f.relative_to(root)),
-                    age_days=age,
-                    severity="warn",
-                    reason=f"age {age}d in soft window ({WARN_DAYS}–{HARD_DAYS}d)",
-                ))
-    return out
-
-
-def format_text(findings: list[Finding]) -> str:
-    if not findings:
-        return "✅  No one-off-script age violations."
-    lines = []
-    fails = [f for f in findings if f.severity == "fail"]
-    warns = [f for f in findings if f.severity == "warn"]
-    if fails:
-        lines.append(f"❌  {len(fails)} one-off script(s) past hard limit:")
-        for f in fails:
-            lines.append(f"  🔴 {f.path}  →  {f.reason}")
-    if warns:
-        lines.append(f"⚠️  {len(warns)} one-off script(s) in soft window:")
-        for f in warns:
-            lines.append(f"  🟡 {f.path}  →  {f.reason}")
-    lines.append(
-        "\nPurge candidates per docs/contracts/one-off-script-lifecycle.md."
-    )
-    return "\n".join(lines)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--format", choices=["text", "json"], default="text")
-    parser.add_argument("--root", type=Path, default=ROOT)
-    args = parser.parse_args()
-    try:
-        findings = scan(args.root)
-    except Exception as e:    # pragma: no cover
-        print(f"Internal error: {e}", file=sys.stderr)
-        return 3
-    if args.format == "json":
-        print(json.dumps([asdict(f) for f in findings], indent=2))
-    else:
-        print(format_text(findings))
-    return 1 if any(f.severity == "fail" for f in findings) else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/lint_orchestration_dsl.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""Lint `.agent-config/orchestrations/*.yaml` pipeline files.
-
-CI gate for the orchestration DSL contract
-(`docs/contracts/orchestration-dsl-v1.md`). Hard-fails on:
-
-- missing or malformed top-level keys
-  (`schema_version`, `name`, `description`, `steps`)
-- `schema_version != 1`
-- `name` not matching `[a-z][a-z0-9-]*` or not matching the filename
-- duplicate `steps[].id`
-- `steps[].kind` outside the enum (`skill` / `command` / `persona` /
-  `subagent`)
-- `steps[].ref` pointing at a non-existent target on disk
-- `${{ ... }}` reference to an unknown input or step id
-- `steps[]` length outside [1, 32]
-- `outputs` referencing an unknown step
-
-Exit codes mirror `lint_hook_manifest.py`:
-  0 — clean
-  1 — at least one hard failure
-  2 — file or schema-load error
-
-Invocation:
-
-    python3 scripts/lint_orchestration_dsl.py [--dir PATH] [--file PATH]
-"""
-from __future__ import annotations
-
-import argparse
-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.agent_src import resolve_logical  # noqa: E402
-
-DEFAULT_DIR = REPO_ROOT / ".agent-config" / "orchestrations"
-
-NAME_RE = re.compile(r"^[a-z][a-z0-9-]*$")
-STEP_ID_RE = re.compile(r"^[a-z][a-z0-9_]*$")
-INTERP_RE = re.compile(r"\$\{\{\s*(inputs|steps)\.([a-z0-9_-]+)(?:\.output)?\s*\}\}")
-
-VALID_KINDS = {"skill", "command", "persona", "subagent"}
-MAX_STEPS = 32
-MIN_STEPS = 1
-
-# Subagent-orchestration modes — kept in lock-step with
-# .agent-src.uncondensed/skills/subagent-orchestration/SKILL.md.
-SUBAGENT_MODES = {
-    "do-and-judge", "do-and-judge-two-stage",
-    "do-in-steps", "do-in-parallel", "do-in-worktrees",
-    "do-competitively", "judge-with-debate",
-}
-
-
-def _load_yaml(path: Path) -> object:
-    """Reuse the dispatcher's loader so the linter sees what the
-    runtime sees — fallback parser when PyYAML is not installed."""
-    sys.path.insert(0, str(REPO_ROOT / "src" / "scripts"))
-    from hooks.dispatch_hook import _load_yaml as _load  # noqa: E402
-    return _load(path)
-
-
-def _ref_exists(kind: str, ref: str) -> bool:
-    if kind == "skill":
-        return resolve_logical(f"skills/{ref}/SKILL.md") is not None
-    if kind == "command":
-        return resolve_logical(f"commands/{ref}.md") is not None
-    if kind == "persona":
-        return resolve_logical(f"personas/{ref}.md") is not None
-    if kind == "subagent":
-        return ref in SUBAGENT_MODES
-    return False
-
-
-def _walk_interpolations(value: object):
-    """Yield (namespace, ident) tuples for every ${{ ns.ident }} in the
-    nested value (dict / list / str)."""
-    if isinstance(value, str):
-        for match in INTERP_RE.finditer(value):
-            yield match.group(1), match.group(2)
-    elif isinstance(value, dict):
-        for v in value.values():
-            yield from _walk_interpolations(v)
-    elif isinstance(value, list):
-        for v in value:
-            yield from _walk_interpolations(v)
-
-
-def _check_unknown_namespaces(value: object, path: str, errors: list[str]) -> None:
-    if isinstance(value, str):
-        for match in re.finditer(r"\$\{\{\s*([a-z]+)\.", value):
-            if match.group(1) not in ("inputs", "steps"):
-                errors.append(f"{path}: unknown interpolation namespace '{match.group(1)}'")
-    elif isinstance(value, dict):
-        for k, v in value.items():
-            _check_unknown_namespaces(v, f"{path}.{k}", errors)
-    elif isinstance(value, list):
-        for i, v in enumerate(value):
-            _check_unknown_namespaces(v, f"{path}[{i}]", errors)
-
-
-def _check_steps(doc: dict, input_ids: set[str], errors: list[str]) -> set[str]:
-    steps = doc.get("steps")
-    if not isinstance(steps, list) or not (MIN_STEPS <= len(steps) <= MAX_STEPS):
-        errors.append(f"steps: must be a list of {MIN_STEPS}–{MAX_STEPS} entries")
-        return set()
-    step_ids: set[str] = set()
-    for i, step in enumerate(steps):
-        if not isinstance(step, dict):
-            errors.append(f"steps[{i}]: must be a mapping")
-            continue
-        sid = step.get("id")
-        if not isinstance(sid, str) or not STEP_ID_RE.match(sid):
-            errors.append(f"steps[{i}].id: must be snake-case identifier")
-            continue
-        if sid in step_ids:
-            errors.append(f"steps[{i}].id: duplicate id '{sid}'")
-            continue
-        step_ids.add(sid)
-        kind = step.get("kind")
-        ref = step.get("ref")
-        if kind not in VALID_KINDS:
-            errors.append(f"steps.{sid}.kind: must be one of {sorted(VALID_KINDS)}")
-            continue
-        if not isinstance(ref, str) or not _ref_exists(kind, ref):
-            errors.append(f"steps.{sid}.ref: {kind} '{ref}' not found on disk")
-        _check_unknown_namespaces(step.get("with"), f"steps.{sid}.with", errors)
-        for ns, ident in _walk_interpolations(step.get("with") or {}):
-            if ns == "inputs" and ident not in input_ids:
-                errors.append(f"steps.{sid}.with: unknown input '{ident}'")
-            if ns == "steps" and ident not in step_ids - {sid}:
-                errors.append(f"steps.{sid}.with: unknown step '{ident}' (forward ref or self)")
-    return step_ids
-
-
-
-def _check_outputs(doc: dict, step_ids: set[str], input_ids: set[str], errors: list[str]) -> None:
-    outputs = doc.get("outputs")
-    if outputs is None:
-        return
-    if not isinstance(outputs, dict):
-        errors.append("outputs: must be a mapping")
-        return
-    for name, value in outputs.items():
-        for ns, ident in _walk_interpolations(value):
-            if ns == "steps" and ident not in step_ids:
-                errors.append(f"outputs.{name}: unknown step '{ident}'")
-            if ns == "inputs" and ident not in input_ids:
-                errors.append(f"outputs.{name}: unknown input '{ident}'")
-
-
-def _check_inputs(doc: dict, errors: list[str]) -> set[str]:
-    inputs = doc.get("inputs") or []
-    if not isinstance(inputs, list):
-        errors.append("inputs: must be a list")
-        return set()
-    ids: set[str] = set()
-    for i, inp in enumerate(inputs):
-        if not isinstance(inp, dict) or not isinstance(inp.get("id"), str):
-            errors.append(f"inputs[{i}]: must be a mapping with string 'id'")
-            continue
-        if inp["id"] in ids:
-            errors.append(f"inputs[{i}].id: duplicate id '{inp['id']}'")
-        ids.add(inp["id"])
-    return ids
-
-
-def lint(path: Path) -> int:
-    try:
-        doc = _load_yaml(path)
-    except Exception as exc:
-        sys.stderr.write(f"lint_orchestration_dsl: load error: {exc}\n")
-        return 2
-    if not isinstance(doc, dict):
-        sys.stderr.write(f"{path}: top-level must be a mapping\n")
-        return 1
-
-    errors: list[str] = []
-    if doc.get("schema_version") != 1:
-        errors.append("schema_version: must be 1")
-    name = doc.get("name")
-    if not isinstance(name, str) or not NAME_RE.match(name):
-        errors.append("name: must be kebab-case starting with a letter")
-    elif name != path.stem:
-        errors.append(f"name: '{name}' must match filename stem '{path.stem}'")
-    if not isinstance(doc.get("description"), str) or not doc["description"].strip():
-        errors.append("description: must be a non-empty string")
-
-    input_ids = _check_inputs(doc, errors)
-    step_ids = _check_steps(doc, input_ids, errors)
-    _check_outputs(doc, step_ids, input_ids, errors)
-
-    for e in errors:
-        sys.stderr.write(f"error: {path}: {e}\n")
-    return 1 if errors else 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--dir", type=Path, default=DEFAULT_DIR)
-    parser.add_argument("--file", type=Path, default=None)
-    args = parser.parse_args(argv)
-    if args.file is not None:
-        return lint(args.file)
-    if not args.dir.is_dir():
-        return 0  # opt-in directory; absence is not a failure
-    rc = 0
-    for path in sorted(args.dir.glob("*.yaml")):
-        rc = max(rc, lint(path))
-    return rc
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/lint_orchestrator_auto_detect.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-"""Auto-detection contract linter for command orchestrators (6.1.0 Step 1).
-
-Every command source under ``src/domains/**/command.md`` that opts into
-auto-detection (front-matter ``auto_detect: true``) MUST honor the
-non-interactive contract by carrying both:
-
-  1. a body link to ``contexts/execution/non-interactive-contract.md`` —
-     the single source of truth for TTY/CI detection, confidence tiers,
-     ``--yes``/``--json`` semantics, abort schemas, and the kill-switch;
-  2. a ``## Non-interactive & auto-detection`` section that holds the
-     orchestrator's confidence-tiered detection table.
-
-This is the CI test that 6.1.0 Acceptance Criterion 1 ("every merged
-command works non-interactively (CI-safe); proven by a CI test") rests
-on: an orchestrator cannot claim auto-detection without wiring the
-contract that makes it CI-safe.
-
-Symmetry guard: ``auto_detect`` is only meaningful on an orchestrator
-(``type: orchestrator``). A non-orchestrator carrying ``auto_detect`` is
-a mistake and fails too.
-
-Exit codes: 0 = clean, 1 = violations found, 3 = internal error.
-
-Usage:
-    python3 scripts/lint_orchestrator_auto_detect.py
-    python3 scripts/lint_orchestrator_auto_detect.py --quiet
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent.parent
-DOMAINS = ROOT / "src" / "domains"
-
-CONTRACT_LINK = "contexts/execution/non-interactive-contract.md"
-SECTION_HEADING = "## Non-interactive & auto-detection"
-
-_AUTO_DETECT_RE = re.compile(r"^auto_detect:\s*(true|false)\s*$", re.MULTILINE)
-_TYPE_RE = re.compile(r"^type:\s*orchestrator\s*$", re.MULTILINE)
-
-
-@dataclass
-class Violation:
-    file: str
-    reason: str
-
-
-def _split_frontmatter(text: str) -> tuple[str, str]:
-    """Return (frontmatter, body); frontmatter is '' when absent."""
-    if not text.startswith("---\n"):
-        return "", text
-    end = text.find("\n---\n", 4)
-    if end == -1:
-        return "", text
-    return text[4:end], text[end + len("\n---\n"):]
-
-
-def check() -> list[Violation]:
-    violations: list[Violation] = []
-    if not DOMAINS.is_dir():
-        return violations
-    for path in sorted(DOMAINS.rglob("command.md")):
-        text = path.read_text(encoding="utf-8")
-        fm, body = _split_frontmatter(text)
-        m = _AUTO_DETECT_RE.search(fm)
-        if not m:
-            continue  # opted out of the contract — nothing to enforce
-        rel = path.relative_to(ROOT).as_posix()
-        is_orchestrator = bool(_TYPE_RE.search(fm))
-        if m.group(1) == "false":
-            # Explicit kill-switch — allowed, but still must be an orchestrator.
-            if not is_orchestrator:
-                violations.append(Violation(rel, "auto_detect set on a non-orchestrator command (type: orchestrator required)"))
-            continue
-        # auto_detect: true → full contract required.
-        if not is_orchestrator:
-            violations.append(Violation(rel, "auto_detect: true on a non-orchestrator command (type: orchestrator required)"))
-        if CONTRACT_LINK not in body:
-            violations.append(Violation(rel, f"auto_detect: true but missing a body link to {CONTRACT_LINK}"))
-        if SECTION_HEADING not in body:
-            violations.append(Violation(rel, f"auto_detect: true but missing the '{SECTION_HEADING}' section"))
-    return violations
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--quiet", action="store_true", help="Suppress the success line.")
-    args = parser.parse_args()
-    try:
-        violations = check()
-    except Exception as exc:  # pragma: no cover — defensive
-        print(f"❌  lint-orchestrator-auto-detect: internal error: {exc}", file=sys.stderr)
-        return 3
-    if violations:
-        print("❌  Orchestrator auto-detection contract violations:", file=sys.stderr)
-        for v in violations:
-            print(f"  • {v.file}\n      {v.reason}", file=sys.stderr)
-        return 1
-    if not args.quiet:
-        print("✅  Every auto_detect orchestrator honors the non-interactive contract.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())