docs: replace volatile counts/formulas with pointers to source of truth

Author: sbryngelson

.claude/rules/common-pitfalls.md

@@ -4,9 +4,9 @@
 - Grid dimensions: `m`, `n`, `p` (cells in x, y, z). 1D: n=p=0. 2D: p=0.
 - Interior domain: `0:m`, `0:n`, `0:p`
 - Buffer/ghost region: `-buff_size:m+buff_size` (similar for n, p in multi-D)
-- `buff_size` is set per reconstruction scheme in `s_configure_coordinate_bounds` (`m_helper_basic.fpp`):
-  WENO `weno_polyn + 2` (`2*weno_polyn + 2` if `viscous`), MUSCL `muscl_polyn + 2`, IGR `(igr_order-1)/2 + 2`;
-  then floored to `max(.,6)` with Lagrange bubbles and `max(.,10)` with IB. Don't assume `2*weno_polyn + 2`.
+- `buff_size` is **not** a single formula: it's set per reconstruction scheme (WENO/MUSCL/IGR) in
+  `s_configure_coordinate_bounds` (`m_helper_basic.fpp`) and floored higher for Lagrange bubbles and IB.
+  Read that routine for the current value rather than assuming one.
 - Domain bounds: `idwint(1:3)` (interior `0:m`), `idwbuff(1:3)` (with ghost cells)
 - Cell-center coords: `x_cc(-buff_size:m+buff_size)`, `y_cc(...)`, `z_cc(...)`
 - Cell-boundary coords: `x_cb(-1-buff_size:m+buff_size)`

.claude/rules/gpu-and-mpi.md

@@ -33,7 +33,7 @@ Full set with signatures in `parallel_macros.fpp`. The ones you reach for most:
 Others in `parallel_macros.fpp`: `GPU_ENTER_DATA`/`GPU_EXIT_DATA`, `GPU_DECLARE`, `GPU_ROUTINE`,
 `GPU_ATOMIC`, `GPU_WAIT`, and the block macros `GPU_DATA`, `GPU_HOST_DATA`.
 
-Typical GPU loop pattern (used 750+ times in the codebase):
+Typical GPU loop pattern (the dominant spatial-loop idiom):
 ```
 $:GPU_PARALLEL_LOOP(private='[i,j,k,l]', collapse=3)
 do l = idwbuff(3)%beg, idwbuff(3)%end

.claude/rules/parameter-system.md

@@ -1,7 +1,7 @@
 # Parameter System
 
 ## Overview
-MFC has ~3,400 simulation parameters defined in Python and read by Fortran via namelist files.
+MFC's simulation parameters are defined in Python and read by Fortran via namelist files.
 
 ## Parameter Flow: Python → Fortran
 

CLAUDE.md

@@ -29,17 +29,17 @@ Run `./mfc.sh <command> --help` for the full flag set; the most-used invocations
 ./mfc.sh build -j 8                 # all 3 targets; flags: -t <target>, --gpu acc|mp, --debug,
                                     #   -i case.py --case-optimization (10x speedup)
 ./mfc.sh run case.py -n 4           # run with 4 MPI ranks; --no-build; -e batch (toolchain/templates/)
-./mfc.sh test -j 8                  # full suite (560+); --only <1D|Bubbles|UUID>, -l, -% N (sample),
+./mfc.sh test -j 8                  # full suite; --only <1D|Bubbles|UUID>, -l, -% N (sample),
                                     #   --generate (regenerate golden files after an intended output change)
 
 # Verify before committing
-./mfc.sh precheck -j 8              # all 7 CI lint checks
+./mfc.sh precheck -j 8              # all CI lint checks
 ./mfc.sh format -j 8               # auto-format Fortran (.fpp/.f90) + Python
 ./mfc.sh lint                       # ruff lint + Python unit tests   (spelling: ./mfc.sh spelling)
 
 # Case files
 ./mfc.sh validate case.py           # validate without running
-./mfc.sh params <query>             # search 3,400 case parameters
+./mfc.sh params <query>             # search case parameters
 ./mfc.sh new <name>                 # new case from template       (clean: ./mfc.sh clean)
 ```
 
@@ -66,7 +66,7 @@ IMPORTANT: Follow this loop for ALL code changes. Do not skip steps.
 2. **Plan** — For multi-file changes, outline your approach before implementing.
 3. **Implement** — Make small, focused changes. One logical change per commit.
 4. **Format** — Run `./mfc.sh format -j 8` to auto-format.
-5. **Verify** — Run `./mfc.sh precheck -j 8` (same 7 checks as CI lint gate).
+5. **Verify** — Run `./mfc.sh precheck -j 8` (same checks as the CI lint gate).
 6. **Build** — Run `./mfc.sh build -j 8` to verify compilation.
 7. **Test** — Run relevant tests: `./mfc.sh test --only <feature> -j 8`.
    For changes to `src/common/`, test ALL three targets: `./mfc.sh test -j 8`.
@@ -86,11 +86,11 @@ src/
   simulation/     # CFD solver (GPU-accelerated via OpenACC / OpenMP target offload)
   post_process/   # Data output and visualization
 toolchain/        # Python CLI, build system, testing, parameter management
-  mfc/params/definitions.py   # ~3,400 parameter definitions (source of truth)
+  mfc/params/definitions.py   # parameter definitions (source of truth)
   mfc/case_validator.py       # Physics constraint validation
   mfc/test/                   # Test runner and case generation
 examples/         # Example simulation cases (case.py files)
-tests/            # 560+ regression test golden files
+tests/            # regression test golden files
 ```
 
 Source files are `.fpp` (Fortran + Fypp macros), preprocessed to `.f90` by CMake.