fix(tests): make CI deterministic — hermetic fixtures + serial test run --patch

The remaining CI reds were environment/parallelism issues invisible on a local
macOS run:

- import_config: the test set the process-global HOME to point build_import_preview
  at a fixture. That doesn't redirect dirs::home_dir() on Windows (Known-Folder
  API) AND raced with every parallel test reading the home dir. Added an
  injected-paths variant (build_import_preview_with_paths) so the test stages a
  fixture with zero env mutation — works on all platforms.
- stats fixtures: wrote each JSONL line via the async write_transcript_entry,
  then read back synchronously — a write/read visibility gap dropped trailing
  lines on the loaded Linux runner (flaking turn counts / last-prompt). Now
  written in one synchronous std::fs::write.
- ci.yml: run tests with --test-threads=1. Several tests across the suite mutate
  global env (HOME, ANTHROPIC_API_KEY, …); serial execution removes the parallel
  races deterministically.

Verified: cargo test --workspace --no-fail-fast -- --test-threads=1 → 30/30
binaries green (incl doctests); release build clean, 0 warnings. Ships as a
patch to v0.1.6.

Author: Kuberwastaken

.github/workflows/ci.yml

@@ -58,7 +58,10 @@ jobs:
 
       - name: Run tests
         working-directory: src-rust
-        run: cargo test --workspace --locked
+        # Run serially: a number of tests mutate process-global state (env vars
+        # like HOME / ANTHROPIC_API_KEY, etc.) and would otherwise race under
+        # parallel execution, flaking non-deterministically across runners.
+        run: cargo test --workspace --locked -- --test-threads=1
 
       # Advisory for now: the codebase has pre-existing clippy warnings and
       # rustfmt drift. Flip continue-on-error off once they are cleaned up.

src-rust/crates/commands/src/stats.rs

@@ -1216,8 +1216,7 @@ pub fn run(raw: &[&str], ctx: &CommandContext) -> CommandResult {
 mod tests {
     use super::*;
     use claurst_core::session_storage::{
-        write_transcript_entry, AiTitleEntry, CustomTitleEntry, LastPromptEntry,
-        TranscriptMessage,
+        AiTitleEntry, CustomTitleEntry, LastPromptEntry, TranscriptMessage,
     };
     use claurst_core::types::{Message, MessageContent, MessageCost, Role};
     use tempfile::TempDir;
@@ -1292,9 +1291,19 @@ mod tests {
         entries: Vec<TranscriptEntry>,
     ) -> PathBuf {
         let path = dir.join(format!("{session_id}.jsonl"));
-        for e in entries {
-            write_transcript_entry(&path, &e).await.unwrap();
+        // Write the whole fixture synchronously in one shot. The reader
+        // (`aggregate_from_dir` / `parse_jsonl_sync`) uses blocking `std::fs`,
+        // so writing each line via the async `write_transcript_entry`
+        // (open/append/close per entry on the blocking pool) left a
+        // write-then-read visibility gap that dropped trailing lines on the
+        // loaded Linux CI runner — non-deterministically failing the turn count
+        // and last-prompt assertions. A single sync write removes that race.
+        let mut buf = String::new();
+        for e in &entries {
+            buf.push_str(&serde_json::to_string(e).unwrap());
+            buf.push('\n');
         }
+        std::fs::write(&path, buf).unwrap();
         path
     }
 

src-rust/crates/core/src/import_config.rs

@@ -124,6 +124,18 @@ pub fn build_import_preview(selection: ImportSelection) -> Result<ImportPreview>
     Ok(prepare_import(selection)?.preview)
 }
 
+/// Like [`build_import_preview`] but against an explicit [`ImportPaths`] instead
+/// of the detected home directory. Lets tests stage a fixture without mutating
+/// the process-global `HOME` env var (which races with every other test that
+/// reads the home directory in parallel).
+#[cfg(test)]
+pub(crate) fn build_import_preview_with_paths(
+    selection: ImportSelection,
+    paths: ImportPaths,
+) -> Result<ImportPreview> {
+    Ok(prepare_import_with_paths(selection, paths)?.preview)
+}
+
 pub fn execute_import(selection: ImportSelection) -> Result<ImportExecutionResult> {
     let prepared = prepare_import(selection)?;
     let paths = ImportPaths::detect();
@@ -193,7 +205,13 @@ pub fn summarize_import_result(result: &ImportExecutionResult, paths: &ImportPat
 }
 
 fn prepare_import(selection: ImportSelection) -> Result<PreparedImport> {
-    let paths = ImportPaths::detect();
+    prepare_import_with_paths(selection, ImportPaths::detect())
+}
+
+fn prepare_import_with_paths(
+    selection: ImportSelection,
+    paths: ImportPaths,
+) -> Result<PreparedImport> {
     let mut preview = ImportPreview {
         selection,
         claude_md: None,
@@ -857,10 +875,13 @@ mod tests {
 
     #[test]
     fn build_import_preview_maps_settings_and_doc() {
+        // Stage the fixture against an explicit ImportPaths instead of mutating
+        // the process-global HOME env var. The old approach set_var("HOME"),
+        // which (a) doesn't redirect dirs::home_dir() on Windows and (b) raced
+        // with every other test reading the home dir in parallel.
         let tmp = TempDir::new().unwrap();
-        let home = tmp.path();
-        let claude_dir = home.join(".claude");
-        let claurst_dir = home.join(".claurst");
+        let claude_dir = tmp.path().join(".claude");
+        let claurst_dir = tmp.path().join(".claurst");
         std::fs::create_dir_all(&claude_dir).unwrap();
         std::fs::create_dir_all(&claurst_dir).unwrap();
         std::fs::write(claude_dir.join("CLAUDE.md"), "hello\nworld").unwrap();
@@ -883,22 +904,20 @@ mod tests {
         )
         .unwrap();
 
-        let old_home = std::env::var("HOME").ok();
-        std::env::set_var("HOME", home);
+        let paths = ImportPaths {
+            source_claude_md: claude_dir.join("CLAUDE.md"),
+            source_settings_json: claude_dir.join("settings.json"),
+            target_claude_md: claurst_dir.join("CLAUDE.md"),
+            target_settings_json: claurst_dir.join("settings.json"),
+        };
 
-        let preview = build_import_preview(ImportSelection::Both).unwrap();
+        let preview = build_import_preview_with_paths(ImportSelection::Both, paths).unwrap();
         assert!(preview.claude_md.is_some());
         let settings = preview.settings.unwrap();
         assert!(settings.fields.iter().any(|f| f.name == "model" && f.action == PreviewAction::Skip));
         assert!(settings.fields.iter().any(|f| f.name == "theme"));
         assert!(settings.fields.iter().any(|f| f.name.starts_with("hooks")));
         assert!(settings.fields.iter().any(|f| f.name.starts_with("mcpServers")));
         assert!(settings.fields.iter().any(|f| f.name == "env" && f.action == PreviewAction::Skip));
-
-        if let Some(old) = old_home {
-            std::env::set_var("HOME", old);
-        } else {
-            std::env::remove_var("HOME");
-        }
     }
 }