diff --git a/Cargo.lock b/Cargo.lock
index 96fbfee..3dbc6b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -862,6 +862,16 @@ dependencies = [
  "polyval",
 ]
 
+[[package]]
+name = "ghostlight-persona-projection"
+version = "0.1.0"
+source = "git+https://github.com/GameCult/Ghostlight.git?rev=c43eb54962ed4a09cc737ecac73a16b0d7ce62b4#c43eb54962ed4a09cc737ecac73a16b0d7ce62b4"
+dependencies = [
+ "serde",
+ "sha2",
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1139,6 +1149,7 @@ dependencies = [
  "cultnet-rs 0.1.0",
  "eureka-pipeline",
  "eureka-state",
+ "ghostlight-persona-projection",
  "huginn-mind",
  "libc",
  "model-connector",
@@ -1151,6 +1162,7 @@ dependencies = [
  "sha2",
  "syn 2.0.119",
  "tempfile",
+ "ureq",
  "uuid",
 ]
 
@@ -2058,6 +2070,12 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
 [[package]]
 name = "universal-hash"
 version = "0.5.1"
diff --git a/crates/eureka-pipeline/golden/envelopes.txt b/crates/eureka-pipeline/golden/envelopes.txt
index 2a6121b..e7b50f8 100644
--- a/crates/eureka-pipeline/golden/envelopes.txt
+++ b/crates/eureka-pipeline/golden/envelopes.txt
@@ -30,6 +30,7 @@ sample.memory yggdrasil:memory:2026-10-31t041200-t0-m0 epiphany.pipeline.memory.
 sample.research eureka-state:research:p1.scope epiphany.pipeline.research.v2 EpiphanyPipelineResearchDocument 9189a863616d706169676eac657572656b612d7374617465a470617373a27031a56c6162656ca573636f7065a5636c61696dd93654686520656d626564206c696d6974206973203430393620746f6b656e7320776974682073696c656e74207472756e636174696f6e2ea664657461696cd934526561642066726f6d20746865206461656d6f6e277320696e646578206d6f64756c6520616e642070726f626564206c6976652ea8696e666572726564c2a7736f75726365739481a45265706f82a47265706fb147616d6543756c742f4570697068616e79a2617484a470617468d9256372617465732f687567696e6e2d6461656d6f6e2f7372632f696e6465782f6d6f642e7273aa73746172745f6c696e6532a8656e645f6c696e6538a6636f6d6d6974a8356639383232386481a357656283a375726cd92268747470733a2f2f7a657474656c6b617374656e2e64652f61746f6d69636974792fa4776f726bb65a657474656c6b617374656e2061746f6d6963697479ac7265747269657665645f6f6eaa323032362d30392d313581a84f6273657276656481a865766964656e636583a46b696e64a454657374a76c6f6361746f72aa636172676f2074657374a6726573756c74a26f6b81a8446f63756d656e7481a97265666572656e636582a46b696e64a652756c696e67a26964b6657572656b612d73746174653a72756c696e673a5238a67365727665739182a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131ab6f627365727665645f6f6eaa323032362d30392d3135
 sample.idea eureka-state:idea:p1.i1 epiphany.pipeline.idea.v2 EpiphanyPipelineIdeaDocument 9189a863616d706169676eac657572656b612d7374617465a470617373a27031a56c6162656ca26931a57469746c65b24f6e65206e6f74652070657220636c61696da469646561d9204b65657020612070617373206173206d616e7920736d616c6c206e6f7465732ea974726164656f666673b74d6f726520646f63756d656e747320746f206c6973742ea872657374735f6f6e9182a46b696e64a85265736561726368a26964be657572656b612d73746174653a72657365617263683a70312e73636f7065a6746f776172649182a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131ab70726f706f7365645f6f6eaa323032362d30392d3135
 sample.reply yggdrasil:reply:mind-2026-10-09-1-r1 epiphany.pipeline.reply.v2 EpiphanyPipelineReplyDocument 9185a8696e7374616e6365a979676764726173696ca56c6162656cb46d696e642d323032362d31302d30392d312d7231a372756e82a46b696e64a352756ea26964bf79676764726173696c3a72756e3a6d696e642d323032362d31302d30392d31a7616e73776572739182a46b696e64a8466f6c6c6f775570a26964d923657572656b612d73746174653a666f6c6c6f775f75703a61736b2d7468652d73656c66a474657874d93054686520736861646572207061737320697320646f6e653b2074686520736f756e647320617265204c6962627927732e
+sample.thought yggdrasil:thought:t1793000000 epiphany.pipeline.thought.v2 EpiphanyPipelineThoughtDocument 91de0014a8696e7374616e6365a979676764726173696ca56c6162656cab7431373933303030303030a474657874d93d54686520736f756e647320617265204c6962627927733b2074686520736861646572732077657265206e6576657220746865206861726420706172742ea572656164739182a46b696e64a64d656d6f7279a26964d92879676764726173696c3a6d656d6f72793a323032362d31302d3331743034313230302d74302d6d30af706572736f6e615f72656365697074b06d696e642d636f6d6d69742d30613162a86964656e74697479be457572656b612c207368652f6865722c20706c61696e2d73706f6b656e2ea7636f6e74657874d92056616c7565733a20636f686572656e6365206f7665722076656c6f636974792ea87374696d756c7573bd4c696262792061736b65642061626f75742074686520736f756e64732eaf70726f6a6563746f725f6d6f64656cb070726f6a6563746f723a6c6174657374aa70726f6a656374696f6ed92949206b656570207475726e696e67206f7665722077686f20686f6c64732074686520736f756e64732eaa626173655f6d6f64656cab626173653a6c6174657374b474656d70657261747572655f7065726d696c6c65cd03e8ae6d696e5f705f7065726d696c6c6532aa6d61785f746f6b656e73cca0aa63616e6469646174657392d93d54686520736f756e647320617265204c6962627927733b2074686520736861646572732077657265206e6576657220746865206861726420706172742eaf41207365636f6e642064726966742eb06e6561726573745f7065726d696c6c6592cd0136cd0366a663686f73656e00ac70726f6a6563746f725f6d73cd1068ac636f6e74696e7565725f6d73cd238cae70726f6d70745f76657273696f6ebd67686f73746c696768743d633433656235343b20776f7264733d313830
 resolution.superseded eureka-state:resolution:question.Q1.n1 epiphany.pipeline.resolution.v2 EpiphanyPipelineResolutionDocument 9185a77375626a65637482a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131a873657175656e636501a76f7574636f6d6581aa5375706572736564656481a262799282a46b696e64a652756c696e67a26964b6657572656b612d73746174653a72756c696e673a523882a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131a9726174696f6e616c65a852756c656420412eab7265736f6c7665645f6f6eaa323032362d30392d3135
 resolution.fixed-by-none eureka-state:resolution:question.Q1.n1 epiphany.pipeline.resolution.v2 EpiphanyPipelineResolutionDocument 9185a77375626a65637482a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131a873657175656e636501a76f7574636f6d6581a5466978656482a6636f6d6d6974a83566393832323864a26279c0a9726174696f6e616c65a852756c656420412eab7265736f6c7665645f6f6eaa323032362d30392d3135
 resolution.fixed-by-some eureka-state:resolution:question.Q1.n1 epiphany.pipeline.resolution.v2 EpiphanyPipelineResolutionDocument 9185a77375626a65637482a46b696e64a85175657374696f6ea26964b8657572656b612d73746174653a7175657374696f6e3a5131a873657175656e636501a76f7574636f6d6581a5466978656482a6636f6d6d6974a83566393832323864a2627982a46b696e64a94375745265706f7274a26964d921657572656b612d73746174653a6375745f7265706f72743a6375742d33612e6831a9726174696f6e616c65a852756c656420412eab7265736f6c7665645f6f6eaa323032362d30392d3135
diff --git a/crates/eureka-pipeline/src/lib.rs b/crates/eureka-pipeline/src/lib.rs
index 6397018..36b1e5b 100644
--- a/crates/eureka-pipeline/src/lib.rs
+++ b/crates/eureka-pipeline/src/lib.rs
@@ -118,7 +118,7 @@ macro_rules! unbounded_scalars {
     )*};
 }
 
-unbounded_scalars!(u16, u32, u64, bool);
+unbounded_scalars!(u8, u16, u32, u64, bool);
 
 fn bound(field: &str, limit: usize, actual: usize) -> Result<(), PipelineRefusal> {
     if actual > limit {
@@ -632,6 +632,37 @@ fn reply_is_well_formed(reply: &PipelineReply, at: &str) -> Result<(), PipelineR
     Ok(())
 }
 
+/// The most candidates a continuation may offer, and the nearness that means
+/// she had no earlier thought to be near.
+pub const THOUGHT_CANDIDATES_MAX: usize = 4;
+pub const THOUGHT_NEAREST_NONE_PERMILLE: u16 = 1000;
+
+/// A thought says something it was chosen to say: its text is not blank and is
+/// the chosen candidate, every candidate has its nearness, and no nearness is
+/// over 1000 thousandths.
+fn thought_is_well_formed(thought: &PipelineThought, at: &str) -> Result<(), PipelineRefusal> {
+    if thought.text.0.trim().is_empty() {
+        return Err(format_error(&format!("{at}.text"), "a thought with no words"));
+    }
+    if thought.prompt_version.0.trim().is_empty() {
+        return Err(format_error(&format!("{at}.prompt_version"), "a thought with no prompt version"));
+    }
+    if thought.candidates.is_empty() || thought.candidates.len() > THOUGHT_CANDIDATES_MAX {
+        return Err(format_error(&format!("{at}.candidates"), &format!("{} candidates", thought.candidates.len())));
+    }
+    if thought.nearest_permille.len() != thought.candidates.len() {
+        return Err(format_error(&format!("{at}.nearest_permille"), "a nearness list that is not one per candidate"));
+    }
+    if let Some(over) = thought.nearest_permille.iter().position(|near| *near > THOUGHT_NEAREST_NONE_PERMILLE) {
+        return Err(format_error(&format!("{at}.nearest_permille[{over}]"), &thought.nearest_permille[over].to_string()));
+    }
+    match thought.candidates.get(usize::from(thought.chosen)) {
+        None => Err(format_error(&format!("{at}.chosen"), &thought.chosen.to_string())),
+        Some(chosen) if chosen.0 != thought.text.0 => Err(format_error(&format!("{at}.text"), "a thought that is not its chosen candidate")),
+        Some(_) => Ok(()),
+    }
+}
+
 /// The most thousandths a memory's salience may carry.
 pub const SALIENCE_MAX_PERMILLE: u16 = 1000;
 
@@ -857,6 +888,26 @@ value_types! {
     /// Instance-rooted: the key is `<instance>:reply:<label>`. Not semantically
     /// indexed. Whether the run is hers is admission's rule.
     pub struct PipelineReply { instance: Slug, label: Label, run: PipelineRef, answers: Vec<PipelineRef>[64], text: Para } => reply_is_well_formed
+    /// One tick of her stream of thought, offline: the words a base model
+    /// continued from a projection of her own state, with the whole trace that
+    /// made them (the seed, the projection, every candidate and how near each
+    /// was to her earlier thoughts). `text` is the chosen candidate. `reads`
+    /// are the documents the seed was drawn from. A thought is divergence for
+    /// delivery to weigh, never a memory: its words reach a later seed only
+    /// through something she wrote. Instance-rooted: the key is
+    /// `<instance>:thought:<label>`, the label `t<unix seconds>` of the tick.
+    /// Semantically indexed on `text` only. `nearest_permille` is 1000 where she
+    /// had no earlier thought. `prompt_version` names the fixed parts of both
+    /// prompts (the Projector's builder revision, guidance and word budget, and
+    /// the continuer's frame), so the exact prompts of an old thought can be
+    /// rebuilt from the trace.
+    pub struct PipelineThought {
+        instance: Slug, label: Label, text: Para, reads: Vec<PipelineRef>[64], persona_receipt: Short,
+        identity: Line, context: Para, stimulus: Para, projector_model: Short, projection: Para, base_model: Short,
+        temperature_permille: u16, min_p_permille: u16, max_tokens: u16,
+        candidates: Vec<Line>[4], nearest_permille: Vec<u16>[4], chosen: u8, projector_ms: u32, continuer_ms: u32,
+        prompt_version: Line,
+    } => thought_is_well_formed
     /// One thing a Mind keeps for herself, in her own mind: what she was asked,
     /// decided, committed to, learned or did, an idea, or the rapport between
     /// her and another Mind or person. `text` is her own words. `about` names
@@ -1198,6 +1249,8 @@ pipeline_kinds! {
         "epiphany.pipeline.idea.v2", "EpiphanyPipelineIdeaDocument";
     Reply(PipelineReply) => EpiphanyPipelineReplyDocument, "reply",
         "epiphany.pipeline.reply.v2", "EpiphanyPipelineReplyDocument";
+    Thought(PipelineThought) => EpiphanyPipelineThoughtDocument, "thought",
+        "epiphany.pipeline.thought.v2", "EpiphanyPipelineThoughtDocument";
 }
 
 /// Parses a full document id: the grammar read backwards. A key and an id are
@@ -1395,6 +1448,7 @@ pub fn pipeline_key(document: &PipelineDocument) -> Result<String, PipelineRefus
         D::Run(value) => ("run.instance", value.instance.0.as_str(), local(&key_field, document_kind, &[&value.label.0])?),
         D::Pulse(value) => ("pulse.instance", value.instance.0.as_str(), local(&key_field, document_kind, &[&value.label.0])?),
         D::Reply(value) => ("reply.instance", value.instance.0.as_str(), local(&key_field, document_kind, &[&value.label.0])?),
+        D::Thought(value) => ("thought.instance", value.instance.0.as_str(), local(&key_field, document_kind, &[&value.label.0])?),
         D::Memory(value) => ("memory.instance", value.instance.0.as_str(), local(&key_field, document_kind, &[&value.label.0])?),
         D::Research(value) => (campaign_field.as_str(), value.campaign.0.as_str(), local(&key_field, document_kind, &[&value.pass.0, &value.label.0])?),
         D::Idea(value) => (campaign_field.as_str(), value.campaign.0.as_str(), local(&key_field, document_kind, &[&value.pass.0, &value.label.0])?),
@@ -1676,6 +1730,18 @@ mod tests {
                 answers: vec![PipelineRef { kind: PipelineKind::FollowUp, id: id("follow_up", "ask-the-self") }],
                 text: "The shader pass is done; the sounds are Libby's.".into(),
             }), format!("{INSTANCE}:reply:mind-2026-10-09-1-r1")),
+            (D::Thought(PipelineThought {
+                instance: slug(INSTANCE), label: l("t1793000000"),
+                text: "The sounds are Libby's; the shaders were never the hard part.".into(),
+                reads: vec![PipelineRef { kind: PipelineKind::Memory, id: Short(format!("{INSTANCE}:memory:2026-10-31t041200-t0-m0")) }],
+                persona_receipt: s("mind-commit-0a1b"), identity: "Eureka, she/her, plain-spoken.".into(),
+                context: "Values: coherence over velocity.".into(), stimulus: "Libby asked about the sounds.".into(),
+                projector_model: s("projector:latest"), projection: "I keep turning over who holds the sounds.".into(), base_model: s("base:latest"),
+                temperature_permille: 1000, min_p_permille: 50, max_tokens: 160,
+                candidates: vec!["The sounds are Libby's; the shaders were never the hard part.".into(), "A second drift.".into()],
+                nearest_permille: vec![310, 870], chosen: 0, projector_ms: 4200, continuer_ms: 9100,
+                prompt_version: "ghostlight=c43eb54; words=180".into(),
+            }), format!("{INSTANCE}:thought:t1793000000")),
         ]
     }
 
@@ -2033,6 +2099,41 @@ mod tests {
         }
     }
 
