@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.12 → 0.1.28

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/directory_ratchet/test_check.py

@@ -1,18 +1,41 @@
 """LAY-004 — ported from `compliance_new/checks/layout/directory-ratchet/test.sh`.
 
-Three committed corpora, same names and shapes as the shell fixtures:
-`directory-ratchet-clean` (one baselined single-file directory, nothing else),
-`directory-ratchet-unbaselined` (an unbaselined single-file directory, plus a
-control: eleven single-file subdirectories of a parent that itself holds zero
-direct files), and `directory-ratchet-excluded` (the row's own `!` exclusions
-under test, run twice against the same files through two Row variants that
-differ by exactly those two patterns).
+Eight committed corpora, the first six same names and shapes as the shell
+fixtures with their registers reworked to the 2026-10-02 generic-ratchet
+principle (v3 for this gate): `directory-ratchet-clean` (one baselined
+single-file directory, nothing else), `directory-ratchet-unbaselined` (an
+unbaselined single-file directory, plus a control: eleven single-file
+subdirectories of a parent that itself holds zero direct files),
+`directory-ratchet-excluded` (the row's own `!` exclusions under test, run
+twice against the same files through two Row variants that differ by exactly
+those two patterns), `directory-ratchet-missing-tree` (a ceiling-configured
+tree with no directory — advisory, not failure),
+`directory-ratchet-stale-entry` (DIR-003's kept reach: a baseline entry under
+a live tree whose directory was deleted), `directory-ratchet-unusable-register`
+(a register that exists but is not valid YAML — could-not-run, the kept
+exception in every ruling shape), and two added for the generic principle:
+`directory-ratchet-no-ceilings` (three files in one directory against a
+register that would exempt them — with NO ceilings declared the gate has
+nothing to enforce and the register is never read, so it stays clean), and
+`directory-ratchet-empty-register` (a register recording ZERO state — a load
+failure, because zero state is no file).
+
+V3 (owner ruling 2026-10-02, superseding this gate's earlier "ratchets sit
+ON TOP" ruling; the same principle DOC-012 v2 shipped): the per-tree
+CEILINGS are CONFIGURATION and live in `[controls.compliance.directory-
+ratchet].max_children`, reaching the engine as the `directory-ceilings`
+declaration. The register records STATE only — over-limit and single-file
+baselines. An absent register records no state, so the ceilings are enforced
+bare (strict — the widening input's normal contract). Two v1 tests were
+reworked and say so in their docstrings. At zero recorded state the file is
+deleted; a file that EXISTS recording zero state is a load failure.
 
 Each fixture carries its own `grants.yaml` at its own root, passed as the
 `register` input override — the same mechanism `DOC-006`'s test uses for its
 packaged profile register, not a path nested to match `policy/config.toml`'s
 tree mapping, which is exactly the coupling that broke this port once already
-(P-14).
+(P-14). The ceilings travel as the `directory-ceilings` declaration, the same
+channel DOC-012's tests use for `docs-pages-per-directory`.
 """
 
 from __future__ import annotations
@@ -38,24 +61,102 @@ def corpus_files(root: pathlib.Path) -> tuple[str, ...]:
     )
 
 
-def run(case: str, *, scope: tuple[str, ...] | None = None) -> object:
+def run(
+    case: str, *, scope: tuple[str, ...] | None = None, ceilings: str | None = None
+) -> object:
     directory = FIXTURES / case
     row = ROW
     if scope is not None:
         row = row.model_copy(update={"engine": row.engine.model_copy(update={"scope": scope})})
+    declarations = {} if ceilings is None else {DirectoryRatchet.CEILINGS_DECLARATION: ceilings}
     return runner.run(
         row, directory, corpus_files(directory),
         inputs={row.id: {"register": directory / "grants.yaml"}},
+        declarations=declarations,
     )
 
 
+# ------------------------------------------------------- the ceilings channel
+
+
 def test_a_fully_baselined_tree_passes() -> None:
