M5c-1 plan: task 02, loopd logs the speaker and sends the turn's number

loopd copies the Turn's speaker onto the User record it logs, as it came (not checked, not neutralised), and never into a request; after a finished turn it sends SessionUpdated with the turn's number, the count of User records in the session's log (Session::turns), so the first turn is 1, a failed turn that was logged counts, and the count goes on after a reopen or a restart. Failed turns are still not told. Given: speaker_turn.rs (8 tests) and new versions of loopd's memory.rs, turn_broker.rs, end_to_end.rs and support/turn.rs (run_turn gains speaker, MemorySource::updated gains turn). Task 01 now copies memory.rs-task01, its own version. Checks: the reference passes make gate with 1138 tests (1130 + 8); the task replayed from its text on a fresh ref-01 worktree with its own target is byte-identical to the reference and passes the gate; /tmp unchanged around both gate runs; 15 one-line mutations (speaker not logged or dropped by the channel or neutralised, speaker in the request at log time or at replay, turn 0-based or +1, counting Assistant records, all records or only speakers' turns, a global or per-process counter, told before logging or on failure, MemoryPort sending 0) all caught; speaker_turn run 60 times under load, no failure; no chat-template tag in the plan or given files; task lines within 100 characters but tables. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-09-27 23:49:35 -07:00
parent 82b7898e84
commit 0a59dc0b22
8 changed files with 1398 additions and 3 deletions
@@ -0,0 +1,97 @@
+//! A turn-loop setup shared by the `turn` and `limits` tests: a home, a fake server, a scripted
+//! port and a registry. Included with `#[path]` because it needs `loopd::turn`, which the earlier
+//! tasks' tests must not depend on. Do not edit.
+
+#![allow(dead_code)]
+
+use crate::support::{FakeServer, Home, ScriptedPort};
+use bxcore::{LogRecord, SessionId, ToolResponse, TurnEvent};
+use loopd::baseline::Baseline;
+use loopd::llama::Client;
+use loopd::session::Session;
+use loopd::tools::Registry;
+use loopd::turn::{Runtime, TurnError, run_turn};
+
+pub struct Setup {
+    pub home: Home,
+    pub server: FakeServer,
+    pub cfg: loopd::config::Config,
+    pub client: Client,
+    pub port: ScriptedPort,
+    pub registry: Registry,
+}
+
+pub fn setup(replies: Vec<ToolResponse>) -> Setup {
+    let home = Home::new();
+    let server = FakeServer::start();
+    let cfg = home.config(&server.socket);
+    let client = Client::new(cfg.clone());
+    Setup {
+        home,
+        server,
+        cfg,
+        client,
+        port: ScriptedPort::new(replies),
+        registry: Registry::m2b(),
+    }
+}
+
+impl Setup {
+    pub fn session(&self, id: &str) -> Session {
+        let baseline = Baseline::assemble(&self.cfg, &self.registry).unwrap();
+        Session::create(
+            &self.home.dir,
+            SessionId::new(id).unwrap(),
+            baseline,
+            self.cfg.slots.main,
+        )
+        .unwrap()
+    }
+
+    pub fn runtime(&self) -> Runtime<'_> {
+        Runtime {
+            cfg: &self.cfg,
+            client: &self.client,
+            port: &self.port,
+            registry: &self.registry,
+        }
+    }
+
+    pub fn turn(
+        &self,
+        session: &mut Session,
+        text: &str,
+    ) -> (Result<loopd::turn::TurnOutcome, TurnError>, Vec<TurnEvent>) {
+        let mut events = Vec::new();
+        let result = run_turn(session, &self.runtime(), text, None, &mut |e| {
+            events.push(e.clone())
+        });
+        (result, events)
+    }
+}
+
+/// The recordings were made in separate conversations, so their timings do not line up and the
+/// loop rightly reports cache losses between them. Most tests are not about that, so `types`
+/// and `records` leave `CacheLoss` out; one test checks it on purpose.
+pub fn without_cache_loss(records: &[LogRecord]) -> Vec<LogRecord> {
+    records
+        .iter()
+        .filter(|r| !matches!(r, LogRecord::CacheLoss { .. }))
+        .cloned()
+        .collect()
+}
+
+pub fn types(records: &[LogRecord]) -> Vec<&'static str> {
+    without_cache_loss(records)
+        .iter()
+        .map(|r| match r {
+            LogRecord::SessionStart { .. } => "start",
+            LogRecord::User { .. } => "user",
+            LogRecord::Assistant { .. } => "assistant",
+            LogRecord::Usage { .. } => "usage",
+            LogRecord::ToolResult { .. } => "tool_result",
+            LogRecord::CacheLoss { .. } => "cache_loss",
+            LogRecord::EpochEnd { .. } => "epoch_end",
+        })
+        .collect()
+}