@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.34 → 0.1.37

package/packages/repo-controls/assets/scaffold/root/AGENTS.md

@@ -1,22 +1,71 @@
 # Agent entry point
 
-This is the first file a human or agent should read on arriving at this
-repository. Edit it to describe what this repository is; the sections below
-describe the layout the adl repo controls enforce.
+First file a human or agent reads here. Keep it short.
 
-## Layout
+## What this repository is
+- <!-- Owner: one or two lines on what this repo is and who uses it. -->
+
+## Layout (paths as declared in `[controls.compliance.trees]`)
 
 | Path | What lives there |
 | --- | --- |
 | `docs/` | reference documentation, see `docs/AGENTS.md` |
 | `plans/` | Features and the PBIs/Bugs under them, see `plans/AGENTS.md` |
 | `workflows/` | CI pipelines and build/release scripts, see `workflows/AGENTS.md` |
-| `.workflows/` | managed hook stubs and lock, rebuilt by `adl repo controls install`; never hand-edit |
-
-## Rules
+| `.workflows/` | managed hook stubs and lock; rebuilt by `adl repo controls install`, never hand-edit |
 
-- This repository is graded by `adl-compliance` on every commit; the enabled
-  gates are `[controls.compliance].enabled` in `adl-config.toml`. A failing
-  gate is fixed, not skipped.
-- `INVARIANTS.md` lists what this repository must never regress.
+## Where to look next
+- `CONTRIBUTING.md`: plans and work items, commits and PRs, release flow, tasks ledger.
+- `INVARIANTS.md`: what must never regress, how each is verified, protected paths.
+- Graded on every commit by `adl repo controls compliance run`; enabled gates are `[controls.compliance].enabled` in `adl-config.toml`. A failing gate is fixed, not skipped.
 - Work-item status lives on the board, never in a file.
+
+## Keep this guidance alive
+- **When:** you were corrected by the owner, a gate or test failed for a reason not written here, or you learned a rule the hard way.
+- **Where (one place only):**
+  - convention or workflow → `CONTRIBUTING.md`
+  - must-never-regress rule → `INVARIANTS.md`, only with its verifying gate/test/command; no check, no invariant
+  - orientation (what lives where) → `AGENTS.md`
+  - folder-specific → that folder's `AGENTS.md`
+  - applies to every repository → tell the owner; never edit global files
+- **How:** put the edit in the same commit/PR that taught you it; edit the existing bullet instead of adding a near-duplicate; one bullet, at most 2 lines.
+- **Never record:** secrets, ids/URLs of one-off items, session or progress state, unverified claims, rules a gate already enforces and explains in its own message.
+
+## Working defaults for code
+Tarun's global instructions cover communication, truthfulness, verification, scope and delegation. These are the coding defaults. Edit them for this repository, except "Truthfulness and verification in code", which a repository may add to but never relax.
+
+### Truthfulness and verification in code
+- No `|| true`, no swallowed errors, no skipped gates.
+- Negative claims need source-level proof: grep the implementation, not a tool listing. Search the whole package first, then narrow.
+- Before reporting what the repository contains, ask the remote (`git show origin/<branch>:<path>`); before reporting a shipped tool's behaviour, ask the installed binary.
+- Name the ref. Where a change is in flight, two branches answer differently and both are right about themselves; say which one you asked.
+- Deployed is not running: a long-lived server or daemon keeps the code it started with. When a fix is installed and behaviour has not changed, restart the process first.
+
+### Checkouts
+- Commit rules: `CONTRIBUTING.md`.
+- At most 3 checkouts per repository, including the main folder; git refuses the 4th and names the command to use. Reconcile old worktrees first (merge, then `git worktree remove <path>`).
+- Prefer the one checkout; parallel subagents share it, each with its own write scope. Only the orchestrator commits.
+
+### Tests
+- For features, bugfixes and non-trivial refactors: tests first, confirmed failing for the right reason; then minimal code to pass; then a separate review pass.
+- Every code change ships a new test. Exempt: pure config, docs, trivial one-liners.
+- A test changes only when the intended behaviour changes. Don't loosen, skip or delete an assertion, or set an expectation to whatever the code returns, to hide a failure. Red is honest.
+- When a change deliberately alters behaviour, rework the tests that assert the old behaviour in the same change; name each one and the decision that changed it.
+
+### Fixing things
+- Fix at the source — the primitive, token or shared layer — so it propagates everywhere, not a narrow downstream patch.
+- Consult official docs before coding against an unfamiliar SDK, framework or API.
+
+### Context tooling
+- Match the tool to the question (when installed; otherwise `rg`):
+  - Orient in unfamiliar code → `crg architecture`, `crg communities`.
+  - Symbols and semantic code queries → `crg search "<text>"`.
+  - Callers, callees, blast radius → `crg query callers_of|callees_of|tests_for|importers_of <target>`, `crg impact`.
+  - Unreferenced code → `crg dead-code`.
+  - A code shape rather than a string → `ast-grep`.
+  - Prose in documentation folders (`docs/`, `plans/`) → `search <text>` (hybrid semantic + keyword).
+  - Literal text or regex → `rg`. Never `grep`; never `find | grep`, which filters file names and misses the file whose contents match.
+  - Files by name or tree → the host's native file-listing tools.
+
+### Temporary files
+- Scratch and throwaway work goes in `.scratchpad/` at the repository root, never `/tmp` or `/private/tmp`. Create it if missing; it is gitignored. Real deliverables go to their proper home.