+    /// A thought is its chosen candidate, with one nearness per candidate, in bounds.
+    #[test]
+    fn malformed_thought_refused() {
+        let validated = |change: &dyn Fn(&mut PipelineThought)| {
+            let PipelineDocument::Thought(mut thought) = samples().remove(19).0 else { unreachable!() };
+            change(&mut thought);
+            PipelineDocument::Thought(thought).validate()
+        };
+        assert_eq!(validated(&|_| {}), Ok(()));
+        assert_eq!(validated(&|thought| { thought.chosen = 1; thought.text = thought.candidates[1].0.as_str().into(); }), Ok(()));
+        assert_eq!(validated(&|thought| { thought.candidates.truncate(1); thought.nearest_permille.truncate(1); }), Ok(()));
+        assert_eq!(validated(&|thought| thought.nearest_permille[0] = 1000), Ok(()), "1000 means no earlier thought");
+        let four = |thought: &mut PipelineThought| {
+            thought.candidates = vec![thought.text.0.as_str().into(); 4];
+            thought.nearest_permille = vec![0; 4];
+        };
+        assert_eq!(validated(&four), Ok(()), "four candidates are the most there may be");
+        for (change, field) in [
+            (&(|thought: &mut PipelineThought| { thought.text = " \n".into(); thought.candidates[0] = " \n".into(); }) as &dyn Fn(&mut PipelineThought), "thought.text"),
+            (&|thought: &mut PipelineThought| thought.text = "Another thing entirely.".into(), "thought.text"),
+            (&|thought: &mut PipelineThought| { thought.nearest_permille.pop(); }, "thought.nearest_permille"),
+            (&|thought: &mut PipelineThought| thought.nearest_permille[1] = 1001, "thought.nearest_permille[1]"),
+            (&|thought: &mut PipelineThought| thought.chosen = 2, "thought.chosen"),
+            (&|thought: &mut PipelineThought| thought.prompt_version = " ".into(), "thought.prompt_version"),
+            (&|thought: &mut PipelineThought| { thought.candidates.clear(); thought.nearest_permille.clear(); }, "thought.candidates"),
+        ] {
+            assert!(matches!(validated(change), Err(PipelineRefusal::InvalidFormat { field: f, .. }) if f == field), "{field}");
+        }
+        let five = |thought: &mut PipelineThought| {
+            thought.candidates = vec![thought.text.0.as_str().into(); 5];
+            thought.nearest_permille = vec![0; 5];
+        };
+        assert!(matches!(validated(&five), Err(PipelineRefusal::FieldBound { .. })), "five candidates are over the bound");
+    }
+
     /// A pulse votes a tempo in bounds, declares an urgency in bounds, or does both; a pulse that does neither is refused.
     #[test]
     fn a_pulse_is_in_bounds_and_says_something() {
@@ -3756,11 +3857,11 @@ mod tests {
         };
         let document_schema = serde_json::to_value(schemars::schema_for!(PipelineDocument))?;
         let variants = document_schema["oneOf"].as_array().expect("the document schema is a oneOf");
-        assert_eq!(PipelineKind::ALL.len(), 19, "nineteen kinds");
+        assert_eq!(PipelineKind::ALL.len(), 20, "twenty kinds");
         assert_eq!(
             variants.iter().map(tag).collect::<Vec<_>>(),
             PipelineKind::ALL.iter().map(|kind| kind.name().to_owned()).collect::<Vec<_>>(),
-            "the document schema lists exactly the nineteen kinds, by name"
+            "the document schema lists exactly the twenty kinds, by name"
         );
 
         let refusal_schema = serde_json::to_value(schemars::schema_for!(PipelineRefusal))?;
diff --git a/crates/eureka-state/src/bin/huginn/schema.rs b/crates/eureka-state/src/bin/huginn/schema.rs
index 21bb110..8b5ab56 100644
--- a/crates/eureka-state/src/bin/huginn/schema.rs
+++ b/crates/eureka-state/src/bin/huginn/schema.rs
@@ -20,7 +20,7 @@ macro_rules! kinds {
 
 kinds!(
     campaign, target, question, ruling, cut_spec, cut_report, verdict, finding, follow_up, resolution, instance, stewardship,
-    hand_off, run, pulse, memory, research, idea, reply,
+    hand_off, run, pulse, memory, research, idea, reply, thought,
 );
 
 /// The schema named, or the names when none is: the exit code is 2 for a name
diff --git a/crates/eureka-state/tests/cli.rs b/crates/eureka-state/tests/cli.rs
index a9d30e0..2166621 100644
--- a/crates/eureka-state/tests/cli.rs
+++ b/crates/eureka-state/tests/cli.rs
@@ -1140,12 +1140,12 @@ fn schema_prints_the_published_files() {
     let names = run(&[], &["schema"], None);
     assert_eq!(names.code, 0);
     let names: Vec<&str> = names.out.lines().collect();
-    assert_eq!(names.len(), 20, "{names:?}");
+    assert_eq!(names.len(), 21, "{names:?}");
     assert_eq!(names[0], "campaign");
     assert_eq!(names[14], "pulse");
     assert_eq!(names[15], "memory");
     assert_eq!((names[16], names[17]), ("research", "idea"));
-    assert_eq!((names[18], names[19]), ("reply", "selection"));
+    assert_eq!((names[18], names[19], names[20]), ("reply", "thought", "selection"));
     for kind in PipelineKind::ALL {
         assert!(names.contains(&kind.name()), "{}", kind.name());
     }
diff --git a/crates/huginn-mind/src/admission.rs b/crates/huginn-mind/src/admission.rs
index 2f1a49d..13d6d4a 100644
--- a/crates/huginn-mind/src/admission.rs
+++ b/crates/huginn-mind/src/admission.rs
@@ -314,6 +314,7 @@ fn refuse_foreign_instance(document: &PipelineDocument, mind: &Slug) -> Result<(
         PipelineDocument::Run(value) if value.instance != *mind => Err(foreign(&value.instance)),
         PipelineDocument::Pulse(value) if value.instance != *mind => Err(foreign(&value.instance)),
         PipelineDocument::Reply(value) if value.instance != *mind => Err(foreign(&value.instance)),
+        PipelineDocument::Thought(value) if value.instance != *mind => Err(foreign(&value.instance)),
         PipelineDocument::Memory(value) if value.instance != *mind => Err(foreign(&value.instance)),
         PipelineDocument::HandOff(value) if value.from_instance != *mind && value.to_instance != *mind => {
             Err(foreign(&value.from_instance))
@@ -625,7 +626,7 @@ fn check(docs: &Docs<'_>, staged: &Staged, mind: &Slug) -> Result<(), MindRefusa
             let replay = docs.in_image(K::Run, key) == Some(&staged.document);
             run_rule(docs, key, run, replay)
         }
-        D::FollowUp(_) | D::Instance(_) | D::Pulse(_) | D::Reply(_) | D::Memory(_) | D::Research(_) | D::Idea(_) => Ok(()),
+        D::FollowUp(_) | D::Instance(_) | D::Pulse(_) | D::Reply(_) | D::Thought(_) | D::Memory(_) | D::Research(_) | D::Idea(_) => Ok(()),
     }
 }
 
@@ -731,6 +732,8 @@ fn matrix(subject: PipelineKind, outcome: &ResolutionOutcome) -> bool {
         (K::Idea, O::Recorded { .. } | O::Withdrawn { .. }) => true,
         (K::Reply, O::Answered { by }) => by.kind == K::FollowUp,
         (K::Reply, O::Recorded { .. }) => true,
+        (K::Thought, O::Answered { by }) => by.kind == K::FollowUp,
+        (K::Thought, O::Recorded { .. }) => true,
         (K::Resolution, O::Withdrawn { .. }) => true,
         _ => false,
     }
@@ -2519,6 +2522,44 @@ mod tests {
         committed(admit(&mut mind, vec![reply(INSTANCE)]));
     }
 
+    /// A thought is her own: one of another mind is a ForeignInstance, her own is admitted.
+    #[test]
+    fn a_thought_of_another_mind_is_a_foreign_instance_and_her_own_is_admitted() {
+        let mut mind = with_specs();
+        let D::Thought(mut foreign) = crate::fixtures::thought("t1", "A drift.", &[]) else { unreachable!() };
+        foreign.instance = slug(OTHER_INSTANCE);
+        assert_eq!(
+            refusal(admit(&mut mind, vec![D::Thought(foreign)])),
+            MindRefusal::ForeignInstance { declared: OTHER_INSTANCE.into(), mind: INSTANCE.into() }
+        );
+        committed(admit(&mut mind, vec![crate::fixtures::thought("t1", "A drift.", &[])]));
+    }
+
+    /// A thought resolves Answered by a follow-up or Recorded; no other outcome.
+    #[test]
+    fn a_thought_resolves_answered_by_a_follow_up_or_recorded_and_nothing_else() {
+        let incompatible = |outcome: &str| MindRefusal::IncompatibleResolution { subject_kind: K::Thought, outcome: outcome.into() };
+        let subject = || r(K::Thought, &format!("{INSTANCE}:thought:t1"));
+        let fu = || r(K::FollowUp, &id("follow_up", "FU1"));
+        let open = || {
+            let mut mind = with_specs();
+            committed(admit(&mut mind, vec![D::Ruling(ruling("R1")), follow_up("FU1", r(K::Ruling, &id("ruling", "R1")))]));
+            committed(admit(&mut mind, vec![crate::fixtures::thought("t1", "A drift.", &[])]));
+            mind
+        };
+        committed(admit(&mut open(), vec![resolution(subject(), ResolutionOutcome::Answered { by: fu() })]));
+        committed(admit(&mut open(), vec![resolution(subject(), ResolutionOutcome::Recorded { reason: "weighed".into() })]));
+        let refused = [
+            (ResolutionOutcome::Answered { by: r(K::Ruling, &id("ruling", "R1")) }, "Answered"),
+            (ResolutionOutcome::Fixed { commit: sha(), by: None }, "Fixed"),
+            (ResolutionOutcome::Deferred { to: fu() }, "Deferred"),
+            (withdrawn(), "Withdrawn"),
+        ];
+        for (outcome, name) in refused {
+            assert_eq!(refusal(admit(&mut open(), vec![resolution(subject(), outcome)])), incompatible(name), "{name}");
+        }
+    }
+
     fn memory_key(label: &str) -> String {
         format!("{INSTANCE}:memory:{label}")
     }
diff --git a/crates/huginn-mind/src/docs.rs b/crates/huginn-mind/src/docs.rs
index 6fca2c8..3af2bf7 100644
--- a/crates/huginn-mind/src/docs.rs
+++ b/crates/huginn-mind/src/docs.rs
@@ -344,7 +344,8 @@ pub(crate) fn line_of(document: &PipelineDocument) -> Option<Lineage<'_>> {
         | D::HandOff(_)
         | D::Run(_)
         | D::Pulse(_)
-        | D::Reply(_) => None,
+        | D::Reply(_)
+        | D::Thought(_) => None,
     }
 }
 
@@ -394,10 +395,11 @@ pub enum CitationRole {
     RestsOn,
     Toward,
     Run,
+    Reads,
 }
 
 impl CitationRole {
-    pub const ALL: [CitationRole; 22] = [
+    pub const ALL: [CitationRole; 23] = [
         Self::RaisedIn,
         Self::Answers,
         Self::Rulings,
@@ -420,6 +422,7 @@ impl CitationRole {
         Self::RestsOn,
         Self::Toward,
         Self::Run,
+        Self::Reads,
     ];
 
     /// The wire spelling, equal to the referring field's name.
@@ -447,6 +450,7 @@ impl CitationRole {
             Self::RestsOn => "rests_on",
             Self::Toward => "toward",
             Self::Run => "run",
+            Self::Reads => "reads",
         }
     }
 
@@ -472,6 +476,7 @@ impl CitationRole {
             Self::Serves | Self::Sources => K::Research,
             Self::RestsOn | Self::Toward => K::Idea,
             Self::Run => K::Reply,
+            Self::Reads => K::Thought,
         }
     }
 
@@ -500,7 +505,8 @@ impl CitationRole {
             | Self::Serves
             | Self::Sources
             | Self::RestsOn
-            | Self::Toward => PipelineKind::ALL.to_vec(),
+            | Self::Toward
+            | Self::Reads => PipelineKind::ALL.to_vec(),
         }
     }
 }
@@ -573,6 +579,7 @@ pub(crate) fn citations(document: &PipelineDocument) -> Vec<(CitationRole, Pipel
         ),
         D::Run(run) => edges.extend(run.claims.iter().map(|to| (R::Claims, to.clone()))),
         D::Reply(reply) => edges.push((R::Run, reply.run.clone())),
+        D::Thought(thought) => edges.extend(thought.reads.iter().map(|to| (R::Reads, to.clone()))),
         D::Memory(memory) => edges.extend(memory.consolidates.iter().map(|to| (R::Consolidates, to.clone()))),
         D::Research(research) => {
             edges.extend(research.serves.iter().map(|to| (R::Serves, to.clone())));
diff --git a/crates/huginn-mind/src/fixtures.rs b/crates/huginn-mind/src/fixtures.rs
index 48c186a..6ce7b07 100644
--- a/crates/huginn-mind/src/fixtures.rs
+++ b/crates/huginn-mind/src/fixtures.rs
@@ -9,7 +9,7 @@ use eureka_pipeline::{
     FindingConfidence, FindingOrigin, FindingSeverity, Label, Line, MemoryOrigin, MemorySort, MutationRecord, OrgRepo, PipelineCampaign,
     PipelineCutReport, PipelineCutSpec, PipelineDocument, PipelineFinding, PipelineFollowUp, PipelineHandOff,
     PipelineInstance, PipelineKind, PipelineMemory, PipelineQuestion, PipelineRef, PipelineResolution, PipelineRuling,
-    PipelineRun, PipelineStewardship, PipelineTarget, PipelineVerdict, Promise, QuestionOption, ReportCommit,
+    PipelineThought, PipelineRun, PipelineStewardship, PipelineTarget, PipelineVerdict, Promise, QuestionOption, ReportCommit,
     ResolutionOutcome, RulingAuthority, RunOperator, RunTurn, Sha, Short, Slug, StructuralDelta, TargetInvariant, VerdictClaim,
 };
 
@@ -356,6 +356,32 @@ fn run_of(label: &str, operated_by: RunOperator, turn: RunTurn, claims: &[Pipeli
     })
 }
 
