Postcampaign P0+P1 batch: ordering convention, _has_trfn, projection-NaN, warns, seeds, guard

P0 (probe-adjudicated):
- #1 process_raw_solution: probe = LATENT (0/79 registry models reorder under MTK 11,
  adversarial declaration order preserved) — fixed as convention unification: the
  pre-err parameter pass resolves by findfirst against MTK order exactly like the
  states loop (identical behavior when orders match); the redundant post-err second
  pass is deleted; the seeded-rescue producer's MIXED-convention raw_sol (states
  MTK-ordered, params original-ordered) is unified to MTK order.
- #2 _has_trfn checked p_true, but trfn vars are transform-added STATES (live in
  ic) — was always false, so multipoint never disabled for transcendental models.
  Now checks ic ∪ p_true.
- #3 MP→SP projection fabricated 0.0 for unmapped vars — now NaN (fails the
  candidate's ODE solve → err 1e15 → ranked out; the 0.0 solved plausibly).
  Same class as the Phase-C data-evaluator fixes.

P1:
- The three multipoint failure catches (template build / combo eval / HC solve) no
  longer gate their @warn on opts.diagnostics (maxlog=10) — a systematically
  failing multipoint stage was invisible at default verbosity.
- Structural RNG seeded: the QR-pivot draw deciding WHICH unidentifiable parameter
  gets fixed; both template rank-probe loops (matching the already-seeded
  noise-frontier twin); the terminal direct-opt rescue (hash-derived per problem);
  _track_gamma_straight's default rng. fast_core's lone unseeded noisy sampling
  seeded (+ using Random).
- Final polish ODE solve guarded (try/catch + polish_ode_maxiters, mirroring the
  in-loss solve) — a throwing integrator in the terminal rescue paths no longer
  kills the estimation.

Tracker checkboxes updated. Full suite: 755/755 green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: orebas

docs/2026-06-10_postcampaign_review.md

@@ -16,7 +16,7 @@ surface (261 unique exports) plus two god files remain the big structural debts.
 
 ## P0 — correctness / broken-now (probe, then fix)
 
