@event4u/agent-config 3.3.0 → 4.2.0

package/scripts/install.sh

@@ -37,6 +37,12 @@ DRY_RUN=false
 VERBOSE=false
 QUIET=false
 SKIP_GITIGNORE=false
+# Per the canonical-channel contract (docs/contracts/skill-distribution-channels.md),
+# consumer installs default to the filesystem channel only (e.g. .claude/skills/) and
+# do NOT project the plugin manifest (.claude-plugin/marketplace.json). Set this true
+# via --legacy-both to also copy the plugin manifest for users on older harnesses
+# that require both channels.
+LEGACY_BOTH=false
 # When true, skip payload sync entirely and only install the project-local
 # `./agent-config` wrapper (Step 7 Phase 2). The bridge stage (install.py)
 # handles the .agent-settings.yml stub + nested-install guard.
@@ -87,6 +93,7 @@ parse_args() {
             --user-type)   shift 2 ;;
             --user-type=*) shift ;;
             --minimal|--settings-only) MINIMAL=true; shift ;;
+            --legacy-both) LEGACY_BOTH=true; shift ;;
             --help|-h) show_help; exit 0 ;;
             *) log_error "Unknown argument: $1"; show_help; exit 1 ;;
         esac
@@ -141,6 +148,10 @@ Options:
   --verbose        Show detailed output
   --quiet          Suppress all output except errors
   --skip-gitignore Do not touch the target project's .gitignore
+  --legacy-both    Also project the Claude plugin manifest
+                   (.claude-plugin/marketplace.json) into the consumer install.
+                   Default is filesystem-only per the canonical-channel contract
+                   at docs/contracts/skill-distribution-channels.md.
   --help, -h       Show this help
 
 Environment:
@@ -604,6 +615,163 @@ generate_windsurfrules() {
 }
 
 
