feat(s5): pluggable message stores and logs (Stage S5)

Tasks T053–T058, T060, T061 (US7).

truefix-store:
- async MessageStore trait (seqnums + sent-message persistence for resend) +
  StoreConfig/build_store factory.
- MemoryStore, FileStore, CachedFileStore, NoopStore. FileStore replays an
  append log on open and tolerates a torn trailing record (recovers the good
  prefix, flags was_corrupted) — supports ForceResendWhenCorruptedStore (T060).
- SQL store via sqlx/SQLite behind the `sql` feature (T057); compiles and its
  restart test passes under `--features sql`. Off by default to keep the core
  build light and license-clean.

truefix-log:
- Log trait with message/event stream separation (FR-H2) + LogConfig/build_log.
- ScreenLog, FileLog (separate messages.log/event.log), TracingLog, CompositeLog
  (fan-out).

Integration (T061):
- Session::seed_sequences restores persisted seqnums.
- Transport gains opt-in Services (store + log): seeds seqnums on connect,
  persists them each event, logs inbound/outbound; existing entry points unchanged.

Tests: 7 store tests (+1 SQL under feature), 3 log tests, a transport
restart-continuity test, and a session seed test. 86 workspace tests green;
fmt/clippy -D warnings clean.

Deferred (unchecked): T059 SQL log — the sync Log trait vs async sqlx needs an
async logging path / background writer; planned refinement. Cross-restart resend
of message *bytes* (restoring them into the engine) is also future work; S5 wires
sequence-number continuity.

Author: zhangjiayin

.codely-cli/auto-saves/chat-auto-save-2026-06-29-21-57-19-495-explore-aw1hj8.json

@@ -36,6 +36,8 @@ truefix-dict = { path = "crates/truefix-dict" }
 truefix-session = { path = "crates/truefix-session" }
 truefix-transport = { path = "crates/truefix-transport" }
 truefix-config = { path = "crates/truefix-config" }
+truefix-store = { path = "crates/truefix-store" }
+truefix-log = { path = "crates/truefix-log" }
 
 [profile.release]
 # Production builds: keep debug info off, optimize. Benchmarks live in benches/.

.codely-cli/auto-saves/chat-auto-save-2026-06-29-22-05-17-296-explore-ca404u.json

@@ -8,5 +8,9 @@ repository.workspace = true
 description = "FIX logging (screen/file/tracing/composite)."
 publish = false
 
+[dependencies]
+thiserror.workspace = true
+tracing.workspace = true
+
 [lints]
 workspace = true

.codely-cli/auto-saves/chat-auto-save-2026-06-29-22-06-09-791-explore-ae89ae.json

@@ -0,0 +1,33 @@
+//! Fan-out log.
+
+use crate::Log;
+
+/// Fans every entry out to each wrapped log.
+pub struct CompositeLog {
+    logs: Vec<Box<dyn Log>>,
+}
+
+impl CompositeLog {
+    /// Create a composite over `logs`.
+    pub fn new(logs: Vec<Box<dyn Log>>) -> Self {
+        Self { logs }
+    }
+}
+
+impl Log for CompositeLog {
+    fn on_incoming(&self, message: &str) {
+        for log in &self.logs {
+            log.on_incoming(message);
+        }
+    }
+    fn on_outgoing(&self, message: &str) {
+        for log in &self.logs {
+            log.on_outgoing(message);
+        }
+    }
+    fn on_event(&self, text: &str) {
+        for log in &self.logs {
+            log.on_event(text);
+        }
+    }
+}

.codely-cli/auto-saves/chat-auto-save-2026-06-29-22-06-35-561-explore-4snuru.json

