feat: constellations preset (seeded asterisms, template-held) (#59)

* feat: add constellation asterism data and seeded pick

* feat: fit constellation figures to grid with aspect correction

* feat: rasterize anti-aliased constellation template

* feat: seed agents along constellation stars and edges

* fix: document and assert seed_agents empty-Vec precondition

* feat: wire InitMode::Constellation seeding and trail pre-seed

Add InitMode::Constellation variant, SimConfig::constellation_restamp_floor
field, Simulation::constellation_template, build-once layout in new()/reset(),
trail pre-seed via max-combine, and extend init_species with constellation_layout
param + dispatch arm. Add non-exhaustive arms in runner.rs and explorer.rs.

* feat: static constellation re-stamp via post-decay max

* test: strengthen constellation drift assertion to verify no re-stamp

* feat: add ConstellationStatic preset and retune Constellation for atlas init

* feat: render both constellation presets as Braille atlas linework

* fix: make Constellation reset deterministic, drop thread_rng re-roll

`effective_init_mode` was calling `InitMode::random(&mut thread_rng())`
for Constellation, making every auto-reset and manual restart choose a
different init layout. Now that the constellation figure is selected by
the seeded sim RNG inside `Simulation::new`, the reset path is fully
deterministic. The function becomes a pass-through and the `preset`
argument is dropped at the function and all three call sites. Stale
doc comments updated accordingly.

* test: register ConstellationStatic and regenerate preset goldens

Add "constellationstatic" to the PRESETS array in preset_config_snapshot.rs
and regenerate tests/golden/preset_configs.txt. The constellation block now
reflects init_mode=Constellation (changed from Random), and a new
constellationstatic block appears with restamp_floor-discriminated scalars.

Fix two clippy field_reassign_with_default errors in constellation test
helpers in src/simulation/mod.rs (use struct-init syntax).

Full gate: 1017 lib + 56 visual_regression + 19 doc tests, all green.

* fix: make ConstellationStatic never-reset behavior explicit

* feat: make constellation template-led — scale to brightness, weight stars, retune presets

Template values (0..1) are now multiplied by max_brightness at every stamp
site (new(), reset(), update()) so the pre-seeded figure renders at full
trail-brightness range instead of ~3% white-point.  Star sigma tightened
to 2.2px; edge peak/sigma reduced to 0.45/0.55 for hairline linework.

ConstellationStatic: restamp_floor 1.0, decay 0.92, deposit 0.6, count 2500.
Constellation drift: decay 0.95, deposit 1.5, count 5000, floor stays 0.0.

Test rewritten to assert held > 1.5 (proves scaling happened) and that
drift decays strictly below the static floor after 20 frames.

* feat: constellation v2 — points render, lin/log split, low white-point, richer canvas-filling figures

- Render: both Constellation + ConstellationStatic switch Braille→Points charset,
  add IntensityMapping::linear_log_split(10.0), explicitly pin auto_normalize=false
- ConstellationStatic sim retune: max_brightness 30→10, deposit_amount 0.6→0.3
  (top-level and species[0]), count 2500→2000
- fit_to_grid margin 10%→5% so figures use more of the canvas
- Replace 6 figures (drop Cassiopeia/Crux): Orion(10s/11e) Ursa Major(10s/10e)
  Scorpius(10s/9e) Cygnus(7s/6e) Leo(9s/9e) Gemini(11s/10e)
- Update test: both_constellations_render_braille_cosmic →
  both_constellations_render_points_cosmic (asserts Points/Cosmic/false/lin-log-split)
- Regenerate preset_configs.txt golden (constellationstatic block only)

* feat: unify into single 'constellations' preset (static), drop drift variant

Author: tamirelazar

src/app/mod.rs

@@ -338,14 +338,10 @@ pub(crate) fn apply_overrides(
         let init = profile.sim.preferred_init_mode.unwrap_or(InitMode::Food);
         let seed = profile.seed.unwrap_or_else(fresh_seed);
         rs.original_seed = seed;
-        // Baseline stays the preset's preferred mode (non-mutating w.r.t. the
-        // reroll) so dirty-projection sees no permanent edit.
+        // Baseline stays the preset's preferred mode (non-mutating w.r.t. any
+        // prior state) so dirty-projection sees no permanent edit.
         rs.original_init_mode = init;
-        // Constellation re-rolls a fresh layout on this (re-)seed. The preset being
-        // applied comes from the overrides; fall back to the live preset for config
-        // loads / resets that don't pin a preset.
-        let effective_preset = ov.preset.unwrap_or(rs.current_preset);
-        let effective_init = crate::app::runner::effective_init_mode(effective_preset, init);
+        let effective_init = crate::app::runner::effective_init_mode(init);
         sim.reset(seed, effective_init);
     }
 

src/app/runner.rs

@@ -84,15 +84,11 @@ fn update_food_persistence(sim: &mut Simulation, runtime_state: &mut RuntimeStat
     }
 }
 
