Method try_squash_insert

atomic-cli/src/commands/git/parallel.rs:2765–2861

Attempt to represent an atomic-origin squash commit by inserting its original change records into the target view instead of writing a new squash change (SPEC §4). Verifies that the insert reproduces the git tree for the touched paths; on divergence or missing originals it rolls back and skips the commit (SPEC §5, decision D1-A).

(
        &self,
        repo: &mut Repository,
        parsed: &ParsedCommit,
    )

    /// tree for the touched paths; on divergence or missing originals it rolls
    /// back and skips the commit (SPEC §5, decision D1-A).
    fn try_squash_insert(
        &self,
        repo: &mut Repository,
        parsed: &ParsedCommit,
    ) -> CliResult<SquashDecision> {
        use atomic_repository::InsertOptions;

        // Merges are handled by the normal path + the phase-3 merge tag.
        if parsed.is_merge {
            return Ok(SquashDecision::NotSquash);
        }

        // Must carry Atomic-Changes trailers to be an atomic-origin squash.
        let message = parsed.full_message();
        let original_hashes = match parse_atomic_changes_trailer(&message) {
            Some(h) => h,
            None => return Ok(SquashDecision::NotSquash),
        };
        let pr_number = parse_pr_number(&message);

        // Resolve every original to a Hash and confirm it exists locally. A
        // missing original means we cannot reconstruct the aggregate — skip and
        // advise `atomic pull` rather than fabricate a squash change (SPEC §5).
        let mut parsed_hashes: Vec<ContentHash> = Vec::with_capacity(original_hashes.len());
        for h in &original_hashes {
            match ContentHash::from_base32(h.as_bytes()) {
                Some(hash) if repo.has_change(&hash) => parsed_hashes.push(hash),
                _ => {
                    print_warning(&format!(
                        "Squash {} references change {} which is not present locally; \
                         skipping (run `atomic pull` to fetch it, then re-import).",
                        parsed.short_sha, h
                    ));
                    return Ok(SquashDecision::Skipped);
                }
            }
        }

        let target = self.options.target_view.clone();

        // Insert the originals (with dependency closure) into the target view.
        // Track exactly which changes we newly added, for rollback on divergence.
        let mut newly_applied: Vec<ContentHash> = Vec::new();
        for hash in &parsed_hashes {
            let options = InsertOptions::default()
                .view(target.clone())
                .apply_deps(true);
            match repo.insert_change_rec(hash, options) {
                Ok(outcome) => {
                    newly_applied.extend(outcome.stats.applied_hashes.iter().copied());
                }
                Err(e) => {
                    print_warning(&format!(
                        "Squash {}: failed to insert original {}: {}; skipping.",
                        parsed.short_sha,
                        &hash.to_base32()[..12],
                        e
                    ));