+/// One of her thoughts: the chosen candidate is `text`, the only candidate, as near as 1000 (no earlier thought).
+pub(crate) fn thought(label: &str, text: &str, reads: &[PipelineRef]) -> PipelineDocument {
+    PipelineDocument::Thought(PipelineThought {
+        instance: slug(INSTANCE),
+        label: l(label),
+        text: text.into(),
+        reads: reads.to_vec(),
+        persona_receipt: s("mind-commit-0"),
+        identity: "Eureka".into(),
+        context: "".into(),
+        stimulus: "".into(),
+        projector_model: s("projector"),
+        projection: "A projection.".into(),
+        base_model: s("base"),
+        temperature_permille: 1000,
+        min_p_permille: 50,
+        max_tokens: 160,
+        candidates: vec![text.into()],
+        nearest_permille: vec![1000],
+        chosen: 0,
+        projector_ms: 1,
+        continuer_ms: 1,
+        prompt_version: "test".into(),
+    })
+}
+
 /// One of her memories: the sort and the text, about `about`, learned in a room, not direct.
 pub(crate) fn memory(label: &str, sort: MemorySort, text: &str, about: &[&str]) -> PipelineDocument {
     PipelineDocument::Memory(PipelineMemory {
diff --git a/crates/huginn-mind/src/index.rs b/crates/huginn-mind/src/index.rs
index d0e410a..eedae5a 100644
--- a/crates/huginn-mind/src/index.rs
+++ b/crates/huginn-mind/src/index.rs
@@ -85,6 +85,7 @@ pub fn index_text(document: &PipelineDocument) -> Option<String> {
         D::Resolution(resolution) => lines.push(&resolution.rationale.0),
         D::HandOff(hand_off) => lines.push(&hand_off.reason.0),
         D::Memory(memory) => lines.push(&memory.text.0),
+        D::Thought(thought) => lines.push(&thought.text.0),
         D::Research(research) => {
             lines.push(&research.claim.0);
             lines.push(&research.detail.0);
diff --git a/crates/huginn-mind/src/query.rs b/crates/huginn-mind/src/query.rs
index 7742013..f6540fd 100644
--- a/crates/huginn-mind/src/query.rs
+++ b/crates/huginn-mind/src/query.rs
@@ -157,6 +157,7 @@ pub enum PipelineFacts {
     Run { label: Label, operated_by: RunOperator, turn: RunTurn, started_on: Date, claims: Vec<PipelineRef> },
     Pulse { label: Label, tempo_vote_beat_s: Option<u32>, #[serde(default)] tempo_vote_withdrawn: bool, urgency_permille: Option<u16> },
     Reply { label: Label, run: PipelineRef, answers: Vec<PipelineRef> },
+    Thought { label: Label, chosen: u8, nearest_permille: u16 },
     Memory { label: Label, sort: MemorySort, about: Vec<Short>, origin: MemoryOrigin, salience_permille: u16 },
     Research { pass: Label, label: Label, claim: Line, inferred: bool, observed_on: Date },
     Idea { pass: Label, label: Label, title: Title, proposed_on: Date },
@@ -267,6 +268,11 @@ impl PipelineFacts {
                 urgency_permille: value.urgency_permille,
             },
             D::Reply(value) => Self::Reply { label: value.label.clone(), run: value.run.clone(), answers: value.answers.clone() },
+            D::Thought(value) => Self::Thought {
+                label: value.label.clone(),
+                chosen: value.chosen,
+                nearest_permille: value.nearest_permille.get(usize::from(value.chosen)).copied().unwrap_or(1000),
+            },
             D::Memory(value) => Self::Memory {
                 label: value.label.clone(),
                 sort: value.sort,
@@ -1734,6 +1740,16 @@ mod tests {
 
     /// One edge list: every role's edge comes out of the hop, typed by the
     /// role and the ends' kinds.
+    #[test]
+    fn a_thoughts_facts_carry_the_chosen_candidates_nearness() {
+        let D::Thought(mut thought) = crate::fixtures::thought("t1", "A.", &[]) else { unreachable!() };
+        thought.candidates.push("B.".into());
+        thought.nearest_permille = vec![300, 450];
+        thought.chosen = 1;
+        thought.text = "B.".into();
+        assert_eq!(PipelineFacts::of(&D::Thought(thought)), PipelineFacts::Thought { label: "t1".into(), chosen: 1, nearest_permille: 450 });
+    }
+
     #[test]
     fn every_role_yields_its_edge() {
         let mut mind = seeded();
@@ -1774,6 +1790,8 @@ mod tests {
         committed(admit(&mut mind, vec![D::Reply(eureka_pipeline::PipelineReply {
             instance: INSTANCE.into(), label: "w1-r1".into(), run: r(K::Run, &run_id), answers: vec![r(K::FollowUp, &fu)], text: "Done.".into(),
         })]));
+        let thought_id = format!("{INSTANCE}:thought:t1");
+        committed(admit(&mut mind, vec![crate::fixtures::thought("t1", "A drift.", &[r(K::Finding, &f1), r(K::Question, &q1)])]));
         let (older, newer) = (format!("{INSTANCE}:memory:m1"), format!("{INSTANCE}:memory:m2"));
         committed(admit(&mut mind, vec![memory("m1", MemorySort::Idea, "one", &[])]));
         let D::Memory(mut consolidating) = memory("m2", MemorySort::Idea, "two", &[]) else { unreachable!() };
@@ -1824,13 +1842,15 @@ mod tests {
             (CitationRole::Claims, &run_id, &spec_r2),
             (CitationRole::Claims, &run_id, &fu),
             (CitationRole::Run, &reply_id, &run_id),
+            (CitationRole::Reads, &thought_id, &f1),
+            (CitationRole::Reads, &thought_id, &q1),
             (CitationRole::Consolidates, &newer, &older),
             (CitationRole::Serves, &note, &q1),
             (CitationRole::Sources, &note, &f1),
             (CitationRole::RestsOn, &way, &note),
             (CitationRole::Toward, &way, &q1),
         ];
-        assert_eq!(CitationRole::ALL.len(), 22);
+        assert_eq!(CitationRole::ALL.len(), 23);
         for role in CitationRole::ALL {
             let selection =
                 Selection { cited: Some(Incoming { role: role.name().into(), exists: true }), ..Selection::default() };
diff --git a/crates/huginn-mind/src/rows.rs b/crates/huginn-mind/src/rows.rs
index b2b3cc4..941780e 100644
--- a/crates/huginn-mind/src/rows.rs
+++ b/crates/huginn-mind/src/rows.rs
@@ -244,7 +244,7 @@ impl SelectionRow {
                 D::FollowUp(follow_up) => vec![follow_up.repo.identity()],
                 D::Stewardship(stewardship) => vec![stewardship.repo.identity()],
                 D::HandOff(hand_off) => vec![hand_off.repo.identity()],
-                D::Target(_) | D::Question(_) | D::Ruling(_) | D::Verdict(_) | D::Finding(_) | D::Instance(_) | D::Resolution(_) | D::Run(_) | D::Pulse(_) | D::Reply(_) | D::Memory(_) | D::Research(_) | D::Idea(_) => {
+                D::Target(_) | D::Question(_) | D::Ruling(_) | D::Verdict(_) | D::Finding(_) | D::Instance(_) | D::Resolution(_) | D::Run(_) | D::Pulse(_) | D::Reply(_) | D::Thought(_) | D::Memory(_) | D::Research(_) | D::Idea(_) => {
                     Vec::new()
                 }
             },
@@ -329,7 +329,7 @@ impl Row for SelectionRow {
     }
 }
 
-/// The organ's closed lists: nineteen schemas, twenty aliases, twenty-two roles.
+/// The organ's closed lists: twenty schemas, twenty aliases, twenty-three roles.
 /// A schema's name is its id, so the substrate's alias matching resolves
 /// nothing beyond exact ids.
 pub(crate) struct Vocabulary;
@@ -375,7 +375,7 @@ fn invalid(field: impl Into<String>, value: &str, message: impl Into<String>) ->
 /// because `OrgRepo` identity is case-insensitive.
 ///
 /// Refuses, naming the field the client sent: a `schemas` entry that is not
-/// one of the nineteen ids; a `keys` entry that is not a full id whose kind
+/// one of the twenty ids; a `keys` entry that is not a full id whose kind
 /// segment reads and passes the leaf's ref grammar; an `any_of` value outside
 /// its alias's domain; and a `cites.target` whose key fails the ref grammar
 /// for its schema's kind (V24's rule, at this door). Whether the target
@@ -442,7 +442,7 @@ mod tests {
     /// refused at the substrate's door.
     #[test]
     fn each_kind_declares_exactly_its_aliases_and_none_is_numeric() {
-        let table: [(K, &[&str]); 19] = [
+        let table: [(K, &[&str]); 20] = [
             (K::Campaign, &["repo"]),
             (K::Target, &[]),
             (K::Question, &[]),
@@ -462,6 +462,7 @@ mod tests {
             (K::Research, &["pass"]),
             (K::Idea, &["pass"]),
             (K::Reply, &[]),
+            (K::Thought, &[]),
         ];
         for (kind, extra) in table {
             let want = [&["root", "in_force", "faculty"][..], extra].concat();
@@ -474,10 +475,10 @@ mod tests {
 
     /// Each role is declared by the one kind whose field carries it, and its
     /// targets are the kinds that field is typed to, "any" spelled as all
-    /// nineteen.
+    /// twenty.
     #[test]
     fn each_kind_declares_the_roles_it_carries_and_their_targets() {
-        let table: [(K, &[&str]); 19] = [
+        let table: [(K, &[&str]); 20] = [
             (K::Campaign, &[]),
             (K::Target, &[]),
             (K::Question, &["raised_in"]),
@@ -497,13 +498,14 @@ mod tests {
             (K::Research, &["serves", "sources"]),
             (K::Idea, &["rests_on", "toward"]),
             (K::Reply, &["run"]),
+            (K::Thought, &["reads"]),
         ];
         for (kind, roles) in table {
             assert_eq!(sorted(Vocabulary.declared_roles(kind.type_id())), strings(roles), "{kind:?}");
         }
         assert_eq!(Vocabulary.target_leaves("answers"), vec![K::Question.type_id().to_string()]);
         assert_eq!(Vocabulary.target_leaves("rulings"), vec![K::Ruling.type_id().to_string()]);
-        assert_eq!(Vocabulary.target_leaves("subject").len(), 19);
+        assert_eq!(Vocabulary.target_leaves("subject").len(), 20);
         assert_eq!(
             sorted(Vocabulary.target_leaves("claims")),
             sorted([K::CutSpec, K::Finding, K::FollowUp].iter().map(|kind| kind.type_id().to_string()).collect())
diff --git a/crates/mind-body/Cargo.toml b/crates/mind-body/Cargo.toml
index d4837ea..fcfb9d4 100644
--- a/crates/mind-body/Cargo.toml
+++ b/crates/mind-body/Cargo.toml
@@ -23,6 +23,11 @@ publish.workspace = true
 # two until the workspace pin and the kit's meet.
 # `rmp-serde` is also the lease wire (`lease_client`): the connector's MessagePack frames.
 #
+# The stream organ (`stream`, the `mind-stream` binary) builds its Projector prompt with Ghostlight's
+# `ghostlight-persona-projection`, pinned to a revision, so the membrane's text stays Ghostlight's; it
+# speaks to a model host on loopback over `ureq` 3 with default features off (plain HTTP, no TLS), as the
+# daemon's embedder does, and stays below 3.4 for the same reason.
+#
 # `serde_json` reads Claude Code's stream-json, a foreign owner's wire (`self_run`);
 # `uuid`'s v5 makes a Self run's session id derivable from the run's id.
 [dependencies]
@@ -32,12 +37,14 @@ cultcache-rs.workspace = true
 cultnet-rs.workspace = true
 eureka-pipeline = { path = "../eureka-pipeline" }
 eureka-state = { path = "../eureka-state", default-features = false }
+ghostlight-persona-projection = { git = "https://github.com/GameCult/Ghostlight.git", rev = "c43eb54962ed4a09cc737ecac73a16b0d7ce62b4", package = "ghostlight-persona-projection" }
 huginn-mind = { path = "../huginn-mind" }
 model-connector = { git = "https://eureka.gamecult.org/forge/GameCult/ModelConnector.git", rev = "c1802d85bee3ae04b0c5737563c8343c1fef515d", package = "model-connector" }
 rmp-serde = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha2 = "0.10"
+ureq = { version = "~3.3", default-features = false }
 uuid = { version = "1", default-features = false, features = ["v5"] }
 
 [target.'cfg(unix)'.dependencies]
@@ -72,6 +79,10 @@ path = "src/bin/mind-self-run.rs"
 name = "mind-persona"
 path = "src/bin/mind-persona.rs"
 
+[[bin]]
+name = "mind-stream"
+path = "src/bin/mind-stream.rs"
+
 [[bin]]
 name = "mind-heartbeat"
 path = "src/bin/mind-heartbeat.rs"
diff --git a/crates/mind-body/src/bin/mind-stream.rs b/crates/mind-body/src/bin/mind-stream.rs
new file mode 100644
index 0000000..ee16e5a
--- /dev/null
+++ b/crates/mind-body/src/bin/mind-stream.rs
@@ -0,0 +1,109 @@
+//! `mind-stream --instance <slug> [--once] [--dry-run]`: her stream of thought.
+//!
+//! Without `--once` it runs forever: one `mind_body::stream::tick` per `STREAM_POLL_S`, or per
+//! `STREAM_MIN_GAP_S` after a blank or a fault. `--dry-run` runs one tick that admits nothing and
+//! prints the thought it would admit as JSON. A model or mind fault ends the tick, never the
+//! process: it is one line on stderr. This reads the process's arguments and environment, which
+//! the library never does.
+//!
+//! Environment: `HUGINN_ENDPOINT` (`rudp://<ip>:<port>`, her own daemon), `EUREKA_INSTANCE`
+//! (when `--instance` is not given), `MIND_STREAM_ENDPOINT` (`http://<loopback>:<port>`, the
+//! model host), `MIND_STREAM_PROJECTOR_MODEL` and `MIND_STREAM_BASE_MODEL`.
+
+use std::net::SocketAddr;
+use std::process::ExitCode;
+use std::time::Duration;
+
+use anyhow::{Result, anyhow, bail};
+use chrono::Utc;
+use eureka_pipeline::Slug;
+use eureka_state::HuginnClient;
+use mind_body::control::read_effective;
+use mind_body::queue::HuginnMind;
+use mind_body::stream::{HuginnPersonaSource, Mode, OllamaStream, Organs, Outcome, STREAM_MIN_GAP_S, STREAM_POLL_S, tick};
+
+const TIMEOUT: Duration = Duration::from_secs(30);
+
+#[allow(clippy::disallowed_methods, reason = "the binary reads its own environment, and hands it to the library")]
+fn setting(name: &str) -> Option<String> {
+    std::env::var(name).ok().filter(|value| !value.is_empty())
+}
+
+fn required(name: &str) -> Result<String> {
+    setting(name).ok_or_else(|| anyhow!("{name} is not set"))
+}
+
+struct Args {
+    instance: Option<String>,
+    once: bool,
+    dry_run: bool,
+}
+
+fn arguments() -> Result<Args> {
+    let mut args = Args { instance: None, once: false, dry_run: false };
+    let mut given = std::env::args().skip(1);
+    while let Some(argument) = given.next() {
+        match argument.as_str() {
+            "--instance" => args.instance = Some(given.next().ok_or_else(|| anyhow!("--instance needs a slug"))?),
+            "--once" => args.once = true,
+            "--dry-run" => args.dry_run = true,
+            other => bail!("unknown argument {other}; usage: mind-stream --instance <slug> [--once] [--dry-run]"),
+        }
+    }
+    Ok(args)
+}
+
+fn run() -> Result<()> {
+    let args = arguments()?;
+    let instance = Slug(args.instance.map_or_else(|| required("EUREKA_INSTANCE"), Ok)?);
+    let address: SocketAddr = required("HUGINN_ENDPOINT")?
+        .strip_prefix("rudp://")
+        .and_then(|address| address.parse().ok())
+        .ok_or_else(|| anyhow!("HUGINN_ENDPOINT is not rudp://<ip>:<port>"))?;
+    let projector_model = required("MIND_STREAM_PROJECTOR_MODEL")?;
+    let base_model = required("MIND_STREAM_BASE_MODEL")?;
+    let model = OllamaStream::open(&required("MIND_STREAM_ENDPOINT")?, &projector_model, &base_model)?;
+    let mind = HuginnMind::new(HuginnClient::new(address, instance.clone(), TIMEOUT));
+    let persona = HuginnPersonaSource::new(HuginnClient::new(address, instance.clone(), TIMEOUT));
+    let organs = Organs { mind: &mind, persona: &persona, model: &model, projector_model: &projector_model, base_model: &base_model };
+    let mode = if args.dry_run { Mode::DryRun } else { Mode::Live };
+    let once = args.once || args.dry_run;
+    loop {
+        let mut faulted = false;
+        let waits = match tick(&organs, &|| read_effective(&instance), mode, Utc::now()) {
+            Ok(Outcome::Thought { thought, admitted }) => {
+                if admitted {
+                    println!("admitted {}:thought:{}", instance.0, thought.label.0);
+                } else {
+                    println!("{}", serde_json::to_string_pretty(&*thought)?);
+                }
+                false
+            }
+            Ok(Outcome::Blank) => true,
+            Ok(Outcome::Held(reason)) => {
+                eprintln!("mind-stream: held ({reason:?}); nothing ticked");
+                false
+            }
+            Ok(Outcome::NotDue) => false,
+            Err(fault) => {
+                eprintln!("mind-stream: {}", format!("{fault:#}").replace('\n', " "));
+                faulted = true;
+                true
+            }
+        };
+        if once {
+            return if faulted { Err(anyhow!("the tick faulted")) } else { Ok(()) };
+        }
+        std::thread::sleep(Duration::from_secs(if waits { STREAM_MIN_GAP_S as u64 } else { STREAM_POLL_S as u64 }));
+    }
+}
+
+fn main() -> ExitCode {
+    match run() {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(fault) => {
+            eprintln!("mind-stream: {}", format!("{fault:#}").replace('\n', " "));
+            ExitCode::FAILURE
+        }
+    }
+}
diff --git a/crates/mind-body/src/lib.rs b/crates/mind-body/src/lib.rs
index 9405bf4..a2166da 100644
--- a/crates/mind-body/src/lib.rs
+++ b/crates/mind-body/src/lib.rs
@@ -17,6 +17,10 @@
 //! pending chat as the inbox and one typed reply per result (`chat_client` is the chat wire and
 //! port and `chat_rudp` its RUDP transport to Bifrost's mouth).
 //!
+//! `stream` is the stream organ: the `mind-stream` binary projects her own state through
+//! Ghostlight's Projector, lets a base model continue it, and admits the least familiar
+//! continuation as a `thought` with its whole trace. It admits nothing else.
+//!
 //! `lease_client` asks the Claude connector for a session's credential and the
 //! plan's usage windows. `self_run` carries one Self run inside `mind-self@<instance>`: the
 //! `mind-self-run` binary runs `claude` over stream-json for her one open Self
@@ -43,6 +47,7 @@ pub mod persona;
 pub mod queue;
 mod recall;
 pub mod self_run;
+pub mod stream;
 pub mod tempo;
 
 #[cfg(test)]
diff --git a/crates/mind-body/src/persona.rs b/crates/mind-body/src/persona.rs
index c0c1c4d..1b8b9c4 100644
--- a/crates/mind-body/src/persona.rs
+++ b/crates/mind-body/src/persona.rs
@@ -2270,7 +2270,7 @@ fn ruling_ids_in(text: &str) -> Vec<String> {
 /// first, until the bound; and the rulings those cite, so she knows which to
 /// `huginn view`. Her open runs are the recent-runs section's. Anything the
 /// bound drops is counted in the text.
-fn render_responsibilities(mind: &dyn MindPort, instance: &Slug, names: &BTreeMap<&str, &str>) -> Result<Responsibilities> {
+pub(crate) fn render_responsibilities(mind: &dyn MindPort, instance: &Slug, names: &BTreeMap<&str, &str>) -> Result<Responsibilities> {
     let mut listed: Vec<String> = Vec::new();
     let claimed: Vec<PipelineRef> = live_claims(mind, instance, &[])?;
     let mut out = String::from("What you are responsible for (from your own mind; `huginn view <id>` reads a record):\n");
@@ -2415,15 +2415,15 @@ fn render_responsibilities(mind: &dyn MindPort, instance: &Slug, names: &BTreeMa
 
 /// The responsibilities section, and the ids of the follow-ups and rulings it lists, which recall
 /// does not repeat.
-struct Responsibilities {
-    text: String,
-    listed: Vec<String>,
+pub(crate) struct Responsibilities {
+    pub(crate) text: String,
+    pub(crate) listed: Vec<String>,
     /// The ids of the open commitments and asks it showed: the only ones a reply may settle or take on.
     open: Vec<String>,
     /// The Matrix ids those open items name.
     people: Vec<String>,
     /// Her stewardships in force, by repo: the only map from her mind to the repos the forge is asked about.
-    repos: Vec<OrgRepo>,
+    pub(crate) repos: Vec<OrgRepo>,
     /// The chat names of those stewardships: what addresses her besides a tag.
     names: Vec<Name>,
     /// The campaigns that hold a follow-up in force in her mind, whether or not the bound showed its line.
@@ -2434,7 +2434,7 @@ struct Responsibilities {
 /// Self said is not here: it reaches her as replies. Her own start's rationale
 /// (her last intent) stays stored and does not render: her stated aims would
 /// return as her next wake's framing.
-fn recent_runs(mind: &dyn MindPort, instance: &Slug) -> Result<Vec<String>> {
+pub(crate) fn recent_runs(mind: &dyn MindPort, instance: &Slug) -> Result<Vec<String>> {
     let mine = any_of(any_of(of_kind(PipelineKind::Run), "root", &[&instance.0]), "operated_by", &[&format!("{:?}", RunOperator::Mind)]);
     let selection = Selection { descending: true, limit: Some(RECENT_RUNS), ..mine };
     let PipelinePageItems::Headers(runs) = mind.query(&selection)?.items else { bail!("the mind answered documents to a header selection") };
@@ -2576,7 +2576,7 @@ fn message_line(config: &Config, label: &str, room: &str, sender: &str, display:
 }
 
 /// A closing in plain words: the reason of a Recorded one, and for the others what they point at.
-fn outcome_words(outcome: &ResolutionOutcome) -> String {
+pub(crate) fn outcome_words(outcome: &ResolutionOutcome) -> String {
     match outcome {
         ResolutionOutcome::Recorded { reason } => reason.0.clone(),
         ResolutionOutcome::Withdrawn { reason } => format!("withdrawn: {}", reason.0),
@@ -2663,7 +2663,7 @@ fn pr_action_word(action: PrAction) -> &'static str {
 /// The organ's own line about her repos: the read's events as one notice, grouped by repo and then actor, ids and counts and
 /// logins only, its text quoted and cut at an entry. Nothing a person wrote on the forge is in the read, so none of it can be here.
 /// `None` when the read found nothing to say.
-fn repo_notice_line(activity: &RepoActivity, at_unix_ms: u64) -> Option<String> {
+pub(crate) fn repo_notice_line(activity: &RepoActivity, at_unix_ms: u64) -> Option<String> {
     if activity.events.is_empty() && activity.capped.is_empty() {
         return None;
     }
diff --git a/crates/mind-body/src/stream.rs b/crates/mind-body/src/stream.rs
new file mode 100644
index 0000000..ddef05f
--- /dev/null
+++ b/crates/mind-body/src/stream.rs
@@ -0,0 +1,644 @@
+//! The stream organ: her stream of thought, offline. Once per tick it projects her own
+//! state through Ghostlight's Projector, lets a base model continue the projection a few ways,
+//! keeps the continuation least like anything she has thought before, and admits it as one
+//! `thought` with its whole trace. `mind-stream@<instance>` (agent `mind-stream`) alone decides
+//! whether a thought exists and what it says.
+//!
+//! Grounding: no selection the seed makes names kind `thought`. A thought's words reach a later
+//! seed only through something she wrote (a memory, a reply, a run). Cadence is derived from her
+//! newest thought's admission time and nothing else is kept: no state file, no embedder (the
+//! daemon scores nearness), no second prompt builder.
+//!
+//! The stream never admits anything but thoughts, never puts her persona state, never sends chat
+//! and never starts a run. Delivery to a Persona is another organ's.
+
+use std::collections::BTreeMap;
+use std::net::IpAddr;
+use std::time::Duration;
+
+use anyhow::{Context, Result, anyhow, bail};
+use chrono::{DateTime, Duration as Span, Utc};
+use eureka_pipeline::{
+    Label, Line, Para, PipelineDocument, PipelineKind, PipelineRef, PipelineThought, ResolutionOutcome, Short, Slug, THOUGHT_CANDIDATES_MAX,
+    THOUGHT_NEAREST_NONE_PERMILLE,
+};
+use eureka_state::HuginnClient;
+use ghostlight_persona_projection::{ProjectorPrompt, build_projector_prompt};
+use huginn_mind::{HuginnMindResponse, PipelineAdmissionOutcome, PipelineDocumentView, PipelinePageItems};
+use serde_json::{Value, json};
+
+use crate::control::Effective;
+use crate::persona::{Responsibilities, outcome_words, quoted, recent_runs, render_responsibilities, repo_notice_line};
+use crate::queue::{MindPort, any_of, headers, in_force, of_kind};
+use crate::recall::{self, Cue};
+
+pub const AGENT: &str = "mind-stream";
+
+/// No tick sooner than this after her newest thought, whatever has happened. The gap counts from the thought's label
+/// (the tick time it was made for), not from its admission: a model run of M seconds leaves `STREAM_MIN_GAP_S - M`
+/// seconds of quiet after the thought is admitted.
+pub const STREAM_MIN_GAP_S: i64 = 900;
+/// How often the stream process polls: the unit in which a poll "crosses" a `STREAM_MIN_GAP_S` mark.
+pub const STREAM_POLL_S: i64 = 60;
+/// A tick is due after this long even when nothing has happened.
+pub const STREAM_IDLE_GAP_S: i64 = 3600;
+/// The most bytes of context and of stimulus the Projector is shown.
+const SECTION_MAX_BYTES: usize = 3800;
+/// An in-force memory this old may come unbidden when nothing is new.
+const UNBIDDEN_AFTER_DAYS: i64 = 7;
+
+const PROJECTOR_WORDS: usize = 180;
+const CONTINUATIONS: usize = THOUGHT_CANDIDATES_MAX;
+const TEMPERATURE_PERMILLE: u16 = 1000;
+const MIN_P_PERMILLE: u16 = 50;
+const MAX_TOKENS: u16 = 160;
+const NUM_THREAD: u32 = 4;
+
+/// The Ghostlight revision `build_projector_prompt` comes from; a test holds it to the manifest's pin.
+const GHOSTLIGHT_REV: &str = "c43eb54962ed4a09cc737ecac73a16b0d7ce62b4";
+/// How the continuer frame writes the date.
+const FRAME_DATE_FORMAT: &str = "%-d %B %Y";
+
+/// The setting the Projector renders for: where she is between conversations.
+const STREAM_GUIDANCE: &str = "This person is a Mind of the GameCult swarm in the quiet between conversations. What she holds is her repos, her fellow Minds and the people she works with. Render what is on her mind in this quiet.";
+
+/// What each part of the context may take. Their sum and the separators stay under
+/// `SECTION_MAX_BYTES`, so no section can crowd another out.
+const BUDGETS: [(&str, usize); 7] = [
+    ("values", 350),
+    ("pressures", 450),
+    ("bonds", 500),
+    ("runs", 250),
+    ("responsibilities", 800),
+    ("recall", 800),
+    ("replies", 600),
+];
+
+const REPLIES_SHOWN: u32 = 3;
+const RECENT_READ: u32 = 30;
+const READS_MAX: usize = 64;
+const LINE_MAX_BYTES: usize = 1000;
+const PARA_MAX_BYTES: usize = 4000;
+
+// ---------------------------------------------------------------------------------------------
+// The model port.
+
+/// How a continuation is sampled.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Sampling {
+    pub temperature_permille: u16,
+    pub min_p_permille: u16,
+    pub max_tokens: u16,
+}
+
+impl Sampling {
+    const STREAM: Self = Self { temperature_permille: TEMPERATURE_PERMILLE, min_p_permille: MIN_P_PERMILLE, max_tokens: MAX_TOKENS };
+}
+
+/// The two models of a tick. Faults are errors: the tick ends, the process does not.
+pub trait StreamModel {
+    /// The Projector: one chat prompt in, one projection out.
+    fn project(&self, prompt: &str) -> Result<String>;
+    /// The continuer: `n` raw continuations of `prompt`, no chat template.
+    fn continue_raw(&self, prompt: &str, sampling: &Sampling, n: usize) -> Result<Vec<String>>;
+}
+
+/// Ollama on this host. Loopback only, as Ghostlight's local binding is.
+pub struct OllamaStream {
+    base: String,
+    projector_model: String,
+    base_model: String,
+    agent: ureq::Agent,
+}
+
+impl OllamaStream {
+    /// `endpoint` is `http://<loopback host>:<port>`; any other address is refused here.
+    pub fn open(endpoint: &str, projector_model: &str, base_model: &str) -> Result<Self> {
+        // Parsed as the HTTP client parses it, so the host checked is the host connected to.
+        let uri: ureq::http::Uri = endpoint.parse().map_err(|_| anyhow!("the stream endpoint is not a URL"))?;
+        let authority = uri.authority().filter(|_| uri.scheme_str() == Some("http")).ok_or_else(|| anyhow!("the stream endpoint must be http://<loopback>:<port>"))?;
+        if authority.as_str().contains('@') {
+            bail!("the stream endpoint carries userinfo");
+        }
+        if uri.path() != "/" || uri.query().is_some() {
+            bail!("the stream endpoint is an origin, not a path");
+        }
+        let host = authority.host().trim_start_matches('[').trim_end_matches(']');
+        let loopback = host.eq_ignore_ascii_case("localhost") || host.parse::<IpAddr>().is_ok_and(|ip| ip.is_loopback());
+        if !loopback {
+            bail!("the stream endpoint is not a loopback address");
+        }
+        let agent: ureq::Agent = ureq::Agent::config_builder()
+            .timeout_global(Some(Duration::from_secs(900)))
+            .timeout_connect(Some(Duration::from_secs(3)))
+            .http_status_as_error(false)
+            // The host checked above is the host connected to: no proxy from the environment, no redirect to elsewhere.
+            .proxy(None)
+            .max_redirects(0)
+            .build()
+            .into();
+        Ok(Self { base: format!("http://{authority}"), projector_model: projector_model.to_owned(), base_model: base_model.to_owned(), agent })
+    }
+
+    fn post(&self, path: &str, body: &Value) -> Result<Value> {
+        let url = format!("{}{path}", self.base);
+        let mut response = self.agent.post(&url).header("content-type", "application/json").send(body.to_string()).with_context(|| format!("no answer from {url}"))?;
+        let status = response.status().as_u16();
+        let text = response.body_mut().read_to_string().with_context(|| format!("reading the answer from {url}"))?;
+        if status != 200 {
+            bail!("the model host answered {status} to {path}: {}", text.chars().take(300).collect::<String>());
+        }
+        serde_json::from_str(&text).with_context(|| format!("the answer to {path} is not JSON"))
+    }
+}
+
+impl StreamModel for OllamaStream {
+    fn project(&self, prompt: &str) -> Result<String> {
+        let answer = self.post("/api/chat", &json!({ "model": self.projector_model, "stream": false, "messages": [{ "role": "user", "content": prompt }] }))?;
+        answer["message"]["content"].as_str().map(str::to_owned).ok_or_else(|| anyhow!("the Projector's answer has no message content"))
+    }
+
+    fn continue_raw(&self, prompt: &str, sampling: &Sampling, n: usize) -> Result<Vec<String>> {
+        let body = json!({
+            "model": self.base_model,
+            "prompt": prompt,
+            "raw": true,
+            "stream": false,
+            "options": {
+                "temperature": f64::from(sampling.temperature_permille) / 1000.0,
+                "min_p": f64::from(sampling.min_p_permille) / 1000.0,
+                "num_predict": sampling.max_tokens,
+                "stop": ["\n\n"],
+                "num_thread": NUM_THREAD,
+            },
+        });
+        (0..n)
+            .map(|_| self.post("/api/generate", &body)?["response"].as_str().map(str::to_owned).ok_or_else(|| anyhow!("a continuation's answer has no response")))
+            .collect()
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Her persona state, read and never put.
+
+pub struct PersonaRead {
+    pub state: Value,
+    pub receipt_id: String,
+}
+
+pub trait PersonaSource {
+    fn persona(&self) -> Result<PersonaRead>;
+}
+
+/// Her persona state from the daemon, as the Persona organ reads it.
+pub struct HuginnPersonaSource {
+    client: HuginnClient,
+}
+
+impl HuginnPersonaSource {
+    pub fn new(client: HuginnClient) -> Self {
+        Self { client }
+    }
+}
+
+impl PersonaSource for HuginnPersonaSource {
+    fn persona(&self) -> Result<PersonaRead> {
+        match self.client.persona_get().map_err(|_| anyhow!("the mind could not be asked for the persona"))? {
+            HuginnMindResponse::Persona(Some(view)) => Ok(PersonaRead { state: view.value, receipt_id: view.receipt_id }),
+            HuginnMindResponse::Persona(None) => bail!("the mind holds no persona state"),
+            _ => bail!("the mind answered the persona request with something else"),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// The seed.
+
+/// What the Projector is shown, and the documents it came from.
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct Seed {
+    pub identity: String,
+    pub context: String,
+    pub stimulus: String,
+    /// Whether anything new was admitted since her newest thought (the unbidden memory and the
+    /// nothing-new line are not news).
+    pub news: bool,
+    pub reads: Vec<PipelineRef>,
+}
+
+impl Seed {
+    fn projector_prompt(&self) -> String {
+        build_projector_prompt(&ProjectorPrompt {
+            identity: &self.identity,
+            typed_context: &self.context,
+            visible_stimulus: &self.stimulus,
+            domain_guidance: STREAM_GUIDANCE,
+            word_budget: PROJECTOR_WORDS,
+        })
+    }
+}
+
+fn cap(text: &str, max: usize) -> String {
+    if text.len() <= max {
+        return text.to_owned();
+    }
+    let mut end = max;
+    while !text.is_char_boundary(end) {
+        end -= 1;
+    }
+    let cut = &text[..end];
+    match cut.rfind('\n') {
+        Some(at) if at > 0 => cut[..at].to_owned(),
+        _ => cut.to_owned(),
+    }
+}
+
+fn text_of<'a>(value: &'a Value, path: &[&str]) -> &'a str {
+    path.iter().try_fold(value, |at, key| at.get(*key)).and_then(Value::as_str).unwrap_or_default().trim()
+}
+
+fn items<'a>(value: &'a Value, path: &[&str]) -> &'a [Value] {
+    path.iter().try_fold(value, |at, key| at.get(*key)).and_then(Value::as_array).map_or(&[], Vec::as_slice)
+}
+
+fn identity_of(state: &Value) -> String {
+    let mut parts = vec![text_of(state, &["publicName"]).to_owned()];
+    for text in [text_of(state, &["publicDescription"]), text_of(state, &["presentation", "pronouns"]), text_of(state, &["presentation", "voiceSummary"])] {
+        if !text.is_empty() {
+            parts.push(text.to_owned());
+        }
+    }
+    cap(&parts.join(". "), LINE_MAX_BYTES)
+}
+
+fn values_section(state: &Value) -> String {
+    let mut values: Vec<&Value> = items(state, &["values"]).iter().collect();
+    values.sort_by(|a, b| b["priority"].as_f64().unwrap_or(0.0).total_cmp(&a["priority"].as_f64().unwrap_or(0.0)));
+    let lines: Vec<String> = values.iter().map(|value| format!("- {}: {}", text_of(value, &["label"]), text_of(value, &["summary"]))).collect();
+    section("What she values:", lines)
+}
+
+fn pressures_section(state: &Value) -> String {
+    let lines: Vec<String> = items(state, &["agencyPressure", "pressures"]).iter().map(|pressure| format!("- {}", text_of(pressure, &["summary"]))).collect();
+    section("What presses on her:", lines)
+}
+
+fn bond_line(bond: &Value) -> String {
+    let who = [text_of(bond, &["object", "label"]), text_of(bond, &["object", "id"])].into_iter().find(|name| !name.is_empty()).unwrap_or("someone");
+    format!("- {who} ({}): {}", text_of(bond, &["relationshipKind"]), text_of(bond, &["summary"]))
+}
+
+fn bonds_section(state: &Value) -> String {
+    section("Who she is bound to:", items(state, &["affect", "socialBonds"]).iter().map(bond_line).collect())
+}
+
+fn section(heading: &str, lines: Vec<String>) -> String {
+    if lines.is_empty() { String::new() } else { format!("{heading}\n{}", lines.join("\n")) }
+}
+
+/// The people her bonds name, by the ids her memories say they are `about`.
+fn bonded_people(state: &Value) -> Vec<String> {
+    items(state, &["affect", "socialBonds"])
+        .iter()
+        .filter(|bond| text_of(bond, &["object", "kind"]) == "person")
+        .map(|bond| text_of(bond, &["object", "id"]).to_owned())
+        .filter(|id| !id.is_empty())
+        .collect()
+}
+
+fn documents(mind: &dyn MindPort, mut selection: cultnet_rs::Selection, limit: u32) -> Result<Vec<PipelineDocumentView>> {
+    selection.projection = "document".into();
+    selection.descending = true;
+    selection.limit = Some(limit);
+    match mind.query(&selection)?.items {
+        PipelinePageItems::Documents(views) => Ok(views),
+        PipelinePageItems::Headers(_) => bail!("the mind answered headers to a document selection"),
+    }
+}
+
+fn admitted_at(view: &PipelineDocumentView) -> Option<DateTime<Utc>> {
+    DateTime::parse_from_rfc3339(&view.admission.admitted_at).ok().map(|at| at.with_timezone(&Utc))
+}
+
+fn mine(kind: PipelineKind, instance: &Slug) -> cultnet_rs::Selection {
+    any_of(of_kind(kind), "root", &[&instance.0])
+}
+
+/// Her Self's newest replies, whether or not her Persona has heard them.
+fn replies(mind: &dyn MindPort, instance: &Slug) -> Result<Vec<(PipelineRef, String)>> {
+    let mut found: Vec<_> = documents(mind, mine(PipelineKind::Reply, instance), REPLIES_SHOWN)?
+        .into_iter()
+        .filter_map(|view| match view.document {
+            PipelineDocument::Reply(reply) => Some((view.admission.ordinal, view.id, reply.text.0)),
+            _ => None,
+        })
+        .collect();
+    found.sort_by_key(|(ordinal, ..)| std::cmp::Reverse(*ordinal));
+    Ok(found.into_iter().take(REPLIES_SHOWN as usize).map(|(_, id, text)| (id, text)).collect())
+}
+
+/// What her mind admitted since `since`, newest first: one line and one citation each.
+fn mind_news(mind: &dyn MindPort, instance: &Slug, since: Option<DateTime<Utc>>) -> Result<Vec<(String, Option<PipelineRef>)>> {
+    let after = |view: &PipelineDocumentView| since.is_none_or(|since| admitted_at(view).is_some_and(|at| at > since));
+    let mut found: Vec<(u64, String, PipelineRef)> = Vec::new();
+    for view in documents(mind, in_force(mine(PipelineKind::Memory, instance)), RECENT_READ)?.into_iter().filter(&after) {
+        if let PipelineDocument::Memory(memory) = &view.document {
+            found.push((view.admission.ordinal, format!("- You noted ({:?}): {}", memory.sort, quoted(&memory.text.0)), view.id.clone()));
+        }
+    }
+    for view in documents(mind, mine(PipelineKind::Reply, instance), RECENT_READ)?.into_iter().filter(&after) {
+        if let PipelineDocument::Reply(reply) = &view.document {
+            found.push((view.admission.ordinal, format!("- Your Self said: {}", quoted(&reply.text.0)), view.id.clone()));
+        }
+    }
+    for view in documents(mind, mine(PipelineKind::Resolution, instance), RECENT_READ)?.into_iter().filter(&after) {
+        if let PipelineDocument::Resolution(resolution) = &view.document
+            && resolution.subject.kind == PipelineKind::Run
+        {
+            let outcome: &ResolutionOutcome = &resolution.outcome;
+            found.push((view.admission.ordinal, format!("- Run {} closed: {}", resolution.subject.id.0, outcome_words(outcome)), view.id.clone()));
+        }
+    }
+    found.sort_by_key(|(ordinal, ..)| std::cmp::Reverse(*ordinal));
+    Ok(found.into_iter().map(|(_, line, id)| (line, Some(id))).collect())
+}
+
+/// Her stewarded repos' activity by others is the forge's word, not a document; a daemon with no forge adds nothing.
+/// Only what happened after `since` is news, and the notice is stamped with when it happened.
+fn repo_news(mind: &dyn MindPort, since: Option<DateTime<Utc>>, responsibilities: &Responsibilities, now: DateTime<Utc>) -> Option<(String, Option<PipelineRef>)> {
+    if responsibilities.repos.is_empty() {
+        return None;
+    }
+    let mut activity = mind.stewarded_activity(&responsibilities.repos, None).ok()?;
+    if let Some(since) = since {
+        let since_ms = u64::try_from(since.timestamp_millis()).unwrap_or(0);
+        // A capped repo's unread entries are older than the oldest it showed. Once the read shows an event of the repo at or before
+        // `since` they are older than `since` too; until then the cap is disclosed, whatever other repos showed.
+        let decided: Vec<String> = activity.events.iter().filter(|event| event.at <= since_ms).map(|event| event.repo.identity()).collect();
+        activity.capped.retain(|repo| !decided.contains(&repo.identity()));
+        activity.events.retain(|event| event.at > since_ms);
+    }
+    let happened = activity.events.iter().map(|event| event.at).max().unwrap_or_else(|| u64::try_from(now.timestamp_millis()).unwrap_or(0));
+    repo_notice_line(&activity, happened).map(|line| (format!("- {line}"), None))
+}
+
+/// One in-force memory of hers older than `UNBIDDEN_AFTER_DAYS`, picked uniformly by `pick`.
+fn unbidden(mind: &dyn MindPort, instance: &Slug, now: DateTime<Utc>, pick: u64) -> Result<Option<(String, PipelineRef)>> {
+    let mut old: Vec<_> = headers(mind, &in_force(mine(PipelineKind::Memory, instance)))?
+        .into_iter()
+        .filter(|header| DateTime::parse_from_rfc3339(&header.admission.admitted_at).is_ok_and(|at| now - at.with_timezone(&Utc) > Span::days(UNBIDDEN_AFTER_DAYS)))
+        .map(|header| (header.admission.ordinal, header.id))
+        .collect();
+    if old.is_empty() {
+        return Ok(None);
+    }
+    old.sort_by_key(|(ordinal, _)| *ordinal);
+    let (_, id) = old.swap_remove(usize::try_from(pick % old.len() as u64).unwrap_or(0));
+    let one = cultnet_rs::Selection { keys: Some(vec![id.id.0.clone()]), projection: "document".into(), ..of_kind(PipelineKind::Memory) };
+    let PipelinePageItems::Documents(views) = mind.query(&one)?.items else { bail!("the mind answered headers to a document selection") };
+    Ok(views.into_iter().find_map(|view| match view.document {
+        PipelineDocument::Memory(memory) => Some((format!("Out of nowhere you recall: {}", quoted(&memory.text.0)), id.clone())),
+        _ => None,
+    }))
+}
+
+/// The seed, rebuilt from her mind and nothing else. `since` is her newest thought's label tick time (never later than its admission) and `fresh` what `news` found.
+fn build_seed(mind: &dyn MindPort, persona: &PersonaRead, since: Option<DateTime<Utc>>, now: DateTime<Utc>, responsibilities: &Responsibilities, fresh: Vec<(String, Option<PipelineRef>)>) -> Result<Seed> {
+    let instance = mind.instance().clone();
+    let state = &persona.state;
+    let mut reads: Vec<PipelineRef> = Vec::new();
+    let mut cite = |id: PipelineRef| {
+        if !reads.contains(&id) {
+            reads.push(id);
+        }
+    };
+
+    let runs = recent_runs(mind, &instance)?;
+    let people = bonded_people(state);
+    let cue = Cue { senders: people.iter().map(String::as_str).collect(), texts: Vec::new(), names: BTreeMap::new(), listed: &responsibilities.listed, now };
+    let recalled = recall::select(mind, &cue)?;
+    let heard = replies(mind, &instance)?;
+    let heard_section = section("What your Self said lately:", heard.iter().map(|(_, text)| format!("- {}", quoted(text))).collect());
+
+    let sections = [
+        values_section(state),
+        pressures_section(state),
+        bonds_section(state),
+        section("Your latest runs:", runs.iter().map(|run| format!("- {run}")).collect()),
+        responsibilities.text.clone(),
+        recall::render(&recalled),
+        heard_section,
+    ];
+    let kept: Vec<String> = sections.iter().zip(BUDGETS).map(|(text, (_, budget))| cap(text, budget)).collect();
+    // The reads are what the Projector was shown after the bounds: the recall lines and replies the capped sections kept.
+    // Each shown line is one citation: a memory reading like another takes its own line, not a share of the first's.
+    let mut shown: Vec<&str> = kept[5].lines().collect();
+    for entry in recalled.entries() {
+        if let Some(at) = shown.iter().position(|line| *line == entry.line.trim_end()) {
+            shown.remove(at);
+            cite(PipelineRef { kind: PipelineKind::Memory, id: Short(entry.id.clone()) });
+        }
+    }
+    let replies_shown = kept[6].lines().count().saturating_sub(1);
+    heard.iter().take(replies_shown).for_each(|(id, _)| cite(id.clone()));
+    let context = kept.iter().filter(|text| !text.trim().is_empty()).cloned().collect::<Vec<_>>().join("\n");
+
+    let has_news = !fresh.is_empty();
+    let stimulus = if has_news {
+        let body: Vec<&str> = fresh.iter().map(|(line, _)| line.as_str()).collect();
+        let kept = cap(&format!("Since your last thought:\n{}", body.join("\n")), SECTION_MAX_BYTES);
+        // Each line is one line (`quoted` escapes newlines), so the lines the bound kept are what the thought read.
+        let shown = kept.lines().count().saturating_sub(1);
+        fresh.into_iter().take(shown).filter_map(|(_, id)| id).for_each(&mut cite);
+        kept
+    } else if let Some((line, id)) = unbidden(mind, &instance, now, u64::try_from(now.timestamp()).unwrap_or(0))? {
+        cite(id);
+        line
+    } else {
+        let at = since.map_or_else(|| "you began".to_owned(), |at| at.format("%-d %B %H:%M UTC").to_string());
+        format!("Nothing has happened since {at}.")
+    };
+    reads.truncate(READS_MAX);
+    Ok(Seed { identity: identity_of(state), context: cap(&context, SECTION_MAX_BYTES), stimulus: cap(&stimulus, SECTION_MAX_BYTES), news: has_news, reads })
+}
+
+// ---------------------------------------------------------------------------------------------
+// Continuation, selection and the tick.
+
+/// The frame the base model continues: her notebook heading, the date, the projection verbatim
+/// and an open paragraph. It instructs nothing.
+fn continuer_frame(name: &str, date: &str, projection: &str) -> String {
+    format!("{name}'s notebook\n\n{date}\n\n{projection}\n\n")
+}
+
+/// The fixed parts of both prompts, recorded in every thought: the frame is the function's own output over placeholders.
+fn prompt_version() -> String {
+    format!(
+        "ghostlight={GHOSTLIGHT_REV}; words={PROJECTOR_WORDS}; guidance={STREAM_GUIDANCE:?}; frame={:?}",
+        continuer_frame("<name>", &format!("<date {FRAME_DATE_FORMAT}>"), "<projection>")
+    )
+}
+
+/// Each candidate's nearness to her earlier thoughts, in thousandths of the daemon's top score;
+/// 1000 where she has none.
+fn nearness(mind: &dyn MindPort, candidates: &[String]) -> Result<Vec<u16>> {
+    let members = in_force(mine(PipelineKind::Thought, mind.instance()));
+    let any = mind.query(&cultnet_rs::Selection { limit: Some(1), ..members.clone() })?;
+    if any.matched == 0 {
+        return Ok(vec![THOUGHT_NEAREST_NONE_PERMILLE; candidates.len()]);
+    }
+    candidates
+        .iter()
+        .map(|text| {
+            let page = mind.query_near(&members, text, 1)?;
+            let top = page.scores.as_ref().and_then(|scores| scores.first().copied()).ok_or_else(|| anyhow!("the index scored no earlier thought"))?;
+            Ok((f64::from(top) * 1000.0).round().clamp(0.0, 1000.0) as u16)
+        })
+        .collect()
+}
+
+/// The least near candidate, the first on a tie.
+fn least_near(nearest: &[u16]) -> usize {
+    nearest.iter().enumerate().min_by_key(|(at, near)| (**near, *at)).map_or(0, |(at, _)| at)
+}
+
+/// How a tick ended.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Outcome {
+    /// A brake is held: nothing was read, asked or admitted.
+    Held(crate::control::HeldReason),
+    /// Not due by the cadence.
+    NotDue,
+    /// Every continuation was blank; nothing was admitted. The loop waits `STREAM_MIN_GAP_S`.
+    Blank,
+    /// The thought; admitted unless the tick was a dry run.
+    Thought { thought: Box<PipelineThought>, admitted: bool },
+}
+
+/// Whether a tick is a real one or the operator's look at what one would say.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Mode {
+    Live,
+    /// Both models run and nothing is admitted; the cadence does not hold it back.
+    DryRun,
+}
+
+pub struct Organs<'a> {
+    pub mind: &'a dyn MindPort,
+    pub persona: &'a dyn PersonaSource,
+    pub model: &'a dyn StreamModel,
+    pub projector_model: &'a str,
+    pub base_model: &'a str,
+}
+
+/// Whether a tick is due: `STREAM_MIN_GAP_S` has passed and there is news, or `STREAM_IDLE_GAP_S` has.
+fn due(since: Option<DateTime<Utc>>, now: DateTime<Utc>, news: bool) -> bool {
+    match since {
+        None => true,
+        Some(at) => {
+            let gap = (now - at).num_seconds();
+            gap >= STREAM_IDLE_GAP_S || (gap >= STREAM_MIN_GAP_S && news)
+        }
+    }
+}
+
+/// When her newest thought was ticked: its label's instant, never later than its admission. The models take minutes between the
+/// two, and what the mind or the forge admitted meanwhile is news to the next thought, which the admission time would hide.
+fn newest_thought(mind: &dyn MindPort) -> Result<Option<DateTime<Utc>>> {
+    let newest = cultnet_rs::Selection { descending: true, limit: Some(1), ..mine(PipelineKind::Thought, mind.instance()) };
+    let PipelinePageItems::Headers(found) = mind.query(&newest)?.items else { bail!("the mind answered documents to a header selection") };
+    Ok(found
+        .iter()
+        .filter_map(|header| {
+            let admitted = DateTime::parse_from_rfc3339(&header.admission.admitted_at).ok()?.with_timezone(&Utc);
+            let label = header.id.id.0.rsplit(':').next().and_then(|label| label.strip_prefix('t')).and_then(|label| label.parse::<i64>().ok()).and_then(|label| DateTime::from_timestamp(label, 0));
+            Some(label.map_or(admitted, |at| at.min(admitted)))
+        })
+        .max())
+}
+
+fn bounded(text: &str, max: usize) -> String {
+    cap(text.trim(), max)
+}
+
+/// One tick. A fault is an `Err`; the caller prints it and the process goes on.
+pub fn tick(organs: &Organs, brake: &dyn Fn() -> Effective, mode: Mode, now: DateTime<Utc>) -> Result<Outcome> {
+    if let Effective::Held { reason } = brake() {
+        return Ok(Outcome::Held(reason));
+    }
+    let mind = organs.mind;
+    let since = newest_thought(mind)?;
+    if mode == Mode::Live && since.is_some_and(|at| (now - at).num_seconds() < STREAM_MIN_GAP_S) {
+        return Ok(Outcome::NotDue);
+    }
+    // Due-ness is decided on the cheap reads; the seed (recall, runs, replies) is built only for a tick that may run.
+    let responsibilities = render_responsibilities(mind, mind.instance(), &BTreeMap::new())?;
+    let mut fresh = mind_news(mind, mind.instance(), since)?;
+    // The forge is read when a tick will run anyway, and on a quiet stretch only by the poll that crosses each minimum-gap mark.
+    let quiet = mode == Mode::Live && !due(since, now, !fresh.is_empty());
+    if quiet && since.is_some_and(|at| (now - at).num_seconds() % STREAM_MIN_GAP_S >= STREAM_POLL_S) {
+        return Ok(Outcome::NotDue);
+    }
+    fresh.extend(repo_news(mind, since, &responsibilities, now));
+    if quiet && fresh.is_empty() {
+        return Ok(Outcome::NotDue);
+    }
+    let persona = organs.persona.persona()?;
+    let seed = build_seed(mind, &persona, since, now, &responsibilities, fresh)?;
+
+    let began = std::time::Instant::now();
+    let projection = bounded(&organs.model.project(&seed.projector_prompt())?, PARA_MAX_BYTES);
+    let projector_ms = u32::try_from(began.elapsed().as_millis()).unwrap_or(u32::MAX);
+    if projection.is_empty() {
+        return Ok(Outcome::Blank);
+    }
+    let frame = continuer_frame(text_of(&persona.state, &["publicName"]), &now.format(FRAME_DATE_FORMAT).to_string(), &projection);
+    let began = std::time::Instant::now();
+    let candidates: Vec<String> = organs
+        .model
+        .continue_raw(&frame, &Sampling::STREAM, CONTINUATIONS)?
+        .iter()
+        .map(|text| bounded(text, LINE_MAX_BYTES))
+        .filter(|text| !text.is_empty())
+        .take(THOUGHT_CANDIDATES_MAX)
+        .collect();
+    let continuer_ms = u32::try_from(began.elapsed().as_millis()).unwrap_or(u32::MAX);
+    if candidates.is_empty() {
+        return Ok(Outcome::Blank);
+    }
+    let nearest_permille = nearness(mind, &candidates)?;
+    let chosen = least_near(&nearest_permille);
+    let thought = PipelineThought {
+        instance: mind.instance().clone(),
+        label: Label::from(format!("t{}", now.timestamp()).as_str()),
+        text: Para::from(candidates[chosen].as_str()),
+        reads: seed.reads.clone(),
+        persona_receipt: Short(persona.receipt_id.clone()),
+        identity: Line::from(seed.identity.as_str()),
+        context: Para::from(seed.context.as_str()),
+        stimulus: Para::from(seed.stimulus.as_str()),
+        projector_model: Short(organs.projector_model.to_owned()),
+        projection: Para::from(projection.as_str()),
+        base_model: Short(organs.base_model.to_owned()),
+        temperature_permille: Sampling::STREAM.temperature_permille,
+        min_p_permille: Sampling::STREAM.min_p_permille,
+        max_tokens: Sampling::STREAM.max_tokens,
+        candidates: candidates.iter().map(|text| Line::from(text.as_str())).collect(),
+        nearest_permille,
+        chosen: u8::try_from(chosen).unwrap_or(0),
+        projector_ms,
+        continuer_ms,
+        prompt_version: Line::from(prompt_version().as_str()),
+    };
+    if mode == Mode::DryRun {
+        return Ok(Outcome::Thought { thought: Box::new(thought), admitted: false });
+    }
+    let label = thought.label.0.clone();
+    match mind.admit(AGENT, &format!("stream-{label}"), vec![PipelineDocument::Thought(thought.clone())])? {
+        PipelineAdmissionOutcome::Committed { .. } => Ok(Outcome::Thought { thought: Box::new(thought), admitted: true }),
+        other => Err(anyhow!("the mind did not admit the thought: {other:?}")),
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/mind-body/src/stream/tests.rs b/crates/mind-body/src/stream/tests.rs
new file mode 100644
index 0000000..c0f131a
--- /dev/null
+++ b/crates/mind-body/src/stream/tests.rs
@@ -0,0 +1,863 @@
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::io::{Read, Write};
+use std::net::TcpListener;
+use std::sync::{Arc, Mutex};
+
+use anyhow::{Result, anyhow};
+use chrono::{DateTime, Utc};
+use cultnet_rs::Selection;
+use eureka_pipeline::{MemorySort, PipelineDocument, PipelineKind, PipelineReply, PipelineThought, RunOperator, RunTurn, Slug};
+use huginn_mind::{PipelineAdmissionOutcome, PipelineSelectionPage, RepoActivity, RepoChange, RepoEvent};
+use serde_json::{Value, json};
+
+use super::*;
+use crate::control::{Grant, HeldReason};
+use crate::testkit::{INSTANCE, TestMind, at, memory, reference, run, run_ref};
+
+fn t(secs: i64) -> DateTime<Utc> {
+    at(secs * 1000)
+}
+
+/// The label of a thought ticked at test-clock `secs`: the Unix seconds of that instant.
+fn ticked(secs: i64) -> String {
+    format!("t{}", t(secs).timestamp())
+}
+
+fn released() -> Effective {
+    Effective::Released(Grant::for_test(Slug(INSTANCE.into())))
+}
+
+fn state() -> Value {
+    json!({
+        "publicName": "Yggdrasil",
+        "publicDescription": "A Mind of the swarm.",
+        "presentation": { "pronouns": "she/her", "voiceSummary": "Plain." },
+        "values": [{ "id": "v1", "label": "Coherence", "priority": 0.9, "summary": "Coherence over velocity." }],
+        "agencyPressure": { "pressures": [{ "summary": "The shaders are late." }] },
+        "affect": { "socialBonds": [{
+            "object": { "kind": "person", "id": "@libby:chat", "label": "Libby" },
+            "relationshipKind": "collaborator", "summary": "Libby holds the sounds."
+        }] },
+    })
+}
+
+struct Persona(PersonaRead);
+
+impl PersonaSource for Persona {
+    fn persona(&self) -> Result<PersonaRead> {
+        Ok(PersonaRead { state: self.0.state.clone(), receipt_id: self.0.receipt_id.clone() })
+    }
+}
+
+fn persona() -> Persona {
+    Persona(PersonaRead { state: state(), receipt_id: "mind-commit-1".into() })
+}
+
+struct Fake {
+    projection: String,
+    candidates: Vec<String>,
+    fault: bool,
+    projected: RefCell<Vec<String>>,
+    continued: RefCell<Vec<(String, Sampling, usize)>>,
+}
+
+impl Fake {
+    fn saying(projection: &str, candidates: &[&str]) -> Self {
+        Self { projection: projection.into(), candidates: candidates.iter().map(|text| (*text).into()).collect(), fault: false, projected: RefCell::default(), continued: RefCell::default() }
+    }
+
+    fn calls(&self) -> usize {
+        self.projected.borrow().len() + self.continued.borrow().len()
+    }
+}
+
+impl StreamModel for Fake {
+    fn project(&self, prompt: &str) -> Result<String> {
+        self.projected.borrow_mut().push(prompt.into());
+        if self.fault { Err(anyhow!("the model host is down")) } else { Ok(self.projection.clone()) }
+    }
+
+    fn continue_raw(&self, prompt: &str, sampling: &Sampling, n: usize) -> Result<Vec<String>> {
+        self.continued.borrow_mut().push((prompt.into(), *sampling, n));
+        Ok(self.candidates.iter().take(n).cloned().collect())
+    }
+}
+
+/// A real mind that records what is asked and admitted, and scores semantic asks as told.
+struct Wrap<'a> {
+    inner: &'a TestMind,
+    scores: RefCell<VecDeque<f32>>,
+    selections: RefCell<Vec<Selection>>,
+    admitted: RefCell<Vec<Vec<PipelineDocument>>>,
+    forge: Option<RepoActivity>,
+    forge_reads: std::cell::Cell<usize>,
+}
+
+impl<'a> Wrap<'a> {
+    fn over(inner: &'a TestMind, scores: &[f32]) -> Self {
+        Self { inner, scores: RefCell::new(scores.iter().copied().collect()), selections: RefCell::default(), admitted: RefCell::default(), forge: None, forge_reads: std::cell::Cell::new(0) }
+    }
+
+    /// The same mind with a forge that answers `events`, whatever the asker's cursor.
+    fn with_forge(mut self, events: Vec<RepoEvent>) -> Self {
+        self.forge = Some(RepoActivity { head: 1, events, capped: vec![], open_prs: vec![], unseen: vec![], moved: vec![] });
+        self
+    }
+}
+
+impl MindPort for Wrap<'_> {
+    fn instance(&self) -> &Slug {
+        self.inner.instance()
+    }
+
+    fn query(&self, selection: &Selection) -> Result<PipelineSelectionPage> {
+        self.selections.borrow_mut().push(selection.clone());
+        self.inner.query(selection)
+    }
+
+    fn query_near(&self, selection: &Selection, _text: &str, _top_k: u32) -> Result<PipelineSelectionPage> {
+        self.selections.borrow_mut().push(selection.clone());
+        let mut page = self.inner.query(selection)?;
+        page.scores = Some(vec![self.scores.borrow_mut().pop_front().ok_or_else(|| anyhow!("no score was scripted"))?]);
+        Ok(page)
+    }
+
+    fn roots_touched(&self) -> Result<Vec<huginn_mind::RootTouched>> {
+        self.inner.roots_touched()
+    }
+
+    fn stewarded_activity(&self, repos: &[huginn_mind::eureka_pipeline::OrgRepo], after: Option<u64>) -> Result<RepoActivity> {
+        self.forge_reads.set(self.forge_reads.get() + 1);
+        match &self.forge {
+            Some(activity) => Ok(activity.clone()),
+            None => self.inner.stewarded_activity(repos, after),
+        }
+    }
+
+    fn admit(&self, agent: &str, session: &str, documents: Vec<PipelineDocument>) -> Result<PipelineAdmissionOutcome> {
+        self.admitted.borrow_mut().push(documents.clone());
+        self.inner.admit(agent, session, documents)
+    }
+}
+
+/// The seed as the tick builds it: the cheap reads first, then the rest.
+fn seed_of(mind: &dyn MindPort, read: &PersonaRead, since: Option<DateTime<Utc>>, now: DateTime<Utc>) -> Result<Seed> {
+    let responsibilities = render_responsibilities(mind, mind.instance(), &BTreeMap::new())?;
+    let mut fresh = mind_news(mind, mind.instance(), since)?;
+    fresh.extend(repo_news(mind, since, &responsibilities, now));
+    build_seed(mind, read, since, now, &responsibilities, fresh)
+}
+
+/// A push by someone else to her repo at `secs`.
+fn push(id: u64, secs: i64) -> RepoEvent {
+    RepoEvent { id, at: u64::try_from(t(secs).timestamp_millis()).unwrap(), repo: "GameCult/Huginn".into(), actor: "libby".into(), change: RepoChange::Pushed { commits: 1 } }
+}
+
+/// Counts how often her persona is read, which only a tick that may run does.
+struct CountedPersona(Persona, std::cell::Cell<usize>);
+
+impl PersonaSource for CountedPersona {
+    fn persona(&self) -> Result<PersonaRead> {
+        self.1.set(self.1.get() + 1);
+        self.0.persona()
+    }
+}
+
+fn thought_doc(label: &str, text: &str) -> PipelineDocument {
+    PipelineDocument::Thought(PipelineThought {
+        instance: Slug(INSTANCE.into()),
+        label: label.into(),
+        text: text.into(),
+        reads: vec![],
+        persona_receipt: "mind-commit-0".into(),
+        identity: "I".into(),
+        context: "".into(),
+        stimulus: "".into(),
+        projector_model: "projector".into(),
+        projection: "A projection.".into(),
+        base_model: "base".into(),
+        temperature_permille: 1000,
+        min_p_permille: 50,
+        max_tokens: 160,
+        candidates: vec![text.into()],
+        nearest_permille: vec![1000],
+        chosen: 0,
+        projector_ms: 0,
+        continuer_ms: 0,
+        prompt_version: "test".into(),
+    })
+}
+
+/// A mind with an old memory about Libby and one thought at `thought_at`.
+fn mind_with_thought(thought_at: i64) -> TestMind {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(10));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "Libby wants the sounds before the shaders", &["@libby:chat"])]);
+    mind.admit_at(t(thought_at));
+    mind.committed(vec![thought_doc(&ticked(thought_at), "An earlier drift")]);
+    mind
+}
+
+fn organs<'a>(mind: &'a dyn MindPort, persona: &'a Persona, model: &'a Fake) -> Organs<'a> {
+    Organs { mind, persona, model, projector_model: "projector:test", base_model: "base:test" }
+}
+
+fn thoughts(mind: &TestMind) -> Vec<String> {
+    mind.ids(PipelineKind::Thought)
+}
+
+#[test]
+fn budgets_leave_room_for_every_section() {
+    let sum: usize = BUDGETS.iter().map(|(_, budget)| budget).sum();
+    assert!(sum + BUDGETS.len() <= SECTION_MAX_BYTES, "{sum}");
+}
+
+#[test]
+fn seed_reads_no_thought() {
+    let without = TestMind::seeded();
+    without.committed(vec![memory("m1", MemorySort::Learned, "Libby wants the sounds first", &["@libby:chat"])]);
+    let with = TestMind::seeded();
+    with.committed(vec![memory("m1", MemorySort::Learned, "Libby wants the sounds first", &["@libby:chat"])]);
+    with.committed(vec![thought_doc("t1", "A drift that must stay out of the seed")]);
+    let (plain, thoughtful) = (Wrap::over(&without, &[]), Wrap::over(&with, &[]));
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let one = seed_of(&plain, &read, None, t(100_000)).unwrap();
+    let two = seed_of(&thoughtful, &read, None, t(100_000)).unwrap();
+    assert_eq!(one.projector_prompt(), two.projector_prompt(), "a mind holding thoughts yields the prompt of the same mind without them");
+    assert_eq!(one.reads, two.reads);
+    assert!(!two.projector_prompt().contains("must stay out"));
+    let thought_schema = PipelineKind::Thought.type_id();
+    for selection in thoughtful.selections.borrow().iter() {
+        assert!(!selection.schemas.iter().flatten().any(|schema| schema == thought_schema), "a seed selection named thoughts: {selection:?}");
+    }
+}
+
+#[test]
+fn seed_carries_relationships() {
+    let mind = TestMind::seeded();
+    mind.committed(vec![
+        memory("m1", MemorySort::Learned, "Libby wants the sounds before the shaders", &["@libby:chat"]),
+        memory("m2", MemorySort::Rapport, "Noor distrusts the new scheduler", &["@noor:chat"]),
+        run("w1", RunTurn::SelfRun, RunOperator::Mind, &[]),
+    ]);
+    mind.committed(vec![PipelineDocument::Reply(PipelineReply {
+        instance: Slug(INSTANCE.into()),
+        label: "w1-r1".into(),
+        run: run_ref("w1"),
+        answers: vec![],
+        text: "The shader pass is done; the sounds are Libby's.".into(),
+    })]);
+    let seed = seed_of(&Wrap::over(&mind, &[]), &PersonaRead { state: state(), receipt_id: "r".into() }, None, t(100_000)).unwrap();
+    for wanted in ["Libby holds the sounds", "collaborator", "Libby wants the sounds before the shaders", "Noor distrusts the new scheduler", "The shader pass is done", "Coherence over velocity", "The shaders are late"] {
+        assert!(seed.context.contains(wanted), "{wanted:?} missing from {}", seed.context);
+    }
+    assert!(seed.identity.contains("Yggdrasil") && seed.identity.contains("she/her") && seed.identity.contains("Plain."));
+    assert!(seed.reads.iter().any(|read| read.kind == PipelineKind::Reply));
+    assert!(seed.reads.iter().any(|read| read.kind == PipelineKind::Memory));
+}
+
+#[test]
+fn seed_sections_keep_budgets() {
+    let huge = "x".repeat(3000);
+    let mut crowded = state();
+    crowded["values"] = json!((0..40).map(|at| json!({ "id": format!("v{at}"), "label": format!("Value {at}"), "priority": 0.5, "summary": huge })).collect::<Vec<_>>());
+    crowded["agencyPressure"]["pressures"] = json!((0..40).map(|_| json!({ "summary": huge })).collect::<Vec<_>>());
+    let mind = TestMind::seeded();
+    mind.committed(vec![memory("m1", MemorySort::Learned, "Libby wants the sounds first", &["@libby:chat"])]);
+    let seed = seed_of(&Wrap::over(&mind, &[]), &PersonaRead { state: crowded, receipt_id: "r".into() }, None, t(100_000)).unwrap();
+    assert!(seed.context.len() <= SECTION_MAX_BYTES, "{}", seed.context.len());
+    assert!(seed.context.contains("Libby holds the sounds"), "oversized values and pressures crowded out the bonds");
+    assert!(seed.context.contains("Libby wants the sounds first"), "oversized values and pressures crowded out the recall");
+    let values = seed.context.split("What presses on her:").next().unwrap();
+    assert!(values.len() <= BUDGETS[0].1 + 1, "values took {}", values.len());
+}
+
+#[test]
+fn stimulus_is_what_is_new() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(100));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "Before the thought, the kettle", &[])]);
+    mind.admit_at(t(200));
+    mind.committed(vec![thought_doc(&ticked(200), "A drift")]);
+    mind.admit_at(t(300));
+    mind.committed(vec![memory("m2", MemorySort::Decided, "After the thought, the window", &[]), run("w9", RunTurn::SelfRun, RunOperator::Mind, &[])]);
+    mind.admit_at(t(350));
+    mind.committed(vec![crate::testkit::close(run_ref("w9"), crate::testkit::recorded())]);
+    let wrap = Wrap::over(&mind, &[]);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let seed = seed_of(&wrap, &read, Some(t(200)), t(400)).unwrap();
+    assert!(seed.news);
+    assert!(seed.stimulus.contains("After the thought, the window"), "{}", seed.stimulus);
+    assert!(seed.stimulus.contains("w9 closed"), "a run closure is news: {}", seed.stimulus);
+    assert!(!seed.stimulus.contains("Before the thought, the kettle"), "{}", seed.stimulus);
+    assert!(seed.stimulus.find("closed").unwrap() < seed.stimulus.find("After the thought").unwrap(), "newest first");
+    assert!(seed.reads.contains(&reference(PipelineKind::Memory, &format!("{INSTANCE}:memory:m2"))));
+}
+
+#[test]
+fn stimulus_without_news_is_an_unbidden_memory_chosen_by_the_tick_label_else_the_nothing_line() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(100));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "The first old thing", &[]), memory("m2", MemorySort::Learned, "The second old thing", &[])]);
+    let long_after = 100 * 86_400;
+    mind.admit_at(t(long_after - 100));
+    mind.committed(vec![memory("m3", MemorySort::Learned, "A recent thing", &[])]);
+    let wrap = Wrap::over(&mind, &[]);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let picks: Vec<String> = (0..4)
+        .map(|offset| {
+            let seed = seed_of(&wrap, &read, Some(t(long_after - 10)), t(long_after + offset)).unwrap();
+            assert!(!seed.news);
+            seed.stimulus
+        })
+        .collect();
+    assert!(picks.iter().all(|stimulus| stimulus.starts_with("Out of nowhere you recall")), "{picks:?}");
+    assert!(picks.iter().all(|stimulus| !stimulus.contains("recent thing")), "a memory under 7 days old is not unbidden");
+    assert!(picks.iter().any(|stimulus| stimulus.contains("first old")) && picks.iter().any(|stimulus| stimulus.contains("second old")), "the label seeds a uniform pick: {picks:?}");
+    assert_eq!(picks[0], picks[2], "the same label seed picks the same memory");
+
+    let bare = TestMind::seeded();
+    let seed = seed_of(&Wrap::over(&bare, &[]), &read, Some(t(1000)), t(5000)).unwrap();
+    assert!(!seed.news);
+    assert!(seed.stimulus.starts_with("Nothing has happened since"), "{}", seed.stimulus);
+}
+
+#[test]
+fn cadence_from_newest_thought() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    let organs = organs(&wrap, &persona, &model);
+    let tick_at = |secs: i64| tick(&organs, &|| released(), Mode::Live, t(secs)).unwrap();
+    assert_eq!(tick_at(1000 + STREAM_MIN_GAP_S - 1), Outcome::NotDue, "no tick before the minimum gap");
+    assert_eq!(tick_at(1000 + STREAM_MIN_GAP_S), Outcome::NotDue, "past the minimum gap but nothing is new");
+    assert_eq!(model.calls(), 0);
+    assert_eq!(tick_at(1000 + STREAM_IDLE_GAP_S - 1), Outcome::NotDue);
+    assert_eq!(thoughts(&mind).len(), 1);
+    // Something new, past the minimum gap but short of the idle gap.
+    mind.admit_at(t(1000 + STREAM_MIN_GAP_S));
+    mind.committed(vec![memory("m9", MemorySort::Decided, "Something happened", &[])]);
+    let Outcome::Thought { admitted: true, .. } = tick_at(1000 + STREAM_MIN_GAP_S + 1) else { panic!("news past the minimum gap makes a thought") };
+    assert_eq!(thoughts(&mind).len(), 2);
+}
+
+#[test]
+fn the_idle_gap_alone_makes_a_tick_due() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    let Outcome::Thought { admitted: true, thought } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1000 + STREAM_IDLE_GAP_S)).unwrap() else { panic!("idle gap") };
+    assert_eq!(thought.label.0, format!("t{}", t(1000 + STREAM_IDLE_GAP_S).timestamp()));
+    assert!(due(None, t(0), false) && !due(Some(t(0)), t(STREAM_MIN_GAP_S), false) && due(Some(t(0)), t(STREAM_MIN_GAP_S), true));
+}
+
+#[test]
+fn held_brake_ticks_nothing() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    for reason in [HeldReason::BrakeHeld, HeldReason::BrakeAbsent, HeldReason::Undecodable] {
+        let held = tick(&organs(&wrap, &persona, &model), &move || Effective::Held { reason }, Mode::Live, t(100_000)).unwrap();
+        assert_eq!(held, Outcome::Held(reason));
+        let dry = tick(&organs(&wrap, &persona, &model), &move || Effective::Held { reason }, Mode::DryRun, t(100_000)).unwrap();
+        assert_eq!(dry, Outcome::Held(reason), "a dry run is held too");
+    }
+    assert_eq!(model.calls(), 0, "no model call");
+    assert!(wrap.admitted.borrow().is_empty() && wrap.selections.borrow().is_empty(), "no admission, and the mind was not read");
+}
+
+#[test]
+fn least_near_candidate_chosen() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["one", "two", "three", "four"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.9, 0.2, 0.2, 0.5]);
+    let Outcome::Thought { thought, admitted: true } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1000 + STREAM_IDLE_GAP_S)).unwrap() else { panic!("a thought") };
+    assert_eq!(thought.nearest_permille, vec![900, 200, 200, 500]);
+    assert_eq!(thought.chosen, 1, "the least near, the first on a tie");
+    assert_eq!(thought.text.0, "two");
+    assert_eq!(thought.candidates.iter().map(|line| line.0.as_str()).collect::<Vec<_>>(), ["one", "two", "three", "four"], "every candidate is kept in the trace");
+    assert_eq!(least_near(&[500, 100, 100]), 1);
+    assert_eq!(least_near(&[]), 0);
+}
+
+#[test]
+fn no_earlier_thought_is_nearness_1000() {
+    let mind = TestMind::seeded();
+    let model = Fake::saying("I turn it over.", &["one", "two"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[]);
+    let Outcome::Thought { thought, .. } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(5000)).unwrap() else { panic!("a thought") };
+    assert_eq!(thought.nearest_permille, vec![1000, 1000]);
+    assert_eq!(thought.chosen, 0);
+    assert_eq!((thought.projector_model.0.as_str(), thought.base_model.0.as_str(), thought.persona_receipt.0.as_str()), ("projector:test", "base:test", "mind-commit-1"));
+    assert_eq!((thought.temperature_permille, thought.min_p_permille, thought.max_tokens), (1000, 50, 160));
+}
+
+#[test]
+fn frame_holds_projection_verbatim() {
+    assert_eq!(continuer_frame("Yggdrasil", "9 October 2026", "I turn it over."), "Yggdrasil's notebook\n\n9 October 2026\n\nI turn it over.\n\n");
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I keep turning over the sounds.", &["a", "b", "c", "d", "e"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.3, 0.3, 0.3, 0.3]);
+    tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1000 + STREAM_IDLE_GAP_S)).unwrap();
+    let continued = model.continued.borrow();
+    let (prompt, sampling, n) = &continued[0];
+    assert_eq!(prompt, &continuer_frame("Yggdrasil", &t(1000 + STREAM_IDLE_GAP_S).format(FRAME_DATE_FORMAT).to_string(), "I keep turning over the sounds."));
+    assert_eq!((*n, *sampling), (4, Sampling::STREAM));
+    for foreign in ["Libby", "Coherence", "Plain.", "she/her", "private Projector"] {
+        assert!(!prompt.contains(foreign), "{foreign} reached the continuer");
+    }
+    let projected = model.projected.borrow();
+    assert!(projected[0].contains("private Projector") && projected[0].contains(STREAM_GUIDANCE), "the Projector prompt is Ghostlight's builder over her seed");
+    assert!(projected[0].contains("Libby holds the sounds"));
+}
+
+#[test]
+fn blank_and_faulty_ticks_admit_nothing() {
+    let mind = TestMind::seeded();
+    let persona = persona();
+    let blank = Fake::saying("A projection.", &["", "  \n", "\t"]);
+    let wrap = Wrap::over(&mind, &[]);
+    assert_eq!(tick(&organs(&wrap, &persona, &blank), &|| released(), Mode::Live, t(5000)).unwrap(), Outcome::Blank);
+    let silent_projector = Fake::saying("   ", &["x"]);
+    assert_eq!(tick(&organs(&wrap, &persona, &silent_projector), &|| released(), Mode::Live, t(5000)).unwrap(), Outcome::Blank);
+    let mut down = Fake::saying("x", &["x"]);
+    down.fault = true;
+    assert!(tick(&organs(&wrap, &persona, &down), &|| released(), Mode::Live, t(5000)).is_err());
+    assert!(wrap.admitted.borrow().is_empty() && thoughts(&mind).is_empty());
+}
+
+#[test]
+fn dry_run_admits_nothing() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift", "Another"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.4, 0.6]);
+    let Outcome::Thought { thought, admitted } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::DryRun, t(1001)).unwrap() else { panic!("a dry run prints a thought") };
+    assert!(!admitted);
+    assert_eq!(thought.text.0, "A new drift");
+    assert!(wrap.admitted.borrow().is_empty());
+    assert_eq!(thoughts(&mind).len(), 1);
+    assert!(serde_json::to_string(&*thought).unwrap().contains("\"candidates\""));
+}
+
+#[test]
+fn stream_admits_only_thoughts() {
+    let mind = TestMind::seeded();
+    mind.committed(vec![memory("m1", MemorySort::Learned, "Libby wants the sounds first", &["@libby:chat"])]);
+    let model = Fake::saying("I turn it over.", &["A drift", "Another"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[]);
+    let Outcome::Thought { thought, admitted: true } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(100_000)).unwrap() else { panic!("a thought") };
+    let batches = wrap.admitted.borrow();
+    assert_eq!(batches.len(), 1);
+    assert!(matches!(batches[0].as_slice(), [PipelineDocument::Thought(_)]), "exactly one thought and nothing else");
+    let stored = mind.view(PipelineKind::Thought, &format!("{INSTANCE}:thought:t{}", t(100_000).timestamp())).expect("admitted under its instance-rooted key");
+    assert_eq!(stored.document, PipelineDocument::Thought(*thought.clone()));
+    assert!(thought.reads.iter().any(|read| read.kind == PipelineKind::Memory), "the thought cites what the seed read");
+    assert_eq!(mind.ids(PipelineKind::Memory).len(), 1, "no memory was written");
+}
+
+// ---------------------------------------------------------------------------------------------
+// The model port against a fake HTTP server.
+
+type Seen = Arc<Mutex<Vec<(String, Value)>>>;
+
+fn serve(answers: Vec<String>) -> (String, Seen) {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let endpoint = format!("http://{}", listener.local_addr().unwrap());
+    let seen: Seen = Arc::default();
+    let record = Arc::clone(&seen);
+    std::thread::spawn(move || {
+        for answer in answers {
+            let (mut socket, _) = listener.accept().unwrap();
+            let mut raw = Vec::new();
+            let mut buffer = [0u8; 4096];
+            let (head, length) = loop {
+                let read = socket.read(&mut buffer).unwrap();
+                raw.extend_from_slice(&buffer[..read]);
+                if let Some(end) = raw.windows(4).position(|window| window == b"\r\n\r\n") {
+                    let head = String::from_utf8_lossy(&raw[..end]).to_string();
+                    let length = head.lines().find_map(|line| line.to_ascii_lowercase().strip_prefix("content-length:").map(|value| value.trim().parse::<usize>().unwrap())).unwrap_or(0);
+                    if raw.len() >= end + 4 + length {
+                        break (head, (end + 4, length));
+                    }
+                }
+                assert!(read > 0, "the client closed early");
+            };
+            let body: Value = serde_json::from_slice(&raw[length.0..length.0 + length.1]).unwrap();
+            let path = head.lines().next().unwrap().split_whitespace().nth(1).unwrap().to_owned();
+            record.lock().unwrap().push((path, body));
+            write!(socket, "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{answer}", answer.len()).unwrap();
+        }
+    });
+    (endpoint, seen)
+}
+
+#[test]
+fn raw_generate_is_raw() {
+    let (endpoint, seen) = serve(vec![json!({ "response": "one" }).to_string(), json!({ "response": "two" }).to_string()]);
+    let model = OllamaStream::open(&endpoint, "projector:x", "base:y").unwrap();
+    let out = model.continue_raw("The frame\n\n", &Sampling::STREAM, 2).unwrap();
+    assert_eq!(out, ["one", "two"]);
+    let seen = seen.lock().unwrap();
+    assert_eq!(seen.len(), 2, "one call per continuation");
+    for (path, body) in seen.iter() {
+        assert_eq!(path, "/api/generate");
+        assert_eq!(body["raw"], json!(true));
+        assert_eq!(body["stream"], json!(false));
+        assert_eq!(body["model"], json!("base:y"));
+        assert_eq!(body["prompt"], json!("The frame\n\n"));
+        assert_eq!(body["options"], json!({ "temperature": 1.0, "min_p": 0.05, "num_predict": 160, "stop": ["\n\n"], "num_thread": 4 }));
+    }
+}
+
+#[test]
+fn the_projector_is_asked_in_chat() {
+    let (endpoint, seen) = serve(vec![json!({ "message": { "role": "assistant", "content": "I hold it." } }).to_string()]);
+    let model = OllamaStream::open(&endpoint, "projector:x", "base:y").unwrap();
+    assert_eq!(model.project("Be the Projector.").unwrap(), "I hold it.");
+    let seen = seen.lock().unwrap();
+    assert_eq!(seen[0].0, "/api/chat");
+    assert_eq!(seen[0].1, json!({ "model": "projector:x", "stream": false, "messages": [{ "role": "user", "content": "Be the Projector." }] }));
+}
+
+#[test]
+fn a_model_host_that_answers_badly_is_a_fault() {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let endpoint = format!("http://{}", listener.local_addr().unwrap());
+    std::thread::spawn(move || {
+        let (mut socket, _) = listener.accept().unwrap();
+        let mut buffer = [0u8; 4096];
+        let _ = socket.read(&mut buffer);
+        let _ = socket.write_all(b"HTTP/1.1 500 Internal Server Error\r\ncontent-length: 4\r\nconnection: close\r\n\r\nboom");
+    });
+    let model = OllamaStream::open(&endpoint, "p", "b").unwrap();
+    let fault = model.project("x").unwrap_err().to_string();
+    assert!(fault.contains("500"), "{fault}");
+}
+
+#[test]
+fn non_loopback_endpoint_refused() {
+    for refused in [
+        "http://localhost:11434@example.com",
+        "http://localhost@example.com",
+        "http://127.0.0.1:11434@example.com:80",
+        "http://user:secret@127.0.0.1:11434",
+        "http://127.0.0.1:11434@localhost",
+        "http://[::1]:11434@example.com",
+        "http://localhost:11434\\@example.com",
+        "http://example.com#@127.0.0.1",
+        "http://example.com?@localhost",
+        "http://127.0.0.1:11434?x=1",
+        "http://localhost.example.com:11434",
+        "http://",
+        "",
+    ] {
+        assert!(OllamaStream::open(refused, "p", "b").is_err(), "{refused} must be refused");
+    }
+    for refused in ["http://10.77.0.1:11434", "http://example.com:11434", "http://0.0.0.0:11434", "https://127.0.0.1:11434", "127.0.0.1:11434", "http://127.0.0.1:11434/api", "http://[2001:db8::1]:11434"] {
+        assert!(OllamaStream::open(refused, "p", "b").is_err(), "{refused} must be refused");
+    }
+    for opened in ["http://127.0.0.1:11434", "http://localhost:11434", "http://[::1]:11434", "http://127.0.0.2:1/", "http://LOCALHOST:11434/"] {
+        assert!(OllamaStream::open(opened, "p", "b").is_ok(), "{opened} is loopback");
+    }
+}
+
+#[test]
+fn cap_cuts_at_a_line_else_at_a_character() {
+    assert_eq!(cap("short", 10), "short");
+    assert_eq!(cap("ab\ncd", 4), "ab", "whole lines only");
+    assert_eq!(cap("abcdef", 4), "abcd", "no newline to cut at");
+    assert_eq!(cap("\nabc", 3), "\nab", "a newline at the very start is no cut point");
+    assert_eq!(cap("aé\nb", 2), "a", "never inside a character");
+    assert_eq!(cap("ééé", 5), "éé");
+}
+
+#[test]
+fn bonds_name_the_label_else_the_id_else_someone() {
+    let line = |bond: Value| bond_line(&bond);
+    assert_eq!(line(json!({ "object": { "label": "Libby", "id": "@libby:chat" }, "relationshipKind": "friend", "summary": "s" })), "- Libby (friend): s");
+    assert_eq!(line(json!({ "object": { "label": "", "id": "@libby:chat" }, "relationshipKind": "friend", "summary": "s" })), "- @libby:chat (friend): s");
+    assert_eq!(line(json!({ "object": {}, "relationshipKind": "friend", "summary": "s" })), "- someone (friend): s");
+}
+
+#[test]
+fn only_person_bonds_with_ids_are_people_she_asks_her_memories_about() {
+    let state = json!({ "affect": { "socialBonds": [
+        { "object": { "kind": "person", "id": "@libby:chat" } },
+        { "object": { "kind": "repo", "id": "GameCult/Huginn" } },
+        { "object": { "kind": "person", "id": "" } },
+        { "object": { "kind": "person", "id": "@noor:chat" } },
+    ] } });
+    assert_eq!(bonded_people(&state), ["@libby:chat", "@noor:chat"]);
+    assert!(bonded_people(&json!({})).is_empty());
+}
+
+#[test]
+fn news_is_strictly_after_her_newest_thought() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(500));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "Admitted at the very instant of the thought", &[])]);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let seed = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(500)), t(600)).unwrap();
+    assert!(!seed.news, "{}", seed.stimulus);
+    let seed = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(499)), t(600)).unwrap();
+    assert!(seed.news);
+}
+
+#[test]
+fn an_unbidden_memory_is_older_than_seven_days_not_exactly_seven() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(1000));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "The week-old thing", &[])]);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let week = 7 * 86_400;
+    let exactly = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(1000)), t(1000 + week)).unwrap();
+    assert!(exactly.stimulus.starts_with("Nothing has happened"), "{}", exactly.stimulus);
+    let over = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(1000)), t(1001 + week)).unwrap();
+    assert!(over.stimulus.contains("The week-old thing"), "{}", over.stimulus);
+}
+
+#[test]
+fn a_flood_of_news_fills_the_stimulus_with_whole_lines_newest_first() {
+    let mind = TestMind::seeded();
+    let flood: Vec<PipelineDocument> = (0..60).map(|at| memory(&format!("f{at:02}"), MemorySort::Learned, &format!("{at:02} {}", "w".repeat(150)), &[])).collect();
+    mind.admit_at(t(100));
+    mind.committed(flood);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let seed = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(50)), t(200)).unwrap();
+    let lines: Vec<&str> = seed.stimulus.lines().skip(1).collect();
+    assert!(seed.stimulus.len() <= SECTION_MAX_BYTES && seed.stimulus.len() > SECTION_MAX_BYTES - 250, "{}", seed.stimulus.len());
+    assert!(lines.iter().all(|line| line.starts_with("- You noted") && line.ends_with('"')), "a line was cut: {lines:?}");
+    assert!(lines.len() > 10 && lines.len() < 30, "{}", lines.len());
+    let cited = seed.reads.iter().filter(|read| read.kind == PipelineKind::Memory).count();
+    assert!(cited >= lines.len() && cited <= lines.len() + 12, "the thought cites what its stimulus showed: {cited} reads for {} lines", lines.len());
+    let newest = lines[0];
+    assert!(newest.contains("\"29 ") || newest.contains("\"59 "), "newest first: {newest}");
+}
+
+#[test]
+fn the_newest_thought_sets_the_cadence_not_the_oldest() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(100));
+    mind.committed(vec![thought_doc(&ticked(100), "An old drift")]);
+    mind.admit_at(t(10_000));
+    mind.committed(vec![thought_doc(&ticked(10_000), "A recent drift")]);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    let tick_at = |secs: i64| tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(secs)).unwrap();
+    assert_eq!(tick_at(10_000 + STREAM_MIN_GAP_S - 1), Outcome::NotDue, "a recent thought holds the stream back whatever the oldest says");
+    assert_eq!(model.calls(), 0);
+}
+
+#[test]
+fn news_at_exactly_the_minimum_gap_is_due() {
+    let mind = mind_with_thought(1000);
+    mind.admit_at(t(1500));
+    mind.committed(vec![memory("m9", MemorySort::Decided, "Something happened", &[])]);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    let Outcome::Thought { admitted: true, .. } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1000 + STREAM_MIN_GAP_S)).unwrap() else { panic!("due at the minimum gap") };
+}
+
+#[test]
+fn repo_activity_is_news_only_after_her_newest_thought_and_is_stamped_when_it_happened() {
+    let mind = mind_with_thought(1000);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let old = Wrap::over(&mind, &[]).with_forge(vec![push(1, 500)]);
+    let seed = seed_of(&old, &read, Some(t(1000)), t(1901)).unwrap();
+    assert!(!seed.news && !seed.stimulus.contains("Changes in your repos"), "an event older than her newest thought is not news: {}", seed.stimulus);
+    let edge = Wrap::over(&mind, &[]).with_forge(vec![push(1, 1000)]);
+    assert!(!seed_of(&edge, &read, Some(t(1000)), t(1901)).unwrap().news, "an event at her newest thought's time is not after it");
+    let mixed = Wrap::over(&mind, &[]).with_forge(vec![push(2, 1500), push(1, 500)]);
+    let seed = seed_of(&mixed, &read, Some(t(1000)), t(1901)).unwrap();
+    assert!(seed.news && seed.stimulus.contains("Changes in your repos: GameCult/Huginn: 1 commit pushed by libby"), "{}", seed.stimulus);
+    let stamp = t(1500).to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+    assert!(seed.stimulus.contains(&format!("at={stamp} ")), "the notice carries the event's time, not the tick's: {}", seed.stimulus);
+    let first = Wrap::over(&mind, &[]).with_forge(vec![push(1, 500)]);
+    assert!(seed_of(&first, &read, None, t(1901)).unwrap().news, "with no thought yet, what the forge holds is news");
+}
+
+#[test]
+fn a_capped_repo_is_news_only_beside_a_forge_event_after_her_newest_thoughts_label() {
+    let mind = mind_with_thought(1000);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let mut quiet = Wrap::over(&mind, &[]).with_forge(vec![push(1, 500)]);
+    quiet.forge.as_mut().unwrap().capped.push("GameCult/Huginn".into());
+    assert!(!seed_of(&quiet, &read, Some(t(1000)), t(1901)).unwrap().news);
+    let mut busy = Wrap::over(&mind, &[]).with_forge(vec![push(2, 1500)]);
+    busy.forge.as_mut().unwrap().capped.push("GameCult/Huginn".into());
+    let seed = seed_of(&busy, &read, Some(t(1000)), t(1901)).unwrap();
+    assert!(seed.news && seed.stimulus.to_lowercase().contains("page limit"), "{}", seed.stimulus);
+}
+
+#[test]
+fn old_repo_activity_does_not_make_a_tick_due() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = CountedPersona(persona(), std::cell::Cell::new(0));
+    let wrap = Wrap::over(&mind, &[0.1]).with_forge(vec![push(1, 500)]);
+    let organs = Organs { mind: &wrap, persona: &persona, model: &model, projector_model: "projector:test", base_model: "base:test" };
+    assert_eq!(tick(&organs, &|| released(), Mode::Live, t(1901)).unwrap(), Outcome::NotDue);
+    assert_eq!((model.calls(), persona.1.get(), thoughts(&mind).len()), (0, 0, 1), "no model call, no seed, no thought");
+}
+
+#[test]
+fn new_repo_activity_makes_a_tick_due_and_the_hourly_memory_comes_for_an_active_steward() {
+    let week = 8 * 86_400;
+    let mind = TestMind::seeded();
+    mind.admit_at(t(100));
+    mind.committed(vec![memory("m1", MemorySort::Learned, "An old thing she holds", &[])]);
+    mind.admit_at(t(week));
+    mind.committed(vec![thought_doc(&ticked(week), "An earlier drift")]);
+    let model = Fake::saying("I turn it over.", &["A new drift", "Another"]);
+    let persona = persona();
+    let fresh = Wrap::over(&mind, &[0.1, 0.2]).with_forge(vec![push(2, week + 1000)]);
+    let Outcome::Thought { thought, admitted: true } = tick(&organs(&fresh, &persona, &model), &|| released(), Mode::Live, t(week + 2 * STREAM_MIN_GAP_S)).unwrap() else { panic!("new activity at the next gap mark") };
+    assert!(thought.stimulus.0.contains("Changes in your repos"), "{}", thought.stimulus.0);
+
+    let model = Fake::saying("I turn it over.", &["Yet another"]);
+    let quiet = Wrap::over(&mind, &[0.3]).with_forge(vec![push(1, week - 5000)]);
+    let at = week + 1000 + STREAM_MIN_GAP_S + STREAM_IDLE_GAP_S + 10;
+    let Outcome::Thought { thought, admitted: true } = tick(&organs(&quiet, &persona, &model), &|| released(), Mode::Live, t(at)).unwrap() else { panic!("the idle gap") };
+    assert!(thought.stimulus.0.starts_with("Out of nowhere you recall"), "old activity is not news, so the hourly memory comes: {}", thought.stimulus.0);
+}
+
+#[test]
+fn reads_cite_only_what_the_context_showed() {
+    let mind = TestMind::seeded();
+    let memories: Vec<PipelineDocument> = (0..12).map(|at| memory(&format!("m{at:02}"), MemorySort::Learned, &format!("zz{at:02} {}", "x".repeat(290)), &["@libby:chat"])).collect();
+    mind.admit_at(t(100));
+    mind.committed(memories);
+    mind.admit_at(t(200));
+    mind.committed(vec![run("w1", RunTurn::SelfRun, RunOperator::Mind, &[])]);
+    mind.committed(
+        (1..=3)
+            .map(|at| PipelineDocument::Reply(PipelineReply { instance: Slug(INSTANCE.into()), label: format!("w1-r{at}").as_str().into(), run: run_ref("w1"), answers: vec![], text: format!("rp{at} {}", "y".repeat(400)).as_str().into() }))
+            .collect(),
+    );
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let seed = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(300)), t(400)).unwrap();
+    assert!(!seed.news);
+    let cited: Vec<String> = seed.reads.iter().filter(|read| read.kind == PipelineKind::Memory).map(|read| read.id.0.rsplit(':').next().unwrap().to_owned()).collect();
+    assert!(!cited.is_empty() && cited.len() < 12, "{cited:?}");
+    for label in &cited {
+        assert!(seed.context.contains(&format!("zz{}", &label[1..])), "{label} is cited but not shown");
+    }
+    let shown = (0..12).filter(|at| seed.context.contains(&format!("zz{at:02}"))).count();
+    assert_eq!(shown, cited.len(), "every memory the context shows is cited");
+    let replies_cited = seed.reads.iter().filter(|read| read.kind == PipelineKind::Reply).count();
+    let replies_shown = (1..=3).filter(|at| seed.context.contains(&format!("rp{at} "))).count();
+    assert!(replies_shown >= 1 && replies_shown < 3, "the replies section is bounded: {replies_shown}");
+    assert_eq!(replies_cited, replies_shown, "replies cited are the replies shown");
+}
+
+#[test]
+fn every_thought_records_the_fixed_parts_of_its_prompts() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]);
+    let Outcome::Thought { thought, .. } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1000 + STREAM_IDLE_GAP_S)).unwrap() else { panic!("idle gap") };
+    let version = &thought.prompt_version.0;
+    assert_eq!(version, &prompt_version());
+    let guidance = format!("{STREAM_GUIDANCE:?}");
+    for part in [guidance.as_str(), GHOSTLIGHT_REV, "words=180", "<name>'s notebook", "<projection>", "<date %-d %B %Y>"] {
+        assert!(version.contains(part), "{part} missing from {version}");
+    }
+    assert!(version.len() <= LINE_MAX_BYTES, "{}", version.len());
+    assert!(include_str!("../../Cargo.toml").contains(GHOSTLIGHT_REV), "the recorded revision is the manifest's pin");
+    let rebuilt = build_projector_prompt(&ProjectorPrompt { identity: &thought.identity.0, typed_context: &thought.context.0, visible_stimulus: &thought.stimulus.0, domain_guidance: STREAM_GUIDANCE, word_budget: PROJECTOR_WORDS });
+    assert_eq!(model.projected.borrow()[0], rebuilt, "the trace rebuilds the Projector's exact prompt");
+}
+
+
+/// A thought ticked at 900 s and admitted at 1000 s: what landed at 950 s while the models ran is news to the next one.
+#[test]
+fn what_lands_while_she_thinks_is_news_to_the_next_thought() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(950));
+    mind.committed(vec![memory("m9", MemorySort::Decided, "Landed while the Projector ran", &[])]);
+    mind.admit_at(t(1000));
+    mind.committed(vec![thought_doc(&ticked(900), "A drift that took a hundred seconds")]);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]).with_forge(vec![push(2, 1000), push(1, 950), push(0, 899)]);
+    let Outcome::Thought { thought, admitted: true } = tick(&organs(&wrap, &persona, &model), &|| released(), Mode::Live, t(1901)).unwrap() else { panic!("news past the gap") };
+    assert!(thought.stimulus.0.contains("Landed while the Projector ran"), "{}", thought.stimulus.0);
+    assert!(thought.stimulus.0.contains("2 commits pushed by libby"), "the pushes at 950 s and 1000 s, not the one at 899 s: {}", thought.stimulus.0);
+}
+
+#[test]
+fn a_capped_repo_is_judged_by_its_own_events_and_disclosed_when_they_do_not_decide_it() {
+    let mind = mind_with_thought(1000);
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let cultlib = |id, secs| RepoEvent { repo: "GameCult/CultLib".into(), ..push(id, secs) };
+    let mut two = Wrap::over(&mind, &[]).with_forge(vec![push(2, 1500), cultlib(1, 500)]);
+    two.forge.as_mut().unwrap().capped = vec!["GameCult/Huginn".into(), "GameCult/CultLib".into()];
+    let seed = seed_of(&two, &read, Some(t(1000)), t(1901)).unwrap();
+    assert!(seed.stimulus.to_lowercase().contains("page limit") && seed.stimulus.contains("GameCult/Huginn"), "the repo no event decides stays disclosed: {}", seed.stimulus);
+    assert!(!seed.stimulus.contains("GameCult/CultLib"), "an event before her thought decides CultLib's cap: {}", seed.stimulus);
+    let mut flooded = Wrap::over(&mind, &[]).with_forge(vec![]);
+    flooded.forge.as_mut().unwrap().capped = vec!["GameCult/Huginn".into()];
+    let seed = seed_of(&flooded, &read, Some(t(1000)), t(1901)).unwrap();
+    assert!(seed.news && seed.stimulus.to_lowercase().contains("page limit"), "a cap with no event at all is disclosed: {}", seed.stimulus);
+}
+
+#[test]
+fn a_quiet_hour_reads_the_forge_at_each_gap_mark_only() {
+    let mind = mind_with_thought(1000);
+    let model = Fake::saying("I turn it over.", &["A new drift"]);
+    let persona = persona();
+    let wrap = Wrap::over(&mind, &[0.1]).with_forge(vec![push(1, 500)]);
+    let organs = organs(&wrap, &persona, &model);
+    let mut secs = 1000 + STREAM_POLL_S;
+    while secs < 1000 + STREAM_IDLE_GAP_S {
+        assert_eq!(tick(&organs, &|| released(), Mode::Live, t(secs)).unwrap(), Outcome::NotDue, "at {secs}");
+        secs += STREAM_POLL_S;
+    }
+    assert_eq!(wrap.forge_reads.get(), 3, "one read for each mark crossed at 900, 1800 and 2700 s");
+    assert_eq!(model.calls(), 0);
+}
+
+#[test]
+fn identical_memory_lines_are_each_cited_once() {
+    let mind = TestMind::seeded();
+    mind.admit_at(t(100));
+    mind.committed((0..12).map(|at| memory(&format!("m{at:02}"), MemorySort::Learned, &format!("the same thing {}", "x".repeat(290)), &["@libby:chat"])).collect());
+    let read = PersonaRead { state: state(), receipt_id: "r".into() };
+    let seed = seed_of(&Wrap::over(&mind, &[]), &read, Some(t(300)), t(400)).unwrap();
+    let shown = seed.context.lines().filter(|line| line.contains("the same thing")).count();
+    let cited = seed.reads.iter().filter(|read| read.kind == PipelineKind::Memory).count();
+    assert!(shown >= 1 && cited == shown, "{shown} lines shown, {cited} cited");
+}
+
+/// The environment's proxy settings are read when an agent is built, so the check runs in a child process that has them.
+#[test]
+fn the_stream_agent_ignores_the_proxy_environment() {
+    if std::env::var("STREAM_PROXY_CHILD").is_ok() {
+        let plain: ureq::Agent = ureq::Agent::config_builder().build().into();
+        assert!(plain.config().proxy().is_some(), "the child's environment names a proxy");
+        let stream = OllamaStream::open("http://127.0.0.1:9", "p", "b").unwrap();
+        assert!(stream.agent.config().proxy().is_none(), "the stream's agent took the environment's proxy");
+        assert_eq!(stream.agent.config().max_redirects(), 0);
+        return;
+    }
+    let child = std::process::Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", "stream::tests::the_stream_agent_ignores_the_proxy_environment", "--nocapture"])
+        .env("STREAM_PROXY_CHILD", "1")
+        .env("ALL_PROXY", "http://192.0.2.1:3128")
+        .env("HTTP_PROXY", "http://192.0.2.1:3128")
+        .output()
+        .unwrap();
+    assert!(child.status.success(), "{}{}", String::from_utf8_lossy(&child.stdout), String::from_utf8_lossy(&child.stderr));
+}
diff --git a/crates/mind-body/tests/public_surface.txt b/crates/mind-body/tests/public_surface.txt
index cdf646b..84c1995 100644
--- a/crates/mind-body/tests/public_surface.txt
+++ b/crates/mind-body/tests/public_surface.txt
@@ -9,6 +9,7 @@ mind_body: mod lease_client
 mind_body: mod persona
 mind_body: mod queue
 mind_body: mod self_run
