SpaceAge Refactoring Policy

Status: standing engineering rule established 2026-08-27.

Purpose

Refactoring is continuous maintenance, not an end-of-project rescue phase. It must improve ownership, readability, testability, or performance while preserving verified behavior. Cosmetic churn alone is not sufficient justification.

Cadence

Every feature or defect: clean the touched boundary, remove duplication introduced by the change, check real-time safety, and preserve focused tests.
Every 5-10 meaningful changes: review the affected subsystem for oversized functions, confused ownership, dead code, duplicated calculations, blocking work, allocation, persistence drift, and missing regression coverage.
Every subsystem milestone: perform a deeper maturity pass before declaring the subsystem complete. Current examples include Redshift, convolution reverb, Mixer routing, and Arranger ownership.
Before a requested test build: run diff/format checks and the focused gates for changed behavior. A build is not a reason to begin a broad refactor.
Before beta: pause feature expansion for a repository-wide stabilization pass backed by before/after behavior and performance evidence.
During beta: refactor only to address a verified defect, measured performance problem, unsafe boundary, or material maintenance hazard.

This is a change-count and milestone schedule rather than a calendar schedule. Development intensity varies; the architectural pressure created by changes is the useful trigger.

Required Evidence

State the boundary and reason before a nontrivial refactor.
Preserve or add focused behavioral tests.
For DSP, require exact or tolerance-defined before/after audio evidence.
For real-time paths, verify that the refactor adds no allocation, blocking, locking, file access, or avoidable per-sample work.
Record meaningful refactors in the relevant engineering report.
Keep normal Windows/JUCE behavior authoritative over speculative portability.

Guardrails

Do not mix a broad refactor with an urgent defect fix unless the boundary is itself the defect.
Do not rename or move large surfaces merely for consistency.
Do not extract helpers that obscure state ownership or add hot-path overhead.
Do not claim a speedup from source shape alone; measure it.
Prefer a sequence of independently provable extractions over one large rewrite.

Current Milestone

Redshift is in a maturity refactor. Its large voice renderer will be separated incrementally into preparation, modulation, oscillator, filter, and output responsibilities. Every extraction must continue to pass the focused Redshift audio gate and exact optimized/reference render-signature comparison.

Review Log

2026-08-28 - Redshift Motion Interpolation Safety Boundary

Boundary: quantify trajectory error before changing audio-rate Tone Motion.
Reason: lowering update rate based only on CPU results risks zippering, altered transients, and discontinuity smearing.
Implementation: a self-test-only class wrapper delegates to the exact file-local production evaluator; the harness covers fastest eligible cycles and boundaries.
Result: eight-sample interpolation is numerically viable only for the narrow derivative-smooth candidate set. A broader six-shape trial failed and those sharper routes remain audio-rate. Production rendering is unchanged in this step.

2026-08-28 - Redshift Polyphony Benchmark Integrity

Boundary: sustained-polyphony CPU fixtures must allocate voices directly and prove retained counts; UI-style pending triggers are intentionally coalescing.
Reason: requesting many hits through one pending Pad slot can silently benchmark one voice and produce invalid scaling claims.
Implementation: the new 12-row Redshift matrix and corrected custom-cycle fixture use the immediate test allocator, explicit Poly/Gate mode, indefinite holds, post-warm-up/post-measurement counts, and finite/audible output checks.
Result: the dense 32-voice profile measured 90.52%, exposing a genuine next optimization target rather than hiding it behind an under-filled fixture.

2026-08-28 - Redshift Tone Project-State Contract

Boundary: ordinary project persistence is tested independently from reusable Motion Block and Tone Scene file formats.
Reason: file-format round trips cannot prove that a normal project save owns every newer route field or preserves neighboring instrument slots.
Implementation: one table-driven gate covers all 107 shared/per-destination parameters, while existing focused gates retain Step Motion and MSEG coverage.
Validation: toneProjectState=1, toneBlock=1, toneScene=1, Step Motion, MSEG, lane isolation, and hot-path equivalence all pass. The added work is test-only and creates no runtime cost.

2026-08-28 - Redshift Transport Clock Ownership

Boundary: host playhead capture belongs to block preparation; voice rendering consumes only an immutable sample position.
Reason: per-voice host queries and independently accumulated route clocks would add callback overhead and drift across seeks or loop returns.
Implementation: host sample position is preferred, PPQ/BPM is the metadata fallback, and the existing internal sequencer clock remains the final fallback.
Validation: standalone behavior, the complete focused Redshift contract, transportClock=1, and paired hot-path equivalence pass. Multi-host listening remains a release validation task rather than a reason to duplicate clock state.

2026-08-28 - Shared MSEG Core Boundary

Boundary: normalized multi-segment curve storage, validation, and evaluation.
Reason: curve mathematics must be reusable without depending on Redshift, JUCE controls, project files, or destination-specific units.
Implementation: SpaceAgeMotionCurve.h uses fixed-capacity value storage and separates message-thread validation from prepared real-time evaluation.
Scope: no route owns a curve yet, so this structural checkpoint changes no sound and adds no audio-callback work.
Validation: exact interpolation, curvature, malformed input, Release compile, focused Redshift behavior, and hot-path equivalence contracts pass.

2026-08-28 - Shared MSEG Playback Ownership

Boundary: pure held-phase mapping and release-tail evaluation remain separate from future voice-owned elapsed time and note state.
Reason: hiding playback state inside a shared curve would confuse polyphonic ownership and make cross-synth reuse unsafe.
Implementation: fixed playback settings define loop mode and point indices; prepared helpers consume explicit elapsed phase or captured release value.
Scope: no route owns playback state yet, so existing rendering is unchanged.
Validation: forward/ping-pong loops, one-shot completion, release continuity, malformed regions, and focused Redshift hot-path equivalence pass.

2026-08-28 - Redshift MSEG Immutable Route State

Boundary: one optional curve snapshot per instrument slot and Tone destination.
Reason: route editing, project state, lane copy/undo, and future rendering must agree on ownership before MSEG becomes audible.
Implementation: validated immutable publication mirrors the proven Step Motion model; untouched routes remain sparse and disabled edited routes are retained.
Persistence: projects and scoped lane snapshots carry only bounded route data.
Validation: enabled/disabled round-trip, point and playback identity, destination isolation, clear, malformed rejection, and hot-path equivalence pass.

2026-08-28 - Redshift MSEG Preset Transaction

Boundary: one shared MSEG serializer/parser serves Redshift patches and Tone Motion Blocks; project state retains its processor-owned representation.
Reason: independent parsers would drift on validation and legacy clearing.
Implementation: complete bounded route sets are parsed and validated before any parameter or immutable route is published. Tone Motion Block version 5 owns MSEG; versions 1-4 and legacy patches clear it deliberately.
Validation: current round-trip, legacy clearing, malformed transactional refusal, visible legacy patch recall, and focused Redshift hot-path equivalence pass.

2026-08-28 - Redshift MSEG Audio Ownership

Boundary: immutable route shape is block-owned; held/release clocks and captured values are voice-owned; destination mapping remains Tone Motion-owned.
Reason: polyphonic release continuity cannot live in a shared route object, and MSEG must not duplicate A/B, Depth, trigger, offset, fade, or launch behavior.
Implementation: enabled MSEG has explicit precedence over Step Motion and replaces only normalized trajectory evaluation.
Validation: audible curved-loop route, release evaluator, lane isolation, bounded output, existing motion contracts, and hot-path equivalence pass.

2026-08-28 - Redshift Step Motion Editor Boundary

Boundary: each Tone Motion popup edits one instrument-slot/destination pattern.
Reason: representing 16 steps across eight routes as ordinary host parameters would multiply parameter count, lookup, persistence, and polling overhead.
Implementation: the editor publishes one bounded immutable snapshot only when a control changes; the audio renderer acquires that snapshot once per block.
Ownership: one scoped instrument-patch Undo checkpoint begins each slider gesture or discrete toggle/combo change. Disabled edited patterns remain owned by their route and untouched routes remain sparse.
Validation: Release compilation and the focused Redshift audio, state, persistence, Motion Block, isolation, and hot-path equivalence contracts pass.

2026-08-27 - Redshift Maturity Pass Started

