A segment with no cascade in it scores nothing, not penalties

[amburger66]

Rest-point segmentation splits an episode into several independently scored trajectories, while the track covers the whole episode. A segment that is pick-and-place therefore has no onsets to offer, and every observed interval reads as a cascade the sim failed to reproduce — one missing-cascade penalty each, worth the track's entire duration.

The evidence

run_20260819_104757 produced the best data this experiment has yet managed: a clean capture (all dominoes 1.1–4.5°), all five toppling in both the twin and the real row, and id matching complete at 5/5 with a correct non-identity permutation.

Its sweep still reported every physical parameter as flat, and the agent declined.

The reported SSEs were 1.791e+05, 1.877e+05, 1.962e+05, 2.047e+05. One penalty term is summary_weight × duration² = 5 × 41.30² = 8528.4, so those are:

21.00   22.01   23.01   24.00

Integers. The objective was made entirely of penalties and contained no measurement. Five of the six segments were pick-and-place contributing ~4 penalties each, and being near-constant in θ they flattened the sweep.

The change

A segment contributes nothing when neither side has a cascade in it.

Why both, and not just the rollout

Requiring both is the whole subtlety, and the naive version is actively harmful. A θ that stalls the cascade also produces no onsets — so its segment would be skipped and score zero, making a friction that breaks the chain look better than one that reproduces it. That is the exact inversion interval_residuals penalises a one-sided domino to prevent.

It isn't hypothetical: the rollout-only version broke a landed test on the first attempt — test_the_objective_prefers_the_cascade_that_matches_the_track, asserting 0 < 0, the property the whole step exists for.

Gating on the recorded states alone fails in the other direction, because that same test hands in two identical states as its recorded trajectory while the rollout carries the cascade being scored.

Verified on the real run

Not only on fixtures. Reproducing that run's own truncation and segmentation and scoring through the real objective:

lateral_friction	SSE	penalty-equivalents
0.05	25589.6	3.00
0.1	25589.6	3.00
0.3	25589.6	3.00
0.5	8530.3	1.00
0.8	8530.2	1.00
1.0	25589.4	3.00

21–24 penalties → 1–3, and the first discrimination this sweep has ever shown: 0.5–0.8 comes back 3× better than the rest.

Not sufficient on its own

The numbers say so plainly: 1.00 and 3.00 are still exact integers, so what remains is still pure penalty — just twenty fewer of them. A healthy objective would show fractional values, with real interval differences contributing.

Those remaining penalties come from the cascade segment itself, where sim and observed still measure from different origin dominoes: the gripper occludes the pushed domino exactly while it falls, so the track cannot report its onset, and propagation_intervals drops whichever falls first. Fixing that needs a separate interval-exclusion change, deliberately not in this PR.

Tests

Two, and the second pins the trap rather than the feature:

• a no-cascade segment contributes nothing
• a stalled θ in a real cascade segment is still penalised

Reverting to the rollout-only skip fails the second. tests/code_sim_learning 163 passed, mypy clean, pylint 10.00/10.

---

Second commit: a tie at the earliest onset must not delete both dominoes

bee9a3a. This supersedes the "Not sufficient on its own" section above, whose diagnosis was wrong.

That section said the remaining 1–3 penalties came from the pushed domino's reference mismatch. Checked: they did not. Both streams agree the reference is domino_3. The real cause was propagation_intervals dropping every entry at the earliest time rather than dropping the origin.

They tie routinely. The sim samples one state per action, 83.3 ms; the track runs at 60 fps. So the pushed domino and the one beside it land on the same sim step and are 5× resolvable on camera:

	domino_3	domino_4
twin	0.0833 s	0.0833 s — tied
camera	23.902 s	24.252 s — 350 ms apart

Both were dropped from the twin's list; the camera kept domino_4; it had no counterpart and drew the full missing-cascade penalty — reporting that the twin's chain never reached a domino it had toppled cleanly to 90°.

Nothing is dropped now. The origin contributes a zero, which carries no information while both streams agree on which fell first, and everything when they do not. Dropping exactly one would require the streams to agree on which, and neither can see the other from inside that function.

Effect, at the sweep's best candidate

	before	after
penalties	1	0
SSE	8530.1	1.0524
spread across the six candidates	2.99990	16211

1.0524 is the first fractional SSE this experiment has produced — a measurement in seconds rather than a count of dominoes that failed to pair up.

What it still does not do

It does not get friction declared. The verdict moves from flat across the range - this data cannot constrain it to weak evidence, because the rule that recommends declaring compares the best candidate against the baseline, and the baseline (1.191) is already close to the best (1.052).

