Add level 8: Scroll of Tags (tags + newlines)

Three keys:
- scroll: multi-line string (block scalar `|`)
- weight: fractional float (e.g. 12.5) — forces float without needing
  the `!!float` tag in the target text
- title:  string of digits (player needs quotes or `!!str` to avoid int)

Per-seed deterministic via ChaCha8Rng XOR'd with 0x..08.

Not wired into levels::registry() yet — integration belongs to a follow-up.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/levels/l04_list.rs

@@ -0,0 +1,71 @@
+//! Level 4 — lists. A chest of loot lies open before you.
+//!
+//! Paired design note: `l04.md`.
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Sequence, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct List;
+
+const ITEMS: &[&str] = &[
+    "sword", "torch", "rope", "bread", "dagger", "scroll", "gem", "coin", "potion", "shield",
+];
+
+#[derive(Serialize)]
+struct DescCtx {
+    items: Vec<String>,
+}
+
+impl Level for List {
+    fn id(&self) -> u8 {
+        4
+    }
+
+    fn name(&self) -> &'static str {
+        "The Chest"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0004);
+        let n = rng.gen_range(3..=5);
+        let items: Vec<&'static str> = ITEMS.choose_multiple(&mut rng, n).copied().collect();
+
+        let seq: Sequence = items
+            .iter()
+            .map(|i| Value::String((*i).to_string()))
+            .collect();
+
+        let mut top = Mapping::new();
+        top.insert(Value::String("chest".to_string()), Value::Sequence(seq));
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l04",
+            "A chest lies open. Inside:\n{% for it in items %}- {{ it }}\n{% endfor %}\n💡 Wrap the items as a YAML list under a `chest:` key.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l04",
+                &DescCtx {
+                    items: items.iter().map(|s| s.to_string()).collect(),
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "📦 A chest of loot lies open before you.".to_string(),
+        }
+    }
+}

src/levels/l05_dict_list.rs

@@ -0,0 +1,99 @@
+//! Level 5 — dictionaries AND lists. Each chamber keeps its own inventory.
+//!
+//! Paired design note: `l05.md`.
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Sequence, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct DictList;
+
+const CHAMBERS: &[&str] = &[
+    "armory", "pantry", "library", "vault", "kitchen", "cellar",
+];
+const ITEMS: &[&str] = &[
+    "sword", "shield", "bread", "water", "tome", "scroll", "gem", "coin", "dagger", "potion",
+];
+
+#[derive(Serialize)]
+struct DescCtx {
+    chambers: Vec<ChamberDesc>,
+}
+
+#[derive(Serialize)]
+struct ChamberDesc {
+    name: String,
+    items: Vec<String>,
+}
+
+impl Level for DictList {
+    fn id(&self) -> u8 {
+        5
+    }
+
+    fn name(&self) -> &'static str {
+        "Chambers"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0005);
+        let n = rng.gen_range(2..=3);
+        let chamber_names: Vec<&'static str> =
+            CHAMBERS.choose_multiple(&mut rng, n).copied().collect();
+
+        let mut inner = Mapping::new();
+        let mut desc_chambers = Vec::new();
+        for name in &chamber_names {
+            let item_n = rng.gen_range(2..=3);
+            let items: Vec<&'static str> =
+                ITEMS.choose_multiple(&mut rng, item_n).copied().collect();
+            let seq: Sequence = items
+                .iter()
+                .map(|i| Value::String((*i).to_string()))
+                .collect();
+            inner.insert(Value::String((*name).to_string()), Value::Sequence(seq));
+            desc_chambers.push(ChamberDesc {
+                name: (*name).to_string(),
+                items: items.iter().map(|s| s.to_string()).collect(),
+            });
+        }
+
+        let mut top = Mapping::new();
+        top.insert(
+            Value::String("chambers".to_string()),
+            Value::Mapping(inner),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l05",
+            "Several chambers branch off, each with its own inventory:\n\
+             {% for c in chambers %}\n{{ c.name }}:{% for it in c.items %}\n  - {{ it }}{% endfor %}\n{% endfor %}\n\
+             💡 Wrap the whole tree under a `chambers:` key — a dict of lists.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l05",
+                &DescCtx {
+                    chambers: desc_chambers,
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "🏛 You enter a hall. Doors lead to many chambers.".to_string(),
+        }
+    }
+}

src/levels/l06_anchors.rs

