From f7f4e58d78089b28d762a9a2fc0895355e4ef7ef Mon Sep 17 00:00:00 2001
From: Weksa <weksa@minds.weksa.gamecult.org>
Date: Thu, 12 Nov 2026 16:27:13 +0000
Subject: [PATCH 1/5] language-ontology-scene s1-2: the run pins the
 speaker-state store, assembled is the one scene door, select reads slot
 Scene, Prompt::lower refuses an unread scene, weksa scene put|dump,
 speaker_scene_revision(n)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/weksa/examples/show_working.rs         |   1 +
 crates/weksa/src/context.rs                   |  27 +--
 crates/weksa/src/inventory.rs                 |   8 +-
 crates/weksa/src/lower.rs                     |   3 +
 crates/weksa/src/main.rs                      | 184 +++++++++++++++++-
 crates/weksa/src/ontology.rs                  |  12 +-
 crates/weksa/src/run.rs                       |  88 ++++++++-
 crates/weksa/src/store.rs                     |   7 +-
 crates/weksa/tests/cli.rs                     |   3 +
 crates/weksa/tests/common/mod.rs              |  15 ++
 crates/weksa/tests/context.rs                 |  34 +++-
 crates/weksa/tests/golf_loop.rs               |  25 ++-
 crates/weksa/tests/original_corpus.rs         |   4 +
 crates/weksa/tests/scene.rs                   |   4 +-
 crates/weksa/tests/speaker_state.rs           |   4 +-
 schemas/cultnet/weksa.loop_run.schema.json    |  12 +-
 .../cultnet/weksa.ontology_entry.schema.json  |   2 +-
 17 files changed, 388 insertions(+), 45 deletions(-)

diff --git a/crates/weksa/examples/show_working.rs b/crates/weksa/examples/show_working.rs
index 8c23fb2..6c39bdb 100644
--- a/crates/weksa/examples/show_working.rs
+++ b/crates/weksa/examples/show_working.rs
@@ -259,6 +259,7 @@ fn lower_error(e: &LowerError) -> Value {
         LowerError::ConsentMissing { predication } => ("ConsentMissing", format!("{predication} is a request the packet does not carry the addressee's consent to")),
         LowerError::AskerNotAddressee { predication } => ("AskerNotAddressee", format!("the agent of {predication} is not the addressee")),
         LowerError::EntityRead { entity, .. } => ("EntityRead", format!("the entity store failed reading {entity}")),
+        LowerError::SceneUnread => ("SceneUnread", "the view's scene was never read".to_string()),
     };
     json!({ "variant": variant, "reason": reason })
 }
