@event4u/agent-config 2.26.0 → 3.1.0

package/scripts/measure_frugality_savings.py

@@ -3,7 +3,7 @@
 
 Measures the *current state* of the frugality canon along four
 deterministic axes. Output: JSONL baseline appended to
-agents/.frugality-baseline.jsonl (gitignored).
+agents/runtime/frugality/baseline.jsonl (gitignored).
 
 Metrics:
   A. footprint    — per-rule char/token count, kernel/tier breakdown
@@ -140,7 +140,7 @@ def metric_d_redundancy(root: Path) -> dict:
 
 def main() -> int:
     root = Path(__file__).resolve().parent.parent
-    corpus = root / "agents" / ".agent-chat-history"
+    corpus = root / "agents" / "runtime" / ".agent-chat-history"
 
     record = {
         "schema_version": 1,
@@ -152,7 +152,7 @@ def main() -> int:
         "metric_d_redundancy": metric_d_redundancy(root),
     }
 
-    out = root / "agents" / ".frugality-baseline.jsonl"
+    out = root / "agents" / "runtime" / "frugality" / "baseline.jsonl"
     with out.open("a") as fh:
         fh.write(json.dumps(record, ensure_ascii=False) + "\n")
     print(json.dumps(record, indent=2, ensure_ascii=False))

package/scripts/measure_roadmap_trajectory.py

@@ -3,7 +3,7 @@
 
 Walks `agents/roadmaps/archive/` and computes per-roadmap checkbox
 completion ratio at archival time. Output: one-line trajectory metric
-per roadmap, plus an aggregate `agents/reports/roadmap-trajectory.json`.
+per roadmap, plus an aggregate `agents/runtime/reports/roadmap-trajectory.json`.
 
 Checkbox grammar (mirrors `scripts/roadmap_progress_check.py`):
 - `[ ]` — open

package/scripts/measure_rule_budget.py

@@ -26,9 +26,11 @@ import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from _lib.agent_src import artefact_roots  # noqa: E402
+
 OVERRIDES_FILE = REPO_ROOT / "docs" / "contracts" / "iron-law-overrides.txt"
-TREND_FILE = REPO_ROOT / "agents" / ".rule-budget-history.jsonl"
+TREND_FILE = REPO_ROOT / "agents" / "runtime" / ".rule-budget-history.jsonl"
 
 # Council R2 amendments (2026-05-06) — see docs/contracts/kernel-membership.md § 5.1.
 # Per-rule cap raised 1.5k → 2.5k; warning band raised 1.2k → 2.0k.
@@ -93,8 +95,24 @@ def measure_rule(path: Path) -> dict[str, object]:
 
 
 def collect() -> list[dict[str, object]]:
-    rules = [measure_rule(p) for p in sorted(RULES_DIR.glob("*.md"))]
-    return rules
+    """Collect rule measurements from every source root (multi-root aware).
+
+    Pre-move: reads .agent-src.uncompressed/rules/*.md.
+    Post-move (ADR-017): reads packages/*/.agent-src.uncompressed/rules/*.md.
+    Deduplicates on logical rule id (stem) — first root wins.
+    """
+    seen: set[str] = set()
+    rules: list[dict[str, object]] = []
+    for root in artefact_roots():
+        rules_dir = root / "rules"
+        if not rules_dir.is_dir():
+            continue
+        for p in sorted(rules_dir.glob("*.md")):
+            if p.stem in seen:
+                continue
+            seen.add(p.stem)
+            rules.append(measure_rule(p))
+    return sorted(rules, key=lambda r: r["id"])
 
 
 def load_overrides() -> set[str]:
@@ -138,7 +156,7 @@ def aggregate(rules: list[dict[str, object]]) -> dict[str, object]:
 
 def render_table(rules: list[dict[str, object]], agg: dict[str, object]) -> str:
     lines: list[str] = []
-    lines.append("Rule budget — source: .agent-src.uncompressed/rules/")
+    lines.append("Rule budget — source: rules/ under every artefact root (multi-root aware, ADR-017)")
     lines.append("")
     lines.append(f"{'id':<40} {'type':<7} {'tier':<5} {'chars':>7}")
     lines.append("-" * 62)