+# Run scripts/_lib/scope_guard.sh as a pre-flight check. On DRIFT findings
+# the function surfaces a numbered-options prompt and aborts on no-confirm
+# paths. SCOPE_GUARD_BYPASS=1 (set by the orchestrator, CI runs, and
+# --dry-run) skips the prompt entirely. Findings are always logged in
+# verbose mode regardless.
+run_scope_guard() {
+    local target="$1"
+    local guard="$SOURCE_DIR/scripts/_lib/scope_guard.sh"
+
+    # Skip when the guard is not present (e.g. trimmed install bundle).
+    [[ -f "$guard" ]] || { log_verbose "scope_guard.sh not found — skipping cross-scope drift check"; return 0; }
+
+    # Bypass paths that cannot or must not be interactive.
+    if $DRY_RUN; then
+        log_verbose "skip scope_guard (--dry-run)"
+        return 0
+    fi
+    if [[ "${SCOPE_GUARD_BYPASS:-0}" == "1" ]]; then
+        log_verbose "skip scope_guard (SCOPE_GUARD_BYPASS=1)"
+        return 0
+    fi
+    if [[ "${CI:-0}" == "true" ]] || [[ "${CI:-0}" == "1" ]]; then
+        log_verbose "skip scope_guard (CI=true)"
+        return 0
+    fi
+
+    local output verdict
+    output="$(bash "$guard" project "$SOURCE_DIR" "$target" 2>/dev/null || true)"
+    [[ -n "$output" ]] || return 0
+
+    local summary
+    summary="$(echo "$output" | grep '^SUMMARY' | tail -1)"
+    [[ -n "$summary" ]] || return 0
+    verdict="$(echo "$summary" | cut -f2)"
+
+    if [[ "$verdict" == "OK" ]]; then
+        log_verbose "scope_guard OK (no cross-scope install)"
+        return 0
+    fi
+
+    if [[ "$verdict" == "WARN" ]]; then
+        $QUIET || {
+            echo ""
+            echo "  ⚠️  Cross-scope install detected (same version, no drift)."
+            echo "$output" | awk -F'\t' '$1=="WARN" { printf "       - %s at %s (v%s)\n", $2, $3, $4 }'
+            echo ""
+        }
+        return 0
+    fi
+
+    # DRIFT: surface the gate. Non-interactive shells get the warning and
+    # an exit code that the caller can short-circuit with SCOPE_GUARD_BYPASS=1.
+    echo ""
+    echo "  ❌  Cross-scope DRIFT detected — same package installed at user AND project scope at different versions:"
+    echo "$output" | awk -F'\t' '$1=="DRIFT" { printf "       - %s: other-scope=%s (v%s) vs this-install=v%s\n", $2, $3, $4, $5 }'
+    echo ""
+    echo "      The 2026-05-25 root cause (duplicate skill registration with stale frontmatter)"
+    echo "      will fire when both registrations load. Choose how to proceed:"
+    echo ""
+    echo "         1. Abort install — fix drift first (recommended)"
+    echo "         2. Upgrade the OTHER scope first (run scripts/install.sh --target=\$HOME or equivalent)"
+    echo "         3. Force install at this scope — accept drift (set SCOPE_GUARD_BYPASS=1)"
+    echo "         4. Clean the other scope (bash scripts/cleanup_other_scope.sh --confirm)"
+    echo ""
+    echo "      Recommendation: 1"
+    echo ""
+
+    # In interactive mode the caller has stdin; we honour SCOPE_GUARD_BYPASS=1
+    # already above. Default: abort.
+    if [[ -t 0 ]]; then
+        local choice
+        read -r -p "      Enter 1-4 [default 1]: " choice || choice=1
+        case "${choice:-1}" in
+            2) echo "      → Re-run scripts/install.sh against the other scope first; aborting this run."; exit 2 ;;
+            3) log_warn "Continuing despite DRIFT (user opted into option 3)" ;;
+            4) echo "      → Run: bash scripts/cleanup_other_scope.sh --confirm — then retry."; exit 2 ;;
+            *) echo "      → Aborting (option 1)."; exit 2 ;;
+        esac
+    else
+        echo "      Non-interactive shell — aborting. Set SCOPE_GUARD_BYPASS=1 to override."
+        exit 2
+    fi
+}
+
+# Post-install skill-registration probe (Phase C Step 6). Informational by
+# default; PROBE_STRICT=1 turns drift findings into a non-zero exit so a
+# release install fails loudly. Skipped in dry-run and when python3 or the
+# probe script is missing (older bundles).
+run_post_install_probe() {
+    local target="$1"
+    local probe="$SOURCE_DIR/scripts/probe_skill_registration.py"
+
+    [[ -f "$probe" ]] || { log_verbose "skip probe_skill_registration.py (not found)"; return 0; }
+    if ! command -v python3 >/dev/null 2>&1; then
+        log_verbose "skip skill-registration probe (python3 missing)"
+        return 0
+    fi
+    if $DRY_RUN; then
+        log_verbose "skip skill-registration probe (--dry-run)"
+        return 0
+    fi
+    if [[ "${PROBE_BYPASS:-0}" == "1" ]]; then
+        log_verbose "skip skill-registration probe (PROBE_BYPASS=1)"
+        return 0
+    fi
+
+    local args=( "$probe" "--project" "$target" "--format=text" )
+    [[ "${PROBE_STRICT:-0}" == "1" ]] && args+=("--strict")
+
+    if python3 "${args[@]}" > /tmp/agent-config-probe.$$ 2>&1; then
+        # On clean output (no findings) only show a one-liner.
+        if grep -qE 'DUPLICATE|DRIFT' /tmp/agent-config-probe.$$; then
+            $QUIET || echo ""
+            $QUIET || echo "  ⚠️  Skill-registration findings:"
+            $QUIET || sed -n '/DUPLICATE\|DRIFT/,$p' /tmp/agent-config-probe.$$ | head -40
+            $QUIET || echo ""
+            $QUIET || echo "      Run: python3 scripts/probe_skill_registration.py — for the full report."
+        else
+            log_info "Skill-registration probe: clean (no duplicates / drift)"
+        fi
+        rm -f /tmp/agent-config-probe.$$
+        return 0
+    else
+        local code=$?
+        echo ""
+        echo "  ❌  Skill-registration probe surfaced DUPLICATE / DRIFT findings (PROBE_STRICT=1):"
+        sed -n '/DUPLICATE\|DRIFT/,$p' /tmp/agent-config-probe.$$ | head -40
+        rm -f /tmp/agent-config-probe.$$
+        return "$code"
+    fi
+}
+
+# Project the Claude plugin manifest into the consumer install — gated on
+# --legacy-both. Default install path is filesystem-only per the canonical-
+# channel contract (docs/contracts/skill-distribution-channels.md). Only
+# users on older Claude Code harnesses that need both channels opt in.
+project_legacy_plugin_manifest() {
+    local project_root="$1"
+    local source_manifest="$SOURCE_DIR/.claude-plugin/marketplace.json"
+    local target_manifest="$project_root/.claude-plugin/marketplace.json"
+
+    if ! $LEGACY_BOTH; then
+        log_verbose "skip .claude-plugin/marketplace.json (filesystem is canonical; use --legacy-both to opt in)"
+        return 0
+    fi
+    is_tool_enabled "claude-code" || { log_verbose "skip .claude-plugin/marketplace.json (claude-code not selected)"; return 0; }
+    [[ -f "$source_manifest" ]] || { log_verbose "skip .claude-plugin/marketplace.json (source manifest absent)"; return 0; }
+
+    if $DRY_RUN; then
+        log_verbose "copy .claude-plugin/marketplace.json (--legacy-both)"
+        return
+    fi
+    mkdir -p "$(dirname "$target_manifest")"
+    cp "$source_manifest" "$target_manifest"
+    log_info "Projected .claude-plugin/marketplace.json (--legacy-both opted in)"
+}
+
 # Create GEMINI.md symlink (gemini-cli only).
 create_gemini_md() {
     local project_root="$1"
@@ -883,7 +1051,15 @@ main() {
         echo ""
     fi
 
-    # 0. Migrate legacy infra files (root → agents/) before any content sync.
+    # 0a. Cross-scope drift pre-flight (Phase B Step 3). Detect prior installs
+    #     of the same package at the OTHER scope (user-global ↔ project-local).
+    #     On DRIFT the function surfaces a numbered-options gate per the
+    #     non-destructive-by-default contract. SCOPE_GUARD_BYPASS=1 from the
+    #     orchestrator or a CI run skips the gate so non-interactive paths do
+    #     not hang.
+    run_scope_guard "$TARGET_DIR"
+
+    # 0b. Migrate legacy infra files (root → agents/) before any content sync.
     migrate_legacy_root_infra "$TARGET_DIR"
     migrate_legacy_low_impact_decisions "$TARGET_DIR"
     migrate_legacy_prices_file "$TARGET_DIR"
@@ -920,6 +1096,9 @@ main() {
     create_tool_symlinks "$TARGET_DIR"
     create_skill_symlinks "$TARGET_DIR"
 
+    # 3b. Optionally project the Claude plugin manifest (--legacy-both).
+    project_legacy_plugin_manifest "$TARGET_DIR"
+
     # 4. Generate files
     generate_windsurfrules "$TARGET_DIR"
     create_gemini_md "$TARGET_DIR"
@@ -927,6 +1106,13 @@ main() {
     # 5. Install consumer CLI wrapper (gitignored, overwritten on every install)
     install_cli_wrapper "$TARGET_DIR"
 
+    # 5b. Post-install registration probe (Phase C Step 6). Surfaces any
+    #     duplicate / drifting skill registrations the new install would
+    #     conflict with. PROBE_STRICT=1 (set by release installs) flips
+    #     informational output into a non-zero exit so a release stops on
+    #     drift findings.
+    run_post_install_probe "$TARGET_DIR"
+
     # 6. Manage .gitignore
     ensure_gitignore "$TARGET_DIR"
 

package/scripts/inventory_frontmatter.py

@@ -2,7 +2,7 @@
 """
 Inventory frontmatter keys across all agent artefacts.
 
-Reads .agent-src.uncompressed/{skills,rules,commands,personas}, parses the
+Reads .agent-src.uncondensed/{skills,rules,commands,personas}, parses the
 YAML frontmatter of every file, and prints per-type:
 
 - total file count
@@ -26,7 +26,7 @@ from collections import Counter, defaultdict
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
-SRC = ROOT / ".agent-src.uncompressed"
+SRC = ROOT / ".agent-src.uncondensed"
 
 FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
 

package/scripts/iron_law_sha.py

@@ -13,7 +13,7 @@ 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. Compression of a kernel rule
+deterministic, stdlib-only, no network. Condensation of a kernel rule
 must preserve this SHA (or surface a deliberate ADR-tracked diff).
 """
 
@@ -26,7 +26,7 @@ import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+RULES_DIR = REPO_ROOT / ".agent-src.uncondensed" / "rules"
 
 # Locked kernel set — kept in sync with measure_rule_budget.KERNEL_RULES.
 KERNEL_RULES = (
@@ -50,7 +50,7 @@ def iron_law_sha(text: str) -> str:
 
     Algorithm matches `scripts/_pilot_measure.py` exactly so the SHAs
     recorded in `docs/contracts/kernel-membership.md` § 2 stay
-    reproducible across pre / post compression.
+    reproducible across pre / post condensation.
     """
     blocks = _FENCE_RE.findall(text)
     norm = "".join(_WS_RE.sub(" ", b).strip().upper() for b in blocks)

package/scripts/lint_agents_layout.py

@@ -9,12 +9,12 @@ everything else lives in a typed subdirectory (`runtime/`, `settings/`,
 
 Two layout tiers:
 
-  MAINTAINER (this source repo, identified by ``.agent-src.uncompressed/``)
+  MAINTAINER (this source repo, identified by ``.agent-src.uncondensed/``)
       Full `agents/` tree allowed — only the flat-file whitelist is
       enforced. Phase 4 of road-to-global-only-install keeps the
       maintainer surface unchanged.
 
-  CONSUMER (any repo without ``.agent-src.uncompressed/``)
+  CONSUMER (any repo without ``.agent-src.uncondensed/``)
       Global-only target shape: `agents/overrides/` + the bridge
       marker `agents/.event4u-bridge.yml` are the **only** expected
       artefacts. Anything else surfaces as a WARNING with a pointer
@@ -55,6 +55,13 @@ ALLOWED_FLAT_FILES: frozenset[str] = frozenset(
         # Consumer bridge marker (Phase 4 of road-to-global-only-install).
         # Spec: docs/contracts/consumer-bridge.md (event4u-bridge/v1).
         ".event4u-bridge.yml",
+        # Per-tool projection toggle — which generated trees
+        # `task generate-tools` writes (`.claude/`, `.cursor/`,
+        # `.clinerules/`, `.windsurfrules`). Lives at agents/ root
+        # because both the package and the consumer generators read
+        # it before any subdirectory is touched (ADR-028 § Root layout
+        # toggle).
+        ".agent-tools.yml",
     }
 )
 
@@ -76,21 +83,21 @@ def is_source_repo(project_root: Path) -> bool:
     """True when running inside the agent-config source repo.
 
     The maintainer surface is identified by **any** of:
-      - ``.agent-src.uncompressed/`` at the workspace root (legacy / single-pack layout),
-      - ``packages/<pack>/.agent-src.uncompressed/`` (current monorepo layout — see ``AGENTS.md``),
-      - ``.agent-src/`` at the workspace root (compressed authoring tree).
+      - ``.agent-src.uncondensed/`` at the workspace root (legacy / single-pack layout),
+      - ``packages/<pack>/.agent-src.uncondensed/`` (current monorepo layout — see ``AGENTS.md``),
+      - ``.agent-src/`` at the workspace root (condensed authoring tree).
 
     Consumer repos ship none of these — they only carry the deployed
     `.augment/`, `.claude/`, etc. plus `agents/overrides/`.
     """
-    if (project_root / ".agent-src.uncompressed").is_dir():
+    if (project_root / ".agent-src.uncondensed").is_dir():
         return True
     if (project_root / ".agent-src").is_dir():
         return True
     packages = project_root / "packages"
     if packages.is_dir():
         for sub in packages.iterdir():
-            if (sub / ".agent-src.uncompressed").is_dir():
+            if (sub / ".agent-src.uncondensed").is_dir():
                 return True
     return False
 

package/scripts/lint_agents_md.py

@@ -2,7 +2,7 @@
 """Thin-Root contract linter for AGENTS.md files (Phase 7).
 
 Enforces caps + pointer-ratio + pointer-anatomy + emergency-triage
-contract from `.agent-src.uncompressed/skills/agents-md-thin-root/SKILL.md`:
+contract from `.agent-src.uncondensed/skills/agents-md-thin-root/SKILL.md`:
 
   (a) total char-count under FAIL/WARN budgets per file class
   (b) substantive-pointer ratio >= 0.40
@@ -65,7 +65,7 @@ class Target:
 TARGETS = [
     Target(ROOT / "AGENTS.md", "package-root", 3000, 2800, template=False),
     Target(
-        ROOT / "packages" / "core" / ".agent-src.uncompressed" / "templates" / "AGENTS.md",
+        ROOT / "packages" / "core" / ".agent-src.uncondensed" / "templates" / "AGENTS.md",
         "consumer-template", 2500, 2300, template=True,
     ),
 ]
@@ -81,10 +81,10 @@ def _resolve(target_str: str, template: bool) -> bool:
         return True
     candidates = [ROOT / raw]
     if template and raw.startswith(".augment/"):
-        candidates.append(ROOT / raw.replace(".augment/", ".agent-src.uncompressed/", 1))
+        candidates.append(ROOT / raw.replace(".augment/", ".agent-src.uncondensed/", 1))
         candidates.append(ROOT / raw.replace(".augment/", ".agent-src/", 1))
     if raw.startswith(".agent-src/"):
-        candidates.append(ROOT / raw.replace(".agent-src/", ".agent-src.uncompressed/", 1))
+        candidates.append(ROOT / raw.replace(".agent-src/", ".agent-src.uncondensed/", 1))
     return any(c.exists() for c in candidates)
 
 

package/scripts/lint_archived_skills.py

@@ -2,13 +2,13 @@
 """Lint archive notes under agents/evidence/archived-skills/.
 
 Enforces the contract from
-.agent-src.uncompressed/templates/skill-archive-note.md:
+.agent-src.uncondensed/templates/skill-archive-note.md:
 
   1. Every <slug>.md under agents/evidence/archived-skills/ has the six required
      frontmatter fields with valid values.
   2. `reason` is one of {unused, merged, superseded, deprecated}.
   3. When `reason ∈ {merged, superseded}` the `replacement` slug exists
-     under .agent-src.uncompressed/skills/.
+     under .agent-src.uncondensed/skills/.
   4. No archived slug still has a live SKILL.md (no zombies).
   5. No live SKILL.md cites an archived slug as a router target in
      its frontmatter `replaced_by:` field.
@@ -34,7 +34,7 @@ REPO = Path(__file__).resolve().parents[1]
 ARCHIVE_DIR = REPO / "agents" / "evidence" / "archived-skills"
 
 # Live skill directories live under every artefact root post-monorepo
-# Phase 4 (legacy + packages/*/.agent-src.uncompressed/skills/).
+# Phase 4 (legacy + packages/*/.agent-src.uncondensed/skills/).
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from _lib.agent_src import artefact_roots  # noqa: E402
 

package/scripts/lint_artefact_frontmatter.py

@@ -2,7 +2,7 @@
 """Lint Phase-4 discovery frontmatter on every artefact.
 
 Walks the same trees as `scripts/build_discovery_manifest.py` (skills,
-rules, commands, templates under `.agent-src.uncompressed/`) and asserts
+rules, commands, templates under `.agent-src.uncondensed/`) and asserts
 per-file that the five ADR-013 keys (`workspaces`, `packs`, `lifecycle`,
 `trust`, `install`) are present and well-formed:
 
@@ -31,7 +31,7 @@ except ImportError:  # pragma: no cover
     sys.exit(2)
 
 ROOT = Path(__file__).resolve().parents[1]
-SRC = ROOT / ".agent-src.uncompressed"
+SRC = ROOT / ".agent-src.uncondensed"
 VOCAB_DIR = ROOT / "config" / "discovery"
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))

package/scripts/lint_bench_ab.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Validate the A/B bench corpora + `docs/benchmark.md` shape.
+
+Phase 5 Step 3 of `agents/roadmaps/road-to-package-impact-benchmark.md`.
+
+Checks:
+
+- `internal/bench/corpora/ab-tracka.yaml`
+  - version: 1
+  - corpus_id: ab-tracka
+  - prompts: ≥ 30 entries
+  - per prompt: id, category ∈ {rule, skill}, expected_target, expected_keywords, prompt
+
+- `internal/bench/corpora/ab-trackb.yaml`
+  - version: 1
+  - corpus_id: ab-trackb
+  - tasks: ≥ 10 entries
+  - per task: id, category ∈ {bugfix, feature, refactor, uiaudit, testadd},
+    prompt, seed_files, success_criteria
+
+- `docs/benchmark.md` (if it exists)
+  - carries every section in REQUIRED_SECTIONS
+
+Exit 0 on success, 1 on the first violation (with file + line where possible).
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+TRACK_A_PATH = REPO_ROOT / "internal" / "bench" / "corpora" / "ab-tracka.yaml"
+TRACK_B_PATH = REPO_ROOT / "internal" / "bench" / "corpora" / "ab-trackb.yaml"
+DOCS_PATH = REPO_ROOT / "docs" / "benchmark.md"
+
+REQUIRED_SECTIONS = (
+    "## Headline",
+    "## Track A",
+    "## Track B",
+    "## Methodology",
+    "## History",
+)
+
+TRACK_A_CATEGORIES = {"rule", "skill"}
+TRACK_B_CATEGORIES = {"bugfix", "feature", "refactor", "uiaudit", "testadd"}
+
+try:
+    import yaml
+except ImportError:
+    sys.stderr.write("lint_bench_ab: PyYAML required (pip install pyyaml)\n")
+    raise SystemExit(2)
+
+
+class LintError(Exception):
+    pass
+
+
+def _fail(path: Path, msg: str) -> None:
+    sys.stderr.write(f"lint_bench_ab: {path.relative_to(REPO_ROOT)}: {msg}\n")
+    raise LintError(msg)
+
+
+def lint_track_a() -> None:
+    if not TRACK_A_PATH.exists():
+        _fail(TRACK_A_PATH, "missing corpus file")
+    data = yaml.safe_load(TRACK_A_PATH.read_text())
+    if data.get("version") != 1:
+        _fail(TRACK_A_PATH, f"version must be 1 (got {data.get('version')!r})")
+    if data.get("corpus_id") != "ab-tracka":
+        _fail(TRACK_A_PATH, f"corpus_id must be 'ab-tracka' (got {data.get('corpus_id')!r})")
+    prompts = data.get("prompts") or []
+    if not isinstance(prompts, list):
+        _fail(TRACK_A_PATH, "prompts must be a list")
+    if len(prompts) < 30:
+        _fail(TRACK_A_PATH, f"prompts must have ≥ 30 entries (found {len(prompts)})")
+    ids = set()
+    for i, prompt in enumerate(prompts):
+        loc = f"prompts[{i}]"
+        if not isinstance(prompt, dict):
+            _fail(TRACK_A_PATH, f"{loc} must be a mapping")
+        pid = prompt.get("id")
+        if not isinstance(pid, str) or not pid:
+            _fail(TRACK_A_PATH, f"{loc}.id must be a non-empty string")
+        if pid in ids:
+            _fail(TRACK_A_PATH, f"{loc}.id duplicates an earlier id ({pid!r})")
+        ids.add(pid)
+        cat = prompt.get("category")
+        if cat not in TRACK_A_CATEGORIES:
+            _fail(TRACK_A_PATH, f"{loc}.category must be in {TRACK_A_CATEGORIES} (got {cat!r})")
+        target = prompt.get("expected_target")
+        if not isinstance(target, str) or not target:
+            _fail(TRACK_A_PATH, f"{loc}.expected_target must be a non-empty string")
+        keywords = prompt.get("expected_keywords")
+        if keywords is not None and not isinstance(keywords, list):
+            _fail(TRACK_A_PATH, f"{loc}.expected_keywords must be a list when present")
+        if not isinstance(prompt.get("prompt"), str) or not prompt["prompt"]:
+            _fail(TRACK_A_PATH, f"{loc}.prompt must be a non-empty string")
+
+
+def lint_track_b() -> None:
+    if not TRACK_B_PATH.exists():
+        _fail(TRACK_B_PATH, "missing corpus file")
+    data = yaml.safe_load(TRACK_B_PATH.read_text())
+    if data.get("version") != 1:
+        _fail(TRACK_B_PATH, f"version must be 1 (got {data.get('version')!r})")
+    if data.get("corpus_id") != "ab-trackb":
+        _fail(TRACK_B_PATH, f"corpus_id must be 'ab-trackb' (got {data.get('corpus_id')!r})")
+    tasks = data.get("tasks") or []
+    if not isinstance(tasks, list):
+        _fail(TRACK_B_PATH, "tasks must be a list")
+    if len(tasks) < 10:
+        _fail(TRACK_B_PATH, f"tasks must have ≥ 10 entries (found {len(tasks)})")
+    ids = set()
+    for i, task in enumerate(tasks):
+        loc = f"tasks[{i}]"
+        if not isinstance(task, dict):
+            _fail(TRACK_B_PATH, f"{loc} must be a mapping")
+        tid = task.get("id")
+        if not isinstance(tid, str) or not tid:
+            _fail(TRACK_B_PATH, f"{loc}.id must be a non-empty string")
+        if tid in ids:
+            _fail(TRACK_B_PATH, f"{loc}.id duplicates an earlier id ({tid!r})")
+        ids.add(tid)
+        cat = task.get("category")
+        if cat not in TRACK_B_CATEGORIES:
+            _fail(TRACK_B_PATH, f"{loc}.category must be in {TRACK_B_CATEGORIES} (got {cat!r})")
+        if not isinstance(task.get("prompt"), str) or not task["prompt"]:
+            _fail(TRACK_B_PATH, f"{loc}.prompt must be a non-empty string")
+        seeds = task.get("seed_files")
+        if not isinstance(seeds, list):
+            _fail(TRACK_B_PATH, f"{loc}.seed_files must be a list")
+        crit = task.get("success_criteria")
+        if not isinstance(crit, dict) or not crit:
+            _fail(TRACK_B_PATH, f"{loc}.success_criteria must be a non-empty mapping")
+
+
+def lint_doc(quiet: bool) -> None:
+    if not DOCS_PATH.exists():
+        if not quiet:
+            sys.stdout.write(
+                f"lint_bench_ab: {DOCS_PATH.relative_to(REPO_ROOT)} not yet rendered "
+                "(run task bench:ab:diff) — skipping doc shape check\n"
+            )
+        return
+    body = DOCS_PATH.read_text()
+    missing = [section for section in REQUIRED_SECTIONS if section not in body]
+    if missing:
+        _fail(DOCS_PATH, f"missing required sections: {missing}")
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate A/B bench corpora + docs/benchmark.md.")
+    parser.add_argument("--quiet", action="store_true", help="Only emit on error.")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv if argv is not None else sys.argv[1:])
+    try:
+        lint_track_a()
+        lint_track_b()
+        lint_doc(args.quiet)
+    except LintError:
+        return 1
+    if not args.quiet:
+        sys.stdout.write("lint_bench_ab: OK\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/lint_bench_corpus.py

@@ -40,7 +40,7 @@ REPO = Path(__file__).resolve().parents[1]
 CORPUS_DIR = REPO / "tests" / "eval"
 
 # Live skill directories live under every artefact root post-monorepo
-# Phase 4 (legacy + packages/*/.agent-src.uncompressed/skills/).
+# Phase 4 (legacy + packages/*/.agent-src.uncondensed/skills/).
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from _lib.agent_src import artefact_roots  # noqa: E402
 

package/scripts/lint_command_tiers.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Lint slash-command frontmatter for the `tier:` key.
 
-Hard-fails CI if any command under .agent-src.uncompressed/commands/
+Hard-fails CI if any command under .agent-src.uncondensed/commands/
 lacks a `tier:` declaration or uses an unknown tier value. The valid
 tier set is locked by docs/contracts/command-surface-tiers.md.
 
@@ -27,7 +27,7 @@ from _lib.agent_src import artefact_roots  # noqa: E402
 COMMANDS_DIRS = [root / "commands" for root in artefact_roots() if (root / "commands").is_dir()]
 # Consumer-facing projection — must also carry tier so .augment/commands/
 # (which symlinks to .agent-src/commands/) renders the tier filter.
-COMMANDS_DIR_COMPRESSED = REPO / ".agent-src" / "commands"
+COMMANDS_DIR_CONDENSED = REPO / ".agent-src" / "commands"
 
 VALID_TIERS = frozenset({"0", "1", "2"})
 
@@ -116,11 +116,11 @@ def main() -> int:
     rc = 0
     for commands_dir in COMMANDS_DIRS:
         rc |= lint(commands_dir, quiet=QUIET)
-    # The compressed projection is the consumer-facing tree (via the
+    # The condensed projection is the consumer-facing tree (via the
     # .augment/commands → .agent-src/commands symlink). It must also
     # carry tier so the surface stays uniform.
-    if COMMANDS_DIR_COMPRESSED.is_dir():
-        rc |= lint(COMMANDS_DIR_COMPRESSED, quiet=QUIET)
+    if COMMANDS_DIR_CONDENSED.is_dir():
+        rc |= lint(COMMANDS_DIR_CONDENSED, quiet=QUIET)
     return rc
 
 

package/scripts/lint_context_spine_usage.py

@@ -28,7 +28,7 @@ QUIET = "--quiet" in sys.argv
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 SKILL_GLOBS = (
-    ".agent-src.uncompressed/skills/**/SKILL.md",
+    ".agent-src.uncondensed/skills/**/SKILL.md",
     ".agent-src/skills/**/SKILL.md",
 )
 VALID_SLOTS = (