@event4u/agent-config 2.26.0 → 3.1.0

package/scripts/plan_physical_move.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""Plan + apply the physical monorepo migration (Phase 4).
+
+Reads every `.md` artefact under `.agent-src.uncompressed/`, decides
+its destination under `packages/core/` or `packages/pack-<id>/` using
+the deterministic rules from
+`agents/roadmaps/monorepo-phase-4-physical-package-layout.md` § Mapping
+rules, and emits `dist/migration/move-plan.json`.
+
+CLI:
+  --dry-run   (default) emit the plan JSON only; no FS changes
+  --apply     execute the moves via `git mv` (history-preserving)
+
+Schema: see docs/contracts/move-plan.schema.json (added in this phase).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from validate_frontmatter import parse_frontmatter  # noqa: E402
+
+ROOT = Path(__file__).resolve().parents[1]
+SRC = ROOT / ".agent-src.uncompressed"
+PACKAGES = ROOT / "packages"
+CORE = PACKAGES / "core" / ".agent-src.uncompressed"
+VOCAB_DIR = ROOT / "config" / "discovery"
+PLAN_OUT = ROOT / "dist" / "migration" / "move-plan.json"
+UNASSIGNED_YAML = VOCAB_DIR / "unassigned-artefacts.yml"
+
+# Locked kernel — `docs/contracts/kernel-membership.md` § 4. Pinned to
+# core regardless of frontmatter (sanity check, not duplication).
+KERNEL_RULES = frozenset({
+    "agent-authority",
+    "ask-when-uncertain",
+    "commit-policy",
+    "direct-answers",
+    "language-and-tone",
+    "no-cheap-questions",
+    "non-destructive-by-default",
+    "scope-control",
+    "verify-before-complete",
+    "user-interrupt-priority",  # admitted post-P2.2
+})
+
+# Non-frontmatter trees that follow the host package (core) by default.
+# Scaffold templates, profiles, presets, contexts, user-types, scripts,
+# ghostwriter, packs — none of these carry pack metadata.
+CORE_DIRS = (
+    "templates",
+    "profiles",
+    "presets",
+    "contexts",
+    "user-types",
+    "scripts",
+    "ghostwriter",
+    "packs",
+    "personas",
+)
+
+
+def _load_pack_ids() -> set[str]:
+    packs = yaml.safe_load((VOCAB_DIR / "packs.yml").read_text(encoding="utf-8")) or []
+    return {p["id"] for p in packs}
+
+
+def _load_unassigned() -> dict[str, str]:
+    raw = yaml.safe_load(UNASSIGNED_YAML.read_text(encoding="utf-8")) or []
+    return {e["path"]: e["reason"] for e in raw}
+
+
+def _is_core(fm: dict[str, Any] | None, stem: str) -> bool:
+    if stem in KERNEL_RULES:
+        return True
+    if fm is None:
+        return False
+    trust = fm.get("trust") or {}
+    install = fm.get("install") or {}
+    return (
+        trust.get("level") == "core"
+        and install.get("removable") is False
+    )
+
+
+def _primary_pack(fm: dict[str, Any] | None) -> str | None:
+    """Round-2 council refinement R1: explicit ``primary_pack:`` wins over
+    ``packs[0]`` fallback. The ``primary_pack`` lint lands in Phase 4.4.
+    """
+    if not fm:
+        return None
+    explicit = fm.get("primary_pack")
+    if isinstance(explicit, str) and explicit.strip():
+        return explicit.strip()
+    packs = fm.get("packs")
+    if not isinstance(packs, list) or not packs:
+        return None
+    return packs[0]
+
+
+def _dest_for(src: Path, fm: dict[str, Any] | None, pack_ids: set[str]) -> tuple[Path, str, str | None]:
+    """Return (destination_path, reason, conflict_reason_or_None)."""
+    rel = src.relative_to(SRC)
+    parts = rel.parts
+    top = parts[0] if parts else ""
+
+    # Non-frontmatter trees → core verbatim.
+    if top in CORE_DIRS:
+        return CORE / rel, f"core dir: {top}/", None
+
+    stem = src.stem if src.name != "SKILL.md" else src.parent.name
+
+    if _is_core(fm, stem):
+        reason = "kernel rule" if stem in KERNEL_RULES else "trust.level=core + install.removable=false"
+        return CORE / rel, reason, None
+
+    primary = _primary_pack(fm)
+    if primary is None:
+        return CORE / rel, "no primary pack — falling back to core", "missing primary pack"
+    if primary not in pack_ids:
+        return CORE / rel, f"unknown pack '{primary}' — falling back to core", f"unknown pack: {primary}"
+    if primary == "meta":
+        # meta = package-internal scaffolding; lives in core alongside the kernel.
+        return CORE / rel, "primary pack: meta (package internals → core)", None
+
+    dest_root = PACKAGES / f"pack-{primary}" / ".agent-src.uncompressed"
+    return dest_root / rel, f"primary pack: {primary}", None
+
+
+# Filesystem artefacts that must never be moved (runtime caches, scratch).
+_SKIP_DIR_NAMES = frozenset({".pytest_cache", "__pycache__", ".mypy_cache",
+                              ".ruff_cache", "node_modules", ".DS_Store"})
+
+
+def _should_skip(p: Path) -> bool:
+    return any(part in _SKIP_DIR_NAMES for part in p.parts)
+
+
+def _gitignored(paths: list[Path]) -> set[Path]:
+    """Return the subset of paths matched by .gitignore (runtime artefacts,
+    eval last-run.json, caches, …). These never participate in `git mv`."""
+    if not paths:
+        return set()
+    rel = [p.relative_to(ROOT).as_posix() for p in paths]
+    result = subprocess.run(
+        ["git", "check-ignore", "--stdin"],
+        cwd=ROOT,
+        input="\n".join(rel),
+        capture_output=True,
+        text=True,
+    )
+    # check-ignore exits 0 when at least one path matched, 1 when none, >1 on error.
+    if result.returncode > 1:
+        return set()
+    ignored = {line.strip() for line in result.stdout.splitlines() if line.strip()}
+    return {ROOT / r for r in rel if r in ignored}
+
+
+def _iter_artefacts() -> list[Path]:
+    """Every source file under SRC. Includes non-md so the plan covers
+    the full tree (templates/, scripts/, packs/, hooks, .gitattributes
+    fragments, …). Runtime caches and gitignored files are excluded.
+    """
+    paths: list[Path] = []
+    for p in sorted(SRC.rglob("*")):
+        if not p.is_file():
+            continue
+        if _should_skip(p):
+            continue
+        paths.append(p)
+    ignored = _gitignored(paths)
+    return [p for p in paths if p not in ignored]
+
+
+def _find_owning_skill_fm(src: Path) -> dict[str, Any] | None:
+    """For a non-SKILL.md file under skills/<name>/, return the sibling SKILL.md frontmatter.
+
+    Looks first at the source location (pre-move) and then under
+    ``packages/*/.agent-src.uncompressed/skills/<name>/SKILL.md`` so the
+    planner can resume mid-migration when the parent SKILL.md has already
+    been relocated.
+    """
+    if "skills" not in src.parts:
+        return None
+    idx = src.parts.index("skills")
+    if idx + 1 >= len(src.parts):
+        return None
+    skill_name = src.parts[idx + 1]
+    candidates = [ROOT / Path(*src.parts[: idx + 2]) / "SKILL.md"]
+    pkgs_root = ROOT / "packages"
+    if pkgs_root.exists():
+        for pkg in pkgs_root.iterdir():
+            cand = pkg / ".agent-src.uncompressed" / "skills" / skill_name / "SKILL.md"
+            if cand.exists():
+                candidates.append(cand)
+    for cand in candidates:
+        if cand.exists():
+            parsed, _ = parse_frontmatter(cand.read_text(encoding="utf-8", errors="replace"))
+            if isinstance(parsed, dict):
+                return parsed
+    return None
+
+
+def _build_plan() -> dict[str, Any]:
+    pack_ids = _load_pack_ids()
+    unassigned = _load_unassigned()
+    moves: list[dict[str, Any]] = []
+    stays_in_core: list[dict[str, Any]] = []
+    conflicts: list[dict[str, Any]] = []
+
+    for src in _iter_artefacts():
+        rel_src = src.relative_to(ROOT).as_posix()
+        fm: dict[str, Any] | None = None
+        # Only .md files carry artefact frontmatter. Non-md files (yaml,
+        # python, php, hooks, .gitattributes fragments, …) inherit their
+        # placement from the parent directory or sibling SKILL.md.
+        if src.suffix == ".md":
+            try:
+                text = src.read_text(encoding="utf-8", errors="replace")
+                parsed, _ = parse_frontmatter(text)
+                if isinstance(parsed, dict):
+                    fm = parsed
+            except Exception as exc:  # noqa: BLE001
+                conflicts.append({"path": rel_src, "reason": f"parse error: {exc}"})
+                continue
+
+        # Quarantined scaffolds → core, no conflict.
+        if rel_src in unassigned and fm is None:
+            dest = CORE / src.relative_to(SRC)
+            stays_in_core.append({
+                "from": rel_src,
+                "to": dest.relative_to(ROOT).as_posix(),
+                "reason": f"unassigned scaffold: {unassigned[rel_src]}",
+            })
+            continue
+
+        # Skill auxiliary files (sub-pages, prompt fragments) inherit the
+        # parent SKILL.md's pack/trust. They never carry their own frontmatter.
+        inherited = False
+        if fm is None and src.name != "SKILL.md":
+            owner_fm = _find_owning_skill_fm(src)
+            if owner_fm is not None:
+                fm = owner_fm
+                inherited = True
+
+        dest, reason, conflict = _dest_for(src, fm, pack_ids)
+        if inherited:
+            reason = f"inherits parent SKILL.md → {reason}"
+        entry = {
+            "from": rel_src,
+            "to": dest.relative_to(ROOT).as_posix(),
+            "reason": reason,
+        }
+        if conflict:
+            conflicts.append({"path": rel_src, "reason": conflict, "fallback_to": entry["to"]})
+        if dest.is_relative_to(CORE):
+            stays_in_core.append(entry)
+        else:
+            moves.append(entry)
+
+    return {
+        "schema_version": "1",
+        "source_root": SRC.relative_to(ROOT).as_posix(),
+        "packages_root": PACKAGES.relative_to(ROOT).as_posix(),
+        "totals": {
+            "moves": len(moves),
+            "stays_in_core": len(stays_in_core),
+            "conflicts": len(conflicts),
+        },
+        "moves": moves,
+        "stays_in_core": stays_in_core,
+        "conflicts": conflicts,
+    }
+
+
+def _write_plan(plan: dict[str, Any]) -> None:
+    PLAN_OUT.parent.mkdir(parents=True, exist_ok=True)
+    PLAN_OUT.write_text(
+        json.dumps(plan, indent=2, sort_keys=False, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _apply(plan: dict[str, Any]) -> int:
+    """Execute every move + stay via `git mv` so history follows.
+
+    Idempotent: entries whose source is already absent and whose
+    destination already exists are silently skipped. This lets a
+    partial run be resumed without rewinding the worktree.
+    """
+    if plan["conflicts"]:
+        print(f"ERROR: {len(plan['conflicts'])} unresolved conflict(s); refusing --apply.", file=sys.stderr)
+        return 2
+
+    all_entries = plan["moves"] + plan["stays_in_core"]
+    moved = 0
+    skipped = 0
+    for entry in all_entries:
+        src = ROOT / entry["from"]
+        dst = ROOT / entry["to"]
+        if not src.exists():
+            if dst.exists():
+                skipped += 1
+                continue
+            print(f"ERROR: source missing AND destination missing: {entry['from']}", file=sys.stderr)
+            return 3
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        result = subprocess.run(
+            ["git", "mv", str(src), str(dst)],
+            cwd=ROOT,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print(f"ERROR: git mv failed: {entry['from']} -> {entry['to']}\n{result.stderr}", file=sys.stderr)
+            return 4
+        moved += 1
+    print(f"Applied {moved} moves, skipped {skipped} already-moved entries.")
+    return 0
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--apply", action="store_true", help="Execute moves via git mv (default: dry-run only)")
+    ap.add_argument("--out", type=Path, default=PLAN_OUT, help="Plan JSON output path")
+    args = ap.parse_args()
+
+    plan = _build_plan()
+    PLAN_OUT.parent.mkdir(parents=True, exist_ok=True)
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        json.dumps(plan, indent=2, sort_keys=False, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    print(f"Plan: {args.out.relative_to(ROOT)}")
+    print(f"  moves         : {plan['totals']['moves']}")
+    print(f"  stays_in_core : {plan['totals']['stays_in_core']}")
+    print(f"  conflicts     : {plan['totals']['conflicts']}")
+
+    if args.apply:
+        return _apply(plan)
+
+    return 1 if plan["conflicts"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/prepack-check.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * prepack-check.mjs — guard the published artifact.
+ *
+ * Runs during `npm pack` and `npm publish`. Asserts the compiled TS
+ * CLI binary exists, is executable, and carries the Node shebang
+ * before the tarball is built. Otherwise a silently-broken `dist/`
+ * ships and every `npx @event4u/agent-config` greets the consumer
+ * with a cryptic `Cannot find module` panic.
+ *
+ * Folded from external council pass 2026-05-18 (Phase 1.3 acceptance).
+ *
+ * Skip with PREPACK_SKIP_BUILD_CHECK=1 only for local `npm pack` dry-runs
+ * that intentionally test the failure mode.
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { argv, env, exit } from 'node:process';
+
+const BIN = resolve('dist/cli/agent-config.js');
+const SHEBANG = '#!/usr/bin/env node';
+
+function die(msg) {
+    process.stderr.write(`prepack-check: ${msg}\n`);
+    exit(1);
+}
+
+if (env.PREPACK_SKIP_BUILD_CHECK === '1') {
+    process.stderr.write('prepack-check: skipped (PREPACK_SKIP_BUILD_CHECK=1)\n');
+    exit(0);
+}
+
+let st;
+try {
+    st = statSync(BIN);
+} catch {
+    die(`compiled CLI binary missing at ${BIN}. Run \`npm run build\` before \`npm pack\`.`);
+}
+
+if (!st.isFile()) {
+    die(`${BIN} is not a regular file.`);
+}
+
+// Executable bit check (skip on Windows where mode bits are unreliable).
+if (process.platform !== 'win32') {
+    // 0o111 = any executable bit set
+    if ((st.mode & 0o111) === 0) {
+        die(`${BIN} is not executable. Build step must chmod +x the bin entry.`);
+    }
+}
+
+const head = readFileSync(BIN, 'utf8').slice(0, SHEBANG.length);
+if (head !== SHEBANG) {
+    die(`${BIN} missing Node shebang. Expected "${SHEBANG}" as first line.`);
+}
+
+process.stderr.write(`prepack-check: ${BIN} OK\n`);
+
+// Optional: invoked with --verbose dumps the size for tarball-budget bookkeeping.
+if (argv.includes('--verbose')) {
+    process.stderr.write(`prepack-check: size=${st.size} bytes\n`);
+}

package/scripts/probe_projection_fidelity.py

@@ -5,7 +5,7 @@ Reads tests/fixtures/projection_fidelity/fixtures.yml, walks the
 projected trees (.augment/, .claude/, .cursor/, .clinerules/,
 .windsurfrules, .windsurf/), and records pass/fail/partial per check.
 
-Output: agents/reports/projection-fidelity.json + stdout summary.
+Output: agents/runtime/reports/projection-fidelity.json + stdout summary.
 
 Pure stdlib (PyYAML reuse from scripts/_lib if installed; otherwise
 inline minimal YAML loader for the fixture's restricted shape).
@@ -172,7 +172,7 @@ def check_entry(entry: dict) -> dict:
 def main() -> int:
     ap = argparse.ArgumentParser()
     ap.add_argument("--fixture", default="tests/fixtures/projection_fidelity/fixtures.yml")
-    ap.add_argument("--report", default="agents/reports/projection-fidelity.json")
+    ap.add_argument("--report", default="agents/runtime/reports/projection-fidelity.json")
     args = ap.parse_args()
 
     fixture = yaml.safe_load((ROOT / args.fixture).read_text(encoding="utf-8"))

package/scripts/refine_ticket_detect.py

@@ -32,13 +32,36 @@ except ImportError as exc:
     ) from exc
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-DEFAULT_MAP = (
-    REPO_ROOT
-    / ".agent-src.uncompressed"
-    / "skills"
-    / "refine-ticket"
-    / "detection-map.yml"
-)
+
+# Post-monorepo Phase 4 the detection map lives under any package's
+# .agent-src.uncompressed/. Discover it via the shared helper; fall
+# back to the legacy flat path so consumers and older sub-trees still
+# work.
+import sys as _sys  # noqa: E402
+
+_sys.path.insert(0, str(REPO_ROOT / "scripts"))
+try:
+    from _lib.agent_src import artefact_roots as _artefact_roots
+except ImportError:
+    _artefact_roots = None
+
+
+def _discover_default_map() -> Path:
+    if _artefact_roots is not None:
+        for root in _artefact_roots():
+            candidate = root / "skills" / "refine-ticket" / "detection-map.yml"
+            if candidate.is_file():
+                return candidate
+    return (
+        REPO_ROOT
+        / ".agent-src.uncompressed"
+        / "skills"
+        / "refine-ticket"
+        / "detection-map.yml"
+    )
+
+
+DEFAULT_MAP = _discover_default_map()
 
 # Composite tokens that contain a sub-skill keyword as a substring but
 # are not themselves triggers (Phase F2). Matched with word boundaries
@@ -94,7 +117,7 @@ class RepoContext:
 
     Feeds the skill's Top-5 risks with project-specific vocabulary —
     recent branch names (naming-convention signal), recent commit
-    subjects (active modules signal), and on-disk `agents/contexts/`
+    subjects (active modules signal), and on-disk `agents/settings/contexts/`
     documents (domain-vocabulary signal).
 
     Empty when `repo_aware=False` — the skill still produces the same

package/scripts/schemas/command.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/command.schema.json",
   "title": "Command frontmatter",
-  "$comment": "Source: agents/docs/frontmatter-contract.md#commands. `description` is required at schema level because 66/67 commands declare it — the one exception is a known gap, not a supported shape.",
+  "$comment": "Source: agents/reference/docs/frontmatter-contract.md#commands. `description` is required at schema level because 66/67 commands declare it — the one exception is a known gap, not a supported shape.",
   "type": "object",
   "additionalProperties": false,
   "required": ["name", "description", "disable-model-invocation"],
@@ -117,6 +117,50 @@
           "description": "Optional per-command override of the global cooldown duration (e.g. '10m'). Defaults to settings."
         }
       }
+    },
+    "workspaces": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
+      "description": "ADR-013 workspace ids (additive discovery axis). Closed vocabulary enforced by scripts/lint_artefact_frontmatter.py against config/discovery/workspaces.yml."
+    },
+    "packs": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
+      "description": "ADR-013 pack ids (additive discovery axis). Closed vocabulary enforced by scripts/lint_artefact_frontmatter.py against config/discovery/packs.yml."
+    },
+    "lifecycle": {
+      "type": "string",
+      "enum": ["active", "deprecated", "experimental", "archived"],
+      "description": "ADR-013 lifecycle state."
+    },
+    "trust": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["level", "confidence", "human_review_required"],
+      "properties": {
+        "level": {"type": "string", "enum": ["core", "professional", "experimental", "advisory", "restricted"]},
+        "confidence": {"type": "string", "enum": ["high", "medium", "low"]},
+        "human_review_required": {"type": "boolean"}
+      },
+      "description": "ADR-013 trust block. Vocabulary mirrored by scripts/lint_artefact_frontmatter.py."
+    },
+    "install": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["default", "removable"],
+      "properties": {
+        "default": {"type": "boolean"},
+        "removable": {"type": "boolean"}
+      },
+      "description": "ADR-013 install hints (default-on at consumer install; user-removable)."
+    },
+    "gui_runnable": {
+      "type": "boolean",
+      "description": "AI OS Product UI allowlist (road-to-ai-os-product-ui.md Phase 1). When true, the command is exposed in the browser /tasks surface and may be spawned by POST /api/v1/task/run. Default false — commands that touch git, secrets, or run destructive migrations must stay false (terminal only). Per-command opt-in, never opt-out."
     }
   }
 }

