SemanticCompute v1.19.0

SemanticCompute v1.19.0 — the SDR lane, all the way to cyclostationary

A minor: five additive families (catalogue 163 → 168) covering wideband SDR operation end to end —
ultrafast scanning, RX/TX, full waveform analysis, and modulation recognition — built for HackRF-class
work and wired into a real consumer (PC1) in the same pass.

Added

Polyphase filterbank channeliser — the ultrafast-scanning primitive: one pass splits a wideband
block into N simultaneously-analysed channels, instead of a retune-and-FFT sweep. The polyphase arm
stage is the kernel; the across-arms DFT composes with the FFT family. Forward-sign DFT pinned by a
tone test — which caught this family's own first draft using the mirrored sign. 62 dB measured channel
rejection.

CFAR detection (cell-averaging + ordered-statistic) — per-cell adaptive detection floors. The two
variants ship together because their failures differ, and one fixture pins both: CA masks a weaker
target inside a stronger one's training ring; OS at a stated rank detects it. The floor output is
exactly peak picking's floor buffer — CFAR ∘ PeakPicking is the detect-then-refine chain, tested as a
composition.

Quadrature FM discriminator — instantaneous frequency as the angle of x[i]·conj(x[i−1]); conjugate
order pinned (the flip decodes inverted FSK from a system that "works"), amplitude immunity pinned.

Root-raised-cosine tap design (host-only, apply via Batched FIR) — the zero-ISI matched cascade is
the defining test; singular points use analytic limits; unit-energy and integer-group-delay conventions
stated.

Spectral correlation + coherence (the cyclostationary lane) — a PSD says "there is power at f";
only cyclostationary analysis says "there is a MODULATED signal with symbol rate α". SCF by
cyclic-periodogram averaging over STFT frames, with coherence as the scale-free [0,1] surface. α in
even integer bins (half-bin shifts refused); α = 0 IS the periodogram (the scale anchor); zero-power
coherence is 0, never NaN. Measured: BPSK's symbol-rate coherence 1.0 against 0.10 off-cycle and 0.19
for noise — the modulation-vs-noise discrimination the lane exists for.

Verification surface: 1,221 tests in 265 suites; the kernel-compile sweep covers 370 programs across
229 lowerings, 0 failed.

SemanticCompute v1.18.0

SemanticCompute v1.18.0 — reachable, consistent, and honest about its own confidence

A minor shaped entirely by one consumer's verification discipline. Their standing test for done-ness —
merged, on a released main, discoverable by the normal route, AND consistent with the paths that
already existed — is this release's changelog in four clauses.

Fixed

precision is now in sc_check_parity's declared JSON schema. The v1.17.0 runtime accepted it,
validated it, and refused unknowns helpfully — and tools/list never mentioned it, so a client
discovering the tool by schema introspection (the normal MCP route) would report the feature missing
from a build that has it. The consumer's third instance of "a fix that exists but is not reachable by
the normal route", and the argument that has moved every change in this thread.

A passing float64 check now reports the OBSERVED maximum error. The first float64 path reported
maxAbsoluteError: 0 on a pass whose true maximum was 3.55e-15 — and the finding was worse than the
report: the float32 doctor had always reported the observed maximum over ALL elements, so the two
precisions carried differently-scoped numbers under the same field name. Not a convention; a
divergence, introduced by testing the new path in isolation. Now mirrored to float32 exactly,
including the relative-error denominator, pinned by a passing-check-reports-true-max test.

Added

The suggestion abstention floor. sc_suggest_families labels its own confidence regime: top
coverage below 40% returns confidence: "low" with an abstention-grade note — because a consumer
left a resampler unmapped for a week on a top-ranked nonsense hit, and "a confident wrong answer is
indistinguishable from a confident right one, so a detector that guesses costs more than one that
abstains". The floor is honest about its limits: the same 28–36 band has held both nonsense and
CORRECT top hits in the evidence, so below the floor the claim is "rank carries little signal here",
never "this is wrong". The pinned below-floor case is the consumer's own: a windowed-sinc FIR
DESIGNER, for which the honest answer is that no family covers it (SC ships FIR apply, not design).

The landing page's code-knowable numbers are gated (LandingNumbersSyncTests) — family counts and
the full kind-distribution bars are checked against the catalogue, closing the drift class found at
the v1.15.0 cut the way the README table gate closed its sibling.

Verification surface: 1,201 tests in 260 suites; the kernel-compile sweep covers 365 programs across
224 lowerings, 0 failed.

