Milestone 3 - Step 2

codetracer-python-recorder/src/session/bootstrap/filesystem.rs: 
codetracer-python-recorder/src/session/bootstrap/filters.rs: 
codetracer-python-recorder/src/session/bootstrap/metadata.rs: 
codetracer-python-recorder/src/session/bootstrap.rs: 
design-docs/codetracer-architecture-refactor-implementation-plan.status.md: 

Signed-off-by: Tzanko Matev <[email protected]>

Author: tzanko-matev

codetracer-python-recorder/src/session/bootstrap.rs

@@ -94,73 +94,9 @@ impl TraceSessionBootstrap {
 mod tests {
     use super::*;
     use metadata::tests::{with_sys_argv, ProgramArgs};
-    use recorder_errors::ErrorCode;
     use std::path::PathBuf;
     use tempfile::tempdir;
 
-    #[test]
-    fn ensure_trace_directory_creates_missing_dir() {
-        let tmp = tempdir().expect("tempdir");
-        let target = tmp.path().join("trace-out");
-        ensure_trace_directory(&target).expect("create directory");
-        assert!(target.is_dir());
-    }
-
-    #[test]
-    fn ensure_trace_directory_rejects_file_path() {
-        let tmp = tempdir().expect("tempdir");
-        let file_path = tmp.path().join("trace.bin");
-        std::fs::write(&file_path, b"stub").expect("write stub file");
-        let err = ensure_trace_directory(&file_path).expect_err("should reject file path");
-        assert_eq!(err.code, ErrorCode::TraceDirectoryConflict);
-    }
-
-    #[test]
-    fn resolve_trace_format_accepts_supported_aliases() {
-        assert!(matches!(
-            resolve_trace_format("json").expect("json format"),
-            TraceEventsFileFormat::Json
-        ));
-        assert!(matches!(
-            resolve_trace_format("BiNaRy").expect("binary alias"),
-            TraceEventsFileFormat::BinaryV0
-        ));
-    }
-
-    #[test]
-    fn resolve_trace_format_rejects_unknown_values() {
-        let err = resolve_trace_format("yaml").expect_err("should reject yaml");
-        assert_eq!(err.code, ErrorCode::UnsupportedFormat);
-        assert!(err.message().contains("unsupported trace format"));
-    }
-
-    #[test]
-    fn collect_program_metadata_reads_sys_argv() {
-        Python::with_gil(|py| {
-            let metadata = with_sys_argv(
-                py,
-                ProgramArgs::new(["/tmp/prog.py", "--flag", "value"]),
-                || collect_program_metadata(py),
-            )
-            .expect("metadata");
-            assert_eq!(metadata.program, "/tmp/prog.py");
-            assert_eq!(
-                metadata.args,
-                vec!["--flag".to_string(), "value".to_string()]
-            );
-        });
-    }
-
-    #[test]
-    fn collect_program_metadata_defaults_unknown_program() {
-        Python::with_gil(|py| {
-            let metadata = with_sys_argv(py, ProgramArgs::empty(), || collect_program_metadata(py))
-                .expect("metadata");
-            assert_eq!(metadata.program, "<unknown>");
-            assert!(metadata.args.is_empty());
-        });
-    }
-
     #[test]
     fn prepare_bootstrap_populates_fields_and_creates_directory() {
         Python::with_gil(|py| {

codetracer-python-recorder/src/session/bootstrap/filesystem.rs

@@ -78,3 +78,44 @@ pub fn current_directory() -> Result<PathBuf> {
             .with_context("io", err.to_string())
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn creates_missing_directory() {
+        let tmp = tempdir().expect("tempdir");
+        let target = tmp.path().join("trace-out");
+        ensure_trace_directory(&target).expect("create directory");
+        assert!(target.is_dir());
+    }
+
+    #[test]
+    fn rejects_existing_file_target() {
+        let tmp = tempdir().expect("tempdir");
+        let file_path = tmp.path().join("trace.bin");
+        std::fs::write(&file_path, b"stub").expect("write stub file");
+        let err = ensure_trace_directory(&file_path).expect_err("should reject file path");
+        assert_eq!(err.code, ErrorCode::TraceDirectoryConflict);
+    }
+
+    #[test]
+    fn resolves_supported_formats() {
+        assert!(matches!(
+            resolve_trace_format("json").expect("json format"),
+            TraceEventsFileFormat::Json
+        ));
+        assert!(matches!(
+            resolve_trace_format("binary").expect("binary format"),
+            TraceEventsFileFormat::BinaryV0
+        ));
+    }
+
+    #[test]
+    fn rejects_unknown_format() {
+        let err = resolve_trace_format("yaml").expect_err("should reject yaml");
+        assert_eq!(err.code, ErrorCode::UnsupportedFormat);
+    }
+}

codetracer-python-recorder/src/session/bootstrap/filters.rs

@@ -51,7 +51,7 @@ fn discover_default_trace_filter(program: &str) -> Result<Option<PathBuf>> {
 pub mod tests {
     use super::*;
     use std::fs;
-    use std::path::Path;
+    use std::path::{Path, PathBuf};
     use tempfile::tempdir;
 
     pub fn write_default_filter(root: &Path) -> PathBuf {
@@ -121,4 +121,44 @@ pub mod tests {
             discover_default_trace_filter(script.to_str().expect("utf8")).expect("discover");
         assert!(found.is_some());
     }
+
+    #[test]
+    fn load_trace_filter_includes_builtin() {
+        let temp = tempdir().expect("tempdir");
+        let root = temp.path();
+        let script = write_app(root);
+
+        let engine = load_trace_filter(None, script.to_str().expect("utf8"))
+            .expect("load")
+            .expect("engine");
+        let summary = engine.summary();
+        assert!(summary
+            .entries
+            .iter()
+            .any(|entry| entry.path == PathBuf::from("<inline:builtin-default>")));
+    }
+
+    #[test]
+    fn load_trace_filter_merges_default_and_override() {
+        let temp = tempdir().expect("tempdir");
+        let root = temp.path();
+        let script = write_app(root);
+        let (default_filter_path, override_filter_path) = write_default_and_override(root);
+
+        let engine = load_trace_filter(
+            Some(&[override_filter_path.clone()]),
+            script.to_str().expect("utf8"),
+        )
+        .expect("load")
+        .expect("engine");
+        let paths: Vec<PathBuf> = engine
+            .summary()
+            .entries
+            .iter()
+            .map(|entry| entry.path.clone())
+            .collect();
+        assert!(paths.contains(&PathBuf::from("<inline:builtin-default>")));
+        assert!(paths.contains(&default_filter_path));
+        assert!(paths.contains(&override_filter_path));
+    }
 }

codetracer-python-recorder/src/session/bootstrap/metadata.rs

@@ -80,4 +80,31 @@ pub mod tests {
             .expect("restore argv");
         result
     }
+
+    #[test]
+    fn collects_program_and_args() {
+        Python::with_gil(|py| {
+            let metadata = with_sys_argv(
+                py,
+                ProgramArgs::new(["/tmp/prog.py", "--flag", "value"]),
+                || collect_program_metadata(py),
+            )
+            .expect("metadata");
+            assert_eq!(metadata.program, "/tmp/prog.py");
+            assert_eq!(
+                metadata.args,
+                vec!["--flag".to_string(), "value".to_string()]
+            );
+        });
+    }
+
+    #[test]
+    fn defaults_to_unknown_program() {
+        Python::with_gil(|py| {
+            let metadata = with_sys_argv(py, ProgramArgs::empty(), || collect_program_metadata(py))
+                .expect("metadata");
+            assert_eq!(metadata.program, "<unknown>");
+            assert!(metadata.args.is_empty());
+        });
+    }
 }

design-docs/codetracer-architecture-refactor-implementation-plan.status.md

@@ -52,12 +52,7 @@
   - `logger.rs` owns the log installation, filter parsing, policy application, and error-code scoping; it exposes helpers (`with_error_code`, `log_recorder_error`, `set_active_trace_id`) for the rest of the crate.
   - `metrics.rs` encapsulates the `RecorderMetrics` trait, sink installation, and testing harness; `trailer.rs` manages JSON error toggles and payload emission via the logger's context snapshot.
   - Updated facade tests (`structured_log_records`, `json_error_trailers_emit_payload`, metrics capture) to rely on the new modules; `just test` verifies Rust + Python suites after the split.
-- 🔄 Milestone 3 Kickoff: revisiting `session/bootstrap.rs` to catalogue filesystem, metadata, and filter responsibilities ahead of submodule extraction.
-  - Filesystem prep: `ensure_trace_directory`, `resolve_trace_format`, directory walkers (`discover_default_trace_filter`, `resolve_program_directory`, `current_directory`).
-  - Metadata capture: `ProgramMetadata` struct, `collect_program_metadata`.
-  - Filter loading: constants (`TRACE_FILTER_*`, builtin include), `load_trace_filter`, `discover_default_trace_filter`, explicit override merge logic.
-  - `TraceSessionBootstrap::prepare` orchestrates all helpers and owns the struct fields; tests cover directory creation, format validation, metadata fallbacks, filter discovery/merging.
-- ✅ Milestone 3 Step 1: established `session/bootstrap/{filesystem,metadata,filters}.rs`, re-exported `ProgramMetadata`, and migrated helper functions/tests without changing the facade API. `just test` validates the split scaffold.
+- ✅ Milestone 3 complete: `session/bootstrap` delegates to `filesystem`, `metadata`, and `filters` submodules, each with focused unit tests covering success and failure paths (e.g., unwritable directory, unsupported formats, missing filters). `TraceSessionBootstrap` now orchestrates these modules without additional helper functions, and `just test` (Rust + Python) confirms parity.
 
 ### Planned Extraction Order (Milestone 2)
 1. **Policy model split:** Move data structures (`OnRecorderError`, `IoCapturePolicy`, `RecorderPolicy`, `PolicyUpdate`, `PolicyPath`) and policy cell helpers (`policy_cell`, `policy_snapshot`, `apply_policy_update`) into `policy::model`. Expose minimal APIs for environment/FFI modules.
@@ -74,5 +69,5 @@
 5. **Tests:** After each move, update unit tests in `trace_filter` modules and dependent integration tests (`session/bootstrap.rs` tests, `runtime` tests). Targeted command: `just test` (covers Rust + Python suites).
 
 ## Next Actions
-1. Continue Milestone 3 by tightening module responsibilities: move remaining filesystem/metadata/filter helpers into their submodules (e.g., `TraceSessionBootstrap::prepare` orchestration steps).
-2. Add focused unit tests within the new modules for error scenarios (unwritable directory, unsupported format, missing default filter) before rerunning `just test`.
+1. Proceed to Milestone 4: begin the monitoring plumbing cleanup per the implementation roadmap.
+2. Watch for integration regressions in CLI/session flows now that bootstrap responsibilities are modularised; add follow-up tasks if any arise.