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

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

@@ -3,12 +3,13 @@ work item it is named for.
 
     plans/
     ├── AGENTS.md
-    ├── templates/
-    │   ├── feature.md
-    │   └── backlog-item.md
+    ├── LEDGER.md
     └── features/
         └── az<id>-<slug>/
-            ├── spec.md
+            ├── intent.md
+            ├── requirements.md
+            ├── design.md
+            ├── file-map-reference.md
             └── items/
                 └── az<id>-<slug>.md
 
@@ -25,6 +26,16 @@ and never renamed. A filename whose id disagrees with its own `work_item:` is
 the one way this rots, and it rots silently: every tool keeps working, and the
 file simply describes a different work item than its name claims.
 
+R1–R7 (ADL process handover, 2026-10-12): `intent.md` is the one required plan
+file — a Feature with only `intent.md` passes until its planning run writes
+`requirements.md`, `design.md` and `file-map-reference.md` (R2, R3, R6). Plan
+files mirror the Feature's five board states; item files keep the twelve item
+states (R1). `GAPS-AND-FINDINGS.md` is retired from the plans root (R7). Every
+plan file and item file carries its required-section list, `requirements.md`
+acceptance criteria are EARS sentences, and every item file names its Feature's
+board URL in `feature:` (R4). The file contracts ship in the workitems-process
+skill's references, so the fix hints point there (R5).
+
 Replaces the earlier `.plans/a_new|b_committed|c_done` lifecycle tree. That
 design mirrored a work item's state in a directory name, which meant two
 authorities for one fact. State now lives only on the board and files do not
@@ -58,7 +69,19 @@ class PlansLayout(Check):
     FEATURES: ClassVar[str] = "features"
     TEMPLATES: ClassVar[str] = "templates"
     ITEMS: ClassVar[str] = "items"
-    SPEC: ClassVar[str] = "spec.md"
+
+    # The four plan files. `intent.md` is required — it lands with the Feature
+    # itself — and the other three arrive with the planning run (R2).
+    INTENT: ClassVar[str] = "intent.md"
+    REQUIREMENTS: ClassVar[str] = "requirements.md"
+    DESIGN: ClassVar[str] = "design.md"
+    FILE_MAP: ClassVar[str] = "file-map-reference.md"
+    PLAN_FILES: ClassVar[tuple[str, ...]] = (
+        INTENT,
+        REQUIREMENTS,
+        DESIGN,
+        FILE_MAP,
+    )
 
     # Supporting documents, named by ROLE and not by topic. The topic is already
     # the directory (`az355-channels-humans-and-agents`), so a file called
@@ -67,15 +90,9 @@ class PlansLayout(Check):
     # you can tell what a file is from its name, in every feature, without opening
     # it. Adding a name here later is cheap; leaving the set open is how a tree
     # ends up with HANDOVER.md, handover-v2.md and channels-notes.md side by side.
-    SUPPORTING: ClassVar[tuple[str, ...]] = ("handoff.md", "intent.md", "review.md")
+    SUPPORTING: ClassVar[tuple[str, ...]] = ("handoff.md", "review.md")
 
     ROOT_DIRS: ClassVar[tuple[str, ...]] = ("features", "templates")
-    # `GAPS-AND-FINDINGS.md` sits here because its own rows say where they go:
-    # each becomes an item file "parented under the same Feature as the plan it
-    # was found from". It is a register OF plans work, so it belongs beside the
-    # plans, not at the repository root. `root_shape.REGISTERS` still permits a
-    # register at root for repositories that keep one there -- that is an
-    # allowlist, not a requirement, so nothing breaks by leaving.
     # `LEDGER.md`, not `LEDGER.yaml`. Owner ruling 2026-09-17: the plan-event
     # ledger is Markdown, because the estate already has ast-grep markdown and
     # yq frontmatter tooling to scan it, and a YAML register beside a tree of