So sharp identifiability with an already-correct baseline reads identically to data too thin to say anything. That's a gap in the verdict rule rather than in this PR, and worth raising on its own.

[yichao-liang]

Automated review (Claude Code): 10 inline findings, ranked most-severe first in each comment's header tag. 7 correctness, 3 cleanup. The common thread in the top findings: the new skip gate consults the simulated and recorded onsets but never the camera track itself, which reintroduces the stall-scores-better inversion in a few forms.

[yichao-liang]

[correctness / severity 1] The no-cascade skip gates on sim and recorded onsets but never on the track's own onsets. When the recorded baseline itself stalls the cascade, a stalling candidate theta scores 0 while a theta that reproduces the camera's real cascade scores > 0 - the exact objective inversion this gate's comment says it prevents.

The recorded states are the twin's own open-loop simulation under the baseline theta. If that baseline friction stalls the chain after the push (< 2 onsets in the cascade segment), any candidate theta that also stalls hits both gate legs and the segment yields zero terms, while a candidate matching the track's 5-domino cascade proceeds to interval_residuals and accrues nonzero SSE. compute_rollout_sse then prefers the stalling theta over the correct one, silently - even though track.angles_deg, the one theta-independent witness that a cascade happened, is available two lines below the gate and is never consulted.

[yichao-liang]

[correctness / severity 2] Keeping the origin at 0.0 while retaining the len(onsets) < 2 -> return {} guard creates a new false missing-cascade penalty: when one stream detects exactly 1 onset and the other >= 2, the origin domino that BOTH streams agree fell now draws the full penalty (pre-PR it was absent from both sides).

Example: a candidate theta topples only the pushed domino. Sim onsets = {origin: t}, the < 2 guard collapses sim_intervals to {}, while obs_intervals now keeps all 5 entries including the origin at 0.0. interval_residuals over the union emits 5 penalties instead of the pre-PR 4 - one charged for the pushed domino both streams saw fall, the exact "chain never reached a domino it laid flat" false report this PR's docstring says it eliminates. It also makes "pushed domino fell" score identically to "nothing fell", and creates a 2-penalty jump between 1-onset and 2-onset thetas.

Consistent semantics: return {id: 0.0} for a single onset (guard on not onsets instead of len(onsets) < 2).

[yichao-liang]

[correctness / severity 3] When every segment skips (e.g. partial matching), the objective returns exactly 0.0, flat in theta, with only a repeated log warning as a trace - and the identifiability pipeline confidently reports INSENSITIVE. That violates this module's own fail-loud policy, which the load-failure path enforces by falling back to per-step scoring.

The all-skip state is demonstrated by this PR's own comment (run_20260819_133802: 2-of-5 matching, 99 zero evaluations read as "insensitive to friction"). Nothing numeric detects it: compute_rollout_sse is a plain sum, identifiability's sensitivity screen sees d_sse = 0 and declares insensitivity, and solve_lm's empty-residual check returns the prior centre - precisely the outcome _load_scored_track's docstring ("scoring nothing would make every theta equally good... Failing loud is the whole point of the flag") forbids. The warning here only annotates the failure; a zero-interval-terms-across-all-trajectories condition should fall back to per-step scoring or raise, mirroring the load-failure path.

[yichao-liang]

[correctness / severity 4] The skip only rescues all-or-nothing segments: any segment with >= 2 recorded onsets that is not THE cascade segment is still scored against the WHOLE episode's track intervals, drawing the same theta-flat integer penalty mass this PR diagnoses - and two gate-passing segments double-count the track's observed intervals.

Example: a cascade that pauses past segment_min_rest_steps is split by split_at_rest_points into two segments that each pass the gate and each get compared against all 5 track onsets - each drawing whole missing-cascade penalties for the dominoes in the other half. Likewise a gripper knock-over of 2 dominoes during pick-and-place. A bad candidate theta toppling 2 dominoes in a pick-and-place segment even makes the penalty mass appear/disappear discontinuously across thetas.

The deeper mechanism already half-exists: _episode_id_maps builds the concatenated whole episode. Computing onsets once per episode over it and yielding interval residuals once per episode removes both the special-case skip and the double count (preserving original step indices across the concatenation).

[yichao-liang]

[correctness / severity 5] The rewritten cache contract ("What is cached is the FILE's contents, never anything derived from a config") is false: the cached value is load_tracks(path, config.track_fallback_fps, config.track_wait_s) keyed by path alone, so the first caller's fps fixes every later caller's timestamps.