-    verdict = run("directory-ratchet-clean")
+    verdict = run("directory-ratchet-clean", ceilings="frontend/packages/desktop/src:10")
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert not verdict.findings
+    assert not verdict.advisories
+
+
+def test_no_ceilings_configured_means_nothing_to_enforce() -> None:
+    """The generic principle's config half: no `[controls.compliance.directory-
+    ratchet]` table, no ceilings declared — the gate has NOTHING to enforce
+    and passes clean even with a three-file directory on disk whose register
+    would exempt it (proving the register is not even read: its entry could
+    only ever REMOVE findings)."""
+    verdict = run("directory-ratchet-no-ceilings")
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert not verdict.findings
+    assert not verdict.advisories
+
+
+def test_a_baseline_entry_exempts_its_directory_up_to_the_recorded_count() -> None:
+    """The state half: the same three-file directory, now under a declared
+    ceiling of 2, is CLEAN because the register records its count of 3 — an
+    entry forgives the directory up to the count recorded (growing past it
+    is DIR-002, reported separately)."""
+    verdict = run(
+        "directory-ratchet-no-ceilings", ceilings="frontend/packages/desktop/src:2"
+    )
     assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert not verdict.findings
+
+
+def test_an_over_ceiling_directory_with_no_register_is_dir_001() -> None:
+    """The same three-file corpus one more time, register pointed at a path
+    that does not exist: no recorded state means no exemptions allowed, so
+    the ceiling of 2 is enforced bare — DIR-001 names the directory."""
+    directory = FIXTURES / "directory-ratchet-no-ceilings"
+    verdict = runner.run(
+        ROW, directory, corpus_files(directory),
+        inputs={ROW.id: {"register": directory / "does-not-exist.yaml"}},
+        declarations={DirectoryRatchet.CEILINGS_DECLARATION: "frontend/packages/desktop/src:2"},
+    )
+    assert verdict.outcome is Outcome.FINDINGS
+    findings = [f for f in verdict.findings if f.rule == "DIR-001"]
+    assert len(findings) == 1, tuple(f.render() for f in verdict.findings)
+    assert findings[0].path == "frontend/packages/desktop/src"
+    assert findings[0].message == "3 direct children (max 2), no ratchet entry"
+
+
+def test_a_malformed_ceilings_declaration_is_could_not_run() -> None:
+    for bad in ("frontend/packages/desktop/src:banana", "frontend/packages/desktop/src:0"):
+        verdict = run("directory-ratchet-clean", ceilings=bad)
+        assert verdict.outcome is Outcome.COULD_NOT_RUN, bad
+        assert "directory-ratchet" in verdict.message
+        assert "frontend/packages/desktop/src" in verdict.message
+    # An entry with no ceiling half at all:
+    verdict = run("directory-ratchet-clean", ceilings="frontend/packages/desktop/src")
+    assert verdict.outcome is Outcome.COULD_NOT_RUN
+    assert "directory-ratchet" in verdict.message
+
+
+def test_a_register_recording_zero_state_is_a_load_failure() -> None:
+    """The ruling's deletion half, enforced loudly: a register file that
+    EXISTS but records no state (no over-limit baseline, no single-file
+    baseline, no docs_pages section) is the shape the owner deletes — read
+    as a load failure, never as a silent empty pass."""
+    verdict = run(
+        "directory-ratchet-empty-register",
+        ceilings="frontend/packages/desktop/src:2",
+    )
+    assert verdict.outcome is Outcome.COULD_NOT_RUN
+    assert "a register grading nothing" in verdict.message
+
+
+# ------------------------------------------------------- the original corpus
 
 
 def test_an_unbaselined_single_file_directory_is_reported() -> None:
-    verdict = run("directory-ratchet-unbaselined")
+    verdict = run("directory-ratchet-unbaselined", ceilings="frontend/packages/desktop/src:10")
     assert verdict.outcome is Outcome.FINDINGS
     paths = {f.path for f in verdict.findings if f.rule == "DIR-001"}
     assert "frontend/packages/desktop/src/renderer/fresh" in paths
@@ -66,14 +167,14 @@ def test_a_subdirectory_alone_never_trips_the_rule() -> None:
     """`many` holds eleven subdirectories and zero direct files of its own, so it
     needs no baseline entry; each subdirectory holds exactly one file and IS
     reported. Both halves matter, or this corpus is silent by accident."""