@@ -86,8 +103,11 @@ class PlansLayout(Check):
     # Markdown form as "legacy", and this list allowed only the YAML. A
     # repository could not satisfy all three at once -- a managed repository's conversion
     # failed here the moment it succeeded elsewhere.
+    #
+    # R7 (2026-10-12): `GAPS-AND-FINDINGS.md` is retired with the register it
+    # held; findings enter only through report-bug.
     ROOT_ALLOWED_FILES: ClassVar[tuple[str, ...]] = (
-        "AGENTS.md", "CLAUDE.md", "LEDGER.md", "GAPS-AND-FINDINGS.md",
+        "AGENTS.md", "CLAUDE.md", "LEDGER.md",
     )
     IGNORED: ClassVar[str] = ".DS_Store"
     KEEP: ClassVar[str] = ".gitkeep"
@@ -97,23 +117,71 @@ class PlansLayout(Check):
     ITEM_FILE: ClassVar[re.Pattern[str]] = re.compile(r"^az([0-9]+)-[a-z0-9]+(-[a-z0-9]+)*\.md$")
 
     WORK_ITEM_LINE: ClassVar[re.Pattern[str]] = PlanMetadata.WORK_ITEM_LINE
+    FEATURE_LINE: ClassVar[re.Pattern[str]] = PlanMetadata.FEATURE_LINE
     EPIC_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^epic:\s*(.+)$")
     TYPE_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^type:\s*(.+)$")
     TITLE_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^title:\s*(.+)$")
     STATUS_LINE: ClassVar[re.Pattern[str]] = PlanMetadata.STATUS_LINE
     MODIFIED_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^last_update:\s*(.+)$")
-    SOURCES_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^sources:\s*$")
 
-    ITEM_TYPES: ClassVar[tuple[str, ...]] = ("pbi", "bug")
+    # The frontmatter `type:` each plan file declares.
+    INTENT_TYPE: ClassVar[str] = "intent"
     FEATURE_TYPE: ClassVar[str] = "feature"
+    DESIGN_TYPE: ClassVar[str] = "design"
+    FILE_MAP_TYPE: ClassVar[str] = "file-map"
+
+    ITEM_TYPES: ClassVar[tuple[str, ...]] = ("pbi", "bug")
 
     # The board's own states. `status` here mirrors the work item, not a
-    # document lifecycle, so `draft` and `stable` are wrong in this tree.
+    # document lifecycle, so `draft` and `stable` are wrong in this tree. Plan
+    # files mirror the FEATURE's state, item files the ITEM's (R1).
     #
     # This gate checks the value is a REAL state; it cannot check the value is
     # the CURRENT one, because that needs the board. A file whose status has
     # gone stale is the known cost of keeping the field at all.