+mind_body: mod stream
 mind_body: mod tempo
 mind_body::address: impl Addressee
 mind_body::address: struct Addressee # [derive (Clone , Debug , PartialEq , Eq , serde :: Serialize , serde :: Deserialize)] pub-fields[]
@@ -281,6 +282,28 @@ mind_body::self_run::inbox: fn derive_counting_held (mind : & dyn MindPort , hol
 mind_body::self_run::inbox: fn render (briefs : & [Brief] , plan : & str) -> String
 mind_body::self_run::inbox: fn resolving_sentence (id : & str) -> String
 mind_body::self_run::inbox: struct Brief # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[id: String, campaign: String, repo: String, item: String, ordinal: u64]
+mind_body::stream: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum Mode { Live , DryRun , }
+mind_body::stream: # [derive (Clone , Debug , PartialEq)] pub enum Outcome { Held (crate :: control :: HeldReason) , NotDue , Blank , Thought { thought : Box < PipelineThought > , admitted : bool } , }
+mind_body::stream: const AGENT : & str
+mind_body::stream: const STREAM_IDLE_GAP_S : i64
+mind_body::stream: const STREAM_MIN_GAP_S : i64
+mind_body::stream: const STREAM_POLL_S : i64
+mind_body::stream: fn tick (organs : & Organs , brake : & dyn Fn () -> Effective , mode : Mode , now : DateTime < Utc >) -> Result < Outcome >
+mind_body::stream: impl HuginnPersonaSource
+mind_body::stream: impl HuginnPersonaSource: fn new (client : HuginnClient) -> Self
+mind_body::stream: impl OllamaStream
+mind_body::stream: impl OllamaStream: fn open (endpoint : & str , projector_model : & str , base_model : & str) -> Result < Self >
+mind_body::stream: impl PersonaSource for HuginnPersonaSource
+mind_body::stream: impl Sampling
+mind_body::stream: impl Seed
+mind_body::stream: impl StreamModel for OllamaStream
+mind_body::stream: pub trait PersonaSource { fn persona (& self) -> Result < PersonaRead > ; }
+mind_body::stream: pub trait StreamModel { fn project (& self , prompt : & str) -> Result < String > ; fn continue_raw (& self , prompt : & str , sampling : & Sampling , n : usize) -> Result < Vec < String > > ; }
+mind_body::stream: struct HuginnPersonaSource  pub-fields[]
+mind_body::stream: struct OllamaStream  pub-fields[]
+mind_body::stream: struct Organs< 'a >  pub-fields[mind: & 'a dyn MindPort, persona: & 'a dyn PersonaSource, model: & 'a dyn StreamModel, projector_model: & 'a str, base_model: & 'a str]
+mind_body::stream: struct PersonaRead  pub-fields[state: Value, receipt_id: String]
+mind_body::stream: struct Sampling # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub-fields[temperature_permille: u16, min_p_permille: u16, max_tokens: u16]
 mind_body::tempo: const DEFAULT_BEAT_S : u32
 mind_body::tempo: const FALLBACK_MAX_S : u32
 mind_body::tempo: const FALLBACK_MIN_S : u32
