Fix :generic_start MP fan-out cascade: completeness target is a SOLUTION count

codex report (17h cstr_0_1em8 cell, pre-campaign code; adjudicated REAL, untouched
by the campaign): when a fan-out fell short and fresh-solved, the loop-persistent
completeness target was bumped to the fresh solve's only_finite=false endpoint
count — the homotopy PATH bound (~Bezout/BKK incl. at-infinity; cstr MP: 393) —
while every subsequent fan-out tracks only the N generic anchor solutions
(n_accounted <= N = 3 by construction). `3 < 393` was permanently true, so EVERY
later MP point needlessly fresh-solved: 135 combos x fresh polyhedral solve
(~15.4h of the 17h cell). Performance bug only — the fresh solves still found the
solutions.

Fix: bump with the fresh solve's FINITE solution count. Complete-anchor case
(fresh finite == N): target stays N, fan-outs judged fairly, cascade dead.
Genuine-undercoverage case (fresh finite > N): target rises (correct — fan-outs of
N really are incomplete) and a @warn tripwire fires. The fan-out decision itself
still counts at-infinity endpoints (1d0569b's good half is preserved); only the
bump quantity changes.

Verification: full suite 755/755 (easy models never execute the bump). cstr
efficacy probe: the `genuinely short (N < path-bound)` discard pattern is
structurally impossible now; this probe's config sits fully in the at-infinity
blind spot (finite-kept=0 every point) so its fresh-solves are genuine and
identical pre/post — the original cell's collapse is implied by its logged
discarded-finite pattern + the arithmetic. BONUS: the tripwire fired on its first
run (fresh 7 finite vs anchor N=3) — first observed anchor-undercoverage specimen;
the monodromy_solve+trace-test anchor-repair design (postcampaign review doc,
verified against installed HC.jl, O(N)-tracks cost) is now non-speculative.

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

Author: orebas

docs/2026-06-10_postcampaign_review.md

@@ -171,6 +171,40 @@ surface (261 unique exports) plus two god files remain the big structural debts.
 
 ---
 
+## Designed follow-up — :generic_start anchor repair (Oren's go-back question, 2026-06-10)
+
+The MP fan-out perf fix (target bumps with the fresh FINITE count, never the path
+count) leaves a designed-but-unbuilt follow-up. If the new `@warn` tripwire
+("fresh solve found more finite solutions than the generic-start anchor count")
+EVER fires in a real run, the anchor undercovered. **STATUS: first firing OBSERVED
+2026-06-10 on the cstr efficacy probe itself** (point 4 of an MP combo: fresh found
+7 finite vs anchor N=3; all complex/projected — dedup-verify step 1 below matters
+before trusting the 7). The follow-up is no longer speculative. — and since #isolated-finite at
+any parameter ≤ the generic count, that means the p0 anchor solve LOST roots, which
+also silently invalidates earlier points' "complete" fan-out verdicts. Plan (build
+on first observed firing, not speculatively):
+1. Dedup/verify the fresh M-solution set (clustered singular endpoints can inflate it).
+2. Repair the ANCHOR: γ-track the M solutions p_i → p0 (complex), merge into
+   `generic_start_solutions` → corrected N for all future points.
+3. Re-fan-out the repaired anchor to points 1..i-1 and dedup-merge into their kept
+   sets (tracking-priced, not fresh-solve-priced; all results are assembled before
+   return so go-back is local to solve_with_hc_parameterized).
+4. The deeper systematic fix is anchor-side completeness, and it is CHEAP (verified
+   against installed HC.jl, 2026-06-10): after the one-time anchor solve at p0, run
+   `monodromy_solve(...; trace_test = true)` seeded with the anchor solutions —
+   tops up missing roots AND certifies completeness via the trace test (LRS18);
+   standalone checker `verify_solution_completeness`. Cost is O(N_true) path-tracks
+   (~seconds at N=3..18), vs the mixed-cells + BKK-paths fresh solve (CPU-hours;
+   cstr MP: 393 paths for 3 solutions; receptor: 6402 for 18). Caveats: numerical
+   certificate (pass ⇒ high confidence; fail ⇒ investigate — false negatives
+   possible per HC's own docs); multi-component families make the trace fail
+   honestly (seed more, e.g. from one fresh solve's finite set). FREE cross-check
+   for SP systems: auto-M (quotient-basis dim) is already computed — anchor_N ≠ M
+   is an exact undercoverage detector. Column-scaled anchor solve additionally
+   reduces blind-spot path loss at p0 (receptor lesson). Detection via fan-out
+   shortfall alone is opportunistic and misses the all-fan-outs-track-cleanly
+   undercoverage case — the certificate closes that hole.
+
 ## Suggested execution order
 
 1. **Now:** P0#4 test-target deps (one line, our regression) → commit.

docs/2026-06-10_session_handoff.md

@@ -49,10 +49,18 @@ left an unloadable tree once). `Pkg.test` ≠ the local include gate — verify
 
 ## OPEN FINDING — :generic_start MP fanout perf bug (codex report 2026-06-10)
 
-Reported by codex on a 17h cstr_0_1em8 cell; adjudicated this session as **REAL,
-pre-existing, NOT touched by the campaign, still present** — a PERFORMANCE bug, not
-correctness. Detail in the answer below; not yet fixed (was a query, not a fix
-request). Lives at `src/core/homotopy_continuation.jl:943-964`.
+Reported by codex on a 17h cstr_0_1em8 cell; adjudicated as **REAL, pre-existing,
+NOT touched by the campaign** — a PERFORMANCE bug, not correctness.
+**FIXED 2026-06-10** (commit following this doc's): the completeness target now
+bumps with the fresh solve's FINITE solution count, never the only_finite=false
+path/endpoint count; plus an undercoverage `@warn` tripwire — which FIRED on its
+first probe run (fresh 7 finite vs anchor N=3 on a cstr MP combo), making the
+anchor-repair follow-up (monodromy_solve + trace test, design in the postcampaign
+review doc) non-speculative. Efficacy probe verified mechanics (no count-branch
+fresh-solves possible; this reduced config sits fully in the at-infinity blind spot
+so its fresh-solves are genuine); the original cell's 15h collapse is implied by
+codex's logged `3 < 393 genuinely short` discarded-finite pattern + arithmetic,
+not re-measured. Was at `src/core/homotopy_continuation.jl:943-964`.
 
 Root cause: in the `:generic_start` (default) MP path, after point 1's fanout comes
 up short and triggers a fresh `_hc_solve`, line 964 bumps the loop-persistent

src/core/homotopy_continuation.jl

@@ -961,7 +961,19 @@ function solve_with_hc_parameterized(poly_system, solve_vars, data_vars, param_v
 				end
 				result = _hc_solve(hc_system; target_parameters = current_params, show_progress = show_progress)
 				all_solutions = HomotopyContinuation.solutions(result; only_nonsingular = false)
-				initial_solution_count = max(initial_solution_count, length(HomotopyContinuation.solutions(result; only_nonsingular = false, only_finite = false)))
+				# Completeness target must stay a SOLUTION count (≈ the generic count N), NOT the fresh
+				# solve's only_finite=false endpoint count. The fan-out only ever tracks N generic
+				# solutions, so n_accounted ≤ N; bumping the target to the fresh solve's path/endpoint
+				# count (the homotopy path bound ~Bezout/BKK incl. at-infinity — e.g. 393) made
+				# `n_accounted < target` permanently true ⇒ EVERY subsequent point needlessly fresh-solved
+				# (the 15h-cstr blowup; report 2026-06-10). Use the FRESH FINITE count: it raises the
+				# target only on genuine generic-anchor undercoverage (fresh finds > N real solutions),
+				# the one case where fan-outs of N really are incomplete and should keep fresh-solving.
+				fresh_finite = length(all_solutions)
+				if fresh_finite > initial_solution_count
+					@warn "[HC-PARAM] Fresh solve found more finite solutions ($fresh_finite) than the generic-start anchor count ($initial_solution_count): generic anchor undercovered; subsequent fan-outs will fresh-solve." maxlog = 3
+				end
+				initial_solution_count = max(initial_solution_count, fresh_finite)
 			elseif debug
 				real_count = length(HomotopyContinuation.solutions(result, only_real = true, real_tol = real_tol))
 				println("[HC-PARAM] Point $i: fan-out complete ($n_accounted accounted, $(length(all_solutions)) finite, $real_count real)")