Simulation: one turn per room that woke her, each in its own room (Soul R7)

woken() returns one wake per room; every turn of hers in a round reads from where the round found her, so a direct message is never marked seen without a turn. Test: a DM and a #minds address in one round give Libby a turn in each, each reading only its own room's line.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-11-20 06:01:11 +01:00
commit 8881b3f4b5
2 changed files with 53 additions and 16 deletions

View file

@ -4,8 +4,9 @@
//!
//! Who wakes is the heartbeat's: `heartbeat::wakes` under the plan's `WakePolicy`, over each persona's addressee as the
//! heartbeat's addressing table holds it (her stewarded projects' names included) when the plan names the table. The
//! beat is the heartbeat's too: when it falls, one Persona wakes, the winner of `tempo::pick`. Those woken in one round
//! go in an order drawn from the seed, each against the room as it stands at her turn.
//! beat is the heartbeat's too: when it falls, one Persona wakes, the winner of `tempo::pick`. A persona woken in several
//! rooms in one round takes one turn in each. The turns of a round go in an order drawn from the seed, each against the
//! room as it stands at that turn.
//!
//! Her state does not move during a run: the Interpreter (C3b) and the commit (C3c) are not built. `state_after_turn`
//! is the seam where they will. An explicit addressee (the Interpreter naming whom she speaks to) cannot be simulated
@ -205,8 +206,10 @@ fn in_exchange(lines: &[Line], at: usize, her: &str, window: Duration) -> bool {
lines[..at].iter().any(|earlier| earlier.room == line.room && earlier.from == her && earlier.at_ms >= since)
}
/// Her wakes: one per room a new line woke her in, in the order of each room's first waking line. A room's turn takes
/// the strongest cause among its lines, so no room that woke her, a direct message least of all, is passed over.
#[allow(clippy::too_many_arguments, reason = "one wake decision's inputs, each a plan or room fact")]
fn woken(lines: &[Line], runs: &[usize], seen: usize, member: &Member, operators: &[String], cast: &[String], policy: WakePolicy, gap: Duration) -> Option<Woken> {
fn woken(lines: &[Line], runs: &[usize], seen: usize, member: &Member, operators: &[String], cast: &[String], policy: WakePolicy, gap: Duration) -> Vec<Woken> {
let mut found: Vec<(usize, WakeCause)> = Vec::new();
for (at, line) in lines.iter().enumerate().skip(seen) {
if !line.visible_to(&member.entry.id, &member.rooms) {
@ -218,16 +221,28 @@ fn woken(lines: &[Line], runs: &[usize], seen: usize, member: &Member, operators
found.push((at, cause));
}
}
let cause = found.iter().map(|(_, cause)| *cause).min()?;
let line = found.iter().rev().find(|(_, found)| *found == cause).map_or(0, |(at, _)| *at);
if cause != WakeCause::AddressedByMind {
return Some(Woken { cause, line, how: None, by: vec![] });
let mut rooms: Vec<&str> = Vec::new();
for (at, _) in &found {
if !rooms.contains(&lines[*at].room.as_str()) {
rooms.push(&lines[*at].room);
}
}
let addressing: Vec<usize> = found.iter().filter(|(_, cause)| *cause == WakeCause::AddressedByMind).map(|(at, _)| *at).collect();
let rank = |how: &str| ["mention or reply", "id as text", "name in text"].iter().position(|one| *one == how).unwrap_or(3);
let how = addressing.iter().map(|at| how_addressed(&lines[*at], *at, member, lines)).min_by_key(|how| rank(how));
let by = addressing.iter().map(|at| json!({ "from": lines[*at].from, "how": how_addressed(&lines[*at], *at, member, lines), "says": lines[*at].says })).collect();
Some(Woken { cause, line, how, by })
rooms
.into_iter()
.filter_map(|room| {
let found: Vec<(usize, WakeCause)> = found.iter().copied().filter(|(at, _)| lines[*at].room == room).collect();
let cause = found.iter().map(|(_, cause)| *cause).min()?;
let line = found.iter().rev().find(|(_, found)| *found == cause).map_or(0, |(at, _)| *at);
if cause != WakeCause::AddressedByMind {
return Some(Woken { cause, line, how: None, by: vec![] });
}
let addressing: Vec<usize> = found.iter().filter(|(_, cause)| *cause == WakeCause::AddressedByMind).map(|(at, _)| *at).collect();
let rank = |how: &str| ["mention or reply", "id as text", "name in text"].iter().position(|one| *one == how).unwrap_or(3);
let how = addressing.iter().map(|at| how_addressed(&lines[*at], *at, member, lines)).min_by_key(|how| rank(how));
let by = addressing.iter().map(|at| json!({ "from": lines[*at].from, "how": how_addressed(&lines[*at], *at, member, lines), "says": lines[*at].says })).collect();
Some(Woken { cause, line, how, by })
})
.collect()
}
/// The wire spelling of a cause, and of the beat.
@ -333,7 +348,9 @@ fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize)
for round in 1..=plan.rounds {
scripted(round, &mut lines, &mut rounds_of, &mut causes)?;
let round_at = at_round(round);
let mut woke: Vec<(usize, Option<Woken>)> = members.iter().enumerate().filter_map(|(at, member)| woken(&lines, &mind_runs(&lines, &cast, member), seen[at], member, &plan.operators, &cast, plan.wake, Duration::minutes(plan.exchange_minutes)).map(|why| (at, Some(why)))).collect();
// One turn per room that woke her, each in its room; all of hers this round read from where the round found her.
let round_seen = seen.clone();
let mut woke: Vec<(usize, Option<Woken>)> = members.iter().enumerate().flat_map(|(at, member)| woken(&lines, &mind_runs(&lines, &cast, member), seen[at], member, &plan.operators, &cast, plan.wake, Duration::minutes(plan.exchange_minutes)).into_iter().map(move |why| (at, Some(why)))).collect();
// The beat, as the heartbeat's: when it has fallen, one more wake for the winner of `tempo::pick` among those
// not already woken.
if plan.beat_s > 0 && (round_at - last_beat).num_seconds() >= i64::from(plan.beat_s) {
@ -358,13 +375,13 @@ fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize)
counter += 1;
let member = &members[at];
let id = member.entry.id.clone();
let fresh: Vec<&Line> = lines[seen[at]..].iter().filter(|line| line.from != id && line.visible_to(&id, &member.rooms)).collect();
let fresh: Vec<&Line> = lines[round_seen[at]..].iter().filter(|line| line.from != id && line.visible_to(&id, &member.rooms)).collect();
// The turn is in the room of the line that woke her; a beat's, in the room of the newest line she has not seen.
let woke_on = why.as_ref().map(|why| &lines[why.line]).or(fresh.last().copied());
let here = woke_on.map_or_else(|| member.rooms[0].clone(), |line| line.room.clone());
// Woken by a direct message, she answers in it: to its sender alone.
let dm_to = woke_on.filter(|line| line.dm_to.as_deref() == Some(id.as_str())).map(|line| line.from.clone());
let kind = if fresh.is_empty() { TurnKind::Beat } else { TurnKind::Chat };
let kind = if fresh.iter().any(|line| line.room == here) { TurnKind::Chat } else { TurnKind::Beat };
let now = round_at + Duration::seconds(30 + counter as i64);
let request = Request {
instance: localpart(&id).to_owned(),
@ -383,7 +400,7 @@ fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize)
recent: recent[at].clone(),
own_rooms: member.entry.own_rooms.clone(),
};
let view = View { lines: &lines, viewer: &id, rooms: &member.rooms, seen: seen[at] };
let view = View { lines: &lines, viewer: &id, rooms: &member.rooms, seen: round_seen[at] };
let names = Names(&member.addressee);
let organs = Organs { persona: None, chat: Some(&view), addressing: Some(&names), model: harness.model };
let report = project(&organs, &request, now).unwrap_or_else(|fault| json!({ "error": format!("{fault:#}") }));

View file

@ -364,3 +364,23 @@ fn the_turn_is_in_the_room_of_the_line_that_woke_her() {
let (_, run) = run_plan(&path, &silent());
assert_eq!(run["turns"][0]["room"], "#tobiah:gamecult.org", "{}", run["turns"]);
}
#[test]
fn soul_r7_woken_in_a_direct_message_and_a_room_at_once_she_takes_a_turn_in_each() {
let dir = tempfile::tempdir().unwrap();
let path = plan(dir.path(), "\"ruled\"", 1, "");
let line = |room: &str, dm: bool, says: &str| format!("[[message]]\nround = 1\nfrom = \"@meta:gamecult.org\"\nname = \"Meta\"\nroom = \"{room}\"\n{}says = \"{says}\"\n", if dm { "dm = true\nto = \"@libby:gamecult.org\"\n" } else { "" });
let opening = "[[message]]\nfrom = \"@meta:gamecult.org\"\nname = \"Meta\"\nroom = \"#minds:gamecult.org\"\nsays = \"good afternoon, everyone\"\n";
let text = std::fs::read_to_string(&path).unwrap().replace(opening, &format!("{}{}", line("!dm-libby:gamecult.org", true, "just you: how are you, really?"), line("#minds:gamecult.org", false, "Libby, how was the gig?")));
std::fs::write(&path, text).unwrap();
let (_, run) = run_plan(&path, &silent());
let mut libby: Vec<(String, String)> = run["turns"].as_array().unwrap().iter().filter(|turn| turn["persona"] == "Libby").map(|turn| (turn["room"].as_str().unwrap().to_owned(), turn["kind"].as_str().unwrap().to_owned())).collect();
libby.sort();
assert_eq!(libby, vec![("!dm-libby:gamecult.org".to_owned(), "chat".to_owned()), ("#minds:gamecult.org".to_owned(), "chat".to_owned())], "{}", run["turns"]);
// Each turn read its own room's line, and no other's.
for turn in run["turns"].as_array().unwrap().iter().filter(|turn| turn["persona"] == "Libby") {
let stimulus = turn["report"]["renders"][0].to_string() + &turn["report"].to_string();
let (own, other) = if turn["room"] == "#minds:gamecult.org" { ("how was the gig", "how are you, really") } else { ("how are you, really", "how was the gig") };
assert!(stimulus.contains(own) && !stimulus.contains(other), "{}: {stimulus}", turn["room"]);
}
}