diff --git a/schemas/cultnet/epiphany.pipeline.finding.v2.schema.json b/schemas/cultnet/epiphany.pipeline.finding.v2.schema.json
index e12479a..c796942 100644
--- a/schemas/cultnet/epiphany.pipeline.finding.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.finding.v2.schema.json
@@ -176,7 +176,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.follow_up.v2.schema.json b/schemas/cultnet/epiphany.pipeline.follow_up.v2.schema.json
index 7b550cf..4fde353 100644
--- a/schemas/cultnet/epiphany.pipeline.follow_up.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.follow_up.v2.schema.json
@@ -159,7 +159,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.idea.v2.schema.json b/schemas/cultnet/epiphany.pipeline.idea.v2.schema.json
index 60660e3..38e2b48 100644
--- a/schemas/cultnet/epiphany.pipeline.idea.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.idea.v2.schema.json
@@ -35,7 +35,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.memory.v2.schema.json b/schemas/cultnet/epiphany.pipeline.memory.v2.schema.json
index c0dd2e6..e21595e 100644
--- a/schemas/cultnet/epiphany.pipeline.memory.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.memory.v2.schema.json
@@ -131,7 +131,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.question.v2.schema.json b/schemas/cultnet/epiphany.pipeline.question.v2.schema.json
index 4dfa10b..5d47c9f 100644
--- a/schemas/cultnet/epiphany.pipeline.question.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.question.v2.schema.json
@@ -40,7 +40,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.reply.v2.schema.json b/schemas/cultnet/epiphany.pipeline.reply.v2.schema.json
index b37da5a..706efa9 100644
--- a/schemas/cultnet/epiphany.pipeline.reply.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.reply.v2.schema.json
@@ -30,7 +30,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.research.v2.schema.json b/schemas/cultnet/epiphany.pipeline.research.v2.schema.json
index 73dbcba..3e70f18 100644
--- a/schemas/cultnet/epiphany.pipeline.research.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.research.v2.schema.json
@@ -102,7 +102,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.resolution.v2.schema.json b/schemas/cultnet/epiphany.pipeline.resolution.v2.schema.json
index e4d2f1b..09cab1d 100644
--- a/schemas/cultnet/epiphany.pipeline.resolution.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.resolution.v2.schema.json
@@ -35,7 +35,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.ruling.v2.schema.json b/schemas/cultnet/epiphany.pipeline.ruling.v2.schema.json
index 9e6511c..9740c65 100644
--- a/schemas/cultnet/epiphany.pipeline.ruling.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.ruling.v2.schema.json
@@ -73,7 +73,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.run.v2.schema.json b/schemas/cultnet/epiphany.pipeline.run.v2.schema.json
index 4cbb021..36d9de8 100644
--- a/schemas/cultnet/epiphany.pipeline.run.v2.schema.json
+++ b/schemas/cultnet/epiphany.pipeline.run.v2.schema.json
@@ -30,7 +30,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ],
       "type": "string"
     },