package/scripts/schemas/persona.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/persona.schema.json",
   "title": "Persona frontmatter",
-  "$comment": "Source: agents/docs/frontmatter-contract.md#personas. `mode` enum mirrors the values declared in personas/*.md plus the additional `incident` value from templates/persona.md.",
+  "$comment": "Source: agents/reference/docs/frontmatter-contract.md#personas. `mode` enum mirrors the values declared in personas/*.md plus the additional `incident` value from templates/persona.md.",
   "type": "object",
   "additionalProperties": false,
   "required": ["id", "role", "description", "tier", "mode", "version", "source"],

package/scripts/schemas/rule.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/rule.schema.json",
   "title": "Rule frontmatter",
-  "$comment": "Source: agents/docs/frontmatter-contract.md#rules. `type` is authoritative; `alwaysApply` is a Cursor/Cline sidecar and accepted but not enforced.",
+  "$comment": "Source: agents/reference/docs/frontmatter-contract.md#rules. `type` is authoritative; `alwaysApply` is a Cursor/Cline sidecar and accepted but not enforced.",
   "type": "object",
   "additionalProperties": false,
   "required": ["type", "source", "description"],
@@ -29,8 +29,8 @@
       "type": "array",
       "items": {
         "type": "string",
-        "pattern": "^((\\.\\./)*contexts/|agents/contexts/|\\.agent-src/contexts/)[^\\s]+\\.md$",
-        "description": "Logical name (preferred — `contexts/<area>/<file>.md`) or project-local (`agents/contexts/<file>.md`). The `.agent-src.uncompressed/` prefix is rejected by the regex; the rewriter (`scripts/compress.py::_rewrite_paths`) resolves logical names at compress time. Rewritten relative forms (`../contexts/...`, `../../contexts/...`) are accepted so the linter passes on the compressed mirror in CI."
+        "pattern": "^((\\.\\./)*contexts/|agents/settings/contexts/|\\.agent-src/contexts/)[^\\s]+\\.md$",
+        "description": "Logical name (preferred — `contexts/<area>/<file>.md`) or project-local (`agents/settings/contexts/<file>.md`). The `.agent-src.uncompressed/` prefix is rejected by the regex; the rewriter (`scripts/compress.py::_rewrite_paths`) resolves logical names at compress time. Rewritten relative forms (`../contexts/...`, `../../contexts/...`) are accepted so the linter passes on the compressed mirror in CI."
       },
       "description": "Lazy on-demand context references. Use logical names rooted at the source (e.g. `contexts/execution/foo.md`); the `.agent-src.uncompressed/` prefix is forbidden by the regex (road-to-path-fixes.md P5.3). Path rules and budget caps enforced by scripts/lint_load_context.py. Contract: docs/contracts/load-context-schema.md."
     },
