feat(extension): type-aware pulse plot — interp=zoh|linear|cubic in AMICODE_PULSE_META

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.

[kateebonner]

What

The Run Inspector's native pulse plot (#66) was hardwired to ZOH stairs, so a linear-spline pulse drew as wrong stairs. AMICODE_PULSE_META now carries an optional interp=zoh|linear|cubic field and the plot branches per mode: stairs (zero-order hold), polyline through linear-spline knots, smooth curve through cubic knots.

Contract decisions

• interp= is a TRAILING optional field (after bounds=). Trailing so the opencode fork's tail-capture mirror regex (problems.ts, labels=([^\n]*)$) keeps matching without a coordinated change. Emitters: append it at the end of the line.
• Unknown values coerce to zoh without dropping the meta. A future interp kind degrades an old client to stairs — never to NO_DATA. (Deliberate: strict-grammar fragility is what NO_DATA'd the cloud path this week.)
• No interp= → zoh: every existing run.log renders exactly as before (verified against a real pre-change run dir).

Render details

• Path math extracted to DOM-free media/ui/components/pulsepath.ts, unit-tested: mode-correct crosshair mapping (interval midpoints under zoh, knots under splines), duration (n·dt vs (n−1)·dt), single-knot degenerate holds.
• Cubic is knot-faithful, not coefficient-faithful — the record carries values only, so the curve is a Catmull-Rom through the true knots. Faithful cubic needs knot derivatives carried in the line format (flagged to the cloud-delivery side; offered as a format extension).
• Warming hint no longer promises "~1–2 min": a cloud run warms ~6 min and then streams in ~15 s sidecar sync bursts; the copy now stays true for both. The render path was already burst-safe (wholesale path swap per record, 5 Hz coalescing throttle).
• Dev harness gains interp/knot-count switches (pnpm run dev:pulseplot) for eyeballing all three modes; 12 knots makes them unmistakable.

Tested

• 787 unit tests pass incl. 12 new (grammar: interp present/absent/unknown; geometry: all three paths, cursor mapping, durations). Typecheck + repertoire lint clean.
• Real-pipeline eyeball: a real x-gate transmon run dir stamped interp=linear renders as a polyline in the inspector (F=0.99993 intact), interp=cubic as a smooth curve, and the untouched original as stairs — full state matrix incl. the no-pulse-data empty state.

Out of scope

Cloud delivery of AMICODE_PULSE lines (remote_executor forwarder + runner capture) — owned separately; this PR defines the contract the relay serves. Mock-replay acceptance pending the shared playback harness.

🤖 Generated with Claude Code

[kateebonner]

Thorough re-test pass:

• Full suite: 788 passed (37 on the pulse grammar/geometry files, incl. 4 new future-field tests). Typecheck, webview bundle, repertoire lint all clean.
• Real-corpus replay: every AMICODE_PULSE* line from all ~50 run dirs on a real machine through the new parser — 30 metas, 2,258 records, 0 dropped; all legacy metas correctly default to zoh.
• Adversarial review caught one real gap, fixed in the follow-up commit: the parser tolerated only interp= as a trailing field, so the next format extension (e.g. the planned d= cubic derivatives) would have stranded this client on NO_DATA — the exact failure class this PR exists to prevent. Both pulse lines now accept an open key=value tail; genuine corruption still rejects.
• Live verification in the extension dev host: real x-gate run stamped interp=linear renders as a polyline (F=0.99993 intact), interp=cubic as a smooth curve, untouched run as stairs, and a pulse-free run shows the no-data hint.

[jack-champagne]

Locking the pulse-derivative line format so the emit + render sides match 👇

Emitter (cloud/solve output) now emits, order-agnostic:

• AMICODE_PULSE_META … interp=zoh|linear|cubic — feeds your type-aware mode select. (Heads up: your parser coerces missing interp → zoh, so a linear/cubic pulse without this field was drawing as stairs — now it's set.)
• AMICODE_PULSE … a=<knots> d=<du knots> — d= is the first-derivative (du) at each knot, same layout as a= (comma-sep knots, ;-sep drives), appended as an open-tail field. Emitted only when the trajectory has a :du component — ZOH has none, so it's omitted there (your tail treats absent = Catmull-Rom fallback ✅).

For faithful cubic, du is all you need — value + slope → Hermite. ddu is not needed for the plot (that's the smoothness-reg term; only matters for a quintic/C² render). So don't wait on it.

Your follow-up (consume side): parse d= out of the tail into PulseRecord, and swap cubicPath's Catmull-Rom tangents (p(k+1)−p(k−1))/6 for the provided d[k] (Hermite). Linear/ZOH paths unchanged.

I'm generating a real cubic solve sample (interp=cubic + d=) right now so you can build the Hermite render against actual solver derivatives, not synthetic — will point you at it shortly (~/repos/harmoniqs/plans/run-inspector-mock/).

One thing to sanity-check when you wire it: this assumes the cubic curve is cubic-Hermite in (value, du). If Piccolissimo's cubic basis actually leans on ddu for the segment shape, du-only Hermite won't be pixel-faithful and we'd add a dd= field — worth an eyeball against the solver's own dense pulse.

[jack-champagne]

Correction on the sample I promised: bumping the integrator'sspline_order to 3 doesn't make the control cubic (bit-identical optimum → still LinearSplinePulse). So the sample at ~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is interp=linear + d=<du>, not cubic.

Still useful: the d= plumbing works end-to-end and the values are real (they're exactly the linear segment slopes, e.g. d[0] = (a[1]−a[0])/dt), so you can build + wire your Hermite render against it — flip interp=cubic on your end to exercise the curve code against real derivatives. Just don't treat it as ground-truth for cubic fidelity — a genuinely cubic pulse needs a cubic pulse constructor in the solve, which isn't wired yet (chasing that separately).

[jack-champagne]

Real cubic sample is up now (thanks Jack — the fix was CubicSplinePulse(values, derivatives, times); the pulse type sets the spline order, the integrator kwarg is overridden by it).

~/repos/harmoniqs/plans/run-inspector-mock/sample-run/ is now a genuine cubic solve:

• AMICODE_PULSE_META … interp=cubic
• d= on all 61 lines, and the derivatives are independent now (e.g. d[0]=0, 0.0588, −0.178…) — NOT the linear slopes from before (−2.70…). So it actually curves the segments.
• result.toml: integrator = spline_cubic, fidelity 0.99999957.

So you can build + validate the Hermite render against ground-truth cubic derivatives. ./playback_run.sh sample-run to animate it.