Return a compact summary to the model from edit_file, write_file, and morph_edit_file instead of the full diff

Author: alexylon

AGENTS.md

@@ -428,7 +428,7 @@ Gitignored scratchpad for helper files the user asks to be created there — typ
 - Do not leave `unwrap()` or `expect()` in normal code paths.
 - Use strong types where possible.
 - Add or update important tests and keep them self-contained.
-- After each important change, but only when we are ready to commit, update if relevant:
+- After each important change, but only when you have finalized the current task, update if relevant:
     - `README.md`
     - `CHANGELOG.md` under `[Unreleased]`. Stick to the standard Keep-a-Changelog categories (`Added`, `Changed`, `Deprecated`, `Removed`, `Fixed`, `Security`) — do NOT add an `Internal` section. Pure refactors, dead-code removals, and test-only additions are not user-notable; leave them out. The changelog is for users, not contributors. Within each entry, describe the user-visible behaviour in plain English: no file paths, no bare `Type::method` shorthand, no Rust attribute syntax, no crate names. CLI flags, env vars, slash commands, and API wire formats are fine because the user encounters them directly.
 - Run:

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to Sofos are documented in this file.
 
 ## [Unreleased]
 
+### Changed
+
+- **File-edit tool results are now fixed-size summaries.** `edit_file`, `write_file` (when it overwrites an existing file), and `morph_edit_file` previously returned the full syntax-highlighted diff to the model as the tool result. The colored diff carried truecolor ANSI escape sequences that roughly multiplied the byte count per line, and the tool result stayed in conversation history for every subsequent turn — so a session with many edits paid that bloated cost again on each later turn, and a single large rewrite could push the response into the hundreds of thousands of tokens. The model now sees a fixed two-line summary (`Success. Updated the following files:` followed by `M <path>`) regardless of edit size, while the terminal still renders the full colored diff exactly as before. If the model needs to verify the post-edit state it can re-read a range of the file.
+
 ## [0.2.11] - 2026-05-16
 
 ### Added

src/repl/response_handler.rs

@@ -393,8 +393,11 @@ impl ResponseHandler {
                         );
                     }
 
