@amsterdamdatalabs/adl-agent-control-linux-x64 0.1.30 → 0.1.32

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

@@ -74,19 +74,19 @@ rows:
         # Same reasoning, the TypeScript-shaped colocated test file: this scope
         # excluded `test_*.py` but nothing that names a TypeScript test the way
         # every managed repo's own convention does. Caught live against
-        # enact-vps-m5: `global-tools/test/install-embedding-model.test.ts`
+        # a managed repository: `global-tools/test/install-embedding-model.test.ts`
         # asserts that `selectVocabulary` DROPS non-Latin-script tokens, and
         # embeds a CJK literal as the negative-test input -- exactly
         # the "test asserting a non-English string" case above, just in `.ts`
         # rather than `.py`. COVERAGE COST, stated not buried: 548 colocated
         # `*.test.ts`/`*.test.tsx` files across the four managed repos
-        # (enact-m5 400, enact-vps-m5 134, enact-repo-controls-m5 14,
-        # enact-extensions 0) stop being graded for english-only.
+        # (400, 134, 14 and 0 in the four
+        # repositories) stop being graded for english-only.
         - '!**/*.test.ts'
         - '!**/*.test.tsx'
         # The four exclusions removed here named
-        # `<typescript>/packages/desktop/...` and `<typescript>/tests/unit/...`
-        # -- one repository's files written into the shared package. Measured
+        # one repository's application and unit-test files, written into the
+        # shared package under a tree placeholder. Measured
         # before removing: 0 of the 4 exist in ANY of the four managed
         # repositories, so they excluded nothing anywhere. If a consumer ever
         # has legitimately non-English source, it declares that itself.
@@ -363,7 +363,6 @@ rows:
       scope:
         - '{AGENTS,CLAUDE}.md'
         - '**/{AGENTS,CLAUDE}.md'
-        - <compliance>/checks/layout/agents-layout/check.sh
         - '!**/fixtures/**'
     grants: 0
     timeout_ms: 60000
@@ -386,7 +385,7 @@ rows:
         #
         # Same shape as LAY-014's `!<workflows>/scripts/**/fixtures/**`, one
         # level up. COVERAGE COST, stated rather than buried: this drops 19 of
-        # enact-m5's 44 `workflows/scripts/` files (43%) from the gate. The risk
+        # one managed repository's 44 `workflows/scripts/` files (43%) from the gate. The risk
         # it trades away is small — a TEST that truly needs a gitignored file
         # fails loudly in CI, whereas a production CI script referencing one can
         # silently skip, and production scripts are all still graded.
@@ -410,29 +409,14 @@ rows:
       # recorded state the register file is deleted. No ceilings declared
       # means nothing to enforce — the gate is inert.
       scope:
-        - <typescript>/**
-        - <rust>/**
-        - <infra>/**
-        - <dev>/**
-        - <workflows>/**
-        # A single '*' cannot cross a '/': it is one path segment, not "the rest
-        # of the subtree". Confirmed live against this checkout, not just the
-        # ported test fixture — locales/de/common.json sits two segments below
-        # locales/, and real crate/build/terraform files sit at varying depths
-        # below their prefix (`rg`/`find` measured 2 and 4 segments for
-        # Cargo.toml, 4 for build.rs, 2 through 5 for main.tf) — every nested
-        # occurrence was silently unexcluded until these five became '**'.
-        - '!<typescript>/packages/desktop/src/renderer/services/i18n/locales/**'
-        - '!<rust>/crates/enact-app/assets/builtin-skills/**'
-        - '!<rust>/crates/enact-app/assets/builtin-harnesses/*'
-        - '!<dev>/seed/access/*'
-        - '!<dev>/seed/infra/*'
-        - '!<dev>/seed/tenancy/*'
-        - '!<dev>/scripts/*'
-        - '!<dev>/ops/*'
-        - '!**/Cargo.toml'
-        - '!**/build.rs'
-        - '!**/main.tf'
+        # The WHOLE repository (Tarun, 2026-10-08, PBI 598): the ratchet is
+        # repo-wide and hardcodes no exclusion. `**` matches every path of the
+        # Git-visible universe the CLI hands over (`ls-files --cached --others
+        # --exclude-standard`), and the measurement itself skips dot-prefixed
+        # components. What a repository exempts it declares itself: a ceiling
+        # per tree in [controls.compliance.directory-ratchet].max_children and
+        # its over-limit / single-file baselines in the ratchet register below.
+        - '**'
         # The ratchet register is a named INPUT of this gate, not a scope entry:
         # it is the CONSUMER's own file (<compliance>/ratchets/
         # LAY-004-over-limit-directory.yaml -- the estate's settled location for
