fix(git): preserve import history, file identity, and diff fidelity

atomic-cli/src/commands/agent/hooks.rs

@@ -239,11 +239,30 @@ impl Command for Hooks {
                     }
                 }
             }
-            None => find_repository_root().map_err(|e| {
-                // Log to stderr — the agent should continue even if Atomic can't find a repo
-                eprintln!("[atomic] Warning: {}", e);
-                e
-            })?,
+            None => match find_repository_root() {
+                Ok(root) => root,
+                Err(error @ CliError::RepositoryNotFound { .. }) => {
+                    // Same state as the hints path: the hook ran outside an
+                    // Atomic repository (or the repository disappeared since
+                    // the caller's probe). Nothing to record — exit quietly
+                    // instead of failing the hook (and, through the agent
+                    // bridge plugins' strict tool propagation, the tool call).
+                    log::warn!(
+                        "hooks: no Atomic repository for {} {}: {}",
+                        self.agent_name,
+                        self.verb,
+                        error
+                    );
+                    if let Some(response) = agent.stdout_response(hook_type) {
+                        println!("{}", response);
+                    }
+                    return Ok(());
+                }
+                // Only the genuine not-an-Atomic-repository state is quiet.
+                // Any other discovery failure (I/O and friends) stays fatal:
+                // swallowing it would hide real breakage behind exit 0.
+                Err(error) => return Err(error),
+            },
         };
 
         // Hooks are never suppressed under a managed run: sessions adopt its

atomic-cli/src/commands/diff/helpers.rs

@@ -1070,6 +1070,31 @@ where
             _ => FileDiff::modified(file_path),
         };
 
+        // A whole-file rewrite's tombstones carry identities, not old text.
+        // Render its textual delta using recorded before-content, even when
+        // context is disabled or only statistics were requested.
+        if let Some((before_content, after_content)) =
+            atomic_repository::diff_engine::whole_file_replacement_text(
+                ops,
+                &change.contents,
+                || before(file_path),
+            )
+        {
+            let result = diff_text(&before_content, &after_content, Algorithm::Myers);
+            let old_lines: Vec<_> = before_content.split(|&b| b == b'\n').collect();
+            let new_lines: Vec<_> = after_content.split(|&b| b == b'\n').collect();
+            for mut hunk in
+                build_hunks_from_diff(&result, &old_lines, &new_lines, config.context_lines)
+            {
+                hunk.lines = Diff::repair_diff_lines(hunk.lines);
+                file_diff.add_hunk(hunk);
+            }
+            file_diff.compute_stats();
+            stats.add_file(file_diff.stats.clone());
+            file_diffs.push(file_diff);
+            continue;
+        }
+
         // Pass 1: flatten line operations into numbered changed lines.
         let mut insertions = 0usize;
         let mut deletions = 0usize;

atomic-cli/src/commands/git/import.rs

@@ -873,6 +873,8 @@ impl Command for Import {
             let branches = self.get_all_branches(&git_repo)?;
 
             let mut total_imported = 0;
+            let checked_out_branch = current_git_branch(&git_repo);
+            let mut checked_out_verification = None;
             for branch_name in branches {
                 let preserve_branch_working_copy =
                     preserve_current_view && original_view != branch_name;
@@ -882,6 +884,13 @@ impl Command for Import {
                             "missing prevalidated import plan for '{branch_name}'"
                         ))
                     })?;
+                if checked_out_branch.as_deref() == Some(branch_name.as_str()) {
+                    if let (Some(expected), Some(raw)) =
+                        (plan.expected_git_tree(), plan.raw_git_tree())
+                    {
+                        checked_out_verification = Some((branch_name.clone(), expected, raw));
+                    }
+                }
 
                 // Ensure the view exists
                 if !repo
@@ -948,8 +957,17 @@ impl Command for Import {
                 print_info(
                     "Working copy materialization deferred to the explicit command boundary (metadata-only reactive budget).",
                 );
+            } else if let Some(checked_out) = current_git_branch(&git_repo) {
+                // Importing every branch must finish on the checked-out branch,
+                // not whichever ref happened to sort last. Its complete target
+                // tree has passed the same preflight and publication checks as
+                // single-branch import, so adopt Git's existing materialization.
+                repo.align_to_view(working_copy, &checked_out)
+                    .map_err(|e| CliError::Internal(e.into()))?;
+                print_info("Using Git working copy as imported materialization.");
+                reindex_working_copy(&repo, working_copy);
             } else {
-                // Materialize the working copy from the graph
+                // Detached imports have no checked-out branch to adopt.
                 print_info("Materializing working copy...");
                 match repo.materialize(working_copy) {
                     Ok(result) => {
@@ -986,6 +1004,22 @@ impl Command for Import {
                 "Imported {} total changes across all branches",
                 total_imported
             ));
+            if !self.skip_checkpoint_refresh {
+                if let Some((view, expected, raw)) = checked_out_verification {
+                    // Use the same canonical tree proof as single-branch import.
+                    // The generic native-status fallback interprets escaped Git
+                    // names as disk names and is not an import equivalence proof.
+                    super::bridge::refresh_checkpoint_after_verified_import(
+                        &repo,
+                        working_copy,
+                        &git_repo,
+                        &view,
+                        &expected,
+                        &raw,
+                    )?;
+                    checkpoint_refreshed = true;
+                }
+            }
         } else {
             // Import single branch
             let branch_name = self.branch.clone().unwrap_or(default_branch);
@@ -1250,15 +1284,16 @@ fn reindex_working_copy(repo: &Repository, working_copy: WorkingCopyId) {
     let mut entries: Vec<(String, i64, u32, u64, Hash)> = Vec::new();
 
     for file in &tracked {
-        let abs = repo_root.join(&file.path);
+        let path = file.path.to_string_lossy();
+        let abs = repo_root.join(super::parallel::canonical_tree_path(&path));
         if let Ok(metadata) = std::fs::metadata(&abs) {
             let mtime = metadata.modified().unwrap_or(SystemTime::UNIX_EPOCH);
             let duration = mtime
                 .duration_since(SystemTime::UNIX_EPOCH)
                 .unwrap_or_default();
             if let Ok(bytes) = std::fs::read(&abs) {
                 entries.push((
-                    file.path.to_string_lossy().replace('\\', "/"),
+                    path.into_owned(),
                     duration.as_secs() as i64,
                     duration.subsec_nanos(),
                     metadata.len(),