SemanticCompute v1.17.0

SemanticCompute v1.17.0 — the doctor learns float64

A minor: one capability, long asked for and now cleanly scoped. The longest-standing consumer question
— asked three times by a Double-native package whose 20+ family mappings could not be parity-checked
end to end — received its decision and its implementation the same day.

Added

Doctor-level float64 comparison. SLCompatibilityDoctor.compareDoubleBuffers judges two float64
buffers at FULL precision: bit identity under exact, absolute/relative bars evaluated in Double, and
ulp(n) counted in DOUBLE ULPs (slDoubleULPDistance, new) — one float32 step at 1.0 spans ~2²⁹ of
them, which is the resolution gap this surface exists for.

The scope is the design. Families and lowerings remain float32 — a verdict about whether two arrays
agree is not a claim about what a GPU will do with them, and conflating those is what made the original
silent-narrowing bug possible. A float64 result carries that scope in its own precision field rather
than leaving it to inference.

Over MCP: sc_check_parity gains precision: "float64". The float32 exact refusal — which was
always correct — now names the float64 path as its first remedy. An unknown precision refuses rather
than defaulting, per the house rule that a typo must never become a false green.

The pinned defining case is the requesting consumer's own: two Doubles differing by 6.66e-16 —
identical as float32 — are seen, measured exactly, and tolerable only under a knowingly-stated double
bar.

Verification surface: 1,196 tests in 258 suites; the kernel-compile sweep covers 365 programs across
224 lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus
the externally verified CUDA runner.

SemanticCompute v1.16.0

SemanticCompute v1.16.0 — the tracking lane

A minor, by the rule: four additive families (catalogue 159 → 163) — the estimator consumer's full
outstanding request queue, built in one cycle with their own trap characterisations pinned as tests.

Added

Linear assignment (gated bipartite matching) — tracks↔detections, detections↔ground truth, cells
across frames; three consumers hand-roll this shape. The OBJECTIVE is the family: maximise feasible
pairs first, minimise cost second, with gating STRUCTURAL — a forbidden pair is an absent edge, never a
big finite cost, because big-M does not gate, it only makes bad assignments expensive. Ships its own
brute-force oracle whose lexicographic ordering forbids the zero-cost empty matching (the requesting
consumer's reference trap: theirs declared a correct solver broken on every input). A third trap
surfaced during this family's own construction and is preserved as a test fixture: row-by-row
shortest-path assignment steals contested columns under gating — max cardinality survives, min cost
does not — so the solver augments globally from every unmatched row, confirmed by a 60-trial
brute-force cross-check. Host-only by design: the solve is sequential, and the parallel work in an
assignment pipeline is the caller's cost matrix, which composes from families that already ship.

Spectral peak picking — floored local maxima with log-parabolic sub-bin refinement. The floor is
LOAD-BEARING, in the consumer's own words kept in the header: without it every query finds "a peak" in
noise, a tracker can never miss a detection, and a dead track gets dragged around by the noise floor
with its covariance shrinking while its information gets worse. The plateau test is asymmetric
(b > a && b ≥ g) so a flat top is one peak; an exact log-parabola's position is recovered to float
precision (test-pinned); edge bins are never peaks. Goertzel and BatchedDTFT evaluate where you point
them — this finds where to point.

Batched EKF predict (per-track transition) — the narrowed remainder after the consumer's own
correction (their glide model fits BatchedEKF exactly as shipped; recorded). Every convention mirrors
BatchedEKF verbatim — n ≤ 4, per-track Q, row-major packing — with F now a per-track buffer, so a
model moves between the families by changing one buffer's shape. Bit-exact agreement with BatchedEKF
under a replicated F is a test, not a hope.

Phase unwrap (predictive + sequential) — both forms, because they fail differently and a consumer
should choose knowingly: predictive (pred + princarg(meas − pred)) isolates a glitch to one sample;
sequential (the numpy.unwrap shape) is path-dependent by definition — one glitch shifts every later
output by 2π. Both behaviours pinned side by side as facts of the forms. princarg uses
round-half-to-even on both backends, the convention shared with the complex-onset family.

Verification surface: 1,190 tests in 257 suites; the kernel-compile sweep covers 365 programs across
224 lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus
the externally verified CUDA runner.

SemanticCompute v1.15.0

SemanticCompute v1.15.0 — Savitzky–Golay, and two kinds of honesty about drift

A minor, by the rule: one additive family (catalogue 158 → 159), one latent GPU bug fixed before any
consumer could hit it, and a documentation-drift class killed with a gate after a consumer caught it.

Added

Savitzky–Golay smooth/derivative — batched, with POLYNOMIAL-CONSISTENT edges. The natural companion
to the Hampel identifier already in the catalogue: Hampel rejects the spikes a polynomial fit would
chase, S–G preserves the peaks Hampel leaves noisy; robust smoothing is the composition, no fused
kernel required.

• The requesting consumer's own analysis had correctly ruled the single-signal interior "Correlation
  with time-reversed taps — never a gap". What no family covered: the EDGES (a different weight row at
  each boundary position — the window's own least-squares fit evaluated off-centre, not a fixed-tap
  correlation) and the batch fused with them.