@@ -485,21 +469,21 @@ rows:
   - id: LAY-008
     name: placement
     domain: layout
-    title: Run retained placement gate
+    title: Reject throwaway files and undeclared image placement
     severity: M
     controls:
       - EC-A.5.36
     engine:
+      # Every file: a throwaway extension is reported anywhere, and an image or
+      # screenshot-named file is reported unless it sits in a directory the
+      # repository declares in `asset-dirs`. (The root allowlist is LAY-012's
+      # `root-closed-set`, not this row's.)
       scope:
-        - '*'
-        - '*.{log,tmp,bak,swp}'
-        - '**/*.{log,tmp,bak,swp}'
-        - <compliance>/checks/layout/placement/check.sh
+        - '**'
         # The corpora under placement-allowed/ and placement-stray/ are the
-        # gate's own test input: enumerated asset paths, a screenshot, a
-        # markdown file inside a crate src/ tree, and a file under retired
-        # apps/. Graded as production content they are exactly the findings
-        # the gate exists to raise.
+        # gate's own test input: a screenshot and a throwaway file. Graded as
+        # production content they are exactly the findings the gate exists to
+        # raise.
         - '!**/fixtures/**'
     grants: 0
     timeout_ms: 60000
@@ -567,7 +551,6 @@ rows:
         - '!.git/**'
         - '!.DS_Store'
         - '!.cache/**'
-        - '!.enactrs/**'
         - '!.pytest_cache/**'
         - '!.ruff_cache/**'
         - '!.scratch/**'
@@ -652,27 +635,6 @@ rows:
     grants: 0
     timeout_ms: 60000
 
-  # ---- pipeline ----
-  - id: PIP-004
-    name: phase-disjoint
-    domain: pipeline
-    title: Enforce phase mutual exclusion across every registry row
-    severity: M
-    controls:
-      - EC-A.5.36
-    engine:
-      # Scope is SELECTION, not resolution. The check finds the registry
-      # structurally, from its own position in the package, and that is why it
-      # needs no path here to READ it -- but scope decides whether a changed
-      # file makes this row run at all, and an empty scope matches nothing. The
-      # gate that enforces phase disjointness across the registry was therefore
-      # never selected by a change to the registry: the one edit that can break
-      # it was the one edit that did not run it.
-      scope:
-        - <compliance>/policy/gate-registry.yaml
-    grants: 0
-    timeout_ms: 60000
-
   # ---- repository ----
   - id: REP-001
     name: license-declared
@@ -707,53 +669,32 @@ rows:
       - EC-A.5.21
     engine:
       scope:
-        # The tree-derived DEFAULT: each half is exactly two entries under its own
-        # tree. A repository whose manifests do not sit one level under its tree
-        # (enact-combined: a brace-union `typescript` tree, manifests at the root and
-        # under apps/*/) states the paths itself with `[controls.compliance.lockfiles]`
-        # (`bun-manifests`/`bun-lockfiles`, `cargo-manifests`/`cargo-lockfiles`); a
-        # declared half REPLACES that half's two entries, in the scope and in what the
-        # check grades. See `LockfileIntegrity.declared_scope`.
-        - <rust>/Cargo.toml
-        - <rust>/Cargo.lock
-        - <typescript>/package.json
-        - <typescript>/bun.lock
+        # The REPOSITORY-ROOT pairs, graded automatically (Tarun, 2026-10-08,
+        # PBI 598): `Cargo.toml` -> `Cargo.lock` and `package.json` -> `bun.lock`.
+        # Every other lockfile is graded only because the repository declares it
+        # with `[controls.compliance.lockfiles]` (`bun-manifests`/`bun-lockfiles`,
+        # `cargo-manifests`/`cargo-lockfiles`); a declaration ADDS its manifests
+        # and lockfiles to this scope and to what the check grades. See
+        # `LockfileIntegrity.declared_scope`.
+        - Cargo.toml
+        - Cargo.lock
+        - package.json
+        - bun.lock
     grants: 0
     timeout_ms: 60000
   - id: REP-004