diff --git a/crates/weksa/src/context.rs b/crates/weksa/src/context.rs
index 2b88a08..3dec960 100644
--- a/crates/weksa/src/context.rs
+++ b/crates/weksa/src/context.rs
@@ -37,7 +37,7 @@ use crate::packet::{
 use crate::run::LADDER_STEP;
 use crate::split::{Checkpoint, Split, SplitScheme, fnv1a64, hex16};
 use crate::store::{CorpusStore, normalized};
-use crate::validate::LoweringInput;
+use crate::validate::{LoweringInput, SceneRead};
 
 /// The instructions a mint prompt starts with: the editor's whole brief. Fixed
 /// per run by `PROMPT_SOURCE_DIGEST`.
@@ -71,7 +71,7 @@ A feature is {feature, value}; value is {\"Grade\": 0 to 1000}, {\"Option\": lab
 /// Fixed per run by `PROMPT_SOURCE_DIGEST`.
 pub const LOWER_INSTRUCTIONS: &str = "\
 Say the packet below in the language on the language line, as one utterance of its speaker: all of its meaning and nothing it does not carry.
-Every id is the inventory's listed below and every feature value is as listed; a grade is permille, 0 to 1000. The stance is the speaker's felt affect and restraint: it shapes how the utterance is said, not what it says. The ontology lines are choices this language makes for this speaker and stance: realize each where the packet allows; they add no meaning.
+Every id is the inventory's listed below and every feature value is as listed; a grade is permille, 0 to 1000. The stance is the speaker's felt affect and restraint: it shapes how the utterance is said, not what it says. The ontology lines are choices this language makes for this speaker, stance and scene: realize each where the packet allows; they add no meaning.
 A referent with an entity is named by one of that entity's forms on the entities line.
 Answer with one JSON object and nothing else: {\"text\": \"...\"}. No code fence, no commentary.";
 
@@ -89,7 +89,7 @@ Answer with one JSON object and nothing else: {\"text\": \"...\"}, the continuat
 /// ```no_run
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let panel = ["en-US".to_string()];
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &panel).unwrap();
 /// let t = run.train().unwrap();
@@ -104,7 +104,7 @@ Answer with one JSON object and nothing else: {\"text\": \"...\"}, the continuat
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
 /// # for n in ["c.cc", "i.cc", "e.cc", "o.cc"] { std::fs::write(p(n), [0x90]).unwrap(); }
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &["en-US".to_string()]).unwrap();
 /// let t = run.train().unwrap();
 /// let _u = t.clone();
@@ -115,7 +115,7 @@ Answer with one JSON object and nothing else: {\"text\": \"...\"}, the continuat
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
 /// # for n in ["c.cc", "i.cc", "e.cc", "o.cc"] { std::fs::write(p(n), [0x90]).unwrap(); }
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &["en-US".to_string()]).unwrap();
 /// let t = run.train().unwrap();
 /// s(&t);
@@ -337,7 +337,7 @@ impl EditFeedback {
 /// ```no_run
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let panel = ["en-US".to_string()];
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &panel).unwrap();
 /// let t = run.train().unwrap();
@@ -356,7 +356,7 @@ impl EditFeedback {
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
 /// # for n in ["c.cc", "i.cc", "e.cc", "o.cc"] { std::fs::write(p(n), [0x90]).unwrap(); }
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &["en-US".to_string()]).unwrap();
 /// let t = run.train().unwrap();
 /// let inv = run.inventory().inventory().unwrap();
@@ -369,7 +369,7 @@ impl EditFeedback {
 /// # let dir = tempfile::tempdir().unwrap();
 /// # let p = |n: &str| dir.path().join(n);
 /// # for n in ["c.cc", "i.cc", "e.cc", "o.cc"] { std::fs::write(p(n), [0x90]).unwrap(); }
-/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc") };
+/// # let paths = weksa::run::RunPaths { corpus: &p("c.cc"), inventory: &p("i.cc"), entities: &p("e.cc"), ontology: &p("o.cc"), speaker_state: &p("s.cc") };
 /// # let run = weksa::run::RunStores::create(&p("run"), "t", paths, "m", "e", weksa::run::LowererReach::ToolLessRelay, weksa::corpus::ModelFamily::Unrecorded, &["en-US".to_string()]).unwrap();
 /// let t = run.train().unwrap();
 /// let inv = run.inventory().inventory().unwrap();
@@ -528,9 +528,11 @@ impl Prompt {
     /// `input` (no kind, constraints, scene, speaker or group), the forms in
     /// `language` of every entity its referents cite, the `ontology:` section
     /// and the entries of `inventory` live at the view's revision. The section
-    /// holds the entries `ontology::select` chooses from the view's stance and
-    /// discourse features and `language`, never the caller; the view's speaker
-    /// and group are still never read. `item`
+    /// holds the entries `ontology::select` chooses from the view's stance,
+    /// discourse and the scene relation `with_scene` read, and `language`,
+    /// never the caller; the scene's values are never printed, only the entries
+    /// they select. A view whose scene was never read is refused
+    /// ([`LowerError::SceneUnread`]). `item`
     /// goes only to [`Prompt::item_keys`], never into the text. A speaker's
     /// entity id appears
     /// only when the encoder cites that entity on a referent, which is naming a
@@ -545,6 +547,9 @@ impl Prompt {
         entities: &dyn EntityForms,
         ontology: &Ontology,
     ) -> Result<Prompt, LowerError> {
+        if input.scene_read() == &SceneRead::Unread {
+            return Err(LowerError::SceneUnread);
+        }
         let mut forms: BTreeMap<&str, Vec<String>> = BTreeMap::new();
         for id in input.referents().iter().filter_map(|r| r.entity.as_ref()) {
             let found = entity(entities, id)?;
diff --git a/crates/weksa/src/inventory.rs b/crates/weksa/src/inventory.rs
index ec59b13..3ffd5ad 100644
--- a/crates/weksa/src/inventory.rs
+++ b/crates/weksa/src/inventory.rs
@@ -551,7 +551,7 @@ pub fn proof_revision() -> (InventoryRevision, Vec<InventoryEntry>) {
 /// arrive as community ids with cut `language-ontology`. Hand-seeded like
 /// [`proof_revision`] until the loop's minting round owns the vocabulary; the
 /// features take the ids after the seed's.
-pub fn speaker_scene_revision() -> (InventoryRevision, Vec<InventoryEntry>) {
+pub fn speaker_scene_revision(n: u32) -> (InventoryRevision, Vec<InventoryEntry>) {
     let taken = seed()
         .1
         .iter()
@@ -593,15 +593,15 @@ pub fn speaker_scene_revision() -> (InventoryRevision, Vec<InventoryEntry>) {
             gloss: gloss.to_string(),
             value_kind: Some(kind),
             applies_to: vec![slot],
-            introduced_rev: 3,
+            introduced_rev: n,
             retired_rev: None,
         });
     }
     let changes = entries.iter().map(|e| Change::Add(e.id)).collect();
     (
         InventoryRevision {
-            n: 3,
-            parent: Some(2),
+            n,
+            parent: Some(n - 1),
             changes,
             frozen: false,
         },
diff --git a/crates/weksa/src/lower.rs b/crates/weksa/src/lower.rs
index 76f3158..28f4ca2 100644
--- a/crates/weksa/src/lower.rs
+++ b/crates/weksa/src/lower.rs
@@ -182,6 +182,8 @@ pub enum LowerError {
     AskerNotAddressee { predication: NodeId },
     /// The entity port failed to read.
     EntityRead { entity: EntityId, why: String },
+    /// A lowering prompt was asked of a view whose scene was never read.
+    SceneUnread,
 }
 
 impl fmt::Display for LowerError {
@@ -203,6 +205,7 @@ impl fmt::Display for LowerError {
             LowerError::ConsentMissing { .. } => "request lacks the addressee's consent",
             LowerError::AskerNotAddressee { .. } => "request agent is not the addressee",
             LowerError::EntityRead { .. } => "entity port failed to read",
+            LowerError::SceneUnread => "the view's scene was never read",
         })
     }
 }
diff --git a/crates/weksa/src/main.rs b/crates/weksa/src/main.rs
index b9b094e..efae4ff 100644
--- a/crates/weksa/src/main.rs
+++ b/crates/weksa/src/main.rs
@@ -10,7 +10,8 @@ use unicode_normalization::UnicodeNormalization;
 use weksa::corpus::{CorpusItem, ModelFamily, NameSpan, Source, Turn};
 use weksa::encode::OntologyDraft;
 use weksa::entity::{Entity, EntityOrigin, LanguageForms, Pronunciation};
-use weksa::inventory::{proof_revision, seed};
+use weksa::inventory::{proof_revision, seed, speaker_scene_revision};
+use weksa::packet::{FeatValue, FeatureValue, Grade};
 use weksa::packet::proof_packet;
 use weksa::model::RecordedAnswers;
 use weksa::run::{
@@ -18,8 +19,8 @@ use weksa::run::{
 };
 use weksa::score::ScoreInput;
 use weksa::{
-    Annotator, AnswerFiles, CorpusStore, EntityId, EntityStore, InventoryStore, OllamaEmbedder, OntologyStore, PacketStore,
-    Scorer, Split, SplitScheme, StoreError, lower, pronounce, validate,
+    Annotator, AnswerFiles, CorpusStore, EntityId, EntityStore, Family, InventoryStore, OllamaEmbedder, OntologyStore, OptionLabel,
+    PacketStore, PairRelation, Party, Scene, Slot, SpeakerStateStore, ValueKind, Scorer, Split, SplitScheme, StoreError, lower, pronounce, validate,
 };
 
 #[derive(Parser)]
@@ -40,6 +41,9 @@ struct Cli {
     /// The language ontology store.
     #[arg(long, global = true, default_value = "data/ontology/ontology.cc")]
     ontology: PathBuf,
+    /// The speaker-state store (scenes).
+    #[arg(long, global = true, default_value = "data/corpus/speaker-state.cc")]
+    speaker_state: PathBuf,
     #[command(subcommand)]
     command: Command,
 }
@@ -57,6 +61,8 @@ enum Command {
     #[command(subcommand)]
     Ontology(OntologyCommand),
     #[command(subcommand)]
+    Scene(SceneCommand),
+    #[command(subcommand)]
     Packet(PacketCommand),
     /// Lower a stored packet to English text.
     Lower {
@@ -87,7 +93,7 @@ enum Command {
 
 #[derive(Subcommand)]
 enum LoopCommand {
-    /// Pin the global --corpus, --inventory, --entities and --ontology as a run at ROOT.
+    /// Pin the global --corpus, --inventory, --entities, --ontology and --speaker-state as a run at ROOT.
     Open {
         root: PathBuf,
         #[arg(long)]
@@ -191,6 +197,38 @@ enum InventoryCommand {
     Proof,
     /// Admit revision 3 of the Dao De Jing test bed stores (after seed and proof).
     Dao,
+    /// Admit the speaker-state revision (Scene and Speaker features) as the
+    /// inventory's latest plus one.
+    SpeakerScene,
+}
+
+#[derive(Subcommand)]
+enum SceneCommand {
+    /// Append a scene revision for one corpus group: its one live speaker's
+    /// relation to the addressee, as Scene-slot feature values.
+    Put {
+        #[arg(long)]
+        group: String,
+        /// `entity:<slug>` of a named addressee, or `unnamed`.
+        #[arg(long)]
+        to: String,
+        /// The inventory revision the glosses resolve at.
+        #[arg(long)]
+        inventory_rev: u32,
+        /// `gloss=value`, repeated: a grade 0-1000, an option label or true/false.
+        #[arg(long = "set", value_name = "GLOSS=VALUE")]
+        set: Vec<String>,
+        #[arg(long, requires = "generator", conflicts_with = "operator")]
+        model_family: Option<ModelFamilyArg>,
+        /// The attestation string naming the annotating model.
+        #[arg(long, requires = "model_family")]
+        generator: Option<String>,
+        /// Annotated by the operator, not a model.
+        #[arg(long)]
+        operator: bool,
+    },
+    /// Text projection of the scenes for review; not a store.
+    Dump,
 }
 
 #[derive(Subcommand)]
@@ -734,6 +772,143 @@ fn main() -> Result<()> {
                 .map_err(refused)?;
             println!("admitted rev:2 with {count} entries");
         }
+        Command::Inventory(InventoryCommand::SpeakerScene) => {
+            let store = InventoryStore::open(&cli.inventory)?;
+            let latest = store
+                .inventory()?
+                .latest()
+                .map(|r| r.n)
+                .context("the inventory holds no revision")?;
+            let (rev, entries) = speaker_scene_revision(latest + 1);
+            let (n, count) = (rev.n, entries.len());
+            let mut store = store;
+            store.admit_revision(rev, entries).map_err(refused)?;
+            println!("admitted rev:{n} with {count} entries");
+        }
+        Command::Scene(SceneCommand::Put {
+            group,
+            to,
+            inventory_rev,
+            set,
+            model_family,
+            generator,
+            operator,
+        }) => {
+            let annotator = match (model_family, generator, operator) {
+                (Some(family), Some(generator), false) => Annotator::Model {
+                    family: family.into(),
+                    generator,
+                },
+                (None, None, true) => Annotator::Operator,
+                _ => bail!("name the annotator: --model-family with --generator, or --operator"),
+            };
+            let inventory_store = InventoryStore::open(&cli.inventory)?;
+            let inventory = inventory_store.inventory()?;
+            let corpus = CorpusStore::open(&cli.corpus)?;
+            let live: Vec<CorpusItem> = corpus
+                .all()?
+                .into_iter()
+                .filter(|i| i.group == group && !i.withdrawn)
+                .collect();
+            let mut speakers: Vec<EntityId> = live.iter().map(|i| i.speaker.clone()).collect();
+            speakers.sort();
+            speakers.dedup();
+            let [from] = speakers.as_slice() else {
+                bail!("a scene group holds one live speaker; multi-party scenes wait");
+            };
+            let to = match to.as_str() {
+                "unnamed" => Party::Unnamed,
+                named => Party::Named(
+                    EntityId::parse(named).map_err(|_| anyhow::anyhow!("the addressee is unnamed or an entity id"))?,
+                ),
+            };
+            let mut features = Vec::new();
+            for pair in &set {
+                let bad = || anyhow::anyhow!("a --set is gloss=value of a live Scene feature");
+                let (gloss, value) = pair.split_once('=').ok_or_else(bad)?;
+                let entry = inventory
+                    .entries()
+                    .find(|e| {
+                        e.family() == Family::Feature
+                            && e.gloss == gloss
+                            && e.live_at(inventory_rev)
+                            && e.applies_to.contains(&Slot::Scene)
+                    })
+                    .ok_or_else(bad)?;
+                let value = match entry.value_kind.as_ref().ok_or_else(bad)? {
+                    ValueKind::Grade => FeatValue::Grade(
+                        Grade::new(value.parse().map_err(|_| bad())?).map_err(|_| bad())?,
+                    ),
+                    ValueKind::Options(_) => {
+                        FeatValue::Option(OptionLabel::parse(value).map_err(|_| bad())?)
+                    }
+                    ValueKind::Flag => FeatValue::Flag(value.parse().map_err(|_| bad())?),
+                };
+                features.push(FeatureValue { feature: entry.id.clone(), value });
+            }
+            let mut participants = vec![from.clone()];
+            if let Party::Named(a) = &to
+                && a != from
+            {
+                participants.push(a.clone());
+            }
+            let mut state = SpeakerStateStore::open(&cli.speaker_state)?;
+            let latest = state.scene(&group)?;
+            let mut scene = Scene {
+                group,
+                n: latest.as_ref().map_or(1, |l| l.n + 1),
+                inventory_rev,
+                participants,
+                relations: vec![PairRelation { from: from.clone(), to, features }],
+                annotator,
+            };
+            if let Some(l) = &latest {
+                let same = Scene { n: l.n, ..scene.clone() };
+                if &same == l {
+                    println!("unchanged");
+                    return Ok(());
+                }
+            }
+            scene.n = latest.map_or(1, |l| l.n + 1);
+            let key = weksa::speaker::scene_key(&scene.group, scene.n);
+            let outcome = state
+                .put_scene(scene, &inventory_store, &corpus, &EntityStore::open(&cli.entities)?)
+                .map_err(refused)?;
+            println!("{outcome:?} {key}");
+        }
+        Command::Scene(SceneCommand::Dump) => {
+            let inventory = InventoryStore::open(&cli.inventory)?.inventory()?;
+            let gloss = |f: &FeatureValue| {
+                let name = inventory.entry(&f.feature).map_or("?", |e| e.gloss.as_str());
+                match &f.value {
+                    FeatValue::Grade(g) => format!("{name}={}", g.get()),
+                    FeatValue::Option(l) => format!("{name}={l}"),
+                    FeatValue::Flag(b) => format!("{name}={b}"),
+                }
+            };
+            for s in SpeakerStateStore::open(&cli.speaker_state)?.all_scenes()? {
+                let who = match &s.annotator {
+                    Annotator::Operator => "Operator".to_string(),
+                    Annotator::Model { family, generator } => format!("Model {family:?} {generator}"),
+                };
+                let people: Vec<&str> = s.participants.iter().map(|p| p.as_str()).collect();
+                println!(
+                    "scene:{}@{} rev:{} {who} [{}]",
+                    s.group,
+                    s.n,
+                    s.inventory_rev,
+                    people.join(",")
+                );
+                for r in &s.relations {
+                    let to = match &r.to {
+                        Party::Named(e) => e.as_str().to_string(),
+                        Party::Unnamed => "unnamed".to_string(),
+                    };
+                    let feats: Vec<String> = r.features.iter().map(&gloss).collect();
+                    println!("  {}->{to} {}", r.from, feats.join(" "));
+                }
+            }
+        }
         Command::Inventory(InventoryCommand::Dao) => {
             let (rev, entries) = weksa::daodejing::revision();
             let count = entries.len();
@@ -850,6 +1025,7 @@ fn main() -> Result<()> {
                     inventory: &cli.inventory,
                     entities: &cli.entities,
                     ontology: &cli.ontology,
+                    speaker_state: &cli.speaker_state,
                 },
                 &answerer,
                 &embed_model,
diff --git a/crates/weksa/src/ontology.rs b/crates/weksa/src/ontology.rs
index 30bc5dd..b1cc384 100644
--- a/crates/weksa/src/ontology.rs
+++ b/crates/weksa/src/ontology.rs
@@ -1,7 +1,7 @@
 //! The language ontology: per target language, the choices its culture makes
 //! about word, grammar, discourse, sound and script for a speaker in a stance
 //! (ruling `persona-drives-ontology`). An entry says when it applies (feature
-//! conditions over the lowering view's stance and discourse) and what it
+//! conditions over the lowering view's stance, discourse and scene relation) and what it
 //! chooses. `select` is the only reader that decides which entries a lowering
 //! prompt carries, and it runs only inside `Prompt::lower`;
 //! `OntologyStore::admit` is the only writer. Entries are immutable.
@@ -51,8 +51,8 @@ pub enum Test {
     Is(FeatValue),
 }
 
-/// One feature of one slot of the view, tested. Only `Stance` and `Discourse`
-/// reach a lowering view today.
+/// One feature of one slot of the view, tested. `Stance`, `Discourse` and
+/// `Scene` reach a lowering view; `Speaker` does not yet.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub struct Condition {
     pub slot: Slot,
@@ -149,8 +149,9 @@ impl Ontology {
 }
 
 /// The entries of exactly `language` whose every condition holds against the
-/// view's stance and discourse features, in `n` order. An absent feature meets
-/// no condition. Nothing else of the view is read.
+/// view's stance, discourse and scene-relation features (the scene's only when
+/// `with_scene` selected a relation), in `n` order. An absent feature meets no
+/// condition. Nothing else of the view is read.
 pub fn select<'a>(
     o: &'a Ontology,
     language: &str,
@@ -163,6 +164,7 @@ pub fn select<'a>(
             e.when.iter().all(|c| match c.slot {
                 Slot::Stance => c.holds(&input.stance().features),
                 Slot::Discourse => c.holds(&input.discourse().features),
+                Slot::Scene => c.holds(input.scene()),
                 _ => false,
             })
         })
diff --git a/crates/weksa/src/run.rs b/crates/weksa/src/run.rs
index 770d9b1..6d598d9 100644
--- a/crates/weksa/src/run.rs
+++ b/crates/weksa/src/run.rs
@@ -48,10 +48,12 @@ use crate::packet::{Packet, Stance};
 use crate::score::{CHRF_VERSION, chrf, Embedder, ItemScore, ScoreInput, Scorer, SplitMean, aggregate};
 use crate::split::{Split, SplitScheme, fnv1a64, fnv1a64_of, hex16};
 use crate::store::{
-    CorpusStore, EntityStore, InventoryStore, OntologyStore, PacketStore, StoreError,
+    CorpusStore, EntityStore, InventoryStore, OntologyStore, PacketStore, SpeakerStateStore,
+    StoreError,
     check_ontology_entry, open_cache_over,
 };
-use crate::validate::LoweringInput;
+use crate::inventory::Slot;
+use crate::validate::{LoweringInput, feature_refusals};
 
 /// The digest of the prompt builder's source: `context.rs`, then `split.rs`,
 /// whose scheme and digest function decide which lines the prompt holds as
@@ -137,6 +139,13 @@ pub struct RunRecord {
     /// 16 hex of the ontology file's bytes.
     #[cultcache(key = 16)]
     pub ontology_digest: String,
+    /// Canonical absolute path of the speaker-state store (scenes): read-only
+    /// for the run, pinned by `speaker_state_digest`.
+    #[cultcache(key = 17)]
+    pub speaker_state: String,
+    /// 16 hex of the speaker-state file's bytes.
+    #[cultcache(key = 18)]
+    pub speaker_state_digest: String,
 }
 
 /// How a run's lowering prompts reach the model that answers them (rulings
@@ -442,6 +451,7 @@ pub enum DriftOf {
     Corpus,
     Entities,
     Ontology,
+    SpeakerState,
     Prompts,
     Model,
     Embedder,
@@ -480,6 +490,8 @@ pub enum RunError {
     /// An ontology entry of a panel language does not read against the run's
     /// head inventory at its revision.
     Ontology,
+    /// A scene does not read against the run's inventory.
+    SpeakerState,
 }
 
 impl fmt::Display for RunError {
@@ -504,6 +516,9 @@ impl fmt::Display for RunError {
             RunError::Ontology => f.write_str(
                 "an ontology entry of a panel language does not read against the run's inventory",
             ),
+            RunError::SpeakerState => {
+                f.write_str("a scene does not read against the run's inventory")
+            }
             RunError::Panel => f.write_str(
                 "the panel is empty, repeats or misspells a language, or names one with no live Train or Validation item",
             ),
@@ -519,13 +534,14 @@ impl fmt::Debug for RunError {
 
 impl std::error::Error for RunError {}
 
-/// The four stores a run pins.
+/// The five stores a run pins.
 #[derive(Clone, Copy)]
 pub struct RunPaths<'a> {
     pub corpus: &'a Path,
     pub inventory: &'a Path,
     pub entities: &'a Path,
     pub ontology: &'a Path,
+    pub speaker_state: &'a Path,
 }
 
 /// A run's open stores, reopened only from its record. The one public producer
@@ -538,6 +554,7 @@ pub struct RunStores {
     inventory: InventoryStore,
     entities: EntityStore,
     ontology: OntologyStore,
+    speaker_state: SpeakerStateStore,
 }
 
 /// The run's own copy of the inventory, made at `create`.
@@ -554,6 +571,9 @@ fn check_pins(cache: &CultCache, root: &Path, record: &RunRecord) -> Result<(),
     if file_digest(&record.ontology).as_ref() != Some(&record.ontology_digest) {
         return Err(RunError::Drift(DriftOf::Ontology));
     }
+    if file_digest(&record.speaker_state).as_ref() != Some(&record.speaker_state_digest) {
+        return Err(RunError::Drift(DriftOf::SpeakerState));
+    }
     let (path, digest, _) = head_of(cache, root, record)?;
     if file_digest_at(&path).as_ref() != Some(&digest) {
         return Err(RunError::Drift(DriftOf::Inventory));
@@ -692,6 +712,8 @@ impl RunStores {
             entities: canonical(paths.entities)?,
             ontology: canonical(paths.ontology)?,
             ontology_digest: String::new(),
+            speaker_state: canonical(paths.speaker_state)?,
+            speaker_state_digest: String::new(),
             corpus_digest: String::new(),
             entity_digest: String::new(),
             prompt_digest: hex16(PROMPT_SOURCE_DIGEST),
@@ -714,12 +736,14 @@ impl RunStores {
                 entity_digest: file_digest(&record.entities).ok_or(RunError::Store)?,
                 inventory_digest: file_digest_at(&head).ok_or(RunError::Store)?,
                 ontology_digest: file_digest(&record.ontology).ok_or(RunError::Store)?,
+                speaker_state_digest: file_digest(&record.speaker_state).ok_or(RunError::Store)?,
                 ..record
             };
             between();
             let mut run = Self::with(root, cache, record)?;
             run.check_panel()?;
             run.check_ontology()?;
+            run.check_scenes()?;
             // The stores were read between the digests: unless they still match
             // the pins, what was opened is not what was pinned. Nothing is
             // recorded for a run that did not pin.
@@ -771,6 +795,8 @@ impl RunStores {
             inventory: InventoryStore::open(&head).map_err(store)?,
             entities: EntityStore::open(Path::new(&record.entities)).map_err(store)?,
             ontology: OntologyStore::open(Path::new(&record.ontology)).map_err(store)?,
+            speaker_state: SpeakerStateStore::open(Path::new(&record.speaker_state))
+                .map_err(store)?,
             cache,
             record,
         })
@@ -803,6 +829,40 @@ impl RunStores {
             })
     }
 
+    /// Every scene's relation features read against the run's inventory at the
+    /// scene's own revision, and again at the head: the checks `put_scene`
+    /// applied, applied again to this inventory.
+    fn check_scenes(&self) -> Result<(), RunError> {
+        let inventory = self.inventory.inventory().map_err(|_| RunError::Store)?;
+        let scenes = self.speaker_state.all_scenes().map_err(|_| RunError::Store)?;
+        for scene in &scenes {
+            let head = inventory.latest().map(|r| r.n).ok_or(RunError::SpeakerState)?;
+            for r in &scene.relations {
+                for rev in [scene.inventory_rev, head] {
+                    if !feature_refusals(&inventory, rev, &r.features, Slot::Scene).is_empty() {
+                        return Err(RunError::SpeakerState);
+                    }
+                }
+            }
+            if scene.relations.is_empty()
+                && !(inventory.has_revision(scene.inventory_rev) && inventory.has_revision(head))
+            {
+                return Err(RunError::SpeakerState);
+            }
+        }
+        Ok(())
+    }
+
+    /// The one door by which a loop view gets its scene: `with_scene` over the
+    /// run's pinned speaker-state and corpus stores.
+    fn assembled(
+        &self,
+        view: LoweringInput,
+        inventory: &InventoryStore,
+    ) -> Result<LoweringInput, StoreError> {
+        view.with_scene(&inventory.inventory()?, &self.speaker_state, &self.corpus)
+    }
+
     /// Every panel language holds a live Train and a live Validation item.
     fn check_panel(&self) -> Result<(), RunError> {
         let items = self.corpus.all().map_err(|_| RunError::Store)?;
@@ -1300,6 +1360,9 @@ impl RunStores {
                     let view = stores[slot]
                         .admit(packet, &self.inventory, &self.corpus, &self.entities)
                         .map_err(|_| RunError::Store)?;
+                    let view = self
+                        .assembled(view, &self.inventory)
+                        .map_err(|_| RunError::Store)?;
                     Prompt::lower(
                         &view,
                         &packet_item,
@@ -1586,19 +1649,23 @@ fn score_round<M: ModelPort, E: Embedder>(
     // Phase 2: one lowering prompt per admitted view, answered through the
     // port. Nothing is kept unless every one is answered.
     let mut unanswered = Vec::new();
-    for (at, id, packet_key, view) in &admitted {
+    for (at, id, packet_key, view) in admitted {
         // Each item is lowered in its own language: the only reference the
         // scorer has is the item's own text.
-        let language = &items[*at].language;
-        let Ok(prompt) = Prompt::lower(view, id, language, &inventory, &run.entities, &ontology) else {
-            fates[*at] = Fate::Refused(Stage::Lower, Some(packet_key.clone()));
+        let language = &items[at].language;
+        let Ok(view) = run.assembled(view, inventory_store) else {
+            fates[at] = Fate::Refused(Stage::Lower, Some(packet_key.clone()));
+            continue;
+        };
+        let Ok(prompt) = Prompt::lower(&view, &id, language, &inventory, &run.entities, &ontology) else {
+            fates[at] = Fate::Refused(Stage::Lower, Some(packet_key.clone()));
             continue;
         };
         calls.push(Call {
             prompt: prompt.digest(),
             items: prompt.item_keys().to_vec(),
         });
-        fates[*at] = match model.answer(&prompt) {
+        fates[at] = match model.answer(&prompt) {
             Ok(answer) => match LoweringDraft::parse(&answer) {
                 Ok(draft) if draft.usable() => {
                     Fate::Lowered(draft.text, packet_key.clone())
@@ -2793,6 +2860,8 @@ mod tests {
             panel: vec!["en-US".into()],
             ontology: String::new(),
             ontology_digest: String::new(),
+            speaker_state: String::new(),
+            speaker_state_digest: String::new(),
         }
     }
 
@@ -2985,6 +3054,8 @@ mod tests {
             );
             let ontology = dir.path().join("o.cc");
             fs::write(&ontology, [0x90]).unwrap();
+            let speaker_state = dir.path().join("s.cc");
+            fs::write(&speaker_state, [0x90]).unwrap();
             let root = dir.path().join("run");
             let mut run = RunStores::create(
                 &root,
@@ -2994,6 +3065,7 @@ mod tests {
                     inventory: &inventory,
                     entities: &entities,
                     ontology: &ontology,
+                    speaker_state: &speaker_state,
                 },
                 "fake-model",
                 "bag",
diff --git a/crates/weksa/src/store.rs b/crates/weksa/src/store.rs
index 5afb025..cff3086 100644
--- a/crates/weksa/src/store.rs
+++ b/crates/weksa/src/store.rs
@@ -1320,8 +1320,11 @@ pub(crate) fn check_ontology_entry(
     }
     let mut out = Vec::new();
     for c in &e.when {
-        if !matches!(c.slot, Slot::Stance | Slot::Discourse) {
-            return Err(malformed(&key, "a condition reads slot Stance or Discourse"));
+        if !matches!(c.slot, Slot::Stance | Slot::Discourse | Slot::Scene) {
+            return Err(malformed(
+                &key,
+                "a condition reads slot Stance, Discourse or Scene",
+            ));
         }
         if matches!(c.test, Test::Is(FeatValue::Grade(_))) {
             return Err(malformed(&key, "Is names an option or a flag"));
diff --git a/crates/weksa/tests/cli.rs b/crates/weksa/tests/cli.rs
index d46db9f..e90297b 100644
--- a/crates/weksa/tests/cli.rs
+++ b/crates/weksa/tests/cli.rs
@@ -14,6 +14,8 @@ fn weksa(dir: &std::path::Path, args: &[&str]) -> Output {
             "./e.cc",
             "--ontology",
             "./o.cc",
+            "--speaker-state",
+            "./s.cc",
         ])
         .args(args)
         .output()
@@ -1341,6 +1343,7 @@ fn dao_stores(dir: &std::path::Path) {
         std::fs::copy(src.join(from), dir.join(to)).unwrap();
     }
     std::fs::write(dir.join("o.cc"), [0x90]).unwrap();
+    std::fs::write(dir.join("s.cc"), [0x90]).unwrap();
 }
 
 #[test]
diff --git a/crates/weksa/tests/common/mod.rs b/crates/weksa/tests/common/mod.rs
index 8350428..723a371 100644
--- a/crates/weksa/tests/common/mod.rs
+++ b/crates/weksa/tests/common/mod.rs
@@ -123,6 +123,20 @@ pub fn ontology_in(dir: &std::path::Path) -> std::path::PathBuf {
     path
 }
 
+/// An empty speaker-state store beside `ontology` (same directory), made if absent.
+pub fn speaker_state_beside(ontology: &std::path::Path) -> std::path::PathBuf {
+    let path = ontology.with_file_name("speaker-state.cc");
+    if !path.exists() {
+        std::fs::write(&path, [0x90]).unwrap();
+    }
+    path
+}
+
+/// An empty speaker-state store at `<dir>/speaker-state.cc`, made if absent.
+pub fn speaker_state_in(dir: &std::path::Path) -> std::path::PathBuf {
+    speaker_state_beside(&dir.join("ontology.cc"))
+}
+
 /// A run over the stores `world()` and `corpus()` keep in `dir`: `c.cc`,
 /// `i.cc` and `entities.cc`. Read at the call, so create it after the items.
 /// The run's en-US panel needs a live Train and a live Validation item: a
@@ -158,6 +172,7 @@ pub fn run_over(dir: &std::path::Path) -> weksa::run::RunStores {
             inventory: &dir.join("i.cc"),
             entities: &dir.join("entities.cc"),
             ontology: &dir.join("ontology.cc"),
+            speaker_state: &speaker_state_beside(&dir.join("ontology.cc")),
         },
         "fake-model",
         "bag",
diff --git a/crates/weksa/tests/context.rs b/crates/weksa/tests/context.rs
index 5d44f01..82cf5b9 100644
--- a/crates/weksa/tests/context.rs
+++ b/crates/weksa/tests/context.rs
@@ -547,7 +547,8 @@ mod lowering {
         Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data").join(sub)
     }
 
-    fn admitted(
+    /// The admitted view, its scene never read.
+    fn admitted_unread(
         packet: Packet,
         inv: &InventoryStore,
         corpus: &str,
@@ -561,6 +562,37 @@ mod lowering {
             .unwrap()
     }
 
+    /// The admitted view with its scene read over an empty speaker-state store.
+    fn admitted(
+        packet: Packet,
+        inv: &InventoryStore,
+        corpus: &str,
+        entities: &EntityStore,
+    ) -> LoweringInput {
+        let view = admitted_unread(packet, inv, corpus, entities);
+        let dir = tempfile::tempdir().unwrap();
+        let state = weksa::SpeakerStateStore::open(&dir.path().join("s.cc")).unwrap();
+        let corpus = CorpusStore::open(&data(corpus)).unwrap();
+        view.with_scene(&inv.inventory().unwrap(), &state, &corpus).unwrap()
+    }
+
+    #[test]
+    fn lowering_prompt_refuses_an_unread_scene() {
+        let cast = InventoryStore::open(&data("interlingua/inventory.cc")).unwrap();
+        let entities = EntityStore::open(&data("entity/entity.cc")).unwrap();
+        let inv = cast.inventory().unwrap();
+        let item = CorpusItemId::parse("item:nibu:1").unwrap();
+        let held = Held(vec![nibu(&[("en-US", &["Nibu"])])]);
+        let unread = admitted_unread(proof_packet(), &cast, "corpus/corpus.cc", &entities);
+        let empty = weksa::Ontology::empty();
+        assert_eq!(
+            Prompt::lower(&unread, &item, "en-US", &inv, &held, &empty).err(),
+            Some(LowerError::SceneUnread)
+        );
+        let read = admitted(proof_packet(), &cast, "corpus/corpus.cc", &entities);
+        assert!(Prompt::lower(&read, &item, "en-US", &inv, &held, &empty).is_ok());
+    }
+
     fn dao(index: usize) -> (LoweringInput, Inventory, EntityStore, CorpusItemId) {
         let inv = InventoryStore::open(&data("daodejing/inventory.cc")).unwrap();
         let entities = EntityStore::open(&data("daodejing/entity.cc")).unwrap();
diff --git a/crates/weksa/tests/golf_loop.rs b/crates/weksa/tests/golf_loop.rs
index 0b22f4c..3c36f33 100644
--- a/crates/weksa/tests/golf_loop.rs
+++ b/crates/weksa/tests/golf_loop.rs
@@ -24,12 +24,13 @@ fn rewrite_run(root: &Path, change: impl FnOnce(&mut RunRecord)) {
     cache.put(format!("run:{}", record.label), &record).unwrap();
 }
 
-fn paths(dir: &Path) -> (PathBuf, PathBuf, PathBuf, PathBuf) {
+fn paths(dir: &Path) -> (PathBuf, PathBuf, PathBuf, PathBuf, PathBuf) {
     (
         dir.join("c.cc"),
         dir.join("i.cc"),
         dir.join("entities.cc"),
         common::ontology_in(dir),
+        common::speaker_state_in(dir),
     )
 }
 
@@ -42,7 +43,7 @@ fn a_run_pins_its_stores_and_refuses_drift() {
     let mut w = world();
     let dir = w.dir.path().to_path_buf();
     let root = dir.join("run");
-    let (c, i, e, o) = paths(&dir);
+    let (c, i, e, o, s) = paths(&dir);
     let at = |label: &str, model: &str| {
         RunStores::create(
             &root,
@@ -52,6 +53,7 @@ fn a_run_pins_its_stores_and_refuses_drift() {
                 inventory: &i,
                 entities: &e,
                 ontology: &o,
+                speaker_state: &s,
             },
             model,
             "bag",
@@ -147,7 +149,7 @@ fn a_run_works_on_its_own_copy_of_the_inventory() {
     let w = world();
     let dir = w.dir.path().to_path_buf();
     let root = dir.join("run");
-    let (c, i, e, o) = paths(&dir);
+    let (c, i, e, o, s) = paths(&dir);
     let source_bytes = std::fs::read(&i).unwrap();
     let mut run = RunStores::create(
         &root,
@@ -157,6 +159,7 @@ fn a_run_works_on_its_own_copy_of_the_inventory() {
             inventory: &i,
             entities: &e,
             ontology: &o,
+            speaker_state: &s,
         },
         "fake-model",
         "bag",
@@ -236,6 +239,7 @@ fn create_refuses_a_root_that_holds_an_inventory_and_never_truncates_it() {
                 inventory,
                 entities: &dao.entities,
                 ontology: &dao.ontology,
+                speaker_state: &common::speaker_state_beside(&dao.ontology),
             },
             "fake-model",
             "bag",
@@ -285,6 +289,7 @@ fn a_create_that_fails_leaves_no_inventory_and_the_retry_succeeds() {
                 inventory,
                 entities,
                 ontology: &dao.ontology,
+                speaker_state: &common::speaker_state_beside(&dao.ontology),
             },
             "fake-model",
             "bag",
@@ -398,11 +403,13 @@ fn a_store_changed_between_its_digest_and_its_open_is_drift() {
     }
     let (c, i, e) = (dir.join("c.cc"), dir.join("i.cc"), dir.join("entities.cc"));
     let o = dir.join("ontology.cc");
+    let s = common::speaker_state_beside(&o);
     let paths = || weksa::run::RunPaths {
         corpus: &c,
         inventory: &i,
         entities: &e,
         ontology: &o,
+        speaker_state: &s,
     };
     assert_eq!(
         RunStores::create_between(
@@ -457,6 +464,7 @@ fn window(
         inventory: &i,
         entities: &e,
         ontology: &o,
+        speaker_state: &common::speaker_state_beside(&o),
     };
     let created = RunStores::create_between(
         &root,
@@ -905,6 +913,7 @@ fn dao_build(
             inventory: &inventory,
             entities: &entities,
             ontology: &ontology,
+            speaker_state: &common::speaker_state_beside(&ontology),
         },
         "fake-model",
         "bag",
@@ -1087,6 +1096,8 @@ fn lowering_prompts(dao: &Dao, inventory: &InventoryStore) -> Vec<(String, Promp
             let view = store
                 .admit(packet, inventory, &corpus, dao.run.entities())
                 .unwrap();
+            let state = weksa::SpeakerStateStore::open(&dir.path().join("s.cc")).unwrap();
+            let view = view.with_scene(&inv, &state, &corpus).unwrap();
             let prompt = Prompt::lower(&view, &key, "en-US", &inv, dao.run.entities(), &weksa::Ontology::empty()).unwrap();
             (key.to_string(), prompt)
         })
@@ -1560,6 +1571,7 @@ fn errors_echo_no_input() {
         inventory: &missing,
         entities: &missing,
         ontology: &missing,
+        speaker_state: &common::speaker_state_beside(&missing),
     };
     let e = RunStores::create(
         &root,
@@ -1629,6 +1641,7 @@ fn errors_echo_no_input() {
             inventory: &dao.inventory,
             entities: &dao.entities,
             ontology: &dao.ontology,
+            speaker_state: &common::speaker_state_beside(&dao.ontology),
         },
         "fake-model",
         "bag",
@@ -2551,6 +2564,7 @@ fn a_changed_head_is_drift() {
             inventory: &dao.inventory,
             entities: &dao.entities,
             ontology: &dao.ontology,
+            speaker_state: &common::speaker_state_beside(&dao.ontology),
         },
         "fake-model",
         "bag",
@@ -2891,6 +2905,7 @@ fn a_summary_line_says_how_lowerings_were_answered() {
         inventory: &dao.inventory,
         entities: &dao.entities,
         ontology: &dao.ontology,
+        speaker_state: &common::speaker_state_beside(&dao.ontology),
     };
     RunStores::create(
         &root,
@@ -3615,6 +3630,7 @@ fn mixed_family_round(family: ModelFamily) -> u32 {
             inventory: &dir.join("i.cc"),
             entities: &dir.join("entities.cc"),
             ontology: &dir.join("ontology.cc"),
+            speaker_state: &common::speaker_state_beside(&dir.join("ontology.cc")),
         },
         "not-a-draft",
         "bag",
@@ -4402,7 +4418,7 @@ fn open_refuses_a_bad_panel() {
         let created = RunStores::create(
             &root,
             "p",
-            RunPaths { corpus, inventory, entities, ontology: &dao.ontology },
+            RunPaths { corpus, inventory, entities, ontology: &dao.ontology, speaker_state: &common::speaker_state_beside(&dao.ontology) },
             "fake-model",
             "bag",
             weksa::run::LowererReach::ToolLessRelay,
@@ -4762,6 +4778,7 @@ fn create_refuses_an_entry_its_inventory_cannot_read() {
                 inventory: &dir.join("i.cc"),
                 entities: &dir.join("e.cc"),
                 ontology,
+                speaker_state: &common::speaker_state_beside(&ontology),
             },
             "fake-model",
             "bag",
diff --git a/crates/weksa/tests/original_corpus.rs b/crates/weksa/tests/original_corpus.rs
index 2a48196..8b06da7 100644
--- a/crates/weksa/tests/original_corpus.rs
+++ b/crates/weksa/tests/original_corpus.rs
@@ -307,6 +307,7 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
                 inventory: &i,
                 entities: &e,
                 ontology: &onto,
+                speaker_state: &common::speaker_state_beside(&onto),
             },
             "m",
             "bag",
@@ -351,6 +352,7 @@ fn the_recall_probe_covers_every_live_original_item_and_names_no_work() {
             inventory: &i,
             entities: &e,
             ontology: &o,
+            speaker_state: &common::speaker_state_beside(&o),
         },
         "m",
         "bag",
@@ -429,6 +431,7 @@ fn original_round(family: ModelFamily) -> (weksa::run::RunStores, weksa::run::Ro
             inventory: &tmp.join("inventory.cc"),
             entities: &tmp.join("entity.cc"),
             ontology: &tmp.join("ontology.cc"),
+            speaker_state: &common::speaker_state_beside(&tmp.join("ontology.cc")),
         },
         "nope",
         "bag",
@@ -588,6 +591,7 @@ fn no_test_item_is_offered_to_a_round_or_recall_or_recorded() {
             inventory: &p("inventory.cc"),
             entities: &p("entity.cc"),
             ontology: &p("ontology.cc"),
+            speaker_state: &common::speaker_state_beside(&p("ontology.cc")),
         },
         "nope",
         "bag",
diff --git a/crates/weksa/tests/scene.rs b/crates/weksa/tests/scene.rs
index a85b2e0..66f3cb7 100644
--- a/crates/weksa/tests/scene.rs
+++ b/crates/weksa/tests/scene.rs
@@ -27,7 +27,7 @@ struct W {
 fn world() -> W {
     let dir = tempfile::tempdir().unwrap();
     let mut inventory = InventoryStore::open(&dir.path().join("i.cc")).unwrap();
-    for (rev, entries) in [seed(), proof_revision(), speaker_scene_revision()] {
+    for (rev, entries) in [seed(), proof_revision(), speaker_scene_revision(3)] {
         inventory.admit_revision(rev, entries).unwrap();
     }
     let entities = entities_in(dir.path());
@@ -60,7 +60,7 @@ fn feat(gloss: &str, value: FeatValue) -> FeatureValue {
     let feature = seed()
         .1
         .into_iter()
-        .chain(speaker_scene_revision().1)
+        .chain(speaker_scene_revision(3).1)
         .find(|e| e.gloss == gloss)
         .unwrap_or_else(|| panic!("no feature {gloss}"))
         .id;
diff --git a/crates/weksa/tests/speaker_state.rs b/crates/weksa/tests/speaker_state.rs
index dfb4c59..d79b9dd 100644
--- a/crates/weksa/tests/speaker_state.rs
+++ b/crates/weksa/tests/speaker_state.rs
@@ -26,7 +26,7 @@ struct W {
 fn world() -> W {
     let dir = tempfile::tempdir().unwrap();
     let mut inventory = InventoryStore::open(&dir.path().join("i.cc")).unwrap();
-    for (rev, entries) in [seed(), proof_revision(), speaker_scene_revision()] {
+    for (rev, entries) in [seed(), proof_revision(), speaker_scene_revision(3)] {
         inventory.admit_revision(rev, entries).unwrap();
     }
     let entities = entities_in(dir.path());
@@ -60,7 +60,7 @@ fn feat(gloss: &str, value: FeatValue) -> FeatureValue {
     let feature = seed()
         .1
         .into_iter()
-        .chain(speaker_scene_revision().1)
+        .chain(speaker_scene_revision(3).1)
         .find(|e| e.gloss == gloss)
         .unwrap_or_else(|| panic!("no feature {gloss}"))
         .id;
diff --git a/schemas/cultnet/weksa.loop_run.schema.json b/schemas/cultnet/weksa.loop_run.schema.json
index e5b144b..346f41c 100644
--- a/schemas/cultnet/weksa.loop_run.schema.json
+++ b/schemas/cultnet/weksa.loop_run.schema.json
@@ -66,6 +66,14 @@
     },
     "prompt_digest": {
       "type": "string"
+    },
+    "speaker_state": {
+      "description": "Canonical absolute path of the speaker-state store (scenes): read-only\nfor the run, pinned by `speaker_state_digest`.",
+      "type": "string"
+    },
+    "speaker_state_digest": {
+      "description": "16 hex of the speaker-state file's bytes.",
+      "type": "string"
     }
   },
   "required": [
@@ -83,7 +91,9 @@
     "lowerer_reach",
     "panel",
     "ontology",
-    "ontology_digest"
+    "ontology_digest",
+    "speaker_state",
+    "speaker_state_digest"
   ],
   "$defs": {
     "LowererReach": {
diff --git a/schemas/cultnet/weksa.ontology_entry.schema.json b/schemas/cultnet/weksa.ontology_entry.schema.json
index 080275b..4483fa7 100644
--- a/schemas/cultnet/weksa.ontology_entry.schema.json
+++ b/schemas/cultnet/weksa.ontology_entry.schema.json
@@ -89,7 +89,7 @@
       ]
     },
     "Condition": {
-      "description": "One feature of one slot of the view, tested. Only `Stance` and `Discourse`\nreach a lowering view today.",
+      "description": "One feature of one slot of the view, tested. `Stance`, `Discourse` and\n`Scene` reach a lowering view; `Speaker` does not yet.",
       "type": "object",
       "properties": {
         "feature": {
-- 
2.47.3


From 966a3678a70df3ff410fd371216c47585f5d781d Mon Sep 17 00:00:00 2001
From: Weksa <weksa@minds.weksa.gamecult.org>
Date: Thu, 12 Nov 2026 16:31:55 +0000
Subject: [PATCH 2/5] language-ontology-scene s3-6: inventory rev 4 in both
 beds, empty speaker-state stores committed, scene tests, original corpus
 checks, lowering map

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/weksa/src/main.rs                 |   2 +-
 crates/weksa/src/run.rs                  |   4 +-
 crates/weksa/tests/cli.rs                |  65 ++++++-
 crates/weksa/tests/common/mod.rs         |  15 ++
 crates/weksa/tests/golf_loop.rs          | 217 ++++++++++++++++++++++-
 crates/weksa/tests/original_corpus.rs    |  38 +++-
 crates/weksa/tests/scene.rs              |  57 ++++++
 crates/weksa/tests/stores.rs             |  41 ++++-
 data/corpus/speaker-state.cc             |   1 +
 data/daodejing/inventory.cc              | Bin 10559 -> 11369 bytes
 data/daodejing/speaker-state.cc          |   1 +
 data/original/inventory.cc               | Bin 10559 -> 11369 bytes
 data/original/speaker-state.cc           |   1 +
 docs/targets/interlingua-lowering-map.md |   8 +-
 14 files changed, 429 insertions(+), 21 deletions(-)
 create mode 100644 data/corpus/speaker-state.cc
 create mode 100644 data/daodejing/speaker-state.cc
 create mode 100644 data/original/speaker-state.cc

diff --git a/crates/weksa/src/main.rs b/crates/weksa/src/main.rs
index efae4ff..c4d7be6 100644
--- a/crates/weksa/src/main.rs
+++ b/crates/weksa/src/main.rs
@@ -844,7 +844,7 @@ fn main() -> Result<()> {
                     }
                     ValueKind::Flag => FeatValue::Flag(value.parse().map_err(|_| bad())?),
                 };
-                features.push(FeatureValue { feature: entry.id.clone(), value });
+                features.push(FeatureValue { feature: entry.id, value });
             }
             let mut participants = vec![from.clone()];
             if let Party::Named(a) = &to
diff --git a/crates/weksa/src/run.rs b/crates/weksa/src/run.rs
index 6d598d9..8b49f8e 100644
--- a/crates/weksa/src/run.rs
+++ b/crates/weksa/src/run.rs
@@ -2953,7 +2953,7 @@ mod tests {
     }
 
     /// Answers the Dao encode prompts from `answers` by item, the candidate
-    /// inventory's (rev 4) from the good drafts, and the editor with one concept.
+    /// inventory's (rev 5) from the good drafts, and the editor with one concept.
     struct Fake {
         degraded: HashMap<String, String>,
         good: HashMap<String, String>,
@@ -2980,7 +2980,7 @@ mod tests {
                 };
                 return Ok(format!(r#"{{"text":"{text}"}}"#));
             }
-            let answers = if prompt.text().contains("\n\ninventory rev:4\n") {
+            let answers = if prompt.text().contains("\n\ninventory rev:5\n") {
                 &self.good
             } else {
                 &self.degraded
diff --git a/crates/weksa/tests/cli.rs b/crates/weksa/tests/cli.rs
index e90297b..65563ea 100644
--- a/crates/weksa/tests/cli.rs
+++ b/crates/weksa/tests/cli.rs
@@ -1416,7 +1416,7 @@ fn loop_open_and_unanswered_round() {
     assert!(second.status.success(), "{}", out(&second));
     assert_eq!(
         out(&second),
-        "round 1 rev 3 en-US train n=1 scored=0 chrf=0.00 meaning=0.0000 refused=1 validation n=2 scored=0 chrf=0.00 meaning=0.0000 refused parse=2 admit=0 lower=0 parse-reasons=syntaxx3 lowering=tool-less-relay\n"
+        "round 1 rev 4 en-US train n=1 scored=0 chrf=0.00 meaning=0.0000 refused=1 validation n=2 scored=0 chrf=0.00 meaning=0.0000 refused parse=2 admit=0 lower=0 parse-reasons=syntaxx3 lowering=tool-less-relay\n"
     );
 
     // The global store flags are not read by loop round: a drifted store is refused.
@@ -1549,7 +1549,7 @@ fn loop_cycle_asks_then_decides() {
     assert!(done.status.success(), "{}", out(&done));
     assert_eq!(
         out(&done),
-        "cycle 1 rev 3->none en-US base=0.0000 candidate=none floor=0.0000 threshold=0.0050 rejected edit-parse lowering=tool-less-relay\n"
+        "cycle 1 rev 4->none en-US base=0.0000 candidate=none floor=0.0000 threshold=0.0050 rejected edit-parse lowering=tool-less-relay\n"
     );
 
     // The next cycle asks afresh in its own directory.
@@ -1814,3 +1814,64 @@ fn ontology_admit_and_dump() {
     assert!(!out(&o).contains("LEAKYCHOICE"), "{}", out(&o));
     assert_eq!(out(&weksa(d.path(), &["ontology", "dump"])), before);
 }
+
+#[test]
+fn scene_put_and_dump() {
+    let d = tempfile::tempdir().unwrap();
+    cast_entities(d.path(), &["nibu", "brokkr"]);
+    for step in ["seed", "proof", "speaker-scene"] {
+        let o = weksa(d.path(), &["inventory", step]);
+        assert!(o.status.success(), "{}", out(&o));
+    }
+    let mut add = ADD.to_vec();
+    add.extend(["--persona", "nibu", "--fixture", "f.yaml", "--author", "Ada Writer"]);
+    let o = weksa(d.path(), &add);
+    assert!(o.status.success(), "{}", out(&o));
+    let put = |group: &str, to: &str, sets: &[&str]| {
+        let mut args = vec![
+            "scene", "put", "--group", group, "--to", to, "--inventory-rev", "3",
+            "--model-family", "anthropic", "--generator", "a scene annotator",
+        ];
+        for s in sets {
+            args.extend(["--set", s]);
+        }
+        weksa(d.path(), &args)
+    };
+    let sets = ["relative_status=above", "intimacy=200", "in_group=false"];
+    let o = put("scene-1", "unnamed", &sets);
+    assert!(o.status.success(), "{}", out(&o));
+    let dump = out(&weksa(d.path(), &["scene", "dump"]));
+    for want in ["scene:scene-1@1", "rev:3", "Anthropic", "a scene annotator", "entity:nibu->unnamed", "relative_status=above", "intimacy=200", "in_group=false"] {
+        assert!(dump.contains(want), "{want}: {dump}");
+    }
+    // A repeat is unchanged and writes nothing.
+    let o = put("scene-1", "unnamed", &sets);
+    assert!(out(&o).contains("unchanged"), "{}", out(&o));
+    assert_eq!(out(&weksa(d.path(), &["scene", "dump"])), dump);
+    // A changed value is the next revision.
+    let o = put("scene-1", "unnamed", &["relative_status=level", "intimacy=200", "in_group=false"]);
+    assert!(o.status.success(), "{}", out(&o));
+    assert!(out(&weksa(d.path(), &["scene", "dump"])).contains("scene:scene-1@2"));
+    // An unknown gloss and an unknown group are refused and not echoed.
+    for (group, set) in [("scene-1", "canarygloss=1"), ("canarygroup", "intimacy=1")] {
+        let before = out(&weksa(d.path(), &["scene", "dump"]));
+        let o = put(group, "unnamed", &[set]);
+        assert!(!o.status.success());
+        assert!(!out(&o).contains("canary"), "{}", out(&o));
+        assert_eq!(out(&weksa(d.path(), &["scene", "dump"])), before);
+    }
+    // A group with two live speakers is refused: multi-party scenes wait.
+    let mut two = add.clone();
+    let at = two.iter().position(|a| *a == "entity:nibu").unwrap();
+    two[at] = "entity:brokkr";
+    let at = two.iter().position(|a| *a == "nibu").unwrap();
+    two[at] = "brokkr";
+    two.retain(|a| *a != "Mind the hatch.");
+    let at = two.iter().position(|a| *a == "--text").unwrap() + 1;
+    two.insert(at, "Brokkr speaks.");
+    let o = weksa(d.path(), &two);
+    assert!(o.status.success(), "{}", out(&o));
+    let o = put("scene-1", "unnamed", &sets);
+    assert!(!o.status.success());
+    assert!(!out(&o).contains("scene-1"), "{}", out(&o));
+}
diff --git a/crates/weksa/tests/common/mod.rs b/crates/weksa/tests/common/mod.rs
index 723a371..fa2deb9 100644
--- a/crates/weksa/tests/common/mod.rs
+++ b/crates/weksa/tests/common/mod.rs
@@ -123,6 +123,21 @@ pub fn ontology_in(dir: &std::path::Path) -> std::path::PathBuf {
     path
 }
 
+/// A new inventory store at `path` holding the Dao inventory as it stood at
+/// rev 3 (seed, proof, the Dao revision): the loop tests' fixed head, whose
+/// round and candidate revisions they pin. The committed
+/// `data/daodejing/inventory.cc` is rev 4 and is read by the corpus tests.
+pub fn dao_rev3_at(path: &std::path::Path) {
+    let mut store = weksa::InventoryStore::open(path).unwrap();
+    for (rev, entries) in [
+        weksa::inventory::seed(),
+        weksa::inventory::proof_revision(),
+        weksa::daodejing::revision(),
+    ] {
+        store.admit_revision(rev, entries).unwrap();
+    }
+}
+
 /// An empty speaker-state store beside `ontology` (same directory), made if absent.
 pub fn speaker_state_beside(ontology: &std::path::Path) -> std::path::PathBuf {
     let path = ontology.with_file_name("speaker-state.cc");
diff --git a/crates/weksa/tests/golf_loop.rs b/crates/weksa/tests/golf_loop.rs
index 3c36f33..d2bf719 100644
--- a/crates/weksa/tests/golf_loop.rs
+++ b/crates/weksa/tests/golf_loop.rs
@@ -896,9 +896,11 @@ fn dao_build(
         std::fs::copy(src.join(from), dir.path().join(to)).unwrap();
         dir.path().join(to)
     };
+    // The Dao inventory at rev 3: the pins below are written against it.
+    common::dao_rev3_at(&dir.path().join("i.cc"));
     let (corpus, inventory, entities) = (
         copy("corpus.cc", "c.cc"),
-        copy("inventory.cc", "i.cc"),
+        dir.path().join("i.cc"),
         copy("entity.cc", "e.cc"),
     );
     edit(&corpus, &entities);
@@ -4778,7 +4780,7 @@ fn create_refuses_an_entry_its_inventory_cannot_read() {
                 inventory: &dir.join("i.cc"),
                 entities: &dir.join("e.cc"),
                 ontology,
-                speaker_state: &common::speaker_state_beside(&ontology),
+                speaker_state: &common::speaker_state_beside(ontology),
             },
             "fake-model",
             "bag",
@@ -4834,3 +4836,214 @@ fn round_lowering_prompts_carry_selected_entries() {
     }
     assert_eq!(seen.len(), 6, "three items in each language");
 }
+
+/// Admits the speaker-state revision (rev 4) onto the rev-3 Dao inventory at
+/// `inventory`, and the scene for the group of `item:daodejing:3`: Laozi's
+/// relation to an unnamed party, above, intimacy 200.
+fn put_dao_scene(speaker_state: &Path, inventory: &Path, corpus: &Path, entities: &Path) {
+    use weksa::packet::{FeatValue, FeatureValue};
+    let mut inv_store = InventoryStore::open(inventory).unwrap();
+    let (rev, entries) = weksa::inventory::speaker_scene_revision(4);
+    inv_store.admit_revision(rev, entries).unwrap();
+    let inv = inv_store.inventory().unwrap();
+    let id = |gloss: &str| inv.entries().find(|e| e.gloss == gloss).unwrap().id;
+    let corpus = CorpusStore::open(corpus).unwrap();
+    let item = corpus.get("item:daodejing:3").unwrap().unwrap();
+    let scene = weksa::Scene {
+        group: item.group.clone(),
+        n: 1,
+        inventory_rev: 4,
+        participants: vec![item.speaker.clone()],
+        relations: vec![weksa::PairRelation {
+            from: item.speaker.clone(),
+            to: weksa::Party::Unnamed,
+            features: vec![
+                FeatureValue {
+                    feature: id("relative_status"),
+                    value: FeatValue::Option(common::lab("above")),
+                },
+                FeatureValue {
+                    feature: id("intimacy"),
+                    value: FeatValue::Grade(common::grade(200)),
+                },
+            ],
+        }],
+        annotator: weksa::Annotator::Operator,
+    };
+    weksa::SpeakerStateStore::open(speaker_state)
+        .unwrap()
+        .put_scene(scene, &inv_store, &corpus, &weksa::EntityStore::open(entities).unwrap())
+        .unwrap();
+}
+
+/// A Dao run whose store holds a scene for item 3's group and whose ontology
+/// holds en-US:1, selected when the speaker is above the addressee.
+fn scene_dao(extra: impl FnOnce(&Path, &Path)) -> Dao {
+    dao_build(
+        |_, _| {},
+        &["en-US"],
+        |ontology, inventory| {
+            use weksa::{Condition, Layer, OntologyEntry, OntologyStore, Slot, Test};
+            let dir = ontology.parent().unwrap();
+            put_dao_scene(
+                &common::speaker_state_beside(ontology),
+                inventory,
+                &dir.join("c.cc"),
+                &dir.join("e.cc"),
+            );
+            let inv_store = InventoryStore::open(inventory).unwrap();
+            let status = inv_store
+                .inventory()
+                .unwrap()
+                .entries()
+                .find(|e| e.gloss == "relative_status")
+                .unwrap()
+                .id;
+            OntologyStore::open(ontology)
+                .unwrap()
+                .admit(
+                    vec![OntologyEntry {
+                        language: "en-US".into(),
+                        n: 1,
+                        inventory_rev: 4,
+                        layer: Layer::Discourse,
+                        when: vec![Condition {
+                            slot: Slot::Scene,
+                            feature: status,
+                            test: Test::Is(weksa::packet::FeatValue::Option(common::lab("above"))),
+                        }],
+                        choice: "ENABOVE".into(),
+                        examples: vec![],
+                        annotator: weksa::Annotator::Operator,
+                    }],
+                    &inv_store,
+                )
+                .unwrap();
+            extra(&dir.join("c.cc"), &dir.join("e.cc"));
+        },
+    )
+}
+
+/// Answers for items 1 to 3 where item 3 names referent n2 (no entity) as its
+/// addressee, or nobody.
+fn addressing(addressee: Option<&str>) -> Vec<(usize, String)> {
+    (1..=3)
+        .map(|n| {
+            let mut v = serde_json::to_value(draft_of(n)).unwrap();
+            if n == 3 {
+                v["discourse"]["addressee"] = serde_json::json!(addressee);
+            }
+            (n, v.to_string())
+        })
+        .collect()
+}
+
+fn lowering_of(model: &FakeModel, marker: &str) -> Vec<String> {
+    lowering_texts(model)
+        .into_iter()
+        .filter(|t| t.contains(marker))
+        .map(String::from)
+        .collect()
+}
+
+#[test]
+fn round_prompts_carry_scene_selected_entries() {
+    // Above an unnamed addressee: item 3's prompt holds the entry, the other
+    // two (no scene for their groups) read NoScene and print without it.
+    let mut dao = scene_dao(|_, _| {});
+    let mut model = fake(&addressing(Some("n2")));
+    recorded(round(&mut dao.run, &mut model, &Scorer::new(Bag)).unwrap());
+    assert_eq!(lowering_texts(&model).len(), 3);
+    let with = lowering_of(&model, "\nonto:en-US:1 [discourse] ENABOVE");
+    assert_eq!(with.len(), 1, "only item 3 has a scene and an addressee");
+    assert_eq!(
+        lowering_texts(&model).iter().filter(|t| t.contains("ontology: none")).count(),
+        2
+    );
+    // The same item with no addressee selects no Scene entry.
+    let mut dao = scene_dao(|_, _| {});
+    let mut model = fake(&addressing(None));
+    recorded(round(&mut dao.run, &mut model, &Scorer::new(Bag)).unwrap());
+    assert!(lowering_of(&model, "ENABOVE").is_empty());
+    assert_eq!(lowering_texts(&model).len(), 3);
+}
+
+#[test]
+fn a_scene_read_failure_is_a_lower_refusal() {
+    // A live item of item 3's group, in a language outside the panel, spoken by
+    // someone the scene does not cover: V16 for that group.
+    let mut dao = scene_dao(|corpus, entities| {
+        let mut entity_store = weksa::EntityStore::open(entities).unwrap();
+        entity_store.put(ent("stranger", "en-US", &["Stranger"])).unwrap();
+        let mut store = CorpusStore::open(corpus).unwrap();
+        let mut twin = store.get("item:daodejing:3").unwrap().unwrap();
+        twin.id = "item:daodejing:93".into();
+        twin.language = "pt-BR".into();
+        twin.text = "PORTUGUESEMARK 93 o sabio".into();
+        twin.speaker = common::eid("stranger");
+        twin.names = vec![];
+        twin.prior_turns = vec![];
+        store.add(twin, &entity_store).unwrap();
+    });
+    let mut model = fake(&addressing(Some("n2")));
+    let r = recorded(round(&mut dao.run, &mut model, &Scorer::new(Bag)).unwrap());
+    // Item 3 never reached the model; items 1 and 2 did, and the round recorded.
+    assert_eq!(lowering_texts(&model).len(), 2);
+    assert_eq!(r.n(), 1);
+}
+
+#[test]
+fn a_run_pins_its_speaker_state_and_refuses_drift() {
+    let dao = scene_dao(|_, _| {});
+    let r = dao.run.record();
+    let path = dao.ontology.with_file_name("speaker-state.cc");
+    assert_eq!(r.speaker_state, std::fs::canonicalize(&path).unwrap().to_str().unwrap());
+    assert_eq!(r.speaker_state_digest, hex(&path));
+    let root = dao.root.clone();
+    assert_eq!(RunStores::open(&root).unwrap().record(), dao.run.record());
+    let mut bytes = std::fs::read(&path).unwrap();
+    bytes.push(0xc0);
+    std::fs::write(&path, bytes).unwrap();
+    assert_eq!(
+        RunStores::open(&root).err(),
+        Some(RunError::Drift(DriftOf::SpeakerState))
+    );
+}
+
+#[test]
+fn create_refuses_a_scene_its_inventory_cannot_read() {
+    // The scene is admitted against a copy that gained rev 4; the run's head
+    // inventory stops at rev 3.
+    let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/daodejing");
+    let dir = tempfile::tempdir().unwrap();
+    for (from, to) in [("corpus.cc", "c.cc"), ("entity.cc", "e.cc")] {
+        std::fs::copy(src.join(from), dir.path().join(to)).unwrap();
+    }
+    common::dao_rev3_at(&dir.path().join("i.cc"));
+    common::dao_rev3_at(&dir.path().join("rich.cc"));
+    let state = common::speaker_state_in(dir.path());
+    put_dao_scene(&state, &dir.path().join("rich.cc"), &dir.path().join("c.cc"), &dir.path().join("e.cc"));
+    let ontology = common::ontology_in(dir.path());
+    let root = dir.path().join("run");
+    let create = || {
+        RunStores::create(
+            &root,
+            "x",
+            RunPaths {
+                corpus: &dir.path().join("c.cc"),
+                inventory: &dir.path().join("i.cc"),
+                entities: &dir.path().join("e.cc"),
+                ontology: &ontology,
+                speaker_state: &state,
+            },
+            "fake-model",
+            "bag",
+            weksa::run::LowererReach::ToolLessRelay,
+            ModelFamily::Unrecorded,
+            &["en-US".to_string()],
+        )
+    };
+    assert_eq!(create().err(), Some(RunError::SpeakerState));
+    assert!(!root.join("run.cc").exists());
+    assert!(!root.join("inventory.cc").exists());
+}
diff --git a/crates/weksa/tests/original_corpus.rs b/crates/weksa/tests/original_corpus.rs
index 8b06da7..8838554 100644
--- a/crates/weksa/tests/original_corpus.rs
+++ b/crates/weksa/tests/original_corpus.rs
@@ -18,7 +18,7 @@ use weksa::{CorpusStore, EntityStore, InventoryStore};
 fn stores() -> (CorpusStore, EntityStore) {
     let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/original");
     let tmp = tempfile::tempdir().unwrap();
-    for f in ["corpus.cc", "entity.cc", "inventory.cc"] {
+    for f in ["corpus.cc", "entity.cc", "inventory.cc", "speaker-state.cc"] {
         std::fs::copy(dir.join(f), tmp.path().join(f)).unwrap();
     }
     let keep = tmp.keep();
@@ -241,14 +241,22 @@ fn the_first_six_original_items_are_unchanged() {
 }
 
 #[test]
-fn the_original_inventory_is_the_dao_revision_three() {
+fn the_original_inventory_is_the_dao_inventory() {
     let dao = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/daodejing/inventory.cc");
     let own = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/original/inventory.cc");
     assert_eq!(std::fs::read(dao).unwrap(), std::fs::read(&own).unwrap());
     let tmp = tempfile::tempdir().unwrap();
     let copy = tmp.path().join("inventory.cc");
     std::fs::copy(&own, &copy).unwrap();
-    assert!(InventoryStore::open(&copy).is_ok());
+    let inventory = InventoryStore::open(&copy).unwrap().inventory().unwrap();
+    // Revision 4 is the speaker-state vocabulary: the same six features the
+    // generator admits, ids and all.
+    assert_eq!(inventory.latest().unwrap().n, 4);
+    let (rev, entries) = weksa::inventory::speaker_scene_revision(4);
+    assert_eq!(inventory.latest().unwrap().changes, rev.changes);
+    for e in &entries {
+        assert_eq!(inventory.entry(&e.id), Some(e), "{}", e.gloss);
+    }
 }
 
 /// The committed seed ontology: every entry model-drafted, exactly the two
@@ -270,8 +278,12 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
         match &e.annotator {
             Annotator::Model { family, generator } => {
                 assert_eq!(*family, ModelFamily::Anthropic, "{}", e.key());
-                assert_eq!(
-                    generator, "claude-sonnet-5-5 (Weksa Hands, model-drafted seed ontology)",
+                assert!(
+                    [
+                        "claude-sonnet-5-5 (Weksa Hands, model-drafted seed ontology)",
+                        "claude-sonnet-5-5 (Weksa Hands, model-drafted scene ontology)",
+                    ]
+                    .contains(&generator.as_str()),
                     "{}",
                     e.key()
                 );
@@ -283,6 +295,15 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
     langs.sort();
     langs.dedup();
     assert_eq!(langs, PANEL);
+    // Every entry from number 10 on is conditioned on the scene relation, and
+    // only an entry with a Scene condition may name a politeness level.
+    for e in entries.iter().filter(|e| e.n >= 10) {
+        assert!(
+            e.when.iter().any(|c| c.slot == weksa::inventory::Slot::Scene),
+            "{} has no Scene condition",
+            e.key()
+        );
+    }
     for lang in PANEL {
         let stance = |c: &Condition| c.slot == weksa::inventory::Slot::Stance;
         assert!(
@@ -299,6 +320,7 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
             tmp.path().join(format!("{corpus}-{f}"))
         };
         let (c, i, e) = (copy("corpus.cc"), copy("inventory.cc"), copy("entity.cc"));
+        let s = copy("speaker-state.cc");
         RunStores::create(
             &tmp.path().join(format!("run-{corpus}")),
             corpus,
@@ -307,7 +329,7 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
                 inventory: &i,
                 entities: &e,
                 ontology: &onto,
-                speaker_state: &common::speaker_state_beside(&onto),
+                speaker_state: &s,
             },
             "m",
             "bag",
@@ -419,7 +441,7 @@ fn original_round(family: ModelFamily) -> (weksa::run::RunStores, weksa::run::Ro
     use weksa::run::{LowererReach, RoundOutcome, RunPaths, RunStores, round};
     let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/original");
     let tmp = tempfile::tempdir().unwrap().keep();
-    for f in ["corpus.cc", "entity.cc", "inventory.cc"] {
+    for f in ["corpus.cc", "entity.cc", "inventory.cc", "speaker-state.cc"] {
         std::fs::copy(src.join(f), tmp.join(f)).unwrap();
     }
     std::fs::write(tmp.join("ontology.cc"), [0x90]).unwrap();
@@ -578,7 +600,7 @@ fn no_test_item_is_offered_to_a_round_or_recall_or_recorded() {
     use weksa::run::{LowererReach, RoundOutcome, RunPaths, RunStores, round};
     let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/original");
     let tmp = tempfile::tempdir().unwrap();
-    for f in ["corpus.cc", "entity.cc", "inventory.cc"] {
+    for f in ["corpus.cc", "entity.cc", "inventory.cc", "speaker-state.cc"] {
         std::fs::copy(src.join(f), tmp.path().join(f)).unwrap();
     }
     std::fs::write(tmp.path().join("ontology.cc"), [0x90]).unwrap();
diff --git a/crates/weksa/tests/scene.rs b/crates/weksa/tests/scene.rs
index 66f3cb7..5974883 100644
--- a/crates/weksa/tests/scene.rs
+++ b/crates/weksa/tests/scene.rs
@@ -408,3 +408,60 @@ fn only_live_speakers_of_the_views_group_and_the_views_own_speaker_must_be_cover
         ["V16"]
     );
 }
+
+mod select {
+    use super::*;
+    use weksa::speaker::Annotator;
+    use weksa::{Condition, Layer, OntologyEntry, OntologyStore, Slot, Test, select};
+
+    fn scene_feature(gloss: &str) -> weksa::InvId {
+        speaker_scene_revision(3).1.into_iter().find(|e| e.gloss == gloss).unwrap().id
+    }
+
+    fn entry(n: u32, slot: Slot, gloss: &str, test: Test) -> OntologyEntry {
+        OntologyEntry {
+            language: "ja-JP".into(),
+            n,
+            inventory_rev: 3,
+            layer: Layer::Grammar,
+            when: vec![Condition { slot, feature: scene_feature(gloss), test }],
+            choice: "a choice".into(),
+            examples: vec![],
+            annotator: Annotator::Operator,
+        }
+    }
+
+    #[test]
+    fn select_reads_the_scene_relation() {
+        let mut w = world();
+        put(&mut w, standard("g", 1));
+        let mut store = OntologyStore::open(&w.dir.path().join("o.cc")).unwrap();
+        store
+            .admit(
+                vec![
+                    entry(1, Slot::Scene, "relative_status", Test::Is(FeatValue::Option(lab("above")))),
+                    entry(2, Slot::Scene, "intimacy", Test::AtLeast(grade(150))),
+                ],
+                &w.inventory,
+            )
+            .unwrap();
+        let ontology = store.ontology().unwrap();
+        let keys = |read: SceneRead, w: &W| {
+            let view = view_of(w, 3, Some("n3")).with_scene(&inv(w), &w.state, &w.corpus).unwrap();
+            assert_eq!(view.scene_read(), &read);
+            select(&ontology, "ja-JP", &view).iter().map(|e| e.n).collect::<Vec<_>>()
+        };
+        // Brokkr is above-status at intimacy 200: both Scene entries select.
+        assert_eq!(keys(selected(1, status()), &w), [1, 2]);
+        // No scene for the group: neither selects.
+        let empty = world();
+        assert_eq!(keys(SceneRead::NoScene, &empty), Vec::<u32>::new());
+        // No addressee, and no relation to the addressee: neither selects.
+        let view = view_of(&w, 3, None).with_scene(&inv(&w), &w.state, &w.corpus).unwrap();
+        assert_eq!(view.scene_read(), &SceneRead::NoAddressee { rev: 1 });
+        assert!(select(&ontology, "ja-JP", &view).is_empty());
+        let mut lone = world();
+        put(&mut lone, scene("g", 1, &["nibu", "brokkr"], vec![relation("brokkr", Party::Named(eid("nibu")), intimacy(99))]));
+        assert_eq!(keys(SceneRead::NoRelation { rev: 1 }, &lone), Vec::<u32>::new());
+    }
+}
diff --git a/crates/weksa/tests/stores.rs b/crates/weksa/tests/stores.rs
index f027611..5b26e85 100644
--- a/crates/weksa/tests/stores.rs
+++ b/crates/weksa/tests/stores.rs
@@ -1740,9 +1740,9 @@ mod ontology {
             "five conditions",
             vec![OntologyEntry { when: (0..5).map(|_| restraint()).collect(), ..entry("ja-JP", 1) }],
         ));
-        for slot in [Slot::Speaker, Slot::Scene, Slot::Predication] {
+        for slot in [Slot::Speaker, Slot::Predication] {
             cases.push((
-                "slot not Stance or Discourse",
+                "slot not Stance, Discourse or Scene",
                 vec![OntologyEntry {
                     when: vec![when(slot, "restraint", Test::AtLeast(Grade::new(1).unwrap()))],
                     ..entry("ja-JP", 1)
@@ -1818,6 +1818,43 @@ mod ontology {
         assert_eq!(s.all().unwrap().len(), 64);
     }
 
+    #[test]
+    fn ontology_admit_takes_scene_refuses_speaker() {
+        use weksa::inventory::{proof_revision, speaker_scene_revision};
+        let d = dir();
+        let mut inventory = InventoryStore::open(&d.path().join("i.cc")).unwrap();
+        for (rev, entries) in [seed(), proof_revision(), speaker_scene_revision(3)] {
+            inventory.admit_revision(rev, entries).unwrap();
+        }
+        let scene_feature = |gloss: &str| {
+            speaker_scene_revision(3).1.into_iter().find(|e| e.gloss == gloss).unwrap().id
+        };
+        let at = |slot, feature, test| OntologyEntry {
+            inventory_rev: 3,
+            when: vec![Condition { slot, feature, test }],
+            ..entry("ja-JP", 1)
+        };
+        let above = Test::Is(FeatValue::Option(lab("above")));
+        let mut s = store(&d);
+        // A Scene condition on a Scene feature admits.
+        assert_eq!(
+            s.admit(vec![at(Slot::Scene, scene_feature("relative_status"), above.clone())], &inventory)
+                .unwrap(),
+            AddOutcome::Added
+        );
+        // Speaker and Predication slots refuse, and a Scene condition naming a
+        // Stance feature refuses.
+        for bad in [
+            at(Slot::Speaker, scene_feature("education"), Test::AtLeast(Grade::new(1).unwrap())),
+            at(Slot::Predication, feature("modality"), Test::Is(FeatValue::Option(lab("actual")))),
+            at(Slot::Scene, feature("restraint"), Test::AtLeast(Grade::new(1).unwrap())),
+        ] {
+            let bad = OntologyEntry { n: 2, ..bad };
+            assert!(s.admit(vec![bad], &inventory).is_err());
+        }
+        assert_eq!(s.all().unwrap().len(), 1);
+    }
+
     #[test]
     fn ontology_admit_is_all_or_nothing() {
         let d = dir();
diff --git a/data/corpus/speaker-state.cc b/data/corpus/speaker-state.cc
new file mode 100644
index 0000000..9e99dd5
--- /dev/null
+++ b/data/corpus/speaker-state.cc
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/data/daodejing/inventory.cc b/data/daodejing/inventory.cc
index 373eb3cf259663321fdf94128b4f11a984998f01..3904b809b75c3558a065b8043c36df0a79b8aeaf 100644
GIT binary patch
delta 653
zcmaLT!Ab%_7zc1Pp%C!_f>0{*(!p7`z$F4Nb*dl>qC?9#^R;e`JF+{w;n61uS@Q*I
zFzt{abP9^-5qg1+y+te4y6d6Kz<&<E@B98QhhHb7k3{C8J0RR5&=eZ-QF48pNft8x
zStgw*2Qjyglq0mMDP>LFIDN15hUb8VYlDW$k2WwYOb>KN1b<Guf6x>rw;W&AfblEI
zzyl_6jeF3MRRR{Ie3WgcLqqY4$^3R~!s>K_QoJ`UVKy*n$z2=M5P9uRg~`sjtr)Qq
zAy7c*hRxmP-44UX-x^WD|6I!N#Q-$|C{GS2CWoLS-Z07JREwIH@w-vK+5~(Fb}A;~
zg?uF@79wJ40MsQxaoqY3Q74DhV#;wuQHR(7o$xxhMOgfeBz2R~A*P&x6BI5UTHLh^
z9aEPH`SSv!V0XgB$D{1^;(S-y;AyJ=yteGbW<obL*K6NaC=EMD<#<+#Ga1cfWhR$q
HvikN7C_nnL

delta 42
ycmaDEu|H_T6-J)qDJzrn^O92wN~{bg7pmxO=3`RjnY@;-e)2yd&dr{JEm8n~#1KgU

diff --git a/data/daodejing/speaker-state.cc b/data/daodejing/speaker-state.cc
new file mode 100644
index 0000000..9e99dd5
--- /dev/null
+++ b/data/daodejing/speaker-state.cc
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/data/original/inventory.cc b/data/original/inventory.cc
index 373eb3cf259663321fdf94128b4f11a984998f01..3904b809b75c3558a065b8043c36df0a79b8aeaf 100644
GIT binary patch
delta 653
zcmaLT!Ab%_7zc1Pp%C!_f>0{*(!p7`z$F4Nb*dl>qC?9#^R;e`JF+{w;n61uS@Q*I
zFzt{abP9^-5qg1+y+te4y6d6Kz<&<E@B98QhhHb7k3{C8J0RR5&=eZ-QF48pNft8x
zStgw*2Qjyglq0mMDP>LFIDN15hUb8VYlDW$k2WwYOb>KN1b<Guf6x>rw;W&AfblEI
zzyl_6jeF3MRRR{Ie3WgcLqqY4$^3R~!s>K_QoJ`UVKy*n$z2=M5P9uRg~`sjtr)Qq
zAy7c*hRxmP-44UX-x^WD|6I!N#Q-$|C{GS2CWoLS-Z07JREwIH@w-vK+5~(Fb}A;~
zg?uF@79wJ40MsQxaoqY3Q74DhV#;wuQHR(7o$xxhMOgfeBz2R~A*P&x6BI5UTHLh^
z9aEPH`SSv!V0XgB$D{1^;(S-y;AyJ=yteGbW<obL*K6NaC=EMD<#<+#Ga1cfWhR$q
HvikN7C_nnL

delta 42
ycmaDEu|H_T6-J)qDJzrn^O92wN~{bg7pmxO=3`RjnY@;-e)2yd&dr{JEm8n~#1KgU

diff --git a/data/original/speaker-state.cc b/data/original/speaker-state.cc
new file mode 100644
index 0000000..9e99dd5
--- /dev/null
+++ b/data/original/speaker-state.cc
@@ -0,0 +1 @@
+�
\ No newline at end of file
diff --git a/docs/targets/interlingua-lowering-map.md b/docs/targets/interlingua-lowering-map.md
index 22db5cd..a100cd9 100644
--- a/docs/targets/interlingua-lowering-map.md
+++ b/docs/targets/interlingua-lowering-map.md
@@ -33,11 +33,11 @@ means no store holds it and nothing writes it.
 | Schema version | `weksa.interlingua_packet.v<N>` constant in `crates/weksa`; published JSON Schema at `schemas/cultnet/` | Bumped by a commit that changes the Rust types; the published schema is regenerated in the same commit and a test fails on drift | A cut (Hands, under a spec); never the loop |
 | Inventory entry | Key `<family>:<n>`, `n` canonical decimal >= 1 (families: concept, frame, role, relation, speech_act, feature, referent_kind, extension); type `weksa.inventory_entry`, with a bounded gloss, value kind (option labels bounded), the slots a feature may sit in (`Discourse`, `Referent`, `Predication`, `Relation`; `Stance` from cut `speaker-state`, `Speaker` and `Scene` from cut `speaker-scene`), `introduced_rev` and optional `retired_rev`. Speaker axes, scene relations and affects are features of those slots, so the loop grows them like any closed-class family and convergence covers them | Added or retired by an inventory revision; never edited in place (a changed meaning is a retire plus an add); a retired id still resolves for packets of earlier revisions | The loop's accepted rounds, whose minting call the context builder assembles from Train items only; Self on merge to main. Admission checks form, not text |
 | Inventory revision | Key `rev:<n>`, type `weksa.inventory_revision`, with parent, change list and `frozen` | Appended per accepted round; exactly one revision is ever marked frozen, by the convergence test | The loop's accept rule appends; the convergence test freezes; Self records the freeze as a ruling |
-| Target profile | Locale or language-project id (`en-US`, `ja-JP`, a conlang's slug). Until entries grow in rounds there is no profile revision document: a run names the profile it lowered with by the ontology store's path and digest in its `RunRecord` (cut `language-ontology`); `profile:<language>:<n>` revision documents arrive with follow-up `language-ontology-growth` | The ontology store is revised by commit; a run pins it and refuses drift | Profile authors and accepted rounds; never the lowerer's defaults (`persona-drives-register`) |
-| Language ontology entry (cut `language-ontology`) | Key `onto:<language>:<n>`, `n` from 1 per language; type `weksa.ontology_entry` in `data/ontology/ontology.cc`: the language, the inventory revision its conditions are read at, a layer (lexicon, grammar, discourse, phonology, orthography), at most four conditions (a feature id of slot `Stance` or `Discourse` with `AtLeast`/`AtMost` a grade or `Is` an option or flag; slots `Speaker` and `Scene` and community ids join with follow-up `language-ontology-view-assembly`), a choice of 1 to 200 bytes, at most three examples of 1 to 120 bytes, and an `Annotator` | Admitted in all-or-nothing batches through `OntologyStore::admit`, immutable, never edited; retire arrives with `language-ontology-growth`. The run pins the store like the entity store (path and digest, `Drift(Ontology)`), never copies it, because no loop step writes it yet. Cut `language-ontology-seed` converts by drafting, not by parse: a fresh model drafts each language's seed from that language's YAML and the inventory's feature lines with no corpus text, then deletes `data/target-language-ontology/` and `.weksa/cultural-ontology/` in the same cut | Seed: a labelled model (`Annotator::Model`), no operator gate, never Test evidence (`ja-ontology-owner-answer`); attestation (operator, native reader) appends later. Accepted rounds later, through a mint call from Train items only. Selection is `ontology::select(ontology, language, view)`, called only inside `Prompt::lower`, so no caller picks entries; the prompt prints each selected entry's id, layer, choice and examples. Its text is minted text for the leak diagnostic, which today has no runtime caller (follow-up `leak-diagnostic-in-round`) |
+| Target profile | Locale or language-project id (`en-US`, `ja-JP`, a conlang's slug). Until entries grow in rounds there is no profile revision document: a run names the profile it lowered with by the ontology store's path and digest in its `RunRecord` (cut `language-ontology`); `profile:<language>:<n>` revision documents arrive with follow-up `language-ontology-growth` | The ontology store is revised by commit; a run pins it and refuses drift; it likewise pins the speaker-state store (`RunRecord` keys 17 and 18, `Drift(SpeakerState)`, cut `language-ontology-scene`) | Profile authors and accepted rounds; never the lowerer's defaults (`persona-drives-register`) |
+| Language ontology entry (cut `language-ontology`) | Key `onto:<language>:<n>`, `n` from 1 per language; type `weksa.ontology_entry` in `data/ontology/ontology.cc`: the language, the inventory revision its conditions are read at, a layer (lexicon, grammar, discourse, phonology, orthography), at most four conditions (a feature id of slot `Stance`, `Discourse` or `Scene` with `AtLeast`/`AtMost` a grade or `Is` an option or flag; a `Scene` condition reads the relation of the item's speaker to its addressee that `with_scene` selected; slot `Speaker` and community ids wait on follow-up `language-ontology-communities`), a choice of 1 to 200 bytes, at most three examples of 1 to 120 bytes, and an `Annotator` | Admitted in all-or-nothing batches through `OntologyStore::admit`, immutable, never edited; retire arrives with `language-ontology-growth`. The run pins the store like the entity store (path and digest, `Drift(Ontology)`), never copies it, because no loop step writes it yet. Cut `language-ontology-seed` converts by drafting, not by parse: a fresh model drafts each language's seed from that language's YAML and the inventory's feature lines with no corpus text, then deletes `data/target-language-ontology/` and `.weksa/cultural-ontology/` in the same cut | Seed: a labelled model (`Annotator::Model`), no operator gate, never Test evidence (`ja-ontology-owner-answer`); attestation (operator, native reader) appends later. Accepted rounds later, through a mint call from Train items only. Selection is `ontology::select(ontology, language, view)`, called only inside `Prompt::lower`, so no caller picks entries; the prompt prints each selected entry's id, layer, choice and examples. Its text is minted text for the leak diagnostic, which today has no runtime caller (follow-up `leak-diagnostic-in-round`) |
 | Community (cut `language-ontology`, follow-up `language-ontology-communities`) | Key `community:<slug>`; type `weksa.community`, converted from `data/cultural-ontology/cultures/` and `referents/` (YAML deleted in the same cut) | Revised by commit; a speaker names the communities it belongs to by id | The cultural ontology's author (owner-attested evidence only; Discord-only content stays deleted, `discord-only-content-deleted`) |
 | Speaker (cut `speaker-scene`) | Key `speaker:<slug>@<n>`; type `weksa.speaker`: stable axes as feature values of slot `Speaker` (origin, socioeconomic standing, age cohort, education and whatever the loop adds), at an inventory revision, and an `Annotator` | A new revision appends, never edits; a corpus item and every prior turn name a speaker slug, and a round records the speaker revisions it read | The annotator it names: `PersonaSnapshot` (a projection of a `gamecult.persona_state.v0` document, naming its source document and `updatedAt`), `Operator`, `WorkMetadata` (a public-domain work's own cast list and narration), or `Model { family, generator }` (the 2b `ModelFamily`) |
-| Scene (cut `speaker-scene`) | Key `scene:<group>@<n>`, the item's split group; type `weksa.scene`: participants (speaker slugs) and, per ordered pair, relation features of slot `Scene` (relative status, intimacy, in-group, audience and whatever the loop adds), at an inventory revision, and an `Annotator` | As Speaker. Keyed by the group, so a scene never straddles the split | As Speaker |
+| Scene (cut `speaker-scene`) | Key `scene:<group>@<n>`, the item's split group; type `weksa.scene`: participants (speaker slugs) and, per ordered pair, relation features of slot `Scene` (relative status, intimacy, in-group, audience and whatever the loop adds), at an inventory revision, and an `Annotator` | As Speaker. Keyed by the group, so a scene never straddles the split. `data/original/speaker-state.cc` holds Model-annotated keeper scenes, one per Train or Validation group of both languages (`weksa scene put|dump`); a Test group has none and reads `NoScene` | As Speaker; a model-annotated scene is never Test evidence |
 | Corpus item | Key `item:<source-slug>:<n>`, `n` canonical decimal >= 1 (no sign, no leading zero, from cut 2b); type `weksa.corpus_item` with text, language, speaker, split group, prior turns, source. Source `ModelWritten` carries a `ModelFamily` enum, the generator string as the fixture wrote it, and a prompt digest (cut 2b). The item carries no speaker state of its own: its speaker slug and group name the Speaker and Scene documents | Admitted once; the whole item is immutable (re-adding an identical item is a no-op, any difference is refused; a correction is a new item that `supersedes` the old); text already held under another key is refused unless the new item supersedes that key (cut 2b); withdrawn, never deleted, so old scores stay explainable | Importers and `weksa corpus add`, under `corpus-cast-plus-public-domain`; the source enum has no variant for Discord or any training-forbidden source (`corpus-clean`) |
 | Split assignment | Derived: `split(scheme, item.group)` | Fixed for a scheme; a new scheme is a new constant, never a reassignment. A model-written item whose group derives test is in no split; a superseding item keeps its predecessor's group | The hash function. Nobody assigns by hand, so there is no writer to forbid |
 | Loop round | Key `run:<label>:round:<n>`; type `weksa.loop_round` with spec version, profile revisions, model ids and prompt digests, sampled train items, Validation means and refusal counts (from cut `ja-panel-loop`: one set per language of the run's panel, no pooled mean), the digest of the inventory file it was scored under and, for a cycle's candidate round, its cycle `k` | Scored and recorded whole; immutable. A candidate round is put in one batch with its Decision. Lives in the run store on Yggdrasil | `run::round` and `run::cycle` (both through `score_round`) |
@@ -424,7 +424,7 @@ One line per cut; specs exist for the cuts about to run (2d and 4, siblings on `
 4. `speaker-state`: packet `stance` (felt affect and restraint, slot `Stance`, packet schema v4); formality, warmth and intensity out of the seed and the standard; only `PacketStore::admit` yields a `LoweringInput`, and it refuses packets for withdrawn items (follow-up `lowering-input-from-packet-store`). (spec r1)
 4a. `speaker-relation-input`: slot `Scene` and its first seed features (`relative_status`, `intimacy`, `in_group`; inventory revision 3, now `speaker_scene_revision`); `LoweringInput::with_scene` carries the speaker's relation to the addressee as typed `Scene` feature values. Since 4b it takes the `SpeakerStateStore` and the `CorpusStore`, reads the scene of the view's own item group for the item's speaker, and selects the relation by the addressee referent's entity (V16 when the scene does not list the item's speaker or the speaker of any live item of the group, the rule `put_scene` applies too; V17 refuses an addressee that names a predication; V13 is retired). The English lowerer does not render it. (PR for follow-up `chat-s3352-3352`)
 4b. `speaker-scene` (spec r1; `speaker-scene-seeds` is its cut 4c: CLI, inventory revision 3, cast speakers and scenes; `Party::Unnamed` covers an addressee with no entity; Speaker and Scene share one `SpeakerStateStore`): slots `Speaker` and `Scene` with their seed features; `weksa.speaker` (`speaker:<entity-slug>@<n>`) and `weksa.scene` (`scene:<group>@<n>`, participants and ordered-pair relations) documents with `Annotator` `Operator` and `Model { family, generator }`, validated by the packet's shared feature check, append-only per key; their stores, `weksa speaker` and `weksa scene` commands, published schemas; Model-annotated cast speakers and scenes for the committed items. Waits on 2d and 4; `pd-speaker-annotation` blocks only the public-domain annotator. Part 1 landed (branch `weksa-lowering/speaker-scene`): `speaker.rs`, `SpeakerStateStore`, slots `Speaker` and `Scene` exclusive to their own feature lists, `speaker_scene_revision()` (Speaker features 22-24), `with_scene` on the store, schemas. The CLI, the committed inventory revision 3 and the seeds stay with 4c.
-5. `language-ontology`, in sequential cuts on `d9ebbcf`. 5a `language-ontology` (spec r1): `weksa.ontology_entry`, `OntologyStore`, `ontology::select` over the view's `Stance` and `Discourse` features, `Prompt::lower` printing the selected entries of the item's language, `RunRecord` pinning the ontology store (keys 15 and 16), `weksa ontology admit|dump`; `ontology.rs` joins `PROMPT_SOURCE_DIGEST`. 5b `language-ontology-seed` (spec r1, after 5a): Model-annotated en-US and ja-JP seed entries drafted by an isolated model, `data/target-language-ontology/`, `.weksa/cultural-ontology/` and `schemas/target-language-cultural-ontology.md` deleted. Lost until 5d: keigo, hierarchy and uchi-soto hang on scene relations, so ja-JP politeness is still the lowerer's guess. 5c `language-ontology-view-assembly` (follow-up): the run pins the `SpeakerStateStore`, the round reads the item's Speaker and Scene through the stores, `select` widens to slots `Speaker` and `Scene`; waits on `speaker-scene-seeds`. 5d `language-ontology-communities` (follow-up): `weksa.community` from `data/cultural-ontology/` (YAML deleted, owns `edda-referent-yaml-parse`), community ids on `weksa.speaker`, community conditions; waits on 5c and question `persona-speech-community-home`.
+5. `language-ontology`, in sequential cuts on `d9ebbcf`. 5a `language-ontology` (spec r1): `weksa.ontology_entry`, `OntologyStore`, `ontology::select` over the view's `Stance` and `Discourse` features, `Prompt::lower` printing the selected entries of the item's language, `RunRecord` pinning the ontology store (keys 15 and 16), `weksa ontology admit|dump`; `ontology.rs` joins `PROMPT_SOURCE_DIGEST`. 5b `language-ontology-seed` (spec r1, after 5a): Model-annotated en-US and ja-JP seed entries drafted by an isolated model, `data/target-language-ontology/`, `.weksa/cultural-ontology/` and `schemas/target-language-cultural-ontology.md` deleted. Lost until 5c': keigo, hierarchy and uchi-soto hang on the scene relation from 5c', so ja-JP politeness is still the lowerer's guess. 5c' `language-ontology-scene` (spec r1, after 5b): the run pins the `SpeakerStateStore` (keys 17 and 18, `Drift(SpeakerState)`), `RunStores::assembled` is the one door that reads the item's scene into a loop view, `select` reads slot `Scene`, `Prompt::lower` refuses a view whose scene was never read, `weksa scene put|dump` and `weksa inventory speaker-scene` (inventory rev 4), Model-annotated keeper scenes and Scene-conditioned entries for `data/original`. 5c `language-ontology-view-assembly` (follow-up, now only the Speaker read): `select` widens to slot `Speaker`; waits on `speaker-scene-seeds`. 5d `language-ontology-communities` (follow-up): `weksa.community` from `data/cultural-ontology/` (YAML deleted, owns `edda-referent-yaml-parse`), community ids on `weksa.speaker`, community conditions; waits on 5c and question `persona-speech-community-home`.
 6. `pd-importer`: public-domain play and fiction dialogue into the corpus with speaker, scene group, edition provenance, and Speaker and Scene annotations by the ruled annotator. Waits on 4, follow-up `gutenberg-terms` and question `pd-speaker-annotation`.
 7a. `loop-context-builder`: `context.rs` (`TrainItems`, `EncoderOffer`, `Prompt`: corpus text reaches a model call only through `Prompt::mint` over live Train items or `Prompt::encode` over one offered item; instructions are the consts `MINT_INSTRUCTIONS` and `ENCODE_INSTRUCTIONS` in `context.rs`; `Checkpoint` has no public constructor, offers each item once, and its offers borrow it (the gate is typed `TestReadings` and Test offers on the round path; operator tools such as `weksa corpus dump` and `weksa score` still read corpus text of any split); prior turns print the held Train text), `SplitScheme::live`, `CorpusItem::cited_entities` (one owner of the id set `PacketStore::admit` and the offer share), and checkpoint-only Test readings (`Checkpoint`, `TestReadings`; `Aggregate` and `leak_diagnostic` carry no Test). Library only; since 7b `TrainItems::from_corpus` and `EncoderOffer::for_round` are crate-private and `RunStores` is their one public producer. Merges follow-ups `loop-context-builder-2` and `scorer-test-readings-type`. (spec r1)
 7b. `golf-loop-round` (spec r1; branch `weksa-lowering/golf-loop-round`): the smallest loop that scores one round. `run.rs`: `RunStores` pins the corpus and entity stores of a run by canonical path and FNV-1a 64 digest at `create`, reopens only from `<root>/run.cc` and refuses drift (corpus, entities, `PROMPT_SOURCE_DIGEST` of `context.rs`, a second pin on `lower.rs` retired in 7d, model, embedder); `round` encodes every live Train and Validation item through a `ModelPort` (`model.rs`; the one adapter `AnswerFiles` writes `<digest>.prompt` and reads `<digest>.answer`, so the model is the Claude session), reads each answer into a `PacketDraft` (`encode.rs`, the one place a model's JSON is read), admits through `PacketStore::admit` into `<root>/round-<n>/packets.cc`, lowers, scores once, and keeps a `RoundRecord` (`weksa.loop_round`, no text, no Test; Train rows, Validation only as means and refusal counts). `weksa loop open|round`. Not here: the spec-edit step, accept rule and composite, noise floor, Score and lowering documents, a subprocess adapter, the checkpoint door, a model lowerer (follow-ups `golf-loop-spec-edit`, `golf-loop-accept-rule`, `golf-loop-score-documents`, `golf-loop-subprocess-adapter`, `golf-loop-checkpoint-door-bound`, `golf-loop-model-lowerer`). `packet-store-inventory-binding` is met for loop packets only (`RunStores` admits with the run's inventory); `validate`, `packet proof|dao` and `lower` still take caller stores. Waits on 7a, `checkpoint-gate`, 4b.
-- 
2.47.3


From 31a0c2406e161a35c13c81ac35559183891318d6 Mon Sep 17 00:00:00 2001
From: Weksa <weksa@minds.weksa.gamecult.org>
Date: Thu, 12 Nov 2026 16:33:36 +0000
Subject: [PATCH 3/5] language-ontology-scene s7: 56 model-annotated keeper
 scenes and Scene-conditioned ontology entries (ja-JP:10-14, en-US:10-13) at
 inventory rev 4

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/weksa/tests/original_corpus.rs |  40 ++++++++++++++++++++++++++
 data/ontology/ontology.cc             | Bin 6632 -> 11425 bytes
 data/original/speaker-state.cc        | Bin 1 -> 15341 bytes
 3 files changed, 40 insertions(+)

diff --git a/crates/weksa/tests/original_corpus.rs b/crates/weksa/tests/original_corpus.rs
index 8838554..f4bd887 100644
--- a/crates/weksa/tests/original_corpus.rs
+++ b/crates/weksa/tests/original_corpus.rs
@@ -977,3 +977,43 @@ fn every_original_passage_rests_on_a_live_inventory_concept() {
         assert!(hit.len() >= 12, "{lang}: {} distinct concepts", hit.len());
     }
 }
+
+/// The committed scenes: one per live Train or Validation group of
+/// `data/original`, none for any other group, every one model-annotated and
+/// never Test evidence (a Test group gets no scene and reads `NoScene`).
+#[test]
+fn committed_scenes_cover_original_groups() {
+    use std::collections::BTreeSet;
+    use weksa::speaker::Annotator;
+    use weksa::{CorpusStore, Split, SplitScheme, SpeakerStateStore};
+    let data = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/original");
+    let tmp = tempfile::tempdir().unwrap();
+    let state = tmp.path().join("speaker-state.cc");
+    std::fs::copy(data.join("speaker-state.cc"), &state).unwrap();
+    let scenes = SpeakerStateStore::open(&state).unwrap().all_scenes().unwrap();
+    let live: BTreeSet<String> = CorpusStore::open(&data.join("corpus.cc"))
+        .unwrap()
+        .all()
+        .unwrap()
+        .into_iter()
+        .filter(|i| matches!(SplitScheme::V1.live(i), Some(Split::Train | Split::Validation)))
+        .map(|i| i.group)
+        .collect();
+    assert_eq!(live.len(), 56);
+    let held: BTreeSet<String> = scenes.iter().map(|s| s.group.clone()).collect();
+    assert_eq!(held, live, "one scene per live Train or Validation group, none other");
+    assert_eq!(scenes.len(), 56, "each group holds revision 1 only");
+    for s in &scenes {
+        match &s.annotator {
+            Annotator::Model { family, generator } => {
+                assert_eq!(*family, ModelFamily::Anthropic, "{}", s.group);
+                assert_eq!(
+                    generator, "claude-sonnet-5-5 (Weksa Hands, model-annotated original scenes)",
+                    "{}",
+                    s.group
+                );
+            }
+            other => panic!("{} is {other:?}", s.group),
+        }
+    }
+}
diff --git a/data/ontology/ontology.cc b/data/ontology/ontology.cc
index 2f9cdf7af6d247d95ebed9420e16bc70bce0d5cb..de60651eee63b177ed211e20a5b8bd5ac5394d66 100644
GIT binary patch
literal 11425
zcmd5?Yi}IY8LmTG?)_G&SLrmOB?-HmIDr5QtrgKi3<;nb3KV)dJ9~C_vUAy<nX$8~
zT6s2*8wrWy&={$RQeqpYfpE)(CQT)1zf|I5rLNQuRVQ{5wNk(E1NyvY&dhEcC+rfl
zsuVe%nKLu%_kG^yectEn_&Y{m`35&CBIo(86uII4v4ii8h^ohPuH(CwTdx09IKHee
zc=E(TEAfm47dM~z#WD|XviZZ@7R&O>7P@&^Mz8syke=x}msy5)V5KeW0+ubyKmFrh
zjxG4kegF8}*A5(^za%f5?BhfEg+JPRYgVsWm+kM*_OE%Ye_ej{-TAfsKl)4G%@dRA
zuD-sR@0p(A2GSGzn!kETh#K=Nf_XI|j0)q1&rHY1e|g5)2$zoOl$q!Ay4QBhog$8;
z_<0~aKfS7tGi;>7eK9Pgdhm!Vi|QF}$rp~tT*<r&mo@yJ8$14}CAcS;VY&E8pQGry
zG8ay6a*M)hOqIB8TJ@Rrj$e^(%`|4p!V!`qz0G?Kiw8xK^<2jhe)f*+9c=j%lx(&E
zAJ5A$n;wxZN{;synJ4fgfx(IcZ?wm8^@8!97s$11^Zn}($bafU-mtV4$g!=5Jj?Yb
zhYWnY>5|}nAjM(*f4=|jLq6gZ{%+6<ryi;KfWl-!Snf!3VtuhFg-4;SnB|I)Swz|o
za2%f(0?8<vQW(Bf&ofVjFp0ZIiE^3B0UoI$Yq(fWFW?p;5Fn;C*D`&<Y%Z&S7o*Ji
zrf&&cR#_Z&%_1vsi8t9b3avRTyxe&6yZ5<)Rb+KHz#}}*ELe5s^Qyo{wOqH#xQ}$1
z9&#-lwW`90>7wo0sIh_OZ9}F664XOXpA~S;vY5nQ34oQ@AhSftXM#(sKG0k_2&my%
z`1C>&Sg?ZLY^&wGR+BCsPVego8sF&>8kDumVWXoW)7V(@RgH}smrg$*xs9NYca01S
zm1AA;t~LEFJRQ2<;^hynynJ=Md}_VF$@Tn?`t~&^hiZaX8PJ1l()%*3XaahU&)mSz
zmZcli+Aug``W5Dgz?a-&L>+)L;8+TfQ4iS`jzM@r!Qr}Q0c4Zzs;T<UFvn${#hr4D
zIvkZu>G@d)>`9E^m_}9ot_t4d()8;9;kVjA7!yT}qgrr}4~k(W*8*M!&U}B1K~T3v
zh5?ZZmL6(Q;nf*vE_<xPohkt;1KbgsgkgfA=!|3)Vbyw$sx{p(&fheuZfawk{Z~%;
ze1v>><>eY7)9d|>pkx1|CA*q4Er>WE8jT4sj%icq5>iqmVsI}&bpsOfi6j%}nNe;P
zK_!U>T)<TTltFBTBVk!)%|rT#m8d}wXUB+9Kmv<_wKSbM#F;gaB)B3s{-+J1o?&Il
z3xo`g2bW3$SQs&Z&pIDCejhjq^_^jx1GFn2ufoFI>4$kGqiCk;xFc-vRvRewS=ptB
zcG7_slV;X-1BkzBK-}ChAQoytyZ}<|2p1`HeB3<P>R4!C3pK0+8F|z`H-Vj2TT!_U
zoQf!xDZ6NOf|><#j`qV1L)3g;uvF$i9f~0|atIU}0Yy;~5_g&4nz$h<5S$tkSfiLh
zfP-qTMANAwqpp)X^%$ib>cVCtP&z)xHP8d34N!2uxg}<kf+#^X(lR_o_&q{FyP)fc
z6=Fg6=YMMqEa^*H&A#SO9+eav5^?C_46WVJOc~eTNCkv%_})EA8PFd}bV^HI2kl+8
zaysjQ7jb9BETU-X1c&VMq1HBmn5q98RpgH@^hm9>2dSe<NmTFSI!f2{O>Y!iOi+#{
z&Z!}EJ0sO<Gl^EyQmw^=PsSB8Z+%PK-8HYdW}5zbr;H@DvlcWSs1D=_4Odafv;y?n
zw0Ek)h|2{FT?ink=K}Hsilf%aq2e&TP^UzvtAH_qPUb3+B$+$n<i-wfLN({u!|q5&
z+;w&8xji4ZcfwprKE9&!u{6zxmd>9P-?oG_fA)h`I0I6QDU-Ctk;V=L5UN2bN5Rk%
zEQ(s-P%&VBAxaUXVsVYCf*D-OIx_+Ex1kvPTRqhePz2oSaZK;{G%@{r+hnJs+L}<3
zp(F+Rx)`_ZaoxB9#7rTIX;mvYrNK!!L03UV0fL+rO#dDgI0$XiM#wy2mGm5_l2Oc!
zHPc&^Ad96ujR6d59xQM7IHv2miRqU#PQTDqOz)f*(`#7sp$!;em?5N3<xis7Lgy(8
z1WwOdF;Sq%Ra?Xi1l%fc;#4x*LCKaeEuR_mV^LG$rj=s^QWCuS={=6;o!!LqULDVC
zyNajgR+^jDobzF`GzfO2NtjEBP8(xw9dgei9Zz+P0*87i1j>_uN>#nf@F7kCI#DzY
zlCGYs&L@v3x@dAF{2&@Ej<!bx&|LX|!~{Xpii?LxWX$6A9D9%iB-tAzBpg@@qS)iG
z-_=dnZ`5JGu4B4gfEFHF4>_%5dY%j+l)D3=WUEoHjHxl{b?tgy0hmMsBzv0x%#EE?
zT3s0la0M`IK)JhBULWX0a4%ldy1SbwenUs``c!ItQq#J99uX{gviZzVAZya}1SmlA
zveLa6S1~-x&2e<&s!vNEL@Ty{CNOTH-(%L5wg(#})u?LvCZod>xv}@3;3m*Y$Q)o#
z!8s|y)u9==XK~%kvkyMnoh3OiF{$pl*pfU1A+H>TY{`U;1&Jzs(|}>6`!o09U%~jx
zqyEU%t0Hb?DbyrE;~aye1>It#taAKb^@u3Jl6We*yC=}-!K|?@rshaxfW+-Ac^9j~
z7KOitwTL%30R=B$X8`JIb#DLBD112zw?*M^qwtMrwDC@IJROBE#iu@dM8_tkj(k@p
z<}n@m8&ad{(^{CxKnSZ6){%tK;*pmOr%>kAm;rybD$Ft*A0QebG~@Y14gFQ&Y<Be}
zs8}_)s0&IwXKnZjtFjnE0%VV7eUB}V!e^t#&M15>3J*q&t#lZkLCiC3c5fqU?23<8
zz&u(x``nIm2VRN7qjM84%pIJ(+?~i?^OkedVHEB@|L*p=U%wPJ_DA8ax!pMPD!oNL
zAFJ@1UFUZnSC{ctJQ>N~lV0v5--}`y=!AFUO!oa<C;b20nf$m}9fCN|YELrtBFR5g
z`x450%EQ7zqX(uk+G8MytRl1|I8laU#dTb1mP{j_rbxP00vpmZCR0G<mb0gJDP$a-
zJv1}-7E--i0Seh|)p7Hia}%ed@Bn}mHO7(s3$G#d@9VsW&jT4JFHAp2m&0*_48c>~
zKHBItCOUEulAVl6jftC568MZ=#na7ggO@mo=~hQ#7*VHV%Zq#!^qShr0BzH`6&EKJ
z1P>lhGk*`-1G$iG{bG64*pXo%WBM^cWYHL30b9w>jUQ_z{wRta`6d#7H_dXA;#UUF
z#N=`I<mkB*So!<&uL2@S^ENyjxAZ!}9l0M#g6DLCZ(cgj{pfb1>dG$Re6#t3=5}pF
zwJOkx-4~?`b;hCM14*;^ZFAETt75XI8dcj<NUqvJRE9DwqAO9@h{D5Q-q^qb9j`*h
zNZOaoEf5H;4nwmlCMGn2a|hl!d-9D7TVKEM;)y7H6YJ-m-FtrOdDQXQ(|<_Y2hscN
z+iznvK1?(U>fd#K&xvz8XVOw`uEV+6eS2ni?ui>jaywXKDr%tj?1&oZ1~^RVgSesB
z2<ga=Nf7cMjgT*<2<d*qs&gN?&1~onQ6Dz9sqF~puT*5jTgK_m#DX+}S&*#d1V7no
z;H=6T*bPcHx3CKlvqsyHqA(hpad0XeH^9~^b~oU57jxrhW)B^{u=NFn5cGoG=XP#C
zduk#I#|Q*UB7pyiXrl1-ghYVY7YP)jjZ=vdIXZU`$l5#ia;!>v#3Zq87t4o^Iz?jJ
zEzvM(H=Bnau`$8XgzW_d8evr2-1yhjO15Y~#Fjnc>|nw+U{Wd-XvZatlVVHFG7UUR
z2Rrtnsg&b^5(77W7j~_}u|1R<J4VHeU{jSLvQUGaMsG33$2fQ$v2YT+cXaUJLF-N7
zZawJJU3<_Ubl^c7*l?@SK8&8X$Zlo@WlSR#6%!^O4W7%fNxOnlV7S=OhH1Jyi+Kp&
zsgT$zD<Xl)s?M;i#OS3?n+A3ck_#)yq2j|ZtY~YeZI2<I5n!^C@Rve6398U&^2+T$
zGW$HrW-n!Vv~lF@No0LDDy~CHUA$y>M5sx!zpRseRR;Idmo>OQ$<Wr{5J9$z_`Zy)
z&WopL)X!W4WrMInuB!S`(x;OywRj=z%HO_IhxDrbZCm@>=@)5;yyC$!HesvWcCovH
z-9>H^;_EI1CXcOwcpc!{<{aSr2WSiN78z~v(2fi}lWa)1wHLzY2(JwQ7jgsA1p_O@
zqY8Rwx?u4l-j)0PZ5{EecE2~ycfa{1{`W-*NL_H^862ehyHJC<{U=FyQv{FBzP3yK
zLW4i};Mn{N2zjpq+?5^vbsgYquf~@hZ1ZI)P?&5k_RHXpQ5@?Sla-$WWb-n2IL2$P
zHW2k!^T_U2UIscU#-#1a*E+5w4m_^6F!ZQ43k>(Z({^QdKc&NZUE40h!o9Y&f2)U=
zOQdNx8<J+i*VIjUkz7T16xi@pUphz|Ea;&GS2Fp=Wt=Vu9r%lszxb<Bmu^^6mauE-
zaTB|0fO@;{82)Q?3jcb`-d&mJ*Xx{Im3cncGS8ta+D-HLTOt{vU5NVDhMA^yFQD(V
mD#sUmUgg+;h{7G@9*%}{zd17dN9c6$@tglW{mN$^!~X$m)*Sl)

delta 30
mcmZ1&`NDX@6GowpPdynYAK>HJe3;9CXL5oP&t`qaB5nZ4dkaSZ

diff --git a/data/original/speaker-state.cc b/data/original/speaker-state.cc
index 9e99dd5ec98fdb081b58e76344a05122e25dcb94..91aa9e5c5401550315af2f94e068e1094cd60d0b 100644
GIT binary patch
literal 15341
zcmds;O>f*p7{}R^53<?=0x6ENn>M0*Di=UVz=byzQE7HP*`3&)i9GhMR)|9+PMn&i
zGGBmzptL}nQeK5rdZYr%YZ0G;6DLm0csJYG$F@Al$gaJ&#NNMU|MWcn=b7>2{p<bE
z4f?1*#A`fYK3*HO_ujoS#tuhoypJhX|GuUi7e7=_-GA=Q78h6X&<n`Jt!_*CX=`<M
z>J{vB!sy~zaUt;o4|_dvw$*+8jkosH3t#;EktZ*I9^Xor`D8#SaxFwh#67og1BadU
z&ZgCFTkXzE?al7SMtA-6`8z*H*A_*MNB6E`8jxVpbuiw+{@(uL{~x?esdxf=|I$ZW
z7zLq^yX~{P@4vVch&w+(JvPD*&UDsy51#Rnjqk3!qa1DTzW20?2H)=<JkM<GUi$DU
z8Vr55L;Cm6^<5O&*y4;*99U<pGtI|em9(4BB5L#1rY9BR0VxYmfbHhd?Kfit{E5ql
zkOd#+lGr$Z=f~*dqf1$c4-GlEcqE={PUr!L#=pwZ8Hd}2aJUIL^bmD&L5Ps}DY`lb
zAvN_U0kflrIH5Wy)a-~wg|WC;R#YTdVAq`-n}rk=#^T{+2pi{{rm%{I3=x|8lSo8`
zkCA=ssE{H<7Cr2;v62h(`q8+c94*v0zW~13Cp^HumS6l5eLA<!naq$!1?z~-n6DEW
zYL-Y%{Yk(q*&^7@&k|u6Y8{D1OUS}!JkSY?1r}0d$RfMreC%O4#t`{E7HTDl>KHSb
zA&+dwD6PkUo#&9a$F8eVQy7WTI*ePOmTV)ja>2Q2A}r%x^vS%GOjSkEIMqz%Nii$4
zG#VV8ga${3G_qZzv~}uN$=I+F=?{qxkl&)~YIsbAhD@@ZqqKa1y_bmmt<YyWL{ul8
z$qad9_oBCx8B@#}9(Ek!!3J71)G8Z`3|UklHoi&bi_DfDvNm<%<B#Z2&6p!;{keRZ
z<l>;7#s-I|GQUQjsZe5_A(8B?SuHDT(uiQ<XeACLB6WsDDv&!VzUqa(R;2;HDrNQO
zk<y7UC)BYK(3c6-a?+Tbq%UI=)4r?%xsp<I^*RtxbNwaojT9&4h-_(P3UJa`SN~i|
z>DoDR5Y<W-(6vv6hD<V7GN;~7*4tv%b>AgB5I!WHa08oJ9UWKwE4rojA&R;vIxGK_
zMd#}@I&7Qhk@-Eku}CIX8d9l%%cgWBob|L?G|-Vq*>ds-J*^Jyp7Pc~to68%8S=>L
z;eYrqnKZ>Ld{YWffKJxJ$2vnG6-bzr!V@5eS*LaU6%?MS(2z-H;c1k%J@ReRTIHjO
z@}Xz0e?~V|bDe7q$y6X(QtUNAq1MhbuvaOoKaVs&k#VAvJfM*cq^|x%QreP`+RQ;(
zOh8*QQ`VnKipx&K8=Dik>{M8PCMl6J5fgHn8zvx9X3FKH5~2ap+f{>9rpo$LN!g^I
zgboqDqE&mqCjF7L{#@Wt>Ne6E4^W3vg{1x*;AntD-2BNZFmfj~^(O(hpj~9!I6o-B
zXuwouNF!^xcehd6D;wCax`=8G-3c6OzdDl{^2l7-th|<7{}!{Q2J^&a%**Xn!SJ@!
z7?P;KN(OGnd&t)q=m(!R#G>V6;ggYuWdIhjsQxTqhWLzW%^#{`sZwJ|BHKGl8@GeK
z1$VRt`qkb-NDMhtz$suw<vTv1gIw1H6?LkrKMm-c;_Eey$wS~3v8etmpjQM#G|r6+
zP)(&~2}uw;e_;km2#q0$><+86@k<yJWARPXabrSi3`tbLHxncX&Ht(a#Kc%=YER;S
DbfvdS

literal 1
IcmbOL005BykpKVy

-- 
2.47.3


From 71b9d0e0559a5ebd7aae99cf5a295e2443305c08 Mon Sep 17 00:00:00 2001
From: Weksa <weksa@minds.weksa.gamecult.org>
Date: Thu, 12 Nov 2026 16:48:52 +0000
Subject: [PATCH 4/5] language-ontology-scene fix: default bed carries rev 3-4,
 scene entries never co-select in a layer, en-US:8 names no register, keeper
 rank re-derived from situation, README and doc true

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                             |   9 ++-
 crates/weksa/src/inventory.rs         |   2 +-
 crates/weksa/tests/original_corpus.rs | 104 +++++++++++++++++++++++---
 crates/weksa/tests/stores.rs          |   5 +-
 data/interlingua/inventory.cc         | Bin 7967 -> 11369 bytes
 data/ontology/ontology.cc             | Bin 11425 -> 11501 bytes
 data/original/speaker-state.cc        | Bin 15341 -> 19417 bytes
 7 files changed, 104 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index bfa07f2..34f83c0 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,8 @@ culture, and constraint, and the planned lowerer that turns an agent's
 meaning packet into the reader's display language.
 
 **What is valuable here.** The interlingua standard and the lowering design: a
-meaning packet owns what is meant, speaker and scene state (planned; not yet live) own register,
+meaning packet owns what is meant, the scene state (live: `weksa scene put|dump`; speaker
+documents are planned) owns the speaker's relation to the addressee, which selects register,
 address and politeness, and a lowerer owns surface text and leaves a trace.
 
 **The problem it solves.** An agent's outward speech today is one English
@@ -84,9 +85,9 @@ target-specific English receipt.
 
 The language ontology is `data/ontology/ontology.cc` (read it with
 `weksa ontology dump`): per language, the lexicon, grammar and discourse choices a lowerer
-reads for a stance and discourse packet. No entry fixes an address or politeness level; those
-belong to the speaker and scene state. Its en-US and ja-JP entries are
-model-drafted seeds, never Test evidence. Nothing yet grows them from accepted
+reads for a stance, a discourse and a scene relation. Only an entry with a Scene condition names an
+address or politeness level; the relation, from `data/original/speaker-state.cc`, picks it. Its
+en-US and ja-JP entries and the keeper scenes are model-drafted or model-annotated, never Test evidence. Nothing yet grows them from accepted
 rounds; until that mint exists they change only by a new `weksa ontology admit`.
 
 For the first AquaSynth speech-training handoff, see
diff --git a/crates/weksa/src/inventory.rs b/crates/weksa/src/inventory.rs
index 3ffd5ad..4820ea5 100644
--- a/crates/weksa/src/inventory.rs
+++ b/crates/weksa/src/inventory.rs
@@ -541,7 +541,7 @@ pub fn proof_revision() -> (InventoryRevision, Vec<InventoryEntry>) {
     )
 }
 
-/// Revision 3: the speaker-state vocabulary. First the Scene features, the
+/// Revision `n`: the speaker-state vocabulary. First the Scene features, the
 /// speaker's relation to one party of a scene (slot `Scene`): `relative_status`
 /// is the speaker's standing against the addressee's, not a register word, what
 /// it selects is each language's ontology's business. Then the Speaker features
diff --git a/crates/weksa/tests/original_corpus.rs b/crates/weksa/tests/original_corpus.rs
index f4bd887..515e855 100644
--- a/crates/weksa/tests/original_corpus.rs
+++ b/crates/weksa/tests/original_corpus.rs
@@ -282,6 +282,7 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
                     [
                         "claude-sonnet-5-5 (Weksa Hands, model-drafted seed ontology)",
                         "claude-sonnet-5-5 (Weksa Hands, model-drafted scene ontology)",
+                        "claude-sonnet-5-5 (Weksa Hands, reworded seed entry)",
                     ]
                     .contains(&generator.as_str()),
                     "{}",
@@ -313,16 +314,27 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
             "{lang} has no Stance-conditioned entry"
         );
     }
-    for (corpus, panel) in [("original", &PANEL[..]), ("daodejing", &PANEL[..1])] {
+    // Every committed inventory bed, the default one included, carries the
+    // revisions the entries bind to: a run opens over each with its panel.
+    // The default bed (data/interlingua) is read with the original corpus,
+    // entities and scenes, as `loop open` with its defaults and `--corpus
+    // data/original` does.
+    for (corpus, bed, panel) in [
+        ("original", "original", &PANEL[..]),
+        ("daodejing", "daodejing", &PANEL[..1]),
+        ("original", "interlingua", &PANEL[..]),
+    ] {
         let dir = data.join(corpus);
-        let copy = |f: &str| {
-            std::fs::copy(dir.join(f), tmp.path().join(format!("{corpus}-{f}"))).unwrap();
-            tmp.path().join(format!("{corpus}-{f}"))
+        let name = format!("{corpus}-{bed}");
+        let copy = |from: &Path, f: &str| {
+            let to = tmp.path().join(format!("{name}-{f}"));
+            std::fs::copy(from.join(f), &to).unwrap();
+            to
         };
-        let (c, i, e) = (copy("corpus.cc"), copy("inventory.cc"), copy("entity.cc"));
-        let s = copy("speaker-state.cc");
+        let (c, i, e) = (copy(&dir, "corpus.cc"), copy(&data.join(bed), "inventory.cc"), copy(&dir, "entity.cc"));
+        let s = copy(&dir, "speaker-state.cc");
         RunStores::create(
-            &tmp.path().join(format!("run-{corpus}")),
+            &tmp.path().join(format!("run-{name}")),
             corpus,
             RunPaths {
                 corpus: &c,
@@ -337,7 +349,7 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
             ModelFamily::Unrecorded,
             &panel.iter().map(|l| l.to_string()).collect::<Vec<_>>(),
         )
-        .unwrap_or_else(|e| panic!("{corpus}: {e:?}"));
+        .unwrap_or_else(|e| panic!("{name}: {e:?}"));
     }
 }
 
@@ -1001,8 +1013,9 @@ fn committed_scenes_cover_original_groups() {
         .collect();
     assert_eq!(live.len(), 56);
     let held: BTreeSet<String> = scenes.iter().map(|s| s.group.clone()).collect();
-    assert_eq!(held, live, "one scene per live Train or Validation group, none other");
-    assert_eq!(scenes.len(), 56, "each group holds revision 1 only");
+    assert_eq!(held, live, "a scene for each live Train or Validation group, none other");
+    // Revisions append: a group's later revisions re-derived its relation.
+    assert!(scenes.iter().all(|s| s.n <= 2));
     for s in &scenes {
         match &s.annotator {
             Annotator::Model { family, generator } => {
@@ -1017,3 +1030,74 @@ fn committed_scenes_cover_original_groups() {
         }
     }
 }
+
+/// The committed ontology's Scene-conditioned entries, over every scene relation
+/// (relative_status x in_group x intimacy in steps of 50): an entry that names
+/// a register or politeness level has a Scene condition, and two Scene-conditioned
+/// entries of one language and layer are never selected by the same relation, so
+/// the ontology never gives opposing instructions for one relation.
+#[test]
+fn scene_entries_never_co_select_in_a_layer_and_levels_hang_on_the_scene() {
+    use weksa::inventory::Slot;
+    use weksa::ontology::{Condition, Test};
+    use weksa::packet::FeatValue;
+    use weksa::OntologyStore;
+    let data = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data");
+    let tmp = tempfile::tempdir().unwrap();
+    let onto = tmp.path().join("ontology.cc");
+    std::fs::copy(data.join("ontology/ontology.cc"), &onto).unwrap();
+    let inv = InventoryStore::open(&data.join("original/inventory.cc")).unwrap().inventory().unwrap();
+    let id = |gloss: &str| inv.entries().find(|e| e.gloss == gloss).unwrap().id;
+    let (status, intimacy, in_group) = (id("relative_status"), id("intimacy"), id("in_group"));
+    let entries = OntologyStore::open(&onto).unwrap().all().unwrap();
+    // Terms that name a register or politeness level.
+    let levels = [
+        "teineigo", "sonkeigo", "kenjogo", "desu/masu", "honorific", "register",
+        "politeness", "polite", "formal", "informal", "casual",
+    ];
+    for e in &entries {
+        let lower = e.choice.to_lowercase();
+        if levels.iter().any(|t| lower.contains(t)) {
+            // The seed entries that say they set no level carry "no politeness" or
+            // follow the rest of the line; every other naming is Scene-conditioned.
+            let disclaimed = lower.contains("sets no politeness")
+                || lower.contains("politeness follows the rest")
+                || lower.contains("politeness follows")
+                || lower.contains("own register allows");
+            assert!(
+                disclaimed || e.when.iter().any(|c: &Condition| c.slot == Slot::Scene),
+                "{} names a level without a Scene condition",
+                e.key()
+            );
+        }
+    }
+    let holds = |c: &Condition, rel: (&str, u16, bool)| match (c.feature, &c.test) {
+        (f, Test::Is(FeatValue::Option(l))) if f == status => l.as_str() == rel.0,
+        (f, Test::AtLeast(g)) if f == intimacy => rel.1 >= g.get(),
+        (f, Test::AtMost(g)) if f == intimacy => rel.1 <= g.get(),
+        (f, Test::Is(FeatValue::Flag(b))) if f == in_group => *b == rel.2,
+        _ => panic!("a Scene condition this test does not model"),
+    };
+    let selects = |e: &weksa::OntologyEntry, rel| {
+        e.when.iter().all(|c| c.slot != Slot::Scene || holds(c, rel))
+            && e.when.iter().all(|c| c.slot == Slot::Scene)
+    };
+    for st in ["below", "level", "above"] {
+        for ig in [false, true] {
+            for it in (0..=1000).step_by(50) {
+                let rel = (st, it, ig);
+                let mut seen = std::collections::BTreeSet::new();
+                for e in entries.iter().filter(|e| e.when.iter().any(|c| c.slot == Slot::Scene)) {
+                    if selects(e, rel) {
+                        assert!(
+                            seen.insert((e.language.clone(), e.layer.name())),
+                            "{} co-selects with another {} entry at {rel:?}",
+                            e.key(),
+                            e.layer.name()
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/weksa/tests/stores.rs b/crates/weksa/tests/stores.rs
index 5b26e85..386178e 100644
--- a/crates/weksa/tests/stores.rs
+++ b/crates/weksa/tests/stores.rs
@@ -1584,7 +1584,8 @@ fn seed_reseeded() {
         .unwrap();
     assert_eq!(items.len(), 3);
     // The committed inventory is the seed, reseeded (stance features in, the
-    // displayed-affect features out), then the nibu-proof revision.
+    // displayed-affect features out), the nibu-proof revision, the Dao revision
+    // and the speaker-scene revision: the same four as the other beds.
     let committed = InventoryStore::open(&root.join("data/interlingua/inventory.cc"))
         .unwrap()
         .inventory()
@@ -1593,6 +1594,8 @@ fn seed_reseeded() {
     let (proof, proof_entries) = weksa::inventory::proof_revision();
     assert!(committed.has_revision(rev.n) && committed.has_revision(proof.n));
     entries.extend(proof_entries);
+    entries.extend(weksa::daodejing::revision().1);
+    entries.extend(weksa::inventory::speaker_scene_revision(4).1);
     let mut have: Vec<_> = committed.entries().cloned().collect();
     let mut want = entries;
     have.sort_by_key(|e| e.id);
diff --git a/data/interlingua/inventory.cc b/data/interlingua/inventory.cc
index cf353dbe05112cf2edefb596b06a4e009e41515c..7018ee525bd4b3e946aa0ac75375195ff4be4521 100644
GIT binary patch
delta 2566
zcmaJ?U2hvz5XG^hBqXJxYD*JT#W6@lB@plR`fCvtc>y6oc_>H~LRww#PV9yCuC=?i
zo2MxMfa<z_<U{q=sf(yXB!q;7N>%;=j|i1FD*gm_KYi~t;l<Ld_nbL1b7uDIYtL>@
zf6uIaKDe*hmIfV9k;u1;+hlEFV|fxkB2uofBcYF_iXxYla_!S67lz4yic}o+4byz|
zW%kiv_AnsXJRKvA8ny)j1_hWmxI7n`JjjQ3$J^&XWOuQ!%^_H2rO}?KjC{3NkT}3g
zObYp4AMh7oaXA#J90-#+)XNO2JaIh-tftqRLz3f_e31jP=_>bHfP3?xt+N7%Z9~-u
z?079fVl9yP7ME#@kyx7=u4>v=Qw2-!I)>F0@bv&+<M5jdzWzP6f@fG=h-gA|>X=|~
z+vKx__0`k>s2C8w%@MvbBSgg?T1K-4uBXB+4NMcL_jpMtv=HAsrVmK+``80V0EHep
zbyNsVJf{n4-*$9YK$7D#d4<!<G!T`hE<juDU<d2=EknbC;Su>}G5<aX-(kv?e{nll
z1GNEOAHY(hxvSXH)&H0#3Ju5G^b*5X9ye&q?EZWSEBVt=m9b{GX#rxN$(-HRnOxN)
z2V7`3%m|juoJ`NWdGcUkIkS}9i2T{Dt6cr(hsn!Ib>!kEM?jvg7x-0YUayVXhNbf!
z3k_P}5?q)isQW=jg4=L1&HkJvPjk;_Ld10ru{)gX0rt8MC{q2Q119#29;mKIpSg$Q
zk2;=VTP_L6?7nY84@@67>>k|qZ)jjaju=aat0_lh@@rg*S7#|u@yMV{)5hAq{~q;C
z%0driA|rD7+@8$-rW9(^vAdnoyC!ZXI#`C#@*i>{WJUz~(X}<h20ACZZD>KUmQD{q
zENOhB6P!FJ$5IBn@D9g#g<&k+2feG&*4ftolF*H4a3r5FB=UqhLe=b+?RaVD@Az8F
zF!c%DF%w+caqq#t-KAFx>s{0HqhBy}aBio%PySxIo+E#*E(II-8kg_I;dsx%ZBXR9
zSo1<Z#Sg*-<3CRu$;;*M=+qo+xkg|P21R~-Ve54+!NmkqIWi6U-2gXQ$tVk<E5V<l
z&E);+ad1xDxqA`=|5_Jz>2d<BJ#6EBdPZpH!d(uw<V0Tk=iKtZcc7<~ej=AMm&gYj
zD+jF7-!gXw*@Zuz+c><ttLwA9<ii>t*26G8=~7XMB_T#!e4t1r?tvo7LR=Q&iV#<Y
zIMO#0BnU*DzynV~f<nYARFEJL2?CKI5D5ZNBrq{qs5UX!;ZD%$IErv_z=3Lyqq)iH
m++22UPhgPC4x=_CH$jTaPU58OG>)rI<GAWHj;l^%`SHKUq|j{u

delta 99
zcmaDEG2d>(6-FM9DJzrn^O92wN~{bg7pmw@=3|mzhYC$Tr=&mm4hOfG(ei?#)UwpP
tk^>W%4!|``o+zQWxsQW`adS1-4(7>g`RXVC6XM+LDd^0ySzP?35CFC2CVv0`

diff --git a/data/ontology/ontology.cc b/data/ontology/ontology.cc
index de60651eee63b177ed211e20a5b8bd5ac5394d66..b4a032b09c4c58e54f0aa6327e44508aee8fd6ee 100644
GIT binary patch
delta 494
zcmZ1&`8INcI3ufxxs`$GW*J5oMp-a3>L?TcjHRi0x}m{bEGu0yi<9$9i;7bxO*WJ?
zoE$D|x_JxJ37D=%mOv(`0oU1hpv=WDIADTrxfEbZg?PFd1)vr%N<uA|+^1r@`4ula
zOwl(!e;CtCz#GP#C0GR0dgK>WC&%P|70t=_G=%kB9n;cMlS?x5^Q;sS70MHfaurJQ
z^HLScGfOfQiu2P-Qu9(%6bdqm5{onQ(kJ%{ONwm`Nz6`Fs08{;p(HamRYxH|JF(J!
z@<cHeMw7`O85M+zQp@v;Qh?fuQ-MTkUP;kpIS~`6Ps2rmVJ=%QTE-{{^VE|WOS2Mn
zy#lx<TT81?_LCF=hgP}xe3)u!Nq$(s=u6*$i3-Td!bFYam0-+BMGKgMX-Y3(%w`oo
e81tHHE{y4+9s^^p)ChtyH)-|51gB{8G6Db|sF6Pa

delta 519
zcmaDGxiE5rI3ufprIoSaW*J5oMp<KHD?_uWql^z`EKSYR4GrdES?Q8loSa`;RGd0-
z@<eIb$^EjDn;$WqWMl;^-MoP%kO|6UW9NY~7mIT;!A#{=fLY+k(+y)@<n@O!Rr%q}
zN&#<}=t;pMMnSN<fR5pYI)-C1qoz%~w_{pbYH~?tex8*=d16tnLS|lCeo<~>jzUpt
zdS-D+YLP;DW=V!Za(-S(Q6gAju|i^Aib8s7UP(@>LS}A3YEfcIW?5>n-ozaqsg*hk
zC5hQU@e+m9#Nx`ycZIblE2z6n77%8e>?NWK^+$<FFwAXdM9UbZVF9&u#?q`rU9SKx
zmgVk6iMhFnMTlTJB)$L^OzD#Ruwbf|z5^4Dk(Gss*2ycuf^4ax1<a~PN-to{^D2If
x0<aJ<huS*XfZuU*o|+;etkj?~Y?BT7bvK_?SBB~Tsu2WZ`e^mTm=Cmh838?en+E^@

diff --git a/data/original/speaker-state.cc b/data/original/speaker-state.cc
index 91aa9e5c5401550315af2f94e068e1094cd60d0b..c4f563d1a4d37b3448236825ecbb96c147a60095 100644
GIT binary patch
delta 902
zcmaD`esenGgr$t`8<+7iPOcXcU{A~|%gk{wntYK-TGGVA%D_14$i->v@{2OlGxHL2
zbivY0lMfo$O*UYZn#^w?Jh{L;Y_f-rz~;k@25ev>l8RCjQ*avrmWCKnz%DgeOek}5
zzM#NnW)3A5u=cc~{NfVa+QHHw?FT{H7Mt=gf@sc+#G<79(jtgHX{gIDPul=@IaC3v
z#R0kkn_YRum?zuwiLewWLUc<(bzhpc9<DnpQ8%$T5!2%z)P*<a2?#O)-5|jT4mE6c
z19hjB7Ud&r&)i%u<i*UEn3S0Zu~i0Y>y>F6k!{TeseoyeoGdDoHTl1k@a7YuvFww9
zmU9#*W+&!B9WDzs;_9?b$VNbvz|CM{4w@`rkg-`+R*rG9s;oT3*-B8ox2A1J(VLN(
zn_rojlCNt7GXNCpnUim+32zRQQ(^{sT$ru6G&d9C3nmkb$^G)8EI<K>dQcSq*UJPu
zx?5403FPR>bCuX3w&HMcNn&=st_jRS$;k>zS)1o6pW+5alK@9fVoFLXG@`-Q>4`HU
z>^j2(PELy}^dadYCo!)iwFnx<Am#J)C7{Yd33v~;@Z|F{VUs}#p~FCi1;k)0%Fl-;
zKnZB5T$r{N9x5PNgnb*hGQp{Ti-{TQ<Ode45PxCQSCW~M3iA>y=cH|ZWy#D00M-aM
Ag#Z8m

delta 115
zcmcaPo$+n?gr$rY8<+7iZr;!2z&6>yMqslvml6wzu{e^SadLp2z~)LpG3Lnzy26_`
zhzc@I{?8$>`Jsdr^JZPy81~I`Rpl5b?=unJ{6<}gd9$338q?+o{ZrhVf%+LY2iWPb
TOy18Vuz8xZ8SCb2p3F=Dv$G|E

-- 
2.47.3


From 139fa94b29328bfd23f04d61993ac72944127a82 Mon Sep 17 00:00:00 2001
From: Weksa <weksa@minds.weksa.gamecult.org>
Date: Thu, 12 Nov 2026 17:11:57 +0000
Subject: [PATCH 5/5] language-ontology-scene r2: a run reads entries and
 scenes at its own head, default bed is seed+proof+scene rev 3 (no Dao),
 politeness keyword guard replaced by model readings, nine seed entries
 reworded

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/weksa/src/ontology.rs                  |   4 +-
 crates/weksa/src/run.rs                       |  43 ++++-------
 crates/weksa/src/speaker.rs                   |   2 +
 crates/weksa/src/store.rs                     |  17 +++--
 crates/weksa/tests/golf_loop.rs               |  67 ++++++++++++++++
 crates/weksa/tests/original_corpus.rs         |  72 ++++++++++--------
 crates/weksa/tests/stores.rs                  |   9 ++-
 data/interlingua/inventory.cc                 | Bin 11369 -> 8777 bytes
 data/ontology/ontology.cc                     | Bin 11501 -> 12262 bytes
 docs/targets/interlingua-lowering-map.md      |   6 +-
 .../cultnet/weksa.ontology_entry.schema.json  |   2 +-
 schemas/cultnet/weksa.scene.schema.json       |   1 +
 12 files changed, 146 insertions(+), 77 deletions(-)

diff --git a/crates/weksa/src/ontology.rs b/crates/weksa/src/ontology.rs
index b1cc384..5919588 100644
--- a/crates/weksa/src/ontology.rs
+++ b/crates/weksa/src/ontology.rs
@@ -100,7 +100,9 @@ pub struct OntologyEntry {
     /// The entry's number within its language, from 1.
     #[cultcache(key = 1)]
     pub n: u32,
-    /// The inventory revision the conditions read against.
+    /// The revision, of the inventory the entry was admitted through, at which the
+    /// store read its conditions: provenance only; a run reads the conditions'
+    /// features at its own head.
     #[cultcache(key = 2)]
     pub inventory_rev: u32,
     #[cultcache(key = 3)]
diff --git a/crates/weksa/src/run.rs b/crates/weksa/src/run.rs
index 8b49f8e..3d0da2a 100644
--- a/crates/weksa/src/run.rs
+++ b/crates/weksa/src/run.rs
@@ -43,7 +43,6 @@ use crate::corpus::{CorpusItem, CorpusItemId, ModelFamily, Source};
 use crate::encode::{EditDraft, LoweringDraft, PacketDraft, encoder_id};
 use crate::form::{is_attestation, is_language_tag, is_slug};
 use crate::model::{ModelPort, PortError};
-use crate::ontology::OntologyEntry;
 use crate::packet::{Packet, Stance};
 use crate::score::{CHRF_VERSION, chrf, Embedder, ItemScore, ScoreInput, Scorer, SplitMean, aggregate};
 use crate::split::{Split, SplitScheme, fnv1a64, fnv1a64_of, hex16};
@@ -807,46 +806,34 @@ impl RunStores {
     }
 
     /// Every ontology entry of a panel language reads against the run's head
-    /// inventory at its own revision: the check the store applied at admission,
-    /// applied again to this inventory.
+    /// inventory: every condition's feature is live at the head in the
+    /// condition's slot and fits its test. An entry's `inventory_rev` names a
+    /// revision of the inventory it was admitted through, and beds number
+    /// revisions independently, so a run never reads it.
     fn check_ontology(&self) -> Result<(), RunError> {
         let inventory = self.inventory.inventory().map_err(|_| RunError::Store)?;
         let entries = self.ontology.all().map_err(|_| RunError::Store)?;
-        let head = inventory.latest().map(|r| r.n);
         entries
             .iter()
             .filter(|e| self.record.panel.contains(&e.language))
             .try_for_each(|e| {
-                // At its own revision, and again at the head: an entry on a
-                // feature the head retired could never select.
-                let at_head = OntologyEntry {
-                    inventory_rev: head.ok_or(RunError::Ontology)?,
-                    ..e.clone()
-                };
-                check_ontology_entry(e, &inventory)
-                    .and_then(|()| check_ontology_entry(&at_head, &inventory))
-                    .map_err(|_| RunError::Ontology)
+                let head = inventory.latest().map(|r| r.n).ok_or(RunError::Ontology)?;
+                check_ontology_entry(e, &inventory, head).map_err(|_| RunError::Ontology)
             })
     }
 
-    /// Every scene's relation features read against the run's inventory at the
-    /// scene's own revision, and again at the head: the checks `put_scene`
-    /// applied, applied again to this inventory.
+    /// Every scene's relation features read against the run's head inventory
+    /// in slot `Scene`, as [`check_ontology`](Self::check_ontology) reads
+    /// entries: the scene's `inventory_rev` is admission provenance a run never reads.
     fn check_scenes(&self) -> Result<(), RunError> {
         let inventory = self.inventory.inventory().map_err(|_| RunError::Store)?;
         let scenes = self.speaker_state.all_scenes().map_err(|_| RunError::Store)?;
-        for scene in &scenes {
-            let head = inventory.latest().map(|r| r.n).ok_or(RunError::SpeakerState)?;
-            for r in &scene.relations {
-                for rev in [scene.inventory_rev, head] {
-                    if !feature_refusals(&inventory, rev, &r.features, Slot::Scene).is_empty() {
-                        return Err(RunError::SpeakerState);
-                    }
-                }
-            }
-            if scene.relations.is_empty()
-                && !(inventory.has_revision(scene.inventory_rev) && inventory.has_revision(head))
-            {
+        if scenes.is_empty() {
+            return Ok(());
+        }
+        let head = inventory.latest().map(|r| r.n).ok_or(RunError::SpeakerState)?;
+        for r in scenes.iter().flat_map(|s| &s.relations) {
+            if !feature_refusals(&inventory, head, &r.features, Slot::Scene).is_empty() {
                 return Err(RunError::SpeakerState);
             }
         }
diff --git a/crates/weksa/src/speaker.rs b/crates/weksa/src/speaker.rs
index c2e0e58..0f44d13 100644
--- a/crates/weksa/src/speaker.rs
+++ b/crates/weksa/src/speaker.rs
@@ -71,6 +71,8 @@ pub struct Scene {
     /// The revision, from 1.
     #[cultcache(key = 1)]
     pub n: u32,
+    /// The revision, of the inventory the scene was admitted through, at which
+    /// `put_scene` read its features: provenance only; a run never reads it.
     #[cultcache(key = 2)]
     pub inventory_rev: u32,
     #[cultcache(key = 3)]
diff --git a/crates/weksa/src/store.rs b/crates/weksa/src/store.rs
index cff3086..7408dce 100644
--- a/crates/weksa/src/store.rs
+++ b/crates/weksa/src/store.rs
@@ -1273,7 +1273,7 @@ impl OntologyStore {
                 return Err(malformed(&key, "a language holds at most 64 entries"));
             }
             counted.insert(e.language.as_str(), e.n);
-            check_ontology_entry(e, &inv)?;
+            check_ontology_entry(e, &inv, e.inventory_rev)?;
         }
         let mut staged = Vec::new();
         for e in &batch {
@@ -1286,13 +1286,14 @@ impl OntologyStore {
 
 /// The rules of one ontology entry against an inventory: the annotator, the
 /// bounded and normalized text of the choice and examples, the condition count
-/// and each condition's feature (slot `Stance` or `Discourse`, a grade feature
-/// for `AtLeast` and `AtMost`, an option or flag value for `Is`) read at the
-/// entry's inventory revision. The store applies it on admission and a run
-/// applies it again against its own head inventory.
+/// and each condition's feature (slot `Stance`, `Discourse` or `Scene`, a grade
+/// feature for `AtLeast` and `AtMost`, an option or flag value for `Is`) read at
+/// `rev`. The store passes the entry's own `inventory_rev` on admission; a run
+/// passes its inventory's head, because beds number revisions independently.
 pub(crate) fn check_ontology_entry(
     e: &OntologyEntry,
     inventory: &Inventory,
+    rev: u32,
 ) -> Result<(), StoreError> {
     let key = e.key();
     check_annotator(&key, &e.annotator)?;
@@ -1331,13 +1332,13 @@ pub(crate) fn check_ontology_entry(
         }
         out.extend(feature_refusals(
             inventory,
-            e.inventory_rev,
+            rev,
             &[c.as_value()],
             c.slot,
         ));
     }
-    if e.when.is_empty() && !inventory.has_revision(e.inventory_rev) {
-        out.extend(feature_refusals(inventory, e.inventory_rev, &[], Slot::Stance));
+    if e.when.is_empty() && !inventory.has_revision(rev) {
+        out.extend(feature_refusals(inventory, rev, &[], Slot::Stance));
     }
     if !out.is_empty() {
         return Err(StoreError::Invalid(out));
diff --git a/crates/weksa/tests/golf_loop.rs b/crates/weksa/tests/golf_loop.rs
index d2bf719..3ce5e62 100644
--- a/crates/weksa/tests/golf_loop.rs
+++ b/crates/weksa/tests/golf_loop.rs
@@ -5047,3 +5047,70 @@ fn create_refuses_a_scene_its_inventory_cannot_read() {
     assert!(!root.join("run.cc").exists());
     assert!(!root.join("inventory.cc").exists());
 }
+
+#[test]
+fn a_run_reads_entries_and_scenes_at_its_own_head() {
+    use weksa::{Condition, Layer, OntologyEntry, OntologyStore, Slot, Test};
+    // An entry and a scene admitted at rev 4 through a Dao-shaped inventory open
+    // a run whose own inventory is seed, proof and the scene revision as rev 3:
+    // beds number revisions independently, so a run reads features at its head.
+    let src = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../data/daodejing");
+    let dir = tempfile::tempdir().unwrap();
+    for (from, to) in [("corpus.cc", "c.cc"), ("entity.cc", "e.cc")] {
+        std::fs::copy(src.join(from), dir.path().join(to)).unwrap();
+    }
+    let rich = dir.path().join("rich.cc");
+    common::dao_rev3_at(&rich);
+    let state = common::speaker_state_in(dir.path());
+    put_dao_scene(&state, &rich, &dir.path().join("c.cc"), &dir.path().join("e.cc"));
+    let rich_store = InventoryStore::open(&rich).unwrap();
+    let status = rich_store.inventory().unwrap().entries().find(|e| e.gloss == "relative_status").unwrap().id;
+    let ontology = common::ontology_in(dir.path());
+    OntologyStore::open(&ontology)
+        .unwrap()
+        .admit(
+            vec![OntologyEntry {
+                language: "en-US".into(),
+                n: 1,
+                inventory_rev: 4,
+                layer: Layer::Discourse,
+                when: vec![Condition {
+                    slot: Slot::Scene,
+                    feature: status,
+                    test: Test::Is(weksa::packet::FeatValue::Option(common::lab("above"))),
+                }],
+                choice: "ENABOVE".into(),
+                examples: vec![],
+                annotator: weksa::Annotator::Operator,
+            }],
+            &rich_store,
+        )
+        .unwrap();
+    let head = dir.path().join("i.cc");
+    let mut own = InventoryStore::open(&head).unwrap();
+    for (rev, entries) in [
+        weksa::inventory::seed(),
+        weksa::inventory::proof_revision(),
+        weksa::inventory::speaker_scene_revision(3),
+    ] {
+        own.admit_revision(rev, entries).unwrap();
+    }
+    drop(own);
+    let run = RunStores::create(
+        &dir.path().join("run"),
+        "x",
+        RunPaths {
+            corpus: &dir.path().join("c.cc"),
+            inventory: &head,
+            entities: &dir.path().join("e.cc"),
+            ontology: &ontology,
+            speaker_state: &state,
+        },
+        "fake-model",
+        "bag",
+        weksa::run::LowererReach::ToolLessRelay,
+        ModelFamily::Unrecorded,
+        &["en-US".to_string()],
+    );
+    assert!(run.is_ok(), "{:?}", run.err());
+}
diff --git a/crates/weksa/tests/original_corpus.rs b/crates/weksa/tests/original_corpus.rs
index 515e855..6a651e7 100644
--- a/crates/weksa/tests/original_corpus.rs
+++ b/crates/weksa/tests/original_corpus.rs
@@ -314,11 +314,12 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
             "{lang} has no Stance-conditioned entry"
         );
     }
-    // Every committed inventory bed, the default one included, carries the
-    // revisions the entries bind to: a run opens over each with its panel.
-    // The default bed (data/interlingua) is read with the original corpus,
-    // entities and scenes, as `loop open` with its defaults and `--corpus
-    // data/original` does.
+    // A run opens over every committed inventory bed with its panel. The default
+    // bed (data/interlingua) numbers the scene revision 3 and holds no Dao
+    // revision; the Dao beds number it 4. Entries and scenes admitted at 4 open
+    // over both because a run reads features at its own head. The default bed is
+    // read with the original corpus, entities and scenes, as `loop open` with its
+    // defaults and `--corpus data/original` does.
     for (corpus, bed, panel) in [
         ("original", "original", &PANEL[..]),
         ("daodejing", "daodejing", &PANEL[..1]),
@@ -349,7 +350,34 @@ fn committed_ontology_is_model_drafted_and_reads_every_inventory() {
             ModelFamily::Unrecorded,
             &panel.iter().map(|l| l.to_string()).collect::<Vec<_>>(),
         )
-        .unwrap_or_else(|e| panic!("{name}: {e:?}"));
+.unwrap_or_else(|e| panic!("{name}: {e:?}"));
+    }
+    // Revision numbers are local to a bed, so agreement is proven on the beds:
+    // every feature an entry condition or a committed scene relation names means
+    // the same in all three (gloss, value kind, slots, retirement).
+    let mut named: std::collections::BTreeSet<weksa::InvId> = entries
+        .iter()
+        .flat_map(|e| e.when.iter().map(|c| c.feature))
+        .collect();
+    let scenes = weksa::SpeakerStateStore::open(&data.join("original/speaker-state.cc")).unwrap();
+    for s in scenes.all_scenes().unwrap() {
+        named.extend(s.relations.iter().flat_map(|r| r.features.iter().map(|f| f.feature)));
+    }
+    let beds: Vec<_> = ["interlingua", "original", "daodejing"]
+        .iter()
+        .map(|b| {
+            let copy = tmp.path().join(format!("bed-{b}.cc"));
+            std::fs::copy(data.join(b).join("inventory.cc"), &copy).unwrap();
+            InventoryStore::open(&copy).unwrap().inventory().unwrap()
+        })
+        .collect();
+    for id in named {
+        let shape = |inv: &weksa::Inventory| {
+            let e = inv.entry(&id).unwrap_or_else(|| panic!("{id} is missing from a bed"));
+            (e.gloss.clone(), e.value_kind.clone(), e.applies_to.clone(), e.retired_rev)
+        };
+        assert_eq!(shape(&beds[0]), shape(&beds[1]), "{id}");
+        assert_eq!(shape(&beds[1]), shape(&beds[2]), "{id}");
     }
 }
 
@@ -1032,12 +1060,13 @@ fn committed_scenes_cover_original_groups() {
 }
 
 /// The committed ontology's Scene-conditioned entries, over every scene relation
-/// (relative_status x in_group x intimacy in steps of 50): an entry that names
-/// a register or politeness level has a Scene condition, and two Scene-conditioned
-/// entries of one language and layer are never selected by the same relation, so
-/// the ontology never gives opposing instructions for one relation.
+/// (relative_status x in_group x intimacy in steps of 50): two entries of one
+/// language and layer are never selected by the same relation, so the ontology
+/// never gives two instructions for one relation in one layer. Whether an entry's
+/// text keeps a politeness level on the scene is a model reading owed per change,
+/// not a test.
 #[test]
-fn scene_entries_never_co_select_in_a_layer_and_levels_hang_on_the_scene() {
+fn scene_entries_never_co_select_in_a_layer() {
     use weksa::inventory::Slot;
     use weksa::ontology::{Condition, Test};
     use weksa::packet::FeatValue;
@@ -1050,27 +1079,6 @@ fn scene_entries_never_co_select_in_a_layer_and_levels_hang_on_the_scene() {
     let id = |gloss: &str| inv.entries().find(|e| e.gloss == gloss).unwrap().id;
     let (status, intimacy, in_group) = (id("relative_status"), id("intimacy"), id("in_group"));
     let entries = OntologyStore::open(&onto).unwrap().all().unwrap();
-    // Terms that name a register or politeness level.
-    let levels = [
-        "teineigo", "sonkeigo", "kenjogo", "desu/masu", "honorific", "register",
-        "politeness", "polite", "formal", "informal", "casual",
-    ];
-    for e in &entries {
-        let lower = e.choice.to_lowercase();
-        if levels.iter().any(|t| lower.contains(t)) {
-            // The seed entries that say they set no level carry "no politeness" or
-            // follow the rest of the line; every other naming is Scene-conditioned.
-            let disclaimed = lower.contains("sets no politeness")
-                || lower.contains("politeness follows the rest")
-                || lower.contains("politeness follows")
-                || lower.contains("own register allows");
-            assert!(
-                disclaimed || e.when.iter().any(|c: &Condition| c.slot == Slot::Scene),
-                "{} names a level without a Scene condition",
-                e.key()
-            );
-        }
-    }
     let holds = |c: &Condition, rel: (&str, u16, bool)| match (c.feature, &c.test) {
         (f, Test::Is(FeatValue::Option(l))) if f == status => l.as_str() == rel.0,
         (f, Test::AtLeast(g)) if f == intimacy => rel.1 >= g.get(),
diff --git a/crates/weksa/tests/stores.rs b/crates/weksa/tests/stores.rs
index 386178e..706adb9 100644
--- a/crates/weksa/tests/stores.rs
+++ b/crates/weksa/tests/stores.rs
@@ -1584,8 +1584,9 @@ fn seed_reseeded() {
         .unwrap();
     assert_eq!(items.len(), 3);
     // The committed inventory is the seed, reseeded (stance features in, the
-    // displayed-affect features out), the nibu-proof revision, the Dao revision
-    // and the speaker-scene revision: the same four as the other beds.
+    // displayed-affect features out), the nibu-proof revision and the
+    // speaker-scene revision as rev 3: never the Dao revision (ruling
+    // `dao-round-seed-inventory`).
     let committed = InventoryStore::open(&root.join("data/interlingua/inventory.cc"))
         .unwrap()
         .inventory()
@@ -1594,8 +1595,8 @@ fn seed_reseeded() {
     let (proof, proof_entries) = weksa::inventory::proof_revision();
     assert!(committed.has_revision(rev.n) && committed.has_revision(proof.n));
     entries.extend(proof_entries);
-    entries.extend(weksa::daodejing::revision().1);
-    entries.extend(weksa::inventory::speaker_scene_revision(4).1);
+    entries.extend(weksa::inventory::speaker_scene_revision(3).1);
+    assert_eq!(committed.latest().unwrap().n, 3);
     let mut have: Vec<_> = committed.entries().cloned().collect();
     let mut want = entries;
     have.sort_by_key(|e| e.id);
diff --git a/data/interlingua/inventory.cc b/data/interlingua/inventory.cc
index 7018ee525bd4b3e946aa0ac75375195ff4be4521..de8593f0decf77b0e00623de8059c2d7e2650a5f 100644
GIT binary patch
delta 226
zcmaDEanfbO6-FNaDJzrn^O92wN~{bg7pmw@=3|mzhYC$Tr=&mm4hOfG(ei?#)UwpP
zk^>W%4!|``o+zQWxsQW`adS1-GiG*kD+6;YBg@Gdd`^talUMVthl?cgs{%#Z`3>MA
z`}kG(m=8=@m6n=VQd*R1Wn?tjkVzRXEhS(I)DR$m(9kZR0TkJQB=TG!jFEY>ouD7f
XW^r*bVP2^9QAbjzFf&bN*GU2Z8p}m0

delta 2089
zcmaKt%TE(g6vpj?&{iQKJmjG%R80s$=-hVN>F5UI#-+v>V@$?rdud18X`Pu;SRp%?
zCbyEf!_e~5V6}Teq6>GLxOA`l1FoGXopVcBo^$7S&UerGdi(wM@x$gXPv~iFH&c=`
zxU7*MeRJf3cRaA?Bp82WmO=NK1RrO4mV5Mdc-=YUnP|N#6$*#1e1|nBNuCUz0WkG+
zNyZRp4o0qn4kNA(sDX=RZ3PkwJ!iCt)fYQ7-5rWBpv6U3i}+R*i_fqOdhiTO-u8r9
zKux$Pc2Ct5Ea$X*2bnO)?)?&5c`Pn<P)UP|f`0BnBpX;%v^*t}GoTv)nsSNcnvyCM
zN^(xXa<-yKa*pCt2G0RL?BY}Vx(zf*u3)Q-NjqNQkq*z2$KJ8?&hmK_H45GY1+TOV
zqUfi*l*?mP6Yz2d7YbN+9h8K~&%Vj7V?a!!Dr#7v7(+=o4!XK_h0va+RIpGjDOr^w
z$y#WV2cT<yDArUlE(&E)5woRbDI-F!>l4`MnY;t=dDm^@pVhLM!9p5qRg7i9+Pfgi
zS>cprBGYjQR2y|wW4F`##7b5A3Z~t<V~Oodsi@z8p7SYw8*_C_?kHHr#dN{qoTZZ&
zp}E#OZ@?3@9|+#81Ao9n>(1wVvaX6bSb{fA+m+zzMM=&=r<pd5fXNKEd!!o1V2n4S
z)$|?vdhMr*Z1mm=`44Nmi&)eu3YqGkCli6{$?==OHIJVh1fnOIe}SudW+K?m+zYaL
z=A|oh5S-RCe_fey=z+V<^ZxnPerUwsv%RQ@MbaFNOatKq>*fLG<C|heGw*39%>Bc6
zW8C?eeJ{zHBFd_yNlVr|ZOU9foaTr_C3Xsu{<2}!@{CQG8;b!^VTVY5G#syXSl&d*
zKwo4AaF-p9`%n~DbfXKl*^C9Yj`~LjSDinOZ=TmRpZE8<@wLr`Y_@F>7;-R7nc>Ov
z!bGW<p<+bEv9(pBTf0D<`hcb41QjQ#*wWXoM+rofK*X%V0*F$GV$?Y$5K#gVB@kHx
n?af-S9a!Xy9a)?m0Ej!PH59zW$H|vVkpZw?T=V<LpQ-eJ=q(7l

diff --git a/data/ontology/ontology.cc b/data/ontology/ontology.cc
index b4a032b09c4c58e54f0aa6327e44508aee8fd6ee..e3feabb443378f00ff9b82ae2b592b00666a0f0e 100644
GIT binary patch
delta 1769
zcmaJ>U1%It6lP*gQro!IB#lkec=Eg5cC#i8{xsPlmbMx(CRlxFEy&I8-Rx~9bC<by
zvsna_S&9Y&O7<#AsHLJLwb5#@L;`IBKKLN0pl>T8)*(S3#Gf}`#50rZ&d@?(cbI$6
zJ?DJq`@TDWoY{P3xmK%qyr-+Hr>pyVgLd3o(6SR{rO5J*0dG-Wai6!S+xefD)3B>i
z+qGTo>{r?k>f~;r-Bf2=TGUUw+b6=1VKNB@hge!988?_Q3_Jl@o;HDJj9wU_GzBtA
zVMtFK(x5^BGX#rM$RvrRW7LEc*O{bl$jvjUP9)X>$=yty2`6lVpi)HCQa>M~5qO?w
zBGFanJq#(G5`lX!u;HXcG?_@D`Lx8wLnJm5fj-D^BPfB05s(=c!wkVp^-G{lRn{C=
zSE^b{w0vLH@1J)@g#yoL?<h0y9D_5A>T%(rGH6gh5o|BSIThF&+oV!@);UHXfs^2S
zjGB@#19WE4NPex~g*im=K+5DpIvou|k|P0lHd5$OUj`m(8e-BRl0b|bm~MoDC2){Y
zk_F-Xc?tf&9uIzYPoJmV*AJw$YEQdMa|_hyc<FSd(n3*fNljIsOu&n%j7U*3LQUT=
z-i$uxx3oaT^f1JTNE3Zad}c^Cic$*PM%g9hX|WaIsJkg5dG%fO-eZO6psNx{Yz9Qv
z-Flcx9k+l%X}s6jGAS^JM@XhkGYbUy)b;IQsn3ezYP{xzHm%lbUhe9J?A^4veH=to
zUt8Z@I5Ln7!!YM@$9rKHMx4bF1d&f7*GUq0^`zq|8j~~*Om5?d-g};OJUck^cWcQw
z-_%Nv`KRmldG~2}UzN9bb^njvv2zFZdy&^3hBDuH)#_@~n;rR;-xjBBYtgnY*w&Ks
z%uU&oxmDlpx@}#wa|#3MR$~wi9aWz<hkTW;s?BDheSmlN=sm=wYPO~6)FT}x4>>%O
zF~W3$76fjfQ8O<8&UG#N`gZOdHFyRuv5Y8nptZhXePjAv+d_~oJnM>Wy=`0X+ZJwK
zC?UGs8uB?YJh$NTw*#FRQswtotGc#xo%xl`9M-_>&x*ya;jB0A*u@s}wsoyk{GYba
zgPzS7wu`IIz*E|+;_Z(Cj>T|7XRMe`*eD1|vch?ys%ScObZ<iie#(+8mQ?HQjXPDL
zbz^zPwr17O?TwX%U};g;QluM!{eJNy+xpnSnwxfXv0k^G@#jmx;z9q^?c2c0Rac<n
z`nSO*|A(ee{d@2&Ew83R;Uk4^mq1i}&d$Bzmi=O@vOQ_p)+O6ocKhN1L^JPKzTuEx
z`SWV<(5=?|ikpMrP!(j<`gL*<f2+k^7jpD)r)!<%!+tJL6}g<KIi{H^6n<jjph(A(
z_$762C^un*gxvcA2`2H=co*YD^4Jkc`VbLpzW2$-nsQbC^v|1@Z`={sl6V?p)<Qpz
UQ$4qsAfrsrs=orY2=vka0Z`_z1ONa4

delta 1015
zcmY+DUr19?9LG6BCZ;L#-(1dlWb@B-UVJFcKPAS56g7iN)IiSMb-Qi5XWV<|@Fl$x
z5h>L5M-Z4KMLvjy6p~R%Mbcx>MK5(zf(Uzzg6eF|-Su+dcYnY0y`SIj`#Za1--g#q
zP<C_M;g+_hBaiIpgc0y2uPL2b&pKrU=IjGTV9oh$+_C36P;N?XWE-7@?mQVOFjnn^
z4|z2$?U?xeSfrRlX_yA4FqQClOb!ZE6vP0g6L^ZoBuwKXr>*wWNuI+4G|s`xLoWD^
zj>Dg#JaFYZ(^Lcb{h7bB!AikN)CYS7eNOEi?!ih>5JQPm#t|V9RIrc71V<(63-gix
zWxW<dR<!gOEo~J>(SiMzUjKyFVlV23i^bhmZQ~3H@&Aw&A;Nnw4UwtNByAJd0gik#
z=q1jKc~pR<)Qir;xzbTPr#%@Wg5tsPAW=H;FpXiq;AgNb%4paO*RAe!!!N9gLDp`w
z88(cTA2b45@!lvKtSmP&QWZ930GVLPdDWtAd|8>()fHX6q^qm!gwwA2)WFT~*yYZ+
z@esbcWb}$z+L{%Pi3%)MS50Fwq3{w8P(KmzBro}74{ns0&B@Qgcu+_u+?bg`CW#Ox
z%mmgvFS4F_EJt}ZOsQ5*xQ``1Ajk<x5)RY2j0J^TSlgMqp{v&tgfp{ipEnutygob6
z0=QG=W4mF7#hOgiGI(3Fj5LVWmZmFAb?(A_Gq+L8&3hL}WA7l`FX%!Mn67KKwI^wK
z(a#o=!LU6Q6kg<I8Gh6`OxhMyx*ch?Pj17S!uk<ZWJudn(%H~e+yPG;dKrk><AEX9
z{wkZ{jVBX#7=C#^=4u<dx}>X@b#-}xYf76C<}yojV43rx9@ycIHpsE@ASQC+Rk7C;
gBAm9Vt5<aOu0Esg-dfvv4oOcR>^-}kTB~D!0e=@?5dZ)H

diff --git a/docs/targets/interlingua-lowering-map.md b/docs/targets/interlingua-lowering-map.md
index a100cd9..b32c83c 100644
--- a/docs/targets/interlingua-lowering-map.md
+++ b/docs/targets/interlingua-lowering-map.md
@@ -34,10 +34,10 @@ means no store holds it and nothing writes it.
 | Inventory entry | Key `<family>:<n>`, `n` canonical decimal >= 1 (families: concept, frame, role, relation, speech_act, feature, referent_kind, extension); type `weksa.inventory_entry`, with a bounded gloss, value kind (option labels bounded), the slots a feature may sit in (`Discourse`, `Referent`, `Predication`, `Relation`; `Stance` from cut `speaker-state`, `Speaker` and `Scene` from cut `speaker-scene`), `introduced_rev` and optional `retired_rev`. Speaker axes, scene relations and affects are features of those slots, so the loop grows them like any closed-class family and convergence covers them | Added or retired by an inventory revision; never edited in place (a changed meaning is a retire plus an add); a retired id still resolves for packets of earlier revisions | The loop's accepted rounds, whose minting call the context builder assembles from Train items only; Self on merge to main. Admission checks form, not text |
 | Inventory revision | Key `rev:<n>`, type `weksa.inventory_revision`, with parent, change list and `frozen` | Appended per accepted round; exactly one revision is ever marked frozen, by the convergence test | The loop's accept rule appends; the convergence test freezes; Self records the freeze as a ruling |
 | Target profile | Locale or language-project id (`en-US`, `ja-JP`, a conlang's slug). Until entries grow in rounds there is no profile revision document: a run names the profile it lowered with by the ontology store's path and digest in its `RunRecord` (cut `language-ontology`); `profile:<language>:<n>` revision documents arrive with follow-up `language-ontology-growth` | The ontology store is revised by commit; a run pins it and refuses drift; it likewise pins the speaker-state store (`RunRecord` keys 17 and 18, `Drift(SpeakerState)`, cut `language-ontology-scene`) | Profile authors and accepted rounds; never the lowerer's defaults (`persona-drives-register`) |
-| Language ontology entry (cut `language-ontology`) | Key `onto:<language>:<n>`, `n` from 1 per language; type `weksa.ontology_entry` in `data/ontology/ontology.cc`: the language, the inventory revision its conditions are read at, a layer (lexicon, grammar, discourse, phonology, orthography), at most four conditions (a feature id of slot `Stance`, `Discourse` or `Scene` with `AtLeast`/`AtMost` a grade or `Is` an option or flag; a `Scene` condition reads the relation of the item's speaker to its addressee that `with_scene` selected; slot `Speaker` and community ids wait on follow-up `language-ontology-communities`), a choice of 1 to 200 bytes, at most three examples of 1 to 120 bytes, and an `Annotator` | Admitted in all-or-nothing batches through `OntologyStore::admit`, immutable, never edited; retire arrives with `language-ontology-growth`. The run pins the store like the entity store (path and digest, `Drift(Ontology)`), never copies it, because no loop step writes it yet. Cut `language-ontology-seed` converts by drafting, not by parse: a fresh model drafts each language's seed from that language's YAML and the inventory's feature lines with no corpus text, then deletes `data/target-language-ontology/` and `.weksa/cultural-ontology/` in the same cut | Seed: a labelled model (`Annotator::Model`), no operator gate, never Test evidence (`ja-ontology-owner-answer`); attestation (operator, native reader) appends later. Accepted rounds later, through a mint call from Train items only. Selection is `ontology::select(ontology, language, view)`, called only inside `Prompt::lower`, so no caller picks entries; the prompt prints each selected entry's id, layer, choice and examples. Its text is minted text for the leak diagnostic, which today has no runtime caller (follow-up `leak-diagnostic-in-round`) |
+| Language ontology entry (cut `language-ontology`) | Key `onto:<language>:<n>`, `n` from 1 per language; type `weksa.ontology_entry` in `data/ontology/ontology.cc`: the language, the revision of the inventory it was admitted through (provenance: beds number revisions independently and a run reads each condition's feature at its own head), a layer (lexicon, grammar, discourse, phonology, orthography), at most four conditions (a feature id of slot `Stance`, `Discourse` or `Scene` with `AtLeast`/`AtMost` a grade or `Is` an option or flag; a `Scene` condition reads the relation of the item's speaker to its addressee that `with_scene` selected; slot `Speaker` and community ids wait on follow-up `language-ontology-communities`), a choice of 1 to 200 bytes, at most three examples of 1 to 120 bytes, and an `Annotator`. Whether an entry's text keeps politeness on the scene is a model reader's judgment, owed per change (a mint owes it under `language-ontology-growth`), not a test | Admitted in all-or-nothing batches through `OntologyStore::admit`, immutable, never edited; retire arrives with `language-ontology-growth`. The run pins the store like the entity store (path and digest, `Drift(Ontology)`), never copies it, because no loop step writes it yet. Cut `language-ontology-seed` converts by drafting, not by parse: a fresh model drafts each language's seed from that language's YAML and the inventory's feature lines with no corpus text, then deletes `data/target-language-ontology/` and `.weksa/cultural-ontology/` in the same cut | Seed: a labelled model (`Annotator::Model`), no operator gate, never Test evidence (`ja-ontology-owner-answer`); attestation (operator, native reader) appends later. Accepted rounds later, through a mint call from Train items only. Selection is `ontology::select(ontology, language, view)`, called only inside `Prompt::lower`, so no caller picks entries; the prompt prints each selected entry's id, layer, choice and examples. Its text is minted text for the leak diagnostic, which today has no runtime caller (follow-up `leak-diagnostic-in-round`) |
 | Community (cut `language-ontology`, follow-up `language-ontology-communities`) | Key `community:<slug>`; type `weksa.community`, converted from `data/cultural-ontology/cultures/` and `referents/` (YAML deleted in the same cut) | Revised by commit; a speaker names the communities it belongs to by id | The cultural ontology's author (owner-attested evidence only; Discord-only content stays deleted, `discord-only-content-deleted`) |
 | Speaker (cut `speaker-scene`) | Key `speaker:<slug>@<n>`; type `weksa.speaker`: stable axes as feature values of slot `Speaker` (origin, socioeconomic standing, age cohort, education and whatever the loop adds), at an inventory revision, and an `Annotator` | A new revision appends, never edits; a corpus item and every prior turn name a speaker slug, and a round records the speaker revisions it read | The annotator it names: `PersonaSnapshot` (a projection of a `gamecult.persona_state.v0` document, naming its source document and `updatedAt`), `Operator`, `WorkMetadata` (a public-domain work's own cast list and narration), or `Model { family, generator }` (the 2b `ModelFamily`) |
-| Scene (cut `speaker-scene`) | Key `scene:<group>@<n>`, the item's split group; type `weksa.scene`: participants (speaker slugs) and, per ordered pair, relation features of slot `Scene` (relative status, intimacy, in-group, audience and whatever the loop adds), at an inventory revision, and an `Annotator` | As Speaker. Keyed by the group, so a scene never straddles the split. `data/original/speaker-state.cc` holds Model-annotated keeper scenes, one per Train or Validation group of both languages (`weksa scene put|dump`); a Test group has none and reads `NoScene` | As Speaker; a model-annotated scene is never Test evidence |
+| Scene (cut `speaker-scene`) | Key `scene:<group>@<n>`, the item's split group; type `weksa.scene`: participants (speaker slugs) and, per ordered pair, relation features of slot `Scene` (relative status, intimacy, in-group, audience and whatever the loop adds), at an inventory revision (provenance; a run reads the features at its own head), and an `Annotator` | As Speaker. Keyed by the group, so a scene never straddles the split. `data/original/speaker-state.cc` holds Model-annotated keeper scenes, one per Train or Validation group of both languages (`weksa scene put|dump`); a Test group has none and reads `NoScene` | As Speaker; a model-annotated scene is never Test evidence |
 | Corpus item | Key `item:<source-slug>:<n>`, `n` canonical decimal >= 1 (no sign, no leading zero, from cut 2b); type `weksa.corpus_item` with text, language, speaker, split group, prior turns, source. Source `ModelWritten` carries a `ModelFamily` enum, the generator string as the fixture wrote it, and a prompt digest (cut 2b). The item carries no speaker state of its own: its speaker slug and group name the Speaker and Scene documents | Admitted once; the whole item is immutable (re-adding an identical item is a no-op, any difference is refused; a correction is a new item that `supersedes` the old); text already held under another key is refused unless the new item supersedes that key (cut 2b); withdrawn, never deleted, so old scores stay explainable | Importers and `weksa corpus add`, under `corpus-cast-plus-public-domain`; the source enum has no variant for Discord or any training-forbidden source (`corpus-clean`) |
 | Split assignment | Derived: `split(scheme, item.group)` | Fixed for a scheme; a new scheme is a new constant, never a reassignment. A model-written item whose group derives test is in no split; a superseding item keeps its predecessor's group | The hash function. Nobody assigns by hand, so there is no writer to forbid |
 | Loop round | Key `run:<label>:round:<n>`; type `weksa.loop_round` with spec version, profile revisions, model ids and prompt digests, sampled train items, Validation means and refusal counts (from cut `ja-panel-loop`: one set per language of the run's panel, no pooled mean), the digest of the inventory file it was scored under and, for a cycle's candidate round, its cycle `k` | Scored and recorded whole; immutable. A candidate round is put in one batch with its Decision. Lives in the run store on Yggdrasil | `run::round` and `run::cycle` (both through `score_round`) |
@@ -424,7 +424,7 @@ One line per cut; specs exist for the cuts about to run (2d and 4, siblings on `
 4. `speaker-state`: packet `stance` (felt affect and restraint, slot `Stance`, packet schema v4); formality, warmth and intensity out of the seed and the standard; only `PacketStore::admit` yields a `LoweringInput`, and it refuses packets for withdrawn items (follow-up `lowering-input-from-packet-store`). (spec r1)
 4a. `speaker-relation-input`: slot `Scene` and its first seed features (`relative_status`, `intimacy`, `in_group`; inventory revision 3, now `speaker_scene_revision`); `LoweringInput::with_scene` carries the speaker's relation to the addressee as typed `Scene` feature values. Since 4b it takes the `SpeakerStateStore` and the `CorpusStore`, reads the scene of the view's own item group for the item's speaker, and selects the relation by the addressee referent's entity (V16 when the scene does not list the item's speaker or the speaker of any live item of the group, the rule `put_scene` applies too; V17 refuses an addressee that names a predication; V13 is retired). The English lowerer does not render it. (PR for follow-up `chat-s3352-3352`)
 4b. `speaker-scene` (spec r1; `speaker-scene-seeds` is its cut 4c: CLI, inventory revision 3, cast speakers and scenes; `Party::Unnamed` covers an addressee with no entity; Speaker and Scene share one `SpeakerStateStore`): slots `Speaker` and `Scene` with their seed features; `weksa.speaker` (`speaker:<entity-slug>@<n>`) and `weksa.scene` (`scene:<group>@<n>`, participants and ordered-pair relations) documents with `Annotator` `Operator` and `Model { family, generator }`, validated by the packet's shared feature check, append-only per key; their stores, `weksa speaker` and `weksa scene` commands, published schemas; Model-annotated cast speakers and scenes for the committed items. Waits on 2d and 4; `pd-speaker-annotation` blocks only the public-domain annotator. Part 1 landed (branch `weksa-lowering/speaker-scene`): `speaker.rs`, `SpeakerStateStore`, slots `Speaker` and `Scene` exclusive to their own feature lists, `speaker_scene_revision()` (Speaker features 22-24), `with_scene` on the store, schemas. The CLI, the committed inventory revision 3 and the seeds stay with 4c.
-5. `language-ontology`, in sequential cuts on `d9ebbcf`. 5a `language-ontology` (spec r1): `weksa.ontology_entry`, `OntologyStore`, `ontology::select` over the view's `Stance` and `Discourse` features, `Prompt::lower` printing the selected entries of the item's language, `RunRecord` pinning the ontology store (keys 15 and 16), `weksa ontology admit|dump`; `ontology.rs` joins `PROMPT_SOURCE_DIGEST`. 5b `language-ontology-seed` (spec r1, after 5a): Model-annotated en-US and ja-JP seed entries drafted by an isolated model, `data/target-language-ontology/`, `.weksa/cultural-ontology/` and `schemas/target-language-cultural-ontology.md` deleted. Lost until 5c': keigo, hierarchy and uchi-soto hang on the scene relation from 5c', so ja-JP politeness is still the lowerer's guess. 5c' `language-ontology-scene` (spec r1, after 5b): the run pins the `SpeakerStateStore` (keys 17 and 18, `Drift(SpeakerState)`), `RunStores::assembled` is the one door that reads the item's scene into a loop view, `select` reads slot `Scene`, `Prompt::lower` refuses a view whose scene was never read, `weksa scene put|dump` and `weksa inventory speaker-scene` (inventory rev 4), Model-annotated keeper scenes and Scene-conditioned entries for `data/original`. 5c `language-ontology-view-assembly` (follow-up, now only the Speaker read): `select` widens to slot `Speaker`; waits on `speaker-scene-seeds`. 5d `language-ontology-communities` (follow-up): `weksa.community` from `data/cultural-ontology/` (YAML deleted, owns `edda-referent-yaml-parse`), community ids on `weksa.speaker`, community conditions; waits on 5c and question `persona-speech-community-home`.
+5. `language-ontology`, in sequential cuts on `d9ebbcf`. 5a `language-ontology` (spec r1): `weksa.ontology_entry`, `OntologyStore`, `ontology::select` over the view's `Stance` and `Discourse` features, `Prompt::lower` printing the selected entries of the item's language, `RunRecord` pinning the ontology store (keys 15 and 16), `weksa ontology admit|dump`; `ontology.rs` joins `PROMPT_SOURCE_DIGEST`. 5b `language-ontology-seed` (spec r1, after 5a): Model-annotated en-US and ja-JP seed entries drafted by an isolated model, `data/target-language-ontology/`, `.weksa/cultural-ontology/` and `schemas/target-language-cultural-ontology.md` deleted. Lost until 5c': keigo, hierarchy and uchi-soto hang on the scene relation from 5c', so ja-JP politeness is still the lowerer's guess. 5c' `language-ontology-scene` (spec r1, after 5b): the run pins the `SpeakerStateStore` (keys 17 and 18, `Drift(SpeakerState)`), `RunStores::assembled` is the one door that reads the item's scene into a loop view, `select` reads slot `Scene`, `Prompt::lower` refuses a view whose scene was never read, `weksa scene put|dump` and `weksa inventory speaker-scene` (rev 4 in data/original and data/daodejing, rev 3 in data/interlingua, which holds no Dao revision), Model-annotated keeper scenes and Scene-conditioned entries for `data/original`. 5c `language-ontology-view-assembly` (follow-up, now only the Speaker read): `select` widens to slot `Speaker`; waits on `speaker-scene-seeds`. 5d `language-ontology-communities` (follow-up): `weksa.community` from `data/cultural-ontology/` (YAML deleted, owns `edda-referent-yaml-parse`), community ids on `weksa.speaker`, community conditions; waits on 5c and question `persona-speech-community-home`.
 6. `pd-importer`: public-domain play and fiction dialogue into the corpus with speaker, scene group, edition provenance, and Speaker and Scene annotations by the ruled annotator. Waits on 4, follow-up `gutenberg-terms` and question `pd-speaker-annotation`.
 7a. `loop-context-builder`: `context.rs` (`TrainItems`, `EncoderOffer`, `Prompt`: corpus text reaches a model call only through `Prompt::mint` over live Train items or `Prompt::encode` over one offered item; instructions are the consts `MINT_INSTRUCTIONS` and `ENCODE_INSTRUCTIONS` in `context.rs`; `Checkpoint` has no public constructor, offers each item once, and its offers borrow it (the gate is typed `TestReadings` and Test offers on the round path; operator tools such as `weksa corpus dump` and `weksa score` still read corpus text of any split); prior turns print the held Train text), `SplitScheme::live`, `CorpusItem::cited_entities` (one owner of the id set `PacketStore::admit` and the offer share), and checkpoint-only Test readings (`Checkpoint`, `TestReadings`; `Aggregate` and `leak_diagnostic` carry no Test). Library only; since 7b `TrainItems::from_corpus` and `EncoderOffer::for_round` are crate-private and `RunStores` is their one public producer. Merges follow-ups `loop-context-builder-2` and `scorer-test-readings-type`. (spec r1)
 7b. `golf-loop-round` (spec r1; branch `weksa-lowering/golf-loop-round`): the smallest loop that scores one round. `run.rs`: `RunStores` pins the corpus and entity stores of a run by canonical path and FNV-1a 64 digest at `create`, reopens only from `<root>/run.cc` and refuses drift (corpus, entities, `PROMPT_SOURCE_DIGEST` of `context.rs`, a second pin on `lower.rs` retired in 7d, model, embedder); `round` encodes every live Train and Validation item through a `ModelPort` (`model.rs`; the one adapter `AnswerFiles` writes `<digest>.prompt` and reads `<digest>.answer`, so the model is the Claude session), reads each answer into a `PacketDraft` (`encode.rs`, the one place a model's JSON is read), admits through `PacketStore::admit` into `<root>/round-<n>/packets.cc`, lowers, scores once, and keeps a `RoundRecord` (`weksa.loop_round`, no text, no Test; Train rows, Validation only as means and refusal counts). `weksa loop open|round`. Not here: the spec-edit step, accept rule and composite, noise floor, Score and lowering documents, a subprocess adapter, the checkpoint door, a model lowerer (follow-ups `golf-loop-spec-edit`, `golf-loop-accept-rule`, `golf-loop-score-documents`, `golf-loop-subprocess-adapter`, `golf-loop-checkpoint-door-bound`, `golf-loop-model-lowerer`). `packet-store-inventory-binding` is met for loop packets only (`RunStores` admits with the run's inventory); `validate`, `packet proof|dao` and `lower` still take caller stores. Waits on 7a, `checkpoint-gate`, 4b.
diff --git a/schemas/cultnet/weksa.ontology_entry.schema.json b/schemas/cultnet/weksa.ontology_entry.schema.json
index 4483fa7..8e0529b 100644
--- a/schemas/cultnet/weksa.ontology_entry.schema.json
+++ b/schemas/cultnet/weksa.ontology_entry.schema.json
@@ -17,7 +17,7 @@
       }
     },
     "inventory_rev": {
-      "description": "The inventory revision the conditions read against.",
+      "description": "The revision, of the inventory the entry was admitted through, at which the\nstore read its conditions: provenance only; a run reads the conditions'\nfeatures at its own head.",
       "type": "integer",
       "format": "uint32",
       "minimum": 0
diff --git a/schemas/cultnet/weksa.scene.schema.json b/schemas/cultnet/weksa.scene.schema.json
index 90e240b..e463558 100644
--- a/schemas/cultnet/weksa.scene.schema.json
+++ b/schemas/cultnet/weksa.scene.schema.json
@@ -12,6 +12,7 @@
       "type": "string"
     },
     "inventory_rev": {
+      "description": "The revision, of the inventory the scene was admitted through, at which\n`put_scene` read its features: provenance only; a run never reads it.",
       "type": "integer",
       "format": "uint32",
       "minimum": 0
-- 
2.47.3