• The edge policy is pinned by the test that matters: a ramp's first derivative is exact at sample 0,
  where the common reflection convention collapses it toward zero — the mirror makes the boundary look
  locally symmetric precisely when a trend detector needs the slope most.
• Degree-≤p polynomials pass through EXACTLY, edges included. Derivative scaling is d!/hᵈ with the
  sample step a real parameter. Weight rows sum to 1 (smoothing) or 0 (derivatives), asserted at design
  time. Measured: 1.85× peak retention versus a same-width boxcar.
• Adopted by the FIRFilters package as a test-only oracle: its independently coded S–G design is held
  against the family (centre weights across a design grid, every interior output), and the edge-policy
  difference is asserted AS A FACT — with a sentinel that fires if the two conventions ever silently
  converge.

Fixed

• ResamplePolyphase's GPU kernel could overflow its position product — i·M in 32-bit overflows
  once outCount·M exceeds 2³² (a long file at a large reduced M). The CPU reference always used 64-bit
  positions, so the two sides were identical only until the file got long. Found while wiring the
  consumer estate; the kernel now computes positions in ulong, parity re-verified unchanged.
• The README family table had rotted to misinformation — a consumer diffing sc_list_families
  against it found 141 of 158 canonical names absent. Regenerated mechanically from the catalogue and
  GATED (ReadmeFamilyTableSyncTests: every name verbatim, stated count matches) so it cannot rot
  again. The landing page's live-surface numbers were trued in the same sweep and its release chips
  pinned to their true versions.

Verification surface: 1,172 tests in 253 suites; the kernel-compile sweep covers 361 programs across
220 lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus
the externally verified CUDA runner.

SemanticCompute v1.14.0

SemanticCompute v1.14.0 — the audio-estate lane

A minor, by the rule: seven additive families (catalogue 151 → 158), each traced to hand-rolled call
sites or an explicit consumer roadmap ask before being declared a gap. This is the release for the audio
estate that has been rewriting the same numerics in module after module — five LPC implementations, five
linear-interpolation resamplers, three envelope-follower recurrences — with conventions nobody wrote down.

Added

Batched LPC (Levinson–Durbin + all-pole spectral envelope) — the estate's most-duplicated numeric.
Conventions pinned rather than assumed: the analysis-polynomial sign (an AR(2) recovery test cannot pass
under the negated convention), silence yields zeros not NaN (a silent frame has no vocal tract), and an
unstable reflection coefficient freezes the recursion at the last stable order rather than sending poles
outside the unit circle into a formant display.

Sobel 2D gradient magnitude — a consumer plan's top priority verbatim: its MPS-based onset detector was
"the only unverified GPU path" in the module. The edge policy — the convention that silently diverges — is
stated (replicate) and pinned by a border-value test.

Polyphase windowed-sinc resample — rational L/M positions split exactly into integer + fraction, so
phase never drifts along the signal (pinned on 100k samples — the classic accumulator-resampler bug).
Per-position kernel normalisation passes DC at exactly unity. Measured: 99.7 dB interior SNR at
44100→48000 with 32 taps, where linear interpolation manages ~35.

True peak (BS.1770-4 method) — inter-sample peak metering, absent estate-wide. 4× oversampling through
the SAME windowed-sinc kernel as the resampler — one interpolator, two families, no second implementation
to disagree with. Stated honestly: the informative Annex 2 filter is not claimed. The canonical case
(fs/4 at π/4 phase: 0.707 sample peak hiding a 1.0 true peak) is pinned.