Boundary: renderPolySynthVoice and Redshift block preparation.
Reason: the renderer had reached 666 lines and combined motion evaluation, oscillator generation, filtering, and state management.
First extraction: deterministic oscillator Pitch Motion shape evaluation.
Validation: focused Redshift gate passed all 20 waveforms, all seven Pitch Motion shapes, Tone Motion, persistence and ownership checks, and exact optimized/reference render signatures.
Result: the deterministic random hash and shape switch now have one named, stateless boundary. The renderer remains the owner of clock selection, endpoint interpolation, depth, and frequency conversion.
Performance note: the validation run's wall-clock benchmark was contaminated by machine load on both paths, so no speed claim is attached to this structural extraction.

2026-08-27 - Redshift Tone Motion Trajectory Extraction

Boundary: the deterministic cycle, skew, shape, and seeded-random trajectory calculation formerly embedded in renderPolySynthVoice.
Reason: Tone Motion's shape machinery obscured the renderer's ownership of voice timing, endpoints, depth, fade, and destination state.
Change: introduced a stateless redshiftToneMotionTrajectory helper. The renderer still selects the clock, applies route offsets, owns the base-value fallback, and performs endpoint, depth, and fade interpolation.
Result: renderPolySynthVoice decreased from 643 to 581 lines while preserving the established state and real-time boundaries.
Validation: Release compilation succeeded. The focused Redshift gate passed all 20 waveforms, all seven Pitch Motion shapes, Tone Motion, depth-zero, cycle preparation/ownership/publication, embedded-cycle, motion-block, and exact optimized/reference hot-path equivalence checks.
Performance note: this is a structural extraction with no performance claim; the validation gate was not run as a controlled benchmark.

2026-08-27 - Redshift Built-In Oscillator Extraction

Boundary: built-in oscillator phase normalization, PolyBLEP correction, pulse generation, shape morphing, and harmonic evaluation.
Reason: the stateless oscillator implementation occupied a large local-lambda cluster inside the voice renderer and hid the boundary between waveform math and voice/custom-cycle state.
Change: introduced named stateless helpers for phase normalization, PolyBLEP, and the built-in oscillator evaluator. The renderer retains phase advancement, custom-cycle ownership, mip selection, source morphing, and spread rendering.
Result: renderPolySynthVoice decreased from 581 to 485 lines, and from 666 to 485 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed all 20 waveforms, oscillator 2, shape controls, source morphing, spread, all seven Pitch Motion shapes, Tone Motion, custom-cycle preparation and ownership, and exact optimized/reference hot-path equivalence.
Performance note: this extraction establishes a testable oscillator boundary; no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Metallic Shimmer Extraction

Boundary: metallic sine-table sampling and the six partial phase accumulators.
Reason: the metallic oscillator bank was an isolated stateful calculation embedded between the main oscillator mixer and wavefolder.
Change: introduced named helpers for sine-table interpolation and metallic shimmer rendering. The phase array is passed explicitly by reference, keeping voice-state mutation visible at the renderer call site.
Result: renderPolySynthVoice decreased from 485 to 452 lines, and from 666 to 452 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed every waveform and modulation check plus exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed; this change clarifies ownership and creates a focused boundary for later profiling or optimization.

2026-08-27 - Redshift Filter Core Extraction

Boundary: topology-preserving state-variable filtering, pole cascading, output-mode selection, state clamping, and invalid-output recovery.
Reason: the filter state update was a cohesive DSP stage embedded after oscillator mixing, while cutoff modulation and coefficient preparation belong to the surrounding voice-control flow.
Change: introduced redshiftFilterSample with four explicit ladder-state references and fully prepared coefficients. Cutoff, envelope, velocity, X-mod, Tone Motion, static-coefficient selection, and band-pass gain selection remain in the voice renderer.
Result: renderPolySynthVoice decreased from 452 to 414 lines, and from 666 to 414 lines across the maturity pass so far.
Real-time check: band-pass gain remains conditionally evaluated only for the band-pass mode, avoiding a new square-root operation in other filter modes.
Validation: Release compilation succeeded. The focused Redshift gate passed bypass, low-pass, high-pass, band-pass, isolation, every waveform and modulation check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Pitch Expression Extraction

Boundary: per-sample drift, cross-modulation, and vibrato evaluation.
Reason: these related, stateless pitch-expression calculations obscured the renderer's ownership of glide state, MIDI expression, root-frequency caching, oscillator tuning, and filter application.
Change: introduced redshiftPitchExpression, returning drift, X-mod filter value, X-mod pitch value, and vibrato as one explicit value bundle. The helper owns no voice state and performs no allocation.
Result: renderPolySynthVoice decreased from 414 to 399 lines, and from 666 to 399 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed all filter, waveform, oscillator, Pitch Motion, Tone Motion, custom-cycle, ownership, and exact optimized/reference hot-path equivalence checks.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Pitch Motion Multiplier Extraction

Boundary: one oscillator's Pitch Motion clock selection, phase calculation, trajectory evaluation, endpoint interpolation, depth, and cents-to-frequency conversion.
Reason: this stateless route calculation is independently meaningful and has dedicated shape coverage, while activation and final oscillator-frequency limits remain renderer responsibilities.
Change: introduced redshiftPitchMotionMultiplier. It performs no allocation and owns no mutable voice or processor state.
Result: renderPolySynthVoice decreased from 399 to 392 lines, and from 666 to 392 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed all seven Pitch Motion shapes, every oscillator and Tone Motion check, custom-cycle ownership, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Tone Motion Route Extraction

Boundary: evaluation of one active Tone Motion route from trigger and clock selection through trajectory, endpoint interpolation, fade, and depth.
Reason: route evaluation is stateless and cohesive, while route activation and storage of the resulting per-voice destination value belong in the renderer.
Change: introduced redshiftToneMotionValue. The renderer retains the prepared hot-path bypass, active-route test, free-running clock publication, and voice destination ownership.
Result: renderPolySynthVoice decreased from 392 to 374 lines, and from 666 to 374 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed Tone Motion, depth-zero behavior, cycle preparation/ownership/publication, every oscillator check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Custom-Cycle Mip Cache Extraction

Boundary: prepared custom-cycle mip selection and its lower/upper frequency cache bounds for one oscillator.
Reason: mip hysteresis is cohesive stateful logic, while cycle ownership, source selection, and waveform sampling belong to the renderer and prepared cycle subsystem.
Change: introduced redshiftCachedCycleMip with explicit references to the mip index and both frequency bounds. Shared cycle pointers are not passed to or retained by the helper.
Result: renderPolySynthVoice decreased from 374 to 362 lines, and from 666 to 362 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed cycle frames, preparation, ownership, publication, embedded-cycle rendering, every oscillator and modulation check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Oscillator Source Boundary

Boundary: sampling one Redshift source and morphing between two sources across built-in oscillators, embedded table frames, and custom single-cycle tables.
Reason: source dispatch requires the processor's embedded wavetable sampler, but does not need to own voice phase, cycle pointers, mip-cache state, spread, or oscillator level mixing.
Change: introduced allocation-free noexcept member functions sampleRedshiftOscillator and sampleRedshiftMorphOscillator. All source and target cycle pointers remain borrowed for the duration of each call.
Result: renderPolySynthVoice decreased from 362 to 307 lines, and from 666 to 307 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed all 20 waveforms, oscillator 2, source morphing, spread, custom-cycle frames, preparation/ownership/publication, every modulation check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark; the helpers are eligible for normal compiler inlining and add no allocation.

2026-08-27 - Redshift Root-Frequency Cache Extraction

Boundary: root pitch conversion and prepared hot-path cache validation/update.
Reason: frequency caching is cohesive mutable logic, while glide, MIDI pitch expression, drift, vibrato, X-mod, Pitch Motion, and final oscillator limits remain renderer responsibilities.
Change: introduced redshiftCachedRootFrequency with explicit references to cache validity, cached pitch, cached base frequency, and cached output.
Result: renderPolySynthVoice decreased from 307 to 293 lines, and from 666 to 293 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed oscillator tuning, all seven Pitch Motion shapes, every source and modulation check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Oscillator Spread Extraction