@@ -0,0 +1,53 @@
+//! File log: separate `messages.log` and `event.log` streams (FR-H2).
+
+use std::fs::{File, OpenOptions};
+use std::io::Write;
+use std::path::Path;
+use std::sync::Mutex;
+
+use crate::{Log, LogError};
+
+/// Logs inbound/outbound messages to `messages.log` and events to `event.log`.
+pub struct FileLog {
+    messages: Mutex<File>,
+    events: Mutex<File>,
+}
+
+impl FileLog {
+    /// Open (creating if needed) the log files in `dir`.
+    pub fn open(dir: &Path) -> Result<Self, LogError> {
+        std::fs::create_dir_all(dir).map_err(|e| LogError::Io(e.to_string()))?;
+        let messages = open_append(&dir.join("messages.log"))?;
+        let events = open_append(&dir.join("event.log"))?;
+        Ok(Self {
+            messages: Mutex::new(messages),
+            events: Mutex::new(events),
+        })
+    }
+}
+
+fn open_append(path: &Path) -> Result<File, LogError> {
+    OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+        .map_err(|e| LogError::Io(e.to_string()))
+}
+
+fn write_line(file: &Mutex<File>, line: &str) {
+    if let Ok(mut f) = file.lock() {
+        let _ = writeln!(f, "{line}");
+    }
+}
+
+impl Log for FileLog {
+    fn on_incoming(&self, message: &str) {
+        write_line(&self.messages, &format!("I {message}"));
+    }
+    fn on_outgoing(&self, message: &str) {
+        write_line(&self.messages, &format!("O {message}"));
+    }
+    fn on_event(&self, text: &str) {
+        write_line(&self.events, text);
+    }
+}

Cargo.lock

@@ -1,7 +1,10 @@
-//! FIX logging (screen/file/tracing/composite).
+//! `truefix-log` — pluggable FIX logging with message/event stream separation (FR-H2).
 //!
-//! Part of the TrueFix FIX engine. Design: `specs/001-fix-engine-parity/`.
-//! This crate is scaffolding (Stage S0); functionality lands in later stages.
+//! The [`Log`] trait separates **message** logging (inbound/outbound wire messages) from
+//! **event** logging (session lifecycle, errors). Implementations: [`ScreenLog`], [`FileLog`],
+//! [`TracingLog`], and [`CompositeLog`] (fan-out).
+//!
+//! Design: `specs/001-fix-engine-parity/`.
 #![cfg_attr(
     not(test),
     deny(
@@ -11,3 +14,70 @@
         clippy::indexing_slicing
     )
 )]
+
+mod composite;
+mod file;
+mod screen;
+mod tracing_log;
+
+use std::path::PathBuf;
+
+use thiserror::Error;
+
+pub use composite::CompositeLog;
+pub use file::FileLog;
+pub use screen::ScreenLog;
+pub use tracing_log::TracingLog;
+
+/// An error constructing a log.
+#[derive(Debug, Error)]
+pub enum LogError {
+    /// An I/O error (e.g. opening a log file).
+    #[error("log I/O error: {0}")]
+    Io(String),
+}
+
+/// A FIX log sink. Message logging (incoming/outgoing) is kept separate from event logging.
+///
+/// Methods are best-effort and infallible from the caller's perspective; a sink that cannot
+/// write drops the entry rather than failing the session.
+pub trait Log: Send + Sync {
+    /// Log an inbound wire message.
+    fn on_incoming(&self, message: &str);
+    /// Log an outbound wire message.
+    fn on_outgoing(&self, message: &str);
+    /// Log a session event.
+    fn on_event(&self, text: &str);
+}
+
+/// Which log backend to construct.
+#[derive(Debug, Clone)]
+pub enum LogConfig {
+    /// Log to stdout/stderr.
+    Screen,
+    /// Log to files in a directory (`messages.log` + `event.log`).
+    File {
+        /// Directory holding the log files.
+        dir: PathBuf,
+    },
+    /// Log via the `tracing` facade.
+    Tracing,
+    /// Fan out to several logs.
+    Composite(Vec<LogConfig>),
+}
+
+/// Build a boxed [`Log`] from a [`LogConfig`].
+pub fn build_log(config: &LogConfig) -> Result<Box<dyn Log>, LogError> {
+    Ok(match config {
+        LogConfig::Screen => Box::new(ScreenLog::new()),
+        LogConfig::File { dir } => Box::new(FileLog::open(dir)?),
+        LogConfig::Tracing => Box::new(TracingLog::new()),
+        LogConfig::Composite(parts) => {
+            let mut logs: Vec<Box<dyn Log>> = Vec::with_capacity(parts.len());
+            for part in parts {
+                logs.push(build_log(part)?);
+            }
+            Box::new(CompositeLog::new(logs))
+        }
+    })
+}