Add the baseline and the log replay function

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)

crates/loopd/tests/support/mod.rs

@@ -58,6 +58,90 @@ retry_window_ms = 5000
     loopd::config::Config::parse(&text).unwrap()
 }
 
+/// A temporary `BOXMAKER_HOME` with a `system.md` beside a `config.toml`, for session tests.
+pub struct Home {
+    pub dir: PathBuf,
+}
+
+impl Home {
+    pub fn new() -> Home {
+        let n = NEXT.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("loopd-home-{}-{n}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("system.md"), "You are Boxmaker, a test agent.\n").unwrap();
+        Home { dir }
+    }
+
+    /// A config for `socket` whose home, system prompt and channel socket are all under this
+    /// directory, with the fast test limits.
+    pub fn config(&self, socket: &Path) -> loopd::config::Config {
+        let mut cfg = test_config(socket);
+        cfg.paths.home = self.dir.clone();
+        cfg.baseline.system = self.dir.join("system.md");
+        cfg.channel.socket = self.dir.join("loop.sock");
+        cfg
+    }
+
+    pub fn write(&self, relative: &str, text: &str) {
+        let path = self.dir.join(relative);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(path, text).unwrap();
+    }
+
+    pub fn read(&self, relative: &str) -> String {
+        std::fs::read_to_string(self.dir.join(relative)).unwrap()
+    }
+
+    /// The records of a session's log, epoch 0.
+    pub fn records(&self, session: &str) -> Vec<proto::LogRecord> {
+        let text = self.read(&format!("sessions/{session}/0.jsonl"));
+        text.lines()
+            .map(|l| serde_json::from_str(l).unwrap())
+            .collect()
+    }
+}
+
+/// A tool port that answers from a script and records what it was asked.
+pub struct ScriptedPort {
+    replies: Mutex<VecDeque<proto::ToolResponse>>,
+    calls: Mutex<Vec<proto::ToolRequest>>,
+}
+
+impl ScriptedPort {
+    /// Replies are given in order; when they run out, every call gets `fallback`.
+    pub fn new(replies: Vec<proto::ToolResponse>) -> ScriptedPort {
+        ScriptedPort {
+            replies: Mutex::new(replies.into()),
+            calls: Mutex::new(Vec::new()),
+        }
+    }
+
+    pub fn calls(&self) -> Vec<proto::ToolRequest> {
+        self.calls.lock().unwrap().clone()
+    }
+}
+
+pub fn ok_result(content: &str) -> proto::ToolResponse {
+    proto::ToolResponse::Result {
+        content: content.to_string(),
+        class: proto::DataClass::Private,
+        untrusted: true,
+        truncated: false,
+    }
+}
+
+impl loopd::tools::ToolPort for ScriptedPort {
+    fn call(&self, request: &proto::ToolRequest) -> proto::ToolResponse {
+        self.calls.lock().unwrap().push(request.clone());
+        self.replies
+            .lock()
+            .unwrap()
+            .pop_front()
+            .unwrap_or_else(|| ok_result("scripted"))
+    }
+}
+
 /// What an independent script derived from a recorded stream: `tests/fixtures/expected/`.
 pub fn expected(name: &str) -> serde_json::Value {
     serde_json::from_slice(&fixture_bytes("expected", &format!("{name}.json"))).unwrap()