package/packages/repo-controls/assets/scaffold/root/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Contributing
+
+How to contribute to THIS repository. Orientation is in `AGENTS.md`; what must never regress, and the protected paths, are in `INVARIANTS.md`. Tree paths are those declared in `[controls.compliance.trees]`; `plans/` is the default.
+
+## Plans and work items
+- A plan is a Feature; a backlog item is a PBI or a Bug. One file each; the board is the only place their state lives.
+- Layout: `plans/features/az<feature id>-<slug>/` with `intent.md`, `requirements.md` (plan files `design.md`/`file-map-reference.md` optional), items under `items/az<id>-<slug>.md`.
+- The id is the identity: allocate the item on the board first, then name the file. Until then it is a row in the plan's `## Items` table.
+- Nothing moves between directories; the plan text is the work item's fields.
+- An item names its `feature:` as the Feature's full board URL; a gap found along the way is filed through `report-bug`, never a register file.
+
+## Commits and PRs
+- Each commit is independently green and on one topic. Never `git stash`. Green wins over one topic, and say so.
+- Subject: `<type>(<scope>): <lowercase subject>`; types `feat|fix|docs|refactor|perf|chore`; no `!`.
+- Branch: `<type>/<kebab>`, same types, not configurable.
+- `release:` is reserved for the promotion PR the pipeline raises; never write one by hand.
+- A PR body needs non-empty `## Summary`, `## Why` and `## Changes`; the title follows the subject grammar.
+
+## Release flow
+- `<type>/<kebab>` branch → PR → `integration` (auto-completes when green) → pipeline opens `integration → main` → owner approves. No agent opens that PR.
+- A repository that differs states it under "Release flow of this repository".
+
+## Tasks ledger
+- At the start and the end of a task, log with `adl activity add "<note>"` and read the log with `adl activity list`. The MCP tools `activity_add`/`activity_list` are the same storage; the CLI is the documented fallback.
+- The log is `.adl/agent-activity.sqlite` — gitignored, local only. One ledger per repository; the tool fills time, surface, agent and repo, and only the note is caller-supplied.
+
+## Release flow of this repository
+- <!-- Owner: state any difference from the flow above; delete this section if none. -->

package/packages/repo-controls/assets/scaffold/root/INVARIANTS.md

@@ -0,0 +1,17 @@
+# Invariants
+
+Must-never-regress rules. One bullet each: `rule` — verified by `gate/test/command`. No check, no invariant. Add yours under "This repository".
+
+## Estate-wide
+- The compliance gates enabled in `adl-config.toml` pass before every commit — verified by `adl repo controls` pre-commit and CI. A gate is switched off only by the owner, by removing it from `[controls.compliance] enabled`.
+- A compliance exemption list only shrinks: remove a file once it passes; never add one — verified by the gate that reads the register.
+- No multi-line comments in code; the explanation lives in `docs/` — verified by `repository.no-multiline-comments`.
+- The standard trees `docs`, `plans`, `workflows` and `compliance` are those declared in `[controls.compliance.trees]`, matching the layout in `AGENTS.md` — verified by the layout and docs gates.
+
+## Protected paths
+- Landed only by the owner; an agent leaves them uncommitted and asks — verified by the pre-commit integrity gate.
+- `adl-config.toml`, `compliance/` (or the compliance tree declared in `[controls.compliance.trees]`) and `workflows/`, plus any pattern this repository adds under `[controls.integrity].watched`.
+- No dot folder is protected as a whole: `.workflows/` and the agent surface folders hold the repository's own hooks and skills.
+
+## This repository
+- <!-- Owner: `rule` — verified by `gate/test/command`. -->

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/docs/closed_set/test_check.py