-    name: no-banned-commands
+    name: no-legacy-search
     domain: repository
-    title: Forbid banned command invocations in shell scripts and justfiles
+    title: Forbid standalone legacy search in shell scripts and justfiles
     severity: M
     controls:
       - EC-A.5.36
     engine:
       scope:
-        # Both GIT-001 (no version-control invocation) and GRP-001 (no
-        # standalone grep, use rg) are restricted to the compliance package --
-        # a deliberate, explicit decision (both are compliance gates), not an
-        # inherited default. Neither rule is about the rest of the repository,
-        # so nothing here is expressed as an extension glob any more: the old
-        # repository-wide `*.{sh,bash,...}` list existed only because GRP-001
-        # used to run everywhere and needed to exclude non-shell files from a
-        # much larger candidate set. Restricted to compliance/**, that ceiling
-        # is gone -- check.sh's own shell/justfile filter is enough.
-        - <compliance>/**
-        # The scope contract itself. `discover_files` lists the tree through the
-        # version-control plumbing; every other file in this package reaches it
-        # through this one, which is why it is exempted here rather than at each
-        # caller. Out of scope, not granted: the rule does not apply to the
-        # implementation of the mechanism it exists to make optional everywhere
-        # else.
-        - '!<compliance>/lib/discovery.sh'
-        # The same exemption, on the test side. `_corpus-set.sh` is the one
-        # place a fixture enumerates its corpus, and it asks the corpus the
-        # same question the runner asks the repository, through the same
-        # plumbing -- deliberately, so the set a test hands over is the same
-        # KIND of set production hands over. Every converted gate test reaches
-        # it through this file, which is why it is exempted here rather than at
-        # each caller.
-        - '!<compliance>/checks/framework/_corpus-set.sh'
+        # Repo-wide: every file, narrowed by the check to the shell scripts
+        # and justfiles `core/scripts.py` selects (by suffix, name or
+        # shebang), the same selector REP-007 uses.
+        - '**'
         # EVERY gate's fixture corpus, not just this row's. A fixture is
         # deliberate violation material -- both halves of this row's own corpus
         # contain real invocations on purpose -- and graded as production
@@ -775,3 +716,56 @@ rows:
         - '**'
     grants: 0
     timeout_ms: 60000
+  # Split from REP-004 (Tarun 2026-10-08: PBI 605). Same repo-wide scope; a
+  # repository whose git hooks and release scripts must call the version-control
+  # tool leaves this gate out of `enabled` and keeps REP-004.
+  - id: REP-006
+    name: no-vcs-in-scripts
+    domain: repository
+    title: Forbid version-control calls in shell scripts and justfiles
+    severity: M
+    controls:
+      - EC-A.5.36
+    engine:
+      scope:
+        # Repo-wide: every file, narrowed by the check to the shell scripts
+        # and justfiles `core/scripts.py` selects (by suffix, name or
+        # shebang), the same selector REP-007 uses.
+        - '**'
+        # EVERY gate's fixture corpus, not just this row's. A fixture is
+        # deliberate violation material -- both halves of this row's own corpus
+        # contain real invocations on purpose -- and graded as production
+        # content it fails the gate it exists to prove. Declared here rather
+        # than skipped inside the check: path exclusions carry no default in
+        # this tree.
+        - '!**/fixtures/**'
+        # The managed projections adl rebuilds on every install (Tarun,
+        # 2026-10-08): their git hooks must call the version-control tool and
+        # the repository cannot edit them. Only this gate leaves them out.
+        - '!.workflows/**'
+        - '!.agents/**'
+        - '!.claude/**'
+        - '!.codex/**'
+        - '!.cursor/**'
+        - '!.kimi-code/**'
+        - '!.opencode/**'
+    grants: 0
+    timeout_ms: 60000
+  # Bug 602 (Tarun 2026-10-08): no multi-line comment in code; the explanation
+  # moves to docs/. Grades every code file by suffix (the check's own question,
+  # `scanner.is_code_file`), so the scope is the whole repository less every
+  # gate's fixture corpus. Exempt files are named by the repository's own
+  # register, `<compliance>/ratchets/REP-007-multiline-comments.yaml`.
+  - id: REP-007
+    name: no-multiline-comments
+    domain: repository
+    title: Forbid multi-line comments in code files
+    severity: M
+    controls:
+      - EC-A.8.28
+    engine:
+      scope:
+        - '**'
+        - '!**/fixtures/**'
+    grants: 0
+    timeout_ms: 60000

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

@@ -69,7 +69,7 @@ class EngineSpec(StrictModel):
     """Ordered list, last match wins, '!' excludes. Not a grant: it carries no
     signature and there is nothing to shrink.
 
-    Stored EXPANDED: `<rust>/crates/**` is `backend/crates/**` by the time
+    Stored EXPANDED: `<docs>/guides/**` is `documentation/guides/**` by the time
     anything reads this. Nothing downstream knows placeholders exist, which is
     the point — one mechanism resolves the consumer's layout, at load, and the
     matcher sees ordinary repository-relative globs."""

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

@@ -57,9 +57,7 @@ VCS_AND_META: frozenset[str] = frozenset({
 
 GUIDES: frozenset[str] = frozenset({
     "AGENTS.md",
-    "CLAUDE-INVARIANTS.md",
     "CLAUDE.md",
-    "INDEPENDENT-VERIFICATION.md",
     "INVARIANTS.md",
     "README.md",
 })
@@ -93,33 +91,18 @@ NODE_TOOLCHAIN: frozenset[str] = frozenset({
     ".nvmrc",
     ".prettierrc",
     ".prettierignore",
-    # Same tool as `.prettierrc` above, the same relationship `.dockerignore`
-    # already has to Docker in `VCS_AND_META` — a paired root-required ignore
-    # file, not a look-alike added on resemblance. Deliberately NOT extended
-    # to `.markdownlint.json`/`.markdownlintignore`/`.yamllint.yml`: grepped
-    # for real in the one consumer repository that carries all three
-    # (enact-extensions) — zero hits in `package.json`, `bun.lock`, any
-    # `scripts/` file, or `azure-pipelines.yml`. Nothing in that repository's
-    # own tooling invokes markdownlint or yamllint; they read as editor-only
-    # preference files there, not a root file some build step requires to
-    # find, so they stay off this list until a consumer shows otherwise.
+    # Paired root-required ignore file like `.dockerignore`; markdownlint/yamllint files are declared by the repository.
     "biome.json",
     "bun.lock",
     "bunfig.toml",
     "eslint.config.js",
-    "index.html",
-    "knip.json",
     "opencode.json",
     "opencode.jsonc",
     "package-lock.json",
     "package.json",
-    "playwright.config.ts",
     "pnpm-lock.yaml",
-    "svelte.config.js",
     "tsconfig.json",
     "tsconfig.base.json",
-    "vite.config.ts",
-    "vitest.config.ts",
     "yarn.lock",
 })
 
@@ -147,18 +130,10 @@ PROJECT_CONFIG: frozenset[str] = frozenset({
     # `azure-pipelines.yml` at their root, and `layout.placement`/
     # `layout.root-closed-set` both reported it as undeclared, a false
     # failure on every Azure-DevOps-driven consumer this package can
-    # plausibly serve. Same shape as `docker-compose.yml` below: a
-    # build/deploy pipeline definition naming THIS repository's own stages,
+    # plausibly serve. A build/deploy
+    # pipeline definition naming THIS repository's own stages,
     # not a language-specific toolchain file.
-    "coverage-floor.json",
-    "ctx_overlays.json",
-    "docker-compose.yml",
-    "drizzle.config.ts",
     "adl-config.toml",
-    # An adl-controlled Enact repository carries BOTH config files at its root,
-    # permanently (Tarun, 2026-10-01: "there will be both"). Built in here so no
-    # repository declares it by hand under `[controls.compliance.root] files`.
-    "enact-config.toml",
     "justfile",
 })
 
@@ -195,37 +170,21 @@ AGENT_TREES: frozenset[str] = frozenset({
 })
 
 KNOWLEDGE_TREES: frozenset[str] = frozenset({
-    ".changeset",
-    ".docs",
-    ".donors",
     "docs",
     "plans",
-    "specs",
 })
 
-# Only the standard source trees. `apps/` and `packaging/` are not standard — a
-# repository that has them declares them under `[controls.compliance.root] dirs`.
-# (Tarun, 2026-10-01 — reverses the 2026-09-27 central listing.)
+# Only adl's own or language-neutral trees (PBI 601); any other layout is declared under `[controls.compliance.root] dirs`.
 SOURCE_TREES: frozenset[str] = frozenset({
-    "backend",
-    "compliance",
-    "docker",
     "bin",
-    "dev",
-    "frontend",
-    "infra",
-    "live-probes",
+    "compliance",
     "packages",
     "scripts",
-    "server",
-    "shared",
     "src",
-    "src-tauri",
-    "static",
     "tests",
     # The CI tree: pipelines, pipeline-templates, scripts, tools. Distinct from
     # `.workflows/`, which is adl-repo-controls' managed hook stubs and lock, and
-    # both are live — one is what Azure runs, the other is what git runs. A repository
+    # both are live -- one is what Azure runs, the other is what git runs. A repository
     # carrying both is not mid-migration, and LAY-012 calling this one undeclared said
     # it was. (Owner decision, 2026-09-15.)
     "workflows",

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

@@ -27,6 +27,12 @@ from .policy.grants import granted
 from .policy.registry import Row
 
 
+def _names_unknown_tree(relative: str, trees: Mapping[str, str] | None) -> bool:
+    """Does `relative` name a `<tree>` the effective map has no entry for at all?"""
+    known = trees or {}
+    return any(match.group(1) not in known for match in PLACEHOLDER.finditer(relative))
+
+
 def resolve_inputs(
     check: type[Check],
     root: Path,
@@ -34,6 +40,7 @@ def resolve_inputs(
     stack: ExitStack,
     trees: Mapping[str, str] | None = None,
     declared_trees: Mapping[str, str] | None = None,
+    dropped: dict[str, str] | None = None,
 ) -> dict[str, Path]:
     """Declared logical names -> absolute paths. The only place inputs are joined.
 
@@ -80,6 +87,8 @@ def resolve_inputs(
             # Declared-absent behaves like undeclared here; which of the two it
             # was decides below whether that is fatal or merely narrowing.
             if not absent(relative, trees)
+            # A WIDENING input (register of grants) with an unknown tree is "no register", never an error (PBI 599).
+            and not (name in check.widening_inputs and _names_unknown_tree(relative, trees))
         }
     except TreeMapError as exc:
         raise CouldNotRun(f"{check.id} declares an input naming an unknown tree: {exc}") from exc
@@ -99,6 +108,9 @@ def resolve_inputs(
                         # only produce MORE findings. The check reads it with
                         # `.get()` and must never assume it is present.
                         resolved.pop(name, None)
+                        if dropped is not None and name not in check.widening_inputs:
+                            # Bug 597: a non-widening input dropped because its tree is declared ""; `run` turns a subscript of it into could-not-run.
+                            dropped[name] = tree
                         break
                     raise CouldNotRun(
                         f"{check.id} requires `{name}`; declare "
@@ -116,7 +128,7 @@ def resolve_inputs(
     # Overrides are keyed BY GATE ID. A flat map was handed to every selected
     # row, and the unknown-name guard below then failed every check that did not
     # happen to declare that name -- so declaring the one input `LAY-004` needs
-    # took enact-m5 from 14 PASS to 18 ERROR / 1 FAIL / 0 PASS. The channel was
+    # took a managed repository from 14 PASS to 18 ERROR / 1 FAIL / 0 PASS. The channel was
     # unusable the moment anyone used it, which is why no repository in the
     # fleet had ever declared an input.
     mine = override.get(check.id) if override else None
@@ -168,7 +180,7 @@ def applicable_files(
 
     given_paths = tuple(given)
     narrowed = FileSet(paths=scope.intersect(patterns, given_paths))
-    if not narrowed and exhaustive:
+    if not narrowed and exhaustive and not (check.empty_scope_is_clean and restated is None):
         raise CouldNotRun(
             f"engine.scope matches no file on disk ({' | '.join(patterns)}); "
             "a scope selecting nothing is could-not-run, never a clean pass"
@@ -236,6 +248,9 @@ def prepare_batches(
         except CouldNotRun as exc:
             results[row.id] = BatchResult(error=str(exc))
             continue
+        except Exception as exc:
+            results[row.id] = BatchResult(error=_crashed(check, exc))
+            continue
         if not files:
             results[row.id] = BatchResult()
             continue
@@ -259,13 +274,17 @@ def prepare_batches(
         )
         try:
             produced = provider.run(request)
-        except (CouldNotRun, OSError) as exc:
-            reason = f"batch provider {key!r} could not run: {type(exc).__name__}: {exc}"
-            results.update({gate: BatchResult(error=reason) for gate in files_by_gate})
+            if not isinstance(produced, Mapping):
+                raise TypeError(
+                    f"batch provider {key!r} returned {type(produced).__name__}, "
+                    "not a mapping of gate id to BatchResult"
+                )
+            extra = sorted(set(produced) - set(files_by_gate))
+        except Exception as exc:
+            results.update({gate: BatchResult(error=f"{gate} crashed: {type(exc).__name__}: {exc}") for gate in files_by_gate})
             continue
 
         expected = set(files_by_gate)
-        extra = sorted(set(produced) - expected)
         if extra:
             reason = (
                 f"batch provider {key!r} returned unrequested gate result(s): "
@@ -288,6 +307,10 @@ def prepare_batches(
     return results
 
 
+def _crashed(check_class: type[Check], exc: Exception) -> str:
+    return f"{check_class.id} crashed: {type(exc).__name__}: {exc}"
+
+
 def run(
     row: Row,
     root: Path,
@@ -338,8 +361,10 @@ def run(
         )
     except CouldNotRun as exc:
         return could_not_run(row, str(exc))
+    except Exception as exc:
+        return could_not_run(row, _crashed(check_class, exc))
 
-    if (check_class.whole_scope or restated is not None) and not narrowed:
+    if (check_class.whole_scope or check_class.empty_scope_is_clean or restated is not None) and not narrowed:
         return decide(row, (), (), ())
 
     missing = [tool for tool in check_class.requires if shutil.which(tool) is None]
@@ -352,6 +377,7 @@ def run(
         if batch is None:
             batch = BatchResult(error=f"no batch result was prepared for {row.id}")
 
+    dropped: dict[str, str] = {}
     try:
         with ExitStack() as stack:
             # A structural grant is already spent by the time the findings
@@ -363,7 +389,9 @@ def run(
                 allowance = granted(row.resolved_grants(trees, declared_trees), root)
             context = Context(
                 root=root, row=row,
-                inputs=resolve_inputs(check_class, root, inputs, stack, trees, declared_trees),
+                inputs=resolve_inputs(
+                    check_class, root, inputs, stack, trees, declared_trees, dropped
+                ),
                 declarations=dict(declarations or {}),
                 committed_sizes=dict(committed_sizes or {}),
                 batch_reports=batch.reports if batch is not None else None,
@@ -373,11 +401,29 @@ def run(
             # valid while `as_file` holds it, and a lazy generator would read it
             # after the stack closed.
             reported = tuple(check_class().run(context, narrowed))
+            for item in reported:
+                if not isinstance(item, (Finding, Advisory)):
+                    raise TypeError(f"produced {type(item).__name__}, not a Finding or Advisory")
     except CouldNotRun as exc:
         return could_not_run(row, str(exc))
     except OSError as exc:
         # An unreadable input is a tool failure, not a violation (F-05).
         return could_not_run(row, f"{type(exc).__name__}: {exc}")
+    except KeyError as exc:
+        # Bug 597: an input dropped for a tree declared "" is could-not-run, never clean; any other KeyError is a crash (below).
+        name = exc.args[0] if exc.args else None
+        if isinstance(name, str) and name in dropped:
+            return could_not_run(
+                row,
+                f"{check_class.id} requires input `{name}` from tree <{dropped[name]}>, "
+                f"which adl-config.toml declares absent ([controls.compliance.trees]."
+                f"{dropped[name]} = \"\"); nothing to grade, and a gate that graded "
+                "nothing is could-not-run, never a clean pass",
+            )
+        return could_not_run(row, _crashed(check_class, exc))
+    except Exception as exc:
+        # Bug 597: one check's unexpected exception is that row's could-not-run, not every row's.
+        return could_not_run(row, _crashed(check_class, exc))
 
     # Partitioned by TYPE, not by a flag on one record. An advisory that could be
     # mistaken for a finding eventually is one, and then it moves a verdict.

package/packages/repo-controls/scripts/hooks/pre-commit

@@ -19,11 +19,21 @@ scratchpad_allowlisted() {
     # `scripts/hooks/pre-commit` is where it LIVES in adl-repo-controls. Both
     # are this same policy naming the thing it polices, which is what this
     # allowlist is for.
-    .gitignore | .dockerignore | AGENTS.md | .workflows/hooks/pre-commit | scripts/hooks/pre-commit | src/integrity.ts | workflows/scripts/tests/hooks/*) return 0 ;;
+    .gitignore | .dockerignore | AGENTS.md | .workflows/hooks/pre-commit | scripts/hooks/pre-commit | packages/repo-controls/scripts/hooks/pre-commit | src/integrity.ts | workflows/scripts/tests/hooks/*) return 0 ;;
   esac
   return 1
 }
 
+added_lines_mention_scratchpad() {
+  local diff line
+  diff="$(git diff --cached -- "$1")"
+  [[ "$diff" == *.scratchpad* ]] || return 1
+  while IFS= read -r line; do
+    [[ "$line" == +* && "$line" != +++* && "$line" == *.scratchpad* ]] && return 0
+  done <<<"$diff"
+  return 1
+}
+
 staged_files=()
 scratchpad_paths=()
 while IFS= read -r -d '' file; do
@@ -43,7 +53,7 @@ fi
 offenders=()
 for file in "${staged_files[@]}"; do
   scratchpad_allowlisted "$file" && continue
-  if git diff --cached -- "$file" | grep '^+' | grep -v '^+++' | grep -Fq '.scratchpad'; then
+  if added_lines_mention_scratchpad "$file"; then
     offenders+=("$file")
   fi
 done

package/packages/repo-controls/scripts/hooks/pre-push

@@ -102,12 +102,10 @@ if [[ "$git_config_count" =~ ^[0-9]+$ ]]; then
 fi
 unset GIT_CONFIG_COUNT
 
-# Static checks run against HEAD (the tip being pushed), not the dirty index or
-# worktree, so same-checkout staged/unstaged foreign breakage cannot block delivery.
-# so same-checkout uncommitted foreign breakage cannot block delivery.
-# Reuse a prior pass for the same immutable tree OID under .coverage-cache/.
+# Static checks run against HEAD, keyed by tree + declared checks + export links (see README, No silent skips).
 HEAD_TREE_OID="$(git rev-parse 'HEAD^{tree}')"
-STATIC_CACHE="$ROOT/.coverage-cache/pre-push-static/${HEAD_TREE_OID}.ok"
+STATIC_CACHE_KEY="$(printf '%s\n%s\n%s\n' "$HEAD_TREE_OID" "${ADL_REPO_CONTROLS_STATIC_CHECKS?}" "${ADL_REPO_CONTROLS_EXPORT_LINKS:-}" | git hash-object --stdin)"
+STATIC_CACHE="$ROOT/.coverage-cache/pre-push-static/${HEAD_TREE_OID}-${STATIC_CACHE_KEY}.ok"
 if [[ -f "$STATIC_CACHE" ]]; then
   echo "pre-push: reusing static-check pass for tree ${HEAD_TREE_OID}"
 else
@@ -120,32 +118,42 @@ else
   git archive --format=tar -o "$PUSH_ARCHIVE" HEAD
   tar -xf "$PUSH_ARCHIVE" -C "$PUSH_TREE"
   rm -f -- "$PUSH_ARCHIVE"
-  # Untracked paths the export needs, declared by the repository. This was
-  # `ln -s "$ROOT/node_modules"` -- a package that calls itself language
-  # agnostic assuming JavaScript. A Rust repo links `target/`, a Python one its
-  # virtualenv, and a repo with no ecosystem links nothing.
+  # Declared untracked paths the export needs; a missing target fails.
   while IFS= read -r export_link; do
     [[ -n "$export_link" ]] || continue
-    [[ -e "$ROOT/$export_link" ]] || continue
+    if [[ ! -e "$ROOT/$export_link" ]]; then
+      echo "pre-push: FAIL — export_links entry '${export_link}' does not exist in the checkout." >&2
+      exit 1
+    fi
     mkdir -p "$(dirname -- "$PUSH_TREE/$export_link")"
     ln -s "$ROOT/$export_link" "$PUSH_TREE/$export_link"
   done <<<"${ADL_REPO_CONTROLS_EXPORT_LINKS:-}"
 
   static_check_labels=()
-  while IFS=$'\t' read -r static_check_label static_check_command; do
-    [[ -n "$static_check_label" ]] || continue
+  while IFS= read -r static_check_line; do
+    [[ -n "$static_check_line" ]] || continue
+    # Split on the first tab by hand; `read` with a tab IFS collapses a leading tab.
+    static_check_label="${static_check_line%%$'\t'*}"
+    static_check_command=""
+    [[ "$static_check_line" == *$'\t'* ]] && static_check_command="${static_check_line#*$'\t'}"
+    if [[ -z "$static_check_label" ]]; then
+      echo 'pre-push: FAIL — static check has an empty label.' >&2
+      exit 1
+    fi
+    if [[ -z "$static_check_command" ]]; then
+      echo "pre-push: FAIL — static check '${static_check_label}' has an empty command." >&2
+      exit 1
+    fi
     echo "pre-push: ${static_check_label} (HEAD)"
     (cd "$PUSH_TREE" && bash -c "$static_check_command" </dev/null)
     static_check_labels+=("$static_check_label")
   done <<<"${ADL_REPO_CONTROLS_STATIC_CHECKS?}"
-  # The PreToolUse deny corpus is the only thing asserting that destructive
-  # commands stay denied, and nothing else ran it — `git update-ref` sat in
-  # its ALLOW list while being exactly what strands a shared checkout. Cheap
-  # enough to assert on every push.
 
-  mkdir -p "$ROOT/.coverage-cache/pre-push-static"
-  printf '%s\n%s\n' "${static_check_labels[*]}" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" >"$STATIC_CACHE"
-  echo "pre-push: recorded static-check pass for tree ${HEAD_TREE_OID}"
+  if ((${#static_check_labels[@]} > 0)); then
+    mkdir -p "$ROOT/.coverage-cache/pre-push-static"
+    printf '%s\n%s\n' "${static_check_labels[*]}" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" >"$STATIC_CACHE"
+    echo "pre-push: recorded static-check pass for tree ${HEAD_TREE_OID}"
+  fi
 fi
 
 # The outgoing-commit coverage ratchet moved to `coverageRatchetStep` in