Harness fixes after Soul's hold on #79: one owner of the wake rule, the heartbeat's beat, group state in the Projector
- F1: `heartbeat::wakes(policy, addressee, delivery, speaker, mind_run)` is the one wake rule. The poll asks it with `WakePolicy::Live` (behaviour unchanged until `po-mind-wakes-mind` is answered); the simulator asks it with the plan's policy: `ruled`, `humans_pace`, `names_with_cap = N`, `all_messages`. The simulator reads each persona's addressee from the heartbeat's addressing table (stewarded project names included) when the plan names `heartbeat.cc`. - F2: the beat falls on `beat_s` of simulated time and wakes one Persona, the winner of `tempo::pick`. - F5: Mind-addressed evidence is counted per wake (its strongest evidence), not per line. - F6: reply chains are per room and count Mind lines spoken in turns another Mind's line woke. - F7: a failed call is a failure, apart from silence; silence rate is per woken turn that did not fail. - F8: a test that another seed changes the order. - F9: `--state` docs say P4 and P5 are not checked. - Group state (`select.group_state`, default on): one packet line over the room's last `group_lines` lines: who spoke to whom, when a human last spoke, how many Mind lines in a row, lines to her, an open question to everyone. Inside the context budget, narrated by the Projector like every other line; golden fixtures for the four scenario rooms. - Reports: wakes by cause and by round, per-room chains, failures, 18 representative lines, the explicit-addressee gap. - Tuning: `persona.words` and `persona.guidance` get the upper bounds the Projector's knobs have. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
fe723867f7
commit
b90c21e695
11 changed files with 667 additions and 209 deletions
4
crates/mind-body/fixtures/harness/golden-group.txt
Normal file
4
crates/mind-body/fixtures/harness/golden-group.txt
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
quiet-beat.toml: - the room lately: libby to the room, Kiko to the room, libby to the room; no human has spoken here lately; the last 3 lines are the Minds' alone
|
||||
operator-warm.toml: - the room lately: Meta, who runs the place to her; a human, Meta, who runs the place, last spoke 1 min ago; 1 line is to her
|
||||
mind-teases.toml: - the room lately: she to the room, aqua to the room, Kiko to her; no human has spoken here lately; the last 3 lines are the Minds' alone; 1 line is to her
|
||||
deru-passing.toml: - the room lately: weksa to the room, Deru to the room; a human, Deru, last spoke 1 min ago
|
||||
|
|
@ -17,7 +17,8 @@
|
|||
//! [--room <fixture.toml>] [--seed N] [--state <file>] [--select-only | --renders K [--through projector|persona]
|
||||
//! [--judge <state-file>]]` is the experiment tool over the Projector and the Persona stage
|
||||
//! (`mind_body::projection::project`): it prints, as JSON, the packet the Select stage builds from her stored state (or
|
||||
//! `--state`, checked as a put would check it), and with `--renders` the Projector's narrations of K successive turns;
|
||||
//! `--state`, checked as a put checks its content, rules P1 to P3; P4 and P5 compare it with the stored document and are
|
||||
//! not checked), and with `--renders` the Projector's narrations of K successive turns;
|
||||
//! `--through persona` adds her prose and the quoted lines it would say; `--judge` renders a second state too and asks
|
||||
//! the model which narration came from which. It writes nothing and reads no brake.
|
||||
//!
|
||||
|
|
|
|||
|
|
@ -393,12 +393,92 @@ pub(crate) fn stewardships_of(mind: &dyn MindPort) -> Result<(Vec<Name>, Vec<Org
|
|||
Ok((names, repos))
|
||||
}
|
||||
|
||||
/// Whether a delivery wakes `who` off the beat: the operator or another Mind of
|
||||
/// the roster addresses her. A Mind naming herself does not; a member does not.
|
||||
fn wakes(config: &Config, who: &Addressee, delivery: &ChatDelivery) -> bool {
|
||||
let from_operator = config.operators.contains(&delivery.sender);
|
||||
let from_other_mind = delivery.sender != who.matrix_id() && config.personas.iter().any(|mind| mind.matrix_id == delivery.sender);
|
||||
(from_operator || from_other_mind) && is_for(who, delivery)
|
||||
/// Who sent a line, as the wake rule sees them.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum Speaker {
|
||||
Operator,
|
||||
/// Another Mind of the roster.
|
||||
Mind,
|
||||
/// A human who is not the operator: a member.
|
||||
Member,
|
||||
/// The Persona herself.
|
||||
Her,
|
||||
}
|
||||
|
||||
impl Speaker {
|
||||
fn human(self) -> bool {
|
||||
matches!(self, Self::Operator | Self::Member)
|
||||
}
|
||||
}
|
||||
|
||||
/// Which lines wake a Persona off the beat. `Live` is the heartbeat's rule today and the only one `poll` uses; the rest
|
||||
/// are what desk question `po-mind-wakes-mind` weighs, run in `mind-persona project --simulate` until it is answered.
|
||||
/// The beat is not here: every policy has it, and it wakes one Persona by `tempo::pick`.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub(crate) enum WakePolicy {
|
||||
/// The operator or another Mind addressing her (`is_for`). A member's line does not.
|
||||
Live,
|
||||
/// Ruling `persona-only-wake-humans-in-rooms`: a line addressing her, from anyone, and any human line in her rooms.
|
||||
Ruled,
|
||||
/// Human lines only: each wakes every Mind in the room once; a Mind's line never wakes a Mind.
|
||||
HumansPace,
|
||||
/// `Ruled`, with at most this many Mind lines in a row in a room before a human must speak again: a Mind's line past
|
||||
/// the cap wakes no one.
|
||||
NamesWithCap(usize),
|
||||
/// The swarm's old loop, a control: any line in her rooms but her own.
|
||||
AllMessages,
|
||||
}
|
||||
|
||||
/// Why a line wakes her, strongest first.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub(crate) enum WakeCause {
|
||||
AddressedByHuman,
|
||||
Human,
|
||||
AddressedByMind,
|
||||
/// A Mind's line that does not address her: only the control wakes on it.
|
||||
Mind,
|
||||
}
|
||||
|
||||
/// Whether a line in her rooms wakes `who` off the beat under `policy`, and why. `mind_run` is how many Mind lines in a
|
||||
/// row came before this one in its room since a human last spoke there. The one owner of the wake rule: the heartbeat's
|
||||
/// poll asks it with `Live`, the simulator with the policy under test.
|
||||
pub(crate) fn wakes(policy: WakePolicy, who: &Addressee, delivery: &ChatDelivery, speaker: Speaker, mind_run: usize) -> Option<WakeCause> {
|
||||
if speaker == Speaker::Her {
|
||||
return None;
|
||||
}
|
||||
let addressed = is_for(who, delivery);
|
||||
let human = speaker.human();
|
||||
let cause = match (human, addressed) {
|
||||
(true, true) => WakeCause::AddressedByHuman,
|
||||
(true, false) => WakeCause::Human,
|
||||
(false, true) => WakeCause::AddressedByMind,
|
||||
(false, false) => WakeCause::Mind,
|
||||
};
|
||||
let wakes = match policy {
|
||||
WakePolicy::Live => addressed && matches!(speaker, Speaker::Operator | Speaker::Mind),
|
||||
WakePolicy::Ruled => human || addressed,
|
||||
WakePolicy::HumansPace => human,
|
||||
WakePolicy::NamesWithCap(cap) => human || (addressed && mind_run < cap),
|
||||
WakePolicy::AllMessages => true,
|
||||
};
|
||||
wakes.then_some(cause)
|
||||
}
|
||||
|
||||
impl Config {
|
||||
/// Who sent a delivery, as `wakes` sees them.
|
||||
fn speaker(&self, who: &Addressee, delivery: &ChatDelivery) -> Speaker {
|
||||
if delivery.sender == who.matrix_id() {
|
||||
Speaker::Her
|
||||
} else if self.operators.contains(&delivery.sender) {
|
||||
Speaker::Operator
|
||||
} else if self.personas.iter().any(|mind| mind.matrix_id == delivery.sender) {
|
||||
Speaker::Mind
|
||||
} else {
|
||||
Speaker::Member
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The mouth pages a pending answer, so fewer deliveries may come than wait.
|
||||
|
|
@ -528,7 +608,7 @@ pub fn poll(organs: &Organs, config: &Config) -> Result<Outcome> {
|
|||
pending.sort_by_key(|delivery| delivery.seq);
|
||||
pending
|
||||
.into_iter()
|
||||
.filter(|delivery| wakes(config, &row.addressee, delivery))
|
||||
.filter(|delivery| wakes(WakePolicy::Live, &row.addressee, delivery, config.speaker(&row.addressee, delivery), 0).is_some())
|
||||
.map(|delivery| format!("{}:{}", slug.0, delivery.event_id))
|
||||
.find(|key| !state.handled_mentions.contains(key))
|
||||
};
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ Eureka (she/her). Dry, direct, almost feral; zeal aimed at revealing.
|
|||
- mood, with no earlier turn to measure from: lighter, more settled than middling
|
||||
- bond [bond-kiko] Kiko, sparring partner: fair trust, heavy friction. Kiko pokes her to stop massaging the pipeline.
|
||||
- bond [bond-libby] Libby, collaborator: fair trust, a little friction. Libby holds the sounds and teases her about the pipeline.
|
||||
- the room lately: Libby to her, Kiko to the room; no human has spoken here lately; the last 2 lines are the Minds' alone; 1 line is to her
|
||||
- memory [libby-sounds]: Libby laughed at the door fix.
|
||||
- memory [t1-m0]: The heartbeat stalled at noon.
|
||||
- memory [curse]: Her curse is the knife. The same drive makes her good and will lead her wrong.
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@ const TAIL_LINES: usize = 40;
|
|||
|
||||
/// A persona state file, checked as a put would check its content (huginn-mind's rules P1 to P3: the published schema,
|
||||
/// `personaId` is the instance, canonical provenance). A file this accepts is one a put would not refuse for what it says.
|
||||
/// P4 and P5 are not checked: they compare `updatedAt` with the stored document, and no store is read here.
|
||||
pub fn state_file(path: &Path, instance: &str) -> Result<Value> {
|
||||
let text = std::fs::read_to_string(path).with_context(|| format!("{} could not be read", path.display()))?;
|
||||
let state: Value = serde_json::from_str(&text).with_context(|| format!("{} is not JSON", path.display()))?;
|
||||
|
|
|
|||
|
|
@ -218,3 +218,37 @@ fn a_batch_state_without_a_file_is_her_stored_state() {
|
|||
let report = batch(&harness(dir.path(), Some(&Stored), Some(&model)), &plan).unwrap();
|
||||
assert!(report.contains("## stored × quiet, sample 1") && !report.contains("failed"), "{report}");
|
||||
}
|
||||
|
||||
fn group_line_of(dir: &Path, name: &str) -> Option<String> {
|
||||
let fixture = room(name);
|
||||
let harness = harness(dir, None, None);
|
||||
let organs = Organs { persona: None, chat: Some(&fixture), addressing: fixture.addressee(), model: None };
|
||||
let report = project(&organs, &fixture_request(&harness, &fixture, Some(control()), 1, None, Through::Projector), fixture.now).unwrap();
|
||||
report["packet"]["context"].as_str().unwrap().lines().find(|line| line.starts_with("- the room lately")).map(str::to_owned)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_group_state_reads_each_scenario_room_as_the_golden_file_says() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut rendered = String::new();
|
||||
for name in ["quiet-beat.toml", "operator-warm.toml", "mind-teases.toml", "deru-passing.toml"] {
|
||||
let line = group_line_of(dir.path(), name).unwrap_or_else(|| "(none)".into());
|
||||
assert!(line.len() <= 360, "the slot holds its byte budget: {line}");
|
||||
rendered.push_str(&format!("{name}: {line}
|
||||
"));
|
||||
}
|
||||
let golden = include_str!("../../../fixtures/harness/golden-group.txt").replace("
|
||||
", "
|
||||
");
|
||||
assert_eq!(rendered, golden, "the group state moved; if deliberately, the new golden file is:
|
||||
{rendered}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_group_state_is_off_when_the_tuning_says_so() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::write(dir.path().join("persona-tuning.toml"), "[select]
|
||||
group_state = false
|
||||
").unwrap();
|
||||
assert!(group_line_of(dir.path(), "mind-teases.toml").is_none());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
//! here; reaching into it is the Interpreter's, through its read tools, when wondering leads to reading.
|
||||
//!
|
||||
//! Every packet carries its fixed slots: identity, the hour, her mood as change, a bond line for each person
|
||||
//! present, and the stimulus. The rest comes from her state's pools. Each candidate is ordered by
|
||||
//! present, the group state (who has been talking to whom, `group_line`), and the stimulus. The rest comes from her state's pools. Each candidate is ordered by
|
||||
//! `log(score) / T` plus Gumbel noise and included with probability `1 - exp(-score / inclusion_score)`, where
|
||||
//! `score = salience × recency × touch × relevance × unresolved × freshness`; then each pool's cap and the context
|
||||
//! budget bound what is kept. A cap is a maximum, never a target: a pool with fewer candidates than its cap still
|
||||
|
|
@ -814,6 +814,95 @@ fn also_here(named: &[String]) -> Option<String> {
|
|||
Some(line)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// The group state: what the room's recent lines say about who is talking to whom.
|
||||
|
||||
/// Whether a sender is a Mind of the swarm (she is one); anyone else is a human.
|
||||
fn is_mind(inputs: &Inputs, sender: &str) -> bool {
|
||||
sender == inputs.people.own_sender || inputs.people.minds.iter().any(|mind| mind == sender)
|
||||
}
|
||||
|
||||
/// The label her bond with a sender gives them, when she has a live one.
|
||||
fn bond_label(inputs: &Inputs, sender: &str) -> Option<String> {
|
||||
let person = inputs.people.person_of(sender);
|
||||
items(inputs.state, &["affect", "socialBonds"]).iter().find(|bond| live(bond) && text(bond, &["object", "id"]).to_lowercase() == person).map(|bond| text(bond, &["object", "label"]).to_owned()).filter(|label| !label.is_empty())
|
||||
}
|
||||
|
||||
/// The words a line may call its sender by: the Matrix localpart, the display name, and the bond's label when she has one.
|
||||
fn names_of(line: &RoomLine, inputs: &Inputs) -> Vec<String> {
|
||||
[Some(localpart(&line.sender).to_owned()), Some(line.display.trim().to_owned()), bond_label(inputs, &line.sender)].into_iter().flatten().filter(|name| !name.is_empty()).collect()
|
||||
}
|
||||
|
||||
/// The group-state slot (`select.group_state`): over the room's last `group_lines` lines, who spoke to whom (to her, to
|
||||
/// someone else present by name, or to the room); when a human last spoke; how many lines in a row are the Minds' alone;
|
||||
/// how many lines are to her; and whether a human's question to everyone stands open. Code reads names and question marks,
|
||||
/// not meaning: whom a line is to by the names in it is a cue, and the Interpreter (C3b) will know better. None when the
|
||||
/// room shows no line.
|
||||
fn group_line(inputs: &Inputs, tuning: &Tuning) -> Option<String> {
|
||||
let here = inputs.room.here.as_deref();
|
||||
let mut lines: Vec<&RoomLine> = Vec::new();
|
||||
for line in inputs.room.messages.iter().chain(&inputs.room.tail) {
|
||||
if here.is_some_and(|here| line.room != here) || lines.iter().any(|seen| seen.sender == line.sender && seen.at_ms == line.at_ms && seen.text == line.text) {
|
||||
continue;
|
||||
}
|
||||
lines.push(line);
|
||||
}
|
||||
lines.sort_by_key(|line| line.at_ms);
|
||||
if lines.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let to_her = |line: &RoomLine| line.sender != inputs.people.own_sender && (line.to_her || [localpart(inputs.people.own_sender), text(inputs.state, &["publicName"])].iter().any(|name| crate::address::names_whole_word(&line.text, name, false)));
|
||||
let window = &lines[lines.len().saturating_sub(tuning.select.group_lines)..];
|
||||
// A tail line carries no display name: an unbonded sender there goes by the handle in her Matrix id.
|
||||
let label = |line: &RoomLine| {
|
||||
if line.sender == inputs.people.own_sender {
|
||||
"she".to_owned()
|
||||
} else if line.display.trim().is_empty() && bond_label(inputs, &line.sender).is_none() {
|
||||
localpart(&line.sender).to_owned()
|
||||
} else {
|
||||
name_of(line, inputs)
|
||||
}
|
||||
};
|
||||
let talk: Vec<String> = window
|
||||
.iter()
|
||||
.map(|line| {
|
||||
let target = if to_her(line) {
|
||||
"her".to_owned()
|
||||
} else {
|
||||
window.iter().filter(|other| other.sender != line.sender).find(|other| names_of(other, inputs).iter().any(|name| crate::address::names_whole_word(&line.text, name, false))).map_or_else(|| "the room".to_owned(), |other| label(other))
|
||||
};
|
||||
format!("{} to {target}", label(line))
|
||||
})
|
||||
.collect();
|
||||
let mut parts = vec![format!("the room lately: {}", talk.join(", "))];
|
||||
let last_human = lines.iter().rev().find(|line| !is_mind(inputs, &line.sender));
|
||||
parts.push(match last_human {
|
||||
Some(line) => format!("a human, {}, last spoke {} min ago", label(line), minutes(inputs.now, line.at_ms)),
|
||||
None => "no human has spoken here lately".to_owned(),
|
||||
});
|
||||
let minds_in_a_row = lines.iter().rev().take_while(|line| is_mind(inputs, &line.sender)).count();
|
||||
if minds_in_a_row >= 2 {
|
||||
parts.push(format!("the last {minds_in_a_row} lines are the Minds' alone"));
|
||||
}
|
||||
let addressed = lines.iter().filter(|line| to_her(line)).count();
|
||||
if addressed > 0 {
|
||||
parts.push(format!("{addressed} {} to her", if addressed == 1 { "line is" } else { "lines are" }));
|
||||
}
|
||||
if let Some(line) = last_human
|
||||
&& line.text.trim_end().ends_with('?')
|
||||
&& !to_her(line)
|
||||
&& !window.iter().filter(|other| other.sender != line.sender).any(|other| names_of(other, inputs).iter().any(|name| crate::address::names_whole_word(&line.text, name, false)))
|
||||
{
|
||||
parts.push(format!("{}'s question to everyone is open", label(line)));
|
||||
}
|
||||
Some(clip(&format!("- {}", parts.join("; ")), tuning.select.group_bytes))
|
||||
}
|
||||
|
||||
fn minutes(now: DateTime<Utc>, at_ms: u64) -> i64 {
|
||||
let at = i64::try_from(at_ms).ok().and_then(DateTime::<Utc>::from_timestamp_millis).unwrap_or(now);
|
||||
(now - at).num_minutes().max(0)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// The packet.
|
||||
|
||||
|
|
@ -858,6 +947,12 @@ pub(crate) fn select(inputs: &Inputs, tuning: &Tuning) -> Packet {
|
|||
used += line.len() + 1;
|
||||
fixed.push(line);
|
||||
}
|
||||
if tuning.select.group_state
|
||||
&& let Some(line) = group_line(inputs, tuning).filter(|line| used + line.len() < budget)
|
||||
{
|
||||
used += line.len() + 1;
|
||||
fixed.push(line);
|
||||
}
|
||||
|
||||
// What the room is touching: the content words of what was said there, and of a follow-up's finding.
|
||||
let touching: BTreeSet<String> = inputs.room.messages.iter().chain(&inputs.room.tail).map(|line| line.text.as_str()).chain(inputs.observation).flat_map(content_words).collect();
|
||||
|
|
|
|||
|
|
@ -2,13 +2,14 @@
|
|||
//! one `project` through the Persona stage, and each one's quoted lines join the room as from her Matrix id, so the
|
||||
//! next one hears them.
|
||||
//!
|
||||
//! Who wakes is the real rule: `address::is_for` over each persona's names, plus ruling
|
||||
//! `persona-only-wake-humans-in-rooms` (an addressed message, any human message in her rooms, the beat). Another Mind's
|
||||
//! unaddressed message wakes no one, unless the plan asks for the swarm's old loop (`wake = "all_messages"`), kept as a
|
||||
//! control. Those woken in one round go in an order drawn from the seed, each against the room as it stands at her turn.
|
||||
//! 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.
|
||||
//!
|
||||
//! 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.
|
||||
//! is the seam where they will. An explicit addressee (the Interpreter naming whom she speaks to) cannot be simulated
|
||||
//! until then either: a spoken line addresses another persona only by the names in its text.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::fmt::Write as _;
|
||||
|
|
@ -21,24 +22,17 @@ use serde_json::{Value, json};
|
|||
|
||||
use super::harness::{Harness, Line, Message, cosine, pending_for, state_file, turn_markdown, usage_markdown, usage_total};
|
||||
use super::select::Draw;
|
||||
use super::tuning;
|
||||
use super::{MouthReader, Organs, Request, Through, TurnKind, project};
|
||||
use crate::address::{Addressee, is_for, localpart};
|
||||
use crate::chat_client::ChatPending;
|
||||
use crate::heartbeat::{Addressing, HeartbeatView};
|
||||
use crate::heartbeat::{Addressing, DEFAULT_BEAT_S, FileStore, HeartbeatView, Speaker, WakeCause, WakePolicy, wakes};
|
||||
use crate::tempo::{Standing, pick};
|
||||
|
||||
/// The most personas a simulation holds: the swarm.
|
||||
const CAST_MAX: usize = 8;
|
||||
|
||||
/// Who a message wakes.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
enum Wake {
|
||||
/// The ruled set: a message for her, any human message in her rooms, the beat.
|
||||
#[default]
|
||||
HumansInRooms,
|
||||
/// The swarm's old loop, as a control: any message in her rooms, a Mind's too.
|
||||
AllMessages,
|
||||
}
|
||||
/// How many transcript lines the report quotes as representative.
|
||||
const REPRESENTATIVE_LINES: usize = 18;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
|
|
@ -48,17 +42,21 @@ struct SimFile {
|
|||
repeats: usize,
|
||||
#[serde(default)]
|
||||
seed: u64,
|
||||
#[serde(default)]
|
||||
wake: Wake,
|
||||
/// Every this many rounds the beat wakes everyone who was not woken otherwise; 0 is no beat.
|
||||
#[serde(default)]
|
||||
beat_every: usize,
|
||||
#[serde(default = "ruled")]
|
||||
wake: WakePolicy,
|
||||
/// The heartbeat's beat, in seconds of simulated time; 0 is no beat.
|
||||
#[serde(default = "beat_s")]
|
||||
beat_s: u32,
|
||||
#[serde(default = "two")]
|
||||
round_minutes: i64,
|
||||
start: DateTime<Utc>,
|
||||
rooms: Vec<String>,
|
||||
#[serde(default)]
|
||||
operators: Vec<String>,
|
||||
/// The heartbeat's store (`heartbeat.cc`), read without a lock or a write, for its addressing table: each persona's
|
||||
/// names and her stewarded projects' names. None addresses each by her own names.
|
||||
#[serde(default)]
|
||||
addressing: Option<PathBuf>,
|
||||
cast: Vec<CastEntry>,
|
||||
#[serde(default, rename = "message")]
|
||||
script: Vec<Message>,
|
||||
|
|
@ -72,6 +70,14 @@ fn two() -> i64 {
|
|||
2
|
||||
}
|
||||
|
||||
fn ruled() -> WakePolicy {
|
||||
WakePolicy::Ruled
|
||||
}
|
||||
|
||||
fn beat_s() -> u32 {
|
||||
DEFAULT_BEAT_S
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct CastEntry {
|
||||
|
|
@ -82,15 +88,14 @@ struct CastEntry {
|
|||
/// Her rooms; none is every room of the plan.
|
||||
#[serde(default)]
|
||||
rooms: Vec<String>,
|
||||
/// More names she answers to, beside her handle and display name.
|
||||
#[serde(default)]
|
||||
names: Vec<String>,
|
||||
}
|
||||
|
||||
struct Member {
|
||||
entry: CastEntry,
|
||||
state: Value,
|
||||
addressee: Addressee,
|
||||
/// Where her addressee came from: the heartbeat's table, or her own names.
|
||||
names_from: &'static str,
|
||||
rooms: Vec<String>,
|
||||
}
|
||||
|
||||
|
|
@ -122,8 +127,33 @@ fn state_after_turn(state: Value, _turn: &Value) -> Value {
|
|||
state
|
||||
}
|
||||
|
||||
/// How a Mind's line addressed her, by the evidence `is_for` had: a Matrix tag or a reply to her (`mention or reply`),
|
||||
/// her Matrix id written as plain text (`id as text`), or one of her names in the text (`name in text`).
|
||||
fn speaker(line: &Line, member: &Member, operators: &[String], cast: &[String]) -> Speaker {
|
||||
if line.from == member.entry.id {
|
||||
Speaker::Her
|
||||
} else if operators.contains(&line.from) {
|
||||
Speaker::Operator
|
||||
} else if cast.contains(&line.from) {
|
||||
Speaker::Mind
|
||||
} else {
|
||||
Speaker::Member
|
||||
}
|
||||
}
|
||||
|
||||
/// For each line, how many Mind lines in a row came before it in its room since a human last spoke there.
|
||||
fn mind_runs(lines: &[Line], cast: &[String]) -> Vec<usize> {
|
||||
let mut run: BTreeMap<&str, usize> = BTreeMap::new();
|
||||
lines
|
||||
.iter()
|
||||
.map(|line| {
|
||||
let before = run.get(line.room.as_str()).copied().unwrap_or(0);
|
||||
run.insert(&line.room, if cast.contains(&line.from) { before + 1 } else { 0 });
|
||||
before
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// How a Mind's line addressed her, by the evidence `is_for` had, strongest first: a Matrix tag or a reply to her, her
|
||||
/// Matrix id written as plain text, or one of her names in the text.
|
||||
fn how_addressed(line: &Line, at: usize, member: &Member, lines: &[Line]) -> &'static str {
|
||||
let delivery = line.delivery(at, &member.entry.id, lines);
|
||||
if delivery.mentions.contains(&member.entry.id) || delivery.basis.is_some() {
|
||||
|
|
@ -135,39 +165,45 @@ fn how_addressed(line: &Line, at: usize, member: &Member, lines: &[Line]) -> &'s
|
|||
}
|
||||
}
|
||||
|
||||
/// Why she wakes this round, by the plan's rule, and the Minds' lines that addressed her; none leaves her asleep. A
|
||||
/// human outranks a Mind: a wake a human's line would cause is counted as the human's, so the Mind-addressed wakes are
|
||||
/// exactly those no human caused.
|
||||
fn wake_reason(lines: &[Line], seen: usize, member: &Member, cast: &[String], wake: Wake, beat: bool) -> Option<(&'static str, Vec<Value>)> {
|
||||
let (mut human_addressed, mut human, mut mind) = (false, false, false);
|
||||
let mut by_minds = Vec::new();
|
||||
/// One wake: why (the strongest cause among her new lines, under the plan's policy) and, when only Minds' lines caused
|
||||
/// it, the strongest evidence that addressed her and the lines that did.
|
||||
struct Woken {
|
||||
cause: WakeCause,
|
||||
how: Option<&'static str>,
|
||||
by: Vec<Value>,
|
||||
}
|
||||
|
||||
fn woken(lines: &[Line], runs: &[usize], seen: usize, member: &Member, operators: &[String], cast: &[String], policy: WakePolicy) -> Option<Woken> {
|
||||
let mut found: Vec<(usize, WakeCause)> = Vec::new();
|
||||
for (at, line) in lines.iter().enumerate().skip(seen) {
|
||||
if line.from == member.entry.id || !(member.rooms.contains(&line.room) || line.dm) {
|
||||
if !(member.rooms.contains(&line.room) || line.dm) {
|
||||
continue;
|
||||
}
|
||||
let is_human = !cast.contains(&line.from);
|
||||
let addressed = is_for(&member.addressee, &line.delivery(at, &member.entry.id, lines));
|
||||
match (is_human, addressed) {
|
||||
(true, true) => human_addressed = true,
|
||||
(true, false) => human = true,
|
||||
(false, true) => by_minds.push(json!({ "from": line.from, "how": how_addressed(line, at, member, lines), "says": line.says })),
|
||||
(false, false) => mind = true,
|
||||
let delivery = line.delivery(at, &member.entry.id, lines);
|
||||
if let Some(cause) = wakes(policy, &member.addressee, &delivery, speaker(line, member, operators, cast), runs[at]) {
|
||||
found.push((at, cause));
|
||||
}
|
||||
}
|
||||
let why = if human_addressed {
|
||||
"addressed by a human"
|
||||
} else if human {
|
||||
"a human in her rooms"
|
||||
} else if !by_minds.is_empty() {
|
||||
"addressed by a Mind"
|
||||
} else if wake == Wake::AllMessages && mind {
|
||||
"a message in her rooms"
|
||||
} else if beat {
|
||||
"the beat"
|
||||
} else {
|
||||
return None;
|
||||
};
|
||||
Some((why, if why == "addressed by a Mind" { by_minds } else { Vec::new() }))
|
||||
let cause = found.iter().map(|(_, cause)| *cause).min()?;
|
||||
if cause != WakeCause::AddressedByMind {
|
||||
return Some(Woken { cause, 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, how, by })
|
||||
}
|
||||
|
||||
/// The wire spelling of a cause, and of the beat.
|
||||
fn cause_word(cause: Option<WakeCause>) -> &'static str {
|
||||
match cause {
|
||||
Some(WakeCause::AddressedByHuman) => "addressed_by_human",
|
||||
Some(WakeCause::Human) => "human",
|
||||
Some(WakeCause::AddressedByMind) => "addressed_by_mind",
|
||||
Some(WakeCause::Mind) => "mind",
|
||||
None => "beat",
|
||||
}
|
||||
}
|
||||
|
||||
/// A seeded shuffle, so the order of those woken together is drawn, and replays.
|
||||
|
|
@ -191,13 +227,32 @@ pub fn simulate(harness: &Harness, plan_path: &Path) -> Result<String> {
|
|||
bail!("a simulation needs rounds, repeats, a room and a positive round_minutes");
|
||||
}
|
||||
let base = plan_path.parent().unwrap_or(Path::new("."));
|
||||
let mut members = cast_of(&plan, base)?;
|
||||
let group_state = tuning::load(&harness.tuning).map(|loaded| loaded.tuning.select.group_state).ok();
|
||||
let runs: Vec<Value> = (0..plan.repeats).map(|repeat| run(harness, &plan, &mut members, repeat)).collect::<Result<_>>()?;
|
||||
Ok(markdown(plan_path, &plan, &members, group_state, &runs))
|
||||
}
|
||||
|
||||
/// The plan's cast: each persona's state, checked as a put would check it, and her addressee, from the heartbeat's
|
||||
/// table when the plan names it and the table holds her; and the script checked against the rooms.
|
||||
fn cast_of(plan: &SimFile, base: &Path) -> Result<Vec<Member>> {
|
||||
let table = match &plan.addressing {
|
||||
Some(path) => FileStore::new(base.join(path)).addressing().with_context(|| format!("the heartbeat store {} could not be read", path.display()))?.unwrap_or_default(),
|
||||
None => Addressing::default(),
|
||||
};
|
||||
let mut members = Vec::new();
|
||||
for entry in &plan.cast {
|
||||
let state = state_file(&base.join(&entry.state), localpart(&entry.id))?;
|
||||
let rooms = if entry.rooms.is_empty() { plan.rooms.clone() } else { entry.rooms.clone() };
|
||||
let public = state["publicName"].as_str().unwrap_or_default().to_owned();
|
||||
let names = [localpart(&entry.id), entry.name.as_str(), public.as_str()].into_iter().chain(entry.names.iter().map(String::as_str)).filter(|name| !name.is_empty());
|
||||
members.push(Member { addressee: Addressee::new(&entry.id, names), entry: entry.clone(), state, rooms });
|
||||
let (addressee, names_from) = match table.minds.iter().find(|row| row.matrix_id() == entry.id) {
|
||||
Some(row) => (row.clone(), "the heartbeat's table"),
|
||||
None => {
|
||||
let public = state["publicName"].as_str().unwrap_or_default().to_owned();
|
||||
let names = [localpart(&entry.id), entry.name.as_str(), public.as_str()].into_iter().filter(|name| !name.is_empty()).map(str::to_owned).collect::<Vec<_>>();
|
||||
(Addressee::new(&entry.id, names.iter().map(String::as_str)), "her own names")
|
||||
}
|
||||
};
|
||||
members.push(Member { addressee, names_from, entry: entry.clone(), state, rooms });
|
||||
}
|
||||
for (at, message) in plan.script.iter().enumerate() {
|
||||
if message.ago.is_some() || message.new || message.tag {
|
||||
|
|
@ -207,8 +262,7 @@ pub fn simulate(harness: &Harness, plan_path: &Path) -> Result<String> {
|
|||
bail!("script message {} is in {}, which is not one of the rooms", at + 1, message.room);
|
||||
}
|
||||
}
|
||||
let runs: Vec<Value> = (0..plan.repeats).map(|repeat| run(harness, &plan, &mut members, repeat)).collect::<Result<_>>()?;
|
||||
Ok(markdown(plan_path, &plan, &runs))
|
||||
Ok(members)
|
||||
}
|
||||
|
||||
fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize) -> Result<Value> {
|
||||
|
|
@ -216,32 +270,58 @@ fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize)
|
|||
let cast: Vec<String> = members.iter().map(|member| member.entry.id.clone()).collect();
|
||||
let at_round = |round: usize| plan.start + Duration::minutes(plan.round_minutes * round as i64);
|
||||
let mut lines: Vec<Line> = Vec::new();
|
||||
// Per line: the round, and the cause of the turn that spoke it (none for a script line).
|
||||
let mut rounds_of: Vec<usize> = Vec::new();
|
||||
let scripted = |round: usize, lines: &mut Vec<Line>, rounds_of: &mut Vec<usize>| -> Result<()> {
|
||||
let mut causes: Vec<Option<&'static str>> = Vec::new();
|
||||
let scripted = |round: usize, lines: &mut Vec<Line>, rounds_of: &mut Vec<usize>, causes: &mut Vec<Option<&'static str>>| -> Result<()> {
|
||||
for (at, message) in plan.script.iter().enumerate().filter(|(_, message)| message.round.unwrap_or(0) == round) {
|
||||
lines.push(Line::of(message, at_round(round) + Duration::seconds(at as i64), None, at)?);
|
||||
rounds_of.push(round);
|
||||
causes.push(None);
|
||||
}
|
||||
Ok(())
|
||||
};
|
||||
scripted(0, &mut lines, &mut rounds_of)?;
|
||||
scripted(0, &mut lines, &mut rounds_of, &mut causes)?;
|
||||
let opening = lines.len();
|
||||
let mut seen = vec![0usize; members.len()];
|
||||
let mut last_turn: Vec<Option<DateTime<Utc>>> = vec![None; members.len()];
|
||||
let mut last_beat = plan.start;
|
||||
let mut recent: Vec<Vec<Vec<String>>> = vec![Vec::new(); members.len()];
|
||||
let mut turns = Vec::new();
|
||||
let mut counter = 0u64;
|
||||
for round in 1..=plan.rounds {
|
||||
scripted(round, &mut lines, &mut rounds_of)?;
|
||||
let beat = plan.beat_every > 0 && round % plan.beat_every == 0;
|
||||
let woken: Vec<(usize, (&'static str, Vec<Value>))> = members.iter().enumerate().filter_map(|(at, member)| wake_reason(&lines, seen[at], member, &cast, plan.wake, beat).map(|why| (at, why))).collect();
|
||||
for (at, (why, addressed_by)) in shuffled(woken, seed ^ (round as u64).wrapping_mul(0x9E37_79B9)) {
|
||||
scripted(round, &mut lines, &mut rounds_of, &mut causes)?;
|
||||
let round_at = at_round(round);
|
||||
let runs = mind_runs(&lines, &cast);
|
||||
let mut woke: Vec<(usize, Option<Woken>)> = members.iter().enumerate().filter_map(|(at, member)| woken(&lines, &runs, seen[at], member, &plan.operators, &cast, plan.wake).map(|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) {
|
||||
let standings: Vec<Standing> = members
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(at, member)| Standing {
|
||||
slug: localpart(&member.entry.id).to_owned(),
|
||||
eligible: !woke.iter().any(|(woken, _)| *woken == at),
|
||||
waited_s: last_turn[at].map(|turn| u64::try_from((round_at - turn).num_seconds()).unwrap_or(0)),
|
||||
last_turn_ms: last_turn[at].map(|turn| turn.timestamp_millis()),
|
||||
topic_permille: 0,
|
||||
addressed_by_member: lines.iter().enumerate().skip(seen[at]).any(|(index, line)| !plan.operators.contains(&line.from) && line.from != member.entry.id && is_for(&member.addressee, &line.delivery(index, &member.entry.id, &lines))),
|
||||
})
|
||||
.collect();
|
||||
if let Some(winner) = pick(&standings, plan.beat_s) {
|
||||
woke.push((winner, None));
|
||||
last_beat = round_at;
|
||||
}
|
||||
}
|
||||
for (at, why) in shuffled(woke, seed ^ (round as u64).wrapping_mul(0x9E37_79B9)) {
|
||||
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 && (member.rooms.contains(&line.room) || line.dm)).collect();
|
||||
let here = fresh.iter().rev().find(|line| line.mentions.contains(&id)).or(fresh.last()).map_or_else(|| member.rooms[0].clone(), |line| line.room.clone());
|
||||
let kind = if fresh.is_empty() { TurnKind::Beat } else { TurnKind::Chat };
|
||||
let now = at_round(round) + Duration::seconds(30 + counter as i64);
|
||||
let now = round_at + Duration::seconds(30 + counter as i64);
|
||||
let request = Request {
|
||||
instance: localpart(&id).to_owned(),
|
||||
kind,
|
||||
|
|
@ -263,24 +343,31 @@ fn run(harness: &Harness, plan: &SimFile, members: &mut [Member], repeat: usize)
|
|||
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:#}") }));
|
||||
seen[at] = lines.len();
|
||||
last_turn[at] = Some(now);
|
||||
let render = &report["renders"][0];
|
||||
if let Some(selected) = render["selected"].as_array() {
|
||||
recent[at].push(selected.iter().filter_map(Value::as_str).map(str::to_owned).collect());
|
||||
}
|
||||
// A failed call is a failure, never a silence.
|
||||
let failed = report.get("error").or_else(|| render.get("failed")).or_else(|| render["persona"].get("failed")).map(|fault| fault.as_str().unwrap_or_default().to_owned());
|
||||
let said: Vec<String> = render["persona"]["would_say"].as_array().map(|said| said.iter().filter_map(Value::as_str).map(str::to_owned).collect()).unwrap_or_default();
|
||||
let line = (!said.is_empty()).then(|| said.join(" "));
|
||||
let cause = cause_word(why.as_ref().map(|why| why.cause));
|
||||
if let Some(says) = &line {
|
||||
lines.push(Line { from: id.clone(), name: member.entry.name.clone(), room: here.clone(), at_ms: u64::try_from(now.timestamp_millis()).unwrap_or_default(), says: says.clone(), mentions: vec![], dm: false, follow_up: false, reply_to: None, new: false });
|
||||
rounds_of.push(round);
|
||||
causes.push(Some(cause));
|
||||
}
|
||||
let turn = json!({ "round": round, "persona": member.entry.name, "id": id, "woke": why, "addressed_by": addressed_by, "kind": kind, "room": here, "said": line, "report": report });
|
||||
let outcome = if failed.is_some() { "failed" } else if line.is_some() { "spoke" } else { "silent" };
|
||||
let (how, by) = why.map_or((None, vec![]), |why| (why.how, why.by));
|
||||
let turn = json!({ "round": round, "persona": member.entry.name, "id": id, "woke": cause, "how": how, "addressed_by": by, "kind": kind, "room": here, "outcome": outcome, "failed": failed, "said": line, "report": report });
|
||||
let member = &mut members[at];
|
||||
member.state = state_after_turn(std::mem::take(&mut member.state), &turn);
|
||||
turns.push(turn);
|
||||
}
|
||||
}
|
||||
let metrics = metrics(members, &lines, &rounds_of, opening, &turns, plan.rounds);
|
||||
let transcript: Vec<Value> = lines.iter().zip(&rounds_of).map(|(line, round)| json!({ "round": round, "room": line.room, "from": line.from, "name": line.name, "says": line.says, "mind": cast.contains(&line.from) })).collect();
|
||||
let metrics = metrics(members, &lines, &rounds_of, &causes, opening, &turns, plan.rounds);
|
||||
let transcript: Vec<Value> = lines.iter().zip(&rounds_of).zip(&causes).map(|((line, round), cause)| json!({ "round": round, "room": line.room, "from": line.from, "name": line.name, "says": line.says, "mind": cast.contains(&line.from), "woke": cause })).collect();
|
||||
Ok(json!({ "repeat": repeat + 1, "seed": seed, "transcript": transcript, "turns": turns, "metrics": metrics }))
|
||||
}
|
||||
|
||||
|
|
@ -311,12 +398,39 @@ fn mean_pairwise(texts: &BTreeMap<String, String>) -> Option<f64> {
|
|||
/// Which rounds a measure keeps.
|
||||
type Keep<'a> = &'a dyn Fn(usize) -> bool;
|
||||
|
||||
fn metrics(members: &[Member], lines: &[Line], rounds_of: &[usize], opening: usize, turns: &[Value], rounds: usize) -> Value {
|
||||
/// A Mind-to-Mind reply: a Mind's line spoken in a turn another Mind's line woke.
|
||||
fn mind_reply(cause: Option<&str>) -> bool {
|
||||
matches!(cause, Some("addressed_by_mind" | "mind"))
|
||||
}
|
||||
|
||||
/// Per room: Mind-to-Mind replies in a row with no human line and no human-woken answer between them.
|
||||
fn reply_chains(lines: &[Line], causes: &[Option<&str>], opening: usize, cast: &[&str]) -> Value {
|
||||
let mut rooms: BTreeMap<String, (usize, usize, usize, usize)> = BTreeMap::new();
|
||||
for (line, cause) in lines.iter().zip(causes).skip(opening) {
|
||||
let (longest, chains, total, run) = rooms.entry(line.room.clone()).or_default();
|
||||
if cast.contains(&line.from.as_str()) && mind_reply(*cause) {
|
||||
*run += 1;
|
||||
*total += 1;
|
||||
*longest = (*longest).max(*run);
|
||||
} else {
|
||||
*chains += usize::from(*run >= 3);
|
||||
*run = 0;
|
||||
}
|
||||
}
|
||||
let out: BTreeMap<String, Value> = rooms
|
||||
.into_iter()
|
||||
.map(|(room, (longest, chains, total, run))| (room, json!({ "longest": longest, "chains_of_3_or_more": chains + usize::from(run >= 3), "mind_to_mind_replies": total })))
|
||||
.collect();
|
||||
json!(out)
|
||||
}
|
||||
|
||||
fn metrics(members: &[Member], lines: &[Line], rounds_of: &[usize], causes: &[Option<&str>], opening: usize, turns: &[Value], rounds: usize) -> Value {
|
||||
let cast: Vec<&str> = members.iter().map(|member| member.entry.id.as_str()).collect();
|
||||
let outcome = |turn: &&Value, what: &str| turn["outcome"] == what;
|
||||
let mut per = BTreeMap::new();
|
||||
for member in members {
|
||||
let mine: Vec<&Value> = turns.iter().filter(|turn| turn["id"] == member.entry.id.as_str()).collect();
|
||||
let spoke = mine.iter().filter(|turn| !turn["said"].is_null()).count();
|
||||
let (spoke, silent, failed) = (mine.iter().filter(|turn| outcome(turn, "spoke")).count(), mine.iter().filter(|turn| outcome(turn, "silent")).count(), mine.iter().filter(|turn| outcome(turn, "failed")).count());
|
||||
let mut addressed = BTreeMap::new();
|
||||
for (at, line) in lines.iter().enumerate().skip(opening).filter(|(_, line)| line.from == member.entry.id) {
|
||||
for other in members.iter().filter(|other| other.entry.id != member.entry.id) {
|
||||
|
|
@ -325,22 +439,11 @@ fn metrics(members: &[Member], lines: &[Line], rounds_of: &[usize], opening: usi
|
|||
}
|
||||
}
|
||||
}
|
||||
per.insert(member.entry.name.clone(), json!({ "turns": mine.len(), "messages": spoke, "silence_rate": if mine.is_empty() { Value::Null } else { json!(1.0 - spoke as f64 / mine.len() as f64) }, "addressed": addressed }));
|
||||
let answered = spoke + silent;
|
||||
per.insert(member.entry.name.clone(), json!({ "turns": mine.len(), "messages": spoke, "failed": failed, "silence_rate": if answered == 0 { Value::Null } else { json!(silent as f64 / answered as f64) }, "addressed": addressed }));
|
||||
}
|
||||
// Mind-to-Mind chains: runs of Mind lines with no human line between them.
|
||||
let (mut longest, mut long_chains, mut run) = (0usize, 0usize, 0usize);
|
||||
for line in &lines[opening..] {
|
||||
if cast.contains(&line.from.as_str()) {
|
||||
run += 1;
|
||||
longest = longest.max(run);
|
||||
} else {
|
||||
long_chains += usize::from(run >= 3);
|
||||
run = 0;
|
||||
}
|
||||
}
|
||||
long_chains += usize::from(run >= 3);
|
||||
let half = rounds.div_ceil(2);
|
||||
let spoken_by = |keep: &dyn Fn(usize) -> bool| -> BTreeMap<String, String> {
|
||||
let spoken_by = |keep: Keep| -> BTreeMap<String, String> {
|
||||
let mut texts = BTreeMap::new();
|
||||
for (line, _) in lines.iter().zip(rounds_of).skip(opening).filter(|(line, round)| cast.contains(&line.from.as_str()) && keep(**round)) {
|
||||
let text: &mut String = texts.entry(line.from.clone()).or_default();
|
||||
|
|
@ -349,7 +452,7 @@ fn metrics(members: &[Member], lines: &[Line], rounds_of: &[usize], opening: usi
|
|||
}
|
||||
texts
|
||||
};
|
||||
let prose_by = |keep: &dyn Fn(usize) -> bool| -> BTreeMap<String, String> {
|
||||
let prose_by = |keep: Keep| -> BTreeMap<String, String> {
|
||||
let mut texts = BTreeMap::new();
|
||||
for turn in turns.iter().filter(|turn| turn["round"].as_u64().is_some_and(|round| keep(round as usize))) {
|
||||
let text: &mut String = texts.entry(turn["id"].as_str().unwrap_or_default().to_owned()).or_default();
|
||||
|
|
@ -360,31 +463,34 @@ fn metrics(members: &[Member], lines: &[Line], rounds_of: &[usize], opening: usi
|
|||
};
|
||||
let (all, early, late): (Keep, Keep, Keep) = (&|_| true, &|round| round <= half, &|round| round > half);
|
||||
let mind_lines: Vec<&Line> = lines[opening..].iter().filter(|line| cast.contains(&line.from.as_str())).collect();
|
||||
const CAUSES: [&str; 5] = ["addressed_by_human", "human", "addressed_by_mind", "mind", "beat"];
|
||||
let count_causes = |these: &[&Value]| -> BTreeMap<&str, usize> { CAUSES.iter().map(|cause| (*cause, these.iter().filter(|turn| turn["woke"] == *cause).count())).collect() };
|
||||
let wakes_by_round: Vec<Value> = (1..=rounds)
|
||||
.map(|round| {
|
||||
let these: Vec<&Value> = turns.iter().filter(|turn| turn["round"] == round).collect();
|
||||
let count = |whys: &[&str]| these.iter().filter(|turn| whys.contains(&turn["woke"].as_str().unwrap_or_default())).count();
|
||||
json!({ "round": round, "human": count(&["addressed by a human", "a human in her rooms"]), "mind_addressed": count(&["addressed by a Mind"]), "mind_unaddressed": count(&["a message in her rooms"]), "beat": count(&["the beat"]) })
|
||||
json!({ "round": round, "causes": count_causes(&these) })
|
||||
})
|
||||
.collect();
|
||||
let mind_addressed: Vec<Value> = turns
|
||||
.iter()
|
||||
.filter(|turn| turn["woke"] == "addressed by a Mind")
|
||||
.flat_map(|turn| turn["addressed_by"].as_array().into_iter().flatten().map(move |by| json!({ "round": turn["round"], "persona": turn["persona"], "from": by["from"], "how": by["how"], "says": by["says"] })))
|
||||
.collect();
|
||||
let every: Vec<&Value> = turns.iter().collect();
|
||||
let mind_woken: Vec<&Value> = turns.iter().filter(|turn| turn["woke"] == "addressed_by_mind").collect();
|
||||
let by_how = |how: &str| mind_woken.iter().filter(|turn| turn["how"] == how).count();
|
||||
let id_as_text: Vec<Value> = mind_woken.iter().filter(|turn| turn["how"] == "id as text").map(|turn| json!({ "round": turn["round"], "persona": turn["persona"], "by": turn["addressed_by"] })).collect();
|
||||
let (silent, failed) = (turns.iter().filter(|turn| turn["outcome"] == "silent").count(), turns.iter().filter(|turn| turn["outcome"] == "failed").count());
|
||||
let answered = turns.len() - failed;
|
||||
let work = mind_lines.iter().filter(|line| work_talk(&line.says)).count();
|
||||
json!({
|
||||
"personas": per,
|
||||
"turns": turns.len(),
|
||||
"wakes": count_causes(&every),
|
||||
"failed": failed,
|
||||
"mind_messages": mind_lines.len(),
|
||||
"silence_rate": if turns.is_empty() { Value::Null } else { json!(turns.iter().filter(|turn| turn["said"].is_null()).count() as f64 / turns.len() as f64) },
|
||||
"mind_chain_longest": longest,
|
||||
"mind_chains_of_3_or_more": long_chains,
|
||||
"silence_rate": if answered == 0 { Value::Null } else { json!(silent as f64 / answered as f64) },
|
||||
"reply_chains": reply_chains(lines, causes, opening, &cast),
|
||||
"convergence_lines": { "all": mean_pairwise(&spoken_by(all)), "first_half": mean_pairwise(&spoken_by(early)), "second_half": mean_pairwise(&spoken_by(late)) },
|
||||
"convergence_prose": { "all": mean_pairwise(&prose_by(all)), "first_half": mean_pairwise(&prose_by(early)), "second_half": mean_pairwise(&prose_by(late)) },
|
||||
"work_talk_share": if mind_lines.is_empty() { Value::Null } else { json!(work as f64 / mind_lines.len() as f64) },
|
||||
"wakes_by_round": wakes_by_round,
|
||||
"mind_addressed": mind_addressed,
|
||||
"mind_addressed_wakes": { "total": mind_woken.len(), "mention_or_reply": by_how("mention or reply"), "id_as_text": by_how("id as text"), "name_in_text": by_how("name in text"), "id_as_text_wakes": id_as_text },
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -397,57 +503,100 @@ fn number(value: &Value) -> String {
|
|||
value.as_f64().map_or_else(|| "n/a".into(), |number| format!("{number:.3}"))
|
||||
}
|
||||
|
||||
fn markdown(plan_path: &Path, plan: &SimFile, runs: &[Value]) -> String {
|
||||
fn policy_words(policy: WakePolicy) -> String {
|
||||
match policy {
|
||||
WakePolicy::Live => "live: the operator or another Mind addressing her (the heartbeat's rule today)".into(),
|
||||
WakePolicy::Ruled => "ruled: a line addressing her, from anyone, and any human line in her rooms".into(),
|
||||
WakePolicy::HumansPace => "humans_pace: human lines only, each waking every Mind in the room once; a Mind's line wakes no one".into(),
|
||||
WakePolicy::NamesWithCap(cap) => format!("names_with_cap {cap}: ruled, but a Mind's line past {cap} Mind lines in a row in its room wakes no one until a human speaks"),
|
||||
WakePolicy::AllMessages => "all_messages: any line in her rooms, a Mind's too (the old loop, the control)".into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// `count` lines spread evenly over the transcript, the first and the last included.
|
||||
fn representative(transcript: &[Value], count: usize) -> Vec<&Value> {
|
||||
if transcript.len() <= count {
|
||||
return transcript.iter().collect();
|
||||
}
|
||||
let mut at: Vec<usize> = (0..count).map(|index| index * (transcript.len() - 1) / (count - 1)).collect();
|
||||
at.dedup();
|
||||
at.into_iter().map(|index| &transcript[index]).collect()
|
||||
}
|
||||
|
||||
fn transcript_line(line: &Value) -> String {
|
||||
let who = if line["mind"] == true { line["name"].as_str().unwrap_or_default().to_owned() } else { format!("{} (human)", line["name"].as_str().unwrap_or_default()) };
|
||||
let woke = line["woke"].as_str().map_or_else(String::new, |cause| format!(" _(woke: {cause})_"));
|
||||
format!("- r{} {} **{who}**{woke}: {}", line["round"], line["room"].as_str().unwrap_or_default(), one_line(line["says"].as_str().unwrap_or_default()))
|
||||
}
|
||||
|
||||
fn markdown(plan_path: &Path, plan: &SimFile, members: &[Member], group_state: Option<bool>, runs: &[Value]) -> String {
|
||||
let mut out = String::new();
|
||||
let _ = writeln!(out, "# Swarm simulation\n");
|
||||
let _ = writeln!(out, "> **State does not evolve during a run.** The Interpreter (C3b) and the commit (C3c) are not built, so every persona starts each turn from the state the plan gave her. `state_after_turn` in `projection/simulate.rs` is the seam where they will move it between rounds. Freshness carries over: each persona's earlier packets in the run count against repeating an item.\n");
|
||||
let _ = writeln!(out, "> **No explicit addressee.** Whom a line is to is the Interpreter's to say (C3b); until then a spoken line carries no Matrix mention, so one persona addresses another only through names in the text.\n");
|
||||
let _ = writeln!(out, "- plan: `{}`", plan_path.display());
|
||||
let _ = writeln!(out, "- cast: {}", plan.cast.iter().map(|entry| format!("{} (`{}`, `{}`)", entry.name, entry.id, entry.state.display())).collect::<Vec<_>>().join(", "));
|
||||
let _ = writeln!(out, "- cast: {}", members.iter().map(|member| format!("{} (`{}`, `{}`, names from {})", member.entry.name, member.entry.id, member.entry.state.display(), member.names_from)).collect::<Vec<_>>().join(", "));
|
||||
let _ = writeln!(out, "- rooms: {}; rounds: {}; repeats: {}; seed: {}; minutes a round: {}", plan.rooms.join(", "), plan.rounds, plan.repeats, plan.seed, plan.round_minutes);
|
||||
let _ = writeln!(out, "- wake: {}; beat: {}", match plan.wake { Wake::HumansInRooms => "ruled set (addressed, any human message in her rooms, the beat; another Mind's unaddressed message wakes no one)", Wake::AllMessages => "control: any message in her rooms wakes her, a Mind's too (the old loop)" }, if plan.beat_every == 0 { "off".to_owned() } else { format!("every {} rounds", plan.beat_every) });
|
||||
let _ = writeln!(out, "- wake: {}; beat: {}", policy_words(plan.wake), if plan.beat_s == 0 { "off".to_owned() } else { format!("every {} s of simulated time, one Persona by `tempo::pick`", plan.beat_s) });
|
||||
let _ = writeln!(out, "- group state in the Projector's packet: {}", match group_state { Some(true) => "on", Some(false) => "off", None => "unknown (the tuning did not load)" });
|
||||
let _ = writeln!(out, "- speech: the double-quoted spans of her prose, joined, posted to the room she woke in; none is silence. A preview of the Interpreter's speech, not its decision");
|
||||
let _ = writeln!(out, "- wakes: a human-caused wake is counted as the human's even when a Mind also addressed her; Mind-addressed wakes are split by evidence (Matrix mention or reply, her id written as text, a name in the text). Spoken lines here carry no Matrix mention, so a Mind addresses another only through text
|
||||
- convergence is the mean pairwise cosine of speakers' word counts (lexical, cheap); work-talk share is a lexical heuristic over a fixed word list, not a classifier");
|
||||
let _ = writeln!(out, "- wakes are counted per wake, by its strongest cause: addressed by a human, a human line, addressed by a Mind, a Mind's line (control only), the beat. A Mind-addressed wake's evidence is its strongest: a Matrix mention or reply, her id written as text, a name in the text");
|
||||
let _ = writeln!(out, "- silence rate is per woken turn that did not fail; a failed call is counted apart. Reply chains are per room: Mind lines spoken in turns another Mind's line woke, in a row");
|
||||
let _ = writeln!(out, "- convergence is the mean pairwise cosine of speakers' word counts (lexical, cheap); work-talk share is a lexical heuristic over a fixed word list, not a classifier");
|
||||
let _ = writeln!(out, "- read-only: nothing is posted, no state is put, no Mind is asked\n");
|
||||
for run in runs {
|
||||
let metrics = &run["metrics"];
|
||||
let wakes = &metrics["wakes"];
|
||||
let _ = writeln!(out, "## Repeat {} (seed {})\n", run["repeat"], run["seed"]);
|
||||
let _ = writeln!(out, "### Metrics\n");
|
||||
let _ = writeln!(out, "- turns: {}; Mind messages: {}; silence rate: {}", metrics["turns"], metrics["mind_messages"], number(&metrics["silence_rate"]));
|
||||
let _ = writeln!(out, "- longest Mind-to-Mind chain with no human between: {}; chains of 3 or more: {}", metrics["mind_chain_longest"], metrics["mind_chains_of_3_or_more"]);
|
||||
let _ = writeln!(
|
||||
out,
|
||||
"- wakes: {} (addressed by a human {}, a human line {}, addressed by a Mind {}, a Mind's line {}, the beat {}); failed {}",
|
||||
metrics["turns"], wakes["addressed_by_human"], wakes["human"], wakes["addressed_by_mind"], wakes["mind"], wakes["beat"], metrics["failed"]
|
||||
);
|
||||
let _ = writeln!(out, "- Mind messages: {}; silence rate per woken turn: {}", metrics["mind_messages"], number(&metrics["silence_rate"]));
|
||||
if let Some(rooms) = metrics["reply_chains"].as_object() {
|
||||
for (room, chain) in rooms {
|
||||
let _ = writeln!(out, "- reply chains in {room}: longest {}, chains of 3 or more {}, Mind-to-Mind replies {}", chain["longest"], chain["chains_of_3_or_more"], chain["mind_to_mind_replies"]);
|
||||
}
|
||||
}
|
||||
let addressed = &metrics["mind_addressed_wakes"];
|
||||
let _ = writeln!(out, "- Mind-addressed wakes: {} (Matrix mention or reply {}, her id written as text {}, a name in the text {})", addressed["total"], addressed["mention_or_reply"], addressed["id_as_text"], addressed["name_in_text"]);
|
||||
let _ = writeln!(out, "- convergence of spoken lines: all {}, first half {}, second half {}", number(&metrics["convergence_lines"]["all"]), number(&metrics["convergence_lines"]["first_half"]), number(&metrics["convergence_lines"]["second_half"]));
|
||||
let _ = writeln!(out, "- convergence of prose: all {}, first half {}, second half {}", number(&metrics["convergence_prose"]["all"]), number(&metrics["convergence_prose"]["first_half"]), number(&metrics["convergence_prose"]["second_half"]));
|
||||
let _ = writeln!(out, "- work-talk share of Mind lines (heuristic): {}\n", number(&metrics["work_talk_share"]));
|
||||
let _ = writeln!(out, "| persona | turns | messages | silence rate | addressed |\n|---|---|---|---|---|");
|
||||
let _ = writeln!(out, "| persona | wakes | messages | failed | silence rate | addressed |\n|---|---|---|---|---|---|");
|
||||
if let Some(personas) = metrics["personas"].as_object() {
|
||||
for (name, row) in personas {
|
||||
let addressed = row["addressed"].as_object().map(|map| map.iter().map(|(who, count)| format!("{who} {count}")).collect::<Vec<_>>().join(", ")).unwrap_or_default();
|
||||
let _ = writeln!(out, "| {name} | {} | {} | {} | {addressed} |", row["turns"], row["messages"], number(&row["silence_rate"]));
|
||||
let named = row["addressed"].as_object().map(|map| map.iter().map(|(who, count)| format!("{who} {count}")).collect::<Vec<_>>().join(", ")).unwrap_or_default();
|
||||
let _ = writeln!(out, "| {name} | {} | {} | {} | {} | {named} |", row["turns"], row["messages"], row["failed"], number(&row["silence_rate"]));
|
||||
}
|
||||
}
|
||||
let _ = writeln!(out, "\n### Wakes by round\n\nA wake a human's line would cause is counted as the human's; Mind-addressed wakes are those only a Mind's line caused.\n\n| round | human | Mind-addressed | Mind, unaddressed (control) | beat |\n|---|---|---|---|---|");
|
||||
let _ = writeln!(out, "\n### Wakes by round\n\n| round | addressed by a human | a human line | addressed by a Mind | a Mind's line | beat |\n|---|---|---|---|---|---|");
|
||||
for row in metrics["wakes_by_round"].as_array().into_iter().flatten() {
|
||||
let _ = writeln!(out, "| {} | {} | {} | {} | {} |", row["round"], row["human"], row["mind_addressed"], row["mind_unaddressed"], row["beat"]);
|
||||
let causes = &row["causes"];
|
||||
let _ = writeln!(out, "| {} | {} | {} | {} | {} | {} |", row["round"], causes["addressed_by_human"], causes["human"], causes["addressed_by_mind"], causes["mind"], causes["beat"]);
|
||||
}
|
||||
let addressed = metrics["mind_addressed"].as_array().cloned().unwrap_or_default();
|
||||
let by_how = |how: &str| addressed.iter().filter(|one| one["how"] == how).count();
|
||||
let _ = writeln!(out, "\nMind-addressed wake evidence: {} lines; a Matrix mention or reply {}, her Matrix id written as text {}, a name in the text {}.\n", addressed.len(), by_how("mention or reply"), by_how("id as text"), by_how("name in text"));
|
||||
let as_text: Vec<&Value> = addressed.iter().filter(|one| one["how"] == "id as text").collect();
|
||||
let as_text = addressed["id_as_text_wakes"].as_array().cloned().unwrap_or_default();
|
||||
if !as_text.is_empty() {
|
||||
let _ = writeln!(out, "Wakes where the only address was an id written as text (no mention, no reply):\n");
|
||||
let _ = writeln!(out, "\nWakes whose only address was an id written as text (no mention, no reply):\n");
|
||||
for one in as_text {
|
||||
let _ = writeln!(out, "- r{} {} woken by {}: {}", one["round"], one["persona"].as_str().unwrap_or_default(), one["from"].as_str().unwrap_or_default(), one_line(one["says"].as_str().unwrap_or_default()));
|
||||
let by = one["by"].as_array().into_iter().flatten().map(|by| format!("{}: {}", by["from"].as_str().unwrap_or_default(), one_line(by["says"].as_str().unwrap_or_default()))).collect::<Vec<_>>().join("; ");
|
||||
let _ = writeln!(out, "- r{} {}: {by}", one["round"], one["persona"].as_str().unwrap_or_default());
|
||||
}
|
||||
}
|
||||
let transcript = run["transcript"].as_array().cloned().unwrap_or_default();
|
||||
let _ = writeln!(out, "\n### Representative lines\n");
|
||||
for line in representative(&transcript, REPRESENTATIVE_LINES) {
|
||||
let _ = writeln!(out, "{}", transcript_line(line));
|
||||
}
|
||||
let _ = writeln!(out, "\n### Transcript\n");
|
||||
for line in run["transcript"].as_array().into_iter().flatten() {
|
||||
let who = if line["mind"] == true { line["name"].as_str().unwrap_or_default().to_owned() } else { format!("{} (human)", line["name"].as_str().unwrap_or_default()) };
|
||||
let _ = writeln!(out, "- r{} {} **{who}**: {}", line["round"], line["room"].as_str().unwrap_or_default(), one_line(line["says"].as_str().unwrap_or_default()));
|
||||
for line in &transcript {
|
||||
let _ = writeln!(out, "{}", transcript_line(line));
|
||||
}
|
||||
let _ = writeln!(out, "\n### Turns\n");
|
||||
for turn in run["turns"].as_array().into_iter().flatten() {
|
||||
let said = if turn["said"].is_null() { "silent".to_owned() } else { "spoke".to_owned() };
|
||||
let _ = writeln!(out, "<details><summary>round {}, {} (woke: {}, {} turn, {}): {said}</summary>\n", turn["round"], turn["persona"].as_str().unwrap_or_default(), turn["woke"].as_str().unwrap_or_default(), turn["kind"].as_str().unwrap_or_default(), turn["room"].as_str().unwrap_or_default());
|
||||
let _ = writeln!(out, "<details><summary>round {}, {} (woke: {}, {} turn, {}): {}</summary>\n", turn["round"], turn["persona"].as_str().unwrap_or_default(), turn["woke"].as_str().unwrap_or_default(), turn["kind"].as_str().unwrap_or_default(), turn["room"].as_str().unwrap_or_default(), turn["outcome"].as_str().unwrap_or_default());
|
||||
let report = &turn["report"];
|
||||
if let Some(error) = report.get("error") {
|
||||
let _ = writeln!(out, "**failed:** {}\n", error.as_str().unwrap_or_default());
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ use serde_json::Value;
|
|||
|
||||
use super::*;
|
||||
use crate::projection::harness::tests::{Scripted, control};
|
||||
use crate::projection::{Answer, Failed, Model, Spent};
|
||||
|
||||
const TOBIAH: &str = "@eureka:gamecult.org";
|
||||
const LIBBY: &str = "@libby:gamecult.org";
|
||||
|
|
@ -18,18 +19,21 @@ fn cast(dir: &Path) {
|
|||
std::fs::write(dir.join("libby.json"), libby.to_string()).unwrap();
|
||||
}
|
||||
|
||||
/// A plan over the two, the operator opening; `wake` is the TOML value of the policy; no beat unless `extra` sets one.
|
||||
fn plan(dir: &Path, wake: &str, rounds: usize, extra: &str) -> PathBuf {
|
||||
cast(dir);
|
||||
let path = dir.join("plan.toml");
|
||||
let beat = if extra.contains("beat_s") { "" } else { "beat_s = 0\n" };
|
||||
std::fs::write(
|
||||
&path,
|
||||
format!(
|
||||
r##"rounds = {rounds}
|
||||
seed = 11
|
||||
wake = "{wake}"
|
||||
wake = {wake}
|
||||
start = "2026-11-20T15:00:00Z"
|
||||
rooms = ["#minds:gamecult.org"]
|
||||
operators = ["@meta:gamecult.org"]
|
||||
{beat}{extra}
|
||||
[[cast]]
|
||||
id = "{TOBIAH}"
|
||||
name = "Tobiah"
|
||||
|
|
@ -43,33 +47,38 @@ from = "@meta:gamecult.org"
|
|||
name = "Meta"
|
||||
room = "#minds:gamecult.org"
|
||||
says = "good afternoon, everyone"
|
||||
{extra}"##
|
||||
"##
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
path
|
||||
}
|
||||
|
||||
/// Both speak every turn, neither naming the other: a Mind line wakes no one under the ruled set.
|
||||
fn chatty() -> Scripted {
|
||||
Scripted::new(|prompt| if prompt.contains("Who you are:\nTobiah") { "\"what a day\" he says".into() } else { "\"mm, the deploy went fine\" she says".into() })
|
||||
fn is_tobiah(prompt: &str) -> bool {
|
||||
prompt.contains("Who you are:\nTobiah")
|
||||
}
|
||||
|
||||
fn run_plan(path: &Path, model: &Scripted) -> (SimFile, Vec<Member>, Value) {
|
||||
/// Both speak every turn, neither naming the other.
|
||||
fn chatty() -> Scripted {
|
||||
Scripted::new(|prompt| if is_tobiah(prompt) { "\"what a day\" he says".into() } else { "\"mm, the deploy went fine\" she says".into() })
|
||||
}
|
||||
|
||||
/// Both speak every turn, each naming the other.
|
||||
fn namers() -> Scripted {
|
||||
Scripted::new(|prompt| if is_tobiah(prompt) { "\"Libby, tea?\"".into() } else { "\"Tobiah, yes please.\"".into() })
|
||||
}
|
||||
|
||||
fn silent() -> Scripted {
|
||||
Scripted::new(|_| "Nobody needs anything from her.".into())
|
||||
}
|
||||
|
||||
fn run_plan(path: &Path, model: &dyn Model) -> (Vec<Member>, Value) {
|
||||
let plan: SimFile = toml::from_str(&std::fs::read_to_string(path).unwrap()).unwrap();
|
||||
let base = path.parent().unwrap();
|
||||
let mut members: Vec<Member> = plan
|
||||
.cast
|
||||
.iter()
|
||||
.map(|entry| {
|
||||
let state = state_file(&base.join(&entry.state), localpart(&entry.id)).unwrap();
|
||||
let public = state["publicName"].as_str().unwrap().to_owned();
|
||||
Member { addressee: Addressee::new(&entry.id, [localpart(&entry.id), entry.name.as_str(), public.as_str()]), entry: entry.clone(), state, rooms: plan.rooms.clone() }
|
||||
})
|
||||
.collect();
|
||||
let mut members = cast_of(&plan, base).unwrap();
|
||||
let harness = Harness { instance: "eureka".into(), persona: None, model: Some(model), tuning: base.join("persona-tuning.toml") };
|
||||
let run = run(&harness, &plan, &mut members, 0).unwrap();
|
||||
(plan, members, run)
|
||||
(members, run)
|
||||
}
|
||||
|
||||
fn turns(run: &Value) -> Vec<(u64, String, String)> {
|
||||
|
|
@ -77,68 +86,156 @@ fn turns(run: &Value) -> Vec<(u64, String, String)> {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn under_the_ruled_wake_set_a_minds_unaddressed_line_wakes_no_one() {
|
||||
fn the_wake_policies_are_the_heartbeats_one_function() {
|
||||
let libby = Addressee::new(LIBBY, ["libby", "Libby"]);
|
||||
let line = |from: &str, says: &str| Line { from: from.into(), name: String::new(), room: "#minds:x".into(), at_ms: 0, says: says.into(), mentions: vec![], dm: false, follow_up: false, reply_to: None, new: false };
|
||||
let ask = |policy: WakePolicy, from: &str, says: &str, speaker: Speaker, run: usize| wakes(policy, &libby, &line(from, says).delivery(0, LIBBY, &[]), speaker, run);
|
||||
let (named, unnamed) = ("Libby, tea?", "what a day");
|
||||
use WakeCause::*;
|
||||
// Ruled: anyone addressing her, any human line.
|
||||
assert_eq!(ask(WakePolicy::Ruled, TOBIAH, named, Speaker::Mind, 0), Some(AddressedByMind));
|
||||
assert_eq!(ask(WakePolicy::Ruled, TOBIAH, unnamed, Speaker::Mind, 0), None, "another Mind's unaddressed line wakes no one");
|
||||
assert_eq!(ask(WakePolicy::Ruled, "@deru:x", unnamed, Speaker::Member, 0), Some(Human));
|
||||
assert_eq!(ask(WakePolicy::Ruled, "@deru:x", named, Speaker::Member, 0), Some(AddressedByHuman));
|
||||
// Live, the heartbeat's today: a member's line does not wake her, the operator's or a Mind's address does.
|
||||
assert_eq!(ask(WakePolicy::Live, "@deru:x", named, Speaker::Member, 0), None);
|
||||
assert_eq!(ask(WakePolicy::Live, "@meta:x", named, Speaker::Operator, 0), Some(AddressedByHuman));
|
||||
assert_eq!(ask(WakePolicy::Live, TOBIAH, named, Speaker::Mind, 0), Some(AddressedByMind));
|
||||
assert_eq!(ask(WakePolicy::Live, "@meta:x", unnamed, Speaker::Operator, 0), None);
|
||||
// Humans pace: a Mind's line never wakes a Mind.
|
||||
assert_eq!(ask(WakePolicy::HumansPace, TOBIAH, named, Speaker::Mind, 0), None);
|
||||
assert_eq!(ask(WakePolicy::HumansPace, "@meta:x", unnamed, Speaker::Operator, 0), Some(Human));
|
||||
// The cap: a Mind's address wakes her only while the Mind run before the line is under it.
|
||||
assert_eq!(ask(WakePolicy::NamesWithCap(2), TOBIAH, named, Speaker::Mind, 1), Some(AddressedByMind));
|
||||
assert_eq!(ask(WakePolicy::NamesWithCap(2), TOBIAH, named, Speaker::Mind, 2), None);
|
||||
assert_eq!(ask(WakePolicy::NamesWithCap(2), "@meta:x", unnamed, Speaker::Operator, 9), Some(Human), "a human always may");
|
||||
// The control, and her own line never.
|
||||
assert_eq!(ask(WakePolicy::AllMessages, TOBIAH, unnamed, Speaker::Mind, 0), Some(Mind));
|
||||
assert_eq!(ask(WakePolicy::AllMessages, LIBBY, named, Speaker::Her, 0), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn under_the_ruled_set_unaddressed_mind_lines_wake_no_one() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, _, run) = run_plan(&plan(dir.path(), "humans_in_rooms", 6, ""), &chatty());
|
||||
let (_, run) = run_plan(&plan(dir.path(), "\"ruled\"", 6, ""), &chatty());
|
||||
let turns = turns(&run);
|
||||
assert_eq!(turns.len(), 2, "the operator's opening wakes both in round 1, and then nothing does: {turns:?}");
|
||||
assert!(turns.iter().all(|(round, _, why)| *round == 1 && why == "a human in her rooms"), "{turns:?}");
|
||||
let transcript = run["transcript"].as_array().unwrap();
|
||||
assert_eq!(transcript.len(), 3);
|
||||
assert!(transcript.iter().any(|line| line["from"] == TOBIAH && line["says"] == "what a day" && line["mind"] == true), "her quoted words join the room as from her id: {transcript:?}");
|
||||
assert!(turns.iter().all(|(round, _, why)| *round == 1 && why == "human"), "{turns:?}");
|
||||
assert!(run["transcript"].as_array().unwrap().iter().any(|line| line["from"] == TOBIAH && line["says"] == "what a day" && line["woke"] == "human"), "her quoted words join the room as from her id");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_old_loop_control_lets_minds_wake_each_other_into_a_chain() {
|
||||
fn the_control_lets_minds_wake_each_other_into_a_reply_chain_counted_per_room() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, _, run) = run_plan(&plan(dir.path(), "all_messages", 6, ""), &chatty());
|
||||
let turns = turns(&run);
|
||||
assert!(turns.len() >= 6, "every round someone answers a Mind: {turns:?}");
|
||||
assert!(turns.iter().any(|(_, _, why)| why == "a message in her rooms"));
|
||||
let (_, run) = run_plan(&plan(dir.path(), "\"all_messages\"", 6, ""), &chatty());
|
||||
let metrics = &run["metrics"];
|
||||
assert!(metrics["mind_chain_longest"].as_u64().unwrap() >= 5, "{metrics}");
|
||||
assert!(metrics["mind_chains_of_3_or_more"].as_u64().unwrap() >= 1);
|
||||
assert_eq!(metrics["silence_rate"].as_f64(), Some(0.0));
|
||||
assert!(metrics["wakes"]["mind"].as_u64().unwrap() >= 5, "{metrics}");
|
||||
let chain = &metrics["reply_chains"]["#minds:gamecult.org"];
|
||||
// The two round-1 answers are to the operator; every later line is a reply to a Mind.
|
||||
assert_eq!(chain["mind_to_mind_replies"].as_u64(), Some(metrics["mind_messages"].as_u64().unwrap() - 2), "{metrics}");
|
||||
assert!(chain["longest"].as_u64().unwrap() >= 5 && chain["chains_of_3_or_more"] == 1, "{chain}");
|
||||
let work = metrics["work_talk_share"].as_f64().unwrap();
|
||||
assert!(work > 0.3 && work < 0.7, "Libby's lines name the deploy, Tobiah's do not: {work}");
|
||||
assert!(metrics["convergence_lines"]["all"].as_f64().unwrap() < 0.5, "two different lines are not one voice: {metrics}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_scripted_interjection_wakes_everyone_in_her_room_and_addressing_is_counted() {
|
||||
fn naming_runs_away_under_the_ruled_set_and_stops_at_the_cap() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, ruled) = run_plan(&plan(dir.path(), "\"ruled\"", 6, ""), &namers());
|
||||
assert!(turns(&ruled).iter().filter(|(_, _, why)| why == "addressed_by_mind").count() >= 5, "{:?}", turns(&ruled));
|
||||
assert_eq!(ruled["metrics"]["mind_addressed_wakes"]["name_in_text"], ruled["metrics"]["mind_addressed_wakes"]["total"]);
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, capped) = run_plan(&plan(dir.path(), "{ names_with_cap = 2 }", 6, ""), &namers());
|
||||
let capped = turns(&capped);
|
||||
assert!(capped.iter().all(|(round, _, _)| *round <= 2), "after two Mind lines in a row no Mind's address wakes anyone: {capped:?}");
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, paced) = run_plan(&plan(dir.path(), "\"humans_pace\"", 6, ""), &namers());
|
||||
assert_eq!(turns(&paced).len(), 2, "under humans_pace only the operator's line wakes anyone");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_human_interjection_wakes_everyone_in_her_room_under_humans_pace() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let interjection = "[[message]]\nround = 4\nfrom = \"@deru:gamecult.org\"\nname = \"Deru\"\nroom = \"#minds:gamecult.org\"\nsays = \"kettle news\"\n";
|
||||
let model = Scripted::new(|prompt| if prompt.contains("Who you are:\nTobiah") { "\"Libby, tea?\"".into() } else { "She does not answer.".into() });
|
||||
let (_, members, run) = run_plan(&plan(dir.path(), "humans_in_rooms", 5, interjection), &model);
|
||||
let turns = turns(&run);
|
||||
let fourth: Vec<&String> = turns.iter().filter(|(round, _, _)| *round == 4).map(|(_, who, _)| who).collect();
|
||||
assert_eq!(fourth.len(), 2, "Deru's line at round 4 wakes both: {turns:?}");
|
||||
assert_eq!(run["metrics"]["personas"]["Tobiah"]["addressed"]["Libby"].as_u64().unwrap(), run["metrics"]["personas"]["Tobiah"]["messages"].as_u64().unwrap());
|
||||
let path = plan(dir.path(), "\"humans_pace\"", 5, "");
|
||||
std::fs::write(&path, format!("{}{interjection}", std::fs::read_to_string(&path).unwrap())).unwrap();
|
||||
let (members, run) = run_plan(&path, &namers());
|
||||
let rounds = run["metrics"]["wakes_by_round"].as_array().unwrap();
|
||||
assert_eq!((rounds[0]["human"].as_u64(), rounds[3]["human"].as_u64()), (Some(2), Some(2)), "the opening and Deru wake both: {rounds:?}");
|
||||
let by_minds: u64 = rounds.iter().map(|row| row["mind_addressed"].as_u64().unwrap()).sum();
|
||||
assert_eq!(by_minds as usize, run["metrics"]["mind_addressed"].as_array().unwrap().len(), "one line addressed each Mind-addressed wake");
|
||||
assert_eq!(run["metrics"]["personas"]["Libby"]["silence_rate"].as_f64(), Some(1.0));
|
||||
// The seam: no state moved.
|
||||
assert_eq!(members[0].state, control());
|
||||
assert_eq!((rounds[0]["causes"]["human"].as_u64(), rounds[3]["causes"]["human"].as_u64(), rounds[1]["causes"]["addressed_by_mind"].as_u64()), (Some(2), Some(2), Some(0)), "{rounds:?}");
|
||||
assert_eq!(run["metrics"]["personas"]["Tobiah"]["addressed"]["Libby"].as_u64(), run["metrics"]["personas"]["Tobiah"]["messages"].as_u64());
|
||||
assert_eq!(members[0].state, control(), "the seam: no state moved");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_same_seed_replays_the_same_order() {
|
||||
fn the_beat_wakes_one_persona_by_the_heartbeats_pick() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = plan(dir.path(), "all_messages", 4, "");
|
||||
let (_, _, first) = run_plan(&path, &chatty());
|
||||
let (_, _, second) = run_plan(&path, &chatty());
|
||||
assert_eq!(turns(&first), turns(&second));
|
||||
let (_, run) = run_plan(&plan(dir.path(), "\"ruled\"", 4, "beat_s = 120"), &silent());
|
||||
let turns = turns(&run);
|
||||
for round in 2..=4 {
|
||||
let beats: Vec<&(u64, String, String)> = turns.iter().filter(|(at, _, _)| *at == round).collect();
|
||||
assert_eq!(beats.len(), 1, "one wake a beat: {turns:?}");
|
||||
assert_eq!(beats[0].2, "beat");
|
||||
}
|
||||
// The pick takes whoever waited longest: the two alternate.
|
||||
assert_ne!(turns[2].1, turns[3].1, "{turns:?}");
|
||||
assert_eq!(run["metrics"]["silence_rate"].as_f64(), Some(1.0));
|
||||
}
|
||||
|
||||
/// A model whose Persona stage fails: a failure, never a silence.
|
||||
struct FailingPersona;
|
||||
|
||||
impl Model for FailingPersona {
|
||||
fn ask(&self, _request_id: &str, model: &str, prompt: &str) -> std::result::Result<Answer, Failed> {
|
||||
if prompt.starts_with("<!-- membrane:") {
|
||||
Ok(Answer { text: "The room is slow.".into(), usage: None })
|
||||
} else {
|
||||
Err(Failed { reason: "the provider failed the call: Overloaded".into(), usage: Some(Spent { model: model.into(), input_tokens: 5, output_tokens: 0, cache_read_tokens: 0, cache_write_tokens: 0, reasoning_tokens: None }) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_report_names_the_state_gap_and_carries_the_transcript_and_usage() {
|
||||
fn a_failed_call_is_a_failure_and_not_a_silence() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let (_, run) = run_plan(&plan(dir.path(), "\"ruled\"", 2, ""), &FailingPersona);
|
||||
let metrics = &run["metrics"];
|
||||
assert_eq!((metrics["failed"].as_u64(), metrics["silence_rate"].is_null()), (Some(2), true), "{metrics}");
|
||||
assert!(run["turns"].as_array().unwrap().iter().all(|turn| turn["outcome"] == "failed" && turn["failed"].as_str().unwrap().contains("Overloaded")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_seed_replays_its_order_and_another_seed_changes_it() {
|
||||
let items: Vec<usize> = (0..8).collect();
|
||||
assert_eq!(shuffled(items.clone(), 1), shuffled(items.clone(), 1));
|
||||
assert_ne!(shuffled(items.clone(), 1), shuffled(items.clone(), 2));
|
||||
let mut sorted = shuffled(items.clone(), 2);
|
||||
sorted.sort_unstable();
|
||||
assert_eq!(sorted, items, "a shuffle, nothing lost");
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = plan(dir.path(), "\"all_messages\"", 4, "");
|
||||
assert_eq!(turns(&run_plan(&path, &chatty()).1), turns(&run_plan(&path, &chatty()).1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_wake_by_an_id_written_as_text_is_counted_once_and_listed() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let model = Scripted::new(|prompt| if is_tobiah(prompt) { "\"ask @libby:gamecult.org, and Libby too\"".into() } else { "\"Tobiah?\"".into() });
|
||||
let (_, run) = run_plan(&plan(dir.path(), "\"ruled\"", 3, ""), &model);
|
||||
let addressed = &run["metrics"]["mind_addressed_wakes"];
|
||||
let libby_mind_wakes = turns(&run).iter().filter(|(_, who, why)| who == "Libby" && why == "addressed_by_mind").count();
|
||||
assert!(libby_mind_wakes >= 1, "{:?}", turns(&run));
|
||||
assert_eq!(addressed["total"].as_u64().unwrap() as usize, turns(&run).iter().filter(|(_, _, why)| why == "addressed_by_mind").count());
|
||||
assert_eq!(addressed["id_as_text"].as_u64().unwrap() as usize, libby_mind_wakes, "the strongest evidence of each wake, once per wake: {addressed}");
|
||||
assert_eq!(addressed["id_as_text_wakes"].as_array().unwrap().len(), libby_mind_wakes);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_report_names_its_gaps_and_carries_representative_lines_and_usage() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let model = chatty();
|
||||
let harness = Harness { instance: "eureka".into(), persona: None, model: Some(&model), tuning: dir.path().join("persona-tuning.toml") };
|
||||
let report = simulate(&harness, &plan(dir.path(), "humans_in_rooms", 3, "")).unwrap();
|
||||
for part in ["# Swarm simulation", "State does not evolve during a run", "## Repeat 1 (seed 11)", "### Transcript", "**Meta (human)**: good afternoon, everyone", "**Tobiah**: what a day", "<details><summary>round 1, ", "### Wakes by round", "| 1 | 2 | 0 | 0 | 0 |", "## Total usage", "| claude-sonnet-5-5 | 4 |"] {
|
||||
let report = simulate(&harness, &plan(dir.path(), "\"ruled\"", 3, "")).unwrap();
|
||||
for part in ["# Swarm simulation", "State does not evolve during a run", "No explicit addressee", "group state in the Projector's packet: on", "### Representative lines", "**Meta (human)**: good afternoon, everyone", "**Tobiah** _(woke: human)_: what a day", "### Wakes by round", "| 1 | 0 | 2 | 0 | 0 | 0 |", "## Total usage", "| claude-sonnet-5-5 | 4 |"] {
|
||||
assert!(report.contains(part), "{part}\n{report}");
|
||||
}
|
||||
}
|
||||
|
|
@ -148,7 +245,7 @@ fn a_cast_past_eight_or_a_foreign_state_is_refused() {
|
|||
let dir = tempfile::tempdir().unwrap();
|
||||
let model = chatty();
|
||||
let harness = Harness { instance: "eureka".into(), persona: None, model: Some(&model), tuning: dir.path().join("persona-tuning.toml") };
|
||||
let path = plan(dir.path(), "humans_in_rooms", 2, "");
|
||||
let path = plan(dir.path(), "\"ruled\"", 2, "");
|
||||
let text = std::fs::read_to_string(&path).unwrap().replace("state = \"libby.json\"", "state = \"tobiah.json\"");
|
||||
std::fs::write(&path, text).unwrap();
|
||||
assert!(format!("{:#}", simulate(&harness, &path).unwrap_err()).contains("refused by a put"), "Libby cannot hold Eureka's state");
|
||||
|
|
@ -156,28 +253,3 @@ fn a_cast_past_eight_or_a_foreign_state_is_refused() {
|
|||
std::fs::write(&path, format!("rounds = 1\nstart = \"2026-11-20T15:00:00Z\"\nrooms = [\"#a:x\"]\n{many}")).unwrap();
|
||||
assert!(format!("{:#}", simulate(&harness, &path).unwrap_err()).contains("1 to 8"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wake_reason_is_the_ruled_set_and_the_control_widens_it_to_minds() {
|
||||
let libby = Member { addressee: Addressee::new(LIBBY, ["libby", "Libby"]), entry: CastEntry { id: LIBBY.into(), name: "Libby".into(), state: PathBuf::new(), rooms: vec![], names: vec![] }, state: Value::Null, rooms: vec!["#minds:x".into()] };
|
||||
let cast = vec![TOBIAH.to_owned(), LIBBY.to_owned()];
|
||||
let line = |from: &str, room: &str, says: &str| Line { from: from.into(), name: String::new(), room: room.into(), at_ms: 0, says: says.into(), mentions: vec![], dm: false, follow_up: false, reply_to: None, new: false };
|
||||
let reason = |lines: &[Line], wake: Wake, beat: bool| wake_reason(lines, 0, &libby, &cast, wake, beat).map(|(why, _)| why);
|
||||
let named = [line(TOBIAH, "#minds:x", "Libby, tea?")];
|
||||
let unnamed = [line(TOBIAH, "#minds:x", "what a day")];
|
||||
let human = [line("@deru:x", "#minds:x", "kettle news")];
|
||||
let elsewhere = [line("@deru:x", "#other:x", "kettle news")];
|
||||
assert_eq!(reason(&named, Wake::HumansInRooms, false), Some("addressed by a Mind"));
|
||||
let by_id = [line(TOBIAH, "#minds:x", "ask @libby:gamecult.org about it")];
|
||||
let (why, by) = wake_reason(&by_id, 0, &libby, &cast, Wake::HumansInRooms, false).unwrap();
|
||||
assert_eq!((why, by[0]["how"].as_str()), ("addressed by a Mind", Some("id as text")));
|
||||
assert_eq!(wake_reason(&named, 0, &libby, &cast, Wake::HumansInRooms, false).unwrap().1[0]["how"], "name in text");
|
||||
let both = [line(TOBIAH, "#minds:x", "Libby, tea?"), line("@deru:x", "#minds:x", "Libby, kettle?")];
|
||||
assert_eq!(reason(&both, Wake::HumansInRooms, false), Some("addressed by a human"), "a human's address outranks a Mind's");
|
||||
assert_eq!(reason(&unnamed, Wake::HumansInRooms, false), None, "another Mind's unaddressed line wakes no one");
|
||||
assert_eq!(reason(&unnamed, Wake::AllMessages, false), Some("a message in her rooms"));
|
||||
assert_eq!(reason(&human, Wake::HumansInRooms, false), Some("a human in her rooms"));
|
||||
assert_eq!(reason(&elsewhere, Wake::HumansInRooms, false), None, "not her room");
|
||||
assert_eq!(reason(&unnamed, Wake::HumansInRooms, true), Some("the beat"));
|
||||
assert!(wake_reason(&named, 1, &libby, &cast, Wake::HumansInRooms, false).is_none(), "a line she has seen is not new");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,6 +36,8 @@ const ADDRESSED_RANGE: std::ops::RangeInclusive<usize> = 1024..=64 * 1024;
|
|||
const PART_BYTES_MAX: usize = 32 * 1024;
|
||||
/// The most words a lived stream may be given: a thin moment gets a thin stream, and no budget needs a book.
|
||||
const WORDS_MAX: usize = 2000;
|
||||
/// The most room lines the group state reads: a recent window, not the room's history.
|
||||
const GROUP_LINES_MAX: usize = 40;
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(default, deny_unknown_fields)]
|
||||
|
|
@ -97,6 +99,14 @@ pub struct SelectTuning {
|
|||
pub people_full: usize,
|
||||
/// The room lines a beat shows.
|
||||
pub beat_tail_lines: usize,
|
||||
/// The group-state slot: who has been talking to whom, how long since a human spoke, what is addressed to her or
|
||||
/// open to anyone, and how long the run of Mind lines is (prior art: group state in the prompt is what lets a
|
||||
/// participant judge whether to speak).
|
||||
pub group_state: bool,
|
||||
/// The room lines the group state reads.
|
||||
pub group_lines: usize,
|
||||
/// The group-state slot's bytes.
|
||||
pub group_bytes: usize,
|
||||
pub caps: PoolCaps,
|
||||
}
|
||||
|
||||
|
|
@ -153,6 +163,9 @@ impl Default for SelectTuning {
|
|||
freshness_window: 5,
|
||||
people_full: 2,
|
||||
beat_tail_lines: 6,
|
||||
group_state: true,
|
||||
group_lines: 6,
|
||||
group_bytes: 360,
|
||||
caps: PoolCaps::default(),
|
||||
}
|
||||
}
|
||||
|
|
@ -203,6 +216,8 @@ impl Tuning {
|
|||
("select.identity_bytes", select.identity_bytes),
|
||||
("select.bond_summary_bytes", select.bond_summary_bytes),
|
||||
("select.item_bytes", select.item_bytes),
|
||||
("select.group_lines", select.group_lines),
|
||||
("select.group_bytes", select.group_bytes),
|
||||
("projector.words", self.projector.words),
|
||||
("projector.beat_words", self.projector.beat_words),
|
||||
("persona.words", self.persona.words),
|
||||
|
|
@ -218,13 +233,18 @@ impl Tuning {
|
|||
("select.identity_bytes", select.identity_bytes),
|
||||
("select.bond_summary_bytes", select.bond_summary_bytes),
|
||||
("select.item_bytes", select.item_bytes),
|
||||
("select.group_bytes", select.group_bytes),
|
||||
("projector.guidance", self.projector.guidance.len()),
|
||||
("persona.guidance", self.persona.guidance.len()),
|
||||
] {
|
||||
if bytes > PART_BYTES_MAX {
|
||||
bail!("{name} must be at most {PART_BYTES_MAX} bytes, not {bytes}: the prompt must fit the connector's frame");
|
||||
}
|
||||
}
|
||||
for (name, words) in [("projector.words", self.projector.words), ("projector.beat_words", self.projector.beat_words)] {
|
||||
if select.group_lines > GROUP_LINES_MAX {
|
||||
bail!("select.group_lines must be at most {GROUP_LINES_MAX}, not {}", select.group_lines);
|
||||
}
|
||||
for (name, words) in [("projector.words", self.projector.words), ("projector.beat_words", self.projector.beat_words), ("persona.words", self.persona.words)] {
|
||||
if words > WORDS_MAX {
|
||||
bail!("{name} must be at most {WORDS_MAX}, not {words}");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -161,6 +161,7 @@ mind_body::heartbeat: impl HeartbeatView for FileStore
|
|||
mind_body::heartbeat: impl PersonaId
|
||||
mind_body::heartbeat: impl PersonaId: fn parse (spec : & str) -> Result < Self >
|
||||
mind_body::heartbeat: impl Row < '_ >
|
||||
mind_body::heartbeat: impl Speaker
|
||||
mind_body::heartbeat: impl Store for FileStore
|
||||
mind_body::heartbeat: impl fmt :: Display for Outcome
|
||||
mind_body::heartbeat: impl fmt :: Display for PollTrace
|
||||
|
|
@ -296,7 +297,7 @@ mind_body::projection::tuning: struct Loaded # [derive (Clone , Debug , PartialE
|
|||
mind_body::projection::tuning: struct PersonaTuning # [derive (Clone , Debug , PartialEq , Serialize , Deserialize)] pub-fields[model: String, guidance: String, words: usize]
|
||||
mind_body::projection::tuning: struct PoolCaps # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[memories_about_present: usize, other_memories: usize, needs: usize, incubation: usize, stance: usize, value: usize, said: usize]
|
||||
mind_body::projection::tuning: struct ProjectorTuning # [derive (Clone , Debug , PartialEq , Serialize , Deserialize)] pub-fields[model: String, guidance: String, words: usize, beat_words: usize]
|
||||
mind_body::projection::tuning: struct SelectTuning # [derive (Clone , Debug , PartialEq , Serialize , Deserialize)] pub-fields[temperature: f64, inclusion_score: f64, context_bytes: usize, stimulus_bytes: usize, heard_bytes: usize, addressed_bytes: usize, identity_bytes: usize, bond_summary_bytes: usize, item_bytes: usize, memory_tau_h: f64, freshness_base: f64, freshness_window: usize, people_full: usize, beat_tail_lines: usize, caps: PoolCaps]
|
||||
mind_body::projection::tuning: struct SelectTuning # [derive (Clone , Debug , PartialEq , Serialize , Deserialize)] pub-fields[temperature: f64, inclusion_score: f64, context_bytes: usize, stimulus_bytes: usize, heard_bytes: usize, addressed_bytes: usize, identity_bytes: usize, bond_summary_bytes: usize, item_bytes: usize, memory_tau_h: f64, freshness_base: f64, freshness_window: usize, people_full: usize, beat_tail_lines: usize, group_state: bool, group_lines: usize, group_bytes: usize, caps: PoolCaps]
|
||||
mind_body::projection::tuning: struct Tuning # [derive (Clone , Debug , Default , PartialEq , Serialize , Deserialize)] pub-fields[projector: ProjectorTuning, persona: PersonaTuning, select: SelectTuning, lens: LensWeights]
|
||||
mind_body::queue: fn on_hold (mind : & dyn MindPort) -> Result < Held >
|
||||
mind_body::queue: impl Held
|
||||
|
|
|
|||
Loading…
Reference in a new issue