fensu-cli 0.5.2__tar.gz → 0.7.0__tar.gz

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/Cargo.lock

@@ -392,7 +392,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "fensu-cli"
-version = "0.5.2"
+version = "0.7.0"
 dependencies = [
  "cap-fs-ext",
  "cap-std",

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fensu-cli
-Version: 0.5.2
+Version: 0.7.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fensu-cli"
-version = "0.5.2" # x-release-please-version
+version = "0.7.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
 publish = false

fensu_cli-0.7.0/crates/fensu-cli/assets/catalogue.json

@@ -0,0 +1 @@
+[{"code":"FFA001","family":"annotations","slug":"parameter-annotation","message":"function parameters must define type annotations","remediation":"Annotate every parameter with the value type accepted by the function.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFA002","family":"annotations","slug":"return-annotation","message":"functions must define return type annotations","remediation":"Declare the returned value type, using None when the function returns no value.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFA101","family":"annotations","slug":"module-variable-annotation","message":"module-level variables must define type annotations","remediation":"Add an explicit annotation to the first module-level assignment.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFA102","family":"annotations","slug":"class-attribute-annotation","message":"class attributes must define type annotations","remediation":"Annotate the class attribute where it is first assigned.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFA103","family":"annotations","slug":"local-variable-annotation","message":"local variables must define type annotations on first binding unless assigned a scalar literal","remediation":"Annotate first bindings whose type is not evident from a number, string, bool, bytes, or f-string literal.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL001","family":"layers","slug":"absolute-imports-only","message":"use absolute imports; relative imports hide package boundaries","remediation":"Replace relative imports with an absolute import path.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL002","family":"layers","slug":"no-star-imports","message":"star imports hide names from dependency-boundary analysis","remediation":"Import each required name explicitly.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL101","family":"layers","slug":"no-sibling-package-internals","message":"subpackage code must not import sibling internals","remediation":"Publish the dependency through the owning sibling's main/ entry or role files.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL102","family":"layers","slug":"no-cross-package-internals","message":"cross-package imports must use public surfaces, not helpers or internals","remediation":"Import from classes, models, types, constants, exceptions, or a thin main/ entry.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL103","family":"layers","slug":"no-internal-public-surface-imports","message":"internal code must import from the owning module, not the bare package","remediation":"Import from the concrete owning module below the package surface.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL104","family":"layers","slug":"no-cross-domain-private-main-imports","message":"domain-private main entries may only be imported within their owning domain","remediation":"Remove the leading underscore to publish the main entry, or route the caller through a public main entry owned by the target domain.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL105","family":"layers","slug":"public-main-entry-external-use","message":"public main entries must have an importer outside their owning domain","remediation":"Prefix the entry module filename with '_' until another domain or tooling imports it.","severity":"error","enabled_by_default":true,"execution_owner":"project"},{"code":"FFL110","family":"layers","slug":"no-cross-file-use-of-helper-private-class","message":"helper-private classes are file-local details; move shared classes to classes/","remediation":"If another module needs this class, move it to the owning classes/ package.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFL301","family":"layers","slug":"no-runtime-imports-from-tooling","message":"runtime code must not import from tooling modules","remediation":"Move reusable logic into the runtime package or keep the dependency inside tooling.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH001","family":"hygiene","slug":"single-line-docstrings","message":"docstrings must be a single line; move extended explanation into docs or tests","remediation":"Keep one concise summary line and move extended rationale into documentation or tests.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH002","family":"hygiene","slug":"no-standalone-comments","message":"standalone comments are not allowed; prefer clear names or docs/tests","remediation":"Replace the comment with clearer names or move lasting explanation into documentation or tests.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH003","family":"hygiene","slug":"no-raw-builtin-raise","message":"runtime code must raise structured errors instead of raw built-in exceptions","remediation":"Raise a domain-specific exception from exceptions.py with a stable actionable message.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH004","family":"hygiene","slug":"no-assert-in-runtime","message":"runtime code must not use assert for invariants; raise a structured error","remediation":"Replace assert with an explicit guard that raises a domain-specific exception.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH005","family":"hygiene","slug":"no-swallowed-exception-probe","message":"runtime code must not swallow broad exceptions as existence probe answers","remediation":"Use an explicit metadata or existence check, or catch only the expected exception and preserve failures.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH006","family":"hygiene","slug":"no-complex-comprehensions-in-tooling","message":"nested or multi-generator comprehensions hide control flow and data shapes","remediation":"Extract a named helper when the transformation has a coherent purpose. For one-off local logic, use simple statements with named intermediate values instead of nested comprehension control flow.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH007","family":"hygiene","slug":"no-unnamed-string-decisions","message":"string literals must not directly control comparison behavior","remediation":"Name the decision value in constants.py or compare against an enum member so the branch expresses the concept it represents.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH008","family":"hygiene","slug":"no-magic-numeric-comparisons","message":"non-canonical numeric literals must not directly control comparisons","remediation":"Name the threshold or sentinel in constants.py and compare against that name; only -1, 0, and 1 are self-explanatory comparison values.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFH009","family":"hygiene","slug":"no-import-time-side-effects","message":"runtime and tooling modules must not execute standalone calls during import","remediation":"Move the operation into an explicit function or assign a pure constructor result.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS001","family":"shape","slug":"too-many-statements","message":"main functions must stay phase-shaped and below the statement limit","remediation":"Extract cohesive phases into helpers that return explicit result models.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS002","family":"shape","slug":"too-many-distinct-calls","message":"main functions must not coordinate too many distinct callees","remediation":"Group related work into named phase helpers and keep main/ as a short ordered flow.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS003","family":"shape","slug":"too-many-locals","message":"main functions must not juggle too many local variables","remediation":"Let each extracted phase own its intermediates and return one structured result.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS010","family":"shape","slug":"max-arguments","message":"functions must stay below the configured argument limit","remediation":"Reduce the function's responsibility or group cohesive inputs into a typed model.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS011","family":"shape","slug":"max-statements-global","message":"functions must stay below the global statement limit","remediation":"Split the function at a meaningful phase boundary with explicit inputs and outputs.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS101","family":"shape","slug":"meaningful-project-result-discarded","message":"main orchestrators must consume meaningful project-local call results","remediation":"Assign, return, or explicitly discard the phase result with _ = call(...).","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS102","family":"shape","slug":"parameter-mutation-in-phase-helpers","message":"helpers must return values instead of mutating parameters","remediation":"Return a new or updated value so dataflow remains visible to the caller.","severity":"error","enabled_by_default":false,"execution_owner":"file"},{"code":"FFS110","family":"shape","slug":"default-mutation-return","message":"functions that mutate parameters must return every mutated parameter","remediation":"Return each mutated parameter explicitly, or avoid parameter mutation and return a new value.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS120","family":"shape","slug":"keyword-only-arguments","message":"functions beyond the parameter threshold must be entirely keyword-only","remediation":"Insert * before the first non-receiver parameter so every call argument names its meaning.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS130","family":"shape","slug":"no-outer-state-mutation","message":"functions must not mutate module-global or closure-captured state","remediation":"Pass state explicitly and return the updated value instead of mutating outer scope.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS131","family":"shape","slug":"no-complex-comprehensions","message":"nested or multi-generator comprehensions hide control flow and data shapes","remediation":"Extract a named helper when the transformation has a coherent purpose. For one-off local logic, use simple statements with named intermediate values instead of nested comprehension control flow.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFS201","family":"shape","slug":"mutable-result-model","message":"dataclass result models must be frozen","remediation":"Declare the shared result model with @dataclass(frozen=True).","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT001","family":"tests","slug":"test-layout","message":"tests must live under a configured test root and supported scope","remediation":"Move the test beneath a configured test root and one of the configured test_scopes.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT002","family":"tests","slug":"test-scope","message":"test scope must be one of the configured test scopes","remediation":"Move the test beneath a configured test root and one of the configured test_scopes.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT003","family":"tests","slug":"test-mirrored-root","message":"test directories must mirror a configured runtime or tooling root","remediation":"Mirror the complete configured source or tooling path beneath the test scope.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT004","family":"tests","slug":"src-mirror-depth","message":"runtime tests must include an area beneath the configured source root","remediation":"Move the test beneath the package and source area it exercises.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT005","family":"tests","slug":"src-package-exists","message":"runtime tests must mirror a configured source package","remediation":"Correct the mirrored package name or move the test to the package it exercises.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT006","family":"tests","slug":"src-area-exists","message":"runtime tests must mirror an existing source package area","remediation":"Correct the mirrored area path so it matches the runtime module location.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT007","family":"tests","slug":"scripts-mirror-depth","message":"tooling tests must include an area beneath the configured tooling root","remediation":"Move the test beneath the configured tooling area it exercises.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT008","family":"tests","slug":"scripts-area-exists","message":"tooling tests must mirror an existing configured tooling area","remediation":"Correct the mirrored area path so it matches the tooling location.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT101","family":"tests","slug":"init-module-empty","message":"test package __init__.py files must be empty or docstring-only","remediation":"Remove runtime declarations from __init__.py and import them from their owning module.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT102","family":"tests","slug":"absolute-imports","message":"tests must use absolute imports","remediation":"Replace the relative import with the full tests or application package path.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT103","family":"tests","slug":"no-top-level-helpers","message":"test modules may contain only tests, imports, and declarations","remediation":"Move reusable functions into the local helpers.py module.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT104","family":"tests","slug":"no-if-in-tests","message":"tests and local test helpers must not contain conditional control flow","remediation":"Use parametrized cases when setup and assertions remain branch-free; otherwise split the behavior into separate test functions. Keep local test helpers deterministic with per-variant functions or dataclass-driven case data.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT105","family":"tests","slug":"private-constant-order","message":"private test constants must appear before test functions","remediation":"Move the private constant above the first test so module setup is visible before behavior.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT106","family":"tests","slug":"no-complex-comprehensions","message":"nested or multi-generator comprehensions hide control flow and data shapes","remediation":"Extract a named helper when the transformation has a coherent purpose. For one-off local logic, use simple statements with named intermediate values instead of nested comprehension control flow.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT201","family":"tests","slug":"test-types-description","message":"test-case dataclasses must define a description field","remediation":"Add description: str so parametrized cases explain the behavior they represent.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT202","family":"tests","slug":"test-types-expected-field","message":"test-case dataclasses must define at least one expected_ field","remediation":"Name expected outcomes with an expected_ prefix and assert against them in the test.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT203","family":"tests","slug":"local-test-types-import","message":"tests must import test-case types from their local _test_types.py","remediation":"Move the dataclass beside the test and import it through the mirrored absolute path.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT204","family":"tests","slug":"local-test-types-file","message":"test directories must provide a local _test_types.py","remediation":"Create _test_types.py beside the test. Custom-rule tests should define a local wrapper dataclass there rather than parametrizing directly with RuleCase.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT301","family":"tests","slug":"test-file-name","message":"test modules must use a test_ filename","remediation":"Rename the module to test_<behavior>.py.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT302","family":"tests","slug":"test-function-name","message":"test functions must use test_given_<state>_when_<action>_then_<outcome>","remediation":"Rename the test so its precondition, action, and expected behavior are explicit.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT401","family":"tests","slug":"dataclass-parametrize","message":"tests must use dataclass-backed pytest parameterization","remediation":"Add @pytest.mark.parametrize with local test_case dataclass instances.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT402","family":"tests","slug":"accepts-test-case","message":"parametrized tests must accept a test_case argument","remediation":"Name the parameter test_case and read inputs and expectations from that object.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT403","family":"tests","slug":"test-case-annotation","message":"test_case parameters must use a local test-case dataclass annotation","remediation":"Annotate test_case with a dataclass imported from the local _test_types.py.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT404","family":"tests","slug":"expected-field-assertion","message":"tests must assert against an expected_ field from test_case","remediation":"Store the expected outcome on test_case and reference it in a behavior assertion.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT405","family":"tests","slug":"parametrize-arguments","message":"pytest parametrize decorators must define parameter names and values","remediation":"Pass both the parameter-name string and the case sequence to parametrize.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT406","family":"tests","slug":"parametrize-test-case","message":"pytest parametrize must expose cases through the test_case parameter","remediation":"Use \"test_case\" as the parametrize parameter name.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT407","family":"tests","slug":"parametrize-ids","message":"pytest parametrize decorators must define readable case ids","remediation":"Set ids to the case descriptions, normally with ids=lambda case: case.description.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT408","family":"tests","slug":"inline-parametrize-values","message":"pytest parametrize values must be a visible list, tuple, or local comprehension","remediation":"Inline the case sequence in @pytest.mark.parametrize so its cases are visible beside the test.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT411","family":"tests","slug":"nonempty-parametrize-values","message":"pytest parametrize case sequences must not be empty","remediation":"Add at least one behavior case or remove the test until a real case exists.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT412","family":"tests","slug":"no-dict-test-cases","message":"pytest cases must use typed dataclasses instead of dictionaries","remediation":"Define a local frozen test-case dataclass and construct one instance per case.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT413","family":"tests","slug":"local-test-case-constructors","message":"pytest cases must construct dataclasses from the local _test_types.py","remediation":"Parametrize using a dataclass imported from local _test_types.py. For framework harness inputs such as RuleCase, store their fields in the local dataclass and construct the framework object inside the test.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFT414","family":"tests","slug":"description-lambda-ids","message":"pytest case ids must come from each test case description","remediation":"Use ids=lambda case: case.description so failures identify the behavior clearly.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR001","family":"roles","slug":"models-only-models","message":"models role files may contain only structured runtime models","remediation":"Move functions and non-model declarations to their owning role module.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR002","family":"roles","slug":"types-only-types","message":"types role files may contain only type-layer declarations","remediation":"Move runtime values and functions out of types.py into their owning runtime role.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR003","family":"roles","slug":"constants-only-constants","message":"constants role files may contain only assignments and imports","remediation":"Move functions and classes out of constants.py into their owning role module.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR004","family":"roles","slug":"exceptions-only-exceptions","message":"exceptions role files may contain only custom exceptions","remediation":"Move non-exception declarations out of exceptions.py into their owning role.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR101","family":"roles","slug":"model-declaration-outside-models","message":"structured runtime models must be defined in the models role","remediation":"Move the dataclass or structured model into models.py or a models/ package.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR102","family":"roles","slug":"type-declaration-outside-types","message":"type-layer declarations must be defined in the types role","remediation":"Move the protocol, enum, TypedDict, or public type alias into types.py.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR103","family":"roles","slug":"constant-outside-constants","message":"public uppercase constants must be defined in the constants role","remediation":"Move the public constant into constants.py and import it from there.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR104","family":"roles","slug":"exception-declaration-outside-exceptions","message":"custom exceptions must be defined in the exceptions role","remediation":"Move the exception class into exceptions.py or an exceptions/ package.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR201","family":"roles","slug":"banned-generic-filename","message":"generic filenames hide module ownership","remediation":"Rename the module after the domain concept or operation it owns.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR202","family":"roles","slug":"helpers-module-name","message":"use an _helpers package instead of helpers.py","remediation":"Replace helpers.py with an _helpers/ package of specifically named modules.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR203","family":"roles","slug":"classes-module-name","message":"use a classes package instead of classes.py","remediation":"Replace classes.py with a classes/ package containing one class per module.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR204","family":"roles","slug":"banned-generic-package-name","message":"runtime package directories must identify an owner","remediation":"Rename the package after the business domain or technical capability it owns.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR205","family":"roles","slug":"helpers-classes-file-private","message":"plain classes in _helpers modules must be file-private","remediation":"Prefix a file-local helper class with _, or move a shared class into classes/.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR301","family":"roles","slug":"helpers-package-layout","message":"_helpers/ packages must use bounded flat-or-grouped containers","remediation":"Keep _helpers/ flat or group every module into bounded shallow buckets; do not mix modules and Python-containing buckets in one container.","severity":"error","enabled_by_default":true,"execution_owner":"package"},{"code":"FFR302","family":"roles","slug":"main-package-layout","message":"main/ packages must use bounded flat-or-grouped orchestration containers","remediation":"Keep main/ flat or group every entry into bounded shallow buckets; do not mix modules and Python-containing buckets in one container.","severity":"error","enabled_by_default":true,"execution_owner":"package"},{"code":"FFR303","family":"roles","slug":"helpers-reserved-role-filenames","message":"_helpers/ packages must not contain reserved role filenames","remediation":"Rename the helper module after its specific operation, or move role-owned declarations to the corresponding sibling models, types, constants, or exceptions role.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR304","family":"roles","slug":"nested-direct-modules","message":"nested runtime packages may contain only role-oriented direct modules","remediation":"Move additional implementation modules under the package's _helpers/ boundary.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR305","family":"roles","slug":"nested-direct-subpackages","message":"nested runtime packages must use explicit role boundaries","remediation":"Move feature subpackages under _helpers/ or use a supported role such as main/ or classes/.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR306","family":"roles","slug":"top-level-domain-shape","message":"top-level domains must be either role leaves or subdomain branches","remediation":"Keep direct role content in a leaf domain, or move it into a named subdomain when the domain contains subdomains.","severity":"error","enabled_by_default":true,"execution_owner":"domain"},{"code":"FFR307","family":"roles","slug":"top-level-direct-modules","message":"top-level domains must not contain ad hoc direct modules","remediation":"Move the module under a direct role boundary or into an owning named subdomain.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR308","family":"roles","slug":"shared-domain-prefix","message":"sibling domains must not encode one parent domain through a shared name prefix","remediation":"Create one parent domain from the shared prefix and move each remaining suffix beneath it as a named subdomain.","severity":"error","enabled_by_default":true,"execution_owner":"scope"},{"code":"FFR309","family":"roles","slug":"leaf-main-boundary","message":"leaf runtime domains and subdomains must expose meaningful behavior through main/","remediation":"Add a focused main/ entry module only when the leaf owns behavior; otherwise move passive declarations into the closest domain or subdomain whose main/ behavior owns and uses them.","severity":"error","enabled_by_default":true,"execution_owner":"leaf"},{"code":"FFR401","family":"roles","slug":"entry-module-shape","message":"main/ entry modules must expose one focused public function","remediation":"Keep only imports, one public entry function, and at most two small private glue functions; move phase logic to _helpers/.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR402","family":"roles","slug":"init-module-empty","message":"nested __init__.py files must be empty or docstring-only","remediation":"Remove runtime declarations and import from the concrete owning module instead.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR403","family":"roles","slug":"no-reexport-shim","message":"internal modules must not exist only to re-export imports","remediation":"Import the implementation module directly or expose a deliberate API through an approved public surface.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR404","family":"roles","slug":"no-internal-helper-exports","message":"_helpers/ modules must not publish an __all__ surface","remediation":"Keep _helpers/ internal and expose public behavior through main/, classes/, models, types, constants, or exceptions.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR405","family":"roles","slug":"main-entry-name-collision","message":"main/ cannot define a module and package with the same entry name","remediation":"Choose either the flat entry module or the same-named package and remove the competing surface.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR406","family":"roles","slug":"public-surface-shape","message":"root package surfaces may contain only imports and one __all__ declaration","remediation":"Move runtime behavior into an owning module and keep the root __init__.py as a deliberate import surface.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR501","family":"roles","slug":"classes-one-class-per-module","message":"classes/ modules must define exactly one top-level class","remediation":"Split additional classes into separately named modules under classes/.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR502","family":"roles","slug":"helpers-package-shape","message":"_helpers/ packages must contain no main.py orchestration entrypoints","remediation":"Move main.py orchestration into the sibling main/ role; helper depth is enforced by FFR301.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR503","family":"roles","slug":"private-definition-ordering","message":"private constants and dataclasses must appear before top-level functions","remediation":"Move private module declarations above the first function so readers see module state before behavior.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR601","family":"roles","slug":"source-file-line-count","message":"source files must stay below the configured line limit","remediation":"Split the file by a cohesive role or concern instead of extracting arbitrary numbered fragments.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR701","family":"roles","slug":"tooling-entrypoint-shape","message":"direct scripts must remain focused command adapters","remediation":"Keep one public main(), optional private _parse_args() and _build_parser(), and move implementation into a scripts/<tool>/main/ entry.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR702","family":"roles","slug":"tooling-entrypoint-delegation","message":"direct scripts must delegate to an imported main/ entrypoint","remediation":"Import a typed entry function from a runtime or scripts/<tool>/main/ module and return its result from main().","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR703","family":"roles","slug":"tooling-entrypoint-line-count","message":"direct scripts must stay below the configured line limit","remediation":"Move command implementation into a named tooling or runtime package.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR704","family":"roles","slug":"rules-role-content","message":"tooling rules/ modules may contain only decorated rule declarations","remediation":"Keep imports and @rule functions here; move supporting implementation into _helpers/, classes/, models.py, types.py, constants.py, or exceptions.py.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR705","family":"roles","slug":"tooling-package-layout","message":"tool packages must organize implementation through explicit roles","remediation":"Use main/, _helpers/, classes/, rules/, models.py, types.py, constants.py, or exceptions.py directly beneath scripts/<tool>/.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR706","family":"roles","slug":"descriptive-rule-module-names","message":"rule module filenames must describe their policy rather than repeat one rule code","remediation":"Rename the module after the policy or rule family it implements, using a name such as conditional_test_flow.py instead of fft104.py.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFR707","family":"roles","slug":"custom-rule-test-coverage","message":"configured custom rules must have statically declared public-harness cases","remediation":"Add statically visible RuleCase construction passed to evaluate_rule for each custom rule. When FFT413 is active, parametrize with a local _test_types.py dataclass and convert it to RuleCase inside the test.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFN001","family":"naming","slug":"validator-must-not-return","message":"functions under no-return naming contracts must not return values","remediation":"Remove the meaningful return and raise on invalid input, or rename a value-producing function as a query such as is_valid or get_validation_result.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFN002","family":"naming","slug":"predicate-must-return-bool","message":"predicate names must declare an ordinary boolean result","remediation":"Return bool (or TypeGuard/TypeIs), or rename the function to describe the value it returns, such as read_status or current_status.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFN003","family":"naming","slug":"value-name-must-return-value","message":"value-producing names must not declare a no-value result","remediation":"Return the queried or converted value, or rename the function to describe its side effect, such as initialize_cache or export_json.","severity":"error","enabled_by_default":true,"execution_owner":"file"},{"code":"FFN004","family":"naming","slug":"iterator-name-must-produce-iterator","message":"iterator names must produce an iterator or generator","remediation":"Return an iterator or generator, or rename an eager collection function with a name such as collect_items.","severity":"error","enabled_by_default":true,"execution_owner":"file"}]

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/command/helpers/memory_execution.rs

@@ -23,7 +23,7 @@ use crate::command::helpers::{
 };
 use crate::command::models::{ColorMode, MemoryCommand, MemoryProject};
 use crate::configuration::main::load;
-use crate::helpers::render;
+use crate::helpers::reporting::render;
 use crate::models::{CliOutput, Fault};
 
 pub(crate) fn execute_memory(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/command/main/check.rs

@@ -1,4 +1,4 @@
-use crate::helpers::check_execution::execute_check;
+use crate::helpers::check::execution::execute_check;
 use crate::models::CliOutput;
 
 pub(crate) fn run(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/command/main/init.rs

@@ -1,4 +1,4 @@
-use crate::helpers::init::run_init;
+use crate::helpers::init::run::run_init;
 use crate::models::CliOutput;
 
 pub(crate) fn init(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/command/main/rule.rs

@@ -1,4 +1,4 @@
-use crate::helpers::rule::rule_output;
+use crate::helpers::catalogue::metadata::rule_output;
 use crate::models::CliOutput;
 
 pub(crate) fn rule(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/command/main/run_cli.rs

@@ -3,7 +3,8 @@ use std::path::Path;
 
 use crate::command::main::{check, help, init, map, memory, rule, skills};
 use crate::configuration::main::custom_rules;
-use crate::helpers::{check_cleanup, process};
+use crate::helpers::check::cleanup;
+use crate::helpers::hosting::process;
 use crate::models::CliOutput;
 
 pub fn run_cli() -> CliOutput {
@@ -40,7 +41,7 @@ fn dispatch(arguments: &[String]) -> Result<CliOutput, String> {
 }
 
 fn dispatch_check(arguments: &[String]) -> Result<CliOutput, String> {
-    let cleanup = check_cleanup::prepare(Path::new("."));
+    let cleanup = cleanup::prepare(Path::new("."));
     let result = if custom_rules::custom_rules_are_configured(Path::new("."))? {
         let exit_code = process::run_custom_check_host(arguments)?;
         Ok(CliOutput {

fensu_cli-0.5.2/crates/fensu-cli/src/skills/helpers/context/exceptions.rs → fensu_cli-0.7.0/crates/fensu-cli/src/configuration/helpers/exception_targets.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
 
@@ -6,22 +6,11 @@ use fensu_facts::parsing::main::parse_strict::parse_strict;
 use ruff_python_ast::visitor::{walk_stmt, Visitor};
 use ruff_python_ast::Stmt;
 
-use crate::helpers::check_policy::python_version;
-use crate::models::{Config, RuleMetadata};
+use crate::helpers::check::policy::python_version;
+use crate::models::Config;
 
-pub(crate) fn validate(
-    config: &Config,
-    catalogue: &[RuleMetadata],
-    project_root: &Path,
-) -> Result<(), String> {
-    let codes = catalogue
-        .iter()
-        .map(|item| item.code.as_str())
-        .collect::<HashSet<_>>();
+pub(crate) fn validate_targets(config: &Config, project_root: &Path) -> Result<(), String> {
     for exception in &config.exceptions {
-        if !codes.contains(exception.rule.as_str()) {
-            return Err(format!("Unknown rule exception code: {}.", exception.rule));
-        }
         let path = project_root.join(&exception.path);
         if !path.is_file() {
             return Err(format!(
@@ -74,7 +63,7 @@ fn defined_symbols(path: &Path) -> Result<HashMap<String, usize>, String> {
     Ok(collector.symbols)
 }
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 struct SymbolCollector {
     owners: Vec<String>,
     symbols: HashMap<String, usize>,
@@ -89,8 +78,8 @@ impl SymbolCollector {
     }
 }
 
-impl<'a> Visitor<'a> for SymbolCollector {
-    fn visit_stmt(&mut self, statement: &'a Stmt) {
+impl<'ast> Visitor<'ast> for SymbolCollector {
+    fn visit_stmt(&mut self, statement: &'ast Stmt) {
         match statement {
             Stmt::FunctionDef(function) => {
                 let symbol = self.qualified(function.name.as_str());

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/configuration/helpers/mod.rs

@@ -1,5 +1,8 @@
 pub(crate) mod discovery;
+pub(crate) mod exception_targets;
 pub(crate) mod exceptions;
 pub(crate) mod loading;
 pub(crate) mod parsing;
+pub(crate) mod roots;
+pub(crate) mod scopes;
 pub(crate) mod validation;

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/configuration/helpers/parsing.rs

@@ -24,6 +24,7 @@ pub(crate) fn build(
     Ok(Config {
         roots,
         tests: strings_or(table.get("tests"), &["tests"]),
+        test_scopes: strings_or(table.get("test_scopes"), &["unit", "integration", "e2e"]),
         tooling: strings(table.get("tooling")),
         select: strings_or(table.get("select"), &["FF"]),
         warn: strings(table.get("warn")),

fensu_cli-0.7.0/crates/fensu-cli/src/configuration/helpers/roots.rs

@@ -0,0 +1,30 @@
+pub(crate) fn validate_nested_roots(roots: Vec<String>) -> Result<(), String> {
+    for (index, first) in roots.iter().enumerate() {
+        let first_parts = first.split('/').collect::<Vec<_>>();
+        for second in roots.iter().skip(index + 1) {
+            let second_parts = second.split('/').collect::<Vec<_>>();
+            let length = first_parts.len().min(second_parts.len());
+            if first_parts[..length] != second_parts[..length] {
+                continue;
+            }
+            return Err(nested_roots_error(
+                first,
+                second,
+                first_parts.len() <= second_parts.len(),
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn nested_roots_error(first: &str, second: &str, first_is_outer: bool) -> String {
+    let (outer, inner) = if first_is_outer {
+        (first, second)
+    } else {
+        (second, first)
+    };
+    if outer == inner {
+        return format!("Config key roots must not contain duplicate paths: {outer:?}.");
+    }
+    format!("Config key roots must not contain nested paths: {outer:?} contains {inner:?}.")
+}

fensu_cli-0.7.0/crates/fensu-cli/src/configuration/helpers/scopes.rs

@@ -0,0 +1,34 @@
+use std::collections::HashSet;
+
+use crate::configuration::helpers::validation::required_strings;
+
+pub(crate) fn validate_test_scopes(value: Option<&toml::Value>) -> Result<(), String> {
+    let Some(value) = value else {
+        return Ok(());
+    };
+    let scopes = required_strings(Some(value), "test_scopes")?;
+    if scopes.is_empty() {
+        return Err("Config key test_scopes must not be empty.".to_owned());
+    }
+    if scopes.iter().collect::<HashSet<_>>().len() != scopes.len() {
+        return Err("Config key test_scopes must not contain duplicates.".to_owned());
+    }
+    for scope in &scopes {
+        if !valid_test_scope(scope) {
+            return Err(format!(
+                "Config key test_scopes must contain single lowercase path segments: {scope:?}."
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn valid_test_scope(scope: &str) -> bool {
+    let bytes = scope.as_bytes();
+    !scope.is_empty()
+        && bytes[0].is_ascii_lowercase()
+        && !scope.ends_with(['_', '-'])
+        && bytes.iter().all(|byte| {
+            byte.is_ascii_lowercase() || byte.is_ascii_digit() || *byte == b'_' || *byte == b'-'
+        })
+}

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/configuration/helpers/validation.rs

@@ -1,6 +1,8 @@
 use std::collections::HashSet;
 
 use crate::configuration::helpers::exceptions;
+use crate::configuration::helpers::roots::validate_nested_roots;
+use crate::configuration::helpers::scopes::validate_test_scopes;
 use crate::constants::{
     CONFIG_ROLE_NAMES, CONTRACT_BEHAVIORS, DEFAULT_THRESHOLDS, MAX_CORE_SELECTOR_SUFFIX,
 };
@@ -13,6 +15,7 @@ pub(crate) fn validate(table: &toml::map::Map<String, toml::Value>) -> Result<()
         &[
             "roots",
             "tests",
+            "test_scopes",
             "tooling",
             "select",
             "warn",
@@ -39,6 +42,7 @@ pub(crate) fn validate(table: &toml::map::Map<String, toml::Value>) -> Result<()
     validate_optional_table(table, "evaluation", &["include", "exclude"])?;
     validate_optional_table(table, "skills", &["name"])?;
     validate_rule_options(table.get("rule_options"))?;
+    validate_test_scopes(table.get("test_scopes"))?;
     for name in [
         "tests",
         "tooling",
@@ -78,20 +82,6 @@ fn validate_rule_options(value: Option<&toml::Value>) -> Result<(), String> {
     Ok(())
 }
 
-fn validate_nested_roots(roots: Vec<String>) -> Result<(), String> {
-    for (index, first) in roots.iter().enumerate() {
-        let first = first.split('/').collect::<Vec<_>>();
-        for second in roots.iter().skip(index + 1) {
-            let second = second.split('/').collect::<Vec<_>>();
-            let length = first.len().min(second.len());
-            if first[..length] == second[..length] {
-                return Err("Config key roots must not contain nested paths.".to_owned());
-            }
-        }
-    }
-    Ok(())
-}
-
 fn validate_boolean_table(
     table: &toml::map::Map<String, toml::Value>,
     name: &str,

{fensu_cli-0.5.2 → fensu_cli-0.7.0}/crates/fensu-cli/src/configuration/main/mod.rs

@@ -1,3 +1,5 @@
 pub(crate) mod custom_rules;
 pub(crate) mod load;
 pub(crate) mod load_optional;
+pub(crate) mod validate_document;
+pub(crate) mod validate_exception_targets;

fensu_cli-0.7.0/crates/fensu-cli/src/configuration/main/validate_document.rs

@@ -0,0 +1,10 @@
+use crate::configuration::helpers::validation;
+
+pub(crate) fn validate_document(text: &str) -> Result<(), String> {
+    let document = toml::from_slice::<toml::Value>(text.as_bytes())
+        .map_err(|error| format!("Configuration is not valid TOML: {error}"))?;
+    let table = document
+        .as_table()
+        .ok_or_else(|| "Configuration did not contain a TOML table.".to_owned())?;
+    validation::validate(table)
+}

fensu_cli-0.7.0/crates/fensu-cli/src/configuration/main/validate_exception_targets.rs

@@ -0,0 +1,11 @@
+use std::path::Path;
+
+use crate::configuration::helpers::exception_targets;
+use crate::models::Config;
+
+pub(crate) fn validate_exception_targets(
+    config: &Config,
+    project_root: &Path,
+) -> Result<(), String> {
+    exception_targets::validate_targets(config, project_root)
+}

fensu_cli-0.7.0/crates/fensu-cli/src/helpers/catalogue/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod metadata;

fensu_cli-0.5.2/crates/fensu-cli/src/helpers/check_evaluation.rs → fensu_cli-0.7.0/crates/fensu-cli/src/helpers/check/evaluation.rs

@@ -9,12 +9,14 @@ use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIter
 use crate::constants::{
     OWNER_FILE, OWNER_PACKAGE, ROLE_HELPERS, ROLE_MAIN, SCOPE_TEST, SUFFIX_INIT,
 };
-use crate::helpers::check_policy::{
-    apply_exceptions, apply_rule_ignores, is_entry_module, is_main_module, program,
-    resolved_thresholds, role, scope_roots, source_module_name,
+use crate::helpers::catalogue::metadata;
+use crate::helpers::check::exceptions::apply_exceptions;
+use crate::helpers::check::policy::{
+    apply_rule_ignores, is_entry_module, is_main_module, program, resolved_thresholds, role,
+    scope_roots, source_module_name,
 };
-use crate::helpers::check_project::{observe, project_plane};
-use crate::helpers::{render, rule};
+use crate::helpers::check::project::{observe, project_plane};
+use crate::helpers::reporting::render;
 use crate::models::{Config, Fault, RuleMetadata, ScopedSource};
 
 pub(crate) fn evaluate_and_render(
@@ -33,6 +35,10 @@ pub(crate) fn evaluate_and_render(
     };
     let mut all_rules = blocking.clone();
     all_rules.extend(warning_rules.iter().copied());
+    let evaluated_codes = all_rules
+        .iter()
+        .map(|rule| rule.code.as_str())
+        .collect::<HashSet<_>>();
     let codes_by_source = owner_plan(sources, &all_rules);
     let project = project_plane(root, config, sources)?;
     let program_by_path = sources
@@ -75,6 +81,7 @@ pub(crate) fn evaluate_and_render(
                     .map(|name| name.to_string_lossy().into_owned())
                     .collect(),
                 scope_roots: scope_roots(config),
+                test_scopes: config.test_scopes.clone(),
                 observations: HashMap::new(),
                 custom_registrations: Vec::new(),
                 repo_root: root.to_string_lossy().into_owned(),
@@ -86,7 +93,7 @@ pub(crate) fn evaluate_and_render(
             let faults = rows
                 .into_iter()
                 .map(|row| {
-                    let metadata = rule::rule(&row.code)
+                    let metadata = metadata::rule(&row.code)
                         .ok_or_else(|| format!("Unknown native rule code: {}", row.code))?;
                     let path = row.path.unwrap_or_else(|| source.repository_path.clone());
                     Ok(Fault {
@@ -124,7 +131,7 @@ pub(crate) fn evaluate_and_render(
     });
     uses.sort();
     uses.dedup();
-    let (faults, applied) = apply_exceptions(faults, config)?;
+    let (faults, applied) = apply_exceptions(faults, sources, root, &evaluated_codes, config)?;
     let faults = apply_rule_ignores(faults, root, config);
     let blocking_faults = faults
         .iter()
@@ -162,7 +169,8 @@ fn native_rule_options(
 ) -> Result<HashMap<String, HashMap<String, String>>, String> {
     let mut by_code = HashMap::new();
     for code in codes {
-        let rule = rule::rule(code).ok_or_else(|| format!("Unknown native rule code: {code}"))?;
+        let rule =
+            metadata::rule(code).ok_or_else(|| format!("Unknown native rule code: {code}"))?;
         let mut values = HashMap::new();
         for option in &rule.options {
             values.insert(
@@ -178,7 +186,7 @@ fn native_rule_options(
 }
 
 pub(crate) fn selected_rules(select: &[String], ignore: &[String]) -> Vec<&'static RuleMetadata> {
-    rule::catalogue()
+    metadata::catalogue()
         .iter()
         .filter(|rule| {
             let selected = select

fensu_cli-0.7.0/crates/fensu-cli/src/helpers/check/exceptions.rs

@@ -0,0 +1,114 @@
+use std::collections::{HashMap, HashSet};
+use std::path::Path;
+
+use crate::models::{Config, Fault, RuleException, ScopedSource};
+
+type ExceptionKey = (String, String, Option<String>);
+
+pub(crate) fn apply_exceptions(
+    faults: Vec<Fault>,
+    sources: &[ScopedSource],
+    root: &Path,
+    evaluated_codes: &HashSet<&str>,
+    config: &Config,
+) -> Result<(Vec<Fault>, usize), String> {
+    if config.exceptions.is_empty() {
+        return Ok((faults, 0));
+    }
+    let source_by_path = sources
+        .iter()
+        .map(|source| (source.repository_path.as_str(), source))
+        .collect::<HashMap<_, _>>();
+    let mut applied: HashSet<ExceptionKey> = HashSet::new();
+    let retained = faults
+        .into_iter()
+        .filter(|fault| {
+            let reported = repository_path(&fault.path, root);
+            let mut owner: Option<Option<String>> = None;
+            let matching = config.exceptions.iter().find(|entry| {
+                if entry.rule != fault.code || entry.path != reported {
+                    return false;
+                }
+                if entry.symbols.is_empty() {
+                    return true;
+                }
+                let resolved = owner.get_or_insert_with(|| {
+                    source_by_path
+                        .get(reported.as_str())
+                        .and_then(|source| fault_owner(fault, source))
+                });
+                resolved
+                    .as_deref()
+                    .is_some_and(|symbol| entry.symbols.iter().any(|item| item == symbol))
+            });
+            match matching {
+                Some(entry) => {
+                    let symbol = match entry.symbols.is_empty() {
+                        true => None,
+                        false => owner.clone().flatten(),
+                    };
+                    applied.insert((entry.rule.clone(), entry.path.clone(), symbol));
+                    false
+                }
+                None => true,
+            }
+        })
+        .collect::<Vec<_>>();
+    if let Some(message) = stale_exception(config, evaluated_codes, &applied) {
+        return Err(message);
+    }
+    Ok((retained, applied.len()))
+}
+
+fn repository_path(reported: &str, root: &Path) -> String {
+    let candidate = Path::new(reported);
+    candidate
+        .strip_prefix(root)
+        .unwrap_or(candidate)
+        .to_string_lossy()
+        .replace('\\', "/")
+        .trim_start_matches('/')
+        .to_owned()
+}
+
+fn stale_exception(
+    config: &Config,
+    evaluated_codes: &HashSet<&str>,
+    applied: &HashSet<ExceptionKey>,
+) -> Option<String> {
+    for entry in &config.exceptions {
+        if !evaluated_codes.contains(entry.rule.as_str()) {
+            continue;
+        }
+        for symbol in configured_symbols(entry) {
+            let key = (entry.rule.clone(), entry.path.clone(), symbol.clone());
+            if applied.contains(&key) {
+                continue;
+            }
+            let suffix = symbol.map_or_else(String::new, |value| format!("::{value}"));
+            return Some(format!(
+                "Rule exception no longer matches a fault: {} {}{suffix}. Remove it or update its scope. Reason: {}",
+                entry.rule, entry.path, entry.reason
+            ));
+        }
+    }
+    None
+}
+
+fn configured_symbols(entry: &RuleException) -> Vec<Option<String>> {
+    if entry.symbols.is_empty() {
+        return vec![None];
+    }
+    entry
+        .symbols
+        .iter()
+        .map(|symbol| Some(symbol.clone()))
+        .collect()
+}
+
+fn fault_owner(fault: &Fault, source: &ScopedSource) -> Option<String> {
+    source
+        .program
+        .as_ref()?
+        .owner_symbol_at(fault.line?, fault.column.unwrap_or(0))
+}