Boundary: oscillator 1's two detuned spread renders, spread-specific mip selection, phase offsets, and centre/spread recombination.
Reason: spread is a complete optional rendering stage, while the renderer remains responsible for primary phase, source pointers, main mip-cache state, centre oscillator sampling, and downstream level mixing.
Change: introduced allocation-free noexcept applyRedshiftOscillatorSpread. Source pointers are borrowed only for the duration of the call and no state is retained.
Result: renderPolySynthVoice decreased from 293 to 272 lines, and from 666 to 272 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed spread, all 20 waveforms, source morphing, custom-cycle mip and ownership checks, every modulation check, and exact optimized/reference hot-path equivalence.
Performance note: no speedup is claimed without a controlled benchmark; the disabled-spread path returns before additional source rendering.

2026-08-27 - Redshift Phase Advancement Extraction

Boundary: one oscillator's per-sample phase increment and wrap.
Reason: phase advancement is duplicated mutable state logic whose contract is clearer when the mutated scalar is explicit at each oscillator call site.
Change: introduced allocation-free redshiftAdvancePhase; frequency limits, phase ownership, and subsequent source sampling remain in the renderer.
Result: renderPolySynthVoice decreased from 272 to 268 lines, and from 666 to 268 lines across the maturity pass so far.
Validation: Release compilation succeeded. The focused Redshift gate passed all phase-dependent waveform, tuning, Pitch Motion, spread, source morphing, custom-cycle, and exact optimized/reference hot-path equivalence checks.
Maturity note: the remaining renderer is primarily readable stage orchestration. Further extraction should require a concrete ownership, testability, or measured-performance benefit rather than a line-count target.
Performance note: no speedup is claimed without a controlled benchmark.

2026-08-27 - Redshift Benchmark Validity Review

Boundary: the focused Redshift same-process optimized/reference CPU harness.
Finding: its four-second voice lifetime was slightly shorter than warm-up plus all three measured passes, allowing the final pass to enter voice retirement.
Change: test voices now sustain for 30 seconds and measurement uses the median of five passes, keeping the complete 16-voice workload active throughout.
Validation: the strengthened gate passed exact audio signatures and every Redshift behavior check. Reference/optimized measurements stayed in the same narrow 3.18-3.29% range with mixed direction by source route.
Conclusion: the maturity refactor is performance-neutral in this workload. No speed claim is attached; subsequent optimization requires measured DSP work reduction rather than additional structural extraction.

2026-08-27 - Redshift Noise-State Guard Removal

Boundary: per-sample Redshift white-noise validation and pink-state clamping.
Evidence: the production RNG is finite and bounded, voice state begins reset, and the pink recurrence is a convex combination that remains bounded.
Change: production playback omits the unreachable checks; the test-only reference path retains them. The A/B workload now mixes audible pink noise so signature equivalence directly covers the changed state path.
Validation: Release compilation and every focused Redshift check passed. Exact audible-noise signatures matched on procedural, one-cycle, and two-cycle routes. Five-pass CPU medians overlapped with mixed direction, supporting no measurable regression but no percentage speed claim.

2026-08-27 - Redshift Lock-Value Boundary Ownership

Boundary: sequencer step edits, piano-note normalization, and direct project restoration now own finite-number validation for pitch and filter locks.
Reason: these values enter voices through several musical workflows, but their validity should be established once at model boundaries rather than tested on every active Redshift voice and sample.
Change: non-finite lock values normalize to zero at each entry point. The production renderer omits its downstream combined-pitch and cutoff checks; the self-test reference path retains them for behavioral proof.
Validation: Release compilation succeeded and the strengthened focused gate passed all Redshift checks plus exact audible-noise optimized/reference signatures. Five-pass timing moved in both directions, so no percentage gain is claimed.

2026-08-27 - Redshift Bounded Mix Validation

Boundary: oscillator import/preparation owns custom-cycle validity; Redshift's prepared controls and source generators own finite, bounded mix inputs.
Change: production playback retains its sonic saturation clamps while omitting three downstream finite-number branches that cannot activate under those contracts. The reference path remains guarded for A/B proof.
Validation: Release compilation succeeded. The focused gate passed every Redshift behavior check and exact audible-noise signatures for procedural and custom-cycle routes. Timing leaned favorable overall but remains within the harness's noise range, so no percentage speed claim is attached.

2026-08-27 - Redshift Filter-State Clamp Ownership

Boundary: the end of each Redshift filter sample owns the four internal state bounds; zero-initialized voice state supplies the first sample's valid input.
Change: production playback no longer repeats those clamps at the beginning of the next sample and omits unreachable finite checks while preserving all numeric bounds and sonic saturation. The reference path remains fully guarded.
Validation: Release compilation and the complete focused Redshift gate passed, including every filter topology and exact optimized/reference signatures. Timing contained an isolated outlier, so the result carries no percentage speed claim.

2026-08-27 - Redshift Voice-Local Filter Coefficient Cache

Boundary: the block cache owns coefficients shared by voices with no lock; each voice owns coefficients for its constant sequencer filter lock.
Change: exact-cutoff cache invalidation replaces per-sample tan and exp work only when block analysis proves no active cutoff modulation. Dynamic filter routes retain their original sample-accurate calculations.
Validation: the focused benchmark now applies a filter lock to 16 sustained voices. Release compilation, all Redshift checks, and exact reference/optimized signatures passed. Whole-voice timing remained effectively flat, so no broad CPU percentage is claimed.

2026-08-27 - Redshift Settled Filter-State Classification

Boundary: active cutoff modulation owns dynamic coefficient calculation; voice-local constant cutoff owns cached coefficients after an envelope reaches its pre-existing exact-zero settled state.
Change: velocity filtering and settled filter envelopes can now use the same exact-cutoff voice cache as sequencer filter locks. Tone Motion and cross-modulation remain explicitly dynamic.
Validation: the 16-voice benchmark now combines velocity filtering, a settled envelope, a filter lock, audible noise, and procedural/custom-cycle sources. Release compilation, every focused check, and exact reference/optimized signatures passed. All measured medians moved favorably, but no general CPU percentage is inferred from one run.

2026-08-27 - Redshift Phase/Age State Ownership

Boundary: voice initialization and phase/age advancement own validity for Redshift's two oscillator phases and elapsed age.
Change: production playback no longer revalidates those three states on every sample. The self-test reference renderer retains the previous checks.
Validation: Release compilation and the complete strengthened Redshift gate passed with exact reference/optimized signatures. Timing was effectively tied, so this is recorded as cumulative instruction cleanup rather than a measurable percentage gain.

2026-08-27 - Redshift Metallic Phase Ownership

Boundary: metallic voice initialization and redshiftMetalShimmer phase wrapping own validity for the six modal phases.
Change: production playback omits six redundant per-sample finite checks; the guarded reference path retains them for A/B validation.
Validation: the benchmark now runs metallic shimmer on all 16 sustained voices alongside its filtered audible-noise workload. Release compilation, all focused checks, and exact signatures passed. Timing remained mixed and close, so no percentage speed claim is attached.

2026-08-27 - Redshift Metallic Increment Ownership

Boundary: each metallic voice owns phase increments derived from its exact frequency; block controls own modal ratios and sample-rate preparation.
Change: a voice-local cache reuses six increments while frequency, spread, and inverse sample rate remain exactly unchanged. Any key change recomputes all six before phase advancement.
Validation: Release compilation and the dense metallic focused gate passed all behavior checks and exact reference/optimized signatures. Timing remained mixed within a narrow range, so no percentage claim is attached.

2026-08-27 - Redshift Custom-Cycle Route Ownership

Boundary: block preparation owns source-kind/morph routing decisions and the harmonic frequency limit; voices own frequency-dependent mip selection.
Change: two custom-cycle route flags and the harmonic limit are prepared once per block rather than reconstructed per voice/sample. The reference path keeps the old calculations.
Validation: Release compilation and all focused checks passed. Exact signatures matched for zero-, one-, and two-custom-cycle routes under the dense sustained benchmark. One timing route produced an isolated outlier, so no percentage claim is attached.

2026-08-27 - Redshift Mix-Stage Control Ownership