@@ -0,0 +1,113 @@
+//! Level 6 — anchors. Two rooms share the same trap — define it once.
+//!
+//! Paired design note: `l06.md`.
+//!
+//! Note: serde_yaml resolves aliases at parse time, so the target is
+//! emitted **expanded** (the trap dict appears in each room). Players
+//! who use anchors/aliases will produce the same parsed `Value` and
+//! pass via the semantic short-circuit. Players who paste the dict
+//! verbatim also pass.
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct Anchors;
+
+const ROOM_NAMES: &[&str] = &["north", "south", "east", "west"];
+const TRAP_TYPES: &[&str] = &["pit", "snare", "dart", "rune"];
+
+#[derive(Serialize)]
+struct DescCtx {
+    trap_type: String,
+    trap_depth: i64,
+    trap_spikes: bool,
+    rooms: Vec<String>,
+}
+
+impl Level for Anchors {
+    fn id(&self) -> u8 {
+        6
+    }
+
+    fn name(&self) -> &'static str {
+        "Anchors"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0006);
+        let trap_type = *TRAP_TYPES.choose(&mut rng).expect("non-empty");
+        let trap_depth = rng.gen_range(10..=30i64);
+        let trap_spikes = rng.gen_bool(0.5);
+        let n_rooms = rng.gen_range(2..=3);
+        let rooms: Vec<&'static str> = ROOM_NAMES
+            .choose_multiple(&mut rng, n_rooms)
+            .copied()
+            .collect();
+
+        let mut trap = Mapping::new();
+        trap.insert(
+            Value::String("type".to_string()),
+            Value::String(trap_type.to_string()),
+        );
+        trap.insert(Value::String("depth".to_string()), Value::from(trap_depth));
+        trap.insert(
+            Value::String("spikes".to_string()),
+            Value::Bool(trap_spikes),
+        );
+
+        let mut rooms_map = Mapping::new();
+        for r in &rooms {
+            rooms_map.insert(
+                Value::String((*r).to_string()),
+                Value::Mapping(trap.clone()),
+            );
+        }
+
+        let mut top = Mapping::new();
+        top.insert(Value::String("trap".to_string()), Value::Mapping(trap));
+        top.insert(
+            Value::String("rooms".to_string()),
+            Value::Mapping(rooms_map),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l06",
+            "A single trap recurs through these halls:\n\
+             - type: {{ trap_type }}\n\
+             - depth: {{ trap_depth }}\n\
+             - spikes: {{ trap_spikes }}\n\
+             \n\
+             Reuse it for these rooms: {% for r in rooms %}{{ r }}{% if not loop.last %}, {% endif %}{% endfor %}.\n\
+             💡 Define `trap: &name` once and reference it as `*name` in every room.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l06",
+                &DescCtx {
+                    trap_type: trap_type.to_string(),
+                    trap_depth,
+                    trap_spikes,
+                    rooms: rooms.iter().map(|s| s.to_string()).collect(),
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "🪤 A trap recurs through these halls.".to_string(),
+        }
+    }
+}

src/levels/l07_complex.rs

@@ -0,0 +1,142 @@
+//! Level 7 — complex data structures. The full map of a single floor.
+//!
+//! Paired design note: `l07.md`.
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Sequence, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct Complex;
+
+const EXITS: &[&str] = &["north", "south", "east", "west", "up", "down"];
+const CONTENTS: &[&str] = &[
+    "torch", "bench", "gold", "ruby", "scroll", "tome", "dagger", "shield",
+];
+const ROOMS: &[(&str, &str)] = &[
+    ("entrance", "hall"),
+    ("treasury", "vault"),
+    ("library", "study"),
+    ("kitchen", "scullery"),
+];
+
+#[derive(Serialize)]
+struct DescCtx {
+    floor: i64,
+    rooms: Vec<RoomDesc>,
+}
+
+#[derive(Serialize)]
+struct RoomDesc {
+    name: String,
+    kind: String,
+    locked: bool,
+    exits: Vec<String>,
+    contents: Vec<String>,
+}
+
+impl Level for Complex {
+    fn id(&self) -> u8 {
+        7
+    }
+
+    fn name(&self) -> &'static str {
+        "The Floor Map"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0007);
+        let floor = rng.gen_range(1..=5i64);
+        let chosen: Vec<&(&'static str, &'static str)> =
+            ROOMS.choose_multiple(&mut rng, 2).collect();
+
+        let mut rooms_map = Mapping::new();
+        let mut desc_rooms = Vec::new();
+        for (name, kind) in &chosen {
+            let exits_n = rng.gen_range(1..=3);
+            let exits: Vec<&'static str> =
+                EXITS.choose_multiple(&mut rng, exits_n).copied().collect();
+            let contents_n = rng.gen_range(1..=3);
+            let contents: Vec<&'static str> = CONTENTS
+                .choose_multiple(&mut rng, contents_n)
+                .copied()
+                .collect();
+            let locked = rng.gen_bool(0.5);
+
+            let mut room = Mapping::new();
+            room.insert(
+                Value::String("type".to_string()),
+                Value::String((*kind).to_string()),
+            );
+            room.insert(Value::String("locked".to_string()), Value::Bool(locked));
+            let exits_seq: Sequence = exits
+                .iter()
+                .map(|e| Value::String((*e).to_string()))
+                .collect();
+            let contents_seq: Sequence = contents
+                .iter()
+                .map(|c| Value::String((*c).to_string()))
+                .collect();
+            room.insert(
+                Value::String("exits".to_string()),
+                Value::Sequence(exits_seq),
+            );
+            room.insert(
+                Value::String("contents".to_string()),
+                Value::Sequence(contents_seq),
+            );
+            rooms_map.insert(Value::String((*name).to_string()), Value::Mapping(room));
+
+            desc_rooms.push(RoomDesc {
+                name: (*name).to_string(),
+                kind: (*kind).to_string(),
+                locked,
+                exits: exits.iter().map(|s| s.to_string()).collect(),
+                contents: contents.iter().map(|s| s.to_string()).collect(),
+            });
+        }
+
+        let mut top = Mapping::new();
+        top.insert(Value::String("floor".to_string()), Value::from(floor));
+        top.insert(
+            Value::String("rooms".to_string()),
+            Value::Mapping(rooms_map),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l07",
+            "Floor {{ floor }}.\n\
+             {% for r in rooms %}\n\
+             {{ r.name }} — a {{ r.kind }} (locked: {{ r.locked }})\n\
+             \texits:    {% for e in r.exits %}{{ e }}{% if not loop.last %}, {% endif %}{% endfor %}\n\
+             \tcontents: {% for c in r.contents %}{{ c }}{% if not loop.last %}, {% endif %}{% endfor %}\n\
+             {% endfor %}\n\
+             💡 Combine maps, lists, and scalars — `floor:` is an int, each room is a dict with two lists.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l07",
+                &DescCtx {
+                    floor,
+                    rooms: desc_rooms,
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "🗺 The map of this floor is rich with detail.".to_string(),
+        }
+    }
+}