-    STATUSES: ClassVar[tuple[str, ...]] = PlanMetadata.WORK_ITEM_STATUSES
+    FEATURE_STATUSES: ClassVar[tuple[str, ...]] = PlanMetadata.FEATURE_STATUSES
+    ITEM_STATUSES: ClassVar[tuple[str, ...]] = PlanMetadata.ITEM_STATUSES
+
+    # Required sections, per process-design.md § Plan files / § Item files
+    # (R4). One finding per missing section, named so the author can fix the
+    # file without opening the check.
+    INTENT_SECTIONS: ClassVar[tuple[str, ...]] = (
+        "## Why", "## Outcome", "## Constraints", "## Non-goals",
+    )
+    REQUIREMENTS_SECTIONS: ClassVar[tuple[str, ...]] = (
+        "## Problem", "## Acceptance criteria", "## Scope", "## Predecessors",
+        "## Items", "## Open questions for G1", "## Revision log",
+    )
+    DESIGN_SECTIONS: ClassVar[tuple[str, ...]] = (
+        "## Solution", "## Decisions", "## Verification", "## Docs impact",
+        "## Size estimate", "## Risks",
+    )
+    FILE_MAP_SECTIONS: ClassVar[tuple[str, ...]] = ("## Baseline", "## Map")
+    # A type: bug item file is a Fixes Bug item file -- Bugs are never planned,
+    # so the bugfix shape is the only bug shape there is.
+    PBI_SECTIONS: ClassVar[tuple[str, ...]] = ("## What it delivers", "## Verification")
+    BUG_SECTIONS: ClassVar[tuple[str, ...]] = (
+        "## Current behaviour", "## Expected behaviour",
+        "## Behaviour that must not change", "## Responsible Feature",
+        "## Predecessors", "## Verification",
+    )
+
+    # EARS (R4): every numbered acceptance criterion is one sentence of the
+    # form "THE SYSTEM SHALL …", optionally opened by WHEN, WHILE, IF … THEN
+    # or WHERE. One finding per offending criterion.
+    # A criterion is an AC-n reference followed by a sentence delimiter; prose
+    # that merely mentions AC-1 ("AC-1 is the load-bearing criterion") is not
+    # one and is not EARS-checked.
+    AC_LINE: ClassVar[re.Pattern[str]] = re.compile(r"^\s*(?:[-*]\s+)?AC-([0-9]+)[.:)]\s+(.+?)\s*$")
+    EARS: ClassVar[re.Pattern[str]] = re.compile(
+        r"^(?:(?:WHEN|WHILE|WHERE)\b.+?|IF\b.+?THEN\b.+?)?THE\s+SYSTEM\s+SHALL\b",
+        re.IGNORECASE,
+    )
+
+    # The board's own states, as `sources:` list entries. `requirements.md`
+    # derives from `intent.md` (listed first); `design.md` derives from
+    # `requirements.md`.
+    SOURCE_ITEM: ClassVar[re.Pattern[str]] = re.compile(r"^\s*-\s+(.+?)\s*$")
 
     # A work item reference is the URL you can click, not a bare id: the id is
     # already in the filename, so repeating it as a number adds nothing, while
@@ -220,7 +288,7 @@ class PlansLayout(Check):
                     # Derived from the constant, never restated. The hardcoded
                     # version had drifted twice over: it named `LEDGER.yaml`,
                     # which is no longer allowed, and omitted
-                    # `GAPS-AND-FINDINGS.md`, which is -- so it was wrong about
+                    # `GAPS-AND-FINDINGS.md`, which was -- so it was wrong about
                     # both ends of the same four-item list it was describing.
                     f"direct plans files must be one of: {', '.join(self.ROOT_ALLOWED_FILES)}",
                     f"move {entry} into its Feature directory under "
@@ -289,28 +357,45 @@ class PlansLayout(Check):
     def _feature_contents(
         self, ctx: Context, feature_dir: str, feature_id: int, given: set[str]
     ) -> Iterator[Finding]:
-        spec = f"{feature_dir}/{self.SPEC}"
-        if not ctx.path(spec).is_file():
+        intent = f"{feature_dir}/{self.INTENT}"
+        if not ctx.path(intent).is_file():
             yield self.report(
-                spec,
-                "Feature directory must hold a spec.md",
-                f"add {spec} from plans/templates/feature.md",
+                intent,
+                "Feature directory must hold an intent.md",
+                # R5: the file contracts ship in the workitems-process
+                # skill's references, not a per-repo plans/templates/.
+                f"add {intent} per the workitems-process skill's "
+                "references/ado-and-git.md § 4",
             )
         else:
-            yield from self._check_spec(ctx, spec, feature_id)
+            yield from self._check_intent(ctx, intent, feature_id)
+
+        # requirements.md, design.md and file-map-reference.md arrive with
+        # the planning run (R2); each is graded only once it exists.
+        for name, check in (
+            (self.REQUIREMENTS, self._check_requirements),
+            (self.DESIGN, self._check_design),
+            (self.FILE_MAP, self._check_file_map),
+        ):
+            path = f"{feature_dir}/{name}"
+            if ctx.path(path).is_file():
+                yield from check(ctx, path, feature_id)
 
         for entry in sorted(self._under(feature_dir, given)):
             name = entry.rsplit("/", 1)[-1]
