agentbundle 0.43.1__tar.gz → 0.44.2__tar.gz

{agentbundle-0.43.1/agentbundle.egg-info → agentbundle-0.44.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentbundle
-Version: 0.43.1
+Version: 0.44.2
 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-Expression: Apache-2.0 OR MIT
@@ -34,6 +34,34 @@ python -m pip install agentbundle
 
 Requires Python 3.11+. Runs on macOS, Linux, and Windows.
 
+## What's new in 0.44.2
+
+A catalogue you derive with `catalogue init --preset self-hosted` now keeps a
+working drift check on its vendored `credbroker` code. Selecting the
+`credential-brokers` pack copies the package source alongside it, so the check
+that compares the vendored copy against that source has something to compare.
+Previously the source was left behind and the check passed by finding nothing:
+the vendored copy was frozen, and an edit to it went unreported.
+
+`--attribution white-label` also no longer records the upstream catalogue's
+name in `.agentbundle/self-host-state.json`. That file is written after the
+identity scan runs, so the name reached a file you commit and ship. It now
+records your own catalogue's name. `--attribution attributed` is unchanged and
+still records the upstream name.
+
+## What's new in 0.44.1
+
+Installing a pack now adds its default output location to an
+`agentbundle-layout.toml` you already keep. That step has existed for several
+releases and never wrote anything: it looked for a manifest key no pack
+declares, and named the table after the pack while every skill reads a
+differently-named section. A pack now declares the section it writes.
+
+The append also stops rewriting your file. It adds one table and leaves every
+other byte alone — comments, key order, quoting style, line endings, and any
+key it does not recognise — and the file keeps its permissions. A layout
+problem is reported and the install finishes; it no longer aborts.
+
 ## What's new in 0.43.1
 
 `agentbundle catalogue init` now writes `packs/CLAUDE.md` and

{agentbundle-0.43.1 → agentbundle-0.44.2}/README-pypi.md

@@ -14,6 +14,34 @@ python -m pip install agentbundle
 
 Requires Python 3.11+. Runs on macOS, Linux, and Windows.
 
+## What's new in 0.44.2
+
+A catalogue you derive with `catalogue init --preset self-hosted` now keeps a
+working drift check on its vendored `credbroker` code. Selecting the
+`credential-brokers` pack copies the package source alongside it, so the check
+that compares the vendored copy against that source has something to compare.
+Previously the source was left behind and the check passed by finding nothing:
+the vendored copy was frozen, and an edit to it went unreported.
+
+`--attribution white-label` also no longer records the upstream catalogue's
+name in `.agentbundle/self-host-state.json`. That file is written after the
+identity scan runs, so the name reached a file you commit and ship. It now
+records your own catalogue's name. `--attribution attributed` is unchanged and
+still records the upstream name.
+
+## What's new in 0.44.1
+
+Installing a pack now adds its default output location to an
+`agentbundle-layout.toml` you already keep. That step has existed for several
+releases and never wrote anything: it looked for a manifest key no pack
+declares, and named the table after the pack while every skill reads a
+differently-named section. A pack now declares the section it writes.
+
+The append also stops rewriting your file. It adds one table and leaves every
+other byte alone — comments, key order, quoting style, line endings, and any
+key it does not recognise — and the file keeps its permissions. A layout
+problem is reported and the install finishes; it no longer aborts.
+
 ## What's new in 0.43.1
 
 `agentbundle catalogue init` now writes `packs/CLAUDE.md` and

{agentbundle-0.43.1 → agentbundle-0.44.2}/agentbundle/_data/catalogue-scaffold/manifest.json

@@ -16,6 +16,7 @@
     "profiles/_example/README.md": "164494df049ddce3e57cb44ed604cb3d39be0a6ec2072e609ea3fa4bbfc74c72",
     "profiles/_example/profile.toml": "68af18cf50fa0327a9776b029c92bb1cf82710c649691b3ac889eb8537b8eac7",
     "tests/conformance/test_gemini_admissibility.py": "8b337da9272823aed2cb22041b3f9fd27549f075f28b9817efd5be8f8c5bb948",
+    "tests/conformance/test_pack_layout_declared_section.py": "1e03e04b995bd3f3cd2e6362c07d05514d3fe995c0fbe59045e3cc11a1e787a0",
     "tests/conformance/test_pack_metadata.py": "8ea175b88cc6e10ba10cda87676fc225ee2b968d710c8e6ab05fb20e31ec978a",
     "tests/conformance/test_shared_library_boundaries.py": "5e07783459336e657a355f43aa5a9cf6c138603624daec258ecc0fa3d74239c3"
   },