@@ -92,17 +92,6 @@ def test_declared_dirs_and_files_stay_silent() -> None:
         assert f"docs/{entry}: undeclared" not in text
 
 
-def test_the_task_ledger_is_declared() -> None:
-    """`docs/notes.md` is the repository's task ledger (global agent rule: one
-    line at the start and one at the finish of every task), so it is a
-    declared top-level file. The stray file next to it is still reported, which
-    proves the ledger is allowed by name and not because the gate went quiet."""
-    assert "docs/notes.md" in corpus_files(CORPUS)
-    messages = tuple(f.render() for f in findings_for(corpus_files(CORPUS)))
-    assert not any("docs/notes.md" in m for m in messages), messages
-    assert any("docs/stray-root-file.md" in m for m in messages), messages
-
-
 def test_an_empty_set_grades_nothing() -> None:
     """Every undeclared entry is still on disk. A check that grades only what
     it is handed must report none of them against an empty given set."""

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/docs/filename/test_check.py

@@ -45,7 +45,7 @@ VIOLATING = (
 )
 
 # In the corpus, never findings: exempt guide names (root and nested),
-# the standing catalog/ledger names, non-Markdown assets (including one
+# the standing catalog name, non-Markdown assets (including one
 # with a deliberately violating stem), and a path that merely lookalikes
 # the docs/ prefix.
 NOT_FINDINGS = (
@@ -54,7 +54,6 @@ NOT_FINDINGS = (
     "docs/CLAUDE.md",
     "docs/architecture/AGENTS.md",
     "docs/index.md",
-    "docs/notes.md",
     "docs/reference.html",
     "docs/assets/diagram.png",
     "docs/assets/UI-CONTRACT.png",
@@ -147,12 +146,11 @@ def test_guide_names_are_exempt_at_any_depth() -> None:
     assert "docs/architecture/AGENTS.md" not in text
 
 
-def test_the_standing_page_names_are_silent() -> None:
-    """`index.md` (the standing catalog name, also scope-excluded) and
-    `notes.md` (the task ledger) carry conforming stems; both stay silent."""
+def test_the_standing_catalog_name_is_silent() -> None:
+    """`index.md` (the standing catalog name, also scope-excluded) carries a
+    conforming stem and stays silent."""
     text = "\n".join(messages_for(corpus_files(CORPUS)))
     assert "docs/index.md" not in text
-    assert "docs/notes.md" not in text
 
 
 def test_non_markdown_files_are_not_graded() -> None:

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/docs/ledger/test_check.py

@@ -282,6 +282,21 @@ def test_a_ref_with_an_anchor_onto_a_real_path_passes(tmp_path: pathlib.Path) ->
     assert verdict.outcome is Outcome.CLEAN, verdict.render()
 
 
+# ---------------------------------------------------------------------- R9 (§4a)
+
+def test_a_dispatch_order_table_beside_the_event_table_is_not_graded(
+    tmp_path: pathlib.Path,
+) -> None:
+    """R9: the LEDGER holds the event table only. Order comes from Feature
+    predecessor links on the board, so a leftover `## Next` table -- any table
+    whose columns are not the event columns -- is not ledger content and must
+    not be graded, reported or required."""
+    body = table("| 2026-01-01 | an-entry | docs | something happened | — |")
+    body += "\n## Next\n\n| Order | Feature |\n| --- | --- |\n| 1 | az999-next |\n"
+    verdict = run_body(tmp_path, body)
+    assert verdict.outcome is Outcome.CLEAN, verdict.render()
+
+
 # -------------------------------------------------------------- the inverted half
 
 

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/docs/okf_profile/docs-okf-profiles.yaml

@@ -42,7 +42,7 @@ common_optional:
   - last_update
   - related
 
-# Five profiles, deliberately (Compliance is disabled, see below).
+# Four profiles, deliberately (Compliance is disabled, see below).
 #
 # There were eight. Benchmark, Evaluation, Field Note and Specification declared
 # trees that do not exist -- docs/research/benchmarks, docs/research/evaluations,
@@ -64,7 +64,6 @@ common_optional:
 #   Architecture   what the system is          docs/architecture/**
 #   ADR            why it is that way          docs/architecture/decisions/**, docs/decisions/**
 #   Operations     how it is operated          docs/operations/**
-#   Task ledger    what each agent task did    docs/notes.md
 #   Research       what is being found out     docs/research/**
 #   (Compliance    what we must show           docs/compliance/** -- disabled, see below)
 #
@@ -142,21 +141,6 @@ profiles:
       - ["Credentials", "Access", "Sign"]
       - ["Verification", "Evidence", "Check"]
 
-  # The task ledger: one append-only list of dated lines, one per task start
-  # and finish, that the global agent rule requires in every repository
-  # (docs/notes.md, declared in policy/docs_shape.py). It is an operations
-  # document, but not a procedure: it has no Purpose/Procedure/Credentials
-  # sections and no `related` field, so it gets its own profile rather than
-  # the Operations one above. It is graded for what it really has: OKF
-  # frontmatter with `sources`, and its `## Lines` section.
-  - type: Operations
-    paths:
-      - docs/notes.md
-    required:
-      - sources
-    headings:
-      - ["Lines"]
-
   # Research: inputs, findings and experiment plans under docs/research/. No
   # `type` -- the pages there differ (Research, Experiment) -- and no headings;
   # see the header. Title, description and status come from common_required.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/docs/okf_profile/test_check.py

@@ -5,9 +5,9 @@ Architecture page, and one with an invalid `status` value. Each corpus carries
 its own cut-down profile register, passed as the `profiles` input override —
 the packaged production register is not what these two scenarios are about.
 
-The tests below them grade the PACKAGED register: the task-ledger profile, and
-the Research profile for `docs/research/**` together with the engine rule it
-needs (a profile may declare no `type`, leaving the value unconstrained).
+The tests below them grade the PACKAGED register: the Research profile for
+`docs/research/**` together with the engine rule it needs (a profile may
+declare no `type`, leaving the value unconstrained).
 
 The last section grades the closed key set (2026-10-02): a document may carry
 only the keys its profile admits — `common_required`, `common_optional`, and
@@ -72,25 +72,6 @@ def run_packaged(case: str, only: tuple[str, ...] | None = None) -> object:
     return runner.run(ROW, directory, given)
 
 
-def test_the_task_ledger_matches_a_packaged_profile() -> None:
-    """`docs/notes.md` is the repository's task ledger (the global agent rule:
-    one line at the start and one at the finish of every task). It carries
-    OKF frontmatter and a `## Lines` section and nothing else a profile could
-    demand, so the packaged register must select a profile for it."""
-    verdict = run_packaged("okf-ledger-clean")
-    assert verdict.outcome is Outcome.CLEAN, verdict.render()
-
-
-def test_the_task_ledger_profile_requires_the_lines_section() -> None:
-    """Without this, the clean case above also passes against a profile that
-    asserts nothing about the ledger."""
-    verdict = run_packaged("okf-ledger-no-lines")
-    assert verdict.outcome is Outcome.FINDINGS
-    assert any("missing one of headings: Lines" in f.message for f in verdict.findings), (
-        verdict.render()
-    )
-
-
 def messages(verdict: object, relative: str) -> list[str]:
     """Every message reported against one file, sorted, so a test can assert the
     EXACT set rather than that some finding somewhere mentioned a field."""

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

@@ -1,17 +1,20 @@
-"""LAY-016 — at most ten open plans and at most ten open gaps, by default.
-
-Plans and linked gap items use the exact board-state vocabulary shared with
-LAY-009. An unraised gap and a gap linked to active work both remain open. A
-gap linked to terminal work is stale register content and must be deleted.
-
-The two caps are independent and each is `OPEN_LIMIT` (10) unless the
-repository declares its own, as `--declare open-gaps=N` / `--declare
-open-plans=N` (`[controls.compliance.limits].open_gaps` / `.open_plans` in its
-adl-config.toml). `open_gaps_limit` / `open_plans_limit` resolve them: absent
-is the default, and a value that is not a base-10 positive integer is
-could-not-run, never a quiet fall back to the default. The engine default is
-not raised; a repository states the count it carries today and ratchets it
-down.
+"""LAY-016 — at most ten open plans, by default.
+
+Open plans use the Feature board-state vocabulary shared with LAY-009 (R1):
+a Feature folder's `intent.md` is the one plan file that exists from the
+Feature's first day (R2), so it is the state this cap counts. New, In Progress
+and Awaiting Release are open; Done and Removed are closed.
+
+The cap is `OPEN_LIMIT` (10) unless the repository declares its own, as
+`--declare open-plans=N` (`[controls.compliance.limits].open_plans` in its
+adl-config.toml). `open_plans_limit` resolves it: absent is the default, and a
+value that is not a base-10 positive integer is could-not-run, never a quiet
+fall back to the default. The engine default is not raised; a repository
+states the count it carries today and ratchets it down.
+
+R7 (ADL process handover, 2026-10-12) retired the register half of this gate
+with `plans/GAPS-AND-FINDINGS.md` itself: the open-gaps cap, the register
+columns and the `open-gaps` declaration are gone. The open-plans cap stays.
 """
 
 from __future__ import annotations
@@ -33,63 +36,30 @@ class OpenWorkCap(Check):
     inputs: ClassVar[dict[str, str]] = {"plans_root": "<plans>"}
     whole_scope: ClassVar[bool] = True
 
-    # The engine default for each cap. A repository states its own with the
-    # `open-gaps` / `open-plans` declarations; see `open_gaps_limit`.
+    # The engine default. A repository states its own with the
+    # `open-plans` declaration; see `open_plans_limit`.
     OPEN_LIMIT: ClassVar[int] = 10
-    OPEN_GAPS_DECLARATION: ClassVar[str] = "open-gaps"
     OPEN_PLANS_DECLARATION: ClassVar[str] = "open-plans"
     FEATURES: ClassVar[str] = "features"
-    SPEC: ClassVar[str] = "spec.md"
-    REGISTER: ClassVar[str] = "GAPS-AND-FINDINGS.md"
+    INTENT: ClassVar[str] = "intent.md"
     IGNORED: ClassVar[str] = ".DS_Store"
-    COLUMNS: ClassVar[tuple[str, ...]] = (
-        "Found",
-        "Finding",
-        "From plan",
-        "Item file",
-        "Work item",
-    )
-    DIVIDER_CELL: ClassVar[re.Pattern[str]] = re.compile(r"^:?-{3,}:?$")
-    WORK_ITEM_LINK: ClassVar[re.Pattern[str]] = re.compile(
-        r"^\[([0-9]+)\]"
-        r"\((https://dev\.azure\.com/\S+/_workitems/edit/([0-9]+)/?)\)$"
-    )
-    UNRAISED: ClassVar[frozenset[str]] = frozenset(("", "-", "—", "TBD"))
-    EXCERPT: ClassVar[int] = 60
-
-    def open_gaps_limit(self, ctx: Context) -> int:
-        """The open-gap cap in force: the declared one, else `OPEN_LIMIT`."""
-        return self._declared_limit(ctx, self.OPEN_GAPS_DECLARATION, "open_gaps")
 
     def open_plans_limit(self, ctx: Context) -> int:
         """The open-plan cap in force: the declared one, else `OPEN_LIMIT`."""
-        return self._declared_limit(ctx, self.OPEN_PLANS_DECLARATION, "open_plans")
-
-    def _declared_limit(self, ctx: Context, declaration: str, key: str) -> int:
-        """One cap's declared value, else `OPEN_LIMIT`.
-
-        ASCII digits only, so `+20`, `1_0`, ` 20` and full-width digits are
-        refused, which `int()` alone would accept. A declaration that cannot be
-        read as a positive integer is could-not-run: falling back to the default
-        would grade the repository against a cap it explicitly replaced.
-        """
-        declared = ctx.declarations.get(declaration)
+        declared = ctx.declarations.get(self.OPEN_PLANS_DECLARATION)
         if declared is None:
             return self.OPEN_LIMIT
         if re.fullmatch(r"[0-9]+", declared) is None or int(declared) < 1:
             raise CouldNotRun(
-                f"declaration {declaration}={declared!r} is not a base-10 positive "
-                f"integer; set [controls.compliance.limits].{key} to a whole number "
+                f"declaration {self.OPEN_PLANS_DECLARATION}={declared!r} is not a "
+                "base-10 positive integer; set "
+                "[controls.compliance.limits].open_plans to a whole number "
                 "of at least 1"
             )
         return int(declared)
 
     def graded(self, ctx: Context, files: FileSet) -> Iterable[Finding]:
-        # Both caps are resolved before either is graded, so an unreadable
-        # declaration is could-not-run even when the cap it names is not the
-        # one being exceeded.
         plans_limit = self.open_plans_limit(ctx)
-        gaps_limit = self.open_gaps_limit(ctx)
 
         yield from self._cap(
             "plans",
@@ -99,17 +69,6 @@ class OpenWorkCap(Check):
             f"finish or remove open Features until no more than {plans_limit} remain",
         )
 
-        open_gaps, stale_gaps = self._gaps(ctx, set(files))
-        yield from stale_gaps
-        yield from self._cap(
-            "gaps",
-            f"{self._plans(ctx)}/{self.REGISTER}",
-            open_gaps,
-            gaps_limit,
-            "finish linked work and delete its gap row, or resolve unraised gaps, "
-            f"until no more than {gaps_limit} remain",
-        )
-
     def _cap(
         self, subject: str, path: str, open_items: list[str], limit: int, fix: str
     ) -> Iterator[Finding]:
@@ -137,135 +96,33 @@ class OpenWorkCap(Check):
         for name in sorted(names):
             if name == self.IGNORED or not ctx.path(f"{features}/{name}").is_dir():
                 continue
-            spec = f"{features}/{name}/{self.SPEC}"
-            if spec not in given:
+            intent = f"{features}/{name}/{self.INTENT}"
+            if not ctx.path(intent).is_file():
+                # A Feature whose intent.md does not exist yet is mid-migration;
+                # LAY-009 reports the missing file. Counting it either way would
+                # grade a state nobody established.
+                continue
+            if intent not in given:
                 raise CouldNotRun(
-                    f"{spec} is not in the widened Git-visible file set; an on-disk "
-                    "spec outside that set cannot establish plan state"
+                    f"{intent} is not in the widened Git-visible file set; an on-disk "
+                    "intent outside that set cannot establish plan state"
                 )
-            body = self.text(ctx, spec)
+            body = self.text(ctx, intent)
             if body is None:
                 raise CouldNotRun(
-                    f"{spec} is missing; an unreadable plan state cannot be counted"
+                    f"{intent} is missing; an unreadable plan state cannot be counted"
                 )
-            status = self._status(body, spec)
-            if status in PlanMetadata.ACTIVE_STATUSES:
+            status = self._status(body, intent)
+            if status in PlanMetadata.FEATURE_ACTIVE_STATUSES:
                 open_plans.append(name)
         return open_plans
 
     def _status(self, body: str, path: str) -> str:
         status = PlanMetadata.field(body, PlanMetadata.STATUS_LINE)
-        if status not in PlanMetadata.WORK_ITEM_STATUSES:
+        if status not in PlanMetadata.FEATURE_STATUSES:
             shown = "missing" if status is None else repr(status)
             raise CouldNotRun(
                 f"{path} has {shown} status; expected an exact work item state: "
-                f"{', '.join(PlanMetadata.WORK_ITEM_STATUSES)}"
+                f"{', '.join(PlanMetadata.FEATURE_STATUSES)}"
             )
         return status
-
-    def _gaps(self, ctx: Context, given: set[str]) -> tuple[list[str], list[Finding]]:
-        register = f"{self._plans(ctx)}/{self.REGISTER}"
-        if register not in given:
-            return [], []
-        body = self.text(ctx, register)
-        if body is None:
-            raise CouldNotRun(
-                f"{register} is in the widened Git-visible file set but cannot be read"
-            )
-
-        rows = [
-            (number, self._cells(line))
-            for number, line in enumerate(body.splitlines(), start=1)
-            if line.lstrip().startswith("|")
-        ]
-        if not rows:
-            raise CouldNotRun(f"{register} exists but holds no Markdown table")
-        if tuple(rows[0][1]) != self.COLUMNS:
-            raise CouldNotRun(
-                f"{register} has columns {rows[0][1]}, expected {list(self.COLUMNS)}"
-            )
-
-        open_gaps: list[str] = []
-        stale: list[Finding] = []
-        for number, cells in rows[1:]:
-            if len(cells) != len(self.COLUMNS):
-                raise CouldNotRun(
-                    f"{register}:{number} has {len(cells)} cells; expected "
-                    f"{len(self.COLUMNS)}, so its work-item column cannot be identified"
-                )
-            if all(self.DIVIDER_CELL.match(cell) for cell in cells):
-                continue
-
-            label = f"line {number}: {cells[0]} {self._excerpt(cells[1])}"
-            work_item_cell = self._plain(cells[4])
-            if work_item_cell in self.UNRAISED:
-                open_gaps.append(label)
-                continue
-
-            linked = self.WORK_ITEM_LINK.match(work_item_cell)
-            if linked is None or linked.group(1) != linked.group(3):
-                raise CouldNotRun(
-                    f"{register}:{number} has malformed work item link "
-                    f"{work_item_cell!r}; use [id](https://dev.azure.com/.../_workitems/edit/id)"
-                )
-            linked_id = int(linked.group(1))
-            item_path = self._plain(cells[3])
-            item_match = re.fullmatch(
-                rf"{re.escape(self._plans(ctx))}/{self.FEATURES}/"
-                r"az[0-9]+-[a-z0-9]+(?:-[a-z0-9]+)*/items/"
-                r"az([0-9]+)-[a-z0-9]+(?:-[a-z0-9]+)*\.md",
-                item_path,
-            )
-            if item_match is None or int(item_match.group(1)) != linked_id:
-                raise CouldNotRun(
-                    f"{register}:{number} item file {item_path!r} must be a normalized "
-                    f"repository-relative {self._plans(ctx)}/features/az<feature>-<slug>/"
-                    f"items/az{linked_id}-<slug>.md path"
-                )
-            if item_path not in given:
-                raise CouldNotRun(
-                    f"{register}:{number} item file {item_path!r} is not in the widened "
-                    "Git-visible file set; an on-disk path outside that set cannot "
-                    "establish linked work state"
-                )
-            item_body = self.text(ctx, item_path)
-            if item_body is None:
-                raise CouldNotRun(
-                    f"{register}:{number} names item file {item_path!r}, but it is missing"
-                )
-            found_id, why = PlanMetadata.work_item_id(item_body)
-            if why or found_id != linked_id:
-                raise CouldNotRun(
-                    f"{item_path} must carry a work_item link for {linked_id}; "
-                    f"found {why or found_id}"
-                )
-            status = self._status(item_body, item_path)
-            if status in PlanMetadata.ACTIVE_STATUSES:
-                open_gaps.append(label)
-            elif status in PlanMetadata.TERMINAL_STATUSES:
-                stale.append(
-                    self.report(
-                        register,
-                        f"closed gap remains in the register at {label}; linked item "
-                        f"{linked_id} is {status}",
-                        f"delete line {number} from {register}; closed gaps no longer remain",
-                        line=number,
-                    )
-                )
-        return open_gaps, stale
-
-    @staticmethod
-    def _plain(value: str) -> str:
-        stripped = value.strip()
-        if len(stripped) >= 2 and stripped.startswith("`") and stripped.endswith("`"):
-            return stripped[1:-1].strip()
-        return stripped
-
-    @staticmethod
-    def _cells(line: str) -> list[str]:
-        inner = line.strip().removeprefix("|").removesuffix("|")
-        return [cell.strip().replace(r"\|", "|") for cell in re.split(r"(?<!\\)\|", inner)]
-
-    def _excerpt(self, value: str) -> str:
-        flat = " ".join(value.split())
-        return flat if len(flat) <= self.EXCERPT else f"{flat[: self.EXCERPT]}…"

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/open_work_cap/fixtures/open-work-cap-clean/plans/features/az601-clean/intent.md

@@ -0,0 +1,17 @@
+---
+type: intent
+title: "A clean feature"
+status: New
+work_item: https://dev.azure.com/org/project/_workitems/edit/601
+last_update: 2026-09-17T00:00:00Z
+---
+
+# A clean feature
+
+## Why
+
+## Outcome
+
+## Constraints
+
+## Non-goals