@@ -38,7 +38,7 @@
       "type": "array",
       "items": {
         "type": "string",
-        "pattern": "^((\\.\\./)*contexts/|agents/contexts/|\\.agent-src/contexts/)[^\\s]+\\.md$",
+        "pattern": "^((\\.\\./)*contexts/|agents/settings/contexts/|\\.agent-src/contexts/)[^\\s]+\\.md$",
         "description": "Same logical-name rule as `load_context`."
       },
       "description": "Eager auto-loaded context references. Same logical-name rule as `load_context`. Counts against the per-rule char budget; enforced by scripts/lint_load_context.py."
@@ -98,6 +98,46 @@
         }
       },
       "description": "Per-rule allowlist consumed by the post-compression validator (scripts/check_compressed_paths.py). Rules that document forbidden path substrings as their subject matter (e.g. augment-portability, no-roadmap-references) declare the literal strings here so the gate does not flag itself. road-to-path-fixes.md P5.1."
+    },
+    "workspaces": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
+      "description": "ADR-013 workspace ids (additive discovery axis). Closed vocabulary enforced by scripts/lint_artefact_frontmatter.py against config/discovery/workspaces.yml."
+    },
+    "packs": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {"type": "string", "pattern": "^[a-z][a-z0-9-]*$"},
+      "description": "ADR-013 pack ids (additive discovery axis). Closed vocabulary enforced by scripts/lint_artefact_frontmatter.py against config/discovery/packs.yml."
+    },
+    "lifecycle": {
+      "type": "string",
+      "enum": ["active", "deprecated", "experimental", "archived"],
+      "description": "ADR-013 lifecycle state."
+    },
+    "trust": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["level", "confidence", "human_review_required"],
+      "properties": {
+        "level": {"type": "string", "enum": ["core", "professional", "experimental", "advisory", "restricted"]},
+        "confidence": {"type": "string", "enum": ["high", "medium", "low"]},
+        "human_review_required": {"type": "boolean"}
+      },
+      "description": "ADR-013 trust block. Vocabulary mirrored by scripts/lint_artefact_frontmatter.py."
+    },
+    "install": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["default", "removable"],
+      "properties": {
+        "default": {"type": "boolean"},
+        "removable": {"type": "boolean"}
+      },
+      "description": "ADR-013 install hints (default-on at consumer install; user-removable)."
     }
   }
 }