chore: reduce CRAPload fragility — cover 19 zero-coverage functions at CRAP >= 30

[yvonnedevlinrh]

CRAPload at threshold boundary: 19 functions with 0% coverage and CRAP >= 30

Problem

The CI CRAPload threshold is --max-crapload=38 and main is at exactly CRAPload: 38/38. There are 19 functions with 0% line coverage and CRAP scores >= 30, plus 3 more in the 25-29 range that could tip over with minor complexity changes.

This makes the threshold gate fragile — any bug fix or feature that adds even one branch to a zero-coverage function risks breaking CI, as discovered in #131 (PR #160) where a single && condition increased detectP1CallEffects complexity from 14 to 15 and caused a CRAPload breach.

With 0% coverage, CRAP scores are computed as complexity² + complexity, so complexity increases are amplified quadratically. Even modest coverage (e.g., 50%) would dramatically reduce CRAP scores and create headroom for legitimate complexity growth.

Functions at CRAP >= 30 with 0% coverage (19 total)

Function	Complexity	CRAP	Fix Strategy
crap.BuildContractCoverageFunc	22	506.0	decompose_and_test
aireport.runQualityForPackage	10	110.0	add_tests
crap.analyzePackageCoverage	10	110.0	add_tests
aireport.runQualityStep	8	72.0	add_tests
aireport.runClassifyStep	8	72.0	add_tests
crap.loadTestPackage	8	72.0	add_tests
analysis.detectASTReceiverMutations	24	67.0	decompose
quality.matchContainerUnwrap	50	55.2	decompose
main.runCrap	21	51.0	decompose
main.(analyzeModel).Update	6	42.0	add_tests
aireport.resolvePackagePaths	6	42.0	add_tests
crap.resolvePackagePaths	6	42.0	add_tests
quality.WriteText	32	39.9	decompose
analysis.isPointerArgStore	13	34.1	add_tests
report.writeOneResult	32	32.3	decompose
quality.matchAssertionToEffect	25	32.2	decompose
quality.isTransformationCall	26	31.4	decompose
main.findModuleRoot	5	30.0	add_tests
aireport.loadTestPackageForQuality	5	30.0	add_tests

Functions at risk (CRAP 25-29, 0% coverage)

Function	Complexity	CRAP	Fix Strategy
quality.resolveSSAValueToObj	11	29.4	add_tests
quality.Assess	25	27.8	decompose
loader.LoadModule	7	27.7	add_tests

Suggested approach

1. High-value targets first: The 10 add_tests functions have low complexity (5-13) — even basic coverage would drop them well below the threshold and create CRAPload headroom.
2. Decompose the worst offenders: BuildContractCoverageFunc (complexity 22, CRAP 506) and matchContainerUnwrap (complexity 50, CRAP 55) need structural decomposition before tests are practical.
3. Goal: Reduce CRAPload from 38 to ~30, giving a buffer of 8 functions before the threshold is reached again.

Context

• Current threshold: --max-crapload=38 (set in .github/workflows/test.yml)
• Current CRAPload: 38 (exactly at boundary)
• Related: Bug: http.ResponseWriter.Write() double-counts as both WriterOutput and HTTPResponseWrite #131, PR fix: prevent http.ResponseWriter.Write() double-count as WriterOutput and HTTPResponseWrite #160

[yvonnedevlinrh]

Triage / Action Plan

Scope Update

3 functions from the original list have been consolidated into internal/loader/ (with existing tests) during the analyze-multi-package change:

• aireport.resolvePackagePaths → loader.ResolvePackagePaths
• crap.resolvePackagePaths → loader.ResolvePackagePaths
• main.findModuleRoot → loader.FindModuleRoot

Remaining scope: 16 functions across 6 packages.

Approach

• OpenSpec proposal per phase, separate PRs per phase.

Phase 1 — add_tests quick wins (10 functions)

Low complexity (5–13), where even basic coverage collapses CRAP quadratically. Expected CRAPload reduction: ~10 functions drop below threshold.

PR 1a — internal/crap/ + internal/aireport/ (7 functions)