src/levels/l08_tags.rs

@@ -0,0 +1,111 @@
+//! Level 8 — tags and newlines. The scroll preserves its lines and
+//! demands explicit types.
+//!
+//! Paired design note: `l08.md`.
+//!
+//! The target value uses:
+//! - a multi-line string for `scroll:` (block scalar `|` round-trips through
+//!   serde_yaml as a `Value::String` with embedded newlines),
+//! - a fractional float for `weight:` (forces float type without needing the
+//!   `!!float` tag in the target text — but the player can use either),
+//! - a string of digits for `title:` (player needs quotes or `!!str` to
+//!   avoid the integer interpretation).
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct Tags;
+
+const VERBS: &[&str] = &["Beware", "Avoid", "Heed", "Mark"];
+const NOUNS: &[&str] = &[
+    "the path that turns twice",
+    "the third spring",
+    "the silent statue",
+    "the moonlit door",
+];
+const TITLES: &[&str] = &["1024", "2048", "4096", "8192"];
+
+#[derive(Serialize)]
+struct DescCtx {
+    scroll_lines: Vec<String>,
+    weight: f64,
+    title: String,
+}
+
+impl Level for Tags {
+    fn id(&self) -> u8 {
+        8
+    }
+
+    fn name(&self) -> &'static str {
+        "Scroll of Tags"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0008);
+
+        let line_n = 2;
+        let scroll_lines: Vec<String> = (0..line_n)
+            .map(|_| {
+                let v = VERBS.choose(&mut rng).unwrap();
+                let n = NOUNS.choose(&mut rng).unwrap();
+                format!("{v} {n}.")
+            })
+            .collect();
+        // Block scalar `|` produces a string ending in `\n` after the last line.
+        let scroll_text = format!("{}\n", scroll_lines.join("\n"));
+
+        // Fractional weight so serde_yaml's float serialisation keeps the
+        // `.5` and matches the player's submission unambiguously.
+        let weight = rng.gen_range(1..=20) as f64 + 0.5;
+        let title = TITLES.choose(&mut rng).unwrap().to_string();
+
+        let mut top = Mapping::new();
+        top.insert(
+            Value::String("scroll".to_string()),
+            Value::String(scroll_text),
+        );
+        top.insert(Value::String("weight".to_string()), Value::from(weight));
+        top.insert(
+            Value::String("title".to_string()),
+            Value::String(title.clone()),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l08",
+            "A scroll demands its types. Match exactly:\n\
+             scroll: multi-line text{% for line in scroll_lines %}\n  {{ line }}{% endfor %}\n\
+             weight: must parse as the float {{ weight }}\n\
+             title:  must parse as the string \"{{ title }}\"\n\
+             💡 Block scalar `|` preserves newlines; `!!str` (or quotes) forces a digit-only string.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l08",
+                &DescCtx {
+                    scroll_lines,
+                    weight,
+                    title,
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "📜 An ancient scroll insists on its precise form.".to_string(),
+        }
+    }
+}

src/levels/mod.rs

@@ -13,6 +13,11 @@
 pub mod l01_minimum;
 pub mod l02_kv;
 pub mod l03_dict;
+pub mod l04_list;
+pub mod l05_dict_list;
+pub mod l06_anchors;
+pub mod l07_complex;
+pub mod l08_tags;
 
 use serde::{Deserialize, Serialize};