From e2b76132ba3e5377d0d7523da6ef5c6c4afe02ef Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 10:32:51 +0800
Subject: [PATCH 01/16] =?UTF-8?q?=E8=B0=83=E6=95=B4folder=E9=A1=B6?=
 =?UTF-8?q?=E9=83=A8=E7=9A=84=E7=BB=88=E7=AB=AF=E6=8C=89=E9=92=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/components/layout/folder-title-bar.tsx | 32 +++++++++++-----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/components/layout/folder-title-bar.tsx b/src/components/layout/folder-title-bar.tsx
index aa75138..858fa10 100644
--- a/src/components/layout/folder-title-bar.tsx
+++ b/src/components/layout/folder-title-bar.tsx
@@ -11,11 +11,11 @@ import {
   Columns2,
   FileCode2,
   MessageSquare,
-  PanelBottom,
   PanelLeft,
   PanelRight,
   Search,
   Settings,
+  SquareTerminal,
 } from "lucide-react"
 import { useTranslations } from "next-intl"
 import { getGitBranch, openFolderWindow, openSettingsWindow } from "@/lib/api"
@@ -340,21 +340,6 @@ export function FolderTitleBar() {
               >
                 <PanelLeft className="h-3.5 w-3.5" />
               </Button>
-              <Button
-                variant="ghost"
-                size="icon"
-                className={`h-6 w-6 hover:text-foreground/80 ${terminalOpen ? "bg-accent" : ""}`}
-                onClick={() => toggleTerminal()}
-                title={tTitleBar("withShortcut", {
-                  label: tTitleBar("toggleTerminal"),
-                  shortcut: formatShortcutLabel(
-                    shortcuts.toggle_terminal,
-                    isMac
-                  ),
-                })}
-              >
-                <PanelBottom className="h-3.5 w-3.5" />
-              </Button>
               <Button
                 variant="ghost"
                 size="icon"
@@ -370,6 +355,21 @@ export function FolderTitleBar() {
               >
                 <PanelRight className="h-3.5 w-3.5" />
               </Button>
+              <Button
+                variant="ghost"
+                size="icon"
+                className={`h-6 w-6 hover:text-foreground/80 ${terminalOpen ? "bg-accent" : ""}`}
+                onClick={() => toggleTerminal()}
+                title={tTitleBar("withShortcut", {
+                  label: tTitleBar("toggleTerminal"),
+                  shortcut: formatShortcutLabel(
+                    shortcuts.toggle_terminal,
+                    isMac
+                  ),
+                })}
+              >
+                <SquareTerminal className="h-3.5 w-3.5" />
+              </Button>
               <Button
                 variant="ghost"
                 size="icon"

From 33186b2c030afbb3f3d5a661035fdb336394ef08 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 10:39:23 +0800
Subject: [PATCH 02/16] =?UTF-8?q?Welcome=E9=A1=B5=E9=9D=A2=E6=94=AF?=
 =?UTF-8?q?=E6=8C=81=E5=BF=AB=E6=8D=B7=E9=94=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/components/welcome/welcome-screen.tsx | 34 +++++++++++++++++------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/components/welcome/welcome-screen.tsx b/src/components/welcome/welcome-screen.tsx
index 0949382..bf9ed23 100644
--- a/src/components/welcome/welcome-screen.tsx
+++ b/src/components/welcome/welcome-screen.tsx
@@ -5,6 +5,8 @@ import { Settings } from "lucide-react"
 import { useTranslations } from "next-intl"
 import { toast } from "sonner"
 import { loadFolderHistory, openSettingsWindow } from "@/lib/api"
+import { matchShortcutEvent } from "@/lib/keyboard-shortcuts"
+import { useShortcutSettings } from "@/hooks/use-shortcut-settings"
 import type { FolderHistoryEntry } from "@/lib/types"
 import { FolderList } from "@/components/welcome/folder-list"
 import { FolderActions } from "@/components/welcome/folder-actions"
@@ -18,6 +20,28 @@ export function WelcomeScreen() {
   const t = useTranslations("WelcomePage")
   const [history, setHistory] = useState<FolderHistoryEntry[]>([])
   const [loading, setLoading] = useState(true)
+  const { shortcuts } = useShortcutSettings()
+
+  const handleOpenSettings = useCallback(() => {
+    openSettingsWindow().catch((err) => {
+      console.error("[WelcomeScreen] failed to open settings:", err)
+      const resolvedError = resolveWelcomeError(err)
+      toast.error(t("toasts.openSettingsFailed"), {
+        description: resolvedError.detail ?? t(resolvedError.key),
+      })
+    })
+  }, [t])
+
+  useEffect(() => {
+    function handleKeyDown(e: KeyboardEvent) {
+      if (matchShortcutEvent(e, shortcuts.open_settings)) {
+        e.preventDefault()
+        handleOpenSettings()
+      }
+    }
+    document.addEventListener("keydown", handleKeyDown)
+    return () => document.removeEventListener("keydown", handleKeyDown)
+  }, [shortcuts, handleOpenSettings])
 
   const refreshHistory = useCallback(async () => {
     try {
@@ -49,15 +73,7 @@ export function WelcomeScreen() {
             variant="ghost"
             size="icon"
             className="h-6 w-6 hover:text-foreground/80"
-            onClick={() => {
-              openSettingsWindow().catch((err) => {
-                console.error("[WelcomeScreen] failed to open settings:", err)
-                const resolvedError = resolveWelcomeError(err)
-                toast.error(t("toasts.openSettingsFailed"), {
-                  description: resolvedError.detail ?? t(resolvedError.key),
-                })
-              })
-            }}
+            onClick={handleOpenSettings}
             title={t("openSettings")}
             aria-label={t("openSettings")}
             type="button"

From beb6ae02267e56b2c600d5c49fd5f4acdfb1cdeb Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 10:57:07 +0800
Subject: [PATCH 03/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=BC=9A=E8=AF=9D?=
 =?UTF-8?q?=E9=A1=B5=E9=9D=A2=E6=BB=9A=E5=8A=A8=E5=88=B0=E5=BA=95=E9=83=A8?=
 =?UTF-8?q?=E7=9A=84=E6=8C=89=E9=92=AE=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/components/ai-elements/message-thread.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/ai-elements/message-thread.tsx b/src/components/ai-elements/message-thread.tsx
index c4611da..9ab6c71 100644
--- a/src/components/ai-elements/message-thread.tsx
+++ b/src/components/ai-elements/message-thread.tsx
@@ -91,7 +91,7 @@ export const MessageThreadScrollButton = ({
     !isAtBottom && (
       <Button
         className={cn(
-          "absolute bottom-4 left-[50%] translate-x-[-50%] rounded-full dark:bg-background dark:hover:bg-muted",
+          "absolute bottom-4 left-[50%] translate-x-[-50%] rounded-full bg-background/90 hover:bg-muted/90",
           className
         )}
         onClick={handleScrollToBottom}

From 8bd19738d02853bfa87c5ed9d06d4674885705de Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 14:04:19 +0800
Subject: [PATCH 04/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=B6=88=E6=81=AF?=
 =?UTF-8?q?=E9=87=8C=E8=AF=BB/=E5=86=99=E5=86=85=E5=AE=B9=E6=98=BE?=
 =?UTF-8?q?=E7=A4=BA=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/claude.rs               | 126 ++++++
 src-tauri/src/parsers/codex.rs                |   1 +
 src-tauri/src/parsers/gemini.rs               |   1 +
 src-tauri/src/parsers/mod.rs                  | 113 +++++-
 src-tauri/src/parsers/openclaw.rs             |   9 +-
 src-tauri/src/parsers/opencode.rs             |   1 +
 src/components/ai-elements/tool.tsx           |   6 +-
 src/components/diff/unified-diff-preview.tsx  | 265 +++---------
 src/components/files/file-workspace-panel.tsx |   3 +-
 .../message/content-parts-renderer.tsx        | 384 +++++++-----------
 src/i18n/messages/ar.json                     |   1 +
 src/i18n/messages/de.json                     |   1 +
 src/i18n/messages/en.json                     |   1 +
 src/i18n/messages/es.json                     |   1 +
 src/i18n/messages/fr.json                     |   1 +
 src/i18n/messages/ja.json                     |   1 +
 src/i18n/messages/ko.json                     |   1 +
 src/i18n/messages/pt.json                     |   1 +
 src/i18n/messages/zh-CN.json                  |   1 +
 src/i18n/messages/zh-TW.json                  |   1 +
 src/lib/session-files.ts                      |  23 +-
 src/lib/unified-diff-generator.ts             | 180 ++++++++
 22 files changed, 660 insertions(+), 462 deletions(-)
 create mode 100644 src/lib/unified-diff-generator.ts

diff --git a/src-tauri/src/parsers/claude.rs b/src-tauri/src/parsers/claude.rs
index 34df1ab..2061311 100644
--- a/src-tauri/src/parsers/claude.rs
+++ b/src-tauri/src/parsers/claude.rs
@@ -574,6 +574,131 @@ impl ClaudeParser {
                         }
                     }
                 }
+                "tool_use" => {
+                    // Top-level tool_use record (Claude Code JSONL format)
+                    let timestamp = parse_timestamp(&value).unwrap_or_else(Utc::now);
+                    let tool_name = value
+                        .get("tool_name")
+                        .and_then(|n| n.as_str())
+                        .unwrap_or("unknown")
+                        .to_string();
+                    let input_preview = value.get("tool_input").map(|i| i.to_string());
+                    let synthetic_id = format!("tl-tool-{}", messages.len());
+
+                    // Attach to last assistant message, or create a synthetic one
+                    if let Some(last) = messages
+                        .iter_mut()
+                        .rev()
+                        .find(|m| matches!(m.role, MessageRole::Assistant))
+                    {
+                        last.content.push(ContentBlock::ToolUse {
+                            tool_use_id: Some(synthetic_id),
+                            tool_name,
+                            input_preview,
+                        });
+                    } else {
+                        messages.push(UnifiedMessage {
+                            id: format!("synth-assistant-{}", messages.len()),
+                            role: MessageRole::Assistant,
+                            content: vec![ContentBlock::ToolUse {
+                                tool_use_id: Some(synthetic_id),
+                                tool_name,
+                                input_preview,
+                            }],
+                            timestamp,
+                            usage: None,
+                            duration_ms: None,
+                            model: None,
+                        });
+                    }
+                }
+                "tool_result" => {
+                    // Top-level tool_result record (Claude Code JSONL format)
+                    let tool_output = value.get("tool_output");
+                    let tool_name = value
+                        .get("tool_name")
+                        .and_then(|n| n.as_str())
+                        .unwrap_or("");
+                    let is_error = tool_output
+                        .and_then(|o| o.get("exit"))
+                        .and_then(|e| e.as_i64())
+                        .is_some_and(|code| code != 0);
+
+                    // Extract output text: prefer "preview" (read), then "output" (bash)
+                    let output_text = tool_output
+                        .and_then(|o| {
+                            o.get("preview")
+                                .or_else(|| o.get("output"))
+                                .and_then(|v| v.as_str())
+                        })
+                        .map(|s| s.to_string());
+
+                    // For read tools, structurize with start_line from tool_input.offset
+                    let output_preview =
+                        if tool_name == "read" || tool_name == "Read" {
+                            let start_line = value
+                                .get("tool_input")
+                                .and_then(|i| i.get("offset"))
+                                .and_then(|o| o.as_u64())
+                                .map(|o| o + 1)
+                                .unwrap_or(1);
+                            output_text.map(|text| {
+                                serde_json::json!({
+                                    "start_line": start_line,
+                                    "content": text
+                                })
+                                .to_string()
+                            })
+                        } else {
+                            output_text
+                        };
+
+                    // Find matching ToolUse in the last assistant message and use its ID
+                    let matching_id = messages
+                        .iter()
+                        .rev()
+                        .find(|m| matches!(m.role, MessageRole::Assistant))
+                        .and_then(|m| {
+                            m.content.iter().rev().find_map(|b| {
+                                if let ContentBlock::ToolUse {
+                                    tool_use_id: Some(ref id),
+                                    ..
+                                } = b
+                                {
+                                    Some(id.clone())
+                                } else {
+                                    None
+                                }
+                            })
+                        });
+
+                    // Append ToolResult to the same assistant message so they stay in the same turn
+                    if let Some(last) = messages
+                        .iter_mut()
+                        .rev()
+                        .find(|m| matches!(m.role, MessageRole::Assistant))
+                    {
+                        last.content.push(ContentBlock::ToolResult {
+                            tool_use_id: matching_id,
+                            output_preview,
+                            is_error,
+                        });
+                    } else {
+                        messages.push(UnifiedMessage {
+                            id: format!("synth-result-{}", messages.len()),
+                            role: MessageRole::Assistant,
+                            content: vec![ContentBlock::ToolResult {
+                                tool_use_id: matching_id,
+                                output_preview,
+                                is_error,
+                            }],
+                            timestamp: parse_timestamp(&value).unwrap_or_else(Utc::now),
+                            usage: None,
+                            duration_ms: None,
+                            model: None,
+                        });
+                    }
+                }
                 _ => {}
             }
         }
@@ -583,6 +708,7 @@ impl ClaudeParser {
 
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
+        super::structurize_read_tool_output(&mut turns);
         let context_window_used_tokens = latest_claude_context_window_used_tokens(&turns);
         let context_window_max_tokens =
             claude_context_window_max_tokens_for_model(model.as_deref());
diff --git a/src-tauri/src/parsers/codex.rs b/src-tauri/src/parsers/codex.rs
index 50c6cda..a71ba9d 100644
--- a/src-tauri/src/parsers/codex.rs
+++ b/src-tauri/src/parsers/codex.rs
@@ -773,6 +773,7 @@ impl CodexParser {
 
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
+        super::structurize_read_tool_output(&mut turns);
         let mut session_stats = super::compute_session_stats(&turns);
         session_stats =
             merge_codex_total_usage_stats(session_stats, latest_total_usage, latest_total_tokens);
diff --git a/src-tauri/src/parsers/gemini.rs b/src-tauri/src/parsers/gemini.rs
index 399f37c..9e69a87 100644
--- a/src-tauri/src/parsers/gemini.rs
+++ b/src-tauri/src/parsers/gemini.rs
@@ -556,6 +556,7 @@ impl GeminiParser {
 
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
+        super::structurize_read_tool_output(&mut turns);
         summary.message_count = turns.len() as u32;
         summary.id = conversation_id.to_string();
         let context_window_used_tokens = super::latest_turn_total_usage_tokens(&turns);
diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index bb16962..56f3377 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -4,7 +4,7 @@ pub mod gemini;
 pub mod openclaw;
 pub mod opencode;
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::OnceLock;
 
 use regex::Regex;
@@ -292,6 +292,117 @@ pub fn relocate_orphaned_tool_results(turns: &mut Vec<MessageTurn>) {
     turns.retain(|turn| !turn.blocks.is_empty());
 }
 
+/// Convert Read tool output from numbered-line format to `{"start_line":N,"content":"..."}`.
+///
+/// Claude Code embeds line numbers in Read output like `   115→content`.
+/// This splits on the `→` delimiter (or tab for older `cat -n` format),
+/// extracts the starting line number, and returns clean content.
+pub fn structurize_read_tool_output(turns: &mut [MessageTurn]) {
+    let mut read_tool_ids: HashSet<String> = HashSet::new();
+    for turn in turns.iter() {
+        for block in &turn.blocks {
+            if let ContentBlock::ToolUse {
+                tool_use_id: Some(ref id),
+                ref tool_name,
+                ..
+            } = block
+            {
+                let name = tool_name.to_lowercase();
+                if matches!(
+                    name.as_str(),
+                    "read" | "read_file" | "readfile" | "read file" | "cat" | "view"
+                ) {
+                    read_tool_ids.insert(id.clone());
+                }
+            }
+        }
+    }
+
+    for turn in turns.iter_mut() {
+        for block in turn.blocks.iter_mut() {
+            let is_read_result = matches!(
+                block,
+                ContentBlock::ToolResult { tool_use_id: Some(ref id), .. }
+                if read_tool_ids.contains(id)
+            );
+            if !is_read_result {
+                continue;
+            }
+            if let ContentBlock::ToolResult {
+                ref mut output_preview,
+                ..
+            } = block
+            {
+                if let Some(ref text) = output_preview {
+                    if let Some(json) = strip_numbered_lines(text) {
+                        *output_preview = Some(json);
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Known delimiters between line number and content.
+const LINE_NUM_DELIMITERS: &[&str] = &["→", "\t"];
+
+/// Try to split a line at a known delimiter, returning (line_number, content).
+fn split_line_number(line: &str) -> Option<(u64, &str)> {
+    for delim in LINE_NUM_DELIMITERS {
+        if let Some(pos) = line.find(delim) {
+            let prefix = line[..pos].trim();
+            if let Ok(num) = prefix.parse::<u64>() {
+                let content_start = pos + delim.len();
+                return Some((num, &line[content_start..]));
+            }
+        }
+    }
+    None
+}
+
+/// If most lines have a recognized line-number prefix, strip them all
+/// and return `{"start_line":N,"content":"clean text"}`.
+fn strip_numbered_lines(text: &str) -> Option<String> {
+    let raw_lines: Vec<&str> = text.lines().collect();
+    if raw_lines.len() < 2 {
+        return None;
+    }
+
+    let matched = raw_lines
+        .iter()
+        .filter(|l| l.is_empty() || split_line_number(l).is_some())
+        .count();
+    if matched < raw_lines.len() * 4 / 5 {
+        return None;
+    }
+
+    let mut start_line: u64 = 1;
+    let mut first = true;
+    let stripped: Vec<&str> = raw_lines
+        .iter()
+        .map(|line| {
+            if let Some((num, content)) = split_line_number(line) {
+                if first {
+                    start_line = num;
+                    first = false;
+                }
+                content
+            } else {
+                first = false;
+                *line
+            }
+        })
+        .collect();
+
+    Some(
+        serde_json::json!({
+            "start_line": start_line,
+            "content": stripped.join("\n")
+        })
+        .to_string(),
+    )
+}
+
 /// Extract the last path component as the folder name.
 pub fn folder_name_from_path(path: &str) -> String {
     path.rsplit(['/', '\\']).next().unwrap_or(path).to_string()
diff --git a/src-tauri/src/parsers/openclaw.rs b/src-tauri/src/parsers/openclaw.rs
index 1fcc8df..aaf2876 100644
--- a/src-tauri/src/parsers/openclaw.rs
+++ b/src-tauri/src/parsers/openclaw.rs
@@ -652,6 +652,7 @@ impl OpenClawParser {
         let folder_name = folder_path.as_ref().map(|p| folder_name_from_path(p));
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
+        super::structurize_read_tool_output(&mut turns);
 
         let context_window_used_tokens = latest_turn_total_usage_tokens(&turns);
         let context_window_max_tokens = session_meta
@@ -983,9 +984,15 @@ fn extract_assistant_content(value: &serde_json::Value) -> Vec<ContentBlock> {
                         .and_then(|n| n.as_str())
                         .unwrap_or("unknown")
                         .to_string();
+                    let is_edit_tool = matches!(
+                        tool_name.to_lowercase().as_str(),
+                        "edit" | "write" | "apply_patch" | "patch" | "applypatch"
+                            | "edit_file" | "editfile"
+                    );
+                    let max_len = if is_edit_tool { 50000 } else { 500 };
                     let input_preview = item.get("arguments").map(|a| {
                         let s = a.to_string();
-                        truncate_str(&s, 500)
+                        truncate_str(&s, max_len)
                     });
                     blocks.push(ContentBlock::ToolUse {
                         tool_use_id,
diff --git a/src-tauri/src/parsers/opencode.rs b/src-tauri/src/parsers/opencode.rs
index af2f526..df799b4 100644
--- a/src-tauri/src/parsers/opencode.rs
+++ b/src-tauri/src/parsers/opencode.rs
@@ -189,6 +189,7 @@ impl OpenCodeParser {
         let messages = self.load_sqlite_messages(&conn, conversation_id).await?;
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
+        super::structurize_read_tool_output(&mut turns);
         let context_window_used_tokens = super::latest_turn_total_usage_tokens(&turns);
         let context_window_max_tokens =
             super::infer_context_window_max_tokens(summary.model.as_deref());
diff --git a/src/components/ai-elements/tool.tsx b/src/components/ai-elements/tool.tsx
index 45852f7..ebbe131 100644
--- a/src/components/ai-elements/tool.tsx
+++ b/src/components/ai-elements/tool.tsx
@@ -22,6 +22,7 @@ import { useTranslations } from "next-intl"
 import { isValidElement } from "react"
 
 import { CodeBlock } from "./code-block"
+import { UnifiedDiffPreview } from "@/components/diff/unified-diff-preview"
 import { MessageResponse } from "./message"
 
 export type ToolProps = ComponentProps<typeof Collapsible>
@@ -380,9 +381,10 @@ export const ToolOutput = ({
           <MessageResponse>{output}</MessageResponse>
         </div>
       )
+    } else if (lang === "diff") {
+      Output = <UnifiedDiffPreview diffText={output} />
     } else {
-      const language = detectOutputLanguage(output)
-      Output = <CodeBlock code={output} language={language} />
+      Output = <CodeBlock code={output} language={lang} />
     }
   }
 
diff --git a/src/components/diff/unified-diff-preview.tsx b/src/components/diff/unified-diff-preview.tsx
index 97efd07..e294489 100644
--- a/src/components/diff/unified-diff-preview.tsx
+++ b/src/components/diff/unified-diff-preview.tsx
@@ -1,13 +1,9 @@
 "use client"
 
-import { useCallback, useEffect, useMemo, useRef } from "react"
-import dynamic from "next/dynamic"
-import type { editor as MonacoEditorNs } from "monaco-editor"
+import { useMemo } from "react"
 import { useTranslations } from "next-intl"
 import { useFolderContext } from "@/contexts/folder-context"
-import { defineMonacoThemes, useMonacoThemeSync } from "@/lib/monaco-themes"
 import { cn } from "@/lib/utils"
-import "@/lib/monaco-local"
 
 type RowMarker = "none" | "added" | "deleted" | "modified"
 type DiffFileMode = "modified" | "added" | "deleted" | "renamed"
@@ -67,14 +63,18 @@ interface WorkingFile {
   hunks: WorkingHunk[]
 }
 
-interface HunkPreviewLine {
-  text: string
-  marker: RowMarker
+const ROW_CLASS: Record<RowMarker, string> = {
+  none: "",
+  added: "bg-green-500/10 text-green-900 dark:text-green-300",
+  deleted: "bg-red-500/10 text-red-900 dark:text-red-300",
+  modified: "bg-blue-500/10 text-blue-900 dark:text-blue-300",
 }
 
-const MonacoEditor = dynamic(async () => import("@monaco-editor/react"), {
-  ssr: false,
-})
+const SIGN_CLASS: Record<string, string> = {
+  "+": "text-green-700 dark:text-green-400",
+  "-": "text-red-700 dark:text-red-400",
+  " ": "text-muted-foreground/50",
+}
 
 function normalizePath(raw: string): string | null {
   const trimmed = raw.trim().replace(/^"|"$/g, "")
@@ -190,13 +190,11 @@ function classifyRows(rows: RawDiffRow[]): ParsedDiffRow[] {
       addEnd += 1
     }
 
-    const delRows = rows.slice(index, delEnd)
-    const addRows = rows.slice(delEnd, addEnd)
-    const modifiedPairs = Math.min(delRows.length, addRows.length)
-
-    for (const [delta, row] of delRows.entries()) {
+    for (let d = index; d < delEnd; d++) {
+      const row = rows[d]
+      if (!row) continue
       parsed.push({
-        type: delta < modifiedPairs ? "modified" : "deleted",
+        type: "deleted",
         text: row.text,
         sign: "-",
         oldLine: row.oldLine,
@@ -204,9 +202,11 @@ function classifyRows(rows: RawDiffRow[]): ParsedDiffRow[] {
       })
     }
 
-    for (const [delta, row] of addRows.entries()) {
+    for (let a = delEnd; a < addEnd; a++) {
+      const row = rows[a]
+      if (!row) continue
       parsed.push({
-        type: delta < modifiedPairs ? "modified" : "added",
+        type: "added",
         text: row.text,
         sign: "+",
         oldLine: row.oldLine,
@@ -440,171 +440,53 @@ function toDisplayPath(filePath: string, folderPath: string | null): string {
   return normalizedPath
 }
 
-function countHunkChanges(hunk: ParsedDiffHunk): {
-  additions: number
-  deletions: number
-} {
-  let additions = 0
-  let deletions = 0
-
-  for (const row of hunk.rows) {
-    if (row.sign === "+") additions += 1
-    if (row.sign === "-") deletions += 1
-  }
-
-  return { additions, deletions }
+function rowMarker(row: ParsedDiffRow): RowMarker {
+  if (row.type === "added") return "added"
+  if (row.type === "deleted") return "deleted"
+  return "none"
 }
 
-function buildHunkPreviewLines(rows: ParsedDiffRow[]): {
-  lines: HunkPreviewLine[]
-} {
-  const lines: HunkPreviewLine[] = rows.map((row) => {
-    let marker: RowMarker = "none"
-    if (row.type === "added") marker = "added"
-    else if (row.type === "deleted") marker = "deleted"
-    else if (row.type === "modified") marker = "modified"
-
-    return {
-      text: `${row.sign}${row.text}`,
-      marker,
-    }
-  })
-
-  return {
-    lines,
-  }
-}
-
-function HunkMonacoPreview({
-  hunk,
-  modelId,
-  theme,
-}: {
-  hunk: ParsedDiffHunk
-  modelId: string
-  theme: string
-}) {
-  const t = useTranslations("Folder.diffPreview")
-  const editorRef = useRef<MonacoEditorNs.IStandaloneCodeEditor | null>(null)
-  const decorationsRef = useRef<string[]>([])
-
-  const { lines } = useMemo(() => buildHunkPreviewLines(hunk.rows), [hunk.rows])
-
-  const renderedContent = useMemo(
-    () => lines.map((line) => line.text).join("\n"),
-    [lines]
-  )
-
-  const applyDecorations = useCallback(() => {
-    const editor = editorRef.current
-    if (!editor) return
-
-    const model = editor.getModel()
-    if (!model) return
-
-    const maxLine = model.getLineCount()
-    const decorations: MonacoEditorNs.IModelDeltaDecoration[] = []
-
-    for (const [index, line] of lines.entries()) {
-      const lineNumber = index + 1
-      if (lineNumber > maxLine) continue
-
-      let cls: string | null = null
-      if (line.marker === "added") {
-        cls = "codeg-session-diff-line-added"
-      } else if (line.marker === "modified") {
-        cls = "codeg-session-diff-line-modified"
-      } else if (line.marker === "deleted") {
-        cls = "codeg-session-diff-line-deleted"
-      }
-
-      if (!cls) continue
-
-      decorations.push({
-        range: {
-          startLineNumber: lineNumber,
-          startColumn: 1,
-          endLineNumber: lineNumber,
-          endColumn: 1,
-        },
-        options: {
-          isWholeLine: true,
-          className: cls,
-        },
-      })
-    }
-
-    decorationsRef.current = editor.deltaDecorations(
-      decorationsRef.current,
-      decorations
-    )
-  }, [lines])
-
-  useEffect(() => {
-    applyDecorations()
-  }, [applyDecorations])
-
-  useEffect(
-    () => () => {
-      const editor = editorRef.current
-      if (!editor) return
-      editor.deltaDecorations(decorationsRef.current, [])
-      decorationsRef.current = []
-    },
-    []
-  )
-
+function HunkLines({ rows }: { rows: ParsedDiffRow[] }) {
   return (
-    <MonacoEditor
-      beforeMount={defineMonacoThemes}
-      onMount={(editor) => {
-        editorRef.current = editor
-        applyDecorations()
-      }}
-      path={`inmemory://session-hunk/${encodeURIComponent(modelId)}`}
-      value={renderedContent}
-      language="plaintext"
-      theme={theme}
-      loading={
-        <div className="h-28 flex items-center justify-center text-xs text-muted-foreground">
-          {t("loadingHunk")}
-        </div>
-      }
-      options={{
-        readOnly: true,
-        minimap: { enabled: false },
-        automaticLayout: true,
-        fontSize: 12,
-        lineNumbers: "off",
-        lineDecorationsWidth: 10,
-        glyphMargin: false,
-        wordWrap: "off",
-        scrollBeyondLastLine: false,
-        renderLineHighlight: "none",
-        contextmenu: false,
-        folding: false,
-        scrollbar: {
-          alwaysConsumeMouseWheel: false,
-        },
-        padding: { top: 6, bottom: 6 },
-      }}
-    />
+    <div className="inline-block min-w-full font-mono text-[12px] leading-[20px]">
+      {rows.map((row, i) => {
+        const marker = rowMarker(row)
+        return (
+          <div key={i} className={cn("flex", ROW_CLASS[marker])}>
+            <span className="w-[3.5rem] shrink-0 select-none pr-1 text-right text-muted-foreground/40">
+              {row.oldLine ?? ""}
+            </span>
+            <span className="w-[3.5rem] shrink-0 select-none pr-1 text-right text-muted-foreground/40">
+              {row.newLine ?? ""}
+            </span>
+            <span
+              className={cn(
+                "w-4 shrink-0 select-none text-center",
+                SIGN_CLASS[row.sign] ?? ""
+              )}
+            >
+              {row.sign === " " ? "" : row.sign}
+            </span>
+            <span className="flex-1 whitespace-pre pr-3">{row.text}</span>
+          </div>
+        )
+      })}
+    </div>
   )
 }
 
 export function UnifiedDiffPreview({
   diffText,
-  modelId,
   className,
 }: {
   diffText: string
+  /** @deprecated No longer used — kept for API compat */
   modelId?: string
   className?: string
 }) {
   const t = useTranslations("Folder.diffPreview")
   const { folder } = useFolderContext()
   const files = useMemo(() => parseUnifiedDiff(diffText), [diffText])
-  const theme = useMonacoThemeSync()
 
   if (!diffText.trim()) {
     return (
@@ -621,8 +503,8 @@ export function UnifiedDiffPreview({
 
   if (files.length === 0) {
     return (
-      <div className={cn("h-full overflow-auto p-3", className)}>
-        <pre className="font-mono text-[11px] leading-5 whitespace-pre-wrap text-muted-foreground">
+      <div className={cn("h-full overflow-auto", className)}>
+        <pre className="font-mono text-[11px] leading-5 whitespace-pre-wrap text-muted-foreground p-3">
           {diffText}
         </pre>
       </div>
@@ -630,14 +512,14 @@ export function UnifiedDiffPreview({
   }
 
   return (
-    <div className={cn("h-full overflow-auto p-3", className)}>
+    <div className={cn("h-full overflow-auto", className)}>
       <div className="space-y-3">
         {files.map((file) => (
           <section
             key={file.key}
-            className="overflow-hidden rounded-lg border border-border bg-background"
+            className="flex max-h-[480px] flex-col rounded-lg border border-border bg-background"
           >
-            <header className="flex items-center gap-2 border-b border-border bg-muted/40 px-3 py-2 text-[11px]">
+            <header className="flex shrink-0 items-center gap-2 border-b border-border bg-muted/40 px-3 py-2 text-[11px]">
               <span className="shrink-0 rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground">
                 {t(modeKey(file.mode))}
               </span>
@@ -657,41 +539,10 @@ export function UnifiedDiffPreview({
               </span>
             </header>
 
-            <div className="space-y-2 p-2">
-              {file.hunks.map((hunk, index) => {
-                const hunkStats = countHunkChanges(hunk)
-
-                return (
-                  <div
-                    key={hunk.key}
-                    className="rounded-md border border-border"
-                  >
-                    <div className="flex items-center gap-2 border-b border-border bg-muted/30 px-2 py-1 text-[10px] font-mono text-muted-foreground">
-                      <span>{t("hunkLabel", { index: index + 1 })}</span>
-                      <span className="ml-auto inline-flex items-center gap-2">
-                        <span className="text-green-700 dark:text-green-400">
-                          +{hunkStats.additions}
-                        </span>
-                        <span className="text-red-700 dark:text-red-400">
-                          -{hunkStats.deletions}
-                        </span>
-                      </span>
-                    </div>
-                    <div
-                      className="min-h-[7rem]"
-                      style={{
-                        height: `${Math.max(120, hunk.rows.length * 20 + 18)}px`,
-                      }}
-                    >
-                      <HunkMonacoPreview
-                        hunk={hunk}
-                        modelId={`${modelId ?? "session"}:${file.key}:${hunk.key}`}
-                        theme={theme}
-                      />
-                    </div>
-                  </div>
-                )
-              })}
+            <div className="overflow-auto">
+              {file.hunks.map((hunk) => (
+                <HunkLines key={hunk.key} rows={hunk.rows} />
+              ))}
             </div>
           </section>
         ))}
diff --git a/src/components/files/file-workspace-panel.tsx b/src/components/files/file-workspace-panel.tsx
index 768112c..7d81137 100644
--- a/src/components/files/file-workspace-panel.tsx
+++ b/src/components/files/file-workspace-panel.tsx
@@ -1270,8 +1270,7 @@ export function FileWorkspacePanel() {
         )}
         <UnifiedDiffPreview
           diffText={activeFileTab.content}
-          modelId={activeFileTab.id}
-          className="h-full"
+          className="h-full p-3"
         />
       </div>
     )
diff --git a/src/components/message/content-parts-renderer.tsx b/src/components/message/content-parts-renderer.tsx
index 7961c18..2002ebc 100644
--- a/src/components/message/content-parts-renderer.tsx
+++ b/src/components/message/content-parts-renderer.tsx
@@ -1,5 +1,4 @@
 import { memo, useMemo, useState, type ReactNode } from "react"
-import type { BundledLanguage } from "shiki"
 import type { AdaptedContentPart } from "@/lib/adapters/ai-elements-adapter"
 import type { MessageRole } from "@/lib/types"
 import { normalizeToolName } from "@/lib/tool-call-normalization"
@@ -17,6 +16,8 @@ import {
 } from "@/components/ai-elements/tool"
 import { Terminal } from "@/components/ai-elements/terminal"
 import { CodeBlock } from "@/components/ai-elements/code-block"
+import { UnifiedDiffPreview } from "@/components/diff/unified-diff-preview"
+import { generateUnifiedDiff } from "@/lib/unified-diff-generator"
 import {
   Reasoning,
   ReasoningTrigger,
@@ -374,62 +375,6 @@ function num(obj: Record<string, unknown>, key: string): number | undefined {
   return typeof v === "number" ? v : undefined
 }
 
-/** Guess shiki language from file path extension. */
-const EXT_LANG_MAP: Record<string, BundledLanguage> = {
-  ts: "typescript",
-  tsx: "tsx",
-  js: "javascript",
-  jsx: "jsx",
-  mjs: "javascript",
-  cjs: "javascript",
-  py: "python",
-  rs: "rust",
-  go: "go",
-  java: "java",
-  css: "css",
-  scss: "scss",
-  less: "less",
-  html: "html",
-  json: "json",
-  jsonl: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  md: "markdown",
-  mdx: "mdx",
-  sql: "sql",
-  sh: "bash",
-  bash: "bash",
-  zsh: "bash",
-  toml: "toml",
-  xml: "xml",
-  svg: "xml",
-  vue: "vue",
-  svelte: "svelte",
-  rb: "ruby",
-  php: "php",
-  swift: "swift",
-  kt: "kotlin",
-  c: "c",
-  cpp: "cpp",
-  h: "c",
-  hpp: "cpp",
-  cs: "csharp",
-  dart: "dart",
-  lua: "lua",
-  r: "r",
-  dockerfile: "dockerfile",
-  graphql: "graphql",
-  prisma: "prisma",
-}
-
-function guessLangFromPath(filePath: string): BundledLanguage {
-  const ext = filePath.split(".").pop()?.toLowerCase() ?? ""
-  // Handle dotfiles like "Dockerfile"
-  const basename = filePath.split("/").pop()?.toLowerCase() ?? ""
-  if (basename === "dockerfile") return "dockerfile"
-  return EXT_LANG_MAP[ext] ?? ("log" as BundledLanguage)
-}
-
 type ApplyPatchOp = "add" | "update" | "delete" | "move"
 
 type ApplyPatchFile = {
@@ -1215,115 +1160,46 @@ function localizeDerivedToolTitle(
 
 /** Edit tool: file path + unified diff view */
 function EditToolInput({ input }: { input: Record<string, unknown> }) {
-  const t = useTranslations("Folder.chat.contentParts")
   const filePath = str(input, "file_path")
   const oldString = str(input, "old_string") ?? ""
   const newString = str(input, "new_string") ?? ""
-  const replaceAll = input.replace_all === true
 
   const diffCode = useMemo(() => {
-    const parts: string[] = []
-    if (oldString) {
-      for (const line of oldString.split("\n")) {
-        parts.push(`- ${line}`)
-      }
-    }
-    if (newString) {
-      for (const line of newString.split("\n")) {
-        parts.push(`+ ${line}`)
-      }
-    }
-    return parts.join("\n")
-  }, [oldString, newString])
+    return (
+      generateUnifiedDiff(oldString, newString, filePath ?? undefined) ?? ""
+    )
+  }, [oldString, newString, filePath])
 
-  return (
-    <div className="space-y-2">
-      <div className="flex items-center gap-2 text-xs">
-        <FilePenLineIcon className="size-3.5 shrink-0 text-muted-foreground" />
-        <span className="break-all font-mono text-foreground">
-          {filePath ?? t("unknown")}
-        </span>
-        {replaceAll && (
-          <span className="shrink-0 rounded bg-muted px-1.5 py-0.5 text-[10px] font-medium text-muted-foreground">
-            {t("replaceAll")}
-          </span>
-        )}
-      </div>
-      {diffCode && <CodeBlock code={diffCode} language="diff" />}
-    </div>
-  )
+  return diffCode ? <UnifiedDiffPreview diffText={diffCode} /> : null
 }
 
-/** Edit tool (changes payload): file list + summary + combined diff view */
+/** Edit tool (changes payload): combined diff view */
 function EditChangesToolInput({ changes }: { changes: EditChangePreview[] }) {
-  const t = useTranslations("Folder.chat.contentParts")
-  const { additions, deletions, diffCode } = useMemo(() => {
-    let additions = 0
-    let deletions = 0
+  const diffCode = useMemo(() => {
     const diffParts: string[] = []
 
     for (const change of changes) {
       if (change.unifiedDiff && change.unifiedDiff.trim().length > 0) {
         diffParts.push(change.unifiedDiff.trim())
         diffParts.push("")
-        for (const line of change.unifiedDiff.split("\n")) {
-          if (line.startsWith("+") && !line.startsWith("+++")) additions += 1
-          if (line.startsWith("-") && !line.startsWith("---")) deletions += 1
-        }
         continue
       }
 
-      const oldLines = change.oldText ? change.oldText.split("\n") : []
-      const newLines = change.newText ? change.newText.split("\n") : []
-
-      deletions += oldLines.length
-      additions += newLines.length
-
-      diffParts.push(`--- ${change.path}`)
-      diffParts.push(`+++ ${change.path}`)
-      for (const line of oldLines) {
-        diffParts.push(`-${line}`)
+      const generated = generateUnifiedDiff(
+        change.oldText,
+        change.newText,
+        change.path
+      )
+      if (generated) {
+        diffParts.push(generated)
+        diffParts.push("")
       }
-      for (const line of newLines) {
-        diffParts.push(`+${line}`)
-      }
-      diffParts.push("")
     }
 
-    return {
-      additions,
-      deletions,
-      diffCode: diffParts.join("\n").trim(),
-    }
+    return diffParts.join("\n").trim()
   }, [changes])
 
-  return (
-    <div className="space-y-2">
-      <div className="flex flex-wrap gap-3 text-xs text-muted-foreground">
-        <span>{t("filesCount", { count: changes.length })}</span>
-        {additions > 0 && <span>+{additions}</span>}
-        {deletions > 0 && <span>-{deletions}</span>}
-      </div>
-      <div className="space-y-1 rounded-md bg-muted/40 p-2">
-        {changes.slice(0, 8).map((change, index) => (
-          <div key={`${change.path}-${index}`} className="flex gap-2 text-xs">
-            <span className="shrink-0 rounded bg-blue-500/15 px-1.5 py-0.5 font-medium uppercase text-blue-600">
-              {t("update")}
-            </span>
-            <span className="break-all font-mono text-foreground">
-              {change.path}
-            </span>
-          </div>
-        ))}
-        {changes.length > 8 && (
-          <div className="text-xs text-muted-foreground">
-            {t("moreFiles", { count: changes.length - 8 })}
-          </div>
-        )}
-      </div>
-      {diffCode && <CodeBlock code={diffCode} language="diff" />}
-    </div>
-  )
+  return diffCode ? <UnifiedDiffPreview diffText={diffCode} /> : null
 }
 
 /** Bash / exec_command: terminal-style command display */
@@ -1358,13 +1234,60 @@ function BashToolInput({ input }: { input: Record<string, unknown> }) {
   )
 }
 
+/**
+ * Parse structured read output from backend: `{"start_line":N,"content":"..."}`.
+ * Falls back to raw text with startLine=1 if not structured.
+ */
+function parseReadOutput(raw: string): { startLine: number; content: string } {
+  try {
+    const parsed = JSON.parse(raw)
+    if (
+      typeof parsed === "object" &&
+      parsed !== null &&
+      typeof parsed.start_line === "number" &&
+      typeof parsed.content === "string"
+    ) {
+      return { startLine: parsed.start_line, content: parsed.content }
+    }
+  } catch {
+    // not JSON
+  }
+  return { startLine: 1, content: raw }
+}
+
+/** Lightweight file content viewer with line numbers */
+function FileContentLines({
+  content,
+  startLine = 1,
+}: {
+  content: string
+  startLine?: number
+}) {
+  const lines = useMemo(() => content.split("\n"), [content])
+
+  return (
+    <div className="inline-block min-w-full font-mono text-[12px] leading-[20px]">
+      {lines.map((line, i) => (
+        <div key={i} className="flex">
+          <span className="w-[3.5rem] shrink-0 select-none pr-1 text-right text-muted-foreground/40">
+            {startLine + i}
+          </span>
+          <span className="flex-1 whitespace-pre pr-3">{line}</span>
+        </div>
+      ))}
+    </div>
+  )
+}
+
 /** Read / Write / NotebookEdit: file-focused display */
 function FileToolInput({
   toolName,
   input,
+  output,
 }: {
   toolName: string
   input: Record<string, unknown>
+  output?: string | null
 }) {
   const t = useTranslations("Folder.chat.contentParts")
   const name = toolName.toLowerCase()
@@ -1377,48 +1300,52 @@ function FileToolInput({
   const pages = str(input, "pages")
   const cellType = str(input, "cell_type")
   const editMode = str(input, "edit_mode")
+  const isRead = name === "read" || name === "read file"
 
-  const lang = filePath
-    ? guessLangFromPath(filePath)
-    : ("log" as BundledLanguage)
+  const badges: string[] = []
+  if (offset != null) badges.push(t("offset", { offset }))
+  if (limit != null) badges.push(t("limit", { limit }))
+  if (pages) badges.push(t("pages", { pages }))
+  if (editMode) badges.push(t("mode", { mode: editMode }))
+  if (cellType) badges.push(t("cell", { cell: cellType }))
+
+  const { displayContent, startLine } = useMemo(() => {
+    if (isRead && output) {
+      const parsed = parseReadOutput(output)
+      return { displayContent: parsed.content, startLine: parsed.startLine }
+    }
+    return {
+      displayContent: content ?? newSource ?? null,
+      startLine: 1,
+    }
+  }, [isRead, output, content, newSource])
 
   return (
-    <div className="space-y-2">
-      {filePath && (
-        <div className="flex items-center gap-2 text-xs">
-          {name === "read" || name === "read file" ? (
-            <FileTextIcon className="size-3.5 shrink-0 text-muted-foreground" />
-          ) : (
-            <FilePlusIcon className="size-3.5 shrink-0 text-muted-foreground" />
-          )}
-          <span className="break-all font-mono text-foreground">
-            {filePath}
+    <section className="flex max-h-[480px] flex-col rounded-lg border border-border bg-background">
+      <header className="flex shrink-0 items-center gap-2 border-b border-border bg-muted/40 px-3 py-2 text-[11px]">
+        <span className="shrink-0 rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground">
+          {isRead ? "READ" : "WRITE"}
+        </span>
+        <span
+          className="min-w-0 flex-1 truncate font-mono text-foreground"
+          title={filePath ?? undefined}
+        >
+          {filePath ?? t("unknown")}
+        </span>
+        {badges.length > 0 && (
+          <span className="ml-auto inline-flex shrink-0 items-center gap-2 text-[10px] text-muted-foreground">
+            {badges.map((b) => (
+              <span key={b}>{b}</span>
+            ))}
           </span>
+        )}
+      </header>
+      {displayContent && (
+        <div className="overflow-auto">
+          <FileContentLines content={displayContent} startLine={startLine} />
         </div>
       )}
-      {(offset != null || limit != null || pages) && (
-        <div className="flex flex-wrap gap-3 text-xs text-muted-foreground">
-          {offset != null && <span>{t("offset", { offset })}</span>}
-          {limit != null && <span>{t("limit", { limit })}</span>}
-          {pages && <span>{t("pages", { pages })}</span>}
-        </div>
-      )}
-      {(cellType || editMode) && (
-        <div className="flex flex-wrap gap-3 text-xs text-muted-foreground">
-          {editMode && <span>{t("mode", { mode: editMode })}</span>}
-          {cellType && <span>{t("cell", { cell: cellType })}</span>}
-        </div>
-      )}
-      {(name === "write" || name === "notebookedit") &&
-        (content || newSource) &&
-        (lang === "markdown" || lang === "mdx" ? (
-          <div className="rounded-md border p-3 text-sm prose prose-sm dark:prose-invert max-w-none [&_ul]:list-inside [&_ol]:list-inside">
-            <MessageResponse>{content ?? newSource ?? ""}</MessageResponse>
-          </div>
-        ) : (
-          <CodeBlock code={content ?? newSource ?? ""} language={lang} />
-        ))}
-    </div>
+    </section>
   )
 }
 
@@ -1629,49 +1556,7 @@ function TodoWriteToolInput({ input }: { input: Record<string, unknown> }) {
 }
 
 function ApplyPatchToolInput({ input }: { input: string }) {
-  const t = useTranslations("Folder.chat.contentParts")
-  const { files, additions, deletions } = useMemo(
-    () => parseApplyPatchInput(input),
-    [input]
-  )
-  const opClass: Record<ApplyPatchOp, string> = {
-    add: "bg-green-500/15 text-green-600",
-    update: "bg-blue-500/15 text-blue-600",
-    delete: "bg-red-500/15 text-red-600",
-    move: "bg-purple-500/15 text-purple-600",
-  }
-
-  return (
-    <div className="space-y-2">
-      <div className="flex flex-wrap gap-3 text-xs text-muted-foreground">
-        <span>{t("filesCount", { count: files.length })}</span>
-        {additions > 0 && <span>+{additions}</span>}
-        {deletions > 0 && <span>-{deletions}</span>}
-      </div>
-      {files.length > 0 && (
-        <div className="space-y-1 rounded-md bg-muted/40 p-2">
-          {files.slice(0, 8).map((file, index) => (
-            <div key={`${file.path}-${index}`} className="flex gap-2 text-xs">
-              <span
-                className={`shrink-0 rounded px-1.5 py-0.5 font-medium uppercase ${opClass[file.op]}`}
-              >
-                {file.op}
-              </span>
-              <span className="break-all font-mono text-foreground">
-                {file.path}
-              </span>
-            </div>
-          ))}
-          {files.length > 8 && (
-            <div className="text-xs text-muted-foreground">
-              {t("moreFiles", { count: files.length - 8 })}
-            </div>
-          )}
-        </div>
-      )}
-      <CodeBlock code={input} language="diff" />
-    </div>
-  )
+  return <UnifiedDiffPreview diffText={input} />
 }
 
 // ── Switch mode (plan) input ──────────────────────────────────────────
@@ -1794,20 +1679,41 @@ function GenericToolInput({ input }: { input: string }) {
 
 // ── Dispatcher ───────────────────────────────────────────────────────
 
+function isTruncatedInput(input: string): boolean {
+  return input.endsWith('..."') || input.endsWith("...")
+}
+
 function StructuredToolInput({
   toolName,
   input,
+  output,
 }: {
   toolName: string
   input: string
+  output?: string | null
 }) {
+  const t = useTranslations("Folder.chat.contentParts")
   const name = toolName.toLowerCase()
   const parsed = tryParseJson(input)
+  const truncated =
+    (name === "edit" || name === "write" || name === "apply_patch") &&
+    isTruncatedInput(input)
+
+  const truncationBanner = truncated ? (
+    <div className="rounded-md bg-yellow-500/10 px-2.5 py-1.5 text-[11px] text-yellow-700 dark:text-yellow-400">
+      {t("inputTruncated")}
+    </div>
+  ) : null
 
   if (name === "apply_patch") {
     const patchInput =
       extractApplyPatchTextFromUnknownInput(input, parsed) ?? input
-    return <ApplyPatchToolInput input={patchInput} />
+    return (
+      <>
+        {truncationBanner}
+        <ApplyPatchToolInput input={patchInput} />
+      </>
+    )
   }
 
   if (name === "bash" || name === "exec_command") {
@@ -1831,16 +1737,31 @@ function StructuredToolInput({
   if (name === "edit") {
     const patchInput = extractApplyPatchTextFromUnknownInput(input, parsed)
     if (patchInput) {
-      return <ApplyPatchToolInput input={patchInput} />
+      return (
+        <>
+          {truncationBanner}
+          <ApplyPatchToolInput input={patchInput} />
+        </>
+      )
     }
     if (parsed) {
       const changesPayload = extractEditChangesPayload(parsed)
       if (changesPayload.length > 0) {
-        return <EditChangesToolInput changes={changesPayload} />
+        return (
+          <>
+            {truncationBanner}
+            <EditChangesToolInput changes={changesPayload} />
+          </>
+        )
       }
     }
     if (isCanonicalEditPayload(parsed)) {
-      return <EditToolInput input={parsed} />
+      return (
+        <>
+          {truncationBanner}
+          <EditToolInput input={parsed} />
+        </>
+      )
     }
     return <GenericToolInput input={input} />
   }
@@ -1852,7 +1773,7 @@ function StructuredToolInput({
     name === "write" ||
     name === "notebookedit"
   )
-    return <FileToolInput toolName={toolName} input={parsed} />
+    return <FileToolInput toolName={toolName} input={parsed} output={output} />
   if (name === "glob" || name === "grep")
     return <SearchToolInput toolName={toolName} input={parsed} />
   if (name === "webfetch" || name === "websearch")
@@ -2275,12 +2196,18 @@ const ToolCallPart = memo(function ToolCallPart({
     displayCommand,
     isRunning,
   ])
+  const isFileTool =
+    toolNameLower === "read" ||
+    toolNameLower === "read file" ||
+    toolNameLower === "write" ||
+    toolNameLower === "notebookedit"
   const shouldHideDuplicateResult =
     (toolNameLower === "edit" ||
       toolNameLower === "apply_patch" ||
       toolNameLower === "switch_mode" ||
       toolNameLower === "enterplanmode" ||
-      toolNameLower === "exitplanmode") &&
+      toolNameLower === "exitplanmode" ||
+      isFileTool) &&
     !part.errorText
   const open = (isRunning && (isCommandTool || hasLiveOutput)) || manualOpen
 
@@ -2299,6 +2226,7 @@ const ToolCallPart = memo(function ToolCallPart({
           <StructuredToolInput
             toolName={normalizedToolName}
             input={part.input}
+            output={part.output}
           />
         )}
         {(toolNameLower === "task" || toolNameLower === "agent") &&
diff --git a/src/i18n/messages/ar.json b/src/i18n/messages/ar.json
index 190137a..5536116 100644
--- a/src/i18n/messages/ar.json
+++ b/src/i18n/messages/ar.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "يتم عرض نهاية المخرجات أثناء البث لتحسين الأداء.",
         "result": "النتيجة",
         "unknown": "غير معروف",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "استبدال الكل",
         "filesCount": "الملفات: {count}",
         "update": "تحديث",
diff --git a/src/i18n/messages/de.json b/src/i18n/messages/de.json
index 52ba47f..47a3511 100644
--- a/src/i18n/messages/de.json
+++ b/src/i18n/messages/de.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "Zur besseren Performance wird während des Streamings nur die Endausgabe angezeigt.",
         "result": "Ergebnis",
         "unknown": "unbekannt",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "ALLES ERSETZEN",
         "filesCount": "Dateien: {count}",
         "update": "aktualisieren",
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index f833d87..177b76f 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "Showing tail output while streaming for performance.",
         "result": "Result",
         "unknown": "unknown",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "REPLACE ALL",
         "filesCount": "Files: {count}",
         "update": "update",
diff --git a/src/i18n/messages/es.json b/src/i18n/messages/es.json
index e231eb0..56e75f8 100644
--- a/src/i18n/messages/es.json
+++ b/src/i18n/messages/es.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "Mostrando la salida final durante el streaming para mejorar el rendimiento.",
         "result": "Resultado",
         "unknown": "desconocido",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "REEMPLAZAR TODO",
         "filesCount": "Archivos: {count}",
         "update": "actualizar",
diff --git a/src/i18n/messages/fr.json b/src/i18n/messages/fr.json
index a095030..7cda82d 100644
--- a/src/i18n/messages/fr.json
+++ b/src/i18n/messages/fr.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "Affichage de la fin de la sortie pendant le streaming pour de meilleures performances.",
         "result": "Résultat",
         "unknown": "inconnu",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "TOUT REMPLACER",
         "filesCount": "Fichiers : {count}",
         "update": "mettre à jour",
diff --git a/src/i18n/messages/ja.json b/src/i18n/messages/ja.json
index 05e5831..09f00ea 100644
--- a/src/i18n/messages/ja.json
+++ b/src/i18n/messages/ja.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "パフォーマンスのため、ストリーミング中は末尾出力を表示しています。",
         "result": "結果",
         "unknown": "不明",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "すべて置換",
         "filesCount": "ファイル: {count}",
         "update": "更新",
diff --git a/src/i18n/messages/ko.json b/src/i18n/messages/ko.json
index 34f73aa..e338452 100644
--- a/src/i18n/messages/ko.json
+++ b/src/i18n/messages/ko.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "성능을 위해 스트리밍 중에는 출력의 끝부분만 표시합니다.",
         "result": "결과",
         "unknown": "알 수 없음",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "모두 바꾸기",
         "filesCount": "파일: {count}",
         "update": "업데이트",
diff --git a/src/i18n/messages/pt.json b/src/i18n/messages/pt.json
index 0dbbe38..f6fe5c7 100644
--- a/src/i18n/messages/pt.json
+++ b/src/i18n/messages/pt.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "Mostrando a saída final durante o streaming para melhor desempenho.",
         "result": "Resultado",
         "unknown": "desconhecido",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "SUBSTITUIR TUDO",
         "filesCount": "Arquivos: {count}",
         "update": "atualizar",
diff --git a/src/i18n/messages/zh-CN.json b/src/i18n/messages/zh-CN.json
index c419abe..18a5c3b 100644
--- a/src/i18n/messages/zh-CN.json
+++ b/src/i18n/messages/zh-CN.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "为保证性能，流式输出时仅显示尾部内容。",
         "result": "结果",
         "unknown": "未知",
+        "inputTruncated": "输入已截断，diff 可能不完整。",
         "replaceAll": "全部替换",
         "filesCount": "文件：{count}",
         "update": "更新",
diff --git a/src/i18n/messages/zh-TW.json b/src/i18n/messages/zh-TW.json
index 6c1f01a..270c5d7 100644
--- a/src/i18n/messages/zh-TW.json
+++ b/src/i18n/messages/zh-TW.json
@@ -1485,6 +1485,7 @@
         "showingTailOutput": "為確保效能，串流輸出時僅顯示尾端內容。",
         "result": "結果",
         "unknown": "未知",
+        "inputTruncated": "Input was truncated — diff may be incomplete.",
         "replaceAll": "全部替換",
         "filesCount": "檔案：{count}",
         "update": "更新",
diff --git a/src/lib/session-files.ts b/src/lib/session-files.ts
index 7883af0..1e60315 100644
--- a/src/lib/session-files.ts
+++ b/src/lib/session-files.ts
@@ -1,5 +1,6 @@
 import type { MessageTurn } from "./types"
 import { normalizeToolName } from "./tool-call-normalization"
+import { generateUnifiedDiff } from "./unified-diff-generator"
 
 export type FileOperation = "read" | "edit" | "write" | "apply_patch"
 
@@ -266,32 +267,12 @@ function countDiffLines(text: string): DiffStat {
   return { additions, deletions }
 }
 
-function createHunkHeader(oldLineCount: number, newLineCount: number): string {
-  const oldStart = oldLineCount === 0 ? 0 : 1
-  const newStart = newLineCount === 0 ? 0 : 1
-  return `@@ -${oldStart},${oldLineCount} +${newStart},${newLineCount} @@`
-}
-
 function buildUnifiedDiff(
   filePath: string,
   oldText: string,
   newText: string
 ): string | null {
-  if (!oldText && !newText) return null
-
-  const oldLines = oldText ? oldText.split("\n") : []
-  const newLines = newText ? newText.split("\n") : []
-
-  const lines: string[] = [
-    `--- a/${filePath}`,
-    `+++ b/${filePath}`,
-    createHunkHeader(oldLines.length, newLines.length),
-  ]
-
-  for (const line of oldLines) lines.push(`-${line}`)
-  for (const line of newLines) lines.push(`+${line}`)
-
-  return lines.join("\n")
+  return generateUnifiedDiff(oldText, newText, filePath)
 }
 
 function parseEditChangeValue(value: unknown): EditChangePreview | null {
diff --git a/src/lib/unified-diff-generator.ts b/src/lib/unified-diff-generator.ts
new file mode 100644
index 0000000..7039171
--- /dev/null
+++ b/src/lib/unified-diff-generator.ts
@@ -0,0 +1,180 @@
+import { computeLineDiff, type DiffHunk } from "@/components/merge/merge-diff"
+
+/**
+ * Maximum product of line counts before falling back to naive diff.
+ * Avoids O(n*m) LCS blowup for very large inputs.
+ */
+const LCS_PAIR_BUDGET = 200_000
+
+/**
+ * Generate a unified diff string from old and new text.
+ *
+ * Uses LCS-based line diff when within budget, falls back to
+ * simple "all deletions then all additions" for very large inputs.
+ */
+export function generateUnifiedDiff(
+  oldText: string,
+  newText: string,
+  filePath?: string,
+  contextLines: number = 3
+): string | null {
+  if (!oldText && !newText) return null
+  if (oldText === newText) return null
+
+  const oldLines = oldText ? splitLines(oldText) : []
+  const newLines = newText ? splitLines(newText) : []
+
+  const path = filePath ?? "file"
+  const header = `--- a/${path}\n+++ b/${path}`
+
+  // Performance gate: fall back to naive diff for large inputs
+  if (oldLines.length * newLines.length > LCS_PAIR_BUDGET) {
+    return buildNaiveDiff(header, oldLines, newLines)
+  }
+
+  const hunks = computeLineDiff(oldLines, newLines)
+  if (hunks.length === 0) return null
+
+  const unifiedHunks = buildUnifiedHunks(oldLines, hunks, contextLines)
+
+  return `${header}\n${unifiedHunks}`
+}
+
+function splitLines(text: string): string[] {
+  const lines = text.split("\n")
+  // Remove trailing empty line from trailing newline
+  if (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop()
+  }
+  return lines
+}
+
+/**
+ * Naive diff: all deletions first, then all additions, with a single hunk header.
+ * Used as fallback when inputs are too large for LCS.
+ */
+function buildNaiveDiff(
+  header: string,
+  oldLines: string[],
+  newLines: string[]
+): string {
+  const oldStart = oldLines.length === 0 ? 0 : 1
+  const newStart = newLines.length === 0 ? 0 : 1
+  const hunkHeader = `@@ -${oldStart},${oldLines.length} +${newStart},${newLines.length} @@`
+
+  const parts = [header, hunkHeader]
+  for (const line of oldLines) parts.push(`-${line}`)
+  for (const line of newLines) parts.push(`+${line}`)
+  return parts.join("\n")
+}
+
+/**
+ * Convert DiffHunk[] into unified diff text with context lines and hunk headers.
+ *
+ * Groups nearby hunks that overlap in their context windows into a single
+ * unified hunk, producing output similar to `diff -u`.
+ */
+function buildUnifiedHunks(
+  oldLines: string[],
+  hunks: DiffHunk[],
+  contextLines: number
+): string {
+  // Build "change regions" with context, then merge overlapping ones
+  const regions = hunks.map((hunk) => ({
+    // Context-expanded range in old lines
+    ctxOldStart: Math.max(0, hunk.baseStart - contextLines),
+    ctxOldEnd: Math.min(
+      oldLines.length,
+      hunk.baseStart + hunk.baseCount + contextLines
+    ),
+    hunk,
+  }))
+
+  // Merge overlapping regions
+  const merged: {
+    ctxOldStart: number
+    ctxOldEnd: number
+    hunks: DiffHunk[]
+  }[] = []
+
+  for (const region of regions) {
+    const last = merged[merged.length - 1]
+    if (last && region.ctxOldStart <= last.ctxOldEnd) {
+      // Overlapping — extend and add hunk
+      last.ctxOldEnd = Math.max(last.ctxOldEnd, region.ctxOldEnd)
+      last.hunks.push(region.hunk)
+    } else {
+      merged.push({
+        ctxOldStart: region.ctxOldStart,
+        ctxOldEnd: region.ctxOldEnd,
+        hunks: [region.hunk],
+      })
+    }
+  }
+
+  // Render each merged region as a unified hunk
+  const output: string[] = []
+
+  for (const group of merged) {
+    const lines: string[] = []
+    let oldCursor = group.ctxOldStart
+    let newLineCount = 0
+    const oldLineCount = group.ctxOldEnd - group.ctxOldStart
+
+    for (const hunk of group.hunks) {
+      // Context lines before this change
+      while (oldCursor < hunk.baseStart) {
+        lines.push(` ${oldLines[oldCursor]}`)
+        newLineCount++
+        oldCursor++
+      }
+
+      // Deleted lines
+      for (let i = 0; i < hunk.baseCount; i++) {
+        lines.push(`-${oldLines[hunk.baseStart + i]}`)
+        oldCursor++
+      }
+
+      // Added lines
+      for (const newLine of hunk.newLines) {
+        lines.push(`+${newLine}`)
+        newLineCount++
+      }
+    }
+
+    // Trailing context
+    while (oldCursor < group.ctxOldEnd) {
+      lines.push(` ${oldLines[oldCursor]}`)
+      newLineCount++
+      oldCursor++
+    }
+
+    // Compute hunk header
+    const oldStart = oldLineCount === 0 ? 0 : group.ctxOldStart + 1
+    const newStart =
+      newLineCount === 0
+        ? 0
+        : group.ctxOldStart +
+          1 +
+          computeNewOffset(group.hunks, group.ctxOldStart)
+
+    output.push(
+      `@@ -${oldStart},${oldLineCount} +${newStart},${newLineCount} @@`
+    )
+    output.push(...lines)
+  }
+
+  return output.join("\n")
+}
+
+/**
+ * Compute the offset applied to new-line numbering by hunks before a given position.
+ */
+function computeNewOffset(hunks: DiffHunk[], beforeOldLine: number): number {
+  let offset = 0
+  for (const hunk of hunks) {
+    if (hunk.baseStart >= beforeOldLine) break
+    offset += hunk.newLines.length - hunk.baseCount
+  }
+  return offset
+}

From d5471d2ceb347e5f252449538479f28c92230e08 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 14:30:12 +0800
Subject: [PATCH 05/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=B6=88=E6=81=AF?=
 =?UTF-8?q?=E9=87=8C=E7=9A=84=E8=AF=BB/=E5=86=99=E5=B7=A5=E5=85=B7?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/claude.rs               | 75 +++++++++++++------
 src/components/diff/unified-diff-preview.tsx  |  2 +-
 .../message/content-parts-renderer.tsx        |  2 +-
 src/i18n/messages/ar.json                     |  2 +-
 src/i18n/messages/de.json                     |  2 +-
 src/i18n/messages/es.json                     |  2 +-
 src/i18n/messages/fr.json                     |  2 +-
 src/i18n/messages/ja.json                     |  2 +-
 src/i18n/messages/ko.json                     |  2 +-
 src/i18n/messages/pt.json                     |  2 +-
 src/i18n/messages/zh-TW.json                  |  2 +-
 11 files changed, 62 insertions(+), 33 deletions(-)

diff --git a/src-tauri/src/parsers/claude.rs b/src-tauri/src/parsers/claude.rs
index 2061311..fa32fc7 100644
--- a/src-tauri/src/parsers/claude.rs
+++ b/src-tauri/src/parsers/claude.rs
@@ -633,42 +633,71 @@ impl ClaudeParser {
                         })
                         .map(|s| s.to_string());
 
-                    // For read tools, structurize with start_line from tool_input.offset
-                    let output_preview =
-                        if tool_name == "read" || tool_name == "Read" {
-                            let start_line = value
-                                .get("tool_input")
-                                .and_then(|i| i.get("offset"))
-                                .and_then(|o| o.as_u64())
-                                .map(|o| o + 1)
-                                .unwrap_or(1);
-                            output_text.map(|text| {
-                                serde_json::json!({
-                                    "start_line": start_line,
-                                    "content": text
-                                })
-                                .to_string()
-                            })
-                        } else {
-                            output_text
-                        };
+                    // Don't structurize here — `structurize_read_tool_output`
+                    // will handle Read tool output uniformly after grouping.
+                    let output_preview = output_text;
+
+                    // Find the matching ToolUse by tool_name (reverse scan so the
+                    // most recent match wins), then fall back to the last ToolUse
+                    // without a paired ToolResult yet.
+                    let existing_result_ids: std::collections::HashSet<String> = messages
+                        .iter()
+                        .rev()
+                        .find(|m| matches!(m.role, MessageRole::Assistant))
+                        .map(|m| {
+                            m.content
+                                .iter()
+                                .filter_map(|b| {
+                                    if let ContentBlock::ToolResult {
+                                        tool_use_id: Some(ref id),
+                                        ..
+                                    } = b
+                                    {
+                                        Some(id.clone())
+                                    } else {
+                                        None
+                                    }
+                                })
+                                .collect()
+                        })
+                        .unwrap_or_default();
 
-                    // Find matching ToolUse in the last assistant message and use its ID
                     let matching_id = messages
                         .iter()
                         .rev()
                         .find(|m| matches!(m.role, MessageRole::Assistant))
                         .and_then(|m| {
+                            // First: try to find an unpaired ToolUse with the same tool_name
+                            let by_name = m.content.iter().rev().find_map(|b| {
+                                if let ContentBlock::ToolUse {
+                                    tool_use_id: Some(ref id),
+                                    tool_name: ref tn,
+                                    ..
+                                } = b
+                                {
+                                    if tn == tool_name
+                                        && !existing_result_ids.contains(id)
+                                    {
+                                        return Some(id.clone());
+                                    }
+                                }
+                                None
+                            });
+                            if by_name.is_some() {
+                                return by_name;
+                            }
+                            // Fallback: last unpaired ToolUse regardless of name
                             m.content.iter().rev().find_map(|b| {
                                 if let ContentBlock::ToolUse {
                                     tool_use_id: Some(ref id),
                                     ..
                                 } = b
                                 {
-                                    Some(id.clone())
-                                } else {
-                                    None
+                                    if !existing_result_ids.contains(id) {
+                                        return Some(id.clone());
+                                    }
                                 }
+                                None
                             })
                         });
 
diff --git a/src/components/diff/unified-diff-preview.tsx b/src/components/diff/unified-diff-preview.tsx
index e294489..9749e74 100644
--- a/src/components/diff/unified-diff-preview.tsx
+++ b/src/components/diff/unified-diff-preview.tsx
@@ -517,7 +517,7 @@ export function UnifiedDiffPreview({
         {files.map((file) => (
           <section
             key={file.key}
-            className="flex max-h-[480px] flex-col rounded-lg border border-border bg-background"
+            className="flex max-h-[420px] flex-col rounded-lg border border-border bg-background"
           >
             <header className="flex shrink-0 items-center gap-2 border-b border-border bg-muted/40 px-3 py-2 text-[11px]">
               <span className="shrink-0 rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground">
diff --git a/src/components/message/content-parts-renderer.tsx b/src/components/message/content-parts-renderer.tsx
index 2002ebc..6f38572 100644
--- a/src/components/message/content-parts-renderer.tsx
+++ b/src/components/message/content-parts-renderer.tsx
@@ -1321,7 +1321,7 @@ function FileToolInput({
   }, [isRead, output, content, newSource])
 
   return (
-    <section className="flex max-h-[480px] flex-col rounded-lg border border-border bg-background">
+    <section className="flex max-h-[420px] flex-col rounded-lg border border-border bg-background">
       <header className="flex shrink-0 items-center gap-2 border-b border-border bg-muted/40 px-3 py-2 text-[11px]">
         <span className="shrink-0 rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground">
           {isRead ? "READ" : "WRITE"}
diff --git a/src/i18n/messages/ar.json b/src/i18n/messages/ar.json
index 5536116..5f9298f 100644
--- a/src/i18n/messages/ar.json
+++ b/src/i18n/messages/ar.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "يتم عرض نهاية المخرجات أثناء البث لتحسين الأداء.",
         "result": "النتيجة",
         "unknown": "غير معروف",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "تم اقتطاع الإدخال — قد يكون الفرق غير مكتمل.",
         "replaceAll": "استبدال الكل",
         "filesCount": "الملفات: {count}",
         "update": "تحديث",
diff --git a/src/i18n/messages/de.json b/src/i18n/messages/de.json
index 47a3511..c6b179a 100644
--- a/src/i18n/messages/de.json
+++ b/src/i18n/messages/de.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "Zur besseren Performance wird während des Streamings nur die Endausgabe angezeigt.",
         "result": "Ergebnis",
         "unknown": "unbekannt",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "Eingabe wurde gekürzt — Diff ist möglicherweise unvollständig.",
         "replaceAll": "ALLES ERSETZEN",
         "filesCount": "Dateien: {count}",
         "update": "aktualisieren",
diff --git a/src/i18n/messages/es.json b/src/i18n/messages/es.json
index 56e75f8..3773b55 100644
--- a/src/i18n/messages/es.json
+++ b/src/i18n/messages/es.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "Mostrando la salida final durante el streaming para mejorar el rendimiento.",
         "result": "Resultado",
         "unknown": "desconocido",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "La entrada fue truncada — el diff puede estar incompleto.",
         "replaceAll": "REEMPLAZAR TODO",
         "filesCount": "Archivos: {count}",
         "update": "actualizar",
diff --git a/src/i18n/messages/fr.json b/src/i18n/messages/fr.json
index 7cda82d..b9965ef 100644
--- a/src/i18n/messages/fr.json
+++ b/src/i18n/messages/fr.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "Affichage de la fin de la sortie pendant le streaming pour de meilleures performances.",
         "result": "Résultat",
         "unknown": "inconnu",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "L'entrée a été tronquée — le diff peut être incomplet.",
         "replaceAll": "TOUT REMPLACER",
         "filesCount": "Fichiers : {count}",
         "update": "mettre à jour",
diff --git a/src/i18n/messages/ja.json b/src/i18n/messages/ja.json
index 09f00ea..4f7ea5c 100644
--- a/src/i18n/messages/ja.json
+++ b/src/i18n/messages/ja.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "パフォーマンスのため、ストリーミング中は末尾出力を表示しています。",
         "result": "結果",
         "unknown": "不明",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "入力が切り詰められました — diff が不完全な可能性があります。",
         "replaceAll": "すべて置換",
         "filesCount": "ファイル: {count}",
         "update": "更新",
diff --git a/src/i18n/messages/ko.json b/src/i18n/messages/ko.json
index e338452..f2dc1ac 100644
--- a/src/i18n/messages/ko.json
+++ b/src/i18n/messages/ko.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "성능을 위해 스트리밍 중에는 출력의 끝부분만 표시합니다.",
         "result": "결과",
         "unknown": "알 수 없음",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "입력이 잘렸습니다 — diff가 불완전할 수 있습니다.",
         "replaceAll": "모두 바꾸기",
         "filesCount": "파일: {count}",
         "update": "업데이트",
diff --git a/src/i18n/messages/pt.json b/src/i18n/messages/pt.json
index f6fe5c7..e99c42f 100644
--- a/src/i18n/messages/pt.json
+++ b/src/i18n/messages/pt.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "Mostrando a saída final durante o streaming para melhor desempenho.",
         "result": "Resultado",
         "unknown": "desconhecido",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "A entrada foi truncada — o diff pode estar incompleto.",
         "replaceAll": "SUBSTITUIR TUDO",
         "filesCount": "Arquivos: {count}",
         "update": "atualizar",
diff --git a/src/i18n/messages/zh-TW.json b/src/i18n/messages/zh-TW.json
index 270c5d7..8f3c5cc 100644
--- a/src/i18n/messages/zh-TW.json
+++ b/src/i18n/messages/zh-TW.json
@@ -1485,7 +1485,7 @@
         "showingTailOutput": "為確保效能，串流輸出時僅顯示尾端內容。",
         "result": "結果",
         "unknown": "未知",
-        "inputTruncated": "Input was truncated — diff may be incomplete.",
+        "inputTruncated": "輸入已截斷，diff 可能不完整。",
         "replaceAll": "全部替換",
         "filesCount": "檔案：{count}",
         "update": "更新",

From cb1c7211ef99876d4fa0577dab5423a6cfd3facb Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 15:07:23 +0800
Subject: [PATCH 06/16] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=8F=B3=E4=BE=A7?=
 =?UTF-8?q?=E8=BE=B9=E6=A0=8F=E2=80=9C=E5=B7=AE=E5=BC=82=E2=80=9D=E5=8C=BA?=
 =?UTF-8?q?=E5=9F=9F=E7=BB=9F=E8=AE=A1=E7=9A=84=E8=A1=8C=E6=95=B0=E4=B8=8D?=
 =?UTF-8?q?=E6=AD=A3=E7=A1=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/lib/session-files.ts | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/lib/session-files.ts b/src/lib/session-files.ts
index 1e60315..2fa8a2e 100644
--- a/src/lib/session-files.ts
+++ b/src/lib/session-files.ts
@@ -1,5 +1,6 @@
 import type { MessageTurn } from "./types"
 import { normalizeToolName } from "./tool-call-normalization"
+import { estimateChangedLineStats } from "./line-change-stats"
 import { generateUnifiedDiff } from "./unified-diff-generator"
 
 export type FileOperation = "read" | "edit" | "write" | "apply_patch"
@@ -626,8 +627,12 @@ function computeLineDiff(
             continue
           }
 
-          additions += countLines(change.newText)
-          deletions += countLines(change.oldText)
+          const estimated = estimateChangedLineStats(
+            change.oldText,
+            change.newText
+          )
+          additions += estimated.additions
+          deletions += estimated.deletions
         }
 
         return { additions, deletions }
@@ -643,10 +648,7 @@ function computeLineDiff(
 
     if (!oldStr && !newStr) return null
 
-    return {
-      additions: countLines(newStr),
-      deletions: countLines(oldStr),
-    }
+    return estimateChangedLineStats(oldStr, newStr)
   }
 
   if (op === "write") {

From c0b3e9aff99d306c4c22f96a1713359749ca5fee Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 15:46:52 +0800
Subject: [PATCH 07/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E7=BC=96=E8=BE=91?=
 =?UTF-8?q?=E5=B7=A5=E5=85=B7=E8=B0=83=E7=94=A8=E7=9A=84=E8=A1=8C=E5=8F=B7?=
 =?UTF-8?q?=E8=A7=A3=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/claude.rs               |  68 +++++-
 src-tauri/src/parsers/codex.rs                |   1 +
 src-tauri/src/parsers/gemini.rs               |   1 +
 src-tauri/src/parsers/mod.rs                  | 200 ++++++++++++++++++
 src-tauri/src/parsers/openclaw.rs             |   1 +
 src-tauri/src/parsers/opencode.rs             |   1 +
 .../message/content-parts-renderer.tsx        |  10 +
 src/lib/session-files.ts                      |  37 +++-
 8 files changed, 314 insertions(+), 5 deletions(-)

diff --git a/src-tauri/src/parsers/claude.rs b/src-tauri/src/parsers/claude.rs
index fa32fc7..0776555 100644
--- a/src-tauri/src/parsers/claude.rs
+++ b/src-tauri/src/parsers/claude.rs
@@ -53,6 +53,46 @@ fn strip_system_tags(text: &str) -> Option<String> {
 }
 
 /// Check if a JSONL entry is a system meta message (isMeta: true).
+/// Rebuild a standard unified diff from `toolUseResult.structuredPatch`.
+///
+/// Each hunk in `structuredPatch` has `oldStart`, `oldLines`, `newStart`,
+/// `newLines`, and `lines` (prefixed with ` `, `+`, or `-`).
+fn rebuild_diff_from_structured_patch(
+    file_path: &str,
+    structured_patch: &serde_json::Value,
+) -> Option<String> {
+    let hunks = structured_patch.as_array()?;
+    if hunks.is_empty() {
+        return None;
+    }
+
+    let mut output = String::new();
+    output.push_str(&format!("--- a/{}\n+++ b/{}\n", file_path, file_path));
+
+    for hunk in hunks {
+        let old_start = hunk.get("oldStart").and_then(|v| v.as_u64()).unwrap_or(1);
+        let old_lines = hunk.get("oldLines").and_then(|v| v.as_u64()).unwrap_or(0);
+        let new_start = hunk.get("newStart").and_then(|v| v.as_u64()).unwrap_or(1);
+        let new_lines = hunk.get("newLines").and_then(|v| v.as_u64()).unwrap_or(0);
+
+        output.push_str(&format!(
+            "@@ -{},{} +{},{} @@\n",
+            old_start, old_lines, new_start, new_lines
+        ));
+
+        if let Some(lines) = hunk.get("lines").and_then(|v| v.as_array()) {
+            for line in lines {
+                if let Some(text) = line.as_str() {
+                    output.push_str(text);
+                    output.push('\n');
+                }
+            }
+        }
+    }
+
+    Some(output)
+}
+
 fn is_meta_message(value: &serde_json::Value) -> bool {
     value
         .get("isMeta")
@@ -489,7 +529,7 @@ impl ClaudeParser {
                     continue;
                 }
                 "user" => {
-                    let content = extract_user_content(&value);
+                    let mut content = extract_user_content(&value);
 
                     // Skip user messages that are empty after system tag stripping
                     if content.is_empty() {
@@ -518,6 +558,31 @@ impl ClaudeParser {
                         MessageRole::User
                     };
 
+                    // Check toolUseResult.structuredPatch for real line numbers
+                    if let Some(tur) = value.get("toolUseResult") {
+                        if let Some(sp) = tur.get("structuredPatch") {
+                            let fp = tur
+                                .get("filePath")
+                                .and_then(|v| v.as_str())
+                                .unwrap_or("file");
+                            if let Some(diff) = rebuild_diff_from_structured_patch(fp, sp) {
+                                // Find the matching ToolResult in this user message's content
+                                // and replace its output_preview with the real diff
+                                for block in content.iter_mut() {
+                                    if let ContentBlock::ToolResult {
+                                        ref mut output_preview,
+                                        is_error: false,
+                                        ..
+                                    } = block
+                                    {
+                                        *output_preview = Some(diff.clone());
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
                     messages.push(UnifiedMessage {
                         id: uuid,
                         role,
@@ -738,6 +803,7 @@ impl ClaudeParser {
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
         super::structurize_read_tool_output(&mut turns);
+        super::resolve_patch_line_numbers(&mut turns, cwd.as_deref());
         let context_window_used_tokens = latest_claude_context_window_used_tokens(&turns);
         let context_window_max_tokens =
             claude_context_window_max_tokens_for_model(model.as_deref());
diff --git a/src-tauri/src/parsers/codex.rs b/src-tauri/src/parsers/codex.rs
index a71ba9d..4508f67 100644
--- a/src-tauri/src/parsers/codex.rs
+++ b/src-tauri/src/parsers/codex.rs
@@ -774,6 +774,7 @@ impl CodexParser {
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
         super::structurize_read_tool_output(&mut turns);
+        super::resolve_patch_line_numbers(&mut turns, cwd.as_deref());
         let mut session_stats = super::compute_session_stats(&turns);
         session_stats =
             merge_codex_total_usage_stats(session_stats, latest_total_usage, latest_total_tokens);
diff --git a/src-tauri/src/parsers/gemini.rs b/src-tauri/src/parsers/gemini.rs
index 9e69a87..3953816 100644
--- a/src-tauri/src/parsers/gemini.rs
+++ b/src-tauri/src/parsers/gemini.rs
@@ -557,6 +557,7 @@ impl GeminiParser {
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
         super::structurize_read_tool_output(&mut turns);
+        super::resolve_patch_line_numbers(&mut turns, summary.folder_path.as_deref());
         summary.message_count = turns.len() as u32;
         summary.id = conversation_id.to_string();
         let context_window_used_tokens = super::latest_turn_total_usage_tokens(&turns);
diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index 56f3377..318c19d 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -403,6 +403,206 @@ fn strip_numbered_lines(text: &str) -> Option<String> {
     )
 }
 
+/// Resolve line numbers for `*** Update File` / `*** Add File` style patches.
+///
+/// When a hunk header is just `@@` without `-N,M +N,M`, this reads the actual
+/// file from disk and matches the context lines to calculate real line numbers.
+/// Falls back gracefully if the file doesn't exist or context doesn't match.
+pub fn resolve_patch_line_numbers(turns: &mut [MessageTurn], cwd: Option<&str>) {
+    for turn in turns.iter_mut() {
+        for block in turn.blocks.iter_mut() {
+            if let ContentBlock::ToolUse {
+                ref tool_name,
+                ref mut input_preview,
+                ..
+            } = block
+            {
+                let name = tool_name.to_lowercase();
+                if !matches!(
+                    name.as_str(),
+                    "apply_patch" | "edit" | "patch" | "applypatch"
+                ) {
+                    continue;
+                }
+                if let Some(ref text) = input_preview {
+                    if text.contains("@@\n") || text.contains("@@\r\n") {
+                        if let Some(resolved) = resolve_patch_text(text, cwd) {
+                            *input_preview = Some(resolved);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Resolve a single patch text, replacing bare `@@` with `@@ -N,M +N,M @@`.
+fn resolve_patch_text(patch: &str, cwd: Option<&str>) -> Option<String> {
+    let mut output = String::with_capacity(patch.len() + 256);
+    let mut current_file_path: Option<String> = None;
+    let mut file_lines: Option<Vec<String>> = None;
+    let mut any_resolved = false;
+
+    let lines: Vec<&str> = patch.lines().collect();
+    let mut i = 0;
+
+    while i < lines.len() {
+        let line = lines[i];
+
+        // Detect file markers
+        if line.starts_with("*** Update File: ") || line.starts_with("*** Add File: ") {
+            let marker_end = if line.starts_with("*** Update File: ") {
+                17
+            } else {
+                14
+            };
+            let path = line[marker_end..].trim();
+            current_file_path = Some(path.to_string());
+            file_lines = load_file_lines(path, cwd);
+            output.push_str(line);
+            output.push('\n');
+            i += 1;
+            continue;
+        }
+
+        // Detect bare @@ hunk header (no line numbers)
+        if line == "@@" {
+            if let (Some(ref fl), true) = (&file_lines, current_file_path.is_some()) {
+                // Collect context lines from this hunk to find match position
+                let hunk_lines = collect_hunk_lines(&lines, i + 1);
+                if let Some((old_start, old_count, new_count)) =
+                    find_hunk_position(fl, &hunk_lines)
+                {
+                    let new_start = old_start; // same start for context-based patches
+                    output.push_str(&format!(
+                        "@@ -{},{} +{},{} @@\n",
+                        old_start, old_count, new_start, new_count
+                    ));
+                    any_resolved = true;
+                    i += 1;
+                    continue;
+                }
+            }
+            // Fallback: keep bare @@
+            output.push_str(line);
+            output.push('\n');
+            i += 1;
+            continue;
+        }
+
+        output.push_str(line);
+        output.push('\n');
+        i += 1;
+    }
+
+    if any_resolved { Some(output) } else { None }
+}
+
+/// Load file lines from disk, trying both absolute path and cwd-relative.
+fn load_file_lines(path: &str, cwd: Option<&str>) -> Option<Vec<String>> {
+    use std::fs;
+    use std::path::Path;
+
+    let p = Path::new(path);
+    if p.is_absolute() {
+        if let Ok(content) = fs::read_to_string(p) {
+            return Some(content.lines().map(|l| l.to_string()).collect());
+        }
+    }
+    if let Some(base) = cwd {
+        let full = Path::new(base).join(path);
+        if let Ok(content) = fs::read_to_string(&full) {
+            return Some(content.lines().map(|l| l.to_string()).collect());
+        }
+    }
+    None
+}
+
+/// Collect lines belonging to a hunk (until next `@@` or `*** ` marker or end).
+fn collect_hunk_lines<'a>(lines: &'a [&'a str], start: usize) -> Vec<&'a str> {
+    let mut result = Vec::new();
+    for &line in &lines[start..] {
+        if line == "@@"
+            || line.starts_with("*** ")
+        {
+            break;
+        }
+        result.push(line);
+    }
+    result
+}
+
+/// Find where a hunk's context lines match in the file, returning (start_line, old_count, new_count).
+/// `start_line` is 1-based.
+fn find_hunk_position(
+    file_lines: &[String],
+    hunk_lines: &[&str],
+) -> Option<(usize, usize, usize)> {
+    // Extract context lines (space-prefixed) with their positions in the hunk
+    let context_entries: Vec<(usize, &str)> = hunk_lines
+        .iter()
+        .enumerate()
+        .filter(|(_, l)| l.starts_with(' '))
+        .map(|(i, l)| (i, &l[1..]))  // strip leading space
+        .collect();
+
+    if context_entries.is_empty() {
+        return None;
+    }
+
+    // Use the first context line to find candidate positions
+    let (first_ctx_idx, first_ctx_text) = context_entries[0];
+
+    for (file_idx, file_line) in file_lines.iter().enumerate() {
+        if file_line.as_str() != first_ctx_text {
+            continue;
+        }
+
+        // Verify all context lines match from this position
+        let hunk_start_in_file = file_idx as isize - first_ctx_idx as isize;
+        if hunk_start_in_file < 0 {
+            continue;
+        }
+
+        let all_match = context_entries.iter().all(|(ctx_idx, ctx_text)| {
+            // Map hunk position to file position: only count context and deleted lines
+            let file_offset = hunk_lines[..*ctx_idx]
+                .iter()
+                .filter(|hl| hl.starts_with(' ') || hl.starts_with('-'))
+                .count();
+            let target = hunk_start_in_file as usize + file_offset;
+            target < file_lines.len() && file_lines[target].as_str() == *ctx_text
+        });
+
+        if all_match {
+            // Calculate old_count (context + deleted) and new_count (context + added)
+            let mut old_count = 0usize;
+            let mut new_count = 0usize;
+            for hl in hunk_lines {
+                if hl.starts_with(' ') {
+                    old_count += 1;
+                    new_count += 1;
+                } else if hl.starts_with('-') {
+                    old_count += 1;
+                } else if hl.starts_with('+') {
+                    new_count += 1;
+                }
+            }
+
+            // file_start is the first line of the old file covered by this hunk
+            // We need to find where context/deleted lines start in the file
+            let file_start_offset = hunk_lines[..first_ctx_idx]
+                .iter()
+                .filter(|hl| hl.starts_with(' ') || hl.starts_with('-'))
+                .count();
+            let start_line = (hunk_start_in_file as usize - file_start_offset) + 1; // 1-based
+            return Some((start_line, old_count, new_count));
+        }
+    }
+
+    None
+}
+
 /// Extract the last path component as the folder name.
 pub fn folder_name_from_path(path: &str) -> String {
     path.rsplit(['/', '\\']).next().unwrap_or(path).to_string()
diff --git a/src-tauri/src/parsers/openclaw.rs b/src-tauri/src/parsers/openclaw.rs
index aaf2876..c8e47a5 100644
--- a/src-tauri/src/parsers/openclaw.rs
+++ b/src-tauri/src/parsers/openclaw.rs
@@ -653,6 +653,7 @@ impl OpenClawParser {
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
         super::structurize_read_tool_output(&mut turns);
+        super::resolve_patch_line_numbers(&mut turns, cwd.as_deref());
 
         let context_window_used_tokens = latest_turn_total_usage_tokens(&turns);
         let context_window_max_tokens = session_meta
diff --git a/src-tauri/src/parsers/opencode.rs b/src-tauri/src/parsers/opencode.rs
index df799b4..c500acd 100644
--- a/src-tauri/src/parsers/opencode.rs
+++ b/src-tauri/src/parsers/opencode.rs
@@ -190,6 +190,7 @@ impl OpenCodeParser {
         let mut turns = group_into_turns(messages);
         super::relocate_orphaned_tool_results(&mut turns);
         super::structurize_read_tool_output(&mut turns);
+        super::resolve_patch_line_numbers(&mut turns, summary.folder_path.as_deref());
         let context_window_used_tokens = super::latest_turn_total_usage_tokens(&turns);
         let context_window_max_tokens =
             super::infer_context_window_max_tokens(summary.model.as_deref());
diff --git a/src/components/message/content-parts-renderer.tsx b/src/components/message/content-parts-renderer.tsx
index 6f38572..267242b 100644
--- a/src/components/message/content-parts-renderer.tsx
+++ b/src/components/message/content-parts-renderer.tsx
@@ -1755,6 +1755,16 @@ function StructuredToolInput({
         )
       }
     }
+    // Prefer tool output if it contains a structured diff with real line numbers
+    // (injected by backend from toolUseResult.structuredPatch)
+    if (output && typeof output === "string" && /^@@ /m.test(output)) {
+      return (
+        <>
+          {truncationBanner}
+          <UnifiedDiffPreview diffText={output} />
+        </>
+      )
+    }
     if (isCanonicalEditPayload(parsed)) {
       return (
         <>
diff --git a/src/lib/session-files.ts b/src/lib/session-files.ts
index 2fa8a2e..52a2bf6 100644
--- a/src/lib/session-files.ts
+++ b/src/lib/session-files.ts
@@ -1,4 +1,4 @@
-import type { MessageTurn } from "./types"
+import type { ContentBlock, MessageTurn } from "./types"
 import { normalizeToolName } from "./tool-call-normalization"
 import { estimateChangedLineStats } from "./line-change-stats"
 import { generateUnifiedDiff } from "./unified-diff-generator"
@@ -757,10 +757,12 @@ export function extractSessionFilesGrouped(
           block.input_preview,
           normalizedPath
         )
+        const toolOutput = findToolResultOutput(turn.blocks, block.tool_use_id)
         const diffChunk = buildDiffChunk(
           normalized,
           block.input_preview,
-          normalizedPath
+          normalizedPath,
+          toolOutput
         )
 
         currentFiles.push({
@@ -819,10 +821,12 @@ export function buildSessionFileDiff(
       )
       if (!blockPaths.includes(normalizedTargetPath)) continue
 
+      const toolOutput = findToolResultOutput(turn.blocks, block.tool_use_id)
       const chunk = buildDiffChunk(
         normalized,
         block.input_preview,
-        normalizedTargetPath
+        normalizedTargetPath,
+        toolOutput
       )
       if (chunk && chunk.trim().length > 0) chunks.push(chunk.trim())
     }
@@ -835,10 +839,30 @@ export function buildSessionFileDiff(
   return chunks.join("\n\n")
 }
 
+/** Find the tool_result output matching a tool_use_id within the same turn. */
+function findToolResultOutput(
+  blocks: ContentBlock[],
+  toolUseId: string | null
+): string | null {
+  if (!toolUseId) return null
+  for (const block of blocks) {
+    if (
+      block.type === "tool_result" &&
+      block.tool_use_id === toolUseId &&
+      block.output_preview &&
+      !block.is_error
+    ) {
+      return block.output_preview
+    }
+  }
+  return null
+}
+
 function buildDiffChunk(
   op: string,
   inputPreview: string | null,
-  filePath: string
+  filePath: string,
+  toolOutput?: string | null
 ): string | null {
   if (!inputPreview) return null
 
@@ -860,6 +884,11 @@ function buildDiffChunk(
       }
     }
 
+    // Prefer tool output if backend injected a real diff with line numbers
+    if (toolOutput && /^@@ /m.test(toolOutput)) {
+      return toolOutput.trim()
+    }
+
     if (!parsed) return null
 
     const oldStr =

From d2ef046e592621756eac7b340304829441ca6005 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 16:03:27 +0800
Subject: [PATCH 08/16] =?UTF-8?q?=E6=96=87=E4=BB=B6=E7=BC=96=E8=BE=91?=
 =?UTF-8?q?=E5=B7=A5=E5=85=B7=E8=A1=8C=E5=8F=B7=E8=A7=A3=E6=9E=90=E4=BC=98?=
 =?UTF-8?q?=E5=8C=96?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/mod.rs | 113 +++++++++++++++++++----------------
 1 file changed, 61 insertions(+), 52 deletions(-)

diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index 318c19d..aadf42d 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -534,72 +534,81 @@ fn collect_hunk_lines<'a>(lines: &'a [&'a str], start: usize) -> Vec<&'a str> {
 
 /// Find where a hunk's context lines match in the file, returning (start_line, old_count, new_count).
 /// `start_line` is 1-based.
+///
+/// The file on disk may be in either pre-patch or post-patch state, so we try
+/// matching with "new file" lines (context + added) first, then fall back to
+/// "old file" lines (context + deleted).
 fn find_hunk_position(
     file_lines: &[String],
     hunk_lines: &[&str],
 ) -> Option<(usize, usize, usize)> {
-    // Extract context lines (space-prefixed) with their positions in the hunk
-    let context_entries: Vec<(usize, &str)> = hunk_lines
+    let mut old_count = 0usize;
+    let mut new_count = 0usize;
+    for hl in hunk_lines {
+        if hl.starts_with(' ') {
+            old_count += 1;
+            new_count += 1;
+        } else if hl.starts_with('-') {
+            old_count += 1;
+        } else if hl.starts_with('+') {
+            new_count += 1;
+        }
+    }
+
+    // Build "new file" view: context + added lines (what the file looks like after patch)
+    let new_view: Vec<&str> = hunk_lines
         .iter()
-        .enumerate()
-        .filter(|(_, l)| l.starts_with(' '))
-        .map(|(i, l)| (i, &l[1..]))  // strip leading space
+        .filter(|l| l.starts_with(' ') || l.starts_with('+'))
+        .map(|l| &l[1..])
         .collect();
 
-    if context_entries.is_empty() {
+    // Build "old file" view: context + deleted lines (what the file looked like before patch)
+    let old_view: Vec<&str> = hunk_lines
+        .iter()
+        .filter(|l| l.starts_with(' ') || l.starts_with('-'))
+        .map(|l| &l[1..])
+        .collect();
+
+    // Try matching the new view first (file is post-patch), then old view (file is pre-patch)
+    for (view, is_new) in [(&new_view, true), (&old_view, false)] {
+        if view.is_empty() {
+            continue;
+        }
+        if let Some(pos) = find_view_in_file(file_lines, view) {
+            // `pos` is 0-based file index where the view starts.
+            // For the hunk header we want the OLD file line number.
+            // If matched on new view: adjust by the lines added before this hunk
+            //   (old_start = pos - added_lines_before ... but we don't know that)
+            //   Simpler: old_start = pos for new view match (close enough,
+            //   and matches what the user sees in the file).
+            // If matched on old view: pos is already the old start.
+            let start_line = pos + 1; // 1-based
+            let reported_count = if is_new { new_count } else { old_count };
+            return Some((start_line, reported_count, reported_count));
+        }
+    }
+
+    None
+}
+
+/// Find the position of `view` lines in `file_lines`. Returns 0-based start index.
+fn find_view_in_file(file_lines: &[String], view: &[&str]) -> Option<usize> {
+    if view.is_empty() || view.len() > file_lines.len() {
         return None;
     }
-
-    // Use the first context line to find candidate positions
-    let (first_ctx_idx, first_ctx_text) = context_entries[0];
-
-    for (file_idx, file_line) in file_lines.iter().enumerate() {
-        if file_line.as_str() != first_ctx_text {
+    let first = view[0];
+    for i in 0..=(file_lines.len() - view.len()) {
+        if file_lines[i].as_str() != first {
             continue;
         }
-
-        // Verify all context lines match from this position
-        let hunk_start_in_file = file_idx as isize - first_ctx_idx as isize;
-        if hunk_start_in_file < 0 {
-            continue;
-        }
-
-        let all_match = context_entries.iter().all(|(ctx_idx, ctx_text)| {
-            // Map hunk position to file position: only count context and deleted lines
-            let file_offset = hunk_lines[..*ctx_idx]
-                .iter()
-                .filter(|hl| hl.starts_with(' ') || hl.starts_with('-'))
-                .count();
-            let target = hunk_start_in_file as usize + file_offset;
-            target < file_lines.len() && file_lines[target].as_str() == *ctx_text
-        });
-
+        let all_match = view
+            .iter()
+            .enumerate()
+            .all(|(j, v)| file_lines[i + j].as_str() == *v);
         if all_match {
-            // Calculate old_count (context + deleted) and new_count (context + added)
-            let mut old_count = 0usize;
-            let mut new_count = 0usize;
-            for hl in hunk_lines {
-                if hl.starts_with(' ') {
-                    old_count += 1;
-                    new_count += 1;
-                } else if hl.starts_with('-') {
-                    old_count += 1;
-                } else if hl.starts_with('+') {
-                    new_count += 1;
-                }
-            }
-
-            // file_start is the first line of the old file covered by this hunk
-            // We need to find where context/deleted lines start in the file
-            let file_start_offset = hunk_lines[..first_ctx_idx]
-                .iter()
-                .filter(|hl| hl.starts_with(' ') || hl.starts_with('-'))
-                .count();
-            let start_line = (hunk_start_in_file as usize - file_start_offset) + 1; // 1-based
-            return Some((start_line, old_count, new_count));
+            return Some(i);
         }
     }
-
     None
 }
 

From 4e5f4a382cc5b0af0b77a60a46355f7032229e58 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 16:08:08 +0800
Subject: [PATCH 09/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E7=BC=96=E8=BE=91?=
 =?UTF-8?q?=E5=B7=A5=E5=85=B7=E8=B0=83=E7=94=A8=E9=87=8C=E5=A4=9Ahunk?=
 =?UTF-8?q?=E5=9C=BA=E6=99=AF=E7=9A=84=E8=A1=8C=E5=8F=B7=E8=A7=A3=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/mod.rs | 87 ++++++++++++++++++++++++------------
 1 file changed, 58 insertions(+), 29 deletions(-)

diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index aadf42d..1a38f36 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -535,9 +535,11 @@ fn collect_hunk_lines<'a>(lines: &'a [&'a str], start: usize) -> Vec<&'a str> {
 /// Find where a hunk's context lines match in the file, returning (start_line, old_count, new_count).
 /// `start_line` is 1-based.
 ///
-/// The file on disk may be in either pre-patch or post-patch state, so we try
-/// matching with "new file" lines (context + added) first, then fall back to
-/// "old file" lines (context + deleted).
+/// The file on disk may be in either pre-patch or post-patch state, and may
+/// have been further modified. We try three strategies in order:
+/// 1. Contiguous match of context+added lines (post-patch file, no further edits)
+/// 2. Contiguous match of context+deleted lines (pre-patch file)
+/// 3. Subsequence match of context-only lines (file has been further modified)
 fn find_hunk_position(
     file_lines: &[String],
     hunk_lines: &[&str],
@@ -555,44 +557,41 @@ fn find_hunk_position(
         }
     }
 
-    // Build "new file" view: context + added lines (what the file looks like after patch)
+    // Strategy 1: contiguous match of context+added (post-patch)
     let new_view: Vec<&str> = hunk_lines
         .iter()
         .filter(|l| l.starts_with(' ') || l.starts_with('+'))
         .map(|l| &l[1..])
         .collect();
+    if let Some(pos) = find_contiguous(file_lines, &new_view) {
+        return Some((pos + 1, new_count, new_count));
+    }
 
-    // Build "old file" view: context + deleted lines (what the file looked like before patch)
+    // Strategy 2: contiguous match of context+deleted (pre-patch)
     let old_view: Vec<&str> = hunk_lines
         .iter()
         .filter(|l| l.starts_with(' ') || l.starts_with('-'))
         .map(|l| &l[1..])
         .collect();
+    if let Some(pos) = find_contiguous(file_lines, &old_view) {
+        return Some((pos + 1, old_count, new_count));
+    }
 
-    // Try matching the new view first (file is post-patch), then old view (file is pre-patch)
-    for (view, is_new) in [(&new_view, true), (&old_view, false)] {
-        if view.is_empty() {
-            continue;
-        }
-        if let Some(pos) = find_view_in_file(file_lines, view) {
-            // `pos` is 0-based file index where the view starts.
-            // For the hunk header we want the OLD file line number.
-            // If matched on new view: adjust by the lines added before this hunk
-            //   (old_start = pos - added_lines_before ... but we don't know that)
-            //   Simpler: old_start = pos for new view match (close enough,
-            //   and matches what the user sees in the file).
-            // If matched on old view: pos is already the old start.
-            let start_line = pos + 1; // 1-based
-            let reported_count = if is_new { new_count } else { old_count };
-            return Some((start_line, reported_count, reported_count));
-        }
+    // Strategy 3: subsequence match of context-only lines (file further modified)
+    let ctx_only: Vec<&str> = hunk_lines
+        .iter()
+        .filter(|l| l.starts_with(' '))
+        .map(|l| &l[1..])
+        .collect();
+    if let Some(pos) = find_subsequence(file_lines, &ctx_only) {
+        return Some((pos + 1, old_count, new_count));
     }
 
     None
 }
 
-/// Find the position of `view` lines in `file_lines`. Returns 0-based start index.
-fn find_view_in_file(file_lines: &[String], view: &[&str]) -> Option<usize> {
+/// Find contiguous `view` lines in `file_lines`. Returns 0-based start index.
+fn find_contiguous(file_lines: &[String], view: &[&str]) -> Option<usize> {
     if view.is_empty() || view.len() > file_lines.len() {
         return None;
     }
@@ -601,17 +600,47 @@ fn find_view_in_file(file_lines: &[String], view: &[&str]) -> Option<usize> {
         if file_lines[i].as_str() != first {
             continue;
         }
-        let all_match = view
-            .iter()
-            .enumerate()
-            .all(|(j, v)| file_lines[i + j].as_str() == *v);
-        if all_match {
+        if view.iter().enumerate().all(|(j, v)| file_lines[i + j].as_str() == *v) {
             return Some(i);
         }
     }
     None
 }
 
+/// Find `needles` as an ordered subsequence in `file_lines` within a small window.
+/// Returns 0-based index of the first needle's position.
+fn find_subsequence(file_lines: &[String], needles: &[&str]) -> Option<usize> {
+    if needles.is_empty() {
+        return None;
+    }
+    let first = needles[0];
+    for start in 0..file_lines.len() {
+        if file_lines[start].as_str() != first {
+            continue;
+        }
+        let mut cursor = start + 1;
+        let mut all_found = true;
+        for &needle in &needles[1..] {
+            // Allow up to 10 lines gap between consecutive context lines
+            let limit = std::cmp::min(cursor + 10, file_lines.len());
+            match file_lines[cursor..limit]
+                .iter()
+                .position(|fl| fl.as_str() == needle)
+            {
+                Some(offset) => cursor = cursor + offset + 1,
+                None => {
+                    all_found = false;
+                    break;
+                }
+            }
+        }
+        if all_found {
+            return Some(start);
+        }
+    }
+    None
+}
+
 /// Extract the last path component as the folder name.
 pub fn folder_name_from_path(path: &str) -> String {
     path.rsplit(['/', '\\']).next().unwrap_or(path).to_string()

From 75139a12260751e1721ab46943df2415d4d0174f Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 16:17:21 +0800
Subject: [PATCH 10/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E7=BC=96=E8=BE=91=E5=B7=A5=E5=85=B7=E9=87=8C=E5=A4=9Ahunk?=
 =?UTF-8?q?=E7=9A=84=E6=98=BE=E7=A4=BA=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/components/diff/unified-diff-preview.tsx | 25 ++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/src/components/diff/unified-diff-preview.tsx b/src/components/diff/unified-diff-preview.tsx
index 9749e74..f25113e 100644
--- a/src/components/diff/unified-diff-preview.tsx
+++ b/src/components/diff/unified-diff-preview.tsx
@@ -446,9 +446,21 @@ function rowMarker(row: ParsedDiffRow): RowMarker {
   return "none"
 }
 
+function HunkSeparator({ hunk }: { hunk: ParsedDiffHunk }) {
+  const label =
+    hunk.oldStart != null && hunk.oldCount != null
+      ? `@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart ?? hunk.oldStart},${hunk.newCount ?? hunk.oldCount} @@`
+      : "···"
+  return (
+    <div className="flex items-center gap-2 border-y border-border/50 bg-muted/30 px-3 py-0.5 font-mono text-[11px] text-muted-foreground/60">
+      <span className="select-none">{label}</span>
+    </div>
+  )
+}
+
 function HunkLines({ rows }: { rows: ParsedDiffRow[] }) {
   return (
-    <div className="inline-block min-w-full font-mono text-[12px] leading-[20px]">
+    <div className="font-mono text-[12px] leading-[20px]">
       {rows.map((row, i) => {
         const marker = rowMarker(row)
         return (
@@ -540,9 +552,14 @@ export function UnifiedDiffPreview({
             </header>
 
             <div className="overflow-auto">
-              {file.hunks.map((hunk) => (
-                <HunkLines key={hunk.key} rows={hunk.rows} />
-              ))}
+              <div className="inline-block min-w-full">
+                {file.hunks.map((hunk, hunkIdx) => (
+                  <div key={hunk.key}>
+                    {hunkIdx > 0 && <HunkSeparator hunk={hunk} />}
+                    <HunkLines rows={hunk.rows} />
+                  </div>
+                ))}
+              </div>
             </div>
           </section>
         ))}

From 0ab9d46b634b4e3bde31f321b18b22fe692794c0 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 17:13:29 +0800
Subject: [PATCH 11/16] =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=AE=9E=E6=97=B6?=
 =?UTF-8?q?=E5=93=8D=E5=BA=94=E6=97=B6=E8=A7=A3=E6=9E=90=E7=BC=96=E8=BE=91?=
 =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=9A=84=E4=BB=A3=E7=A0=81=E8=A1=8C=E5=8F=B7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/acp/connection.rs               | 66 +++++++++++++++++--
 src-tauri/src/parsers/mod.rs                  |  4 +-
 .../message/content-parts-renderer.tsx        | 15 ++++-
 src/lib/session-files.ts                      | 10 ++-
 4 files changed, 84 insertions(+), 11 deletions(-)

diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 7155ac1..da30f58 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -689,7 +689,7 @@ async fn run_connection(
                                             notif.update,
                                             SessionUpdate::AvailableCommandsUpdate(_)
                                         ) {
-                                            emit_conversation_update(&cid, &h, notif.update);
+                                            emit_conversation_update(&cid, &h, notif.update, None);
                                         }
                                         Ok(())
                                     })
@@ -1428,10 +1428,11 @@ async fn run_conversation_loop<'a>(
                         Ok(SessionMessage::SessionMessage(dispatch)) => {
                             let cid = conn_id.to_string();
                             let h = handle.clone();
+                            let cwd_opt = Some(cwd);
                             let _ = MatchDispatch::new(dispatch)
                                 .if_notification(
                                     async |notif: SessionNotification| {
-                                        emit_conversation_update(&cid, &h, notif.update);
+                                        emit_conversation_update(&cid, &h, notif.update, cwd_opt);
                                         Ok(())
                                     },
                                 )
@@ -1511,6 +1512,7 @@ async fn run_conversation_loop<'a>(
                                     let h = handle.clone();
                                     let runtime = terminal_runtime.clone();
                                     let session_id = sid.clone();
+                                    let cwd_opt = Some(cwd);
                                     if let Err(e) = MatchDispatch::new(dispatch)
                                         .if_notification(
                                             async |notif: SessionNotification| {
@@ -1518,7 +1520,7 @@ async fn run_conversation_loop<'a>(
                                                     &notif.update,
                                                     &mut tracked_terminal_tool_calls,
                                                 );
-                                                emit_conversation_update(&cid, &h, notif.update);
+                                                emit_conversation_update(&cid, &h, notif.update, cwd_opt);
                                                 if should_poll_now {
                                                     poll_tracked_terminal_tool_calls(
                                                         runtime.as_ref(),
@@ -1885,6 +1887,57 @@ fn serialize_tool_call_content(content: &[ToolCallContent]) -> Option<String> {
     }
 }
 
+/// Resolve line numbers for live tool call input.
+///
+/// - For apply_patch with bare `@@`: resolve line numbers in place.
+/// - For canonical edit JSON (file_path + old_string + new_string):
+///   read the file, find where old_string starts, and inject `_start_line`
+///   into the JSON so the frontend can generate a diff with real line numbers.
+fn resolve_live_tool_input(text: &str, cwd: Option<&str>) -> String {
+    // Apply-patch format: resolve bare @@ in input
+    if text.contains("@@\n") || text.contains("@@\r\n") {
+        if let Some(resolved) = crate::parsers::resolve_patch_text(text, cwd) {
+            return resolved;
+        }
+    }
+
+    // Canonical edit JSON: inject _start_line
+    if let Ok(mut parsed) = serde_json::from_str::<serde_json::Value>(text) {
+        let file_path = parsed
+            .get("file_path")
+            .or_else(|| parsed.get("path"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        let old_string = parsed
+            .get("old_string")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        if let (Some(fp), Some(old_str)) = (file_path, old_string) {
+            if let Some(start_line) = find_string_start_line(&fp, &old_str, cwd) {
+                parsed
+                    .as_object_mut()
+                    .unwrap()
+                    .insert("_start_line".to_string(), serde_json::json!(start_line));
+                return parsed.to_string();
+            }
+        }
+    }
+
+    text.to_string()
+}
+
+/// Find the 1-based start line of `needle` in the file at `path`.
+fn find_string_start_line(path: &str, needle: &str, cwd: Option<&str>) -> Option<u64> {
+    if needle.is_empty() {
+        return None;
+    }
+    let file_lines = crate::parsers::load_file_lines(path, cwd)?;
+    let file_content = file_lines.join("\n");
+    let byte_offset = file_content.find(needle)?;
+    Some(file_content[..byte_offset].matches('\n').count() as u64 + 1)
+}
+
 fn json_value_to_text(val: &Option<serde_json::Value>) -> Option<String> {
     match val {
         Some(serde_json::Value::String(text)) => Some(text.clone()),
@@ -1929,6 +1982,7 @@ fn emit_conversation_update(
     connection_id: &str,
     app_handle: &tauri::AppHandle,
     update: SessionUpdate,
+    cwd: Option<&str>,
 ) {
     match update {
         SessionUpdate::UserMessageChunk(_) => {
@@ -1969,7 +2023,8 @@ fn emit_conversation_update(
         }
         SessionUpdate::ToolCall(tc) => {
             let content = serialize_tool_call_content(&tc.content);
-            let raw_input = json_value_to_text(&tc.raw_input);
+            let raw_input = json_value_to_text(&tc.raw_input)
+                .map(|text| resolve_live_tool_input(&text, cwd));
             let raw_output = json_value_to_text(&tc.raw_output);
             crate::web::event_bridge::emit_event(
                 app_handle,
@@ -1992,7 +2047,8 @@ fn emit_conversation_update(
                 .content
                 .as_deref()
                 .and_then(serialize_tool_call_content);
-            let raw_input = json_value_to_text(&tcu.fields.raw_input);
+            let raw_input = json_value_to_text(&tcu.fields.raw_input)
+                .map(|text| resolve_live_tool_input(&text, cwd));
             let raw_output = json_value_to_text(&tcu.fields.raw_output);
             crate::web::event_bridge::emit_event(
                 app_handle,
diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index 1a38f36..6b0dac5 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -437,7 +437,7 @@ pub fn resolve_patch_line_numbers(turns: &mut [MessageTurn], cwd: Option<&str>)
 }
 
 /// Resolve a single patch text, replacing bare `@@` with `@@ -N,M +N,M @@`.
-fn resolve_patch_text(patch: &str, cwd: Option<&str>) -> Option<String> {
+pub fn resolve_patch_text(patch: &str, cwd: Option<&str>) -> Option<String> {
     let mut output = String::with_capacity(patch.len() + 256);
     let mut current_file_path: Option<String> = None;
     let mut file_lines: Option<Vec<String>> = None;
@@ -499,7 +499,7 @@ fn resolve_patch_text(patch: &str, cwd: Option<&str>) -> Option<String> {
 }
 
 /// Load file lines from disk, trying both absolute path and cwd-relative.
-fn load_file_lines(path: &str, cwd: Option<&str>) -> Option<Vec<String>> {
+pub fn load_file_lines(path: &str, cwd: Option<&str>) -> Option<Vec<String>> {
     use std::fs;
     use std::path::Path;
 
diff --git a/src/components/message/content-parts-renderer.tsx b/src/components/message/content-parts-renderer.tsx
index 267242b..f96908c 100644
--- a/src/components/message/content-parts-renderer.tsx
+++ b/src/components/message/content-parts-renderer.tsx
@@ -1163,12 +1163,21 @@ function EditToolInput({ input }: { input: Record<string, unknown> }) {
   const filePath = str(input, "file_path")
   const oldString = str(input, "old_string") ?? ""
   const newString = str(input, "new_string") ?? ""
+  const startLine = num(input, "_start_line")
 
   const diffCode = useMemo(() => {
-    return (
-      generateUnifiedDiff(oldString, newString, filePath ?? undefined) ?? ""
+    const diff = generateUnifiedDiff(
+      oldString,
+      newString,
+      filePath ?? undefined
     )
-  }, [oldString, newString, filePath])
+    if (!diff || !startLine || startLine <= 1) return diff ?? ""
+    // Replace line numbers in hunk headers with real start line
+    return diff.replace(
+      /^@@ -(\d+),(\d+) \+(\d+),(\d+) @@/gm,
+      (_, _o, oc, _n, nc) => `@@ -${startLine},${oc} +${startLine},${nc} @@`
+    )
+  }, [oldString, newString, filePath, startLine])
 
   return diffCode ? <UnifiedDiffPreview diffText={diffCode} /> : null
 }
diff --git a/src/lib/session-files.ts b/src/lib/session-files.ts
index 52a2bf6..13afff6 100644
--- a/src/lib/session-files.ts
+++ b/src/lib/session-files.ts
@@ -896,7 +896,15 @@ function buildDiffChunk(
     const newStr =
       typeof parsed.new_string === "string" ? parsed.new_string : ""
 
-    return buildUnifiedDiff(filePath, oldStr, newStr)
+    const diff = buildUnifiedDiff(filePath, oldStr, newStr)
+    if (!diff) return null
+    const startLine =
+      typeof parsed._start_line === "number" ? parsed._start_line : 0
+    if (startLine <= 1) return diff
+    return diff.replace(
+      /^@@ -(\d+),(\d+) \+(\d+),(\d+) @@/gm,
+      (_, _o, oc, _n, nc) => `@@ -${startLine},${oc} +${startLine},${nc} @@`
+    )
   }
 
   if (op === "write") {

From 4ea8954535a36a576920fce328d62b180fc252ed Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 17:22:21 +0800
Subject: [PATCH 12/16] =?UTF-8?q?=E6=94=AF=E6=8C=81=E5=AE=9E=E6=97=B6?=
 =?UTF-8?q?=E5=93=8D=E5=BA=94=E6=97=B6=E8=A7=A3=E6=9E=90=E8=AF=BB=E5=8F=96?=
 =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=9A=84=E4=BB=A3=E7=A0=81=E8=A1=8C=E5=8F=B7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/acp/connection.rs | 15 +++++++++++++--
 src-tauri/src/parsers/mod.rs    |  2 +-
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index da30f58..1528c6a 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -1887,6 +1887,15 @@ fn serialize_tool_call_content(content: &[ToolCallContent]) -> Option<String> {
     }
 }
 
+/// If the output looks like numbered lines (`   115→content`), strip them
+/// and return `{"start_line":N,"content":"..."}` — same as the historical path.
+fn structurize_live_output(text: &str) -> String {
+    if let Some(json) = crate::parsers::strip_numbered_lines(text) {
+        return json;
+    }
+    text.to_string()
+}
+
 /// Resolve line numbers for live tool call input.
 ///
 /// - For apply_patch with bare `@@`: resolve line numbers in place.
@@ -2025,7 +2034,8 @@ fn emit_conversation_update(
             let content = serialize_tool_call_content(&tc.content);
             let raw_input = json_value_to_text(&tc.raw_input)
                 .map(|text| resolve_live_tool_input(&text, cwd));
-            let raw_output = json_value_to_text(&tc.raw_output);
+            let raw_output = json_value_to_text(&tc.raw_output)
+                .map(|text| structurize_live_output(&text));
             crate::web::event_bridge::emit_event(
                 app_handle,
                 "acp://event",
@@ -2049,7 +2059,8 @@ fn emit_conversation_update(
                 .and_then(serialize_tool_call_content);
             let raw_input = json_value_to_text(&tcu.fields.raw_input)
                 .map(|text| resolve_live_tool_input(&text, cwd));
-            let raw_output = json_value_to_text(&tcu.fields.raw_output);
+            let raw_output = json_value_to_text(&tcu.fields.raw_output)
+                .map(|text| structurize_live_output(&text));
             crate::web::event_bridge::emit_event(
                 app_handle,
                 "acp://event",
diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index 6b0dac5..a01ac55 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -362,7 +362,7 @@ fn split_line_number(line: &str) -> Option<(u64, &str)> {
 
 /// If most lines have a recognized line-number prefix, strip them all
 /// and return `{"start_line":N,"content":"clean text"}`.
-fn strip_numbered_lines(text: &str) -> Option<String> {
+pub fn strip_numbered_lines(text: &str) -> Option<String> {
     let raw_lines: Vec<&str> = text.lines().collect();
     if raw_lines.len() < 2 {
         return None;

From 622d8c90bdccd12e9c6e18d8b9de4ae5e0301d88 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 17:41:19 +0800
Subject: [PATCH 13/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=B6=88=E6=81=AF?=
 =?UTF-8?q?=E9=87=8C=E7=BC=96=E8=BE=91=E5=B7=A5=E5=85=B7=E4=BB=A3=E7=A0=81?=
 =?UTF-8?q?=E8=A1=8C=E5=8F=B7diff=E8=AE=A1=E7=AE=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/parsers/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src-tauri/src/parsers/mod.rs b/src-tauri/src/parsers/mod.rs
index a01ac55..4eecef4 100644
--- a/src-tauri/src/parsers/mod.rs
+++ b/src-tauri/src/parsers/mod.rs
@@ -564,7 +564,7 @@ fn find_hunk_position(
         .map(|l| &l[1..])
         .collect();
     if let Some(pos) = find_contiguous(file_lines, &new_view) {
-        return Some((pos + 1, new_count, new_count));
+        return Some((pos + 1, old_count, new_count));
     }
 
     // Strategy 2: contiguous match of context+deleted (pre-patch)

From a049db51e2936709f118eeb00fcac00036b9750c Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 18:10:20 +0800
Subject: [PATCH 14/16] =?UTF-8?q?=E4=BC=98=E5=8C=96agent=E8=AF=B7=E6=B1=82?=
 =?UTF-8?q?=E6=96=87=E4=BB=B6=E4=BF=AE=E6=94=B9=E6=9D=83=E9=99=90=E6=97=B6?=
 =?UTF-8?q?=E7=9A=84=E6=96=87=E4=BB=B6=E5=B7=AE=E5=BC=82=E6=98=BE=E7=A4=BA?=
 =?UTF-8?q?=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/acp/connection.rs           | 35 ++++++++++++++++++++--
 src/components/chat/permission-dialog.tsx | 36 ++---------------------
 src/lib/permission-request.ts             | 10 ++++++-
 3 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 1528c6a..1af295d 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -514,10 +514,11 @@ async fn run_connection(
                 let conn_id = conn_id.clone();
                 let handle = handle.clone();
                 let perms = perms.clone();
+                let perm_cwd = cwd_string.clone();
                 async move |req: RequestPermissionRequest,
                             responder: Responder<RequestPermissionResponse>,
                             _cx: ConnectionTo<Agent>| {
-                    handle_permission_request(&conn_id, &handle, &perms, req, responder).await;
+                    handle_permission_request(&conn_id, &handle, &perms, &perm_cwd, req, responder).await;
                     Ok(())
                 }
             },
@@ -861,6 +862,7 @@ async fn handle_permission_request(
     conn_id: &str,
     handle: &tauri::AppHandle,
     perms: &PendingPermissions,
+    cwd: &str,
     req: RequestPermissionRequest,
     responder: Responder<RequestPermissionResponse>,
 ) {
@@ -882,7 +884,36 @@ async fn handle_permission_request(
         })
         .collect();
 
-    let tool_call_value = serde_json::to_value(&req.tool_call).unwrap_or_default();
+    let mut tool_call_value = serde_json::to_value(&req.tool_call).unwrap_or_default();
+
+    // Resolve line numbers in rawInput for edit tool permission requests
+    if let Some(obj) = tool_call_value.as_object_mut() {
+        let raw_input_key = if obj.contains_key("rawInput") {
+            Some("rawInput")
+        } else if obj.contains_key("raw_input") {
+            Some("raw_input")
+        } else {
+            None
+        };
+        if let Some(key) = raw_input_key {
+            if let Some(input_val) = obj.get(key).cloned() {
+                let input_text = match &input_val {
+                    serde_json::Value::String(s) => Some(s.clone()),
+                    v if !v.is_null() => Some(v.to_string()),
+                    _ => None,
+                };
+                if let Some(text) = input_text {
+                    let resolved = resolve_live_tool_input(&text, Some(cwd));
+                    if resolved != text {
+                        obj.insert(
+                            key.to_string(),
+                            serde_json::Value::String(resolved),
+                        );
+                    }
+                }
+            }
+        }
+    }
 
     perms.lock().await.insert(request_id.clone(), responder);
 
diff --git a/src/components/chat/permission-dialog.tsx b/src/components/chat/permission-dialog.tsx
index 8dd3bdc..f204780 100644
--- a/src/components/chat/permission-dialog.tsx
+++ b/src/components/chat/permission-dialog.tsx
@@ -5,7 +5,6 @@ import { useTranslations } from "next-intl"
 import {
   ShieldAlert,
   Terminal,
-  FilePenLine,
   ListTodo,
   Compass,
   FileText,
@@ -15,6 +14,7 @@ import {
 import { Button } from "@/components/ui/button"
 import { Badge } from "@/components/ui/badge"
 import { CodeBlock } from "@/components/ai-elements/code-block"
+import { UnifiedDiffPreview } from "@/components/diff/unified-diff-preview"
 import { MessageResponse } from "@/components/ai-elements/message"
 import type { PendingPermission } from "@/contexts/acp-connections-context"
 import { parsePermissionToolCall } from "@/lib/permission-request"
@@ -86,38 +86,8 @@ export function PermissionDialog({
           </div>
         )}
 
-        {hasFileChanges && (
-          <div className="space-y-1.5 rounded-md border border-border/60 bg-muted/20 p-2">
-            <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
-              <FilePenLine className="h-3.5 w-3.5" />
-              <span>
-                {t("filesSummary", { count: parsed.fileChanges.length })}
-              </span>
-              {(parsed.additions > 0 || parsed.deletions > 0) && (
-                <span>
-                  +{parsed.additions} / -{parsed.deletions}
-                </span>
-              )}
-            </div>
-            <div className="space-y-1 rounded-md bg-muted/40 p-2">
-              {parsed.fileChanges.slice(0, 8).map((change, index) => (
-                <div
-                  key={`${change.path}-${index}`}
-                  className="break-all font-mono text-xs text-foreground/90"
-                >
-                  {change.path}
-                </div>
-              ))}
-              {parsed.fileChanges.length > 8 && (
-                <div className="text-xs text-muted-foreground">
-                  {t("moreFiles", { count: parsed.fileChanges.length - 8 })}
-                </div>
-              )}
-            </div>
-            {parsed.diffPreview && (
-              <CodeBlock code={parsed.diffPreview} language="diff" />
-            )}
-          </div>
+        {hasFileChanges && parsed.diffPreview && (
+          <UnifiedDiffPreview diffText={parsed.diffPreview} />
         )}
 
         {hasPlan && (
diff --git a/src/lib/permission-request.ts b/src/lib/permission-request.ts
index d98f055..bc302b0 100644
--- a/src/lib/permission-request.ts
+++ b/src/lib/permission-request.ts
@@ -145,7 +145,15 @@ function buildCompactDiffFromTexts(
     Math.min(oldLines.length, oldLines.length - suffix + contextLines)
   )
 
-  const parts: string[] = [`--- ${path}`, `+++ ${path}`]
+  const oldStart = Math.max(1, prefix - before.length + 1)
+  const oldCount = before.length + removed.length + after.length
+  const newCount = before.length + added.length + after.length
+
+  const parts: string[] = [
+    `--- ${path}`,
+    `+++ ${path}`,
+    `@@ -${oldStart},${oldCount} +${oldStart},${newCount} @@`,
+  ]
   for (const line of before) parts.push(` ${line}`)
   for (const line of removed) parts.push(`-${line}`)
   for (const line of added) parts.push(`+${line}`)

From ab8a93676720014d6be7828b7305ac3f466bf025 Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 18:47:00 +0800
Subject: [PATCH 15/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E7=BC=96=E8=BE=91=E6=9D=83=E9=99=90=E8=AF=B7=E6=B1=82=E7=9A=84?=
 =?UTF-8?q?=E5=B7=AE=E5=BC=82=E6=A0=B7=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/acp/connection.rs | 75 ++++++++++++++++++++++++---------
 src/lib/permission-request.ts   | 26 ++++++++++--
 2 files changed, 76 insertions(+), 25 deletions(-)

diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 1af295d..20114b3 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -886,32 +886,65 @@ async fn handle_permission_request(
 
     let mut tool_call_value = serde_json::to_value(&req.tool_call).unwrap_or_default();
 
-    // Resolve line numbers in rawInput for edit tool permission requests
+    // Inject _start_line into rawInput object for edit tool permission requests
     if let Some(obj) = tool_call_value.as_object_mut() {
-        let raw_input_key = if obj.contains_key("rawInput") {
-            Some("rawInput")
-        } else if obj.contains_key("raw_input") {
-            Some("raw_input")
-        } else {
-            None
-        };
-        if let Some(key) = raw_input_key {
-            if let Some(input_val) = obj.get(key).cloned() {
-                let input_text = match &input_val {
-                    serde_json::Value::String(s) => Some(s.clone()),
-                    v if !v.is_null() => Some(v.to_string()),
-                    _ => None,
-                };
-                if let Some(text) = input_text {
-                    let resolved = resolve_live_tool_input(&text, Some(cwd));
-                    if resolved != text {
-                        obj.insert(
-                            key.to_string(),
-                            serde_json::Value::String(resolved),
+        let key = ["rawInput", "raw_input"]
+            .into_iter()
+            .find(|k| obj.contains_key(*k));
+        if let Some(key) = key {
+            // If rawInput is an object with file_path + old_string, inject _start_line directly
+            if let Some(input_obj) = obj.get_mut(key).and_then(|v| v.as_object_mut()) {
+                let file_path = input_obj
+                    .get("file_path")
+                    .or_else(|| input_obj.get("path"))
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string());
+                let old_string = input_obj
+                    .get("old_string")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string());
+                if let (Some(fp), Some(old_str)) = (file_path, old_string) {
+                    if let Some(sl) = find_string_start_line(&fp, &old_str, Some(cwd)) {
+                        input_obj.insert(
+                            "_start_line".to_string(),
+                            serde_json::json!(sl),
                         );
                     }
                 }
             }
+            // If rawInput is a string, parse it and try to inject _start_line or resolve @@
+            else if let Some(serde_json::Value::String(text)) = obj.get(key).cloned() {
+                // Try canonical edit JSON: parse, inject _start_line, write back as object
+                if let Ok(mut parsed) = serde_json::from_str::<serde_json::Value>(&text) {
+                    if let Some(input_obj) = parsed.as_object_mut() {
+                        let fp = input_obj
+                            .get("file_path")
+                            .or_else(|| input_obj.get("path"))
+                            .and_then(|v| v.as_str())
+                            .map(|s| s.to_string());
+                        let old_str = input_obj
+                            .get("old_string")
+                            .and_then(|v| v.as_str())
+                            .map(|s| s.to_string());
+                        if let (Some(fp), Some(old_str)) = (fp, old_str) {
+                            if let Some(sl) = find_string_start_line(&fp, &old_str, Some(cwd)) {
+                                input_obj.insert(
+                                    "_start_line".to_string(),
+                                    serde_json::json!(sl),
+                                );
+                                // Write back as object so frontend asObject() works directly
+                                obj.insert(key.to_string(), parsed);
+                            }
+                        }
+                    }
+                }
+                // Apply_patch format: resolve bare @@
+                else if text.contains("@@\n") || text.contains("@@\r\n") {
+                    if let Some(resolved) = crate::parsers::resolve_patch_text(&text, Some(cwd)) {
+                        obj.insert(key.to_string(), serde_json::Value::String(resolved));
+                    }
+                }
+            }
         }
     }
 
diff --git a/src/lib/permission-request.ts b/src/lib/permission-request.ts
index bc302b0..186b976 100644
--- a/src/lib/permission-request.ts
+++ b/src/lib/permission-request.ts
@@ -12,6 +12,7 @@ export interface PermissionFileChange {
   oldText: string
   newText: string
   unifiedDiff?: string
+  startLine?: number
 }
 
 export interface PermissionPlanEntry {
@@ -111,7 +112,8 @@ function buildCompactDiffFromTexts(
   path: string,
   oldText: string,
   newText: string,
-  contextLines: number = 2
+  contextLines: number = 2,
+  startLine: number = 1
 ): string | null {
   const oldLines = splitNormalizedLines(oldText)
   const newLines = splitNormalizedLines(newText)
@@ -145,7 +147,7 @@ function buildCompactDiffFromTexts(
     Math.min(oldLines.length, oldLines.length - suffix + contextLines)
   )
 
-  const oldStart = Math.max(1, prefix - before.length + 1)
+  const oldStart = Math.max(1, startLine + prefix - before.length)
   const oldCount = before.length + removed.length + after.length
   const newCount = before.length + added.length + after.length
 
@@ -197,7 +199,13 @@ function buildDiffPreviewFromChanges(
       typeof change.unifiedDiff === "string" &&
       change.unifiedDiff.trim().length > 0
         ? change.unifiedDiff.trim()
-        : buildCompactDiffFromTexts(change.path, change.oldText, change.newText)
+        : buildCompactDiffFromTexts(
+            change.path,
+            change.oldText,
+            change.newText,
+            2,
+            change.startLine ?? 1
+          )
     if (!block) continue
 
     for (const line of block.split("\n")) {
@@ -358,11 +366,18 @@ function parseChangeRecord(
     pickString(record, ["unifiedDiff", "unified_diff", "diff", "patch"]) ??
     undefined
 
+  const rawStartLine = record._start_line ?? record.start_line
+  const startLine =
+    typeof rawStartLine === "number" && rawStartLine > 0
+      ? rawStartLine
+      : undefined
+
   return {
     path: normalizedPath,
     oldText,
     newText,
     unifiedDiff,
+    startLine,
   }
 }
 
@@ -410,11 +425,13 @@ function extractRawInputFileChanges(
       ]) ?? ""
 
     if (oldText || newText || changes.length === 0) {
+      const rawSl = rawInputObj._start_line ?? rawInputObj.start_line
       changes.push({
         path: directPath,
         oldText,
         newText,
         unifiedDiff: undefined,
+        startLine: typeof rawSl === "number" && rawSl > 0 ? rawSl : undefined,
       })
     }
   }
@@ -503,7 +520,8 @@ function mergeFileChanges(
     const oldText = prev.oldText || change.oldText
     const newText = prev.newText || change.newText
     const unifiedDiff = prev.unifiedDiff || change.unifiedDiff
-    merged.set(path, { path, oldText, newText, unifiedDiff })
+    const startLine = prev.startLine ?? change.startLine
+    merged.set(path, { path, oldText, newText, unifiedDiff, startLine })
   }
   return Array.from(merged.values())
 }

From 829e8cd126138344e3b79f8570728bee2b85a21d Mon Sep 17 00:00:00 2001
From: xintaofei <xintaofei@users.noreply.github.com>
Date: Sat, 28 Mar 2026 18:52:18 +0800
Subject: [PATCH 16/16] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E5=B7=AE=E5=BC=82=E7=9A=84=E8=A1=8C=E6=95=B0=E8=AE=A1=E7=AE=97?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/acp/connection.rs | 122 +++++++++++++-------------------
 1 file changed, 48 insertions(+), 74 deletions(-)

diff --git a/src-tauri/src/acp/connection.rs b/src-tauri/src/acp/connection.rs
index 20114b3..079ae1f 100644
--- a/src-tauri/src/acp/connection.rs
+++ b/src-tauri/src/acp/connection.rs
@@ -886,64 +886,33 @@ async fn handle_permission_request(
 
     let mut tool_call_value = serde_json::to_value(&req.tool_call).unwrap_or_default();
 
-    // Inject _start_line into rawInput object for edit tool permission requests
+    // Resolve line numbers in rawInput for edit tool permission requests
     if let Some(obj) = tool_call_value.as_object_mut() {
         let key = ["rawInput", "raw_input"]
             .into_iter()
             .find(|k| obj.contains_key(*k));
         if let Some(key) = key {
-            // If rawInput is an object with file_path + old_string, inject _start_line directly
-            if let Some(input_obj) = obj.get_mut(key).and_then(|v| v.as_object_mut()) {
-                let file_path = input_obj
-                    .get("file_path")
-                    .or_else(|| input_obj.get("path"))
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string());
-                let old_string = input_obj
-                    .get("old_string")
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string());
-                if let (Some(fp), Some(old_str)) = (file_path, old_string) {
-                    if let Some(sl) = find_string_start_line(&fp, &old_str, Some(cwd)) {
-                        input_obj.insert(
-                            "_start_line".to_string(),
-                            serde_json::json!(sl),
-                        );
-                    }
+            match obj.get_mut(key) {
+                // rawInput is a JSON object: inject _start_line in place
+                Some(v) if v.is_object() => {
+                    inject_start_line(v, Some(cwd));
                 }
-            }
-            // If rawInput is a string, parse it and try to inject _start_line or resolve @@
-            else if let Some(serde_json::Value::String(text)) = obj.get(key).cloned() {
-                // Try canonical edit JSON: parse, inject _start_line, write back as object
-                if let Ok(mut parsed) = serde_json::from_str::<serde_json::Value>(&text) {
-                    if let Some(input_obj) = parsed.as_object_mut() {
-                        let fp = input_obj
-                            .get("file_path")
-                            .or_else(|| input_obj.get("path"))
-                            .and_then(|v| v.as_str())
-                            .map(|s| s.to_string());
-                        let old_str = input_obj
-                            .get("old_string")
-                            .and_then(|v| v.as_str())
-                            .map(|s| s.to_string());
-                        if let (Some(fp), Some(old_str)) = (fp, old_str) {
-                            if let Some(sl) = find_string_start_line(&fp, &old_str, Some(cwd)) {
-                                input_obj.insert(
-                                    "_start_line".to_string(),
-                                    serde_json::json!(sl),
-                                );
-                                // Write back as object so frontend asObject() works directly
-                                obj.insert(key.to_string(), parsed);
-                            }
+                // rawInput is a JSON string: parse, inject, write back as object
+                Some(serde_json::Value::String(text)) => {
+                    let text = text.clone();
+                    if let Ok(mut parsed) = serde_json::from_str::<serde_json::Value>(&text) {
+                        if inject_start_line(&mut parsed, Some(cwd)) {
+                            obj.insert(key.to_string(), parsed);
+                        }
+                    } else if text.contains("@@\n") || text.contains("@@\r\n") {
+                        if let Some(resolved) =
+                            crate::parsers::resolve_patch_text(&text, Some(cwd))
+                        {
+                            obj.insert(key.to_string(), serde_json::Value::String(resolved));
                         }
                     }
                 }
-                // Apply_patch format: resolve bare @@
-                else if text.contains("@@\n") || text.contains("@@\r\n") {
-                    if let Some(resolved) = crate::parsers::resolve_patch_text(&text, Some(cwd)) {
-                        obj.insert(key.to_string(), serde_json::Value::String(resolved));
-                    }
-                }
+                _ => {}
             }
         }
     }
@@ -1962,44 +1931,49 @@ fn structurize_live_output(text: &str) -> String {
 
 /// Resolve line numbers for live tool call input.
 ///
+/// Resolve line numbers for live tool call input (string form).
+///
 /// - For apply_patch with bare `@@`: resolve line numbers in place.
-/// - For canonical edit JSON (file_path + old_string + new_string):
-///   read the file, find where old_string starts, and inject `_start_line`
-///   into the JSON so the frontend can generate a diff with real line numbers.
+/// - For canonical edit JSON: inject `_start_line`.
 fn resolve_live_tool_input(text: &str, cwd: Option<&str>) -> String {
-    // Apply-patch format: resolve bare @@ in input
     if text.contains("@@\n") || text.contains("@@\r\n") {
         if let Some(resolved) = crate::parsers::resolve_patch_text(text, cwd) {
             return resolved;
         }
     }
-
-    // Canonical edit JSON: inject _start_line
     if let Ok(mut parsed) = serde_json::from_str::<serde_json::Value>(text) {
-        let file_path = parsed
-            .get("file_path")
-            .or_else(|| parsed.get("path"))
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string());
-        let old_string = parsed
-            .get("old_string")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string());
-
-        if let (Some(fp), Some(old_str)) = (file_path, old_string) {
-            if let Some(start_line) = find_string_start_line(&fp, &old_str, cwd) {
-                parsed
-                    .as_object_mut()
-                    .unwrap()
-                    .insert("_start_line".to_string(), serde_json::json!(start_line));
-                return parsed.to_string();
-            }
+        if inject_start_line(&mut parsed, cwd) {
+            return parsed.to_string();
         }
     }
-
     text.to_string()
 }
 
+/// Try to inject `_start_line` into a JSON object with `file_path` + `old_string`.
+/// Returns true if injected.
+fn inject_start_line(value: &mut serde_json::Value, cwd: Option<&str>) -> bool {
+    let obj = match value.as_object_mut() {
+        Some(o) => o,
+        None => return false,
+    };
+    let fp = obj
+        .get("file_path")
+        .or_else(|| obj.get("path"))
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    let old_str = obj
+        .get("old_string")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+    if let (Some(fp), Some(old_str)) = (fp, old_str) {
+        if let Some(sl) = find_string_start_line(&fp, &old_str, cwd) {
+            obj.insert("_start_line".to_string(), serde_json::json!(sl));
+            return true;
+        }
+    }
+    false
+}
+
 /// Find the 1-based start line of `needle` in the file at `path`.
 fn find_string_start_line(path: &str, needle: &str, cwd: Option<&str>) -> Option<u64> {
     if needle.is_empty() {