Boundary: audio-block preparation owns noise gains, metallic decay rate, and fold gains derived solely from parameter snapshots; voices own evolving phase and signal state.
Change: production voices consume prepared mix-stage values rather than reconstructing them per sample. The reference renderer preserves the previous calculations for A/B proof.
Validation: the dense benchmark now includes active fold in addition to its metallic, noise, filter, and custom-cycle workload. Release compilation, all focused checks, and exact signatures passed. Mixed timing prevents a general percentage claim.

2026-08-27 - Redshift Spread-Gain Ownership

Boundary: block preparation owns gains derived solely from oscillator spread; voices own detuned frequencies, phases, mip selection, and source rendering.
Change: center and side gains are prepared once per block while the test reference path retains their former per-sample derivation.
Validation: the dense 16-voice benchmark now enables spread across procedural and custom-cycle routes. Release compilation, all focused checks, and exact signatures passed. Mixed timing prevents a general percentage claim.

2026-08-27 - Redshift Spread-Side Mip Ownership

Boundary: each voice owns anti-aliasing mip-band state for its two detuned spread oscillators, parallel to the existing center-oscillator caches.
Change: side mips are reused while frequency stays inside the exact cached harmonic interval and reselected immediately at a boundary.
Validation: Release compilation and the spread-enabled dense benchmark passed every focused check and exact signature across zero-, one-, and two-cycle routes. Timing remained narrowly mixed, so no percentage claim is attached.

2026-08-27 - Redshift Static Width Ownership

Boundary: block preparation owns bounded width and its complement when no active route can move shape amount; dynamic drift owns per-sample width.
Change: the static production path reuses prepared values while the dynamic and reference paths retain the former clamp/complement calculations.
Validation: Release compilation and the dense spread/custom-cycle benchmark passed every focused check and exact signature. A large isolated reference timing outlier prevents a percentage claim.

2026-08-27 - Redshift Spread Phase-Offset Ownership

Boundary: voice initialization owns the two spread offsets derived from fixed random timbre; the renderer owns evolving phases and frequencies.
Change: production spread rendering reuses both voice-local offsets while the reference path retains their previous per-sample derivation.
Validation: Release compilation and the dense spread/custom-cycle benchmark passed every focused check and exact signature. Timing leaned slightly favorable overall but does not support a broad percentage claim.

2026-08-27 - Redshift Spread-Frequency Ownership

Boundary: each voice owns the two detuned frequencies derived from its exact center frequency and the block's spread ratio; the renderer owns evolving phases, mip selection, and oscillator output.
Change: production spread rendering reuses both frequencies while those exact keys remain unchanged. Pitch or spread movement refreshes both values before they are consumed; the reference path retains the former per-sample math.
Validation: Release compilation and the dense 16-voice spread/custom-cycle benchmark passed every focused check with exact signatures. Timing was mixed among the three routes, so no general percentage claim is attached.

2026-08-27 - Redshift Velocity-Filter Ownership

Boundary: a voice owns its static velocity-to-cutoff contribution; block controls own the amount, response mode, and Tone Motion activity.
Change: production rendering caches the contribution against exact amount, mode, and voice velocity. An active velocity-filter motion route bypasses the cache and preserves the original per-sample behavior.
Validation: Release compilation and the dense 16-voice filter/spread/custom- cycle benchmark passed every focused check with exact signatures. Timing was mixed among routes, so no general percentage claim is attached.

2026-08-27 - Redshift Filter-Envelope Lifetime Ownership

Boundary: each voice owns whether its filter envelope has crossed the existing silent threshold; block controls own decay and its Tone Motion activity.
Change: a static-decay voice stops reevaluating an envelope after the original calculation declares it settled. A new voice or decay change clears that state, and animated decay continues through the original per-sample calculation.
Validation: Release compilation and the dense 16-voice filter/spread/custom- cycle benchmark passed every focused check with exact signatures. Timing was mixed among routes, so no general percentage claim is attached.

2026-08-27 - Redshift Filter-Activity Ownership

Boundary: block preparation owns whether any cutoff-related Tone Motion route or cross-modulation can move cutoff; each voice owns its live envelope state.
Change: production rendering consumes one prepared dynamic-cutoff flag instead of rebuilding the same route aggregate for every voice and sample.
Validation: Release compilation and the dense 16-voice filter/spread/custom- cycle benchmark passed every focused check with exact signatures. Route timing was mixed, so no general percentage claim is attached.

2026-08-27 - Redshift Free-Running Clock Ownership

Boundary: the processor render sample owns the global motion-clock conversion; voices own note-reset age and consume the shared value only for global routes.
Change: production rendering reuses one exact samples-to-seconds result across all Redshift voices at the current sample. The self-test reference path keeps the former per-voice division.
Validation: the dense benchmark now activates synced free-running Drive motion on 16 voices. Release compilation and every focused check passed with exact signatures. Mixed route timing prevents a general percentage claim.

2026-08-27 - Redshift Tone-Motion Trigger Ownership

Boundary: block preparation owns whether each Tone Motion route uses note age or the shared free-running clock; voices own note age and evaluated values.
Change: production routes consume one prepared trigger decision rather than decoding trigger and key-reset controls for every voice and sample. The reference path retains the previous decision logic.
Validation: Release compilation and the dense 16-voice free-running-motion benchmark passed every focused check with exact signatures. Timing remained mixed among routes, so no general percentage claim is attached.

2026-08-27 - Redshift Tone-Motion Endpoint Ownership

Boundary: block preparation owns each route's endpoint difference and whether fade is enabled; voice rendering owns elapsed time and interpolation progress.
Change: production routes reuse both prepared values while preserving the existing interpolation order. The reference path retains the previous subtraction and fade-state comparison.
Validation: Release compilation and the dense 16-voice free-running-motion benchmark passed every focused check with exact signatures. Timing remained narrowly mixed, so no general percentage claim is attached.

2026-08-27 - Redshift Active Tone-Motion Route Ownership

Boundary: block preparation owns the ordered set of active Tone Motion destinations; voices own the evaluated value for each active route.
Change: production rendering iterates the compact active-route list instead of scanning all eight destinations. The reference path retains the former scan.
Validation: Release compilation and the one-route, 16-voice free-running-motion benchmark passed every focused check with exact signatures. Route timing was highly variable, so no general percentage claim is attached.

2026-08-27 - Redshift Tone-Motion Phase And Offset Ownership

Boundary: block preparation owns each route's double start phase and whether an offset exists; voice rendering owns motion time and elapsed progression.
Change: production rendering reuses the converted phase and bypasses subtraction for immediate-start routes. Delayed routes and the reference path retain the previous arithmetic and threshold behavior.
Validation: Release compilation and the dense 16-voice free-running-motion benchmark passed every focused check with exact signatures. Timing remained narrowly mixed, so no general percentage claim is attached.

2026-08-27 - Redshift Tone-Motion Fade-Lifetime Ownership

Boundary: each voice owns completion state for note-triggered route fades; block controls own fade duration, offset, and global/note trigger selection.
Change: the original fade calculation marks completion, after which production voices reuse 1.0 until a new voice or changed fade/offset invalidates the state. Global routes and the reference path retain per-sample fade evaluation.
Validation: the dense benchmark now includes global Drive motion plus a fading, note-triggered Bits route on 16 voices. Release compilation and every focused check passed with exact signatures. All timing medians moved favorably, though an outlier prevents a general percentage claim.

2026-08-27 - Redshift Animated-Bits Derived Ownership

Boundary: each voice owns quantization levels derived from its current rounded motion bit depth; Tone Motion continues to own the sample-accurate source value.
Change: production rendering refreshes levels and reciprocal only when rounded depth changes. The self-test reference path retains per-sample derivation.
Validation: Release compilation and the dense two-route, 16-voice modulation benchmark passed every focused check with exact signatures. All three timing medians moved modestly favorably for the measured workload.

2026-08-27 - Redshift Immutable Velocity Ownership

Boundary: voice initialization owns velocity for the complete voice lifetime; the velocity-filter cache owns only mutable amount and response mode keys.
Change: removed duplicated cached velocity state and its per-sample comparison. Voice reset already invalidates the cache before a different velocity can appear.
Validation: Release compilation and the dense 16-voice two-route benchmark passed every focused check with exact signatures. Mixed timing supports no general percentage claim.

