Public report — refine, published 8 Aug 2026.
Concrete security findings (CVE IDs, secret matches, dependency versions) are hidden in this version;
ask the repo owner for the full report.
211findings with an exact file:lineof 221 — the remainder are repo-wide signals (a dimension-level measurement, not a single line); open any file:line and verify
49/102dimensions across the health lenses — wide & deep
Executive summary
Read through the Production lens — the standard calibration. *Green* means good enough to run in production. The score is absolute and comparable across repos.
refinedev/refine carries serious gaps (42%). Several issues below can materially affect correctness, security, or the cost of changing it — and propagate to everything that depends on it.
Most urgent: a critical security exposure was detected (see the Security & Compliance lens). Treat it as a priority regardless of the overall grade.
The area that most needs attention is Readiness (20%) — releases are harder to depend on — versioning, release notes and dependency hygiene are thin, so consumers can't easily tell what changed or trust an upgrade. Security (55%) is the next concern — exposure to security and compliance incidents is elevated.
Leadership focus, highest impact first: ILogger (or Serilog) and log at meaningful points across… (Observability); SAST step (e.g. CodeQL) or a security analyzer package (Security & performance tooling); unused dependencies, declare unlisted imports explicitly,… (Dependency Hygiene).
For scale: — (~0 production lines); rebuilding it from scratch would take roughly — (—). Approximate, ±~30%.
How the score is built — each lens's share of the headlineWidth is the lens's weight in the worst-heaviest fold (the weakest area pulls hardest); colour is that lens's own band. A lens fixes the score in proportion to its width.
Of everything flagged, the best return on effort is: Adopt ILogger (or Serilog) and log at meaningful points across the projects. The rest can wait behind it.
Evidence: priority ranking: top of 5 ranked by impact/effort
→ Adopt ILogger (or Serilog) and log at meaningful points across the projects.
At a glance — Code Health · 71% · Adequate · gated by D3
Findings mapped to OWASP categories; the specific CVEs/secrets are in the Security dimension cards below and findings.md (redacted only on the public version of this report).
OWASP category
Findings
Severity
A03:2021 — Injection
50
High / Critical
A06:2021 — Vulnerable & Outdated Components
50
High / Critical
A05:2021 — Security Misconfiguration
21
High / Critical
Roadmap
Begin by implementing structured logging and health checks to establish baseline observability. Next, introduce static application security testing to identify vulnerabilities early in the development cycle. Simultaneously, clean up the dependency tree by removing unused packages and explicitly declaring all imports. Finally, address the single gaps in automated testing and test distribution to ensure comprehensive coverage and reliability.
Ranked by impact ÷ effort. "Helps" is the estimated gain on the 0–100 health score.
Do this
Helps
Effort
Dimension
Resolve the 1 No automated tests finding(s) in Code Coverage.
ADR Quality: The decision (web application with Supabase/Refine backend and React frontend) is stated but no consequences/trade-offs are given
documentation/blog/2021-12-22-base64-upload.md
8.5
Near-clean
ADR Quality: Decision and consequences/trade-offs are absent from the visible text
documentation/blog/2022-01-18-csv-import.md
8.5
Near-clean
ADR Quality: The decision/consequences section (how to display the array as a table and any trade-offs) is not shown before the clip; cannot be flagged as missing
ADR Quality: The title 'Top React JS Frameworks Every Developer Should Know' is a marketing-style banner with no decision or consequences; it is a comparison post rather than an ADR
ADR Quality: Consequences/trade-offs are not visible before the clip marker (the body ends with a review list and clips)
Methodology & how to trust this report
Watchdog is a deep, periodic assessment — run each sprint, monthly, or quarterly, taking the time to go wider and deeper than a quick check and surfacing in one coherent report what you'd otherwise piece together from a dozen separate tools. It scores deterministically: the same commit yields the same score, every run. 46 of 49 evaluated dimensions are computed purely by tools and static analysis (confidence 1.0); 3 documentation/naming judgement(s) are LLM-assisted and labelled advisory. Overall confidence is 0.7 — the weighted average across measured dimensions; it falls as more of the score leans on LLM-assisted judgement and rises when it's fully tool-backed.
Every figure here is one of three kinds, and we label which: ✓ Measured — a deterministic fact (LoC, complexity, coverage); ~ Modeled — an estimate from a stated model (cost, effort, value-at-risk), always a range with its assumptions, never a precise fact; ◐ Advisory — an LLM prose judgement. We never present a modelled estimate as if it were measured. Perfect or absent scores carry their provenance too (ADR-0011): ✓ Tool-verified means the property itself was measured across the surface; ○ Nothing flagged means the probes came back clean — a claim bounded by what a repository can show; ⊘ Not evidenced means a working control (a tested restore, an automated rollback) showed no positive evidence — absence of evidence is not evidence of a control, so it's excluded from the score rather than awarded a spurious 10; ◐ Sampled · advisory marks an LLM verdict over a bounded sample — advisory, never a deterministic measurement.
What we checked — 49 dimensions across the health lenses
Each chip is a dimension scored from real signals across architecture, testing, dependencies, security & compliance, documentation, git-history and code quality — in one coherent pass. A surface report typically covers a handful.
How to trust any code-health report — three questions
Can you open the finding? Real findings cite a repo-relative file and line you can open at the cited line — never an absolute scratch path. Here, 211 of 221 do; the remainder are repo-wide signals — a dimension-level measurement, not a single line. (Every path in this report is repo-relative by construction: paths are normalized at the producer and the report is rejected if any rooted path leaks through.)
Is there a tool behind the number? Every score below names the method that produced it — Roslyn, git, a scanner, or (for a handful of documentation/naming dimensions) an LLM labelled sampled · advisory — not a narrative.
Does re-running give the same result? Run it again on the same commit and the score — and this report, byte for byte — is identical. A report whose numbers move between runs is describing the run, not the code.
This report answers yes to all three. That's the bar to hold any assessment to.
Tools & methods
The actual versions used this run (captured at analysis time) — re-run on the same commit for the identical score.
Method
Backs
Version
Evaluator
Roslyn static analysis
Complexity, cohesion, coupling, dead code, API surface, layering
What ran differently this time — a tool absent, degraded, or that fell back to an estimate. Named openly, not folded silently into the scores. A degraded run also records its exact cause in diagnostics.md.
D18 Solution Shape — evaluation did not complete — Dimension evaluation failed — excluded from the score.
D19 Documentation Quality — LLM provider failed — The model provider returned an unusable result, so this LLM-assisted dimension fell back to a measurement gap (confidence 0) rather than a penalty. Re-run with a reachable provider to score it.
D30 Dependency Vulnerabilities — scanner not present in this environment — The backing tool was not installed where this scan ran, so this dimension was not scored. Install the tool (or run in the hosted environment, where it is always present) for a graded result.
D32 Data Compliance (PII/GDPR) — scanner not present in this environment — The backing tool was not installed where this scan ran, so this dimension was not scored. Install the tool (or run in the hosted environment, where it is always present) for a graded result.
Repo exclusion declarations (.gitattributes linguist-generated/vendored, .editorconfig generated_code): none declared — every source file was scored.
Limitations & what we did not check
Watchdog assesses the repository exactly as committed, and only the repository. By design it does not reach outside the source tree: the live cloud account, the running CI/CD pipeline, the host's branch-protection and approval rules, the production configuration, or a restore actually exercised against a backup are all out of scope. That boundary is a feature, not a gap — a repo-relative, deterministic scan re-runs identically on any commit and every finding opens at a real file and line, where a live audit can neither be reproduced nor traced. The visible consequence is that controls which leave no in-repo evidence are reported as "not evidenced" and excluded from the score rather than awarded a number a static scan cannot justify.
Per-dimension blind spots
For each dimension that was measured, what a static, repo-only scan structurally cannot see — the honest edge of the measurement, not a failure of it.
D1 Cyclomatic Complexity: Cyclomatic complexity counts branches statically — it cannot tell an essential decision tree from accidental tangle, nor see complexity that lives in data or configuration (large switch-case token tables, DSL lexers/parsers, data-as-code rule tables) rather than control flow: a tokenizer's many single-character cases read as high complexity though each branch is trivial.
D2 Cognitive Complexity: Cognitive-complexity heuristics approximate how hard code is to follow; genuine domain difficulty and well-named intent that eases reading are not captured.
D3 God Classes: "God class" is sized by members and responsibilities visible in the type — a deliberately broad facade over a coherent subsystem can read the same as an accidental grab-bag. For front-end JS the file-length check is cohesion-aware (a single-responsibility module — one class/IIFE — earns a 3× threshold), but cohesion is approximated from top-level declarations, not true dependency structure.
D4 Code Duplication: Duplication is token-similarity (jscpd) — it finds copy-paste, not semantic duplication expressed differently. Committed machine-written code (EF migration scaffolds, *.Designer.cs, model snapshots) is EXCLUDED — its repetition is the tool's, not the team's — so the score reflects hand-written duplication only; the generated footprint is reported separately under Solution Shape.
D5 Coupling: Coupling is measured between projects/assemblies — runtime coupling through DI, reflection, messaging or shared databases is invisible to a static reference graph.
D7 Architectural Integrity: Layering is checked against detected/declared rules — an architecture whose boundaries live in convention or in code review, not in a rule a scanner can read, is not enforced here.
D8 Code Coverage: Coverage is measured by building and running the suite (`dotnet test --collect`) inside Watchdog's isolated image — the target repo is never modified, and nothing on your systems runs. So coverage exists only when the suite builds and runs within the inline time budget; one that needs external services, can't build, or exceeds the budget yields no coverage (D8 then degrades to not-measured, not a low score). Line coverage also says nothing about assertion quality.
D9 Test Distribution: The test-pyramid shape is inferred from project/folder naming and references, with a single test host bucketed per-file by its path tier and content signals — a suite that names tiers unconventionally and gives no per-file signal can still be mis-bucketed.
D12 Dependency Hygiene: Dependency health reads manifests and lockfiles — a vulnerability in a vendored/copied dependency, or risk from how a dependency is actually used, is outside this view.
D13 Secret Scanning: Secret detection is signature- and entropy-based on the current tree — a secret that does not match a known pattern, or one already rotated, will not be flagged (a clean scan is "nothing matched", not "no secrets exist").
D15 Churn × Complexity Hotspots: Churn hotspots come from git history — a freshly imported or squashed repository has no churn signal, and recent rewrites can mask a historically risky file.
D16 Bus Factor: Bus-factor is a time-decayed model of commit attribution (who has recently, repeatedly worked a file), not comprehension — pairing, review and reading-without-committing spread knowledge it can't see; bot commits and shared accounts still distort it.
D20 ADR Quality: ADR quality is an LLM read of the decision records present — it cannot know about decisions made and never recorded, and its verdict is sampled and advisory.
D21 Naming Consistency: Naming quality is an LLM judgement over a bounded sample — it assesses clarity/consistency of the names it sees, not domain-correctness, and is advisory.
D25 ADR Conformance: ADR conformance is the LLM-scored fraction of sampled code that follows recorded decisions — it checks the decisions that were written down and the slices it sampled, not unrecorded rules or the whole tree.
D26 Project Cohesion: Project focus is sized from members/namespaces per project — a project that is broad by deliberate design reads the same as one that has sprawled.
D27 Navigability: Indirection/navigability is structural — it measures hops to follow a call, not whether that indirection buys real flexibility or just ceremony.
D28 Secrets (history): Secret-history scanning sweeps the git log for known patterns — a secret that predates the available history, or never matched a signature, is not found (clean means "nothing matched in the history we can see").
D29 Static Analysis (SAST): SAST findings are pattern-based (semgrep) — it finds classes of bug it has rules for; logic flaws, auth/authorization gaps and issues needing runtime context are out of reach (and clean means "no rule matched").
D31 IaC & Container Security: IaC scanning checks Dockerfiles/Terraform/Kubernetes against best-practice rules — it cannot see the live cloud account, runtime configuration, or drift between the committed config and what is actually deployed.
D33 JS/npm Dependency Vulnerabilities: JS/npm CVE matching reads package manifests and lockfiles — risk from how a dependency is used, and advisories not yet published, fall outside this scan.
D34 Knowledge Freshness: Freshness is decayed commit RECENCY, not comprehension — code read often but rarely committed reads as orphaned, and stable code that genuinely needs no changes is penalised the same as forgotten code; bot/squash commits distort it like the bus factor.
D35 Change Coupling: Change coupling is co-change in COMMITS — files split across separate commits, or coupled only through a shared config/build step, read as uncoupled, and a sweeping commit (rename/format) is excluded so it doesn't couple everything. It shows that files change together, not WHY: a high coupling can be a healthy cohesive pair as readily as a hidden leak.
M4 Documentation accuracy: Onboarding quality is an LLM read of the docs/setup present — it cannot run the onboarding or measure how long a real new joiner takes; the verdict is sampled and advisory.
P4 Deployment & Rollback: Approval/branch-protection rules live in repository settings the scan cannot see — only their in-repo evidence (config files, workflows) is checked, so a control enforced purely in the host's settings reads as "not evidenced".
P6 Release Hygiene: Rollback/observability controls are inferred from repo artefacts (pipelines, dashboards-as-code) — controls configured in external tooling, with no in-repo trace, cannot be credited.
The LLM boundary
LLM-set scores this run (4): D20, D21, D25, M4 (model: Local LLM). For these, a model reads a bounded sample and sets the numeric score (documentation, ADR quality, naming, comment value, onboarding) — D25 sets the ADR-conformance fraction over sampled code, D22 judges API accuracy over a sample. These are sampled and advisory by design: they vary at the margins between runs and are never a deterministic measurement. Every other score in this report is tool-computed at confidence 1.0.
What it measures: How tangled the control flow is — methods with many branches are hard to test and change.
Method: Cyclomatic complexity per method (1 + decision points), computed exhaustively across production source; test projects separated by convention. Deterministic.
Resolve the 1 _compress (cyclomatic 38) finding(s) in Cyclomatic Complexity — start with lz-worker.js. — One of this dimension's main actionable groups (1 warning-level).
Resolve the 1 _decompress (cyclomatic 32) finding(s) in Cyclomatic Complexity — start with lz-worker.js. — One of this dimension's main actionable groups (1 warning-level).
Detailed fixes: d1_recommendation.md · top locations in Appendix A, every location in findings.md.
What it measures: How hard the code is for a person to follow, beyond raw branching.
Method: Cognitive complexity per method (Sonar-style nesting-penalized score), computed exhaustively over production code, excluding test projects. Deterministic.
Resolve the 1 _compress (cognitive 124) finding(s) in Cognitive Complexity — start with lz-worker.js. — One of this dimension's main actionable groups (1 warning-level).
Resolve the 1 _decompress (cognitive 68) finding(s) in Cognitive Complexity — start with lz-worker.js. — One of this dimension's main actionable groups (1 warning-level).
Resolve the 1 injectSitemapLastmod (cognitive 16) finding(s) in Cognitive Complexity — start with blog-plugin.js. — One of this dimension's main actionable groups (1 warning-level).
Detailed fixes: d2_recommendation.md · top locations in Appendix A, every location in findings.md.
Do you agree with this assessment?
D3 · God Classes2.5 / 10Weak✓ Tool-verified
What it measures: Over-large classes that try to do too much ("god classes").
Method: God-class detection by line and method-count thresholds per logical type (partial classes unified), filtered for generated code and registration/contract false positives. Deterministic.
Resolve the 3 FileTooLong finding(s) in God Classes — start with blog-plugin.js, index.js, workbox-eac1af49.js. — One of this dimension's main actionable groups (3 warning-level).
Detailed fixes: d3_recommendation.md · top locations in Appendix A, every location in findings.md.
What it measures: Copy-pasted code that should be shared instead.
Method: Code duplication via token-stream sliding windows with type-aware normalization (locals masked, type names preserved), density-scored per KLoC of production code. Deterministic.
What it measures: Whether volatile projects sit underneath others that depend on them (so their churn ripples upward), and whether project dependencies form cycles. A widely-depended-on but stable shared/kernel project is healthy, not penalised.
Method: Dependency cycles via elementary-DFS over real .csproj references, plus Martin instability (afferent/efferent) per project. Exhaustive over the reference graph, deterministic.
Coverage: Exhaustive · type-level: afferent/efferent coupling + cycles computed over every production type — the population is all types, not a name convention.
What it measures: Whether the code respects its intended layering / architecture rules.
Method: Enforcement rung (Prevented/Verified/Documented) per checkable ADR via Roslyn, plus dependency cycles via the engine shared with D5/AX3. Deterministic, exact.
Of 17 mechanizable ADRs, 17 are prevented by analyzers, 0 by tests, 0 exist only in prose. Coverage: 100 %. Cycles found: 0.
✓ On the Gold path — maintain.
Detailed fixes: d7_recommendation.md.
Do you agree with this assessment?
D8 · Code Coverage0.0 / 10Critical✓ Tool-verified
What it measures: How much of the code is actually exercised by tests.
Method: Coverage from coverlet runs or committed reports (Cobertura/OpenCover/lcov), computed per-file with structured exclusions for generated, trivial, and glue code. When the suite can't be built/run in-image AND no report is committed, coverage is reported NOT-MEASURED (excluded from the score) with the precondition to make it measurable — never a LoC-ratio proxy folded in as if measured. Deterministic.
No automated tests — the solution has no test code.
No automated tests
What to do
Resolve the 1 No automated tests finding(s) in Code Coverage. — One of this dimension's main actionable groups (1 issue-level).
Enforce Code Coverage in CI to reach Verified (currently Documented). — Hardens enforcement from Documented toward Verified — provenance only; does not change the score.
Detailed fixes: d8_recommendation.md · top locations in Appendix A, every location in findings.md.
Do you agree with this assessment?
D9 · Test Distribution0.0 / 10Critical✓ Tool-verified
What it measures: Whether the test suite has a healthy mix of unit / integration / end-to-end tests.
Method: Test projects classified (Unit/Integration/BDD/E2E) from compiled metadata; test methods counted exhaustively across projects with placement-agnostic disk fallback. Deterministic.
What it measures: Whether dependencies are current, secure, and not bloated.
Method: Manifest scan via dotnet list package across all projects; worst-signal-per-package deduction (saturating for vulnerabilities, capped-linear for deprecation/outdated) per KLoC. Exhaustive, deterministic.
What it measures: Whether any secrets (keys, tokens, passwords) have leaked into the code.
Method: In-process native secret scanner (entropy plus signature patterns) across all tracked files; no external tool. A clean result is a measured 10, not no-data zero. Deterministic.
What it measures: Files that change often and are also complex — the riskiest hotspots.
Method: Per production file churn times cyclomatic complexity over a rolling window, computed from git and Roslyn/JS/Razor analysis. Exhaustive, deterministic per commit date.
What it measures: Whether knowledge is concentrated in too few people (the "bus factor").
Method: Living knowledge per author via time-decayed commit attribution (6-month half-life, focus weighting) across largest source files. Deterministic, avoids blame's mechanical-refactor false positives.
What it measures: Whether architecture decisions are recorded well (context, decision, consequences).
Method: Per-ADR judgment by language model at low temperature with two-pass stability; confidence is share of ADRs evaluated; enforcement-field presence detected deterministically. Advisory.
Evaluated 291 ADR(s) individually; mean quality 6.8/10 (mixed — many ADRs miss context or consequences). 72 flagged with a specific gap.
Context/problem and consequences/trade-offs are both absent from the visible text · ×3documentation/blog/2022-02-22-refine-invoice-generator.md
The decision (web application with Supabase/Refine backend and React frontend) is stated but no consequences/trade-offs are givendocumentation/blog/2021-11-12-issue-tracker-refine.md
Decision and consequences/trade-offs are absent from the visible textdocumentation/blog/2021-12-22-base64-upload.md
The decision/consequences section (how to display the array as a table and any trade-offs) is not shown before the clip; cannot be flagged as missingdocumentation/blog/2022-01-18-csv-import.md
The title 'Top React JS Frameworks Every Developer Should Know' is a marketing-style banner with no decision or consequences; it is a comparison post rather than an ADRdocumentation/blog/2022-02-21-top-react-frameworks.md
+ 65 more group(s) — more in Appendix A; the complete list is findings.md.
What to do
Resolve the 3 Context/problem and consequences/trade-offs are both absent from the… finding(s) in ADR Quality — start with 2022-02-22-refine-invoice-generator.md, 2022-03-01-refine-invoice-generator-p2.md, 2022-10-07-responsive-navbar.md. — One of this dimension's main actionable groups (3 warning-level).
Resolve the 1 The decision (web application with Supabase/Refine backend and React… finding(s) in ADR Quality — start with 2021-11-12-issue-tracker-refine.md. — One of this dimension's main actionable groups (1 warning-level).
Resolve the 1 Decision and consequences/trade-offs are absent from the visible text finding(s) in ADR Quality — start with 2021-12-22-base64-upload.md. — One of this dimension's main actionable groups (1 warning-level).
Detailed fixes: d20_recommendation.md · top locations in Appendix A, every location in findings.md.
What it measures: Whether names — types, methods, variables — are clear and consistent.
Method: Judged by language model at low temperature (0.0-0.1) on a deterministic random symbol sample (fixed size, not exhaustive), with disclosed confidence band. Advisory, sampled.
What it measures: Whether the code actually follows the decisions recorded in the project's ADRs.
Method: Judged by language model at low temperature against ADRs plus a deterministic structural code summary; findings linked to repo-rooted ADR paths for traceability. Advisory.
What it measures: How far you must trace to follow a call — low indirection and co-located slices read easier.
Method: Call indirection (interface hops, cross-namespace calls, slice-locality scaled) over a sampled set of method invocations, size-aware baseline. Sampled; confidence discounted by symbol-resolution gaps.
Coverage: Slice locality from the first namespace segments, SAMPLED (≤400 methods) — not exhaustive.
What it measures: Whether any secrets were ever committed — scanned across the full git history, not just now.
Method: Git-history secret scan via gitleaks detect over full history in an isolated checkout; each match flagged High. Exhaustive; degrades cleanly when tool absent.
What it measures: Real static-analysis (SAST) findings — likely security bugs in the code, any language.
Method: Polyglot static analysis via semgrep across the repo using the pinned, image-baked p/security-audit + p/owasp-top-ten rulesets (no scan-time registry fetch); severity rules (ERROR/WARNING/INFO) map to a full-band severity-weighted score. Exhaustive, deterministic; degrades on parse failure.
Coverage: semgrep pattern rules over all files — exhaustive for the rule set, blind to classes of bug without a rule (clean = no rule matched).
High: github-actions-mutable-action-tag · ×50.github/workflows/build-examples.yml:54detected by semgrep finding
What to do
Resolve the 50 High finding(s) in Static Analysis (SAST) — start with build-examples.yml (36), documentation.yml (6), calibreapp-image-actions-dispatch.yml (3). — One of this dimension's main actionable groups (50 issue-level).
Detailed fixes: d29_recommendation.md · top locations in Appendix A, every location in findings.md.
High IaC: KSV-0014 · ×3documentation/k8s/refine-documentation/templates/deployment.yamldetected by trivy finding
Medium IaC: KSV-0001 · ×5documentation/k8s/refine-documentation/templates/deployment.yamldetected by trivy finding
Low IaC: KSV-0003 · ×13documentation/k8s/refine-documentation/templates/deployment.yamldetected by trivy finding
What to do
Resolve the 3 High IaC finding(s) in IaC & Container Security — start with deployment.yaml (3). — One of this dimension's main actionable groups (3 issue-level).
Resolve the 13 Low IaC finding(s) in IaC & Container Security — start with deployment.yaml (11), Dockerfile (2). — One of this dimension's main actionable groups (13 recommendation-level).
Resolve the 5 Medium IaC finding(s) in IaC & Container Security — start with deployment.yaml (5). — One of this dimension's main actionable groups (5 warning-level).
Detailed fixes: d31_recommendation.md · top locations in Appendix A, every location in findings.md.
What it measures: Whether anyone still has living knowledge of each file, or it has been orphaned — last understood long ago by someone now gone quiet. The sibling of the bus factor: D16 asks who owns it, D34 asks whether anyone still knows it.
Method: File orphaning as total living-knowledge decay below one focused-commit's worth within a year, computed per-file from the D16 decay model. Exhaustive, deterministic over fixed history.
What it measures: Whether files that change together actually belong together — pairs that repeatedly co-change in git history despite having no explicit code dependency, surfacing the hidden/logical coupling (and boundaries in the wrong place) a static scan can't see.
Method: Pairwise co-occurrence over the per-commit file sets in git history (production source only — tests and generated dropped): Degree-of-Coupling = shared ÷ min individual revisions, reported above noise floors (each file ≥10 revisions, ≥5 shared commits, ≥50% strength); sweeping commits excluded. Deterministic over fixed history.
Coverage: Population: PRODUCTION source files only — test and generated files are dropped before pairing, so a class co-changing with its own test (trivially ~100%) can't drown the real production↔production coupling. Pairs ranked by Degree-of-Coupling; coupling through a build step, config, or non-source file isn't seen.
What it measures: Whether the build pipeline provides supply-chain integrity — generated provenance/attestation, signed artifacts (cosign/sigstore), an SBOM, and pinned build actions. Presence of the configuration, not a runtime guarantee.
Method: Supply-chain provenance/signing read deterministically from CI/build config (.github/workflows, .gitlab-ci.yml, azure-pipelines, Jenkinsfile, .circleci) + the release surface: four signals — generated provenance/attestation (SLSA/in-toto/actions-attest), artifact signing (cosign/sigstore/gitsign), an SBOM (syft/sbom-action/*.spdx.json/*.cdx.json), and SHA-pinned build actions — scored 10·present/denom. NotApplicable without a build pipeline. Detects configuration presence, not runtime enforcement.
Resolve the 1 Unpinned build actions finding(s) in Supply-chain Provenance & Signing. — One of this dimension's main actionable groups (1 warning-level).
Resolve the 1 No build provenance finding(s) in Supply-chain Provenance & Signing. — One of this dimension's main actionable groups (1 recommendation-level).
Resolve the 1 No artifact signing finding(s) in Supply-chain Provenance & Signing. — One of this dimension's main actionable groups (1 recommendation-level).
Detailed fixes: d36_recommendation.md · top locations in Appendix A, every location in findings.md.
What it measures: Whether the repository publishes a coordinated-vulnerability-disclosure policy (SECURITY.md or security.txt) with a reporting contact, so finders know how to report a vulnerability. Presence of a policy file with a contact, not whether the policy is adequate or honoured.
Method: Vulnerability-disclosure policy read deterministically from the repo: a SECURITY.md (root/.github/docs) or .well-known/security.txt / security.txt, regex-checked for a reporting contact (email / URL / mailto). Present + contact → 10; present without a contact → 4; NotApplicable when no policy file exists (it may live off-repo). Detects the policy file's presence + contact, not its adequacy.
What it measures: Whether dependencies have known published vulnerabilities (CVEs) per the OSV database — npm and other lockfile ecosystems, parsed natively. Complements D33 (npm via trivy) and D30 (.NET via dotnet).
Method: npm/multi-ecosystem CVE scan via osv-scanner (queries the osv.dev database + parses lockfiles natively: package-lock/yarn/pnpm/bun); severity tally (Critical/High/Medium/Low) to 0-10 tight normalizer (8.0). NotApplicable without a JS lockfile. Additive to D33 (trivy fs); exhaustive + deterministic, DB kept fresh.
High CVE: [GHSA redacted] · ×32documentation/pnpm-lock.yamldetected by osv-scanner finding
Critical CVE: [GHSA redacted] · ×18documentation/pnpm-lock.yamldetected by osv-scanner finding
What to do
Resolve the 32 High CVE finding(s) in OSV Dependency Vulnerabilities — start with pnpm-lock.yaml (32). — One of this dimension's main actionable groups (32 issue-level).
Resolve the 18 Critical CVE finding(s) in OSV Dependency Vulnerabilities — start with pnpm-lock.yaml (18). — One of this dimension's main actionable groups (18 issue-level).
Detailed fixes: d38_recommendation.md · top locations in Appendix A, every location in findings.md.
Other · Architecture — Whether the codebase has a recognisable, scale-appropriate structure (a named architectural style, or modular enough for its size) rather than being an ad-hoc ball of mud.
Method: Roslyn plus csproj analysis: architecture style detection (DDD, clean, vertical-slice, CQRS) and structure fitness for repo size. Deterministic.
Maturity · Maturity — Whether the repo and its projects have a README, and whether it's substantive and current.
Method: Filesystem scan: README presence, word count, and headings for depth; git history for staleness. Exhaustive across root and project dirs, deterministic.
What to do
Add a 'Testing' section to the root README — how to run the test suite.
Add an 'Architecture' / 'How it works' section to the root README — the high-level shape.
Maturity · Maturity — Whether the README actually describes the code that exists (LLM-judged, advisory).
Method: Judged by language model at low temperature: README accuracy versus actual projects, within a disclosed tolerance. Advisory, not a measured number.
Readiness · Readiness — Whether SAST, secret/dependency scanning and performance benchmarking are wired in (presence, not runtime).
Method: Filesystem/Roslyn scan: CodeQL, Dependabot, secret-scanning, and BenchmarkDotNet presence in pipelines and projects. Exhaustive, deterministic.
Readiness · Readiness — Whether releases are automated and safely reversible (probes, rolling updates, approval gates) — from manifests/pipeline files, not the live environment.
Method: Filesystem scan: deployment manifests/IaC (K8s YAML, Helm, Terraform) for rolling updates, probes, approval gates, migration hooks. Exhaustive, deterministic.
What to do
Add an approval/environment gate (required reviewers / protection rules) before production promotion.
Readiness · Readiness — Whether releases are traceable — a maintained changelog and explicit version stamping.
Method: Filesystem scan: changelog file presence and version tags in csproj or git tags. Exhaustive, deterministic.
What to do
Stamp a version (csproj <Version>, a VERSION file, or GitVersion) or tag releases with semver so builds and releases are traceable.
Do you agree with this assessment?
R1 · Type Safety9.8 / 10Exemplary✓ Tool-verified
React / JS · Code Health — How much of the frontend is typed TypeScript vs untyped JavaScript.
Method: Frontend file inventory: the share of typed TypeScript vs untyped JavaScript across the source tree. Deterministic, exhaustive over frontend files.
What to do
Migrate the remaining .js/.jsx files to TypeScript.
React / JS · Architecture — Conformance to the detected frontend architecture layout (feature-sliced / layered src) plus cross-package deep-import rules (D-386).
Method: Conformance to the detected frontend layout (feature-sliced / layered src) plus cross-package deep-import rules, over the module graph. Deterministic.
packages/antd/tsup.config.ts:6 reaches into another package with a relative path (../shared/remove-test-ids-plugin) — import the package by name instead. — tsup.config.ts:6
packages/antd/tsup.config.ts:7 reaches into another package with a relative path (../shared/dayjs-esm-replace-plugin) — import the package by name instead. — tsup.config.ts:7
packages/antd/tsup.config.ts:8 reaches into another package with a relative path (../shared/mark-as-external-plugin) — import the package by name instead. — tsup.config.ts:8
packages/chakra-ui/tsup.config.ts:3 reaches into another package with a relative path (../shared/mark-as-external-plugin) — import the package by name instead. — tsup.config.ts:3
packages/chakra-ui/tsup.config.ts:4 reaches into another package with a relative path (../shared/remove-test-ids-plugin) — import the package by name instead. — tsup.config.ts:4
packages/chakra-ui/tsup.config.ts:5 reaches into another package with a relative path (../shared/tabler-cjs-replace-plugin) — import the package by name instead. — tsup.config.ts:5
packages/chakra-ui/tsup.config.ts:6 reaches into another package with a relative path (../shared/dayjs-esm-replace-plugin) — import the package by name instead. — tsup.config.ts:6
packages/core/tsup.config.ts:3 reaches into another package with a relative path (../shared/lodash-replace-plugin) — import the package by name instead. — tsup.config.ts:3
What to do
Fix the listed violations: import through public entries (package exports / slice index), never reach into another layer or package's internals.
React / JS · Code Health — Per-function cyclomatic/cognitive complexity from the token-level function scanner (D-386) — real branching, not a regex heuristic.
Method: Per-function cyclomatic/cognitive complexity from a token-level function scanner (real branching, not a regex heuristic), computed over every frontend function. Deterministic.
Branch-heavy code is where defects cluster — extract decisions into smaller functions. (×8) — check-package.ts:1, index.tsx:44, index.ts:105, …
What to do
Break down the listed branch-heavy functions; aim P95 cyclomatic ≤ 5.
Do you agree with this assessment?
R3 · Large Files7.7 / 10Strong✓ Tool-verified
React / JS · Code Health — How many components/modules exceed the large-file threshold.
Method: Components/modules exceeding the large-file threshold, counted exhaustively across the frontend source tree. Deterministic.
What to do
Split the oversized components into smaller, focused ones.
Do you agree with this assessment?
R4 · Test Coverage6.7 / 10Adequate✓ Tool-verified
React / JS · Readiness — Static test reachability (D-386): the share of production files reachable from any test via the import graph — measured without running anything.
Method: Static test reachability: the share of production files reachable from any test via the import graph — measured without running anything. Deterministic.
No test imports this module directly or transitively — its behavior is unverified. (×8) — mui.ts, fix-v4-deprecations.ts, data-table-filter.tsx, …
What to do
Add tests that import the unreached modules (directly or through their public entry).
Do you agree with this assessment?
R6 · Tooling6.7 / 10Adequate✓ Tool-verified
React / JS · Readiness — Whether the project wires up test, lint and typecheck — detected from each package.json script's COMMAND (eslint / tsc / vitest / jest / playwright), not just its name, and corroborated against CI-workflow invocations so a tool run only in CI still counts.
Method: package.json scanned for test/lint/typecheck script wiring. Deterministic presence check.
test ✓ · lint ✓ · typecheck ✗
What to do
Add the missing tooling (eslint, tsc) as package.json scripts and run them in CI.
Do you agree with this assessment?
R7 · Dead Code4.3 / 10Weak✓ Tool-verified
React / JS · Code Health — Files unreachable from every application/tooling/test entry point, and exports nothing imports (module-graph reachability, D-386).
Method: Dead code: files unreachable from every application/tooling/test entry point plus exports nothing imports, via module-graph reachability. Deterministic, exhaustive over the import graph.
Unreachable from the 48 application, 70 tooling and 867 test entry point(s) detected in this repo. Gate removals on your build/type-check — an undetected custom entry would make these reachable.
no import path from any entry point (48 application, 70 tooling, 867 test roots considered) (×7) — mui.ts, fix-v4-deprecations.ts, data-table-filter.tsx, …
What to do
Delete the dead files and unused exports — every line is maintenance cost and rebuild-estimate inflation with zero runtime value.
React / JS · Readiness — npm dependency truthfulness (D-386): unused dependencies, imports not declared anywhere, and type-/test-only packages shipped as production deps.
Method: npm dependency truthfulness: unused dependencies, imports declared nowhere, and type-/test-only packages shipped as production deps — from the manifest + import graph. Deterministic.
Imported but not declared in any reachable package.json — installs work only by hoisting accident. (×3) — mark-as-external-plugin.ts:1, dayjs-esm-replace-plugin.ts:1, vitest.setup.ts:3
Declared in the root/package.json but never imported anywhere in that package or its workspace members — dead weight and attack surface. Verify against build tooling before removing. (×3)
Every import is type-only — move it to devDependencies. — index.ts:1
What to do
Remove unused dependencies, declare unlisted imports explicitly, and demote type-/test-only packages to devDependencies.
React / JS · Architecture — Import cycles in the module graph (D-386) — files that can only be understood and changed together.
Method: Import cycles in the module graph, detected exhaustively over JS/TS imports (the same cycle detection as the .NET coupling dimension). Deterministic.
Other · Code Health — Whether the code avoids sync-over-async (deadlock-prone blocking on tasks) and async void.
Method: Roslyn syntax scan: async methods scanned for .Wait()/.GetAwaiter().GetResult() and async-void outside event handlers. Deterministic, hard fact per invocation.
Other · Code Health — Whether exceptions are handled rather than silently swallowed or rethrown with lost stack traces.
Method: Roslyn syntax scan: every catch clause counted; empty catches and bare rethrows flagged. Population is all catch clauses, not estimated. Deterministic, hard fact.
Other · Code Health — Whether log calls use message templates (queryable) rather than interpolated strings.
Method: Roslyn syntax scan: every log call-site counted; interpolated-string first-argument violations flagged. Population is all log calls, not estimated. Deterministic.
Do you agree with this assessment?
Reference — by lens
The score is the rank-weighted fold of these lenses (worst-heaviest), each including its meta-dimensions; a lens with a Critical contributor is capped at Fair (its band reads "gated by …") and is never the strongest area however high its average.
Capped at Fair by a Critical contributor — resolve it before relying on this lens.
Not included — 54 check(s) not relevant to this codebase
These checks had nothing to measure here (no tests, no git history, the codebase is small, or the architecture style doesn't apply), so they're omitted above rather than scored low.
AC1 Text alternatives — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC2 Forms & labels — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC3 Page structure — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC4 Keyboard semantics — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC5 ARIA correctness — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC6 Visual & motion safety — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AC7 A11y enforcement — No user-facing web UI (the repo is a library/CLI/worker/headless service) — accessibility is not applicable.
AX1 Captive dependencies — no DI registrations detected
AX10 Code composition — no source files detected — code composition not applicable
AX2 Stateful singletons — no singleton implementations detected
AX3 Project dependency cycles — no csproj graph available
AX4 Dependency direction — no csproj graph available
AX6 Interface segregation — no public interfaces
AX7 Slice cohesion — not applicable — not a vertical-slice architecture
AX8 Test isolation — no test/production split to check
AX9 CQS / query purity — no CQRS query handlers detected — query purity is not applicable to this codebase
AXB2 Runtime readiness — no data
C1 Data Protection — No personal data detected in the analyzed source — no PII-typed entity/column names (Email, FirstName, DateOfBirth, …), no ASP.NET Identity / user-account model, and no stored user credentials. GDPR data-protection controls are therefore N/A here. If this is intentional, record the no-PII posture in an ADR; if the app does process personal data, name those fields conventionally so this dimension activates.
C2 Access Controls — No access-control surface detected in the analyzed source — no web/app surface to authorize (no HTTP API or web-UI project) and no authorization code at all (no [Authorize]/policies, no imperative guard methods). Access control is therefore N/A here — this is a library/CLI, which is authorized by its CALLER, not by itself. If this codebase grows request handlers, the dimension reactivates and a default-deny posture is expected then.
C3 Audit Trail — No personal data detected in the analyzed source — no PII-typed entity/column names (Email, FirstName, DateOfBirth, …), no ASP.NET Identity / user-account model, and no stored user credentials. GDPR data-protection controls are therefore N/A here. If this is intentional, record the no-PII posture in an ADR; if the app does process personal data, name those fields conventionally so this dimension activates.
C4 Data Retention — No personal data detected in the analyzed source — no PII-typed entity/column names (Email, FirstName, DateOfBirth, …), no ASP.NET Identity / user-account model, and no stored user credentials. GDPR data-protection controls are therefore N/A here. If this is intentional, record the no-PII posture in an ADR; if the app does process personal data, name those fields conventionally so this dimension activates.
C5 Data-Subject Rights — No personal data detected in the analyzed source — no PII-typed entity/column names (Email, FirstName, DateOfBirth, …), no ASP.NET Identity / user-account model, and no stored user credentials. GDPR data-protection controls are therefore N/A here. If this is intentional, record the no-PII posture in an ADR; if the app does process personal data, name those fields conventionally so this dimension activates.
D10 Test Quality — No tests in the analyzed solution to assess for quality.
D11 Test Reliability — Test reliability not included
D14 License Compliance — license scan produced no result — the tool ran but its JSON output could not be parsed; the offline NuGet fallback resolved nothing
D17 Explicit Debt — the C# workspace loaded 0 projects, so explicit-debt density could not be measured
D18 Solution Shape — Dimension evaluation failed
D19 Documentation Quality — LLM evaluation failed
D22 Internal API Consistency — No exposed public API
D23 Boundary Type-Coupling — Zero projects and zero LoC mean the code is trivially empty; bounded contexts are not needed.
D24 Comment Value — No inline comments to assess — comment value is not applicable here.
D30 Dependency Vulnerabilities — No .NET solution found; no NuGet dependencies to scan for vulnerabilities.
D32 Data Compliance (PII/GDPR) — No PII/GDPR ruleset is bundled (the public p/gdpr semgrep pack was retired) — data compliance is not assessed in this scan.
D39 IL Efficiency — The target did not build, so no IL was available to measure.
D6 Cohesion (LCOM4) — No production classes were analyzable, so cohesion (LCOM4) was not measured (the solution likely failed to load or has no production code).
DM1 Domain Modelling — not run — 0/3 markers found
ED1 Event-Driven — not run — 0/3 markers found
ED5 Idempotency — no mutating command handlers or message consumers detected — idempotency check not applicable
ES1 Event Sourcing — not run — 0/3 markers found
GD1 Unfinished & placeholder code — no source files
IC1 Incompleteness & stubs — no C# methods found
P12 CI test-gate honesty — no data
P5 DR & Backup — not evidenced — repo shows no backup/RTO/RPO controls; absence of evidence is not evidence of a working control
P7 Outbound HTTP resilience — not applicable — this isn't a service/API/worker
P8 Schema migrations — no EF Core usage detected
P9 Domain vs controller coverage — no coverage report found on disk — run tests with `--collect:"XPlat Code Coverage"` (or in CI) to enable this cross-layer check
PF1 Benchmark discipline — Performance is assessed only for perf-relevant repos — a packaged library, one that ships benchmarks, or one already using allocation-aware APIs. This repo isn't one, so the Performance lens is not applicable and is excluded from the score.
PF2 Allocation hygiene — Performance is assessed only for perf-relevant repos — a packaged library, one that ships benchmarks, or one already using allocation-aware APIs. This repo isn't one, so the Performance lens is not applicable and is excluded from the score.
PF3 Async & latency hygiene — Performance is assessed only for perf-relevant repos — a packaged library, one that ships benchmarks, or one already using allocation-aware APIs. This repo isn't one, so the Performance lens is not applicable and is excluded from the score.
R5 Dependency Freshness — uses a pnpm lockfile — dependency freshness not measured here; JS/npm CVEs are scored in D33 (JS/npm Dependency Vulnerabilities)
S1 Web-Security Posture — No web surface detected in the analyzed source — no HTTP API or web-UI project (no controllers/minimal-API endpoints, no Razor/Blazor views) and no web middleware (HTTPS redirection, HSTS, security headers, cookies). Transport security, security headers, secure cookies, CSRF/input-validation and middleware-order controls are therefore N/A here — this is a library/CLI/worker, not a web app. Crypto hygiene was still checked and found nothing to flag. If this codebase becomes web-facing, the dimension reactivates automatically.
SC1 Supply-chain hygiene — no data
X2 Cancellation propagation — no async methods found
X5 Nullable reference types — no NRT-eligible projects
Appendix A — Findings (grouped)
The findings behind the scores, grouped by severity, then by dimension and kind. The high-severity issues are enumerated in full below; items per group are capped at 25 with any overflow stated explicitly per group, never silently truncated. The complete machine-readable list of every finding (all severities) is the companion findings.md in this report's bundle.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:54— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:55— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:56— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: run-shell-injection .github/workflows/build-examples.yml:63— Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR".
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:65— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: run-shell-injection .github/workflows/build-examples.yml:72— Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR".
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:91— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:92— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:93— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:98— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: run-shell-injection .github/workflows/build-examples.yml:116— Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR".
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:135— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:136— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:137— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:142— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: run-shell-injection .github/workflows/build-examples.yml:160— Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR".
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:179— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:180— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:181— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:186— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: run-shell-injection .github/workflows/build-examples.yml:204— Using variable interpolation `${{...}}` with `github` context data in a `run:` step could allow an attacker to inject their own code into the runner. This would allow them to steal secrets and code. `github` context data can have arbitrary user input and should be treated as untrusted. Instead, use an intermediate environment variable with `env:` to store the data and use the environment variable in the `run:` script. Be sure to use double-quotes the environment variable, like this: "$ENVVAR".
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:223— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:224— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:225— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
High: github-actions-mutable-action-tag .github/workflows/build-examples.yml:230— GitHub Actions step uses a mutable tag or branch reference. Tags and branch names can be silently repointed by the action owner, enabling supply-chain attacks — as seen in the trivy-action and kics-github-action compromises. Pin the reference to a full 40-character commit SHA instead, e.g. `uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608`.
+ 25 more in this group — see findings.md.
D38 · OSV Dependency Vulnerabilities· High CVE · ×32
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— @babel/plugin-transform-modules-systemjs 7.24.1: [GHSA redacted] — upgrade to 7.29.4 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.31.1 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.30.3 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.31.1 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.32.0 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.32.0 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.30.0
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.32.0 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.31.1 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.32.0
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— axios 0.25.0: [GHSA redacted] — upgrade to 0.31.1 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— body-parser 1.20.2: [GHSA redacted] — upgrade to 1.20.3 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— brace-expansion 1.1.11: [GHSA redacted] — upgrade to 1.1.16 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— brace-expansion 1.1.11: [GHSA redacted] — upgrade to 1.1.17 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— brace-expansion 1.1.11: [GHSA redacted] — upgrade to 1.1.18 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— braces 3.0.2: [GHSA redacted] — upgrade to 3.0.3 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— cross-spawn 7.0.3: [GHSA redacted] — upgrade to 7.0.5 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— fast-xml-builder 1.0.0: [GHSA redacted] — upgrade to 1.1.7
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— fast-xml-parser 5.4.1: [GHSA redacted] — upgrade to 5.5.6 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— form-data 4.0.0: [GHSA redacted] — upgrade to 4.0.6 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— glob 10.3.12: [GHSA redacted] — upgrade to 10.5.0 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— http-proxy-middleware 2.0.6: [GHSA redacted] — upgrade to 2.0.7 (in 2 lockfiles)
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— image-size: [GHSA redacted]
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— image-size 1.1.1: [GHSA redacted] — upgrade to 1.2.1
High CVE: [GHSA redacted] documentation/pnpm-lock.yaml— image-size: [GHSA redacted]
Change coupling: docgen.js ↔ docgen.ts documentation/plugins/docgen.js— `documentation/plugins/docgen.js` and `documentation/plugins/docgen.ts` change together 82% of the time (18 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: e2e.ts ↔ index.d.ts cypress/support/e2e.ts— `cypress/support/e2e.ts` and `cypress/support/index.d.ts` change together 77% of the time (10 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.ts ↔ integrations.ts documentation/src/assets/integration-icons/index.ts— `documentation/src/assets/integration-icons/index.ts` and `documentation/src/assets/integrations.ts` change together 68% of the time (19 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: map.tsx ↔ check-package.ts packages/live-previews/src/scope/map.tsx— `packages/live-previews/src/scope/map.tsx` and `packages/live-previews/src/utils/check-package.ts` change together 62% of the time (10 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: preview.tsx ↔ check-package.ts packages/live-previews/pages/preview.tsx— `packages/live-previews/pages/preview.tsx` and `packages/live-previews/src/utils/check-package.ts` change together 62% of the time (10 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.tsx ↔ index.ts packages/cli/src/commands/check-updates/index.tsx— `packages/cli/src/commands/check-updates/index.tsx` and `packages/cli/src/commands/update/interactive/index.ts` change together 60% of the time (6 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.tsx ↔ index.tsx packages/mui/src/components/buttons/edit/index.tsx— `packages/mui/src/components/buttons/edit/index.tsx` and `packages/mui/src/components/buttons/show/index.tsx` change together 57% of the time (23 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.tsx ↔ index.tsx packages/mui/src/components/buttons/create/index.tsx— `packages/mui/src/components/buttons/create/index.tsx` and `packages/mui/src/components/buttons/list/index.tsx` change together 57% of the time (23 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.tsx ↔ index.tsx packages/mui/src/components/buttons/clone/index.tsx— `packages/mui/src/components/buttons/clone/index.tsx` and `packages/mui/src/components/buttons/show/index.tsx` change together 57% of the time (23 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Change coupling: index.tsx ↔ index.tsx packages/mui/src/components/buttons/clone/index.tsx— `packages/mui/src/components/buttons/clone/index.tsx` and `packages/mui/src/components/buttons/list/index.tsx` change together 57% of the time (23 shared commits) with no explicit dependency — a hidden/logical coupling. If they belong together, co-locate them; if not, break the coupling.
Medium IaC: KSV-0001 documentation/k8s/refine-documentation/templates/deployment.yaml— Can elevate its own privileges
Medium IaC: KSV-0012 documentation/k8s/refine-documentation/templates/deployment.yaml— Runs as root user
Medium IaC: KSV-0104 documentation/k8s/refine-documentation/templates/deployment.yaml— Seccomp policies disabled
Medium IaC: KSV-0117 documentation/k8s/refine-documentation/templates/deployment.yaml— Prevent binding to privileged ports
Medium IaC: KSV-0125 documentation/k8s/refine-documentation/templates/deployment.yaml— Restrict container images to trusted registries
D20 · ADR Quality· Context/problem and consequences/trade-offs are both absent from the visible text · ×3
Context/problem and consequences/trade-offs are both absent from the visible text documentation/blog/2022-02-22-refine-invoice-generator.md— Add a Context section explaining why a custom invoice generator is needed (e.g. existing software options, lack of customization) and a Consequences section covering trade-offs like development effort vs long-term maintenance
Context/problem and consequences/trade-offs are both absent from the visible text documentation/blog/2022-03-01-refine-invoice-generator-p2.md— Add a Context section explaining why a customizable invoice generator is needed (e.g. lack of built-in templates for non-technical users) and a Consequences section covering trade-offs such as maintenance burden or loss of design flexibility when switching vendors.
Context/problem and consequences/trade-offs are both absent from the visible text documentation/blog/2022-10-07-responsive-navbar.md— Add a Context section explaining why a responsive navbar is needed (mobile-first navigation, consistent look-and-feel across pages) and a Consequences section covering trade-offs such as Tailwind/Bootstrap integration complexity or Bootstrap dependency
LLM evaluation failed — JSON parse error: Expected start of a property name or value, but instead reached end of data. Path: $.findings[1] | LineNumber: 0 | BytePositionInLine: 954.
D20 · ADR Quality· The decision (web application with Supabase/Refine backend and React frontend) is stated but no consequences/trade-offs are given · ×1
The decision (web application with Supabase/Refine backend and React frontend) is stated but no consequences/trade-offs are given documentation/blog/2021-11-12-issue-tracker-refine.md— Add a Consequences section covering trade-offs such as the need for ongoing Supabase credits, row-level security complexity, and the cost of running an internal web app versus tools like Trello or Asana
D20 · ADR Quality· Decision and consequences/trade-offs are absent from the visible text · ×1
Decision and consequences/trade-offs are absent from the visible text documentation/blog/2021-12-22-base64-upload.md— Add a Decision section stating exactly how Base64 encoding is applied (input type, JavaScript API call, Base64 string stored) and a Consequences section covering trade-offs such as increased payload size and browser compatibility
D20 · ADR Quality· The decision/consequences section (how to display the array as a table and any trade-offs) is not shown before the clip; cannot be flagged as missing · ×1
The decision/consequences section (how to display the array as a table and any trade-offs) is not shown before the clip; cannot be flagged as missing documentation/blog/2022-01-18-csv-import.md
D20 · ADR Quality· The title 'Top React JS Frameworks Every Developer Should Know' is a marketing-style banner with no decision or consequences; it is a comparison post rather than an ADR · ×1
The title 'Top React JS Frameworks Every Developer Should Know' is a marketing-style banner with no decision or consequences; it is a comparison post rather than an ADR documentation/blog/2022-02-21-top-react-frameworks.md— Rename to something like 'React UI/CRUD Frameworks Decisions and Consequences' and replace the body with a real decision record (context, explicit framework decision, trade-offs)
D20 · ADR Quality· Consequences/trade-offs are not visible before the clip marker (the body ends with a review list and clips) · ×1
Consequences/trade-offs are not visible before the clip marker (the body ends with a review list and clips) documentation/blog/2022-03-16-internal-tool-frameworks.md
D20 · ADR Quality· Consequences/trade-offs are not visible before the clip (the body ends in install steps and the clip marker) · ×1
Consequences/trade-offs are not visible before the clip (the body ends in install steps and the clip marker) documentation/blog/2022-03-22-refine-with-react95.md
D20 · ADR Quality· Context/problem (the express/server setup and why multipart/form-data upload matters) is present but embedded in code rather than explained; consequences/trade-offs are not shown · ×1
Context/problem (the express/server setup and why multipart/form-data upload matters) is present but embedded in code rather than explained; consequences/trade-offs are not shown documentation/blog/2022-03-29-react-hook-form-upload.md— Add a one-paragraph problem statement explaining multipart/form-data necessity for file uploads and the trade-offs of using Node's native fs module vs React Hook Form's FormData API
D20 · ADR Quality· Decision and consequences fall below the threshold (only context/problem plus a one-paragraph decision + features are present) · ×1
Decision and consequences fall below the threshold (only context/problem plus a one-paragraph decision + features are present) documentation/blog/2022-04-29-top-react-component-libraries-and-frameworks-every-developer-should-know.md— Add a Decision section stating which libraries/frameworks are recommended with an explicit rationale for selection and a Consequences section covering trade-offs such as large bundle size of Ant Design, cost of paid tiers, and learning curve.
D20 · ADR Quality· No architecture decision; only a promotional banner lists ten free tools with no context/problem and no consequences · ×1
No architecture decision; only a promotional banner lists ten free tools with no context/problem and no consequences documentation/blog/2022-05-02-high-quality-free-resources.md— Replace with an actual architectural decision (e.g. 'Use Supabase as the backend database for real-time storage' plus its trade-offs) instead of marketing content
D20 · ADR Quality· The title 'Best Open-Source Headless CMS to Try for Your Next Application' is informative but the body is essentially a list of open-source headless platforms with no context/problem and no consequences/trade-offs (e.g. learning curve, cost, plugin ecosystem) are addressed · ×1
The title 'Best Open-Source Headless CMS to Try for Your Next Application' is informative but the body is essentially a list of open-source headless platforms with no context/problem and no consequences/trade-offs (e.g. learning curve, cost, plugin ecosystem) are addressed documentation/blog/2022-05-05-open-source-headless-cms.md— Add a Context section explaining why a headless CMS matters over traditional systems (no front-end, content distribution, scalability), then a Decision section selecting one platform and its rationale, plus a Consequences section covering trade-offs like self-hosting costs, learning curve, and plugin dependency
D20 · ADR Quality· Not an architecture decision record · ×1
Not an architecture decision record — it is a company announcement post, not an ADR (context/problem, explicit decision, consequences) documentation/blog/2022-06-10-weve-raised-dollar1m-seed-funding.md— Convert this into an ADR by stating the funding round's purpose (e.g. scaling core team to deliver features/scale), the decision (funding raised, allocated funds used for X/Y), and any trade-offs such as dilution or debt.
D20 · ADR Quality· The body is an introduction stating why Node.js matters before diving into ES6 features; there is no explicit decision or consequences section (e.g. trade-offs of learning ES6 vs newer JS versions) · ×1
The body is an introduction stating why Node.js matters before diving into ES6 features; there is no explicit decision or consequences section (e.g. trade-offs of learning ES6 vs newer JS versions) documentation/blog/2022-09-06-nodejs-developer.md— Add a Decision section covering the skills and tools explicitly required to become a modern Node.js developer, plus a Consequences section noting any trade-offs such as the need for ongoing ES6/async knowledge
D20 · ADR Quality· No context/problem and no explicit decision (what Refine will do) are present · ×1
No context/problem and no explicit decision (what Refine will do) are present documentation/blog/2022-10-04-hacktoberfest.md— Replace the banner-style announcement with an ADR stating what concrete decisions/refactorings/hacks will be done during Hacktoberfest
D20 · ADR Quality· Consequences/trade-offs of using tooltips (e.g. accessibility, performance) are not visible before the clip · ×1
Consequences/trade-offs of using tooltips (e.g. accessibility, performance) are not visible before the clip documentation/blog/2022-11-29-mui-tooltip.md
D20 · ADR Quality· The decision (how to copy files in Docker) and its consequences/trade-offs are embedded in the How-to section with no dedicated Context/Problem or Consequences section · ×1
The decision (how to copy files in Docker) and its consequences/trade-offs are embedded in the How-to section with no dedicated Context/Problem or Consequences section documentation/blog/2022-12-28-docker-copy.md— Add a Context section explaining why copying files between host and container matters (e.g. building multi-stage images, sharing assets), then a Consequences section covering trade-offs like dependency on container ID/name vs volume mounts
D20 · ADR Quality· The body is primarily promotional copy with no context/problem and no explicit decision (the hackathon itself is the decision), plus consequences/trade-offs are absent · ×1
The body is primarily promotional copy with no context/problem and no explicit decision (the hackathon itself is the decision), plus consequences/trade-offs are absent documentation/blog/2023-01-06-hackaton-january.md— Replace the announcement content with a focused ADR: state the problem being solved (e.g. lack of an open-source hackathon for Refine developers) and the concrete decision (hackathon date, prizes, team size), then document trade-offs such as how the prize money is allocated or whether teams are allowed to recruit members outside the hackathon
D20 · ADR Quality· This is a hackathon winner announcement with no context/problem and no explicit decision (the winners are announced), only a one-line description that reads like a press release · ×1
This is a hackathon winner announcement with no context/problem and no explicit decision (the winners are announced), only a one-line description that reads like a press release documentation/blog/2023-02-28-hackathon-january-winners.md— Replace the body with an actual architecture/decision document: state what problem the ADR addresses, the explicit decision (e.g. adopt GraphQL for API layer), and its consequences
D20 · ADR Quality· The body is primarily announcement content with no context/problem and no consequences/trade-offs sections · ×1
The body is primarily announcement content with no context/problem and no consequences/trade-offs sections documentation/blog/2023-03-13-refine-v4-announcement.md— Add a Context/Problem section explaining what v3 was lacking and why v4 fixes it, then a Consequences section covering trade-offs such as reduced bundle size or the codemod process
D20 · ADR Quality· Vague title and no context/problem section describing the invoicing problem being solved by this architecture decision · ×1
Vague title and no context/problem section describing the invoicing problem being solved by this architecture decision documentation/blog/2023-04-10-refine-invoicer-1.md— Rename to something like 'Invoicer - React PDF Invoice Generator App Architecture' and add a Context/Problem section explaining why an invoicing app is needed (e.g. existing tools, requirements) before stating the explicit decision
D20 · ADR Quality· The decision (CRUD pages for Company/Client/Contact resources using Strapi dataProvider/authProvider props) and consequences/trade-offs are present but the visible text is mostly implementation detail rather than a clear context/problem statement · ×1
The decision (CRUD pages for Company/Client/Contact resources using Strapi dataProvider/authProvider props) and consequences/trade-offs are present but the visible text is mostly implementation detail rather than a clear context/problem statement documentation/blog/2023-04-12-refine-invoicer-3.md— Add a Context section explaining why CRUD pages matter for an invoice generator app (e.g. managing customer, vendor, contact info efficiently) and a Consequences section on trade-offs like Strapi API token management or auth page boilerplate
D20 · ADR Quality· The body is a post/blog describing what will be written rather than an explicit decision with consequences (e.g. Strapi collection/authorization setup and its trade-offs) · ×1
The body is a post/blog describing what will be written rather than an explicit decision with consequences (e.g. Strapi collection/authorization setup and its trade-offs) documentation/blog/2023-04-13-refine-invoicer-4.md— Add a Consequences section noting the trade-offs of adding CRUD views to the Pdf Invoice Generator app (e.g. increased complexity, need for data permissions) and how it ties into the RefineWeek series goals
D20 · ADR Quality· No consequences/trade-offs section (e.g. performance cost of rendering PDFs in a modal) present among visible text · ×1
No consequences/trade-offs section (e.g. performance cost of rendering PDFs in a modal) present among visible text documentation/blog/2023-04-14-refine-invoicer-5.md— Add a Consequences section noting the trade-off of rendering PDFs client-side and how to handle large invoices
D20 · ADR Quality· The body is pure celebration content with no context/problem and no explicit decision (the hackathon's purpose, what it addresses, or any constraint being refined), only a list of winners and prizes · ×1
The body is pure celebration content with no context/problem and no explicit decision (the hackathon's purpose, what it addresses, or any constraint being refined), only a list of winners and prizes documentation/blog/2023-06-14-refine-hackathon-2.md— Replace the celebratory sections with an objective problem statement (e.g. 'hackathons are too short to deliver real impact') and an explicit decision (e.g. 'we will now require hackathon projects to include a measurable outcome such as a live demo or published repo for evaluation') followed by consequences
D20 · ADR Quality· This is a celebratory announcement of winners with no context/problem and no decision (the winning projects are described but there is no architecture or design decision being made), only a list of the top five projects · ×1
This is a celebratory announcement of winners with no context/problem and no decision (the winning projects are described but there is no architecture or design decision being made), only a list of the top five projects documentation/blog/2023-08-04-refine-hackathon-2-winners.md— Replace the body with an actual ADR: state the problem the project addresses, the explicit architectural decision it embodies, and its consequences
D20 · ADR Quality· The title 'How to use Docker Exec command?' is informative but the body reads more like a list of steps and prerequisites for running the docker exec command rather than a focused decision with consequences · ×1
The title 'How to use Docker Exec command?' is informative but the body reads more like a list of steps and prerequisites for running the docker exec command rather than a focused decision with consequences documentation/blog/2023-08-18-docker-exec.md— Rephrase the Introduction into a single problem statement (why docker exec matters) plus an explicit Decision section on its purpose, then add Consequences covering trade-offs such as session persistence vs. restart behavior
D20 · ADR Quality· The body is a feature-rich product description with no context/problem and no explicit decision (e.g., what problem this solves or why Refine/GraphQL/Ant Design were chosen), only an authoring guide · ×1
The body is a feature-rich product description with no context/problem and no explicit decision (e.g., what problem this solves or why Refine/GraphQL/Ant Design were chosen), only an authoring guide documentation/blog/2023-10-02-refine-crm-overview.md— Replace the content with a focused ADR: state the concrete problem being solved, the decision (technology stack, specific features to implement), and consequences/trade-offs
D20 · ADR Quality· The body is a runnable Getting started guide with installation steps (CDN, npm install + import), markup example, and initialization code but no context/problem statement or consequences/trade-offs · ×1
The body is a runnable Getting started guide with installation steps (CDN, npm install + import), markup example, and initialization code but no context/problem statement or consequences/trade-offs documentation/blog/2023-12-07-swiper-js.md— Add an introductory Context section explaining why sliders are needed and the shortcomings of alternatives before diving into Swiper's features
D20 · ADR Quality· Consequences/trade-offs (e.g. learning curve for non-CLI users) are not visible before the scanner clips the document · ×1
Consequences/trade-offs (e.g. learning curve for non-CLI users) are not visible before the scanner clips the document documentation/blog/2023-12-15-kubectl-cheat-sheet.md— Add a Consequences section noting that the cheat sheet is a reference-style guide rather than an exhaustive decision document and any trade-offs of relying on CLI commands
D20 · ADR Quality· The body is a tutorial-style guide with only one decision (project planning and concept development) and no explicit decision or consequences; it reads like a long introduction rather than a focused ADR · ×1
The body is a tutorial-style guide with only one decision (project planning and concept development) and no explicit decision or consequences; it reads like a long introduction rather than a focused ADR documentation/blog/2023-12-26-build-an-app.md— Convert the text into an ADR by isolating each numbered step as a decision, adding a Decision rationale section explaining why each is required, and a Consequences section on trade-offs (e.g. market research cost vs ROI)
D20 · ADR Quality· Decision/consequences are present but thin · ×1
Decision/consequences are present but thin: the body states "you might need to build your own image" and ends before covering consequences such as container-registry setup cost or the alternative of using a ready-built image; trade-offs are not fully articulated documentation/blog/2024-01-22-k8s-postgres.md— Add a Consequences section on the registry storage cost (GCP/ECR fees) versus the one-time build, plus an "Alternative: Use a ready-built PostgreSQL image" option
D20 · ADR Quality· The body is a Docker cheat sheet with installation, version-checking, image-searching/pulling/removal, and a bulleted list of commands; it contains no context/problem statement or consequences/trade-offs. · ×1
The body is a Docker cheat sheet with installation, version-checking, image-searching/pulling/removal, and a bulleted list of commands; it contains no context/problem statement or consequences/trade-offs. documentation/blog/2024-02-12-docker-cheat-sheet.md— Add the problem motivating Docker adoption (e.g. portability, isolation) and the decision (keep only one command set per team) with trade-offs such as dependency on Docker desktop for Windows.
D20 · ADR Quality· Consequences/trade-offs are absent despite being a real CSS alignment tutorial · ×1
Consequences/trade-offs are absent despite being a real CSS alignment tutorial documentation/blog/2024-02-13-css-vertical-align.md— Add a Consequences section covering trade-offs such as requiring fixed-height parents for margin-auto or the loss of layout flexibility when using display: flex/grid
D20 · ADR Quality· Consequences/trade-offs (e.g. learning curve for distributed systems, remote server dependency) are not visible before the clip · ×1
Consequences/trade-offs (e.g. learning curve for distributed systems, remote server dependency) are not visible before the clip documentation/blog/2024-02-26-version-control.md
D20 · ADR Quality· The body is a tutorial-style guide with an explicit table-of-contents and detailed subsections (What is CSS Box Shadow / horizontal/vertical offsets / blur radius / spread radius), but the Decision section and consequences/trade-offs are absent; only context/problem and examples are present · ×1
The body is a tutorial-style guide with an explicit table-of-contents and detailed subsections (What is CSS Box Shadow / horizontal/vertical offsets / blur radius / spread radius), but the Decision section and consequences/trade-offs are absent; only context/problem and examples are present documentation/blog/2024-02-28-css-box-shadow.md— Add a short Decision section stating what box-shadow values to use for each purpose, then Consequences noting trade-offs such as performance when multiple shadows are applied
D20 · ADR Quality· The body ends before a decision statement and consequences/trade-offs are visible only beyond the clip marker; the explicit decision and its trade-offs are not yet stated in the visible portion · ×1
The body ends before a decision statement and consequences/trade-offs are visible only beyond the clip marker; the explicit decision and its trade-offs are not yet stated in the visible portion documentation/blog/2024-03-05-css-wrap-text.md
D20 · ADR Quality· The body is mostly installation and setup steps (virtual environment, install prerequisites, DRF configuration), with only a brief overview/why-choose section and a one-line API creation heading; the context/problem and consequences/trade-offs sections are not present · ×1
The body is mostly installation and setup steps (virtual environment, install prerequisites, DRF configuration), with only a brief overview/why-choose section and a one-line API creation heading; the context/problem and consequences/trade-offs sections are not present documentation/blog/2024-04-03-django-rest.md— Add a Context section explaining why REST APIs matter for food delivery apps (data exchange, integration) and a Consequences section covering trade-offs like dependency on DRF, learning curve, and operational complexity
D20 · ADR Quality· The visible content is a loose tutorial rather than an explicit Architecture Decision (context/problem + decision + consequences) document · ×1
The visible content is a loose tutorial rather than an explicit Architecture Decision (context/problem + decision + consequences) document documentation/blog/2024-04-29-nest-js.md— Convert the body into a single Decision by framing each covered topic as a problem/context plus the corresponding decision and its trade-offs.
D20 · ADR Quality· The body is a pure announcement with no context/problem framing and no explicit decision; it reads like an investor pitch rather than an ADR · ×1
The body is a pure announcement with no context/problem framing and no explicit decision; it reads like an investor pitch rather than an ADR documentation/blog/2024-05-06-investment-announce.md— Convert the content into a real ADR by identifying the problem/refinement being addressed (e.g. the gap between low-code and scratch for enterprise internal tools), stating the decision (the new product/feature), and documenting consequences/trade-offs
D20 · ADR Quality· The body is mostly setup/installation content with no context/problem framing or consequences/trade-offs · ×1
The body is mostly setup/installation content with no context/problem framing or consequences/trade-offs documentation/blog/2024-05-07-graphql-with-django.md— Add a Context/Problem section explaining why a GraphQL API (not REST) was chosen for the school management system and a Consequences section on trade-offs such as schema evolution friction vs. query flexibility
D20 · ADR Quality· Decision and consequences are absent (the visible text is only an introduction plus prerequisites and a table-of-contents with no explicit decision) · ×1
Decision and consequences are absent (the visible text is only an introduction plus prerequisites and a table-of-contents with no explicit decision) documentation/blog/2024-05-24-google-lighthouse.md— Add the actual decision (e.g. "audit app performance using Google Lighthouse") and its trade-offs (tooling cost, audit frequency) in a Decision section.
D20 · ADR Quality· The body is mostly setup and wireframe content (initializing Refine, selecting options, showing welcome page), with no context/problem or explicit decision/consequences sections · ×1
The body is mostly setup and wireframe content (initializing Refine, selecting options, showing welcome page), with no context/problem or explicit decision/consequences sections documentation/blog/2024-06-24-react-content-filtering.md— Add a Context section explaining why filtering/search components are needed for the application's data volume, and a Decision section stating what filter types and search behavior will be implemented; also note any consequences such as performance trade-offs from large datasets
D20 · ADR Quality· The body is mostly setup/installation content (React router V6 prerequisites, installing react-router-dom@6, configuring BrowserRouter in index.js) and routes before the decision/usage of useNavigate hook appears · ×1
The body is mostly setup/installation content (React router V6 prerequisites, installing react-router-dom@6, configuring BrowserRouter in index.js) and routes before the decision/usage of useNavigate hook appears documentation/blog/2024-06-24-router-use-navigate.md— Insert a dedicated section explaining how to call useNavigate() to perform a redirect from within components, with an example showing navigate({ replace: true }) and its consequences
D20 · ADR Quality· The body is a feature list (Streamlined Library Integration, Account-Based Boilerplate Management, Continuous Updates and Maintenance, Batteries loaded, Quickly share previews, Configure in the browser) with no context/problem statement or consequences/trade-offs · ×1
The body is a feature list (Streamlined Library Integration, Account-Based Boilerplate Management, Continuous Updates and Maintenance, Batteries loaded, Quickly share previews, Configure in the browser) with no context/problem statement or consequences/trade-offs documentation/blog/2024-07-25-refine-new-part-1.md— Add an Introduction section stating the problem Refine.new solves (e.g. boilerplate creation without codegen, one-size-fits-all project setup) and a Consequences section covering trade-offs such as the 720-combination search burden and the 'batteries-loaded' assumption that all features are present.
D20 · ADR Quality· Consequences/trade-offs (e.g. learning curve, ecosystem/tooling gap) are not visible before the clip · ×1
Consequences/trade-offs (e.g. learning curve, ecosystem/tooling gap) are not visible before the clip documentation/blog/2024-07-30-vite-js.md
D20 · ADR Quality· The decision (how to install/use Zustand in React projects) and consequences/trade-offs are present but buried under the 'What is Zustand?' explanation; a dedicated Getting started section would make this ADR clear · ×1
The decision (how to install/use Zustand in React projects) and consequences/trade-offs are present but buried under the 'What is Zustand?' explanation; a dedicated Getting started section would make this ADR clear documentation/blog/2024-07-31-zustand.md— Add an explicit Decision section covering installation commands, key hooks/API, and a brief Consequences section on trade-offs (e.g. no global state provider abstraction vs. smaller boilerplate)
D20 · ADR Quality· The body begins with setup (project setup, refine.new tool, project steps), but it does not yet state the decision or its consequences; the visible content is mostly boilerplate scaffolding before any real component code appears · ×1
The body begins with setup (project setup, refine.new tool, project steps), but it does not yet state the decision or its consequences; the visible content is mostly boilerplate scaffolding before any real component code appears documentation/blog/2024-08-04-react-tooltip.md— Replace the scaffolded setup with a one-paragraph context/problem and an explicit Decision section describing how to create a responsive tooltip using react-tooltip (props, positioning, accessibility), then add Consequences noting trade-offs such as dependency on react-tooltip and its own styling
D20 · ADR Quality· The body is primarily installation and attribute-reference content with no context/problem framing or consequences/trade-offs · ×1
The body is primarily installation and attribute-reference content with no context/problem framing or consequences/trade-offs documentation/blog/2024-09-06-htmx.md— Add a Context/Problem section explaining why HTMX matters (e.g. the need for markup-driven interactivity) and a Consequences section on trade-offs such as dependency on CDNs vs npm install, browser compatibility, and learning curve
D20 · ADR Quality· Decision and consequences are present but thin · ×1
Decision and consequences are present but thin: the body states what TanStack Table and React Table are (headless, framework agnostic), with a list of covered topics ('Advanced Column Customization in React Table', 'Accessibility Features in React Table') and ends before stating any concrete adapter usage or trade-offs. documentation/blog/2024-09-06-react-table.md— Add one sentence on how to install the @tanstack/react-table adapter and an explicit decision (e.g. "use the @tanstack/react-table adapter for data grids") with its consequences, such as the loss of custom styling and the need to manage state outside the adapter.
D20 · ADR Quality· Decision and consequences are absent from the visible text (the body is mostly installation steps for Next.js setup with MantineProvider, no explicit decision or trade-offs) · ×1
Decision and consequences are absent from the visible text (the body is mostly installation steps for Next.js setup with MantineProvider, no explicit decision or trade-offs) documentation/blog/2024-09-09-mantine-ui.md— Add a Decision section stating what concrete component/library will be used and why, plus Consequences covering trade-offs such as package dependency size and learning curve
D20 · ADR Quality· Consequences/trade-offs are implied in the comparison but not explicitly stated (e.g. no npm ecosystem tools, learning curve for new users) · ×1
Consequences/trade-offs are implied in the comparison but not explicitly stated (e.g. no npm ecosystem tools, learning curve for new users) documentation/blog/2024-09-11-pnpm-guide.md— Add a Consequences section noting that pnpm lacks npm features like global scripts and packages, and note any trade-off of requiring pnpm as the default package manager
D20 · ADR Quality· The decision (which frameworks to master) is stated in the title but the body gives no rationale for choosing them over alternatives and no consequences/trade-offs · ×1
The decision (which frameworks to master) is stated in the title but the body gives no rationale for choosing them over alternatives and no consequences/trade-offs documentation/blog/2024-09-16-frameworks-2024.md— Add a Context section explaining why each framework was selected (e.g. React's ecosystem, Svelte's simplicity, Vue's ease of learning) and a Consequences section on trade-offs such as learning curve or tooling dependency
D20 · ADR Quality· Decision and consequences are absent from the visible text (only frameworks with links and a brief framework description appear) · ×1
Decision and consequences are absent from the visible text (only frameworks with links and a brief framework description appear) documentation/blog/2024-09-18-admin-panel-frameworks.md— Add a Decision section stating which frameworks were selected or recommended for each category (React/Vue/Angular/Blazor) and a Consequences section covering trade-offs such as learning curve, ecosystem maturity, and cross-platform support
D20 · ADR Quality· Consequences/trade-offs of choosing gRPC vs REST are not visible before the clip · ×1
Consequences/trade-offs of choosing gRPC vs REST are not visible before the clip documentation/blog/2024-09-24-grpc-vs-rest.md— Add a Consequences section covering trade-offs such as latency/round-trip cost for gRPC versus request/response overhead for REST
D20 · ADR Quality· The body is a tutorial table of contents and prerequisites listing plus an introductory paragraph that states what one will learn but gives no context/problem or explicit decision; the real content (the nine covered topics) is cut by the scanner clip marker · ×1
The body is a tutorial table of contents and prerequisites listing plus an introductory paragraph that states what one will learn but gives no context/problem or explicit decision; the real content (the nine covered topics) is cut by the scanner clip marker documentation/blog/2024-10-22-astro-js.md— Replace the intro with a problem statement motivating Astro (e.g. static site generation vs traditional CMS, speed, ease of setup), and extract the decision (setup steps, project structure, component building) into its own section so it is explicit and consequences/trade-offs are covered
D20 · ADR Quality· The body is an explanatory tutorial rather than a formally structured ADR; trade-offs and consequences are not present in the visible text (only 'round corners' vs elliptical corners explained) · ×1
The body is an explanatory tutorial rather than a formally structured ADR; trade-offs and consequences are not present in the visible text (only 'round corners' vs elliptical corners explained) documentation/blog/2024-10-23-css-rounded-corners.md— Convert this into a decision document: state which corner-shape to use by default, when to prefer one over the other, and any performance or layout consequences
D20 · ADR Quality· Consequences/trade-offs (e.g. over-context usage, performance cost) are not visible before the clip marker · ×1
Consequences/trade-offs (e.g. over-context usage, performance cost) are not visible before the clip marker documentation/blog/2024-10-30-react-context.md
D20 · ADR Quality· The body is a long documentation post about using the keyof operator to define advanced types in TypeScript with examples (the title 'Building components with Radix UI' is unrelated), not an ADR · ×1
The body is a long documentation post about using the keyof operator to define advanced types in TypeScript with examples (the title 'Building components with Radix UI' is unrelated), not an ADR documentation/blog/2024-11-06-radix-ui.md
D20 · ADR Quality· The decision (introducing six editors with pros/cons) is stated but the body clips mid-Introduction before a dedicated comparison table or full coverage of each editor's strengths and weaknesses · ×1
The decision (introducing six editors with pros/cons) is stated but the body clips mid-Introduction before a dedicated comparison table or full coverage of each editor's strengths and weaknesses documentation/blog/2024-11-11-online-ide.md— Add a dedicated section comparing each listed editor (CodeSandbox, Codepen, JSFiddle, StackBlitz, Glitch, Repl.it) side-by-side by feature set, cost, ease-of-use, and use case. The clip occurs before the comparison table is shown.
D20 · ADR Quality· Consequences/trade-offs (e.g. learning curve for Go/parallel model) are not visible before the clip · ×1
Consequences/trade-offs (e.g. learning curve for Go/parallel model) are not visible before the clip documentation/blog/2024-11-12-esbuild.md
D20 · ADR Quality· The body is mostly setup/project-setup content with no context/problem framing or consequences/trade-offs · ×1
The body is mostly setup/project-setup content with no context/problem framing or consequences/trade-offs documentation/blog/2024-12-18-tailwind-grid.md— Add a Context section explaining why CSS Grid was chosen over Flexbox for this project and the trade-offs of using Tailwind's grid classes (e.g. needing to customize tailwind.config.js, learning curve) before stating the decision.
D20 · ADR Quality· Decision/consequences (getting started with the card component, variants like outlined/image cards) fall past the clip marker and cannot be confirmed missing · ×1
Decision/consequences (getting started with the card component, variants like outlined/image cards) fall past the clip marker and cannot be confirmed missing documentation/blog/2024-12-26-mui-card.md
D20 · ADR Quality· Decision and consequences are absent from the visible text (only introduction + table-of-contents plus a one-line description of the article's purpose) · ×1
Decision and consequences are absent from the visible text (only introduction + table-of-contents plus a one-line description of the article's purpose) documentation/blog/2024-12-31-js-substring.md— Add a Decision section stating what substring() usage is being documented or clarified, and a Consequences section noting trade-offs such as the difference between slice/substr and substring
D20 · ADR Quality· The decision (how to install and use React Slick in a project) and consequences/trade-offs are present but deferred past the clip; only context/problem and an informative title are visible · ×1
The decision (how to install and use React Slick in a project) and consequences/trade-offs are present but deferred past the clip; only context/problem and an informative title are visible documentation/blog/2025-01-02-react-slick.md— Ensure the body ends with a concrete Decision section covering installation, import syntax, and usage code, plus Consequences noting trade-offs such as third-party dependency cost or learning curve
D20 · ADR Quality· The body is mostly benefit-driven with no context/problem and no explicit decision (e.g. "use FastAPI instead of Django/Flask") · ×1
The body is mostly benefit-driven with no context/problem and no explicit decision (e.g. "use FastAPI instead of Django/Flask") documentation/blog/2025-01-09-fast-api.md— Add a Context section stating the problem being solved (slow Python backend frameworks) and an Explicit Decision section comparing FastAPI to alternatives, then Consequences covering trade-offs such as learning curve for new developers
D20 · ADR Quality· The title 'Essentials of TypeScript Classes' is informative but the body is primarily a tutorial listing features (type annotations, readonly fields, parameter properties, generics, implements), with no context/problem and no consequences/trade-offs section · ×1
The title 'Essentials of TypeScript Classes' is informative but the body is primarily a tutorial listing features (type annotations, readonly fields, parameter properties, generics, implements), with no context/problem and no consequences/trade-offs section documentation/blog/2025-01-13-ts-classes.md— Add an explicit Context/Problem section explaining why class typing matters for developers working with interfaces or when multiple implementations are needed, then document the trade-offs of adding type annotations to every member
D20 · ADR Quality· The decision (what Bolt.new does and why it matters) is clear but the body ends before covering consequences/trade-offs such as cost, token limits, or how it compares to alternatives · ×1
The decision (what Bolt.new does and why it matters) is clear but the body ends before covering consequences/trade-offs such as cost, token limits, or how it compares to alternatives documentation/blog/2025-02-05-bolt-new.md— Add a Consequences section addressing pricing tiers, token usage costs, and the trade-off of relying on AI-generated code versus full control over design decisions
D20 · ADR Quality· No context/problem section (the body begins with an announcement of Claude 4 without stating the problem being solved) and no consequences/trade-offs · ×1
No context/problem section (the body begins with an announcement of Claude 4 without stating the problem being solved) and no consequences/trade-offs documentation/blog/2025-05-26-claude4.md— Add a Context/Problem section explaining why Refine needs this upgrade (e.g. current output quality, cost, or time spent on styling/configuration) before the decision, then document trade-offs such as increased Refine Credits usage and integration effort
D20 · ADR Quality· The body clips before the decision's consequences/trade-offs are visible (the article 'explores both their successes and the obstacles they encountered along the way' but the actual trade-offs of competing against giants like Google/Apple/Mozilla are not shown in the excerpt) · ×1
The body clips before the decision's consequences/trade-offs are visible (the article 'explores both their successes and the obstacles they encountered along the way' but the actual trade-offs of competing against giants like Google/Apple/Mozilla are not shown in the excerpt) documentation/blog/2025-10-08-arc-browser-journey.md
D20 · ADR Quality· The body compares React Query/TanStack Query/SWR but does not state the problem they solve and only briefly states the decision (React Query is TanStack Query), with no consequences/trade-offs · ×1
The body compares React Query/TanStack Query/SWR but does not state the problem they solve and only briefly states the decision (React Query is TanStack Query), with no consequences/trade-offs documentation/blog/2025-12-01-tanstack-vs-swr.md— Add a Context section explaining what each library solves (e.g. caching, background refetching, optimistic updates) for readers who are new to them, and a Consequences section covering trade-offs like API surface area cost vs the single-benefit of rebranding
No tests found — No test projects found in the repository.
Info — 1 finding(s)
D22 · Internal API Consistency· No exposed public API · ×1
No exposed public API — No intentionally-exposed types (IsPackable or .Contracts) to evaluate.
Appendix B — Reproduction & audit trail
Every external tool invocation behind a deep-scan dimension — the tool, its captured version, the exact command, how many findings it yielded, and a link to the retained raw output. To reproduce any finding: check out the same commit and run the command shown (repo-relative — never an absolute scratch path). The complete raw scanner output is retained verbatim under artifacts/raw/ (indexed in artifacts/raw/index.json); per-invocation exit codes and wall-clock durations are in sidecar.json — kept out of this table so the rendered report stays byte-identical across runs of the same commit.
Run 019fdebe-fce8-7585-914d-7b3cb05836e6 · every finding is also locatable in findings.md, and the complete scoring record (with exit codes + durations) in sidecar.json.
Issues: 105 · Warnings: 97 · Recommendations: 18 · Info: 1 — Appendix A · all findings · full markdown report.
Generated by Watchdog — deterministic code-health analysis. 08-08-2026 @ 00:21 UTC.
Downloadable artifacts
Machine-readable and reproducible from this commit + frozen rubric — drop them straight into a contract appendix, a CRA dossier, or a downstream SCA / VEX tool.