agentbundle 0.3.0__tar.gz → 0.4.0__tar.gz

agentbundle-0.4.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: agentbundle
+Version: 0.4.0
+Summary: npm for your coding agent. Install packs of skills, subagents, and hooks into any repo, for every major agent.
+Author-email: eugenelim <eugenelim@users.noreply.github.com>
+License: Apache-2.0 OR MIT
+Project-URL: Homepage, https://github.com/eugenelim/agent-ready-repo
+Project-URL: Source, https://github.com/eugenelim/agent-ready-repo
+Project-URL: Documentation, https://github.com/eugenelim/agent-ready-repo/blob/main/docs/guides/_shared/how-to/install-agentbundle-from-clone.md
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# agentbundle
+
+[![PyPI](https://img.shields.io/pypi/v/agentbundle)](https://pypi.org/project/agentbundle/)
+[![Python](https://img.shields.io/pypi/pyversions/agentbundle)](https://pypi.org/project/agentbundle/)
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)](https://github.com/eugenelim/agent-ready-repo#license)
+
+**The installer for [agent-ready-repo](https://github.com/eugenelim/agent-ready-repo).** Think npm, but for the skills, subagents, and hooks your coding agent runs on.
+
+`agentbundle` installs packs of agent primitives into your repo or your home directory. It projects each primitive into the layout every agent expects. One pack. One command. Every major agent.
+
+```bash
+pip install agentbundle
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo
+```
+
+That lands `core`, the flagship pack and the loop itself, in your repo. Claude Code, Codex, Cursor, Copilot, Gemini, and Kiro all read it.
+
+## Common commands
+
+```bash
+# See what's in a catalogue
+agentbundle list-packs git+https://github.com/eugenelim/agent-ready-repo
+
+# Install the flagship loop into this repo
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo
+
+# Install a pack at user scope, so it follows you across every project
+agentbundle install --pack research git+https://github.com/eugenelim/agent-ready-repo --scope user
+
+# Preview an install without writing a file
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo --dry-run
+
+# Upgrade a pack; it reports the .upstream files you need to reconcile
+agentbundle upgrade --pack core --to 0.4.0 git+https://github.com/eugenelim/agent-ready-repo
+```
+
+A catalogue is a git URL or a local path. Installs auto-detect your agent; pass `--adapter` to override.
+
+## Build your own catalogue
+
+`agentbundle` isn't tied to the agent-ready-repo catalogue. Any repo that lays its packs out the same way can use it. A pack is a directory:
+
+```text
+my-pack/
+  pack.toml                  # name, version, adapter-contract, install scope,
+                             # plus rich metadata (license, maintainers, links,
+                             # categories, keywords) and a README pointer
+  .claude-plugin/
+    plugin.json              # Claude Code plugin manifest (hand-authored)
+  README.md                  # the pack's portable doc — projected with the pack
+  .apm/                      # primitives — projected by the build pipeline
+    skills/<name>/
+      SKILL.md               # the skill body; one folder per skill
+      references/            # progressive-disclosure docs, loaded on demand
+      assets/                # templates the skill copies into the repo
+    agents/<name>.md         # subagents
+    hooks/<name>.py          # lifecycle hooks
+  seeds/                     # files scaffolded into the adopter repo
+```
+
+`pack.toml` is the **single source of truth** for a pack's metadata. Declare
+`license`, `[[pack.maintainers]]`, `[pack.links]`, `categories`, and
+`keywords` once; the build projects the cleanly-mappable subset — plus the
+pack's `README.md` — into each distribution route's manifest (the `plugin.json`
+/ `marketplace.json` entry), so the catalogue describes each pack richly rather
+than with a single sentence. Extra fields stay in `pack.toml`; the projection
+is deliberately lossy per tool.
+
+Point a catalogue URI (a git URL or a local path) at the repo that holds your packs. Then `validate` a pack against the adapter contract, `render` it to preview the projection, and `install` it into a target repo. `scaffold` drops a pack's seeds into a fresh directory to start from. The build pipeline (`agentbundle.build`) is the same engine `make build` runs.
+
+See the [pack layout reference](https://github.com/eugenelim/agent-ready-repo/blob/main/docs/architecture/pack-layout.md) and [authoring a skill](https://github.com/eugenelim/agent-ready-repo/blob/main/docs/guides/_shared/how-to/author-a-skill.md).
+
+## Credentials
+
+`agentbundle` doesn't resolve secrets. Credentialed skills use [`credbroker`](https://pypi.org/project/credbroker/), a standalone resolver that keeps cleartext out of the model's reach.
+
+## Learn more
+
+The full story — the loop, the reviewers, the pack catalogue — is in the [agent-ready-repo README](https://github.com/eugenelim/agent-ready-repo#readme).

agentbundle-0.4.0/README.md

@@ -0,0 +1,79 @@
+# agentbundle
+
+[![PyPI](https://img.shields.io/pypi/v/agentbundle)](https://pypi.org/project/agentbundle/)
+[![Python](https://img.shields.io/pypi/pyversions/agentbundle)](https://pypi.org/project/agentbundle/)
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)](https://github.com/eugenelim/agent-ready-repo#license)
+
+**The installer for [agent-ready-repo](https://github.com/eugenelim/agent-ready-repo).** Think npm, but for the skills, subagents, and hooks your coding agent runs on.
+
+`agentbundle` installs packs of agent primitives into your repo or your home directory. It projects each primitive into the layout every agent expects. One pack. One command. Every major agent.
+
+```bash
+pip install agentbundle
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo
+```
+
+That lands `core`, the flagship pack and the loop itself, in your repo. Claude Code, Codex, Cursor, Copilot, Gemini, and Kiro all read it.
+
+## Common commands
+
+```bash
+# See what's in a catalogue
+agentbundle list-packs git+https://github.com/eugenelim/agent-ready-repo
+
+# Install the flagship loop into this repo
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo
+
+# Install a pack at user scope, so it follows you across every project
+agentbundle install --pack research git+https://github.com/eugenelim/agent-ready-repo --scope user
+
+# Preview an install without writing a file
+agentbundle install --pack core git+https://github.com/eugenelim/agent-ready-repo --dry-run
+
+# Upgrade a pack; it reports the .upstream files you need to reconcile
+agentbundle upgrade --pack core --to 0.4.0 git+https://github.com/eugenelim/agent-ready-repo
+```
+
+A catalogue is a git URL or a local path. Installs auto-detect your agent; pass `--adapter` to override.
+
+## Build your own catalogue
+
+`agentbundle` isn't tied to the agent-ready-repo catalogue. Any repo that lays its packs out the same way can use it. A pack is a directory:
+
+```text
+my-pack/
+  pack.toml                  # name, version, adapter-contract, install scope,
+                             # plus rich metadata (license, maintainers, links,
+                             # categories, keywords) and a README pointer
+  .claude-plugin/
+    plugin.json              # Claude Code plugin manifest (hand-authored)
+  README.md                  # the pack's portable doc — projected with the pack
+  .apm/                      # primitives — projected by the build pipeline
+    skills/<name>/
+      SKILL.md               # the skill body; one folder per skill
+      references/            # progressive-disclosure docs, loaded on demand
+      assets/                # templates the skill copies into the repo
+    agents/<name>.md         # subagents
+    hooks/<name>.py          # lifecycle hooks
+  seeds/                     # files scaffolded into the adopter repo
+```
+
+`pack.toml` is the **single source of truth** for a pack's metadata. Declare
+`license`, `[[pack.maintainers]]`, `[pack.links]`, `categories`, and
+`keywords` once; the build projects the cleanly-mappable subset — plus the
+pack's `README.md` — into each distribution route's manifest (the `plugin.json`
+/ `marketplace.json` entry), so the catalogue describes each pack richly rather
+than with a single sentence. Extra fields stay in `pack.toml`; the projection
+is deliberately lossy per tool.
+
+Point a catalogue URI (a git URL or a local path) at the repo that holds your packs. Then `validate` a pack against the adapter contract, `render` it to preview the projection, and `install` it into a target repo. `scaffold` drops a pack's seeds into a fresh directory to start from. The build pipeline (`agentbundle.build`) is the same engine `make build` runs.
+
+See the [pack layout reference](https://github.com/eugenelim/agent-ready-repo/blob/main/docs/architecture/pack-layout.md) and [authoring a skill](https://github.com/eugenelim/agent-ready-repo/blob/main/docs/guides/_shared/how-to/author-a-skill.md).
+
+## Credentials
+
+`agentbundle` doesn't resolve secrets. Credentialed skills use [`credbroker`](https://pypi.org/project/credbroker/), a standalone resolver that keeps cleartext out of the model's reach.
+
+## Learn more
+
+The full story — the loop, the reviewers, the pack catalogue — is in the [agent-ready-repo README](https://github.com/eugenelim/agent-ready-repo#readme).

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/_data/adapter.toml

@@ -63,7 +63,15 @@
 # kept and name-mapped; tier-preserving model map. hook-body lands under
 # `.gemini/hooks/` (the cursor model — single prefix at both scopes). kiro-ide-hook
 # dropped. Distribution-only (not in SELF_HOST_ADAPTERS).
-version = "0.13"
+# RFC-0031 / ADR-0021 / docs/specs/enriched-pack-manifest (v0.14): pack.toml
+# becomes the rich metadata source of truth (optional readme / display_name /
+# license / maintainers / links / categories / keywords / [pack.metadata.<tool>]
+# / [pack].catalogue). The build projects the cleanly-projectable subset into
+# the claude-plugins + apm routes (plugin.json / marketplace.json entry) plus
+# each pack's README. All new fields are optional — packs pinned below v0.14
+# build and validate unchanged. Declaration + projection only (no @catalogue/pack
+# resolution, no search, no persisted index).
+version = "0.14"
 
 # Sibling schemas this contract references — pack metadata and the
 # per-pack Claude-plugin manifest. Defined by spec AC #3 + #4.

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/_data/pack.schema.json

@@ -9,6 +9,44 @@
         "name": {"type": "string"},
         "version": {"type": "string"},
         "description": {"type": "string"},
+        "readme": {"type": "string"},
+        "display_name": {"type": "string"},
+        "license": {"type": "string"},
+        "catalogue": {"type": "string"},
+        "categories": {
+          "type": "array",
+          "items": {"type": "string"},
+          "maxItems": 5
+        },
+        "keywords": {
+          "type": "array",
+          "items": {"type": "string"},
+          "maxItems": 5
+        },
+        "maintainers": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["name"],
+            "properties": {
+              "name": {"type": "string"},
+              "email": {"type": "string"},
+              "url": {"type": "string"}
+            }
+          }
+        },
+        "links": {
+          "type": "object",
+          "properties": {
+            "homepage": {"type": "string"},
+            "repository": {"type": "string"},
+            "documentation": {"type": "string"},
+            "changelog": {"type": "string"},
+            "issues": {"type": "string"},
+            "icon": {"type": "string"}
+          }
+        },
+        "metadata": {"type": "object"},
         "adapter-contract": {
           "type": "object",
           "properties": {

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/_data/plugin-manifest.derived.schema.json

@@ -14,6 +14,16 @@
       "type": "array",
       "items": {"type": "string"}
     },
+    "author": {"type": "string"},
+    "license": {"type": "string"},
+    "homepage": {"type": "string"},
+    "repository": {"type": "string"},
+    "keywords": {
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "category": {"type": "string"},
+    "displayName": {"type": "string"},
     "hooks": {
       "type": "object",
       "properties": {

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/_data/plugin-manifest.schema.json

@@ -13,6 +13,16 @@
     "agents": {
       "type": "array",
       "items": {"type": "string"}
-    }
+    },
+    "author": {"type": "string"},
+    "license": {"type": "string"},
+    "homepage": {"type": "string"},
+    "repository": {"type": "string"},
+    "keywords": {
+      "type": "array",
+      "items": {"type": "string"}
+    },
+    "category": {"type": "string"},
+    "displayName": {"type": "string"}
   }
 }

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/build/main.py

@@ -137,6 +137,23 @@ def _read_install_marker_template() -> bytes:
     return (REPO_ROOT / "packages" / "agentbundle" / "templates" / "install-marker.py").read_bytes()
 
 
+def _project_pack_readme(pack_path: Path, per_pack_output: Path) -> None:
+    """Copy a pack's ``README.md`` into its per-pack dist route, if present.
+
+    enriched-pack-manifest T5: the README is the sole portable per-pack doc,
+    and the manifest's ``readme = "README.md"`` pointer resolves relative to
+    the route directory. A pack without a README projects none and does not
+    error (the ``readme`` field is then simply absent / unresolved — never a
+    build failure). ``follow_symlinks=False`` mirrors the pack.toml copy so a
+    symlinked README is not dereferenced into ``dist/`` at build time.
+    """
+    readme_src = pack_path / "README.md"
+    if readme_src.is_file():
+        shutil.copy2(
+            readme_src, per_pack_output / "README.md", follow_symlinks=False
+        )
+
+
 def validate_derived_plugin_manifest_dict(manifest: dict, label: str = "<derived>") -> None:
     """Validate an in-memory derived plugin manifest dict against the derived schema.
 
@@ -161,6 +178,78 @@ def validate_derived_plugin_manifest(plugin_json_path: Path) -> None:
     manifest = json.loads(plugin_json_path.read_text(encoding="utf-8"))
     validate_derived_plugin_manifest_dict(manifest, label=str(plugin_json_path))
 
+
+def derive_projectable_subset(pack_toml: dict) -> dict:
+    """Map a parsed ``pack.toml`` to the projectable plugin-manifest subset.
+
+    enriched-pack-manifest (RFC-0031 / ADR-0021): ``pack.toml`` is the rich
+    metadata source of truth; the build projects a *lossy*, schema-compliant
+    subset into the claude-plugins + apm routes (the ``plugin.json`` /
+    ``marketplace.json`` entry). Fixed mapping:
+
+      - ``author``      ← first ``[[pack.maintainers]]``, rendered
+        ``"Name <email>"`` (name alone when no email).
+      - ``license``     ← ``[pack].license`` (verbatim).
+      - ``homepage``    ← ``[pack.links].homepage`` (verbatim).
+      - ``repository``  ← ``[pack.links].repository`` (verbatim).
+      - ``keywords``    ← ``[pack].keywords`` (string entries, verbatim).
+      - ``category``    ← ``categories[0]``.
+      - ``displayName`` ← ``[pack].display_name``.
+
+    **Emit-only-when-present** is the load-bearing invariant: a key appears in
+    the output only when its source field is present and non-empty, so a
+    legacy ``pack.toml`` declaring none of the enriched fields yields ``{}``
+    and the projected manifest is byte-identical to the pre-enrichment output
+    (legacy-invariance AC). This is a pure function — no I/O, no schema read.
+    """
+    pack = pack_toml.get("pack", {})
+    if not isinstance(pack, dict):
+        return {}
+    out: dict = {}
+
+    maintainers = pack.get("maintainers")
+    if isinstance(maintainers, list) and maintainers:
+        first = maintainers[0]
+        if isinstance(first, dict):
+            name = first.get("name")
+            email = first.get("email")
+            if isinstance(name, str) and name:
+                if isinstance(email, str) and email:
+                    out["author"] = f"{name} <{email}>"
+                else:
+                    out["author"] = name
+
+    license_ = pack.get("license")
+    if isinstance(license_, str) and license_:
+        out["license"] = license_
+
+    links = pack.get("links")
+    if isinstance(links, dict):
+        homepage = links.get("homepage")
+        if isinstance(homepage, str) and homepage:
+            out["homepage"] = homepage
+        repository = links.get("repository")
+        if isinstance(repository, str) and repository:
+            out["repository"] = repository
+
+    keywords = pack.get("keywords")
+    if isinstance(keywords, list):
+        kws = [k for k in keywords if isinstance(k, str) and k]
+        if kws:
+            out["keywords"] = kws
+
+    categories = pack.get("categories")
+    if isinstance(categories, list) and categories:
+        first_cat = categories[0]
+        if isinstance(first_cat, str) and first_cat:
+            out["category"] = first_cat
+
+    display_name = pack.get("display_name")
+    if isinstance(display_name, str) and display_name:
+        out["displayName"] = display_name
+
+    return out
+
 # The three RFC-0001 recipes that plain `make build` invokes.
 # RFC-0002 recipes (per-pack-overlay, composite-agents-md,
 # composite-marketplace) fire only under --self.
@@ -392,6 +481,15 @@ def _run_per_pack_single(
         derived["hooks"] = {
             "SessionStart": [{"command": _SESSION_START_COMMAND}]
         }
+        # enriched-pack-manifest: merge the projectable metadata subset derived
+        # from this pack's pack.toml (emit-only-when-present, so a legacy pack
+        # adds no keys and the output stays byte-identical).
+        pack_toml_for_subset = pack.path / "pack.toml"
+        if pack_toml_for_subset.exists():
+            pack_meta = tomllib.loads(
+                pack_toml_for_subset.read_text(encoding="utf-8")
+            )
+            derived.update(derive_projectable_subset(pack_meta))
         # Validate the derived manifest IN MEMORY before writing to disk
         # (Blocker-3: pre-write validation so a synthesis bug never lands
         # a malformed plugin.json in dist/).
@@ -411,6 +509,12 @@ def _run_per_pack_single(
     if pack_toml_src.exists():
         shutil.copy2(pack_toml_src, per_pack_output / "pack.toml", follow_symlinks=False)
 
+    # enriched-pack-manifest T5: project the pack's README.md into the route so
+    # the manifest's `readme = "README.md"` pointer resolves. The README is the
+    # sole portable per-pack doc. follow_symlinks=False mirrors the pack.toml
+    # copy's posture (a symlinked README is not dereferenced into dist/).
+    _project_pack_readme(pack.path, per_pack_output)
+
     # Project the canonical install-marker.py writer into scripts/.
     scripts_dir = per_pack_output / ".claude-plugin" / "scripts"
     scripts_dir.mkdir(parents=True, exist_ok=True)
@@ -478,6 +582,10 @@ def _run_per_pack_apm(recipe: Recipe, packs: list[Pack], output_dir: Path) -> di
                 follow_symlinks=False,
             )
 
+        # enriched-pack-manifest T5: project the pack's README into the APM
+        # route too (the sole portable per-pack doc; same posture as above).
+        _project_pack_readme(pack.path, per_pack_output)
+
         # Issue #190 / RFC-0001 §595: ship the pack's seeds/ inside the APM
         # package so the governance content travels with the pack on the APM
         # route. symlinks=True preserves a seed symlink as a symlink rather

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/build/self_host.py

@@ -39,6 +39,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import tomllib
 import tempfile
 from pathlib import Path
 
@@ -47,6 +48,7 @@ from agentbundle.build.contract import load as load_contract
 from agentbundle.build.main import (
     CONTRACT_PATH,
     REPO_ROOT,
+    derive_projectable_subset,
     discover_packs,
     validate_pack_uniqueness,
 )
@@ -480,6 +482,14 @@ def _project_seeds(packs_dir: Path, output_root: Path) -> dict[Path, Path]:
     # For re-install / self-host against this repo, Manual targets
     # exist and are preserved.
     for relative, src in seen.items():
+        # Guides are repo-owned and reach adopters via `deliver_seeds` at
+        # install, not via self-host projection. Never scaffold the
+        # by-quadrant guide tree here: the seed stays by-quadrant for
+        # adopters, but writing it during self-host litters a repo that
+        # owns its guides (e.g. organized by pack) with untracked
+        # `docs/guides/<quadrant>/README.md` on every build-self run.
+        if relative.as_posix().startswith("docs/guides/"):
+            continue
         if _is_excluded(relative) and (output_root / relative).exists():
             # Manual file on disk — leave it alone. The seed is
             # placeholder; the on-disk file is the adopter's
@@ -507,7 +517,16 @@ def _aggregate_marketplace(
             continue
         manifest = pack_path / ".claude-plugin" / "plugin.json"
         if manifest.exists():
-            entries.append(json.loads(manifest.read_text(encoding="utf-8")))
+            entry = json.loads(manifest.read_text(encoding="utf-8"))
+            # enriched-pack-manifest: surface the projectable metadata subset
+            # (author / license / links / keywords / category / displayName)
+            # derived from pack.toml, so the catalogue entry is described
+            # richly. Emit-only-when-present keeps legacy entries byte-identical.
+            pack_meta = tomllib.loads(
+                (pack_path / "pack.toml").read_text(encoding="utf-8")
+            )
+            entry.update(derive_projectable_subset(pack_meta))
+            entries.append(entry)
     target = output_root / ".claude-plugin" / "marketplace.json"
     target.parent.mkdir(parents=True, exist_ok=True)
     payload = {

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/build/tests/test_adapter_cursor.py

@@ -52,9 +52,10 @@ class CursorContractTests(unittest.TestCase):
 
     def test_contract_version_is_0_11(self) -> None:
         """AC1 — contract bumped to 0.11 by cursor-full-parity; subsequently
-        0.12 (copilot-skills-and-web) then 0.13 (docs/specs/gemini-full-parity).
+        0.12 (copilot-skills-and-web), 0.13 (docs/specs/gemini-full-parity),
+        then 0.14 (docs/specs/enriched-pack-manifest).
         Name preserved to keep the diff small."""
-        self.assertEqual(self.contract["contract"]["version"], "0.13")
+        self.assertEqual(self.contract["contract"]["version"], "0.14")
 
     def test_cursor_block_projects_five_primitives(self) -> None:
         """AC2 — the five standard primitives are in the projection array."""

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/build/tests/test_adapter_gemini.py

@@ -150,9 +150,10 @@ class GeminiContractTests(unittest.TestCase):
     def setUpClass(cls) -> None:
         cls.contract = load_contract(CONTRACT_PATH)
 
-    def test_contract_version_is_0_13(self) -> None:
-        """AC13 — contract bumped to 0.13."""
-        self.assertEqual(self.contract["contract"]["version"], "0.13")
+    def test_contract_version_is_0_14(self) -> None:
+        """Contract version is 0.14 (docs/specs/enriched-pack-manifest bumped it
+        from gemini-full-parity's 0.13). Renamed from the 0_13 method."""
+        self.assertEqual(self.contract["contract"]["version"], "0.14")
 
     def test_gemini_block_projects_five_primitives(self) -> None:
         """AC2 — five standard primitives with their gemini targets."""
@@ -591,9 +592,18 @@ class GeminiAllPacksAdmissibleTests(unittest.TestCase):
         from agentbundle.commands.install import _resolve_target_adapter
 
         pack_dirs = sorted(p for p in self.PACKS_DIR.iterdir() if (p / "pack.toml").exists())
-        self.assertEqual(len(pack_dirs), 11, f"expected 11 packs, found {len(pack_dirs)}")
+        self.assertTrue(pack_dirs, "no packs discovered under packs/ — pack lookup is broken")
+        # Count-independent by design: don't pin the number of packs (every new
+        # pack would break an unrelated adapter test). Assert gemini resolution
+        # for the packs that *support* gemini — a pack with no allowed-adapters
+        # list admits any shipped adapter; a pack with a list must name gemini.
+        # Packs that constrain to a list without gemini are skipped, not failed.
+        # `checked` is the non-vacuity guard the old hard count used to be.
+        checked = 0
         for pack_dir in pack_dirs:
             allowed = self._allowed_adapters(pack_dir)
+            if allowed is not None and "gemini" not in allowed:
+                continue
             for scope in ("repo", "user"):
                 resolved = _resolve_target_adapter(
                     pack_dir,
@@ -607,6 +617,10 @@ class GeminiAllPacksAdmissibleTests(unittest.TestCase):
                     resolved, "gemini",
                     f"{pack_dir.name} @ {scope}: --adapter gemini was not admitted",
                 )
+            checked += 1
+        self.assertTrue(
+            checked, "no pack exercised gemini admission — the check ran vacuously"
+        )
 
 
 if __name__ == "__main__":

{agentbundle-0.3.0 → agentbundle-0.4.0}/agentbundle/build/tests/test_adapter_kiro_ide.py

@@ -134,13 +134,13 @@ class KiroIdeAdapterTests(unittest.TestCase):
         self.assertIn(".kiro.hook", target_repo)
 
     def test_contract_version_is_0_9(self) -> None:
-        """Contract version is 0.13 (docs/specs/gemini-full-parity, atop
-        copilot-skills-and-web's 0.12 and RFC-0026 / cursor-full-parity's 0.11).
+        """Contract version is 0.14 (docs/specs/enriched-pack-manifest, atop
+        gemini-full-parity's 0.13 and copilot-skills-and-web's 0.12).
         Name preserved to keep the diff small."""
         self.assertEqual(
             self.contract["contract"]["version"],
-            "0.13",
-            "adapter.toml [contract] version must be '0.13' after gemini-full-parity",
+            "0.14",
+            "adapter.toml [contract] version must be '0.14' after enriched-pack-manifest",
         )
 
     def test_kiro_ide_hook_projects_with_flat_prefix_path(self) -> None:

agentbundle-0.4.0/agentbundle/build/tests/test_architect_design_reviewer_projection.py

@@ -0,0 +1,88 @@
+"""Durable projection check for architect's `design-reviewer` subagent (RFC-0032).
+
+architect-design-reviewer spec AC10: the agent must project across **all seven**
+adapters architect declares in `allowed-adapters`. The per-adapter projection
+*mechanism* is covered elsewhere with synthetic agents; this test pins the
+*real* architect agent across every route so a future adapter change that drops
+it fails here. It also lands RFC-0032's deferred `kiro-cli` confirmation
+(`kiro-cli` is the one adapter architect ships that the research pack does not).
+
+Naming varies per adapter (codex emits `.toml`, copilot `.agent.md`, kiro remaps
+frontmatter, …), so the assertion globs `design-reviewer*` under the projected
+output rather than hard-coding one extension.
+"""
+
+from __future__ import annotations
+
+import tempfile
+import tomllib
+import unittest
+from pathlib import Path
+
+from agentbundle.build.adapters import ADAPTERS
+from agentbundle.build.contract import load as load_contract
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+CONTRACT_PATH = REPO_ROOT / "docs" / "contracts" / "adapter.toml"
+ARCHITECT_PACK = REPO_ROOT / "packs" / "architect"
+AGENT_NAME = "design-reviewer"
+
+
+def _architect_allowed_adapters() -> list[str]:
+    data = tomllib.loads((ARCHITECT_PACK / "pack.toml").read_text(encoding="utf-8"))
+    return list(data["pack"]["install"]["allowed-adapters"])
+
+
+class ArchitectDesignReviewerProjectionTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.contract = load_contract(CONTRACT_PATH)
+        cls.adapters = _architect_allowed_adapters()
+
+    def test_source_agent_present(self) -> None:
+        self.assertTrue(
+            (ARCHITECT_PACK / ".apm" / "agents" / f"{AGENT_NAME}.md").exists(),
+            "architect must ship .apm/agents/design-reviewer.md",
+        )
+
+    def test_allowed_adapters_are_the_expected_seven(self) -> None:
+        # Pin the seven so this test (and AC10's "all seven") stays honest if the
+        # list ever changes — update deliberately, with the projection re-checked.
+        self.assertEqual(
+            set(self.adapters),
+            {"claude-code", "codex", "copilot", "kiro-ide", "kiro-cli", "cursor", "gemini"},
+        )
+
+    def test_design_reviewer_projects_for_every_allowed_adapter(self) -> None:
+        for adapter in self.adapters:
+            with self.subTest(adapter=adapter):
+                self.assertIn(adapter, ADAPTERS, f"no projector registered for {adapter!r}")
+                with tempfile.TemporaryDirectory() as tmp:
+                    out = Path(tmp) / "out"
+                    ADAPTERS[adapter](ARCHITECT_PACK, self.contract, out)
+                    hits = list(out.rglob(f"{AGENT_NAME}*"))
+                    self.assertTrue(
+                        hits,
+                        f"{adapter}: design-reviewer agent did not project under {out}",
+                    )
+                    self.assertTrue(
+                        any("agents" in h.parts for h in hits),
+                        f"{adapter}: design-reviewer projected but not under an agents/ route: {hits}",
+                    )
+                    if adapter == "cursor":
+                        # cursor encodes the read-only contract as a `readonly`
+                        # frontmatter flag (it drops the source `tools:` allowlist
+                        # and derives the flag for a non-mutating agent). Assert it
+                        # survives projection so AC5's read-only guarantee holds at
+                        # the one target that represents it as a flag rather than a
+                        # tools list — the design-reviewer flags, never rewrites.
+                        agent_hit = next(h for h in hits if "agents" in h.parts)
+                        self.assertIn(
+                            "readonly",
+                            agent_hit.read_text(encoding="utf-8"),
+                            "cursor: design-reviewer must project with the readonly flag",
+                        )
+
+
+if __name__ == "__main__":
+    unittest.main()