-            if name in (self.IGNORED, self.SPEC, self.ITEMS):
+            if name in (self.IGNORED, *self.PLAN_FILES, self.ITEMS):
                 continue
             if name in self.SUPPORTING:
                 # A supporting document carries the same frontmatter as everything
                 # else in this tree. Without it a handoff is an undated wall of prose
                 # that names no work item -- readable today, unattributable in a month,
                 # which is the state CHANNELS-HANDOVER.md was in at the repository root.
-                yield from self._common(ctx, entry, self.text(ctx, entry) or "", feature_id)
+                yield from self._common(
+                    ctx, entry, self.text(ctx, entry) or "", feature_id,
+                    self.ITEM_STATUSES,
+                )
                 continue
-            allowed = ", ".join((self.SPEC, *self.SUPPORTING, f"{self.ITEMS}/"))
+            allowed = ", ".join((*self.PLAN_FILES, *self.SUPPORTING, f"{self.ITEMS}/"))
             yield self.report(
                 entry,
                 f"a Feature directory holds {allowed} only",
@@ -339,11 +424,34 @@ class PlansLayout(Check):
     def _field(body: str, pattern: re.Pattern[str]) -> str | None:
         return PlanMetadata.field(body, pattern)
 
-    def _work_item_id(self, body: str) -> tuple[int | None, str | None]:
-        """The id in `work_item:`, and why it could not be read."""
-        return PlanMetadata.work_item_id(body)
-
-    def _common(self, ctx: Context, path: str, body: str, expected_id: int) -> Iterator[Finding]:
+    def _sources(self, body: str) -> list[str] | None:
+        """The frontmatter `sources:` list, or None when the key is absent."""
+        lines = body.splitlines()
+        if not lines or lines[0].strip() != "---":
+            return None
+        items: list[str] = []
+        in_sources = False
+        for line in lines[1:]:
+            if line.strip() == "---":
+                break
+            if in_sources:
+                found = self.SOURCE_ITEM.match(line)
+                if found:
+                    items.append(found.group(1).strip().strip("\"'"))
+                elif line.strip():
+                    break
+            elif re.match(r"^sources:\s*$", line):
+                in_sources = True
+        return items if in_sources else None
+
+    def _common(
+        self,
+        ctx: Context,
+        path: str,
+        body: str,
+        expected_id: int,
+        statuses: tuple[str, ...],
+    ) -> Iterator[Finding]:
         """The frontmatter every document in this tree carries."""
         if self._field(body, self.TITLE_LINE) is None:
             yield self.report(path, "missing title", f"add `title:` to {path}")
@@ -353,13 +461,13 @@ class PlansLayout(Check):
             yield self.report(
                 path,
                 "missing status",
-                f"add `status:` to {path}, one of: {', '.join(self.STATUSES)}",
+                f"add `status:` to {path}, one of: {', '.join(statuses)}",
             )
-        elif status not in self.STATUSES:
+        elif status not in statuses:
             yield self.report(
                 path,
                 f"status {status!r} is not a work item state",
-                f"set status in {path} to one of: {', '.join(self.STATUSES)}; "
+                f"set status in {path} to one of: {', '.join(statuses)}; "
                 "it mirrors the board, not a document lifecycle",
             )
 
@@ -375,7 +483,7 @@ class PlansLayout(Check):
                 f"set last_update in {path} to YYYY-MM-DDTHH:MM:SSZ",
             )
 
-        found_id, why = self._work_item_id(body)
+        found_id, why = PlanMetadata.work_item_id(body)
         if why == "missing":
             yield self.report(
                 path,
@@ -398,46 +506,136 @@ class PlansLayout(Check):
                 f"az{found_id}",
             )
 