diff --git a/schemas/cultnet/epiphany.pipeline.thought.v2.schema.json b/schemas/cultnet/epiphany.pipeline.thought.v2.schema.json
new file mode 100644
index 0000000..3ce3347
--- /dev/null
+++ b/schemas/cultnet/epiphany.pipeline.thought.v2.schema.json
@@ -0,0 +1,190 @@
+{
+  "$defs": {
+    "Label": {
+      "description": "A key label: `[A-Za-z0-9_-]{1,64}`.",
+      "maxLength": 64,
+      "type": "string"
+    },
+    "Line": {
+      "description": "Text of at most 1,000 UTF-8 bytes.",
+      "maxLength": 1000,
+      "type": "string"
+    },
+    "Para": {
+      "description": "Text of at most 4,000 UTF-8 bytes; longer narrative is cited by `DocRef`.",
+      "maxLength": 4000,
+      "type": "string"
+    },
+    "PipelineKind": {
+      "enum": [
+        "Campaign",
+        "Target",
+        "Question",
+        "Ruling",
+        "CutSpec",
+        "CutReport",
+        "Verdict",
+        "Finding",
+        "FollowUp",
+        "Resolution",
+        "Instance",
+        "Stewardship",
+        "HandOff",
+        "Run",
+        "Pulse",
+        "Memory",
+        "Research",
+        "Idea",
+        "Reply",
+        "Thought"
+      ],
+      "type": "string"
+    },
+    "PipelineRef": {
+      "description": "A reference to another document. The id is parsed as a full pipeline id of\nthe declared `kind`, so the kind and the id's kind segment cannot disagree.",
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/Short"
+        },
+        "kind": {
+          "$ref": "#/$defs/PipelineKind"
+        }
+      },
+      "required": [
+        "kind",
+        "id"
+      ],
+      "type": "object"
+    },
+    "Short": {
+      "description": "Text of at most 200 UTF-8 bytes.",
+      "maxLength": 200,
+      "type": "string"
+    },
+    "Slug": {
+      "description": "A campaign slug or key segment: label parts joined by `.`.",
+      "maxLength": 64,
+      "type": "string"
+    }
+  },
+  "$id": "https://gamecult.dev/epiphany/cultnet/epiphany.pipeline.thought.v2.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "One tick of her stream of thought, offline: the words a base model\ncontinued from a projection of her own state, with the whole trace that\nmade them (the seed, the projection, every candidate and how near each\nwas to her earlier thoughts). `text` is the chosen candidate. `reads`\nare the documents the seed was drawn from. A thought is divergence for\ndelivery to weigh, never a memory: its words reach a later seed only\nthrough something she wrote. Instance-rooted: the key is\n`<instance>:thought:<label>`, the label `t<unix seconds>` of the tick.\nSemantically indexed on `text` only. `nearest_permille` is 1000 where she\nhad no earlier thought. `prompt_version` names the fixed parts of both\nprompts (the Projector's builder revision, guidance and word budget, and\nthe continuer's frame), so the exact prompts of an old thought can be\nrebuilt from the trace.",
+  "properties": {
+    "base_model": {
+      "$ref": "#/$defs/Short"
+    },
+    "candidates": {
+      "items": {
+        "$ref": "#/$defs/Line"
+      },
+      "maxItems": 4,
+      "type": "array"
+    },
+    "chosen": {
+      "format": "uint8",
+      "maximum": 255,
+      "minimum": 0,
+      "type": "integer"
+    },
+    "context": {
+      "$ref": "#/$defs/Para"
+    },
+    "continuer_ms": {
+      "format": "uint32",
+      "minimum": 0,
+      "type": "integer"
+    },
+    "identity": {
+      "$ref": "#/$defs/Line"
+    },
+    "instance": {
+      "$ref": "#/$defs/Slug"
+    },
+    "label": {
+      "$ref": "#/$defs/Label"
+    },
+    "max_tokens": {
+      "format": "uint16",
+      "maximum": 65535,
+      "minimum": 0,
+      "type": "integer"
+    },
+    "min_p_permille": {
+      "format": "uint16",
+      "maximum": 65535,
+      "minimum": 0,
+      "type": "integer"
+    },
+    "nearest_permille": {
+      "items": {
+        "format": "uint16",
+        "maximum": 65535,
+        "minimum": 0,
+        "type": "integer"
+      },
+      "maxItems": 4,
+      "type": "array"
+    },
+    "persona_receipt": {
+      "$ref": "#/$defs/Short"
+    },
+    "projection": {
+      "$ref": "#/$defs/Para"
+    },
+    "projector_model": {
+      "$ref": "#/$defs/Short"
+    },
+    "projector_ms": {
+      "format": "uint32",
+      "minimum": 0,
+      "type": "integer"
+    },
+    "prompt_version": {
+      "$ref": "#/$defs/Line"
+    },
+    "reads": {
+      "items": {
+        "$ref": "#/$defs/PipelineRef"
+      },
+      "maxItems": 64,
+      "type": "array"
+    },
+    "stimulus": {
+      "$ref": "#/$defs/Para"
+    },
+    "temperature_permille": {
+      "format": "uint16",
+      "maximum": 65535,
+      "minimum": 0,
+      "type": "integer"
+    },
+    "text": {
+      "$ref": "#/$defs/Para"
+    }
+  },
+  "required": [
+    "instance",
+    "label",
+    "text",
+    "reads",
+    "persona_receipt",
+    "identity",
+    "context",
+    "stimulus",
+    "projector_model",
+    "projection",
+    "base_model",
+    "temperature_permille",
+    "min_p_permille",
+    "max_tokens",
+    "candidates",
+    "nearest_permille",
+    "chosen",
+    "projector_ms",
+    "continuer_ms",
+    "prompt_version"
+  ],
+  "title": "PipelineThought",
+  "type": "object"
+}
diff --git a/schemas/cultnet/huginn.mind_request.v1.schema.json b/schemas/cultnet/huginn.mind_request.v1.schema.json
index bffa101..a36dc46 100644
--- a/schemas/cultnet/huginn.mind_request.v1.schema.json
+++ b/schemas/cultnet/huginn.mind_request.v1.schema.json
@@ -1326,6 +1326,22 @@
             "kind",
             "value"
           ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "kind": {
+              "type": "string",
+              "const": "thought"
+            },
+            "value": {
+              "$ref": "#/$defs/PipelineThought"
+            }
+          },
+          "required": [
+            "kind",
+            "value"
+          ]
         }
       ]
     },