Batched attack/release envelope follower — the one-pole recurrence three modules rewrite. Pinned: the
attack/release branch compares against the PREVIOUS envelope, initial state is 0, k = 1 − exp(−1/(τ·fs))
with τ = 0 mapping to instant, never to a divide by zero. Sequential per band, parallel over bands — the
win is B bands in one dispatch, stated so nobody expects one band to speed up.

Gammatone/ERB filterbank band energies — requested by a consumer roadmap that recorded a −24 dB
surprise from an unstated normalisation in an earlier attempt. Pinned to the digit: ERB(1 kHz) = 132.639 Hz,
ERB-rate-spaced centres, the 4th-order spectral gammatone with Patterson's 1.019 factor, and area
normalisation as an explicit option rather than a default surprise.

Nearest-centroid assignment — asked for independently by two consumers (DUET spatial clustering and a
drum-piece peeling loop). Ties break to the lowest centroid index by construction (strict < in ascending
order), the chosen distance is returned so stopping criteria need no host recompute, and the update step is
deliberately absent: assignments are labels, and labels feed the fused labelwise scatter.

Verification surface: 1,165 tests in 251 suites; the kernel-compile sweep covers 360 programs across 219
lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus the
externally verified CUDA runner.

SemanticCompute v1.13.0

SemanticCompute v1.13.0 — the percussion-discrimination lane

A minor, by the rule: two additive families (catalogue 149 → 151). This is the release for anyone whose
onset detector or drum classifier keeps confusing instruments that live a few semitones apart below 100 Hz —
the requesting consumer had two independent models fail the same held-out kick/conga discrimination before
the defect was traced to linear-frequency smearing, not to either model.

Added

Constant-Q / Variable-Q spectrogram — per-bin Q-matched window lengths on a log-frequency axis: fine
frequency resolution at the bottom where neighbouring instruments separate, fine time resolution at the top
where they don't need it. The principled fix for the fixed-window STFT's single time-frequency tradeoff.

• The marquee test is the failure in miniature: simultaneous 55 Hz and 65.4 Hz tones — three semitones,
  kick-versus-conga territory — resolve into distinct local maxima with a valley between.
• γ = 0 reproduces constant-Q bit-exactly (Variable-Q is the same kernel; test-pinned).
• The maxWindow clamp is honest: clamped bins are reported and run at reduced Q, rather than the plan
  silently pretending to the nominal bins-per-octave resolution.
• The binding-gap check is recorded in the family header: BatchedDTFT (unframed, one length),
  Goertzel/Chromagram (framed, one shared length) and STFT all near-miss this shape; the new thing is
  the per-bin window length bound to the log-frequency grid with all bins sharing a temporal centre.
• GPU parity measured, not defaulted: 3.0e-7 absolute / 2.9e-5 relative on the fixture, against a stated
  5e-5 / 5e-4 contract bar (~17× relative headroom for transcendental drift over the longest windows).

Complex-domain onset functions (pd / wpd / nwpd / cd / rcd) — the five classical phase-aware ODFs over a
complex STFT, for the magnitude-flux blind spot: a second hit entering DURING another's ring hides its energy
under the old partial, but not its phase.

• princarg-wrapped with round-half-to-even on both backends: a steady tone crossing ±π never fires
  (test-pinned — an unwrapped detector fires on every wrap).
• Rectification pinned: an offset (energy dropping out) that plain complex deviation honestly counts, the
  rectified variant must ignore.
• Frames 0 and 1 are 0 by definition — two frames of history are required, and fabricating them would
  manufacture an onset at the file start.
• GPU parity measured across all five variants: 4.8e-7 relative against a stated 1e-4 / 1e-3 bar.

A trap found by the family's own tests, stated rather than patched: the atan2 phase of an exactly-zero
bin is sign-bit garbage (0, π or −π on signed zeros alone), and pd — the one unweighted variant — reads it
at full scale. That is pd's documented weakness in the onset literature, reproduced faithfully: a test pins
pd going noisy on a zero bin while wpd stays clean on the same spectrum, and the usage guide steers
silent-bin spectra to the weighted variants.

Composes with what already ships

The requesting pipeline's remaining stages need no new families: MFCC = Mel spectrogram → DCT-II,
deltas via Batched FIR, per-band normalisation via Robust per-column standardise (median/MAD — the right
choice when a loud kick is the outlier), cepstral deconvolution via FFT → log-magnitude → InverseFFT.

Verification surface: 1,137 tests in 245 suites; the kernel-compile sweep covers 352 programs across 211
lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus the
externally verified CUDA runner.