-                    let display_output =
-                        UI::create_tool_display_message(tool_name, tool_input, output.text());
+                    let display_output = UI::create_tool_display_message(
+                        tool_name,
+                        tool_input,
+                        output.display_text(),
+                    );
 
                     if !display_output.is_empty() {
                         UI::shared().print_tool_output(&display_output);

src/tools/executor.rs

@@ -39,15 +39,31 @@ const MAX_WEB_FETCH_BODY_BYTES: usize = 64 * 1024 * 1024;
 pub enum ToolExecutionResult {
     /// Simple text result (for most tools)
     Text(String),
+    /// Separate text for the model vs. the on-screen display. The model
+    /// gets a short summary; the user sees the full rendered output
+    /// (e.g. a colored diff). Keeps the tool-result payload small in
+    /// conversation history without losing the visual diff in the TUI.
+    TextWithDisplay { text: String, display: String },
     /// Structured result with optional images (for MCP tools)
     Structured(McpToolResult),
 }
 
 impl ToolExecutionResult {
-    /// Get the text content
+    /// Text shipped back to the model as the tool result.
     pub fn text(&self) -> &str {
         match self {
             ToolExecutionResult::Text(s) => s,
+            ToolExecutionResult::TextWithDisplay { text, .. } => text,
+            ToolExecutionResult::Structured(r) => &r.text,
+        }
+    }
+
+    /// Text rendered to the user in the TUI / session replay. Falls back
+    /// to the model-facing text for tools that don't draw a distinction.
+    pub fn display_text(&self) -> &str {
+        match self {
+            ToolExecutionResult::Text(s) => s,
+            ToolExecutionResult::TextWithDisplay { display, .. } => display,
             ToolExecutionResult::Structured(r) => &r.text,
         }
     }
@@ -56,11 +72,43 @@ impl ToolExecutionResult {
     pub fn images(&self) -> &[ImageData] {
         match self {
             ToolExecutionResult::Text(_) => &[],
+            ToolExecutionResult::TextWithDisplay { .. } => &[],
             ToolExecutionResult::Structured(r) => &r.images,
         }
     }
 }
 
+/// Header line of the model-facing summary every file-modification tool
+/// emits. Mirrors a unified-diff "files changed" preamble: a fixed first
+/// line followed by per-file lines tagged `A` (added), `M` (modified),
+/// or `D` (deleted).
+const FILE_MUTATION_SUMMARY_HEADER: &str = "Success. Updated the following files:";
+
+/// Build a [`ToolExecutionResult`] for a file-modification tool that
+/// wants to keep the user's colored diff while shipping a constant-size
+/// summary to the model. The colored diff carries syntax-highlighting
+/// ANSI that roughly multiplies the byte count per line, and every tool
+/// result stays in conversation history for the rest of the session —
+/// echoing the diff back to the model dominates the cost of repeated
+/// edits. Returning only `M <path>` to the model keeps that cost flat
+/// regardless of edit size; the model can `read_file` a range if it
+/// needs to inspect the post-edit state.
+fn file_modification_result(
+    path: &str,
+    original: &str,
+    modified: &str,
+    success_prefix: &str,
+) -> ToolExecutionResult {
+    let diff_output = diff::generate_compact_diff(original, modified, path);
+    let display_body = format!("{} '{}'\n\nChanges:\n{}", success_prefix, path, diff_output);
+    let display = truncate_for_context(&display_body, MAX_DIFF_TOKENS, TruncationKind::DiffOutput);
+    let summary = format!("{FILE_MUTATION_SUMMARY_HEADER}\nM {path}");
+    ToolExecutionResult::TextWithDisplay {
+        text: summary,
+        display,
+    }
+}
+
 /// ToolExecutor handles execution of tool calls from AI
 #[derive(Clone)]
 pub struct ToolExecutor {
@@ -605,16 +653,12 @@ impl ToolExecutor {
                         path
                     ))
                 } else if let Some(original) = original_content {
-                    let diff_output = diff::generate_compact_diff(&original, content, path);
-                    let body = format!(
-                        "Successfully wrote to file '{}'\n\nChanges:\n{}",
-                        path, diff_output
-                    );
-                    Ok(truncate_for_context(
-                        &body,
-                        MAX_DIFF_TOKENS,
-                        TruncationKind::DiffOutput,
-                    ))
+                    return Ok(file_modification_result(
+                        path,
+                        &original,
+                        content,
+                        "Successfully wrote to file",
+                    ));
                 } else {
                     Ok(format!("Successfully created file '{}'", path))
                 }
@@ -900,16 +944,12 @@ impl ToolExecutor {
                         .write_file_with_outside_access(&resolved.canonical_str, &modified)?;
                 }
 
-                let diff_output = diff::generate_compact_diff(&original, &modified, path);
-                let body = format!(
-                    "Successfully edited '{}'\n\nChanges:\n{}",
-                    path, diff_output
-                );
-                Ok(truncate_for_context(
-                    &body,
-                    MAX_DIFF_TOKENS,
-                    TruncationKind::DiffOutput,
-                ))
+                return Ok(file_modification_result(
+                    path,
+                    &original,
+                    &modified,
+                    "Successfully edited",
+                ));
             }
             ToolName::MorphEditFile => {
                 let morph = self.morph_client.as_ref().ok_or_else(|| {
@@ -1061,18 +1101,12 @@ impl ToolExecutor {
                         .write_file_with_outside_access(&resolved.canonical_str, &merged_code)?;
                 }
 
-                // Generate diff for display
-                let diff_output = diff::generate_compact_diff(&original_code, &merged_code, path);
-
-                let body = format!(
-                    "Successfully applied Morph edit to '{}'\n\nChanges:\n{}",
-                    path, diff_output
-                );
-                Ok(truncate_for_context(
-                    &body,
-                    MAX_DIFF_TOKENS,
-                    TruncationKind::DiffOutput,
-                ))
+                return Ok(file_modification_result(
+                    path,
+                    &original_code,
+                    &merged_code,
+                    "Successfully applied Morph edit to",
+                ));
             }
             ToolName::DeleteFile => {
                 let path = input["path"].as_str().ok_or_else(|| {

src/tools/tests.rs

@@ -406,6 +406,91 @@ async fn test_edit_file_replace_all() {
     assert_eq!(content, "ccc bbb ccc");
 }
 
+#[tokio::test]
+async fn test_edit_file_returns_compact_summary_to_model_and_diff_to_display() {
+    // After a successful edit, the model-facing `text()` is a fixed
+    // two-line summary regardless of edit size, while `display_text()`
+    // still carries the rendered diff for the UI. This keeps repeated
+    // edits from re-billing the diff in conversation history every turn,
+    // and is the contract every file-modification tool routes through
+    // `file_modification_result` to provide.
+    let workspace = tempdir().unwrap();
+    let config_dir = workspace.path().join(".sofos");
+    std::fs::create_dir_all(&config_dir).unwrap();
+    std::fs::write(
+        config_dir.join("config.local.toml"),
+        "[permissions]\nallow = []\ndeny = []\nask = []\n",
+    )
+    .unwrap();
+    std::fs::write(workspace.path().join("greet.txt"), "hello world").unwrap();
+
+    let executor =
+        ToolExecutor::new(workspace.path().to_path_buf(), None, None, false, false).unwrap();
+    let result = executor
+        .execute(
+            "edit_file",
+            &json!({"path": "greet.txt", "old_string": "world", "new_string": "rust"}),
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(
+        result.text(),
+        "Success. Updated the following files:\nM greet.txt",
+        "model should receive only the compact summary"
+    );
+    assert!(
+        result
+            .display_text()
+            .contains("Successfully edited 'greet.txt'"),
+        "display should keep the per-tool success heading"
+    );
+    assert!(
+        result.display_text().contains("Changes:"),
+        "display should keep the diff preamble"
+    );
+    assert!(
+        !result.text().contains('\x1b'),
+        "the summary sent to the model must be free of ANSI escapes"
+    );
+}
+
+#[tokio::test]
+async fn test_write_file_overwrite_returns_compact_summary_to_model() {
+    // Overwriting an existing file with `write_file` is the second tool
+    // that used to echo a colored diff back to the model. The summary
+    // path must mirror `edit_file`'s contract.
+    let workspace = tempdir().unwrap();
+    let config_dir = workspace.path().join(".sofos");
+    std::fs::create_dir_all(&config_dir).unwrap();
+    std::fs::write(
+        config_dir.join("config.local.toml"),
+        "[permissions]\nallow = []\ndeny = []\nask = []\n",
+    )
+    .unwrap();
+    std::fs::write(workspace.path().join("notes.txt"), "old body").unwrap();
+
+    let executor =
+        ToolExecutor::new(workspace.path().to_path_buf(), None, None, false, false).unwrap();
+    let result = executor
+        .execute(
+            "write_file",
+            &json!({"path": "notes.txt", "content": "new body"}),
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(
+        result.text(),
+        "Success. Updated the following files:\nM notes.txt"
+    );
+    assert!(
+        result
+            .display_text()
+            .contains("Successfully wrote to file 'notes.txt'")
+    );
+}
+
 #[tokio::test]
 async fn test_glob_files_finds_matches() {
     let workspace = tempdir().unwrap();