-    verdict = run("directory-ratchet-unbaselined")
+    verdict = run("directory-ratchet-unbaselined", ceilings="frontend/packages/desktop/src:10")
     paths = {f.path for f in verdict.findings if f.rule == "DIR-001"}
     assert "frontend/packages/desktop/src/renderer/many" not in paths
     assert "frontend/packages/desktop/src/renderer/many/sub1" in paths
 
 
 def test_the_row_exclusions_silence_locales_and_vendored_cargo() -> None:
-    verdict = run("directory-ratchet-excluded")
+    verdict = run("directory-ratchet-excluded", ceilings="frontend/packages/desktop/src:20")
     assert verdict.outcome is Outcome.FINDINGS
     paths = {f.path for f in verdict.findings}
     assert not any("locales" in p for p in paths)
@@ -93,7 +194,7 @@ def test_falsifiability_without_the_row_exclusions() -> None:
     )
     assert len(unscoped) == len(ROW.engine.scope) - 2
 
-    verdict = run("directory-ratchet-excluded", scope=unscoped)
+    verdict = run("directory-ratchet-excluded", scope=unscoped, ceilings="frontend/packages/desktop/src:20")
     assert verdict.outcome is Outcome.FINDINGS
     paths = {f.path for f in verdict.findings if f.rule == "DIR-001"}
     assert any("locales" in p for p in paths)
@@ -104,30 +205,86 @@ def test_the_ratchet_register_is_not_a_grant_catalogue() -> None:
     """`structural_grant = True` forces the allowance to 0 regardless of the
     row's own `grants:` field. Passing the register's size as the allowance is
     the trap: a failing gate would report green."""
-    verdict = run("directory-ratchet-unbaselined")
+    verdict = run("directory-ratchet-unbaselined", ceilings="frontend/packages/desktop/src:10")
     assert verdict.granted == 0
     assert verdict.outcome is Outcome.FINDINGS
 
 
-def test_an_absent_register_is_could_not_run_not_a_clean_pass() -> None:
-    """The baseline is the REPOSITORY's, so a repository without one has nothing
-    graded — and nothing graded is could-not-run.
-
-    This gate shipped its register as package data: one donor repository's whole
-    directory shape, 88 of 104 lines naming `backend/crates/enact-*`,
-    `frontend/packages/desktop/*` and `infra/stacks/*`. No repository in this
-    estate has any of those trees, so every one of them hit
-    `registered tree directory is missing: backend/crates` on the first entry —
-    a gate reporting another repo's layout as this repo's defect.
-    """
+def test_an_absent_register_enforces_the_ceilings_bare() -> None:
+    """REWORKED from v1's `test_an_absent_register_means_nothing_is_ratcheted`,
+    which asserted the opposite under the superseded "ratchets sit ON TOP"
+    ruling. Generic principle (2026-10-02): the register records STATE only,
+    so an absent register records no exemptions and the configured ceilings
+    are enforced bare — every single-file directory the clean corpus holds
+    reports DIR-001 (the corpus's `solo` is exempted only by its recorded
+    entry, which is gone)."""
     directory = FIXTURES / "directory-ratchet-clean"
     verdict = runner.run(
         ROW, directory, corpus_files(directory),
         inputs={ROW.id: {"register": directory / "does-not-exist.yaml"}},
+        declarations={DirectoryRatchet.CEILINGS_DECLARATION: "frontend/packages/desktop/src:10"},
+    )
+    assert verdict.outcome is Outcome.FINDINGS
+    findings = [f for f in verdict.findings if f.rule == "DIR-001"]
+    assert {f.path for f in findings} == {
+        "frontend/packages/desktop/src/renderer/solo",
+    }
+
+
+def test_an_absent_register_with_an_empty_scope_is_still_the_runners_dead_scope() -> None:
+    """The C1 guard is untouched: on an exhaustive run whose scope selects
+    nothing, the runner's dead-scope could-not-run stands. The widening-input
+    change only says the CHECK must not add its own register complaint on top
+    of that — and it cannot even run here."""
+    directory = FIXTURES / "directory-ratchet-clean"
+    verdict = runner.run(
+        ROW, directory, (),
+        exhaustive=True,
+        inputs={ROW.id: {"register": directory / "does-not-exist.yaml"}},
+        declarations={DirectoryRatchet.CEILINGS_DECLARATION: "frontend/packages/desktop/src:10"},
+    )
+    assert verdict.outcome is Outcome.COULD_NOT_RUN
+    assert "matches no file on disk" in verdict.message
+    assert "register" not in verdict.message
+
+
+def test_a_register_that_exists_but_is_unusable_is_could_not_run() -> None:
+    """The kept exception through every ruling shape: absent is bare
+    enforcement, UNUSABLE is not. A register that exists but cannot be parsed
+    may be mid-edit; grading it as "no baselines" would silently drop every
+    exemption it names."""
+    verdict = run("directory-ratchet-unusable-register", ceilings="frontend/packages/desktop/src:10")
+    assert verdict.outcome is Outcome.COULD_NOT_RUN
+    assert "unusable" in verdict.message
+
+
+def test_a_configured_tree_that_is_gone_is_an_advisory_not_a_failure() -> None:
+    """Generic principle, the cleanup half: a tree the CONFIGURATION names
+    but the repository no longer has is cleanup, not a defect. One advisory
+    names what is unaccounted; the remaining trees are graded normally."""
+    verdict = run(
+        "directory-ratchet-missing-tree",
+        ceilings="frontend/packages/desktop/src:10,infra:10",
     )
