agentbundle 0.2.0__py3-none-any.whl

agentbundle/build/tests/test_contract_scope.py

@@ -0,0 +1,224 @@
+"""Tests for the RFC-0004 v0.2 `[scope]` table on the adapter contract.
+
+Verifies AC #14 (RFC-0004) for the distribution-adapters spec:
+  - adapter.schema.json accepts a well-formed [adapter.<name>.scope] block.
+  - adapter.schema.json rejects each malformed `allowed-prefixes.user` shape
+    enumerated in the spec: ["/"], [""], ["../"], [".."],
+    ["no-trailing-slash"], ["/begins-with-slash/"], and [].
+  - adapter.toml validates against the v0.2 schema with [contract] version =
+    "0.2" and the two-prefix [adapter."claude-code".scope] block.
+  - The other three reference adapters (kiro, copilot, codex) omit the
+    optional [scope] block and remain valid.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import tomllib
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+CONTRACT_PATH = REPO_ROOT / "docs" / "contracts" / "adapter.toml"
+SCHEMA_PATH = REPO_ROOT / "docs" / "contracts" / "adapter.schema.json"
+
+
+def _load_schema() -> dict:
+    return json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+
+
+def _load_contract() -> dict:
+    return tomllib.loads(CONTRACT_PATH.read_text(encoding="utf-8"))
+
+
+class ContractVersionTests(unittest.TestCase):
+    """Contract version: bumped to 0.2 by RFC-0004, then to 0.3 by RFC-0005,
+    then to 0.4 by RFC-0008 (T2 / spec claude-plugins-install-route), then to
+    0.5 by RFC-0010 (T2 / spec apm-install-route-parity), then to 0.6 by
+    RFC-0011 / pack-allowed-adapters (codex user-scope table), then to 0.7
+    by RFC-0012 / repo-scope-per-adapter-projection (every adapter declares
+    `allowed-prefixes.repo`; copilot gains a scope table) and RFC-0013 /
+    credential-broker-contract (governance bump) co-residing at v0.7, then
+    to 0.8 by docs/specs/dropped-primitives-coverage (codex agent +
+    hook-wiring move from `dropped` to first-class projections)."""
+
+    def test_contract_version_is_0_5(self) -> None:
+        # Class/method name preserved; exact version lives in test_contract.py.
+        # Assert >= 0.8 so v0.8 scope features survive future bumps. Compare as
+        # (major, minor) tuples — a string compare breaks at v0.10 ("0.10" < "0.8"
+        # lexically).
+        contract = _load_contract()
+        version = tuple(int(part) for part in contract["contract"]["version"].split("."))
+        self.assertGreaterEqual(version, (0, 8))
+
+
+class ClaudeCodeScopeBlockTests(unittest.TestCase):
+    """The Claude Code adapter declares the v0.2 [scope] block."""
+
+    def test_claude_code_scope_present(self) -> None:
+        contract = _load_contract()
+        scope = contract["adapter"]["claude-code"].get("scope")
+        self.assertIsNotNone(scope, "Claude Code [scope] block missing")
+        self.assertEqual(scope["repo"], ".")
+        self.assertEqual(scope["user"], "~")
+
+    def test_claude_code_allowed_prefixes_user_two_entries(self) -> None:
+        """Two prefixes ship: projected primitives + CLI infrastructure."""
+        contract = _load_contract()
+        prefixes = (
+            contract["adapter"]["claude-code"]["scope"]["allowed-prefixes"]["user"]
+        )
+        self.assertEqual(prefixes, [".claude/", ".agentbundle/"])
+
+    def test_contract_validates_against_schema(self) -> None:
+        from agentbundle.build.validate import validate
+
+        errors = validate(_load_contract(), _load_schema())
+        self.assertEqual(errors, [], f"v0.2 contract did not validate: {errors}")
+
+
+class OtherAdaptersOmitScopeTests(unittest.TestCase):
+    """v0.3 (RFC-0005) adds a `[scope]` table to Kiro alongside Claude
+    Code's existing one; v0.6 (RFC-0011) adds one to Codex; v0.7
+    (RFC-0012) adds one to Copilot — every shipped adapter now carries
+    a `[scope]` table at v0.7."""
+
+    def test_copilot_has_scope_per_rfc_0012(self) -> None:
+        contract = _load_contract()
+        scope = contract["adapter"]["copilot"].get("scope")
+        self.assertIsNotNone(scope, "copilot [scope] block missing")
+        self.assertEqual(scope["repo"], ".")
+        # v0.10 (RFC-0024 / copilot-full-parity): copilot is now a full-parity,
+        # user-scope-capable adapter. Repo prefixes cover the three projected
+        # primitive homes under `.github/`; the legacy `tools/hooks/` prefix is
+        # gone (hook-body retargeted to `.github/hooks/`).
+        self.assertEqual(
+            scope["allowed-prefixes"]["repo"],
+            [".github/instructions/", ".github/agents/", ".github/hooks/"],
+        )
+        # User scope: `~/.copilot/{agents,instructions,hooks}/` + `.agentbundle/`
+        # (the install state-file home, same as every other user-capable adapter).
+        self.assertEqual(scope["user"], "~")
+        self.assertEqual(
+            scope["allowed-prefixes"]["user"],
+            [
+                ".copilot/agents/",
+                ".copilot/instructions/",
+                ".copilot/hooks/",
+                ".agentbundle/",
+            ],
+        )
+
+    def test_codex_has_scope_per_rfc_0011(self) -> None:
+        contract = _load_contract()
+        scope = contract["adapter"]["codex"].get("scope")
+        self.assertIsNotNone(scope, "Codex [scope] block missing (RFC-0011)")
+        self.assertEqual(scope["repo"], ".")
+        self.assertEqual(scope["user"], "~")
+        # v0.8 (dropped-primitives-coverage) adds `.codex/` to allow
+        # codex agent + hook-wiring projection.
+        self.assertEqual(
+            scope["allowed-prefixes"]["user"],
+            [".agents/skills/", ".codex/", ".agentbundle/"],
+        )
+
+    def test_kiro_has_scope_per_rfc_0005(self) -> None:
+        contract = _load_contract()
+        scope = contract["adapter"]["kiro"].get("scope")
+        self.assertIsNotNone(scope, "Kiro [scope] block missing")
+        self.assertEqual(scope["repo"], ".")
+        self.assertEqual(scope["user"], "~")
+
+    def test_contract_minus_claude_code_scope_still_valid(self) -> None:
+        from agentbundle.build.validate import validate
+
+        contract = _load_contract()
+        contract["adapter"]["claude-code"].pop("scope", None)
+        errors = validate(contract, _load_schema())
+        self.assertEqual(errors, [], f"validate rejected scope-less contract: {errors}")
+
+
+class AllowedPrefixesRejectionTests(unittest.TestCase):
+    """`allowed-prefixes.<scope>` constraints — every bad shape is rejected."""
+
+    def _validate_with_prefixes(self, prefixes: list[str]) -> list[str]:
+        from agentbundle.build.validate import validate
+
+        schema = _load_schema()
+        contract = _load_contract()
+        contract["adapter"]["claude-code"]["scope"]["allowed-prefixes"]["user"] = list(prefixes)
+        return validate(contract, schema)
+
+    def test_rejects_root_only(self) -> None:
+        errors = self._validate_with_prefixes(["/"])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['/']")
+
+    def test_rejects_empty_string(self) -> None:
+        errors = self._validate_with_prefixes([""])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['']")
+
+    def test_rejects_dotdot_slash(self) -> None:
+        errors = self._validate_with_prefixes(["../"])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['../']")
+
+    def test_rejects_bare_dotdot(self) -> None:
+        errors = self._validate_with_prefixes([".."])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['..']")
+
+    def test_rejects_no_trailing_slash(self) -> None:
+        errors = self._validate_with_prefixes(["no-trailing-slash"])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['no-trailing-slash']")
+
+    def test_rejects_leading_slash(self) -> None:
+        errors = self._validate_with_prefixes(["/begins-with-slash/"])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['/begins-with-slash/']")
+
+    def test_rejects_empty_array(self) -> None:
+        errors = self._validate_with_prefixes([])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = []")
+
+    def test_rejects_dotdot_in_middle(self) -> None:
+        """Defence in depth: `..` as an interior segment is also rejected."""
+        errors = self._validate_with_prefixes([".claude/../etc/"])
+        self.assertTrue(errors, "schema accepted allowed-prefixes.user = ['.claude/../etc/']")
+
+    def test_accepts_nested_path(self) -> None:
+        """A nested path like `.claude/skills/` is legal — non-empty, trailing /."""
+        errors = self._validate_with_prefixes([".claude/skills/"])
+        self.assertEqual(errors, [], f"schema rejected nested path: {errors}")
+
+
+class StdlibValidatorExtensionsTests(unittest.TestCase):
+    """Cross-keyword tests for the validator extensions T10 needs."""
+
+    def test_min_items_rejects_short_array(self) -> None:
+        from agentbundle.build.validate import validate
+
+        schema = {"type": "array", "minItems": 1}
+        self.assertTrue(validate([], schema))
+        self.assertEqual(validate(["a"], schema), [])
+
+    def test_pattern_rejects_dotdot_segment(self) -> None:
+        from agentbundle.build.validate import validate
+
+        # The exact pattern shipped on allowed-prefixes.<scope>.items.
+        pattern = r"^((?!\.\.(\/|$))[^/]+/)+$"
+        schema = {"type": "string", "pattern": pattern}
+        for bad in ("../", "..", "/", "", "no-slash", "/abs/"):
+            with self.subTest(value=bad):
+                self.assertTrue(
+                    validate(bad, schema),
+                    f"pattern accepted forbidden value: {bad!r}",
+                )
+        for good in (".claude/", ".agentbundle/", "deep/nested/path/"):
+            with self.subTest(value=good):
+                self.assertEqual(
+                    validate(good, schema),
+                    [],
+                    f"pattern rejected legal value: {good!r}",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

agentbundle/build/tests/test_contract_v07.py

@@ -0,0 +1,191 @@
+"""Tests for adapter-contract v0.7 (RFC-0012 / repo-scope-per-adapter-projection
+and RFC-0013 / credential-broker-contract co-residing at v0.7).
+
+Verifies the T1 edits landed:
+
+  - ``[contract] version == "0.7"`` in both the runtime data file
+    (`_data/adapter.toml`) and the docs mirror
+    (`docs/contracts/adapter.toml`). The two files must stay byte-
+    aligned per the v0.3-schema sync test; this module pins the
+    version on both as belt-and-braces (AC1 for both RFCs).
+  - **RFC-0012 surface:**
+    * ``[adapter.copilot.scope]`` exists with ``repo = "."``,
+      ``allowed-prefixes.repo`` enumerating the per-IDE skill /
+      hook-body targets, and NO ``user`` key (Copilot is admissible
+      at repo scope only).
+    * Every shipped adapter declares ``allowed-prefixes.repo`` as a
+      non-empty list of trailing-slash strings.
+    * Schema validator refuses fixtures that omit the ``repo`` key
+      or ``allowed-prefixes.repo`` from any adapter's scope table.
+  - **RFC-0013 surface:**
+    * Each user-scope-capable adapter (`claude-code`, `kiro`, `codex`)
+      still carries `.agentbundle/` in `allowed-prefixes.user`
+      (non-regression — the prefix is what `metadata.auth: creds`
+      writes its credential cache under).
+  - Property-based ``allowed-prefixes.user`` invariants for every
+    user-scope-capable adapter (header-comment edits and
+    list-order changes don't trip the assertion).
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import tomllib
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+DATA_CONTRACT_PATH = (
+    REPO_ROOT / "packages" / "agentbundle" / "agentbundle" / "_data" / "adapter.toml"
+)
+DOCS_CONTRACT_PATH = REPO_ROOT / "docs" / "contracts" / "adapter.toml"
+DATA_SCHEMA_PATH = (
+    REPO_ROOT
+    / "packages"
+    / "agentbundle"
+    / "agentbundle"
+    / "_data"
+    / "adapter.schema.json"
+)
+
+
+def _version_tuple(contract: dict) -> tuple[int, ...]:
+    """(major, minor) tuple — a string compare breaks at v0.10 ("0.10"<"0.8")."""
+    return tuple(int(part) for part in contract["contract"]["version"].split("."))
+
+
+class TestContractV07(unittest.TestCase):
+    def setUp(self) -> None:
+        self.contract = tomllib.loads(DATA_CONTRACT_PATH.read_text(encoding="utf-8"))
+        self.docs_contract = tomllib.loads(
+            DOCS_CONTRACT_PATH.read_text(encoding="utf-8")
+        )
+
+    def test_contract_version_is_07(self) -> None:
+        """RFC-0012 + RFC-0013 + dropped-primitives-coverage co-residing at v0.8.
+
+        Name preserved to keep the diff small; the v0.7 invariants below
+        remain load-bearing post-v0.8 bump because dropped-primitives-coverage
+        only widens codex's projection table (it does not regress the v0.7
+        ``allowed-prefixes`` / scope-table contracts pinned in this module).
+        """
+        # Exact version check lives in test_contract.py; assert >= 0.8 (v0.7/v0.8
+        # features must survive future bumps — validated by invariant tests below).
+        # Compare as (major, minor) tuples — a string compare breaks at v0.10.
+        self.assertGreaterEqual(_version_tuple(self.contract), (0, 8))
+
+    def test_docs_contract_version_is_07(self) -> None:
+        """docs mirror stays in sync (byte-identical to _data/ adapter.toml)."""
+        self.assertGreaterEqual(_version_tuple(self.docs_contract), (0, 8))
+
+    def test_copilot_scope_table_shape(self) -> None:
+        copilot_scope = self.contract["adapter"]["copilot"].get("scope")
+        self.assertIsNotNone(copilot_scope, "copilot scope table missing")
+        self.assertEqual(copilot_scope["repo"], ".")
+        # v0.10 (RFC-0024 / copilot-full-parity) supersedes-in-part the v0.7
+        # repo-only copilot scope: copilot is now user-scope-capable with three
+        # `.github/` repo prefixes (the legacy `tools/hooks/` prefix is gone).
+        self.assertEqual(
+            copilot_scope["allowed-prefixes"]["repo"],
+            [".github/instructions/", ".github/agents/", ".github/hooks/"],
+        )
+        self.assertEqual(copilot_scope["user"], "~")
+        self.assertEqual(
+            copilot_scope["allowed-prefixes"]["user"],
+            [
+                ".copilot/agents/",
+                ".copilot/instructions/",
+                ".copilot/hooks/",
+                ".agentbundle/",
+            ],
+        )
+
+    def test_every_adapter_has_allowed_prefixes_repo(self) -> None:
+        for name, block in self.contract["adapter"].items():
+            with self.subTest(adapter=name):
+                scope = block.get("scope")
+                self.assertIsNotNone(
+                    scope, f"adapter {name!r} has no scope table at v0.7"
+                )
+                repo_prefixes = scope.get("allowed-prefixes", {}).get("repo")
+                self.assertIsInstance(
+                    repo_prefixes,
+                    list,
+                    f"adapter {name!r} missing allowed-prefixes.repo",
+                )
+                self.assertTrue(
+                    repo_prefixes,
+                    f"adapter {name!r} allowed-prefixes.repo is empty",
+                )
+                for entry in repo_prefixes:
+                    self.assertTrue(
+                        entry.endswith("/"),
+                        f"adapter {name!r} prefix {entry!r} must end with '/'",
+                    )
+
+    def test_existing_user_prefixes_invariants(self) -> None:
+        """Property-based assertion — every user-scope-capable adapter's
+        prefix list still carries its load-bearing entries. RFC-0013's
+        `.agentbundle/` non-regression rolls into this same shape."""
+        cc = self.contract["adapter"]["claude-code"]["scope"]
+        cc_user = cc["allowed-prefixes"]["user"]
+        self.assertIn(".claude/", cc_user)
+        self.assertIn(".agentbundle/", cc_user)
+
+        kiro = self.contract["adapter"]["kiro"]["scope"]
+        kiro_user = kiro["allowed-prefixes"]["user"]
+        self.assertIn(".kiro/", kiro_user)
+        self.assertIn(".agentbundle/", kiro_user)
+
+        codex = self.contract["adapter"]["codex"]["scope"]
+        codex_user = codex["allowed-prefixes"]["user"]
+        self.assertIn(".agents/skills/", codex_user)
+        self.assertIn(".agentbundle/", codex_user)
+
+    def test_all_user_scope_adapters_carry_agentbundle_prefix(self) -> None:
+        """RFC-0013 AC2 — `.agentbundle/` is the credential-cache root
+        every user-scope-capable adapter must admit."""
+        for adapter in ("claude-code", "kiro", "codex"):
+            with self.subTest(adapter=adapter):
+                prefixes = (
+                    self.contract["adapter"][adapter]["scope"]
+                    ["allowed-prefixes"]["user"]
+                )
+                self.assertIn(
+                    ".agentbundle/", prefixes,
+                    f"{adapter} user-scope allowed-prefixes must include "
+                    f"'.agentbundle/' (got {prefixes!r})",
+                )
+
+    def test_schema_refuses_repo_omission(self) -> None:
+        """RFC-0012 AC4 — fixture contract with the ``repo`` key removed
+        from any adapter's scope table fails validation."""
+        from agentbundle.build.validate import validate
+
+        schema = json.loads(DATA_SCHEMA_PATH.read_text(encoding="utf-8"))
+        broken = copy.deepcopy(self.contract)
+        del broken["adapter"]["claude-code"]["scope"]["repo"]
+        errors = validate(broken, schema)
+        self.assertTrue(
+            errors,
+            "schema accepted a scope table missing the 'repo' key",
+        )
+
+    def test_schema_refuses_allowed_prefixes_repo_omission(self) -> None:
+        """RFC-0012 AC4 — fixture contract with ``allowed-prefixes.repo``
+        removed from any adapter's scope table fails validation."""
+        from agentbundle.build.validate import validate
+
+        schema = json.loads(DATA_SCHEMA_PATH.read_text(encoding="utf-8"))
+        broken = copy.deepcopy(self.contract)
+        del broken["adapter"]["kiro"]["scope"]["allowed-prefixes"]["repo"]
+        errors = validate(broken, schema)
+        self.assertTrue(
+            errors,
+            "schema accepted a scope table missing allowed-prefixes.repo",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

agentbundle/build/tests/test_contract_v08.py

@@ -0,0 +1,230 @@
+"""Tests for adapter-contract v0.8 (docs/specs/dropped-primitives-coverage).
+
+Verifies the T1 contract edits:
+
+  - ``[contract] version == "0.8"`` in both the runtime data file
+    (`_data/adapter.toml`) and the docs mirror.
+  - Codex `agent` projection: ``mode == "codex-agent-toml"``,
+    ``target-path == ".codex/agents/"``,
+    ``frontmatter-mapping == "codex-agent-frontmatter-v0.8"``.
+  - Codex `hook-wiring` projection: ``mode == "merge-json"``,
+    ``target-path == ".codex/hooks.json"``, ``managed-key == "hooks"``.
+  - Codex `command` projection: stays `dropped` (no upstream target).
+  - ``[adapter.codex.scope].allowed-prefixes.repo`` and ``.user`` each
+    include ``".codex/"``.
+  - ``[frontmatter-mapping."codex-agent-frontmatter-v0.8"]`` declares
+    per-key sub-tables for ``name`` and ``description``; no ``body``
+    sub-table (body-to-``developer_instructions`` is a mode-level
+    convention, not a rename rule).
+  - Schema admits ``"codex-agent-toml"`` at every site that currently
+    enumerates ``"dropped"``.
+  - Schema validates the v0.8 contract end-to-end.
+  - Property invariants for claude-code (all 5 primitives projected) and
+    kiro (4 of 5 with `command: dropped`) survive the codex changes
+    untouched. Copilot's 3 dropped entries unchanged.
+"""
+
+from __future__ import annotations
+
+import json
+import tomllib
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+DATA_CONTRACT_PATH = (
+    REPO_ROOT / "packages" / "agentbundle" / "agentbundle" / "_data" / "adapter.toml"
+)
+DOCS_CONTRACT_PATH = REPO_ROOT / "docs" / "contracts" / "adapter.toml"
+DATA_SCHEMA_PATH = (
+    REPO_ROOT
+    / "packages"
+    / "agentbundle"
+    / "agentbundle"
+    / "_data"
+    / "adapter.schema.json"
+)
+
+
+def _codex_projection(contract: dict, primitive: str) -> dict:
+    """Find the [[adapter.codex.projection]] entry for ``primitive``."""
+    for entry in contract["adapter"]["codex"]["projection"]:
+        if entry["primitive"] == primitive:
+            return entry
+    raise AssertionError(f"codex projection for primitive {primitive!r} not found")
+
+
+def _version_tuple(contract: dict) -> tuple[int, ...]:
+    """(major, minor) tuple — a string compare breaks at v0.10 ("0.10"<"0.8")."""
+    return tuple(int(part) for part in contract["contract"]["version"].split("."))
+
+
+class TestContractV08(unittest.TestCase):
+    def setUp(self) -> None:
+        self.contract = tomllib.loads(DATA_CONTRACT_PATH.read_text(encoding="utf-8"))
+        self.docs_contract = tomllib.loads(
+            DOCS_CONTRACT_PATH.read_text(encoding="utf-8")
+        )
+        self.schema = json.loads(DATA_SCHEMA_PATH.read_text(encoding="utf-8"))
+
+    def test_contract_version_is_08(self) -> None:
+        # v0.8 features are present; exact version check lives in test_contract.py.
+        # The v0.8 features (codex-agent-toml, codex-agent-frontmatter-v0.8) must
+        # survive future bumps — verify via the codex-specific tests below.
+        # Compare as (major, minor) tuples — a string compare breaks at v0.10.
+        version = _version_tuple(self.contract)
+        self.assertGreaterEqual(version, (0, 8), "contract version must be >= 0.8")
+
+    def test_docs_contract_version_is_08(self) -> None:
+        version = _version_tuple(self.docs_contract)
+        self.assertGreaterEqual(version, (0, 8), "docs contract version must be >= 0.8")
+
+    def test_codex_agent_projection(self) -> None:
+        entry = _codex_projection(self.contract, "agent")
+        self.assertEqual(entry["mode"], "codex-agent-toml")
+        self.assertEqual(entry["target-path"], ".codex/agents/")
+        self.assertEqual(
+            entry["frontmatter-mapping"], "codex-agent-frontmatter-v0.8"
+        )
+        self.assertEqual(entry["on-conflict"], "prompt-then-preserve")
+
+    def test_codex_hook_wiring_projection(self) -> None:
+        entry = _codex_projection(self.contract, "hook-wiring")
+        self.assertEqual(entry["mode"], "merge-json")
+        self.assertEqual(entry["target-path"], ".codex/hooks.json")
+        self.assertEqual(entry["managed-key"], "hooks")
+        self.assertEqual(entry["on-conflict"], "merge-managed-key-only")
+
+    def test_codex_command_still_dropped(self) -> None:
+        entry = _codex_projection(self.contract, "command")
+        self.assertEqual(entry["mode"], "dropped")
+
+    def test_codex_skill_projection_unchanged(self) -> None:
+        """Non-regression — codex skill projection at `.agents/skills/` unchanged."""
+        entry = _codex_projection(self.contract, "skill")
+        self.assertEqual(entry["mode"], "direct-directory")
+        self.assertEqual(entry["target-path"], ".agents/skills/")
+
+    def test_codex_hook_body_projection_unchanged(self) -> None:
+        """Non-regression — codex hook-body projection at `tools/hooks/` unchanged."""
+        entry = _codex_projection(self.contract, "hook-body")
+        self.assertEqual(entry["mode"], "direct-file")
+        self.assertEqual(entry["target-path"], "tools/hooks/")
+
+    def test_codex_allowed_prefixes_includes_codex_dir(self) -> None:
+        scope = self.contract["adapter"]["codex"]["scope"]
+        self.assertIn(".codex/", scope["allowed-prefixes"]["repo"])
+        self.assertIn(".codex/", scope["allowed-prefixes"]["user"])
+
+    def test_codex_allowed_prefixes_preserves_existing_entries(self) -> None:
+        """Non-regression — `.agents/skills/`, `.agentbundle/`, `tools/hooks/` still present."""
+        repo = self.contract["adapter"]["codex"]["scope"]["allowed-prefixes"]["repo"]
+        user = self.contract["adapter"]["codex"]["scope"]["allowed-prefixes"]["user"]
+        for entry in (".agents/skills/", ".agentbundle/"):
+            self.assertIn(entry, repo)
+            self.assertIn(entry, user)
+        self.assertIn("tools/hooks/", repo)
+
+    def test_codex_frontmatter_mapping_table(self) -> None:
+        mapping = self.contract["frontmatter-mapping"]["codex-agent-frontmatter-v0.8"]
+        # Required per-key sub-tables.
+        self.assertIn("name", mapping)
+        self.assertEqual(mapping["name"]["rename"], "name")
+        self.assertIn("description", mapping)
+        self.assertEqual(mapping["description"]["rename"], "description")
+        # No `body` sub-table — body-to-`developer_instructions` is a
+        # mode-level convention per spec AC4, not a frontmatter rename.
+        self.assertNotIn("body", mapping)
+        self.assertNotIn("developer_instructions", mapping)
+
+    def test_schema_admits_codex_agent_toml_mode_at_every_dropped_site(self) -> None:
+        """Walk the schema; every enum array containing "dropped" must also
+        contain "codex-agent-toml". Discovered dynamically so a future schema
+        edit that adds a fifth enum site doesn't silently drift this AC."""
+
+        def walk(node, path):
+            if isinstance(node, dict):
+                for k, v in node.items():
+                    if k == "enum" and isinstance(v, list) and "dropped" in v:
+                        self.assertIn(
+                            "codex-agent-toml",
+                            v,
+                            f"schema enum at {path} admits 'dropped' but not "
+                            f"'codex-agent-toml': {v!r}",
+                        )
+                    walk(v, f"{path}.{k}")
+            elif isinstance(node, list):
+                for i, v in enumerate(node):
+                    walk(v, f"{path}[{i}]")
+
+        walk(self.schema, "$")
+
+    def test_schema_loads_v08_contract(self) -> None:
+        """End-to-end: load schema, validate v0.8 contract; no errors. This
+        is load-bearing — it pins that codex's new `codex-agent-toml` mode
+        and the codex `merge-json` reuse both validate at the codex array
+        site (the projection-mode enum is global across adapters, so
+        `merge-json` already validates without per-site enum edits)."""
+        from agentbundle.build.validate import validate
+
+        errors = validate(self.contract, self.schema)
+        self.assertEqual(
+            errors,
+            [],
+            "v0.8 adapter.toml failed schema validation:\n" + "\n".join(errors),
+        )
+
+    def test_claude_code_unchanged_post_v08(self) -> None:
+        """Property invariant — claude-code projects all 5 primitives."""
+        primitives = {
+            entry["primitive"]: entry
+            for entry in self.contract["adapter"]["claude-code"]["projection"]
+        }
+        self.assertEqual(
+            set(primitives), {"skill", "agent", "hook-body", "hook-wiring", "command"}
+        )
+        for primitive, entry in primitives.items():
+            self.assertNotEqual(
+                entry["mode"],
+                "dropped",
+                f"claude-code {primitive} unexpectedly dropped at v0.8",
+            )
+
+    def test_kiro_unchanged_post_v08(self) -> None:
+        """Property invariant — kiro projects 4 of 5 primitives; command dropped."""
+        primitives = {
+            entry["primitive"]: entry
+            for entry in self.contract["adapter"]["kiro"]["projection"]
+        }
+        self.assertEqual(primitives["command"]["mode"], "dropped")
+        for primitive in ("skill", "agent", "hook-body"):
+            self.assertNotEqual(
+                primitives[primitive]["mode"],
+                "dropped",
+                f"kiro {primitive} unexpectedly dropped at v0.8",
+            )
+
+    def test_copilot_unchanged_post_v08(self) -> None:
+        """Property invariant — at v0.10 (RFC-0024 / copilot-full-parity) copilot
+        projects 4 of 5 primitives; only `command` stays dropped (the v0.8
+        three-dropped state is superseded — agent + hook-wiring flipped to
+        native modes)."""
+        primitives = {
+            entry["primitive"]: entry
+            for entry in self.contract["adapter"]["copilot"]["projection"]
+        }
+        self.assertEqual(
+            primitives["command"]["mode"],
+            "dropped",
+            "copilot command should still be dropped (copilot-cli#618/#1113)",
+        )
+        for primitive in ("skill", "agent", "hook-body", "hook-wiring"):
+            self.assertNotEqual(
+                primitives[primitive]["mode"],
+                "dropped",
+                f"copilot {primitive} should project natively at v0.10",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()