-    def _check_spec(self, ctx: Context, spec: str, feature_id: int) -> Iterator[Finding]:
-        body = self.text(ctx, spec) or ""
-        yield from self._common(ctx, spec, body, feature_id)
+    def _sections(
+        self, path: str, body: str, required: tuple[str, ...]
+    ) -> Iterator[Finding]:
+        """One finding per required section the document does not carry."""
+        headings = {line.strip() for line in body.splitlines()}
+        for section in required:
+            if section not in headings:
+                yield self.report(
+                    path,
+                    f"missing section {section}",
+                    f"add a '{section}' section to {path}",
+                )
 
+    def _check_type(self, path: str, body: str, want: str) -> Iterator[Finding]:
         declared = self._field(body, self.TYPE_LINE)
-        if declared != self.FEATURE_TYPE:
+        if declared != want:
             yield self.report(
-                spec,
-                f"type must be {self.FEATURE_TYPE!r} (got {declared!r})",
-                f"set `type: {self.FEATURE_TYPE}` in {spec}",
+                path,
+                f"type must be {want!r} (got {declared!r})",
+                f"set `type: {want}` in {path}",
             )
 
+    # -------------------------------------------------------------- plan files
+
+    def _check_intent(
+        self, ctx: Context, intent: str, feature_id: int
+    ) -> Iterator[Finding]:
+        body = self.text(ctx, intent) or ""
+        yield from self._common(ctx, intent, body, feature_id, self.FEATURE_STATUSES)
+        yield from self._check_type(intent, body, self.INTENT_TYPE)
+        yield from self._sections(intent, body, self.INTENT_SECTIONS)
+
+    def _check_requirements(
+        self, ctx: Context, requirements: str, feature_id: int
+    ) -> Iterator[Finding]:
+        body = self.text(ctx, requirements) or ""
+        yield from self._common(
+            ctx, requirements, body, feature_id, self.FEATURE_STATUSES
+        )
+        yield from self._check_type(requirements, body, self.FEATURE_TYPE)
+
         epic = self._field(body, self.EPIC_LINE)
         if epic is None:
             yield self.report(
-                spec,
-                "spec.md must name the Epic its Feature hangs under",
-                f"add `epic:` to {spec} as the board URL; it is authored, never "
+                requirements,
+                "requirements.md must name the Epic its Feature hangs under",
+                f"add `epic:` to {requirements} as the board URL; it is authored, never "
                 "tool-created, so a wrong id fails loudly at parenting time",
             )
         elif not self.WORK_ITEM_URL.match(epic):
             yield self.report(
-                spec,
+                requirements,
                 "epic must be a board URL, not a bare id",
-                f"set epic in {spec} to https://dev.azure.com/.../_workitems/edit/<id>",
+                f"set epic in {requirements} to https://dev.azure.com/.../_workitems/edit/<id>",
             )
 
-        if not any(self.SOURCES_LINE.match(line) for line in body.splitlines()):
+        sources = self._sources(body)
+        if sources is None:
             yield self.report(
-                spec,
-                "spec.md must link the documents it derives from",
-                f"add a `sources:` list to {spec} pointing at the docs/ pages "
-                "behind it; a spec with none cannot have its reasoning retraced",
+                requirements,
+                "requirements.md must link the documents it derives from",
+                f"add a `sources:` list to {requirements} pointing at intent.md; "
+                "a requirements file with none cannot have its reasoning retraced",
             )