-/// The init mode to actually seed with. Constellation re-rolls a fresh random
-/// mode each reset; every other preset uses its stable baseline. Does NOT mutate
-/// config or `original_init_mode`, so dirty-projection stays clean.
-pub(crate) fn effective_init_mode(preset: Preset, base: InitMode) -> InitMode {
-    if matches!(preset, Preset::Constellation) {
-        InitMode::random(&mut rand::thread_rng())
-    } else {
-        base
-    }
+/// The init mode to actually seed with. The constellation figure is chosen by
+/// the seeded simulation RNG inside `Simulation::new`, so reset stays
+/// deterministic and every preset uses its stable baseline init mode.
+pub(crate) fn effective_init_mode(base: InitMode) -> InitMode {
+    base
 }
 
 /// Checks if simulation should auto-reset based on entropy collapse.
@@ -132,11 +128,7 @@ fn check_auto_reset(
 
         // Use the live original init mode (the apply seam updates it on restart),
         // NOT the startup `init_mode` local which is stale after a config load.
-        // Constellation re-rolls a fresh layout each reset (non-mutating).
-        let init_mode = effective_init_mode(
-            runtime_state.current_preset,
-            runtime_state.original_init_mode,
-        );
+        let init_mode = effective_init_mode(runtime_state.original_init_mode);
         sim.reset(new_seed, init_mode);
         runtime_state.reset_collapse_counter();
         runtime_state.reset_warmup();
@@ -1049,6 +1041,7 @@ pub fn run_simulation(
                     InitMode::RandomClusters => "Clusters",
                     InitMode::Food => "Food",
                     InitMode::Petri => "Petri",
+                    InitMode::Constellation => "Constellation",
                 };
 
                 let color_mode_name = match color_mode {
@@ -1759,12 +1752,7 @@ pub fn run_simulation(
                             }
                         }
                         ControlAction::Restart => {
-                            // Constellation re-rolls a fresh layout each reset
-                            // (non-mutating: original_init_mode is untouched).
-                            let init_mode = effective_init_mode(
-                                runtime_state.current_preset,
-                                runtime_state.original_init_mode,
-                            );
+                            let init_mode = effective_init_mode(runtime_state.original_init_mode);
                             sim.reset(runtime_state.original_seed, init_mode);
                         }
                         ControlAction::QuickKey(c) => match resolve_bind(c, &user_binds) {
@@ -2894,6 +2882,16 @@ mod tests {
             "CLI override retains sensor_angle"
         );
     }
+
+    #[test]
+    fn constellation_reset_is_now_stable() {
+        use crate::simulation::config::InitMode;
+        // Constellation must NOT re-roll a random init mode anymore.
+        assert_eq!(
+            effective_init_mode(InitMode::Constellation),
+            InitMode::Constellation
+        );
+    }
 }
 
 #[cfg(test)]

src/config_defaults.rs

@@ -717,6 +717,9 @@ pub mod color_mode {
     pub const DEFAULT_MODE: &str = "true";
 }
 
+/// Default constellation re-stamp floor (0.0 = off; Static presets raise it).
+pub const DEFAULT_CONSTELLATION_RESTAMP_FLOOR: f32 = 0.0;
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/exploration/explorer.rs

@@ -423,6 +423,7 @@ impl ExplorationParams {
             InitMode::RandomClusters => "InitMode::RandomClusters",
             InitMode::Food => "InitMode::Food",
             InitMode::Petri => "InitMode::Petri",
+            InitMode::Constellation => "InitMode::Constellation",
         };
 
         format!(

src/preset_app_defaults.rs

@@ -25,12 +25,12 @@ impl Default for PresetAppDefaults {
 impl From<Preset> for PresetAppDefaults {
     fn from(preset: Preset) -> Self {
         match preset {
-            // Constellation re-rolls a fresh layout on collapse. The entropy
-            // detector is too eager for it (low brightness-value diversity in
-            // coherent rotating/blob patterns reads as "dead" while they are
-            // still alive), so default it off and rely on stagnation alone.
+            // Constellation holds its figure indefinitely via the per-frame
+            // template re-stamp, so it must NOT auto-reset — a reset would drop
+            // the held figure. Entropy threshold is moot while auto_reset is
+            // false; set 0.0 to keep the detector off explicitly.
             Preset::Constellation => Self {
-                auto_reset: true,
+                auto_reset: false,
                 entropy_threshold: 0.0,
             },
             _ => Self::default(),
@@ -49,8 +49,9 @@ mod tests {
         );
     }
     #[test]
-    fn constellation_opts_in() {
-        assert!(PresetAppDefaults::from(Preset::Constellation).auto_reset);
+    fn constellation_opts_out_of_auto_reset() {
+        // Constellation holds its figure via template re-stamp — must NOT auto-reset.
+        assert!(!PresetAppDefaults::from(Preset::Constellation).auto_reset);
         assert_eq!(
             PresetAppDefaults::from(Preset::Network).auto_reset,
             crate::config_defaults::auto_reset::DEFAULT_AUTO_RESET

src/preset_sim_defaults.rs

@@ -47,6 +47,9 @@ pub(crate) struct PresetSimDefaults {
     pub separate_species_trails: bool,
     pub sampling_mode: SamplingMode,
     pub respawn_config: RespawnConfig,
+    /// Constellation atlas re-stamp floor. 0.0 = drift (no re-stamp);
+    /// > 0.0 = continuous self-healing template re-stamp (static hold).
+    pub constellation_restamp_floor: f32,
 }
 
 impl Default for PresetSimDefaults {
@@ -80,6 +83,8 @@ impl Default for PresetSimDefaults {
             separate_species_trails: false,
             sampling_mode: SamplingMode::Nearest,
             respawn_config: RespawnConfig::default(),
+            constellation_restamp_floor:
+                crate::config_defaults::DEFAULT_CONSTELLATION_RESTAMP_FLOOR,
         }
     }
 }
@@ -114,6 +119,7 @@ impl PresetSimDefaults {
         config.separate_species_trails = self.separate_species_trails;
         config.sampling_mode = self.sampling_mode;
         config.respawn_config = self.respawn_config;
+        config.constellation_restamp_floor = self.constellation_restamp_floor;
     }
 }
 
@@ -646,24 +652,25 @@ impl From<Preset> for PresetSimDefaults {
                 }],
                 ..Self::default()
             },
-            // Sparse star-map scatter (config.rs:806-826)
+            // Constellation: continuous template re-stamp holds the figure crisp
             Preset::Constellation => Self {
                 sensor_angle: 45.0,
                 sensor_distance: 12.0,
-                rotation_angle: 25.0,
-                step_size: 0.8,
-                decay_factor: 0.96,
-                deposit_amount: 4.0,
+                rotation_angle: 18.0,
+                step_size: 0.3,
+                decay_factor: 0.92,
+                deposit_amount: 0.3,
                 diffusion_kernel: DiffusionKernel::Mean3x3,
-                max_brightness: 30.0,
-                preferred_init_mode: Some(InitMode::Random),
+                max_brightness: 10.0,
+                preferred_init_mode: Some(InitMode::Constellation),
+                constellation_restamp_floor: 1.0,
                 species_configs: vec![SpeciesConfig {
                     name: "default".to_string(),
-                    count: 12_000,
+                    count: 2_000,
                     sensor_angle: 45.0,
-                    rotation_angle: 25.0,
-                    step_size: 0.8,
-                    deposit_amount: 4.0,
+                    rotation_angle: 18.0,
+                    step_size: 0.3,
+                    deposit_amount: 0.3,
                     ..Default::default()
                 }],
                 ..Self::default()
@@ -1020,4 +1027,20 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn constellation_is_registered_and_static() {
+        use crate::simulation::config::{preset_from_name, InitMode, Preset, SimConfig};
+        // Primary name
+        let p = preset_from_name("constellations").expect("preset registered");
+        assert_eq!(p, Preset::Constellation);
+        // Alias
+        let p2 = preset_from_name("constellation").expect("alias registered");
+        assert_eq!(p2, Preset::Constellation);
+
+        let cfg: SimConfig = Preset::Constellation.into();
+        assert!(cfg.constellation_restamp_floor > 0.0);
+        // preferred_init_mode is Option<InitMode>; unwrap since the arm sets Some(_)
+        assert_eq!(cfg.preferred_init_mode.unwrap(), InitMode::Constellation);
+    }
 }

src/profile_overrides.rs

@@ -1943,26 +1943,26 @@ mod tests {
         );
     }
 
-    /// Constellation resolves `auto_reset = true` when CLI does not override it.
+    /// Constellation resolves `auto_reset = false` (static hold) when CLI does not override it.
     #[test]
     fn resolve_app_uses_preset_auto_reset_default() {
         let ov = ProfileOverrides {
             preset: Some(crate::simulation::config::Preset::Constellation),
             ..Default::default()
         };
         assert!(
-            ov.resolve_app().auto_reset,
-            "constellation auto_reset should be on by default"
+            !ov.resolve_app().auto_reset,
+            "constellation auto_reset should be off by default (static hold)"
         );
         // Explicit override wins over the preset's default.
         let ov2 = ProfileOverrides {
             preset: Some(crate::simulation::config::Preset::Constellation),
-            auto_reset: Some(false),
+            auto_reset: Some(true),
             ..Default::default()
         };
         assert!(
-            !ov2.resolve_app().auto_reset,
-            "explicit Some(false) must override the preset default"
+            ov2.resolve_app().auto_reset,
+            "explicit Some(true) must override the preset default"
         );
     }
 

src/render_art_defaults.rs

@@ -208,10 +208,12 @@ impl From<Preset> for RenderArtDefaults {
                 afterglow: 0.1,
                 ..Self::default()
             },
-            // Points charset: sparse particle star-map.
+            // Atlas linework: Points charset for crisp star dots, lin/log split mapping.
             Preset::Constellation => Self {
                 charset: Some(Charset::Points),
                 palette: Some(Palette::Cosmic),
+                intensity_mapping: IntensityMapping::linear_log_split(10.0),
+                auto_normalize: Some(false),
                 ..Self::default()
             },
             // Quantize mapping + Wrap palette cycling: posterized bands.
@@ -489,6 +491,18 @@ mod tests {
         assert_eq!(RenderArtDefaults::from(Preset::Gossamer).afterglow, 0.2);
     }
 
+    #[test]
+    fn constellation_renders_points_cosmic() {
+        let d = RenderArtDefaults::from(Preset::Constellation);
+        assert_eq!(d.charset, Some(Charset::Points));
+        assert_eq!(d.palette, Some(Palette::Cosmic));
+        assert_eq!(d.auto_normalize, Some(false));
+        assert_eq!(
+            d.intensity_mapping,
+            IntensityMapping::linear_log_split(10.0)
+        );
+    }
+
     #[test]
     fn vinescii_is_ascii_vines() {
         use crate::preset_sim_defaults::PresetSimDefaults;

src/simulation/config.rs

@@ -106,7 +106,7 @@ pub enum Preset {
     Etching,
     /// Color that shifts with motion direction (temporal Hue mode).
     Drift,
-    /// Sparse star-map scatter (Points charset).
+    /// Constellation: crisp star-map held via continuous template re-stamp (Points charset).
     Constellation,
     /// Posterized color bands (Quantize mapping + Wrap palette cycles).
     Mosaic,
@@ -274,8 +274,8 @@ pub const PRESETS: &[PresetSpec] = &[
     },
     PresetSpec {
         preset: Preset::Constellation,
-        name: "Constellation",
-        aliases: &[],
+        name: "constellations",
+        aliases: &["constellation", "atlas"],
         quick_key: Some('2'),
     },
     PresetSpec {
@@ -424,11 +424,13 @@ pub enum InitMode {
     Food,
     /// Agents distributed in a Gaussian blob at the center (Petri dish style).
     Petri,
+    /// Agents seeded as a real star constellation (stars + asterism edges).
+    Constellation,
 }
 
 impl InitMode {
-    /// Uniformly pick any init mode. Used by presets (e.g. Constellation) that
-    /// re-roll their starting layout on each reset.
+    /// Uniformly pick any init mode for non-structural presets. Named structural
+    /// modes such as `Constellation` are excluded and keep a stable layout.
     ///
     /// `ALL` is hand-maintained; the exhaustive match below is a compile-time
     /// guard — adding an `InitMode` variant fails to compile here until it is
@@ -459,7 +461,8 @@ impl InitMode {
                 | InitMode::Spiral
                 | InitMode::RandomClusters
                 | InitMode::Food
-                | InitMode::Petri => {}
+                | InitMode::Petri
+                | InitMode::Constellation => {}
             }
         }
         ALL[rng.gen_range(0..ALL.len())]
@@ -1395,6 +1398,10 @@ pub struct SimConfig {
     pub respawn_config: RespawnConfig,
     /// Trail sampling method (nearest or bilinear).
     pub sampling_mode: SamplingMode,
+    /// Constellation atlas re-stamp strength, applied each frame after
+    /// diffusion/decay. 0.0 = no re-stamp (drift); > 0.0 = self-healing
+    /// template source (static hold).
+    pub constellation_restamp_floor: f32,
 }
 
 impl SimConfig {
@@ -1520,6 +1527,8 @@ impl Default for SimConfig {
             },
             respawn_config: RespawnConfig::default(),
             sampling_mode: SamplingMode::Nearest,
+            constellation_restamp_floor:
+                crate::config_defaults::DEFAULT_CONSTELLATION_RESTAMP_FLOOR,
         }
     }
 }