@event4u/agent-config 6.0.0 → 6.1.0

package/src/scripts/audit_command_surface.py

@@ -58,10 +58,13 @@ DOCS_DIR = REPO_ROOT / "docs"
 # Per-size-class VISIBLE-command budgets (docs/contracts/capability-packs.md;
 # enforced as a CI gate by 6.0.0-C Phase 1). `internal` commands are uncapped.
 SIZE_BUDGETS = {"core": 8, "small": 2, "medium": 5, "large": 8, "platform": 10}
-# Proxy until the `visibility:` field lands (6.0.0-C Step 4b): a command counts
-# toward the budget when its tier surfaces it (tier 0 daily-driver / tier 1
-# power-user). tier 2 (or absent → defaults to 2) is internal/uncapped.
+# ADR-090: `visibility:` is the named source of truth (visible / advanced /
+# internal); the integer `tier:` is a back-compat alias. A command counts
+# toward the per-pack budget when it is surfaced — visibility in {visible,
+# advanced} (or, when only the alias is present, tier in {0,1}). `internal`
+# (or absent → defaults to internal) is uncapped.
 VISIBLE_TIERS = {0, 1}
+VISIBLE_VISIBILITIES = {"visible", "advanced"}
 
 FRONTMATTER_RE = re.compile(r"^---\n(.*?)\n---", re.DOTALL)
 DESCRIPTION_RE = re.compile(r'^description:\s*"?(.*?)"?\s*$', re.MULTILINE)
@@ -69,6 +72,7 @@ ALIASES_RE = re.compile(r"^aliases:\s*(.*)$", re.MULTILINE)
 NAME_RE = re.compile(r"^name:\s*(.*)$", re.MULTILINE)
 CLUSTER_RE = re.compile(r"^cluster:\s*(.*)$", re.MULTILINE)
 TIER_RE = re.compile(r"^tier:\s*(\d+)", re.MULTILINE)