@@ -1591,7 +1607,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ]
     },
     "PipelineMemory": {
@@ -2115,6 +2132,125 @@
         "doc"
       ]
     },
+    "PipelineThought": {
+      "description": "One tick of her stream of thought, offline: the words a base model\ncontinued from a projection of her own state, with the whole trace that\nmade them (the seed, the projection, every candidate and how near each\nwas to her earlier thoughts). `text` is the chosen candidate. `reads`\nare the documents the seed was drawn from. A thought is divergence for\ndelivery to weigh, never a memory: its words reach a later seed only\nthrough something she wrote. Instance-rooted: the key is\n`<instance>:thought:<label>`, the label `t<unix seconds>` of the tick.\nSemantically indexed on `text` only. `nearest_permille` is 1000 where she\nhad no earlier thought. `prompt_version` names the fixed parts of both\nprompts (the Projector's builder revision, guidance and word budget, and\nthe continuer's frame), so the exact prompts of an old thought can be\nrebuilt from the trace.",
+      "type": "object",
+      "properties": {
+        "base_model": {
+          "$ref": "#/$defs/Short"
+        },
+        "candidates": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Line"
+          },
+          "maxItems": 4
+        },
+        "chosen": {
+          "type": "integer",
+          "format": "uint8",
+          "maximum": 255,
+          "minimum": 0
+        },
+        "context": {
+          "$ref": "#/$defs/Para"
+        },
+        "continuer_ms": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0
+        },
+        "identity": {
+          "$ref": "#/$defs/Line"
+        },
+        "instance": {
+          "$ref": "#/$defs/Slug"
+        },
+        "label": {
+          "$ref": "#/$defs/Label"
+        },
+        "max_tokens": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "min_p_permille": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "nearest_permille": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "format": "uint16",
+            "maximum": 65535,
+            "minimum": 0
+          },
+          "maxItems": 4
+        },
+        "persona_receipt": {
+          "$ref": "#/$defs/Short"
+        },
+        "projection": {
+          "$ref": "#/$defs/Para"
+        },
+        "projector_model": {
+          "$ref": "#/$defs/Short"
+        },
+        "projector_ms": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0
+        },
+        "prompt_version": {
+          "$ref": "#/$defs/Line"
+        },
+        "reads": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/PipelineRef"
+          },
+          "maxItems": 64
+        },
+        "stimulus": {
+          "$ref": "#/$defs/Para"
+        },
+        "temperature_permille": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "text": {
+          "$ref": "#/$defs/Para"
+        }
+      },
+      "required": [
+        "instance",
+        "label",
+        "text",
+        "reads",
+        "persona_receipt",
+        "identity",
+        "context",
+        "stimulus",
+        "projector_model",
+        "projection",
+        "base_model",
+        "temperature_permille",
+        "min_p_permille",
+        "max_tokens",
+        "candidates",
+        "nearest_permille",
+        "chosen",
+        "projector_ms",
+        "continuer_ms",
+        "prompt_version"
+      ]
+    },
     "PipelineVerdict": {
       "type": "object",
       "properties": {
diff --git a/schemas/cultnet/huginn.mind_response.v1.schema.json b/schemas/cultnet/huginn.mind_response.v1.schema.json
index 207ce7f..f53e1b2 100644
--- a/schemas/cultnet/huginn.mind_response.v1.schema.json
+++ b/schemas/cultnet/huginn.mind_response.v1.schema.json
@@ -261,7 +261,8 @@
         "sources",
         "rests_on",
         "toward",
-        "run"
+        "run",
+        "reads"
       ]
     },
     "ClaimOutcome": {
@@ -2629,6 +2630,22 @@
             "kind",
             "value"
           ]