-    assert verdict.outcome is Outcome.COULD_NOT_RUN, verdict.render()
-    assert "no directory-ratchet register" in verdict.message
-    assert "never a clean pass" in verdict.message
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+    assert not verdict.findings
+    assert len(verdict.advisories) == 1
+    advisory = verdict.advisories[0]
+    assert advisory.path == "infra"
+    assert "no longer accounted" in advisory.message
+    assert "remove its register entries or restore the tree" in advisory.message
+
+
+def test_a_baseline_entry_for_a_deleted_directory_is_still_reported_stale() -> None:
+    """The narrowing of WHO may report absence, not the register's own
+    hygiene: an entry under a tree that STILL exists, naming a directory the
+    repository deleted, is DIR-003 exactly as before. Cleanup of the CONTENT
+    is free; cleanup of the REGISTER is the owner's edit, and the gate still
+    says so."""
+    verdict = run("directory-ratchet-stale-entry", ceilings="frontend/packages/desktop/src:10")
+    assert verdict.outcome is Outcome.FINDINGS
+    stale = {f.path for f in verdict.findings if f.rule == "DIR-003"}
+    assert "frontend/packages/desktop/src/renderer/gone" in stale
 
 
 def test_the_register_is_not_packaged_data() -> None:
@@ -136,3 +293,82 @@ def test_the_register_is_not_packaged_data() -> None:
     assert "register" in DirectoryRatchet.inputs
     assert "register" not in DirectoryRatchet.resources
     assert DirectoryRatchet.inputs["register"].startswith("<")
