@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.4

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/policy/grants-registry.yaml

@@ -0,0 +1,112 @@
+schema: adl.exception-register/v1
+created: '2026-08-22'
+catalogs:
+  - path: compliance/policy/grants/typescript.audit.yaml
+    source: retired 2026-08-23 (frontend-bun-audit-exceptions.json deleted; catalog is now the sole record)
+    source_count: 0
+  - path: compliance/policy/grants/rust.audit.yaml
+    source: retired 2026-08-23 (backend-cargo-audit-exceptions.json deleted; catalog is now the sole record)
+    source_count: 0
+  # backend-parity.yaml removed 2026-08-23. Parity with the legacy
+  # check-rust-policy.py was reached, the catalog held zero entries, and no
+  # `.py` remains under .workflows/ for it to be parity WITH. The register
+  # outlived the file by a day and blocked gate-profile-report until now.
+  - path: compliance/policy/grants/rust.run-001-command-boundary.yaml
+    source: .workflows/config/profiles/rule-profiles.yaml (rust.run-001-command-boundary)
+    source_count: 2
+  - path: compliance/policy/grants/rust.todo-unimplemented-in-test.yaml
+    source: .workflows/config/profiles/rule-profiles.yaml (rust.todo-unimplemented-in-test)
+    source_count: 1
+  - path: compliance/policy/grants/rust.no-ignore-in-tests.yaml
+    source: .workflows/config/profiles/rule-profiles.yaml (rust.no-ignore-in-tests)
+    source_count: 0
+    # emptied 2026-08-24: all 19 inherited #[ignore] uses migrated to Cargo
+    # feature gating the same day (rust.no-ignore-in-tests report now clean
+    # with zero exceptions). File kept as entries: [] -- deletion is blocked
+    # by the sandbox for this tree; the profile row's `exceptions:` reference
+    # stays valid rather than pointing at a removed file.
+  - path: compliance/policy/grants/typescript.no-test-skip.yaml
+    source: .workflows/config/profiles/rule-profiles.yaml (typescript.no-test-skip)
+    source_count: 71
+    # 2743 -> 6045 on 2026-08-23: the old backlog measures 0 and the count is now
+    # entirely ultracite/biome/type-aware's eight project-scanner rules.
+  - path: compliance/policy/grants/framework.inline-suppressions.yaml
+    source: tracked repository inline markers at 8094e112 excluding plan examples
+    baseline_source_count: 145
+    source_count: 186
+  - path: compliance/policy/grants/typescript.bundle-size.yaml
+    source: compliance/policy/grants/typescript.bundle-size.yaml
+    source_count: 1
+  - path: compliance/policy/grants/rust.verified-exception.yaml
+    source: compliance/policy/grants/rust.verified-exception-entry.yaml
+    source_count: 0
+  - path: compliance/policy/grants/rust.crate-edges.yaml
+    source: compliance/policy/inputs/rust-crate-register.yaml
+    source_count: 0
+  # frontend-symbols.yaml removed 2026-08-23 together with its source register
+  # .workflows/config/frontend/frontend-symbol-register.yaml (DEF-0029): the
+  # catalog held zero entries and the register's documented consumers did not
+  # exist, so it granted nothing to nobody.
+  - path: compliance/policy/grants/framework.no-python.yaml
+    source: .workflows/scripts/gates/meta/check-no-python.sh (PY-01)
+    source_count: 2
+  - path: compliance/policy/grants/framework.no-silent-degrade.yaml
+    source: .workflows/scripts/gates/meta/check-no-silent-degrade.sh (SD-01, SD-02)
+    source_count: 1
+  # Registered 2026-08-23. All three suppressed real frontend findings while
+  # appearing in no register, in no profile row's `exceptions:` field, and in no
+  # column of the debt report. An allowance nobody can enumerate is not a
+  # reviewed exception, it is an unrecorded one.
+  - path: compliance/policy/baselines/typescript.dead-code-accounting.yaml
+    source: compliance/policy/grants/typescript.dead-code.yaml
+    source_count: 669
+  # frontend-english-only.yaml retired 2026-08-27, per DEF-0050's own
+  # requirement ("Retire frontend-english-only.yaml and its index entry with
+  # it"). 40 -> 0: the docs.english-only row no longer declares an
+  # `exceptions:` field at all, so this catalog grants nothing regardless of
+  # its contents. Its last 40 findings resolved two ways, not one: the 7
+  # officecli-pitch-deck untranslated-donor-jargon findings were FIXED in
+  # place (Englishized, with dev/seed/capabilities/skill.csv's
+  # content_sha256 recomputed per backend/crates/enact-db/src/repository/skill.rs:81);
+  # the other 33 were reclassified as SCOPE, not an exception -- CJK-handling
+  # code and test fixtures (frontend) or byte-exact/matcher CJK technical
+  # content (dev/seed/capabilities/skill.csv), never prose to translate.
+  # Scope now lives in .workflows/config/docs/english-only-scope.yaml,
+  # resolved via gate_path docs.english_only_scope and read directly by the
+  # gate -- the same reason layout.directory-ratchet's own
+  # excluded_paths/excluded_single_files hold no index entry either: a scope
+  # exclusion is never a grant this register holds.
+  #
+  # The entry itself is now gone too. It was kept as `entries: []` only so
+  # `source_count` would match a file that still existed; the restructure
+  # deleted .workflows/config/exceptions/ entirely, and an index row naming an
+  # absent catalog is a hard failure in gate-profile-report, not a harmless
+  # leftover -- it took framework.violation-baseline down to "could not run".
+  # 224 -> 92 on 2026-08-27. Three owner decisions in one change: every
+  # max_children ceiling raised to 20, `.workflows` dropped as a scanned tree,
+  # and two SCOPE mechanisms added to the baseline (excluded_paths,
+  # excluded_single_files) for shapes the rule should never have judged --
+  # locale directories, vendored skill and harness assets, per-domain seed
+  # CSVs, and any directory whose only file is a Cargo.toml or a main.tf.
+  # 124 entries were deleted as dead rather than granted away.
+  - path: compliance/policy/baselines/layout.directory-ratchet-accounting.yaml
+    source: compliance/policy/grants/layout.directory-ratchet.yaml
+    source_count: 92
+  # frontend-size-ratchet.yaml and its baseline removed 2026-08-24 with the
+  # frontend.file-function-ratchet gate they served. The gate graded files and
+  # functions by LINE COUNT as a proxy for bundle size, and line count does not
+  # determine shipped bytes -- frontend.bundle-size measures those directly,
+  # including the singleChunkMb ceiling. 218 overrides for a proxy metric with
+  # no evidence it achieved its stated purpose. Owner decision.
+  # The shared empty catalog, added 2026-08-27. Every row in the profile
+  # registry now names a grants catalog, so `granted` is a signed number rather
+  # than an absent key. This changes nothing about enforcement -- absence
+  # already meant zero, per the mechanism in AGENTS.md -- it only makes the
+  # zero explicit and reviewable. 128 of the 142 gates grant nothing and all
+  # point here rather than each carrying an identical zero-entry file: 128 empty
+  # catalogs would breach the .workflows directory-ratchet ceiling and add 128
+  # register rows describing nothing. A gate leaves this catalog the moment it
+  # needs its first grant, which makes that switch visible in review.
+  - path: compliance/policy/grants/zero.yaml
+    source: compliance/policy/gate-registry.yaml (every gate granting nothing)
+    source_count: 0

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/policy/grants.py