For a track JSON without per-frame timestamps, load_track derives every sample time as index / fallback_fps and bakes it into the cached angles_deg; a later caller with a different track_fallback_fps gets the cache hit and silently inherits scaled intervals and a wrong duration_s penalty magnitude - the same first-loader-poisons-the-process class this PR just fixed for the frame, one field over. Independently of config divergence, load_tracks' track_wait_s/completeness filtering means a fit that runs while only k of N episode tracks are post-processed caches the truncated list forever (reset_track_cache is only called from tests).

Fix: cache the parsed frames and derive timing on the way out, or include fps/wait in the cache key.

[yichao-liang]

[correctness / severity 6] The partial-mapping guard len(name_to_id) < len(track.angles_deg) is a count comparison, wrong in both directions, and its test asserts the absence of a warning string no code emits, so the branch is effectively untested.

• Suppressed when it should fire: when match_ids_by_xy fails, _map_for falls back to track_name_to_id, which maps every <prefix><n> object to id n regardless of the track's ids - with >= as many env dominoes as track detections the count check passes although nothing was positively identified (and mapped ids may not exist in track.angles_deg).
• Falsely fires: a track with one spurious extra detection makes every legitimate no-cascade skip log the scary "objective could not measure" warning on every evaluation.
• test_a_partial_mapping_does_not_score_zero_in_silence builds a full 4-vs-4 mapping and asserts "could not be matched" not in caplog.text - the actual warning says "could be matched", so the assertion is vacuous and a regression silencing the real 2-of-5 case would pass CI.

[yichao-liang]

[correctness / severity 7 - plausible, not fully confirmed] The skip makes the residual-vector length flip between 0 and N as a function of theta at the 2-onset threshold. On the fit_map_lm_rollout -> solve_lm -> scipy.optimize.least_squares path, a finite-difference probe that crosses the threshold returns a different-length vector, and solve_lm's blanket except Exception silently degrades the whole MAP fit to its initial theta.

Under score_observed_only, interval terms are the ONLY residuals fed to least_squares (method='trf', FD Jacobian). A no-cascade recorded segment whose rollout sits near the 2-onset boundary in theta yields N terms at f0 and 0 terms at the perturbed point (or vice versa); the shape mismatch raises inside approx_derivative, is swallowed by the except ("LM fit raised ...; skipping"), and the fit returns the init point - a silent quality regression rather than a crash. Residual length was already weakly theta-dependent pre-PR via the union, but the guaranteed 0-vs-N cliff is new.

[yichao-liang]

[efficiency] _onsets(sim_series) is computed twice per scored segment - once in the skip gate above and again in propagation_intervals(_onsets(sim_series)) - and the recorded-side series+onsets are rebuilt on every objective evaluation although recorded and name_to_id are theta-invariant across a sweep.

topple_onsets walks every domino's full angle series (O(states x dominoes) with a backdating inner loop), so every non-skipped segment pays onset detection twice per evaluation, ~100 times per sweep, and the recorded-side gate leg re-derives a per-trajectory constant precisely in the stall region the sweep explores most. Hoist sim_onsets = _onsets(sim_series) once and reuse it in both the gate and propagation_intervals; compute the recorded-side onset count once per trajectory alongside the similarly per-episode id_maps. The doubled call also invites divergence if one call site's detection arguments are later edited and the other is not.

[yichao-liang]

[simplification] return [_track_in_world_frame(t, config) for t in ...] is duplicated verbatim on the cache-hit path (here) and the cache-miss path below. A single exit point (store into the cache on miss, then one shared transform-and-return) leaves exactly one place where the on-the-way-out invariant is enforced.

The invariant this PR introduces ("transform on the way OUT, never in") currently lives at two call sites that must stay identical. The next change to what happens on the way out - a filter, an extra config-derived derivation, per-config caching - applied to one branch only makes cache-hit and cache-miss return different objects: the same invisible first-loader-wins divergence this PR exists to fix, reintroduced on whichever path the editor did not test.

[yichao-liang]

[test-coverage] The new _cascade_track helper is a verbatim re-implementation of the inline track builder already living in test_the_objective_prefers_the_cascade_that_matches_the_track (~lines 1016-1028): same 200-frame loop, same min(max((t - onset) / 8.0, 0.0), 1.0) * 90.0 ramp, same timestamp_ns: int(t * (1e9 / 60.0)). The older test should call the helper instead.

Two byte-identical fixture builders now coexist in one file (plus a fifth hand-rolled frame-schema literal in the new cache test, which _cascade_track could absorb via an optional centers parameter). A future change to the onset ramp, frame count, or fps edited in _cascade_track alone silently leaves the ordering test exercising a different track shape than the skip tests - the two properties this PR argues must be measured against the same track.