SemanticCompute v1.12.0

SemanticCompute v1.12.0 — the fused labelwise scatter

A minor, by the rule: one additive family (catalogue 148 → 149) plus new public API, and one correctness
fix in a shipped family that the new family's own cross-validation exposed. This is the release for anyone
sweeping a segmentation labelmap once per statistic: the requesting audit measured the same 512³ label volume
traversed five to six times per refresh — ~8×10⁹ voxel reads for what a single pass yields.

Added

Fused labelwise scatter — per-label bounding box + centroid + voxel count + intensity min/max/mean/variance
from ONE traversal of a label volume. Wanted labels are explicit (background has no hidden special case; ask
for id 0 and it is counted), routed through a host-built dense id→slot table in O(1) per voxel.

Three properties are contract, not accident, each pinned by its own test:

• Absolute coordinates. Bbox and centroid are in the volume's own voxel index space — never
  crop-relative, never offset. Pinned with a label placed entirely in the far octant of an asymmetric
  volume, so a crop-relative implementation cannot pass. The consumer pattern is crop-to-bbox-then-compute:
  positions computed on the crop are crop-relative and the bbox min IS the origin that restores them. A
  consumer of this release fixed exactly the bug this line prevents — a discarded crop origin rendering
  plausible imagery of the wrong anatomy at full confidence.
• Absence is unmistakable. A wanted label with zero voxels reports count 0, nil bbox and nil
  centroid — never (0, 0, 0), which is a plausible position at the volume origin that downstream code
  will happily accept as a real anchor (one consumer feeds centroids into a 12-DOF affine fit, where a
  silent origin would drag the whole transform).
• Exact and inexact are stated per field. Count and bbox are integer work: exact, blocking-invariant,
  and verified BIT-EQUAL on GPU. Centroid and intensity sums are float folds in a fixed order —
  deterministic per blocking, the same summation-order story every reduction family here tells. Variance is
  clamped at zero.

The GPU form is two stages with no atomics: per-block private partials, then a fixed ascending-block fold
per label. Float atomics would make the result depend on thread completion order — the classic
irreproducible-metric bug; this is reproducible by construction, and the CPU reference computes the blocked
form identically so parity is not an accident of ordering.

Fixed

LabelwiseReduction could emit negative variance on near-constant input — latent since the family
shipped, found by the fused scatter's cross-validation against it. E[x²] − mean² cancels below zero in
float32; a negative variance is impossible as a statistic and becomes NaN at the consumer's first sqrt.
Clamped at zero in both the CPU reference and the GPU lowering, with a regression test. (The same
cross-validation first caught the new family's author misreading the old family's output layout. Both catches
are what cross-validating against existing families is for.)

Also in this release

The consumer-feedback inbox gains the mesh-scalar LUT interrogation filing (scattered trilinear probe +
transfer-function evaluation, both wanting CUDA lowerings) — recorded, accepted, queued for a future cycle.

Verification surface: 1,125 tests in 243 suites; the kernel-compile sweep covers 346 programs across 205
lowerings, 0 failed. Four lowering targets, three executed in-core (Metal, portable C, WGSL) plus the
externally verified CUDA runner.

SemanticCompute v1.11.0

SemanticCompute v1.11.0 — the convolution-inference lane

A minor, by the rule: four additive families (catalogue 144 → 148) plus new public API. This is the release
that lets a ported nnU-Net / nnDetection trunk run locally through verified kernels — the geometry ops shipped
in v1.7.0; this adds the trunk.

Added

Conv3D — multi-channel dense 3D convolution in PyTorch semantics exactly: channels-first
[Cout][Cin][kD][kH][kW] weights so checkpoint tensors drop in without a transpose pass, CROSS-CORRELATION
(the kernel is not flipped — pinned with an asymmetric delta, because a flipped implementation passes every
symmetric test ever written), zero padding, floor-division extents, per-output-channel bias.

Transposed Conv3D — ConvTranspose semantics including outputPadding, which resolves the stride-ambiguity
in the output extent; dropping it shifts every skip-connection concat by a voxel in a network that still runs.
Weights [Cin][Cout][k…] — Cin FIRST, PyTorch's own asymmetry, kept because "normalising" it is how a ported
decoder produces plausible garbage. Gather form: the textbook scatter's arithmetic with no atomics.