2026-08-27 - Redshift Sample-Rate Lifetime Ownership

Boundary: prepareToPlay owns sample-rate changes and clears voice state; metallic voice caches own only frequency- and spread-dependent increments.
Change: removed inverse sample rate from each metallic cache's stored keys and hot-path comparisons. Frequency and spread invalidation remain unchanged.
Validation: Release compilation and the dense 16-voice metallic/two-route benchmark passed every focused check with exact signatures. Mixed timing supports no general percentage claim.

2026-08-27 - Redshift Shared Motion-Clock Lifetime Ownership

Boundary: prepareToPlay owns sample-rate changes and invalidates the shared motion clock; the audio loop owns its current render-sample key and seconds value.
Change: removed stored sample rate and its repeated comparison from clock reuse. Re-preparation now explicitly clears validity before any new voice can consume it.
Validation: Release compilation and the dense 16-voice two-route benchmark passed every focused check with exact signatures. All medians moved favorably, but abnormal system load prevents a general percentage claim.

2026-08-27 - Redshift Fade-Key Validity Ownership

Boundary: positive fade duration and offset are the complete initialization and invalidation keys for note-triggered fade completion state.
Change: removed a parallel validity array whose only purpose duplicated the guaranteed zero-versus-positive first-use duration comparison.
Validation: Release compilation and the dense 16-voice two-route benchmark passed every focused check with exact signatures. Mixed timing supports no general percentage claim.

2026-08-27 - Redshift Benchmark Order Ownership

Boundary: the focused benchmark owns fair A/B execution order as well as exact output signatures; product code remains independent of measurement sequencing.
Change: alternate reference/optimized execution order by oscillator route and print the order in test output to make the comparison auditable.
Validation: Release compilation and the alternating-order dense benchmark passed every focused check. The stable baseline showed small cumulative optimized-path regressions, establishing cache-overhead reduction as the next refactoring focus.

2026-08-27 - Redshift Paired-Benchmark Requirement

Boundary: small DSP refactoring decisions require paired measurements close enough in time that scheduler and thermal drift cannot dominate the comparison.
Finding: alternating complete route order still produced contradictory repeated results and a large isolated reference outlier during a dynamic root-cache trial.
Requirement: before the next micro-cache decision, retain both processors for a route and alternate reference/optimized execution within each measured pass. Exact-output signatures remain mandatory and independent of timing acceptance.

2026-08-27 - Redshift Paired-Benchmark Implementation

Boundary: reference and optimized fixtures now share each route's measurement lifetime, while their DSP state, buffers, MIDI queues, and signatures remain independent.
Change: alternate execution order inside every pass and retain the median of five pass-local optimized/reference ratios alongside the two absolute medians.
Validation: Release compilation and two complete focused runs passed exact output. Near-parity ratios repeated for the zero- and one-cycle routes; a single large two-cycle advantage did not repeat and therefore supports no performance claim.

2026-08-27 - First Paired Production Decision

Candidate: bypass root-frequency cache reads and writes while pitch is known to move continuously through drift, cross-modulation, vibrato, or glide.
Result: exact output passed, but an all-route win in the first paired run became two small regressions and one modest win in confirmation.
Decision: reverted. A production optimization now requires directionally consistent repeated paired results, not merely a favorable first measurement.

2026-08-27 - Benchmark Path-Coverage Requirement

Finding: the dynamic root-cache candidate was measured while all fixture controls capable of activating it were zero, so the trial changed no executed DSP path.
Change: enable drift, cross-modulation, vibrato, and vibrato fade in the dense paired fixture and preserve the existing exact-signature requirement.
Rule: before timing a candidate, verify from parameter defaults and fixture setup that its branch is active. Timing an untouched path is not optimization evidence.

2026-08-27 - Root-Cache Candidate Closure

The corrected dynamic workload established a near-parity baseline and exercised the proposed bypass with exact output.
A small all-route improvement did not survive confirmation; one paired route regressed materially under heavier host load.
Close this candidate rather than repeatedly tuning a below-noise micro-change. Continue with larger algorithmic costs that can demonstrate repeatable movement.

2026-08-27 - Redshift Metallic-Tail Lifetime

Boundary: a metallic voice owns its audible decay lifetime; block controls own the current spread-derived decay rate.
Change: retire six-oscillator metallic rendering below the established exp(-19.5) settlement threshold and invalidate retirement when decay rate changes.
Validation: two corrected dynamic paired runs passed exact-signature tolerance and all focused behavior checks. The two-cycle route improved in both runs, with broader route movement varying under host load.

2026-08-27 - Redshift Stochastic-State Activity

Boundary: white and pink noise state advances only while Noise Mix can route that state to audible output; active-noise calculations remain unchanged.
Change: bypass RNG and pink recurrence for production Redshift voices at zero Noise Mix, and dedicate the zero-cycle paired route to that inactive case.
Validation: two corrected dynamic Release runs passed exact output and focused behavior checks. The targeted route showed a small gain followed by parity, with no meaningful regression.

2026-08-27 - Redshift Filter-Cascade Activity

Boundary: third- and fourth-pole recursion belongs only to filter slopes whose selected output consumes those poles.
Change: inactive cascade poles track a bounded current signal value instead of running recursive processing, preserving useful transition state at lower cost.
Validation: two dynamic paired Release runs passed exact output, every filter mode and slope check, and all focused Redshift contracts. Route-specific timing varied, while each run showed a substantial gain on at least one route.

2026-08-27 - Rejected Redshift Comb Ownership Split

Candidate: stop Redshift comb-buffer maintenance at neutral Comb while preserving other engines' shared delay-line behavior and clearing on activation.
Result: exact output passed, but every paired route regressed materially.
Decision: fully reverted. Avoid adding branch and voice-state ownership around a cache-friendly sequential write without stronger evidence.

2026-08-27 - Redshift Character-Control Boundary

Boundary: Drive at 0 dB and Bit Depth at 16 remain active character stages, not neutral bypass states. Their established saturation and quantization are part of patch sound and cannot be removed as a CPU shortcut.
Cleanup: removed a duplicate standby-pole bounds operation while retaining the shared filter-state safety clamp.
Validation: Release compilation and the dynamic focused gate passed exact output plus all filter and Redshift behavior checks.

Candidate: share identical free-running route values across voices while keeping note-triggered motion independent.
Result: exact output passed, but shared cache traffic caused material regressions on two of three paired routes.
Decision: fully reverted. Share only the inexpensive global motion clock; keep complete trajectory evaluation local to each voice.

2026-08-27 - Redshift Benchmark Runtime Budget

Boundary: performance evidence must remain paired and repeated, but the fixture should not render more timed material than needed for a stable median.
Change: move from five 128-block passes to seven 64-block passes and publish the geometry in test output.
Validation: the revised Release gate passed exact output and all focused checks in 252.1 seconds, with paired ratios remaining close to parity.

2026-08-27 - Rejected Pitch-Expression Constant Cache

Candidate: move Redshift's voice-stable drift phase and block-stable x-modulation rate factors out of per-sample pitch-expression calculations.
Result: exact output and all focused contracts passed, but one representative custom-cycle route regressed about 3.3% despite gains on the other two routes.
Decision: fully reverted. Do not add persistent state for these inexpensive constants without evidence of a route-neutral benefit.

2026-08-28 - Redshift Filter-Off Processing Boundary

Boundary: Filter Off owns no audible filter-envelope, coefficient, or recursive filter work; active filter modes retain the topology-preserving implementation.
Change: return the bounded oscillator signal directly while maintaining bounded hidden filter state at the current signal level.
Validation: three paired Release runs passed exact output and all focused Redshift contracts, with targeted ratios 0.979922, 0.989136, and 0.986143. A new live Off-to-low-pass test measured a 0.320717 maximum adjacent-sample transition.

2026-08-28 - Rejected Modulation Sine Approximation

Candidate: share the existing interpolated sine table with Redshift's drift, x-modulation, and width-modulation calculations while leaving oscillators exact.
Result: strict audio equivalence passed, but two of three paired routes regressed.
Decision: fully reverted. Retain standard-library sine until a different modulation representation demonstrates a consistent gain without reducing precision.

2026-08-28 - Dynamic-Cutoff Benchmark Boundary

