feat: config ghost commits (#7873)

codex-rs/core/src/tasks/ghost_snapshot.rs

@@ -73,30 +73,43 @@ impl SessionTask for GhostSnapshotTask {
                 _ = cancellation_token.cancelled() => true,
                 _ = async {
                     let repo_path = ctx_for_task.cwd.clone();
+                    let ghost_snapshot = ctx_for_task.ghost_snapshot.clone();
+                    let ignore_large_untracked_dirs = ghost_snapshot.ignore_large_untracked_dirs;
                     // First, compute a snapshot report so we can warn about
                     // large untracked directories before running the heavier
                     // snapshot logic.
                     if let Ok(Ok(report)) = tokio::task::spawn_blocking({
                         let repo_path = repo_path.clone();
+                        let ghost_snapshot = ghost_snapshot.clone();
                         move || {
-                            let options = CreateGhostCommitOptions::new(&repo_path);
+                            let options =
+                                CreateGhostCommitOptions::new(&repo_path).ghost_snapshot(ghost_snapshot);
                             capture_ghost_snapshot_report(&options)
                         }
                     })
                     .await
-                        && let Some(message) = format_large_untracked_warning(&report) {
-                                session
-                                    .session
-                                    .send_event(
-                                        &ctx_for_task,
-                                        EventMsg::Warning(WarningEvent { message }),
-                                    )
-                                    .await;
-                            }
+                    {
+                        for message in
+                            format_snapshot_warnings(
+                                ghost_snapshot.ignore_large_untracked_files,
+                                ignore_large_untracked_dirs,
+                                &report,
+                            )
+                        {
+                            session
+                                .session
+                                .send_event(
+                                    &ctx_for_task,
+                                    EventMsg::Warning(WarningEvent { message }),
+                                )
+                                .await;
+                        }
+                    }
 
                     // Required to run in a dedicated blocking pool.
                     match tokio::task::spawn_blocking(move || {
-                        let options = CreateGhostCommitOptions::new(&repo_path);
+                        let options =
+                            CreateGhostCommitOptions::new(&repo_path).ghost_snapshot(ghost_snapshot);
                         create_ghost_commit(&options)
                     })
                     .await
@@ -161,10 +174,31 @@ impl GhostSnapshotTask {
     }
 }
 
-fn format_large_untracked_warning(report: &GhostSnapshotReport) -> Option<String> {
+fn format_snapshot_warnings(
+    ignore_large_untracked_files: Option<i64>,
+    ignore_large_untracked_dirs: Option<i64>,
+    report: &GhostSnapshotReport,
+) -> Vec<String> {
+    let mut warnings = Vec::new();
+    if let Some(message) = format_large_untracked_warning(ignore_large_untracked_dirs, report) {
+        warnings.push(message);
+    }
+    if let Some(message) =
+        format_ignored_untracked_files_warning(ignore_large_untracked_files, report)
+    {
+        warnings.push(message);
+    }
+    warnings
+}
+
+fn format_large_untracked_warning(
+    ignore_large_untracked_dirs: Option<i64>,
+    report: &GhostSnapshotReport,
+) -> Option<String> {
     if report.large_untracked_dirs.is_empty() {
         return None;
     }
+    let threshold = ignore_large_untracked_dirs?;
     const MAX_DIRS: usize = 3;
     let mut parts: Vec<String> = Vec::new();
     for dir in report.large_untracked_dirs.iter().take(MAX_DIRS) {
@@ -175,7 +209,85 @@ fn format_large_untracked_warning(report: &GhostSnapshotReport) -> Option<String
         parts.push(format!("{remaining} more"));
     }
     Some(format!(
-        "Repository snapshot encountered large untracked directories: {}. This can slow Codex; consider adding these paths to .gitignore or disabling undo in your config.",
+        "Repository snapshot ignored large untracked directories (>= {threshold} files): {}. These directories are excluded from snapshots and undo cleanup. Adjust `ghost_snapshot.ignore_large_untracked_dirs` to change this behavior.",
         parts.join(", ")
     ))
 }
+
+fn format_ignored_untracked_files_warning(
+    ignore_large_untracked_files: Option<i64>,
+    report: &GhostSnapshotReport,
+) -> Option<String> {
+    let threshold = ignore_large_untracked_files?;
+    if report.ignored_untracked_files.is_empty() {
+        return None;
+    }
+
+    const MAX_FILES: usize = 3;
+    let mut parts: Vec<String> = Vec::new();
+    for file in report.ignored_untracked_files.iter().take(MAX_FILES) {
+        parts.push(format!(
+            "{} ({})",
+            file.path.display(),
+            format_bytes(file.byte_size)
+        ));
+    }
+    if report.ignored_untracked_files.len() > MAX_FILES {
+        let remaining = report.ignored_untracked_files.len() - MAX_FILES;
+        parts.push(format!("{remaining} more"));
+    }
+
+    Some(format!(
+        "Repository snapshot ignored untracked files larger than {}: {}. These files are preserved during undo cleanup, but their contents are not captured in the snapshot. Adjust `ghost_snapshot.ignore_large_untracked_files` to change this behavior. To avoid this message in the future, update your `.gitignore`.",
+        format_bytes(threshold),
+        parts.join(", ")
+    ))
+}
+
+fn format_bytes(bytes: i64) -> String {
+    const KIB: i64 = 1024;
+    const MIB: i64 = 1024 * 1024;
+
+    if bytes >= MIB {
+        return format!("{} MiB", bytes / MIB);
+    }
+    if bytes >= KIB {
+        return format!("{} KiB", bytes / KIB);
+    }
+    format!("{bytes} B")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use codex_git::LargeUntrackedDir;
+    use pretty_assertions::assert_eq;
+    use std::path::PathBuf;
+
+    #[test]
+    fn large_untracked_warning_includes_threshold() {
+        let report = GhostSnapshotReport {
+            large_untracked_dirs: vec![LargeUntrackedDir {
+                path: PathBuf::from("models"),
+                file_count: 250,
+            }],
+            ignored_untracked_files: Vec::new(),
+        };
+
+        let message = format_large_untracked_warning(Some(200), &report).unwrap();
+        assert!(message.contains(">= 200 files"));
+    }
+
+    #[test]
+    fn large_untracked_warning_disabled_when_threshold_disabled() {
+        let report = GhostSnapshotReport {
+            large_untracked_dirs: vec![LargeUntrackedDir {
+                path: PathBuf::from("models"),
+                file_count: 250,
+            }],
+            ignored_untracked_files: Vec::new(),
+        };
+
+        assert_eq!(format_large_untracked_warning(None, &report), None);
+    }
+}

codex-rs/core/src/tasks/undo.rs

@@ -8,7 +8,8 @@ use crate::state::TaskKind;
 use crate::tasks::SessionTask;
 use crate::tasks::SessionTaskContext;
 use async_trait::async_trait;
-use codex_git::restore_ghost_commit;
+use codex_git::RestoreGhostCommitOptions;
+use codex_git::restore_ghost_commit_with_options;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::user_input::UserInput;
 use tokio_util::sync::CancellationToken;
@@ -85,9 +86,12 @@ impl SessionTask for UndoTask {
 
         let commit_id = ghost_commit.id().to_string();
         let repo_path = ctx.cwd.clone();
-        let restore_result =
-            tokio::task::spawn_blocking(move || restore_ghost_commit(&repo_path, &ghost_commit))
-                .await;
+        let ghost_snapshot = ctx.ghost_snapshot.clone();
+        let restore_result = tokio::task::spawn_blocking(move || {
+            let options = RestoreGhostCommitOptions::new(&repo_path).ghost_snapshot(ghost_snapshot);
+            restore_ghost_commit_with_options(&options, &ghost_commit)
+        })
+        .await;
 
         match restore_result {
             Ok(Ok(())) => {