+        elif not sources or "intent.md" not in sources[0]:
+            yield self.report(
+                requirements,
+                "requirements.md must list intent.md first in sources",
+                f"set the first `sources:` entry of {requirements} to intent.md",
+            )
+
+        yield from self._sections(requirements, body, self.REQUIREMENTS_SECTIONS)
+        yield from self._check_ears(requirements, body)
+
+    def _check_design(
+        self, ctx: Context, design: str, feature_id: int
+    ) -> Iterator[Finding]:
+        body = self.text(ctx, design) or ""
+        yield from self._common(ctx, design, body, feature_id, self.FEATURE_STATUSES)
+        yield from self._check_type(design, body, self.DESIGN_TYPE)
+
+        sources = self._sources(body)
+        if sources is None:
+            yield self.report(
+                design,
+                "design.md must link the documents it derives from",
+                f"add a `sources:` list to {design} pointing at requirements.md",
+            )
+        elif not any("requirements.md" in source for source in sources):
+            yield self.report(
+                design,
+                "design.md must list requirements.md in sources",
+                f"add requirements.md to the `sources:` list of {design}",
+            )
+
+        yield from self._sections(design, body, self.DESIGN_SECTIONS)
+
+    def _check_file_map(
+        self, ctx: Context, file_map: str, feature_id: int
+    ) -> Iterator[Finding]:
+        body = self.text(ctx, file_map) or ""
+        yield from self._common(ctx, file_map, body, feature_id, self.FEATURE_STATUSES)
+        yield from self._check_type(file_map, body, self.FILE_MAP_TYPE)
+        yield from self._sections(file_map, body, self.FILE_MAP_SECTIONS)
+
+    # -------------------------------------------------------------------- EARS
+
+    def _check_ears(self, requirements: str, body: str) -> Iterator[Finding]:
+        for number, line in enumerate(body.splitlines(), start=1):
+            found = self.AC_LINE.match(line)
+            if not found:
+                continue
+            if self.EARS.match(found.group(2)):
+                continue
+            yield self.report(
+                requirements,
+                f"AC-{found.group(1)} is not an EARS sentence",
+                f"rewrite AC-{found.group(1)} in {requirements} as "
+                "'THE SYSTEM SHALL …', optionally opened by WHEN / WHILE / "
+                "IF … THEN / WHERE",
+                line=number,
+            )
+
+    # -------------------------------------------------------------- item files
 
     def _check_item(
         self, ctx: Context, item: str, item_id: int, feature_id: int
     ) -> Iterator[Finding]:
         body = self.text(ctx, item) or ""
-        yield from self._common(ctx, item, body, item_id)
+        yield from self._common(ctx, item, body, item_id, self.ITEM_STATUSES)
 
         declared = self._field(body, self.TYPE_LINE)
         if declared is None:
@@ -452,3 +650,33 @@ class PlansLayout(Check):
                 f"type {declared!r} is not pbi or bug",
                 f"set type in {item} to pbi (Product Backlog Item) or bug",
             )
+
+        # R4: the item names its Feature's full board URL; the check requires
+        # the key and verifies it against the folder id.
+        found_feature, why = PlanMetadata.feature_id(body)
+        if why == "missing":
+            yield self.report(
+                item,
+                "missing feature link",
+                f"add `feature:` to {item} as the Feature's full board URL "
+                f"(.../_workitems/edit/{feature_id})",
+            )
+        elif why:
+            yield self.report(
+                item,
+                "feature must be a board URL, not a bare id",
+                f"set feature in {item} to "
+                f"https://dev.azure.com/<org>/<project>/_workitems/edit/{feature_id}",
+            )
+        elif found_feature != feature_id:
+            yield self.report(
+                item,
+                f"feature {found_feature} disagrees with az{feature_id}",
+                f"point feature at {feature_id} in {item}, or move the file "
+                f"under az{found_feature}",
+            )
+
+        if declared == "bug":
+            yield from self._sections(item, body, self.BUG_SECTIONS)
+        else:
+            yield from self._sections(item, body, self.PBI_SECTIONS)

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/plans_layout/fixtures/plans-layout-clean/plans/features/az347-test-coverage/design.md