agentbundle-0.44.2/agentbundle/_data/catalogue-scaffold/tests/conformance/test_pack_layout_declared_section.py

@@ -0,0 +1,236 @@
+"""A pack's declared layout section must be one it documents (spec AC6).
+
+`agentbundle install` appends `[<section>] output_dir = <output_dir>` to an
+adopter's `agentbundle-layout.toml`, taking both values from the pack manifest.
+Every consuming skill then reads that section by prose instruction in its own
+`SKILL.md` — no skill calls Python, so nothing at runtime can reconcile a
+manifest that names a section the pack's own documentation does not.
+
+That is exactly how the original defect survived two releases: the writer and
+the readers were each exercised against their own idea of the shape. So this
+check derives **both** sides from the repository and compares them. It carries
+no list of expected section names; a list is the hand-maintained table the
+design rejects.
+
+Matching the *pair* rather than the section alone is what makes the check
+discriminate. A pack may legitimately document several sections: one per
+output tree it owns, plus any it only *reads* from a sibling pack. Section
+membership alone would then admit a declaration that crosses two of them — a
+section from one documented pair carried on the base from another — which
+installs a default under a section whose readers resolve somewhere else. No
+document describes that combination, and the pair rule is what rejects it.
+
+This file is pack-portable by rule: it derives every pack and every pair from
+the tree rather than naming any. It also ships — `catalogue init` writes it
+into an adopter's catalogue, which may hold no packs, or packs that declare no
+layout — so every tree-derived case skips when its evidence is absent, and the
+rule's own discrimination is proven against synthetic input that is always
+present and can never be vacuous.
+
+That the *source* catalogue actually supplies that evidence is a claim about
+this repository, not about every catalogue, so it lives in `tests/roster/`,
+which does not ship. Without it a mis-rooted glob here would skip rather than
+fail.
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PACKS_DIR = REPO_ROOT / "packs"
+
+# `[section]` immediately followed by an `output_dir = "..."` assignment, inside
+# one fenced block. Intervening comment lines are allowed; a blank line is not,
+# so two unrelated examples cannot be read as one pair.
+_PAIR = re.compile(
+    r"^\[([a-z0-9][a-z0-9-]*)\]\n(?:#[^\n]*\n)*output_dir = \"([^\"]+)\"",
+    re.MULTILINE,
+)
+
+
+def _declaring_packs() -> list[tuple[str, str, str, str]]:
+    """(pack, scope, section, output_dir) for every declared layout scope.
+
+    Both scopes, because the installer honours `[pack.layout.user]` too. No
+    shipped pack declares one today, but this file ships into adopter
+    catalogues where one could — and a user-scope pair no document describes
+    would otherwise pass unseen.
+    """
+    found = []
+    for manifest in sorted(PACKS_DIR.glob("*/pack.toml")):
+        layout = (
+            tomllib.loads(manifest.read_text(encoding="utf-8"))
+            .get("pack", {})
+            .get("layout", {})
+        )
+        for scope in ("repo", "user"):
+            table = layout.get(scope)
+            if not table:
+                continue
+            section, output_dir = table.get("section"), table.get("output_dir")
+            if section is None and output_dir is None:
+                continue
+            found.append((manifest.parent.name, scope, section, output_dir))
+    return found
+
+
+def _is_repo_scope_base(base: str) -> bool:
+    """A repo-scope base is relative; a user-scope base is absolute.
+
+    This is the anchoring rule the layout contract already states — a
+    repo-root file's value is repo-root-relative, a user-profile file's must
+    be an explicit absolute path. Reading scope off the value keeps the check
+    from depending on how a fenced example is commented.
+    """
+    return not base.startswith(("/", "~"))
+
+
+def _documented_pairs(pack: str, *, repo_scope: bool = True) -> set[tuple[str, str]]:
+    """Every (section, base) pair this pack's docs state for one scope.
+
+    Scope matters: a pack's reference docs carry both a repo-scope and a
+    user-scope example for the same section, so unioning them would let a
+    repo-scope declaration be validated by the user-scope base — a pair no
+    reader of the repo file would ever resolve.
+    """
+    pairs: set[tuple[str, str]] = set()
+    for doc in (PACKS_DIR / pack).rglob("references/agentbundle-layout.md"):
+        pairs |= {
+            (section, base)
+            for section, base in _PAIR.findall(doc.read_text(encoding="utf-8"))
+            if _is_repo_scope_base(base) is repo_scope
+        }
+    return pairs
+
+
+def _is_admitted(
+    section: str, output_dir: str, documented: set[tuple[str, str]]
+) -> bool:
+    """The admission decision, in one place.
+
+    Both the tree-derived case and the discrimination proof call this, so a
+    weakening — to section membership alone, say — fails the proof instead of
+    passing it.
+    """
+    return (section, output_dir) in documented
+
+
+def test_the_admission_rule_rejects_a_crossed_declaration() -> None:
+    """A section from one documented pair, carried on another's base.
+
+    Asserted through `_is_admitted`, the same predicate the tree-derived case
+    uses. Weakening that predicate to section membership admits the crossing
+    and turns this red.
+    """
+    documented = {("alpha", "one/alpha"), ("beta", "two/beta")}
+
+    assert _is_admitted("alpha", "one/alpha", documented)
+    assert _is_admitted("beta", "two/beta", documented)
+    assert not _is_admitted("alpha", "two/beta", documented)
+    assert not _is_admitted("beta", "one/alpha", documented)
+
+
+@pytest.mark.parametrize("pack,scope,section,output_dir", _declaring_packs())
+def test_declared_pair_is_documented_by_the_pack(  # noqa: D103
+    pack: str, scope: str, section: str | None, output_dir: str | None
+) -> None:
+    assert section, f"{pack} declares a {scope} layout without a section"
+    assert output_dir, f"{pack} declares a {scope} layout without an output_dir"
+
+    documented = _documented_pairs(pack, repo_scope=scope == "repo")
+    assert documented, f"{pack} declares a layout but documents no section"
+    assert _is_admitted(section, output_dir, documented), (
+        f"{pack} declares ({section!r}, {output_dir!r}); its reference docs "
+        f"document {sorted(documented)}. The installer writes the declared "
+        f"pair, so a pair no document describes installs a default the pack's "
+        f"own skills will not read."
+    )
+
+
+def _crossed_pairs(pairs: set[tuple[str, str]]) -> set[tuple[str, str]]:
+    """Every (section, base) formed from two *different* documented pairs."""
+    return {
+        (one_section, other_base)
+        for one_section, one_base in pairs
+        for other_section, other_base in pairs
+        if one_section != other_section and one_base != other_base
+    }
+
+
+def test_the_rule_rejects_a_crossed_pair() -> None:
+    """The rule must discriminate, proven without depending on the tree.
+
+    Section membership alone would admit a declaration that takes its section
+    from one documented pair and its base from another. This is the property
+    that makes the pair rule worth having, so it is asserted against synthetic
+    input rather than against whichever packs happen to document two pairs
+    today — on an empty catalogue that evidence would simply be absent, and
+    the guarantee would silently stop being checked.
+    """
+    documented = {("alpha", "one/alpha"), ("beta", "two/beta")}
+    crossed = _crossed_pairs(documented)
+
+    assert crossed == {("alpha", "two/beta"), ("beta", "one/alpha")}
+    assert not (crossed & documented), "a crossed pair must never be documented"
+
+
+def test_a_repo_declaration_is_not_validated_by_a_user_scope_example() -> None:
+    """The scope split must discriminate, not merely pass on today's tree.
+
+    A pack documenting the same section at both scopes offers two bases. If
+    the check unioned them, a repo-scope manifest carrying the user-scope base
+    would pass while naming a path no reader of the repo file resolves.
+    """
+    checked = 0
+    for pack, _scope, _section, _base in _declaring_packs():
+        repo_pairs = _documented_pairs(pack, repo_scope=True)
+        user_pairs = _documented_pairs(pack, repo_scope=False)
+        for section, user_base in user_pairs:
+            if any(s == section for s, _ in repo_pairs):
+                assert (section, user_base) not in repo_pairs
+                checked += 1
+    if not checked:
+        pytest.skip("no pack here documents one section at both scopes")
+
+
+def test_no_pack_documents_a_crossing_of_its_own_pairs() -> None:
+    """The same property over the real tree, where there is one."""
+    for pack, _scope, _section, _base in _declaring_packs():
+        pairs = _documented_pairs(pack)
+        assert not (_crossed_pairs(pairs) & pairs), (
+            f"{pack} documents a pair and also a crossing of it, so the rule "
+            "cannot discriminate for that pack"
+        )
+
+
+def test_every_reference_doc_agrees_with_its_pack_on_the_base() -> None:
+    """AC6 admits a pair documented in *one* doc; this requires all of them.
+
+    A pack with several reference pages can otherwise regress one of them to a
+    base the installer does not write, and stay green — the adopter reading
+    that page gets a location nothing populates.
+    """
+    walked = 0
+    for pack, scope, section, output_dir in _declaring_packs():
+        if scope != "repo":
+            continue
+        for doc in sorted((PACKS_DIR / pack).rglob("references/agentbundle-layout.md")):
+            pairs = {
+                (s, b)
+                for s, b in _PAIR.findall(doc.read_text(encoding="utf-8"))
+                if s == section and _is_repo_scope_base(b)
+            }
+            if not pairs:
+                continue  # this page documents another section, or user scope
+            walked += 1
+            assert pairs == {(section, output_dir)}, (
+                f"{doc.relative_to(REPO_ROOT)} documents {sorted(pairs)} for "
+                f"[{section}] while {pack} declares {output_dir!r}"
+            )
+    if not walked:
+        pytest.skip("no reference doc here documents a declared repo-scope section")

{agentbundle-0.43.1 → agentbundle-0.44.2}/agentbundle/_data/pack.schema.json

@@ -248,7 +248,8 @@
               "properties": {
                 "parent": {"type": "string"},
                 "template": {"type": "string"},
-                "output_dir": {"type": "string"}
+                "output_dir": {"type": "string"},
+                "section": {"type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$"}
               }
             },
             "user": {
@@ -257,7 +258,8 @@
               "properties": {
                 "parent": {"type": "string"},
                 "template": {"type": "string"},
-                "output_dir": {"type": "string"}
+                "output_dir": {"type": "string"},
+                "section": {"type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$"}
               }
             }
           }

{agentbundle-0.43.1 → agentbundle-0.44.2}/agentbundle/_data/workspace_status_engine.py

@@ -297,6 +297,16 @@ class LegacyWorkspaceMembership:
     entry_index: int = 0
 
 
+@dataclasses.dataclass(frozen=True)
+class ParseBlockedWorkspaceMembership:
+    """One target-like entry whose safe artifact identity survived parsing."""
+
+    canonical_artifact_path: str
+    ini_slug: str
+    collection: str
+    entry_index: int
+
+
 @dataclasses.dataclass(frozen=True)
 class MigrationSelection:
     """Closed human-selected binding from one legacy finding to one target."""
@@ -2481,12 +2491,12 @@ def _extract_canonical_memberships(
     list[WorkspaceMembership],
     list[LegacyWorkspaceMembership],
     list[RoutingFinding],
-    dict[str, int],
+    list[ParseBlockedWorkspaceMembership],
 ]:
     memberships: list[WorkspaceMembership] = []
     legacy_memberships: list[LegacyWorkspaceMembership] = []
     findings: list[RoutingFinding] = []
-    parse_blocked_path_counts: dict[str, int] = {}
+    parse_blocked_memberships: list[ParseBlockedWorkspaceMembership] = []
     for section_name, top_level_names in _TOP_LEVEL_ENTRY_COLLECTIONS.items():
         section = workspace.get(section_name, {})
         if not isinstance(section, dict):
@@ -2514,8 +2524,13 @@ def _extract_canonical_memberships(
                         dataclasses.replace(legacy_membership, entry_index=entry_index)
                     )
                 if blocked_path is not None:
-                    parse_blocked_path_counts[blocked_path] = (
-                        parse_blocked_path_counts.get(blocked_path, 0) + 1
+                    parse_blocked_memberships.append(
+                        ParseBlockedWorkspaceMembership(
+                            canonical_artifact_path=blocked_path,
+                            ini_slug="",
+                            collection=collection,
+                            entry_index=entry_index,
+                        )
                     )
                 findings.extend(entry_findings)
     for raw_ini_slug, section in workspace.items():
@@ -2569,11 +2584,16 @@ def _extract_canonical_memberships(
                             dataclasses.replace(legacy_membership, entry_index=entry_index)
                         )
                     if blocked_path is not None:
-                        parse_blocked_path_counts[blocked_path] = (
-                            parse_blocked_path_counts.get(blocked_path, 0) + 1
+                        parse_blocked_memberships.append(
+                            ParseBlockedWorkspaceMembership(
+                                canonical_artifact_path=blocked_path,
+                                ini_slug=ini_slug,
+                                collection=collection,
+                                entry_index=entry_index,
+                            )
                         )
                     findings.extend(entry_findings)
-    return memberships, legacy_memberships, findings, parse_blocked_path_counts
+    return memberships, legacy_memberships, findings, parse_blocked_memberships
 
 
 def _membership_status(membership: WorkspaceMembership) -> str | None:
@@ -2856,6 +2876,115 @@ def _legacy_canonical_alias(entry: LegacyWorkspaceEntry) -> str | None:
     return None
 
 
+_SELECTED_SPEC_COLLECTIONS = frozenset(
+    {"backlog.open", "work.queue", "work.active", "work.shipped"}
+)
+
+
+def selected_membership_status(root: Path, selectors: list[str]) -> dict[str, object]:
+    """Return membership occurrences for an explicit ordered spec selection.
+
+    The selected spec artifacts need not exist. Only ``workspace.toml`` is read;
+    matching is performed on canonical repository-relative artifact identities.
+    """
+    if not selectors:
+        return {"error": {"code": "empty_selection"}}
+
+    selected_artifact_paths: list[str] = []
+    for selector in selectors:
+        artifact_path = f"{selector}/spec.md" if isinstance(selector, str) else ""
+        if (
+            not _is_canonical_spec_artifact_path(artifact_path)
+            or _confined_artifact_path(root, selector) is None
+        ):
+            return {"error": {"code": "invalid_selector"}}
+        selected_artifact_paths.append(artifact_path)
+
+    workspace_path = _confined_artifact_path(root, "workspace.toml")
+    if workspace_path is None:
+        return {"error": {"code": "invalid_workspace"}}
+    try:
+        workspace = parse_workspace(workspace_path)
+    except tomllib.TOMLDecodeError:
+        return {"error": {"code": "malformed_toml"}}
+    except OSError:
+        return {"error": {"code": "invalid_workspace"}}
+
+    (
+        memberships,
+        legacy_memberships,
+        findings,
+        parse_blocked_memberships,
+    ) = _extract_canonical_memberships(workspace)
+    if any(finding.code == "invalid_workspace" for finding in findings):
+        return {"error": {"code": "invalid_workspace"}}
+
+    occurrences_by_path: dict[str, list[dict[str, object]]] = {
+        path: [] for path in selected_artifact_paths
+    }
+    for membership in memberships:
+        path = membership.entry.path
+        if (
+            membership.entry.kind != "spec"
+            or membership.collection not in _SELECTED_SPEC_COLLECTIONS
+            or path not in occurrences_by_path
+        ):
+            continue
+        occurrences_by_path[path].append(
+            {
+                "canonical_artifact_path": path,
+                "initiative": membership.ini_slug or None,
+                "collection": membership.collection,
+                "entry_index": membership.entry_index,
+                "form": "canonical",
+            }
+        )
+    for legacy_membership in legacy_memberships:
+        path = _legacy_canonical_alias(legacy_membership.entry)
+        if (
+            legacy_membership.collection not in _SELECTED_SPEC_COLLECTIONS
+            or path not in occurrences_by_path
+        ):
+            continue
+        occurrences_by_path[path].append(
+            {
+                "canonical_artifact_path": path,
+                "initiative": legacy_membership.ini_slug or None,
+                "collection": legacy_membership.collection,
+                "entry_index": legacy_membership.entry_index,
+                "form": "legacy",
+            }
+        )
+    for blocked_membership in parse_blocked_memberships:
+        path = blocked_membership.canonical_artifact_path
+        if (
+            blocked_membership.collection not in _SELECTED_SPEC_COLLECTIONS
+            or path not in occurrences_by_path
+        ):
+            continue
+        occurrences_by_path[path].append(
+            {
+                "canonical_artifact_path": path,
+                "initiative": blocked_membership.ini_slug or None,
+                "collection": blocked_membership.collection,
+                "entry_index": blocked_membership.entry_index,
+                "form": "parse-blocked",
+            }
+        )
+
+    return {
+        "results": [
+            {
+                "selected_directory": selector,
+                "canonical_artifact_path": artifact_path,
+                "membership_present": bool(occurrences_by_path[artifact_path]),
+                "occurrences": occurrences_by_path[artifact_path],
+            }
+            for selector, artifact_path in zip(selectors, selected_artifact_paths, strict=True)
+        ]
+    }
+
+
 def _legacy_membership_is_cooled(
     membership: LegacyWorkspaceMembership,
     root: Path | None,
@@ -3421,8 +3550,12 @@ def run_canonical_reconciliation(
         memberships,
         legacy_memberships,
         parse_findings,
-        parse_blocked_path_counts,
+        parse_blocked_memberships,
     ) = _extract_canonical_memberships(workspace)
+    parse_blocked_path_counts: dict[str, int] = {}
+    for blocked in parse_blocked_memberships:
+        path = blocked.canonical_artifact_path
+        parse_blocked_path_counts[path] = parse_blocked_path_counts.get(path, 0) + 1
     # Cooling is applied at evaluation and emission, never here. Every fact
     # derived below — by_path, duplicate_paths, cycle_paths, legacy_alias_counts
     # and the structural loop — must see a cooled artifact as *cooled*, not as

{agentbundle-0.43.1 → agentbundle-0.44.2}/agentbundle/catalogue_tooling/initialise_self_hosted.py

@@ -28,6 +28,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from agentbundle.build.user_libs import PACK_NAME as _USER_LIBS_PACK
+from agentbundle.build.user_libs import PACKAGE_SUBPATH as _USER_LIBS_PACKAGE_SUBPATH
 from agentbundle.catalogue_tooling.file_safety import (
     UnsafeContentError,
     read_confined_regular_file,
@@ -116,6 +118,33 @@ _BUILD_RESIDUE_DIRS: frozenset[str] = frozenset(
 _BUILD_RESIDUE_FILES: frozenset[str] = frozenset({".DS_Store", "coverage.xml"})
 _VENDORED_PACK_EXCLUDE: tuple[str, ...] = ("tests/",)
 
+# The credbroker project directory: the parent of the package `user_libs`
+# resolves. `user_libs._package_source_dir` looks for the package at
+# `packs_dir.parent / PACKAGE_SUBPATH`, i.e. `<catalogue root>/packages/
+# credbroker/credbroker/`, so a derived catalogue must carry it at exactly that
+# path. Derived from the resolver's own constant rather than re-spelled, so the
+# copy follows the resolver if that path ever moves.
+#
+# Absent it, `compute_projections` finds no sources and returns `[]`, which
+# makes BOTH its consumers silent no-ops in the derived tree: `apply_projection`
+# writes no `.agentbundle/lib/credbroker/` floor, and `check_drift` compares
+# nothing and reports clean. The pack-vendored copy under
+# `.apm/user-libs/credbroker/` still arrives with the pack, so credbroker still
+# runs — as frozen content with no source and no drift signal.
+#
+# This is deliberately NOT the `packages/agentbundle/` treatment. That one is
+# vendored to `.agentbundle/tooling/agentbundle/` because it is an *install
+# source* the adopter `pip install -e`s. credbroker is a *build input resolved
+# by relative path*. Same principle, different mechanics: the two paths are not
+# interchangeable and must not be reconciled.
+_USER_LIBS_PACKAGE_DIR: str = _USER_LIBS_PACKAGE_SUBPATH.parent.as_posix()
+
+# No test content ships to a derived catalogue — the same boundary
+# `_VENDORED_PACK_EXCLUDE` draws. `user_libs.collect_sources` already excludes
+# `tests` from the projection, so the drift gate compares the same file set
+# either way and this costs the gate nothing.
+_USER_LIBS_PACKAGE_EXCLUDE: tuple[str, ...] = ("tests/",)
+
 
 # ---------------------------------------------------------------------------
 # Dataclasses
@@ -780,6 +809,42 @@ def _write_ownership_state(target: Path, state: SelfHostOwnershipState) -> None:
     )
 
 
+def _source_pack_identity(
+    source_meta: dict[str, Any], cfg: SelfHostedInitConfig
+) -> str:
+    """Return the pin recorded in the committed ownership state file.
+
+    Under ``attributed``, that is the source catalogue's name — the accurate
+    provenance pin, and permitted because attributed mode makes no promise of
+    anonymity.
+
+    Otherwise it is the **derived** catalogue's name. The source name is
+    identity anchor #1, and ``verify()`` allows it zero hits anywhere in
+    white-label mode. But the leak check runs over the planned ``file_bytes``
+    map, and ``_OWNERSHIP_STATE_FILE`` is written afterwards and is never in
+    that map — so pinning the source name here would ship the exact banned
+    string in a file the adopter commits, past a control that cannot see it.
+
+    Bringing the state file inside the leak check would instead make a usable
+    pin impossible in the very mode that most needs control over what ships,
+    so the value changes rather than the check's scope.
+
+    The branch is on ``attributed`` rather than on ``white-label`` so that any
+    other value fails closed to the non-disclosing pin, matching how
+    ``_apply_identity_transform_bytes`` and ``verify`` both treat ``attributed``
+    as the single exception.
+
+    Note for editors: this module's own prose is vendored into a target and
+    scanned. ``_transform_text`` replaces anchors case-sensitively while
+    ``verify`` matches case-insensitively, so a differently-cased echo of an
+    anchor value here survives replacement and then fails the leak check. Keep
+    identity wording generic.
+    """
+    if cfg.attribution == "attributed":
+        return source_meta.get("catalogue", {}).get("name", "")
+    return cfg.name or ""
+
+
 # ---------------------------------------------------------------------------
 # Next-steps builder
 # ---------------------------------------------------------------------------
@@ -950,6 +1015,27 @@ def init_self_hosted(cfg: SelfHostedInitConfig) -> SelfHostedInitResult:
         if collect_error:
             return _fail(collect_error)
 
+    # The credbroker package source travels with the pack that vendors it, in
+    # BOTH tooling modes — it is a build input the user-libs projection resolves
+    # by relative path, not an install source. See _USER_LIBS_PACKAGE_DIR.
+    if _USER_LIBS_PACK in pack_names:
+        src_user_libs = cfg.source / _USER_LIBS_PACKAGE_DIR
+        if src_user_libs.is_dir() and not src_user_libs.is_symlink():
+            collect_error = _collect_source_dir(
+                src_user_libs,
+                _USER_LIBS_PACKAGE_DIR,
+                kind="package",
+                exclude=_USER_LIBS_PACKAGE_EXCLUDE,
+            )
+            if collect_error:
+                return _fail(collect_error)
+        else:
+            diagnostics.append(
+                f"{_USER_LIBS_PACKAGE_DIR}/ not found in source; the "
+                f"{_USER_LIBS_PACK} pack ships without its package source, so "
+                "the user-libs projection and its drift gate stay inert"
+            )
+
     # Vendored mode: copy agentbundle source and catalogue-curation.
     if cfg.tooling == "vendored":
         src_agentbundle = cfg.source / "packages" / "agentbundle"
@@ -1097,7 +1183,7 @@ def init_self_hosted(cfg: SelfHostedInitConfig) -> SelfHostedInitResult:
             ],
             adapters=adapters,
             managed_target_path=str(cfg.target),
-            source_pack_identity=source_meta.get("catalogue", {}).get("name", ""),
+            source_pack_identity=_source_pack_identity(source_meta, cfg),
             source_root_kind="self-hosted-source",
         )
         _write_ownership_state(cfg.target, new_state)