Boundary: active-filter optimization evidence must exercise continuously moving cutoff coefficients, not only static or already-settled envelope states.
Change: add synced free-running Cutoff Tone Motion to the paired 16-voice fixture.
Benefit: future filter changes must survive custom-cycle and dynamic-coefficient workloads under the same exact-output comparison.

2026-08-28 - Rejected Shared Dynamic Filter Coefficients

Candidate: share exact matching dynamic coefficients across voices for one rendered sample while preserving independent fallback for different cutoff values.
Result: exact output passed, but strong first-run gains collapsed to parity and a later route regressed about 4.4%.
Decision: fully reverted. Keep the improved benchmark coverage and avoid processor- level coefficient cache traffic without repeatable multi-run evidence.

2026-08-28 - Rejected Filter-Off Motion Classification

Candidate: classify and skip filter-owned Tone Motion destinations while Filter Off.
Result: exact output passed, but route timing was parity to 1.5% slower.
Decision: fully reverted. The existing compact active-route loop is cheaper than per-route destination classification in the measured workload.

2026-08-28 - Redshift Optimization Closeout

Reviewed oscillator specialization, dynamic coefficients, modulation cadence, static pitch preparation, release retirement, polyphony, and voice stealing.
Retained boundary: sound-identical changes require paired evidence; control-rate interpolation requires a separate audible-error and transition contract because it intentionally changes samples.
Next milestone: use whole-project profiling to identify a dominant remaining cost, or build the perceptual harness before changing active modulation cadence.

2026-08-28 - Whole-Project Profiling Boundary

Extended the existing project CPU harness instead of creating a second profiler.
Added repository-controlled dry drums-only and per-tonal-lane passes discovered from the loaded arrangement, with engine and patch attribution in output.
Validation: the Release audio-test target compiles. Runtime percentages are deferred until an actual saved project is available; synthetic numbers are not substituted.

2026-08-28 - Project Profiler Publication Boundary

Added one supported wrapper around the existing profiler rather than duplicating measurement logic in documentation or ad hoc shell commands.
Successful measurement owns receipt archival, latest-report replacement, and report regeneration as one workflow. Validation or profiler failure publishes nothing.
Validation: parser and input-rejection checks passed; runtime publication awaits a representative .sskit project.

2026-08-28 - Project CPU Test-Gate Ownership

Integrated project profiling into the existing run_tests.ps1 gate surface rather than introducing a second user-facing test command convention.
The gate delegates build, execution, receipt, and documentation ownership to the dedicated wrapper; generic report capture is intentionally incompatible.
Validation: both scripts parse, and argument-contract rejection tests pass.

2026-08-28 - Project CPU Workflow Proof

Added a test-only project generator that creates and saves a playable Kick Lab drum lane plus a clipped Redshift bass lane through the production project format.
Added tools/test-project-cpu-profile.ps1 to validate project creation, reload, all project-profile modes, receipt publication, report content, and cleanup in one repeatable workflow. Synthetic results are removed and the prior latest report is restored so test measurements cannot be mistaken for user-project evidence.
Project lane discovery now profiles only lanes that own arrangement clips. Default empty lanes no longer produce false silent-lane failures.
Validation: Release compilation passed. The generated-project workflow passed all five global/effect profiles, drums-only isolation, Redshift lane isolation, report assertions, documentation regeneration, and cleanup.

2026-08-28 - Project CPU Interpretation Boundary

The publication wrapper now parses successful raw profile rows into a compact actionable summary while preserving those measurement rows unchanged in the receipt.
Shared-processing, delay-only, and reverb-only costs are expressed as same-run percentage-point deltas from the shared-effects-off baseline. Dry drum and tonal lane profiles are ranked by median load with P95, P99, and maximum callback load.
The report explicitly states that isolated rows contain common processing cost and must not be added together.
Validation: both PowerShell scripts parse and the generated-project workflow passed the summary, ranking, raw-measurement, publication, restoration, and cleanup checks.

2026-08-28 - Callback Deadline Interpretation

Project reports now compare the original-project callback measurements with the actual 100% audio deadline rather than assigning arbitrary health colors.
The summary reports P99 and worst-observed deadline headroom, identifies any measured callback overrun, names the highest-load isolated workload, and names the largest same-run shared-effect delta.
These statements remain observations from one controlled run, not universal hardware claims or proof that a scheduler spike is caused by a specific DSP component.
Validation: script parsing and the complete generated-project publication/restoration workflow passed with all deadline and investigation-target assertions.

2026-08-28 - Project Profiler Buffer-Size Boundary

Project CPU profiling now accepts validated power-of-two buffer sizes from 64 through 2048 samples. The normal PROJECT_CPU gate forwards the selected size and retains 512 samples as its default.
The measured audio duration remains 262,144 samples for every buffer size. Lower-latency runs therefore increase callback frequency without shortening the observation window.
Receipts include the buffer size in their filenames and reports state the active audio configuration, preventing unlike measurements from being confused.
Validation: Release compilation passed. The full generated-project workflow passed at 256 samples, including all seven profiles, derived analysis, publication, restoration, and synthetic-receipt cleanup.

2026-08-28 - Project CPU Latency Sweep

Added profile-project-cpu-sweep.ps1 and the PROJECT_CPU_SWEEP gate. They reuse the validated single-buffer profiler and build only once per sweep.
The default sweep compares 128, 256, 512, and 1024 samples. A validated custom buffer list may be supplied. Each run retains its raw receipt, while one latest report compares original-project median, P95, P99, maximum, and measured deadline status.
The prior latest report is restored on failure, and the browsable documentation site is regenerated after either successful publication or failure restoration.
Validation: all scripts parse. The generated-project workflow passed a 256/512 sweep, verified both comparison rows and three temporary receipts, then restored the prior report and removed all synthetic receipts.

2026-08-28 - Latency Trend Interpretation

Sweep reports now use the largest tested buffer as their internal relative-load baseline. Each row shows median-load change, P99 headroom, and worst-observed headroom.
The summary identifies the buffer with the least measured callback headroom. Results remain measured values even when machine scheduling makes the trend non-monotonic; the report does not rewrite noisy evidence to match an expected curve.
Validation: script parsing and the complete generated-project workflow passed at 256/512 samples, including trend assertions, aggregate publication, report restoration, and removal of all three synthetic receipts.

2026-08-28 - Latency Sweep Repeatability

Latency sweeps now support one through five repeats per buffer size. One remains the quick default; three is the recommended stronger diagnostic run when time permits.
Repeated rows report standard median load, median P95/P99, median-load spread, and the worst callback maximum observed across all repeats. Every repetition retains its own raw receipt.
Even repeat counts use the conventional average of the two middle measurements.
Validation: the generated project passed two repeats each at 256 and 512 samples, aggregate/trend assertions, five-receipt accounting, report restoration, and complete synthetic cleanup. The corrected even-count median path was rerun successfully.

2026-08-28 - Latency Sweep Order Bias Control

Repeated latency sweeps now execute round-robin by repeat, with ascending buffer size inside each round. A 256/512 two-repeat sweep therefore runs 256, 512, 256, 512 rather than exhausting both 256 runs before measuring 512.
This distributes early, late, thermal, and background-scheduling conditions more fairly across buffer sizes without increasing profiling time or changing aggregate statistics.
Reports state the execution order and list raw receipts chronologically.
Validation: the full generated-project workflow passed, and a direct receipt-marker assertion confirmed the intended round-robin sequence before cleanup and restoration.

2026-08-28 - Project Profile Environment Provenance

Project CPU receipts now contain a metadata header with capture time, project path, audio configuration, host, Windows version, process architecture, processor identity, logical-processor count, and active power plan where Windows exposes it.
The profiler's measured output remains unchanged beneath an explicit raw-output marker. Latest reports mirror the environment block so comparisons can account for machine and power context without opening each receipt.
Missing environment information is labeled unavailable rather than inferred. Collection occurs in the PowerShell publication layer, never in real-time audio code.
Validation: parser checks and the complete generated-project single/repeated-sweep workflow passed receipt metadata, raw-boundary, publication, restoration, and cleanup assertions.

2026-08-28 - Redshift Portable Cycle Archive Contract