@@ -0,0 +1,35 @@
+---
+type: design
+title: "Test coverage"
+status: New
+work_item: https://dev.azure.com/org/proj/_workitems/edit/347
+last_update: 2026-09-15T03:20:00Z
+sources:
+  - requirements.md
+---
+
+# Test coverage
+
+## Solution
+
+A coverage job per gate.
+
+## Decisions
+
+The job runs in CI; the alternative, a local wrapper, was rejected.
+
+## Verification
+
+AC-1: the suite covering the coverage job.
+
+## Docs impact
+
+`docs/operations/compliance-controls.md`.
+
+## Size estimate
+
+One item, two touchpoints, about 40 lines; the job reuses the existing runner.
+
+## Risks
+
+Flaky timing -- the job pins the runner version.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/plans_layout/fixtures/plans-layout-clean/plans/features/az347-test-coverage/file-map-reference.md

@@ -0,0 +1,19 @@
+---
+type: file-map
+title: "Test coverage"
+status: New
+work_item: https://dev.azure.com/org/proj/_workitems/edit/347
+last_update: 2026-09-15T03:20:00Z
+---
+
+# Test coverage
+
+## Baseline
+
+0000000000000000000000000000000000000000
+
+## Map
+
+| Path | Kind | Why | Items |
+| --- | --- | --- | --- |
+| workflows/ | read | the CI layout | 351 |

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/plans_layout/fixtures/plans-layout-clean/plans/features/az347-test-coverage/intent.md

@@ -0,0 +1,25 @@
+---
+type: intent
+title: "Test coverage"
+status: New
+work_item: https://dev.azure.com/org/proj/_workitems/edit/347
+last_update: 2026-09-15T03:20:00Z
+---
+
+# Test coverage
+
+## Why
+
+Coverage tells us which gates are exercised.
+
+## Outcome
+
+Every gate has a measured coverage figure.
+
+## Constraints
+
+None.
+
+## Non-goals
+
+Branch coverage.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/plans_layout/fixtures/plans-layout-clean/plans/features/az347-test-coverage/items/az351-restore-entrypoint.md

@@ -3,7 +3,32 @@ type: bug
 title: "Restore the entrypoint"
 status: Done
 work_item: https://dev.azure.com/org/proj/_workitems/edit/351
+feature: https://dev.azure.com/org/proj/_workitems/edit/347
 last_update: 2026-09-15T03:20:00Z
 ---
 
 # Restore the entrypoint
+
+## Current behaviour
+
+The entrypoint is gone.
+
+## Expected behaviour
+
+THE SYSTEM SHALL restore the entrypoint.
+
+## Behaviour that must not change
+
+The CLI still parses arguments.
+
+## Responsible Feature
+
+az347 test coverage.
+
+## Predecessors
+
+none
+
+## Verification
+
+The entrypoint suite passes.

package/packages/repo-controls/package/adl-compliance/src/adl_compliance/checks/layout/plans_layout/fixtures/plans-layout-clean/plans/features/az347-test-coverage/requirements.md

@@ -0,0 +1,44 @@
+---
+type: feature
+title: "Test coverage"
+status: New
+epic: https://dev.azure.com/org/proj/_workitems/edit/320
+work_item: https://dev.azure.com/org/proj/_workitems/edit/347
+last_update: 2026-09-15T03:20:00Z
+sources:
+  - intent.md
+---
+
+# Test coverage
+
+## Problem
+
+Gate coverage is unmeasured.
+
+## Acceptance criteria
+
+- AC-1: THE SYSTEM SHALL measure coverage per gate.
+
+## Scope
+
+In: the measurement job. Non-goals: branch coverage.
+
+## Predecessors
+
+none
+
+## Items
+
+| Id | Title | Type | Delivers | Verification |
+| --- | --- | --- | --- | --- |
+| 351 | Restore the entrypoint | pbi | AC-1 | suite |
+
+## Open questions for G1
+
+none
+
+## Revision log
+
+| Rev | Date | Baseline | Trigger | Changes |
+| --- | --- | --- | --- | --- |
+| 1 | 2026-09-15 | — | G1 | initial |