Method save_loop_checkpoint

core/src/store/file_store.rs:419–466

(&self, run_id: &str, checkpoint: &LoopCheckpoint)

    }

    async fn save_loop_checkpoint(&self, run_id: &str, checkpoint: &LoopCheckpoint) -> Result<()> {
        let path = self.loop_checkpoint_path(run_id);
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent).await.with_context(|| {
                format!(
                    "Failed to create loop checkpoint directory: {}",
                    parent.display()
                )
            })?;
        }
        let json = serde_json::to_string_pretty(checkpoint)
            .with_context(|| format!("Failed to serialize loop checkpoint for run {run_id}"))?;

        // Crash-atomic write: a checkpoint exists precisely to survive a
        // process crash, so the write itself must be crash-safe. A plain
        // `fs::write` can leave a truncated JSON file if the process dies
        // mid-write — which `resume_run` would then fail to parse,
        // defeating the whole point. Write to a unique temp file, fsync,
        // then atomically rename over the target.
        let unique_suffix = format!(
            "{}.{}",
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .map(|d| d.as_nanos())
                .unwrap_or(0),
            std::process::id()
        );
        let temp_path = path.with_extension(format!("json.{}.tmp", unique_suffix));
        let mut file = fs::File::create(&temp_path).await.with_context(|| {
            format!(
                "Failed to create checkpoint temp file: {}",
                temp_path.display()
            )
        })?;
        file.write_all(json.as_bytes())
            .await
            .with_context(|| format!("Failed to write loop checkpoint for run {run_id}"))?;
        file.sync_all()
            .await
            .with_context(|| format!("Failed to fsync loop checkpoint for run {run_id}"))?;
        fs::rename(&temp_path, &path).await.with_context(|| {
            format!(
                "Failed to rename loop checkpoint into place: {}",
                path.display()
            )
        })?;
        Ok(())
    }

    async fn load_loop_checkpoint(&self, run_id: &str) -> Result<Option<LoopCheckpoint>> {
        let path = self.loop_checkpoint_path(run_id);