-- [ ] **#1 `process_raw_solution` parameter-ordering self-disagreement.** First pass
+- [x] **#1 `process_raw_solution` parameter-ordering self-disagreement.** FIXED 2026-06-10 — probe: LATENT (0/79 registry models + adversarial case reorder under MTK 11); single findfirst pass, second pass deleted, seeded-rescue producer's MIXED-convention vector unified to MTK order. First pass
   assigns params positionally by `original_parameters` index, solves the ODE and
   computes `err` from that assignment; a second pass then re-keys the same dict by
   `findfirst` in MTK order (`parameter_estimation.jl:779-783` vs `:830-840`; states
@@ -26,13 +26,13 @@ surface (261 unique exports) plus two god files remain the big structural debts.
   err/solution and the returned parameter dict describe DIFFERENT vectors.
   VERIFIED code; latent (no CI model reorders). **Probe:** a model whose MTK
   param order differs from declaration order; assert err matches the dict.
-- [ ] **#2 `_has_trfn` inspects `p_true`, but trfn vars live in `ic`** —
+- [x] **#2 `_has_trfn` inspects `p_true`, but trfn vars live in `ic`** —
   always false, so multipoint never disables for transcendental models
   (`optimized_multishot:1731` vs `transcendental_utils.jl:620-633`); downstream
   the count-mismatch fallback bakes PROBE-point data into combo equations
   (`multipoint_template.jl:771-790`) → wrong-time candidates with wrong
   provenance, silently. VERIFIED.
-- [ ] **#3 Multipoint→single-point projection fabricates `0.0`** for unmapped vars
+- [x] **#3 Multipoint→single-point projection fabricates `0.0`** for unmapped vars
   (`optimized_multishot:2457`) — the exact class Phase C exterminated in the data
   evaluators. Fix: NaN (existing finite guards reject). VERIFIED mechanism.
 - [ ] **#4 `Pkg.test()` is broken: `Random` missing from the test target**
@@ -48,7 +48,7 @@ surface (261 unique exports) plus two god files remain the big structural debts.
 
 ## P1 — silent failure / state / flakiness
 
-- [ ] **Multipoint failures invisible at default verbosity:** template-build,
+- [x] **Multipoint failures invisible at default verbosity:** template-build,
   combo-eval, and multipoint-HC catches all gate their `@warn` on
   `opts.diagnostics` (`optimized_multishot:2313,2406,2435`) — incl. the Phase-C5
   one whose comment promises the opposite. Ungate with `maxlog`. VERIFIED.
@@ -66,7 +66,7 @@ surface (261 unique exports) plus two god files remain the big structural debts.
   `_NOISE_VALIDATION_CACHE` keyed by `objectid` — unbounded session growth +
   GC-reuse wrong-Jacobian collision risk (`noise_frontier_construction.jl:664`).
   VERIFIED growth/race chain; INFERRED collision.
-- [ ] **Unseeded RNG in structural decisions + stochastic src paths reachable from
+- [x] **Unseeded RNG in structural decisions + stochastic src paths reachable from
   CI:** `_rank_based_fix_candidates` pivot RNG decides WHICH unidentifiable param
   gets fixed (`parameter_estimation.jl:420`); rank-probe `randn` in template
   stripping (`multipoint_template.jl:135,283` — the NF twin seeds the identical
@@ -82,7 +82,7 @@ surface (261 unique exports) plus two god files remain the big structural debts.
   `data_values` shorter than `data_vars` (`multipoint_template.jl:1062,1139`);
   legacy range-builder admits non-contiguity the NF builder sorts away. Assert
   equality. VERIFIED code / INFERRED trigger.
-- [ ] **Unguarded final ODE re-solve in polish** kills the whole estimation in the
+- [x] **Unguarded final ODE re-solve in polish** kills the whole estimation in the
   nothing-else-worked path (`parameter_estimation.jl:2375`; bare callers
   `optimized_multishot:2910`, `parameter_estimation.jl:2836`). Wrap like the loss.
   VERIFIED.

src/core/homotopy_continuation.jl

@@ -749,7 +749,9 @@ This is distinct from `ParameterHomotopy` (the straight real parameter path, no
 real discriminant and stall (`terminated_max_steps`).
 """
 function _track_gamma_straight(hc_system, starts, p_start, p_target;
-	show_progress = false, rng = MersenneTwister(), max_seeds = 5, target_count = length(starts))
+	show_progress = false, rng = MersenneTwister(0x67a44a01), max_seeds = 5, target_count = length(starts))
+	# Deterministic default rng (postcampaign review P1): all in-package callers
+	# pass rng explicitly; an unseeded default made direct calls run-to-run random.
 	ps = ComplexF64.(p_start)
 	pt = ComplexF64.(p_target)
 	best_res = nothing

src/core/multipoint_template.jl

@@ -131,8 +131,11 @@ function _rank_aware_topdown_strip(equations::Vector, variables::Vector,
     f_combined = _compile_system_function(equations, variables)
     J_full = nothing
     best_full_rank = 0
+    # Seeded rank probes (postcampaign review P1): equation-stripping decisions
+    # must be deterministic; the noise-frontier twin already seeds identically.
+    probe_rng = MersenneTwister(0x9f4d0329)
     for _ in 1:n_rank_probes
-        rand_point = randn(n_var) .* 10.0
+        rand_point = randn(probe_rng, n_var) .* 10.0
         J_probe = ForwardDiff.jacobian(f_combined, rand_point)
         r = rank(J_probe; atol = rank_atol)
         if r > best_full_rank
@@ -279,8 +282,11 @@ function _sensitivity_aware_strip(equations::Vector, variables::Vector,
     f_combined = _compile_system_function(equations, variables)
     J_full = nothing
     best_full_rank = 0
+    # Seeded rank probes (postcampaign review P1): equation-stripping decisions
+    # must be deterministic; the noise-frontier twin already seeds identically.
+    probe_rng = MersenneTwister(0x9f4d0329)
     for _ in 1:n_rank_probes
-        rand_point = randn(n_var) .* 10.0
+        rand_point = randn(probe_rng, n_var) .* 10.0
         J_probe = ForwardDiff.jacobian(f_combined, rand_point)
         r = rank(J_probe; atol = rank_atol)
         if r > best_full_rank

src/core/optimized_multishot_estimation.jl

@@ -1728,7 +1728,13 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 
 		# Check if we should use parameter homotopy and/or multi-point template.
 		# Both can run — single-point always runs, multipoint adds solutions to the pool.
-		_has_trfn = any(startswith(replace(string(k), "(t)" => ""), "_trfn_") for k in keys(PEP.p_true))
+		# trfn vars are STATES added by transform_pep_for_estimation — they land in
+		# PEP.ic, not p_true (postcampaign review P0#2: the old p_true-only check was
+		# always false, so multipoint never disabled for transcendental models).
+		_has_trfn = any(
+			startswith(replace(string(k), "(t)" => ""), "_trfn_")
+			for k in Iterators.flatten((keys(PEP.ic), keys(PEP.p_true)))
+		)
 		use_multipoint = opts.use_multipoint && opts.system_solver == SolverHC && !_has_trfn
 		use_param_homotopy = opts.use_parameter_homotopy && opts.system_solver == SolverHC && n_points >= 3
 
@@ -2311,7 +2317,9 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 							n_points = opts.multipoint_n_points, diagnostics = opts.diagnostics)
 					end
 				catch e
-					opts.diagnostics && @warn "[MULTIPOINT] Template build failed" exception = e
+					# Ungated (postcampaign review P1): a systematically failing template
+					# build must not be invisible at default verbosity.
+					@warn "[MULTIPOINT] Template build failed" exception = e maxlog = 10
 					nothing
 				end
 				if !isnothing(result)
@@ -2406,7 +2414,7 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 						catch e
 							# A systematic combo-eval failure must not be
 							# indistinguishable from "no combos available".
-							opts.diagnostics && @warn "[MULTIPOINT] combo evaluation failed" exception = (e, catch_backtrace())
+							@warn "[MULTIPOINT] combo evaluation failed" exception = (e, catch_backtrace()) maxlog = 10
 						end
 					end
 				_t_mpt_eval_elapsed = time() - _t_mpt_eval_start
@@ -2433,7 +2441,7 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 								precomputed_generic_solutions = _mpt_sols0,
 								precomputed_generic_params = _mpt_p0)
 					catch e
-						opts.diagnostics && @warn "[MULTIPOINT] HC solve failed" exception = e
+						@warn "[MULTIPOINT] HC solve failed" exception = e maxlog = 10
 						nothing
 					end
 					_t_mpt_solve_elapsed = time() - _t_mpt_solve_start
@@ -2453,8 +2461,12 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 						n_projected = 0
 						for (pidx, combo_sols) in enumerate(solutions_by_combo)
 							for sol in combo_sols
-								# Project: extract only the components matching single-point vars
-								projected = Float64[idx > 0 ? sol[idx] : 0.0 for idx in mp_to_sp]
+								# Project: extract only the components matching single-point vars.
+								# Unmapped vars are NaN (NEVER 0.0 — a fabricated value enters the
+								# candidate pool as plausible data; the downstream finite guards
+								# reject NaN cleanly). Postcampaign review P0#3, same class as
+								# the Phase-C data-evaluator fixes.
+								projected = Float64[idx > 0 ? sol[idx] : NaN for idx in mp_to_sp]
 								push!(interp_solutions, projected)
 								push!(interp_time_indices, evals[pidx].time_indices[1])
 								push!(interp_source_types, :multipoint)
@@ -2775,7 +2787,12 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 							end
 
 							raw_sol = raw_ic
-							append!(raw_sol, Float64[params_dict[p] for p in PEP.model.original_parameters])
+							# Parameter block in CURRENT (MTK) order — the convention
+							# process_raw_solution decodes; the states above (raw_ic)
+							# are already MTK-ordered (unknown_syms). Was
+							# original_parameters: a MIXED-convention vector
+							# (postcampaign review P0#1).
+							append!(raw_sol, Float64[params_dict[p] for p in ModelingToolkit.parameters(PEP.model.system)])
 
 							ordered_s, ordered_p, ode_solution, err = _with_detailed_timing_context(:algebraic_resolve_seeded_candidate) do
 								process_raw_solution(
@@ -2893,8 +2910,13 @@ function optimized_multishot_parameter_estimation(PEP::ParameterEstimationProble
 						# Draw on unit scale and clamp into bounds when present — uniform-in-bounds
 						# under ±1e9 default bounds almost always blows up the ODE and Optim 2's
 						# Fminbox hard-errors on the resulting NaN initial mu.
+						# Seeded per problem (postcampaign review P1): unseeded draws made
+						# this terminal rescue a per-session coin flip — the same class as
+						# the direct-opt canary flake (ddb06b4). Hash-derived like the
+						# RESOLVE-SEED pattern above.
+						_draw_rng = MersenneTwister(UInt(abs(hash((PEP.name, :direct_opt_fallback_seed)))))
 						_draw = scale -> begin
-							raw = scale .* randn(p_size)
+							raw = scale .* randn(_draw_rng, p_size)
 							(isnothing(ctx.lb) || isnothing(ctx.ub)) ? raw : clamp.(raw, ctx.lb, ctx.ub)
 						end
 						p0 = _draw(1.0)

src/core/parameter_estimation.jl

@@ -415,9 +415,13 @@ function _rank_based_fix_candidates(candidate_vars, symbolic_identifiable_funcs,
 	for f in funcs_filtered
 		union!(all_vars, Symbolics.get_variables(f))
 	end
+	# Seeded (postcampaign review P1): this Jacobian's pivoted-QR column order
+	# decides WHICH unidentifiable parameter gets fixed to 1.0 — a structural
+	# decision that must not vary run-to-run with the global RNG.
+	fix_probe_rng = MersenneTwister(0x9f4d0329)
 	val_dict = Dict{Num, Float64}()
 	for v in all_vars
-		val_dict[v] = 0.5 + rand()
+		val_dict[v] = 0.5 + rand(fix_probe_rng)
 	end
 	J_num = Array{Float64}(undef, length(funcs_filtered), length(param_syms))
 	for i in 1:size(J_sym, 1)
@@ -776,10 +780,18 @@ function process_raw_solution(raw_sol, model::OrderedODESystem, data_sample, ode
 		ordered_states[state] = raw_sol[idx]
 	end
 
-	# Reorder parameters according to original ordering
+	# Reorder parameters according to original ordering. raw_sol's parameter block
+	# is in CURRENT (MTK) order — the same convention as the states block above and
+	# as the producers (unpack_ODE-based assembly). Resolve each original parameter
+	# to its CURRENT index, exactly like the states loop.
 	param_offset = length(current_states)
 	for (i, param) in enumerate(model.original_parameters)
-		ordered_params[param] = raw_sol[param_offset+i]
+		idx = findfirst(p -> isequal(p, param), current_params)
+		if isnothing(idx)
+			@warn "Parameter $param not found in current parameters, using original index $i"
+			idx = i
+		end
+		ordered_params[param] = raw_sol[param_offset+idx]
 	end
 
 	ic = collect(values(ordered_states))
@@ -827,17 +839,10 @@ function process_raw_solution(raw_sol, model::OrderedODESystem, data_sample, ode
 	end
 
 
-	# Reorder parameters according to original ordering
-	param_offset = length(current_states)
-	for (i, param) in enumerate(model.original_parameters)
-		# Find the index of this parameter in the current parameters
-		idx = findfirst(p -> isequal(p, param), current_params)
-		if isnothing(idx)
-			@warn "Parameter $param not found in current parameters, using original index $i"
-			idx = i
-		end
-		ordered_params[param] = raw_sol[param_offset+idx]
-	end
+	# (The former post-err second parameter pass was folded into the single pass
+	# above — postcampaign review P0#1: two passes with different ordering
+	# conventions meant the ODE solve/err and the returned dict could describe
+	# different parameter vectors whenever MTK order != declaration order.)
 
 	_record_detailed_timing!((
 		category = :process_raw_solution,
@@ -2372,7 +2377,15 @@ function _polish_single_from_context(
 		p = Dict(ctx.param_syms .=> param_opt),
 		build_initializeprob = false,
 	)
-	sol_final = ModelingToolkit.solve(prob_final, ctx.solver; saveat = ctx.t_vector, abstol = ctx.abstol, reltol = ctx.reltol)
+	# Guarded like the in-loss solves (postcampaign review P1): a throwing
+	# integrator here (e.g. SingularException on a rank-deficient candidate) sits
+	# in the nothing-else-worked terminal paths and must not kill the estimation.
+	sol_final = try
+		ModelingToolkit.solve(prob_final, ctx.solver; saveat = ctx.t_vector, abstol = ctx.abstol, reltol = ctx.reltol, maxiters = ctx.polish_ode_maxiters)
+	catch e
+		@warn "Final polish ODE solve threw; returning result without trajectory" exception = e maxlog = 10
+		nothing
+	end
 
 	# Map back to user-facing ordering
 	states_out = OrderedDict(s => ic_opt[ctx.state_index[s]] for s in ctx.state_syms_out if haskey(ctx.state_index, s))

test/fast_core.jl

@@ -3,6 +3,7 @@ using Logging
 using HomotopyContinuation
 using ModelingToolkit
 using OrderedCollections
+using Random
 
 @testset "Fast Core Contracts" begin
     @testset "Ordered ODE construction" begin
@@ -1841,6 +1842,9 @@ using OrderedCollections
         @test isempty(fallback_ident.all_unidentifiable)
         @test isempty(fallback_ident.good_DD.all_unidentifiable)
 
+        # Seeded: this was the only unseeded noisy sampling in CI (postcampaign
+        # review P1 / lane-4 flakiness audit).
+        Random.seed!(20260610)
         opts = EstimationOptions(
             datasize = 21,
             noise_level = 1e-8,