Extended the existing project-archive regression instead of creating a Redshift-only packaging path. Its fixture now includes a Redshift slot explicitly using waveform User Cycle with an imported WAV source.
The contract requires cycle enumeration, archive packaging, local-path redaction, import-root remapping, no missing assets, audible imported rendering, project resave, reopen, and audible rendering after reopen.
Validation: Release compilation and the focused PROJECT_ARCHIVE gate passed. The archive reported five ordinary assets plus one Quasar package, six remapped resources, bound imported assets, finite audible Redshift output, and successful resave/reopen.

2026-08-28 - Redshift Transport Motion Clock Ownership

Boundary: Tone Motion Transport trigger timing is separate from Redshift's lifetime free-running clock and each voice's note-age clock.
Change: added an internal-sequencer-relative sample clock. It resets on both sequencer start paths, advances by the rendered block length only while running, and freezes while stopped. Arrangement-start now uses the same audio-callback guard as the other start controls. The renderer derives each sample's position from one block snapshot rather than performing an atomic update per sample.
Validation: Release compilation and the complete focused Redshift gate passed. Its explicit clock contract proves stopped, start, running, stopped-again, resume, and arrangement-start behavior at exact sample counts.

2026-08-28 - Redshift Note And Legato Clock Ownership

Boundary: Note-triggered Tone Motion owns per-note age; Legato-triggered Tone Motion owns phrase age. Neither borrows the amplitude envelope's general age.
Change: overlapping notes always reset Note age while preserving Legato phrase age. Destination fade-completion caches reset only when their trigger restarts. Block controls gate both per-sample increments when no active route needs them.
Validation: Release compilation and the complete focused Redshift gate passed. The overlap fixture proves a zeroed Note clock and unchanged positive Legato clock at the same note transition.

2026-08-28 - Redshift Live Motion Publication Boundary

Boundary: the audio renderer owns actual per-voice Tone Motion values; the UI owns normalization, refresh rate, and drawing. The UI never reads mutable Voice objects or writes parameters to imitate modulation.
Change: publish the newest active Redshift voice once per block through atomic value and generation snapshots. Publication is enabled only for an open editor. The 20 Hz timer stores a normalized read-only property on the existing knob.
Validation: Release compilation and the complete focused Redshift gate passed. The publication contract proves finite active values, invalid-index rejection, and stale-value invalidation after feedback is disabled.

2026-08-28 - Redshift Tone Motion Block Boundary

Boundary: .sstmotion owns only the complete Tone Motion subsystem: eleven fields across eight destinations plus two legacy shared controls.
Change: serialization and transactional application use one versioned schema. Every value and parameter range is prepared before the first host notification; malformed blocks cannot leave partially changed routes.
Validation: Release compilation and the complete focused Redshift gate passed with toneBlock=1. The contract checks all 106 fields, base-knob exclusion, cross-slot isolation, wrong version, missing field, invalid range, and slot bounds.

2026-08-28 - Redshift Portamento Trajectory Boundary

Boundary: note-transition setup owns mode, direction, duration, and curve selection; the renderer advances only an already prepared finite journey or the preserved legacy coefficient path.
Change: finite Time, interval-scaled Rate, tempo Sync, four musical curves, directional gating, and Off were added without introducing allocation, locking, or parameter lookup inside the per-sample renderer.
Validation: Release compilation and the complete focused Redshift gate passed with portamento=1. The contract proves exact finite arrival, half-octave Rate scaling, tempo-derived duration, direction rejection, Off, and legacy movement. It also proves that Legato Only returns immediately to a held note while Fingered prepares a timed return journey. Explicit Continue and Retrigger envelope-age contracts pass, and Legacy proves the prior Mono restart convention remains intact.

2026-08-28 - Redshift Tone Motion Endpoint Holds

Boundary: the existing trajectory evaluator owns endpoint dwell; no parallel LFO or envelope path was introduced.
Change: each route now prepares Hold A and Hold B once per block. Loop and return geometries remap normalized progress while retaining zero-hold Skew behavior. Version 2 Motion Blocks store all 106 fields and version 1 blocks load with both holds defaulted to zero.
Validation: Release compilation and the complete focused gate passed with endpointHolds=1 and toneBlock=1, including exact dwell, travel, return, one-shot, Hold End, skew-compatibility, and legacy-block checks.

2026-08-28 - Shared Motion Division Compatibility

Boundary: syncedMotionRateChoices() remains the single mapping used by Redshift motion, glide, and other synchronized Engine modulation.
Change: dotted, triplet, 3/16, 5/16, and dotted/triplet bar choices were appended instead of reordering established entries. Saved numeric choice indices therefore keep their original musical meaning.
Validation: Release compilation and the complete focused Redshift gate passed with expandedDivisions=1, barsAscending=1, and all motion contracts intact.

2026-08-28 - Redshift Quantized Launch Boundary

Boundary: note and phrase setup calculate one launch delay from the existing sequencer or free-running sample clock. The ordinary Tone Motion evaluator then treats that delay as part of its existing offset.
Compatibility: Motion Block schema version 3 stores shared Note Launch; versions 1 and 2 load transactionally with Immediate.
Validation: Release compilation and the complete focused gate passed with quantizedLaunch=1, toneBlock=1, and hotPathEquivalent=1.

2026-08-28 - Redshift Step Motion Core Boundary

Boundary: Step Motion uses one fixed 16-value normalized array rather than creating 16 automatable parameters across eight routes and every source slot.
The pure evaluator owns count clamping, rotation, direction, and interpolation; future UI/state code will publish complete immutable route snapshots.
Validation: the focused gate passed with stepMotionCore=1 and hotPathEquivalent=1, covering forward, reverse, ping-pong, rotation, and smooth interpolation.

2026-08-28 - Redshift Step Motion Snapshot Ownership

Boundary: edits allocate and sanitize one complete pattern away from the audio thread, then atomically publish an immutable shared snapshot. Null means the untouched default and requires no pattern allocation.
Project state stores only published routes. Lane copy/paste and targeted undo carry the same shared immutable ownership, preventing cross-lane aliasing or omitted synth state.
Validation: the focused gate passed with stepMotionState=1, proving bounded sanitization, sparse round-trip, clear, isolation, and invalid-index refusal.

2026-08-28 - Redshift Step Motion Preset Ownership

Boundary: one serializer/parser owns Step Motion route data for Redshift patch files and complete Tone Motion Blocks. Parsing prepares every route before any parameter or immutable pattern publication occurs.
Compatibility: .sstmotion schema version 4 stores patterns; versions 1-3 clear them. Older .sspoly patches also clear patterns instead of inheriting stale state from the destination instrument.
Validation: Release compilation passed for both formats. The focused gate proved current Motion Block round-trip, legacy clearing, invalid-step refusal, toneBlock=1, and hotPathEquivalent=1.

2026-08-28 - Redshift Step Motion Audio Ownership

Boundary: block preparation atomically acquires at most one immutable pattern per destination. Rendering borrows that snapshot and never locks or allocates.
Step Motion replaces normalized Shape output while the established route owns timing, trigger, fade, offset, launch, depth, endpoints, and lifetime.
Validation: the focused gate passed with stepMotionAudible=1, proving a distinct bounded cutoff render and cross-slot isolation; all prior contracts and hotPathEquivalent=1 also passed.

2026-08-28 - Redshift MSEG Editor Boundary

Boundary: one Tone popup edits only its instrument-slot/destination MSEG route.
Implementation: the editor keeps a local working copy and publishes one validated immutable snapshot per gesture. STEP and MSEG share the advanced panel and cannot both claim authority for the same route.
Validation: the focused Redshift suite passed MSEG core, playback, state, audible, persistence, isolation, and hot-path-equivalence contracts.

2026-08-28 - Redshift MSEG Factory Ownership

Boundary: the processor-level factory creates complete validated route data; the UI only selects and publishes it, and the renderer remains unaware of preset names.
Benefit: future browsers, drag-and-drop assets, and other instruments can reuse the same shapes without copying UI logic or introducing an audio-path branch.
Validation: all seven factories pass route validation and the complete focused Redshift suite retains hotPathEquivalent=1.

2026-08-28 - Redshift Single-Route Clipboard

