Method phase2_write

atomic-cli/src/commands/git/parallel.rs:2642–2758

Phase 2: Write changes sequentially with hash chaining.

(
        &self,
        repo: &mut Repository,
        commits: &[ParsedCommit],
        line_index: &mut ImportLineIndex,
    )

    /// Phase 2: Write changes sequentially with hash chaining.
    fn phase2_write(
        &self,
        repo: &mut Repository,
        commits: &[ParsedCommit],
        line_index: &mut ImportLineIndex,
    ) -> CliResult<(WriteStats, Vec<ImportedCommitInfo>)> {
        let mut stats = WriteStats::default();
        let mut imported_commits = Vec::new();
        let total = commits.len();
        let phase2_start = Instant::now();
        let mut batch_start = Instant::now();

        for (idx, parsed) in commits.iter().enumerate() {
            // Commits created by `atomic git push` whose referenced view
            // state is already present add nothing — skip them entirely.
            if should_skip_self_push(parsed, &self.options) {
                stats.self_push_skipped += 1;
                continue;
            }

            // Squash → insert (SPEC §4): an atomic-origin squash-merge is
            // represented by inserting its original change records into the
            // target view, not by writing a new squash change. Only attempted
            // on incremental imports (the git-shadow-sync workflow), where the
            // originals already exist in the graph.
            if self.options.incremental {
                match self.try_squash_insert(repo, parsed)? {
                    SquashDecision::Inserted(info) => {
                        stats.squash_inserted += 1;
                        stats.files_processed += parsed.files.len();
                        imported_commits.push(info);
                        continue;
                    }
                    SquashDecision::Skipped => {
                        stats.squash_skipped += 1;
                        continue;
                    }
                    SquashDecision::NotSquash => {}
                }
            }

            // Progress reporting with per-batch timing
            if total > 100 && idx % 100 == 0 {
                if idx == 0 {
                    print_info(&format!("  Writing {}/{}...", idx, total));
                } else {
                    let batch_elapsed = batch_start.elapsed();
                    let total_elapsed = phase2_start.elapsed();
                    let avg_per_commit = total_elapsed.as_secs_f64() / idx as f64;
                    print_info(&format!(
                        "  Writing {}/{}... (last 100: {:.2}s, avg: {:.1}ms/commit)",
                        idx,
                        total,
                        batch_elapsed.as_secs_f64(),
                        avg_per_commit * 1000.0,
                    ));
                }
                batch_start = Instant::now();