+
+
+# --------------------------------------------------------- the shared schema
+# The register model dropped `max_children` in the same change (v3): ceilings
+# are configuration now, and a register recording zero state is a load
+# failure. These pin the schema change itself.
+
+
+def test_a_baselines_only_register_is_valid() -> None:
+    """The register's whole job after the rework: recorded state. Over-limit
+    and single-file baselines, no `docs_pages` section — LAY-004's reader."""
+    from adl_compliance.checks.layout.directory_ratchet.register import Ratchet
+
+    ratchet = Ratchet.model_validate(
+        {
+            "schema_version": 2,
+            "over_children_baseline": {"frontend/packages/desktop/src/renderer": 12},
+            "single_file_baseline": {
+                "frontend/packages/desktop/src/renderer/solo": "item.ts"
+            },
+        }
+    )
+    assert ratchet.docs_pages is None
+
+
+def test_a_register_carrying_max_children_is_refused() -> None:
+    """`max_children` was configuration; configuration moved to adl-config.toml
+    in the same change, so the key it lived in is `extra="forbid"`-refused —
+    a stale register fails loud instead of being silently read as state."""
+    import pytest
+    from pydantic import ValidationError
+
+    from adl_compliance.checks.layout.directory_ratchet.register import Ratchet
+
+    with pytest.raises(ValidationError, match="max_children"):
+        Ratchet.model_validate(
+            {
+                "schema_version": 2,
+                "max_children": {"frontend/packages/desktop/src": 10},
+                "over_children_baseline": {},
+                "single_file_baseline": {},
+            }
+        )
+
+
+def test_a_docs_pages_only_register_is_valid() -> None:
+    """DOC-012's exemption-only shape is untouched by this rework: a register
+    holding only `docs_pages.baseline` parses clean."""
+    from adl_compliance.checks.layout.directory_ratchet.register import DocsPages, Ratchet
+
+    ratchet = Ratchet.model_validate(
+        {"schema_version": 2, "docs_pages": {"baseline": {"docs/operations": 10}}}
+    )
+    assert ratchet.over_children_baseline == {}
+    assert ratchet.docs_pages == DocsPages(baseline={"docs/operations": 10})
+
+
+def test_an_all_empty_register_is_a_load_failure() -> None:
+    """Zero recorded state is no file — an existing file that records nothing
+    is either the wrong file or an emptied register mid-cleanup, and reading
+    it as "no baselines" would silently drop every exemption it used to
+    name. The cross-field validator keeps the v1 `min_length=1` intent in
+    the new shape: at least one of over/single/docs_pages.baseline."""
+    import pytest
+    from pydantic import ValidationError
+
+    from adl_compliance.checks.layout.directory_ratchet.register import Ratchet
+
+    with pytest.raises(ValidationError, match="a register grading nothing"):
+        Ratchet.model_validate({"schema_version": 2})
+    with pytest.raises(ValidationError, match="a register grading nothing"):
+        Ratchet.model_validate(
+            {
+                "schema_version": 2,
+                "over_children_baseline": {},
+                "single_file_baseline": {},
+                "docs_pages": {"baseline": {}},
+            }
+        )

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/markdown_trees/check.py

@@ -9,6 +9,12 @@ The allowed roots are RESOLVED, not listed: `<docs>`, `<plans>`, `<compliance>`,
 graded against its own spelling. The only literals left are `*/LEDGER.md` (a
 register beside the tree it records) and the exclusion list below.
 
+A repository can add further Markdown roots of its own under
+`[controls.compliance.markdown] roots` (the `markdown-roots` declaration): a
+directory whose Markdown is site or application content rather than
+documentation. A declared root only ever WIDENS the allowlist, so declaring
+nothing is the stricter grade.
+
 This docstring used to read "docs/, .plans/, .specs/, or .changeset/" and three
 of those four were wrong. `.specs` was deleted 2026-09-16 as a path that matched
 nothing in this estate and never could; `.plans` became the resolvable `<plans>`
@@ -40,12 +46,20 @@ trees; anything in neither list is reported.
 from __future__ import annotations
 
 import fnmatch
+import glob
 from collections.abc import Iterable
 from typing import ClassVar
 
-from ....policy.root_shape import GOVERNANCE, GUIDES, REGISTERS
+from ....policy.root_shape import (
+    GOVERNANCE,
+    GUIDES,
+    REGISTERS,
+    ROOT_FILES_DECLARATION,
+    declared_root_names,
+)
 from ....core.check import Check
 from ....core.context import Context, FileSet
+from ....core.errors import CouldNotRun
 from ....core.finding import Report
 
 
@@ -85,6 +99,9 @@ class MarkdownTrees(Check):
         # of "what may sit at a repository's root". This gate asked the same question
         # and was not brought in, so it flagged CONTRIBUTING.md and MAINTAINERS.md --
         # exactly the files d841de1 ruled belong at the root, where a newcomer looks.
+        # Only the STANDARD ones: a repository's own root Markdown (a STATUS.md, a
+        # DRIFT.md) is declared under `[controls.compliance.root] files` and added by
+        # `_excluded`.
         *sorted(GOVERNANCE | GUIDES | REGISTERS),
         "AGENTS.md", "CLAUDE.md", "CHANGELOG.md", "RELEASE.md",
         "INVARIANTS.md", "README.md", "CLAUDE-INVARIANTS.md",
@@ -176,8 +193,47 @@ class MarkdownTrees(Check):
     # `<specs>` only ever ADDS allowlist entries here. enact-m5 has no specs
     # tree; requiring one would push the owner to declare a directory that does
     # not exist, and a false declaration is undetectable. Absent -> stricter.
