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

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