Boundary: the clipboard owns exactly one destination's route parameters and optional immutable Step/MSEG data. It excludes base Tone values, other routes, and shared legacy controls.
Transaction: paste validates every target parameter before one scoped undo checkpoint and publication; malformed or unavailable targets change nothing.
Validation: Release compilation and the focused Redshift isolation, persistence, audible-motion, and hot-path contracts pass.

2026-08-28 - Redshift Durable Route Format

Boundary: .sstroute serializes the same destination-neutral data as the single-route clipboard and remains distinct from eight-route .sstmotion files.
Transaction: the parser validates format, version, all 13 finite controls, Step Motion, MSEG, and exclusive trajectory authority before exposing a prepared route.
Validation: exact round-trip and malformed-version refusal pass as toneRouteFile=1, with the complete focused Redshift suite still green.

2026-08-28 - Redshift Route Library Boundary

Boundary: the popup indexes only the dedicated non-recursive Routes folder; selection is inert and explicit Apply reuses the transactional route loader.
Refresh occurs when the popup is created or after a successful save. No watcher, polling timer, or audio-owned catalog state was introduced.
Validation: Release compilation and the focused Redshift suite pass with route file, isolation, audible-motion, and hot-path contracts intact.

2026-08-28 - Redshift Route Drop Boundary

Boundary: only the open Tone Motion popup accepts .sstroute; the global editor drop target remains reserved for MIDI and package workflows.
Transaction: drop delegates to the existing route parser and scoped paste path, preserving validation, undo, destination ownership, and rejection behavior.
Validation: the standalone target and complete focused Redshift suite pass.

2026-08-28 - Redshift Saved-Route Deletion

Boundary: deletion operates only on the selected indexed file in the dedicated Routes folder and never publishes or clears processor route state.
Safety: explicit confirmation precedes disk removal; success refreshes the library and failure is visible without pretending the file was removed.
Validation: Release compilation and the full focused Redshift suite pass.

2026-08-28 - Redshift Motion Rate Badges

Boundary: badges are read-only UI summaries derived from the existing Depth and shared Cycle Length parameter mapping; they own no state or timing logic.
Layout: a fixed Tone-cell header region accommodates compact active labels without covering or resizing the destination knob.
Validation: Release compilation and the full focused Redshift suite pass.

2026-08-28 - Redshift Oscillator Morph Motion

Boundary: the feature mirrors the specialized Pitch Motion ownership model, but retains separate per-oscillator parameters and prepared controls.
Real-time rule: block preparation resolves duration and activation; rendering performs only bounded arithmetic and the shared deterministic shape lookup.
Compatibility: neutral defaults preserve old patch sound, while native patch and project lists explicitly own the new state.
Validation: Release compilation and the full focused Redshift suite pass, including neutral-depth, oscillator-isolation, and CPU contracts.

2026-08-28 - Redshift Morph Motion Blocks

Boundary: .ssmorph owns only A, B, Depth, Duration, Phase, Shape, and Key Reset for one explicitly selected oscillator.
Transaction: the loader prepares and validates every field before publishing any parameter change; unrelated oscillator and patch state remain untouched.
Real-time impact: serialization and factory application are message-thread UI actions and add no render-time branch, allocation, lock, or filesystem access.
Validation: the full focused suite passes with morphBlock=1 and all existing sound, isolation, persistence, and CPU contracts intact.

2026-08-28 - Redshift Morph Block Browser

Boundary: the browser owns only discovery and selection of .ssmorph files in the dedicated folder; applying still delegates to the transactional block API.
Lifecycle: discovery happens at popup construction and successful save, avoiding long-lived filesystem state and keeping the audio architecture unchanged.
Validation: Release compilation and the complete focused Redshift suite pass.

2026-08-28 - Redshift Morph Block Drop Boundary

Boundary: only the open Morph Motion popup accepts one .ssmorph; the global editor remains reserved for its established MIDI and package workflows.
Transaction: drop reuses the validated block loader and cannot partially apply malformed data or target a different oscillator.
Validation: Release compilation and the complete focused Redshift suite pass.

2026-08-28 - Redshift Morph Block Deletion

Boundary: deletion accepts only the currently indexed saved-file entry; factory choices never resolve to a deletable file.
State safety: removing a library asset does not publish, clear, or reconstruct any processor parameter, so the current patch remains sounding as configured.
Validation: Release compilation and the complete focused Redshift suite pass.

2026-08-28 - Redshift Filter Character Boundary

Boundary: filter model selects character independently from filter type, slope, cutoff, resonance, and Tone Motion routing.
Compatibility: Clean is the exact neutral default; Silk interpolates one bounded character amount inside the existing preallocated filter rather than introducing a parallel processor or new ownership graph.
Validation: Release compilation and the full focused Redshift suite pass with silk=1, filter isolation, finite-output, and hot-path equivalence contracts.

2026-08-28 - Redshift Bite Character Extension

Boundary: Bite is a third coordinate in the existing filter-character control, not a second processor, copied ladder implementation, or new state owner.
Real-time rule: the active character performs bounded arithmetic inside the existing filter sample; Clean remains neutral and all states remain per voice.
Validation: the full focused suite passes with bite=1, distinct Clean/Silk/Bite signatures, bounded LP/HP/BP output, isolation, and CPU equivalence contracts.

2026-08-28 - Redshift Filter Authority Presentation

Boundary: presentation derives solely from Filter Type; it never rewrites Model, Slope, or sound state.
Truthfulness: Model and Slope are unavailable while the filter is Off, and Slope is unavailable for fixed-response Band-pass. Stored choices return unchanged.
Real-time impact: this is message-thread component state only and adds no DSP, polling, allocation, or audio-thread branch.

2026-08-28 - Redshift Tone Scene Transaction

Boundary: .ssscene composes 12 base Tone parameters with the existing complete Tone Motion Block; it does not broaden either component's ownership.
Transaction: every base value and the nested motion object validate before the base Tone state is published. Invalid content leaves Tone and Motion unchanged.
Isolation: scene recall excludes oscillators, envelopes, glide, Mixer, lane, automation, and patch identity state. The focused gate passes toneScene=1.

2026-08-28 - Redshift Filter Slope Transition Ownership

Boundary: each voice owns one continuous slope coordinate; the existing filter core owns adjacent-response interpolation and no UI or patch layer owns DSP state.
Efficiency: the existing auxiliary states are reused, with the settled 12 dB optimized bypass preserved.
Validation: all four static responses are distinct and bounded, while a held-note 6-to-24 dB switch passes the focused discontinuity and CPU contracts.

2026-08-28 - Redshift Smooth Motion Evaluation Boundary

Boundary: block preparation decides whether a route belongs to the proven smooth/slow subset; each voice owns only its interpolation anchor, delta, and validity state.
Safety: unsupported or stateful route families continue through the original evaluator, and the approximation resets to an exact production value every eight samples.
Validation: mathematical and rendered A/B gates pass; the paired 32-voice stress render records a 0.901 CPU ratio with negligible output error.

2026-08-28 - Filter Lookup Rejection

Dynamic cutoff and resonance tables were removed after repeated median CPU tests measured regressions. Passing numerical and rendered-error checks is not sufficient evidence for retaining an optimization.
Small CPU claims now require repeated paired passes and median comparison; a single favorable timing pass is treated as exploratory only.

2026-08-28 - Shared Tone Motion Ownership

Boundary: global-clock routes without release-sensitive MSEG state belong to the instrument slot for evaluation; voices consume the resulting immutable sample value. Voice-clock and release-sensitive routes remain voice-owned.
Cache identity includes slot, destination, and global render sample, preventing lane or route leakage while eliminating redundant polyphonic evaluation.
Validation: the shared path is bit-exact against per-voice evaluation and records a 0.778 CPU ratio in the focused 32-voice fixture.

2026-08-28 - Shared Oscillator Motion Ownership

Boundary: Key Reset determines ownership. Off means the instrument slot owns pitch/morph route evaluation; on means each voice owns its note-age trajectory.
Pitch and morph caches are separated by slot, oscillator, value type, and render sample. They cannot publish into another oscillator or instrument instance.
Validation: the expanded global-motion fixture is bit-exact and records a 0.736 CPU ratio at 32 voices.