+    #
+    # This input is reachable only by a caller that builds a Context by hand (the
+    # unit tests do): `cli.py` routes global inputs to batch rows alone, so no
+    # `adl-config.toml` key ever reached `specs_root`. A repository's own extra
+    # Markdown roots arrive through the `markdown-roots` declaration below.
     widening_inputs: ClassVar[frozenset[str]] = frozenset({"specs_root"})
 
+    # `[controls.compliance.markdown].roots` -- directories a repository declares
+    # as homes for Markdown it authors outside every tree above, e.g. an Astro
+    # site's content-collection pages (`apps/marketing/src/content/**/*.md`),
+    # which are site content, not documentation and not movable into `docs/`
+    # without breaking the framework that loads them. Sent to the engine as one
+    # comma-separated `--declare markdown-roots=a,b`.
+    ROOTS_DECLARATION: ClassVar[str] = "markdown-roots"
+
+    def _declared_roots(self, ctx: Context) -> tuple[str, ...]:
+        """The repository-relative directories declared under `markdown-roots`.
+
+        Normalised (a trailing `/` is dropped) and VALIDATED. A declared root can
+        only WIDEN the allowlist, so a malformed one -- absolute, or carrying a
+        `.`, `..` or empty segment -- is could-not-run rather than a pattern
+        that admits more than the repository meant. `adl` rejects the same set
+        when it reads `adl-config.toml`; this is the engine refusing it too,
+        because the engine is also run directly with `--declare`. Whether the
+        directory exists is not asked: this check cannot walk, and a root that
+        matches no file widens nothing.
+        """
+        roots: list[str] = []
+        for name in sorted(declared_root_names(ctx.declarations, self.ROOTS_DECLARATION)):
+            root = name.rstrip("/")
+            if name.startswith("/") or any(part in ("", ".", "..") for part in root.split("/")):
+                raise CouldNotRun(
+                    f"{self.id}: `{self.ROOTS_DECLARATION}` declares {name!r}, which is not a "
+                    "repository-relative directory (it is absolute, or has a `.`, `..` or "
+                    "empty path segment); fix [controls.compliance.markdown].roots in "
+                    "adl-config.toml -- a malformed root could only widen the allowlist, "
+                    "so the gate does not grade against it"
+                )
+            roots.append(root)
+        return tuple(roots)
+
     def _allowed(self, ctx: Context) -> tuple[str, ...]:
         allowed = self.ALLOWED
         # Absent is the fixed list, never a crash. The runner always resolves a
@@ -198,6 +254,14 @@ class MarkdownTrees(Check):
         specs_root = ctx.inputs.get("specs_root")
         if specs_root is not None:
             allowed = (*allowed, f"{ctx.relative(specs_root)}/*.md")
+        # A declared root admits both suffixes this gate grades, like `docs_root`
+        # -- admitting `.md` and reporting `.mdx` beside it would look like half
+        # the declaration was ignored. Escaped: `_matches_any` is `fnmatchcase`, so
+        # a name carrying `*`, `?` or `[` must be literal or it admits more than
+        # it names. Absent declaration = nothing added = stricter.
+        for root in self._declared_roots(ctx):
+            escaped = glob.escape(root)
+            allowed = (*allowed, f"{escaped}/*.md", f"{escaped}/*.mdx")
         return allowed
 
     def _excluded(self, ctx: Context) -> tuple[str, ...]:
@@ -206,7 +270,16 @@ class MarkdownTrees(Check):
             root = ctx.inputs.get(input_name)
             if root is not None:
                 excluded = (*excluded, f"{ctx.relative(root)}/{suffix}")
-        return excluded
+        # Root Markdown the repository declared under `[controls.compliance.root]
+        # files` (the `root-files` declaration). Matched EXACTLY: `_matches_any`
+        # is `fnmatchcase`, so a declared name carrying `*`, `?` or `[` must be
+        # escaped or it would exclude more than it names. A root name has no `/`,
+        # so a nested file of the same name is not the declared one.
+        declared = sorted(
+            name for name in declared_root_names(ctx.declarations, ROOT_FILES_DECLARATION)
+            if "/" not in name and name.endswith(self.MARKDOWN_SUFFIXES)
+        )
+        return (*excluded, *(glob.escape(name) for name in declared))
 
     def graded(self, ctx: Context, files: FileSet) -> Iterable[Report]:
         allowed = self._allowed(ctx)