• analyzePackageCoverage (complexity 10, CRAP 110)
• loadTestPackage (complexity 8, CRAP 72)
• runQualityStep (complexity 8, CRAP 72)
• runClassifyStep (complexity 8, CRAP 72)
• runQualityForPackage (complexity 10, CRAP 110)
• loadTestPackageForQuality (complexity 5, CRAP 30)
• aireport.resolvePackagePaths (complexity 6, CRAP 42)

PR 1b — cmd/gaze/ + internal/report/ + internal/analysis/ (3 functions)

• (analyzeModel).Update (complexity 6, CRAP 42)
• isPointerArgStore (complexity 13, CRAP 34)
• writeOneResult (complexity 32, CRAP 32)

Phase 2 — decompose targets (6 functions)

High complexity where structural refactoring is needed before tests are practical.

• PR 2a — BuildContractCoverageFunc (CRAP 506, worst offender)
• PR 2b — internal/quality/mapping.go (3 interrelated functions)
• PR 2c — Remaining: detectASTReceiverMutations, WriteText, runCrap

Phase 3 — Threshold tightening

Lower --max-crapload from 38 to ~30–33 to lock in headroom.

Goal

CRAPload: 38 → ~30, creating an 8-function buffer against future complexity growth.

[yvonnedevlinrh]

PR 1a refinement (post-triage)

Scope adjustment: BuildContractCoverageFunc (CRAP 506) moved from PR 1a to PR 2a. It needs structural decomposition (extracting the coverage-map-builder as a pure function) before testing is practical.

Coverage accounting finding: gaze crap runs go test -short internally to generate coverage profiles. Tests guarded by testing.Short() are skipped and contribute zero coverage to CRAPload. PR 1a therefore requires light dependency injection (similar to the existing pipelineStepFuncs pattern) so tests run without -short guard. This makes PR 1a a refactoring + test PR, not test-only.

Dedup note: loadTestPackage (internal/crap) and loadTestPackageForQuality (internal/aireport) are near-identical. Tests added separately in PR 1a; consolidation deferred to PR 2a (same file as BuildContractCoverageFunc).

aireport.resolvePackagePaths: Confirmed gone — consolidated into loader.ResolvePackagePaths during the analyze-multi-package change. Removed from PR 1a scope.

Updated PR 1a scope (6 functions, refactoring + test):

• loadTestPackage (crap, complexity 8, CRAP 72)
• loadTestPackageForQuality (aireport, complexity 5, CRAP 30)
• analyzePackageCoverage (crap, complexity 10, CRAP 110) — extend existing tests
• runQualityForPackage (aireport, complexity 10, CRAP 110)
• runQualityStep (aireport, complexity 8, CRAP 72)
• runClassifyStep (aireport, complexity 8, CRAP 72)

Updated PR 2a scope:

• BuildContractCoverageFunc — decompose + test
• loadTestPackage / loadTestPackageForQuality dedup

Implementation constraints:

• DI-based tests must use synthetic data — no dependency on go mod download state or build artifacts, so fresh worktree execution passes by design.
• Leaf function tests (loadTestPackage, loadTestPackageForQuality) that call packages.Load on testdata fixtures should use fixtures with no external imports to avoid module resolution failures in clean environments.

[yvonnedevlinrh]

PR 1b scope — cmd/gaze/ + internal/analysis/ (2 functions)

Branch: opsx/crapload-di-coverage-pr1b
OpenSpec artifacts: openspec/changes/crapload-di-coverage-pr1b/ (proposal, design, specs, tasks — all complete)
Depends on: PR #183 (Phase 1a) merged first

Scope adjustment from original triage

writeOneResult (complexity 32, CRAP 32.3) moved to Phase 2 — its fix strategy is decompose, not add_tests. Complexity is sequential formatting logic but at 32 it needs structural decomposition before testing is practical.

Updated PR 1b scope (2 functions, test-only + 1 export shim)

Function	Package	Complexity	CRAP	Approach
(analyzeModel).Update	cmd/gaze	6	42.0	Direct tests with synthetic tea.Msg values
isPointerArgStore	internal/analysis	13	34.1	Export shim + direct branch coverage tests

Implementation details

(analyzeModel).Update — No production changes. 5 tests in cmd/gaze/interactive_test.go covering all tea.Msg branches: WindowSizeMsg init, WindowSizeMsg resize, KeyMsg quit (verify tea.Quit), KeyMsg help (toggle ShowAll), unhandled message passthrough. TestMain already sets ASCII rendering — no additional setup.