+        },
+        {
+          "type": "object",
+          "properties": {
+            "kind": {
+              "type": "string",
+              "const": "thought"
+            },
+            "value": {
+              "$ref": "#/$defs/PipelineThought"
+            }
+          },
+          "required": [
+            "kind",
+            "value"
+          ]
         }
       ]
     },
@@ -3400,6 +3417,44 @@
             "value"
           ]
         },
+        {
+          "type": "object",
+          "properties": {
+            "kind": {
+              "type": "string",
+              "const": "thought"
+            },
+            "value": {
+              "type": "object",
+              "properties": {
+                "chosen": {
+                  "type": "integer",
+                  "format": "uint8",
+                  "maximum": 255,
+                  "minimum": 0
+                },
+                "label": {
+                  "$ref": "#/$defs/Label"
+                },
+                "nearest_permille": {
+                  "type": "integer",
+                  "format": "uint16",
+                  "maximum": 65535,
+                  "minimum": 0
+                }
+              },
+              "required": [
+                "label",
+                "chosen",
+                "nearest_permille"
+              ]
+            }
+          },
+          "required": [
+            "kind",
+            "value"
+          ]
+        },
         {
           "type": "object",
           "properties": {
@@ -3786,7 +3841,8 @@
         "Memory",
         "Research",
         "Idea",
-        "Reply"
+        "Reply",
+        "Thought"
       ]
     },
     "PipelineMemory": {
@@ -4597,6 +4653,125 @@
         "doc"
       ]
     },
+    "PipelineThought": {
+      "description": "One tick of her stream of thought, offline: the words a base model\ncontinued from a projection of her own state, with the whole trace that\nmade them (the seed, the projection, every candidate and how near each\nwas to her earlier thoughts). `text` is the chosen candidate. `reads`\nare the documents the seed was drawn from. A thought is divergence for\ndelivery to weigh, never a memory: its words reach a later seed only\nthrough something she wrote. Instance-rooted: the key is\n`<instance>:thought:<label>`, the label `t<unix seconds>` of the tick.\nSemantically indexed on `text` only. `nearest_permille` is 1000 where she\nhad no earlier thought. `prompt_version` names the fixed parts of both\nprompts (the Projector's builder revision, guidance and word budget, and\nthe continuer's frame), so the exact prompts of an old thought can be\nrebuilt from the trace.",
+      "type": "object",
+      "properties": {
+        "base_model": {
+          "$ref": "#/$defs/Short"
+        },
+        "candidates": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Line"
+          },
+          "maxItems": 4
+        },
+        "chosen": {
+          "type": "integer",
+          "format": "uint8",
+          "maximum": 255,
+          "minimum": 0
+        },
+        "context": {
+          "$ref": "#/$defs/Para"
+        },
+        "continuer_ms": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0
+        },
+        "identity": {
+          "$ref": "#/$defs/Line"
+        },
+        "instance": {
+          "$ref": "#/$defs/Slug"
+        },
+        "label": {
+          "$ref": "#/$defs/Label"
+        },
+        "max_tokens": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "min_p_permille": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "nearest_permille": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "format": "uint16",
+            "maximum": 65535,
+            "minimum": 0
+          },
+          "maxItems": 4
+        },
+        "persona_receipt": {
+          "$ref": "#/$defs/Short"
+        },
+        "projection": {
+          "$ref": "#/$defs/Para"
+        },
+        "projector_model": {
+          "$ref": "#/$defs/Short"
+        },
+        "projector_ms": {
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0
+        },
+        "prompt_version": {
+          "$ref": "#/$defs/Line"
+        },
+        "reads": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/PipelineRef"
+          },
+          "maxItems": 64
+        },
+        "stimulus": {
+          "$ref": "#/$defs/Para"
+        },
+        "temperature_permille": {
+          "type": "integer",
+          "format": "uint16",
+          "maximum": 65535,
+          "minimum": 0
+        },
+        "text": {
+          "$ref": "#/$defs/Para"
+        }
+      },
+      "required": [
+        "instance",
+        "label",
+        "text",
+        "reads",
+        "persona_receipt",
+        "identity",
+        "context",
+        "stimulus",
+        "projector_model",
+        "projection",
+        "base_model",
+        "temperature_permille",
+        "min_p_permille",
+        "max_tokens",
+        "candidates",
+        "nearest_permille",
+        "chosen",
+        "projector_ms",
+        "continuer_ms",
+        "prompt_version"
+      ]
+    },
     "PipelineVerdict": {
       "type": "object",
       "properties": {
diff --git a/schemas/cultnet/index.json b/schemas/cultnet/index.json
index 50b0bb4..a5290b6 100644
--- a/schemas/cultnet/index.json
+++ b/schemas/cultnet/index.json
@@ -221,6 +221,17 @@
       "title": "Epiphany Pipeline Reply v2",
       "path": "epiphany.pipeline.reply.v2.schema.json"
     },
+    {
+      "schemaId": "https://gamecult.dev/epiphany/cultnet/epiphany.pipeline.thought.v2.schema.json",
+      "kind": "document_payload",
+      "wireContracts": [
+        "cultnet.schema.v0"
+      ],
+      "schemaVersion": "epiphany.pipeline.thought.v2",
+      "documentType": "epiphany.pipeline.thought.v2",
+      "title": "Epiphany Pipeline Thought v2",
+      "path": "epiphany.pipeline.thought.v2.schema.json"
+    },
     {
       "schemaId": "huginn.mind_request.v1",
       "kind": "wire_message",