@@ -0,0 +1,129 @@
+"""Grant catalogues: `adl.exception-catalog/v1`, validated strictly.
+
+A grant is a signed, owned, expiring allowance over a REAL violation, and it
+must shrink. That is the whole difference from scope, which says the rule never
+applied — nothing to sign, nothing to shrink. Because a grant is a signature,
+every field that makes it one is mandatory here: an entry without an owner or a
+reason is not a decision anybody made, and the loader refuses it rather than
+counting it.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+from typing import Annotated
+
+import yaml
+from pydantic import Field, ValidationError
+
+from ..core.constants import Constants
+from ..core.errors import CouldNotRun
+from ..core.finding import Severity
+from ..core.models import OpenModel, StrictModel
+
+
+class GrantSource(OpenModel):
+    """Where the granted findings actually are. Shapes vary by gate, so the
+    fields this package reads are declared and the rest are left alone."""
+
+    finding: str | None = None
+    path_prefix: str | None = None
+    catalog: str | None = None
+    exclude_glob: str | None = None
+    """The path this entry signs for. Declared rather than left to `OpenModel`'s
+    extras, because it is now the ONLY thing a grant grants: the verdict matches
+    a finding's path against it. Every real catalogue in this estate already
+    writes it."""
+
+
+class GrantEntry(StrictModel):
+    """One signed allowance."""
+
+    id: Annotated[str, Field(min_length=1)]
+    severity: Annotated[Severity, Field(strict=False)]
+    owner: Annotated[str, Field(min_length=1)]
+    """Who signed it. An unowned grant is an unattributed decision."""
+
+    reason: Annotated[str, Field(min_length=1)]
+    """Why. Recorded so the next reader can judge whether it still holds."""
+
+    created: Annotated[date, Field(strict=False)]
+    expires: Annotated[date, Field(strict=False)]
+    """Grants expire. One that cannot expire has stopped being a decision.
+
+    `strict=False`, matching `severity` above: YAML naturally quotes an
+    ISO-8601 date as a string (`created: '2026-08-24'`), and `StrictModel`'s
+    `strict=True` default refuses to coerce it — every dated entry in every
+    real signed catalogue in this estate failed `load_catalogue` for this
+    reason alone, catalogue path aside. Representation, not the coercion
+    strict mode exists to forbid (see `status`'s own comment in
+    `docs-okf-profiles.yaml` for the same rule stated once already)."""
+
+    category: str | None = None
+    finding_count: int = 0
+    note: str | None = None
+    """Freeform follow-up the signer left for the next reader — e.g. a
+    related metric this exception deliberately does NOT cover, and why. Real,
+    signed content (`TS-002`'s bundle-size catalogue carries one), not
+    something to strip to fit the schema."""
+    source: GrantSource | None = None
+
+    def expired_on(self, today: date) -> bool:
+        return self.expires < today
+
+
+class GrantsCatalogue(StrictModel):
+    schema_: Annotated[str, Field(alias="schema")]
+    catalog: str
+    entries: Annotated[tuple[GrantEntry, ...], Field(strict=False)]
+    source_count: int | None = None
+    reconciliation: str | None = None
+
+    @property
+    def granted(self) -> tuple[str, ...]:
+        """The paths this catalogue signs for, in declared order.
+
+        Was `sum(entry.finding_count)`. A count forgave any N findings — a
+        catalogue naming three files forgave three findings anywhere, including
+        at paths nobody signed. It also double-counted across rows sharing one
+        catalogue (TS-019/TS-020: 71 signed, 142 forgiven). Neither is possible
+        against a path set.
+        """
+        return tuple(
+            entry.source.exclude_glob
+            for entry in self.entries
+            if entry.source is not None and entry.source.exclude_glob
+        )
+
+
+def load_catalogue(path: Path) -> GrantsCatalogue:
+    if not path.is_file():
+        raise CouldNotRun(f"grants catalogue is missing: {path}")
+    try:
+        document = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except yaml.YAMLError as exc:
+        raise CouldNotRun(f"grants catalogue is not valid YAML: {path}: {exc}") from exc
+    try:
+        return GrantsCatalogue.model_validate(document)
+    except ValidationError as exc:
+        raise CouldNotRun(
+            f"grants catalogue {path} violates {Constants.GRANTS_SCHEMA}:\n{exc}"
+        ) from exc
+
+
+def granted(grants: int | str, root: Path) -> tuple[str, ...]:
+    """WHICH paths a row has signed for.
+
+    An inline integer grants nothing: all 85 such rows carry `0`, and a bare
+    number can no longer mean "forgive this many", because which finding it
+    would forgive was never stated. A catalogue path yields its entries'
+    `source.exclude_glob` values.
+
+    A catalogue that cannot be read is still a could-not-run, never an empty
+    set — empty would silently turn every granted violation back into a failure
+    and invite someone to "fix" the gate by deleting its catalogue.
+    """
+    if isinstance(grants, int):
+        return ()
+    return load_catalogue(root / grants).granted

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/policy/registry.py

@@ -0,0 +1,281 @@
+"""`policy/gate-registry.yaml`, loaded once, validated strictly, as objects.
+
+The YAML is carried over one-to-one and so is its contract: every attribute,
+pattern and cross-field rule in `policy/gate-registry.schema.yaml` is expressed
+below, with the schema's own rule id (ROW-09) quoted in the error message so a
+failure points back at the clause it broke.
+
+That schema file used to be executed by a shell driver in a consumer tree
+(`.workflows/scripts/tests/gates/meta/test-profile-schema.sh`) — a package
+describing its own contract and depending on something outside itself to check
+it. Here the contract is enforced on load, by the thing that does the loading,
+and a registry that violates it cannot be read at all.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from functools import cache
+from importlib import resources
+from typing import Annotated, Self
+
+import yaml
+from pydantic import Field, ValidationError, ValidationInfo, field_validator, model_validator
+
+from ..core.constants import Constants
+from ..core.finding import Severity
+from ..core.models import StrictModel
+from ..core.errors import CouldNotRun
+from .config import PLACEHOLDER, TreeMapError, expand
+from collections.abc import Mapping
+
+from .config import load as load_tree_map
+
+
+def effective_trees(override: Mapping[str, str] | None) -> dict[str, str]:
+    """Packaged defaults with a caller's declared trees over them, per key.
+
+    The one place this precedence is expressed. Scope patterns resolved through
+    `_tree_mapping` and check `inputs` resolved in `runner.resolve_inputs` must
+    agree on what `<workflows>` means; when inputs had their own path to the
+    packaged default they did not, and 29 checks probed paths their repository
+    had explicitly redeclared.
+    """
+    return {**load_tree_map().trees, **(override or {})}
+
+
+def _tree_mapping(info: ValidationInfo) -> dict[str, str] | None:
+    """The packaged `config.toml` trees, with a caller-supplied `context={"trees":
+    {...}}` override winning per key — a key absent from the override still
+    falls back to the packaged default rather than the override replacing the
+    whole map. `None` when no override was passed, so `expand()` uses its own
+    packaged-only default unchanged (byte-identical to before this existed)."""
+    context = info.context or {}
+    override = context.get("trees")
+    if not override:
+        return None
+    return effective_trees(override)
+
+
+class RegistryError(Exception):
+    """The registry could not be read, or violates its schema. Never a finding."""
+
+
+class EngineSpec(StrictModel):
+    """How the gate runs. Every row has one."""
+
+    scope: Annotated[tuple[str, ...], Field(min_length=1, strict=False)]
+    """Ordered list, last match wins, '!' excludes. Not a grant: it carries no
+    signature and there is nothing to shrink.
+
+    Stored EXPANDED: `<rust>/crates/**` is `backend/crates/**` by the time
+    anything reads this. Nothing downstream knows placeholders exist, which is
+    the point — one mechanism resolves the consumer's layout, at load, and the
+    matcher sees ordinary repository-relative globs."""
+
+    rule: str | None = None
+    """One ast-grep rule id, or absent. A row without one is dispatched to a
+    Python check by id (`checks/__init__.py`'s CHECKS tuple) rather than
+    through `core/ast_grep.py` — the two are not alternative spellings of the
+    same thing, and nothing here requires a row to carry either."""
+
+    suppression: str | None = None
+    """The biome lint rule this ast-grep rule is EQUIVALENT to, for owned-
+    suppression honouring (`core/ast_grep.py`'s `AstGrepCheck`).
+
+    A written justification is a decision, not a note to self — a
+    `// biome-ignore <rule>: <reason>` comment with a non-empty `<reason>` is
+    honoured; a bare marker with no reason is not (owner ruling: "If it's
+    legitimate, own it" / "No exception"). Absent here, a row honours no
+    suppression at all: the equivalence is not guessable from the ast-grep
+    rule id alone (`ast-032-no-eval` says nothing about which biome rule, if
+    any, covers the same ground), so an unset field means exactly that — no
+    equivalence declared, nothing to honour — never a silent default guess."""
+
+    # Scope is stored RAW, placeholders intact, and expanded per row at run
+    # time by `runner.run`.
+    #
+    # It used to expand HERE, inside pydantic validation of the whole document.
+    # That made an unresolvable tree a document-level error: with the packaged
+    # defaults removed, one undeclared tree produced 82 validation errors and
+    # NOTHING loaded -- not a single gate ran, for every consumer. The package
+    # cannot ship no defaults while a missing one takes the registry down.
+    #
+    # Expanding at run time makes an undeclared tree could-not-run for the ONE
+    # row that names it, which is the honest verdict and leaves the rest of the
+    # registry working.
+
+    @model_validator(mode="after")
+    def _scope_is_never_absolute(self) -> Self:
+        # ROW-09. An absolute pattern cannot match a repository-relative path,
+        # so it is a positive glob matching nothing — which excludes everything.
+        for pattern in self.scope:
+            if pattern.startswith(("/", "!/")):
+                raise ValueError(f"ROW-09: scope pattern must not be absolute: {pattern}")
+        return self
+
+
+class Row(StrictModel):
+    """One registered gate.
+
+    Three identities, and only one of them is the id — the distinction that cost
+    this estate two gates whose grant catalogues were silently never read:
+
+      id            RST-001             everything inside the package
+      domain+name   rust.acp-boundary   the CLI address
+    """
+
+    id: Annotated[str, Field(pattern=Constants.ID_PATTERN)]
+    name: Annotated[str, Field(pattern=Constants.SLUG_PATTERN)]
+    domain: Annotated[str, Field(pattern=Constants.SLUG_PATTERN)]
+    title: Annotated[str, Field(max_length=Constants.TITLE_LIMIT)]
+    # The wire spells it 'M'; the member VALUE is 'M'. Enum-by-value is a
+    # representation, not the coercion strict mode exists to forbid.
+    severity: Annotated[Severity, Field(strict=False)]
+    controls: Annotated[tuple[str, ...], Field(min_length=1, strict=False)]
+    engine: EngineSpec
+    grants: int | str
+    """Either an inline count (109 rows) or a repository-relative catalogue path
+    (12 rows). Carried as the YAML writes it; `grants.granted` resolves it to a
+    number, because turning a path into a count is I/O and this is not.
+
+    A path resolves `<tree>` placeholders like any other, so a catalogue is
+    named logically too and no consumer path is written here (K-42)."""
+
+    timeout_ms: int
+
+    @field_validator("grants", mode="after")
+    @classmethod
+    def _resolve_trees(cls, value: int | str, info: ValidationInfo) -> int | str:
+        if isinstance(value, int):
+            return value
+        # Raw, like scope: resolved by `runner.run` when the row is graded.
+        return value
+
+    def resolved_scope(self, trees: Mapping[str, str] | None = None) -> tuple[str, ...]:
+        """`engine.scope` with its `<tree>` placeholders resolved.
+
+        Scope is stored RAW so that an undeclared tree is one row's
+        could-not-run rather than a registry that will not parse. Every caller
+        that needs real patterns -- the runner, and any test intersecting a
+        file set -- resolves here, so there is one place that knows how, and a
+        raw pattern can never be matched against a real path by accident.
+        """
+        return tuple(expand(pattern, trees) for pattern in self.engine.scope)
+
+    def resolved_grants(
+        self,
+        trees: Mapping[str, str] | None = None,
+        declared_trees: Mapping[str, str] | None = None,
+    ) -> int | str:
+        """`grants` with its `<tree>` placeholder resolved. An inline integer
+        passes through untouched -- 85 rows carry `0` and name no path.
+
+        Unlike `resolved_scope`, this honours `declared_trees`: a grants
+        catalogue is a RATCHET, the repository's own record of signed-for debt,
+        and it SUPPRESSES findings. Reading one from a packaged default the
+        owner never declared is the grants-side twin of the input hole that let
+        TS-001 report PASS over zero files -- and it fails in the more dangerous
+        direction. `None` means "not opted in" and keeps the old behaviour; a
+        mapping (including `{}`) enforces the rule.
+        """
+        if isinstance(self.grants, int):
+            return self.grants
+        if declared_trees is not None:
+            for match in PLACEHOLDER.finditer(self.grants):
+                tree = match.group(1)
+                if tree not in declared_trees:
+                    raise CouldNotRun(
+                        f"{self.id} signs its grants against `{self.grants}`; declare "
+                        f"[controls.compliance.trees].{tree} in adl-config.toml — "
+                        "a forgiveness list read from an undeclared location is "
+                        "could-not-run, never a clean pass"
+                    )
+        return expand(self.grants, trees)
+
+    @property
+    def address(self) -> str:
+        return f"{self.domain}.{self.name}"
+
+
+class Registry(StrictModel):
+    """The whole document, with the constraints that span rows.
+
+    Uniqueness is a property of the SET, so it cannot live on `Row` — and in the
+    shell tree it lived nowhere at all. `id`, `engine.rule` and the
+    `<domain>.<name>` address are each unique, and the schema file says so for
+    the first two while noting the third was "not expressible" there.
+    """
+
+    schema_: Annotated[str, Field(alias="schema")]
+    rows: Annotated[tuple[Row, ...], Field(min_length=1, strict=False)]
+
+    def __iter__(self) -> Iterator[Row]:  # type: ignore[override]
+        return iter(self.rows)
+
+    @model_validator(mode="after")
+    def _schema_is_recognised(self) -> Self:
+        if self.schema_ != Constants.REGISTRY_SCHEMA:
+            raise ValueError(
+                f"unrecognised registry schema: {self.schema_!r}, "
+                f"expected {Constants.REGISTRY_SCHEMA!r}"
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _identities_are_unique(self) -> Self:
+        for label, values in (
+            ("id", [row.id for row in self.rows]),
+            ("address", [row.address for row in self.rows]),
+            ("engine.rule", [r.engine.rule for r in self.rows if r.engine.rule]),
+        ):
+            duplicates = sorted({v for v in values if values.count(v) > 1})
+            if duplicates:
+                raise ValueError(f"{label} must be unique; repeated: {', '.join(duplicates)}")
+        return self
+
+    def by_id(self, gate_id: str) -> Row:
+        for row in self.rows:
+            if row.id == gate_id:
+                return row
+        raise RegistryError(f"no row has id {gate_id!r}")
+
+    def by_address(self, address: str) -> Row:
+        for row in self.rows:
+            if row.address == address:
+                return row
+        raise RegistryError(f"no row is addressed {address!r}")
+
+    def resolve(self, target: str) -> Row:
+        """An id or an address, resolved at the edge — once, here.
+
+        The shell tree resolved this in four places and each tolerated a
+        different spelling, which is how a caller kept passing a retired address
+        long after the row's id had changed.
+        """
+        if re.match(Constants.ID_PATTERN, target):
+            return self.by_id(target)
+        for row in self.rows:
+            if row.address == target:
+                return row
+        raise RegistryError(
+            f"{target!r} is neither a gate id nor a <domain>.<name> address"
+        )
+
+
+def policy_text(filename: str) -> str:
+    """Package data, resolved by the interpreter. No path is ever written down."""
+    return (resources.files(__package__) / filename).read_text(encoding="utf-8")
+
+
+@cache
+def load(filename: str = "gate-registry.yaml") -> Registry:
+    try:
+        document = yaml.safe_load(policy_text(filename))
+    except yaml.YAMLError as exc:
+        raise RegistryError(f"{filename} is not valid YAML: {exc}") from exc
+    try:
+        return Registry.model_validate(document)
+    except ValidationError as exc:
+        raise RegistryError(f"{filename} violates its schema:\n{exc}") from exc