isPointerArgStore — One export shim (IsPointerArgStore) added to internal/analysis/export_test.go following the existing pattern (6 shims already exist: FindFuncDecl, SafeSSABuild, ExprRootIdent, etc.). 6-7 tests in mutation_test.go covering all 6 branch paths: direct trace, UnOp dereference, FieldAddr, FieldAddr+UnOp, IndexAddr, IndexAddr+UnOp, plus negative cases (local var, empty params, receiver-only store). One new testdata fixture (SetTimeout) added to testdata/src/mutation/mutation.go for the FieldAddr branch — existing fixtures cover UnOp (FillSlice), IndexAddr (Normalize), and no-match (ReadOnly) but not struct-field-through-pointer-param.

Implementation constraints

• Tests MUST NOT be guarded by testing.Short() — gaze crap runs go test -short internally, so guarded tests contribute zero coverage to CRAPload.
• Testdata fixtures use only stdlib types — no external imports, so tests pass in clean worktrees without go mod download.
• [P] parallelism: the two function groups touch different packages (cmd/gaze/ vs internal/analysis/) so tasks 2 and 3 in tasks.md are parallel-eligible.

Expected CRAPload impact

• (analyzeModel).Update: CRAP 42 → <15 with ~80% coverage
• isPointerArgStore: CRAP 34 → <15 with ~80% coverage
• Net CRAPload: 32 → ~30 (2-function reduction, reaching the issue's target buffer)

Updated phase plan

Phase	PR	Scope	Status
1a	#183	6 functions in crap/ + aireport/ (DI + tests)	Merged
1b	—	2 functions in cmd/gaze/ + analysis/ (tests only)	Ready for implementation
2a	—	BuildContractCoverageFunc decompose + test + dedup	Planned
2b	—	writeOneResult + quality/mapping.go decompose	Planned
2c	—	Remaining decompose targets	Planned
3	—	Threshold tightening (--max-crapload 38 → ~30-33)	Planned

[yvonnedevlinrh]

Post-Phase 1 Triage — CRAPload at 30/38

Current state (as of main @ 4e8d800, 2026-07-07)

CRAPload:     30/38 (PASS) — down from 38
GazeCRAPload:  5/6  (PASS)

Phase 1 reduced CRAPload by 8 functions (38 → 30), meeting the original issue's target of "~30, giving a buffer of 8 functions."

Phase 1 results

PR	Branch	Merged	Functions covered	CRAPload impact
#183 (Phase 1a)	opsx/crapload-di-coverage-pr1a	2026-07-03	6: analyzePackageCoverage, loadTestPackage, runQualityStep, runClassifyStep, runQualityForPackage, loadTestPackageForQuality	38 → 36 (provider-cleanup package moves reduced effective gain)
#187 (Phase 1b)	opsx/crapload-di-coverage-pr1b	2026-07-06	2: (analyzeModel).Update (CRAP 42→6, 100% cov), isPointerArgStore (CRAP 34→~17, 50% cov)	36 → 35 (per PR); 30 on latest main after concurrent merges stabilized

CRAPload trajectory note: The per-PR deltas don't sum cleanly because other merged work (PR #180 provider-cleanup, PR #184 universal-taxonomy, PR #188 ssa-charmbracelet-log) shifted function locations and complexities between phases. The authoritative number is CI on main: CRAPload 30/38.

Key discoveries from Phase 1

1. Package moves affect CRAPload accounting. PR chore: add DI and tests for 6 zero-coverage pipeline functions #183 covered 6 functions in internal/crap/, but PR refactor: provider cleanup — remove deprecated fields, generalize taxonomy, add streaming protocol #180 (provider-cleanup) moved them to internal/provider/goprovider/ — test coverage at the old path didn't carry over. The actual reduction was less than projected until subsequent merges stabilized.
2. isPointerArgStore has structurally unreachable branches. tracesToParam already resolves through FieldAddr/IndexAddr/UnOp chains before isPointerArgStore is called, capping line coverage at ~50%. This function should be a decompose target (Phase 2), not add_tests.
3. writeOneResult was correctly deferred. Its complexity (32) and sequential formatting structure make decomposition the right approach, not bolt-on tests.

Scope reconciliation — original 19 functions

#	Function (original name)	Current location	Status	Resolution
1	crap.BuildContractCoverageFunc	goprovider.BuildContractCoverageFunc	Phase 2a	Moved by provider-interfaces. Decompose + test.
2	aireport.runQualityForPackage	aireport/runner_steps.go	✅ Done (1a)	DI + 7 tests via PR #183
3	crap.analyzePackageCoverage	goprovider/contract.go	✅ Done (1a)	DI + 9 tests via PR #183
4	aireport.runQualityStep	aireport/runner_steps.go	✅ Done (1a)	DI + 5 tests via PR #183
5	aireport.runClassifyStep	aireport/runner_steps.go	✅ Done (1a)	DI + 6 tests via PR #183
6	crap.loadTestPackage	goprovider/contract.go	✅ Done (1a)	Indirect tests via PR #183
7	analysis.detectASTReceiverMutations	analysis/mutation.go	Phase 2c	Decompose. Complexity 24, 3 AST node types in single closure.
8	quality.matchContainerUnwrap	quality/mapping.go	Phase 2b	Decompose. Complexity 50, worst in codebase.
9	main.runCrap	cmd/gaze/main.go	Phase 2c	Decompose. Complexity 21, has tests but still high CRAP.
10	main.(analyzeModel).Update	cmd/gaze/interactive.go	✅ Done (1b)	5 tests, CRAP 42→6 via PR #187
11	aireport.resolvePackagePaths	loader.ResolvePackagePaths	✅ Resolved	Consolidated by analyze-multi-package. Has tests.
12	crap.resolvePackagePaths	loader.ResolvePackagePaths	✅ Resolved	Consolidated by analyze-multi-package. Has tests.
13	quality.WriteText	quality/report.go	Phase 2c	Decompose. Complexity 32. Has partial tests.
14	analysis.isPointerArgStore	analysis/mutation.go	⚠️ Partial (1b), Phase 2c	Tests added (50% cov) but unreachable branches need decompose.
15	report.writeOneResult	report/text.go	Phase 2c	Decompose. Complexity 32. Deferred from 1b.
16	quality.matchAssertionToEffect	quality/mapping.go	Phase 2b	Decompose. Complexity 25. No direct tests.
17	quality.isTransformationCall	quality/mapping.go	Phase 2b	Decompose. Complexity 26. Minimal tests.
18	main.findModuleRoot	crap.findModuleRoot	✅ Resolved	Moved out of main. Has tests.
19	aireport.loadTestPackageForQuality	aireport/runner_steps.go	✅ Done (1a)	Tests via PR #183

Resolved: 11 of 19 functions addressed (8 done via Phase 1, 3 resolved by other work).
Remaining: 8 functions for Phase 2 (all decompose strategy).

Updated phase plan

Phase	PR	Scope	Functions	Status
1a	#183	DI + tests for crap/ + aireport/ pipeline functions	6	✅ Merged
1b	#187	Tests for cmd/gaze/ + analysis/	2	✅ Merged
2a	—	BuildContractCoverageFunc decompose + test; loadTestPackage/loadTestPackageForQuality dedup	1 + dedup	Planned
2b	—	quality/mapping.go decompose: matchContainerUnwrap (50), matchAssertionToEffect (25), isTransformationCall (26)	3	Planned
2c	—	Remaining decompose: detectASTReceiverMutations (24), quality.WriteText (32), writeOneResult (32), runCrap (21), isPointerArgStore restructure (13)	5	Planned
3	—	Threshold tightening: --max-crapload 38 → ~30–33	—	Planned (blocked on Phase 2)

Recommendation

The 8-function buffer goal has been achieved (CRAPload 30/38). Phase 2 decomposition work is valuable for long-term maintainability but is no longer urgent for CI stability. Suggested prioritization:

1. Phase 2a (BuildContractCoverageFunc, CRAP 506) is the highest-value next step — it's the single worst offender and the dedup opportunity saves maintenance cost.
2. Phase 2b (quality/mapping.go trio) could be grouped as a single PR since the 3 functions are interrelated in the same file.
3. Phase 3 threshold tightening should wait until Phase 2 makes meaningful progress — lowering the threshold now would consume the buffer just won.