@@ -241,7 +259,7 @@ def kernel_budget_check(
 
 
 def trend_append(agg: dict[str, object]) -> tuple[int, str]:
-    """Append a daily snapshot to agents/.rule-budget-history.jsonl.
+    """Append a daily snapshot to agents/runtime/.rule-budget-history.jsonl.
 
     Idempotent per UTC day: if today's date already has a row, the file
     is not modified. Snapshot fields: date, kernel_chars, auto_chars,
@@ -284,7 +302,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument(
         "--trend-append",
         action="store_true",
-        help="append today's snapshot to agents/.rule-budget-history.jsonl (idempotent per UTC day)",
+        help="append today's snapshot to agents/runtime/.rule-budget-history.jsonl (idempotent per UTC day)",
     )
     args = parser.parse_args(argv)
 

package/scripts/memory_report.py

@@ -48,7 +48,7 @@ _MODE_MARKER_PATTERN = re.compile(
 )
 _MODE_SCAN_DIRS = (
     Path("agents/sessions"),
-    Path("agents/reports"),
+    Path("agents/runtime/reports"),
     Path("agents/handoffs"),
     Path("agents/learnings"),
 )

package/scripts/migrate_command_suggestions.py

@@ -2,7 +2,7 @@
 """One-shot migration: inject the `suggestion:` frontmatter block into every
 command under `.agent-src.uncompressed/commands/`.
 
-Source-of-truth table: `agents/contexts/command-suggestion-eligibility.md`
+Source-of-truth table: `agents/settings/contexts/command-suggestion-eligibility.md`
 (locked at end of road-to-context-aware-command-suggestion Phase 1).
 
 Idempotent: if `suggestion:` is already present for a command, the file is
@@ -55,8 +55,8 @@ ELIGIBLE: dict[str, tuple[str, str]] = {
     "bug-investigate": ("why is this broken, investigate this error, trace the root cause", "Sentry URL, Jira bug ticket key, or stack trace pasted in the prompt"),
     "commit": ("commit my changes, save this to git, create commits for these changes", "git status shows uncommitted changes"),
     "commit-in-chunks": ("commit everything autonomously, split and commit without confirmation", "autonomous mode active and uncommitted changes present"),
-    "context-create": ("document this part of the codebase, create a context doc for X", "working in a module without an agents/contexts/ doc"),
-    "context-refactor": ("update the context doc, refresh this context document", "existing agents/contexts/*.md referenced in the prompt"),
+    "context-create": ("document this part of the codebase, create a context doc for X", "working in a module without an agents/settings/contexts/ doc"),
+    "context-refactor": ("update the context doc, refresh this context document", "existing agents/settings/contexts/*.md referenced in the prompt"),
     "create-pr": ("open a PR, create a pull request, make a PR for this branch", "branch is ahead of base and not yet on a PR"),
     "create-pr-description": ("write a PR description, draft the PR text", "PR exists or branch ready for review without description"),
     "e2e-heal": ("fix the failing E2E tests, playwright tests are red", "failing test output from tests/e2e/"),

package/scripts/minimal_safe_diff_hook.py

@@ -11,7 +11,7 @@ Wired to multiple events via the manifest:
   - session_start / user_prompt_submit → reset turn-scoped counters
   - pre_tool_use → record the planned edit's path before execution
 
-Output: `agents/state/minimal-safe-diff.json`
+Output: `agents/runtime/state/minimal-safe-diff.json`
   {
     "schema_version": 1,
     "session_id": "<str>",

package/scripts/move_artefact.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Move a single artefact between packs via ``git mv`` (history-preserving).
+
+Phase 4.5 of the monorepo migration (ADR-017). Locates the artefact by
+slug or logical path, computes its destination under the requested
+pack, runs ``git mv`` for the artefact directory (skills/commands) or
+the single file (rules), and rewrites the ``packs:`` frontmatter so the
+discovery manifest stays in sync.
+
+CLI:
+  --id ID            artefact slug (skill/command name or rule stem)
+  --type TYPE        skill | rule | command (required when --id ambiguous)
+  --to PACK          target pack id (e.g. ``laravel``, ``core``)
+  --dry-run          print the planned move and frontmatter edit, no FS changes
+"""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+PACKAGES = ROOT / "packages"
+PACKS_VOCAB = ROOT / "config" / "discovery" / "packs.yml"
+
+
+def _list_pack_ids() -> set[str]:
+    data = yaml.safe_load(PACKS_VOCAB.read_text(encoding="utf-8")) or []
+    return {p["id"] for p in data} | {"core"}
+
+
+def _pack_dir(pack_id: str) -> Path:
+    return PACKAGES / ("core" if pack_id == "core" else f"pack-{pack_id}")
+
+
+def _find_artefact(slug: str, kind: str | None) -> tuple[Path, str, str]:
+    """Return (physical_path, detected_kind, current_pack_id)."""
+    hits: list[tuple[Path, str, str]] = []
+    for pkg in sorted(PACKAGES.iterdir()):
+        src = pkg / ".agent-src.uncompressed"
+        if not src.is_dir():
+            continue
+        pid = "core" if pkg.name == "core" else pkg.name.removeprefix("pack-")
+        for k, rel in (("skill", f"skills/{slug}/SKILL.md"),
+                        ("rule", f"rules/{slug}.md"),
+                        ("command", f"commands/{slug}.md")):
+            p = src / rel
+            if p.exists() and (kind is None or kind == k):
+                hits.append((p, k, pid))
+    if not hits:
+        raise SystemExit(f"error: artefact '{slug}' not found under any pack")
+    if len(hits) > 1 and kind is None:
+        kinds = ", ".join(sorted({h[1] for h in hits}))
+        raise SystemExit(f"error: '{slug}' ambiguous (found as: {kinds}); pass --type")
+    return hits[0]
+
+
+def _move_root(path: Path, kind: str) -> Path:
+    """Return the path to git-mv (directory for skills, file for rule/command)."""
+    return path.parent if kind == "skill" else path
+
+
+def _rewrite_packs(md_path: Path, new_pack: str, dry_run: bool) -> bool:
+    text = md_path.read_text(encoding="utf-8")
+    if not text.startswith("---"):
+        return False
+    end = text.find("\n---", 4)
+    if end == -1:
+        return False
+    head = text[4:end]
+    body = text[end:]
+    fm = yaml.safe_load(head) or {}
+    if not isinstance(fm, dict):
+        return False
+    current = fm.get("packs") or []
+    desired = [] if new_pack == "core" else [new_pack]
+    if current == desired:
+        return False
+    if desired:
+        fm["packs"] = desired
+    else:
+        fm.pop("packs", None)
+    new_text = "---\n" + yaml.safe_dump(fm, sort_keys=False, allow_unicode=True) + body[1:]
+    if dry_run:
+        print(f"  would rewrite frontmatter packs: {current} -> {desired}")
+    else:
+        md_path.write_text(new_text, encoding="utf-8")
+        print(f"  rewrote frontmatter packs: {current} -> {desired}")
+    return True
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--id", required=True, help="artefact slug")
+    ap.add_argument("--to", required=True, help="target pack id")
+    ap.add_argument("--type", choices=["skill", "rule", "command"])
+    ap.add_argument("--dry-run", action="store_true")
+    args = ap.parse_args()
+
+    vocab = _list_pack_ids()
+    if args.to not in vocab:
+        print(f"error: target pack '{args.to}' not in {sorted(vocab)}", file=sys.stderr)
+        return 2
+
+    src_md, kind, current_pack = _find_artefact(args.id, args.type)
+    if current_pack == args.to:
+        print(f"no-op: '{args.id}' already lives in pack '{args.to}'")
+        return 0
+
+    src_root = _move_root(src_md, kind)
+    dest_pkg_src = _pack_dir(args.to) / ".agent-src.uncompressed"
+    rel_under_pack = src_root.relative_to(_pack_dir(current_pack) / ".agent-src.uncompressed")
+    dest_root = dest_pkg_src / rel_under_pack
+
+    print(f"plan: {kind} '{args.id}' : {current_pack} -> {args.to}")
+    print(f"  git mv {src_root.relative_to(ROOT)} {dest_root.relative_to(ROOT)}")
+
+    # Frontmatter must be rewritten BEFORE the move so the new physical
+    # location matches the declared pack. Discovery scanner cross-checks.
+    _rewrite_packs(src_md, args.to, args.dry_run)
+
+    if args.dry_run:
+        print("dry-run: no FS changes")
+        return 0
+
+    dest_root.parent.mkdir(parents=True, exist_ok=True)
+    result = subprocess.run(
+        ["git", "mv", str(src_root.relative_to(ROOT)), str(dest_root.relative_to(ROOT))],
+        cwd=ROOT, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        print(f"git mv failed: {result.stderr}", file=sys.stderr)
+        return result.returncode
+    print(f"moved: {src_root.relative_to(ROOT)} -> {dest_root.relative_to(ROOT)}")
+    print("next: run `task sync` and `task lint-pack-boundaries`")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/new_skill.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Interactive scaffolder for new skills under the packages/ layout.
+
+Phase 4.5 of the monorepo migration (ADR-017). Asks for pack, type,
+name, workspaces, and description, then drops a templated artefact
+into ``packages/<pack-dir>/.agent-src.uncompressed/<type>s/<name>/SKILL.md``.
+
+Type → directory mapping:
+  - skill    → skills/<name>/SKILL.md
+  - rule     → rules/<name>.md
+  - command  → commands/<name>.md
+
+CLI (non-interactive overrides):
+  --pack PACK         pack id (e.g. ``laravel`` or ``core``)
+  --type TYPE         skill | rule | command (default: skill)
+  --name NAME         artefact slug (kebab-case)
+  --description TEXT  one-line description (trigger phrasing)
+  --workspace WS      repeatable; defaults to pack's owner list
+  --force             overwrite if file exists
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[1]
+PACKAGES = ROOT / "packages"
+PACKS_VOCAB = ROOT / "config" / "discovery" / "packs.yml"
+
+TEMPLATES = {
+    "skill": "skills/{name}/SKILL.md",
+    "rule": "rules/{name}.md",
+    "command": "commands/{name}.md",
+}
+
+
+def _load_vocab() -> dict[str, dict[str, Any]]:
+    if not PACKS_VOCAB.exists():
+        return {}
+    data = yaml.safe_load(PACKS_VOCAB.read_text(encoding="utf-8")) or []
+    return {p["id"]: p for p in data}
+
+
+def _list_packs() -> list[str]:
+    if not PACKAGES.exists():
+        return []
+    return sorted([
+        ("core" if p.name == "core" else p.name.removeprefix("pack-"))
+        for p in PACKAGES.iterdir() if p.is_dir()
+    ])
+
+
+def _pack_dir(pack_id: str) -> Path:
+    return PACKAGES / ("core" if pack_id == "core" else f"pack-{pack_id}")
+
+
+def _prompt(label: str, default: str | None = None, choices: list[str] | None = None) -> str:
+    suffix = f" [{default}]" if default else ""
+    if choices:
+        suffix = f" ({'/'.join(choices)})" + suffix
+    while True:
+        raw = input(f"{label}{suffix}: ").strip()
+        if not raw and default is not None:
+            return default
+        if choices and raw not in choices:
+            print(f"  must be one of: {', '.join(choices)}")
+            continue
+        if raw:
+            return raw
+
+
+def _frontmatter(name: str, description: str, workspaces: list[str], pack: str) -> str:
+    fm: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "source": "package",
+        "workspaces": workspaces,
+        "packs": [pack] if pack != "core" else [],
+        "lifecycle": "active",
+        "trust": {"level": "professional", "confidence": "medium", "human_review_required": False},
+        "install": {"default": False, "removable": True},
+    }
+    if not fm["packs"]:
+        del fm["packs"]
+    return "---\n" + yaml.safe_dump(fm, sort_keys=False, allow_unicode=True) + "---\n"
+
+
+def _body(kind: str, name: str, description: str) -> str:
+    if kind == "skill":
+        return (
+            f"\n# {name}\n\n## When to use\n\n{description}\n\n## Procedure\n\n"
+            "1. _TODO: replace with the real step-by-step._\n\n"
+            "## Examples\n\n_TODO: copy-pasteable example._\n"
+        )
+    if kind == "rule":
+        return f"\n# {name}\n\n{description}\n\n## Iron Law\n\n```\nTODO\n```\n"
+    return f"\n# {name}\n\n{description}\n\n## Steps\n\n1. _TODO_\n"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--pack")
+    ap.add_argument("--type", dest="kind", choices=list(TEMPLATES))
+    ap.add_argument("--name")
+    ap.add_argument("--description")
+    ap.add_argument("--workspace", action="append", default=[])
+    ap.add_argument("--force", action="store_true")
+    args = ap.parse_args()
+
+    packs = _list_packs()
+    if not packs:
+        print("error: no packages/ tree found", file=sys.stderr)
+        return 2
+    vocab = _load_vocab()
+    interactive = sys.stdin.isatty()
+    pack = args.pack or (_prompt("pack", default="core", choices=packs) if interactive else "core")
+    if pack not in packs:
+        print(f"error: pack '{pack}' not in {packs}", file=sys.stderr)
+        return 2
+    kind = args.kind or (_prompt("type", default="skill", choices=list(TEMPLATES)) if interactive else "skill")
+    name = args.name or (_prompt("name (kebab-case)") if interactive else "")
+    if not name or " " in name or name != name.lower():
+        print(f"error: name '{name}' must be lowercase kebab-case", file=sys.stderr)
+        return 2
+    description = args.description or (_prompt("description (one line)") if interactive else "TODO: describe trigger")
+    workspaces = args.workspace or vocab.get(pack, {}).get("workspaces") or ["engineering"]
+
+    rel = TEMPLATES[kind].format(name=name)
+    out = _pack_dir(pack) / ".agent-src.uncompressed" / rel
+    if out.exists() and not args.force:
+        print(f"error: {out.relative_to(ROOT)} exists (use --force)", file=sys.stderr)
+        return 1
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(_frontmatter(name, description, workspaces, pack) + _body(kind, name, description), encoding="utf-8")
+    print(f"created: {out.relative_to(ROOT)}")
+    print("next steps:")
+    print("  1. flesh out the body")
+    print("  2. run `task sync` to project into .agent-src/ and .augment/")
+    print("  3. run `task lint-skills` for validation")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/onboarding_gate_hook.py

@@ -5,7 +5,7 @@ Reads `.agent-settings.yml` from the consumer repo and writes a
 deterministic state file the rule body can cite as the source of
 truth for "do I need to prompt the user about /onboard?".
 
-Output is written to `agents/state/onboarding-gate.json` with:
+Output is written to `agents/runtime/state/onboarding-gate.json` with:
   {
     "required": <bool>,         // true → rule fires on first turn
     "reason":   "<string>",     // why this state was set
@@ -31,7 +31,7 @@ import sys
 from pathlib import Path
 
 # Re-use the shared atomic-write helper so concerns honour the single
-# `agents/state/.dispatcher.lock` discipline (hook-architecture-v1.md
+# `agents/runtime/state/.dispatcher.lock` discipline (hook-architecture-v1.md
 # § Concurrency, Phase 7.4).
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from hooks.state_io import atomic_write_json  # noqa: E402
@@ -84,9 +84,9 @@ def _read_onboarded(settings_path: Path) -> tuple[bool, str]:
 
 def _write_state(consumer_root: Path, required: bool, reason: str,
                  settings_present: bool) -> None:
-    """Write `agents/state/onboarding-gate.json` atomically.
+    """Write `agents/runtime/state/onboarding-gate.json` atomically.
 
-    Uses the shared `agents/state/.dispatcher.lock` so concurrent
+    Uses the shared `agents/runtime/state/.dispatcher.lock` so concurrent
     dispatcher invocations across platforms cannot tear the file
     (hook-architecture-v1.md § Concurrency, Phase 7.4).
     """