+VISIBILITY_RE = re.compile(r"^visibility:\s*(visible|advanced|internal)", re.MULTILINE)
 PACK_RE = re.compile(r"^pack:\s*(.*)$", re.MULTILINE)
 
 STOPWORDS = {
@@ -96,6 +100,7 @@ class Command:
     description: str
     aliases: List[str] = field(default_factory=list)
     tier: int | None = None
+    visibility: str | None = None
     cluster: str = ""
     pack: str = ""
     line_count: int = 0
@@ -120,6 +125,8 @@ def parse_frontmatter(text: str) -> dict:
         out["cluster"] = c.group(1).strip().strip('"').strip("'")
     if t := TIER_RE.search(block):
         out["tier"] = int(t.group(1))
+    if v := VISIBILITY_RE.search(block):
+        out["visibility"] = v.group(1)
     if pk := PACK_RE.search(block):
         out["pack"] = pk.group(1).strip().strip('"').strip("'")
     if a := ALIASES_RE.search(block):
@@ -204,6 +211,7 @@ def collect(root: Path) -> List[Command]:
             description=fm.get("description", ""),
             aliases=fm.get("aliases", []),
             tier=fm.get("tier"),
+            visibility=fm.get("visibility"),
             cluster=fm.get("cluster", ""),
             pack=fm.get("pack", ""),
             line_count=len(text.splitlines()),
@@ -394,7 +402,10 @@ def citation_count(name: str) -> int:
 
 
 def _is_visible(c: Command) -> bool:
-    # Absent tier defaults to 2 (internal) per command-surface-tiers.md.
+    # ADR-090: prefer the named visibility field; fall back to the tier alias.
+    # Absent both → internal per command-surface-tiers.md.
+    if c.visibility is not None:
+        return c.visibility in VISIBLE_VISIBILITIES
     return (c.tier if c.tier is not None else 2) in VISIBLE_TIERS
 
 
@@ -552,10 +563,12 @@ def grown_packs(baseline: str, commands: List[Command]) -> dict[str, list[str]]:
         cmd = by_relpath.get(relpath)
         if cmd is None or not cmd.pack:
             continue
-        if not _is_visible_tier(cmd.tier):
+        if not _is_visible(cmd):
             continue  # internal now — never counts toward a visible budget
         if relpath in modified and relpath not in added:
             # Modified file: only a *promotion* into visibility grows the surface.
+            # Baseline is historical (pre-ADR-090) so it carries only the tier
+            # alias — the tier proxy is the correct read for the old revision.
             if _is_visible_tier(_tier_at_ref(baseline, relpath)):
                 continue  # was already visible — not a new surface
         grew.setdefault(cmd.pack, []).append(cmd.name)

package/src/scripts/audit_mcp_tools.py

@@ -7,7 +7,7 @@ registry at `scripts/mcp_server/tools.py`, emits
 claim is banned.
 
 Contract: step-11 Phase 5 Step 3
-(agents/roadmaps/step-11-ruflo-parity.md).
+(an internal parity roadmap (local-only)).
 
 Modes:
   --check    exit non-zero if the generated inventory drifts from
@@ -73,7 +73,7 @@ def _render(catalog: dict, handlers: dict[str, int], cat_lines: dict[str, int])
     lines.append("> [`scripts/mcp_server/consumer_tool_catalog.json`](../../scripts/mcp_server/consumer_tool_catalog.json).")
     lines.append("> Do **not** hand-edit; rerun `python3 scripts/audit_mcp_tools.py --write`.")
     lines.append(">")
-    lines.append("> Step-11 Phase 5 Step 3 (`step-11-ruflo-parity.md`).")
+    lines.append("> Step-11 Phase 5 Step 3 (an internal parity roadmap (local-only)).")
     lines.append("")
     lines.append("## Summary")
     lines.append("")

package/src/scripts/audit_skill_descriptions.py

@@ -8,8 +8,8 @@ Flags descriptions that are:
   - containing hedge terms ("may help", "can be useful", "covers various", ...)
 
 Context:
-  `archive/road-to-anthropic-alignment.md` Phase 2.2 — "pushy description" pattern from
-  anthropics/skills/skills/skill-creator (roadmap archived 2026-04-21).
+  `archive/road-to-anthropic-alignment.md` Phase 2.2 — "pushy description" pattern
+  adapted from an external reference (roadmap archived 2026-04-21).
 
 Usage:
   python3 scripts/audit_skill_descriptions.py               # human table

package/src/scripts/bench_ab_clone.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Materialise the `with` and `without` clones for the package-impact A/B bench.
+"""Materialise the `with`, `without`, and `with-rdp` clones for the value bench.
 
 Phase 1 Step 2 of `agents/roadmaps/road-to-package-impact-benchmark.md`.
 
@@ -55,7 +55,44 @@ def copytree_preserve(src: Path, dst: Path) -> None:
     """
     if dst.exists():
         shutil.rmtree(dst)
-    shutil.copytree(src, dst, symlinks=False)
+    _patterns = shutil.ignore_patterns("worktrees", ".git", "clones", "node_modules")
+
+    def _ignore(directory: str, names: list[str]) -> set[str]:
+        # Exclude local dev / VCS artifacts (worktrees alone are ~740 MB and are
+        # NOT part of the agent-config surface a consumer receives) AND any broken
+        # symlink. The projected `.claude` surface can carry a stale symlink — e.g.
+        # a rule renamed in src/ but not yet re-projected — and `symlinks=False`
+        # would try to copy its missing target and crash. `os.path.exists` resolves
+        # each symlink from its own directory (unlike copytree's flaky
+        # `ignore_dangling_symlinks`, which checks the raw target against the CWD).
+        skip = set(_patterns(directory, names))
+        for name in names:
+            path = os.path.join(directory, name)
+            if os.path.islink(path) and not os.path.exists(path):
+                skip.add(name)
+        return skip
+
+    shutil.copytree(src, dst, symlinks=False, ignore=_ignore)
+
+
+def write_clone_settings(variant: str, target: Path) -> None:
+    """Write a minimal `.agent-settings.yml` carrying the RDP toggle.
+
+    `with` pins `reasoning.enabled: false` (package without the RDP lift);
+    `with-rdp` sets `reasoning.enabled: true` (package + RDP lift). This is the
+    A/B/C lever for the 3-condition value benchmark — the RDP artifacts in the
+    copied surface are gated on this flag (see contexts/execution/rdp-gate.md),
+    so the diff between the two `with*` clones is exactly the lift under test.
+    """
+    enabled = "true" if variant == "with-rdp" else "false"
+    settings = (
+        "# Generated by bench_ab_clone.py for the A/B/C value benchmark.\n"
+        "# Only the RDP toggle is set here; everything else uses package defaults.\n"
+        "reasoning:\n"
+        f"  enabled: {enabled}\n"
+        "  auto_gate: true\n"
+    )
+    (target / ".agent-settings.yml").write_text(settings)
 
 
 def materialise_clone(variant: str, target: Path) -> None:
@@ -68,15 +105,15 @@ def materialise_clone(variant: str, target: Path) -> None:
             copytree_preserve(entry, dest)
         else:
             shutil.copy2(entry, dest)
-    # Layer the agent-config surface onto the `with` variant
-    if variant == "with":
+    # Layer the agent-config surface onto the `with` + `with-rdp` variants
+    if variant in ("with", "with-rdp"):
         for surface in WITH_SURFACES:
             src = REPO_ROOT / surface
             if not src.exists():
                 # Best-effort: a missing surface is reported but does not fail
                 sys.stderr.write(
                     f"bench_ab_clone: surface '{surface}' missing in package root; "
-                    "with-clone may not be representative\n"
+                    f"{variant}-clone may not be representative\n"
                 )
                 continue
             dest = target / surface
@@ -84,6 +121,10 @@ def materialise_clone(variant: str, target: Path) -> None:
                 copytree_preserve(src, dest)
             else:
                 shutil.copy2(src, dest)
+        # The RDP cost-gate reads `reasoning.enabled` from .agent-settings.yml,
+        # which is NOT in WITH_SURFACES. Write a minimal settings file so the
+        # toggle is the explicit A/B/C lever: `with` = RDP off, `with-rdp` = on.
+        write_clone_settings(variant, target)
 
 
 def target_shape_hash() -> str:
@@ -108,8 +149,9 @@ def write_manifest(variant: str, target: Path) -> None:
     """Drop a small manifest so other scripts can verify the clone shape."""
     manifest = {
         "variant": variant,
+        "reasoning_enabled": variant == "with-rdp",
         "target_shape_hash": target_shape_hash(),
-        "with_surfaces": list(WITH_SURFACES),
+        "with_surfaces": list(WITH_SURFACES) if variant in ("with", "with-rdp") else [],
         "fixture_relpath": FIXTURE.relative_to(REPO_ROOT).as_posix(),
     }
     (target / ".bench-ab-manifest.json").write_text(
@@ -117,16 +159,18 @@ def write_manifest(variant: str, target: Path) -> None:
     )
 
 
-def clone(variant: str, *, refresh: bool) -> Path:
+def clone(variant: str, *, refresh: bool, quiet: bool = False) -> Path:
     target = CLONES / variant
     if target.exists() and not refresh:
-        sys.stdout.write(f"bench_ab_clone: {variant} clone already present at {target} (use --refresh to rebuild)\n")
+        if not quiet:
+            sys.stdout.write(f"bench_ab_clone: {variant} clone already present at {target} (use --refresh to rebuild)\n")
         return target
     if target.exists():
         shutil.rmtree(target)
     materialise_clone(variant, target)
     write_manifest(variant, target)
-    sys.stdout.write(f"bench_ab_clone: built {variant} clone at {target}\n")
+    if not quiet:
+        sys.stdout.write(f"bench_ab_clone: built {variant} clone at {target}\n")
     return target
 
 
@@ -141,9 +185,10 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     )
     parser.add_argument(
         "--variant",
-        choices=("with", "without", "both"),
+        choices=("with", "without", "with-rdp", "both", "all"),
         default="both",
-        help="Which clone to materialise (default: both).",
+        help="Which clone(s): with | without | with-rdp | both (=with+without, "
+        "back-compat default) | all (=with+without+with-rdp, the 3-condition set).",
     )
     parser.add_argument(
         "--print-shape-hash",
@@ -160,7 +205,12 @@ def main(argv: list[str] | None = None) -> int:
     if args.print_shape_hash:
         sys.stdout.write(target_shape_hash() + "\n")
         return 0
-    variants = ("with", "without") if args.variant == "both" else (args.variant,)
+    if args.variant == "both":
+        variants = ("with", "without")
+    elif args.variant == "all":
+        variants = ("with", "without", "with-rdp")
+    else:
+        variants = (args.variant,)
     for v in variants:
         clone(v, refresh=args.refresh)
     return 0