test(totlib): fp→tr equivalence test (L-7a Phase 2)

[k-yoshimi]

Summary

Phase 2 of L-7a cross-module coupling. Adds the equivalence verification: TotPipeline.run_pipeline and a hand-written fp → compute_rjt_volint → tr.set_param('PLHCD', ...) produce identical scalars at 1e-10 relative tolerance. Stacked on PR #178 (Phase 1 Foundation).

• compute_rjt_volint(state, *, R0, a) -> float helper in python/totlib/pipeline.py (per spec §8 R2 — area integral of RJT[ns][i] MA/m² over the uniform rho-grid, returns A)
• COUPLING_RULES[('fp','tr')] populated with one rule (callable src_state_key, dst_param='PLHCD', transform=v*1e-6). PLHCD is dimensionless per R3 — skeleton coupling, see L-7b for EXTERNAL_DRIVEN_I follow-up
• _extract_source split so callable-rule failures (e.g. missing tr:RR) get accurate error messages instead of being routed through the string-key branch
• test_pipeline_equiv.py (3 lib-required tests): equivalence at 1e-10, coupling-doc recording, active-drive sanity guard (compute_rjt_volint >= 1e3 A to prevent vacuous 0 == 0 passes)

CLAUDE.md non-negotiables

• ✅ 1e-10 equivalence test PASSES (no SKIP, no relaxed tolerance, no xfail)
• ✅ pytest.mark.skipif(not _libs_present(), ...) keyed on env build state (allowed: gates the test on the build environment, not on broken-test masking)
• ✅ Legacy Tot class (python/totlib/totlib.py) untouched — test_totlib.py 31/31 still pass

Pre-push gate (CLAUDE.md)

• ✅ superpowers:code-reviewer (HIGH 0, MED 0, 7 Minor — non-blocking; reviewer concluded "ready to push")
• ✅ codex:codex-rescue independent review (APPROVE — no HIGH/MED/LOW findings)
• ✅ REVIEW_OK_fd28c3c1... marker placed
• ✅ No --no-verify, no pytest.mark.skip, no --ignore-glob

Test plan

• PYTHONPATH=python pytest --forked --timeout=120 --timeout-method=signal python/totlib/tests/test_pipeline*.py python/totlib/tests/test_totlib.py — 102 passed in 2.82s (Phase 1 mock 64 + helpers 4 + equivalence 3 + legacy regression 31)
• pytest python/totlib/tests/test_pipeline_equiv.py -v — 3 passed, 0 skipped with lib*.so present
• CI verifies Phase 2 mock suite on Linux (no Fortran touched, no lib*.so required for the mock subset)
• CI verifies the equivalence test on a Linux env with lib*.so built

Commits (6)

SHA	Title
81fbef7e	feat(totlib): add compute_rjt_volint helper
22863d78	test(totlib): clean up test_pipeline_helpers + add nr=0 case
b53e7d40	feat(totlib): populate COUPLING_RULES[('fp','tr')]
ffb6a185	fix(totlib): drop COUPLING_RULES lambda short-circuit; fix pre-existing test
e597a4bd	fix(totlib): split _extract_source error paths + add lambda regression tests
fd28c3c1	test(totlib): add fp→tr equivalence test at 1e-10 tolerance

Plan deviation (documented)

tr_set_param rejects PN1/PN2/PT1/PT2 (the registry requires PN[1]/PN[2]/PT[1]/PT[2] bracket syntax — see python/trlib/trlib.py:209-230 and python/trlib/examples/quickstart.py:33-38). The equiv test splits the plan-template fixture into TR_SCALAR_PARAMS (set via set_params(**...)) and TR_ARRAY_PARAMS (set individually via set_param('PN[1]', ...)). Pattern X and Pattern Y use the same split, preserving equivalence. Plan template should be synced in a follow-up commit.

Spec / plan

• Spec: docs/superpowers/specs/2026-04-28-l7a-cross-module-coupling-design.md §8 R2 (compute_rjt_volint formula) + R3 (PLHCD as skeleton sink, RA-not-RB choice)
• Plan: docs/superpowers/plans/2026-04-28-l7a-cross-module-coupling.md §"Phase 2"

Depends on

• PR feat(totlib): TotPipeline foundation (L-7a Phase 1) #178 (TotPipeline foundation — Phase 1)

Follow-ups (separate PRs)

• PR 3 (Phase 3, MCP): run_pipeline MCP tool + force-close gate + docs (totlib README, tot_mcp README, applications.md ja/en)
• L-7b: tr-side EXTERNAL_DRIVEN_I proper scalar param to replace the PLHCD skeleton

Notes (skeleton coupling caveat)

R3 confirmed PNBCD is not in tr/tr_param_registry.f90. L-7a uses PLHCD (a dimensionless multiplier) as the L-7a sink param — this is API plumbing, not physical fidelity. Spec §3 Non-goals + §12 follow-up "tr に proper EXTERNAL_DRIVEN_I_MA scalar 追加" track the L-7b path. The equivalence test verifies that pattern X and pattern Y compute identical PLHCD inputs and identical tr final scalars; physical fidelity is L-7b scope.

🤖 Generated with Claude Code

---

Note

Medium Risk
Introduces new fp→tr scalar coupling logic (including a numeric RJT integral) that affects run_pipeline behavior and error surfacing when required tr:* params are missing. Risk is mitigated by new unit tests plus lib-backed equivalence tests, but failures could change cross-module parameter injection.

Overview
Adds concrete fp→tr coupling in TotPipeline. Introduces compute_rjt_volint() to integrate fp’s RJT profile (MA/m^2 over rho) into a driven-current scalar (A), then populates COUPLING_RULES[("fp","tr")] to inject PLHCD in tr via an A→MA-scale transform.

Improves coupling error routing. Splits _extract_source handling so callable-based rules raise TotPipelineCouplingError with clearer exception type/message (e.g., missing tr:RR/tr:RA) instead of falling through to the string-key path.

Expands test coverage. Updates existing pipeline tests for the now-populated rule set, adds targeted rule-regression tests (presence, lambda behavior, missing-param error), adds standalone compute_rjt_volint unit tests, and adds a skip-gated lib-backed equivalence suite asserting hand-wired fp→tr matches run_pipeline at 1e-10 relative tolerance.

^{Reviewed by Cursor Bugbot for commit fd28c3c. Bugbot is set up for automated code reviews on this repo. Configure here.}

[k-yoshimi]

@cursor review

[cursor]

✅ Bugbot reviewed your changes and found no new issues!

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit fd28c3c. Configure here.}