Deterministic library modules for the /assess engine. No LLM calls anywhere in this\npackage - every function is a pure transform of filesystem, git, or pre-computed signal\ndata. The LLM reads run-context.json after the core finishes; it does not call into\nthese modules.
assess_core.py is the orchestrator. It imports from almost every module here, calls\neach one in sequence, and assembles the results into run-context.json. When the\norchestrator grows a new signal, reorganizes the context schema, or changes what data\nblocks it needs, the lib modules that supply that data move in the same commit. This\nis cohesion by design: the lib modules exist to serve the orchestrator's data contract,\nso their shape is coupled to it by construction.
Two modules are the identified co-change hotspots in the git history:
\ndoc_graph.py - the foundation for Layer 0 navigability. Both doc_staleness.py\nand the understanding analysis in keyhole_signals.py depend on its doc->code\nassociation edges. When the core adds a navigability signal or changes how it\nrepresents doc reachability, doc_graph.py is the first file that moves.
keyhole_signals.py - the integration barrier between the individual signal\nmodules and the orchestrator. It assembles all five run-context blocks\n(behaviour, documentation, understanding, runtime, structure) and emits\nthe six named derived findings. Because it touches every upstream signal, it\nco-changes with the core on almost every schema or signal-set change.
Seeing these two files in the same commit as assess_core.py is expected, not a\ndefect. If the core is later decomposed, treat this seam as the natural boundary -\ndoc_graph and keyhole_signals are where the cut-line already lives.
/assess's own hotspot scan flags several directories as historically co-changing:\nskills/assess/scripts, skills/assess/scripts/lib, skills/assess/tests,\nskills/assess/tests/fixtures, and scripts (+ scripts/tests). That is the static\nimport map saying \"separate directories\" while git says \"they move together.\" Here the\ncoupling is genuine subsystem cohesion, and naming it is the point - so a reader (or an\nagent) trusts the boundary deliberately rather than being surprised by the seam:
scripts/lib modules <-> skills/assess/tests. Each deterministic module is\npinned by a test in skills/assess/tests/, and the contract in CLAUDE.md is explicit\n(\"Add a test alongside any change to a deterministic module\"). So a module and its test\nare meant to move in the same commit - the test is the module's behavioural contract,\nnot a separable concern. A reviewer seeing doc_graph.py and test_doc_graph.py in one\ndiff is seeing the intended unit of change.scripts/ (standalone build) <-> skills/. The standalone-skill build under\nscripts/ vendors and transforms the very skills it packages, so a change to a skill's\nshape and the build that ships it co-change by construction. That seam is documented in\nCLAUDE.md's \"Standalone skill pipeline\" section; it is cohesion between a packager and\nthe thing it packages, not a leak.None of these is a refactor task. They are recorded here so the seam is owned: if any is\never cut, this note is where the intended boundary is written down.
\ngit_churn.py\nShared git-churn machinery: per-file commit counts over a configurable window, plus\ngit_commit_info for snapshotting the exact SHA and timestamp at run time. Used by the\ncode heatmap, the doc-staleness heatmap, and doc_staleness.py - churn is computed\none way, not three. Pure subprocess + stdlib, no heavy dependencies.
change_coupling.py\nThree signals derived from git log:
All results are JSON-serialisable so assess_core can drop them straight into\nrun-context.json.
structure_graph.py\nPython import-graph analysis (Signals A1-A4) via grimp + networkx:
Degrades to available: False when grimp/networkx are absent rather than\nblocking the run.
doc_graph.py (co-change hotspot)\nDoc link-graph for Layer 0 navigability. Parses [[wikilinks]] and\n[text](relative/path) links, resolves them to real files, and builds a directed\ngraph. Derives PageRank centrality, orphan rate, connectivity, MOC validation, and\ndoc->code association edges. The doc->code edges are reused by doc_staleness.py and\nunderstanding_analysis.py, making this module a shared dependency for the document\nanalysis layer. Folds in vault-native navigation edges from vault_queries.py (.base\nhubs become entry nodes; dataview query blocks emit edges from their declaring note),\nso a vault navigated by dynamic queries doesn't score as orphaned. doc-graph-svg.py\nrenders this exact graph, so the two artifacts always agree. Obsidian-vault detection\n(_vault_detected) walks the repo subtree, pruning EXCLUDE_DIRS, to find a .obsidian/\ndirectory anywhere under repo_root, not just at the root - a vault kept as a subdirectory\n(repo/notes/.obsidian/) sits below the git rev-parse --show-toplevel scan target and was\npreviously reported as no vault, silently disabling downstream vault accommodations (#179).\nPruning EXCLUDE_DIRS keeps a vendored or build-artifact .obsidian/ from tripping a false\npositive.
raw_source.py\nRaw-source subtree detection (issue #225). Threshold-based, IO-free classifier:\ngiven per-doc graph signals (in/out degree + a machine-extraction-link count), it\nidentifies maximal directory subtrees that are large, almost entirely\nlink-isolated, and carry the machine-extraction fingerprint - a dump of raw,\nmachine-extracted source documents (a disclosure / SAR export of converted\n.msg/.pdf files). doc_graph.py gathers the signals from the link graph it\nalready builds and excludes the qualifying subtrees from the headline read-side\nmetrics (orphan rate, reachability, broken links), reporting them separately so\nthe curated-wiki signal isn't drowned. Pure - no doc_graph import - so\ndoc_graph.py owns the graph and consumes this module's verdict. Co-changes with\ndoc_graph.py (its consumer) and its test tests/test_raw_source.py.
vault_queries.py\nStatic parser for Obsidian dynamic-navigation hubs: .base view files and\ndataview query blocks. Resolves the folder / tag / frontmatter-field\npredicates it can evaluate from the committed files alone (no running Obsidian) into the\nset of notes a hub surfaces. Pure - no filesystem walk, no doc_graph import - so\ndoc_graph.py owns discovery/excludes and consumes this module's parse + selection. Add\na fixture-backed test here alongside any predicate change.
doc_staleness.py\nDoc-staleness metric for Layer 0. Associates each doc with the code it describes via\nnearest-ancestor base-doc rules, computes code churn relative to doc maintenance, and\nemits a signed ratio (high = decaying map). The association logic reuses doc_graph's\ncode-link edges. For generated docs it reads doc_provenance (per-doc and via the\n[[generated]] config map) and replaces the churn ratio with a source-vs-doc verdict.
doc_provenance.py\nProvenance-aware staleness for generated docs (issue #178). Parses a doc's YAML\nfrontmatter source: / generated_by: (no YAML dependency - a minimal stdlib parser),\nresolves the [[generated]] folder->source config mapping, and computes source_newer\n(is any declared source's last change - git commit time, else mtime - more recent than\nthe doc?). doc_staleness.py carries that verdict and doc_complexity_join.py signs\nfreshness from it, so an accurate generated doc is never a lying_map. Co-changes with\ndoc_staleness.py (its consumer) and its test tests/test_doc_provenance.py.
doc_complexity_join.py\nSignal C: crosses the complexity treemap against doc staleness to produce a signed\ndoc_value per unit. Positive = the doc relieves load on the agent's context window;\nnegative = the doc is a lying map over complex code (worse than no doc). The join\nmultiplies complexity by a signed freshness score so trivial code generates near-zero\nsignal regardless of doc state. When a doc carries a doc_provenance verdict, freshness\ncomes from the source-vs-doc comparison (a direct, high-confidence signal that bypasses\nthe churn-ratio confidence guards) instead of the ratio.
ownership_parser.py\nParse half for Layer 0 structure-drift. Ownership is declared in two places an LLM\ncontributor reads as authoritative boundaries: a GitHub CODEOWNERS (glob -> owner,\nhonoured at the root, .github/, or docs/ by GitHub's precedence) and a\nboundary-declaring ARCHITECTURE.md / DESIGN.md - or a seam-mapping README.md\nadmitted only when its prose carries the ownership/seam vocabulary, so a generic project\nREADME is skipped. parse_codeowners resolves each glob against the git-tracked,\nnon-excluded file set into {glob_pattern: {matched_files}}; parse_architecture_md\nsections each doc by markdown header and attributes the path references in a section's\nbody (read from inline code, wikilinks, and bare prose paths) to the module the header\nnames, keyed <doc>::<header> so two docs declaring the same section don't collide, and\nkeeping only references that resolve to real files. find_empty_globs flags the CODEOWNERS\npatterns that match zero tracked files - the cheapest drift, a boundary the filesystem has\nleft behind - and parse_ownership runs both with the module-shape degradation contract\n(available: False, reason \"no ownership map\" when neither map exists). It mirrors\ndoc_graph.py deliberately: the same EXCLUDE_DIRS / is_excluded_path resolution and\ntracked_files filtering, the same honest-degrade-over-crash shape, every collection\nsorted at the boundary for byte-identical output. The one inversion is that it reads\ninline-code path spans (a path written as code is the boundary declaration we want) where\nthe doc graph strips them. This is the parsing foundation the structure-drift signals\nconsume; it owns no drift logic itself.
structure_drift.py\nThe Layer 0 structure-drift signal, built entirely on ownership_parser's parse + resolve\nprimitives (it re-implements no parsing). A declaration is a self-description under no\npressure to stay true: a directory is renamed, a module's files scatter, a pattern is\ntypo'd - and the map becomes a lying map of ownership, the same defect as a stale doc\n(behaviour) or an aged TODO (intent). Tier 0 - detect_path_existence_drift() - is the\nzero-threshold cut: the enumerate-both-sides shape doc_graph.py uses for broken links,\nwhere side A is every declared boundary (CODEOWNERS globs + architecture-doc path\nreferences) and side B the tracked, non-excluded file set, and the finding is the\ndeclarations whose match set is empty. Binary, no statistics; a pattern matching only\nexcluded files counts as empty (the excludes are not part of the navigable repo). It emits\na JSON-serialisable structure_drift run-context block (empty_ownership_patterns, a\ncoverage ratio, and legacy-shape empty_globs mirrors for the orchestrator's\nenumerate-both-sides view), degrades to available: False reason \"no ownership map\", and\nsorts every list by (pattern, declared_in). Tier 1 - detect_grouping_disagreement() -\nis the next cut up: not \"does the boundary still match any file?\" but \"do the files a\nboundary groups still belong together?\". Three lenses each induce a grouping - the declared\none (an owner / architecture module groups its files), the static one (an import-graph\ncommunity groups co-dependent modules), and the historical one (files that keep co-changing).\nA grouping is reported as its co-membership equivalence relation over canonical file-pairs\n(min(a, b), max(a, b)), so disagreement is set algebra over pairs and invariant to\ncommunity relabeling by construction - relabel or reorder the groups and nothing changes,\nbecause the relation carries pairs, never labels. The six metrics are set differences /\nintersections of the three relations (human-vs-static splits/fuses, human-vs-cochange, and\nthe two agreement sets). Known-good architectural seams (the lib<->tests and standalone-build\n<->skills seams documented above) are an allowlist subtracted from the denominator - correct\nby construction, a seam can only suppress an owned boundary, never manufacture drift. Tier 1\ndegrades to available: False reason \"no ownership map\" and emits its own tier_1_available\nfield. keyhole_signals.py orchestrates Tier 1 (feeding it the behaviour block's already-parsed\nco-change pairs) and folds the hidden-seam direction (human_split_but_cochange) into the\nexisting hidden_coupling finding - a recurring directory pair, not the version hot-file's\nrepo-wide couplings; assess_core.py serialises the Tier 0 + Tier 1 result into the\nstructure_drift run-context block. Co-changes with ownership_parser.py (its parse foundation),\nstructure_graph.py and change_coupling.py (the static and historical lenses it consumes),\nkeyhole_signals.py / assess_core.py (its orchestrator and serialiser), and its test\ntests/test_structure_drift.py.
keyhole_signals.py (co-change hotspot)\nIntegration barrier between the individual signal modules and assess_core. Derives\nthe per-directory containment view from the commit-file sets the orchestrator parses\nonce and passes in, then assembles all five run-context blocks from the upstream signal\noutputs. Emits the named derived findings as a fixed-order structured array (the single\nsource of order is FINDING_ORDER): hidden_coupling, lying_map,\nunexplained_complexity, untrusted_hotspot, self_referential_tests,\nunactioned_intent, accretion_ratchet, orphaned_understanding,\ncandidate_dead_weight, override_contradicts_signals (archetype marker disagrees with\nthe deterministic signals - fed the archetype block), and the one positive\nrefactor_boundary last. After assembly apply_config_excludes drops any finding path a\nuser config exclude (exclude_dirs/exclude_patterns) covers - the git-log-derived\nfindings never saw the scan-level filter - and returns the dropped paths as\nexcluded_finding_paths so assess_core can serialise the excluded_by_config\ndisclosure (a suppressed finding is counted and named, never silently vanished). Each\nblock build is wrapped in a catch-all so one signal's failure degrades that block to\navailable: False rather than crashing the run. It also runs structure_drift.py's Tier 1\ngrouping disagreement (fed the behaviour block's co-change pairs so no second git-log parse\nhappens) and folds its hidden-seam direction into the hidden_coupling finding, returning the\nTier 1 result for assess_core to serialise into the structure_drift run-context block - so\nstructure-drift findings flow through this barrier rather than being assembled in the orchestrator.
coupling_analysis.py\nB3 static-vs-historical disagreement cross: compares the import-graph view\n(structure_graph) against the commit-history view (change_coupling) to surface\nhidden coupling (looks modular, bleeds historically), bleeding modules (no static graph\navailable), and refactor boundaries (high containment + low external coupling, a safe\nzone for keyhole edits). Looks-coupled-but-never-co-changes is suppressed - the static\ngraph already surfaces it.
understanding_analysis.py\nSignals B4 + D2. Per module: human anchor (has a confirmed human authored it?), intent\nsource (is there an externalised spec/doc?), authorship class, and the velocity clock\n(days since the last comprehension event - a human-authored commit - rather than\ncalendar age). Primary finding: orphaned understanding - high complexity with no human\nanchor and no externalised spec. Reuses change_coupling.authorship_analysis so the\nconservative agent/human classification is defined one way.
assess_config.py\nReads the optional per-repo .assess/config.toml: exclude_dirs / exclude_patterns\n(the same two lists feed every scan - heatmap, doc graph, staleness, liveness - so\nexclusion is consistent), the [gate] and [structure] sections, and the [[generated]]\nfolder->source provenance map (issue #178) consumed by doc_provenance.py. resolve_excludes\nis the single shared path that combines config excludes with CLI --exclude; both the treemap\nCLI and doc-graph-svg.py call it, so every artifact computes over the identical doc/code set.\nDegrades silently on missing or malformed config rather than blocking the run.
wiki_writer.py\nRenders and writes the .assess/ wiki files (index.md, log.md,\nhotspots/*.md) from string templates. No LLM calls. Pure string formatting + file IO.\nAn optional run_id/schema_version prepends a non-rendering HTML-comment\nprovenance stamp to each file (omitted -> byte-identical legacy output).\nAlso guards wiki integrity: prune_orphan_hotspots(assess_dir, repo_root) stamps\nany hotspot page whose source file left the tree as retired - file deleted\n(history preserved, no active page lies about a live file); append_log_entry\nchains each log.md entry with a <!-- chain:<hash> --> marker and\nverify_log_chain(assess_dir) returns (valid, broken_at_entry) so a later edit\nof a prior entry is detected and disclosed. Both are additive and back-compat -\na legacy wiki (no markers, live files) is untouched and reads valid.
treemap_render.py\nShared treemap layout and SVG primitives for the code heatmap and the doc-staleness\nheatmap. Pulls matplotlib, squarify, and numpy. Must not be imported by the\ndeterministic core (which runs with networkx alone) - only by the treemap scripts.
ci_workflow.py\nRenders the frozen-harness GitHub Action from templates/assess-gate.yml.template\nusing string.Template. Bakes in the toolchain discovered during the current run so\nthe workflow is a reproducible contract, not a norm. The emitted workflow pins its\nsupply chain (actions to commit SHAs, tools to exact releases) and degrades infra\nfailures - toolkit fetch, tool installs, uv setup - to a skip notice so the gate's\nwarn-only contract survives a flaky network or a missing tag.
stats_diff.py\nCompares current complexity stats against a prior run and classifies hotspot\ntransitions: graduated (was in top list, now absent), regressed (worsened), new, and\npersistent. Pure set operations + arithmetic, no LLM.
agent_instructions_grader.py\nHeuristic scoring of agent instruction files (CLAUDE.md, AGENTS.md, GEMINI.md,\n.cursorrules, .github/copilot-instructions.md) on signals that correlate with LLM\nusefulness: positive directives, tradeoff phrases, path references, verifiable\noutcomes, and freshness. Pure regex + arithmetic, filename-agnostic.
liveness_scan.py\nLayer 1 liveness inputs, three tiers:
jvm_capabilities.py to detect JVM/Maven build\nsystems and report, per analysis capability, whether a serving tool is already\nconfigured, could be run/installed in-session, or honest-degrades with a named\ncandidate. Surfaced so a non-enumerated ecosystem proposes a tool rather than\nsilently reading \"absent\".jvm_capabilities.py\nJVM/Maven capability-driven analysis offers (issue #113, v1 bounded). Generalises\n/assess's tool mapping from a hardcoded per-language allowlist (vulture for Python,\nts-prune for TS, staticcheck for Go) to a capability-driven detect-or-propose model,\nproven on one capability (liveness) in one build system (Maven). Reports each capability\nin one of four states - served, offer (with a run-or-install consent shape),\ncredited (a configured pom.xml plugin already serves it), or honest_degrade (nothing\nserves it yet; the report names the capability and a candidate tool). Imported by\nliveness_scan.py, never by the orchestrator - it is an inward dependency of the\nliveness tier.
promissory_markers.py\nWrite-side erosion instrument: detects the four families of promissory markers\n(TODO/FIXME, deprecations, lint suppressions, disabled tests) via one rg pass per\nfamily, then ages each marker by survived touches - the number of commits to its\nfile since the marker's introducing commit (batched git blame + one git-log\npass). A marker that survived many edits to an actively-maintained file is\nunactioned intent; calendar age alone can't tell that from dormancy. Classifies\nmarkers as tracked (issue/ticket/URL/date reference, or a justified suppression)\nvs bare, and each introducing commit as agent/human (reusing change_coupling's\nconservative B4 identity rules). Honours the shared excludes and the generated-file\nfilter (codegen ignore_for_file boilerplate is not debt), and degrades aging to\naging_reliable: False on degenerate history (same verdict as git_churn).\nFeeds the unactioned_intent derived finding, the hotspot pages' marker-debt\nsentence, and the Layer 3/5/8 erosion rules. New ecosystem marker syntaxes need a\nfixture in tests/test_promissory_markers.py - absence is a silent miss.
agent_ops.py\nLayer 8 workflow-maturity evidence: scans the repo-observable agent-operations\nguardrails - .claude/settings.json / .claude/settings.local.json permission\nallow/deny/ask counts, hook events, sandbox config; scripts under\n.claude/hooks/; routine definitions under .claude/workflows/ /\n.claude/routines/. Summary booleans (permissions_encoded, hooks_present,\nroutines_present) credit git-tracked evidence only, mirroring the Layer 0\nrule (an uncommitted settings file reaches no clone). Deliberately excludes\n.claude/agents/ and .claude/skills/ - those are Layer 0's evidence - so the\ntwo layers never double-count. Pure stdlib JSON/filesystem reads plus\ngit_churn.tracked_files.
accretion_ratchet.py\nWrite-side accretion instrument: detects files that only ever grow. Walks each\nfile's full numstat history in author-time order (one git log --no-merges --no-renames --numstat pass, sorted explicitly by %at then SHA so the\naccumulation order is clone-independent) and flags a file when its running\nnet-delta is non-decreasing and its deletion fraction (deletions over total\nchurn) stays below a threshold - growth with almost no deletion pressure, the\nfingerprint of pure append-only accretion rather than ordinary maintenance. A\nmulti-commit gate drops single-touch rename artifacts; binary files (numstat\n-) are skipped. Compensates the Accretion contributor tendency named in the\nrepo north star. Degrades to available: False on git failure and\nreliable: False on degenerate history (same verdict as git_churn). Reuses\ngit_churn's GIT_TIMEOUT_SECONDS and churn_is_degenerate; imports no\norchestrator. Add a fixture-backed test in tests/test_accretion_ratchet.py\nalongside any change to the flagging rule.
archetype.py\nRepository archetype detection (issue #224). Classifies a repo as software or\nknowledge-base from the code-file ratio + the absence of a runtime surface\n(package.json/pyproject.toml/go.mod/Dockerfile/...), with an\nassess-archetype: marker in any instruction file that forces or suppresses\nthe verdict. A knowledge base has no code surface for the write-side layers, so\nthe block names L2-L7 as na_layers (rendered N/A, excluded from the\ndenominator) and renormalises the denominator over the applicable layers (L0,\nL1, L8 → 3). Also detects the Karpathy LLM-wiki maintenance pattern\n(kb_maintenance - immutable sources, schema-as-product, ingest, query-as-filing,\nperiodic consolidation) as a Layer 0 read-side signal and always carries the\ngist pointer. When an assess-archetype: marker forces a classification the\ndeterministic signals disagree with, the override still wins but the block sets\noverride_contradicts_signals + contradiction_details (and records the marker's\noverride_source file) so keyhole_signals can fire the visible\noverride_contradicts_signals finding rather than swallowing the override\nsilently. The IO-free classify_archetype is the tested core; analyze_archetype\ngathers the inputs. Imports doc_graph (extensions) and git_churn\n(tracked_files), never an orchestrator. Structured as an extensible dispatch\n(one archetype today, YAGNI on a general framework). Read by assess_core\n(writes the archetype block to run-context.json), the assess-layer-scorer\nagent (N/A scoring + denominator), and the assess-findings skill (renders N/A
badge.py/assess_finalize.py (the\ndenominator) and its test tests/test_archetype.py.badge.py\nShields.io endpoint badge for the wiki (.assess/badge.json). The shipped badge\nis deterministic by default: assess_core always writes the findings-count form\n(fallback_badge, \"2 findings · 0 stale markers\", colour banded from the counts)\nand stamps a link to assess-report.md, so a badge-clicker lands on the full\nreport. The LLM-derived headline (score_badge, \"7.0/8 · AI-Native\",\nrenormalised over its denominator - 8 for software, the applicable-layer count\nfor a knowledge-base archetype, e.g. \"2.5/3 · Knowledge Base · Solid\") is not\nwritten to the badge; it appears inside assess-report.md, so the badge never\nclaims a grade a deterministic run cannot reproduce. Pure threshold functions,\nfixture-tested. Also exposes maturity_band\n(the same score/denominator fraction mapped to the named tier ladder), the\nsingle source of truth assess_finalize reconciles the LLM's maturity_label\nagainst. Both producers accept an optional run_id provenance stamp.
anomaly_detector.py\nInspects a run-context dict for suspicious results (e.g. zero files scored, implausible\nCCN) and returns typed Anomaly records. Detail strings are sanitised (counts and\ngrades only, no paths or code) so they are safe to include in self-feedback issues.
coverage_report.py\nParses an existing coverage report into the shape the test_pressure scan's\ncoverage_data= param consumes ({_overall, per_file: {relpath: line_rate}}).\nTwo formats: Cobertura coverage.xml (_overall from the root line-rate,\nper-file from each <class> element's filename/line-rate; one iter(\"class\")\nwalk handles both the flat and nested <packages> schemas) and lcov.info\n(per-file LH/LF, overall sum(LH)/sum(LF)). /assess never runs the suite, so a\nreport the project already generated is the only honest line-coverage source - the\nparser reads it without taking a coverage.py runtime dependency. detect_coverage_report\nsearches the repo root, ./coverage/, and ./.coverage/ (a .coverage SQLite file\nis out of scope - reading it needs the coverage.py lib). Honest-degrade is the hard\ncontract: a missing or malformed report returns None, never raises, never blocks the\nassessment; assess_core.py records provenance (\"none found\" vs. the file/format read)\nseparately. Stdlib only, imports no orchestrator. Add fixtures + cases in\ntests/test_coverage_report.py alongside any change to a parse rule.
test_focus.py\nCross-joins three already-collected signals - the hotspot risk band (position in\ncomplexity_stats.top_hotspots), the parsed coverage report, and the\ntest_pressure cheap heuristics - into one ranked focus list. compute_test_focus\nclassifies each top-10 hot file (no_covering_test / covered_but_hollow /\ncovered_clean / unknown_no_coverage), filters out covered_clean, and ranks by\nrisk band then signal severity. Honest-degrade is the contract: coverage_data is None makes every file unknown_no_coverage (never covered_clean) and records\ncoverage_present: False; it never raises. Pure data - inputs are passed in\n(hot_files, coverage_data, cheap_heuristics), no file I/O, stdlib only,\nimports no orchestrator. This block is the SINGLE source both the report focus\ntable and the mutation offer consume - it is the contract, not duplicated\ndownstream. Add cases in tests/test_test_focus.py alongside any change to a\nclassification or ranking rule.
test_pressure/\nLayer 1 write-side truth pressure. Two tiers:
mutmut run then mutmut junitxml - because the run's stdout lists\nonly survivors (no totals); the junitxml report carries every mutant, so per-file\nkilled/survived/total (and a real survivor density) can be derived. Falls back to the\nsurvivor-only stdout parse when junitxml is absent (e.g. mutmut 3.x) or empty.