The load-bearing test is the adjoint identity ⟨conv(x), y⟩ = ⟨x, convᵀ(y)⟩ on a non-square, strided,
padded, multi-channel configuration — it holds trivially on symmetric cases and only exercises the conventions
on awkward ones. It caught its own author twice before shipping: a "helpful" weight permutation (ConvTranspose's
[in][out] IS conv's [out][in]; the same bytes serve both) and a test vector whose claimed variance was wrong.

Instance norm 3D — the nnU-Net normaliser: per-channel spatial statistics, eps inside the sqrt and
biased variance, both pinned by arithmetic chosen so no tolerance can blur which convention is implemented
(σ² = 3, ε = 1 separates the eps conventions by 37%). A constant channel yields β, finite.

LeakyReLU — slope as a real parameter (0 = ReLU, 1 = identity, both asserted). Exact GPU parity,
truthfully: no accumulation, a compare and a multiply round identically.

Measured parity contracts for BoxIoU3D and ROIAlign3D — retrofitted at an adopter's request; both
v1.7.0 families predate SLParityContract. The bars are measured, not reasoned: IoU came back bit-exact over
90,000 pairs (stated default-float anyway — FMA contraction is compiler-discretionary); ROI-Align measured
9.5×10⁻⁷ absolute / 256 ULP at samplingRatio 2 — two orders of magnitude past "≤1 ULP, it's just FMA",
which is why the rationale warns against a ULP-tier bar. Shape tells you the failure mode; only measurement
tells you the magnitude.

sc_list_families gains match: "wholeToken" — exact token equality alongside the default prefix
matching, for negative claims, where a prefix hit is a false verdict: a consumer's doc checker asked "is there
an LU family?" and got seven prefix hits (Lucas-Kanade, Lucy, luminance, lut) as evidence against a true
claim. Whole-token takes LU 7 → 1, and the 1 is the genuine falsifier. Tokens are maximal alphanumeric runs,
deliberately not hump-split — camelCase splitting manufactured a phantom "LU" from Leaky·Re·LU in the first
draft. Unknown match modes refuse.

Upgrade note

A running MCP server keeps the binary it started with: publish, reinstall, restart the client. sc_version's
buildCommit is the proof of what you are talking to.

Verification

1116 tests across 242 suites, green. Compile sweep: 344 programs across 203 lowerings, 0 failed.

Assets

macOS binaries are universal (arm64 + x86_64), Developer-ID signed and notarised. Linux binaries are provided
for x86_64 and arm64, statically linked. Verify any download against SHA256SUMS.txt.

SemanticCompute v1.10.4

SemanticCompute v1.10.4 — the mirrored BatchedCorrelation binding

One family variant, shipped alone so the verified 1.10.3 stayed frozen. Built to a consumer's falsifiable
acceptance criterion, which is the family's test, verbatim.

Added

crossCorrelationBatchMirrored — the shared reference on a (unshifted), each per-row signal shifted:
the single-pair consumer convention, batched. This is the binding perfusion Tmax needs (one shared AIF against
per-voxel TACs, peak at +delay), and the one the original binding cannot express: the two differ by the sign of
τ, only τ ≥ 0 is evaluated, and the keyword-invited substitution silently returns argmax 0 for every voxel —
asked for independently by two consumers who both hit exactly that.

• Acceptance criterion, passing: every row bit-identical (==, not tolerance) to
  CorrelationReference.crossCorrelation(a: sharedReference, b: signal_j, numLags:).
• The consumer's pinned delay-convention test ships batched: shared AIF = bump(6), signal row d = bump(6+d),
  row d's argmax == d for every d.
• The footgun is an executable demonstration in the same test: the original binding on identical data pins
  every argmax to 0 — asserted, so the reason this variant exists is falsifiable.
• GPU parity is the family's own stated bar (default float; expected cause: FMA drift in the dot product,
  measured ≤1.7×10⁻⁶). The adopting consumer explicitly declined trading FMA away: an integer-lag argmax cannot
  move at that delta except on a pathological tie. The bit-identity guarantee is the CPU convention, which is
  what an SLParityContract.bitExact adoption gate should gate.

Verification

1099 tests across 238 suites, green. Compile sweep: 340 programs across 199 lowerings, 0 failed.

Upgrade note

A running MCP server keeps the binary it started with: publish, reinstall, restart the client. sc_version's
buildCommit is the proof of what you are talking to.

Assets

macOS binaries are universal (arm64 + x86_64), Developer-ID signed and notarised. Linux binaries are provided
for x86_64 and arm64, statically linked. Verify any download against SHA256SUMS.txt.